repo_name
stringclasses 6
values | pr_number
int64 512
78.9k
| pr_title
stringlengths 3
144
| pr_description
stringlengths 0
30.3k
| author
stringlengths 2
21
| date_created
timestamp[ns, tz=UTC] | date_merged
timestamp[ns, tz=UTC] | previous_commit
stringlengths 40
40
| pr_commit
stringlengths 40
40
| query
stringlengths 17
30.4k
| filepath
stringlengths 9
210
| before_content
stringlengths 0
112M
| after_content
stringlengths 0
112M
| label
int64 -1
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/profiler/native/transitions/transitions.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include "../profiler.h"
class Transitions : public Profiler
{
public:
Transitions() = default;
virtual ~Transitions() = default;
static GUID GetClsid();
virtual HRESULT STDMETHODCALLTYPE Initialize(IUnknown* pICorProfilerInfoUnk);
virtual HRESULT STDMETHODCALLTYPE Shutdown();
virtual HRESULT STDMETHODCALLTYPE UnmanagedToManagedTransition(FunctionID functionID, COR_PRF_TRANSITION_REASON reason);
virtual HRESULT STDMETHODCALLTYPE ManagedToUnmanagedTransition(FunctionID functionID, COR_PRF_TRANSITION_REASON reason);
private:
std::atomic<int> _failures;
struct TransitionInstance
{
TransitionInstance()
: UnmanagedToManaged{ (COR_PRF_TRANSITION_REASON)-1 }
, ManagedToUnmanaged{ (COR_PRF_TRANSITION_REASON)-1 }
{ }
COR_PRF_TRANSITION_REASON UnmanagedToManaged;
COR_PRF_TRANSITION_REASON ManagedToUnmanaged;
};
TransitionInstance _pinvoke;
TransitionInstance _reversePinvoke;
bool FunctionIsTargetFunction(FunctionID functionID, TransitionInstance** inst);
};
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include "../profiler.h"
class Transitions : public Profiler
{
public:
Transitions() = default;
virtual ~Transitions() = default;
static GUID GetClsid();
virtual HRESULT STDMETHODCALLTYPE Initialize(IUnknown* pICorProfilerInfoUnk);
virtual HRESULT STDMETHODCALLTYPE Shutdown();
virtual HRESULT STDMETHODCALLTYPE UnmanagedToManagedTransition(FunctionID functionID, COR_PRF_TRANSITION_REASON reason);
virtual HRESULT STDMETHODCALLTYPE ManagedToUnmanagedTransition(FunctionID functionID, COR_PRF_TRANSITION_REASON reason);
private:
std::atomic<int> _failures;
struct TransitionInstance
{
TransitionInstance()
: UnmanagedToManaged{ (COR_PRF_TRANSITION_REASON)-1 }
, ManagedToUnmanaged{ (COR_PRF_TRANSITION_REASON)-1 }
{ }
COR_PRF_TRANSITION_REASON UnmanagedToManaged;
COR_PRF_TRANSITION_REASON ManagedToUnmanaged;
};
TransitionInstance _pinvoke;
TransitionInstance _reversePinvoke;
bool FunctionIsTargetFunction(FunctionID functionID, TransitionInstance** inst);
};
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/rapidjson/encodedstream.h | // Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef RAPIDJSON_ENCODEDSTREAM_H_
#define RAPIDJSON_ENCODEDSTREAM_H_
#include "stream.h"
#include "memorystream.h"
#ifdef __GNUC__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(effc++)
#endif
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(padded)
#endif
RAPIDJSON_NAMESPACE_BEGIN
//! Input byte stream wrapper with a statically bound encoding.
/*!
\tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
\tparam InputByteStream Type of input byte stream. For example, FileReadStream.
*/
template <typename Encoding, typename InputByteStream>
class EncodedInputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
public:
typedef typename Encoding::Ch Ch;
EncodedInputStream(InputByteStream& is) : is_(is) {
current_ = Encoding::TakeBOM(is_);
}
Ch Peek() const { return current_; }
Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
size_t Tell() const { return is_.Tell(); }
// Not implemented
void Put(Ch) { RAPIDJSON_ASSERT(false); }
void Flush() { RAPIDJSON_ASSERT(false); }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
EncodedInputStream(const EncodedInputStream&);
EncodedInputStream& operator=(const EncodedInputStream&);
InputByteStream& is_;
Ch current_;
};
//! Specialized for UTF8 MemoryStream.
template <>
class EncodedInputStream<UTF8<>, MemoryStream> {
public:
typedef UTF8<>::Ch Ch;
EncodedInputStream(MemoryStream& is) : is_(is) {
if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
}
Ch Peek() const { return is_.Peek(); }
Ch Take() { return is_.Take(); }
size_t Tell() const { return is_.Tell(); }
// Not implemented
void Put(Ch) {}
void Flush() {}
Ch* PutBegin() { return 0; }
size_t PutEnd(Ch*) { return 0; }
MemoryStream& is_;
private:
EncodedInputStream(const EncodedInputStream&);
EncodedInputStream& operator=(const EncodedInputStream&);
};
//! Output byte stream wrapper with statically bound encoding.
/*!
\tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
\tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
*/
template <typename Encoding, typename OutputByteStream>
class EncodedOutputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
public:
typedef typename Encoding::Ch Ch;
EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) {
if (putBOM)
Encoding::PutBOM(os_);
}
void Put(Ch c) { Encoding::Put(os_, c); }
void Flush() { os_.Flush(); }
// Not implemented
Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
EncodedOutputStream(const EncodedOutputStream&);
EncodedOutputStream& operator=(const EncodedOutputStream&);
OutputByteStream& os_;
};
#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
/*!
\tparam CharType Type of character for reading.
\tparam InputByteStream type of input byte stream to be wrapped.
*/
template <typename CharType, typename InputByteStream>
class AutoUTFInputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
public:
typedef CharType Ch;
//! Constructor.
/*!
\param is input stream to be wrapped.
\param type UTF encoding type if it is not detected from the stream.
*/
AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
DetectType();
static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
takeFunc_ = f[type_];
current_ = takeFunc_(*is_);
}
UTFType GetType() const { return type_; }
bool HasBOM() const { return hasBOM_; }
Ch Peek() const { return current_; }
Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
size_t Tell() const { return is_->Tell(); }
// Not implemented
void Put(Ch) { RAPIDJSON_ASSERT(false); }
void Flush() { RAPIDJSON_ASSERT(false); }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
AutoUTFInputStream(const AutoUTFInputStream&);
AutoUTFInputStream& operator=(const AutoUTFInputStream&);
// Detect encoding type with BOM or RFC 4627
void DetectType() {
// BOM (Byte Order Mark):
// 00 00 FE FF UTF-32BE
// FF FE 00 00 UTF-32LE
// FE FF UTF-16BE
// FF FE UTF-16LE
// EF BB BF UTF-8
const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
if (!c)
return;
unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
hasBOM_ = false;
if (bom == 0xFFFE0000) { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
else if (bom == 0x0000FEFF) { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
else if ((bom & 0xFFFF) == 0xFFFE) { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take(); }
else if ((bom & 0xFFFF) == 0xFEFF) { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take(); }
else if ((bom & 0xFFFFFF) == 0xBFBBEF) { type_ = kUTF8; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); }
// RFC 4627: Section 3
// "Since the first two characters of a JSON text will always be ASCII
// characters [RFC0020], it is possible to determine whether an octet
// stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
// at the pattern of nulls in the first four octets."
// 00 00 00 xx UTF-32BE
// 00 xx 00 xx UTF-16BE
// xx 00 00 00 UTF-32LE
// xx 00 xx 00 UTF-16LE
// xx xx xx xx UTF-8
if (!hasBOM_) {
int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
switch (pattern) {
case 0x08: type_ = kUTF32BE; break;
case 0x0A: type_ = kUTF16BE; break;
case 0x01: type_ = kUTF32LE; break;
case 0x05: type_ = kUTF16LE; break;
case 0x0F: type_ = kUTF8; break;
default: break; // Use type defined by user.
}
}
// Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
}
typedef Ch (*TakeFunc)(InputByteStream& is);
InputByteStream* is_;
UTFType type_;
Ch current_;
TakeFunc takeFunc_;
bool hasBOM_;
};
//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
/*!
\tparam CharType Type of character for writing.
\tparam OutputByteStream type of output byte stream to be wrapped.
*/
template <typename CharType, typename OutputByteStream>
class AutoUTFOutputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
public:
typedef CharType Ch;
//! Constructor.
/*!
\param os output stream to be wrapped.
\param type UTF encoding type.
\param putBOM Whether to write BOM at the beginning of the stream.
*/
AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
// Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
putFunc_ = f[type_];
if (putBOM)
PutBOM();
}
UTFType GetType() const { return type_; }
void Put(Ch c) { putFunc_(*os_, c); }
void Flush() { os_->Flush(); }
// Not implemented
Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
AutoUTFOutputStream(const AutoUTFOutputStream&);
AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
void PutBOM() {
typedef void (*PutBOMFunc)(OutputByteStream&);
static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
f[type_](*os_);
}
typedef void (*PutFunc)(OutputByteStream&, Ch);
OutputByteStream* os_;
UTFType type_;
PutFunc putFunc_;
};
#undef RAPIDJSON_ENCODINGS_FUNC
RAPIDJSON_NAMESPACE_END
#ifdef __clang__
RAPIDJSON_DIAG_POP
#endif
#ifdef __GNUC__
RAPIDJSON_DIAG_POP
#endif
#endif // RAPIDJSON_FILESTREAM_H_
| // Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef RAPIDJSON_ENCODEDSTREAM_H_
#define RAPIDJSON_ENCODEDSTREAM_H_
#include "stream.h"
#include "memorystream.h"
#ifdef __GNUC__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(effc++)
#endif
#ifdef __clang__
RAPIDJSON_DIAG_PUSH
RAPIDJSON_DIAG_OFF(padded)
#endif
RAPIDJSON_NAMESPACE_BEGIN
//! Input byte stream wrapper with a statically bound encoding.
/*!
\tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
\tparam InputByteStream Type of input byte stream. For example, FileReadStream.
*/
template <typename Encoding, typename InputByteStream>
class EncodedInputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
public:
typedef typename Encoding::Ch Ch;
EncodedInputStream(InputByteStream& is) : is_(is) {
current_ = Encoding::TakeBOM(is_);
}
Ch Peek() const { return current_; }
Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
size_t Tell() const { return is_.Tell(); }
// Not implemented
void Put(Ch) { RAPIDJSON_ASSERT(false); }
void Flush() { RAPIDJSON_ASSERT(false); }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
EncodedInputStream(const EncodedInputStream&);
EncodedInputStream& operator=(const EncodedInputStream&);
InputByteStream& is_;
Ch current_;
};
//! Specialized for UTF8 MemoryStream.
template <>
class EncodedInputStream<UTF8<>, MemoryStream> {
public:
typedef UTF8<>::Ch Ch;
EncodedInputStream(MemoryStream& is) : is_(is) {
if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
}
Ch Peek() const { return is_.Peek(); }
Ch Take() { return is_.Take(); }
size_t Tell() const { return is_.Tell(); }
// Not implemented
void Put(Ch) {}
void Flush() {}
Ch* PutBegin() { return 0; }
size_t PutEnd(Ch*) { return 0; }
MemoryStream& is_;
private:
EncodedInputStream(const EncodedInputStream&);
EncodedInputStream& operator=(const EncodedInputStream&);
};
//! Output byte stream wrapper with statically bound encoding.
/*!
\tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
\tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
*/
template <typename Encoding, typename OutputByteStream>
class EncodedOutputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
public:
typedef typename Encoding::Ch Ch;
EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) {
if (putBOM)
Encoding::PutBOM(os_);
}
void Put(Ch c) { Encoding::Put(os_, c); }
void Flush() { os_.Flush(); }
// Not implemented
Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
EncodedOutputStream(const EncodedOutputStream&);
EncodedOutputStream& operator=(const EncodedOutputStream&);
OutputByteStream& os_;
};
#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
/*!
\tparam CharType Type of character for reading.
\tparam InputByteStream type of input byte stream to be wrapped.
*/
template <typename CharType, typename InputByteStream>
class AutoUTFInputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
public:
typedef CharType Ch;
//! Constructor.
/*!
\param is input stream to be wrapped.
\param type UTF encoding type if it is not detected from the stream.
*/
AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
DetectType();
static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
takeFunc_ = f[type_];
current_ = takeFunc_(*is_);
}
UTFType GetType() const { return type_; }
bool HasBOM() const { return hasBOM_; }
Ch Peek() const { return current_; }
Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
size_t Tell() const { return is_->Tell(); }
// Not implemented
void Put(Ch) { RAPIDJSON_ASSERT(false); }
void Flush() { RAPIDJSON_ASSERT(false); }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
AutoUTFInputStream(const AutoUTFInputStream&);
AutoUTFInputStream& operator=(const AutoUTFInputStream&);
// Detect encoding type with BOM or RFC 4627
void DetectType() {
// BOM (Byte Order Mark):
// 00 00 FE FF UTF-32BE
// FF FE 00 00 UTF-32LE
// FE FF UTF-16BE
// FF FE UTF-16LE
// EF BB BF UTF-8
const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
if (!c)
return;
unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
hasBOM_ = false;
if (bom == 0xFFFE0000) { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
else if (bom == 0x0000FEFF) { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
else if ((bom & 0xFFFF) == 0xFFFE) { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take(); }
else if ((bom & 0xFFFF) == 0xFEFF) { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take(); }
else if ((bom & 0xFFFFFF) == 0xBFBBEF) { type_ = kUTF8; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); }
// RFC 4627: Section 3
// "Since the first two characters of a JSON text will always be ASCII
// characters [RFC0020], it is possible to determine whether an octet
// stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
// at the pattern of nulls in the first four octets."
// 00 00 00 xx UTF-32BE
// 00 xx 00 xx UTF-16BE
// xx 00 00 00 UTF-32LE
// xx 00 xx 00 UTF-16LE
// xx xx xx xx UTF-8
if (!hasBOM_) {
int pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
switch (pattern) {
case 0x08: type_ = kUTF32BE; break;
case 0x0A: type_ = kUTF16BE; break;
case 0x01: type_ = kUTF32LE; break;
case 0x05: type_ = kUTF16LE; break;
case 0x0F: type_ = kUTF8; break;
default: break; // Use type defined by user.
}
}
// Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
}
typedef Ch (*TakeFunc)(InputByteStream& is);
InputByteStream* is_;
UTFType type_;
Ch current_;
TakeFunc takeFunc_;
bool hasBOM_;
};
//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
/*!
\tparam CharType Type of character for writing.
\tparam OutputByteStream type of output byte stream to be wrapped.
*/
template <typename CharType, typename OutputByteStream>
class AutoUTFOutputStream {
RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
public:
typedef CharType Ch;
//! Constructor.
/*!
\param os output stream to be wrapped.
\param type UTF encoding type.
\param putBOM Whether to write BOM at the beginning of the stream.
*/
AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
// Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
putFunc_ = f[type_];
if (putBOM)
PutBOM();
}
UTFType GetType() const { return type_; }
void Put(Ch c) { putFunc_(*os_, c); }
void Flush() { os_->Flush(); }
// Not implemented
Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
private:
AutoUTFOutputStream(const AutoUTFOutputStream&);
AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
void PutBOM() {
typedef void (*PutBOMFunc)(OutputByteStream&);
static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
f[type_](*os_);
}
typedef void (*PutFunc)(OutputByteStream&, Ch);
OutputByteStream* os_;
UTFType type_;
PutFunc putFunc_;
};
#undef RAPIDJSON_ENCODINGS_FUNC
RAPIDJSON_NAMESPACE_END
#ifdef __clang__
RAPIDJSON_DIAG_POP
#endif
#ifdef __GNUC__
RAPIDJSON_DIAG_POP
#endif
#endif // RAPIDJSON_FILESTREAM_H_
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/os-solaris.c | /* libunwind - a platform-independent unwind library
Copyright (C) 2003-2005 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <limits.h>
#include <stdio.h>
#include "libunwind_i.h"
#include "os-linux.h" // using linux header for map_iterator implementation
int
tdep_get_elf_image (struct elf_image *ei, pid_t pid, unw_word_t ip,
unsigned long *segbase, unsigned long *mapoff,
char *path, size_t pathlen)
{
struct map_iterator mi;
int found = 0, rc;
unsigned long hi;
if (maps_init (&mi, pid) < 0)
return -1;
while (maps_next (&mi, segbase, &hi, mapoff, NULL))
if (ip >= *segbase && ip < hi)
{
found = 1;
break;
}
if (!found)
{
maps_close (&mi);
return -1;
}
if (path)
{
strncpy(path, mi.path, pathlen);
}
rc = elf_map_image (ei, mi.path);
maps_close (&mi);
return rc;
}
#ifndef UNW_REMOTE_ONLY
void
tdep_get_exe_image_path (char *path)
{
strcpy(path, getexecname());
}
#endif /* !UNW_REMOTE_ONLY */
| /* libunwind - a platform-independent unwind library
Copyright (C) 2003-2005 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <limits.h>
#include <stdio.h>
#include "libunwind_i.h"
#include "os-linux.h" // using linux header for map_iterator implementation
int
tdep_get_elf_image (struct elf_image *ei, pid_t pid, unw_word_t ip,
unsigned long *segbase, unsigned long *mapoff,
char *path, size_t pathlen)
{
struct map_iterator mi;
int found = 0, rc;
unsigned long hi;
if (maps_init (&mi, pid) < 0)
return -1;
while (maps_next (&mi, segbase, &hi, mapoff, NULL))
if (ip >= *segbase && ip < hi)
{
found = 1;
break;
}
if (!found)
{
maps_close (&mi);
return -1;
}
if (path)
{
strncpy(path, mi.path, pathlen);
}
rc = elf_map_image (ei, mi.path);
maps_close (&mi);
return rc;
}
#ifndef UNW_REMOTE_ONLY
void
tdep_get_exe_image_path (char *path)
{
strcpy(path, getexecname());
}
#endif /* !UNW_REMOTE_ONLY */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/public/mono/jit/details/mono-private-unstable-types.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
/**
*
* Private unstable APIs.
*
* WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at
* any time.
*
*/
#ifndef _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H
#define _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H
#include <mono/utils/details/mono-publib-types.h>
#include <mono/metadata/details/image-types.h>
#include <mono/metadata/details/mono-private-unstable-types.h>
MONO_BEGIN_DECLS
typedef struct {
uint32_t kind; // 0 = Path of runtimeconfig.blob, 1 = pointer to image data, >= 2 undefined
union {
struct {
const char *path;
} name;
struct {
const char *data;
uint32_t data_len;
} data;
} runtimeconfig;
} MonovmRuntimeConfigArguments;
typedef void (*MonovmRuntimeConfigArgumentsCleanup) (MonovmRuntimeConfigArguments *args, void *user_data);
typedef struct {
uint32_t assembly_count;
char **basenames; /* Foo.dll */
uint32_t *basename_lens;
char **assembly_filepaths; /* /blah/blah/blah/Foo.dll */
} MonoCoreTrustedPlatformAssemblies;
typedef struct {
uint32_t dir_count;
char **dirs;
} MonoCoreLookupPaths;
typedef struct {
MonoCoreTrustedPlatformAssemblies *trusted_platform_assemblies;
MonoCoreLookupPaths *app_paths;
MonoCoreLookupPaths *native_dll_search_directories;
PInvokeOverrideFn pinvoke_override;
} MonoCoreRuntimeProperties;
/* These are used to load the AOT data for aot images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */
/*
* Return the AOT data for ASSEMBLY. SIZE is the size of the data. OUT_HANDLE should be set to a handle which is later
* passed to the free function.
*/
typedef unsigned char* (*MonoLoadAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void **out_handle);
/* Not yet used */
typedef void (*MonoFreeAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void *handle);
//#ifdef HOST_WASM
typedef void* (*MonoWasmGetNativeToInterpTramp) (MonoMethod *method, void *extra_arg);
//#endif
MONO_END_DECLS
#endif /* _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H */
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
/**
*
* Private unstable APIs.
*
* WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at
* any time.
*
*/
#ifndef _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H
#define _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H
#include <mono/utils/details/mono-publib-types.h>
#include <mono/metadata/details/image-types.h>
#include <mono/metadata/details/mono-private-unstable-types.h>
MONO_BEGIN_DECLS
typedef struct {
uint32_t kind; // 0 = Path of runtimeconfig.blob, 1 = pointer to image data, >= 2 undefined
union {
struct {
const char *path;
} name;
struct {
const char *data;
uint32_t data_len;
} data;
} runtimeconfig;
} MonovmRuntimeConfigArguments;
typedef void (*MonovmRuntimeConfigArgumentsCleanup) (MonovmRuntimeConfigArguments *args, void *user_data);
typedef struct {
uint32_t assembly_count;
char **basenames; /* Foo.dll */
uint32_t *basename_lens;
char **assembly_filepaths; /* /blah/blah/blah/Foo.dll */
} MonoCoreTrustedPlatformAssemblies;
typedef struct {
uint32_t dir_count;
char **dirs;
} MonoCoreLookupPaths;
typedef struct {
MonoCoreTrustedPlatformAssemblies *trusted_platform_assemblies;
MonoCoreLookupPaths *app_paths;
MonoCoreLookupPaths *native_dll_search_directories;
PInvokeOverrideFn pinvoke_override;
} MonoCoreRuntimeProperties;
/* These are used to load the AOT data for aot images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */
/*
* Return the AOT data for ASSEMBLY. SIZE is the size of the data. OUT_HANDLE should be set to a handle which is later
* passed to the free function.
*/
typedef unsigned char* (*MonoLoadAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void **out_handle);
/* Not yet used */
typedef void (*MonoFreeAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void *handle);
//#ifdef HOST_WASM
typedef void* (*MonoWasmGetNativeToInterpTramp) (MonoMethod *method, void *extra_arg);
//#endif
MONO_END_DECLS
#endif /* _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/libs/Common/pal_io_common.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include <stdlib.h>
#include <assert.h>
#include <poll.h>
#include <pal_error_common.h>
#include <pal_utilities.h>
#include <minipal/utils.h>
/**
* Our intermediate pollfd struct to normalize the data types
*/
typedef struct
{
int32_t FileDescriptor; // The file descriptor to poll
int16_t Events; // The events to poll for
int16_t TriggeredEvents; // The events that triggered the poll
} PollEvent;
/**
* Constants passed to and from poll describing what to poll for and what
* kind of data was received from poll.
*/
typedef enum
{
PAL_POLLIN = 0x0001, /* non-urgent readable data available */
PAL_POLLPRI = 0x0002, /* urgent readable data available */
PAL_POLLOUT = 0x0004, /* data can be written without blocked */
PAL_POLLERR = 0x0008, /* an error occurred */
PAL_POLLHUP = 0x0010, /* the file descriptor hung up */
PAL_POLLNVAL = 0x0020, /* the requested events were invalid */
} PollEvents;
inline static int32_t Common_Read(intptr_t fd, void* buffer, int32_t bufferSize)
{
assert(buffer != NULL || bufferSize == 0);
assert(bufferSize >= 0);
if (bufferSize < 0)
{
errno = EINVAL;
return -1;
}
ssize_t count;
while ((count = read(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize)) < 0 && errno == EINTR);
assert(count >= -1 && count <= bufferSize);
return (int32_t)count;
}
inline static int32_t Common_Write(intptr_t fd, const void* buffer, int32_t bufferSize)
{
assert(buffer != NULL || bufferSize == 0);
assert(bufferSize >= 0);
if (bufferSize < 0)
{
errno = ERANGE;
return -1;
}
ssize_t count;
while ((count = write(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize)) < 0 && errno == EINTR);
assert(count >= -1 && count <= bufferSize);
return (int32_t)count;
}
inline static int32_t Common_Poll(PollEvent* pollEvents, uint32_t eventCount, int32_t milliseconds, uint32_t* triggered)
{
if (pollEvents == NULL || triggered == NULL)
{
return Error_EFAULT;
}
if (milliseconds < -1)
{
return Error_EINVAL;
}
struct pollfd stackBuffer[(uint32_t)(2048/sizeof(struct pollfd))];
int useStackBuffer = eventCount <= ARRAY_SIZE(stackBuffer);
struct pollfd* pollfds = NULL;
if (useStackBuffer)
{
pollfds = &stackBuffer[0];
}
else
{
pollfds = (struct pollfd*)calloc(eventCount, sizeof(*pollfds));
if (pollfds == NULL)
{
return Error_ENOMEM;
}
}
for (uint32_t i = 0; i < eventCount; i++)
{
const PollEvent* event = &pollEvents[i];
pollfds[i].fd = event->FileDescriptor;
// we need to do this for platforms like AIX where PAL_POLL* doesn't
// match up to their reality; this is PollEvent -> system polling
switch (event->Events)
{
case PAL_POLLIN:
pollfds[i].events = POLLIN;
break;
case PAL_POLLPRI:
pollfds[i].events = POLLPRI;
break;
case PAL_POLLOUT:
pollfds[i].events = POLLOUT;
break;
case PAL_POLLERR:
pollfds[i].events = POLLERR;
break;
case PAL_POLLHUP:
pollfds[i].events = POLLHUP;
break;
case PAL_POLLNVAL:
pollfds[i].events = POLLNVAL;
break;
default:
pollfds[i].events = event->Events;
break;
}
pollfds[i].revents = 0;
}
int rv;
while ((rv = poll(pollfds, (nfds_t)eventCount, milliseconds)) < 0 && errno == EINTR);
if (rv < 0)
{
if (!useStackBuffer)
{
free(pollfds);
}
*triggered = 0;
return ConvertErrorPlatformToPal(errno);
}
for (uint32_t i = 0; i < eventCount; i++)
{
const struct pollfd* pfd = &pollfds[i];
assert(pfd->fd == pollEvents[i].FileDescriptor);
assert(pfd->events == pollEvents[i].Events);
// same as the other switch, just system -> PollEvent
switch (pfd->revents)
{
case POLLIN:
pollEvents[i].TriggeredEvents = PAL_POLLIN;
break;
case POLLPRI:
pollEvents[i].TriggeredEvents = PAL_POLLPRI;
break;
case POLLOUT:
pollEvents[i].TriggeredEvents = PAL_POLLOUT;
break;
case POLLERR:
pollEvents[i].TriggeredEvents = PAL_POLLERR;
break;
case POLLHUP:
pollEvents[i].TriggeredEvents = PAL_POLLHUP;
break;
case POLLNVAL:
pollEvents[i].TriggeredEvents = PAL_POLLNVAL;
break;
default:
pollEvents[i].TriggeredEvents = (int16_t)pfd->revents;
break;
}
}
*triggered = (uint32_t)rv;
if (!useStackBuffer)
{
free(pollfds);
}
return Error_SUCCESS;
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include <stdlib.h>
#include <assert.h>
#include <poll.h>
#include <pal_error_common.h>
#include <pal_utilities.h>
#include <minipal/utils.h>
/**
* Our intermediate pollfd struct to normalize the data types
*/
typedef struct
{
int32_t FileDescriptor; // The file descriptor to poll
int16_t Events; // The events to poll for
int16_t TriggeredEvents; // The events that triggered the poll
} PollEvent;
/**
* Constants passed to and from poll describing what to poll for and what
* kind of data was received from poll.
*/
typedef enum
{
PAL_POLLIN = 0x0001, /* non-urgent readable data available */
PAL_POLLPRI = 0x0002, /* urgent readable data available */
PAL_POLLOUT = 0x0004, /* data can be written without blocked */
PAL_POLLERR = 0x0008, /* an error occurred */
PAL_POLLHUP = 0x0010, /* the file descriptor hung up */
PAL_POLLNVAL = 0x0020, /* the requested events were invalid */
} PollEvents;
inline static int32_t Common_Read(intptr_t fd, void* buffer, int32_t bufferSize)
{
assert(buffer != NULL || bufferSize == 0);
assert(bufferSize >= 0);
if (bufferSize < 0)
{
errno = EINVAL;
return -1;
}
ssize_t count;
while ((count = read(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize)) < 0 && errno == EINTR);
assert(count >= -1 && count <= bufferSize);
return (int32_t)count;
}
inline static int32_t Common_Write(intptr_t fd, const void* buffer, int32_t bufferSize)
{
assert(buffer != NULL || bufferSize == 0);
assert(bufferSize >= 0);
if (bufferSize < 0)
{
errno = ERANGE;
return -1;
}
ssize_t count;
while ((count = write(ToFileDescriptor(fd), buffer, (uint32_t)bufferSize)) < 0 && errno == EINTR);
assert(count >= -1 && count <= bufferSize);
return (int32_t)count;
}
inline static int32_t Common_Poll(PollEvent* pollEvents, uint32_t eventCount, int32_t milliseconds, uint32_t* triggered)
{
if (pollEvents == NULL || triggered == NULL)
{
return Error_EFAULT;
}
if (milliseconds < -1)
{
return Error_EINVAL;
}
struct pollfd stackBuffer[(uint32_t)(2048/sizeof(struct pollfd))];
int useStackBuffer = eventCount <= ARRAY_SIZE(stackBuffer);
struct pollfd* pollfds = NULL;
if (useStackBuffer)
{
pollfds = &stackBuffer[0];
}
else
{
pollfds = (struct pollfd*)calloc(eventCount, sizeof(*pollfds));
if (pollfds == NULL)
{
return Error_ENOMEM;
}
}
for (uint32_t i = 0; i < eventCount; i++)
{
const PollEvent* event = &pollEvents[i];
pollfds[i].fd = event->FileDescriptor;
// we need to do this for platforms like AIX where PAL_POLL* doesn't
// match up to their reality; this is PollEvent -> system polling
switch (event->Events)
{
case PAL_POLLIN:
pollfds[i].events = POLLIN;
break;
case PAL_POLLPRI:
pollfds[i].events = POLLPRI;
break;
case PAL_POLLOUT:
pollfds[i].events = POLLOUT;
break;
case PAL_POLLERR:
pollfds[i].events = POLLERR;
break;
case PAL_POLLHUP:
pollfds[i].events = POLLHUP;
break;
case PAL_POLLNVAL:
pollfds[i].events = POLLNVAL;
break;
default:
pollfds[i].events = event->Events;
break;
}
pollfds[i].revents = 0;
}
int rv;
while ((rv = poll(pollfds, (nfds_t)eventCount, milliseconds)) < 0 && errno == EINTR);
if (rv < 0)
{
if (!useStackBuffer)
{
free(pollfds);
}
*triggered = 0;
return ConvertErrorPlatformToPal(errno);
}
for (uint32_t i = 0; i < eventCount; i++)
{
const struct pollfd* pfd = &pollfds[i];
assert(pfd->fd == pollEvents[i].FileDescriptor);
assert(pfd->events == pollEvents[i].Events);
// same as the other switch, just system -> PollEvent
switch (pfd->revents)
{
case POLLIN:
pollEvents[i].TriggeredEvents = PAL_POLLIN;
break;
case POLLPRI:
pollEvents[i].TriggeredEvents = PAL_POLLPRI;
break;
case POLLOUT:
pollEvents[i].TriggeredEvents = PAL_POLLOUT;
break;
case POLLERR:
pollEvents[i].TriggeredEvents = PAL_POLLERR;
break;
case POLLHUP:
pollEvents[i].TriggeredEvents = PAL_POLLHUP;
break;
case POLLNVAL:
pollEvents[i].TriggeredEvents = PAL_POLLNVAL;
break;
default:
pollEvents[i].TriggeredEvents = (int16_t)pfd->revents;
break;
}
}
*triggered = (uint32_t)rv;
if (!useStackBuffer)
{
free(pollfds);
}
return Error_SUCCESS;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/metadata/property-bag.h | /**
* \file
* Linearizable property bag.
*
* Authors:
* Rodrigo Kumpera ([email protected])
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#ifndef __MONO_METADATA_PROPERTY_BAG_H__
#define __MONO_METADATA_PROPERTY_BAG_H__
#include <mono/utils/mono-compiler.h>
typedef struct _MonoPropertyBagItem MonoPropertyBagItem;
struct _MonoPropertyBagItem {
MonoPropertyBagItem *next;
int tag;
};
typedef struct {
MonoPropertyBagItem *head;
} MonoPropertyBag;
void* mono_property_bag_get (MonoPropertyBag *bag, int tag);
void* mono_property_bag_add (MonoPropertyBag *bag, void *value);
#endif
| /**
* \file
* Linearizable property bag.
*
* Authors:
* Rodrigo Kumpera ([email protected])
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#ifndef __MONO_METADATA_PROPERTY_BAG_H__
#define __MONO_METADATA_PROPERTY_BAG_H__
#include <mono/utils/mono-compiler.h>
typedef struct _MonoPropertyBagItem MonoPropertyBagItem;
struct _MonoPropertyBagItem {
MonoPropertyBagItem *next;
int tag;
};
typedef struct {
MonoPropertyBagItem *head;
} MonoPropertyBag;
void* mono_property_bag_get (MonoPropertyBag *bag, int tag);
void* mono_property_bag_add (MonoPropertyBag *bag, void *value);
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/mini/aot-runtime-wasm.c | /**
* \file
* WASM AOT runtime
*/
#include "config.h"
#include <sys/types.h>
#include "mini.h"
#include <mono/jit/mono-private-unstable.h>
#include "interp/interp.h"
#ifdef TARGET_WASM
static char
type_to_c (MonoType *t)
{
if (m_type_is_byref (t))
return 'I';
handle_enum:
switch (t->type) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_CHAR:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_PTR:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
return 'I';
case MONO_TYPE_R4:
return 'F';
case MONO_TYPE_R8:
return 'D';
break;
case MONO_TYPE_I8:
case MONO_TYPE_U8:
return 'L';
case MONO_TYPE_VOID:
return 'V';
case MONO_TYPE_VALUETYPE:
if (m_class_is_enumtype (t->data.klass)) {
t = mono_class_enum_basetype_internal (t->data.klass);
goto handle_enum;
}
return 'I';
case MONO_TYPE_GENERICINST:
if (m_class_is_valuetype (t->data.klass))
return 'S';
return 'I';
default:
g_warning ("CANT TRANSLATE %s", mono_type_full_name (t));
return 'X';
}
}
#define FIDX(x) (x)
typedef union {
gint64 l;
struct {
gint32 lo;
gint32 hi;
} pair;
} interp_pair;
static gint64
get_long_arg (InterpMethodArguments *margs, int idx)
{
interp_pair p;
p.pair.lo = (gint32)(gssize)margs->iargs [idx];
p.pair.hi = (gint32)(gssize)margs->iargs [idx + 1];
return p.l;
}
#include "wasm_m2n_invoke.g.h"
static int
compare_icall_tramp (const void *key, const void *elem)
{
return strcmp (key, *(void**)elem);
}
gpointer
mono_wasm_get_interp_to_native_trampoline (MonoMethodSignature *sig)
{
char cookie [32];
int c_count;
c_count = sig->param_count + sig->hasthis + 1;
g_assert (c_count < sizeof (cookie)); //ensure we don't overflow the local
cookie [0] = type_to_c (sig->ret);
if (sig->hasthis)
cookie [1] = 'I';
for (int i = 0; i < sig->param_count; ++i) {
cookie [1 + sig->hasthis + i] = type_to_c (sig->params [i]);
}
cookie [c_count] = 0;
void *p = bsearch (cookie, interp_to_native_signatures, G_N_ELEMENTS (interp_to_native_signatures), sizeof (gpointer), compare_icall_tramp);
if (!p)
g_error ("CANNOT HANDLE INTERP ICALL SIG %s\n", cookie);
int idx = (const char**)p - (const char**)interp_to_native_signatures;
return interp_to_native_invokes [idx];
}
static MonoWasmGetNativeToInterpTramp get_native_to_interp_tramp_cb;
MONO_API void
mono_wasm_install_get_native_to_interp_tramp (MonoWasmGetNativeToInterpTramp cb)
{
get_native_to_interp_tramp_cb = cb;
}
gpointer
mono_wasm_get_native_to_interp_trampoline (MonoMethod *method, gpointer extra_arg)
{
if (get_native_to_interp_tramp_cb)
return get_native_to_interp_tramp_cb (method, extra_arg);
else
return NULL;
}
#else /* TARGET_WASM */
MONO_EMPTY_SOURCE_FILE (aot_runtime_wasm);
#endif /* TARGET_WASM */
| /**
* \file
* WASM AOT runtime
*/
#include "config.h"
#include <sys/types.h>
#include "mini.h"
#include <mono/jit/mono-private-unstable.h>
#include "interp/interp.h"
#ifdef TARGET_WASM
static char
type_to_c (MonoType *t)
{
if (m_type_is_byref (t))
return 'I';
handle_enum:
switch (t->type) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_CHAR:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_PTR:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
return 'I';
case MONO_TYPE_R4:
return 'F';
case MONO_TYPE_R8:
return 'D';
break;
case MONO_TYPE_I8:
case MONO_TYPE_U8:
return 'L';
case MONO_TYPE_VOID:
return 'V';
case MONO_TYPE_VALUETYPE:
if (m_class_is_enumtype (t->data.klass)) {
t = mono_class_enum_basetype_internal (t->data.klass);
goto handle_enum;
}
return 'I';
case MONO_TYPE_GENERICINST:
if (m_class_is_valuetype (t->data.klass))
return 'S';
return 'I';
default:
g_warning ("CANT TRANSLATE %s", mono_type_full_name (t));
return 'X';
}
}
#define FIDX(x) (x)
typedef union {
gint64 l;
struct {
gint32 lo;
gint32 hi;
} pair;
} interp_pair;
static gint64
get_long_arg (InterpMethodArguments *margs, int idx)
{
interp_pair p;
p.pair.lo = (gint32)(gssize)margs->iargs [idx];
p.pair.hi = (gint32)(gssize)margs->iargs [idx + 1];
return p.l;
}
#include "wasm_m2n_invoke.g.h"
static int
compare_icall_tramp (const void *key, const void *elem)
{
return strcmp (key, *(void**)elem);
}
gpointer
mono_wasm_get_interp_to_native_trampoline (MonoMethodSignature *sig)
{
char cookie [32];
int c_count;
c_count = sig->param_count + sig->hasthis + 1;
g_assert (c_count < sizeof (cookie)); //ensure we don't overflow the local
cookie [0] = type_to_c (sig->ret);
if (sig->hasthis)
cookie [1] = 'I';
for (int i = 0; i < sig->param_count; ++i) {
cookie [1 + sig->hasthis + i] = type_to_c (sig->params [i]);
}
cookie [c_count] = 0;
void *p = bsearch (cookie, interp_to_native_signatures, G_N_ELEMENTS (interp_to_native_signatures), sizeof (gpointer), compare_icall_tramp);
if (!p)
g_error ("CANNOT HANDLE INTERP ICALL SIG %s\n", cookie);
int idx = (const char**)p - (const char**)interp_to_native_signatures;
return interp_to_native_invokes [idx];
}
static MonoWasmGetNativeToInterpTramp get_native_to_interp_tramp_cb;
MONO_API void
mono_wasm_install_get_native_to_interp_tramp (MonoWasmGetNativeToInterpTramp cb)
{
get_native_to_interp_tramp_cb = cb;
}
gpointer
mono_wasm_get_native_to_interp_trampoline (MonoMethod *method, gpointer extra_arg)
{
if (get_native_to_interp_tramp_cb)
return get_native_to_interp_tramp_cb (method, extra_arg);
else
return NULL;
}
#else /* TARGET_WASM */
MONO_EMPTY_SOURCE_FILE (aot_runtime_wasm);
#endif /* TARGET_WASM */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/aarch64/Lresume.c | #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gresume.c"
#endif
| #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gresume.c"
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/profiler/native/event.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include <mutex>
#include <condition_variable>
#include <functional>
class AutoEvent
{
private:
std::mutex m_mtx;
std::condition_variable m_cv;
bool m_set = false;
static void DoNothing()
{
}
public:
AutoEvent() = default;
~AutoEvent() = default;
AutoEvent(AutoEvent& other) = delete;
AutoEvent(AutoEvent &&other) = delete;
AutoEvent &operator=(AutoEvent &other) = delete;
AutoEvent &operator=(AutoEvent &&other) = delete;
void Wait(std::function<void()> spuriousCallback = DoNothing)
{
std::unique_lock<std::mutex> lock(m_mtx);
while (!m_set)
{
m_cv.wait(lock, [&]() { return m_set; });
if (!m_set)
{
spuriousCallback();
}
}
m_set = false;
}
void WaitFor(int milliseconds, std::function<void()> spuriousCallback = DoNothing)
{
std::unique_lock<std::mutex> lock(m_mtx);
while (!m_set)
{
m_cv.wait_for(lock, std::chrono::milliseconds(milliseconds), [&]() { return m_set; });
if (!m_set)
{
spuriousCallback();
}
}
m_set = false;
}
void Signal()
{
{
std::lock_guard<std::mutex> guard(m_mtx);
m_set = true;
}
m_cv.notify_one();
}
};
class ManualEvent
{
private:
std::mutex m_mtx;
std::condition_variable m_cv;
bool m_set = false;
static void DoNothing()
{
}
public:
ManualEvent() = default;
~ManualEvent() = default;
ManualEvent(ManualEvent& other) = delete;
ManualEvent(ManualEvent&& other) = delete;
ManualEvent& operator= (ManualEvent& other) = delete;
ManualEvent& operator= (ManualEvent&& other) = delete;
void Wait(std::function<void()> spuriousCallback = DoNothing)
{
std::unique_lock<std::mutex> lock(m_mtx);
while (!m_set)
{
m_cv.wait(lock, [&]() { return m_set; });
if (!m_set)
{
spuriousCallback();
}
}
}
void Signal()
{
{
std::lock_guard<std::mutex> guard(m_mtx);
m_set = true;
}
m_cv.notify_all();
}
void Reset()
{
std::lock_guard<std::mutex> guard(m_mtx);
m_set = false;
}
};
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include <mutex>
#include <condition_variable>
#include <functional>
class AutoEvent
{
private:
std::mutex m_mtx;
std::condition_variable m_cv;
bool m_set = false;
static void DoNothing()
{
}
public:
AutoEvent() = default;
~AutoEvent() = default;
AutoEvent(AutoEvent& other) = delete;
AutoEvent(AutoEvent &&other) = delete;
AutoEvent &operator=(AutoEvent &other) = delete;
AutoEvent &operator=(AutoEvent &&other) = delete;
void Wait(std::function<void()> spuriousCallback = DoNothing)
{
std::unique_lock<std::mutex> lock(m_mtx);
while (!m_set)
{
m_cv.wait(lock, [&]() { return m_set; });
if (!m_set)
{
spuriousCallback();
}
}
m_set = false;
}
void WaitFor(int milliseconds, std::function<void()> spuriousCallback = DoNothing)
{
std::unique_lock<std::mutex> lock(m_mtx);
while (!m_set)
{
m_cv.wait_for(lock, std::chrono::milliseconds(milliseconds), [&]() { return m_set; });
if (!m_set)
{
spuriousCallback();
}
}
m_set = false;
}
void Signal()
{
{
std::lock_guard<std::mutex> guard(m_mtx);
m_set = true;
}
m_cv.notify_one();
}
};
class ManualEvent
{
private:
std::mutex m_mtx;
std::condition_variable m_cv;
bool m_set = false;
static void DoNothing()
{
}
public:
ManualEvent() = default;
~ManualEvent() = default;
ManualEvent(ManualEvent& other) = delete;
ManualEvent(ManualEvent&& other) = delete;
ManualEvent& operator= (ManualEvent& other) = delete;
ManualEvent& operator= (ManualEvent&& other) = delete;
void Wait(std::function<void()> spuriousCallback = DoNothing)
{
std::unique_lock<std::mutex> lock(m_mtx);
while (!m_set)
{
m_cv.wait(lock, [&]() { return m_set; });
if (!m_set)
{
spuriousCallback();
}
}
}
void Signal()
{
{
std::lock_guard<std::mutex> guard(m_mtx);
m_set = true;
}
m_cv.notify_all();
}
void Reset()
{
std::lock_guard<std::mutex> guard(m_mtx);
m_set = false;
}
};
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/mips/Lapply_reg_state.c | #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gapply_reg_state.c"
#endif
| #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gapply_reg_state.c"
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/brotli/common/platform.c | /* Copyright 2016 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
#include <stdlib.h>
#include "./platform.h"
#include <brotli/types.h>
/* Default brotli_alloc_func */
void* BrotliDefaultAllocFunc(void* opaque, size_t size) {
BROTLI_UNUSED(opaque);
return malloc(size);
}
/* Default brotli_free_func */
void BrotliDefaultFreeFunc(void* opaque, void* address) {
BROTLI_UNUSED(opaque);
free(address);
}
| /* Copyright 2016 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
#include <stdlib.h>
#include "./platform.h"
#include <brotli/types.h>
/* Default brotli_alloc_func */
void* BrotliDefaultAllocFunc(void* opaque, size_t size) {
BROTLI_UNUSED(opaque);
return malloc(size);
}
/* Default brotli_free_func */
void BrotliDefaultFreeFunc(void* opaque, void* address) {
BROTLI_UNUSED(opaque);
free(address);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/inc/rt/sal.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/***
*sal.h - markers for documenting the semantics of APIs
*
*
*Purpose:
* sal.h provides a set of annotations to describe how a function uses its
* parameters - the assumptions it makes about them, and the guarantees it makes
* upon finishing.
****/
#pragma once
/*==========================================================================
The comments in this file are intended to give basic understanding of
the usage of SAL, the Microsoft Source Code Annotation Language.
For more details, please see http://go.microsoft.com/fwlink/?LinkID=242134
The macros are defined in 3 layers, plus the structural set:
_In_/_Out_/_Ret_ Layer:
----------------------
This layer provides the highest abstraction and its macros should be used
in most cases. These macros typically start with:
_In_ : input parameter to a function, unmodified by called function
_Out_ : output parameter, written to by called function, pointed-to
location not expected to be initialized prior to call
_Outptr_ : like _Out_ when returned variable is a pointer type
(so param is pointer-to-pointer type). Called function
provides/allocated space.
_Outref_ : like _Outptr_, except param is reference-to-pointer type.
_Inout_ : inout parameter, read from and potentially modified by
called function.
_Ret_ : for return values
_Field_ : class/struct field invariants
For common usage, this class of SAL provides the most concise annotations.
Note that _In_/_Out_/_Inout_/_Outptr_ annotations are designed to be used
with a parameter target. Using them with _At_ to specify non-parameter
targets may yield unexpected results.
This layer also includes a number of other properties that can be specified
to extend the ability of code analysis, most notably:
-- Designating parameters as format strings for printf/scanf/scanf_s
-- Requesting stricter type checking for C enum parameters
_Pre_/_Post_ Layer:
------------------
The macros of this layer only should be used when there is no suitable macro
in the _In_/_Out_ layer. Its macros start with _Pre_ or _Post_.
This layer provides the most flexibility for annotations.
Implementation Abstraction Layer:
--------------------------------
Macros from this layer should never be used directly. The layer only exists
to hide the implementation of the annotation macros.
Structural Layer:
----------------
These annotations, like _At_ and _When_, are used with annotations from
any of the other layers as modifiers, indicating exactly when and where
the annotations apply.
Common syntactic conventions:
----------------------------
Usage:
-----
_In_, _Out_, _Inout_, _Pre_, _Post_, are for formal parameters.
_Ret_, _Deref_ret_ must be used for return values.
Nullness:
--------
If the parameter can be NULL as a precondition to the function, the
annotation contains _opt. If the macro does not contain '_opt' the
parameter cannot be NULL.
If an out/inout parameter returns a null pointer as a postcondition, this is
indicated by _Ret_maybenull_ or _result_maybenull_. If the macro is not
of this form, then the result will not be NULL as a postcondition.
_Outptr_ - output value is not NULL
_Outptr_result_maybenull_ - output value might be NULL
String Type:
-----------
_z: NullTerminated string
for _In_ parameters the buffer must have the specified stringtype before the call
for _Out_ parameters the buffer must have the specified stringtype after the call
for _Inout_ parameters both conditions apply
Extent Syntax:
-------------
Buffer sizes are expressed as element counts, unless the macro explicitly
contains _byte_ or _bytes_. Some annotations specify two buffer sizes, in
which case the second is used to indicate how much of the buffer is valid
as a postcondition. This table outlines the precondition buffer allocation
size, precondition number of valid elements, postcondition allocation size,
and postcondition number of valid elements for representative buffer size
annotations:
Pre | Pre | Post | Post
alloc | valid | alloc | valid
Annotation elems | elems | elems | elems
---------- ------------------------------------
_In_reads_(s) s | s | s | s
_Inout_updates_(s) s | s | s | s
_Inout_updates_to_(s,c) s | s | s | c
_Out_writes_(s) s | 0 | s | s
_Out_writes_to_(s,c) s | 0 | s | c
_Outptr_result_buffer_(s) ? | ? | s | s
_Outptr_result_buffer_to_(s,c) ? | ? | s | c
For the _Outptr_ annotations, the buffer in question is at one level of
dereference. The called function is responsible for supplying the buffer.
Success and failure:
-------------------
The SAL concept of success allows functions to define expressions that can
be tested by the caller, which if it evaluates to non-zero, indicates the
function succeeded, which means that its postconditions are guaranteed to
hold. Otherwise, if the expression evaluates to zero, the function is
considered to have failed, and the postconditions are not guaranteed.
The success criteria can be specified with the _Success_(expr) annotation:
_Success_(return != FALSE) BOOL
PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR pszBuf, LPCSTR pszPath) :
pszBuf is only guaranteed to be NULL-terminated when TRUE is returned,
and FALSE indiates failure. In common practice, callers check for zero
vs. non-zero returns, so it is preferable to express the success
criteria in terms of zero/non-zero, not checked for exactly TRUE.
Functions can specify that some postconditions will still hold, even when
the function fails, using _On_failure_(anno-list), or postconditions that
hold regardless of success or failure using _Always_(anno-list).
The annotation _Return_type_success_(expr) may be used with a typedef to
give a default _Success_ criteria to all functions returning that type.
This is the case for common Windows API status types, including
HRESULT and NTSTATUS. This may be overridden on a per-function basis by
specifying a _Success_ annotation locally.
============================================================================*/
#define __ATTR_SAL
#ifndef _SAL_VERSION /*IFSTRIP=IGN*/
#define _SAL_VERSION 20
#endif
#ifdef _PREFAST_ // [
// choose attribute or __declspec implementation
#ifndef _USE_DECLSPECS_FOR_SAL // [
#define _USE_DECLSPECS_FOR_SAL 1
#endif // ]
#if _USE_DECLSPECS_FOR_SAL // [
#undef _USE_ATTRIBUTES_FOR_SAL
#define _USE_ATTRIBUTES_FOR_SAL 0
#elif !defined(_USE_ATTRIBUTES_FOR_SAL) // ][
#if _MSC_VER >= 1400 /*IFSTRIP=IGN*/ // [
#define _USE_ATTRIBUTES_FOR_SAL 1
#else // ][
#define _USE_ATTRIBUTES_FOR_SAL 0
#endif // ]
#endif // ]
#if !_USE_DECLSPECS_FOR_SAL // [
#if !_USE_ATTRIBUTES_FOR_SAL // [
#if _MSC_VER >= 1400 /*IFSTRIP=IGN*/ // [
#undef _USE_ATTRIBUTES_FOR_SAL
#define _USE_ATTRIBUTES_FOR_SAL 1
#else // ][
#undef _USE_DECLSPECS_FOR_SAL
#define _USE_DECLSPECS_FOR_SAL 1
#endif // ]
#endif // ]
#endif // ]
#else
// Disable expansion of SAL macros in non-Prefast mode to
// improve compiler throughput.
#ifndef _USE_DECLSPECS_FOR_SAL // [
#define _USE_DECLSPECS_FOR_SAL 0
#endif // ]
#ifndef _USE_ATTRIBUTES_FOR_SAL // [
#define _USE_ATTRIBUTES_FOR_SAL 0
#endif // ]
#endif // ]
// safeguard for MIDL and RC builds
#if _USE_DECLSPECS_FOR_SAL && ( defined( MIDL_PASS ) || defined(__midl) || defined(RC_INVOKED) || !defined(_PREFAST_) ) /*IFSTRIP=IGN*/ // [
#undef _USE_DECLSPECS_FOR_SAL
#define _USE_DECLSPECS_FOR_SAL 0
#endif // ]
#if _USE_ATTRIBUTES_FOR_SAL && ( !defined(_MSC_EXTENSIONS) || defined( MIDL_PASS ) || defined(__midl) || defined(RC_INVOKED) ) /*IFSTRIP=IGN*/ // [
#undef _USE_ATTRIBUTES_FOR_SAL
#define _USE_ATTRIBUTES_FOR_SAL 0
#endif // ]
#if _USE_DECLSPECS_FOR_SAL || _USE_ATTRIBUTES_FOR_SAL
// Special enum type for Y/N/M
enum __SAL_YesNo {_SAL_notpresent, _SAL_no, _SAL_maybe, _SAL_yes, _SAL_default};
#endif
#if defined(BUILD_WINDOWS) && !_USE_ATTRIBUTES_FOR_SAL /*IFSTRIP=IGN*/
#define _SAL1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1") _GrouP_(annotes _SAL_nop_impl_)
#define _SAL1_1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.1") _GrouP_(annotes _SAL_nop_impl_)
#define _SAL1_2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.2") _GrouP_(annotes _SAL_nop_impl_)
#define _SAL2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "2") _GrouP_(annotes _SAL_nop_impl_)
#else
#define _SAL1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1") _Group_(annotes _SAL_nop_impl_)
#define _SAL1_1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.1") _Group_(annotes _SAL_nop_impl_)
#define _SAL1_2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.2") _Group_(annotes _SAL_nop_impl_)
#define _SAL2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "2") _Group_(annotes _SAL_nop_impl_)
#endif
//============================================================================
// Structural SAL:
// These annotations modify the use of other annotations. They may
// express the annotation target (i.e. what parameter/field the annotation
// applies to) or the condition under which the annotation is applicable.
//============================================================================
// _At_(target, annos) specifies that the annotations listed in 'annos' is to
// be applied to 'target' rather than to the identifier which is the current
// lexical target.
#define _At_(target, annos) _At_impl_(target, annos _SAL_nop_impl_)
// _At_buffer_(target, iter, bound, annos) is similar to _At_, except that
// target names a buffer, and each annotation in annos is applied to each
// element of target up to bound, with the variable named in iter usable
// by the annotations to refer to relevant offsets within target.
#define _At_buffer_(target, iter, bound, annos) _At_buffer_impl_(target, iter, bound, annos _SAL_nop_impl_)
// _When_(expr, annos) specifies that the annotations listed in 'annos' only
// apply when 'expr' evaluates to non-zero.
#define _When_(expr, annos) _When_impl_(expr, annos _SAL_nop_impl_)
#define _Group_(annos) _Group_impl_(annos _SAL_nop_impl_)
#define _GrouP_(annos) _GrouP_impl_(annos _SAL_nop_impl_)
// <expr> indicates whether normal post conditions apply to a function
#define _Success_(expr) _SAL2_Source_(_Success_, (expr), _Success_impl_(expr))
// <expr> indicates whether post conditions apply to a function returning
// the type that this annotation is applied to
#define _Return_type_success_(expr) _SAL2_Source_(_Return_type_success_, (expr), _Success_impl_(expr))
// Establish postconditions that apply only if the function does not succeed
#define _On_failure_(annos) _On_failure_impl_(annos _SAL_nop_impl_)
// Establish postconditions that apply in both success and failure cases.
// Only applicable with functions that have _Success_ or _Return_type_succss_.
#define _Always_(annos) _Always_impl_(annos _SAL_nop_impl_)
// Usable on a function defintion. Asserts that a function declaration is
// in scope, and its annotations are to be used. There are no other annotations
// allowed on the function definition.
#define _Use_decl_annotations_ _Use_decl_anno_impl_
// _Notref_ may precede a _Deref_ or "real" annotation, and removes one
// level of dereference if the parameter is a C++ reference (&). If the
// net deref on a "real" annotation is negative, it is simply discarded.
#define _Notref_ _Notref_impl_
// Annotations for defensive programming styles.
#define _Pre_defensive_ _SA_annotes0(SAL_pre_defensive)
#define _Post_defensive_ _SA_annotes0(SAL_post_defensive)
#define _In_defensive_(annotes) _Pre_defensive_ _Group_(annotes)
#define _Out_defensive_(annotes) _Post_defensive_ _Group_(annotes)
#define _Inout_defensive_(annotes) _Pre_defensive_ _Post_defensive_ _Group_(annotes)
//============================================================================
// _In_\_Out_ Layer:
//============================================================================
// Reserved pointer parameters, must always be NULL.
#define _Reserved_ _SAL2_Source_(_Reserved_, (), _Pre1_impl_(__null_impl))
// _Const_ allows specification that any namable memory location is considered
// readonly for a given call.
#define _Const_ _SAL2_Source_(_Const_, (), _Pre1_impl_(__readaccess_impl_notref))
// Input parameters --------------------------
// _In_ - Annotations for parameters where data is passed into the function, but not modified.
// _In_ by itself can be used with non-pointer types (although it is redundant).
// e.g. void SetPoint( _In_ const POINT* pPT );
#define _In_ _SAL2_Source_(_In_, (), _Pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_ _Deref_pre1_impl_(__readaccess_impl_notref))
#define _In_opt_ _SAL2_Source_(_In_opt_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_ _Deref_pre_readonly_)
// nullterminated 'in' parameters.
// e.g. void CopyStr( _In_z_ const char* szFrom, _Out_z_cap_(cchTo) char* szTo, size_t cchTo );
#define _In_z_ _SAL2_Source_(_In_z_, (), _In_ _Pre1_impl_(__zterm_impl))
#define _In_opt_z_ _SAL2_Source_(_In_opt_z_, (), _In_opt_ _Pre1_impl_(__zterm_impl))
// 'input' buffers with given size
#define _In_reads_(size) _SAL2_Source_(_In_reads_, (size), _Pre_count_(size) _Deref_pre_readonly_)
#define _In_reads_opt_(size) _SAL2_Source_(_In_reads_opt_, (size), _Pre_opt_count_(size) _Deref_pre_readonly_)
#define _In_reads_bytes_(size) _SAL2_Source_(_In_reads_bytes_, (size), _Pre_bytecount_(size) _Deref_pre_readonly_)
#define _In_reads_bytes_opt_(size) _SAL2_Source_(_In_reads_bytes_opt_, (size), _Pre_opt_bytecount_(size) _Deref_pre_readonly_)
#define _In_reads_z_(size) _SAL2_Source_(_In_reads_z_, (size), _In_reads_(size) _Pre_z_)
#define _In_reads_opt_z_(size) _SAL2_Source_(_In_reads_opt_z_, (size), _Pre_opt_count_(size) _Deref_pre_readonly_ _Pre_opt_z_)
#define _In_reads_or_z_(size) _SAL2_Source_(_In_reads_or_z_, (size), _In_ _When_(_String_length_(_Curr_) < (size), _Pre_z_) _When_(_String_length_(_Curr_) >= (size), _Pre1_impl_(__count_impl(size))))
#define _In_reads_or_z_opt_(size) _SAL2_Source_(_In_reads_or_z_opt_, (size), _In_opt_ _When_(_String_length_(_Curr_) < (size), _Pre_z_) _When_(_String_length_(_Curr_) >= (size), _Pre1_impl_(__count_impl(size))))
// 'input' buffers valid to the given end pointer
#define _In_reads_to_ptr_(ptr) _SAL2_Source_(_In_reads_to_ptr_, (ptr), _Pre_ptrdiff_count_(ptr) _Deref_pre_readonly_)
#define _In_reads_to_ptr_opt_(ptr) _SAL2_Source_(_In_reads_to_ptr_opt_, (ptr), _Pre_opt_ptrdiff_count_(ptr) _Deref_pre_readonly_)
#define _In_reads_to_ptr_z_(ptr) _SAL2_Source_(_In_reads_to_ptr_z_, (ptr), _In_reads_to_ptr_(ptr) _Pre_z_)
#define _In_reads_to_ptr_opt_z_(ptr) _SAL2_Source_(_In_reads_to_ptr_opt_z_, (ptr), _Pre_opt_ptrdiff_count_(ptr) _Deref_pre_readonly_ _Pre_opt_z_)
// Output parameters --------------------------
// _Out_ - Annotations for pointer or reference parameters where data passed back to the caller.
// These are mostly used where the pointer/reference is to a non-pointer type.
// _Outptr_/_Outref) (see below) are typically used to return pointers via parameters.
// e.g. void GetPoint( _Out_ POINT* pPT );
#define _Out_ _SAL2_Source_(_Out_, (), _Out_impl_)
#define _Out_opt_ _SAL2_Source_(_Out_opt_, (), _Out_opt_impl_)
#define _Out_writes_(size) _SAL2_Source_(_Out_writes_, (size), _Pre_cap_(size) _Post_valid_impl_)
#define _Out_writes_opt_(size) _SAL2_Source_(_Out_writes_opt_, (size), _Pre_opt_cap_(size) _Post_valid_impl_)
#define _Out_writes_bytes_(size) _SAL2_Source_(_Out_writes_bytes_, (size), _Pre_bytecap_(size) _Post_valid_impl_)
#define _Out_writes_bytes_opt_(size) _SAL2_Source_(_Out_writes_bytes_opt_, (size), _Pre_opt_bytecap_(size) _Post_valid_impl_)
#define _Out_writes_z_(size) _SAL2_Source_(_Out_writes_z_, (size), _Pre_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_writes_opt_z_(size) _SAL2_Source_(_Out_writes_opt_z_, (size), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_writes_to_(size,count) _SAL2_Source_(_Out_writes_to_, (size,count), _Pre_cap_(size) _Post_valid_impl_ _Post_count_(count))
#define _Out_writes_to_opt_(size,count) _SAL2_Source_(_Out_writes_to_opt_, (size,count), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_count_(count))
#define _Out_writes_all_(size) _SAL2_Source_(_Out_writes_all_, (size), _Out_writes_to_(_Old_(size), _Old_(size)))
#define _Out_writes_all_opt_(size) _SAL2_Source_(_Out_writes_all_opt_, (size), _Out_writes_to_opt_(_Old_(size), _Old_(size)))
#define _Out_writes_bytes_to_(size,count) _SAL2_Source_(_Out_writes_bytes_to_, (size,count), _Pre_bytecap_(size) _Post_valid_impl_ _Post_bytecount_(count))
#define _Out_writes_bytes_to_opt_(size,count) _SAL2_Source_(_Out_writes_bytes_to_opt_, (size,count), _Pre_opt_bytecap_(size) _Post_valid_impl_ _Post_bytecount_(count))
#define _Out_writes_bytes_all_(size) _SAL2_Source_(_Out_writes_bytes_all_, (size), _Out_writes_bytes_to_(_Old_(size), _Old_(size)))
#define _Out_writes_bytes_all_opt_(size) _SAL2_Source_(_Out_writes_bytes_all_opt_, (size), _Out_writes_bytes_to_opt_(_Old_(size), _Old_(size)))
#define _Out_writes_to_ptr_(ptr) _SAL2_Source_(_Out_writes_to_ptr_, (ptr), _Pre_ptrdiff_cap_(ptr) _Post_valid_impl_)
#define _Out_writes_to_ptr_opt_(ptr) _SAL2_Source_(_Out_writes_to_ptr_opt_, (ptr), _Pre_opt_ptrdiff_cap_(ptr) _Post_valid_impl_)
#define _Out_writes_to_ptr_z_(ptr) _SAL2_Source_(_Out_writes_to_ptr_z_, (ptr), _Pre_ptrdiff_cap_(ptr) _Post_valid_impl_ Post_z_)
#define _Out_writes_to_ptr_opt_z_(ptr) _SAL2_Source_(_Out_writes_to_ptr_opt_z_, (ptr), _Pre_opt_ptrdiff_cap_(ptr) _Post_valid_impl_ Post_z_)
// Inout parameters ----------------------------
// _Inout_ - Annotations for pointer or reference parameters where data is passed in and
// potentially modified.
// void ModifyPoint( _Inout_ POINT* pPT );
// void ModifyPointByRef( _Inout_ POINT& pPT );
#define _Inout_ _SAL2_Source_(_Inout_, (), _Prepost_valid_)
#define _Inout_opt_ _SAL2_Source_(_Inout_opt_, (), _Prepost_opt_valid_)
// For modifying string buffers
// void toupper( _Inout_z_ char* sz );
#define _Inout_z_ _SAL2_Source_(_Inout_z_, (), _Prepost_z_)
#define _Inout_opt_z_ _SAL2_Source_(_Inout_opt_z_, (), _Prepost_opt_z_)
// For modifying buffers with explicit element size
#define _Inout_updates_(size) _SAL2_Source_(_Inout_updates_, (size), _Pre_cap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_opt_(size) _SAL2_Source_(_Inout_updates_opt_, (size), _Pre_opt_cap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_z_(size) _SAL2_Source_(_Inout_updates_z_, (size), _Pre_cap_(size) _Pre_valid_impl_ _Post_valid_impl_ _Pre1_impl_(__zterm_impl) _Post1_impl_(__zterm_impl))
#define _Inout_updates_opt_z_(size) _SAL2_Source_(_Inout_updates_opt_z_, (size), _Pre_opt_cap_(size) _Pre_valid_impl_ _Post_valid_impl_ _Pre1_impl_(__zterm_impl) _Post1_impl_(__zterm_impl))
#define _Inout_updates_to_(size,count) _SAL2_Source_(_Inout_updates_to_, (size,count), _Out_writes_to_(size,count) _Pre_valid_impl_ _Pre1_impl_(__count_impl(count)))
#define _Inout_updates_to_opt_(size,count) _SAL2_Source_(_Inout_updates_to_opt_, (size,count), _Out_writes_to_opt_(size,count) _Pre_valid_impl_ _Pre1_impl_(__count_impl(count)))
#define _Inout_updates_all_(size) _SAL2_Source_(_Inout_updates_all_, (size), _Inout_updates_to_(_Old_(size), _Old_(size)))
#define _Inout_updates_all_opt_(size) _SAL2_Source_(_Inout_updates_all_opt_, (size), _Inout_updates_to_opt_(_Old_(size), _Old_(size)))
// For modifying buffers with explicit byte size
#define _Inout_updates_bytes_(size) _SAL2_Source_(_Inout_updates_bytes_, (size), _Pre_bytecap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_bytes_opt_(size) _SAL2_Source_(_Inout_updates_bytes_opt_, (size), _Pre_opt_bytecap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_bytes_to_(size,count) _SAL2_Source_(_Inout_updates_bytes_to_, (size,count), _Out_writes_bytes_to_(size,count) _Pre_valid_impl_ _Pre1_impl_(__bytecount_impl(count)))
#define _Inout_updates_bytes_to_opt_(size,count) _SAL2_Source_(_Inout_updates_bytes_to_opt_, (size,count), _Out_writes_bytes_to_opt_(size,count) _Pre_valid_impl_ _Pre1_impl_(__bytecount_impl(count)))
#define _Inout_updates_bytes_all_(size) _SAL2_Source_(_Inout_updates_bytes_all_, (size), _Inout_updates_bytes_to_(_Old_(size), _Old_(size)))
#define _Inout_updates_bytes_all_opt_(size) _SAL2_Source_(_Inout_updates_bytes_all_opt_, (size), _Inout_updates_bytes_to_opt_(_Old_(size), _Old_(size)))
// Pointer to pointer parameters -------------------------
// _Outptr_ - Annotations for output params returning pointers
// These describe parameters where the called function provides the buffer:
// HRESULT SHStrDupW(_In_ LPCWSTR psz, _Outptr_ LPWSTR *ppwsz);
// The caller passes the address of an LPWSTR variable as ppwsz, and SHStrDupW allocates
// and initializes memory and returns the pointer to the new LPWSTR in *ppwsz.
//
// _Outptr_opt_ - describes parameters that are allowed to be NULL.
// _Outptr_*_result_maybenull_ - describes parameters where the called function might return NULL to the caller.
//
// Example:
// void MyFunc(_Outptr_opt_ int **ppData1, _Outptr_result_maybenull_ int **ppData2);
// Callers:
// MyFunc(NULL, NULL); // error: parameter 2, ppData2, should not be NULL
// MyFunc(&pData1, &pData2); // ok: both non-NULL
// if (*pData1 == *pData2) ... // error: pData2 might be NULL after call
#define _Outptr_ _SAL2_Source_(_Outptr_, (), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(1)))
#define _Outptr_result_maybenull_ _SAL2_Source_(_Outptr_result_maybenull_, (), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(1)))
#define _Outptr_opt_ _SAL2_Source_(_Outptr_opt_, (), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(1)))
#define _Outptr_opt_result_maybenull_ _SAL2_Source_(_Outptr_opt_result_maybenull_, (), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(1)))
// Annotations for _Outptr_ parameters returning pointers to null terminated strings.
#define _Outptr_result_z_ _SAL2_Source_(_Outptr_result_z_, (), _Out_impl_ _Deref_post_z_)
#define _Outptr_opt_result_z_ _SAL2_Source_(_Outptr_opt_result_z_, (), _Out_opt_impl_ _Deref_post_z_)
#define _Outptr_result_maybenull_z_ _SAL2_Source_(_Outptr_result_maybenull_z_, (), _Out_impl_ _Deref_post_opt_z_)
#define _Outptr_opt_result_maybenull_z_ _SAL2_Source_(_Outptr_opt_result_maybenull_z_, (), _Out_opt_impl_ _Deref_post_opt_z_)
// Annotations for _Outptr_ parameters where the output pointer is set to NULL if the function fails.
#define _Outptr_result_nullonfailure_ _SAL2_Source_(_Outptr_result_nullonfailure_, (), _Outptr_ _On_failure_(_Deref_post_null_))
#define _Outptr_opt_result_nullonfailure_ _SAL2_Source_(_Outptr_opt_result_nullonfailure_, (), _Outptr_opt_ _On_failure_(_Deref_post_null_))
// Annotations for _Outptr_ parameters which return a pointer to a ref-counted COM object,
// following the COM convention of setting the output to NULL on failure.
// The current implementation is identical to _Outptr_result_nullonfailure_.
// For pointers to types that are not COM objects, _Outptr_result_nullonfailure_ is preferred.
#define _COM_Outptr_ _SAL2_Source_(_COM_Outptr_, (), _Outptr_ _On_failure_(_Deref_post_null_))
#define _COM_Outptr_result_maybenull_ _SAL2_Source_(_COM_Outptr_result_maybenull_, (), _Outptr_result_maybenull_ _On_failure_(_Deref_post_null_))
#define _COM_Outptr_opt_ _SAL2_Source_(_COM_Outptr_opt_, (), _Outptr_opt_ _On_failure_(_Deref_post_null_))
#define _COM_Outptr_opt_result_maybenull_ _SAL2_Source_(_COM_Outptr_opt_result_maybenull_, (), _Outptr_opt_result_maybenull_ _On_failure_(_Deref_post_null_))
// Annotations for _Outptr_ parameters returning a pointer to buffer with a specified number of elements/bytes
#define _Outptr_result_buffer_(size) _SAL2_Source_(_Outptr_result_buffer_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __cap_impl(size)))
#define _Outptr_opt_result_buffer_(size) _SAL2_Source_(_Outptr_opt_result_buffer_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __cap_impl(size)))
#define _Outptr_result_buffer_to_(size, count) _SAL2_Source_(_Outptr_result_buffer_to_, (size, count), _Out_impl_ _Deref_post3_impl_(__notnull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_opt_result_buffer_to_(size, count) _SAL2_Source_(_Outptr_opt_result_buffer_to_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__notnull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_result_buffer_all_(size) _SAL2_Source_(_Outptr_result_buffer_all_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(size)))
#define _Outptr_opt_result_buffer_all_(size) _SAL2_Source_(_Outptr_opt_result_buffer_all_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(size)))
#define _Outptr_result_buffer_maybenull_(size) _SAL2_Source_(_Outptr_result_buffer_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __cap_impl(size)))
#define _Outptr_opt_result_buffer_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_buffer_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __cap_impl(size)))
#define _Outptr_result_buffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_result_buffer_to_maybenull_, (size, count), _Out_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_opt_result_buffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_opt_result_buffer_to_maybenull_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_result_buffer_all_maybenull_(size) _SAL2_Source_(_Outptr_result_buffer_all_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(size)))
#define _Outptr_opt_result_buffer_all_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_buffer_all_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(size)))
#define _Outptr_result_bytebuffer_(size) _SAL2_Source_(_Outptr_result_bytebuffer_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecap_impl(size)))
#define _Outptr_opt_result_bytebuffer_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecap_impl(size)))
#define _Outptr_result_bytebuffer_to_(size, count) _SAL2_Source_(_Outptr_result_bytebuffer_to_, (size, count), _Out_impl_ _Deref_post3_impl_(__notnull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_opt_result_bytebuffer_to_(size, count) _SAL2_Source_(_Outptr_opt_result_bytebuffer_to_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__notnull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_result_bytebuffer_all_(size) _SAL2_Source_(_Outptr_result_bytebuffer_all_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecount_impl(size)))
#define _Outptr_opt_result_bytebuffer_all_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_all_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecount_impl(size)))
#define _Outptr_result_bytebuffer_maybenull_(size) _SAL2_Source_(_Outptr_result_bytebuffer_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecap_impl(size)))
#define _Outptr_opt_result_bytebuffer_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecap_impl(size)))
#define _Outptr_result_bytebuffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_result_bytebuffer_to_maybenull_, (size, count), _Out_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_opt_result_bytebuffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_opt_result_bytebuffer_to_maybenull_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_result_bytebuffer_all_maybenull_(size) _SAL2_Source_(_Outptr_result_bytebuffer_all_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecount_impl(size)))
#define _Outptr_opt_result_bytebuffer_all_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_all_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecount_impl(size)))
// Annotations for output reference to pointer parameters.
#define _Outref_ _SAL2_Source_(_Outref_, (), _Out_impl_ _Post_notnull_)
#define _Outref_result_maybenull_ _SAL2_Source_(_Outref_result_maybenull_, (), _Pre2_impl_(__notnull_impl_notref, __cap_c_one_notref_impl) _Post_maybenull_ _Post_valid_impl_)
#define _Outref_result_buffer_(size) _SAL2_Source_(_Outref_result_buffer_, (size), _Outref_ _Post1_impl_(__cap_impl(size)))
#define _Outref_result_bytebuffer_(size) _SAL2_Source_(_Outref_result_bytebuffer_, (size), _Outref_ _Post1_impl_(__bytecap_impl(size)))
#define _Outref_result_buffer_to_(size, count) _SAL2_Source_(_Outref_result_buffer_to_, (size, count), _Outref_result_buffer_(size) _Post1_impl_(__count_impl(count)))
#define _Outref_result_bytebuffer_to_(size, count) _SAL2_Source_(_Outref_result_bytebuffer_to_, (size, count), _Outref_result_bytebuffer_(size) _Post1_impl_(__bytecount_impl(count)))
#define _Outref_result_buffer_all_(size) _SAL2_Source_(_Outref_result_buffer_all_, (size), _Outref_result_buffer_to_(size, _Old_(size)))
#define _Outref_result_bytebuffer_all_(size) _SAL2_Source_(_Outref_result_bytebuffer_all_, (size), _Outref_result_bytebuffer_to_(size, _Old_(size)))
#define _Outref_result_buffer_maybenull_(size) _SAL2_Source_(_Outref_result_buffer_maybenull_, (size), _Outref_result_maybenull_ _Post1_impl_(__cap_impl(size)))
#define _Outref_result_bytebuffer_maybenull_(size) _SAL2_Source_(_Outref_result_bytebuffer_maybenull_, (size), _Outref_result_maybenull_ _Post1_impl_(__bytecap_impl(size)))
#define _Outref_result_buffer_to_maybenull_(size, count) _SAL2_Source_(_Outref_result_buffer_to_maybenull_, (size, count), _Outref_result_buffer_maybenull_(size) _Post1_impl_(__count_impl(count)))
#define _Outref_result_bytebuffer_to_maybenull_(size, count) _SAL2_Source_(_Outref_result_bytebuffer_to_maybenull_, (size, count), _Outref_result_bytebuffer_maybenull_(size) _Post1_impl_(__bytecount_impl(count)))
#define _Outref_result_buffer_all_maybenull_(size) _SAL2_Source_(_Outref_result_buffer_all_maybenull_, (size), _Outref_result_buffer_to_maybenull_(size, _Old_(size)))
#define _Outref_result_bytebuffer_all_maybenull_(size) _SAL2_Source_(_Outref_result_bytebuffer_all_maybenull_, (size), _Outref_result_bytebuffer_to_maybenull_(size, _Old_(size)))
// Annotations for output reference to pointer parameters that guarantee
// that the pointer is set to NULL on failure.
#define _Outref_result_nullonfailure_ _SAL2_Source_(_Outref_result_nullonfailure_, (), _Outref_ _On_failure_(_Post_null_))
// Generic annotations to set output value of a by-pointer or by-reference parameter to null/zero on failure.
#define _Result_nullonfailure_ _SAL2_Source_(_Result_nullonfailure_, (), _On_failure_(_Notref_impl_ _Deref_impl_ _Post_null_))
#define _Result_zeroonfailure_ _SAL2_Source_(_Result_zeroonfailure_, (), _On_failure_(_Notref_impl_ _Deref_impl_ _Out_range_(==, 0)))
// return values -------------------------------
//
// _Ret_ annotations
//
// describing conditions that hold for return values after the call
// e.g. _Ret_z_ CString::operator const WCHAR*() const throw();
#define _Ret_z_ _SAL2_Source_(_Ret_z_, (), _Ret2_impl_(__notnull_impl, __zterm_impl) _Ret_valid_impl_)
#define _Ret_maybenull_z_ _SAL2_Source_(_Ret_maybenull_z_, (), _Ret2_impl_(__maybenull_impl,__zterm_impl) _Ret_valid_impl_)
// used with allocated but not yet initialized objects
#define _Ret_notnull_ _SAL2_Source_(_Ret_notnull_, (), _Ret1_impl_(__notnull_impl))
#define _Ret_maybenull_ _SAL2_Source_(_Ret_maybenull_, (), _Ret1_impl_(__maybenull_impl))
#define _Ret_null_ _SAL2_Source_(_Ret_null_, (), _Ret1_impl_(__null_impl))
// used with allocated and initialized objects
// returns single valid object
#define _Ret_valid_ _SAL2_Source_(_Ret_valid_, (), _Ret1_impl_(__notnull_impl_notref) _Ret_valid_impl_)
// returns pointer to initialized buffer of specified size
#define _Ret_writes_(size) _SAL2_Source_(_Ret_writes_, (size), _Ret2_impl_(__notnull_impl, __count_impl(size)) _Ret_valid_impl_)
#define _Ret_writes_z_(size) _SAL2_Source_(_Ret_writes_z_, (size), _Ret3_impl_(__notnull_impl, __count_impl(size), __zterm_impl) _Ret_valid_impl_)
#define _Ret_writes_bytes_(size) _SAL2_Source_(_Ret_writes_bytes_, (size), _Ret2_impl_(__notnull_impl, __bytecount_impl(size)) _Ret_valid_impl_)
#define _Ret_writes_maybenull_(size) _SAL2_Source_(_Ret_writes_maybenull_, (size), _Ret2_impl_(__maybenull_impl,__count_impl(size)) _Ret_valid_impl_)
#define _Ret_writes_maybenull_z_(size) _SAL2_Source_(_Ret_writes_maybenull_z_, (size), _Ret3_impl_(__maybenull_impl,__count_impl(size),__zterm_impl) _Ret_valid_impl_)
#define _Ret_writes_bytes_maybenull_(size) _SAL2_Source_(_Ret_writes_bytes_maybenull_, (size), _Ret2_impl_(__maybenull_impl,__bytecount_impl(size)) _Ret_valid_impl_)
// returns pointer to partially initialized buffer, with total size 'size' and initialized size 'count'
#define _Ret_writes_to_(size,count) _SAL2_Source_(_Ret_writes_to_, (size,count), _Ret3_impl_(__notnull_impl, __cap_impl(size), __count_impl(count)) _Ret_valid_impl_)
#define _Ret_writes_bytes_to_(size,count) _SAL2_Source_(_Ret_writes_bytes_to_, (size,count), _Ret3_impl_(__notnull_impl, __bytecap_impl(size), __bytecount_impl(count)) _Ret_valid_impl_)
#define _Ret_writes_to_maybenull_(size,count) _SAL2_Source_(_Ret_writes_to_maybenull_, (size,count), _Ret3_impl_(__maybenull_impl, __cap_impl(size), __count_impl(count)) _Ret_valid_impl_)
#define _Ret_writes_bytes_to_maybenull_(size,count) _SAL2_Source_(_Ret_writes_bytes_to_maybenull_, (size,count), _Ret3_impl_(__maybenull_impl, __bytecap_impl(size), __bytecount_impl(count)) _Ret_valid_impl_)
// Annotations for strict type checking
#define _Points_to_data_ _SAL2_Source_(_Points_to_data_, (), _Pre_ _Points_to_data_impl_)
#define _Literal_ _SAL2_Source_(_Literal_, (), _Pre_ _Literal_impl_)
#define _Notliteral_ _SAL2_Source_(_Notliteral_, (), _Pre_ _Notliteral_impl_)
// Check the return value of a function e.g. _Check_return_ ErrorCode Foo();
#define _Check_return_ _SAL2_Source_(_Check_return_, (), _Check_return_impl_)
#define _Must_inspect_result_ _SAL2_Source_(_Must_inspect_result_, (), _Must_inspect_impl_ _Check_return_impl_)
// e.g. MyPrintF( _Printf_format_string_ const WCHAR* wzFormat, ... );
#define _Printf_format_string_ _SAL2_Source_(_Printf_format_string_, (), _Printf_format_string_impl_)
#define _Scanf_format_string_ _SAL2_Source_(_Scanf_format_string_, (), _Scanf_format_string_impl_)
#define _Scanf_s_format_string_ _SAL2_Source_(_Scanf_s_format_string_, (), _Scanf_s_format_string_impl_)
#define _Format_string_impl_(kind,where) _SA_annotes2(SAL_IsFormatString2, kind, where)
#define _Printf_format_string_params_(x) _SAL2_Source_(_Printf_format_string_params_, (x), _Format_string_impl_("printf", x))
#define _Scanf_format_string_params_(x) _SAL2_Source_(_Scanf_format_string_params_, (x), _Format_string_impl_("scanf", x))
#define _Scanf_s_format_string_params_(x) _SAL2_Source_(_Scanf_s_format_string_params_, (x), _Format_string_impl_("scanf_s", x))
// annotations to express value of integral or pointer parameter
#define _In_range_(lb,ub) _SAL2_Source_(_In_range_, (lb,ub), _In_range_impl_(lb,ub))
#define _Out_range_(lb,ub) _SAL2_Source_(_Out_range_, (lb,ub), _Out_range_impl_(lb,ub))
#define _Ret_range_(lb,ub) _SAL2_Source_(_Ret_range_, (lb,ub), _Ret_range_impl_(lb,ub))
#define _Deref_in_range_(lb,ub) _SAL2_Source_(_Deref_in_range_, (lb,ub), _Deref_in_range_impl_(lb,ub))
#define _Deref_out_range_(lb,ub) _SAL2_Source_(_Deref_out_range_, (lb,ub), _Deref_out_range_impl_(lb,ub))
#define _Deref_ret_range_(lb,ub) _SAL2_Source_(_Deref_ret_range_, (lb,ub), _Deref_ret_range_impl_(lb,ub))
#define _Pre_equal_to_(expr) _SAL2_Source_(_Pre_equal_to_, (expr), _In_range_(==, expr))
#define _Post_equal_to_(expr) _SAL2_Source_(_Post_equal_to_, (expr), _Out_range_(==, expr))
// annotation to express that a value (usually a field of a mutable class)
// is not changed by a function call
#define _Unchanged_(e) _SAL2_Source_(_Unchanged_, (e), _At_(e, _Post_equal_to_(_Old_(e)) _Const_))
// Annotations to allow expressing generalized pre and post conditions.
// 'cond' may be any valid SAL expression that is considered to be true as a precondition
// or postcondition (respsectively).
#define _Pre_satisfies_(cond) _SAL2_Source_(_Pre_satisfies_, (cond), _Pre_satisfies_impl_(cond))
#define _Post_satisfies_(cond) _SAL2_Source_(_Post_satisfies_, (cond), _Post_satisfies_impl_(cond))
// Annotations to express struct, class and field invariants
#define _Struct_size_bytes_(size) _SAL2_Source_(_Struct_size_bytes_, (size), _Writable_bytes_(size))
#define _Field_size_(size) _SAL2_Source_(_Field_size_, (size), _Notnull_ _Writable_elements_(size))
#define _Field_size_opt_(size) _SAL2_Source_(_Field_size_opt_, (size), _Maybenull_ _Writable_elements_(size))
#define _Field_size_part_(size, count) _SAL2_Source_(_Field_size_part_, (size, count), _Notnull_ _Writable_elements_(size) _Readable_elements_(count))
#define _Field_size_part_opt_(size, count) _SAL2_Source_(_Field_size_part_opt_, (size, count), _Maybenull_ _Writable_elements_(size) _Readable_elements_(count))
#define _Field_size_full_(size) _SAL2_Source_(_Field_size_full_, (size), _Field_size_part_(size, size))
#define _Field_size_full_opt_(size) _SAL2_Source_(_Field_size_full_opt_, (size), _Field_size_part_opt_(size, size))
#define _Field_size_bytes_(size) _SAL2_Source_(_Field_size_bytes_, (size), _Notnull_ _Writable_bytes_(size))
#define _Field_size_bytes_opt_(size) _SAL2_Source_(_Field_size_bytes_opt_, (size), _Maybenull_ _Writable_bytes_(size))
#define _Field_size_bytes_part_(size, count) _SAL2_Source_(_Field_size_bytes_part_, (size, count), _Notnull_ _Writable_bytes_(size) _Readable_bytes_(count))
#define _Field_size_bytes_part_opt_(size, count) _SAL2_Source_(_Field_size_bytes_part_opt_, (size, count), _Maybenull_ _Writable_bytes_(size) _Readable_bytes_(count))
#define _Field_size_bytes_full_(size) _SAL2_Source_(_Field_size_bytes_full_, (size), _Field_size_bytes_part_(size, size))
#define _Field_size_bytes_full_opt_(size) _SAL2_Source_(_Field_size_bytes_full_opt_, (size), _Field_size_bytes_part_opt_(size, size))
#define _Field_z_ _SAL2_Source_(_Field_z_, (), _Null_terminated_)
#define _Field_range_(min,max) _SAL2_Source_(_Field_range_, (min,max), _Field_range_impl_(min,max))
//============================================================================
// _Pre_\_Post_ Layer:
//============================================================================
//
// Raw Pre/Post for declaring custom pre/post conditions
//
#define _Pre_ _Pre_impl_
#define _Post_ _Post_impl_
//
// Validity property
//
#define _Valid_ _Valid_impl_
#define _Notvalid_ _Notvalid_impl_
#define _Maybevalid_ _Maybevalid_impl_
//
// Buffer size properties
//
// Expressing buffer sizes without specifying pre or post condition
#define _Readable_bytes_(size) _SAL2_Source_(_Readable_bytes_, (size), _Readable_bytes_impl_(size))
#define _Readable_elements_(size) _SAL2_Source_(_Readable_elements_, (size), _Readable_elements_impl_(size))
#define _Writable_bytes_(size) _SAL2_Source_(_Writable_bytes_, (size), _Writable_bytes_impl_(size))
#define _Writable_elements_(size) _SAL2_Source_(_Writable_elements_, (size), _Writable_elements_impl_(size))
#define _Null_terminated_ _SAL2_Source_(_Null_terminated_, (), _Null_terminated_impl_)
#define _NullNull_terminated_ _SAL2_Source_(_NullNull_terminated_, (), _NullNull_terminated_impl_)
// Expressing buffer size as pre or post condition
#define _Pre_readable_size_(size) _SAL2_Source_(_Pre_readable_size_, (size), _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Pre_writable_size_(size) _SAL2_Source_(_Pre_writable_size_, (size), _Pre1_impl_(__cap_impl(size)))
#define _Pre_readable_byte_size_(size) _SAL2_Source_(_Pre_readable_byte_size_, (size), _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
#define _Pre_writable_byte_size_(size) _SAL2_Source_(_Pre_writable_byte_size_, (size), _Pre1_impl_(__bytecap_impl(size)))
#define _Post_readable_size_(size) _SAL2_Source_(_Post_readable_size_, (size), _Post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Post_writable_size_(size) _SAL2_Source_(_Post_writable_size_, (size), _Post1_impl_(__cap_impl(size)))
#define _Post_readable_byte_size_(size) _SAL2_Source_(_Post_readable_byte_size_, (size), _Post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
#define _Post_writable_byte_size_(size) _SAL2_Source_(_Post_writable_byte_size_, (size), _Post1_impl_(__bytecap_impl(size)))
//
// Pointer null-ness properties
//
#define _Null_ _Null_impl_
#define _Notnull_ _Notnull_impl_
#define _Maybenull_ _Maybenull_impl_
//
// _Pre_ annotations ---
//
// describing conditions that must be met before the call of the function
// e.g. int strlen( _Pre_z_ const char* sz );
// buffer is a zero terminated string
#define _Pre_z_ _SAL2_Source_(_Pre_z_, (), _Pre1_impl_(__zterm_impl) _Pre_valid_impl_)
// valid size unknown or indicated by type (e.g.:LPSTR)
#define _Pre_valid_ _SAL2_Source_(_Pre_valid_, (), _Pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_)
#define _Pre_opt_valid_ _SAL2_Source_(_Pre_opt_valid_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_)
#define _Pre_invalid_ _SAL2_Source_(_Pre_invalid_, (), _Deref_pre1_impl_(__notvalid_impl))
// Overrides recursive valid when some field is not yet initialized when using _Inout_
#define _Pre_unknown_ _SAL2_Source_(_Pre_unknown_, (), _Pre1_impl_(__maybevalid_impl))
// used with allocated but not yet initialized objects
#define _Pre_notnull_ _SAL2_Source_(_Pre_notnull_, (), _Pre1_impl_(__notnull_impl_notref))
#define _Pre_maybenull_ _SAL2_Source_(_Pre_maybenull_, (), _Pre1_impl_(__maybenull_impl_notref))
#define _Pre_null_ _SAL2_Source_(_Pre_null_, (), _Pre1_impl_(__null_impl_notref))
//
// _Post_ annotations ---
//
// describing conditions that hold after the function call
// void CopyStr( _In_z_ const char* szFrom, _Pre_cap_(cch) _Post_z_ char* szFrom, size_t cchFrom );
// buffer will be a zero-terminated string after the call
#define _Post_z_ _SAL2_Source_(_Post_z_, (), _Post1_impl_(__zterm_impl) _Post_valid_impl_)
// e.g. HRESULT InitStruct( _Post_valid_ Struct* pobj );
#define _Post_valid_ _SAL2_Source_(_Post_valid_, (), _Post_valid_impl_)
#define _Post_invalid_ _SAL2_Source_(_Post_invalid_, (), _Deref_post1_impl_(__notvalid_impl))
// e.g. void free( _Post_ptr_invalid_ void* pv );
#define _Post_ptr_invalid_ _SAL2_Source_(_Post_ptr_invalid_, (), _Post1_impl_(__notvalid_impl))
// e.g. void ThrowExceptionIfNull( _Post_notnull_ const void* pv );
#define _Post_notnull_ _SAL2_Source_(_Post_notnull_, (), _Post1_impl_(__notnull_impl))
// e.g. HRESULT GetObject(_Outptr_ _On_failure_(_At_(*p, _Post_null_)) T **p);
#define _Post_null_ _SAL2_Source_(_Post_null_, (), _Post1_impl_(__null_impl))
#define _Post_maybenull_ _SAL2_Source_(_Post_maybenull_, (), _Post1_impl_(__maybenull_impl))
#define _Prepost_z_ _SAL2_Source_(_Prepost_z_, (), _Pre_z_ _Post_z_)
// #pragma region Input Buffer SAL 1 compatibility macros
/*==========================================================================
This section contains definitions for macros defined for VS2010 and earlier.
Usage of these macros is still supported, but the SAL 2 macros defined above
are recommended instead. This comment block is retained to assist in
understanding SAL that still uses the older syntax.
The macros are defined in 3 layers:
_In_\_Out_ Layer:
----------------
This layer provides the highest abstraction and its macros should be used
in most cases. Its macros start with _In_, _Out_ or _Inout_. For the
typical case they provide the most concise annotations.
_Pre_\_Post_ Layer:
------------------
The macros of this layer only should be used when there is no suitable macro
in the _In_\_Out_ layer. Its macros start with _Pre_, _Post_, _Ret_,
_Deref_pre_ _Deref_post_ and _Deref_ret_. This layer provides the most
flexibility for annotations.
Implementation Abstraction Layer:
--------------------------------
Macros from this layer should never be used directly. The layer only exists
to hide the implementation of the annotation macros.
Annotation Syntax:
|--------------|----------|----------------|-----------------------------|
| Usage | Nullness | ZeroTerminated | Extent |
|--------------|----------|----------------|-----------------------------|
| _In_ | <> | <> | <> |
| _Out_ | opt_ | z_ | [byte]cap_[c_|x_]( size ) |
| _Inout_ | | | [byte]count_[c_|x_]( size ) |
| _Deref_out_ | | | ptrdiff_cap_( ptr ) |
|--------------| | | ptrdiff_count_( ptr ) |
| _Ret_ | | | |
| _Deref_ret_ | | | |
|--------------| | | |
| _Pre_ | | | |
| _Post_ | | | |
| _Deref_pre_ | | | |
| _Deref_post_ | | | |
|--------------|----------|----------------|-----------------------------|
Usage:
-----
_In_, _Out_, _Inout_, _Pre_, _Post_, _Deref_pre_, _Deref_post_ are for
formal parameters.
_Ret_, _Deref_ret_ must be used for return values.
Nullness:
--------
If the pointer can be NULL the annotation contains _opt. If the macro
does not contain '_opt' the pointer may not be NULL.
String Type:
-----------
_z: NullTerminated string
for _In_ parameters the buffer must have the specified stringtype before the call
for _Out_ parameters the buffer must have the specified stringtype after the call
for _Inout_ parameters both conditions apply
Extent Syntax:
|------|---------------|---------------|
| Unit | Writ\Readable | Argument Type |
|------|---------------|---------------|
| <> | cap_ | <> |
| byte | count_ | c_ |
| | | x_ |
|------|---------------|---------------|
'cap' (capacity) describes the writable size of the buffer and is typically used
with _Out_. The default unit is elements. Use 'bytecap' if the size is given in bytes
'count' describes the readable size of the buffer and is typically used with _In_.
The default unit is elements. Use 'bytecount' if the size is given in bytes.
Argument syntax for cap_, bytecap_, count_, bytecount_:
(<parameter>|return)[+n] e.g. cch, return, cb+2
If the buffer size is a constant expression use the c_ postfix.
E.g. cap_c_(20), count_c_(MAX_PATH), bytecount_c_(16)
If the buffer size is given by a limiting pointer use the ptrdiff_ versions
of the macros.
If the buffer size is neither a parameter nor a constant expression use the x_
postfix. e.g. bytecount_x_(num*size) x_ annotations accept any arbitrary string.
No analysis can be done for x_ annotations but they at least tell the tool that
the buffer has some sort of extent description. x_ annotations might be supported
by future compiler versions.
============================================================================*/
// e.g. void SetCharRange( _In_count_(cch) const char* rgch, size_t cch )
// valid buffer extent described by another parameter
#define _In_count_(size) _SAL1_1_Source_(_In_count_, (size), _Pre_count_(size) _Deref_pre_readonly_)
#define _In_opt_count_(size) _SAL1_1_Source_(_In_opt_count_, (size), _Pre_opt_count_(size) _Deref_pre_readonly_)
#define _In_bytecount_(size) _SAL1_1_Source_(_In_bytecount_, (size), _Pre_bytecount_(size) _Deref_pre_readonly_)
#define _In_opt_bytecount_(size) _SAL1_1_Source_(_In_opt_bytecount_, (size), _Pre_opt_bytecount_(size) _Deref_pre_readonly_)
// valid buffer extent described by a constant extression
#define _In_count_c_(size) _SAL1_1_Source_(_In_count_c_, (size), _Pre_count_c_(size) _Deref_pre_readonly_)
#define _In_opt_count_c_(size) _SAL1_1_Source_(_In_opt_count_c_, (size), _Pre_opt_count_c_(size) _Deref_pre_readonly_)
#define _In_bytecount_c_(size) _SAL1_1_Source_(_In_bytecount_c_, (size), _Pre_bytecount_c_(size) _Deref_pre_readonly_)
#define _In_opt_bytecount_c_(size) _SAL1_1_Source_(_In_opt_bytecount_c_, (size), _Pre_opt_bytecount_c_(size) _Deref_pre_readonly_)
// nullterminated 'input' buffers with given size
// e.g. void SetCharRange( _In_count_(cch) const char* rgch, size_t cch )
// nullterminated valid buffer extent described by another parameter
#define _In_z_count_(size) _SAL1_1_Source_(_In_z_count_, (size), _Pre_z_ _Pre_count_(size) _Deref_pre_readonly_)
#define _In_opt_z_count_(size) _SAL1_1_Source_(_In_opt_z_count_, (size), _Pre_opt_z_ _Pre_opt_count_(size) _Deref_pre_readonly_)
#define _In_z_bytecount_(size) _SAL1_1_Source_(_In_z_bytecount_, (size), _Pre_z_ _Pre_bytecount_(size) _Deref_pre_readonly_)
#define _In_opt_z_bytecount_(size) _SAL1_1_Source_(_In_opt_z_bytecount_, (size), _Pre_opt_z_ _Pre_opt_bytecount_(size) _Deref_pre_readonly_)
// nullterminated valid buffer extent described by a constant extression
#define _In_z_count_c_(size) _SAL1_1_Source_(_In_z_count_c_, (size), _Pre_z_ _Pre_count_c_(size) _Deref_pre_readonly_)
#define _In_opt_z_count_c_(size) _SAL1_1_Source_(_In_opt_z_count_c_, (size), _Pre_opt_z_ _Pre_opt_count_c_(size) _Deref_pre_readonly_)
#define _In_z_bytecount_c_(size) _SAL1_1_Source_(_In_z_bytecount_c_, (size), _Pre_z_ _Pre_bytecount_c_(size) _Deref_pre_readonly_)
#define _In_opt_z_bytecount_c_(size) _SAL1_1_Source_(_In_opt_z_bytecount_c_, (size), _Pre_opt_z_ _Pre_opt_bytecount_c_(size) _Deref_pre_readonly_)
// buffer capacity is described by another pointer
// e.g. void Foo( _In_ptrdiff_count_(pchMax) const char* pch, const char* pchMax ) { while pch < pchMax ) pch++; }
#define _In_ptrdiff_count_(size) _SAL1_1_Source_(_In_ptrdiff_count_, (size), _Pre_ptrdiff_count_(size) _Deref_pre_readonly_)
#define _In_opt_ptrdiff_count_(size) _SAL1_1_Source_(_In_opt_ptrdiff_count_, (size), _Pre_opt_ptrdiff_count_(size) _Deref_pre_readonly_)
// 'x' version for complex expressions that are not supported by the current compiler version
// e.g. void Set3ColMatrix( _In_count_x_(3*cRows) const Elem* matrix, int cRows );
#define _In_count_x_(size) _SAL1_1_Source_(_In_count_x_, (size), _Pre_count_x_(size) _Deref_pre_readonly_)
#define _In_opt_count_x_(size) _SAL1_1_Source_(_In_opt_count_x_, (size), _Pre_opt_count_x_(size) _Deref_pre_readonly_)
#define _In_bytecount_x_(size) _SAL1_1_Source_(_In_bytecount_x_, (size), _Pre_bytecount_x_(size) _Deref_pre_readonly_)
#define _In_opt_bytecount_x_(size) _SAL1_1_Source_(_In_opt_bytecount_x_, (size), _Pre_opt_bytecount_x_(size) _Deref_pre_readonly_)
// 'out' with buffer size
// e.g. void GetIndeces( _Out_cap_(cIndeces) int* rgIndeces, size_t cIndices );
// buffer capacity is described by another parameter
#define _Out_cap_(size) _SAL1_1_Source_(_Out_cap_, (size), _Pre_cap_(size) _Post_valid_impl_)
#define _Out_opt_cap_(size) _SAL1_1_Source_(_Out_opt_cap_, (size), _Pre_opt_cap_(size) _Post_valid_impl_)
#define _Out_bytecap_(size) _SAL1_1_Source_(_Out_bytecap_, (size), _Pre_bytecap_(size) _Post_valid_impl_)
#define _Out_opt_bytecap_(size) _SAL1_1_Source_(_Out_opt_bytecap_, (size), _Pre_opt_bytecap_(size) _Post_valid_impl_)
// buffer capacity is described by a constant expression
#define _Out_cap_c_(size) _SAL1_1_Source_(_Out_cap_c_, (size), _Pre_cap_c_(size) _Post_valid_impl_)
#define _Out_opt_cap_c_(size) _SAL1_1_Source_(_Out_opt_cap_c_, (size), _Pre_opt_cap_c_(size) _Post_valid_impl_)
#define _Out_bytecap_c_(size) _SAL1_1_Source_(_Out_bytecap_c_, (size), _Pre_bytecap_c_(size) _Post_valid_impl_)
#define _Out_opt_bytecap_c_(size) _SAL1_1_Source_(_Out_opt_bytecap_c_, (size), _Pre_opt_bytecap_c_(size) _Post_valid_impl_)
// buffer capacity is described by another parameter multiplied by a constant expression
#define _Out_cap_m_(mult,size) _SAL1_1_Source_(_Out_cap_m_, (mult,size), _Pre_cap_m_(mult,size) _Post_valid_impl_)
#define _Out_opt_cap_m_(mult,size) _SAL1_1_Source_(_Out_opt_cap_m_, (mult,size), _Pre_opt_cap_m_(mult,size) _Post_valid_impl_)
#define _Out_z_cap_m_(mult,size) _SAL1_1_Source_(_Out_z_cap_m_, (mult,size), _Pre_cap_m_(mult,size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_m_(mult,size) _SAL1_1_Source_(_Out_opt_z_cap_m_, (mult,size), _Pre_opt_cap_m_(mult,size) _Post_valid_impl_ _Post_z_)
// buffer capacity is described by another pointer
// e.g. void Foo( _Out_ptrdiff_cap_(pchMax) char* pch, const char* pchMax ) { while pch < pchMax ) pch++; }
#define _Out_ptrdiff_cap_(size) _SAL1_1_Source_(_Out_ptrdiff_cap_, (size), _Pre_ptrdiff_cap_(size) _Post_valid_impl_)
#define _Out_opt_ptrdiff_cap_(size) _SAL1_1_Source_(_Out_opt_ptrdiff_cap_, (size), _Pre_opt_ptrdiff_cap_(size) _Post_valid_impl_)
// buffer capacity is described by a complex expression
#define _Out_cap_x_(size) _SAL1_1_Source_(_Out_cap_x_, (size), _Pre_cap_x_(size) _Post_valid_impl_)
#define _Out_opt_cap_x_(size) _SAL1_1_Source_(_Out_opt_cap_x_, (size), _Pre_opt_cap_x_(size) _Post_valid_impl_)
#define _Out_bytecap_x_(size) _SAL1_1_Source_(_Out_bytecap_x_, (size), _Pre_bytecap_x_(size) _Post_valid_impl_)
#define _Out_opt_bytecap_x_(size) _SAL1_1_Source_(_Out_opt_bytecap_x_, (size), _Pre_opt_bytecap_x_(size) _Post_valid_impl_)
// a zero terminated string is filled into a buffer of given capacity
// e.g. void CopyStr( _In_z_ const char* szFrom, _Out_z_cap_(cchTo) char* szTo, size_t cchTo );
// buffer capacity is described by another parameter
#define _Out_z_cap_(size) _SAL1_1_Source_(_Out_z_cap_, (size), _Pre_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_(size) _SAL1_1_Source_(_Out_opt_z_cap_, (size), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_z_bytecap_(size) _SAL1_1_Source_(_Out_z_bytecap_, (size), _Pre_bytecap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_bytecap_(size) _SAL1_1_Source_(_Out_opt_z_bytecap_, (size), _Pre_opt_bytecap_(size) _Post_valid_impl_ _Post_z_)
// buffer capacity is described by a constant expression
#define _Out_z_cap_c_(size) _SAL1_1_Source_(_Out_z_cap_c_, (size), _Pre_cap_c_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_c_(size) _SAL1_1_Source_(_Out_opt_z_cap_c_, (size), _Pre_opt_cap_c_(size) _Post_valid_impl_ _Post_z_)
#define _Out_z_bytecap_c_(size) _SAL1_1_Source_(_Out_z_bytecap_c_, (size), _Pre_bytecap_c_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Out_opt_z_bytecap_c_, (size), _Pre_opt_bytecap_c_(size) _Post_valid_impl_ _Post_z_)
// buffer capacity is described by a complex expression
#define _Out_z_cap_x_(size) _SAL1_1_Source_(_Out_z_cap_x_, (size), _Pre_cap_x_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_x_(size) _SAL1_1_Source_(_Out_opt_z_cap_x_, (size), _Pre_opt_cap_x_(size) _Post_valid_impl_ _Post_z_)
#define _Out_z_bytecap_x_(size) _SAL1_1_Source_(_Out_z_bytecap_x_, (size), _Pre_bytecap_x_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Out_opt_z_bytecap_x_, (size), _Pre_opt_bytecap_x_(size) _Post_valid_impl_ _Post_z_)
// a zero terminated string is filled into a buffer of given capacity
// e.g. size_t CopyCharRange( _In_count_(cchFrom) const char* rgchFrom, size_t cchFrom, _Out_cap_post_count_(cchTo,return)) char* rgchTo, size_t cchTo );
#define _Out_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_cap_post_count_, (cap,count), _Pre_cap_(cap) _Post_valid_impl_ _Post_count_(count))
#define _Out_opt_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_opt_cap_post_count_, (cap,count), _Pre_opt_cap_(cap) _Post_valid_impl_ _Post_count_(count))
#define _Out_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_bytecap_post_bytecount_, (cap,count), _Pre_bytecap_(cap) _Post_valid_impl_ _Post_bytecount_(count))
#define _Out_opt_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_opt_bytecap_post_bytecount_, (cap,count), _Pre_opt_bytecap_(cap) _Post_valid_impl_ _Post_bytecount_(count))
// a zero terminated string is filled into a buffer of given capacity
// e.g. size_t CopyStr( _In_z_ const char* szFrom, _Out_z_cap_post_count_(cchTo,return+1) char* szTo, size_t cchTo );
#define _Out_z_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_z_cap_post_count_, (cap,count), _Pre_cap_(cap) _Post_valid_impl_ _Post_z_count_(count))
#define _Out_opt_z_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_opt_z_cap_post_count_, (cap,count), _Pre_opt_cap_(cap) _Post_valid_impl_ _Post_z_count_(count))
#define _Out_z_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_z_bytecap_post_bytecount_, (cap,count), _Pre_bytecap_(cap) _Post_valid_impl_ _Post_z_bytecount_(count))
#define _Out_opt_z_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_opt_z_bytecap_post_bytecount_, (cap,count), _Pre_opt_bytecap_(cap) _Post_valid_impl_ _Post_z_bytecount_(count))
// only use with dereferenced arguments e.g. '*pcch'
#define _Out_capcount_(capcount) _SAL1_1_Source_(_Out_capcount_, (capcount), _Pre_cap_(capcount) _Post_valid_impl_ _Post_count_(capcount))
#define _Out_opt_capcount_(capcount) _SAL1_1_Source_(_Out_opt_capcount_, (capcount), _Pre_opt_cap_(capcount) _Post_valid_impl_ _Post_count_(capcount))
#define _Out_bytecapcount_(capcount) _SAL1_1_Source_(_Out_bytecapcount_, (capcount), _Pre_bytecap_(capcount) _Post_valid_impl_ _Post_bytecount_(capcount))
#define _Out_opt_bytecapcount_(capcount) _SAL1_1_Source_(_Out_opt_bytecapcount_, (capcount), _Pre_opt_bytecap_(capcount) _Post_valid_impl_ _Post_bytecount_(capcount))
#define _Out_capcount_x_(capcount) _SAL1_1_Source_(_Out_capcount_x_, (capcount), _Pre_cap_x_(capcount) _Post_valid_impl_ _Post_count_x_(capcount))
#define _Out_opt_capcount_x_(capcount) _SAL1_1_Source_(_Out_opt_capcount_x_, (capcount), _Pre_opt_cap_x_(capcount) _Post_valid_impl_ _Post_count_x_(capcount))
#define _Out_bytecapcount_x_(capcount) _SAL1_1_Source_(_Out_bytecapcount_x_, (capcount), _Pre_bytecap_x_(capcount) _Post_valid_impl_ _Post_bytecount_x_(capcount))
#define _Out_opt_bytecapcount_x_(capcount) _SAL1_1_Source_(_Out_opt_bytecapcount_x_, (capcount), _Pre_opt_bytecap_x_(capcount) _Post_valid_impl_ _Post_bytecount_x_(capcount))
// e.g. GetString( _Out_z_capcount_(*pLen+1) char* sz, size_t* pLen );
#define _Out_z_capcount_(capcount) _SAL1_1_Source_(_Out_z_capcount_, (capcount), _Pre_cap_(capcount) _Post_valid_impl_ _Post_z_count_(capcount))
#define _Out_opt_z_capcount_(capcount) _SAL1_1_Source_(_Out_opt_z_capcount_, (capcount), _Pre_opt_cap_(capcount) _Post_valid_impl_ _Post_z_count_(capcount))
#define _Out_z_bytecapcount_(capcount) _SAL1_1_Source_(_Out_z_bytecapcount_, (capcount), _Pre_bytecap_(capcount) _Post_valid_impl_ _Post_z_bytecount_(capcount))
#define _Out_opt_z_bytecapcount_(capcount) _SAL1_1_Source_(_Out_opt_z_bytecapcount_, (capcount), _Pre_opt_bytecap_(capcount) _Post_valid_impl_ _Post_z_bytecount_(capcount))
// 'inout' buffers with initialized elements before and after the call
// e.g. void ModifyIndices( _Inout_count_(cIndices) int* rgIndeces, size_t cIndices );
#define _Inout_count_(size) _SAL1_1_Source_(_Inout_count_, (size), _Prepost_count_(size))
#define _Inout_opt_count_(size) _SAL1_1_Source_(_Inout_opt_count_, (size), _Prepost_opt_count_(size))
#define _Inout_bytecount_(size) _SAL1_1_Source_(_Inout_bytecount_, (size), _Prepost_bytecount_(size))
#define _Inout_opt_bytecount_(size) _SAL1_1_Source_(_Inout_opt_bytecount_, (size), _Prepost_opt_bytecount_(size))
#define _Inout_count_c_(size) _SAL1_1_Source_(_Inout_count_c_, (size), _Prepost_count_c_(size))
#define _Inout_opt_count_c_(size) _SAL1_1_Source_(_Inout_opt_count_c_, (size), _Prepost_opt_count_c_(size))
#define _Inout_bytecount_c_(size) _SAL1_1_Source_(_Inout_bytecount_c_, (size), _Prepost_bytecount_c_(size))
#define _Inout_opt_bytecount_c_(size) _SAL1_1_Source_(_Inout_opt_bytecount_c_, (size), _Prepost_opt_bytecount_c_(size))
// nullterminated 'inout' buffers with initialized elements before and after the call
// e.g. void ModifyIndices( _Inout_count_(cIndices) int* rgIndeces, size_t cIndices );
#define _Inout_z_count_(size) _SAL1_1_Source_(_Inout_z_count_, (size), _Prepost_z_ _Prepost_count_(size))
#define _Inout_opt_z_count_(size) _SAL1_1_Source_(_Inout_opt_z_count_, (size), _Prepost_z_ _Prepost_opt_count_(size))
#define _Inout_z_bytecount_(size) _SAL1_1_Source_(_Inout_z_bytecount_, (size), _Prepost_z_ _Prepost_bytecount_(size))
#define _Inout_opt_z_bytecount_(size) _SAL1_1_Source_(_Inout_opt_z_bytecount_, (size), _Prepost_z_ _Prepost_opt_bytecount_(size))
#define _Inout_z_count_c_(size) _SAL1_1_Source_(_Inout_z_count_c_, (size), _Prepost_z_ _Prepost_count_c_(size))
#define _Inout_opt_z_count_c_(size) _SAL1_1_Source_(_Inout_opt_z_count_c_, (size), _Prepost_z_ _Prepost_opt_count_c_(size))
#define _Inout_z_bytecount_c_(size) _SAL1_1_Source_(_Inout_z_bytecount_c_, (size), _Prepost_z_ _Prepost_bytecount_c_(size))
#define _Inout_opt_z_bytecount_c_(size) _SAL1_1_Source_(_Inout_opt_z_bytecount_c_, (size), _Prepost_z_ _Prepost_opt_bytecount_c_(size))
#define _Inout_ptrdiff_count_(size) _SAL1_1_Source_(_Inout_ptrdiff_count_, (size), _Pre_ptrdiff_count_(size))
#define _Inout_opt_ptrdiff_count_(size) _SAL1_1_Source_(_Inout_opt_ptrdiff_count_, (size), _Pre_opt_ptrdiff_count_(size))
#define _Inout_count_x_(size) _SAL1_1_Source_(_Inout_count_x_, (size), _Prepost_count_x_(size))
#define _Inout_opt_count_x_(size) _SAL1_1_Source_(_Inout_opt_count_x_, (size), _Prepost_opt_count_x_(size))
#define _Inout_bytecount_x_(size) _SAL1_1_Source_(_Inout_bytecount_x_, (size), _Prepost_bytecount_x_(size))
#define _Inout_opt_bytecount_x_(size) _SAL1_1_Source_(_Inout_opt_bytecount_x_, (size), _Prepost_opt_bytecount_x_(size))
// e.g. void AppendToLPSTR( _In_ LPCSTR szFrom, _Inout_cap_(cchTo) LPSTR* szTo, size_t cchTo );
#define _Inout_cap_(size) _SAL1_1_Source_(_Inout_cap_, (size), _Pre_valid_cap_(size) _Post_valid_)
#define _Inout_opt_cap_(size) _SAL1_1_Source_(_Inout_opt_cap_, (size), _Pre_opt_valid_cap_(size) _Post_valid_)
#define _Inout_bytecap_(size) _SAL1_1_Source_(_Inout_bytecap_, (size), _Pre_valid_bytecap_(size) _Post_valid_)
#define _Inout_opt_bytecap_(size) _SAL1_1_Source_(_Inout_opt_bytecap_, (size), _Pre_opt_valid_bytecap_(size) _Post_valid_)
#define _Inout_cap_c_(size) _SAL1_1_Source_(_Inout_cap_c_, (size), _Pre_valid_cap_c_(size) _Post_valid_)
#define _Inout_opt_cap_c_(size) _SAL1_1_Source_(_Inout_opt_cap_c_, (size), _Pre_opt_valid_cap_c_(size) _Post_valid_)
#define _Inout_bytecap_c_(size) _SAL1_1_Source_(_Inout_bytecap_c_, (size), _Pre_valid_bytecap_c_(size) _Post_valid_)
#define _Inout_opt_bytecap_c_(size) _SAL1_1_Source_(_Inout_opt_bytecap_c_, (size), _Pre_opt_valid_bytecap_c_(size) _Post_valid_)
#define _Inout_cap_x_(size) _SAL1_1_Source_(_Inout_cap_x_, (size), _Pre_valid_cap_x_(size) _Post_valid_)
#define _Inout_opt_cap_x_(size) _SAL1_1_Source_(_Inout_opt_cap_x_, (size), _Pre_opt_valid_cap_x_(size) _Post_valid_)
#define _Inout_bytecap_x_(size) _SAL1_1_Source_(_Inout_bytecap_x_, (size), _Pre_valid_bytecap_x_(size) _Post_valid_)
#define _Inout_opt_bytecap_x_(size) _SAL1_1_Source_(_Inout_opt_bytecap_x_, (size), _Pre_opt_valid_bytecap_x_(size) _Post_valid_)
// inout string buffers with writable size
// e.g. void AppendStr( _In_z_ const char* szFrom, _Inout_z_cap_(cchTo) char* szTo, size_t cchTo );
#define _Inout_z_cap_(size) _SAL1_1_Source_(_Inout_z_cap_, (size), _Pre_z_cap_(size) _Post_z_)
#define _Inout_opt_z_cap_(size) _SAL1_1_Source_(_Inout_opt_z_cap_, (size), _Pre_opt_z_cap_(size) _Post_z_)
#define _Inout_z_bytecap_(size) _SAL1_1_Source_(_Inout_z_bytecap_, (size), _Pre_z_bytecap_(size) _Post_z_)
#define _Inout_opt_z_bytecap_(size) _SAL1_1_Source_(_Inout_opt_z_bytecap_, (size), _Pre_opt_z_bytecap_(size) _Post_z_)
#define _Inout_z_cap_c_(size) _SAL1_1_Source_(_Inout_z_cap_c_, (size), _Pre_z_cap_c_(size) _Post_z_)
#define _Inout_opt_z_cap_c_(size) _SAL1_1_Source_(_Inout_opt_z_cap_c_, (size), _Pre_opt_z_cap_c_(size) _Post_z_)
#define _Inout_z_bytecap_c_(size) _SAL1_1_Source_(_Inout_z_bytecap_c_, (size), _Pre_z_bytecap_c_(size) _Post_z_)
#define _Inout_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Inout_opt_z_bytecap_c_, (size), _Pre_opt_z_bytecap_c_(size) _Post_z_)
#define _Inout_z_cap_x_(size) _SAL1_1_Source_(_Inout_z_cap_x_, (size), _Pre_z_cap_x_(size) _Post_z_)
#define _Inout_opt_z_cap_x_(size) _SAL1_1_Source_(_Inout_opt_z_cap_x_, (size), _Pre_opt_z_cap_x_(size) _Post_z_)
#define _Inout_z_bytecap_x_(size) _SAL1_1_Source_(_Inout_z_bytecap_x_, (size), _Pre_z_bytecap_x_(size) _Post_z_)
#define _Inout_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Inout_opt_z_bytecap_x_, (size), _Pre_opt_z_bytecap_x_(size) _Post_z_)
// returning pointers to valid objects
#define _Ret_ _SAL1_1_Source_(_Ret_, (), _Ret_valid_)
#define _Ret_opt_ _SAL1_1_Source_(_Ret_opt_, (), _Ret_opt_valid_)
// annotations to express 'boundedness' of integral value parameter
#define _In_bound_ _SAL1_1_Source_(_In_bound_, (), _In_bound_impl_)
#define _Out_bound_ _SAL1_1_Source_(_Out_bound_, (), _Out_bound_impl_)
#define _Ret_bound_ _SAL1_1_Source_(_Ret_bound_, (), _Ret_bound_impl_)
#define _Deref_in_bound_ _SAL1_1_Source_(_Deref_in_bound_, (), _Deref_in_bound_impl_)
#define _Deref_out_bound_ _SAL1_1_Source_(_Deref_out_bound_, (), _Deref_out_bound_impl_)
#define _Deref_inout_bound_ _SAL1_1_Source_(_Deref_inout_bound_, (), _Deref_in_bound_ _Deref_out_bound_)
#define _Deref_ret_bound_ _SAL1_1_Source_(_Deref_ret_bound_, (), _Deref_ret_bound_impl_)
// e.g. HRESULT HrCreatePoint( _Deref_out_opt_ POINT** ppPT );
#define _Deref_out_ _SAL1_1_Source_(_Deref_out_, (), _Out_ _Deref_post_valid_)
#define _Deref_out_opt_ _SAL1_1_Source_(_Deref_out_opt_, (), _Out_ _Deref_post_opt_valid_)
#define _Deref_opt_out_ _SAL1_1_Source_(_Deref_opt_out_, (), _Out_opt_ _Deref_post_valid_)
#define _Deref_opt_out_opt_ _SAL1_1_Source_(_Deref_opt_out_opt_, (), _Out_opt_ _Deref_post_opt_valid_)
// e.g. void CloneString( _In_z_ const WCHAR* wzFrom, _Deref_out_z_ WCHAR** pWzTo );
#define _Deref_out_z_ _SAL1_1_Source_(_Deref_out_z_, (), _Out_ _Deref_post_z_)
#define _Deref_out_opt_z_ _SAL1_1_Source_(_Deref_out_opt_z_, (), _Out_ _Deref_post_opt_z_)
#define _Deref_opt_out_z_ _SAL1_1_Source_(_Deref_opt_out_z_, (), _Out_opt_ _Deref_post_z_)
#define _Deref_opt_out_opt_z_ _SAL1_1_Source_(_Deref_opt_out_opt_z_, (), _Out_opt_ _Deref_post_opt_z_)
//
// _Deref_pre_ ---
//
// describing conditions for array elements of dereferenced pointer parameters that must be met before the call
// e.g. void SaveStringArray( _In_count_(cStrings) _Deref_pre_z_ const WCHAR* const rgpwch[] );
#define _Deref_pre_z_ _SAL1_1_Source_(_Deref_pre_z_, (), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__zterm_impl) _Pre_valid_impl_)
#define _Deref_pre_opt_z_ _SAL1_1_Source_(_Deref_pre_opt_z_, (), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__zterm_impl) _Pre_valid_impl_)
// e.g. void FillInArrayOfStr32( _In_count_(cStrings) _Deref_pre_cap_c_(32) _Deref_post_z_ WCHAR* const rgpwch[] );
// buffer capacity is described by another parameter
#define _Deref_pre_cap_(size) _SAL1_1_Source_(_Deref_pre_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)))
#define _Deref_pre_opt_cap_(size) _SAL1_1_Source_(_Deref_pre_opt_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)))
#define _Deref_pre_bytecap_(size) _SAL1_1_Source_(_Deref_pre_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)))
#define _Deref_pre_opt_bytecap_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)))
// buffer capacity is described by a constant expression
#define _Deref_pre_cap_c_(size) _SAL1_1_Source_(_Deref_pre_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)))
#define _Deref_pre_opt_cap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)))
#define _Deref_pre_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)))
#define _Deref_pre_opt_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)))
// buffer capacity is described by a complex condition
#define _Deref_pre_cap_x_(size) _SAL1_1_Source_(_Deref_pre_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)))
#define _Deref_pre_opt_cap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)))
#define _Deref_pre_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)))
#define _Deref_pre_opt_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)))
// convenience macros for nullterminated buffers with given capacity
#define _Deref_pre_z_cap_(size) _SAL1_1_Source_(_Deref_pre_z_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_cap_(size) _SAL1_1_Source_(_Deref_pre_opt_z_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_bytecap_(size) _SAL1_1_Source_(_Deref_pre_z_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_bytecap_(size) _SAL1_1_Source_(_Deref_pre_opt_z_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_cap_c_(size) _SAL1_1_Source_(_Deref_pre_z_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_cap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_z_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_z_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_z_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_cap_x_(size) _SAL1_1_Source_(_Deref_pre_z_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_cap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_z_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_z_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_z_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
// known capacity and valid but unknown readable extent
#define _Deref_pre_valid_cap_(size) _SAL1_1_Source_(_Deref_pre_valid_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_cap_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_bytecap_(size) _SAL1_1_Source_(_Deref_pre_valid_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_bytecap_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_cap_c_(size) _SAL1_1_Source_(_Deref_pre_valid_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_cap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_valid_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_cap_x_(size) _SAL1_1_Source_(_Deref_pre_valid_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_cap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_valid_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
// e.g. void SaveMatrix( _In_count_(n) _Deref_pre_count_(n) const Elem** matrix, size_t n );
// valid buffer extent is described by another parameter
#define _Deref_pre_count_(size) _SAL1_1_Source_(_Deref_pre_count_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_count_(size) _SAL1_1_Source_(_Deref_pre_opt_count_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_bytecount_(size) _SAL1_1_Source_(_Deref_pre_bytecount_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_bytecount_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecount_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
// valid buffer extent is described by a constant expression
#define _Deref_pre_count_c_(size) _SAL1_1_Source_(_Deref_pre_count_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_count_c_(size) _SAL1_1_Source_(_Deref_pre_opt_count_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_bytecount_c_(size) _SAL1_1_Source_(_Deref_pre_bytecount_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_bytecount_c_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecount_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
// valid buffer extent is described by a complex expression
#define _Deref_pre_count_x_(size) _SAL1_1_Source_(_Deref_pre_count_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_count_x_(size) _SAL1_1_Source_(_Deref_pre_opt_count_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_bytecount_x_(size) _SAL1_1_Source_(_Deref_pre_bytecount_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_bytecount_x_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecount_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
// e.g. void PrintStringArray( _In_count_(cElems) _Deref_pre_valid_ LPCSTR rgStr[], size_t cElems );
#define _Deref_pre_valid_ _SAL1_1_Source_(_Deref_pre_valid_, (), _Deref_pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_ _SAL1_1_Source_(_Deref_pre_opt_valid_, (), _Deref_pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_)
#define _Deref_pre_invalid_ _SAL1_1_Source_(_Deref_pre_invalid_, (), _Deref_pre1_impl_(__notvalid_impl))
#define _Deref_pre_notnull_ _SAL1_1_Source_(_Deref_pre_notnull_, (), _Deref_pre1_impl_(__notnull_impl_notref))
#define _Deref_pre_maybenull_ _SAL1_1_Source_(_Deref_pre_maybenull_, (), _Deref_pre1_impl_(__maybenull_impl_notref))
#define _Deref_pre_null_ _SAL1_1_Source_(_Deref_pre_null_, (), _Deref_pre1_impl_(__null_impl_notref))
// restrict access rights
#define _Deref_pre_readonly_ _SAL1_1_Source_(_Deref_pre_readonly_, (), _Deref_pre1_impl_(__readaccess_impl_notref))
#define _Deref_pre_writeonly_ _SAL1_1_Source_(_Deref_pre_writeonly_, (), _Deref_pre1_impl_(__writeaccess_impl_notref))
//
// _Deref_post_ ---
//
// describing conditions for array elements or dereferenced pointer parameters that hold after the call
// e.g. void CloneString( _In_z_ const Wchar_t* wzIn _Out_ _Deref_post_z_ WCHAR** pWzOut );
#define _Deref_post_z_ _SAL1_1_Source_(_Deref_post_z_, (), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__zterm_impl) _Post_valid_impl_)
#define _Deref_post_opt_z_ _SAL1_1_Source_(_Deref_post_opt_z_, (), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__zterm_impl) _Post_valid_impl_)
// e.g. HRESULT HrAllocateMemory( size_t cb, _Out_ _Deref_post_bytecap_(cb) void** ppv );
// buffer capacity is described by another parameter
#define _Deref_post_cap_(size) _SAL1_1_Source_(_Deref_post_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_impl(size)))
#define _Deref_post_opt_cap_(size) _SAL1_1_Source_(_Deref_post_opt_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_impl(size)))
#define _Deref_post_bytecap_(size) _SAL1_1_Source_(_Deref_post_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)))
#define _Deref_post_opt_bytecap_(size) _SAL1_1_Source_(_Deref_post_opt_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)))
// buffer capacity is described by a constant expression
#define _Deref_post_cap_c_(size) _SAL1_1_Source_(_Deref_post_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)))
#define _Deref_post_opt_cap_c_(size) _SAL1_1_Source_(_Deref_post_opt_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)))
#define _Deref_post_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)))
#define _Deref_post_opt_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_opt_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)))
// buffer capacity is described by a complex expression
#define _Deref_post_cap_x_(size) _SAL1_1_Source_(_Deref_post_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)))
#define _Deref_post_opt_cap_x_(size) _SAL1_1_Source_(_Deref_post_opt_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)))
#define _Deref_post_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)))
#define _Deref_post_opt_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_opt_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)))
// convenience macros for nullterminated buffers with given capacity
#define _Deref_post_z_cap_(size) _SAL1_1_Source_(_Deref_post_z_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_cap_(size) _SAL1_1_Source_(_Deref_post_opt_z_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_bytecap_(size) _SAL1_1_Source_(_Deref_post_z_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_bytecap_(size) _SAL1_1_Source_(_Deref_post_opt_z_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_cap_c_(size) _SAL1_1_Source_(_Deref_post_z_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_cap_c_(size) _SAL1_1_Source_(_Deref_post_opt_z_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_z_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_opt_z_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_cap_x_(size) _SAL1_1_Source_(_Deref_post_z_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_cap_x_(size) _SAL1_1_Source_(_Deref_post_opt_z_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_z_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_opt_z_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Post_valid_impl_)
// known capacity and valid but unknown readable extent
#define _Deref_post_valid_cap_(size) _SAL1_1_Source_(_Deref_post_valid_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_cap_(size) _SAL1_1_Source_(_Deref_post_opt_valid_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_bytecap_(size) _SAL1_1_Source_(_Deref_post_valid_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_bytecap_(size) _SAL1_1_Source_(_Deref_post_opt_valid_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_cap_c_(size) _SAL1_1_Source_(_Deref_post_valid_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_cap_c_(size) _SAL1_1_Source_(_Deref_post_opt_valid_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_valid_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_opt_valid_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_cap_x_(size) _SAL1_1_Source_(_Deref_post_valid_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_cap_x_(size) _SAL1_1_Source_(_Deref_post_opt_valid_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_valid_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_opt_valid_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)) _Post_valid_impl_)
// e.g. HRESULT HrAllocateZeroInitializedMemory( size_t cb, _Out_ _Deref_post_bytecount_(cb) void** ppv );
// valid buffer extent is described by another parameter
#define _Deref_post_count_(size) _SAL1_1_Source_(_Deref_post_count_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_count_(size) _SAL1_1_Source_(_Deref_post_opt_count_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Deref_post_bytecount_(size) _SAL1_1_Source_(_Deref_post_bytecount_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_bytecount_(size) _SAL1_1_Source_(_Deref_post_opt_bytecount_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
// buffer capacity is described by a constant expression
#define _Deref_post_count_c_(size) _SAL1_1_Source_(_Deref_post_count_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_count_c_(size) _SAL1_1_Source_(_Deref_post_opt_count_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_bytecount_c_(size) _SAL1_1_Source_(_Deref_post_bytecount_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_bytecount_c_(size) _SAL1_1_Source_(_Deref_post_opt_bytecount_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)
// buffer capacity is described by a complex expression
#define _Deref_post_count_x_(size) _SAL1_1_Source_(_Deref_post_count_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_count_x_(size) _SAL1_1_Source_(_Deref_post_opt_count_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_bytecount_x_(size) _SAL1_1_Source_(_Deref_post_bytecount_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_bytecount_x_(size) _SAL1_1_Source_(_Deref_post_opt_bytecount_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)
// e.g. void GetStrings( _Out_count_(cElems) _Deref_post_valid_ LPSTR const rgStr[], size_t cElems );
#define _Deref_post_valid_ _SAL1_1_Source_(_Deref_post_valid_, (), _Deref_post1_impl_(__notnull_impl_notref) _Post_valid_impl_)
#define _Deref_post_opt_valid_ _SAL1_1_Source_(_Deref_post_opt_valid_, (), _Deref_post1_impl_(__maybenull_impl_notref) _Post_valid_impl_)
#define _Deref_post_notnull_ _SAL1_1_Source_(_Deref_post_notnull_, (), _Deref_post1_impl_(__notnull_impl_notref))
#define _Deref_post_maybenull_ _SAL1_1_Source_(_Deref_post_maybenull_, (), _Deref_post1_impl_(__maybenull_impl_notref))
#define _Deref_post_null_ _SAL1_1_Source_(_Deref_post_null_, (), _Deref_post1_impl_(__null_impl_notref))
//
// _Deref_ret_ ---
//
#define _Deref_ret_z_ _SAL1_1_Source_(_Deref_ret_z_, (), _Deref_ret1_impl_(__notnull_impl_notref) _Deref_ret1_impl_(__zterm_impl))
#define _Deref_ret_opt_z_ _SAL1_1_Source_(_Deref_ret_opt_z_, (), _Deref_ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__zterm_impl))
//
// special _Deref_ ---
//
#define _Deref2_pre_readonly_ _SAL1_1_Source_(_Deref2_pre_readonly_, (), _Deref2_pre1_impl_(__readaccess_impl_notref))
//
// _Ret_ ---
//
// e.g. _Ret_opt_valid_ LPSTR void* CloneSTR( _Pre_valid_ LPSTR src );
#define _Ret_opt_valid_ _SAL1_1_Source_(_Ret_opt_valid_, (), _Ret1_impl_(__maybenull_impl_notref) _Ret_valid_impl_)
#define _Ret_opt_z_ _SAL1_1_Source_(_Ret_opt_z_, (), _Ret2_impl_(__maybenull_impl,__zterm_impl) _Ret_valid_impl_)
// e.g. _Ret_opt_bytecap_(cb) void* AllocateMemory( size_t cb );
// Buffer capacity is described by another parameter
#define _Ret_cap_(size) _SAL1_1_Source_(_Ret_cap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_impl(size)))
#define _Ret_opt_cap_(size) _SAL1_1_Source_(_Ret_opt_cap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_impl(size)))
#define _Ret_bytecap_(size) _SAL1_1_Source_(_Ret_bytecap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_impl(size)))
#define _Ret_opt_bytecap_(size) _SAL1_1_Source_(_Ret_opt_bytecap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_impl(size)))
// Buffer capacity is described by a constant expression
#define _Ret_cap_c_(size) _SAL1_1_Source_(_Ret_cap_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_c_impl(size)))
#define _Ret_opt_cap_c_(size) _SAL1_1_Source_(_Ret_opt_cap_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_c_impl(size)))
#define _Ret_bytecap_c_(size) _SAL1_1_Source_(_Ret_bytecap_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_c_impl(size)))
#define _Ret_opt_bytecap_c_(size) _SAL1_1_Source_(_Ret_opt_bytecap_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_c_impl(size)))
// Buffer capacity is described by a complex condition
#define _Ret_cap_x_(size) _SAL1_1_Source_(_Ret_cap_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_x_impl(size)))
#define _Ret_opt_cap_x_(size) _SAL1_1_Source_(_Ret_opt_cap_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_x_impl(size)))
#define _Ret_bytecap_x_(size) _SAL1_1_Source_(_Ret_bytecap_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_x_impl(size)))
#define _Ret_opt_bytecap_x_(size) _SAL1_1_Source_(_Ret_opt_bytecap_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_x_impl(size)))
// return value is nullterminated and capacity is given by another parameter
#define _Ret_z_cap_(size) _SAL1_1_Source_(_Ret_z_cap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__cap_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_cap_(size) _SAL1_1_Source_(_Ret_opt_z_cap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__cap_impl(size)) _Ret_valid_impl_)
#define _Ret_z_bytecap_(size) _SAL1_1_Source_(_Ret_z_bytecap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecap_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_bytecap_(size) _SAL1_1_Source_(_Ret_opt_z_bytecap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecap_impl(size)) _Ret_valid_impl_)
// e.g. _Ret_opt_bytecount_(cb) void* AllocateZeroInitializedMemory( size_t cb );
// Valid Buffer extent is described by another parameter
#define _Ret_count_(size) _SAL1_1_Source_(_Ret_count_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_count_(size) _SAL1_1_Source_(_Ret_opt_count_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_impl(size)) _Ret_valid_impl_)
#define _Ret_bytecount_(size) _SAL1_1_Source_(_Ret_bytecount_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_bytecount_(size) _SAL1_1_Source_(_Ret_opt_bytecount_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_impl(size)) _Ret_valid_impl_)
// Valid Buffer extent is described by a constant expression
#define _Ret_count_c_(size) _SAL1_1_Source_(_Ret_count_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_c_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_count_c_(size) _SAL1_1_Source_(_Ret_opt_count_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_c_impl(size)) _Ret_valid_impl_)
#define _Ret_bytecount_c_(size) _SAL1_1_Source_(_Ret_bytecount_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_c_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_bytecount_c_(size) _SAL1_1_Source_(_Ret_opt_bytecount_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_c_impl(size)) _Ret_valid_impl_)
// Valid Buffer extent is described by a complex expression
#define _Ret_count_x_(size) _SAL1_1_Source_(_Ret_count_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_x_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_count_x_(size) _SAL1_1_Source_(_Ret_opt_count_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_x_impl(size)) _Ret_valid_impl_)
#define _Ret_bytecount_x_(size) _SAL1_1_Source_(_Ret_bytecount_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_x_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_bytecount_x_(size) _SAL1_1_Source_(_Ret_opt_bytecount_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_x_impl(size)) _Ret_valid_impl_)
// return value is nullterminated and length is given by another parameter
#define _Ret_z_count_(size) _SAL1_1_Source_(_Ret_z_count_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__count_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_count_(size) _SAL1_1_Source_(_Ret_opt_z_count_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__count_impl(size)) _Ret_valid_impl_)
#define _Ret_z_bytecount_(size) _SAL1_1_Source_(_Ret_z_bytecount_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecount_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_bytecount_(size) _SAL1_1_Source_(_Ret_opt_z_bytecount_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecount_impl(size)) _Ret_valid_impl_)
// _Pre_ annotations ---
#define _Pre_opt_z_ _SAL1_1_Source_(_Pre_opt_z_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__zterm_impl) _Pre_valid_impl_)
// restrict access rights
#define _Pre_readonly_ _SAL1_1_Source_(_Pre_readonly_, (), _Pre1_impl_(__readaccess_impl_notref))
#define _Pre_writeonly_ _SAL1_1_Source_(_Pre_writeonly_, (), _Pre1_impl_(__writeaccess_impl_notref))
// e.g. void FreeMemory( _Pre_bytecap_(cb) _Post_ptr_invalid_ void* pv, size_t cb );
// buffer capacity described by another parameter
#define _Pre_cap_(size) _SAL1_1_Source_(_Pre_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_impl(size)))
#define _Pre_opt_cap_(size) _SAL1_1_Source_(_Pre_opt_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_impl(size)))
#define _Pre_bytecap_(size) _SAL1_1_Source_(_Pre_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_impl(size)))
#define _Pre_opt_bytecap_(size) _SAL1_1_Source_(_Pre_opt_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_impl(size)))
// buffer capacity described by a constant expression
#define _Pre_cap_c_(size) _SAL1_1_Source_(_Pre_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_impl(size)))
#define _Pre_opt_cap_c_(size) _SAL1_1_Source_(_Pre_opt_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_impl(size)))
#define _Pre_bytecap_c_(size) _SAL1_1_Source_(_Pre_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)))
#define _Pre_opt_bytecap_c_(size) _SAL1_1_Source_(_Pre_opt_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)))
#define _Pre_cap_c_one_ _SAL1_1_Source_(_Pre_cap_c_one_, (), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl))
#define _Pre_opt_cap_c_one_ _SAL1_1_Source_(_Pre_opt_cap_c_one_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl))
// buffer capacity is described by another parameter multiplied by a constant expression
#define _Pre_cap_m_(mult,size) _SAL1_1_Source_(_Pre_cap_m_, (mult,size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__mult_impl(mult,size)))
#define _Pre_opt_cap_m_(mult,size) _SAL1_1_Source_(_Pre_opt_cap_m_, (mult,size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__mult_impl(mult,size)))
// buffer capacity described by size of other buffer, only used by dangerous legacy APIs
// e.g. int strcpy(_Pre_cap_for_(src) char* dst, const char* src);
#define _Pre_cap_for_(param) _SAL1_1_Source_(_Pre_cap_for_, (param), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_for_impl(param)))
#define _Pre_opt_cap_for_(param) _SAL1_1_Source_(_Pre_opt_cap_for_, (param), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_for_impl(param)))
// buffer capacity described by a complex condition
#define _Pre_cap_x_(size) _SAL1_1_Source_(_Pre_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(size)))
#define _Pre_opt_cap_x_(size) _SAL1_1_Source_(_Pre_opt_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(size)))
#define _Pre_bytecap_x_(size) _SAL1_1_Source_(_Pre_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)))
#define _Pre_opt_bytecap_x_(size) _SAL1_1_Source_(_Pre_opt_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)))
// buffer capacity described by the difference to another pointer parameter
#define _Pre_ptrdiff_cap_(ptr) _SAL1_1_Source_(_Pre_ptrdiff_cap_, (ptr), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(__ptrdiff(ptr))))
#define _Pre_opt_ptrdiff_cap_(ptr) _SAL1_1_Source_(_Pre_opt_ptrdiff_cap_, (ptr), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(__ptrdiff(ptr))))
// e.g. void AppendStr( _Pre_z_ const char* szFrom, _Pre_z_cap_(cchTo) _Post_z_ char* szTo, size_t cchTo );
#define _Pre_z_cap_(size) _SAL1_1_Source_(_Pre_z_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_cap_(size) _SAL1_1_Source_(_Pre_opt_z_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_z_bytecap_(size) _SAL1_1_Source_(_Pre_z_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_bytecap_(size) _SAL1_1_Source_(_Pre_opt_z_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_z_cap_c_(size) _SAL1_1_Source_(_Pre_z_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_cap_c_(size) _SAL1_1_Source_(_Pre_opt_z_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_z_bytecap_c_(size) _SAL1_1_Source_(_Pre_z_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Pre_opt_z_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_z_cap_x_(size) _SAL1_1_Source_(_Pre_z_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_cap_x_(size) _SAL1_1_Source_(_Pre_opt_z_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_z_bytecap_x_(size) _SAL1_1_Source_(_Pre_z_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Pre_opt_z_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
// known capacity and valid but unknown readable extent
#define _Pre_valid_cap_(size) _SAL1_1_Source_(_Pre_valid_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_cap_(size) _SAL1_1_Source_(_Pre_opt_valid_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_bytecap_(size) _SAL1_1_Source_(_Pre_valid_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_bytecap_(size) _SAL1_1_Source_(_Pre_opt_valid_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_cap_c_(size) _SAL1_1_Source_(_Pre_valid_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_cap_c_(size) _SAL1_1_Source_(_Pre_opt_valid_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_bytecap_c_(size) _SAL1_1_Source_(_Pre_valid_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_bytecap_c_(size) _SAL1_1_Source_(_Pre_opt_valid_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_cap_x_(size) _SAL1_1_Source_(_Pre_valid_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_cap_x_(size) _SAL1_1_Source_(_Pre_opt_valid_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_bytecap_x_(size) _SAL1_1_Source_(_Pre_valid_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Pre_opt_valid_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
// e.g. void AppendCharRange( _Pre_count_(cchFrom) const char* rgFrom, size_t cchFrom, _Out_z_cap_(cchTo) char* szTo, size_t cchTo );
// Valid buffer extent described by another parameter
#define _Pre_count_(size) _SAL1_1_Source_(_Pre_count_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_count_(size) _SAL1_1_Source_(_Pre_opt_count_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Pre_bytecount_(size) _SAL1_1_Source_(_Pre_bytecount_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_bytecount_(size) _SAL1_1_Source_(_Pre_opt_bytecount_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
// Valid buffer extent described by a constant expression
#define _Pre_count_c_(size) _SAL1_1_Source_(_Pre_count_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_count_c_(size) _SAL1_1_Source_(_Pre_opt_count_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Pre_bytecount_c_(size) _SAL1_1_Source_(_Pre_bytecount_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_bytecount_c_(size) _SAL1_1_Source_(_Pre_opt_bytecount_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
// Valid buffer extent described by a complex expression
#define _Pre_count_x_(size) _SAL1_1_Source_(_Pre_count_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_count_x_(size) _SAL1_1_Source_(_Pre_opt_count_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Pre_bytecount_x_(size) _SAL1_1_Source_(_Pre_bytecount_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_bytecount_x_(size) _SAL1_1_Source_(_Pre_opt_bytecount_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
// Valid buffer extent described by the difference to another pointer parameter
#define _Pre_ptrdiff_count_(ptr) _SAL1_1_Source_(_Pre_ptrdiff_count_, (ptr), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_x_impl(__ptrdiff(ptr))) _Pre_valid_impl_)
#define _Pre_opt_ptrdiff_count_(ptr) _SAL1_1_Source_(_Pre_opt_ptrdiff_count_, (ptr), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_x_impl(__ptrdiff(ptr))) _Pre_valid_impl_)
// char * strncpy(_Out_cap_(_Count) _Post_maybez_ char * _Dest, _In_z_ const char * _Source, _In_ size_t _Count)
// buffer maybe zero-terminated after the call
#define _Post_maybez_ _SAL1_1_Source_(_Post_maybez_, (), _Post1_impl_(__maybezterm_impl))
// e.g. SIZE_T HeapSize( _In_ HANDLE hHeap, DWORD dwFlags, _Pre_notnull_ _Post_bytecap_(return) LPCVOID lpMem );
#define _Post_cap_(size) _SAL1_1_Source_(_Post_cap_, (size), _Post1_impl_(__cap_impl(size)))
#define _Post_bytecap_(size) _SAL1_1_Source_(_Post_bytecap_, (size), _Post1_impl_(__bytecap_impl(size)))
// e.g. int strlen( _In_z_ _Post_count_(return+1) const char* sz );
#define _Post_count_(size) _SAL1_1_Source_(_Post_count_, (size), _Post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Post_bytecount_(size) _SAL1_1_Source_(_Post_bytecount_, (size), _Post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
#define _Post_count_c_(size) _SAL1_1_Source_(_Post_count_c_, (size), _Post1_impl_(__count_c_impl(size)) _Post_valid_impl_)
#define _Post_bytecount_c_(size) _SAL1_1_Source_(_Post_bytecount_c_, (size), _Post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)
#define _Post_count_x_(size) _SAL1_1_Source_(_Post_count_x_, (size), _Post1_impl_(__count_x_impl(size)) _Post_valid_impl_)
#define _Post_bytecount_x_(size) _SAL1_1_Source_(_Post_bytecount_x_, (size), _Post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)
// e.g. size_t CopyStr( _In_z_ const char* szFrom, _Pre_cap_(cch) _Post_z_count_(return+1) char* szFrom, size_t cchFrom );
#define _Post_z_count_(size) _SAL1_1_Source_(_Post_z_count_, (size), _Post2_impl_(__zterm_impl,__count_impl(size)) _Post_valid_impl_)
#define _Post_z_bytecount_(size) _SAL1_1_Source_(_Post_z_bytecount_, (size), _Post2_impl_(__zterm_impl,__bytecount_impl(size)) _Post_valid_impl_)
#define _Post_z_count_c_(size) _SAL1_1_Source_(_Post_z_count_c_, (size), _Post2_impl_(__zterm_impl,__count_c_impl(size)) _Post_valid_impl_)
#define _Post_z_bytecount_c_(size) _SAL1_1_Source_(_Post_z_bytecount_c_, (size), _Post2_impl_(__zterm_impl,__bytecount_c_impl(size)) _Post_valid_impl_)
#define _Post_z_count_x_(size) _SAL1_1_Source_(_Post_z_count_x_, (size), _Post2_impl_(__zterm_impl,__count_x_impl(size)) _Post_valid_impl_)
#define _Post_z_bytecount_x_(size) _SAL1_1_Source_(_Post_z_bytecount_x_, (size), _Post2_impl_(__zterm_impl,__bytecount_x_impl(size)) _Post_valid_impl_)
//
// _Prepost_ ---
//
// describing conditions that hold before and after the function call
#define _Prepost_opt_z_ _SAL1_1_Source_(_Prepost_opt_z_, (), _Pre_opt_z_ _Post_z_)
#define _Prepost_count_(size) _SAL1_1_Source_(_Prepost_count_, (size), _Pre_count_(size) _Post_count_(size))
#define _Prepost_opt_count_(size) _SAL1_1_Source_(_Prepost_opt_count_, (size), _Pre_opt_count_(size) _Post_count_(size))
#define _Prepost_bytecount_(size) _SAL1_1_Source_(_Prepost_bytecount_, (size), _Pre_bytecount_(size) _Post_bytecount_(size))
#define _Prepost_opt_bytecount_(size) _SAL1_1_Source_(_Prepost_opt_bytecount_, (size), _Pre_opt_bytecount_(size) _Post_bytecount_(size))
#define _Prepost_count_c_(size) _SAL1_1_Source_(_Prepost_count_c_, (size), _Pre_count_c_(size) _Post_count_c_(size))
#define _Prepost_opt_count_c_(size) _SAL1_1_Source_(_Prepost_opt_count_c_, (size), _Pre_opt_count_c_(size) _Post_count_c_(size))
#define _Prepost_bytecount_c_(size) _SAL1_1_Source_(_Prepost_bytecount_c_, (size), _Pre_bytecount_c_(size) _Post_bytecount_c_(size))
#define _Prepost_opt_bytecount_c_(size) _SAL1_1_Source_(_Prepost_opt_bytecount_c_, (size), _Pre_opt_bytecount_c_(size) _Post_bytecount_c_(size))
#define _Prepost_count_x_(size) _SAL1_1_Source_(_Prepost_count_x_, (size), _Pre_count_x_(size) _Post_count_x_(size))
#define _Prepost_opt_count_x_(size) _SAL1_1_Source_(_Prepost_opt_count_x_, (size), _Pre_opt_count_x_(size) _Post_count_x_(size))
#define _Prepost_bytecount_x_(size) _SAL1_1_Source_(_Prepost_bytecount_x_, (size), _Pre_bytecount_x_(size) _Post_bytecount_x_(size))
#define _Prepost_opt_bytecount_x_(size) _SAL1_1_Source_(_Prepost_opt_bytecount_x_, (size), _Pre_opt_bytecount_x_(size) _Post_bytecount_x_(size))
#define _Prepost_valid_ _SAL1_1_Source_(_Prepost_valid_, (), _Pre_valid_ _Post_valid_)
#define _Prepost_opt_valid_ _SAL1_1_Source_(_Prepost_opt_valid_, (), _Pre_opt_valid_ _Post_valid_)
//
// _Deref_<both> ---
//
// short version for _Deref_pre_<ann> _Deref_post_<ann>
// describing conditions for array elements or dereferenced pointer parameters that hold before and after the call
#define _Deref_prepost_z_ _SAL1_1_Source_(_Deref_prepost_z_, (), _Deref_pre_z_ _Deref_post_z_)
#define _Deref_prepost_opt_z_ _SAL1_1_Source_(_Deref_prepost_opt_z_, (), _Deref_pre_opt_z_ _Deref_post_opt_z_)
#define _Deref_prepost_cap_(size) _SAL1_1_Source_(_Deref_prepost_cap_, (size), _Deref_pre_cap_(size) _Deref_post_cap_(size))
#define _Deref_prepost_opt_cap_(size) _SAL1_1_Source_(_Deref_prepost_opt_cap_, (size), _Deref_pre_opt_cap_(size) _Deref_post_opt_cap_(size))
#define _Deref_prepost_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_bytecap_, (size), _Deref_pre_bytecap_(size) _Deref_post_bytecap_(size))
#define _Deref_prepost_opt_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecap_, (size), _Deref_pre_opt_bytecap_(size) _Deref_post_opt_bytecap_(size))
#define _Deref_prepost_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_cap_x_, (size), _Deref_pre_cap_x_(size) _Deref_post_cap_x_(size))
#define _Deref_prepost_opt_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_cap_x_, (size), _Deref_pre_opt_cap_x_(size) _Deref_post_opt_cap_x_(size))
#define _Deref_prepost_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_bytecap_x_, (size), _Deref_pre_bytecap_x_(size) _Deref_post_bytecap_x_(size))
#define _Deref_prepost_opt_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecap_x_, (size), _Deref_pre_opt_bytecap_x_(size) _Deref_post_opt_bytecap_x_(size))
#define _Deref_prepost_z_cap_(size) _SAL1_1_Source_(_Deref_prepost_z_cap_, (size), _Deref_pre_z_cap_(size) _Deref_post_z_cap_(size))
#define _Deref_prepost_opt_z_cap_(size) _SAL1_1_Source_(_Deref_prepost_opt_z_cap_, (size), _Deref_pre_opt_z_cap_(size) _Deref_post_opt_z_cap_(size))
#define _Deref_prepost_z_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_z_bytecap_, (size), _Deref_pre_z_bytecap_(size) _Deref_post_z_bytecap_(size))
#define _Deref_prepost_opt_z_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_opt_z_bytecap_, (size), _Deref_pre_opt_z_bytecap_(size) _Deref_post_opt_z_bytecap_(size))
#define _Deref_prepost_valid_cap_(size) _SAL1_1_Source_(_Deref_prepost_valid_cap_, (size), _Deref_pre_valid_cap_(size) _Deref_post_valid_cap_(size))
#define _Deref_prepost_opt_valid_cap_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_cap_, (size), _Deref_pre_opt_valid_cap_(size) _Deref_post_opt_valid_cap_(size))
#define _Deref_prepost_valid_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_valid_bytecap_, (size), _Deref_pre_valid_bytecap_(size) _Deref_post_valid_bytecap_(size))
#define _Deref_prepost_opt_valid_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_bytecap_, (size), _Deref_pre_opt_valid_bytecap_(size) _Deref_post_opt_valid_bytecap_(size))
#define _Deref_prepost_valid_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_valid_cap_x_, (size), _Deref_pre_valid_cap_x_(size) _Deref_post_valid_cap_x_(size))
#define _Deref_prepost_opt_valid_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_cap_x_, (size), _Deref_pre_opt_valid_cap_x_(size) _Deref_post_opt_valid_cap_x_(size))
#define _Deref_prepost_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_valid_bytecap_x_, (size), _Deref_pre_valid_bytecap_x_(size) _Deref_post_valid_bytecap_x_(size))
#define _Deref_prepost_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_bytecap_x_, (size), _Deref_pre_opt_valid_bytecap_x_(size) _Deref_post_opt_valid_bytecap_x_(size))
#define _Deref_prepost_count_(size) _SAL1_1_Source_(_Deref_prepost_count_, (size), _Deref_pre_count_(size) _Deref_post_count_(size))
#define _Deref_prepost_opt_count_(size) _SAL1_1_Source_(_Deref_prepost_opt_count_, (size), _Deref_pre_opt_count_(size) _Deref_post_opt_count_(size))
#define _Deref_prepost_bytecount_(size) _SAL1_1_Source_(_Deref_prepost_bytecount_, (size), _Deref_pre_bytecount_(size) _Deref_post_bytecount_(size))
#define _Deref_prepost_opt_bytecount_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecount_, (size), _Deref_pre_opt_bytecount_(size) _Deref_post_opt_bytecount_(size))
#define _Deref_prepost_count_x_(size) _SAL1_1_Source_(_Deref_prepost_count_x_, (size), _Deref_pre_count_x_(size) _Deref_post_count_x_(size))
#define _Deref_prepost_opt_count_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_count_x_, (size), _Deref_pre_opt_count_x_(size) _Deref_post_opt_count_x_(size))
#define _Deref_prepost_bytecount_x_(size) _SAL1_1_Source_(_Deref_prepost_bytecount_x_, (size), _Deref_pre_bytecount_x_(size) _Deref_post_bytecount_x_(size))
#define _Deref_prepost_opt_bytecount_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecount_x_, (size), _Deref_pre_opt_bytecount_x_(size) _Deref_post_opt_bytecount_x_(size))
#define _Deref_prepost_valid_ _SAL1_1_Source_(_Deref_prepost_valid_, (), _Deref_pre_valid_ _Deref_post_valid_)
#define _Deref_prepost_opt_valid_ _SAL1_1_Source_(_Deref_prepost_opt_valid_, (), _Deref_pre_opt_valid_ _Deref_post_opt_valid_)
//
// _Deref_<miscellaneous>
//
// used with references to arrays
#define _Deref_out_z_cap_c_(size) _SAL1_1_Source_(_Deref_out_z_cap_c_, (size), _Deref_pre_cap_c_(size) _Deref_post_z_)
#define _Deref_inout_z_cap_c_(size) _SAL1_1_Source_(_Deref_inout_z_cap_c_, (size), _Deref_pre_z_cap_c_(size) _Deref_post_z_)
#define _Deref_out_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_out_z_bytecap_c_, (size), _Deref_pre_bytecap_c_(size) _Deref_post_z_)
#define _Deref_inout_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_inout_z_bytecap_c_, (size), _Deref_pre_z_bytecap_c_(size) _Deref_post_z_)
#define _Deref_inout_z_ _SAL1_1_Source_(_Deref_inout_z_, (), _Deref_prepost_z_)
// #pragma endregion Input Buffer SAL 1 compatibility macros
//============================================================================
// Implementation Layer:
//============================================================================
// Naming conventions:
// A symbol the begins with _SA_ is for the machinery of creating any
// annotations; many of those come from sourceannotations.h in the case
// of attributes.
// A symbol that ends with _impl is the very lowest level macro. It is
// not required to be a legal standalone annotation, and in the case
// of attribute annotations, usually is not. (In the case of some declspec
// annotations, it might be, but it should not be assumed so.) Those
// symols will be used in the _PreN..., _PostN... and _RetN... annotations
// to build up more complete annotations.
// A symbol ending in _impl_ is reserved to the implementation as well,
// but it does form a complete annotation; usually they are used to build
// up even higher level annotations.
#if _USE_ATTRIBUTES_FOR_SAL || _USE_DECLSPECS_FOR_SAL // [
// Sharable "_impl" macros: these can be shared between the various annotation
// forms but are part of the implementation of the macros. These are collected
// here to assure that only necessary differences in the annotations
// exist.
#define _Always_impl_(annos) _Group_(annos _SAL_nop_impl_) _On_failure_impl_(annos _SAL_nop_impl_)
#define _Bound_impl_ _SA_annotes0(SAL_bound)
#define _Field_range_impl_(min,max) _Range_impl_(min,max)
#define _Literal_impl_ _SA_annotes1(SAL_constant, __yes)
#define _Maybenull_impl_ _SA_annotes1(SAL_null, __maybe)
#define _Maybevalid_impl_ _SA_annotes1(SAL_valid, __maybe)
#define _Must_inspect_impl_ _Post_impl_ _SA_annotes0(SAL_mustInspect)
#define _Notliteral_impl_ _SA_annotes1(SAL_constant, __no)
#define _Notnull_impl_ _SA_annotes1(SAL_null, __no)
#define _Notvalid_impl_ _SA_annotes1(SAL_valid, __no)
#define _NullNull_terminated_impl_ _Group_(_SA_annotes1(SAL_nullTerminated, __yes) _SA_annotes1(SAL_readableTo,inexpressibleCount("NullNull terminated string")))
#define _Null_impl_ _SA_annotes1(SAL_null, __yes)
#define _Null_terminated_impl_ _SA_annotes1(SAL_nullTerminated, __yes)
#define _Out_impl_ _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl) _Post_valid_impl_
#define _Out_opt_impl_ _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl) _Post_valid_impl_
#define _Points_to_data_impl_ _At_(*_Curr_, _SA_annotes1(SAL_mayBePointer, __no))
#define _Post_satisfies_impl_(cond) _Post_impl_ _Satisfies_impl_(cond)
#define _Post_valid_impl_ _Post1_impl_(__valid_impl)
#define _Pre_satisfies_impl_(cond) _Pre_impl_ _Satisfies_impl_(cond)
#define _Pre_valid_impl_ _Pre1_impl_(__valid_impl)
#define _Range_impl_(min,max) _SA_annotes2(SAL_range, min, max)
#define _Readable_bytes_impl_(size) _SA_annotes1(SAL_readableTo, byteCount(size))
#define _Readable_elements_impl_(size) _SA_annotes1(SAL_readableTo, elementCount(size))
#define _Ret_valid_impl_ _Ret1_impl_(__valid_impl)
#define _Satisfies_impl_(cond) _SA_annotes1(SAL_satisfies, cond)
#define _Valid_impl_ _SA_annotes1(SAL_valid, __yes)
#define _Writable_bytes_impl_(size) _SA_annotes1(SAL_writableTo, byteCount(size))
#define _Writable_elements_impl_(size) _SA_annotes1(SAL_writableTo, elementCount(size))
#define _In_range_impl_(min,max) _Pre_impl_ _Range_impl_(min,max)
#define _Out_range_impl_(min,max) _Post_impl_ _Range_impl_(min,max)
#define _Ret_range_impl_(min,max) _Post_impl_ _Range_impl_(min,max)
#define _Deref_in_range_impl_(min,max) _Deref_pre_impl_ _Range_impl_(min,max)
#define _Deref_out_range_impl_(min,max) _Deref_post_impl_ _Range_impl_(min,max)
#define _Deref_ret_range_impl_(min,max) _Deref_post_impl_ _Range_impl_(min,max)
#define _Deref_pre_impl_ _Pre_impl_ _Notref_impl_ _Deref_impl_
#define _Deref_post_impl_ _Post_impl_ _Notref_impl_ _Deref_impl_
// The following are for the implementation machinery, and are not
// suitable for annotating general code.
// We're tying to phase this out, someday. The parser quotes the param.
#define __AuToQuOtE _SA_annotes0(SAL_AuToQuOtE)
// Normally the parser does some simple type checking of annotation params,
// defer that check to the plugin.
#define __deferTypecheck _SA_annotes0(SAL_deferTypecheck)
#define _SA_SPECSTRIZE( x ) #x
#define _SAL_nop_impl_ /* nothing */
#define __nop_impl(x) x
#endif
#if _USE_ATTRIBUTES_FOR_SAL // [
// Using attributes for sal
#include "codeanalysis\sourceannotations.h"
#define _SA_annotes0(n) [SAL_annotes(Name=#n)]
#define _SA_annotes1(n,pp1) [SAL_annotes(Name=#n, p1=_SA_SPECSTRIZE(pp1))]
#define _SA_annotes2(n,pp1,pp2) [SAL_annotes(Name=#n, p1=_SA_SPECSTRIZE(pp1), p2=_SA_SPECSTRIZE(pp2))]
#define _SA_annotes3(n,pp1,pp2,pp3) [SAL_annotes(Name=#n, p1=_SA_SPECSTRIZE(pp1), p2=_SA_SPECSTRIZE(pp2), p3=_SA_SPECSTRIZE(pp3))]
#define _Pre_impl_ [SAL_pre]
#define _Post_impl_ [SAL_post]
#define _Deref_impl_ [SAL_deref]
#define _Notref_impl_ [SAL_notref]
// Declare a function to be an annotation or primop (respectively).
// Done this way so that they don't appear in the regular compiler's
// namespace.
#define __ANNOTATION(fun) _SA_annotes0(SAL_annotation) void __SA_##fun;
#define __PRIMOP(type, fun) _SA_annotes0(SAL_primop) type __SA_##fun;
#define __QUALIFIER(fun) _SA_annotes0(SAL_qualifier) void __SA_##fun;
// Benign declspec needed here for WindowsPREfast
#define __In_impl_ [SA_Pre(Valid=SA_Yes)] [SA_Pre(Deref=1, Notref=1, Access=SA_Read)] __declspec("SAL_pre SAL_valid")
#elif _USE_DECLSPECS_FOR_SAL // ][
// Using declspecs for sal
#define _SA_annotes0(n) __declspec(#n)
#define _SA_annotes1(n,pp1) __declspec(#n "(" _SA_SPECSTRIZE(pp1) ")" )
#define _SA_annotes2(n,pp1,pp2) __declspec(#n "(" _SA_SPECSTRIZE(pp1) "," _SA_SPECSTRIZE(pp2) ")")
#define _SA_annotes3(n,pp1,pp2,pp3) __declspec(#n "(" _SA_SPECSTRIZE(pp1) "," _SA_SPECSTRIZE(pp2) "," _SA_SPECSTRIZE(pp3) ")")
#define _Pre_impl_ _SA_annotes0(SAL_pre)
#define _Post_impl_ _SA_annotes0(SAL_post)
#define _Deref_impl_ _SA_annotes0(SAL_deref)
#define _Notref_impl_ _SA_annotes0(SAL_notref)
// Declare a function to be an annotation or primop (respectively).
// Done this way so that they don't appear in the regular compiler's
// namespace.
#define __ANNOTATION(fun) _SA_annotes0(SAL_annotation) void __SA_##fun
#define __PRIMOP(type, fun) _SA_annotes0(SAL_primop) type __SA_##fun
#define __QUALIFIER(fun) _SA_annotes0(SAL_qualifier) void __SA_##fun;
#define __In_impl_ _Pre_impl_ _SA_annotes0(SAL_valid) _Pre_impl_ _Deref_impl_ _Notref_impl_ _SA_annotes0(SAL_readonly)
#else // ][
// Using "nothing" for sal
#define _SA_annotes0(n)
#define _SA_annotes1(n,pp1)
#define _SA_annotes2(n,pp1,pp2)
#define _SA_annotes3(n,pp1,pp2,pp3)
#define __ANNOTATION(fun)
#define __PRIMOP(type, fun)
#define __QUALIFIER(type, fun)
#endif // ]
#if _USE_ATTRIBUTES_FOR_SAL || _USE_DECLSPECS_FOR_SAL // [
// Declare annotations that need to be declared.
__ANNOTATION(SAL_useHeader(void));
__ANNOTATION(SAL_bound(void));
__ANNOTATION(SAL_allocator(void)); //??? resolve with PFD
__ANNOTATION(SAL_file_parser(__AuToQuOtE __In_impl_ char *, __In_impl_ char *));
__ANNOTATION(SAL_source_code_content(__In_impl_ char *));
__ANNOTATION(SAL_analysisHint(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_untrusted_data_source(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_untrusted_data_source_this(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_validated(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_validated_this(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_encoded(void));
__ANNOTATION(SAL_adt(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_add_adt_property(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_remove_adt_property(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_transfer_adt_property_from(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_post_type(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_volatile(void));
__ANNOTATION(SAL_nonvolatile(void));
__ANNOTATION(SAL_entrypoint(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_blocksOn(__In_impl_ void*));
__ANNOTATION(SAL_mustInspect(void));
// Only appears in model files, but needs to be declared.
__ANNOTATION(SAL_TypeName(__AuToQuOtE __In_impl_ char *));
// To be declared well-known soon.
__ANNOTATION(SAL_interlocked(void);)
#pragma warning (suppress: 28227 28241)
__ANNOTATION(SAL_name(__In_impl_ char *, __In_impl_ char *, __In_impl_ char *);)
__PRIMOP(char *, _Macro_value_(__In_impl_ char *));
__PRIMOP(int, _Macro_defined_(__In_impl_ char *));
__PRIMOP(char *, _Strstr_(__In_impl_ char *, __In_impl_ char *));
#endif // ]
#if _USE_ATTRIBUTES_FOR_SAL // [
#define _Check_return_impl_ [SA_Post(MustCheck=SA_Yes)]
#define _Success_impl_(expr) [SA_Success(Condition=#expr)]
#define _On_failure_impl_(annos) [SAL_context(p1="SAL_failed")] _Group_(_Post_impl_ _Group_(annos _SAL_nop_impl_))
#define _Printf_format_string_impl_ [SA_FormatString(Style="printf")]
#define _Scanf_format_string_impl_ [SA_FormatString(Style="scanf")]
#define _Scanf_s_format_string_impl_ [SA_FormatString(Style="scanf_s")]
#define _In_bound_impl_ [SA_PreBound(Deref=0)]
#define _Out_bound_impl_ [SA_PostBound(Deref=0)]
#define _Ret_bound_impl_ [SA_PostBound(Deref=0)]
#define _Deref_in_bound_impl_ [SA_PreBound(Deref=1)]
#define _Deref_out_bound_impl_ [SA_PostBound(Deref=1)]
#define _Deref_ret_bound_impl_ [SA_PostBound(Deref=1)]
#define __valid_impl Valid=SA_Yes
#define __maybevalid_impl Valid=SA_Maybe
#define __notvalid_impl Valid=SA_No
#define __null_impl Null=SA_Yes
#define __maybenull_impl Null=SA_Maybe
#define __notnull_impl Null=SA_No
#define __null_impl_notref Null=SA_Yes,Notref=1
#define __maybenull_impl_notref Null=SA_Maybe,Notref=1
#define __notnull_impl_notref Null=SA_No,Notref=1
#define __zterm_impl NullTerminated=SA_Yes
#define __maybezterm_impl NullTerminated=SA_Maybe
#define __maybzterm_impl NullTerminated=SA_Maybe
#define __notzterm_impl NullTerminated=SA_No
#define __readaccess_impl Access=SA_Read
#define __writeaccess_impl Access=SA_Write
#define __allaccess_impl Access=SA_ReadWrite
#define __readaccess_impl_notref Access=SA_Read,Notref=1
#define __writeaccess_impl_notref Access=SA_Write,Notref=1
#define __allaccess_impl_notref Access=SA_ReadWrite,Notref=1
#if _MSC_VER >= 1610 /*IFSTRIP=IGN*/ // [
// For SAL2, we need to expect general expressions.
#define __cap_impl(size) WritableElements="\n"#size
#define __bytecap_impl(size) WritableBytes="\n"#size
#define __bytecount_impl(size) ValidBytes="\n"#size
#define __count_impl(size) ValidElements="\n"#size
#else // ][
#define __cap_impl(size) WritableElements=#size
#define __bytecap_impl(size) WritableBytes=#size
#define __bytecount_impl(size) ValidBytes=#size
#define __count_impl(size) ValidElements=#size
#endif // ]
#define __cap_c_impl(size) WritableElementsConst=size
#define __cap_c_one_notref_impl WritableElementsConst=1,Notref=1
#define __cap_for_impl(param) WritableElementsLength=#param
#define __cap_x_impl(size) WritableElements="\n@"#size
#define __bytecap_c_impl(size) WritableBytesConst=size
#define __bytecap_x_impl(size) WritableBytes="\n@"#size
#define __mult_impl(mult,size) __cap_impl((mult)*(size))
#define __count_c_impl(size) ValidElementsConst=size
#define __count_x_impl(size) ValidElements="\n@"#size
#define __bytecount_c_impl(size) ValidBytesConst=size
#define __bytecount_x_impl(size) ValidBytes="\n@"#size
#define _At_impl_(target, annos) [SAL_at(p1=#target)] _Group_(annos)
#define _At_buffer_impl_(target, iter, bound, annos) [SAL_at_buffer(p1=#target, p2=#iter, p3=#bound)] _Group_(annos)
#define _When_impl_(expr, annos) [SAL_when(p1=#expr)] _Group_(annos)
#define _Group_impl_(annos) [SAL_begin] annos [SAL_end]
#define _GrouP_impl_(annos) [SAL_BEGIN] annos [SAL_END]
#define _Use_decl_anno_impl_ _SA_annotes0(SAL_useHeader) // this is a special case!
#define _Pre1_impl_(p1) [SA_Pre(p1)]
#define _Pre2_impl_(p1,p2) [SA_Pre(p1,p2)]
#define _Pre3_impl_(p1,p2,p3) [SA_Pre(p1,p2,p3)]
#define _Post1_impl_(p1) [SA_Post(p1)]
#define _Post2_impl_(p1,p2) [SA_Post(p1,p2)]
#define _Post3_impl_(p1,p2,p3) [SA_Post(p1,p2,p3)]
#define _Ret1_impl_(p1) [SA_Post(p1)]
#define _Ret2_impl_(p1,p2) [SA_Post(p1,p2)]
#define _Ret3_impl_(p1,p2,p3) [SA_Post(p1,p2,p3)]
#define _Deref_pre1_impl_(p1) [SA_Pre(Deref=1,p1)]
#define _Deref_pre2_impl_(p1,p2) [SA_Pre(Deref=1,p1,p2)]
#define _Deref_pre3_impl_(p1,p2,p3) [SA_Pre(Deref=1,p1,p2,p3)]
#define _Deref_post1_impl_(p1) [SA_Post(Deref=1,p1)]
#define _Deref_post2_impl_(p1,p2) [SA_Post(Deref=1,p1,p2)]
#define _Deref_post3_impl_(p1,p2,p3) [SA_Post(Deref=1,p1,p2,p3)]
#define _Deref_ret1_impl_(p1) [SA_Post(Deref=1,p1)]
#define _Deref_ret2_impl_(p1,p2) [SA_Post(Deref=1,p1,p2)]
#define _Deref_ret3_impl_(p1,p2,p3) [SA_Post(Deref=1,p1,p2,p3)]
#define _Deref2_pre1_impl_(p1) [SA_Pre(Deref=2,Notref=1,p1)]
#define _Deref2_post1_impl_(p1) [SA_Post(Deref=2,Notref=1,p1)]
#define _Deref2_ret1_impl_(p1) [SA_Post(Deref=2,Notref=1,p1)]
// Obsolete -- may be needed for transition to attributes.
#define __inner_typefix(ctype) [SAL_typefix(p1=_SA_SPECSTRIZE(ctype))]
#define __inner_exceptthat [SAL_except]
#elif _USE_DECLSPECS_FOR_SAL // ][
#define _Check_return_impl_ __post _SA_annotes0(SAL_checkReturn)
#define _Success_impl_(expr) _SA_annotes1(SAL_success, expr)
#define _On_failure_impl_(annos) _SA_annotes1(SAL_context, SAL_failed) _Group_(_Post_impl_ _Group_(_SAL_nop_impl_ annos))
#define _Printf_format_string_impl_ _SA_annotes1(SAL_IsFormatString, "printf")
#define _Scanf_format_string_impl_ _SA_annotes1(SAL_IsFormatString, "scanf")
#define _Scanf_s_format_string_impl_ _SA_annotes1(SAL_IsFormatString, "scanf_s")
#define _In_bound_impl_ _Pre_impl_ _Bound_impl_
#define _Out_bound_impl_ _Post_impl_ _Bound_impl_
#define _Ret_bound_impl_ _Post_impl_ _Bound_impl_
#define _Deref_in_bound_impl_ _Deref_pre_impl_ _Bound_impl_
#define _Deref_out_bound_impl_ _Deref_post_impl_ _Bound_impl_
#define _Deref_ret_bound_impl_ _Deref_post_impl_ _Bound_impl_
#define __null_impl _SA_annotes0(SAL_null) // _SA_annotes1(SAL_null, __yes)
#define __notnull_impl _SA_annotes0(SAL_notnull) // _SA_annotes1(SAL_null, __no)
#define __maybenull_impl _SA_annotes0(SAL_maybenull) // _SA_annotes1(SAL_null, __maybe)
#define __valid_impl _SA_annotes0(SAL_valid) // _SA_annotes1(SAL_valid, __yes)
#define __notvalid_impl _SA_annotes0(SAL_notvalid) // _SA_annotes1(SAL_valid, __no)
#define __maybevalid_impl _SA_annotes0(SAL_maybevalid) // _SA_annotes1(SAL_valid, __maybe)
#define __null_impl_notref _Notref_ _Null_impl_
#define __maybenull_impl_notref _Notref_ _Maybenull_impl_
#define __notnull_impl_notref _Notref_ _Notnull_impl_
#define __zterm_impl _SA_annotes1(SAL_nullTerminated, __yes)
#define __maybezterm_impl _SA_annotes1(SAL_nullTerminated, __maybe)
#define __maybzterm_impl _SA_annotes1(SAL_nullTerminated, __maybe)
#define __notzterm_impl _SA_annotes1(SAL_nullTerminated, __no)
#define __readaccess_impl _SA_annotes1(SAL_access, 0x1)
#define __writeaccess_impl _SA_annotes1(SAL_access, 0x2)
#define __allaccess_impl _SA_annotes1(SAL_access, 0x3)
#define __readaccess_impl_notref _Notref_ _SA_annotes1(SAL_access, 0x1)
#define __writeaccess_impl_notref _Notref_ _SA_annotes1(SAL_access, 0x2)
#define __allaccess_impl_notref _Notref_ _SA_annotes1(SAL_access, 0x3)
#define __cap_impl(size) _SA_annotes1(SAL_writableTo,elementCount(size))
#define __cap_c_impl(size) _SA_annotes1(SAL_writableTo,elementCount(size))
#define __cap_c_one_notref_impl _Notref_ _SA_annotes1(SAL_writableTo,elementCount(1))
#define __cap_for_impl(param) _SA_annotes1(SAL_writableTo,inexpressibleCount(sizeof(param)))
#define __cap_x_impl(size) _SA_annotes1(SAL_writableTo,inexpressibleCount(#size))
#define __bytecap_impl(size) _SA_annotes1(SAL_writableTo,byteCount(size))
#define __bytecap_c_impl(size) _SA_annotes1(SAL_writableTo,byteCount(size))
#define __bytecap_x_impl(size) _SA_annotes1(SAL_writableTo,inexpressibleCount(#size))
#define __mult_impl(mult,size) _SA_annotes1(SAL_writableTo,(mult)*(size))
#define __count_impl(size) _SA_annotes1(SAL_readableTo,elementCount(size))
#define __count_c_impl(size) _SA_annotes1(SAL_readableTo,elementCount(size))
#define __count_x_impl(size) _SA_annotes1(SAL_readableTo,inexpressibleCount(#size))
#define __bytecount_impl(size) _SA_annotes1(SAL_readableTo,byteCount(size))
#define __bytecount_c_impl(size) _SA_annotes1(SAL_readableTo,byteCount(size))
#define __bytecount_x_impl(size) _SA_annotes1(SAL_readableTo,inexpressibleCount(#size))
#define _At_impl_(target, annos) _SA_annotes0(SAL_at(target)) _Group_(annos)
#define _At_buffer_impl_(target, iter, bound, annos) _SA_annotes3(SAL_at_buffer, target, iter, bound) _Group_(annos)
#define _Group_impl_(annos) _SA_annotes0(SAL_begin) annos _SA_annotes0(SAL_end)
#define _GrouP_impl_(annos) _SA_annotes0(SAL_BEGIN) annos _SA_annotes0(SAL_END)
#define _When_impl_(expr, annos) _SA_annotes0(SAL_when(expr)) _Group_(annos)
#define _Use_decl_anno_impl_ __declspec("SAL_useHeader()") // this is a special case!
#define _Pre1_impl_(p1) _Pre_impl_ p1
#define _Pre2_impl_(p1,p2) _Pre_impl_ p1 _Pre_impl_ p2
#define _Pre3_impl_(p1,p2,p3) _Pre_impl_ p1 _Pre_impl_ p2 _Pre_impl_ p3
#define _Post1_impl_(p1) _Post_impl_ p1
#define _Post2_impl_(p1,p2) _Post_impl_ p1 _Post_impl_ p2
#define _Post3_impl_(p1,p2,p3) _Post_impl_ p1 _Post_impl_ p2 _Post_impl_ p3
#define _Ret1_impl_(p1) _Post_impl_ p1
#define _Ret2_impl_(p1,p2) _Post_impl_ p1 _Post_impl_ p2
#define _Ret3_impl_(p1,p2,p3) _Post_impl_ p1 _Post_impl_ p2 _Post_impl_ p3
#define _Deref_pre1_impl_(p1) _Deref_pre_impl_ p1
#define _Deref_pre2_impl_(p1,p2) _Deref_pre_impl_ p1 _Deref_pre_impl_ p2
#define _Deref_pre3_impl_(p1,p2,p3) _Deref_pre_impl_ p1 _Deref_pre_impl_ p2 _Deref_pre_impl_ p3
#define _Deref_post1_impl_(p1) _Deref_post_impl_ p1
#define _Deref_post2_impl_(p1,p2) _Deref_post_impl_ p1 _Deref_post_impl_ p2
#define _Deref_post3_impl_(p1,p2,p3) _Deref_post_impl_ p1 _Deref_post_impl_ p2 _Deref_post_impl_ p3
#define _Deref_ret1_impl_(p1) _Deref_post_impl_ p1
#define _Deref_ret2_impl_(p1,p2) _Deref_post_impl_ p1 _Deref_post_impl_ p2
#define _Deref_ret3_impl_(p1,p2,p3) _Deref_post_impl_ p1 _Deref_post_impl_ p2 _Deref_post_impl_ p3
#define _Deref2_pre1_impl_(p1) _Deref_pre_impl_ _Notref_impl_ _Deref_impl_ p1
#define _Deref2_post1_impl_(p1) _Deref_post_impl_ _Notref_impl_ _Deref_impl_ p1
#define _Deref2_ret1_impl_(p1) _Deref_post_impl_ _Notref_impl_ _Deref_impl_ p1
#define __inner_typefix(ctype) _SA_annotes1(SAL_typefix, ctype)
#define __inner_exceptthat _SA_annotes0(SAL_except)
#elif defined(_MSC_EXTENSIONS) && !defined( MIDL_PASS ) && !defined(__midl) && !defined(RC_INVOKED) && defined(_PFT_VER) && _MSC_VER >= 1400 /*IFSTRIP=IGN*/ // ][
// minimum attribute expansion for foreground build
#pragma push_macro( "SA" )
#pragma push_macro( "REPEATABLE" )
#ifdef __cplusplus // [
#define SA( id ) id
#define REPEATABLE [repeatable]
#else // !__cplusplus // ][
#define SA( id ) SA_##id
#define REPEATABLE
#endif // !__cplusplus // ]
REPEATABLE
[source_annotation_attribute( SA( Parameter ) )]
struct __P_impl
{
#ifdef __cplusplus // [
__P_impl();
#endif // ]
int __d_;
};
typedef struct __P_impl __P_impl;
REPEATABLE
[source_annotation_attribute( SA( ReturnValue ) )]
struct __R_impl
{
#ifdef __cplusplus // [
__R_impl();
#endif // ]
int __d_;
};
typedef struct __R_impl __R_impl;
[source_annotation_attribute( SA( Method ) )]
struct __M_
{
#ifdef __cplusplus // [
__M_();
#endif // ]
int __d_;
};
typedef struct __M_ __M_;
[source_annotation_attribute( SA( All ) )]
struct __A_
{
#ifdef __cplusplus // [
__A_();
#endif // ]
int __d_;
};
typedef struct __A_ __A_;
[source_annotation_attribute( SA( Field ) )]
struct __F_
{
#ifdef __cplusplus // [
__F_();
#endif // ]
int __d_;
};
typedef struct __F_ __F_;
#pragma pop_macro( "REPEATABLE" )
#pragma pop_macro( "SA" )
#define _SAL_nop_impl_
#define _At_impl_(target, annos) [__A_(__d_=0)]
#define _At_buffer_impl_(target, iter, bound, annos) [__A_(__d_=0)]
#define _When_impl_(expr, annos) annos
#define _Group_impl_(annos) annos
#define _GrouP_impl_(annos) annos
#define _Use_decl_anno_impl_ [__M_(__d_=0)]
#define _Points_to_data_impl_ [__P_impl(__d_=0)]
#define _Literal_impl_ [__P_impl(__d_=0)]
#define _Notliteral_impl_ [__P_impl(__d_=0)]
#define _Pre_valid_impl_ [__P_impl(__d_=0)]
#define _Post_valid_impl_ [__P_impl(__d_=0)]
#define _Ret_valid_impl_ [__R_impl(__d_=0)]
#define _Check_return_impl_ [__R_impl(__d_=0)]
#define _Must_inspect_impl_ [__R_impl(__d_=0)]
#define _Success_impl_(expr) [__M_(__d_=0)]
#define _On_failure_impl_(expr) [__M_(__d_=0)]
#define _Always_impl_(expr) [__M_(__d_=0)]
#define _Printf_format_string_impl_ [__P_impl(__d_=0)]
#define _Scanf_format_string_impl_ [__P_impl(__d_=0)]
#define _Scanf_s_format_string_impl_ [__P_impl(__d_=0)]
#define _Raises_SEH_exception_impl_ [__M_(__d_=0)]
#define _Maybe_raises_SEH_exception_impl_ [__M_(__d_=0)]
#define _In_bound_impl_ [__P_impl(__d_=0)]
#define _Out_bound_impl_ [__P_impl(__d_=0)]
#define _Ret_bound_impl_ [__R_impl(__d_=0)]
#define _Deref_in_bound_impl_ [__P_impl(__d_=0)]
#define _Deref_out_bound_impl_ [__P_impl(__d_=0)]
#define _Deref_ret_bound_impl_ [__R_impl(__d_=0)]
#define _Range_impl_(min,max) [__P_impl(__d_=0)]
#define _In_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Out_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Ret_range_impl_(min,max) [__R_impl(__d_=0)]
#define _Deref_in_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Deref_out_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Deref_ret_range_impl_(min,max) [__R_impl(__d_=0)]
#define _Field_range_impl_(min,max) [__F_(__d_=0)]
#define _Pre_satisfies_impl_(cond) [__A_(__d_=0)]
#define _Post_satisfies_impl_(cond) [__A_(__d_=0)]
#define _Satisfies_impl_(cond) [__A_(__d_=0)]
#define _Null_impl_ [__A_(__d_=0)]
#define _Notnull_impl_ [__A_(__d_=0)]
#define _Maybenull_impl_ [__A_(__d_=0)]
#define _Valid_impl_ [__A_(__d_=0)]
#define _Notvalid_impl_ [__A_(__d_=0)]
#define _Maybevalid_impl_ [__A_(__d_=0)]
#define _Readable_bytes_impl_(size) [__A_(__d_=0)]
#define _Readable_elements_impl_(size) [__A_(__d_=0)]
#define _Writable_bytes_impl_(size) [__A_(__d_=0)]
#define _Writable_elements_impl_(size) [__A_(__d_=0)]
#define _Null_terminated_impl_ [__A_(__d_=0)]
#define _NullNull_terminated_impl_ [__A_(__d_=0)]
#define _Pre_impl_ [__P_impl(__d_=0)]
#define _Pre1_impl_(p1) [__P_impl(__d_=0)]
#define _Pre2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Pre3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Post_impl_ [__P_impl(__d_=0)]
#define _Post1_impl_(p1) [__P_impl(__d_=0)]
#define _Post2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Post3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Ret1_impl_(p1) [__R_impl(__d_=0)]
#define _Ret2_impl_(p1,p2) [__R_impl(__d_=0)]
#define _Ret3_impl_(p1,p2,p3) [__R_impl(__d_=0)]
#define _Deref_pre1_impl_(p1) [__P_impl(__d_=0)]
#define _Deref_pre2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Deref_pre3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Deref_post1_impl_(p1) [__P_impl(__d_=0)]
#define _Deref_post2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Deref_post3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Deref_ret1_impl_(p1) [__R_impl(__d_=0)]
#define _Deref_ret2_impl_(p1,p2) [__R_impl(__d_=0)]
#define _Deref_ret3_impl_(p1,p2,p3) [__R_impl(__d_=0)]
#define _Deref2_pre1_impl_(p1) //[__P_impl(__d_=0)]
#define _Deref2_post1_impl_(p1) //[__P_impl(__d_=0)]
#define _Deref2_ret1_impl_(p1) //[__P_impl(__d_=0)]
#else // ][
#define _SAL_nop_impl_ X
#define _At_impl_(target, annos)
#define _When_impl_(expr, annos)
#define _Group_impl_(annos)
#define _GrouP_impl_(annos)
#define _At_buffer_impl_(target, iter, bound, annos)
#define _Use_decl_anno_impl_
#define _Points_to_data_impl_
#define _Literal_impl_
#define _Notliteral_impl_
#define _Notref_impl_
#define _Pre_valid_impl_
#define _Post_valid_impl_
#define _Ret_valid_impl_
#define _Check_return_impl_
#define _Must_inspect_impl_
#define _Success_impl_(expr)
#define _On_failure_impl_(annos)
#define _Always_impl_(annos)
#define _Printf_format_string_impl_
#define _Scanf_format_string_impl_
#define _Scanf_s_format_string_impl_
#define _In_bound_impl_
#define _Out_bound_impl_
#define _Ret_bound_impl_
#define _Deref_in_bound_impl_
#define _Deref_out_bound_impl_
#define _Deref_ret_bound_impl_
#define _Range_impl_(min,max)
#define _In_range_impl_(min,max)
#define _Out_range_impl_(min,max)
#define _Ret_range_impl_(min,max)
#define _Deref_in_range_impl_(min,max)
#define _Deref_out_range_impl_(min,max)
#define _Deref_ret_range_impl_(min,max)
#define _Satisfies_impl_(expr)
#define _Pre_satisfies_impl_(expr)
#define _Post_satisfies_impl_(expr)
#define _Null_impl_
#define _Notnull_impl_
#define _Maybenull_impl_
#define _Valid_impl_
#define _Notvalid_impl_
#define _Maybevalid_impl_
#define _Field_range_impl_(min,max)
#define _Pre_impl_
#define _Pre1_impl_(p1)
#define _Pre2_impl_(p1,p2)
#define _Pre3_impl_(p1,p2,p3)
#define _Post_impl_
#define _Post1_impl_(p1)
#define _Post2_impl_(p1,p2)
#define _Post3_impl_(p1,p2,p3)
#define _Ret1_impl_(p1)
#define _Ret2_impl_(p1,p2)
#define _Ret3_impl_(p1,p2,p3)
#define _Deref_pre1_impl_(p1)
#define _Deref_pre2_impl_(p1,p2)
#define _Deref_pre3_impl_(p1,p2,p3)
#define _Deref_post1_impl_(p1)
#define _Deref_post2_impl_(p1,p2)
#define _Deref_post3_impl_(p1,p2,p3)
#define _Deref_ret1_impl_(p1)
#define _Deref_ret2_impl_(p1,p2)
#define _Deref_ret3_impl_(p1,p2,p3)
#define _Deref2_pre1_impl_(p1)
#define _Deref2_post1_impl_(p1)
#define _Deref2_ret1_impl_(p1)
#define _Readable_bytes_impl_(size)
#define _Readable_elements_impl_(size)
#define _Writable_bytes_impl_(size)
#define _Writable_elements_impl_(size)
#define _Null_terminated_impl_
#define _NullNull_terminated_impl_
// Obsolete -- may be needed for transition to attributes.
#define __inner_typefix(ctype)
#define __inner_exceptthat
#endif // ]
// This section contains the deprecated annotations
/*
-------------------------------------------------------------------------------
Introduction
sal.h provides a set of annotations to describe how a function uses its
parameters - the assumptions it makes about them, and the guarantees it makes
upon finishing.
Annotations may be placed before either a function parameter's type or its return
type, and describe the function's behavior regarding the parameter or return value.
There are two classes of annotations: buffer annotations and advanced annotations.
Buffer annotations describe how functions use their pointer parameters, and
advanced annotations either describe complex/unusual buffer behavior, or provide
additional information about a parameter that is not otherwise expressible.
-------------------------------------------------------------------------------
Buffer Annotations
The most important annotations in sal.h provide a consistent way to annotate
buffer parameters or return values for a function. Each of these annotations describes
a single buffer (which could be a string, a fixed-length or variable-length array,
or just a pointer) that the function interacts with: where it is, how large it is,
how much is initialized, and what the function does with it.
The appropriate macro for a given buffer can be constructed using the table below.
Just pick the appropriate values from each category, and combine them together
with a leading underscore. Some combinations of values do not make sense as buffer
annotations. Only meaningful annotations can be added to your code; for a list of
these, see the buffer annotation definitions section.
Only a single buffer annotation should be used for each parameter.
|------------|------------|---------|--------|----------|----------|---------------|
| Level | Usage | Size | Output | NullTerm | Optional | Parameters |
|------------|------------|---------|--------|----------|----------|---------------|
| <> | <> | <> | <> | _z | <> | <> |
| _deref | _in | _ecount | _full | _nz | _opt | (size) |
| _deref_opt | _out | _bcount | _part | | | (size,length) |
| | _inout | | | | | |
| | | | | | | |
|------------|------------|---------|--------|----------|----------|---------------|
Level: Describes the buffer pointer's level of indirection from the parameter or
return value 'p'.
<> : p is the buffer pointer.
_deref : *p is the buffer pointer. p must not be NULL.
_deref_opt : *p may be the buffer pointer. p may be NULL, in which case the rest of
the annotation is ignored.
Usage: Describes how the function uses the buffer.
<> : The buffer is not accessed. If used on the return value or with _deref, the
function will provide the buffer, and it will be uninitialized at exit.
Otherwise, the caller must provide the buffer. This should only be used
for alloc and free functions.
_in : The function will only read from the buffer. The caller must provide the
buffer and initialize it. Cannot be used with _deref.
_out : The function will only write to the buffer. If used on the return value or
with _deref, the function will provide the buffer and initialize it.
Otherwise, the caller must provide the buffer, and the function will
initialize it.
_inout : The function may freely read from and write to the buffer. The caller must
provide the buffer and initialize it. If used with _deref, the buffer may
be reallocated by the function.
Size: Describes the total size of the buffer. This may be less than the space actually
allocated for the buffer, in which case it describes the accessible amount.
<> : No buffer size is given. If the type specifies the buffer size (such as
with LPSTR and LPWSTR), that amount is used. Otherwise, the buffer is one
element long. Must be used with _in, _out, or _inout.
_ecount : The buffer size is an explicit element count.
_bcount : The buffer size is an explicit byte count.
Output: Describes how much of the buffer will be initialized by the function. For
_inout buffers, this also describes how much is initialized at entry. Omit this
category for _in buffers; they must be fully initialized by the caller.
<> : The type specifies how much is initialized. For instance, a function initializing
an LPWSTR must NULL-terminate the string.
_full : The function initializes the entire buffer.
_part : The function initializes part of the buffer, and explicitly indicates how much.
NullTerm: States if the present of a '\0' marks the end of valid elements in the buffer.
_z : A '\0' indicated the end of the buffer
_nz : The buffer may not be null terminated and a '\0' does not indicate the end of the
buffer.
Optional: Describes if the buffer itself is optional.
<> : The pointer to the buffer must not be NULL.
_opt : The pointer to the buffer might be NULL. It will be checked before being dereferenced.
Parameters: Gives explicit counts for the size and length of the buffer.
<> : There is no explicit count. Use when neither _ecount nor _bcount is used.
(size) : Only the buffer's total size is given. Use with _ecount or _bcount but not _part.
(size,length) : The buffer's total size and initialized length are given. Use with _ecount_part
and _bcount_part.
-------------------------------------------------------------------------------
Buffer Annotation Examples
LWSTDAPI_(BOOL) StrToIntExA(
__in LPCSTR pszString,
DWORD dwFlags,
__out int *piRet -- A pointer whose dereference will be filled in.
);
void MyPaintingFunction(
__in HWND hwndControl, -- An initialized read-only parameter.
__in_opt HDC hdcOptional, -- An initialized read-only parameter that might be NULL.
__inout IPropertyStore *ppsStore -- An initialized parameter that may be freely used
-- and modified.
);
LWSTDAPI_(BOOL) PathCompactPathExA(
__out_ecount(cchMax) LPSTR pszOut, -- A string buffer with cch elements that will
-- be NULL terminated on exit.
__in LPCSTR pszSrc,
UINT cchMax,
DWORD dwFlags
);
HRESULT SHLocalAllocBytes(
size_t cb,
__deref_bcount(cb) T **ppv -- A pointer whose dereference will be set to an
-- uninitialized buffer with cb bytes.
);
__inout_bcount_full(cb) : A buffer with cb elements that is fully initialized at
entry and exit, and may be written to by this function.
__out_ecount_part(count, *countOut) : A buffer with count elements that will be
partially initialized by this function. The function indicates how much it
initialized by setting *countOut.
-------------------------------------------------------------------------------
Advanced Annotations
Advanced annotations describe behavior that is not expressible with the regular
buffer macros. These may be used either to annotate buffer parameters that involve
complex or conditional behavior, or to enrich existing annotations with additional
information.
__success(expr) f :
<expr> indicates whether function f succeeded or not. If <expr> is true at exit,
all the function's guarantees (as given by other annotations) must hold. If <expr>
is false at exit, the caller should not expect any of the function's guarantees
to hold. If not used, the function must always satisfy its guarantees. Added
automatically to functions that indicate success in standard ways, such as by
returning an HRESULT.
__nullterminated p :
Pointer p is a buffer that may be read or written up to and including the first
NULL character or pointer. May be used on typedefs, which marks valid (properly
initialized) instances of that type as being NULL-terminated.
__nullnullterminated p :
Pointer p is a buffer that may be read or written up to and including the first
sequence of two NULL characters or pointers. May be used on typedefs, which marks
valid instances of that type as being double-NULL terminated.
__reserved v :
Value v must be 0/NULL, reserved for future use.
__checkReturn v :
Return value v must not be ignored by callers of this function.
__typefix(ctype) v :
Value v should be treated as an instance of ctype, rather than its declared type.
__override f :
Specify C#-style 'override' behaviour for overriding virtual methods.
__callback f :
Function f can be used as a function pointer.
__format_string p :
Pointer p is a string that contains % markers in the style of printf.
__blocksOn(resource) f :
Function f blocks on the resource 'resource'.
FALLTHROUGH :
Annotates switch statement labels where fall-through is desired, to distinguish
from forgotten break statements.
-------------------------------------------------------------------------------
Advanced Annotation Examples
__success(return != FALSE) LWSTDAPI_(BOOL)
PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, LPCSTR pszPath) :
pszBuf is only guaranteed to be NULL-terminated when TRUE is returned.
typedef __nullterminated WCHAR* LPWSTR : Initialized LPWSTRs are NULL-terminated strings.
__out_ecount(cch) __typefix(LPWSTR) void *psz : psz is a buffer parameter which will be
a NULL-terminated WCHAR string at exit, and which initially contains cch WCHARs.
-------------------------------------------------------------------------------
*/
#define __specstrings
#ifdef __cplusplus // [
#ifndef __nothrow // [
# define __nothrow NOTHROW_DECL
#endif // ]
extern "C" {
#else // ][
#ifndef __nothrow // [
# define __nothrow
#endif // ]
#endif /* #ifdef __cplusplus */ // ]
/*
-------------------------------------------------------------------------------
Helper Macro Definitions
These express behavior common to many of the high-level annotations.
DO NOT USE THESE IN YOUR CODE.
-------------------------------------------------------------------------------
*/
/*
The helper annotations are only understood by the compiler version used by
various defect detection tools. When the regular compiler is running, they
are defined into nothing, and do not affect the compiled code.
*/
#if !defined(__midl) && defined(_PREFAST_) // [
/*
In the primitive "SAL_*" annotations "SAL" stands for Standard
Annotation Language. These "SAL_*" annotations are the
primitives the compiler understands and high-level MACROs
will decompose into these primivates.
*/
#define _SA_SPECSTRIZE( x ) #x
/*
__null p
__notnull p
__maybenull p
Annotates a pointer p. States that pointer p is null. Commonly used
in the negated form __notnull or the possibly null form __maybenull.
*/
#ifndef PAL_STDCPP_COMPAT
#define __null _Null_impl_
#define __notnull _Notnull_impl_
#define __maybenull _Maybenull_impl_
#endif // !PAL_STDCPP_COMPAT
/*
__readonly l
__notreadonly l
__mabyereadonly l
Annotates a location l. States that location l is not modified after
this point. If the annotation is placed on the precondition state of
a function, the restriction only applies until the postcondition state
of the function. __maybereadonly states that the annotated location
may be modified, whereas __notreadonly states that a location must be
modified.
*/
#define __readonly _Pre1_impl_(__readaccess_impl)
#define __notreadonly _Pre1_impl_(__allaccess_impl)
#define __maybereadonly _Pre1_impl_(__readaccess_impl)
/*
__valid v
__notvalid v
__maybevalid v
Annotates any value v. States that the value satisfies all properties of
valid values of its type. For example, for a string buffer, valid means
that the buffer pointer is either NULL or points to a NULL-terminated string.
*/
#define __valid _Valid_impl_
#define __notvalid _Notvalid_impl_
#define __maybevalid _Maybevalid_impl_
/*
__readableTo(extent) p
Annotates a buffer pointer p. If the buffer can be read, extent describes
how much of the buffer is readable. For a reader of the buffer, this is
an explicit permission to read up to that amount, rather than a restriction to
read only up to it.
*/
#define __readableTo(extent) _SA_annotes1(SAL_readableTo, extent)
/*
__elem_readableTo(size)
Annotates a buffer pointer p as being readable to size elements.
*/
#define __elem_readableTo(size) _SA_annotes1(SAL_readableTo, elementCount( size ))
/*
__byte_readableTo(size)
Annotates a buffer pointer p as being readable to size bytes.
*/
#define __byte_readableTo(size) _SA_annotes1(SAL_readableTo, byteCount(size))
/*
__writableTo(extent) p
Annotates a buffer pointer p. If the buffer can be modified, extent
describes how much of the buffer is writable (usually the allocation
size). For a writer of the buffer, this is an explicit permission to
write up to that amount, rather than a restriction to write only up to it.
*/
#define __writableTo(size) _SA_annotes1(SAL_writableTo, size)
/*
__elem_writableTo(size)
Annotates a buffer pointer p as being writable to size elements.
*/
#define __elem_writableTo(size) _SA_annotes1(SAL_writableTo, elementCount( size ))
/*
__byte_writableTo(size)
Annotates a buffer pointer p as being writable to size bytes.
*/
#define __byte_writableTo(size) _SA_annotes1(SAL_writableTo, byteCount( size))
/*
__deref p
Annotates a pointer p. The next annotation applies one dereference down
in the type. If readableTo(p, size) then the next annotation applies to
all elements *(p+i) for which i satisfies the size. If p is a pointer
to a struct, the next annotation applies to all fields of the struct.
*/
#define __deref _Deref_impl_
/*
__pre __next_annotation
The next annotation applies in the precondition state
*/
#define __pre _Pre_impl_
/*
__post __next_annotation
The next annotation applies in the postcondition state
*/
#define __post _Post_impl_
/*
__precond(<expr>)
When <expr> is true, the next annotation applies in the precondition state
(currently not enabled)
*/
#define __precond(expr) __pre
/*
__postcond(<expr>)
When <expr> is true, the next annotation applies in the postcondition state
(currently not enabled)
*/
#define __postcond(expr) __post
/*
__exceptthat
Given a set of annotations Q containing __exceptthat maybeP, the effect of
the except clause is to erase any P or notP annotations (explicit or
implied) within Q at the same level of dereferencing that the except
clause appears, and to replace it with maybeP.
Example 1: __valid __pre_except_maybenull on a pointer p means that the
pointer may be null, and is otherwise valid, thus overriding
the implicit notnull annotation implied by __valid on
pointers.
Example 2: __valid __deref __pre_except_maybenull on an int **p means
that p is not null (implied by valid), but the elements
pointed to by p could be null, and are otherwise valid.
*/
#define __exceptthat __inner_exceptthat
/*
_refparam
Added to all out parameter macros to indicate that they are all reference
parameters.
*/
#define __refparam _Notref_ __deref __notreadonly
/*
__inner_*
Helper macros that directly correspond to certain high-level annotations.
*/
/*
Macros to classify the entrypoints and indicate their category.
Pre-defined control point categories include: RPC, LPC, DeviceDriver, UserToKernel, ISAPI, COM.
*/
#define __inner_control_entrypoint(category) _SA_annotes2(SAL_entrypoint, controlEntry, category)
/*
Pre-defined data entry point categories include: Registry, File, Network.
*/
#define __inner_data_entrypoint(category) _SA_annotes2(SAL_entrypoint, dataEntry, category)
#define __inner_override _SA_annotes0(__override)
#define __inner_callback _SA_annotes0(__callback)
#define __inner_blocksOn(resource) _SA_annotes1(SAL_blocksOn, resource)
#define __post_except_maybenull __post __inner_exceptthat _Maybenull_impl_
#define __pre_except_maybenull __pre __inner_exceptthat _Maybenull_impl_
#define __post_deref_except_maybenull __post __deref __inner_exceptthat _Maybenull_impl_
#define __pre_deref_except_maybenull __pre __deref __inner_exceptthat _Maybenull_impl_
#define __inexpressible_readableTo(size) _Readable_elements_impl_(_Inexpressible_(size))
#define __inexpressible_writableTo(size) _Writable_elements_impl_(_Inexpressible_(size))
#else // ][
#ifndef PAL_STDCPP_COMPAT
#define __null
#define __notnull
#define __deref
#endif // !PAL_STDCPP_COMPAT
#define __maybenull
#define __readonly
#define __notreadonly
#define __maybereadonly
#define __valid
#define __notvalid
#define __maybevalid
#define __readableTo(extent)
#define __elem_readableTo(size)
#define __byte_readableTo(size)
#define __writableTo(size)
#define __elem_writableTo(size)
#define __byte_writableTo(size)
#define __pre
#define __post
#define __precond(expr)
#define __postcond(expr)
#define __exceptthat
#define __inner_override
#define __inner_callback
#define __inner_blocksOn(resource)
#define __refparam
#define __inner_control_entrypoint(category)
#define __inner_data_entrypoint(category)
#define __post_except_maybenull
#define __pre_except_maybenull
#define __post_deref_except_maybenull
#define __pre_deref_except_maybenull
#define __inexpressible_readableTo(size)
#define __inexpressible_writableTo(size)
#endif /* #if !defined(__midl) && defined(_PREFAST_) */ // ]
/*
-------------------------------------------------------------------------------
Buffer Annotation Definitions
Any of these may be used to directly annotate functions, but only one should
be used for each parameter. To determine which annotation to use for a given
buffer, use the table in the buffer annotations section.
-------------------------------------------------------------------------------
*/
#define __ecount(size) _SAL1_Source_(__ecount, (size), __notnull __elem_writableTo(size))
#define __bcount(size) _SAL1_Source_(__bcount, (size), __notnull __byte_writableTo(size))
#define __in_ecount(size) _SAL1_Source_(__in_ecount, (size), _In_reads_(size))
#define __in_bcount(size) _SAL1_Source_(__in_bcount, (size), _In_reads_bytes_(size))
#define __in_z _SAL1_Source_(__in_z, (), _In_z_)
#define __in_ecount_z(size) _SAL1_Source_(__in_ecount_z, (size), _In_reads_z_(size))
#define __in_bcount_z(size) _SAL1_Source_(__in_bcount_z, (size), __in_bcount(size) __pre __nullterminated)
#define __in_nz _SAL1_Source_(__in_nz, (), __in)
#define __in_ecount_nz(size) _SAL1_Source_(__in_ecount_nz, (size), __in_ecount(size))
#define __in_bcount_nz(size) _SAL1_Source_(__in_bcount_nz, (size), __in_bcount(size))
#define __out_ecount(size) _SAL1_Source_(__out_ecount, (size), _Out_writes_(size))
#define __out_bcount(size) _SAL1_Source_(__out_bcount, (size), _Out_writes_bytes_(size))
#define __out_ecount_part(size,length) _SAL1_Source_(__out_ecount_part, (size,length), _Out_writes_to_(size,length))
#define __out_bcount_part(size,length) _SAL1_Source_(__out_bcount_part, (size,length), _Out_writes_bytes_to_(size,length))
#define __out_ecount_full(size) _SAL1_Source_(__out_ecount_full, (size), _Out_writes_all_(size))
#define __out_bcount_full(size) _SAL1_Source_(__out_bcount_full, (size), _Out_writes_bytes_all_(size))
#define __out_z _SAL1_Source_(__out_z, (), __post __valid __refparam __post __nullterminated)
#define __out_z_opt _SAL1_Source_(__out_z_opt, (), __post __valid __refparam __post __nullterminated __pre_except_maybenull)
#define __out_ecount_z(size) _SAL1_Source_(__out_ecount_z, (size), __ecount(size) __post __valid __refparam __post __nullterminated)
#define __out_bcount_z(size) _SAL1_Source_(__out_bcount_z, (size), __bcount(size) __post __valid __refparam __post __nullterminated)
#define __out_ecount_part_z(size,length) _SAL1_Source_(__out_ecount_part_z, (size,length), __out_ecount_part(size,length) __post __nullterminated)
#define __out_bcount_part_z(size,length) _SAL1_Source_(__out_bcount_part_z, (size,length), __out_bcount_part(size,length) __post __nullterminated)
#define __out_ecount_full_z(size) _SAL1_Source_(__out_ecount_full_z, (size), __out_ecount_full(size) __post __nullterminated)
#define __out_bcount_full_z(size) _SAL1_Source_(__out_bcount_full_z, (size), __out_bcount_full(size) __post __nullterminated)
#define __out_nz _SAL1_Source_(__out_nz, (), __post __valid __refparam)
#define __out_nz_opt _SAL1_Source_(__out_nz_opt, (), __post __valid __refparam __post_except_maybenull_)
#define __out_ecount_nz(size) _SAL1_Source_(__out_ecount_nz, (size), __ecount(size) __post __valid __refparam)
#define __out_bcount_nz(size) _SAL1_Source_(__out_bcount_nz, (size), __bcount(size) __post __valid __refparam)
#define __inout _SAL1_Source_(__inout, (), _Inout_)
#define __inout_ecount(size) _SAL1_Source_(__inout_ecount, (size), _Inout_updates_(size))
#define __inout_bcount(size) _SAL1_Source_(__inout_bcount, (size), _Inout_updates_bytes_(size))
#define __inout_ecount_part(size,length) _SAL1_Source_(__inout_ecount_part, (size,length), _Inout_updates_to_(size,length))
#define __inout_bcount_part(size,length) _SAL1_Source_(__inout_bcount_part, (size,length), _Inout_updates_bytes_to_(size,length))
#define __inout_ecount_full(size) _SAL1_Source_(__inout_ecount_full, (size), _Inout_updates_all_(size))
#define __inout_bcount_full(size) _SAL1_Source_(__inout_bcount_full, (size), _Inout_updates_bytes_all_(size))
#define __inout_z _SAL1_Source_(__inout_z, (), _Inout_z_)
#define __inout_ecount_z(size) _SAL1_Source_(__inout_ecount_z, (size), _Inout_updates_z_(size))
#define __inout_bcount_z(size) _SAL1_Source_(__inout_bcount_z, (size), __inout_bcount(size) __pre __nullterminated __post __nullterminated)
#define __inout_nz _SAL1_Source_(__inout_nz, (), __inout)
#define __inout_ecount_nz(size) _SAL1_Source_(__inout_ecount_nz, (size), __inout_ecount(size))
#define __inout_bcount_nz(size) _SAL1_Source_(__inout_bcount_nz, (size), __inout_bcount(size))
#define __ecount_opt(size) _SAL1_Source_(__ecount_opt, (size), __ecount(size) __pre_except_maybenull)
#define __bcount_opt(size) _SAL1_Source_(__bcount_opt, (size), __bcount(size) __pre_except_maybenull)
#define __in_opt _SAL1_Source_(__in_opt, (), _In_opt_)
#define __in_ecount_opt(size) _SAL1_Source_(__in_ecount_opt, (size), _In_reads_opt_(size))
#define __in_bcount_opt(size) _SAL1_Source_(__in_bcount_opt, (size), _In_reads_bytes_opt_(size))
#define __in_z_opt _SAL1_Source_(__in_z_opt, (), _In_opt_z_)
#define __in_ecount_z_opt(size) _SAL1_Source_(__in_ecount_z_opt, (size), __in_ecount_opt(size) __pre __nullterminated)
#define __in_bcount_z_opt(size) _SAL1_Source_(__in_bcount_z_opt, (size), __in_bcount_opt(size) __pre __nullterminated)
#define __in_nz_opt _SAL1_Source_(__in_nz_opt, (), __in_opt)
#define __in_ecount_nz_opt(size) _SAL1_Source_(__in_ecount_nz_opt, (size), __in_ecount_opt(size))
#define __in_bcount_nz_opt(size) _SAL1_Source_(__in_bcount_nz_opt, (size), __in_bcount_opt(size))
#define __out_opt _SAL1_Source_(__out_opt, (), _Out_opt_)
#define __out_ecount_opt(size) _SAL1_Source_(__out_ecount_opt, (size), _Out_writes_opt_(size))
#define __out_bcount_opt(size) _SAL1_Source_(__out_bcount_opt, (size), _Out_writes_bytes_opt_(size))
#define __out_ecount_part_opt(size,length) _SAL1_Source_(__out_ecount_part_opt, (size,length), __out_ecount_part(size,length) __pre_except_maybenull)
#define __out_bcount_part_opt(size,length) _SAL1_Source_(__out_bcount_part_opt, (size,length), __out_bcount_part(size,length) __pre_except_maybenull)
#define __out_ecount_full_opt(size) _SAL1_Source_(__out_ecount_full_opt, (size), __out_ecount_full(size) __pre_except_maybenull)
#define __out_bcount_full_opt(size) _SAL1_Source_(__out_bcount_full_opt, (size), __out_bcount_full(size) __pre_except_maybenull)
#define __out_ecount_z_opt(size) _SAL1_Source_(__out_ecount_z_opt, (size), __out_ecount_opt(size) __post __nullterminated)
#define __out_bcount_z_opt(size) _SAL1_Source_(__out_bcount_z_opt, (size), __out_bcount_opt(size) __post __nullterminated)
#define __out_ecount_part_z_opt(size,length) _SAL1_Source_(__out_ecount_part_z_opt, (size,length), __out_ecount_part_opt(size,length) __post __nullterminated)
#define __out_bcount_part_z_opt(size,length) _SAL1_Source_(__out_bcount_part_z_opt, (size,length), __out_bcount_part_opt(size,length) __post __nullterminated)
#define __out_ecount_full_z_opt(size) _SAL1_Source_(__out_ecount_full_z_opt, (size), __out_ecount_full_opt(size) __post __nullterminated)
#define __out_bcount_full_z_opt(size) _SAL1_Source_(__out_bcount_full_z_opt, (size), __out_bcount_full_opt(size) __post __nullterminated)
#define __out_ecount_nz_opt(size) _SAL1_Source_(__out_ecount_nz_opt, (size), __out_ecount_opt(size) __post __nullterminated)
#define __out_bcount_nz_opt(size) _SAL1_Source_(__out_bcount_nz_opt, (size), __out_bcount_opt(size) __post __nullterminated)
#define __inout_opt _SAL1_Source_(__inout_opt, (), _Inout_opt_)
#define __inout_ecount_opt(size) _SAL1_Source_(__inout_ecount_opt, (size), __inout_ecount(size) __pre_except_maybenull)
#define __inout_bcount_opt(size) _SAL1_Source_(__inout_bcount_opt, (size), __inout_bcount(size) __pre_except_maybenull)
#define __inout_ecount_part_opt(size,length) _SAL1_Source_(__inout_ecount_part_opt, (size,length), __inout_ecount_part(size,length) __pre_except_maybenull)
#define __inout_bcount_part_opt(size,length) _SAL1_Source_(__inout_bcount_part_opt, (size,length), __inout_bcount_part(size,length) __pre_except_maybenull)
#define __inout_ecount_full_opt(size) _SAL1_Source_(__inout_ecount_full_opt, (size), __inout_ecount_full(size) __pre_except_maybenull)
#define __inout_bcount_full_opt(size) _SAL1_Source_(__inout_bcount_full_opt, (size), __inout_bcount_full(size) __pre_except_maybenull)
#define __inout_z_opt _SAL1_Source_(__inout_z_opt, (), __inout_opt __pre __nullterminated __post __nullterminated)
#define __inout_ecount_z_opt(size) _SAL1_Source_(__inout_ecount_z_opt, (size), __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated)
#define __inout_ecount_z_opt(size) _SAL1_Source_(__inout_ecount_z_opt, (size), __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated)
#define __inout_bcount_z_opt(size) _SAL1_Source_(__inout_bcount_z_opt, (size), __inout_bcount_opt(size))
#define __inout_nz_opt _SAL1_Source_(__inout_nz_opt, (), __inout_opt)
#define __inout_ecount_nz_opt(size) _SAL1_Source_(__inout_ecount_nz_opt, (size), __inout_ecount_opt(size))
#define __inout_bcount_nz_opt(size) _SAL1_Source_(__inout_bcount_nz_opt, (size), __inout_bcount_opt(size))
#define __deref_ecount(size) _SAL1_Source_(__deref_ecount, (size), _Notref_ __ecount(1) __post _Notref_ __elem_readableTo(1) __post _Notref_ __deref _Notref_ __notnull __post __deref __elem_writableTo(size))
#define __deref_bcount(size) _SAL1_Source_(__deref_bcount, (size), _Notref_ __ecount(1) __post _Notref_ __elem_readableTo(1) __post _Notref_ __deref _Notref_ __notnull __post __deref __byte_writableTo(size))
#define __deref_out _SAL1_Source_(__deref_out, (), _Outptr_)
#define __deref_out_ecount(size) _SAL1_Source_(__deref_out_ecount, (size), _Outptr_result_buffer_(size))
#define __deref_out_bcount(size) _SAL1_Source_(__deref_out_bcount, (size), _Outptr_result_bytebuffer_(size))
#define __deref_out_ecount_part(size,length) _SAL1_Source_(__deref_out_ecount_part, (size,length), _Outptr_result_buffer_to_(size,length))
#define __deref_out_bcount_part(size,length) _SAL1_Source_(__deref_out_bcount_part, (size,length), _Outptr_result_bytebuffer_to_(size,length))
#define __deref_out_ecount_full(size) _SAL1_Source_(__deref_out_ecount_full, (size), __deref_out_ecount_part(size,size))
#define __deref_out_bcount_full(size) _SAL1_Source_(__deref_out_bcount_full, (size), __deref_out_bcount_part(size,size))
#define __deref_out_z _SAL1_Source_(__deref_out_z, (), _Outptr_result_z_)
#define __deref_out_ecount_z(size) _SAL1_Source_(__deref_out_ecount_z, (size), __deref_out_ecount(size) __post __deref __nullterminated)
#define __deref_out_bcount_z(size) _SAL1_Source_(__deref_out_bcount_z, (size), __deref_out_bcount(size) __post __deref __nullterminated)
#define __deref_out_nz _SAL1_Source_(__deref_out_nz, (), __deref_out)
#define __deref_out_ecount_nz(size) _SAL1_Source_(__deref_out_ecount_nz, (size), __deref_out_ecount(size))
#define __deref_out_bcount_nz(size) _SAL1_Source_(__deref_out_bcount_nz, (size), __deref_out_ecount(size))
#define __deref_inout _SAL1_Source_(__deref_inout, (), _Notref_ __notnull _Notref_ __elem_readableTo(1) __pre __deref __valid __post _Notref_ __deref __valid __refparam)
#define __deref_inout_z _SAL1_Source_(__deref_inout_z, (), __deref_inout __pre __deref __nullterminated __post _Notref_ __deref __nullterminated)
#define __deref_inout_ecount(size) _SAL1_Source_(__deref_inout_ecount, (size), __deref_inout __pre __deref __elem_writableTo(size) __post _Notref_ __deref __elem_writableTo(size))
#define __deref_inout_bcount(size) _SAL1_Source_(__deref_inout_bcount, (size), __deref_inout __pre __deref __byte_writableTo(size) __post _Notref_ __deref __byte_writableTo(size))
#define __deref_inout_ecount_part(size,length) _SAL1_Source_(__deref_inout_ecount_part, (size,length), __deref_inout_ecount(size) __pre __deref __elem_readableTo(length) __post __deref __elem_readableTo(length))
#define __deref_inout_bcount_part(size,length) _SAL1_Source_(__deref_inout_bcount_part, (size,length), __deref_inout_bcount(size) __pre __deref __byte_readableTo(length) __post __deref __byte_readableTo(length))
#define __deref_inout_ecount_full(size) _SAL1_Source_(__deref_inout_ecount_full, (size), __deref_inout_ecount_part(size,size))
#define __deref_inout_bcount_full(size) _SAL1_Source_(__deref_inout_bcount_full, (size), __deref_inout_bcount_part(size,size))
#define __deref_inout_ecount_z(size) _SAL1_Source_(__deref_inout_ecount_z, (size), __deref_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_bcount_z(size) _SAL1_Source_(__deref_inout_bcount_z, (size), __deref_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_nz _SAL1_Source_(__deref_inout_nz, (), __deref_inout)
#define __deref_inout_ecount_nz(size) _SAL1_Source_(__deref_inout_ecount_nz, (size), __deref_inout_ecount(size))
#define __deref_inout_bcount_nz(size) _SAL1_Source_(__deref_inout_bcount_nz, (size), __deref_inout_ecount(size))
#define __deref_ecount_opt(size) _SAL1_Source_(__deref_ecount_opt, (size), __deref_ecount(size) __post_deref_except_maybenull)
#define __deref_bcount_opt(size) _SAL1_Source_(__deref_bcount_opt, (size), __deref_bcount(size) __post_deref_except_maybenull)
#define __deref_out_opt _SAL1_Source_(__deref_out_opt, (), __deref_out __post_deref_except_maybenull)
#define __deref_out_ecount_opt(size) _SAL1_Source_(__deref_out_ecount_opt, (size), __deref_out_ecount(size) __post_deref_except_maybenull)
#define __deref_out_bcount_opt(size) _SAL1_Source_(__deref_out_bcount_opt, (size), __deref_out_bcount(size) __post_deref_except_maybenull)
#define __deref_out_ecount_part_opt(size,length) _SAL1_Source_(__deref_out_ecount_part_opt, (size,length), __deref_out_ecount_part(size,length) __post_deref_except_maybenull)
#define __deref_out_bcount_part_opt(size,length) _SAL1_Source_(__deref_out_bcount_part_opt, (size,length), __deref_out_bcount_part(size,length) __post_deref_except_maybenull)
#define __deref_out_ecount_full_opt(size) _SAL1_Source_(__deref_out_ecount_full_opt, (size), __deref_out_ecount_full(size) __post_deref_except_maybenull)
#define __deref_out_bcount_full_opt(size) _SAL1_Source_(__deref_out_bcount_full_opt, (size), __deref_out_bcount_full(size) __post_deref_except_maybenull)
#define __deref_out_z_opt _SAL1_Source_(__deref_out_z_opt, (), _Outptr_result_maybenull_z_)
#define __deref_out_ecount_z_opt(size) _SAL1_Source_(__deref_out_ecount_z_opt, (size), __deref_out_ecount_opt(size) __post __deref __nullterminated)
#define __deref_out_bcount_z_opt(size) _SAL1_Source_(__deref_out_bcount_z_opt, (size), __deref_out_bcount_opt(size) __post __deref __nullterminated)
#define __deref_out_nz_opt _SAL1_Source_(__deref_out_nz_opt, (), __deref_out_opt)
#define __deref_out_ecount_nz_opt(size) _SAL1_Source_(__deref_out_ecount_nz_opt, (size), __deref_out_ecount_opt(size))
#define __deref_out_bcount_nz_opt(size) _SAL1_Source_(__deref_out_bcount_nz_opt, (size), __deref_out_bcount_opt(size))
#define __deref_inout_opt _SAL1_Source_(__deref_inout_opt, (), __deref_inout __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_ecount_opt(size) _SAL1_Source_(__deref_inout_ecount_opt, (size), __deref_inout_ecount(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_bcount_opt(size) _SAL1_Source_(__deref_inout_bcount_opt, (size), __deref_inout_bcount(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_ecount_part_opt(size,length) _SAL1_Source_(__deref_inout_ecount_part_opt, (size,length), __deref_inout_ecount_part(size,length) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_bcount_part_opt(size,length) _SAL1_Source_(__deref_inout_bcount_part_opt, (size,length), __deref_inout_bcount_part(size,length) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_ecount_full_opt(size) _SAL1_Source_(__deref_inout_ecount_full_opt, (size), __deref_inout_ecount_full(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_bcount_full_opt(size) _SAL1_Source_(__deref_inout_bcount_full_opt, (size), __deref_inout_bcount_full(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_z_opt _SAL1_Source_(__deref_inout_z_opt, (), __deref_inout_opt __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_ecount_z_opt(size) _SAL1_Source_(__deref_inout_ecount_z_opt, (size), __deref_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_bcount_z_opt(size) _SAL1_Source_(__deref_inout_bcount_z_opt, (size), __deref_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_nz_opt _SAL1_Source_(__deref_inout_nz_opt, (), __deref_inout_opt)
#define __deref_inout_ecount_nz_opt(size) _SAL1_Source_(__deref_inout_ecount_nz_opt, (size), __deref_inout_ecount_opt(size))
#define __deref_inout_bcount_nz_opt(size) _SAL1_Source_(__deref_inout_bcount_nz_opt, (size), __deref_inout_bcount_opt(size))
#define __deref_opt_ecount(size) _SAL1_Source_(__deref_opt_ecount, (size), __deref_ecount(size) __pre_except_maybenull)
#define __deref_opt_bcount(size) _SAL1_Source_(__deref_opt_bcount, (size), __deref_bcount(size) __pre_except_maybenull)
#define __deref_opt_out _SAL1_Source_(__deref_opt_out, (), _Outptr_opt_)
#define __deref_opt_out_z _SAL1_Source_(__deref_opt_out_z, (), _Outptr_opt_result_z_)
#define __deref_opt_out_ecount(size) _SAL1_Source_(__deref_opt_out_ecount, (size), __deref_out_ecount(size) __pre_except_maybenull)
#define __deref_opt_out_bcount(size) _SAL1_Source_(__deref_opt_out_bcount, (size), __deref_out_bcount(size) __pre_except_maybenull)
#define __deref_opt_out_ecount_part(size,length) _SAL1_Source_(__deref_opt_out_ecount_part, (size,length), __deref_out_ecount_part(size,length) __pre_except_maybenull)
#define __deref_opt_out_bcount_part(size,length) _SAL1_Source_(__deref_opt_out_bcount_part, (size,length), __deref_out_bcount_part(size,length) __pre_except_maybenull)
#define __deref_opt_out_ecount_full(size) _SAL1_Source_(__deref_opt_out_ecount_full, (size), __deref_out_ecount_full(size) __pre_except_maybenull)
#define __deref_opt_out_bcount_full(size) _SAL1_Source_(__deref_opt_out_bcount_full, (size), __deref_out_bcount_full(size) __pre_except_maybenull)
#define __deref_opt_inout _SAL1_Source_(__deref_opt_inout, (), _Inout_opt_)
#define __deref_opt_inout_ecount(size) _SAL1_Source_(__deref_opt_inout_ecount, (size), __deref_inout_ecount(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount(size) _SAL1_Source_(__deref_opt_inout_bcount, (size), __deref_inout_bcount(size) __pre_except_maybenull)
#define __deref_opt_inout_ecount_part(size,length) _SAL1_Source_(__deref_opt_inout_ecount_part, (size,length), __deref_inout_ecount_part(size,length) __pre_except_maybenull)
#define __deref_opt_inout_bcount_part(size,length) _SAL1_Source_(__deref_opt_inout_bcount_part, (size,length), __deref_inout_bcount_part(size,length) __pre_except_maybenull)
#define __deref_opt_inout_ecount_full(size) _SAL1_Source_(__deref_opt_inout_ecount_full, (size), __deref_inout_ecount_full(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount_full(size) _SAL1_Source_(__deref_opt_inout_bcount_full, (size), __deref_inout_bcount_full(size) __pre_except_maybenull)
#define __deref_opt_inout_z _SAL1_Source_(__deref_opt_inout_z, (), __deref_opt_inout __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_ecount_z(size) _SAL1_Source_(__deref_opt_inout_ecount_z, (size), __deref_opt_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_bcount_z(size) _SAL1_Source_(__deref_opt_inout_bcount_z, (size), __deref_opt_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_nz _SAL1_Source_(__deref_opt_inout_nz, (), __deref_opt_inout)
#define __deref_opt_inout_ecount_nz(size) _SAL1_Source_(__deref_opt_inout_ecount_nz, (size), __deref_opt_inout_ecount(size))
#define __deref_opt_inout_bcount_nz(size) _SAL1_Source_(__deref_opt_inout_bcount_nz, (size), __deref_opt_inout_bcount(size))
#define __deref_opt_ecount_opt(size) _SAL1_Source_(__deref_opt_ecount_opt, (size), __deref_ecount_opt(size) __pre_except_maybenull)
#define __deref_opt_bcount_opt(size) _SAL1_Source_(__deref_opt_bcount_opt, (size), __deref_bcount_opt(size) __pre_except_maybenull)
#define __deref_opt_out_opt _SAL1_Source_(__deref_opt_out_opt, (), _Outptr_opt_result_maybenull_)
#define __deref_opt_out_ecount_opt(size) _SAL1_Source_(__deref_opt_out_ecount_opt, (size), __deref_out_ecount_opt(size) __pre_except_maybenull)
#define __deref_opt_out_bcount_opt(size) _SAL1_Source_(__deref_opt_out_bcount_opt, (size), __deref_out_bcount_opt(size) __pre_except_maybenull)
#define __deref_opt_out_ecount_part_opt(size,length) _SAL1_Source_(__deref_opt_out_ecount_part_opt, (size,length), __deref_out_ecount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_out_bcount_part_opt(size,length) _SAL1_Source_(__deref_opt_out_bcount_part_opt, (size,length), __deref_out_bcount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_out_ecount_full_opt(size) _SAL1_Source_(__deref_opt_out_ecount_full_opt, (size), __deref_out_ecount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_out_bcount_full_opt(size) _SAL1_Source_(__deref_opt_out_bcount_full_opt, (size), __deref_out_bcount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_out_z_opt _SAL1_Source_(__deref_opt_out_z_opt, (), __post __deref __valid __refparam __pre_except_maybenull __pre_deref_except_maybenull __post_deref_except_maybenull __post __deref __nullterminated)
#define __deref_opt_out_ecount_z_opt(size) _SAL1_Source_(__deref_opt_out_ecount_z_opt, (size), __deref_opt_out_ecount_opt(size) __post __deref __nullterminated)
#define __deref_opt_out_bcount_z_opt(size) _SAL1_Source_(__deref_opt_out_bcount_z_opt, (size), __deref_opt_out_bcount_opt(size) __post __deref __nullterminated)
#define __deref_opt_out_nz_opt _SAL1_Source_(__deref_opt_out_nz_opt, (), __deref_opt_out_opt)
#define __deref_opt_out_ecount_nz_opt(size) _SAL1_Source_(__deref_opt_out_ecount_nz_opt, (size), __deref_opt_out_ecount_opt(size))
#define __deref_opt_out_bcount_nz_opt(size) _SAL1_Source_(__deref_opt_out_bcount_nz_opt, (size), __deref_opt_out_bcount_opt(size))
#define __deref_opt_inout_opt _SAL1_Source_(__deref_opt_inout_opt, (), __deref_inout_opt __pre_except_maybenull)
#define __deref_opt_inout_ecount_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_opt, (size), __deref_inout_ecount_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_opt, (size), __deref_inout_bcount_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_ecount_part_opt(size,length) _SAL1_Source_(__deref_opt_inout_ecount_part_opt, (size,length), __deref_inout_ecount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_inout_bcount_part_opt(size,length) _SAL1_Source_(__deref_opt_inout_bcount_part_opt, (size,length), __deref_inout_bcount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_inout_ecount_full_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_full_opt, (size), __deref_inout_ecount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount_full_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_full_opt, (size), __deref_inout_bcount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_z_opt _SAL1_Source_(__deref_opt_inout_z_opt, (), __deref_opt_inout_opt __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_ecount_z_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_z_opt, (size), __deref_opt_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_bcount_z_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_z_opt, (size), __deref_opt_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_nz_opt _SAL1_Source_(__deref_opt_inout_nz_opt, (), __deref_opt_inout_opt)
#define __deref_opt_inout_ecount_nz_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_nz_opt, (size), __deref_opt_inout_ecount_opt(size))
#define __deref_opt_inout_bcount_nz_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_nz_opt, (size), __deref_opt_inout_bcount_opt(size))
/*
-------------------------------------------------------------------------------
Advanced Annotation Definitions
Any of these may be used to directly annotate functions, and may be used in
combination with each other or with regular buffer macros. For an explanation
of each annotation, see the advanced annotations section.
-------------------------------------------------------------------------------
*/
#define __success(expr) _Success_(expr)
#define __nullterminated _Null_terminated_
#define __nullnullterminated
#define __clr_reserved _SAL1_Source_(__reserved, (), _Reserved_)
#define __checkReturn _SAL1_Source_(__checkReturn, (), _Check_return_)
#define __typefix(ctype) _SAL1_Source_(__typefix, (ctype), __inner_typefix(ctype))
#define __override __inner_override
#define __callback __inner_callback
#define __format_string _Printf_format_string_
#define __blocksOn(resource) __inner_blocksOn(resource)
#define __control_entrypoint(category) __inner_control_entrypoint(category)
#define __data_entrypoint(category) __inner_data_entrypoint(category)
#define __useHeader _Use_decl_anno_impl_
#define __on_failure(annotes) _On_failure_impl_(annotes _SAL_nop_impl_)
#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) (0)
#endif
#ifndef __fallthrough // [
#if __has_cpp_attribute(fallthrough)
#define __fallthrough [[fallthrough]]
#else
#define __fallthrough
#endif
#endif // ]
#ifndef __analysis_assume // [
#ifdef _PREFAST_ // [
#define __analysis_assume(expr) __assume(expr)
#else // ][
#define __analysis_assume(expr)
#endif // ]
#endif // ]
#ifndef _Analysis_assume_ // [
#ifdef _PREFAST_ // [
#define _Analysis_assume_(expr) __assume(expr)
#else // ][
#define _Analysis_assume_(expr)
#endif // ]
#endif // ]
#define _Analysis_noreturn_ _SAL2_Source_(_Analysis_noreturn_, (), _SA_annotes0(SAL_terminates))
#ifdef _PREFAST_ // [
__inline __nothrow
void __AnalysisAssumeNullterminated(_Post_ __nullterminated void *p);
#define _Analysis_assume_nullterminated_(x) __AnalysisAssumeNullterminated(x)
#else // ][
#define _Analysis_assume_nullterminated_(x)
#endif // ]
//
// Set the analysis mode (global flags to analysis).
// They take effect at the point of declaration; use at global scope
// as a declaration.
//
// Synthesize a unique symbol.
#define ___MKID(x, y) x ## y
#define __MKID(x, y) ___MKID(x, y)
#define __GENSYM(x) __MKID(x, __COUNTER__)
__ANNOTATION(SAL_analysisMode(__AuToQuOtE __In_impl_ char *mode);)
#define _Analysis_mode_impl_(mode) _SA_annotes1(SAL_analysisMode, #mode)
#define _Analysis_mode_(mode) \
typedef _Analysis_mode_impl_(mode) int \
__GENSYM(__prefast_analysis_mode_flag);
// The following are predefined:
// _Analysis_operator_new_throw_ (operator new throws)
// _Analysis_operator_new_null_ (operator new returns null)
// _Analysis_operator_new_never_fails_ (operator new never fails)
//
// Function class annotations.
__ANNOTATION(SAL_functionClassNew(__In_impl_ char*);)
__PRIMOP(int, _In_function_class_(__In_impl_ char*);)
#define _In_function_class_(x) _In_function_class_(#x)
#define _Function_class_(x) _SA_annotes1(SAL_functionClassNew, #x)
/*
* interlocked operand used in interlocked instructions
*/
//#define _Interlocked_operand_ _Pre_ _SA_annotes0(SAL_interlocked)
#define _Enum_is_bitflag_ _SA_annotes0(SAL_enumIsBitflag)
#define _Strict_type_match_ _SA_annotes0(SAL_strictType2)
#define _Maybe_raises_SEH_exception_ _Pre_ _SA_annotes1(SAL_inTry,__yes)
#define _Raises_SEH_exception_ _Group_(_Maybe_raises_SEH_exception_ _Analysis_noreturn_)
#ifdef __cplusplus // [
}
#endif // ]
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/***
*sal.h - markers for documenting the semantics of APIs
*
*
*Purpose:
* sal.h provides a set of annotations to describe how a function uses its
* parameters - the assumptions it makes about them, and the guarantees it makes
* upon finishing.
****/
#pragma once
/*==========================================================================
The comments in this file are intended to give basic understanding of
the usage of SAL, the Microsoft Source Code Annotation Language.
For more details, please see http://go.microsoft.com/fwlink/?LinkID=242134
The macros are defined in 3 layers, plus the structural set:
_In_/_Out_/_Ret_ Layer:
----------------------
This layer provides the highest abstraction and its macros should be used
in most cases. These macros typically start with:
_In_ : input parameter to a function, unmodified by called function
_Out_ : output parameter, written to by called function, pointed-to
location not expected to be initialized prior to call
_Outptr_ : like _Out_ when returned variable is a pointer type
(so param is pointer-to-pointer type). Called function
provides/allocated space.
_Outref_ : like _Outptr_, except param is reference-to-pointer type.
_Inout_ : inout parameter, read from and potentially modified by
called function.
_Ret_ : for return values
_Field_ : class/struct field invariants
For common usage, this class of SAL provides the most concise annotations.
Note that _In_/_Out_/_Inout_/_Outptr_ annotations are designed to be used
with a parameter target. Using them with _At_ to specify non-parameter
targets may yield unexpected results.
This layer also includes a number of other properties that can be specified
to extend the ability of code analysis, most notably:
-- Designating parameters as format strings for printf/scanf/scanf_s
-- Requesting stricter type checking for C enum parameters
_Pre_/_Post_ Layer:
------------------
The macros of this layer only should be used when there is no suitable macro
in the _In_/_Out_ layer. Its macros start with _Pre_ or _Post_.
This layer provides the most flexibility for annotations.
Implementation Abstraction Layer:
--------------------------------
Macros from this layer should never be used directly. The layer only exists
to hide the implementation of the annotation macros.
Structural Layer:
----------------
These annotations, like _At_ and _When_, are used with annotations from
any of the other layers as modifiers, indicating exactly when and where
the annotations apply.
Common syntactic conventions:
----------------------------
Usage:
-----
_In_, _Out_, _Inout_, _Pre_, _Post_, are for formal parameters.
_Ret_, _Deref_ret_ must be used for return values.
Nullness:
--------
If the parameter can be NULL as a precondition to the function, the
annotation contains _opt. If the macro does not contain '_opt' the
parameter cannot be NULL.
If an out/inout parameter returns a null pointer as a postcondition, this is
indicated by _Ret_maybenull_ or _result_maybenull_. If the macro is not
of this form, then the result will not be NULL as a postcondition.
_Outptr_ - output value is not NULL
_Outptr_result_maybenull_ - output value might be NULL
String Type:
-----------
_z: NullTerminated string
for _In_ parameters the buffer must have the specified stringtype before the call
for _Out_ parameters the buffer must have the specified stringtype after the call
for _Inout_ parameters both conditions apply
Extent Syntax:
-------------
Buffer sizes are expressed as element counts, unless the macro explicitly
contains _byte_ or _bytes_. Some annotations specify two buffer sizes, in
which case the second is used to indicate how much of the buffer is valid
as a postcondition. This table outlines the precondition buffer allocation
size, precondition number of valid elements, postcondition allocation size,
and postcondition number of valid elements for representative buffer size
annotations:
Pre | Pre | Post | Post
alloc | valid | alloc | valid
Annotation elems | elems | elems | elems
---------- ------------------------------------
_In_reads_(s) s | s | s | s
_Inout_updates_(s) s | s | s | s
_Inout_updates_to_(s,c) s | s | s | c
_Out_writes_(s) s | 0 | s | s
_Out_writes_to_(s,c) s | 0 | s | c
_Outptr_result_buffer_(s) ? | ? | s | s
_Outptr_result_buffer_to_(s,c) ? | ? | s | c
For the _Outptr_ annotations, the buffer in question is at one level of
dereference. The called function is responsible for supplying the buffer.
Success and failure:
-------------------
The SAL concept of success allows functions to define expressions that can
be tested by the caller, which if it evaluates to non-zero, indicates the
function succeeded, which means that its postconditions are guaranteed to
hold. Otherwise, if the expression evaluates to zero, the function is
considered to have failed, and the postconditions are not guaranteed.
The success criteria can be specified with the _Success_(expr) annotation:
_Success_(return != FALSE) BOOL
PathCanonicalizeA(_Out_writes_(MAX_PATH) LPSTR pszBuf, LPCSTR pszPath) :
pszBuf is only guaranteed to be NULL-terminated when TRUE is returned,
and FALSE indiates failure. In common practice, callers check for zero
vs. non-zero returns, so it is preferable to express the success
criteria in terms of zero/non-zero, not checked for exactly TRUE.
Functions can specify that some postconditions will still hold, even when
the function fails, using _On_failure_(anno-list), or postconditions that
hold regardless of success or failure using _Always_(anno-list).
The annotation _Return_type_success_(expr) may be used with a typedef to
give a default _Success_ criteria to all functions returning that type.
This is the case for common Windows API status types, including
HRESULT and NTSTATUS. This may be overridden on a per-function basis by
specifying a _Success_ annotation locally.
============================================================================*/
#define __ATTR_SAL
#ifndef _SAL_VERSION /*IFSTRIP=IGN*/
#define _SAL_VERSION 20
#endif
#ifdef _PREFAST_ // [
// choose attribute or __declspec implementation
#ifndef _USE_DECLSPECS_FOR_SAL // [
#define _USE_DECLSPECS_FOR_SAL 1
#endif // ]
#if _USE_DECLSPECS_FOR_SAL // [
#undef _USE_ATTRIBUTES_FOR_SAL
#define _USE_ATTRIBUTES_FOR_SAL 0
#elif !defined(_USE_ATTRIBUTES_FOR_SAL) // ][
#if _MSC_VER >= 1400 /*IFSTRIP=IGN*/ // [
#define _USE_ATTRIBUTES_FOR_SAL 1
#else // ][
#define _USE_ATTRIBUTES_FOR_SAL 0
#endif // ]
#endif // ]
#if !_USE_DECLSPECS_FOR_SAL // [
#if !_USE_ATTRIBUTES_FOR_SAL // [
#if _MSC_VER >= 1400 /*IFSTRIP=IGN*/ // [
#undef _USE_ATTRIBUTES_FOR_SAL
#define _USE_ATTRIBUTES_FOR_SAL 1
#else // ][
#undef _USE_DECLSPECS_FOR_SAL
#define _USE_DECLSPECS_FOR_SAL 1
#endif // ]
#endif // ]
#endif // ]
#else
// Disable expansion of SAL macros in non-Prefast mode to
// improve compiler throughput.
#ifndef _USE_DECLSPECS_FOR_SAL // [
#define _USE_DECLSPECS_FOR_SAL 0
#endif // ]
#ifndef _USE_ATTRIBUTES_FOR_SAL // [
#define _USE_ATTRIBUTES_FOR_SAL 0
#endif // ]
#endif // ]
// safeguard for MIDL and RC builds
#if _USE_DECLSPECS_FOR_SAL && ( defined( MIDL_PASS ) || defined(__midl) || defined(RC_INVOKED) || !defined(_PREFAST_) ) /*IFSTRIP=IGN*/ // [
#undef _USE_DECLSPECS_FOR_SAL
#define _USE_DECLSPECS_FOR_SAL 0
#endif // ]
#if _USE_ATTRIBUTES_FOR_SAL && ( !defined(_MSC_EXTENSIONS) || defined( MIDL_PASS ) || defined(__midl) || defined(RC_INVOKED) ) /*IFSTRIP=IGN*/ // [
#undef _USE_ATTRIBUTES_FOR_SAL
#define _USE_ATTRIBUTES_FOR_SAL 0
#endif // ]
#if _USE_DECLSPECS_FOR_SAL || _USE_ATTRIBUTES_FOR_SAL
// Special enum type for Y/N/M
enum __SAL_YesNo {_SAL_notpresent, _SAL_no, _SAL_maybe, _SAL_yes, _SAL_default};
#endif
#if defined(BUILD_WINDOWS) && !_USE_ATTRIBUTES_FOR_SAL /*IFSTRIP=IGN*/
#define _SAL1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1") _GrouP_(annotes _SAL_nop_impl_)
#define _SAL1_1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.1") _GrouP_(annotes _SAL_nop_impl_)
#define _SAL1_2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.2") _GrouP_(annotes _SAL_nop_impl_)
#define _SAL2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "2") _GrouP_(annotes _SAL_nop_impl_)
#else
#define _SAL1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1") _Group_(annotes _SAL_nop_impl_)
#define _SAL1_1_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.1") _Group_(annotes _SAL_nop_impl_)
#define _SAL1_2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "1.2") _Group_(annotes _SAL_nop_impl_)
#define _SAL2_Source_(Name, args, annotes) _SA_annotes3(SAL_name, #Name, "", "2") _Group_(annotes _SAL_nop_impl_)
#endif
//============================================================================
// Structural SAL:
// These annotations modify the use of other annotations. They may
// express the annotation target (i.e. what parameter/field the annotation
// applies to) or the condition under which the annotation is applicable.
//============================================================================
// _At_(target, annos) specifies that the annotations listed in 'annos' is to
// be applied to 'target' rather than to the identifier which is the current
// lexical target.
#define _At_(target, annos) _At_impl_(target, annos _SAL_nop_impl_)
// _At_buffer_(target, iter, bound, annos) is similar to _At_, except that
// target names a buffer, and each annotation in annos is applied to each
// element of target up to bound, with the variable named in iter usable
// by the annotations to refer to relevant offsets within target.
#define _At_buffer_(target, iter, bound, annos) _At_buffer_impl_(target, iter, bound, annos _SAL_nop_impl_)
// _When_(expr, annos) specifies that the annotations listed in 'annos' only
// apply when 'expr' evaluates to non-zero.
#define _When_(expr, annos) _When_impl_(expr, annos _SAL_nop_impl_)
#define _Group_(annos) _Group_impl_(annos _SAL_nop_impl_)
#define _GrouP_(annos) _GrouP_impl_(annos _SAL_nop_impl_)
// <expr> indicates whether normal post conditions apply to a function
#define _Success_(expr) _SAL2_Source_(_Success_, (expr), _Success_impl_(expr))
// <expr> indicates whether post conditions apply to a function returning
// the type that this annotation is applied to
#define _Return_type_success_(expr) _SAL2_Source_(_Return_type_success_, (expr), _Success_impl_(expr))
// Establish postconditions that apply only if the function does not succeed
#define _On_failure_(annos) _On_failure_impl_(annos _SAL_nop_impl_)
// Establish postconditions that apply in both success and failure cases.
// Only applicable with functions that have _Success_ or _Return_type_succss_.
#define _Always_(annos) _Always_impl_(annos _SAL_nop_impl_)
// Usable on a function defintion. Asserts that a function declaration is
// in scope, and its annotations are to be used. There are no other annotations
// allowed on the function definition.
#define _Use_decl_annotations_ _Use_decl_anno_impl_
// _Notref_ may precede a _Deref_ or "real" annotation, and removes one
// level of dereference if the parameter is a C++ reference (&). If the
// net deref on a "real" annotation is negative, it is simply discarded.
#define _Notref_ _Notref_impl_
// Annotations for defensive programming styles.
#define _Pre_defensive_ _SA_annotes0(SAL_pre_defensive)
#define _Post_defensive_ _SA_annotes0(SAL_post_defensive)
#define _In_defensive_(annotes) _Pre_defensive_ _Group_(annotes)
#define _Out_defensive_(annotes) _Post_defensive_ _Group_(annotes)
#define _Inout_defensive_(annotes) _Pre_defensive_ _Post_defensive_ _Group_(annotes)
//============================================================================
// _In_\_Out_ Layer:
//============================================================================
// Reserved pointer parameters, must always be NULL.
#define _Reserved_ _SAL2_Source_(_Reserved_, (), _Pre1_impl_(__null_impl))
// _Const_ allows specification that any namable memory location is considered
// readonly for a given call.
#define _Const_ _SAL2_Source_(_Const_, (), _Pre1_impl_(__readaccess_impl_notref))
// Input parameters --------------------------
// _In_ - Annotations for parameters where data is passed into the function, but not modified.
// _In_ by itself can be used with non-pointer types (although it is redundant).
// e.g. void SetPoint( _In_ const POINT* pPT );
#define _In_ _SAL2_Source_(_In_, (), _Pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_ _Deref_pre1_impl_(__readaccess_impl_notref))
#define _In_opt_ _SAL2_Source_(_In_opt_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_ _Deref_pre_readonly_)
// nullterminated 'in' parameters.
// e.g. void CopyStr( _In_z_ const char* szFrom, _Out_z_cap_(cchTo) char* szTo, size_t cchTo );
#define _In_z_ _SAL2_Source_(_In_z_, (), _In_ _Pre1_impl_(__zterm_impl))
#define _In_opt_z_ _SAL2_Source_(_In_opt_z_, (), _In_opt_ _Pre1_impl_(__zterm_impl))
// 'input' buffers with given size
#define _In_reads_(size) _SAL2_Source_(_In_reads_, (size), _Pre_count_(size) _Deref_pre_readonly_)
#define _In_reads_opt_(size) _SAL2_Source_(_In_reads_opt_, (size), _Pre_opt_count_(size) _Deref_pre_readonly_)
#define _In_reads_bytes_(size) _SAL2_Source_(_In_reads_bytes_, (size), _Pre_bytecount_(size) _Deref_pre_readonly_)
#define _In_reads_bytes_opt_(size) _SAL2_Source_(_In_reads_bytes_opt_, (size), _Pre_opt_bytecount_(size) _Deref_pre_readonly_)
#define _In_reads_z_(size) _SAL2_Source_(_In_reads_z_, (size), _In_reads_(size) _Pre_z_)
#define _In_reads_opt_z_(size) _SAL2_Source_(_In_reads_opt_z_, (size), _Pre_opt_count_(size) _Deref_pre_readonly_ _Pre_opt_z_)
#define _In_reads_or_z_(size) _SAL2_Source_(_In_reads_or_z_, (size), _In_ _When_(_String_length_(_Curr_) < (size), _Pre_z_) _When_(_String_length_(_Curr_) >= (size), _Pre1_impl_(__count_impl(size))))
#define _In_reads_or_z_opt_(size) _SAL2_Source_(_In_reads_or_z_opt_, (size), _In_opt_ _When_(_String_length_(_Curr_) < (size), _Pre_z_) _When_(_String_length_(_Curr_) >= (size), _Pre1_impl_(__count_impl(size))))
// 'input' buffers valid to the given end pointer
#define _In_reads_to_ptr_(ptr) _SAL2_Source_(_In_reads_to_ptr_, (ptr), _Pre_ptrdiff_count_(ptr) _Deref_pre_readonly_)
#define _In_reads_to_ptr_opt_(ptr) _SAL2_Source_(_In_reads_to_ptr_opt_, (ptr), _Pre_opt_ptrdiff_count_(ptr) _Deref_pre_readonly_)
#define _In_reads_to_ptr_z_(ptr) _SAL2_Source_(_In_reads_to_ptr_z_, (ptr), _In_reads_to_ptr_(ptr) _Pre_z_)
#define _In_reads_to_ptr_opt_z_(ptr) _SAL2_Source_(_In_reads_to_ptr_opt_z_, (ptr), _Pre_opt_ptrdiff_count_(ptr) _Deref_pre_readonly_ _Pre_opt_z_)
// Output parameters --------------------------
// _Out_ - Annotations for pointer or reference parameters where data passed back to the caller.
// These are mostly used where the pointer/reference is to a non-pointer type.
// _Outptr_/_Outref) (see below) are typically used to return pointers via parameters.
// e.g. void GetPoint( _Out_ POINT* pPT );
#define _Out_ _SAL2_Source_(_Out_, (), _Out_impl_)
#define _Out_opt_ _SAL2_Source_(_Out_opt_, (), _Out_opt_impl_)
#define _Out_writes_(size) _SAL2_Source_(_Out_writes_, (size), _Pre_cap_(size) _Post_valid_impl_)
#define _Out_writes_opt_(size) _SAL2_Source_(_Out_writes_opt_, (size), _Pre_opt_cap_(size) _Post_valid_impl_)
#define _Out_writes_bytes_(size) _SAL2_Source_(_Out_writes_bytes_, (size), _Pre_bytecap_(size) _Post_valid_impl_)
#define _Out_writes_bytes_opt_(size) _SAL2_Source_(_Out_writes_bytes_opt_, (size), _Pre_opt_bytecap_(size) _Post_valid_impl_)
#define _Out_writes_z_(size) _SAL2_Source_(_Out_writes_z_, (size), _Pre_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_writes_opt_z_(size) _SAL2_Source_(_Out_writes_opt_z_, (size), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_writes_to_(size,count) _SAL2_Source_(_Out_writes_to_, (size,count), _Pre_cap_(size) _Post_valid_impl_ _Post_count_(count))
#define _Out_writes_to_opt_(size,count) _SAL2_Source_(_Out_writes_to_opt_, (size,count), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_count_(count))
#define _Out_writes_all_(size) _SAL2_Source_(_Out_writes_all_, (size), _Out_writes_to_(_Old_(size), _Old_(size)))
#define _Out_writes_all_opt_(size) _SAL2_Source_(_Out_writes_all_opt_, (size), _Out_writes_to_opt_(_Old_(size), _Old_(size)))
#define _Out_writes_bytes_to_(size,count) _SAL2_Source_(_Out_writes_bytes_to_, (size,count), _Pre_bytecap_(size) _Post_valid_impl_ _Post_bytecount_(count))
#define _Out_writes_bytes_to_opt_(size,count) _SAL2_Source_(_Out_writes_bytes_to_opt_, (size,count), _Pre_opt_bytecap_(size) _Post_valid_impl_ _Post_bytecount_(count))
#define _Out_writes_bytes_all_(size) _SAL2_Source_(_Out_writes_bytes_all_, (size), _Out_writes_bytes_to_(_Old_(size), _Old_(size)))
#define _Out_writes_bytes_all_opt_(size) _SAL2_Source_(_Out_writes_bytes_all_opt_, (size), _Out_writes_bytes_to_opt_(_Old_(size), _Old_(size)))
#define _Out_writes_to_ptr_(ptr) _SAL2_Source_(_Out_writes_to_ptr_, (ptr), _Pre_ptrdiff_cap_(ptr) _Post_valid_impl_)
#define _Out_writes_to_ptr_opt_(ptr) _SAL2_Source_(_Out_writes_to_ptr_opt_, (ptr), _Pre_opt_ptrdiff_cap_(ptr) _Post_valid_impl_)
#define _Out_writes_to_ptr_z_(ptr) _SAL2_Source_(_Out_writes_to_ptr_z_, (ptr), _Pre_ptrdiff_cap_(ptr) _Post_valid_impl_ Post_z_)
#define _Out_writes_to_ptr_opt_z_(ptr) _SAL2_Source_(_Out_writes_to_ptr_opt_z_, (ptr), _Pre_opt_ptrdiff_cap_(ptr) _Post_valid_impl_ Post_z_)
// Inout parameters ----------------------------
// _Inout_ - Annotations for pointer or reference parameters where data is passed in and
// potentially modified.
// void ModifyPoint( _Inout_ POINT* pPT );
// void ModifyPointByRef( _Inout_ POINT& pPT );
#define _Inout_ _SAL2_Source_(_Inout_, (), _Prepost_valid_)
#define _Inout_opt_ _SAL2_Source_(_Inout_opt_, (), _Prepost_opt_valid_)
// For modifying string buffers
// void toupper( _Inout_z_ char* sz );
#define _Inout_z_ _SAL2_Source_(_Inout_z_, (), _Prepost_z_)
#define _Inout_opt_z_ _SAL2_Source_(_Inout_opt_z_, (), _Prepost_opt_z_)
// For modifying buffers with explicit element size
#define _Inout_updates_(size) _SAL2_Source_(_Inout_updates_, (size), _Pre_cap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_opt_(size) _SAL2_Source_(_Inout_updates_opt_, (size), _Pre_opt_cap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_z_(size) _SAL2_Source_(_Inout_updates_z_, (size), _Pre_cap_(size) _Pre_valid_impl_ _Post_valid_impl_ _Pre1_impl_(__zterm_impl) _Post1_impl_(__zterm_impl))
#define _Inout_updates_opt_z_(size) _SAL2_Source_(_Inout_updates_opt_z_, (size), _Pre_opt_cap_(size) _Pre_valid_impl_ _Post_valid_impl_ _Pre1_impl_(__zterm_impl) _Post1_impl_(__zterm_impl))
#define _Inout_updates_to_(size,count) _SAL2_Source_(_Inout_updates_to_, (size,count), _Out_writes_to_(size,count) _Pre_valid_impl_ _Pre1_impl_(__count_impl(count)))
#define _Inout_updates_to_opt_(size,count) _SAL2_Source_(_Inout_updates_to_opt_, (size,count), _Out_writes_to_opt_(size,count) _Pre_valid_impl_ _Pre1_impl_(__count_impl(count)))
#define _Inout_updates_all_(size) _SAL2_Source_(_Inout_updates_all_, (size), _Inout_updates_to_(_Old_(size), _Old_(size)))
#define _Inout_updates_all_opt_(size) _SAL2_Source_(_Inout_updates_all_opt_, (size), _Inout_updates_to_opt_(_Old_(size), _Old_(size)))
// For modifying buffers with explicit byte size
#define _Inout_updates_bytes_(size) _SAL2_Source_(_Inout_updates_bytes_, (size), _Pre_bytecap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_bytes_opt_(size) _SAL2_Source_(_Inout_updates_bytes_opt_, (size), _Pre_opt_bytecap_(size) _Pre_valid_impl_ _Post_valid_impl_)
#define _Inout_updates_bytes_to_(size,count) _SAL2_Source_(_Inout_updates_bytes_to_, (size,count), _Out_writes_bytes_to_(size,count) _Pre_valid_impl_ _Pre1_impl_(__bytecount_impl(count)))
#define _Inout_updates_bytes_to_opt_(size,count) _SAL2_Source_(_Inout_updates_bytes_to_opt_, (size,count), _Out_writes_bytes_to_opt_(size,count) _Pre_valid_impl_ _Pre1_impl_(__bytecount_impl(count)))
#define _Inout_updates_bytes_all_(size) _SAL2_Source_(_Inout_updates_bytes_all_, (size), _Inout_updates_bytes_to_(_Old_(size), _Old_(size)))
#define _Inout_updates_bytes_all_opt_(size) _SAL2_Source_(_Inout_updates_bytes_all_opt_, (size), _Inout_updates_bytes_to_opt_(_Old_(size), _Old_(size)))
// Pointer to pointer parameters -------------------------
// _Outptr_ - Annotations for output params returning pointers
// These describe parameters where the called function provides the buffer:
// HRESULT SHStrDupW(_In_ LPCWSTR psz, _Outptr_ LPWSTR *ppwsz);
// The caller passes the address of an LPWSTR variable as ppwsz, and SHStrDupW allocates
// and initializes memory and returns the pointer to the new LPWSTR in *ppwsz.
//
// _Outptr_opt_ - describes parameters that are allowed to be NULL.
// _Outptr_*_result_maybenull_ - describes parameters where the called function might return NULL to the caller.
//
// Example:
// void MyFunc(_Outptr_opt_ int **ppData1, _Outptr_result_maybenull_ int **ppData2);
// Callers:
// MyFunc(NULL, NULL); // error: parameter 2, ppData2, should not be NULL
// MyFunc(&pData1, &pData2); // ok: both non-NULL
// if (*pData1 == *pData2) ... // error: pData2 might be NULL after call
#define _Outptr_ _SAL2_Source_(_Outptr_, (), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(1)))
#define _Outptr_result_maybenull_ _SAL2_Source_(_Outptr_result_maybenull_, (), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(1)))
#define _Outptr_opt_ _SAL2_Source_(_Outptr_opt_, (), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(1)))
#define _Outptr_opt_result_maybenull_ _SAL2_Source_(_Outptr_opt_result_maybenull_, (), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(1)))
// Annotations for _Outptr_ parameters returning pointers to null terminated strings.
#define _Outptr_result_z_ _SAL2_Source_(_Outptr_result_z_, (), _Out_impl_ _Deref_post_z_)
#define _Outptr_opt_result_z_ _SAL2_Source_(_Outptr_opt_result_z_, (), _Out_opt_impl_ _Deref_post_z_)
#define _Outptr_result_maybenull_z_ _SAL2_Source_(_Outptr_result_maybenull_z_, (), _Out_impl_ _Deref_post_opt_z_)
#define _Outptr_opt_result_maybenull_z_ _SAL2_Source_(_Outptr_opt_result_maybenull_z_, (), _Out_opt_impl_ _Deref_post_opt_z_)
// Annotations for _Outptr_ parameters where the output pointer is set to NULL if the function fails.
#define _Outptr_result_nullonfailure_ _SAL2_Source_(_Outptr_result_nullonfailure_, (), _Outptr_ _On_failure_(_Deref_post_null_))
#define _Outptr_opt_result_nullonfailure_ _SAL2_Source_(_Outptr_opt_result_nullonfailure_, (), _Outptr_opt_ _On_failure_(_Deref_post_null_))
// Annotations for _Outptr_ parameters which return a pointer to a ref-counted COM object,
// following the COM convention of setting the output to NULL on failure.
// The current implementation is identical to _Outptr_result_nullonfailure_.
// For pointers to types that are not COM objects, _Outptr_result_nullonfailure_ is preferred.
#define _COM_Outptr_ _SAL2_Source_(_COM_Outptr_, (), _Outptr_ _On_failure_(_Deref_post_null_))
#define _COM_Outptr_result_maybenull_ _SAL2_Source_(_COM_Outptr_result_maybenull_, (), _Outptr_result_maybenull_ _On_failure_(_Deref_post_null_))
#define _COM_Outptr_opt_ _SAL2_Source_(_COM_Outptr_opt_, (), _Outptr_opt_ _On_failure_(_Deref_post_null_))
#define _COM_Outptr_opt_result_maybenull_ _SAL2_Source_(_COM_Outptr_opt_result_maybenull_, (), _Outptr_opt_result_maybenull_ _On_failure_(_Deref_post_null_))
// Annotations for _Outptr_ parameters returning a pointer to buffer with a specified number of elements/bytes
#define _Outptr_result_buffer_(size) _SAL2_Source_(_Outptr_result_buffer_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __cap_impl(size)))
#define _Outptr_opt_result_buffer_(size) _SAL2_Source_(_Outptr_opt_result_buffer_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __cap_impl(size)))
#define _Outptr_result_buffer_to_(size, count) _SAL2_Source_(_Outptr_result_buffer_to_, (size, count), _Out_impl_ _Deref_post3_impl_(__notnull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_opt_result_buffer_to_(size, count) _SAL2_Source_(_Outptr_opt_result_buffer_to_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__notnull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_result_buffer_all_(size) _SAL2_Source_(_Outptr_result_buffer_all_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(size)))
#define _Outptr_opt_result_buffer_all_(size) _SAL2_Source_(_Outptr_opt_result_buffer_all_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(size)))
#define _Outptr_result_buffer_maybenull_(size) _SAL2_Source_(_Outptr_result_buffer_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __cap_impl(size)))
#define _Outptr_opt_result_buffer_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_buffer_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __cap_impl(size)))
#define _Outptr_result_buffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_result_buffer_to_maybenull_, (size, count), _Out_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_opt_result_buffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_opt_result_buffer_to_maybenull_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __cap_impl(size), __count_impl(count)))
#define _Outptr_result_buffer_all_maybenull_(size) _SAL2_Source_(_Outptr_result_buffer_all_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(size)))
#define _Outptr_opt_result_buffer_all_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_buffer_all_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(size)))
#define _Outptr_result_bytebuffer_(size) _SAL2_Source_(_Outptr_result_bytebuffer_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecap_impl(size)))
#define _Outptr_opt_result_bytebuffer_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecap_impl(size)))
#define _Outptr_result_bytebuffer_to_(size, count) _SAL2_Source_(_Outptr_result_bytebuffer_to_, (size, count), _Out_impl_ _Deref_post3_impl_(__notnull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_opt_result_bytebuffer_to_(size, count) _SAL2_Source_(_Outptr_opt_result_bytebuffer_to_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__notnull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_result_bytebuffer_all_(size) _SAL2_Source_(_Outptr_result_bytebuffer_all_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecount_impl(size)))
#define _Outptr_opt_result_bytebuffer_all_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_all_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecount_impl(size)))
#define _Outptr_result_bytebuffer_maybenull_(size) _SAL2_Source_(_Outptr_result_bytebuffer_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecap_impl(size)))
#define _Outptr_opt_result_bytebuffer_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecap_impl(size)))
#define _Outptr_result_bytebuffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_result_bytebuffer_to_maybenull_, (size, count), _Out_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_opt_result_bytebuffer_to_maybenull_(size, count) _SAL2_Source_(_Outptr_opt_result_bytebuffer_to_maybenull_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))
#define _Outptr_result_bytebuffer_all_maybenull_(size) _SAL2_Source_(_Outptr_result_bytebuffer_all_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecount_impl(size)))
#define _Outptr_opt_result_bytebuffer_all_maybenull_(size) _SAL2_Source_(_Outptr_opt_result_bytebuffer_all_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecount_impl(size)))
// Annotations for output reference to pointer parameters.
#define _Outref_ _SAL2_Source_(_Outref_, (), _Out_impl_ _Post_notnull_)
#define _Outref_result_maybenull_ _SAL2_Source_(_Outref_result_maybenull_, (), _Pre2_impl_(__notnull_impl_notref, __cap_c_one_notref_impl) _Post_maybenull_ _Post_valid_impl_)
#define _Outref_result_buffer_(size) _SAL2_Source_(_Outref_result_buffer_, (size), _Outref_ _Post1_impl_(__cap_impl(size)))
#define _Outref_result_bytebuffer_(size) _SAL2_Source_(_Outref_result_bytebuffer_, (size), _Outref_ _Post1_impl_(__bytecap_impl(size)))
#define _Outref_result_buffer_to_(size, count) _SAL2_Source_(_Outref_result_buffer_to_, (size, count), _Outref_result_buffer_(size) _Post1_impl_(__count_impl(count)))
#define _Outref_result_bytebuffer_to_(size, count) _SAL2_Source_(_Outref_result_bytebuffer_to_, (size, count), _Outref_result_bytebuffer_(size) _Post1_impl_(__bytecount_impl(count)))
#define _Outref_result_buffer_all_(size) _SAL2_Source_(_Outref_result_buffer_all_, (size), _Outref_result_buffer_to_(size, _Old_(size)))
#define _Outref_result_bytebuffer_all_(size) _SAL2_Source_(_Outref_result_bytebuffer_all_, (size), _Outref_result_bytebuffer_to_(size, _Old_(size)))
#define _Outref_result_buffer_maybenull_(size) _SAL2_Source_(_Outref_result_buffer_maybenull_, (size), _Outref_result_maybenull_ _Post1_impl_(__cap_impl(size)))
#define _Outref_result_bytebuffer_maybenull_(size) _SAL2_Source_(_Outref_result_bytebuffer_maybenull_, (size), _Outref_result_maybenull_ _Post1_impl_(__bytecap_impl(size)))
#define _Outref_result_buffer_to_maybenull_(size, count) _SAL2_Source_(_Outref_result_buffer_to_maybenull_, (size, count), _Outref_result_buffer_maybenull_(size) _Post1_impl_(__count_impl(count)))
#define _Outref_result_bytebuffer_to_maybenull_(size, count) _SAL2_Source_(_Outref_result_bytebuffer_to_maybenull_, (size, count), _Outref_result_bytebuffer_maybenull_(size) _Post1_impl_(__bytecount_impl(count)))
#define _Outref_result_buffer_all_maybenull_(size) _SAL2_Source_(_Outref_result_buffer_all_maybenull_, (size), _Outref_result_buffer_to_maybenull_(size, _Old_(size)))
#define _Outref_result_bytebuffer_all_maybenull_(size) _SAL2_Source_(_Outref_result_bytebuffer_all_maybenull_, (size), _Outref_result_bytebuffer_to_maybenull_(size, _Old_(size)))
// Annotations for output reference to pointer parameters that guarantee
// that the pointer is set to NULL on failure.
#define _Outref_result_nullonfailure_ _SAL2_Source_(_Outref_result_nullonfailure_, (), _Outref_ _On_failure_(_Post_null_))
// Generic annotations to set output value of a by-pointer or by-reference parameter to null/zero on failure.
#define _Result_nullonfailure_ _SAL2_Source_(_Result_nullonfailure_, (), _On_failure_(_Notref_impl_ _Deref_impl_ _Post_null_))
#define _Result_zeroonfailure_ _SAL2_Source_(_Result_zeroonfailure_, (), _On_failure_(_Notref_impl_ _Deref_impl_ _Out_range_(==, 0)))
// return values -------------------------------
//
// _Ret_ annotations
//
// describing conditions that hold for return values after the call
// e.g. _Ret_z_ CString::operator const WCHAR*() const throw();
#define _Ret_z_ _SAL2_Source_(_Ret_z_, (), _Ret2_impl_(__notnull_impl, __zterm_impl) _Ret_valid_impl_)
#define _Ret_maybenull_z_ _SAL2_Source_(_Ret_maybenull_z_, (), _Ret2_impl_(__maybenull_impl,__zterm_impl) _Ret_valid_impl_)
// used with allocated but not yet initialized objects
#define _Ret_notnull_ _SAL2_Source_(_Ret_notnull_, (), _Ret1_impl_(__notnull_impl))
#define _Ret_maybenull_ _SAL2_Source_(_Ret_maybenull_, (), _Ret1_impl_(__maybenull_impl))
#define _Ret_null_ _SAL2_Source_(_Ret_null_, (), _Ret1_impl_(__null_impl))
// used with allocated and initialized objects
// returns single valid object
#define _Ret_valid_ _SAL2_Source_(_Ret_valid_, (), _Ret1_impl_(__notnull_impl_notref) _Ret_valid_impl_)
// returns pointer to initialized buffer of specified size
#define _Ret_writes_(size) _SAL2_Source_(_Ret_writes_, (size), _Ret2_impl_(__notnull_impl, __count_impl(size)) _Ret_valid_impl_)
#define _Ret_writes_z_(size) _SAL2_Source_(_Ret_writes_z_, (size), _Ret3_impl_(__notnull_impl, __count_impl(size), __zterm_impl) _Ret_valid_impl_)
#define _Ret_writes_bytes_(size) _SAL2_Source_(_Ret_writes_bytes_, (size), _Ret2_impl_(__notnull_impl, __bytecount_impl(size)) _Ret_valid_impl_)
#define _Ret_writes_maybenull_(size) _SAL2_Source_(_Ret_writes_maybenull_, (size), _Ret2_impl_(__maybenull_impl,__count_impl(size)) _Ret_valid_impl_)
#define _Ret_writes_maybenull_z_(size) _SAL2_Source_(_Ret_writes_maybenull_z_, (size), _Ret3_impl_(__maybenull_impl,__count_impl(size),__zterm_impl) _Ret_valid_impl_)
#define _Ret_writes_bytes_maybenull_(size) _SAL2_Source_(_Ret_writes_bytes_maybenull_, (size), _Ret2_impl_(__maybenull_impl,__bytecount_impl(size)) _Ret_valid_impl_)
// returns pointer to partially initialized buffer, with total size 'size' and initialized size 'count'
#define _Ret_writes_to_(size,count) _SAL2_Source_(_Ret_writes_to_, (size,count), _Ret3_impl_(__notnull_impl, __cap_impl(size), __count_impl(count)) _Ret_valid_impl_)
#define _Ret_writes_bytes_to_(size,count) _SAL2_Source_(_Ret_writes_bytes_to_, (size,count), _Ret3_impl_(__notnull_impl, __bytecap_impl(size), __bytecount_impl(count)) _Ret_valid_impl_)
#define _Ret_writes_to_maybenull_(size,count) _SAL2_Source_(_Ret_writes_to_maybenull_, (size,count), _Ret3_impl_(__maybenull_impl, __cap_impl(size), __count_impl(count)) _Ret_valid_impl_)
#define _Ret_writes_bytes_to_maybenull_(size,count) _SAL2_Source_(_Ret_writes_bytes_to_maybenull_, (size,count), _Ret3_impl_(__maybenull_impl, __bytecap_impl(size), __bytecount_impl(count)) _Ret_valid_impl_)
// Annotations for strict type checking
#define _Points_to_data_ _SAL2_Source_(_Points_to_data_, (), _Pre_ _Points_to_data_impl_)
#define _Literal_ _SAL2_Source_(_Literal_, (), _Pre_ _Literal_impl_)
#define _Notliteral_ _SAL2_Source_(_Notliteral_, (), _Pre_ _Notliteral_impl_)
// Check the return value of a function e.g. _Check_return_ ErrorCode Foo();
#define _Check_return_ _SAL2_Source_(_Check_return_, (), _Check_return_impl_)
#define _Must_inspect_result_ _SAL2_Source_(_Must_inspect_result_, (), _Must_inspect_impl_ _Check_return_impl_)
// e.g. MyPrintF( _Printf_format_string_ const WCHAR* wzFormat, ... );
#define _Printf_format_string_ _SAL2_Source_(_Printf_format_string_, (), _Printf_format_string_impl_)
#define _Scanf_format_string_ _SAL2_Source_(_Scanf_format_string_, (), _Scanf_format_string_impl_)
#define _Scanf_s_format_string_ _SAL2_Source_(_Scanf_s_format_string_, (), _Scanf_s_format_string_impl_)
#define _Format_string_impl_(kind,where) _SA_annotes2(SAL_IsFormatString2, kind, where)
#define _Printf_format_string_params_(x) _SAL2_Source_(_Printf_format_string_params_, (x), _Format_string_impl_("printf", x))
#define _Scanf_format_string_params_(x) _SAL2_Source_(_Scanf_format_string_params_, (x), _Format_string_impl_("scanf", x))
#define _Scanf_s_format_string_params_(x) _SAL2_Source_(_Scanf_s_format_string_params_, (x), _Format_string_impl_("scanf_s", x))
// annotations to express value of integral or pointer parameter
#define _In_range_(lb,ub) _SAL2_Source_(_In_range_, (lb,ub), _In_range_impl_(lb,ub))
#define _Out_range_(lb,ub) _SAL2_Source_(_Out_range_, (lb,ub), _Out_range_impl_(lb,ub))
#define _Ret_range_(lb,ub) _SAL2_Source_(_Ret_range_, (lb,ub), _Ret_range_impl_(lb,ub))
#define _Deref_in_range_(lb,ub) _SAL2_Source_(_Deref_in_range_, (lb,ub), _Deref_in_range_impl_(lb,ub))
#define _Deref_out_range_(lb,ub) _SAL2_Source_(_Deref_out_range_, (lb,ub), _Deref_out_range_impl_(lb,ub))
#define _Deref_ret_range_(lb,ub) _SAL2_Source_(_Deref_ret_range_, (lb,ub), _Deref_ret_range_impl_(lb,ub))
#define _Pre_equal_to_(expr) _SAL2_Source_(_Pre_equal_to_, (expr), _In_range_(==, expr))
#define _Post_equal_to_(expr) _SAL2_Source_(_Post_equal_to_, (expr), _Out_range_(==, expr))
// annotation to express that a value (usually a field of a mutable class)
// is not changed by a function call
#define _Unchanged_(e) _SAL2_Source_(_Unchanged_, (e), _At_(e, _Post_equal_to_(_Old_(e)) _Const_))
// Annotations to allow expressing generalized pre and post conditions.
// 'cond' may be any valid SAL expression that is considered to be true as a precondition
// or postcondition (respsectively).
#define _Pre_satisfies_(cond) _SAL2_Source_(_Pre_satisfies_, (cond), _Pre_satisfies_impl_(cond))
#define _Post_satisfies_(cond) _SAL2_Source_(_Post_satisfies_, (cond), _Post_satisfies_impl_(cond))
// Annotations to express struct, class and field invariants
#define _Struct_size_bytes_(size) _SAL2_Source_(_Struct_size_bytes_, (size), _Writable_bytes_(size))
#define _Field_size_(size) _SAL2_Source_(_Field_size_, (size), _Notnull_ _Writable_elements_(size))
#define _Field_size_opt_(size) _SAL2_Source_(_Field_size_opt_, (size), _Maybenull_ _Writable_elements_(size))
#define _Field_size_part_(size, count) _SAL2_Source_(_Field_size_part_, (size, count), _Notnull_ _Writable_elements_(size) _Readable_elements_(count))
#define _Field_size_part_opt_(size, count) _SAL2_Source_(_Field_size_part_opt_, (size, count), _Maybenull_ _Writable_elements_(size) _Readable_elements_(count))
#define _Field_size_full_(size) _SAL2_Source_(_Field_size_full_, (size), _Field_size_part_(size, size))
#define _Field_size_full_opt_(size) _SAL2_Source_(_Field_size_full_opt_, (size), _Field_size_part_opt_(size, size))
#define _Field_size_bytes_(size) _SAL2_Source_(_Field_size_bytes_, (size), _Notnull_ _Writable_bytes_(size))
#define _Field_size_bytes_opt_(size) _SAL2_Source_(_Field_size_bytes_opt_, (size), _Maybenull_ _Writable_bytes_(size))
#define _Field_size_bytes_part_(size, count) _SAL2_Source_(_Field_size_bytes_part_, (size, count), _Notnull_ _Writable_bytes_(size) _Readable_bytes_(count))
#define _Field_size_bytes_part_opt_(size, count) _SAL2_Source_(_Field_size_bytes_part_opt_, (size, count), _Maybenull_ _Writable_bytes_(size) _Readable_bytes_(count))
#define _Field_size_bytes_full_(size) _SAL2_Source_(_Field_size_bytes_full_, (size), _Field_size_bytes_part_(size, size))
#define _Field_size_bytes_full_opt_(size) _SAL2_Source_(_Field_size_bytes_full_opt_, (size), _Field_size_bytes_part_opt_(size, size))
#define _Field_z_ _SAL2_Source_(_Field_z_, (), _Null_terminated_)
#define _Field_range_(min,max) _SAL2_Source_(_Field_range_, (min,max), _Field_range_impl_(min,max))
//============================================================================
// _Pre_\_Post_ Layer:
//============================================================================
//
// Raw Pre/Post for declaring custom pre/post conditions
//
#define _Pre_ _Pre_impl_
#define _Post_ _Post_impl_
//
// Validity property
//
#define _Valid_ _Valid_impl_
#define _Notvalid_ _Notvalid_impl_
#define _Maybevalid_ _Maybevalid_impl_
//
// Buffer size properties
//
// Expressing buffer sizes without specifying pre or post condition
#define _Readable_bytes_(size) _SAL2_Source_(_Readable_bytes_, (size), _Readable_bytes_impl_(size))
#define _Readable_elements_(size) _SAL2_Source_(_Readable_elements_, (size), _Readable_elements_impl_(size))
#define _Writable_bytes_(size) _SAL2_Source_(_Writable_bytes_, (size), _Writable_bytes_impl_(size))
#define _Writable_elements_(size) _SAL2_Source_(_Writable_elements_, (size), _Writable_elements_impl_(size))
#define _Null_terminated_ _SAL2_Source_(_Null_terminated_, (), _Null_terminated_impl_)
#define _NullNull_terminated_ _SAL2_Source_(_NullNull_terminated_, (), _NullNull_terminated_impl_)
// Expressing buffer size as pre or post condition
#define _Pre_readable_size_(size) _SAL2_Source_(_Pre_readable_size_, (size), _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Pre_writable_size_(size) _SAL2_Source_(_Pre_writable_size_, (size), _Pre1_impl_(__cap_impl(size)))
#define _Pre_readable_byte_size_(size) _SAL2_Source_(_Pre_readable_byte_size_, (size), _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
#define _Pre_writable_byte_size_(size) _SAL2_Source_(_Pre_writable_byte_size_, (size), _Pre1_impl_(__bytecap_impl(size)))
#define _Post_readable_size_(size) _SAL2_Source_(_Post_readable_size_, (size), _Post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Post_writable_size_(size) _SAL2_Source_(_Post_writable_size_, (size), _Post1_impl_(__cap_impl(size)))
#define _Post_readable_byte_size_(size) _SAL2_Source_(_Post_readable_byte_size_, (size), _Post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
#define _Post_writable_byte_size_(size) _SAL2_Source_(_Post_writable_byte_size_, (size), _Post1_impl_(__bytecap_impl(size)))
//
// Pointer null-ness properties
//
#define _Null_ _Null_impl_
#define _Notnull_ _Notnull_impl_
#define _Maybenull_ _Maybenull_impl_
//
// _Pre_ annotations ---
//
// describing conditions that must be met before the call of the function
// e.g. int strlen( _Pre_z_ const char* sz );
// buffer is a zero terminated string
#define _Pre_z_ _SAL2_Source_(_Pre_z_, (), _Pre1_impl_(__zterm_impl) _Pre_valid_impl_)
// valid size unknown or indicated by type (e.g.:LPSTR)
#define _Pre_valid_ _SAL2_Source_(_Pre_valid_, (), _Pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_)
#define _Pre_opt_valid_ _SAL2_Source_(_Pre_opt_valid_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_)
#define _Pre_invalid_ _SAL2_Source_(_Pre_invalid_, (), _Deref_pre1_impl_(__notvalid_impl))
// Overrides recursive valid when some field is not yet initialized when using _Inout_
#define _Pre_unknown_ _SAL2_Source_(_Pre_unknown_, (), _Pre1_impl_(__maybevalid_impl))
// used with allocated but not yet initialized objects
#define _Pre_notnull_ _SAL2_Source_(_Pre_notnull_, (), _Pre1_impl_(__notnull_impl_notref))
#define _Pre_maybenull_ _SAL2_Source_(_Pre_maybenull_, (), _Pre1_impl_(__maybenull_impl_notref))
#define _Pre_null_ _SAL2_Source_(_Pre_null_, (), _Pre1_impl_(__null_impl_notref))
//
// _Post_ annotations ---
//
// describing conditions that hold after the function call
// void CopyStr( _In_z_ const char* szFrom, _Pre_cap_(cch) _Post_z_ char* szFrom, size_t cchFrom );
// buffer will be a zero-terminated string after the call
#define _Post_z_ _SAL2_Source_(_Post_z_, (), _Post1_impl_(__zterm_impl) _Post_valid_impl_)
// e.g. HRESULT InitStruct( _Post_valid_ Struct* pobj );
#define _Post_valid_ _SAL2_Source_(_Post_valid_, (), _Post_valid_impl_)
#define _Post_invalid_ _SAL2_Source_(_Post_invalid_, (), _Deref_post1_impl_(__notvalid_impl))
// e.g. void free( _Post_ptr_invalid_ void* pv );
#define _Post_ptr_invalid_ _SAL2_Source_(_Post_ptr_invalid_, (), _Post1_impl_(__notvalid_impl))
// e.g. void ThrowExceptionIfNull( _Post_notnull_ const void* pv );
#define _Post_notnull_ _SAL2_Source_(_Post_notnull_, (), _Post1_impl_(__notnull_impl))
// e.g. HRESULT GetObject(_Outptr_ _On_failure_(_At_(*p, _Post_null_)) T **p);
#define _Post_null_ _SAL2_Source_(_Post_null_, (), _Post1_impl_(__null_impl))
#define _Post_maybenull_ _SAL2_Source_(_Post_maybenull_, (), _Post1_impl_(__maybenull_impl))
#define _Prepost_z_ _SAL2_Source_(_Prepost_z_, (), _Pre_z_ _Post_z_)
// #pragma region Input Buffer SAL 1 compatibility macros
/*==========================================================================
This section contains definitions for macros defined for VS2010 and earlier.
Usage of these macros is still supported, but the SAL 2 macros defined above
are recommended instead. This comment block is retained to assist in
understanding SAL that still uses the older syntax.
The macros are defined in 3 layers:
_In_\_Out_ Layer:
----------------
This layer provides the highest abstraction and its macros should be used
in most cases. Its macros start with _In_, _Out_ or _Inout_. For the
typical case they provide the most concise annotations.
_Pre_\_Post_ Layer:
------------------
The macros of this layer only should be used when there is no suitable macro
in the _In_\_Out_ layer. Its macros start with _Pre_, _Post_, _Ret_,
_Deref_pre_ _Deref_post_ and _Deref_ret_. This layer provides the most
flexibility for annotations.
Implementation Abstraction Layer:
--------------------------------
Macros from this layer should never be used directly. The layer only exists
to hide the implementation of the annotation macros.
Annotation Syntax:
|--------------|----------|----------------|-----------------------------|
| Usage | Nullness | ZeroTerminated | Extent |
|--------------|----------|----------------|-----------------------------|
| _In_ | <> | <> | <> |
| _Out_ | opt_ | z_ | [byte]cap_[c_|x_]( size ) |
| _Inout_ | | | [byte]count_[c_|x_]( size ) |
| _Deref_out_ | | | ptrdiff_cap_( ptr ) |
|--------------| | | ptrdiff_count_( ptr ) |
| _Ret_ | | | |
| _Deref_ret_ | | | |
|--------------| | | |
| _Pre_ | | | |
| _Post_ | | | |
| _Deref_pre_ | | | |
| _Deref_post_ | | | |
|--------------|----------|----------------|-----------------------------|
Usage:
-----
_In_, _Out_, _Inout_, _Pre_, _Post_, _Deref_pre_, _Deref_post_ are for
formal parameters.
_Ret_, _Deref_ret_ must be used for return values.
Nullness:
--------
If the pointer can be NULL the annotation contains _opt. If the macro
does not contain '_opt' the pointer may not be NULL.
String Type:
-----------
_z: NullTerminated string
for _In_ parameters the buffer must have the specified stringtype before the call
for _Out_ parameters the buffer must have the specified stringtype after the call
for _Inout_ parameters both conditions apply
Extent Syntax:
|------|---------------|---------------|
| Unit | Writ\Readable | Argument Type |
|------|---------------|---------------|
| <> | cap_ | <> |
| byte | count_ | c_ |
| | | x_ |
|------|---------------|---------------|
'cap' (capacity) describes the writable size of the buffer and is typically used
with _Out_. The default unit is elements. Use 'bytecap' if the size is given in bytes
'count' describes the readable size of the buffer and is typically used with _In_.
The default unit is elements. Use 'bytecount' if the size is given in bytes.
Argument syntax for cap_, bytecap_, count_, bytecount_:
(<parameter>|return)[+n] e.g. cch, return, cb+2
If the buffer size is a constant expression use the c_ postfix.
E.g. cap_c_(20), count_c_(MAX_PATH), bytecount_c_(16)
If the buffer size is given by a limiting pointer use the ptrdiff_ versions
of the macros.
If the buffer size is neither a parameter nor a constant expression use the x_
postfix. e.g. bytecount_x_(num*size) x_ annotations accept any arbitrary string.
No analysis can be done for x_ annotations but they at least tell the tool that
the buffer has some sort of extent description. x_ annotations might be supported
by future compiler versions.
============================================================================*/
// e.g. void SetCharRange( _In_count_(cch) const char* rgch, size_t cch )
// valid buffer extent described by another parameter
#define _In_count_(size) _SAL1_1_Source_(_In_count_, (size), _Pre_count_(size) _Deref_pre_readonly_)
#define _In_opt_count_(size) _SAL1_1_Source_(_In_opt_count_, (size), _Pre_opt_count_(size) _Deref_pre_readonly_)
#define _In_bytecount_(size) _SAL1_1_Source_(_In_bytecount_, (size), _Pre_bytecount_(size) _Deref_pre_readonly_)
#define _In_opt_bytecount_(size) _SAL1_1_Source_(_In_opt_bytecount_, (size), _Pre_opt_bytecount_(size) _Deref_pre_readonly_)
// valid buffer extent described by a constant extression
#define _In_count_c_(size) _SAL1_1_Source_(_In_count_c_, (size), _Pre_count_c_(size) _Deref_pre_readonly_)
#define _In_opt_count_c_(size) _SAL1_1_Source_(_In_opt_count_c_, (size), _Pre_opt_count_c_(size) _Deref_pre_readonly_)
#define _In_bytecount_c_(size) _SAL1_1_Source_(_In_bytecount_c_, (size), _Pre_bytecount_c_(size) _Deref_pre_readonly_)
#define _In_opt_bytecount_c_(size) _SAL1_1_Source_(_In_opt_bytecount_c_, (size), _Pre_opt_bytecount_c_(size) _Deref_pre_readonly_)
// nullterminated 'input' buffers with given size
// e.g. void SetCharRange( _In_count_(cch) const char* rgch, size_t cch )
// nullterminated valid buffer extent described by another parameter
#define _In_z_count_(size) _SAL1_1_Source_(_In_z_count_, (size), _Pre_z_ _Pre_count_(size) _Deref_pre_readonly_)
#define _In_opt_z_count_(size) _SAL1_1_Source_(_In_opt_z_count_, (size), _Pre_opt_z_ _Pre_opt_count_(size) _Deref_pre_readonly_)
#define _In_z_bytecount_(size) _SAL1_1_Source_(_In_z_bytecount_, (size), _Pre_z_ _Pre_bytecount_(size) _Deref_pre_readonly_)
#define _In_opt_z_bytecount_(size) _SAL1_1_Source_(_In_opt_z_bytecount_, (size), _Pre_opt_z_ _Pre_opt_bytecount_(size) _Deref_pre_readonly_)
// nullterminated valid buffer extent described by a constant extression
#define _In_z_count_c_(size) _SAL1_1_Source_(_In_z_count_c_, (size), _Pre_z_ _Pre_count_c_(size) _Deref_pre_readonly_)
#define _In_opt_z_count_c_(size) _SAL1_1_Source_(_In_opt_z_count_c_, (size), _Pre_opt_z_ _Pre_opt_count_c_(size) _Deref_pre_readonly_)
#define _In_z_bytecount_c_(size) _SAL1_1_Source_(_In_z_bytecount_c_, (size), _Pre_z_ _Pre_bytecount_c_(size) _Deref_pre_readonly_)
#define _In_opt_z_bytecount_c_(size) _SAL1_1_Source_(_In_opt_z_bytecount_c_, (size), _Pre_opt_z_ _Pre_opt_bytecount_c_(size) _Deref_pre_readonly_)
// buffer capacity is described by another pointer
// e.g. void Foo( _In_ptrdiff_count_(pchMax) const char* pch, const char* pchMax ) { while pch < pchMax ) pch++; }
#define _In_ptrdiff_count_(size) _SAL1_1_Source_(_In_ptrdiff_count_, (size), _Pre_ptrdiff_count_(size) _Deref_pre_readonly_)
#define _In_opt_ptrdiff_count_(size) _SAL1_1_Source_(_In_opt_ptrdiff_count_, (size), _Pre_opt_ptrdiff_count_(size) _Deref_pre_readonly_)
// 'x' version for complex expressions that are not supported by the current compiler version
// e.g. void Set3ColMatrix( _In_count_x_(3*cRows) const Elem* matrix, int cRows );
#define _In_count_x_(size) _SAL1_1_Source_(_In_count_x_, (size), _Pre_count_x_(size) _Deref_pre_readonly_)
#define _In_opt_count_x_(size) _SAL1_1_Source_(_In_opt_count_x_, (size), _Pre_opt_count_x_(size) _Deref_pre_readonly_)
#define _In_bytecount_x_(size) _SAL1_1_Source_(_In_bytecount_x_, (size), _Pre_bytecount_x_(size) _Deref_pre_readonly_)
#define _In_opt_bytecount_x_(size) _SAL1_1_Source_(_In_opt_bytecount_x_, (size), _Pre_opt_bytecount_x_(size) _Deref_pre_readonly_)
// 'out' with buffer size
// e.g. void GetIndeces( _Out_cap_(cIndeces) int* rgIndeces, size_t cIndices );
// buffer capacity is described by another parameter
#define _Out_cap_(size) _SAL1_1_Source_(_Out_cap_, (size), _Pre_cap_(size) _Post_valid_impl_)
#define _Out_opt_cap_(size) _SAL1_1_Source_(_Out_opt_cap_, (size), _Pre_opt_cap_(size) _Post_valid_impl_)
#define _Out_bytecap_(size) _SAL1_1_Source_(_Out_bytecap_, (size), _Pre_bytecap_(size) _Post_valid_impl_)
#define _Out_opt_bytecap_(size) _SAL1_1_Source_(_Out_opt_bytecap_, (size), _Pre_opt_bytecap_(size) _Post_valid_impl_)
// buffer capacity is described by a constant expression
#define _Out_cap_c_(size) _SAL1_1_Source_(_Out_cap_c_, (size), _Pre_cap_c_(size) _Post_valid_impl_)
#define _Out_opt_cap_c_(size) _SAL1_1_Source_(_Out_opt_cap_c_, (size), _Pre_opt_cap_c_(size) _Post_valid_impl_)
#define _Out_bytecap_c_(size) _SAL1_1_Source_(_Out_bytecap_c_, (size), _Pre_bytecap_c_(size) _Post_valid_impl_)
#define _Out_opt_bytecap_c_(size) _SAL1_1_Source_(_Out_opt_bytecap_c_, (size), _Pre_opt_bytecap_c_(size) _Post_valid_impl_)
// buffer capacity is described by another parameter multiplied by a constant expression
#define _Out_cap_m_(mult,size) _SAL1_1_Source_(_Out_cap_m_, (mult,size), _Pre_cap_m_(mult,size) _Post_valid_impl_)
#define _Out_opt_cap_m_(mult,size) _SAL1_1_Source_(_Out_opt_cap_m_, (mult,size), _Pre_opt_cap_m_(mult,size) _Post_valid_impl_)
#define _Out_z_cap_m_(mult,size) _SAL1_1_Source_(_Out_z_cap_m_, (mult,size), _Pre_cap_m_(mult,size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_m_(mult,size) _SAL1_1_Source_(_Out_opt_z_cap_m_, (mult,size), _Pre_opt_cap_m_(mult,size) _Post_valid_impl_ _Post_z_)
// buffer capacity is described by another pointer
// e.g. void Foo( _Out_ptrdiff_cap_(pchMax) char* pch, const char* pchMax ) { while pch < pchMax ) pch++; }
#define _Out_ptrdiff_cap_(size) _SAL1_1_Source_(_Out_ptrdiff_cap_, (size), _Pre_ptrdiff_cap_(size) _Post_valid_impl_)
#define _Out_opt_ptrdiff_cap_(size) _SAL1_1_Source_(_Out_opt_ptrdiff_cap_, (size), _Pre_opt_ptrdiff_cap_(size) _Post_valid_impl_)
// buffer capacity is described by a complex expression
#define _Out_cap_x_(size) _SAL1_1_Source_(_Out_cap_x_, (size), _Pre_cap_x_(size) _Post_valid_impl_)
#define _Out_opt_cap_x_(size) _SAL1_1_Source_(_Out_opt_cap_x_, (size), _Pre_opt_cap_x_(size) _Post_valid_impl_)
#define _Out_bytecap_x_(size) _SAL1_1_Source_(_Out_bytecap_x_, (size), _Pre_bytecap_x_(size) _Post_valid_impl_)
#define _Out_opt_bytecap_x_(size) _SAL1_1_Source_(_Out_opt_bytecap_x_, (size), _Pre_opt_bytecap_x_(size) _Post_valid_impl_)
// a zero terminated string is filled into a buffer of given capacity
// e.g. void CopyStr( _In_z_ const char* szFrom, _Out_z_cap_(cchTo) char* szTo, size_t cchTo );
// buffer capacity is described by another parameter
#define _Out_z_cap_(size) _SAL1_1_Source_(_Out_z_cap_, (size), _Pre_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_(size) _SAL1_1_Source_(_Out_opt_z_cap_, (size), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_z_bytecap_(size) _SAL1_1_Source_(_Out_z_bytecap_, (size), _Pre_bytecap_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_bytecap_(size) _SAL1_1_Source_(_Out_opt_z_bytecap_, (size), _Pre_opt_bytecap_(size) _Post_valid_impl_ _Post_z_)
// buffer capacity is described by a constant expression
#define _Out_z_cap_c_(size) _SAL1_1_Source_(_Out_z_cap_c_, (size), _Pre_cap_c_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_c_(size) _SAL1_1_Source_(_Out_opt_z_cap_c_, (size), _Pre_opt_cap_c_(size) _Post_valid_impl_ _Post_z_)
#define _Out_z_bytecap_c_(size) _SAL1_1_Source_(_Out_z_bytecap_c_, (size), _Pre_bytecap_c_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Out_opt_z_bytecap_c_, (size), _Pre_opt_bytecap_c_(size) _Post_valid_impl_ _Post_z_)
// buffer capacity is described by a complex expression
#define _Out_z_cap_x_(size) _SAL1_1_Source_(_Out_z_cap_x_, (size), _Pre_cap_x_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_cap_x_(size) _SAL1_1_Source_(_Out_opt_z_cap_x_, (size), _Pre_opt_cap_x_(size) _Post_valid_impl_ _Post_z_)
#define _Out_z_bytecap_x_(size) _SAL1_1_Source_(_Out_z_bytecap_x_, (size), _Pre_bytecap_x_(size) _Post_valid_impl_ _Post_z_)
#define _Out_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Out_opt_z_bytecap_x_, (size), _Pre_opt_bytecap_x_(size) _Post_valid_impl_ _Post_z_)
// a zero terminated string is filled into a buffer of given capacity
// e.g. size_t CopyCharRange( _In_count_(cchFrom) const char* rgchFrom, size_t cchFrom, _Out_cap_post_count_(cchTo,return)) char* rgchTo, size_t cchTo );
#define _Out_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_cap_post_count_, (cap,count), _Pre_cap_(cap) _Post_valid_impl_ _Post_count_(count))
#define _Out_opt_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_opt_cap_post_count_, (cap,count), _Pre_opt_cap_(cap) _Post_valid_impl_ _Post_count_(count))
#define _Out_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_bytecap_post_bytecount_, (cap,count), _Pre_bytecap_(cap) _Post_valid_impl_ _Post_bytecount_(count))
#define _Out_opt_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_opt_bytecap_post_bytecount_, (cap,count), _Pre_opt_bytecap_(cap) _Post_valid_impl_ _Post_bytecount_(count))
// a zero terminated string is filled into a buffer of given capacity
// e.g. size_t CopyStr( _In_z_ const char* szFrom, _Out_z_cap_post_count_(cchTo,return+1) char* szTo, size_t cchTo );
#define _Out_z_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_z_cap_post_count_, (cap,count), _Pre_cap_(cap) _Post_valid_impl_ _Post_z_count_(count))
#define _Out_opt_z_cap_post_count_(cap,count) _SAL1_1_Source_(_Out_opt_z_cap_post_count_, (cap,count), _Pre_opt_cap_(cap) _Post_valid_impl_ _Post_z_count_(count))
#define _Out_z_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_z_bytecap_post_bytecount_, (cap,count), _Pre_bytecap_(cap) _Post_valid_impl_ _Post_z_bytecount_(count))
#define _Out_opt_z_bytecap_post_bytecount_(cap,count) _SAL1_1_Source_(_Out_opt_z_bytecap_post_bytecount_, (cap,count), _Pre_opt_bytecap_(cap) _Post_valid_impl_ _Post_z_bytecount_(count))
// only use with dereferenced arguments e.g. '*pcch'
#define _Out_capcount_(capcount) _SAL1_1_Source_(_Out_capcount_, (capcount), _Pre_cap_(capcount) _Post_valid_impl_ _Post_count_(capcount))
#define _Out_opt_capcount_(capcount) _SAL1_1_Source_(_Out_opt_capcount_, (capcount), _Pre_opt_cap_(capcount) _Post_valid_impl_ _Post_count_(capcount))
#define _Out_bytecapcount_(capcount) _SAL1_1_Source_(_Out_bytecapcount_, (capcount), _Pre_bytecap_(capcount) _Post_valid_impl_ _Post_bytecount_(capcount))
#define _Out_opt_bytecapcount_(capcount) _SAL1_1_Source_(_Out_opt_bytecapcount_, (capcount), _Pre_opt_bytecap_(capcount) _Post_valid_impl_ _Post_bytecount_(capcount))
#define _Out_capcount_x_(capcount) _SAL1_1_Source_(_Out_capcount_x_, (capcount), _Pre_cap_x_(capcount) _Post_valid_impl_ _Post_count_x_(capcount))
#define _Out_opt_capcount_x_(capcount) _SAL1_1_Source_(_Out_opt_capcount_x_, (capcount), _Pre_opt_cap_x_(capcount) _Post_valid_impl_ _Post_count_x_(capcount))
#define _Out_bytecapcount_x_(capcount) _SAL1_1_Source_(_Out_bytecapcount_x_, (capcount), _Pre_bytecap_x_(capcount) _Post_valid_impl_ _Post_bytecount_x_(capcount))
#define _Out_opt_bytecapcount_x_(capcount) _SAL1_1_Source_(_Out_opt_bytecapcount_x_, (capcount), _Pre_opt_bytecap_x_(capcount) _Post_valid_impl_ _Post_bytecount_x_(capcount))
// e.g. GetString( _Out_z_capcount_(*pLen+1) char* sz, size_t* pLen );
#define _Out_z_capcount_(capcount) _SAL1_1_Source_(_Out_z_capcount_, (capcount), _Pre_cap_(capcount) _Post_valid_impl_ _Post_z_count_(capcount))
#define _Out_opt_z_capcount_(capcount) _SAL1_1_Source_(_Out_opt_z_capcount_, (capcount), _Pre_opt_cap_(capcount) _Post_valid_impl_ _Post_z_count_(capcount))
#define _Out_z_bytecapcount_(capcount) _SAL1_1_Source_(_Out_z_bytecapcount_, (capcount), _Pre_bytecap_(capcount) _Post_valid_impl_ _Post_z_bytecount_(capcount))
#define _Out_opt_z_bytecapcount_(capcount) _SAL1_1_Source_(_Out_opt_z_bytecapcount_, (capcount), _Pre_opt_bytecap_(capcount) _Post_valid_impl_ _Post_z_bytecount_(capcount))
// 'inout' buffers with initialized elements before and after the call
// e.g. void ModifyIndices( _Inout_count_(cIndices) int* rgIndeces, size_t cIndices );
#define _Inout_count_(size) _SAL1_1_Source_(_Inout_count_, (size), _Prepost_count_(size))
#define _Inout_opt_count_(size) _SAL1_1_Source_(_Inout_opt_count_, (size), _Prepost_opt_count_(size))
#define _Inout_bytecount_(size) _SAL1_1_Source_(_Inout_bytecount_, (size), _Prepost_bytecount_(size))
#define _Inout_opt_bytecount_(size) _SAL1_1_Source_(_Inout_opt_bytecount_, (size), _Prepost_opt_bytecount_(size))
#define _Inout_count_c_(size) _SAL1_1_Source_(_Inout_count_c_, (size), _Prepost_count_c_(size))
#define _Inout_opt_count_c_(size) _SAL1_1_Source_(_Inout_opt_count_c_, (size), _Prepost_opt_count_c_(size))
#define _Inout_bytecount_c_(size) _SAL1_1_Source_(_Inout_bytecount_c_, (size), _Prepost_bytecount_c_(size))
#define _Inout_opt_bytecount_c_(size) _SAL1_1_Source_(_Inout_opt_bytecount_c_, (size), _Prepost_opt_bytecount_c_(size))
// nullterminated 'inout' buffers with initialized elements before and after the call
// e.g. void ModifyIndices( _Inout_count_(cIndices) int* rgIndeces, size_t cIndices );
#define _Inout_z_count_(size) _SAL1_1_Source_(_Inout_z_count_, (size), _Prepost_z_ _Prepost_count_(size))
#define _Inout_opt_z_count_(size) _SAL1_1_Source_(_Inout_opt_z_count_, (size), _Prepost_z_ _Prepost_opt_count_(size))
#define _Inout_z_bytecount_(size) _SAL1_1_Source_(_Inout_z_bytecount_, (size), _Prepost_z_ _Prepost_bytecount_(size))
#define _Inout_opt_z_bytecount_(size) _SAL1_1_Source_(_Inout_opt_z_bytecount_, (size), _Prepost_z_ _Prepost_opt_bytecount_(size))
#define _Inout_z_count_c_(size) _SAL1_1_Source_(_Inout_z_count_c_, (size), _Prepost_z_ _Prepost_count_c_(size))
#define _Inout_opt_z_count_c_(size) _SAL1_1_Source_(_Inout_opt_z_count_c_, (size), _Prepost_z_ _Prepost_opt_count_c_(size))
#define _Inout_z_bytecount_c_(size) _SAL1_1_Source_(_Inout_z_bytecount_c_, (size), _Prepost_z_ _Prepost_bytecount_c_(size))
#define _Inout_opt_z_bytecount_c_(size) _SAL1_1_Source_(_Inout_opt_z_bytecount_c_, (size), _Prepost_z_ _Prepost_opt_bytecount_c_(size))
#define _Inout_ptrdiff_count_(size) _SAL1_1_Source_(_Inout_ptrdiff_count_, (size), _Pre_ptrdiff_count_(size))
#define _Inout_opt_ptrdiff_count_(size) _SAL1_1_Source_(_Inout_opt_ptrdiff_count_, (size), _Pre_opt_ptrdiff_count_(size))
#define _Inout_count_x_(size) _SAL1_1_Source_(_Inout_count_x_, (size), _Prepost_count_x_(size))
#define _Inout_opt_count_x_(size) _SAL1_1_Source_(_Inout_opt_count_x_, (size), _Prepost_opt_count_x_(size))
#define _Inout_bytecount_x_(size) _SAL1_1_Source_(_Inout_bytecount_x_, (size), _Prepost_bytecount_x_(size))
#define _Inout_opt_bytecount_x_(size) _SAL1_1_Source_(_Inout_opt_bytecount_x_, (size), _Prepost_opt_bytecount_x_(size))
// e.g. void AppendToLPSTR( _In_ LPCSTR szFrom, _Inout_cap_(cchTo) LPSTR* szTo, size_t cchTo );
#define _Inout_cap_(size) _SAL1_1_Source_(_Inout_cap_, (size), _Pre_valid_cap_(size) _Post_valid_)
#define _Inout_opt_cap_(size) _SAL1_1_Source_(_Inout_opt_cap_, (size), _Pre_opt_valid_cap_(size) _Post_valid_)
#define _Inout_bytecap_(size) _SAL1_1_Source_(_Inout_bytecap_, (size), _Pre_valid_bytecap_(size) _Post_valid_)
#define _Inout_opt_bytecap_(size) _SAL1_1_Source_(_Inout_opt_bytecap_, (size), _Pre_opt_valid_bytecap_(size) _Post_valid_)
#define _Inout_cap_c_(size) _SAL1_1_Source_(_Inout_cap_c_, (size), _Pre_valid_cap_c_(size) _Post_valid_)
#define _Inout_opt_cap_c_(size) _SAL1_1_Source_(_Inout_opt_cap_c_, (size), _Pre_opt_valid_cap_c_(size) _Post_valid_)
#define _Inout_bytecap_c_(size) _SAL1_1_Source_(_Inout_bytecap_c_, (size), _Pre_valid_bytecap_c_(size) _Post_valid_)
#define _Inout_opt_bytecap_c_(size) _SAL1_1_Source_(_Inout_opt_bytecap_c_, (size), _Pre_opt_valid_bytecap_c_(size) _Post_valid_)
#define _Inout_cap_x_(size) _SAL1_1_Source_(_Inout_cap_x_, (size), _Pre_valid_cap_x_(size) _Post_valid_)
#define _Inout_opt_cap_x_(size) _SAL1_1_Source_(_Inout_opt_cap_x_, (size), _Pre_opt_valid_cap_x_(size) _Post_valid_)
#define _Inout_bytecap_x_(size) _SAL1_1_Source_(_Inout_bytecap_x_, (size), _Pre_valid_bytecap_x_(size) _Post_valid_)
#define _Inout_opt_bytecap_x_(size) _SAL1_1_Source_(_Inout_opt_bytecap_x_, (size), _Pre_opt_valid_bytecap_x_(size) _Post_valid_)
// inout string buffers with writable size
// e.g. void AppendStr( _In_z_ const char* szFrom, _Inout_z_cap_(cchTo) char* szTo, size_t cchTo );
#define _Inout_z_cap_(size) _SAL1_1_Source_(_Inout_z_cap_, (size), _Pre_z_cap_(size) _Post_z_)
#define _Inout_opt_z_cap_(size) _SAL1_1_Source_(_Inout_opt_z_cap_, (size), _Pre_opt_z_cap_(size) _Post_z_)
#define _Inout_z_bytecap_(size) _SAL1_1_Source_(_Inout_z_bytecap_, (size), _Pre_z_bytecap_(size) _Post_z_)
#define _Inout_opt_z_bytecap_(size) _SAL1_1_Source_(_Inout_opt_z_bytecap_, (size), _Pre_opt_z_bytecap_(size) _Post_z_)
#define _Inout_z_cap_c_(size) _SAL1_1_Source_(_Inout_z_cap_c_, (size), _Pre_z_cap_c_(size) _Post_z_)
#define _Inout_opt_z_cap_c_(size) _SAL1_1_Source_(_Inout_opt_z_cap_c_, (size), _Pre_opt_z_cap_c_(size) _Post_z_)
#define _Inout_z_bytecap_c_(size) _SAL1_1_Source_(_Inout_z_bytecap_c_, (size), _Pre_z_bytecap_c_(size) _Post_z_)
#define _Inout_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Inout_opt_z_bytecap_c_, (size), _Pre_opt_z_bytecap_c_(size) _Post_z_)
#define _Inout_z_cap_x_(size) _SAL1_1_Source_(_Inout_z_cap_x_, (size), _Pre_z_cap_x_(size) _Post_z_)
#define _Inout_opt_z_cap_x_(size) _SAL1_1_Source_(_Inout_opt_z_cap_x_, (size), _Pre_opt_z_cap_x_(size) _Post_z_)
#define _Inout_z_bytecap_x_(size) _SAL1_1_Source_(_Inout_z_bytecap_x_, (size), _Pre_z_bytecap_x_(size) _Post_z_)
#define _Inout_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Inout_opt_z_bytecap_x_, (size), _Pre_opt_z_bytecap_x_(size) _Post_z_)
// returning pointers to valid objects
#define _Ret_ _SAL1_1_Source_(_Ret_, (), _Ret_valid_)
#define _Ret_opt_ _SAL1_1_Source_(_Ret_opt_, (), _Ret_opt_valid_)
// annotations to express 'boundedness' of integral value parameter
#define _In_bound_ _SAL1_1_Source_(_In_bound_, (), _In_bound_impl_)
#define _Out_bound_ _SAL1_1_Source_(_Out_bound_, (), _Out_bound_impl_)
#define _Ret_bound_ _SAL1_1_Source_(_Ret_bound_, (), _Ret_bound_impl_)
#define _Deref_in_bound_ _SAL1_1_Source_(_Deref_in_bound_, (), _Deref_in_bound_impl_)
#define _Deref_out_bound_ _SAL1_1_Source_(_Deref_out_bound_, (), _Deref_out_bound_impl_)
#define _Deref_inout_bound_ _SAL1_1_Source_(_Deref_inout_bound_, (), _Deref_in_bound_ _Deref_out_bound_)
#define _Deref_ret_bound_ _SAL1_1_Source_(_Deref_ret_bound_, (), _Deref_ret_bound_impl_)
// e.g. HRESULT HrCreatePoint( _Deref_out_opt_ POINT** ppPT );
#define _Deref_out_ _SAL1_1_Source_(_Deref_out_, (), _Out_ _Deref_post_valid_)
#define _Deref_out_opt_ _SAL1_1_Source_(_Deref_out_opt_, (), _Out_ _Deref_post_opt_valid_)
#define _Deref_opt_out_ _SAL1_1_Source_(_Deref_opt_out_, (), _Out_opt_ _Deref_post_valid_)
#define _Deref_opt_out_opt_ _SAL1_1_Source_(_Deref_opt_out_opt_, (), _Out_opt_ _Deref_post_opt_valid_)
// e.g. void CloneString( _In_z_ const WCHAR* wzFrom, _Deref_out_z_ WCHAR** pWzTo );
#define _Deref_out_z_ _SAL1_1_Source_(_Deref_out_z_, (), _Out_ _Deref_post_z_)
#define _Deref_out_opt_z_ _SAL1_1_Source_(_Deref_out_opt_z_, (), _Out_ _Deref_post_opt_z_)
#define _Deref_opt_out_z_ _SAL1_1_Source_(_Deref_opt_out_z_, (), _Out_opt_ _Deref_post_z_)
#define _Deref_opt_out_opt_z_ _SAL1_1_Source_(_Deref_opt_out_opt_z_, (), _Out_opt_ _Deref_post_opt_z_)
//
// _Deref_pre_ ---
//
// describing conditions for array elements of dereferenced pointer parameters that must be met before the call
// e.g. void SaveStringArray( _In_count_(cStrings) _Deref_pre_z_ const WCHAR* const rgpwch[] );
#define _Deref_pre_z_ _SAL1_1_Source_(_Deref_pre_z_, (), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__zterm_impl) _Pre_valid_impl_)
#define _Deref_pre_opt_z_ _SAL1_1_Source_(_Deref_pre_opt_z_, (), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__zterm_impl) _Pre_valid_impl_)
// e.g. void FillInArrayOfStr32( _In_count_(cStrings) _Deref_pre_cap_c_(32) _Deref_post_z_ WCHAR* const rgpwch[] );
// buffer capacity is described by another parameter
#define _Deref_pre_cap_(size) _SAL1_1_Source_(_Deref_pre_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)))
#define _Deref_pre_opt_cap_(size) _SAL1_1_Source_(_Deref_pre_opt_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)))
#define _Deref_pre_bytecap_(size) _SAL1_1_Source_(_Deref_pre_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)))
#define _Deref_pre_opt_bytecap_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)))
// buffer capacity is described by a constant expression
#define _Deref_pre_cap_c_(size) _SAL1_1_Source_(_Deref_pre_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)))
#define _Deref_pre_opt_cap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)))
#define _Deref_pre_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)))
#define _Deref_pre_opt_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)))
// buffer capacity is described by a complex condition
#define _Deref_pre_cap_x_(size) _SAL1_1_Source_(_Deref_pre_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)))
#define _Deref_pre_opt_cap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)))
#define _Deref_pre_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)))
#define _Deref_pre_opt_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)))
// convenience macros for nullterminated buffers with given capacity
#define _Deref_pre_z_cap_(size) _SAL1_1_Source_(_Deref_pre_z_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_cap_(size) _SAL1_1_Source_(_Deref_pre_opt_z_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_bytecap_(size) _SAL1_1_Source_(_Deref_pre_z_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_bytecap_(size) _SAL1_1_Source_(_Deref_pre_opt_z_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_cap_c_(size) _SAL1_1_Source_(_Deref_pre_z_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_cap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_z_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_z_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_z_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_cap_x_(size) _SAL1_1_Source_(_Deref_pre_z_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_cap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_z_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_z_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_z_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
// known capacity and valid but unknown readable extent
#define _Deref_pre_valid_cap_(size) _SAL1_1_Source_(_Deref_pre_valid_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_cap_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_bytecap_(size) _SAL1_1_Source_(_Deref_pre_valid_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_bytecap_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_cap_c_(size) _SAL1_1_Source_(_Deref_pre_valid_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_cap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_valid_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_cap_x_(size) _SAL1_1_Source_(_Deref_pre_valid_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_cap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_valid_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
// e.g. void SaveMatrix( _In_count_(n) _Deref_pre_count_(n) const Elem** matrix, size_t n );
// valid buffer extent is described by another parameter
#define _Deref_pre_count_(size) _SAL1_1_Source_(_Deref_pre_count_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_count_(size) _SAL1_1_Source_(_Deref_pre_opt_count_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_bytecount_(size) _SAL1_1_Source_(_Deref_pre_bytecount_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_bytecount_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecount_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
// valid buffer extent is described by a constant expression
#define _Deref_pre_count_c_(size) _SAL1_1_Source_(_Deref_pre_count_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_count_c_(size) _SAL1_1_Source_(_Deref_pre_opt_count_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_bytecount_c_(size) _SAL1_1_Source_(_Deref_pre_bytecount_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_bytecount_c_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecount_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
// valid buffer extent is described by a complex expression
#define _Deref_pre_count_x_(size) _SAL1_1_Source_(_Deref_pre_count_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_count_x_(size) _SAL1_1_Source_(_Deref_pre_opt_count_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_bytecount_x_(size) _SAL1_1_Source_(_Deref_pre_bytecount_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
#define _Deref_pre_opt_bytecount_x_(size) _SAL1_1_Source_(_Deref_pre_opt_bytecount_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
// e.g. void PrintStringArray( _In_count_(cElems) _Deref_pre_valid_ LPCSTR rgStr[], size_t cElems );
#define _Deref_pre_valid_ _SAL1_1_Source_(_Deref_pre_valid_, (), _Deref_pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_)
#define _Deref_pre_opt_valid_ _SAL1_1_Source_(_Deref_pre_opt_valid_, (), _Deref_pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_)
#define _Deref_pre_invalid_ _SAL1_1_Source_(_Deref_pre_invalid_, (), _Deref_pre1_impl_(__notvalid_impl))
#define _Deref_pre_notnull_ _SAL1_1_Source_(_Deref_pre_notnull_, (), _Deref_pre1_impl_(__notnull_impl_notref))
#define _Deref_pre_maybenull_ _SAL1_1_Source_(_Deref_pre_maybenull_, (), _Deref_pre1_impl_(__maybenull_impl_notref))
#define _Deref_pre_null_ _SAL1_1_Source_(_Deref_pre_null_, (), _Deref_pre1_impl_(__null_impl_notref))
// restrict access rights
#define _Deref_pre_readonly_ _SAL1_1_Source_(_Deref_pre_readonly_, (), _Deref_pre1_impl_(__readaccess_impl_notref))
#define _Deref_pre_writeonly_ _SAL1_1_Source_(_Deref_pre_writeonly_, (), _Deref_pre1_impl_(__writeaccess_impl_notref))
//
// _Deref_post_ ---
//
// describing conditions for array elements or dereferenced pointer parameters that hold after the call
// e.g. void CloneString( _In_z_ const Wchar_t* wzIn _Out_ _Deref_post_z_ WCHAR** pWzOut );
#define _Deref_post_z_ _SAL1_1_Source_(_Deref_post_z_, (), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__zterm_impl) _Post_valid_impl_)
#define _Deref_post_opt_z_ _SAL1_1_Source_(_Deref_post_opt_z_, (), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__zterm_impl) _Post_valid_impl_)
// e.g. HRESULT HrAllocateMemory( size_t cb, _Out_ _Deref_post_bytecap_(cb) void** ppv );
// buffer capacity is described by another parameter
#define _Deref_post_cap_(size) _SAL1_1_Source_(_Deref_post_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_impl(size)))
#define _Deref_post_opt_cap_(size) _SAL1_1_Source_(_Deref_post_opt_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_impl(size)))
#define _Deref_post_bytecap_(size) _SAL1_1_Source_(_Deref_post_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)))
#define _Deref_post_opt_bytecap_(size) _SAL1_1_Source_(_Deref_post_opt_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)))
// buffer capacity is described by a constant expression
#define _Deref_post_cap_c_(size) _SAL1_1_Source_(_Deref_post_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)))
#define _Deref_post_opt_cap_c_(size) _SAL1_1_Source_(_Deref_post_opt_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)))
#define _Deref_post_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)))
#define _Deref_post_opt_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_opt_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)))
// buffer capacity is described by a complex expression
#define _Deref_post_cap_x_(size) _SAL1_1_Source_(_Deref_post_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)))
#define _Deref_post_opt_cap_x_(size) _SAL1_1_Source_(_Deref_post_opt_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)))
#define _Deref_post_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)))
#define _Deref_post_opt_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_opt_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)))
// convenience macros for nullterminated buffers with given capacity
#define _Deref_post_z_cap_(size) _SAL1_1_Source_(_Deref_post_z_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_cap_(size) _SAL1_1_Source_(_Deref_post_opt_z_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_bytecap_(size) _SAL1_1_Source_(_Deref_post_z_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_bytecap_(size) _SAL1_1_Source_(_Deref_post_opt_z_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_cap_c_(size) _SAL1_1_Source_(_Deref_post_z_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_cap_c_(size) _SAL1_1_Source_(_Deref_post_opt_z_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_z_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_opt_z_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_cap_x_(size) _SAL1_1_Source_(_Deref_post_z_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_cap_x_(size) _SAL1_1_Source_(_Deref_post_opt_z_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_z_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_opt_z_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Post_valid_impl_)
// known capacity and valid but unknown readable extent
#define _Deref_post_valid_cap_(size) _SAL1_1_Source_(_Deref_post_valid_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_cap_(size) _SAL1_1_Source_(_Deref_post_opt_valid_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_bytecap_(size) _SAL1_1_Source_(_Deref_post_valid_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_bytecap_(size) _SAL1_1_Source_(_Deref_post_opt_valid_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_cap_c_(size) _SAL1_1_Source_(_Deref_post_valid_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_cap_c_(size) _SAL1_1_Source_(_Deref_post_opt_valid_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_valid_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_bytecap_c_(size) _SAL1_1_Source_(_Deref_post_opt_valid_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_cap_x_(size) _SAL1_1_Source_(_Deref_post_valid_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_cap_x_(size) _SAL1_1_Source_(_Deref_post_opt_valid_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_valid_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_post_opt_valid_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)) _Post_valid_impl_)
// e.g. HRESULT HrAllocateZeroInitializedMemory( size_t cb, _Out_ _Deref_post_bytecount_(cb) void** ppv );
// valid buffer extent is described by another parameter
#define _Deref_post_count_(size) _SAL1_1_Source_(_Deref_post_count_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_count_(size) _SAL1_1_Source_(_Deref_post_opt_count_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Deref_post_bytecount_(size) _SAL1_1_Source_(_Deref_post_bytecount_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_bytecount_(size) _SAL1_1_Source_(_Deref_post_opt_bytecount_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
// buffer capacity is described by a constant expression
#define _Deref_post_count_c_(size) _SAL1_1_Source_(_Deref_post_count_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_count_c_(size) _SAL1_1_Source_(_Deref_post_opt_count_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_bytecount_c_(size) _SAL1_1_Source_(_Deref_post_bytecount_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_bytecount_c_(size) _SAL1_1_Source_(_Deref_post_opt_bytecount_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)
// buffer capacity is described by a complex expression
#define _Deref_post_count_x_(size) _SAL1_1_Source_(_Deref_post_count_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_count_x_(size) _SAL1_1_Source_(_Deref_post_opt_count_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_bytecount_x_(size) _SAL1_1_Source_(_Deref_post_bytecount_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)
#define _Deref_post_opt_bytecount_x_(size) _SAL1_1_Source_(_Deref_post_opt_bytecount_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)
// e.g. void GetStrings( _Out_count_(cElems) _Deref_post_valid_ LPSTR const rgStr[], size_t cElems );
#define _Deref_post_valid_ _SAL1_1_Source_(_Deref_post_valid_, (), _Deref_post1_impl_(__notnull_impl_notref) _Post_valid_impl_)
#define _Deref_post_opt_valid_ _SAL1_1_Source_(_Deref_post_opt_valid_, (), _Deref_post1_impl_(__maybenull_impl_notref) _Post_valid_impl_)
#define _Deref_post_notnull_ _SAL1_1_Source_(_Deref_post_notnull_, (), _Deref_post1_impl_(__notnull_impl_notref))
#define _Deref_post_maybenull_ _SAL1_1_Source_(_Deref_post_maybenull_, (), _Deref_post1_impl_(__maybenull_impl_notref))
#define _Deref_post_null_ _SAL1_1_Source_(_Deref_post_null_, (), _Deref_post1_impl_(__null_impl_notref))
//
// _Deref_ret_ ---
//
#define _Deref_ret_z_ _SAL1_1_Source_(_Deref_ret_z_, (), _Deref_ret1_impl_(__notnull_impl_notref) _Deref_ret1_impl_(__zterm_impl))
#define _Deref_ret_opt_z_ _SAL1_1_Source_(_Deref_ret_opt_z_, (), _Deref_ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__zterm_impl))
//
// special _Deref_ ---
//
#define _Deref2_pre_readonly_ _SAL1_1_Source_(_Deref2_pre_readonly_, (), _Deref2_pre1_impl_(__readaccess_impl_notref))
//
// _Ret_ ---
//
// e.g. _Ret_opt_valid_ LPSTR void* CloneSTR( _Pre_valid_ LPSTR src );
#define _Ret_opt_valid_ _SAL1_1_Source_(_Ret_opt_valid_, (), _Ret1_impl_(__maybenull_impl_notref) _Ret_valid_impl_)
#define _Ret_opt_z_ _SAL1_1_Source_(_Ret_opt_z_, (), _Ret2_impl_(__maybenull_impl,__zterm_impl) _Ret_valid_impl_)
// e.g. _Ret_opt_bytecap_(cb) void* AllocateMemory( size_t cb );
// Buffer capacity is described by another parameter
#define _Ret_cap_(size) _SAL1_1_Source_(_Ret_cap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_impl(size)))
#define _Ret_opt_cap_(size) _SAL1_1_Source_(_Ret_opt_cap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_impl(size)))
#define _Ret_bytecap_(size) _SAL1_1_Source_(_Ret_bytecap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_impl(size)))
#define _Ret_opt_bytecap_(size) _SAL1_1_Source_(_Ret_opt_bytecap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_impl(size)))
// Buffer capacity is described by a constant expression
#define _Ret_cap_c_(size) _SAL1_1_Source_(_Ret_cap_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_c_impl(size)))
#define _Ret_opt_cap_c_(size) _SAL1_1_Source_(_Ret_opt_cap_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_c_impl(size)))
#define _Ret_bytecap_c_(size) _SAL1_1_Source_(_Ret_bytecap_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_c_impl(size)))
#define _Ret_opt_bytecap_c_(size) _SAL1_1_Source_(_Ret_opt_bytecap_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_c_impl(size)))
// Buffer capacity is described by a complex condition
#define _Ret_cap_x_(size) _SAL1_1_Source_(_Ret_cap_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_x_impl(size)))
#define _Ret_opt_cap_x_(size) _SAL1_1_Source_(_Ret_opt_cap_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_x_impl(size)))
#define _Ret_bytecap_x_(size) _SAL1_1_Source_(_Ret_bytecap_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_x_impl(size)))
#define _Ret_opt_bytecap_x_(size) _SAL1_1_Source_(_Ret_opt_bytecap_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_x_impl(size)))
// return value is nullterminated and capacity is given by another parameter
#define _Ret_z_cap_(size) _SAL1_1_Source_(_Ret_z_cap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__cap_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_cap_(size) _SAL1_1_Source_(_Ret_opt_z_cap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__cap_impl(size)) _Ret_valid_impl_)
#define _Ret_z_bytecap_(size) _SAL1_1_Source_(_Ret_z_bytecap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecap_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_bytecap_(size) _SAL1_1_Source_(_Ret_opt_z_bytecap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecap_impl(size)) _Ret_valid_impl_)
// e.g. _Ret_opt_bytecount_(cb) void* AllocateZeroInitializedMemory( size_t cb );
// Valid Buffer extent is described by another parameter
#define _Ret_count_(size) _SAL1_1_Source_(_Ret_count_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_count_(size) _SAL1_1_Source_(_Ret_opt_count_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_impl(size)) _Ret_valid_impl_)
#define _Ret_bytecount_(size) _SAL1_1_Source_(_Ret_bytecount_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_bytecount_(size) _SAL1_1_Source_(_Ret_opt_bytecount_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_impl(size)) _Ret_valid_impl_)
// Valid Buffer extent is described by a constant expression
#define _Ret_count_c_(size) _SAL1_1_Source_(_Ret_count_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_c_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_count_c_(size) _SAL1_1_Source_(_Ret_opt_count_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_c_impl(size)) _Ret_valid_impl_)
#define _Ret_bytecount_c_(size) _SAL1_1_Source_(_Ret_bytecount_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_c_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_bytecount_c_(size) _SAL1_1_Source_(_Ret_opt_bytecount_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_c_impl(size)) _Ret_valid_impl_)
// Valid Buffer extent is described by a complex expression
#define _Ret_count_x_(size) _SAL1_1_Source_(_Ret_count_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_x_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_count_x_(size) _SAL1_1_Source_(_Ret_opt_count_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_x_impl(size)) _Ret_valid_impl_)
#define _Ret_bytecount_x_(size) _SAL1_1_Source_(_Ret_bytecount_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_x_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_bytecount_x_(size) _SAL1_1_Source_(_Ret_opt_bytecount_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_x_impl(size)) _Ret_valid_impl_)
// return value is nullterminated and length is given by another parameter
#define _Ret_z_count_(size) _SAL1_1_Source_(_Ret_z_count_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__count_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_count_(size) _SAL1_1_Source_(_Ret_opt_z_count_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__count_impl(size)) _Ret_valid_impl_)
#define _Ret_z_bytecount_(size) _SAL1_1_Source_(_Ret_z_bytecount_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecount_impl(size)) _Ret_valid_impl_)
#define _Ret_opt_z_bytecount_(size) _SAL1_1_Source_(_Ret_opt_z_bytecount_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecount_impl(size)) _Ret_valid_impl_)
// _Pre_ annotations ---
#define _Pre_opt_z_ _SAL1_1_Source_(_Pre_opt_z_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__zterm_impl) _Pre_valid_impl_)
// restrict access rights
#define _Pre_readonly_ _SAL1_1_Source_(_Pre_readonly_, (), _Pre1_impl_(__readaccess_impl_notref))
#define _Pre_writeonly_ _SAL1_1_Source_(_Pre_writeonly_, (), _Pre1_impl_(__writeaccess_impl_notref))
// e.g. void FreeMemory( _Pre_bytecap_(cb) _Post_ptr_invalid_ void* pv, size_t cb );
// buffer capacity described by another parameter
#define _Pre_cap_(size) _SAL1_1_Source_(_Pre_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_impl(size)))
#define _Pre_opt_cap_(size) _SAL1_1_Source_(_Pre_opt_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_impl(size)))
#define _Pre_bytecap_(size) _SAL1_1_Source_(_Pre_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_impl(size)))
#define _Pre_opt_bytecap_(size) _SAL1_1_Source_(_Pre_opt_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_impl(size)))
// buffer capacity described by a constant expression
#define _Pre_cap_c_(size) _SAL1_1_Source_(_Pre_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_impl(size)))
#define _Pre_opt_cap_c_(size) _SAL1_1_Source_(_Pre_opt_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_impl(size)))
#define _Pre_bytecap_c_(size) _SAL1_1_Source_(_Pre_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)))
#define _Pre_opt_bytecap_c_(size) _SAL1_1_Source_(_Pre_opt_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)))
#define _Pre_cap_c_one_ _SAL1_1_Source_(_Pre_cap_c_one_, (), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl))
#define _Pre_opt_cap_c_one_ _SAL1_1_Source_(_Pre_opt_cap_c_one_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl))
// buffer capacity is described by another parameter multiplied by a constant expression
#define _Pre_cap_m_(mult,size) _SAL1_1_Source_(_Pre_cap_m_, (mult,size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__mult_impl(mult,size)))
#define _Pre_opt_cap_m_(mult,size) _SAL1_1_Source_(_Pre_opt_cap_m_, (mult,size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__mult_impl(mult,size)))
// buffer capacity described by size of other buffer, only used by dangerous legacy APIs
// e.g. int strcpy(_Pre_cap_for_(src) char* dst, const char* src);
#define _Pre_cap_for_(param) _SAL1_1_Source_(_Pre_cap_for_, (param), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_for_impl(param)))
#define _Pre_opt_cap_for_(param) _SAL1_1_Source_(_Pre_opt_cap_for_, (param), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_for_impl(param)))
// buffer capacity described by a complex condition
#define _Pre_cap_x_(size) _SAL1_1_Source_(_Pre_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(size)))
#define _Pre_opt_cap_x_(size) _SAL1_1_Source_(_Pre_opt_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(size)))
#define _Pre_bytecap_x_(size) _SAL1_1_Source_(_Pre_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)))
#define _Pre_opt_bytecap_x_(size) _SAL1_1_Source_(_Pre_opt_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)))
// buffer capacity described by the difference to another pointer parameter
#define _Pre_ptrdiff_cap_(ptr) _SAL1_1_Source_(_Pre_ptrdiff_cap_, (ptr), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(__ptrdiff(ptr))))
#define _Pre_opt_ptrdiff_cap_(ptr) _SAL1_1_Source_(_Pre_opt_ptrdiff_cap_, (ptr), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(__ptrdiff(ptr))))
// e.g. void AppendStr( _Pre_z_ const char* szFrom, _Pre_z_cap_(cchTo) _Post_z_ char* szTo, size_t cchTo );
#define _Pre_z_cap_(size) _SAL1_1_Source_(_Pre_z_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_cap_(size) _SAL1_1_Source_(_Pre_opt_z_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_z_bytecap_(size) _SAL1_1_Source_(_Pre_z_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_bytecap_(size) _SAL1_1_Source_(_Pre_opt_z_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_z_cap_c_(size) _SAL1_1_Source_(_Pre_z_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_cap_c_(size) _SAL1_1_Source_(_Pre_opt_z_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_z_bytecap_c_(size) _SAL1_1_Source_(_Pre_z_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_bytecap_c_(size) _SAL1_1_Source_(_Pre_opt_z_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_z_cap_x_(size) _SAL1_1_Source_(_Pre_z_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_cap_x_(size) _SAL1_1_Source_(_Pre_opt_z_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_z_bytecap_x_(size) _SAL1_1_Source_(_Pre_z_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_z_bytecap_x_(size) _SAL1_1_Source_(_Pre_opt_z_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)
// known capacity and valid but unknown readable extent
#define _Pre_valid_cap_(size) _SAL1_1_Source_(_Pre_valid_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_cap_(size) _SAL1_1_Source_(_Pre_opt_valid_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_bytecap_(size) _SAL1_1_Source_(_Pre_valid_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_bytecap_(size) _SAL1_1_Source_(_Pre_opt_valid_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_cap_c_(size) _SAL1_1_Source_(_Pre_valid_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_cap_c_(size) _SAL1_1_Source_(_Pre_opt_valid_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_bytecap_c_(size) _SAL1_1_Source_(_Pre_valid_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_bytecap_c_(size) _SAL1_1_Source_(_Pre_opt_valid_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_cap_x_(size) _SAL1_1_Source_(_Pre_valid_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_cap_x_(size) _SAL1_1_Source_(_Pre_opt_valid_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_valid_bytecap_x_(size) _SAL1_1_Source_(_Pre_valid_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Pre_opt_valid_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)
// e.g. void AppendCharRange( _Pre_count_(cchFrom) const char* rgFrom, size_t cchFrom, _Out_z_cap_(cchTo) char* szTo, size_t cchTo );
// Valid buffer extent described by another parameter
#define _Pre_count_(size) _SAL1_1_Source_(_Pre_count_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_count_(size) _SAL1_1_Source_(_Pre_opt_count_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)
#define _Pre_bytecount_(size) _SAL1_1_Source_(_Pre_bytecount_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_bytecount_(size) _SAL1_1_Source_(_Pre_opt_bytecount_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)
// Valid buffer extent described by a constant expression
#define _Pre_count_c_(size) _SAL1_1_Source_(_Pre_count_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_count_c_(size) _SAL1_1_Source_(_Pre_opt_count_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)
#define _Pre_bytecount_c_(size) _SAL1_1_Source_(_Pre_bytecount_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_bytecount_c_(size) _SAL1_1_Source_(_Pre_opt_bytecount_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)
// Valid buffer extent described by a complex expression
#define _Pre_count_x_(size) _SAL1_1_Source_(_Pre_count_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_count_x_(size) _SAL1_1_Source_(_Pre_opt_count_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)
#define _Pre_bytecount_x_(size) _SAL1_1_Source_(_Pre_bytecount_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
#define _Pre_opt_bytecount_x_(size) _SAL1_1_Source_(_Pre_opt_bytecount_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)
// Valid buffer extent described by the difference to another pointer parameter
#define _Pre_ptrdiff_count_(ptr) _SAL1_1_Source_(_Pre_ptrdiff_count_, (ptr), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_x_impl(__ptrdiff(ptr))) _Pre_valid_impl_)
#define _Pre_opt_ptrdiff_count_(ptr) _SAL1_1_Source_(_Pre_opt_ptrdiff_count_, (ptr), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_x_impl(__ptrdiff(ptr))) _Pre_valid_impl_)
// char * strncpy(_Out_cap_(_Count) _Post_maybez_ char * _Dest, _In_z_ const char * _Source, _In_ size_t _Count)
// buffer maybe zero-terminated after the call
#define _Post_maybez_ _SAL1_1_Source_(_Post_maybez_, (), _Post1_impl_(__maybezterm_impl))
// e.g. SIZE_T HeapSize( _In_ HANDLE hHeap, DWORD dwFlags, _Pre_notnull_ _Post_bytecap_(return) LPCVOID lpMem );
#define _Post_cap_(size) _SAL1_1_Source_(_Post_cap_, (size), _Post1_impl_(__cap_impl(size)))
#define _Post_bytecap_(size) _SAL1_1_Source_(_Post_bytecap_, (size), _Post1_impl_(__bytecap_impl(size)))
// e.g. int strlen( _In_z_ _Post_count_(return+1) const char* sz );
#define _Post_count_(size) _SAL1_1_Source_(_Post_count_, (size), _Post1_impl_(__count_impl(size)) _Post_valid_impl_)
#define _Post_bytecount_(size) _SAL1_1_Source_(_Post_bytecount_, (size), _Post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)
#define _Post_count_c_(size) _SAL1_1_Source_(_Post_count_c_, (size), _Post1_impl_(__count_c_impl(size)) _Post_valid_impl_)
#define _Post_bytecount_c_(size) _SAL1_1_Source_(_Post_bytecount_c_, (size), _Post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)
#define _Post_count_x_(size) _SAL1_1_Source_(_Post_count_x_, (size), _Post1_impl_(__count_x_impl(size)) _Post_valid_impl_)
#define _Post_bytecount_x_(size) _SAL1_1_Source_(_Post_bytecount_x_, (size), _Post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)
// e.g. size_t CopyStr( _In_z_ const char* szFrom, _Pre_cap_(cch) _Post_z_count_(return+1) char* szFrom, size_t cchFrom );
#define _Post_z_count_(size) _SAL1_1_Source_(_Post_z_count_, (size), _Post2_impl_(__zterm_impl,__count_impl(size)) _Post_valid_impl_)
#define _Post_z_bytecount_(size) _SAL1_1_Source_(_Post_z_bytecount_, (size), _Post2_impl_(__zterm_impl,__bytecount_impl(size)) _Post_valid_impl_)
#define _Post_z_count_c_(size) _SAL1_1_Source_(_Post_z_count_c_, (size), _Post2_impl_(__zterm_impl,__count_c_impl(size)) _Post_valid_impl_)
#define _Post_z_bytecount_c_(size) _SAL1_1_Source_(_Post_z_bytecount_c_, (size), _Post2_impl_(__zterm_impl,__bytecount_c_impl(size)) _Post_valid_impl_)
#define _Post_z_count_x_(size) _SAL1_1_Source_(_Post_z_count_x_, (size), _Post2_impl_(__zterm_impl,__count_x_impl(size)) _Post_valid_impl_)
#define _Post_z_bytecount_x_(size) _SAL1_1_Source_(_Post_z_bytecount_x_, (size), _Post2_impl_(__zterm_impl,__bytecount_x_impl(size)) _Post_valid_impl_)
//
// _Prepost_ ---
//
// describing conditions that hold before and after the function call
#define _Prepost_opt_z_ _SAL1_1_Source_(_Prepost_opt_z_, (), _Pre_opt_z_ _Post_z_)
#define _Prepost_count_(size) _SAL1_1_Source_(_Prepost_count_, (size), _Pre_count_(size) _Post_count_(size))
#define _Prepost_opt_count_(size) _SAL1_1_Source_(_Prepost_opt_count_, (size), _Pre_opt_count_(size) _Post_count_(size))
#define _Prepost_bytecount_(size) _SAL1_1_Source_(_Prepost_bytecount_, (size), _Pre_bytecount_(size) _Post_bytecount_(size))
#define _Prepost_opt_bytecount_(size) _SAL1_1_Source_(_Prepost_opt_bytecount_, (size), _Pre_opt_bytecount_(size) _Post_bytecount_(size))
#define _Prepost_count_c_(size) _SAL1_1_Source_(_Prepost_count_c_, (size), _Pre_count_c_(size) _Post_count_c_(size))
#define _Prepost_opt_count_c_(size) _SAL1_1_Source_(_Prepost_opt_count_c_, (size), _Pre_opt_count_c_(size) _Post_count_c_(size))
#define _Prepost_bytecount_c_(size) _SAL1_1_Source_(_Prepost_bytecount_c_, (size), _Pre_bytecount_c_(size) _Post_bytecount_c_(size))
#define _Prepost_opt_bytecount_c_(size) _SAL1_1_Source_(_Prepost_opt_bytecount_c_, (size), _Pre_opt_bytecount_c_(size) _Post_bytecount_c_(size))
#define _Prepost_count_x_(size) _SAL1_1_Source_(_Prepost_count_x_, (size), _Pre_count_x_(size) _Post_count_x_(size))
#define _Prepost_opt_count_x_(size) _SAL1_1_Source_(_Prepost_opt_count_x_, (size), _Pre_opt_count_x_(size) _Post_count_x_(size))
#define _Prepost_bytecount_x_(size) _SAL1_1_Source_(_Prepost_bytecount_x_, (size), _Pre_bytecount_x_(size) _Post_bytecount_x_(size))
#define _Prepost_opt_bytecount_x_(size) _SAL1_1_Source_(_Prepost_opt_bytecount_x_, (size), _Pre_opt_bytecount_x_(size) _Post_bytecount_x_(size))
#define _Prepost_valid_ _SAL1_1_Source_(_Prepost_valid_, (), _Pre_valid_ _Post_valid_)
#define _Prepost_opt_valid_ _SAL1_1_Source_(_Prepost_opt_valid_, (), _Pre_opt_valid_ _Post_valid_)
//
// _Deref_<both> ---
//
// short version for _Deref_pre_<ann> _Deref_post_<ann>
// describing conditions for array elements or dereferenced pointer parameters that hold before and after the call
#define _Deref_prepost_z_ _SAL1_1_Source_(_Deref_prepost_z_, (), _Deref_pre_z_ _Deref_post_z_)
#define _Deref_prepost_opt_z_ _SAL1_1_Source_(_Deref_prepost_opt_z_, (), _Deref_pre_opt_z_ _Deref_post_opt_z_)
#define _Deref_prepost_cap_(size) _SAL1_1_Source_(_Deref_prepost_cap_, (size), _Deref_pre_cap_(size) _Deref_post_cap_(size))
#define _Deref_prepost_opt_cap_(size) _SAL1_1_Source_(_Deref_prepost_opt_cap_, (size), _Deref_pre_opt_cap_(size) _Deref_post_opt_cap_(size))
#define _Deref_prepost_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_bytecap_, (size), _Deref_pre_bytecap_(size) _Deref_post_bytecap_(size))
#define _Deref_prepost_opt_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecap_, (size), _Deref_pre_opt_bytecap_(size) _Deref_post_opt_bytecap_(size))
#define _Deref_prepost_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_cap_x_, (size), _Deref_pre_cap_x_(size) _Deref_post_cap_x_(size))
#define _Deref_prepost_opt_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_cap_x_, (size), _Deref_pre_opt_cap_x_(size) _Deref_post_opt_cap_x_(size))
#define _Deref_prepost_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_bytecap_x_, (size), _Deref_pre_bytecap_x_(size) _Deref_post_bytecap_x_(size))
#define _Deref_prepost_opt_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecap_x_, (size), _Deref_pre_opt_bytecap_x_(size) _Deref_post_opt_bytecap_x_(size))
#define _Deref_prepost_z_cap_(size) _SAL1_1_Source_(_Deref_prepost_z_cap_, (size), _Deref_pre_z_cap_(size) _Deref_post_z_cap_(size))
#define _Deref_prepost_opt_z_cap_(size) _SAL1_1_Source_(_Deref_prepost_opt_z_cap_, (size), _Deref_pre_opt_z_cap_(size) _Deref_post_opt_z_cap_(size))
#define _Deref_prepost_z_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_z_bytecap_, (size), _Deref_pre_z_bytecap_(size) _Deref_post_z_bytecap_(size))
#define _Deref_prepost_opt_z_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_opt_z_bytecap_, (size), _Deref_pre_opt_z_bytecap_(size) _Deref_post_opt_z_bytecap_(size))
#define _Deref_prepost_valid_cap_(size) _SAL1_1_Source_(_Deref_prepost_valid_cap_, (size), _Deref_pre_valid_cap_(size) _Deref_post_valid_cap_(size))
#define _Deref_prepost_opt_valid_cap_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_cap_, (size), _Deref_pre_opt_valid_cap_(size) _Deref_post_opt_valid_cap_(size))
#define _Deref_prepost_valid_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_valid_bytecap_, (size), _Deref_pre_valid_bytecap_(size) _Deref_post_valid_bytecap_(size))
#define _Deref_prepost_opt_valid_bytecap_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_bytecap_, (size), _Deref_pre_opt_valid_bytecap_(size) _Deref_post_opt_valid_bytecap_(size))
#define _Deref_prepost_valid_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_valid_cap_x_, (size), _Deref_pre_valid_cap_x_(size) _Deref_post_valid_cap_x_(size))
#define _Deref_prepost_opt_valid_cap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_cap_x_, (size), _Deref_pre_opt_valid_cap_x_(size) _Deref_post_opt_valid_cap_x_(size))
#define _Deref_prepost_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_valid_bytecap_x_, (size), _Deref_pre_valid_bytecap_x_(size) _Deref_post_valid_bytecap_x_(size))
#define _Deref_prepost_opt_valid_bytecap_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_valid_bytecap_x_, (size), _Deref_pre_opt_valid_bytecap_x_(size) _Deref_post_opt_valid_bytecap_x_(size))
#define _Deref_prepost_count_(size) _SAL1_1_Source_(_Deref_prepost_count_, (size), _Deref_pre_count_(size) _Deref_post_count_(size))
#define _Deref_prepost_opt_count_(size) _SAL1_1_Source_(_Deref_prepost_opt_count_, (size), _Deref_pre_opt_count_(size) _Deref_post_opt_count_(size))
#define _Deref_prepost_bytecount_(size) _SAL1_1_Source_(_Deref_prepost_bytecount_, (size), _Deref_pre_bytecount_(size) _Deref_post_bytecount_(size))
#define _Deref_prepost_opt_bytecount_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecount_, (size), _Deref_pre_opt_bytecount_(size) _Deref_post_opt_bytecount_(size))
#define _Deref_prepost_count_x_(size) _SAL1_1_Source_(_Deref_prepost_count_x_, (size), _Deref_pre_count_x_(size) _Deref_post_count_x_(size))
#define _Deref_prepost_opt_count_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_count_x_, (size), _Deref_pre_opt_count_x_(size) _Deref_post_opt_count_x_(size))
#define _Deref_prepost_bytecount_x_(size) _SAL1_1_Source_(_Deref_prepost_bytecount_x_, (size), _Deref_pre_bytecount_x_(size) _Deref_post_bytecount_x_(size))
#define _Deref_prepost_opt_bytecount_x_(size) _SAL1_1_Source_(_Deref_prepost_opt_bytecount_x_, (size), _Deref_pre_opt_bytecount_x_(size) _Deref_post_opt_bytecount_x_(size))
#define _Deref_prepost_valid_ _SAL1_1_Source_(_Deref_prepost_valid_, (), _Deref_pre_valid_ _Deref_post_valid_)
#define _Deref_prepost_opt_valid_ _SAL1_1_Source_(_Deref_prepost_opt_valid_, (), _Deref_pre_opt_valid_ _Deref_post_opt_valid_)
//
// _Deref_<miscellaneous>
//
// used with references to arrays
#define _Deref_out_z_cap_c_(size) _SAL1_1_Source_(_Deref_out_z_cap_c_, (size), _Deref_pre_cap_c_(size) _Deref_post_z_)
#define _Deref_inout_z_cap_c_(size) _SAL1_1_Source_(_Deref_inout_z_cap_c_, (size), _Deref_pre_z_cap_c_(size) _Deref_post_z_)
#define _Deref_out_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_out_z_bytecap_c_, (size), _Deref_pre_bytecap_c_(size) _Deref_post_z_)
#define _Deref_inout_z_bytecap_c_(size) _SAL1_1_Source_(_Deref_inout_z_bytecap_c_, (size), _Deref_pre_z_bytecap_c_(size) _Deref_post_z_)
#define _Deref_inout_z_ _SAL1_1_Source_(_Deref_inout_z_, (), _Deref_prepost_z_)
// #pragma endregion Input Buffer SAL 1 compatibility macros
//============================================================================
// Implementation Layer:
//============================================================================
// Naming conventions:
// A symbol the begins with _SA_ is for the machinery of creating any
// annotations; many of those come from sourceannotations.h in the case
// of attributes.
// A symbol that ends with _impl is the very lowest level macro. It is
// not required to be a legal standalone annotation, and in the case
// of attribute annotations, usually is not. (In the case of some declspec
// annotations, it might be, but it should not be assumed so.) Those
// symols will be used in the _PreN..., _PostN... and _RetN... annotations
// to build up more complete annotations.
// A symbol ending in _impl_ is reserved to the implementation as well,
// but it does form a complete annotation; usually they are used to build
// up even higher level annotations.
#if _USE_ATTRIBUTES_FOR_SAL || _USE_DECLSPECS_FOR_SAL // [
// Sharable "_impl" macros: these can be shared between the various annotation
// forms but are part of the implementation of the macros. These are collected
// here to assure that only necessary differences in the annotations
// exist.
#define _Always_impl_(annos) _Group_(annos _SAL_nop_impl_) _On_failure_impl_(annos _SAL_nop_impl_)
#define _Bound_impl_ _SA_annotes0(SAL_bound)
#define _Field_range_impl_(min,max) _Range_impl_(min,max)
#define _Literal_impl_ _SA_annotes1(SAL_constant, __yes)
#define _Maybenull_impl_ _SA_annotes1(SAL_null, __maybe)
#define _Maybevalid_impl_ _SA_annotes1(SAL_valid, __maybe)
#define _Must_inspect_impl_ _Post_impl_ _SA_annotes0(SAL_mustInspect)
#define _Notliteral_impl_ _SA_annotes1(SAL_constant, __no)
#define _Notnull_impl_ _SA_annotes1(SAL_null, __no)
#define _Notvalid_impl_ _SA_annotes1(SAL_valid, __no)
#define _NullNull_terminated_impl_ _Group_(_SA_annotes1(SAL_nullTerminated, __yes) _SA_annotes1(SAL_readableTo,inexpressibleCount("NullNull terminated string")))
#define _Null_impl_ _SA_annotes1(SAL_null, __yes)
#define _Null_terminated_impl_ _SA_annotes1(SAL_nullTerminated, __yes)
#define _Out_impl_ _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl) _Post_valid_impl_
#define _Out_opt_impl_ _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl) _Post_valid_impl_
#define _Points_to_data_impl_ _At_(*_Curr_, _SA_annotes1(SAL_mayBePointer, __no))
#define _Post_satisfies_impl_(cond) _Post_impl_ _Satisfies_impl_(cond)
#define _Post_valid_impl_ _Post1_impl_(__valid_impl)
#define _Pre_satisfies_impl_(cond) _Pre_impl_ _Satisfies_impl_(cond)
#define _Pre_valid_impl_ _Pre1_impl_(__valid_impl)
#define _Range_impl_(min,max) _SA_annotes2(SAL_range, min, max)
#define _Readable_bytes_impl_(size) _SA_annotes1(SAL_readableTo, byteCount(size))
#define _Readable_elements_impl_(size) _SA_annotes1(SAL_readableTo, elementCount(size))
#define _Ret_valid_impl_ _Ret1_impl_(__valid_impl)
#define _Satisfies_impl_(cond) _SA_annotes1(SAL_satisfies, cond)
#define _Valid_impl_ _SA_annotes1(SAL_valid, __yes)
#define _Writable_bytes_impl_(size) _SA_annotes1(SAL_writableTo, byteCount(size))
#define _Writable_elements_impl_(size) _SA_annotes1(SAL_writableTo, elementCount(size))
#define _In_range_impl_(min,max) _Pre_impl_ _Range_impl_(min,max)
#define _Out_range_impl_(min,max) _Post_impl_ _Range_impl_(min,max)
#define _Ret_range_impl_(min,max) _Post_impl_ _Range_impl_(min,max)
#define _Deref_in_range_impl_(min,max) _Deref_pre_impl_ _Range_impl_(min,max)
#define _Deref_out_range_impl_(min,max) _Deref_post_impl_ _Range_impl_(min,max)
#define _Deref_ret_range_impl_(min,max) _Deref_post_impl_ _Range_impl_(min,max)
#define _Deref_pre_impl_ _Pre_impl_ _Notref_impl_ _Deref_impl_
#define _Deref_post_impl_ _Post_impl_ _Notref_impl_ _Deref_impl_
// The following are for the implementation machinery, and are not
// suitable for annotating general code.
// We're tying to phase this out, someday. The parser quotes the param.
#define __AuToQuOtE _SA_annotes0(SAL_AuToQuOtE)
// Normally the parser does some simple type checking of annotation params,
// defer that check to the plugin.
#define __deferTypecheck _SA_annotes0(SAL_deferTypecheck)
#define _SA_SPECSTRIZE( x ) #x
#define _SAL_nop_impl_ /* nothing */
#define __nop_impl(x) x
#endif
#if _USE_ATTRIBUTES_FOR_SAL // [
// Using attributes for sal
#include "codeanalysis\sourceannotations.h"
#define _SA_annotes0(n) [SAL_annotes(Name=#n)]
#define _SA_annotes1(n,pp1) [SAL_annotes(Name=#n, p1=_SA_SPECSTRIZE(pp1))]
#define _SA_annotes2(n,pp1,pp2) [SAL_annotes(Name=#n, p1=_SA_SPECSTRIZE(pp1), p2=_SA_SPECSTRIZE(pp2))]
#define _SA_annotes3(n,pp1,pp2,pp3) [SAL_annotes(Name=#n, p1=_SA_SPECSTRIZE(pp1), p2=_SA_SPECSTRIZE(pp2), p3=_SA_SPECSTRIZE(pp3))]
#define _Pre_impl_ [SAL_pre]
#define _Post_impl_ [SAL_post]
#define _Deref_impl_ [SAL_deref]
#define _Notref_impl_ [SAL_notref]
// Declare a function to be an annotation or primop (respectively).
// Done this way so that they don't appear in the regular compiler's
// namespace.
#define __ANNOTATION(fun) _SA_annotes0(SAL_annotation) void __SA_##fun;
#define __PRIMOP(type, fun) _SA_annotes0(SAL_primop) type __SA_##fun;
#define __QUALIFIER(fun) _SA_annotes0(SAL_qualifier) void __SA_##fun;
// Benign declspec needed here for WindowsPREfast
#define __In_impl_ [SA_Pre(Valid=SA_Yes)] [SA_Pre(Deref=1, Notref=1, Access=SA_Read)] __declspec("SAL_pre SAL_valid")
#elif _USE_DECLSPECS_FOR_SAL // ][
// Using declspecs for sal
#define _SA_annotes0(n) __declspec(#n)
#define _SA_annotes1(n,pp1) __declspec(#n "(" _SA_SPECSTRIZE(pp1) ")" )
#define _SA_annotes2(n,pp1,pp2) __declspec(#n "(" _SA_SPECSTRIZE(pp1) "," _SA_SPECSTRIZE(pp2) ")")
#define _SA_annotes3(n,pp1,pp2,pp3) __declspec(#n "(" _SA_SPECSTRIZE(pp1) "," _SA_SPECSTRIZE(pp2) "," _SA_SPECSTRIZE(pp3) ")")
#define _Pre_impl_ _SA_annotes0(SAL_pre)
#define _Post_impl_ _SA_annotes0(SAL_post)
#define _Deref_impl_ _SA_annotes0(SAL_deref)
#define _Notref_impl_ _SA_annotes0(SAL_notref)
// Declare a function to be an annotation or primop (respectively).
// Done this way so that they don't appear in the regular compiler's
// namespace.
#define __ANNOTATION(fun) _SA_annotes0(SAL_annotation) void __SA_##fun
#define __PRIMOP(type, fun) _SA_annotes0(SAL_primop) type __SA_##fun
#define __QUALIFIER(fun) _SA_annotes0(SAL_qualifier) void __SA_##fun;
#define __In_impl_ _Pre_impl_ _SA_annotes0(SAL_valid) _Pre_impl_ _Deref_impl_ _Notref_impl_ _SA_annotes0(SAL_readonly)
#else // ][
// Using "nothing" for sal
#define _SA_annotes0(n)
#define _SA_annotes1(n,pp1)
#define _SA_annotes2(n,pp1,pp2)
#define _SA_annotes3(n,pp1,pp2,pp3)
#define __ANNOTATION(fun)
#define __PRIMOP(type, fun)
#define __QUALIFIER(type, fun)
#endif // ]
#if _USE_ATTRIBUTES_FOR_SAL || _USE_DECLSPECS_FOR_SAL // [
// Declare annotations that need to be declared.
__ANNOTATION(SAL_useHeader(void));
__ANNOTATION(SAL_bound(void));
__ANNOTATION(SAL_allocator(void)); //??? resolve with PFD
__ANNOTATION(SAL_file_parser(__AuToQuOtE __In_impl_ char *, __In_impl_ char *));
__ANNOTATION(SAL_source_code_content(__In_impl_ char *));
__ANNOTATION(SAL_analysisHint(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_untrusted_data_source(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_untrusted_data_source_this(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_validated(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_validated_this(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_encoded(void));
__ANNOTATION(SAL_adt(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_add_adt_property(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_remove_adt_property(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_transfer_adt_property_from(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_post_type(__AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_volatile(void));
__ANNOTATION(SAL_nonvolatile(void));
__ANNOTATION(SAL_entrypoint(__AuToQuOtE __In_impl_ char *, __AuToQuOtE __In_impl_ char *));
__ANNOTATION(SAL_blocksOn(__In_impl_ void*));
__ANNOTATION(SAL_mustInspect(void));
// Only appears in model files, but needs to be declared.
__ANNOTATION(SAL_TypeName(__AuToQuOtE __In_impl_ char *));
// To be declared well-known soon.
__ANNOTATION(SAL_interlocked(void);)
#pragma warning (suppress: 28227 28241)
__ANNOTATION(SAL_name(__In_impl_ char *, __In_impl_ char *, __In_impl_ char *);)
__PRIMOP(char *, _Macro_value_(__In_impl_ char *));
__PRIMOP(int, _Macro_defined_(__In_impl_ char *));
__PRIMOP(char *, _Strstr_(__In_impl_ char *, __In_impl_ char *));
#endif // ]
#if _USE_ATTRIBUTES_FOR_SAL // [
#define _Check_return_impl_ [SA_Post(MustCheck=SA_Yes)]
#define _Success_impl_(expr) [SA_Success(Condition=#expr)]
#define _On_failure_impl_(annos) [SAL_context(p1="SAL_failed")] _Group_(_Post_impl_ _Group_(annos _SAL_nop_impl_))
#define _Printf_format_string_impl_ [SA_FormatString(Style="printf")]
#define _Scanf_format_string_impl_ [SA_FormatString(Style="scanf")]
#define _Scanf_s_format_string_impl_ [SA_FormatString(Style="scanf_s")]
#define _In_bound_impl_ [SA_PreBound(Deref=0)]
#define _Out_bound_impl_ [SA_PostBound(Deref=0)]
#define _Ret_bound_impl_ [SA_PostBound(Deref=0)]
#define _Deref_in_bound_impl_ [SA_PreBound(Deref=1)]
#define _Deref_out_bound_impl_ [SA_PostBound(Deref=1)]
#define _Deref_ret_bound_impl_ [SA_PostBound(Deref=1)]
#define __valid_impl Valid=SA_Yes
#define __maybevalid_impl Valid=SA_Maybe
#define __notvalid_impl Valid=SA_No
#define __null_impl Null=SA_Yes
#define __maybenull_impl Null=SA_Maybe
#define __notnull_impl Null=SA_No
#define __null_impl_notref Null=SA_Yes,Notref=1
#define __maybenull_impl_notref Null=SA_Maybe,Notref=1
#define __notnull_impl_notref Null=SA_No,Notref=1
#define __zterm_impl NullTerminated=SA_Yes
#define __maybezterm_impl NullTerminated=SA_Maybe
#define __maybzterm_impl NullTerminated=SA_Maybe
#define __notzterm_impl NullTerminated=SA_No
#define __readaccess_impl Access=SA_Read
#define __writeaccess_impl Access=SA_Write
#define __allaccess_impl Access=SA_ReadWrite
#define __readaccess_impl_notref Access=SA_Read,Notref=1
#define __writeaccess_impl_notref Access=SA_Write,Notref=1
#define __allaccess_impl_notref Access=SA_ReadWrite,Notref=1
#if _MSC_VER >= 1610 /*IFSTRIP=IGN*/ // [
// For SAL2, we need to expect general expressions.
#define __cap_impl(size) WritableElements="\n"#size
#define __bytecap_impl(size) WritableBytes="\n"#size
#define __bytecount_impl(size) ValidBytes="\n"#size
#define __count_impl(size) ValidElements="\n"#size
#else // ][
#define __cap_impl(size) WritableElements=#size
#define __bytecap_impl(size) WritableBytes=#size
#define __bytecount_impl(size) ValidBytes=#size
#define __count_impl(size) ValidElements=#size
#endif // ]
#define __cap_c_impl(size) WritableElementsConst=size
#define __cap_c_one_notref_impl WritableElementsConst=1,Notref=1
#define __cap_for_impl(param) WritableElementsLength=#param
#define __cap_x_impl(size) WritableElements="\n@"#size
#define __bytecap_c_impl(size) WritableBytesConst=size
#define __bytecap_x_impl(size) WritableBytes="\n@"#size
#define __mult_impl(mult,size) __cap_impl((mult)*(size))
#define __count_c_impl(size) ValidElementsConst=size
#define __count_x_impl(size) ValidElements="\n@"#size
#define __bytecount_c_impl(size) ValidBytesConst=size
#define __bytecount_x_impl(size) ValidBytes="\n@"#size
#define _At_impl_(target, annos) [SAL_at(p1=#target)] _Group_(annos)
#define _At_buffer_impl_(target, iter, bound, annos) [SAL_at_buffer(p1=#target, p2=#iter, p3=#bound)] _Group_(annos)
#define _When_impl_(expr, annos) [SAL_when(p1=#expr)] _Group_(annos)
#define _Group_impl_(annos) [SAL_begin] annos [SAL_end]
#define _GrouP_impl_(annos) [SAL_BEGIN] annos [SAL_END]
#define _Use_decl_anno_impl_ _SA_annotes0(SAL_useHeader) // this is a special case!
#define _Pre1_impl_(p1) [SA_Pre(p1)]
#define _Pre2_impl_(p1,p2) [SA_Pre(p1,p2)]
#define _Pre3_impl_(p1,p2,p3) [SA_Pre(p1,p2,p3)]
#define _Post1_impl_(p1) [SA_Post(p1)]
#define _Post2_impl_(p1,p2) [SA_Post(p1,p2)]
#define _Post3_impl_(p1,p2,p3) [SA_Post(p1,p2,p3)]
#define _Ret1_impl_(p1) [SA_Post(p1)]
#define _Ret2_impl_(p1,p2) [SA_Post(p1,p2)]
#define _Ret3_impl_(p1,p2,p3) [SA_Post(p1,p2,p3)]
#define _Deref_pre1_impl_(p1) [SA_Pre(Deref=1,p1)]
#define _Deref_pre2_impl_(p1,p2) [SA_Pre(Deref=1,p1,p2)]
#define _Deref_pre3_impl_(p1,p2,p3) [SA_Pre(Deref=1,p1,p2,p3)]
#define _Deref_post1_impl_(p1) [SA_Post(Deref=1,p1)]
#define _Deref_post2_impl_(p1,p2) [SA_Post(Deref=1,p1,p2)]
#define _Deref_post3_impl_(p1,p2,p3) [SA_Post(Deref=1,p1,p2,p3)]
#define _Deref_ret1_impl_(p1) [SA_Post(Deref=1,p1)]
#define _Deref_ret2_impl_(p1,p2) [SA_Post(Deref=1,p1,p2)]
#define _Deref_ret3_impl_(p1,p2,p3) [SA_Post(Deref=1,p1,p2,p3)]
#define _Deref2_pre1_impl_(p1) [SA_Pre(Deref=2,Notref=1,p1)]
#define _Deref2_post1_impl_(p1) [SA_Post(Deref=2,Notref=1,p1)]
#define _Deref2_ret1_impl_(p1) [SA_Post(Deref=2,Notref=1,p1)]
// Obsolete -- may be needed for transition to attributes.
#define __inner_typefix(ctype) [SAL_typefix(p1=_SA_SPECSTRIZE(ctype))]
#define __inner_exceptthat [SAL_except]
#elif _USE_DECLSPECS_FOR_SAL // ][
#define _Check_return_impl_ __post _SA_annotes0(SAL_checkReturn)
#define _Success_impl_(expr) _SA_annotes1(SAL_success, expr)
#define _On_failure_impl_(annos) _SA_annotes1(SAL_context, SAL_failed) _Group_(_Post_impl_ _Group_(_SAL_nop_impl_ annos))
#define _Printf_format_string_impl_ _SA_annotes1(SAL_IsFormatString, "printf")
#define _Scanf_format_string_impl_ _SA_annotes1(SAL_IsFormatString, "scanf")
#define _Scanf_s_format_string_impl_ _SA_annotes1(SAL_IsFormatString, "scanf_s")
#define _In_bound_impl_ _Pre_impl_ _Bound_impl_
#define _Out_bound_impl_ _Post_impl_ _Bound_impl_
#define _Ret_bound_impl_ _Post_impl_ _Bound_impl_
#define _Deref_in_bound_impl_ _Deref_pre_impl_ _Bound_impl_
#define _Deref_out_bound_impl_ _Deref_post_impl_ _Bound_impl_
#define _Deref_ret_bound_impl_ _Deref_post_impl_ _Bound_impl_
#define __null_impl _SA_annotes0(SAL_null) // _SA_annotes1(SAL_null, __yes)
#define __notnull_impl _SA_annotes0(SAL_notnull) // _SA_annotes1(SAL_null, __no)
#define __maybenull_impl _SA_annotes0(SAL_maybenull) // _SA_annotes1(SAL_null, __maybe)
#define __valid_impl _SA_annotes0(SAL_valid) // _SA_annotes1(SAL_valid, __yes)
#define __notvalid_impl _SA_annotes0(SAL_notvalid) // _SA_annotes1(SAL_valid, __no)
#define __maybevalid_impl _SA_annotes0(SAL_maybevalid) // _SA_annotes1(SAL_valid, __maybe)
#define __null_impl_notref _Notref_ _Null_impl_
#define __maybenull_impl_notref _Notref_ _Maybenull_impl_
#define __notnull_impl_notref _Notref_ _Notnull_impl_
#define __zterm_impl _SA_annotes1(SAL_nullTerminated, __yes)
#define __maybezterm_impl _SA_annotes1(SAL_nullTerminated, __maybe)
#define __maybzterm_impl _SA_annotes1(SAL_nullTerminated, __maybe)
#define __notzterm_impl _SA_annotes1(SAL_nullTerminated, __no)
#define __readaccess_impl _SA_annotes1(SAL_access, 0x1)
#define __writeaccess_impl _SA_annotes1(SAL_access, 0x2)
#define __allaccess_impl _SA_annotes1(SAL_access, 0x3)
#define __readaccess_impl_notref _Notref_ _SA_annotes1(SAL_access, 0x1)
#define __writeaccess_impl_notref _Notref_ _SA_annotes1(SAL_access, 0x2)
#define __allaccess_impl_notref _Notref_ _SA_annotes1(SAL_access, 0x3)
#define __cap_impl(size) _SA_annotes1(SAL_writableTo,elementCount(size))
#define __cap_c_impl(size) _SA_annotes1(SAL_writableTo,elementCount(size))
#define __cap_c_one_notref_impl _Notref_ _SA_annotes1(SAL_writableTo,elementCount(1))
#define __cap_for_impl(param) _SA_annotes1(SAL_writableTo,inexpressibleCount(sizeof(param)))
#define __cap_x_impl(size) _SA_annotes1(SAL_writableTo,inexpressibleCount(#size))
#define __bytecap_impl(size) _SA_annotes1(SAL_writableTo,byteCount(size))
#define __bytecap_c_impl(size) _SA_annotes1(SAL_writableTo,byteCount(size))
#define __bytecap_x_impl(size) _SA_annotes1(SAL_writableTo,inexpressibleCount(#size))
#define __mult_impl(mult,size) _SA_annotes1(SAL_writableTo,(mult)*(size))
#define __count_impl(size) _SA_annotes1(SAL_readableTo,elementCount(size))
#define __count_c_impl(size) _SA_annotes1(SAL_readableTo,elementCount(size))
#define __count_x_impl(size) _SA_annotes1(SAL_readableTo,inexpressibleCount(#size))
#define __bytecount_impl(size) _SA_annotes1(SAL_readableTo,byteCount(size))
#define __bytecount_c_impl(size) _SA_annotes1(SAL_readableTo,byteCount(size))
#define __bytecount_x_impl(size) _SA_annotes1(SAL_readableTo,inexpressibleCount(#size))
#define _At_impl_(target, annos) _SA_annotes0(SAL_at(target)) _Group_(annos)
#define _At_buffer_impl_(target, iter, bound, annos) _SA_annotes3(SAL_at_buffer, target, iter, bound) _Group_(annos)
#define _Group_impl_(annos) _SA_annotes0(SAL_begin) annos _SA_annotes0(SAL_end)
#define _GrouP_impl_(annos) _SA_annotes0(SAL_BEGIN) annos _SA_annotes0(SAL_END)
#define _When_impl_(expr, annos) _SA_annotes0(SAL_when(expr)) _Group_(annos)
#define _Use_decl_anno_impl_ __declspec("SAL_useHeader()") // this is a special case!
#define _Pre1_impl_(p1) _Pre_impl_ p1
#define _Pre2_impl_(p1,p2) _Pre_impl_ p1 _Pre_impl_ p2
#define _Pre3_impl_(p1,p2,p3) _Pre_impl_ p1 _Pre_impl_ p2 _Pre_impl_ p3
#define _Post1_impl_(p1) _Post_impl_ p1
#define _Post2_impl_(p1,p2) _Post_impl_ p1 _Post_impl_ p2
#define _Post3_impl_(p1,p2,p3) _Post_impl_ p1 _Post_impl_ p2 _Post_impl_ p3
#define _Ret1_impl_(p1) _Post_impl_ p1
#define _Ret2_impl_(p1,p2) _Post_impl_ p1 _Post_impl_ p2
#define _Ret3_impl_(p1,p2,p3) _Post_impl_ p1 _Post_impl_ p2 _Post_impl_ p3
#define _Deref_pre1_impl_(p1) _Deref_pre_impl_ p1
#define _Deref_pre2_impl_(p1,p2) _Deref_pre_impl_ p1 _Deref_pre_impl_ p2
#define _Deref_pre3_impl_(p1,p2,p3) _Deref_pre_impl_ p1 _Deref_pre_impl_ p2 _Deref_pre_impl_ p3
#define _Deref_post1_impl_(p1) _Deref_post_impl_ p1
#define _Deref_post2_impl_(p1,p2) _Deref_post_impl_ p1 _Deref_post_impl_ p2
#define _Deref_post3_impl_(p1,p2,p3) _Deref_post_impl_ p1 _Deref_post_impl_ p2 _Deref_post_impl_ p3
#define _Deref_ret1_impl_(p1) _Deref_post_impl_ p1
#define _Deref_ret2_impl_(p1,p2) _Deref_post_impl_ p1 _Deref_post_impl_ p2
#define _Deref_ret3_impl_(p1,p2,p3) _Deref_post_impl_ p1 _Deref_post_impl_ p2 _Deref_post_impl_ p3
#define _Deref2_pre1_impl_(p1) _Deref_pre_impl_ _Notref_impl_ _Deref_impl_ p1
#define _Deref2_post1_impl_(p1) _Deref_post_impl_ _Notref_impl_ _Deref_impl_ p1
#define _Deref2_ret1_impl_(p1) _Deref_post_impl_ _Notref_impl_ _Deref_impl_ p1
#define __inner_typefix(ctype) _SA_annotes1(SAL_typefix, ctype)
#define __inner_exceptthat _SA_annotes0(SAL_except)
#elif defined(_MSC_EXTENSIONS) && !defined( MIDL_PASS ) && !defined(__midl) && !defined(RC_INVOKED) && defined(_PFT_VER) && _MSC_VER >= 1400 /*IFSTRIP=IGN*/ // ][
// minimum attribute expansion for foreground build
#pragma push_macro( "SA" )
#pragma push_macro( "REPEATABLE" )
#ifdef __cplusplus // [
#define SA( id ) id
#define REPEATABLE [repeatable]
#else // !__cplusplus // ][
#define SA( id ) SA_##id
#define REPEATABLE
#endif // !__cplusplus // ]
REPEATABLE
[source_annotation_attribute( SA( Parameter ) )]
struct __P_impl
{
#ifdef __cplusplus // [
__P_impl();
#endif // ]
int __d_;
};
typedef struct __P_impl __P_impl;
REPEATABLE
[source_annotation_attribute( SA( ReturnValue ) )]
struct __R_impl
{
#ifdef __cplusplus // [
__R_impl();
#endif // ]
int __d_;
};
typedef struct __R_impl __R_impl;
[source_annotation_attribute( SA( Method ) )]
struct __M_
{
#ifdef __cplusplus // [
__M_();
#endif // ]
int __d_;
};
typedef struct __M_ __M_;
[source_annotation_attribute( SA( All ) )]
struct __A_
{
#ifdef __cplusplus // [
__A_();
#endif // ]
int __d_;
};
typedef struct __A_ __A_;
[source_annotation_attribute( SA( Field ) )]
struct __F_
{
#ifdef __cplusplus // [
__F_();
#endif // ]
int __d_;
};
typedef struct __F_ __F_;
#pragma pop_macro( "REPEATABLE" )
#pragma pop_macro( "SA" )
#define _SAL_nop_impl_
#define _At_impl_(target, annos) [__A_(__d_=0)]
#define _At_buffer_impl_(target, iter, bound, annos) [__A_(__d_=0)]
#define _When_impl_(expr, annos) annos
#define _Group_impl_(annos) annos
#define _GrouP_impl_(annos) annos
#define _Use_decl_anno_impl_ [__M_(__d_=0)]
#define _Points_to_data_impl_ [__P_impl(__d_=0)]
#define _Literal_impl_ [__P_impl(__d_=0)]
#define _Notliteral_impl_ [__P_impl(__d_=0)]
#define _Pre_valid_impl_ [__P_impl(__d_=0)]
#define _Post_valid_impl_ [__P_impl(__d_=0)]
#define _Ret_valid_impl_ [__R_impl(__d_=0)]
#define _Check_return_impl_ [__R_impl(__d_=0)]
#define _Must_inspect_impl_ [__R_impl(__d_=0)]
#define _Success_impl_(expr) [__M_(__d_=0)]
#define _On_failure_impl_(expr) [__M_(__d_=0)]
#define _Always_impl_(expr) [__M_(__d_=0)]
#define _Printf_format_string_impl_ [__P_impl(__d_=0)]
#define _Scanf_format_string_impl_ [__P_impl(__d_=0)]
#define _Scanf_s_format_string_impl_ [__P_impl(__d_=0)]
#define _Raises_SEH_exception_impl_ [__M_(__d_=0)]
#define _Maybe_raises_SEH_exception_impl_ [__M_(__d_=0)]
#define _In_bound_impl_ [__P_impl(__d_=0)]
#define _Out_bound_impl_ [__P_impl(__d_=0)]
#define _Ret_bound_impl_ [__R_impl(__d_=0)]
#define _Deref_in_bound_impl_ [__P_impl(__d_=0)]
#define _Deref_out_bound_impl_ [__P_impl(__d_=0)]
#define _Deref_ret_bound_impl_ [__R_impl(__d_=0)]
#define _Range_impl_(min,max) [__P_impl(__d_=0)]
#define _In_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Out_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Ret_range_impl_(min,max) [__R_impl(__d_=0)]
#define _Deref_in_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Deref_out_range_impl_(min,max) [__P_impl(__d_=0)]
#define _Deref_ret_range_impl_(min,max) [__R_impl(__d_=0)]
#define _Field_range_impl_(min,max) [__F_(__d_=0)]
#define _Pre_satisfies_impl_(cond) [__A_(__d_=0)]
#define _Post_satisfies_impl_(cond) [__A_(__d_=0)]
#define _Satisfies_impl_(cond) [__A_(__d_=0)]
#define _Null_impl_ [__A_(__d_=0)]
#define _Notnull_impl_ [__A_(__d_=0)]
#define _Maybenull_impl_ [__A_(__d_=0)]
#define _Valid_impl_ [__A_(__d_=0)]
#define _Notvalid_impl_ [__A_(__d_=0)]
#define _Maybevalid_impl_ [__A_(__d_=0)]
#define _Readable_bytes_impl_(size) [__A_(__d_=0)]
#define _Readable_elements_impl_(size) [__A_(__d_=0)]
#define _Writable_bytes_impl_(size) [__A_(__d_=0)]
#define _Writable_elements_impl_(size) [__A_(__d_=0)]
#define _Null_terminated_impl_ [__A_(__d_=0)]
#define _NullNull_terminated_impl_ [__A_(__d_=0)]
#define _Pre_impl_ [__P_impl(__d_=0)]
#define _Pre1_impl_(p1) [__P_impl(__d_=0)]
#define _Pre2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Pre3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Post_impl_ [__P_impl(__d_=0)]
#define _Post1_impl_(p1) [__P_impl(__d_=0)]
#define _Post2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Post3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Ret1_impl_(p1) [__R_impl(__d_=0)]
#define _Ret2_impl_(p1,p2) [__R_impl(__d_=0)]
#define _Ret3_impl_(p1,p2,p3) [__R_impl(__d_=0)]
#define _Deref_pre1_impl_(p1) [__P_impl(__d_=0)]
#define _Deref_pre2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Deref_pre3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Deref_post1_impl_(p1) [__P_impl(__d_=0)]
#define _Deref_post2_impl_(p1,p2) [__P_impl(__d_=0)]
#define _Deref_post3_impl_(p1,p2,p3) [__P_impl(__d_=0)]
#define _Deref_ret1_impl_(p1) [__R_impl(__d_=0)]
#define _Deref_ret2_impl_(p1,p2) [__R_impl(__d_=0)]
#define _Deref_ret3_impl_(p1,p2,p3) [__R_impl(__d_=0)]
#define _Deref2_pre1_impl_(p1) //[__P_impl(__d_=0)]
#define _Deref2_post1_impl_(p1) //[__P_impl(__d_=0)]
#define _Deref2_ret1_impl_(p1) //[__P_impl(__d_=0)]
#else // ][
#define _SAL_nop_impl_ X
#define _At_impl_(target, annos)
#define _When_impl_(expr, annos)
#define _Group_impl_(annos)
#define _GrouP_impl_(annos)
#define _At_buffer_impl_(target, iter, bound, annos)
#define _Use_decl_anno_impl_
#define _Points_to_data_impl_
#define _Literal_impl_
#define _Notliteral_impl_
#define _Notref_impl_
#define _Pre_valid_impl_
#define _Post_valid_impl_
#define _Ret_valid_impl_
#define _Check_return_impl_
#define _Must_inspect_impl_
#define _Success_impl_(expr)
#define _On_failure_impl_(annos)
#define _Always_impl_(annos)
#define _Printf_format_string_impl_
#define _Scanf_format_string_impl_
#define _Scanf_s_format_string_impl_
#define _In_bound_impl_
#define _Out_bound_impl_
#define _Ret_bound_impl_
#define _Deref_in_bound_impl_
#define _Deref_out_bound_impl_
#define _Deref_ret_bound_impl_
#define _Range_impl_(min,max)
#define _In_range_impl_(min,max)
#define _Out_range_impl_(min,max)
#define _Ret_range_impl_(min,max)
#define _Deref_in_range_impl_(min,max)
#define _Deref_out_range_impl_(min,max)
#define _Deref_ret_range_impl_(min,max)
#define _Satisfies_impl_(expr)
#define _Pre_satisfies_impl_(expr)
#define _Post_satisfies_impl_(expr)
#define _Null_impl_
#define _Notnull_impl_
#define _Maybenull_impl_
#define _Valid_impl_
#define _Notvalid_impl_
#define _Maybevalid_impl_
#define _Field_range_impl_(min,max)
#define _Pre_impl_
#define _Pre1_impl_(p1)
#define _Pre2_impl_(p1,p2)
#define _Pre3_impl_(p1,p2,p3)
#define _Post_impl_
#define _Post1_impl_(p1)
#define _Post2_impl_(p1,p2)
#define _Post3_impl_(p1,p2,p3)
#define _Ret1_impl_(p1)
#define _Ret2_impl_(p1,p2)
#define _Ret3_impl_(p1,p2,p3)
#define _Deref_pre1_impl_(p1)
#define _Deref_pre2_impl_(p1,p2)
#define _Deref_pre3_impl_(p1,p2,p3)
#define _Deref_post1_impl_(p1)
#define _Deref_post2_impl_(p1,p2)
#define _Deref_post3_impl_(p1,p2,p3)
#define _Deref_ret1_impl_(p1)
#define _Deref_ret2_impl_(p1,p2)
#define _Deref_ret3_impl_(p1,p2,p3)
#define _Deref2_pre1_impl_(p1)
#define _Deref2_post1_impl_(p1)
#define _Deref2_ret1_impl_(p1)
#define _Readable_bytes_impl_(size)
#define _Readable_elements_impl_(size)
#define _Writable_bytes_impl_(size)
#define _Writable_elements_impl_(size)
#define _Null_terminated_impl_
#define _NullNull_terminated_impl_
// Obsolete -- may be needed for transition to attributes.
#define __inner_typefix(ctype)
#define __inner_exceptthat
#endif // ]
// This section contains the deprecated annotations
/*
-------------------------------------------------------------------------------
Introduction
sal.h provides a set of annotations to describe how a function uses its
parameters - the assumptions it makes about them, and the guarantees it makes
upon finishing.
Annotations may be placed before either a function parameter's type or its return
type, and describe the function's behavior regarding the parameter or return value.
There are two classes of annotations: buffer annotations and advanced annotations.
Buffer annotations describe how functions use their pointer parameters, and
advanced annotations either describe complex/unusual buffer behavior, or provide
additional information about a parameter that is not otherwise expressible.
-------------------------------------------------------------------------------
Buffer Annotations
The most important annotations in sal.h provide a consistent way to annotate
buffer parameters or return values for a function. Each of these annotations describes
a single buffer (which could be a string, a fixed-length or variable-length array,
or just a pointer) that the function interacts with: where it is, how large it is,
how much is initialized, and what the function does with it.
The appropriate macro for a given buffer can be constructed using the table below.
Just pick the appropriate values from each category, and combine them together
with a leading underscore. Some combinations of values do not make sense as buffer
annotations. Only meaningful annotations can be added to your code; for a list of
these, see the buffer annotation definitions section.
Only a single buffer annotation should be used for each parameter.
|------------|------------|---------|--------|----------|----------|---------------|
| Level | Usage | Size | Output | NullTerm | Optional | Parameters |
|------------|------------|---------|--------|----------|----------|---------------|
| <> | <> | <> | <> | _z | <> | <> |
| _deref | _in | _ecount | _full | _nz | _opt | (size) |
| _deref_opt | _out | _bcount | _part | | | (size,length) |
| | _inout | | | | | |
| | | | | | | |
|------------|------------|---------|--------|----------|----------|---------------|
Level: Describes the buffer pointer's level of indirection from the parameter or
return value 'p'.
<> : p is the buffer pointer.
_deref : *p is the buffer pointer. p must not be NULL.
_deref_opt : *p may be the buffer pointer. p may be NULL, in which case the rest of
the annotation is ignored.
Usage: Describes how the function uses the buffer.
<> : The buffer is not accessed. If used on the return value or with _deref, the
function will provide the buffer, and it will be uninitialized at exit.
Otherwise, the caller must provide the buffer. This should only be used
for alloc and free functions.
_in : The function will only read from the buffer. The caller must provide the
buffer and initialize it. Cannot be used with _deref.
_out : The function will only write to the buffer. If used on the return value or
with _deref, the function will provide the buffer and initialize it.
Otherwise, the caller must provide the buffer, and the function will
initialize it.
_inout : The function may freely read from and write to the buffer. The caller must
provide the buffer and initialize it. If used with _deref, the buffer may
be reallocated by the function.
Size: Describes the total size of the buffer. This may be less than the space actually
allocated for the buffer, in which case it describes the accessible amount.
<> : No buffer size is given. If the type specifies the buffer size (such as
with LPSTR and LPWSTR), that amount is used. Otherwise, the buffer is one
element long. Must be used with _in, _out, or _inout.
_ecount : The buffer size is an explicit element count.
_bcount : The buffer size is an explicit byte count.
Output: Describes how much of the buffer will be initialized by the function. For
_inout buffers, this also describes how much is initialized at entry. Omit this
category for _in buffers; they must be fully initialized by the caller.
<> : The type specifies how much is initialized. For instance, a function initializing
an LPWSTR must NULL-terminate the string.
_full : The function initializes the entire buffer.
_part : The function initializes part of the buffer, and explicitly indicates how much.
NullTerm: States if the present of a '\0' marks the end of valid elements in the buffer.
_z : A '\0' indicated the end of the buffer
_nz : The buffer may not be null terminated and a '\0' does not indicate the end of the
buffer.
Optional: Describes if the buffer itself is optional.
<> : The pointer to the buffer must not be NULL.
_opt : The pointer to the buffer might be NULL. It will be checked before being dereferenced.
Parameters: Gives explicit counts for the size and length of the buffer.
<> : There is no explicit count. Use when neither _ecount nor _bcount is used.
(size) : Only the buffer's total size is given. Use with _ecount or _bcount but not _part.
(size,length) : The buffer's total size and initialized length are given. Use with _ecount_part
and _bcount_part.
-------------------------------------------------------------------------------
Buffer Annotation Examples
LWSTDAPI_(BOOL) StrToIntExA(
__in LPCSTR pszString,
DWORD dwFlags,
__out int *piRet -- A pointer whose dereference will be filled in.
);
void MyPaintingFunction(
__in HWND hwndControl, -- An initialized read-only parameter.
__in_opt HDC hdcOptional, -- An initialized read-only parameter that might be NULL.
__inout IPropertyStore *ppsStore -- An initialized parameter that may be freely used
-- and modified.
);
LWSTDAPI_(BOOL) PathCompactPathExA(
__out_ecount(cchMax) LPSTR pszOut, -- A string buffer with cch elements that will
-- be NULL terminated on exit.
__in LPCSTR pszSrc,
UINT cchMax,
DWORD dwFlags
);
HRESULT SHLocalAllocBytes(
size_t cb,
__deref_bcount(cb) T **ppv -- A pointer whose dereference will be set to an
-- uninitialized buffer with cb bytes.
);
__inout_bcount_full(cb) : A buffer with cb elements that is fully initialized at
entry and exit, and may be written to by this function.
__out_ecount_part(count, *countOut) : A buffer with count elements that will be
partially initialized by this function. The function indicates how much it
initialized by setting *countOut.
-------------------------------------------------------------------------------
Advanced Annotations
Advanced annotations describe behavior that is not expressible with the regular
buffer macros. These may be used either to annotate buffer parameters that involve
complex or conditional behavior, or to enrich existing annotations with additional
information.
__success(expr) f :
<expr> indicates whether function f succeeded or not. If <expr> is true at exit,
all the function's guarantees (as given by other annotations) must hold. If <expr>
is false at exit, the caller should not expect any of the function's guarantees
to hold. If not used, the function must always satisfy its guarantees. Added
automatically to functions that indicate success in standard ways, such as by
returning an HRESULT.
__nullterminated p :
Pointer p is a buffer that may be read or written up to and including the first
NULL character or pointer. May be used on typedefs, which marks valid (properly
initialized) instances of that type as being NULL-terminated.
__nullnullterminated p :
Pointer p is a buffer that may be read or written up to and including the first
sequence of two NULL characters or pointers. May be used on typedefs, which marks
valid instances of that type as being double-NULL terminated.
__reserved v :
Value v must be 0/NULL, reserved for future use.
__checkReturn v :
Return value v must not be ignored by callers of this function.
__typefix(ctype) v :
Value v should be treated as an instance of ctype, rather than its declared type.
__override f :
Specify C#-style 'override' behaviour for overriding virtual methods.
__callback f :
Function f can be used as a function pointer.
__format_string p :
Pointer p is a string that contains % markers in the style of printf.
__blocksOn(resource) f :
Function f blocks on the resource 'resource'.
FALLTHROUGH :
Annotates switch statement labels where fall-through is desired, to distinguish
from forgotten break statements.
-------------------------------------------------------------------------------
Advanced Annotation Examples
__success(return != FALSE) LWSTDAPI_(BOOL)
PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, LPCSTR pszPath) :
pszBuf is only guaranteed to be NULL-terminated when TRUE is returned.
typedef __nullterminated WCHAR* LPWSTR : Initialized LPWSTRs are NULL-terminated strings.
__out_ecount(cch) __typefix(LPWSTR) void *psz : psz is a buffer parameter which will be
a NULL-terminated WCHAR string at exit, and which initially contains cch WCHARs.
-------------------------------------------------------------------------------
*/
#define __specstrings
#ifdef __cplusplus // [
#ifndef __nothrow // [
# define __nothrow NOTHROW_DECL
#endif // ]
extern "C" {
#else // ][
#ifndef __nothrow // [
# define __nothrow
#endif // ]
#endif /* #ifdef __cplusplus */ // ]
/*
-------------------------------------------------------------------------------
Helper Macro Definitions
These express behavior common to many of the high-level annotations.
DO NOT USE THESE IN YOUR CODE.
-------------------------------------------------------------------------------
*/
/*
The helper annotations are only understood by the compiler version used by
various defect detection tools. When the regular compiler is running, they
are defined into nothing, and do not affect the compiled code.
*/
#if !defined(__midl) && defined(_PREFAST_) // [
/*
In the primitive "SAL_*" annotations "SAL" stands for Standard
Annotation Language. These "SAL_*" annotations are the
primitives the compiler understands and high-level MACROs
will decompose into these primivates.
*/
#define _SA_SPECSTRIZE( x ) #x
/*
__null p
__notnull p
__maybenull p
Annotates a pointer p. States that pointer p is null. Commonly used
in the negated form __notnull or the possibly null form __maybenull.
*/
#ifndef PAL_STDCPP_COMPAT
#define __null _Null_impl_
#define __notnull _Notnull_impl_
#define __maybenull _Maybenull_impl_
#endif // !PAL_STDCPP_COMPAT
/*
__readonly l
__notreadonly l
__mabyereadonly l
Annotates a location l. States that location l is not modified after
this point. If the annotation is placed on the precondition state of
a function, the restriction only applies until the postcondition state
of the function. __maybereadonly states that the annotated location
may be modified, whereas __notreadonly states that a location must be
modified.
*/
#define __readonly _Pre1_impl_(__readaccess_impl)
#define __notreadonly _Pre1_impl_(__allaccess_impl)
#define __maybereadonly _Pre1_impl_(__readaccess_impl)
/*
__valid v
__notvalid v
__maybevalid v
Annotates any value v. States that the value satisfies all properties of
valid values of its type. For example, for a string buffer, valid means
that the buffer pointer is either NULL or points to a NULL-terminated string.
*/
#define __valid _Valid_impl_
#define __notvalid _Notvalid_impl_
#define __maybevalid _Maybevalid_impl_
/*
__readableTo(extent) p
Annotates a buffer pointer p. If the buffer can be read, extent describes
how much of the buffer is readable. For a reader of the buffer, this is
an explicit permission to read up to that amount, rather than a restriction to
read only up to it.
*/
#define __readableTo(extent) _SA_annotes1(SAL_readableTo, extent)
/*
__elem_readableTo(size)
Annotates a buffer pointer p as being readable to size elements.
*/
#define __elem_readableTo(size) _SA_annotes1(SAL_readableTo, elementCount( size ))
/*
__byte_readableTo(size)
Annotates a buffer pointer p as being readable to size bytes.
*/
#define __byte_readableTo(size) _SA_annotes1(SAL_readableTo, byteCount(size))
/*
__writableTo(extent) p
Annotates a buffer pointer p. If the buffer can be modified, extent
describes how much of the buffer is writable (usually the allocation
size). For a writer of the buffer, this is an explicit permission to
write up to that amount, rather than a restriction to write only up to it.
*/
#define __writableTo(size) _SA_annotes1(SAL_writableTo, size)
/*
__elem_writableTo(size)
Annotates a buffer pointer p as being writable to size elements.
*/
#define __elem_writableTo(size) _SA_annotes1(SAL_writableTo, elementCount( size ))
/*
__byte_writableTo(size)
Annotates a buffer pointer p as being writable to size bytes.
*/
#define __byte_writableTo(size) _SA_annotes1(SAL_writableTo, byteCount( size))
/*
__deref p
Annotates a pointer p. The next annotation applies one dereference down
in the type. If readableTo(p, size) then the next annotation applies to
all elements *(p+i) for which i satisfies the size. If p is a pointer
to a struct, the next annotation applies to all fields of the struct.
*/
#define __deref _Deref_impl_
/*
__pre __next_annotation
The next annotation applies in the precondition state
*/
#define __pre _Pre_impl_
/*
__post __next_annotation
The next annotation applies in the postcondition state
*/
#define __post _Post_impl_
/*
__precond(<expr>)
When <expr> is true, the next annotation applies in the precondition state
(currently not enabled)
*/
#define __precond(expr) __pre
/*
__postcond(<expr>)
When <expr> is true, the next annotation applies in the postcondition state
(currently not enabled)
*/
#define __postcond(expr) __post
/*
__exceptthat
Given a set of annotations Q containing __exceptthat maybeP, the effect of
the except clause is to erase any P or notP annotations (explicit or
implied) within Q at the same level of dereferencing that the except
clause appears, and to replace it with maybeP.
Example 1: __valid __pre_except_maybenull on a pointer p means that the
pointer may be null, and is otherwise valid, thus overriding
the implicit notnull annotation implied by __valid on
pointers.
Example 2: __valid __deref __pre_except_maybenull on an int **p means
that p is not null (implied by valid), but the elements
pointed to by p could be null, and are otherwise valid.
*/
#define __exceptthat __inner_exceptthat
/*
_refparam
Added to all out parameter macros to indicate that they are all reference
parameters.
*/
#define __refparam _Notref_ __deref __notreadonly
/*
__inner_*
Helper macros that directly correspond to certain high-level annotations.
*/
/*
Macros to classify the entrypoints and indicate their category.
Pre-defined control point categories include: RPC, LPC, DeviceDriver, UserToKernel, ISAPI, COM.
*/
#define __inner_control_entrypoint(category) _SA_annotes2(SAL_entrypoint, controlEntry, category)
/*
Pre-defined data entry point categories include: Registry, File, Network.
*/
#define __inner_data_entrypoint(category) _SA_annotes2(SAL_entrypoint, dataEntry, category)
#define __inner_override _SA_annotes0(__override)
#define __inner_callback _SA_annotes0(__callback)
#define __inner_blocksOn(resource) _SA_annotes1(SAL_blocksOn, resource)
#define __post_except_maybenull __post __inner_exceptthat _Maybenull_impl_
#define __pre_except_maybenull __pre __inner_exceptthat _Maybenull_impl_
#define __post_deref_except_maybenull __post __deref __inner_exceptthat _Maybenull_impl_
#define __pre_deref_except_maybenull __pre __deref __inner_exceptthat _Maybenull_impl_
#define __inexpressible_readableTo(size) _Readable_elements_impl_(_Inexpressible_(size))
#define __inexpressible_writableTo(size) _Writable_elements_impl_(_Inexpressible_(size))
#else // ][
#ifndef PAL_STDCPP_COMPAT
#define __null
#define __notnull
#define __deref
#endif // !PAL_STDCPP_COMPAT
#define __maybenull
#define __readonly
#define __notreadonly
#define __maybereadonly
#define __valid
#define __notvalid
#define __maybevalid
#define __readableTo(extent)
#define __elem_readableTo(size)
#define __byte_readableTo(size)
#define __writableTo(size)
#define __elem_writableTo(size)
#define __byte_writableTo(size)
#define __pre
#define __post
#define __precond(expr)
#define __postcond(expr)
#define __exceptthat
#define __inner_override
#define __inner_callback
#define __inner_blocksOn(resource)
#define __refparam
#define __inner_control_entrypoint(category)
#define __inner_data_entrypoint(category)
#define __post_except_maybenull
#define __pre_except_maybenull
#define __post_deref_except_maybenull
#define __pre_deref_except_maybenull
#define __inexpressible_readableTo(size)
#define __inexpressible_writableTo(size)
#endif /* #if !defined(__midl) && defined(_PREFAST_) */ // ]
/*
-------------------------------------------------------------------------------
Buffer Annotation Definitions
Any of these may be used to directly annotate functions, but only one should
be used for each parameter. To determine which annotation to use for a given
buffer, use the table in the buffer annotations section.
-------------------------------------------------------------------------------
*/
#define __ecount(size) _SAL1_Source_(__ecount, (size), __notnull __elem_writableTo(size))
#define __bcount(size) _SAL1_Source_(__bcount, (size), __notnull __byte_writableTo(size))
#define __in_ecount(size) _SAL1_Source_(__in_ecount, (size), _In_reads_(size))
#define __in_bcount(size) _SAL1_Source_(__in_bcount, (size), _In_reads_bytes_(size))
#define __in_z _SAL1_Source_(__in_z, (), _In_z_)
#define __in_ecount_z(size) _SAL1_Source_(__in_ecount_z, (size), _In_reads_z_(size))
#define __in_bcount_z(size) _SAL1_Source_(__in_bcount_z, (size), __in_bcount(size) __pre __nullterminated)
#define __in_nz _SAL1_Source_(__in_nz, (), __in)
#define __in_ecount_nz(size) _SAL1_Source_(__in_ecount_nz, (size), __in_ecount(size))
#define __in_bcount_nz(size) _SAL1_Source_(__in_bcount_nz, (size), __in_bcount(size))
#define __out_ecount(size) _SAL1_Source_(__out_ecount, (size), _Out_writes_(size))
#define __out_bcount(size) _SAL1_Source_(__out_bcount, (size), _Out_writes_bytes_(size))
#define __out_ecount_part(size,length) _SAL1_Source_(__out_ecount_part, (size,length), _Out_writes_to_(size,length))
#define __out_bcount_part(size,length) _SAL1_Source_(__out_bcount_part, (size,length), _Out_writes_bytes_to_(size,length))
#define __out_ecount_full(size) _SAL1_Source_(__out_ecount_full, (size), _Out_writes_all_(size))
#define __out_bcount_full(size) _SAL1_Source_(__out_bcount_full, (size), _Out_writes_bytes_all_(size))
#define __out_z _SAL1_Source_(__out_z, (), __post __valid __refparam __post __nullterminated)
#define __out_z_opt _SAL1_Source_(__out_z_opt, (), __post __valid __refparam __post __nullterminated __pre_except_maybenull)
#define __out_ecount_z(size) _SAL1_Source_(__out_ecount_z, (size), __ecount(size) __post __valid __refparam __post __nullterminated)
#define __out_bcount_z(size) _SAL1_Source_(__out_bcount_z, (size), __bcount(size) __post __valid __refparam __post __nullterminated)
#define __out_ecount_part_z(size,length) _SAL1_Source_(__out_ecount_part_z, (size,length), __out_ecount_part(size,length) __post __nullterminated)
#define __out_bcount_part_z(size,length) _SAL1_Source_(__out_bcount_part_z, (size,length), __out_bcount_part(size,length) __post __nullterminated)
#define __out_ecount_full_z(size) _SAL1_Source_(__out_ecount_full_z, (size), __out_ecount_full(size) __post __nullterminated)
#define __out_bcount_full_z(size) _SAL1_Source_(__out_bcount_full_z, (size), __out_bcount_full(size) __post __nullterminated)
#define __out_nz _SAL1_Source_(__out_nz, (), __post __valid __refparam)
#define __out_nz_opt _SAL1_Source_(__out_nz_opt, (), __post __valid __refparam __post_except_maybenull_)
#define __out_ecount_nz(size) _SAL1_Source_(__out_ecount_nz, (size), __ecount(size) __post __valid __refparam)
#define __out_bcount_nz(size) _SAL1_Source_(__out_bcount_nz, (size), __bcount(size) __post __valid __refparam)
#define __inout _SAL1_Source_(__inout, (), _Inout_)
#define __inout_ecount(size) _SAL1_Source_(__inout_ecount, (size), _Inout_updates_(size))
#define __inout_bcount(size) _SAL1_Source_(__inout_bcount, (size), _Inout_updates_bytes_(size))
#define __inout_ecount_part(size,length) _SAL1_Source_(__inout_ecount_part, (size,length), _Inout_updates_to_(size,length))
#define __inout_bcount_part(size,length) _SAL1_Source_(__inout_bcount_part, (size,length), _Inout_updates_bytes_to_(size,length))
#define __inout_ecount_full(size) _SAL1_Source_(__inout_ecount_full, (size), _Inout_updates_all_(size))
#define __inout_bcount_full(size) _SAL1_Source_(__inout_bcount_full, (size), _Inout_updates_bytes_all_(size))
#define __inout_z _SAL1_Source_(__inout_z, (), _Inout_z_)
#define __inout_ecount_z(size) _SAL1_Source_(__inout_ecount_z, (size), _Inout_updates_z_(size))
#define __inout_bcount_z(size) _SAL1_Source_(__inout_bcount_z, (size), __inout_bcount(size) __pre __nullterminated __post __nullterminated)
#define __inout_nz _SAL1_Source_(__inout_nz, (), __inout)
#define __inout_ecount_nz(size) _SAL1_Source_(__inout_ecount_nz, (size), __inout_ecount(size))
#define __inout_bcount_nz(size) _SAL1_Source_(__inout_bcount_nz, (size), __inout_bcount(size))
#define __ecount_opt(size) _SAL1_Source_(__ecount_opt, (size), __ecount(size) __pre_except_maybenull)
#define __bcount_opt(size) _SAL1_Source_(__bcount_opt, (size), __bcount(size) __pre_except_maybenull)
#define __in_opt _SAL1_Source_(__in_opt, (), _In_opt_)
#define __in_ecount_opt(size) _SAL1_Source_(__in_ecount_opt, (size), _In_reads_opt_(size))
#define __in_bcount_opt(size) _SAL1_Source_(__in_bcount_opt, (size), _In_reads_bytes_opt_(size))
#define __in_z_opt _SAL1_Source_(__in_z_opt, (), _In_opt_z_)
#define __in_ecount_z_opt(size) _SAL1_Source_(__in_ecount_z_opt, (size), __in_ecount_opt(size) __pre __nullterminated)
#define __in_bcount_z_opt(size) _SAL1_Source_(__in_bcount_z_opt, (size), __in_bcount_opt(size) __pre __nullterminated)
#define __in_nz_opt _SAL1_Source_(__in_nz_opt, (), __in_opt)
#define __in_ecount_nz_opt(size) _SAL1_Source_(__in_ecount_nz_opt, (size), __in_ecount_opt(size))
#define __in_bcount_nz_opt(size) _SAL1_Source_(__in_bcount_nz_opt, (size), __in_bcount_opt(size))
#define __out_opt _SAL1_Source_(__out_opt, (), _Out_opt_)
#define __out_ecount_opt(size) _SAL1_Source_(__out_ecount_opt, (size), _Out_writes_opt_(size))
#define __out_bcount_opt(size) _SAL1_Source_(__out_bcount_opt, (size), _Out_writes_bytes_opt_(size))
#define __out_ecount_part_opt(size,length) _SAL1_Source_(__out_ecount_part_opt, (size,length), __out_ecount_part(size,length) __pre_except_maybenull)
#define __out_bcount_part_opt(size,length) _SAL1_Source_(__out_bcount_part_opt, (size,length), __out_bcount_part(size,length) __pre_except_maybenull)
#define __out_ecount_full_opt(size) _SAL1_Source_(__out_ecount_full_opt, (size), __out_ecount_full(size) __pre_except_maybenull)
#define __out_bcount_full_opt(size) _SAL1_Source_(__out_bcount_full_opt, (size), __out_bcount_full(size) __pre_except_maybenull)
#define __out_ecount_z_opt(size) _SAL1_Source_(__out_ecount_z_opt, (size), __out_ecount_opt(size) __post __nullterminated)
#define __out_bcount_z_opt(size) _SAL1_Source_(__out_bcount_z_opt, (size), __out_bcount_opt(size) __post __nullterminated)
#define __out_ecount_part_z_opt(size,length) _SAL1_Source_(__out_ecount_part_z_opt, (size,length), __out_ecount_part_opt(size,length) __post __nullterminated)
#define __out_bcount_part_z_opt(size,length) _SAL1_Source_(__out_bcount_part_z_opt, (size,length), __out_bcount_part_opt(size,length) __post __nullterminated)
#define __out_ecount_full_z_opt(size) _SAL1_Source_(__out_ecount_full_z_opt, (size), __out_ecount_full_opt(size) __post __nullterminated)
#define __out_bcount_full_z_opt(size) _SAL1_Source_(__out_bcount_full_z_opt, (size), __out_bcount_full_opt(size) __post __nullterminated)
#define __out_ecount_nz_opt(size) _SAL1_Source_(__out_ecount_nz_opt, (size), __out_ecount_opt(size) __post __nullterminated)
#define __out_bcount_nz_opt(size) _SAL1_Source_(__out_bcount_nz_opt, (size), __out_bcount_opt(size) __post __nullterminated)
#define __inout_opt _SAL1_Source_(__inout_opt, (), _Inout_opt_)
#define __inout_ecount_opt(size) _SAL1_Source_(__inout_ecount_opt, (size), __inout_ecount(size) __pre_except_maybenull)
#define __inout_bcount_opt(size) _SAL1_Source_(__inout_bcount_opt, (size), __inout_bcount(size) __pre_except_maybenull)
#define __inout_ecount_part_opt(size,length) _SAL1_Source_(__inout_ecount_part_opt, (size,length), __inout_ecount_part(size,length) __pre_except_maybenull)
#define __inout_bcount_part_opt(size,length) _SAL1_Source_(__inout_bcount_part_opt, (size,length), __inout_bcount_part(size,length) __pre_except_maybenull)
#define __inout_ecount_full_opt(size) _SAL1_Source_(__inout_ecount_full_opt, (size), __inout_ecount_full(size) __pre_except_maybenull)
#define __inout_bcount_full_opt(size) _SAL1_Source_(__inout_bcount_full_opt, (size), __inout_bcount_full(size) __pre_except_maybenull)
#define __inout_z_opt _SAL1_Source_(__inout_z_opt, (), __inout_opt __pre __nullterminated __post __nullterminated)
#define __inout_ecount_z_opt(size) _SAL1_Source_(__inout_ecount_z_opt, (size), __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated)
#define __inout_ecount_z_opt(size) _SAL1_Source_(__inout_ecount_z_opt, (size), __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated)
#define __inout_bcount_z_opt(size) _SAL1_Source_(__inout_bcount_z_opt, (size), __inout_bcount_opt(size))
#define __inout_nz_opt _SAL1_Source_(__inout_nz_opt, (), __inout_opt)
#define __inout_ecount_nz_opt(size) _SAL1_Source_(__inout_ecount_nz_opt, (size), __inout_ecount_opt(size))
#define __inout_bcount_nz_opt(size) _SAL1_Source_(__inout_bcount_nz_opt, (size), __inout_bcount_opt(size))
#define __deref_ecount(size) _SAL1_Source_(__deref_ecount, (size), _Notref_ __ecount(1) __post _Notref_ __elem_readableTo(1) __post _Notref_ __deref _Notref_ __notnull __post __deref __elem_writableTo(size))
#define __deref_bcount(size) _SAL1_Source_(__deref_bcount, (size), _Notref_ __ecount(1) __post _Notref_ __elem_readableTo(1) __post _Notref_ __deref _Notref_ __notnull __post __deref __byte_writableTo(size))
#define __deref_out _SAL1_Source_(__deref_out, (), _Outptr_)
#define __deref_out_ecount(size) _SAL1_Source_(__deref_out_ecount, (size), _Outptr_result_buffer_(size))
#define __deref_out_bcount(size) _SAL1_Source_(__deref_out_bcount, (size), _Outptr_result_bytebuffer_(size))
#define __deref_out_ecount_part(size,length) _SAL1_Source_(__deref_out_ecount_part, (size,length), _Outptr_result_buffer_to_(size,length))
#define __deref_out_bcount_part(size,length) _SAL1_Source_(__deref_out_bcount_part, (size,length), _Outptr_result_bytebuffer_to_(size,length))
#define __deref_out_ecount_full(size) _SAL1_Source_(__deref_out_ecount_full, (size), __deref_out_ecount_part(size,size))
#define __deref_out_bcount_full(size) _SAL1_Source_(__deref_out_bcount_full, (size), __deref_out_bcount_part(size,size))
#define __deref_out_z _SAL1_Source_(__deref_out_z, (), _Outptr_result_z_)
#define __deref_out_ecount_z(size) _SAL1_Source_(__deref_out_ecount_z, (size), __deref_out_ecount(size) __post __deref __nullterminated)
#define __deref_out_bcount_z(size) _SAL1_Source_(__deref_out_bcount_z, (size), __deref_out_bcount(size) __post __deref __nullterminated)
#define __deref_out_nz _SAL1_Source_(__deref_out_nz, (), __deref_out)
#define __deref_out_ecount_nz(size) _SAL1_Source_(__deref_out_ecount_nz, (size), __deref_out_ecount(size))
#define __deref_out_bcount_nz(size) _SAL1_Source_(__deref_out_bcount_nz, (size), __deref_out_ecount(size))
#define __deref_inout _SAL1_Source_(__deref_inout, (), _Notref_ __notnull _Notref_ __elem_readableTo(1) __pre __deref __valid __post _Notref_ __deref __valid __refparam)
#define __deref_inout_z _SAL1_Source_(__deref_inout_z, (), __deref_inout __pre __deref __nullterminated __post _Notref_ __deref __nullterminated)
#define __deref_inout_ecount(size) _SAL1_Source_(__deref_inout_ecount, (size), __deref_inout __pre __deref __elem_writableTo(size) __post _Notref_ __deref __elem_writableTo(size))
#define __deref_inout_bcount(size) _SAL1_Source_(__deref_inout_bcount, (size), __deref_inout __pre __deref __byte_writableTo(size) __post _Notref_ __deref __byte_writableTo(size))
#define __deref_inout_ecount_part(size,length) _SAL1_Source_(__deref_inout_ecount_part, (size,length), __deref_inout_ecount(size) __pre __deref __elem_readableTo(length) __post __deref __elem_readableTo(length))
#define __deref_inout_bcount_part(size,length) _SAL1_Source_(__deref_inout_bcount_part, (size,length), __deref_inout_bcount(size) __pre __deref __byte_readableTo(length) __post __deref __byte_readableTo(length))
#define __deref_inout_ecount_full(size) _SAL1_Source_(__deref_inout_ecount_full, (size), __deref_inout_ecount_part(size,size))
#define __deref_inout_bcount_full(size) _SAL1_Source_(__deref_inout_bcount_full, (size), __deref_inout_bcount_part(size,size))
#define __deref_inout_ecount_z(size) _SAL1_Source_(__deref_inout_ecount_z, (size), __deref_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_bcount_z(size) _SAL1_Source_(__deref_inout_bcount_z, (size), __deref_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_nz _SAL1_Source_(__deref_inout_nz, (), __deref_inout)
#define __deref_inout_ecount_nz(size) _SAL1_Source_(__deref_inout_ecount_nz, (size), __deref_inout_ecount(size))
#define __deref_inout_bcount_nz(size) _SAL1_Source_(__deref_inout_bcount_nz, (size), __deref_inout_ecount(size))
#define __deref_ecount_opt(size) _SAL1_Source_(__deref_ecount_opt, (size), __deref_ecount(size) __post_deref_except_maybenull)
#define __deref_bcount_opt(size) _SAL1_Source_(__deref_bcount_opt, (size), __deref_bcount(size) __post_deref_except_maybenull)
#define __deref_out_opt _SAL1_Source_(__deref_out_opt, (), __deref_out __post_deref_except_maybenull)
#define __deref_out_ecount_opt(size) _SAL1_Source_(__deref_out_ecount_opt, (size), __deref_out_ecount(size) __post_deref_except_maybenull)
#define __deref_out_bcount_opt(size) _SAL1_Source_(__deref_out_bcount_opt, (size), __deref_out_bcount(size) __post_deref_except_maybenull)
#define __deref_out_ecount_part_opt(size,length) _SAL1_Source_(__deref_out_ecount_part_opt, (size,length), __deref_out_ecount_part(size,length) __post_deref_except_maybenull)
#define __deref_out_bcount_part_opt(size,length) _SAL1_Source_(__deref_out_bcount_part_opt, (size,length), __deref_out_bcount_part(size,length) __post_deref_except_maybenull)
#define __deref_out_ecount_full_opt(size) _SAL1_Source_(__deref_out_ecount_full_opt, (size), __deref_out_ecount_full(size) __post_deref_except_maybenull)
#define __deref_out_bcount_full_opt(size) _SAL1_Source_(__deref_out_bcount_full_opt, (size), __deref_out_bcount_full(size) __post_deref_except_maybenull)
#define __deref_out_z_opt _SAL1_Source_(__deref_out_z_opt, (), _Outptr_result_maybenull_z_)
#define __deref_out_ecount_z_opt(size) _SAL1_Source_(__deref_out_ecount_z_opt, (size), __deref_out_ecount_opt(size) __post __deref __nullterminated)
#define __deref_out_bcount_z_opt(size) _SAL1_Source_(__deref_out_bcount_z_opt, (size), __deref_out_bcount_opt(size) __post __deref __nullterminated)
#define __deref_out_nz_opt _SAL1_Source_(__deref_out_nz_opt, (), __deref_out_opt)
#define __deref_out_ecount_nz_opt(size) _SAL1_Source_(__deref_out_ecount_nz_opt, (size), __deref_out_ecount_opt(size))
#define __deref_out_bcount_nz_opt(size) _SAL1_Source_(__deref_out_bcount_nz_opt, (size), __deref_out_bcount_opt(size))
#define __deref_inout_opt _SAL1_Source_(__deref_inout_opt, (), __deref_inout __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_ecount_opt(size) _SAL1_Source_(__deref_inout_ecount_opt, (size), __deref_inout_ecount(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_bcount_opt(size) _SAL1_Source_(__deref_inout_bcount_opt, (size), __deref_inout_bcount(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_ecount_part_opt(size,length) _SAL1_Source_(__deref_inout_ecount_part_opt, (size,length), __deref_inout_ecount_part(size,length) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_bcount_part_opt(size,length) _SAL1_Source_(__deref_inout_bcount_part_opt, (size,length), __deref_inout_bcount_part(size,length) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_ecount_full_opt(size) _SAL1_Source_(__deref_inout_ecount_full_opt, (size), __deref_inout_ecount_full(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_bcount_full_opt(size) _SAL1_Source_(__deref_inout_bcount_full_opt, (size), __deref_inout_bcount_full(size) __pre_deref_except_maybenull __post_deref_except_maybenull)
#define __deref_inout_z_opt _SAL1_Source_(__deref_inout_z_opt, (), __deref_inout_opt __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_ecount_z_opt(size) _SAL1_Source_(__deref_inout_ecount_z_opt, (size), __deref_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_bcount_z_opt(size) _SAL1_Source_(__deref_inout_bcount_z_opt, (size), __deref_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_inout_nz_opt _SAL1_Source_(__deref_inout_nz_opt, (), __deref_inout_opt)
#define __deref_inout_ecount_nz_opt(size) _SAL1_Source_(__deref_inout_ecount_nz_opt, (size), __deref_inout_ecount_opt(size))
#define __deref_inout_bcount_nz_opt(size) _SAL1_Source_(__deref_inout_bcount_nz_opt, (size), __deref_inout_bcount_opt(size))
#define __deref_opt_ecount(size) _SAL1_Source_(__deref_opt_ecount, (size), __deref_ecount(size) __pre_except_maybenull)
#define __deref_opt_bcount(size) _SAL1_Source_(__deref_opt_bcount, (size), __deref_bcount(size) __pre_except_maybenull)
#define __deref_opt_out _SAL1_Source_(__deref_opt_out, (), _Outptr_opt_)
#define __deref_opt_out_z _SAL1_Source_(__deref_opt_out_z, (), _Outptr_opt_result_z_)
#define __deref_opt_out_ecount(size) _SAL1_Source_(__deref_opt_out_ecount, (size), __deref_out_ecount(size) __pre_except_maybenull)
#define __deref_opt_out_bcount(size) _SAL1_Source_(__deref_opt_out_bcount, (size), __deref_out_bcount(size) __pre_except_maybenull)
#define __deref_opt_out_ecount_part(size,length) _SAL1_Source_(__deref_opt_out_ecount_part, (size,length), __deref_out_ecount_part(size,length) __pre_except_maybenull)
#define __deref_opt_out_bcount_part(size,length) _SAL1_Source_(__deref_opt_out_bcount_part, (size,length), __deref_out_bcount_part(size,length) __pre_except_maybenull)
#define __deref_opt_out_ecount_full(size) _SAL1_Source_(__deref_opt_out_ecount_full, (size), __deref_out_ecount_full(size) __pre_except_maybenull)
#define __deref_opt_out_bcount_full(size) _SAL1_Source_(__deref_opt_out_bcount_full, (size), __deref_out_bcount_full(size) __pre_except_maybenull)
#define __deref_opt_inout _SAL1_Source_(__deref_opt_inout, (), _Inout_opt_)
#define __deref_opt_inout_ecount(size) _SAL1_Source_(__deref_opt_inout_ecount, (size), __deref_inout_ecount(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount(size) _SAL1_Source_(__deref_opt_inout_bcount, (size), __deref_inout_bcount(size) __pre_except_maybenull)
#define __deref_opt_inout_ecount_part(size,length) _SAL1_Source_(__deref_opt_inout_ecount_part, (size,length), __deref_inout_ecount_part(size,length) __pre_except_maybenull)
#define __deref_opt_inout_bcount_part(size,length) _SAL1_Source_(__deref_opt_inout_bcount_part, (size,length), __deref_inout_bcount_part(size,length) __pre_except_maybenull)
#define __deref_opt_inout_ecount_full(size) _SAL1_Source_(__deref_opt_inout_ecount_full, (size), __deref_inout_ecount_full(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount_full(size) _SAL1_Source_(__deref_opt_inout_bcount_full, (size), __deref_inout_bcount_full(size) __pre_except_maybenull)
#define __deref_opt_inout_z _SAL1_Source_(__deref_opt_inout_z, (), __deref_opt_inout __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_ecount_z(size) _SAL1_Source_(__deref_opt_inout_ecount_z, (size), __deref_opt_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_bcount_z(size) _SAL1_Source_(__deref_opt_inout_bcount_z, (size), __deref_opt_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_nz _SAL1_Source_(__deref_opt_inout_nz, (), __deref_opt_inout)
#define __deref_opt_inout_ecount_nz(size) _SAL1_Source_(__deref_opt_inout_ecount_nz, (size), __deref_opt_inout_ecount(size))
#define __deref_opt_inout_bcount_nz(size) _SAL1_Source_(__deref_opt_inout_bcount_nz, (size), __deref_opt_inout_bcount(size))
#define __deref_opt_ecount_opt(size) _SAL1_Source_(__deref_opt_ecount_opt, (size), __deref_ecount_opt(size) __pre_except_maybenull)
#define __deref_opt_bcount_opt(size) _SAL1_Source_(__deref_opt_bcount_opt, (size), __deref_bcount_opt(size) __pre_except_maybenull)
#define __deref_opt_out_opt _SAL1_Source_(__deref_opt_out_opt, (), _Outptr_opt_result_maybenull_)
#define __deref_opt_out_ecount_opt(size) _SAL1_Source_(__deref_opt_out_ecount_opt, (size), __deref_out_ecount_opt(size) __pre_except_maybenull)
#define __deref_opt_out_bcount_opt(size) _SAL1_Source_(__deref_opt_out_bcount_opt, (size), __deref_out_bcount_opt(size) __pre_except_maybenull)
#define __deref_opt_out_ecount_part_opt(size,length) _SAL1_Source_(__deref_opt_out_ecount_part_opt, (size,length), __deref_out_ecount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_out_bcount_part_opt(size,length) _SAL1_Source_(__deref_opt_out_bcount_part_opt, (size,length), __deref_out_bcount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_out_ecount_full_opt(size) _SAL1_Source_(__deref_opt_out_ecount_full_opt, (size), __deref_out_ecount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_out_bcount_full_opt(size) _SAL1_Source_(__deref_opt_out_bcount_full_opt, (size), __deref_out_bcount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_out_z_opt _SAL1_Source_(__deref_opt_out_z_opt, (), __post __deref __valid __refparam __pre_except_maybenull __pre_deref_except_maybenull __post_deref_except_maybenull __post __deref __nullterminated)
#define __deref_opt_out_ecount_z_opt(size) _SAL1_Source_(__deref_opt_out_ecount_z_opt, (size), __deref_opt_out_ecount_opt(size) __post __deref __nullterminated)
#define __deref_opt_out_bcount_z_opt(size) _SAL1_Source_(__deref_opt_out_bcount_z_opt, (size), __deref_opt_out_bcount_opt(size) __post __deref __nullterminated)
#define __deref_opt_out_nz_opt _SAL1_Source_(__deref_opt_out_nz_opt, (), __deref_opt_out_opt)
#define __deref_opt_out_ecount_nz_opt(size) _SAL1_Source_(__deref_opt_out_ecount_nz_opt, (size), __deref_opt_out_ecount_opt(size))
#define __deref_opt_out_bcount_nz_opt(size) _SAL1_Source_(__deref_opt_out_bcount_nz_opt, (size), __deref_opt_out_bcount_opt(size))
#define __deref_opt_inout_opt _SAL1_Source_(__deref_opt_inout_opt, (), __deref_inout_opt __pre_except_maybenull)
#define __deref_opt_inout_ecount_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_opt, (size), __deref_inout_ecount_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_opt, (size), __deref_inout_bcount_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_ecount_part_opt(size,length) _SAL1_Source_(__deref_opt_inout_ecount_part_opt, (size,length), __deref_inout_ecount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_inout_bcount_part_opt(size,length) _SAL1_Source_(__deref_opt_inout_bcount_part_opt, (size,length), __deref_inout_bcount_part_opt(size,length) __pre_except_maybenull)
#define __deref_opt_inout_ecount_full_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_full_opt, (size), __deref_inout_ecount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_bcount_full_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_full_opt, (size), __deref_inout_bcount_full_opt(size) __pre_except_maybenull)
#define __deref_opt_inout_z_opt _SAL1_Source_(__deref_opt_inout_z_opt, (), __deref_opt_inout_opt __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_ecount_z_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_z_opt, (size), __deref_opt_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_bcount_z_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_z_opt, (size), __deref_opt_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)
#define __deref_opt_inout_nz_opt _SAL1_Source_(__deref_opt_inout_nz_opt, (), __deref_opt_inout_opt)
#define __deref_opt_inout_ecount_nz_opt(size) _SAL1_Source_(__deref_opt_inout_ecount_nz_opt, (size), __deref_opt_inout_ecount_opt(size))
#define __deref_opt_inout_bcount_nz_opt(size) _SAL1_Source_(__deref_opt_inout_bcount_nz_opt, (size), __deref_opt_inout_bcount_opt(size))
/*
-------------------------------------------------------------------------------
Advanced Annotation Definitions
Any of these may be used to directly annotate functions, and may be used in
combination with each other or with regular buffer macros. For an explanation
of each annotation, see the advanced annotations section.
-------------------------------------------------------------------------------
*/
#define __success(expr) _Success_(expr)
#define __nullterminated _Null_terminated_
#define __nullnullterminated
#define __clr_reserved _SAL1_Source_(__reserved, (), _Reserved_)
#define __checkReturn _SAL1_Source_(__checkReturn, (), _Check_return_)
#define __typefix(ctype) _SAL1_Source_(__typefix, (ctype), __inner_typefix(ctype))
#define __override __inner_override
#define __callback __inner_callback
#define __format_string _Printf_format_string_
#define __blocksOn(resource) __inner_blocksOn(resource)
#define __control_entrypoint(category) __inner_control_entrypoint(category)
#define __data_entrypoint(category) __inner_data_entrypoint(category)
#define __useHeader _Use_decl_anno_impl_
#define __on_failure(annotes) _On_failure_impl_(annotes _SAL_nop_impl_)
#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) (0)
#endif
#ifndef __fallthrough // [
#if __has_cpp_attribute(fallthrough)
#define __fallthrough [[fallthrough]]
#else
#define __fallthrough
#endif
#endif // ]
#ifndef __analysis_assume // [
#ifdef _PREFAST_ // [
#define __analysis_assume(expr) __assume(expr)
#else // ][
#define __analysis_assume(expr)
#endif // ]
#endif // ]
#ifndef _Analysis_assume_ // [
#ifdef _PREFAST_ // [
#define _Analysis_assume_(expr) __assume(expr)
#else // ][
#define _Analysis_assume_(expr)
#endif // ]
#endif // ]
#define _Analysis_noreturn_ _SAL2_Source_(_Analysis_noreturn_, (), _SA_annotes0(SAL_terminates))
#ifdef _PREFAST_ // [
__inline __nothrow
void __AnalysisAssumeNullterminated(_Post_ __nullterminated void *p);
#define _Analysis_assume_nullterminated_(x) __AnalysisAssumeNullterminated(x)
#else // ][
#define _Analysis_assume_nullterminated_(x)
#endif // ]
//
// Set the analysis mode (global flags to analysis).
// They take effect at the point of declaration; use at global scope
// as a declaration.
//
// Synthesize a unique symbol.
#define ___MKID(x, y) x ## y
#define __MKID(x, y) ___MKID(x, y)
#define __GENSYM(x) __MKID(x, __COUNTER__)
__ANNOTATION(SAL_analysisMode(__AuToQuOtE __In_impl_ char *mode);)
#define _Analysis_mode_impl_(mode) _SA_annotes1(SAL_analysisMode, #mode)
#define _Analysis_mode_(mode) \
typedef _Analysis_mode_impl_(mode) int \
__GENSYM(__prefast_analysis_mode_flag);
// The following are predefined:
// _Analysis_operator_new_throw_ (operator new throws)
// _Analysis_operator_new_null_ (operator new returns null)
// _Analysis_operator_new_never_fails_ (operator new never fails)
//
// Function class annotations.
__ANNOTATION(SAL_functionClassNew(__In_impl_ char*);)
__PRIMOP(int, _In_function_class_(__In_impl_ char*);)
#define _In_function_class_(x) _In_function_class_(#x)
#define _Function_class_(x) _SA_annotes1(SAL_functionClassNew, #x)
/*
* interlocked operand used in interlocked instructions
*/
//#define _Interlocked_operand_ _Pre_ _SA_annotes0(SAL_interlocked)
#define _Enum_is_bitflag_ _SA_annotes0(SAL_enumIsBitflag)
#define _Strict_type_match_ _SA_annotes0(SAL_strictType2)
#define _Maybe_raises_SEH_exception_ _Pre_ _SA_annotes1(SAL_inTry,__yes)
#define _Raises_SEH_exception_ _Group_(_Maybe_raises_SEH_exception_ _Analysis_noreturn_)
#ifdef __cplusplus // [
}
#endif // ]
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/prebuilt/inc/mscoree.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 8.00.0603 */
/* @@MIDL_FILE_HEADING( ) */
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif /* __RPCNDR_H_VERSION__ */
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __mscoree_h__
#define __mscoree_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __ICLRRuntimeHost_FWD_DEFINED__
#define __ICLRRuntimeHost_FWD_DEFINED__
typedef interface ICLRRuntimeHost ICLRRuntimeHost;
#endif /* __ICLRRuntimeHost_FWD_DEFINED__ */
#ifndef __ICLRRuntimeHost2_FWD_DEFINED__
#define __ICLRRuntimeHost2_FWD_DEFINED__
typedef interface ICLRRuntimeHost2 ICLRRuntimeHost2;
#endif /* __ICLRRuntimeHost2_FWD_DEFINED__ */
#ifndef __ICLRRuntimeHost4_FWD_DEFINED__
#define __ICLRRuntimeHost4_FWD_DEFINED__
typedef interface ICLRRuntimeHost4 ICLRRuntimeHost4;
#endif /* __ICLRRuntimeHost4_FWD_DEFINED__ */
/* header files for imported files */
#include "unknwn.h"
#ifdef __cplusplus
extern "C"{
#endif
/* interface __MIDL_itf_mscoree_0000_0000 */
/* [local] */
struct IActivationFactory;
struct IHostControl;
struct ICLRControl;
EXTERN_GUID(IID_ICLRRuntimeHost, 0x90F1A06C, 0x7712, 0x4762, 0x86, 0xB5, 0x7A, 0x5E, 0xBA, 0x6B, 0xDB, 0x02);
EXTERN_GUID(IID_ICLRRuntimeHost2, 0x712AB73F, 0x2C22, 0x4807, 0xAD, 0x7E, 0xF5, 0x01, 0xD7, 0xb7, 0x2C, 0x2D);
EXTERN_GUID(IID_ICLRRuntimeHost4, 0x64F6D366, 0xD7C2, 0x4F1F, 0xB4, 0xB2, 0xE8, 0x16, 0x0C, 0xAC, 0x43, 0xAF);
typedef HRESULT (STDAPICALLTYPE *FnGetCLRRuntimeHost)(REFIID riid, IUnknown **pUnk);
typedef HRESULT ( __stdcall *FExecuteInAppDomainCallback )(
void *cookie);
typedef /* [public][public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0001
{
STARTUP_CONCURRENT_GC = 0x1,
STARTUP_LOADER_OPTIMIZATION_MASK = ( 0x3 << 1 ) ,
STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN = ( 0x1 << 1 ) ,
STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN = ( 0x2 << 1 ) ,
STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST = ( 0x3 << 1 ) ,
STARTUP_LOADER_SAFEMODE = 0x10,
STARTUP_LOADER_SETPREFERENCE = 0x100,
STARTUP_SERVER_GC = 0x1000,
STARTUP_HOARD_GC_VM = 0x2000,
STARTUP_SINGLE_VERSION_HOSTING_INTERFACE = 0x4000,
STARTUP_LEGACY_IMPERSONATION = 0x10000,
STARTUP_DISABLE_COMMITTHREADSTACK = 0x20000,
STARTUP_ALWAYSFLOW_IMPERSONATION = 0x40000,
STARTUP_TRIM_GC_COMMIT = 0x80000,
STARTUP_ETW = 0x100000,
STARTUP_ARM = 0x400000,
STARTUP_SINGLE_APPDOMAIN = 0x800000,
STARTUP_APPX_APP_MODEL = 0x1000000,
STARTUP_DISABLE_RANDOMIZED_STRING_HASHING = 0x2000000
} STARTUP_FLAGS;
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0002
{
APPDOMAIN_SECURITY_DEFAULT = 0,
APPDOMAIN_SECURITY_SANDBOXED = 0x1,
APPDOMAIN_SECURITY_FORBID_CROSSAD_REVERSE_PINVOKE = 0x2,
APPDOMAIN_IGNORE_UNHANDLED_EXCEPTIONS = 0x4,
APPDOMAIN_FORCE_TRIVIAL_WAIT_OPERATIONS = 0x8,
APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP = 0x10,
APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS = 0x40,
APPDOMAIN_ENABLE_ASSEMBLY_LOADFILE = 0x80,
APPDOMAIN_DISABLE_TRANSPARENCY_ENFORCEMENT = 0x100
} APPDOMAIN_SECURITY_FLAGS;
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0003
{
WAIT_MSGPUMP = 0x1,
WAIT_ALERTABLE = 0x2,
WAIT_NOTINDEADLOCK = 0x4
} WAIT_OPTION;
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0004
{
DUMP_FLAVOR_Mini = 0,
DUMP_FLAVOR_CriticalCLRState = 1,
DUMP_FLAVOR_NonHeapCLRState = 2,
DUMP_FLAVOR_Default = DUMP_FLAVOR_Mini
} ECustomDumpFlavor;
#define BucketParamsCount ( 10 )
#define BucketParamLength ( 255 )
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0005
{
Parameter1 = 0,
Parameter2 = ( Parameter1 + 1 ) ,
Parameter3 = ( Parameter2 + 1 ) ,
Parameter4 = ( Parameter3 + 1 ) ,
Parameter5 = ( Parameter4 + 1 ) ,
Parameter6 = ( Parameter5 + 1 ) ,
Parameter7 = ( Parameter6 + 1 ) ,
Parameter8 = ( Parameter7 + 1 ) ,
Parameter9 = ( Parameter8 + 1 ) ,
InvalidBucketParamIndex = ( Parameter9 + 1 )
} BucketParameterIndex;
typedef struct _BucketParameters
{
BOOL fInited;
WCHAR pszEventTypeName[ 255 ];
WCHAR pszParams[ 10 ][ 255 ];
} BucketParameters;
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0000_v0_0_s_ifspec;
#ifndef __ICLRRuntimeHost_INTERFACE_DEFINED__
#define __ICLRRuntimeHost_INTERFACE_DEFINED__
/* interface ICLRRuntimeHost */
/* [object][local][unique][helpstring][version][uuid] */
EXTERN_C const IID IID_ICLRRuntimeHost;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("90F1A06C-7712-4762-86B5-7A5EBA6BDB02")
ICLRRuntimeHost : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Start( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Stop( void) = 0;
virtual HRESULT STDMETHODCALLTYPE SetHostControl(
/* [in] */ IHostControl *pHostControl) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCLRControl(
/* [out] */ ICLRControl **pCLRControl) = 0;
virtual HRESULT STDMETHODCALLTYPE UnloadAppDomain(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteInAppDomain(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurrentAppDomainId(
/* [out] */ DWORD *pdwAppDomainId) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteApplication(
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteInDefaultAppDomain(
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue) = 0;
};
#else /* C style interface */
typedef struct ICLRRuntimeHostVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ICLRRuntimeHost * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ICLRRuntimeHost * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ICLRRuntimeHost * This);
HRESULT ( STDMETHODCALLTYPE *Start )(
ICLRRuntimeHost * This);
HRESULT ( STDMETHODCALLTYPE *Stop )(
ICLRRuntimeHost * This);
HRESULT ( STDMETHODCALLTYPE *SetHostControl )(
ICLRRuntimeHost * This,
/* [in] */ IHostControl *pHostControl);
HRESULT ( STDMETHODCALLTYPE *GetCLRControl )(
ICLRRuntimeHost * This,
/* [out] */ ICLRControl **pCLRControl);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain )(
ICLRRuntimeHost * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone);
HRESULT ( STDMETHODCALLTYPE *ExecuteInAppDomain )(
ICLRRuntimeHost * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie);
HRESULT ( STDMETHODCALLTYPE *GetCurrentAppDomainId )(
ICLRRuntimeHost * This,
/* [out] */ DWORD *pdwAppDomainId);
HRESULT ( STDMETHODCALLTYPE *ExecuteApplication )(
ICLRRuntimeHost * This,
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *ExecuteInDefaultAppDomain )(
ICLRRuntimeHost * This,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue);
END_INTERFACE
} ICLRRuntimeHostVtbl;
interface ICLRRuntimeHost
{
CONST_VTBL struct ICLRRuntimeHostVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ICLRRuntimeHost_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ICLRRuntimeHost_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ICLRRuntimeHost_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ICLRRuntimeHost_Start(This) \
( (This)->lpVtbl -> Start(This) )
#define ICLRRuntimeHost_Stop(This) \
( (This)->lpVtbl -> Stop(This) )
#define ICLRRuntimeHost_SetHostControl(This,pHostControl) \
( (This)->lpVtbl -> SetHostControl(This,pHostControl) )
#define ICLRRuntimeHost_GetCLRControl(This,pCLRControl) \
( (This)->lpVtbl -> GetCLRControl(This,pCLRControl) )
#define ICLRRuntimeHost_UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) \
( (This)->lpVtbl -> UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) )
#define ICLRRuntimeHost_ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) \
( (This)->lpVtbl -> ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) )
#define ICLRRuntimeHost_GetCurrentAppDomainId(This,pdwAppDomainId) \
( (This)->lpVtbl -> GetCurrentAppDomainId(This,pdwAppDomainId) )
#define ICLRRuntimeHost_ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) \
( (This)->lpVtbl -> ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) )
#define ICLRRuntimeHost_ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) \
( (This)->lpVtbl -> ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ICLRRuntimeHost_INTERFACE_DEFINED__ */
#ifndef __ICLRRuntimeHost2_INTERFACE_DEFINED__
#define __ICLRRuntimeHost2_INTERFACE_DEFINED__
/* interface ICLRRuntimeHost2 */
/* [local][unique][helpstring][version][uuid][object] */
EXTERN_C const IID IID_ICLRRuntimeHost2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("712AB73F-2C22-4807-AD7E-F501D7B72C2D")
ICLRRuntimeHost2 : public ICLRRuntimeHost
{
public:
virtual HRESULT STDMETHODCALLTYPE CreateAppDomainWithManager(
/* [in] */ LPCWSTR wszFriendlyName,
/* [in] */ DWORD dwFlags,
/* [in] */ LPCWSTR wszAppDomainManagerAssemblyName,
/* [in] */ LPCWSTR wszAppDomainManagerTypeName,
/* [in] */ int nProperties,
/* [in] */ LPCWSTR *pPropertyNames,
/* [in] */ LPCWSTR *pPropertyValues,
/* [out] */ DWORD *pAppDomainID) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateDelegate(
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszAssemblyName,
/* [in] */ LPCWSTR wszClassName,
/* [in] */ LPCWSTR wszMethodName,
/* [out] */ INT_PTR *fnPtr) = 0;
virtual HRESULT STDMETHODCALLTYPE Authenticate(
/* [in] */ ULONGLONG authKey) = 0;
virtual HRESULT STDMETHODCALLTYPE RegisterMacEHPort( void) = 0;
virtual HRESULT STDMETHODCALLTYPE SetStartupFlags(
/* [in] */ STARTUP_FLAGS dwFlags) = 0;
virtual HRESULT STDMETHODCALLTYPE DllGetActivationFactory(
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszTypeName,
/* [out] */ IActivationFactory **factory) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteAssembly(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ int argc,
/* [in] */ LPCWSTR *argv,
/* [out] */ DWORD *pReturnValue) = 0;
};
#else /* C style interface */
typedef struct ICLRRuntimeHost2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ICLRRuntimeHost2 * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ICLRRuntimeHost2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *Start )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *Stop )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *SetHostControl )(
ICLRRuntimeHost2 * This,
/* [in] */ IHostControl *pHostControl);
HRESULT ( STDMETHODCALLTYPE *GetCLRControl )(
ICLRRuntimeHost2 * This,
/* [out] */ ICLRControl **pCLRControl);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone);
HRESULT ( STDMETHODCALLTYPE *ExecuteInAppDomain )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie);
HRESULT ( STDMETHODCALLTYPE *GetCurrentAppDomainId )(
ICLRRuntimeHost2 * This,
/* [out] */ DWORD *pdwAppDomainId);
HRESULT ( STDMETHODCALLTYPE *ExecuteApplication )(
ICLRRuntimeHost2 * This,
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *ExecuteInDefaultAppDomain )(
ICLRRuntimeHost2 * This,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *CreateAppDomainWithManager )(
ICLRRuntimeHost2 * This,
/* [in] */ LPCWSTR wszFriendlyName,
/* [in] */ DWORD dwFlags,
/* [in] */ LPCWSTR wszAppDomainManagerAssemblyName,
/* [in] */ LPCWSTR wszAppDomainManagerTypeName,
/* [in] */ int nProperties,
/* [in] */ LPCWSTR *pPropertyNames,
/* [in] */ LPCWSTR *pPropertyValues,
/* [out] */ DWORD *pAppDomainID);
HRESULT ( STDMETHODCALLTYPE *CreateDelegate )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszAssemblyName,
/* [in] */ LPCWSTR wszClassName,
/* [in] */ LPCWSTR wszMethodName,
/* [out] */ INT_PTR *fnPtr);
HRESULT ( STDMETHODCALLTYPE *Authenticate )(
ICLRRuntimeHost2 * This,
/* [in] */ ULONGLONG authKey);
HRESULT ( STDMETHODCALLTYPE *RegisterMacEHPort )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *SetStartupFlags )(
ICLRRuntimeHost2 * This,
/* [in] */ STARTUP_FLAGS dwFlags);
HRESULT ( STDMETHODCALLTYPE *DllGetActivationFactory )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszTypeName,
/* [out] */ IActivationFactory **factory);
HRESULT ( STDMETHODCALLTYPE *ExecuteAssembly )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ int argc,
/* [in] */ LPCWSTR *argv,
/* [out] */ DWORD *pReturnValue);
END_INTERFACE
} ICLRRuntimeHost2Vtbl;
interface ICLRRuntimeHost2
{
CONST_VTBL struct ICLRRuntimeHost2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ICLRRuntimeHost2_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ICLRRuntimeHost2_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ICLRRuntimeHost2_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ICLRRuntimeHost2_Start(This) \
( (This)->lpVtbl -> Start(This) )
#define ICLRRuntimeHost2_Stop(This) \
( (This)->lpVtbl -> Stop(This) )
#define ICLRRuntimeHost2_SetHostControl(This,pHostControl) \
( (This)->lpVtbl -> SetHostControl(This,pHostControl) )
#define ICLRRuntimeHost2_GetCLRControl(This,pCLRControl) \
( (This)->lpVtbl -> GetCLRControl(This,pCLRControl) )
#define ICLRRuntimeHost2_UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) \
( (This)->lpVtbl -> UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) )
#define ICLRRuntimeHost2_ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) \
( (This)->lpVtbl -> ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) )
#define ICLRRuntimeHost2_GetCurrentAppDomainId(This,pdwAppDomainId) \
( (This)->lpVtbl -> GetCurrentAppDomainId(This,pdwAppDomainId) )
#define ICLRRuntimeHost2_ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) \
( (This)->lpVtbl -> ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) )
#define ICLRRuntimeHost2_ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) \
( (This)->lpVtbl -> ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) )
#define ICLRRuntimeHost2_CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) \
( (This)->lpVtbl -> CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) )
#define ICLRRuntimeHost2_CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) \
( (This)->lpVtbl -> CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) )
#define ICLRRuntimeHost2_Authenticate(This,authKey) \
( (This)->lpVtbl -> Authenticate(This,authKey) )
#define ICLRRuntimeHost2_RegisterMacEHPort(This) \
( (This)->lpVtbl -> RegisterMacEHPort(This) )
#define ICLRRuntimeHost2_SetStartupFlags(This,dwFlags) \
( (This)->lpVtbl -> SetStartupFlags(This,dwFlags) )
#define ICLRRuntimeHost2_DllGetActivationFactory(This,appDomainID,wszTypeName,factory) \
( (This)->lpVtbl -> DllGetActivationFactory(This,appDomainID,wszTypeName,factory) )
#define ICLRRuntimeHost2_ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) \
( (This)->lpVtbl -> ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ICLRRuntimeHost2_INTERFACE_DEFINED__ */
#ifndef __ICLRRuntimeHost4_INTERFACE_DEFINED__
#define __ICLRRuntimeHost4_INTERFACE_DEFINED__
/* interface ICLRRuntimeHost4 */
/* [local][unique][helpstring][version][uuid][object] */
EXTERN_C const IID IID_ICLRRuntimeHost4;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("64F6D366-D7C2-4F1F-B4B2-E8160CAC43AF")
ICLRRuntimeHost4 : public ICLRRuntimeHost2
{
public:
virtual HRESULT STDMETHODCALLTYPE UnloadAppDomain2(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone,
/* [out] */ int *pLatchedExitCode) = 0;
};
#else /* C style interface */
typedef struct ICLRRuntimeHost4Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ICLRRuntimeHost4 * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ICLRRuntimeHost4 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *Start )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *Stop )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *SetHostControl )(
ICLRRuntimeHost4 * This,
/* [in] */ IHostControl *pHostControl);
HRESULT ( STDMETHODCALLTYPE *GetCLRControl )(
ICLRRuntimeHost4 * This,
/* [out] */ ICLRControl **pCLRControl);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone);
HRESULT ( STDMETHODCALLTYPE *ExecuteInAppDomain )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie);
HRESULT ( STDMETHODCALLTYPE *GetCurrentAppDomainId )(
ICLRRuntimeHost4 * This,
/* [out] */ DWORD *pdwAppDomainId);
HRESULT ( STDMETHODCALLTYPE *ExecuteApplication )(
ICLRRuntimeHost4 * This,
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *ExecuteInDefaultAppDomain )(
ICLRRuntimeHost4 * This,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *CreateAppDomainWithManager )(
ICLRRuntimeHost4 * This,
/* [in] */ LPCWSTR wszFriendlyName,
/* [in] */ DWORD dwFlags,
/* [in] */ LPCWSTR wszAppDomainManagerAssemblyName,
/* [in] */ LPCWSTR wszAppDomainManagerTypeName,
/* [in] */ int nProperties,
/* [in] */ LPCWSTR *pPropertyNames,
/* [in] */ LPCWSTR *pPropertyValues,
/* [out] */ DWORD *pAppDomainID);
HRESULT ( STDMETHODCALLTYPE *CreateDelegate )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszAssemblyName,
/* [in] */ LPCWSTR wszClassName,
/* [in] */ LPCWSTR wszMethodName,
/* [out] */ INT_PTR *fnPtr);
HRESULT ( STDMETHODCALLTYPE *Authenticate )(
ICLRRuntimeHost4 * This,
/* [in] */ ULONGLONG authKey);
HRESULT ( STDMETHODCALLTYPE *RegisterMacEHPort )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *SetStartupFlags )(
ICLRRuntimeHost4 * This,
/* [in] */ STARTUP_FLAGS dwFlags);
HRESULT ( STDMETHODCALLTYPE *DllGetActivationFactory )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszTypeName,
/* [out] */ IActivationFactory **factory);
HRESULT ( STDMETHODCALLTYPE *ExecuteAssembly )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ int argc,
/* [in] */ LPCWSTR *argv,
/* [out] */ DWORD *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain2 )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone,
/* [out] */ int *pLatchedExitCode);
END_INTERFACE
} ICLRRuntimeHost4Vtbl;
interface ICLRRuntimeHost4
{
CONST_VTBL struct ICLRRuntimeHost4Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ICLRRuntimeHost4_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ICLRRuntimeHost4_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ICLRRuntimeHost4_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ICLRRuntimeHost4_Start(This) \
( (This)->lpVtbl -> Start(This) )
#define ICLRRuntimeHost4_Stop(This) \
( (This)->lpVtbl -> Stop(This) )
#define ICLRRuntimeHost4_SetHostControl(This,pHostControl) \
( (This)->lpVtbl -> SetHostControl(This,pHostControl) )
#define ICLRRuntimeHost4_GetCLRControl(This,pCLRControl) \
( (This)->lpVtbl -> GetCLRControl(This,pCLRControl) )
#define ICLRRuntimeHost4_UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) \
( (This)->lpVtbl -> UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) )
#define ICLRRuntimeHost4_ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) \
( (This)->lpVtbl -> ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) )
#define ICLRRuntimeHost4_GetCurrentAppDomainId(This,pdwAppDomainId) \
( (This)->lpVtbl -> GetCurrentAppDomainId(This,pdwAppDomainId) )
#define ICLRRuntimeHost4_ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) \
( (This)->lpVtbl -> ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) )
#define ICLRRuntimeHost4_ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) \
( (This)->lpVtbl -> ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) )
#define ICLRRuntimeHost4_CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) \
( (This)->lpVtbl -> CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) )
#define ICLRRuntimeHost4_CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) \
( (This)->lpVtbl -> CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) )
#define ICLRRuntimeHost4_Authenticate(This,authKey) \
( (This)->lpVtbl -> Authenticate(This,authKey) )
#define ICLRRuntimeHost4_RegisterMacEHPort(This) \
( (This)->lpVtbl -> RegisterMacEHPort(This) )
#define ICLRRuntimeHost4_SetStartupFlags(This,dwFlags) \
( (This)->lpVtbl -> SetStartupFlags(This,dwFlags) )
#define ICLRRuntimeHost4_DllGetActivationFactory(This,appDomainID,wszTypeName,factory) \
( (This)->lpVtbl -> DllGetActivationFactory(This,appDomainID,wszTypeName,factory) )
#define ICLRRuntimeHost4_ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) \
( (This)->lpVtbl -> ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) )
#define ICLRRuntimeHost4_UnloadAppDomain2(This,dwAppDomainId,fWaitUntilDone,pLatchedExitCode) \
( (This)->lpVtbl -> UnloadAppDomain2(This,dwAppDomainId,fWaitUntilDone,pLatchedExitCode) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ICLRRuntimeHost4_INTERFACE_DEFINED__ */
/* interface __MIDL_itf_mscoree_0000_0003 */
/* [local] */
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0003_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0003_v0_0_s_ifspec;
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 8.00.0603 */
/* @@MIDL_FILE_HEADING( ) */
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif /* __RPCNDR_H_VERSION__ */
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __mscoree_h__
#define __mscoree_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __ICLRRuntimeHost_FWD_DEFINED__
#define __ICLRRuntimeHost_FWD_DEFINED__
typedef interface ICLRRuntimeHost ICLRRuntimeHost;
#endif /* __ICLRRuntimeHost_FWD_DEFINED__ */
#ifndef __ICLRRuntimeHost2_FWD_DEFINED__
#define __ICLRRuntimeHost2_FWD_DEFINED__
typedef interface ICLRRuntimeHost2 ICLRRuntimeHost2;
#endif /* __ICLRRuntimeHost2_FWD_DEFINED__ */
#ifndef __ICLRRuntimeHost4_FWD_DEFINED__
#define __ICLRRuntimeHost4_FWD_DEFINED__
typedef interface ICLRRuntimeHost4 ICLRRuntimeHost4;
#endif /* __ICLRRuntimeHost4_FWD_DEFINED__ */
/* header files for imported files */
#include "unknwn.h"
#ifdef __cplusplus
extern "C"{
#endif
/* interface __MIDL_itf_mscoree_0000_0000 */
/* [local] */
struct IActivationFactory;
struct IHostControl;
struct ICLRControl;
EXTERN_GUID(IID_ICLRRuntimeHost, 0x90F1A06C, 0x7712, 0x4762, 0x86, 0xB5, 0x7A, 0x5E, 0xBA, 0x6B, 0xDB, 0x02);
EXTERN_GUID(IID_ICLRRuntimeHost2, 0x712AB73F, 0x2C22, 0x4807, 0xAD, 0x7E, 0xF5, 0x01, 0xD7, 0xb7, 0x2C, 0x2D);
EXTERN_GUID(IID_ICLRRuntimeHost4, 0x64F6D366, 0xD7C2, 0x4F1F, 0xB4, 0xB2, 0xE8, 0x16, 0x0C, 0xAC, 0x43, 0xAF);
typedef HRESULT (STDAPICALLTYPE *FnGetCLRRuntimeHost)(REFIID riid, IUnknown **pUnk);
typedef HRESULT ( __stdcall *FExecuteInAppDomainCallback )(
void *cookie);
typedef /* [public][public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0001
{
STARTUP_CONCURRENT_GC = 0x1,
STARTUP_LOADER_OPTIMIZATION_MASK = ( 0x3 << 1 ) ,
STARTUP_LOADER_OPTIMIZATION_SINGLE_DOMAIN = ( 0x1 << 1 ) ,
STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN = ( 0x2 << 1 ) ,
STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST = ( 0x3 << 1 ) ,
STARTUP_LOADER_SAFEMODE = 0x10,
STARTUP_LOADER_SETPREFERENCE = 0x100,
STARTUP_SERVER_GC = 0x1000,
STARTUP_HOARD_GC_VM = 0x2000,
STARTUP_SINGLE_VERSION_HOSTING_INTERFACE = 0x4000,
STARTUP_LEGACY_IMPERSONATION = 0x10000,
STARTUP_DISABLE_COMMITTHREADSTACK = 0x20000,
STARTUP_ALWAYSFLOW_IMPERSONATION = 0x40000,
STARTUP_TRIM_GC_COMMIT = 0x80000,
STARTUP_ETW = 0x100000,
STARTUP_ARM = 0x400000,
STARTUP_SINGLE_APPDOMAIN = 0x800000,
STARTUP_APPX_APP_MODEL = 0x1000000,
STARTUP_DISABLE_RANDOMIZED_STRING_HASHING = 0x2000000
} STARTUP_FLAGS;
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0002
{
APPDOMAIN_SECURITY_DEFAULT = 0,
APPDOMAIN_SECURITY_SANDBOXED = 0x1,
APPDOMAIN_SECURITY_FORBID_CROSSAD_REVERSE_PINVOKE = 0x2,
APPDOMAIN_IGNORE_UNHANDLED_EXCEPTIONS = 0x4,
APPDOMAIN_FORCE_TRIVIAL_WAIT_OPERATIONS = 0x8,
APPDOMAIN_ENABLE_PINVOKE_AND_CLASSIC_COMINTEROP = 0x10,
APPDOMAIN_ENABLE_PLATFORM_SPECIFIC_APPS = 0x40,
APPDOMAIN_ENABLE_ASSEMBLY_LOADFILE = 0x80,
APPDOMAIN_DISABLE_TRANSPARENCY_ENFORCEMENT = 0x100
} APPDOMAIN_SECURITY_FLAGS;
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0003
{
WAIT_MSGPUMP = 0x1,
WAIT_ALERTABLE = 0x2,
WAIT_NOTINDEADLOCK = 0x4
} WAIT_OPTION;
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0004
{
DUMP_FLAVOR_Mini = 0,
DUMP_FLAVOR_CriticalCLRState = 1,
DUMP_FLAVOR_NonHeapCLRState = 2,
DUMP_FLAVOR_Default = DUMP_FLAVOR_Mini
} ECustomDumpFlavor;
#define BucketParamsCount ( 10 )
#define BucketParamLength ( 255 )
typedef /* [public] */
enum __MIDL___MIDL_itf_mscoree_0000_0000_0005
{
Parameter1 = 0,
Parameter2 = ( Parameter1 + 1 ) ,
Parameter3 = ( Parameter2 + 1 ) ,
Parameter4 = ( Parameter3 + 1 ) ,
Parameter5 = ( Parameter4 + 1 ) ,
Parameter6 = ( Parameter5 + 1 ) ,
Parameter7 = ( Parameter6 + 1 ) ,
Parameter8 = ( Parameter7 + 1 ) ,
Parameter9 = ( Parameter8 + 1 ) ,
InvalidBucketParamIndex = ( Parameter9 + 1 )
} BucketParameterIndex;
typedef struct _BucketParameters
{
BOOL fInited;
WCHAR pszEventTypeName[ 255 ];
WCHAR pszParams[ 10 ][ 255 ];
} BucketParameters;
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0000_v0_0_s_ifspec;
#ifndef __ICLRRuntimeHost_INTERFACE_DEFINED__
#define __ICLRRuntimeHost_INTERFACE_DEFINED__
/* interface ICLRRuntimeHost */
/* [object][local][unique][helpstring][version][uuid] */
EXTERN_C const IID IID_ICLRRuntimeHost;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("90F1A06C-7712-4762-86B5-7A5EBA6BDB02")
ICLRRuntimeHost : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE Start( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Stop( void) = 0;
virtual HRESULT STDMETHODCALLTYPE SetHostControl(
/* [in] */ IHostControl *pHostControl) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCLRControl(
/* [out] */ ICLRControl **pCLRControl) = 0;
virtual HRESULT STDMETHODCALLTYPE UnloadAppDomain(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteInAppDomain(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurrentAppDomainId(
/* [out] */ DWORD *pdwAppDomainId) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteApplication(
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteInDefaultAppDomain(
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue) = 0;
};
#else /* C style interface */
typedef struct ICLRRuntimeHostVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ICLRRuntimeHost * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ICLRRuntimeHost * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ICLRRuntimeHost * This);
HRESULT ( STDMETHODCALLTYPE *Start )(
ICLRRuntimeHost * This);
HRESULT ( STDMETHODCALLTYPE *Stop )(
ICLRRuntimeHost * This);
HRESULT ( STDMETHODCALLTYPE *SetHostControl )(
ICLRRuntimeHost * This,
/* [in] */ IHostControl *pHostControl);
HRESULT ( STDMETHODCALLTYPE *GetCLRControl )(
ICLRRuntimeHost * This,
/* [out] */ ICLRControl **pCLRControl);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain )(
ICLRRuntimeHost * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone);
HRESULT ( STDMETHODCALLTYPE *ExecuteInAppDomain )(
ICLRRuntimeHost * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie);
HRESULT ( STDMETHODCALLTYPE *GetCurrentAppDomainId )(
ICLRRuntimeHost * This,
/* [out] */ DWORD *pdwAppDomainId);
HRESULT ( STDMETHODCALLTYPE *ExecuteApplication )(
ICLRRuntimeHost * This,
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *ExecuteInDefaultAppDomain )(
ICLRRuntimeHost * This,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue);
END_INTERFACE
} ICLRRuntimeHostVtbl;
interface ICLRRuntimeHost
{
CONST_VTBL struct ICLRRuntimeHostVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ICLRRuntimeHost_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ICLRRuntimeHost_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ICLRRuntimeHost_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ICLRRuntimeHost_Start(This) \
( (This)->lpVtbl -> Start(This) )
#define ICLRRuntimeHost_Stop(This) \
( (This)->lpVtbl -> Stop(This) )
#define ICLRRuntimeHost_SetHostControl(This,pHostControl) \
( (This)->lpVtbl -> SetHostControl(This,pHostControl) )
#define ICLRRuntimeHost_GetCLRControl(This,pCLRControl) \
( (This)->lpVtbl -> GetCLRControl(This,pCLRControl) )
#define ICLRRuntimeHost_UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) \
( (This)->lpVtbl -> UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) )
#define ICLRRuntimeHost_ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) \
( (This)->lpVtbl -> ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) )
#define ICLRRuntimeHost_GetCurrentAppDomainId(This,pdwAppDomainId) \
( (This)->lpVtbl -> GetCurrentAppDomainId(This,pdwAppDomainId) )
#define ICLRRuntimeHost_ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) \
( (This)->lpVtbl -> ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) )
#define ICLRRuntimeHost_ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) \
( (This)->lpVtbl -> ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ICLRRuntimeHost_INTERFACE_DEFINED__ */
#ifndef __ICLRRuntimeHost2_INTERFACE_DEFINED__
#define __ICLRRuntimeHost2_INTERFACE_DEFINED__
/* interface ICLRRuntimeHost2 */
/* [local][unique][helpstring][version][uuid][object] */
EXTERN_C const IID IID_ICLRRuntimeHost2;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("712AB73F-2C22-4807-AD7E-F501D7B72C2D")
ICLRRuntimeHost2 : public ICLRRuntimeHost
{
public:
virtual HRESULT STDMETHODCALLTYPE CreateAppDomainWithManager(
/* [in] */ LPCWSTR wszFriendlyName,
/* [in] */ DWORD dwFlags,
/* [in] */ LPCWSTR wszAppDomainManagerAssemblyName,
/* [in] */ LPCWSTR wszAppDomainManagerTypeName,
/* [in] */ int nProperties,
/* [in] */ LPCWSTR *pPropertyNames,
/* [in] */ LPCWSTR *pPropertyValues,
/* [out] */ DWORD *pAppDomainID) = 0;
virtual HRESULT STDMETHODCALLTYPE CreateDelegate(
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszAssemblyName,
/* [in] */ LPCWSTR wszClassName,
/* [in] */ LPCWSTR wszMethodName,
/* [out] */ INT_PTR *fnPtr) = 0;
virtual HRESULT STDMETHODCALLTYPE Authenticate(
/* [in] */ ULONGLONG authKey) = 0;
virtual HRESULT STDMETHODCALLTYPE RegisterMacEHPort( void) = 0;
virtual HRESULT STDMETHODCALLTYPE SetStartupFlags(
/* [in] */ STARTUP_FLAGS dwFlags) = 0;
virtual HRESULT STDMETHODCALLTYPE DllGetActivationFactory(
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszTypeName,
/* [out] */ IActivationFactory **factory) = 0;
virtual HRESULT STDMETHODCALLTYPE ExecuteAssembly(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ int argc,
/* [in] */ LPCWSTR *argv,
/* [out] */ DWORD *pReturnValue) = 0;
};
#else /* C style interface */
typedef struct ICLRRuntimeHost2Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ICLRRuntimeHost2 * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ICLRRuntimeHost2 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *Start )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *Stop )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *SetHostControl )(
ICLRRuntimeHost2 * This,
/* [in] */ IHostControl *pHostControl);
HRESULT ( STDMETHODCALLTYPE *GetCLRControl )(
ICLRRuntimeHost2 * This,
/* [out] */ ICLRControl **pCLRControl);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone);
HRESULT ( STDMETHODCALLTYPE *ExecuteInAppDomain )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie);
HRESULT ( STDMETHODCALLTYPE *GetCurrentAppDomainId )(
ICLRRuntimeHost2 * This,
/* [out] */ DWORD *pdwAppDomainId);
HRESULT ( STDMETHODCALLTYPE *ExecuteApplication )(
ICLRRuntimeHost2 * This,
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *ExecuteInDefaultAppDomain )(
ICLRRuntimeHost2 * This,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *CreateAppDomainWithManager )(
ICLRRuntimeHost2 * This,
/* [in] */ LPCWSTR wszFriendlyName,
/* [in] */ DWORD dwFlags,
/* [in] */ LPCWSTR wszAppDomainManagerAssemblyName,
/* [in] */ LPCWSTR wszAppDomainManagerTypeName,
/* [in] */ int nProperties,
/* [in] */ LPCWSTR *pPropertyNames,
/* [in] */ LPCWSTR *pPropertyValues,
/* [out] */ DWORD *pAppDomainID);
HRESULT ( STDMETHODCALLTYPE *CreateDelegate )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszAssemblyName,
/* [in] */ LPCWSTR wszClassName,
/* [in] */ LPCWSTR wszMethodName,
/* [out] */ INT_PTR *fnPtr);
HRESULT ( STDMETHODCALLTYPE *Authenticate )(
ICLRRuntimeHost2 * This,
/* [in] */ ULONGLONG authKey);
HRESULT ( STDMETHODCALLTYPE *RegisterMacEHPort )(
ICLRRuntimeHost2 * This);
HRESULT ( STDMETHODCALLTYPE *SetStartupFlags )(
ICLRRuntimeHost2 * This,
/* [in] */ STARTUP_FLAGS dwFlags);
HRESULT ( STDMETHODCALLTYPE *DllGetActivationFactory )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszTypeName,
/* [out] */ IActivationFactory **factory);
HRESULT ( STDMETHODCALLTYPE *ExecuteAssembly )(
ICLRRuntimeHost2 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ int argc,
/* [in] */ LPCWSTR *argv,
/* [out] */ DWORD *pReturnValue);
END_INTERFACE
} ICLRRuntimeHost2Vtbl;
interface ICLRRuntimeHost2
{
CONST_VTBL struct ICLRRuntimeHost2Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ICLRRuntimeHost2_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ICLRRuntimeHost2_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ICLRRuntimeHost2_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ICLRRuntimeHost2_Start(This) \
( (This)->lpVtbl -> Start(This) )
#define ICLRRuntimeHost2_Stop(This) \
( (This)->lpVtbl -> Stop(This) )
#define ICLRRuntimeHost2_SetHostControl(This,pHostControl) \
( (This)->lpVtbl -> SetHostControl(This,pHostControl) )
#define ICLRRuntimeHost2_GetCLRControl(This,pCLRControl) \
( (This)->lpVtbl -> GetCLRControl(This,pCLRControl) )
#define ICLRRuntimeHost2_UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) \
( (This)->lpVtbl -> UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) )
#define ICLRRuntimeHost2_ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) \
( (This)->lpVtbl -> ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) )
#define ICLRRuntimeHost2_GetCurrentAppDomainId(This,pdwAppDomainId) \
( (This)->lpVtbl -> GetCurrentAppDomainId(This,pdwAppDomainId) )
#define ICLRRuntimeHost2_ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) \
( (This)->lpVtbl -> ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) )
#define ICLRRuntimeHost2_ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) \
( (This)->lpVtbl -> ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) )
#define ICLRRuntimeHost2_CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) \
( (This)->lpVtbl -> CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) )
#define ICLRRuntimeHost2_CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) \
( (This)->lpVtbl -> CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) )
#define ICLRRuntimeHost2_Authenticate(This,authKey) \
( (This)->lpVtbl -> Authenticate(This,authKey) )
#define ICLRRuntimeHost2_RegisterMacEHPort(This) \
( (This)->lpVtbl -> RegisterMacEHPort(This) )
#define ICLRRuntimeHost2_SetStartupFlags(This,dwFlags) \
( (This)->lpVtbl -> SetStartupFlags(This,dwFlags) )
#define ICLRRuntimeHost2_DllGetActivationFactory(This,appDomainID,wszTypeName,factory) \
( (This)->lpVtbl -> DllGetActivationFactory(This,appDomainID,wszTypeName,factory) )
#define ICLRRuntimeHost2_ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) \
( (This)->lpVtbl -> ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ICLRRuntimeHost2_INTERFACE_DEFINED__ */
#ifndef __ICLRRuntimeHost4_INTERFACE_DEFINED__
#define __ICLRRuntimeHost4_INTERFACE_DEFINED__
/* interface ICLRRuntimeHost4 */
/* [local][unique][helpstring][version][uuid][object] */
EXTERN_C const IID IID_ICLRRuntimeHost4;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("64F6D366-D7C2-4F1F-B4B2-E8160CAC43AF")
ICLRRuntimeHost4 : public ICLRRuntimeHost2
{
public:
virtual HRESULT STDMETHODCALLTYPE UnloadAppDomain2(
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone,
/* [out] */ int *pLatchedExitCode) = 0;
};
#else /* C style interface */
typedef struct ICLRRuntimeHost4Vtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
ICLRRuntimeHost4 * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
ICLRRuntimeHost4 * This);
ULONG ( STDMETHODCALLTYPE *Release )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *Start )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *Stop )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *SetHostControl )(
ICLRRuntimeHost4 * This,
/* [in] */ IHostControl *pHostControl);
HRESULT ( STDMETHODCALLTYPE *GetCLRControl )(
ICLRRuntimeHost4 * This,
/* [out] */ ICLRControl **pCLRControl);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone);
HRESULT ( STDMETHODCALLTYPE *ExecuteInAppDomain )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ FExecuteInAppDomainCallback pCallback,
/* [in] */ void *cookie);
HRESULT ( STDMETHODCALLTYPE *GetCurrentAppDomainId )(
ICLRRuntimeHost4 * This,
/* [out] */ DWORD *pdwAppDomainId);
HRESULT ( STDMETHODCALLTYPE *ExecuteApplication )(
ICLRRuntimeHost4 * This,
/* [in] */ LPCWSTR pwzAppFullName,
/* [in] */ DWORD dwManifestPaths,
/* [in] */ LPCWSTR *ppwzManifestPaths,
/* [in] */ DWORD dwActivationData,
/* [in] */ LPCWSTR *ppwzActivationData,
/* [out] */ int *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *ExecuteInDefaultAppDomain )(
ICLRRuntimeHost4 * This,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ LPCWSTR pwzTypeName,
/* [in] */ LPCWSTR pwzMethodName,
/* [in] */ LPCWSTR pwzArgument,
/* [out] */ DWORD *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *CreateAppDomainWithManager )(
ICLRRuntimeHost4 * This,
/* [in] */ LPCWSTR wszFriendlyName,
/* [in] */ DWORD dwFlags,
/* [in] */ LPCWSTR wszAppDomainManagerAssemblyName,
/* [in] */ LPCWSTR wszAppDomainManagerTypeName,
/* [in] */ int nProperties,
/* [in] */ LPCWSTR *pPropertyNames,
/* [in] */ LPCWSTR *pPropertyValues,
/* [out] */ DWORD *pAppDomainID);
HRESULT ( STDMETHODCALLTYPE *CreateDelegate )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszAssemblyName,
/* [in] */ LPCWSTR wszClassName,
/* [in] */ LPCWSTR wszMethodName,
/* [out] */ INT_PTR *fnPtr);
HRESULT ( STDMETHODCALLTYPE *Authenticate )(
ICLRRuntimeHost4 * This,
/* [in] */ ULONGLONG authKey);
HRESULT ( STDMETHODCALLTYPE *RegisterMacEHPort )(
ICLRRuntimeHost4 * This);
HRESULT ( STDMETHODCALLTYPE *SetStartupFlags )(
ICLRRuntimeHost4 * This,
/* [in] */ STARTUP_FLAGS dwFlags);
HRESULT ( STDMETHODCALLTYPE *DllGetActivationFactory )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD appDomainID,
/* [in] */ LPCWSTR wszTypeName,
/* [out] */ IActivationFactory **factory);
HRESULT ( STDMETHODCALLTYPE *ExecuteAssembly )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ LPCWSTR pwzAssemblyPath,
/* [in] */ int argc,
/* [in] */ LPCWSTR *argv,
/* [out] */ DWORD *pReturnValue);
HRESULT ( STDMETHODCALLTYPE *UnloadAppDomain2 )(
ICLRRuntimeHost4 * This,
/* [in] */ DWORD dwAppDomainId,
/* [in] */ BOOL fWaitUntilDone,
/* [out] */ int *pLatchedExitCode);
END_INTERFACE
} ICLRRuntimeHost4Vtbl;
interface ICLRRuntimeHost4
{
CONST_VTBL struct ICLRRuntimeHost4Vtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ICLRRuntimeHost4_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define ICLRRuntimeHost4_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define ICLRRuntimeHost4_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define ICLRRuntimeHost4_Start(This) \
( (This)->lpVtbl -> Start(This) )
#define ICLRRuntimeHost4_Stop(This) \
( (This)->lpVtbl -> Stop(This) )
#define ICLRRuntimeHost4_SetHostControl(This,pHostControl) \
( (This)->lpVtbl -> SetHostControl(This,pHostControl) )
#define ICLRRuntimeHost4_GetCLRControl(This,pCLRControl) \
( (This)->lpVtbl -> GetCLRControl(This,pCLRControl) )
#define ICLRRuntimeHost4_UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) \
( (This)->lpVtbl -> UnloadAppDomain(This,dwAppDomainId,fWaitUntilDone) )
#define ICLRRuntimeHost4_ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) \
( (This)->lpVtbl -> ExecuteInAppDomain(This,dwAppDomainId,pCallback,cookie) )
#define ICLRRuntimeHost4_GetCurrentAppDomainId(This,pdwAppDomainId) \
( (This)->lpVtbl -> GetCurrentAppDomainId(This,pdwAppDomainId) )
#define ICLRRuntimeHost4_ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) \
( (This)->lpVtbl -> ExecuteApplication(This,pwzAppFullName,dwManifestPaths,ppwzManifestPaths,dwActivationData,ppwzActivationData,pReturnValue) )
#define ICLRRuntimeHost4_ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) \
( (This)->lpVtbl -> ExecuteInDefaultAppDomain(This,pwzAssemblyPath,pwzTypeName,pwzMethodName,pwzArgument,pReturnValue) )
#define ICLRRuntimeHost4_CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) \
( (This)->lpVtbl -> CreateAppDomainWithManager(This,wszFriendlyName,dwFlags,wszAppDomainManagerAssemblyName,wszAppDomainManagerTypeName,nProperties,pPropertyNames,pPropertyValues,pAppDomainID) )
#define ICLRRuntimeHost4_CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) \
( (This)->lpVtbl -> CreateDelegate(This,appDomainID,wszAssemblyName,wszClassName,wszMethodName,fnPtr) )
#define ICLRRuntimeHost4_Authenticate(This,authKey) \
( (This)->lpVtbl -> Authenticate(This,authKey) )
#define ICLRRuntimeHost4_RegisterMacEHPort(This) \
( (This)->lpVtbl -> RegisterMacEHPort(This) )
#define ICLRRuntimeHost4_SetStartupFlags(This,dwFlags) \
( (This)->lpVtbl -> SetStartupFlags(This,dwFlags) )
#define ICLRRuntimeHost4_DllGetActivationFactory(This,appDomainID,wszTypeName,factory) \
( (This)->lpVtbl -> DllGetActivationFactory(This,appDomainID,wszTypeName,factory) )
#define ICLRRuntimeHost4_ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) \
( (This)->lpVtbl -> ExecuteAssembly(This,dwAppDomainId,pwzAssemblyPath,argc,argv,pReturnValue) )
#define ICLRRuntimeHost4_UnloadAppDomain2(This,dwAppDomainId,fWaitUntilDone,pLatchedExitCode) \
( (This)->lpVtbl -> UnloadAppDomain2(This,dwAppDomainId,fWaitUntilDone,pLatchedExitCode) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __ICLRRuntimeHost4_INTERFACE_DEFINED__ */
/* interface __MIDL_itf_mscoree_0000_0003 */
/* [local] */
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0003_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_mscoree_0000_0003_v0_0_s_ifspec;
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/inc/pesectionman.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// Section Manager for portable executables
// Common to both Memory Only and Static (EXE making) code
#ifndef PESectionMan_H
#define PESectionMan_H
#include "windef.h"
#include "ceegen.h"
#include "blobfetcher.h"
class PESection;
struct PESectionReloc;
struct _IMAGE_SECTION_HEADER;
class PESectionMan
{
public:
virtual ~PESectionMan() {}
HRESULT Init();
HRESULT Cleanup();
// Finds section with given name, or creates a new one
HRESULT getSectionCreate(
const char *name,
unsigned flags, // IMAGE_SCN_* flags. eg. IMAGE_SCN_CNT_INITIALIZED_DATA
PESection **section);
// Since we allocate, we must delete (Bug in VC, see knowledge base Q122675)
void sectionDestroy(PESection **section);
// Apply all the relocs for in memory conversion
HRESULT applyRelocs(CeeGenTokenMapper *pTokenMapper);
HRESULT cloneInstance(PESectionMan *destination);
protected:
// Finds section with given name. returns 0 if not found
virtual PESection *getSection(const char *name);
// Create a new section
virtual HRESULT newSection(
const char *name,
PESection **section,
unsigned flags = sdNone,
unsigned estSize = 0x10000,
unsigned estRelocs = 1);
// Keep proctected & no accessors, so that derived class PEWriter
// is the ONLY one with access
PESection **sectStart;
PESection **sectCur;
PESection **sectEnd;
}; // class PESectionMan
/***************************************************************
* This represents a section of a ICeeFileGen. Multiple sections
* can be created with pointers to one another. These will
* automatically get fixed up when the ICeeFileGen is "baked".
*
* It is implemented using CBlobFetcher as a list of blobs.
* Thus it can grow arbitrarily. At the same time, it can appear
* as a flat consecutive piece of memory which can be indexed into
* using offsets.
*/
class PESection : public CeeSectionImpl {
public:
// bytes in this section at present
unsigned dataLen();
// Apply all the relocs for in memory conversion
HRESULT applyRelocs(CeeGenTokenMapper *pTokenMapper);
// get a block to write on (use instead of write to avoid copy)
char* getBlock(unsigned len, unsigned align=1);
// writes 'val' (which is offset into section 'relativeTo')
// and adds a relocation fixup for that section
void writeSectReloc(unsigned val, CeeSection& relativeTo,
CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra=0);
// Indicates that the DWORD at 'offset' in the current section should
// have the base of section 'relativeTo' added to it
HRESULT addSectReloc(unsigned offset, CeeSection& relativeTo,
CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra=0);
// If relativeTo is NULL, it is treated as a base reloc.
// ie. the value only needs to be fixed at load time if the module gets rebased.
HRESULT addSectReloc(unsigned offset, PESection *relativeTo,
CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra=0);
// Add a base reloc for the given offset in the current section
HRESULT addBaseReloc(unsigned offset, CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra = 0);
// section name
unsigned char *name() {
LIMITED_METHOD_CONTRACT;
return (unsigned char *) m_name;
}
// section flags
unsigned flags() {
LIMITED_METHOD_CONTRACT;
return m_flags;
}
// virtual base
unsigned getBaseRVA() {
LIMITED_METHOD_CONTRACT;
return m_baseRVA;
}
// return the dir entry for this section
int getDirEntry() {
LIMITED_METHOD_CONTRACT;
return dirEntry;
}
// this section will be directory entry 'num'
HRESULT directoryEntry(unsigned num);
// Indexes offset as if this were an array
// Returns a pointer into the correct blob
virtual char * computePointer(unsigned offset) const;
// Checks to see if pointer is in section
virtual BOOL containsPointer(_In_ char *ptr) const;
// Given a pointer pointing into this section,
// computes an offset as if this were an array
virtual unsigned computeOffset(_In_ char *ptr) const;
// Make 'destination' a copy of the current PESection
HRESULT cloneInstance(PESection *destination);
// Cause the section to allocate memory in smaller chunks
void SetInitialGrowth(unsigned growth);
virtual ~PESection();
private:
// purposely not defined,
PESection();
// purposely not defined,
PESection(const PESection&);
// purposely not defined,
PESection& operator=(const PESection& x);
// this dir entry points to this section
int dirEntry;
protected:
friend class PEWriter;
friend class PEWriterSection;
friend class PESectionMan;
PESection(const char* name, unsigned flags,
unsigned estSize, unsigned estRelocs);
// Blob fetcher handles getBlock() and fetching binary chunks.
CBlobFetcher m_blobFetcher;
PESectionReloc* m_relocStart;
PESectionReloc* m_relocCur;
PESectionReloc* m_relocEnd;
// These will be set while baking (finalizing) the file
unsigned m_baseRVA; // RVA into the file of this section.
unsigned m_filePos; // Start offset into the file (treated as a data image)
unsigned m_filePad; // Padding added to the end of the section for alignment
char m_name[8+6]; // extra room for digits
unsigned m_flags;
struct _IMAGE_SECTION_HEADER* m_header; // Corresponding header. Assigned after link()
};
/***************************************************************/
/* implementation section */
inline HRESULT PESection::directoryEntry(unsigned num) {
WRAPPER_NO_CONTRACT;
TESTANDRETURN(num < 16, E_INVALIDARG);
dirEntry = num;
return S_OK;
}
// This remembers the location where a reloc needs to be applied.
// It is relative to the contents of a PESection
struct PESectionReloc {
CeeSectionRelocType type; // type of reloc
unsigned offset; // offset within the current PESection where the reloc is to be applied
CeeSectionRelocExtra extra;
PESection* section; // target PESection. NULL implies that the target is a fixed address outside the module
};
#endif // #define PESectionMan_H
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// Section Manager for portable executables
// Common to both Memory Only and Static (EXE making) code
#ifndef PESectionMan_H
#define PESectionMan_H
#include "windef.h"
#include "ceegen.h"
#include "blobfetcher.h"
class PESection;
struct PESectionReloc;
struct _IMAGE_SECTION_HEADER;
class PESectionMan
{
public:
virtual ~PESectionMan() {}
HRESULT Init();
HRESULT Cleanup();
// Finds section with given name, or creates a new one
HRESULT getSectionCreate(
const char *name,
unsigned flags, // IMAGE_SCN_* flags. eg. IMAGE_SCN_CNT_INITIALIZED_DATA
PESection **section);
// Since we allocate, we must delete (Bug in VC, see knowledge base Q122675)
void sectionDestroy(PESection **section);
// Apply all the relocs for in memory conversion
HRESULT applyRelocs(CeeGenTokenMapper *pTokenMapper);
HRESULT cloneInstance(PESectionMan *destination);
protected:
// Finds section with given name. returns 0 if not found
virtual PESection *getSection(const char *name);
// Create a new section
virtual HRESULT newSection(
const char *name,
PESection **section,
unsigned flags = sdNone,
unsigned estSize = 0x10000,
unsigned estRelocs = 1);
// Keep proctected & no accessors, so that derived class PEWriter
// is the ONLY one with access
PESection **sectStart;
PESection **sectCur;
PESection **sectEnd;
}; // class PESectionMan
/***************************************************************
* This represents a section of a ICeeFileGen. Multiple sections
* can be created with pointers to one another. These will
* automatically get fixed up when the ICeeFileGen is "baked".
*
* It is implemented using CBlobFetcher as a list of blobs.
* Thus it can grow arbitrarily. At the same time, it can appear
* as a flat consecutive piece of memory which can be indexed into
* using offsets.
*/
class PESection : public CeeSectionImpl {
public:
// bytes in this section at present
unsigned dataLen();
// Apply all the relocs for in memory conversion
HRESULT applyRelocs(CeeGenTokenMapper *pTokenMapper);
// get a block to write on (use instead of write to avoid copy)
char* getBlock(unsigned len, unsigned align=1);
// writes 'val' (which is offset into section 'relativeTo')
// and adds a relocation fixup for that section
void writeSectReloc(unsigned val, CeeSection& relativeTo,
CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra=0);
// Indicates that the DWORD at 'offset' in the current section should
// have the base of section 'relativeTo' added to it
HRESULT addSectReloc(unsigned offset, CeeSection& relativeTo,
CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra=0);
// If relativeTo is NULL, it is treated as a base reloc.
// ie. the value only needs to be fixed at load time if the module gets rebased.
HRESULT addSectReloc(unsigned offset, PESection *relativeTo,
CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra=0);
// Add a base reloc for the given offset in the current section
HRESULT addBaseReloc(unsigned offset, CeeSectionRelocType reloc = srRelocHighLow,
CeeSectionRelocExtra *extra = 0);
// section name
unsigned char *name() {
LIMITED_METHOD_CONTRACT;
return (unsigned char *) m_name;
}
// section flags
unsigned flags() {
LIMITED_METHOD_CONTRACT;
return m_flags;
}
// virtual base
unsigned getBaseRVA() {
LIMITED_METHOD_CONTRACT;
return m_baseRVA;
}
// return the dir entry for this section
int getDirEntry() {
LIMITED_METHOD_CONTRACT;
return dirEntry;
}
// this section will be directory entry 'num'
HRESULT directoryEntry(unsigned num);
// Indexes offset as if this were an array
// Returns a pointer into the correct blob
virtual char * computePointer(unsigned offset) const;
// Checks to see if pointer is in section
virtual BOOL containsPointer(_In_ char *ptr) const;
// Given a pointer pointing into this section,
// computes an offset as if this were an array
virtual unsigned computeOffset(_In_ char *ptr) const;
// Make 'destination' a copy of the current PESection
HRESULT cloneInstance(PESection *destination);
// Cause the section to allocate memory in smaller chunks
void SetInitialGrowth(unsigned growth);
virtual ~PESection();
private:
// purposely not defined,
PESection();
// purposely not defined,
PESection(const PESection&);
// purposely not defined,
PESection& operator=(const PESection& x);
// this dir entry points to this section
int dirEntry;
protected:
friend class PEWriter;
friend class PEWriterSection;
friend class PESectionMan;
PESection(const char* name, unsigned flags,
unsigned estSize, unsigned estRelocs);
// Blob fetcher handles getBlock() and fetching binary chunks.
CBlobFetcher m_blobFetcher;
PESectionReloc* m_relocStart;
PESectionReloc* m_relocCur;
PESectionReloc* m_relocEnd;
// These will be set while baking (finalizing) the file
unsigned m_baseRVA; // RVA into the file of this section.
unsigned m_filePos; // Start offset into the file (treated as a data image)
unsigned m_filePad; // Padding added to the end of the section for alignment
char m_name[8+6]; // extra room for digits
unsigned m_flags;
struct _IMAGE_SECTION_HEADER* m_header; // Corresponding header. Assigned after link()
};
/***************************************************************/
/* implementation section */
inline HRESULT PESection::directoryEntry(unsigned num) {
WRAPPER_NO_CONTRACT;
TESTANDRETURN(num < 16, E_INVALIDARG);
dirEntry = num;
return S_OK;
}
// This remembers the location where a reloc needs to be applied.
// It is relative to the contents of a PESection
struct PESectionReloc {
CeeSectionRelocType type; // type of reloc
unsigned offset; // offset within the current PESection where the reloc is to be applied
CeeSectionRelocExtra extra;
PESection* section; // target PESection. NULL implies that the target is a fixed address outside the module
};
#endif // #define PESectionMan_H
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/component/debugger-engine.h | /**
* \file
*/
#ifndef __MONO_DEBUGGER_ENGINE_COMPONENT_H__
#define __MONO_DEBUGGER_ENGINE_COMPONENT_H__
#include <mono/mini/mini.h>
#include <mono/metadata/seq-points-data.h>
#include "debugger-state-machine.h"
#include <mono/metadata/mono-debug.h>
#include <mono/mini/interp/interp-internals.h>
#include "debugger-protocol.h"
#define ModifierKind MdbgProtModifierKind
#define StepDepth MdbgProtStepDepth
#define StepSize MdbgProtStepSize
#define StepFilter MdbgProtStepFilter
#define EventKind MdbgProtEventKind
#define CommandSet MdbgProtCommandSet
#define EVENT_KIND_BREAKPOINT MDBGPROT_EVENT_KIND_BREAKPOINT
#define EVENT_KIND_STEP MDBGPROT_EVENT_KIND_STEP
#define EVENT_KIND_KEEPALIVE MDBGPROT_EVENT_KIND_KEEPALIVE
#define EVENT_KIND_METHOD_ENTRY MDBGPROT_EVENT_KIND_METHOD_ENTRY
#define EVENT_KIND_METHOD_EXIT MDBGPROT_EVENT_KIND_METHOD_EXIT
#define EVENT_KIND_APPDOMAIN_CREATE MDBGPROT_EVENT_KIND_APPDOMAIN_CREATE
#define EVENT_KIND_APPDOMAIN_UNLOAD MDBGPROT_EVENT_KIND_APPDOMAIN_UNLOAD
#define EVENT_KIND_THREAD_START MDBGPROT_EVENT_KIND_THREAD_START
#define EVENT_KIND_THREAD_DEATH MDBGPROT_EVENT_KIND_THREAD_DEATH
#define EVENT_KIND_ASSEMBLY_LOAD MDBGPROT_EVENT_KIND_ASSEMBLY_LOAD
#define EVENT_KIND_ASSEMBLY_UNLOAD MDBGPROT_EVENT_KIND_ASSEMBLY_UNLOAD
#define EVENT_KIND_TYPE_LOAD MDBGPROT_EVENT_KIND_TYPE_LOAD
#define EVENT_KIND_VM_START MDBGPROT_EVENT_KIND_VM_START
#define EVENT_KIND_VM_DEATH MDBGPROT_EVENT_KIND_VM_DEATH
#define EVENT_KIND_CRASH MDBGPROT_EVENT_KIND_CRASH
#define EVENT_KIND_EXCEPTION MDBGPROT_EVENT_KIND_EXCEPTION
#define EVENT_KIND_USER_BREAK MDBGPROT_EVENT_KIND_USER_BREAK
#define EVENT_KIND_USER_LOG MDBGPROT_EVENT_KIND_USER_LOG
#define CMD_EVENT_REQUEST_SET MDBGPROT_CMD_EVENT_REQUEST_SET
#define CMD_EVENT_REQUEST_CLEAR MDBGPROT_CMD_EVENT_REQUEST_CLEAR
#define CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS MDBGPROT_CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS
#define CMD_VM_VERSION MDBGPROT_CMD_VM_VERSION
#define CMD_VM_SET_PROTOCOL_VERSION MDBGPROT_CMD_VM_SET_PROTOCOL_VERSION
#define CMD_VM_ALL_THREADS MDBGPROT_CMD_VM_ALL_THREADS
#define CMD_VM_SUSPEND MDBGPROT_CMD_VM_SUSPEND
#define CMD_VM_RESUME MDBGPROT_CMD_VM_RESUME
#define CMD_VM_DISPOSE MDBGPROT_CMD_VM_DISPOSE
#define CMD_VM_EXIT MDBGPROT_CMD_VM_EXIT
#define CMD_VM_INVOKE_METHOD MDBGPROT_CMD_VM_INVOKE_METHOD
#define CMD_VM_INVOKE_METHODS MDBGPROT_CMD_VM_INVOKE_METHODS
#define CMD_VM_ABORT_INVOKE MDBGPROT_CMD_VM_ABORT_INVOKE
#define CMD_VM_SET_KEEPALIVE MDBGPROT_CMD_VM_SET_KEEPALIVE
#define CMD_VM_GET_TYPES_FOR_SOURCE_FILE MDBGPROT_CMD_VM_GET_TYPES_FOR_SOURCE_FILE
#define CMD_VM_GET_TYPES MDBGPROT_CMD_VM_GET_TYPES
#define CMD_VM_START_BUFFERING MDBGPROT_CMD_VM_START_BUFFERING
#define CMD_VM_STOP_BUFFERING MDBGPROT_CMD_VM_STOP_BUFFERING
#define CMD_APPDOMAIN_GET_ROOT_DOMAIN MDBGPROT_CMD_APPDOMAIN_GET_ROOT_DOMAIN
#define CMD_APPDOMAIN_GET_FRIENDLY_NAME MDBGPROT_CMD_APPDOMAIN_GET_FRIENDLY_NAME
#define CMD_APPDOMAIN_GET_ASSEMBLIES MDBGPROT_CMD_APPDOMAIN_GET_ASSEMBLIES
#define CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY MDBGPROT_CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY
#define CMD_APPDOMAIN_GET_CORLIB MDBGPROT_CMD_APPDOMAIN_GET_CORLIB
#define CMD_APPDOMAIN_CREATE_STRING MDBGPROT_CMD_APPDOMAIN_CREATE_STRING
#define CMD_APPDOMAIN_CREATE_BYTE_ARRAY MDBGPROT_CMD_APPDOMAIN_CREATE_BYTE_ARRAY
#define CMD_APPDOMAIN_CREATE_BOXED_VALUE MDBGPROT_CMD_APPDOMAIN_CREATE_BOXED_VALUE
#define CMD_ASSEMBLY_GET_LOCATION MDBGPROT_CMD_ASSEMBLY_GET_LOCATION
#define CMD_ASSEMBLY_GET_ENTRY_POINT MDBGPROT_CMD_ASSEMBLY_GET_ENTRY_POINT
#define CMD_ASSEMBLY_GET_MANIFEST_MODULE MDBGPROT_CMD_ASSEMBLY_GET_MANIFEST_MODULE
#define CMD_ASSEMBLY_GET_OBJECT MDBGPROT_CMD_ASSEMBLY_GET_OBJECT
#define CMD_ASSEMBLY_GET_DOMAIN MDBGPROT_CMD_ASSEMBLY_GET_DOMAIN
#define CMD_ASSEMBLY_GET_TYPE MDBGPROT_CMD_ASSEMBLY_GET_TYPE
#define CMD_ASSEMBLY_GET_NAME MDBGPROT_CMD_ASSEMBLY_GET_NAME
#define CMD_ASSEMBLY_GET_METADATA_BLOB MDBGPROT_CMD_ASSEMBLY_GET_METADATA_BLOB
#define CMD_ASSEMBLY_GET_IS_DYNAMIC MDBGPROT_CMD_ASSEMBLY_GET_IS_DYNAMIC
#define CMD_ASSEMBLY_GET_PDB_BLOB MDBGPROT_CMD_ASSEMBLY_GET_PDB_BLOB
#define CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN MDBGPROT_CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN
#define CMD_ASSEMBLY_GET_METHOD_FROM_TOKEN MDBGPROT_CMD_ASSEMBLY_GET_METHOD_FROM_TOKEN
#define CMD_ASSEMBLY_HAS_DEBUG_INFO MDBGPROT_CMD_ASSEMBLY_HAS_DEBUG_INFO
#define CMD_ASSEMBLY_GET_CATTRS MDBGPROT_CMD_ASSEMBLY_GET_CATTRS
#define CMD_MODULE_GET_INFO MDBGPROT_CMD_MODULE_GET_INFO
#define CMD_FIELD_GET_INFO MDBGPROT_CMD_FIELD_GET_INFO
#define CMD_TYPE_GET_INFO MDBGPROT_CMD_TYPE_GET_INFO
#define CMD_TYPE_GET_METHODS MDBGPROT_CMD_TYPE_GET_METHODS
#define CMD_TYPE_GET_FIELDS MDBGPROT_CMD_TYPE_GET_FIELDS
#define CMD_TYPE_GET_PROPERTIES MDBGPROT_CMD_TYPE_GET_PROPERTIES
#define CMD_TYPE_GET_CATTRS MDBGPROT_CMD_TYPE_GET_CATTRS
#define CMD_TYPE_GET_FIELD_CATTRS MDBGPROT_CMD_TYPE_GET_FIELD_CATTRS
#define CMD_TYPE_GET_PROPERTY_CATTRS MDBGPROT_CMD_TYPE_GET_PROPERTY_CATTRS
#define CMD_TYPE_GET_VALUES MDBGPROT_CMD_TYPE_GET_VALUES
#define CMD_TYPE_GET_VALUES_2 MDBGPROT_CMD_TYPE_GET_VALUES_2
#define CMD_TYPE_SET_VALUES MDBGPROT_CMD_TYPE_SET_VALUES
#define CMD_TYPE_GET_OBJECT MDBGPROT_CMD_TYPE_GET_OBJECT
#define CMD_TYPE_GET_SOURCE_FILES MDBGPROT_CMD_TYPE_GET_SOURCE_FILES
#define CMD_TYPE_GET_SOURCE_FILES_2 MDBGPROT_CMD_TYPE_GET_SOURCE_FILES_2
#define CMD_TYPE_IS_ASSIGNABLE_FROM MDBGPROT_CMD_TYPE_IS_ASSIGNABLE_FROM
#define CMD_TYPE_GET_METHODS_BY_NAME_FLAGS MDBGPROT_CMD_TYPE_GET_METHODS_BY_NAME_FLAGS
#define CMD_TYPE_GET_INTERFACES MDBGPROT_CMD_TYPE_GET_INTERFACES
#define CMD_TYPE_GET_INTERFACE_MAP MDBGPROT_CMD_TYPE_GET_INTERFACE_MAP
#define CMD_TYPE_IS_INITIALIZED MDBGPROT_CMD_TYPE_IS_INITIALIZED
#define CMD_TYPE_CREATE_INSTANCE MDBGPROT_CMD_TYPE_CREATE_INSTANCE
#define CMD_TYPE_GET_VALUE_SIZE MDBGPROT_CMD_TYPE_GET_VALUE_SIZE
#define CMD_METHOD_GET_NAME MDBGPROT_CMD_METHOD_GET_NAME
#define CMD_METHOD_GET_DECLARING_TYPE MDBGPROT_CMD_METHOD_GET_DECLARING_TYPE
#define CMD_METHOD_GET_DEBUG_INFO MDBGPROT_CMD_METHOD_GET_DEBUG_INFO
#define CMD_METHOD_GET_PARAM_INFO MDBGPROT_CMD_METHOD_GET_PARAM_INFO
#define CMD_METHOD_GET_LOCALS_INFO MDBGPROT_CMD_METHOD_GET_LOCALS_INFO
#define CMD_METHOD_GET_INFO MDBGPROT_CMD_METHOD_GET_INFO
#define CMD_METHOD_GET_BODY MDBGPROT_CMD_METHOD_GET_BODY
#define CMD_METHOD_RESOLVE_TOKEN MDBGPROT_CMD_METHOD_RESOLVE_TOKEN
#define CMD_METHOD_GET_CATTRS MDBGPROT_CMD_METHOD_GET_CATTRS
#define CMD_METHOD_MAKE_GENERIC_METHOD MDBGPROT_CMD_METHOD_MAKE_GENERIC_METHOD
#define CMD_METHOD_TOKEN MDBGPROT_CMD_METHOD_TOKEN
#define CMD_METHOD_ASSEMBLY MDBGPROT_CMD_METHOD_ASSEMBLY
#define CMD_THREAD_GET_NAME MDBGPROT_CMD_THREAD_GET_NAME
#define CMD_THREAD_GET_FRAME_INFO MDBGPROT_CMD_THREAD_GET_FRAME_INFO
#define CMD_THREAD_GET_STATE MDBGPROT_CMD_THREAD_GET_STATE
#define CMD_THREAD_GET_INFO MDBGPROT_CMD_THREAD_GET_INFO
#define CMD_THREAD_GET_ID MDBGPROT_CMD_THREAD_GET_ID
#define CMD_THREAD_GET_TID MDBGPROT_CMD_THREAD_GET_TID
#define CMD_THREAD_SET_IP MDBGPROT_CMD_THREAD_SET_IP
#define CMD_THREAD_ELAPSED_TIME MDBGPROT_CMD_THREAD_ELAPSED_TIME
#define CMD_STACK_FRAME_GET_DOMAIN MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN
#define CMD_STACK_FRAME_GET_ARGUMENT MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENT
#define CMD_STACK_FRAME_GET_VALUES MDBGPROT_CMD_STACK_FRAME_GET_VALUES
#define CMD_STACK_FRAME_GET_THIS MDBGPROT_CMD_STACK_FRAME_GET_THIS
#define CMD_STACK_FRAME_SET_VALUES MDBGPROT_CMD_STACK_FRAME_SET_VALUES
#define CMD_STACK_FRAME_GET_DOMAIN MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN
#define CMD_STACK_FRAME_SET_THIS MDBGPROT_CMD_STACK_FRAME_SET_THIS
#define CMD_ARRAY_REF_GET_TYPE MDBGPROT_CMD_ARRAY_REF_GET_TYPE
#define CMD_ARRAY_REF_GET_LENGTH MDBGPROT_CMD_ARRAY_REF_GET_LENGTH
#define CMD_ARRAY_REF_GET_VALUES MDBGPROT_CMD_ARRAY_REF_GET_VALUES
#define CMD_ARRAY_REF_SET_VALUES MDBGPROT_CMD_ARRAY_REF_SET_VALUES
#define CMD_STRING_REF_GET_VALUE MDBGPROT_CMD_STRING_REF_GET_VALUE
#define CMD_STRING_REF_GET_LENGTH MDBGPROT_CMD_STRING_REF_GET_LENGTH
#define CMD_STRING_REF_GET_CHARS MDBGPROT_CMD_STRING_REF_GET_CHARS
#define CMD_POINTER_GET_VALUE MDBGPROT_CMD_POINTER_GET_VALUE
#define CMD_OBJECT_REF_IS_COLLECTED MDBGPROT_CMD_OBJECT_REF_IS_COLLECTED
#define CMD_OBJECT_REF_GET_TYPE MDBGPROT_CMD_OBJECT_REF_GET_TYPE
#define CMD_OBJECT_REF_GET_VALUES_ICORDBG MDBGPROT_CMD_OBJECT_REF_GET_VALUES_ICORDBG
#define CMD_OBJECT_REF_GET_VALUES MDBGPROT_CMD_OBJECT_REF_GET_VALUES
#define CMD_OBJECT_REF_SET_VALUES MDBGPROT_CMD_OBJECT_REF_SET_VALUES
#define CMD_OBJECT_REF_GET_ADDRESS MDBGPROT_CMD_OBJECT_REF_GET_ADDRESS
#define CMD_OBJECT_REF_GET_DOMAIN MDBGPROT_CMD_OBJECT_REF_GET_DOMAIN
#define CMD_OBJECT_REF_GET_INFO MDBGPROT_CMD_OBJECT_REF_GET_INFO
#define TOKEN_TYPE_METHOD MDBGPROT_TOKEN_TYPE_METHOD
#define TOKEN_TYPE_UNKNOWN MDBGPROT_TOKEN_TYPE_UNKNOWN
#define TOKEN_TYPE_FIELD MDBGPROT_TOKEN_TYPE_FIELD
#define TOKEN_TYPE_METHOD MDBGPROT_TOKEN_TYPE_METHOD
#define TOKEN_TYPE_STRING MDBGPROT_TOKEN_TYPE_STRING
#define TOKEN_TYPE_TYPE MDBGPROT_TOKEN_TYPE_TYPE
#define STEP_FILTER_STATIC_CTOR MDBGPROT_STEP_FILTER_STATIC_CTOR
#define STEP_DEPTH_OVER MDBGPROT_STEP_DEPTH_OVER
#define STEP_DEPTH_OUT MDBGPROT_STEP_DEPTH_OUT
#define STEP_DEPTH_INTO MDBGPROT_STEP_DEPTH_INTO
#define STEP_SIZE_MIN MDBGPROT_STEP_SIZE_MIN
#define STEP_SIZE_LINE MDBGPROT_STEP_SIZE_LINE
#define SUSPEND_POLICY_NONE MDBGPROT_SUSPEND_POLICY_NONE
#define SUSPEND_POLICY_ALL MDBGPROT_SUSPEND_POLICY_ALL
#define SUSPEND_POLICY_EVENT_THREAD MDBGPROT_SUSPEND_POLICY_EVENT_THREAD
#define CMD_COMPOSITE MDBGPROT_CMD_COMPOSITE
#define INVOKE_FLAG_SINGLE_THREADED MDBGPROT_INVOKE_FLAG_SINGLE_THREADED
#define INVOKE_FLAG_VIRTUAL MDBGPROT_INVOKE_FLAG_VIRTUAL
#define INVOKE_FLAG_DISABLE_BREAKPOINTS MDBGPROT_INVOKE_FLAG_DISABLE_BREAKPOINTS
#define INVOKE_FLAG_RETURN_OUT_THIS MDBGPROT_INVOKE_FLAG_RETURN_OUT_THIS
#define INVOKE_FLAG_RETURN_OUT_ARGS MDBGPROT_INVOKE_FLAG_RETURN_OUT_ARGS
#define MOD_KIND_ASSEMBLY_ONLY MDBGPROT_MOD_KIND_ASSEMBLY_ONLY
#define MOD_KIND_EXCEPTION_ONLY MDBGPROT_MOD_KIND_EXCEPTION_ONLY
#define MOD_KIND_NONE MDBGPROT_MOD_KIND_NONE
#define MOD_KIND_COUNT MDBGPROT_MOD_KIND_COUNT
#define MOD_KIND_THREAD_ONLY MDBGPROT_MOD_KIND_THREAD_ONLY
#define MOD_KIND_SOURCE_FILE_ONLY MDBGPROT_MOD_KIND_SOURCE_FILE_ONLY
#define MOD_KIND_TYPE_NAME_ONLY MDBGPROT_MOD_KIND_TYPE_NAME_ONLY
#define MOD_KIND_STEP MDBGPROT_MOD_KIND_STEP
#define MOD_KIND_LOCATION_ONLY MDBGPROT_MOD_KIND_LOCATION_ONLY
#define STEP_FILTER_DEBUGGER_HIDDEN MDBGPROT_STEP_FILTER_DEBUGGER_HIDDEN
#define STEP_FILTER_DEBUGGER_NON_USER_CODE MDBGPROT_STEP_FILTER_DEBUGGER_NON_USER_CODE
#define STEP_FILTER_DEBUGGER_STEP_THROUGH MDBGPROT_STEP_FILTER_DEBUGGER_STEP_THROUGH
#define STEP_FILTER_NONE MDBGPROT_STEP_FILTER_NONE
#define ERR_NONE MDBGPROT_ERR_NONE
#define ERR_INVOKE_ABORTED MDBGPROT_ERR_INVOKE_ABORTED
#define ERR_NOT_SUSPENDED MDBGPROT_ERR_NOT_SUSPENDED
#define ERR_INVALID_ARGUMENT MDBGPROT_ERR_INVALID_ARGUMENT
#define ERR_INVALID_OBJECT MDBGPROT_ERR_INVALID_OBJECT
#define ERR_UNLOADED MDBGPROT_ERR_UNLOADED
#define ERR_NOT_IMPLEMENTED MDBGPROT_ERR_NOT_IMPLEMENTED
#define ERR_LOADER_ERROR MDBGPROT_ERR_LOADER_ERROR
#define ERR_NO_INVOCATION MDBGPROT_ERR_NO_INVOCATION
#define ERR_NO_SEQ_POINT_AT_IL_OFFSET MDBGPROT_ERR_NO_SEQ_POINT_AT_IL_OFFSET
#define ERR_INVALID_FIELDID MDBGPROT_ERR_INVALID_FIELDID
#define ERR_INVALID_FRAMEID MDBGPROT_ERR_INVALID_FRAMEID
#define ERR_ABSENT_INFORMATION MDBGPROT_ERR_ABSENT_INFORMATION
#define VALUE_TYPE_ID_FIXED_ARRAY MDBGPROT_VALUE_TYPE_ID_FIXED_ARRAY
#define VALUE_TYPE_ID_NULL MDBGPROT_VALUE_TYPE_ID_NULL
#define VALUE_TYPE_ID_PARENT_VTYPE MDBGPROT_VALUE_TYPE_ID_PARENT_VTYPE
#define VALUE_TYPE_ID_TYPE MDBGPROT_VALUE_TYPE_ID_TYPE
#define CMD_SET_VM MDBGPROT_CMD_SET_VM
#define CMD_SET_OBJECT_REF MDBGPROT_CMD_SET_OBJECT_REF
#define CMD_SET_STRING_REF MDBGPROT_CMD_SET_STRING_REF
#define CMD_SET_THREAD MDBGPROT_CMD_SET_THREAD
#define CMD_SET_ARRAY_REF MDBGPROT_CMD_SET_ARRAY_REF
#define CMD_SET_EVENT_REQUEST MDBGPROT_CMD_SET_EVENT_REQUEST
#define CMD_SET_STACK_FRAME MDBGPROT_CMD_SET_STACK_FRAME
#define CMD_SET_APPDOMAIN MDBGPROT_CMD_SET_APPDOMAIN
#define CMD_SET_ASSEMBLY MDBGPROT_CMD_SET_ASSEMBLY
#define CMD_SET_METHOD MDBGPROT_CMD_SET_METHOD
#define CMD_SET_TYPE MDBGPROT_CMD_SET_TYPE
#define CMD_SET_MODULE MDBGPROT_CMD_SET_MODULE
#define CMD_SET_FIELD MDBGPROT_CMD_SET_FIELD
#define CMD_SET_POINTER MDBGPROT_CMD_SET_POINTER
#define CMD_SET_EVENT MDBGPROT_CMD_SET_EVENT
#define Buffer MdbgProtBuffer
#define ReplyPacket MdbgProtReplyPacket
#define buffer_init m_dbgprot_buffer_init
#define buffer_free m_dbgprot_buffer_free
#define buffer_add_int m_dbgprot_buffer_add_int
#define buffer_add_long m_dbgprot_buffer_add_long
#define buffer_add_string m_dbgprot_buffer_add_string
#define buffer_add_id m_dbgprot_buffer_add_id
#define buffer_add_byte m_dbgprot_buffer_add_byte
#define buffer_len m_dbgprot_buffer_len
#define buffer_add_buffer m_dbgprot_buffer_add_buffer
#define buffer_add_data m_dbgprot_buffer_add_data
#define buffer_add_utf16 m_dbgprot_buffer_add_utf16
#define buffer_add_byte_array m_dbgprot_buffer_add_byte_array
#define buffer_add_short m_dbgprot_buffer_add_short
#define decode_id m_dbgprot_decode_id
#define decode_int m_dbgprot_decode_int
#define decode_byte m_dbgprot_decode_byte
#define decode_long m_dbgprot_decode_long
#define decode_string m_dbgprot_decode_string
#define event_to_string m_dbgprot_event_to_string
#define ErrorCode MdbgProtErrorCode
#define FRAME_FLAG_DEBUGGER_INVOKE MDBGPROT_FRAME_FLAG_DEBUGGER_INVOKE
#define FRAME_FLAG_NATIVE_TRANSITION MDBGPROT_FRAME_FLAG_NATIVE_TRANSITION
/*
* Contains information about an inserted breakpoint.
*/
typedef struct {
long il_offset, native_offset;
guint8 *ip;
MonoJitInfo *ji;
MonoDomain *domain;
} BreakpointInstance;
/*
* OBJECT IDS
*/
/*
* Represents an object accessible by the debugger client.
*/
typedef struct {
/* Unique id used in the wire protocol to refer to objects */
int id;
/*
* A weakref gc handle pointing to the object. The gc handle is used to
* detect if the object was garbage collected.
*/
MonoGCHandle handle;
} ObjRef;
typedef struct
{
//Must be the first field to ensure pointer equivalence
DbgEngineStackFrame de;
int id;
guint32 il_offset;
/*
* If method is gshared, this is the actual instance, otherwise this is equal to
* method.
*/
MonoMethod *actual_method;
/*
* This is the method which is visible to debugger clients. Same as method,
* except for native-to-managed wrappers.
*/
MonoMethod *api_method;
MonoContext ctx;
MonoDebugMethodJitInfo *jit;
MonoInterpFrameHandle interp_frame;
gpointer frame_addr;
int flags;
host_mgreg_t *reg_locations [MONO_MAX_IREGS];
/*
* Whenever ctx is set. This is FALSE for the last frame of running threads, since
* the frame can become invalid.
*/
gboolean has_ctx;
} StackFrame;
#define DE_ERR_NONE 0
// WARNING WARNING WARNING
// Error codes MUST match those of sdb for now
#define DE_ERR_NOT_IMPLEMENTED 100
MonoGHashTable *
mono_debugger_get_thread_states (void);
gboolean
mono_debugger_is_disconnected (void);
gsize
mono_debugger_tls_thread_id (DebuggerTlsData *debuggerTlsData);
void
mono_debugger_set_thread_state (DebuggerTlsData *ref, MonoDebuggerThreadState expected, MonoDebuggerThreadState set);
MonoDebuggerThreadState
mono_debugger_get_thread_state (DebuggerTlsData *ref);
void mono_de_cleanup (void);
void mono_de_set_log_level (int level, FILE *file);
//locking - we expose the lock object from the debugging engine to ensure we keep the same locking semantics of sdb.
void mono_de_lock (void);
void mono_de_unlock (void);
// domain handling
void mono_de_foreach_domain (GHFunc func, gpointer user_data);
void mono_de_domain_add (MonoDomain *domain);
//breakpoints
void mono_de_clear_breakpoint (MonoBreakpoint *bp);
MonoBreakpoint* mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error);
void mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs);
void mono_de_clear_breakpoints_for_domain (MonoDomain *domain);
void mono_de_add_pending_breakpoints(MonoMethod* method, MonoJitInfo* ji);
//single stepping
void mono_de_start_single_stepping (void);
void mono_de_stop_single_stepping (void);
void mono_de_process_breakpoint (void *tls, gboolean from_signal);
void mono_de_process_single_step (void *tls, gboolean from_signal);
DbgEngineErrorCode mono_de_ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, StepFilter filter, EventRequest *req);
void mono_de_cancel_ss (SingleStepReq *req);
void mono_de_cancel_all_ss (void);
DbgEngineErrorCode mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf);
gboolean set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame);
MonoClass * get_class_to_get_builder_field(DbgEngineStackFrame *frame);
gpointer get_async_method_builder (DbgEngineStackFrame *frame);
MonoMethod* get_notify_debugger_of_wait_completion_method (void);
MonoMethod* get_object_id_for_debugger_method (MonoClass* async_builder_class);
void mono_debugger_free_objref(gpointer value);
#ifdef HOST_ANDROID
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { g_print (__VA_ARGS__); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0)
#elif HOST_WASM
void wasm_debugger_log(int level, const gchar *format, ...);
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { wasm_debugger_log (level, __VA_ARGS__); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0)
#elif defined(HOST_WIN32) && !HAVE_API_SUPPORT_WIN32_CONSOLE
void win32_debugger_log(FILE *stream, const gchar *format, ...);
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { win32_debugger_log (log_file, __VA_ARGS__); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0)
#else
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { fprintf (log_file, __VA_ARGS__); fflush (log_file); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; fflush (log_file); } } while (0)
#endif
#endif
#if defined(HOST_WIN32) && !HAVE_API_SUPPORT_WIN32_CONSOLE
void win32_debugger_log(FILE *stream, const gchar *format, ...);
#define PRINT_ERROR_MSG(...) win32_debugger_log (log_file, __VA_ARGS__)
#define PRINT_MSG(...) win32_debugger_log (log_file, __VA_ARGS__)
#else
#define PRINT_ERROR_MSG(...) g_printerr (__VA_ARGS__)
#define PRINT_MSG(...) g_print (__VA_ARGS__)
#endif
void
mono_de_init(DebuggerEngineCallbacks* cbs);
| /**
* \file
*/
#ifndef __MONO_DEBUGGER_ENGINE_COMPONENT_H__
#define __MONO_DEBUGGER_ENGINE_COMPONENT_H__
#include <mono/mini/mini.h>
#include <mono/metadata/seq-points-data.h>
#include "debugger-state-machine.h"
#include <mono/metadata/mono-debug.h>
#include <mono/mini/interp/interp-internals.h>
#include "debugger-protocol.h"
#define ModifierKind MdbgProtModifierKind
#define StepDepth MdbgProtStepDepth
#define StepSize MdbgProtStepSize
#define StepFilter MdbgProtStepFilter
#define EventKind MdbgProtEventKind
#define CommandSet MdbgProtCommandSet
#define EVENT_KIND_BREAKPOINT MDBGPROT_EVENT_KIND_BREAKPOINT
#define EVENT_KIND_STEP MDBGPROT_EVENT_KIND_STEP
#define EVENT_KIND_KEEPALIVE MDBGPROT_EVENT_KIND_KEEPALIVE
#define EVENT_KIND_METHOD_ENTRY MDBGPROT_EVENT_KIND_METHOD_ENTRY
#define EVENT_KIND_METHOD_EXIT MDBGPROT_EVENT_KIND_METHOD_EXIT
#define EVENT_KIND_APPDOMAIN_CREATE MDBGPROT_EVENT_KIND_APPDOMAIN_CREATE
#define EVENT_KIND_APPDOMAIN_UNLOAD MDBGPROT_EVENT_KIND_APPDOMAIN_UNLOAD
#define EVENT_KIND_THREAD_START MDBGPROT_EVENT_KIND_THREAD_START
#define EVENT_KIND_THREAD_DEATH MDBGPROT_EVENT_KIND_THREAD_DEATH
#define EVENT_KIND_ASSEMBLY_LOAD MDBGPROT_EVENT_KIND_ASSEMBLY_LOAD
#define EVENT_KIND_ASSEMBLY_UNLOAD MDBGPROT_EVENT_KIND_ASSEMBLY_UNLOAD
#define EVENT_KIND_TYPE_LOAD MDBGPROT_EVENT_KIND_TYPE_LOAD
#define EVENT_KIND_VM_START MDBGPROT_EVENT_KIND_VM_START
#define EVENT_KIND_VM_DEATH MDBGPROT_EVENT_KIND_VM_DEATH
#define EVENT_KIND_CRASH MDBGPROT_EVENT_KIND_CRASH
#define EVENT_KIND_EXCEPTION MDBGPROT_EVENT_KIND_EXCEPTION
#define EVENT_KIND_USER_BREAK MDBGPROT_EVENT_KIND_USER_BREAK
#define EVENT_KIND_USER_LOG MDBGPROT_EVENT_KIND_USER_LOG
#define CMD_EVENT_REQUEST_SET MDBGPROT_CMD_EVENT_REQUEST_SET
#define CMD_EVENT_REQUEST_CLEAR MDBGPROT_CMD_EVENT_REQUEST_CLEAR
#define CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS MDBGPROT_CMD_EVENT_REQUEST_CLEAR_ALL_BREAKPOINTS
#define CMD_VM_VERSION MDBGPROT_CMD_VM_VERSION
#define CMD_VM_SET_PROTOCOL_VERSION MDBGPROT_CMD_VM_SET_PROTOCOL_VERSION
#define CMD_VM_ALL_THREADS MDBGPROT_CMD_VM_ALL_THREADS
#define CMD_VM_SUSPEND MDBGPROT_CMD_VM_SUSPEND
#define CMD_VM_RESUME MDBGPROT_CMD_VM_RESUME
#define CMD_VM_DISPOSE MDBGPROT_CMD_VM_DISPOSE
#define CMD_VM_EXIT MDBGPROT_CMD_VM_EXIT
#define CMD_VM_INVOKE_METHOD MDBGPROT_CMD_VM_INVOKE_METHOD
#define CMD_VM_INVOKE_METHODS MDBGPROT_CMD_VM_INVOKE_METHODS
#define CMD_VM_ABORT_INVOKE MDBGPROT_CMD_VM_ABORT_INVOKE
#define CMD_VM_SET_KEEPALIVE MDBGPROT_CMD_VM_SET_KEEPALIVE
#define CMD_VM_GET_TYPES_FOR_SOURCE_FILE MDBGPROT_CMD_VM_GET_TYPES_FOR_SOURCE_FILE
#define CMD_VM_GET_TYPES MDBGPROT_CMD_VM_GET_TYPES
#define CMD_VM_START_BUFFERING MDBGPROT_CMD_VM_START_BUFFERING
#define CMD_VM_STOP_BUFFERING MDBGPROT_CMD_VM_STOP_BUFFERING
#define CMD_APPDOMAIN_GET_ROOT_DOMAIN MDBGPROT_CMD_APPDOMAIN_GET_ROOT_DOMAIN
#define CMD_APPDOMAIN_GET_FRIENDLY_NAME MDBGPROT_CMD_APPDOMAIN_GET_FRIENDLY_NAME
#define CMD_APPDOMAIN_GET_ASSEMBLIES MDBGPROT_CMD_APPDOMAIN_GET_ASSEMBLIES
#define CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY MDBGPROT_CMD_APPDOMAIN_GET_ENTRY_ASSEMBLY
#define CMD_APPDOMAIN_GET_CORLIB MDBGPROT_CMD_APPDOMAIN_GET_CORLIB
#define CMD_APPDOMAIN_CREATE_STRING MDBGPROT_CMD_APPDOMAIN_CREATE_STRING
#define CMD_APPDOMAIN_CREATE_BYTE_ARRAY MDBGPROT_CMD_APPDOMAIN_CREATE_BYTE_ARRAY
#define CMD_APPDOMAIN_CREATE_BOXED_VALUE MDBGPROT_CMD_APPDOMAIN_CREATE_BOXED_VALUE
#define CMD_ASSEMBLY_GET_LOCATION MDBGPROT_CMD_ASSEMBLY_GET_LOCATION
#define CMD_ASSEMBLY_GET_ENTRY_POINT MDBGPROT_CMD_ASSEMBLY_GET_ENTRY_POINT
#define CMD_ASSEMBLY_GET_MANIFEST_MODULE MDBGPROT_CMD_ASSEMBLY_GET_MANIFEST_MODULE
#define CMD_ASSEMBLY_GET_OBJECT MDBGPROT_CMD_ASSEMBLY_GET_OBJECT
#define CMD_ASSEMBLY_GET_DOMAIN MDBGPROT_CMD_ASSEMBLY_GET_DOMAIN
#define CMD_ASSEMBLY_GET_TYPE MDBGPROT_CMD_ASSEMBLY_GET_TYPE
#define CMD_ASSEMBLY_GET_NAME MDBGPROT_CMD_ASSEMBLY_GET_NAME
#define CMD_ASSEMBLY_GET_METADATA_BLOB MDBGPROT_CMD_ASSEMBLY_GET_METADATA_BLOB
#define CMD_ASSEMBLY_GET_IS_DYNAMIC MDBGPROT_CMD_ASSEMBLY_GET_IS_DYNAMIC
#define CMD_ASSEMBLY_GET_PDB_BLOB MDBGPROT_CMD_ASSEMBLY_GET_PDB_BLOB
#define CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN MDBGPROT_CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN
#define CMD_ASSEMBLY_GET_METHOD_FROM_TOKEN MDBGPROT_CMD_ASSEMBLY_GET_METHOD_FROM_TOKEN
#define CMD_ASSEMBLY_HAS_DEBUG_INFO MDBGPROT_CMD_ASSEMBLY_HAS_DEBUG_INFO
#define CMD_ASSEMBLY_GET_CATTRS MDBGPROT_CMD_ASSEMBLY_GET_CATTRS
#define CMD_MODULE_GET_INFO MDBGPROT_CMD_MODULE_GET_INFO
#define CMD_FIELD_GET_INFO MDBGPROT_CMD_FIELD_GET_INFO
#define CMD_TYPE_GET_INFO MDBGPROT_CMD_TYPE_GET_INFO
#define CMD_TYPE_GET_METHODS MDBGPROT_CMD_TYPE_GET_METHODS
#define CMD_TYPE_GET_FIELDS MDBGPROT_CMD_TYPE_GET_FIELDS
#define CMD_TYPE_GET_PROPERTIES MDBGPROT_CMD_TYPE_GET_PROPERTIES
#define CMD_TYPE_GET_CATTRS MDBGPROT_CMD_TYPE_GET_CATTRS
#define CMD_TYPE_GET_FIELD_CATTRS MDBGPROT_CMD_TYPE_GET_FIELD_CATTRS
#define CMD_TYPE_GET_PROPERTY_CATTRS MDBGPROT_CMD_TYPE_GET_PROPERTY_CATTRS
#define CMD_TYPE_GET_VALUES MDBGPROT_CMD_TYPE_GET_VALUES
#define CMD_TYPE_GET_VALUES_2 MDBGPROT_CMD_TYPE_GET_VALUES_2
#define CMD_TYPE_SET_VALUES MDBGPROT_CMD_TYPE_SET_VALUES
#define CMD_TYPE_GET_OBJECT MDBGPROT_CMD_TYPE_GET_OBJECT
#define CMD_TYPE_GET_SOURCE_FILES MDBGPROT_CMD_TYPE_GET_SOURCE_FILES
#define CMD_TYPE_GET_SOURCE_FILES_2 MDBGPROT_CMD_TYPE_GET_SOURCE_FILES_2
#define CMD_TYPE_IS_ASSIGNABLE_FROM MDBGPROT_CMD_TYPE_IS_ASSIGNABLE_FROM
#define CMD_TYPE_GET_METHODS_BY_NAME_FLAGS MDBGPROT_CMD_TYPE_GET_METHODS_BY_NAME_FLAGS
#define CMD_TYPE_GET_INTERFACES MDBGPROT_CMD_TYPE_GET_INTERFACES
#define CMD_TYPE_GET_INTERFACE_MAP MDBGPROT_CMD_TYPE_GET_INTERFACE_MAP
#define CMD_TYPE_IS_INITIALIZED MDBGPROT_CMD_TYPE_IS_INITIALIZED
#define CMD_TYPE_CREATE_INSTANCE MDBGPROT_CMD_TYPE_CREATE_INSTANCE
#define CMD_TYPE_GET_VALUE_SIZE MDBGPROT_CMD_TYPE_GET_VALUE_SIZE
#define CMD_METHOD_GET_NAME MDBGPROT_CMD_METHOD_GET_NAME
#define CMD_METHOD_GET_DECLARING_TYPE MDBGPROT_CMD_METHOD_GET_DECLARING_TYPE
#define CMD_METHOD_GET_DEBUG_INFO MDBGPROT_CMD_METHOD_GET_DEBUG_INFO
#define CMD_METHOD_GET_PARAM_INFO MDBGPROT_CMD_METHOD_GET_PARAM_INFO
#define CMD_METHOD_GET_LOCALS_INFO MDBGPROT_CMD_METHOD_GET_LOCALS_INFO
#define CMD_METHOD_GET_INFO MDBGPROT_CMD_METHOD_GET_INFO
#define CMD_METHOD_GET_BODY MDBGPROT_CMD_METHOD_GET_BODY
#define CMD_METHOD_RESOLVE_TOKEN MDBGPROT_CMD_METHOD_RESOLVE_TOKEN
#define CMD_METHOD_GET_CATTRS MDBGPROT_CMD_METHOD_GET_CATTRS
#define CMD_METHOD_MAKE_GENERIC_METHOD MDBGPROT_CMD_METHOD_MAKE_GENERIC_METHOD
#define CMD_METHOD_TOKEN MDBGPROT_CMD_METHOD_TOKEN
#define CMD_METHOD_ASSEMBLY MDBGPROT_CMD_METHOD_ASSEMBLY
#define CMD_THREAD_GET_NAME MDBGPROT_CMD_THREAD_GET_NAME
#define CMD_THREAD_GET_FRAME_INFO MDBGPROT_CMD_THREAD_GET_FRAME_INFO
#define CMD_THREAD_GET_STATE MDBGPROT_CMD_THREAD_GET_STATE
#define CMD_THREAD_GET_INFO MDBGPROT_CMD_THREAD_GET_INFO
#define CMD_THREAD_GET_ID MDBGPROT_CMD_THREAD_GET_ID
#define CMD_THREAD_GET_TID MDBGPROT_CMD_THREAD_GET_TID
#define CMD_THREAD_SET_IP MDBGPROT_CMD_THREAD_SET_IP
#define CMD_THREAD_ELAPSED_TIME MDBGPROT_CMD_THREAD_ELAPSED_TIME
#define CMD_STACK_FRAME_GET_DOMAIN MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN
#define CMD_STACK_FRAME_GET_ARGUMENT MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENT
#define CMD_STACK_FRAME_GET_VALUES MDBGPROT_CMD_STACK_FRAME_GET_VALUES
#define CMD_STACK_FRAME_GET_THIS MDBGPROT_CMD_STACK_FRAME_GET_THIS
#define CMD_STACK_FRAME_SET_VALUES MDBGPROT_CMD_STACK_FRAME_SET_VALUES
#define CMD_STACK_FRAME_GET_DOMAIN MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN
#define CMD_STACK_FRAME_SET_THIS MDBGPROT_CMD_STACK_FRAME_SET_THIS
#define CMD_ARRAY_REF_GET_TYPE MDBGPROT_CMD_ARRAY_REF_GET_TYPE
#define CMD_ARRAY_REF_GET_LENGTH MDBGPROT_CMD_ARRAY_REF_GET_LENGTH
#define CMD_ARRAY_REF_GET_VALUES MDBGPROT_CMD_ARRAY_REF_GET_VALUES
#define CMD_ARRAY_REF_SET_VALUES MDBGPROT_CMD_ARRAY_REF_SET_VALUES
#define CMD_STRING_REF_GET_VALUE MDBGPROT_CMD_STRING_REF_GET_VALUE
#define CMD_STRING_REF_GET_LENGTH MDBGPROT_CMD_STRING_REF_GET_LENGTH
#define CMD_STRING_REF_GET_CHARS MDBGPROT_CMD_STRING_REF_GET_CHARS
#define CMD_POINTER_GET_VALUE MDBGPROT_CMD_POINTER_GET_VALUE
#define CMD_OBJECT_REF_IS_COLLECTED MDBGPROT_CMD_OBJECT_REF_IS_COLLECTED
#define CMD_OBJECT_REF_GET_TYPE MDBGPROT_CMD_OBJECT_REF_GET_TYPE
#define CMD_OBJECT_REF_GET_VALUES_ICORDBG MDBGPROT_CMD_OBJECT_REF_GET_VALUES_ICORDBG
#define CMD_OBJECT_REF_GET_VALUES MDBGPROT_CMD_OBJECT_REF_GET_VALUES
#define CMD_OBJECT_REF_SET_VALUES MDBGPROT_CMD_OBJECT_REF_SET_VALUES
#define CMD_OBJECT_REF_GET_ADDRESS MDBGPROT_CMD_OBJECT_REF_GET_ADDRESS
#define CMD_OBJECT_REF_GET_DOMAIN MDBGPROT_CMD_OBJECT_REF_GET_DOMAIN
#define CMD_OBJECT_REF_GET_INFO MDBGPROT_CMD_OBJECT_REF_GET_INFO
#define TOKEN_TYPE_METHOD MDBGPROT_TOKEN_TYPE_METHOD
#define TOKEN_TYPE_UNKNOWN MDBGPROT_TOKEN_TYPE_UNKNOWN
#define TOKEN_TYPE_FIELD MDBGPROT_TOKEN_TYPE_FIELD
#define TOKEN_TYPE_METHOD MDBGPROT_TOKEN_TYPE_METHOD
#define TOKEN_TYPE_STRING MDBGPROT_TOKEN_TYPE_STRING
#define TOKEN_TYPE_TYPE MDBGPROT_TOKEN_TYPE_TYPE
#define STEP_FILTER_STATIC_CTOR MDBGPROT_STEP_FILTER_STATIC_CTOR
#define STEP_DEPTH_OVER MDBGPROT_STEP_DEPTH_OVER
#define STEP_DEPTH_OUT MDBGPROT_STEP_DEPTH_OUT
#define STEP_DEPTH_INTO MDBGPROT_STEP_DEPTH_INTO
#define STEP_SIZE_MIN MDBGPROT_STEP_SIZE_MIN
#define STEP_SIZE_LINE MDBGPROT_STEP_SIZE_LINE
#define SUSPEND_POLICY_NONE MDBGPROT_SUSPEND_POLICY_NONE
#define SUSPEND_POLICY_ALL MDBGPROT_SUSPEND_POLICY_ALL
#define SUSPEND_POLICY_EVENT_THREAD MDBGPROT_SUSPEND_POLICY_EVENT_THREAD
#define CMD_COMPOSITE MDBGPROT_CMD_COMPOSITE
#define INVOKE_FLAG_SINGLE_THREADED MDBGPROT_INVOKE_FLAG_SINGLE_THREADED
#define INVOKE_FLAG_VIRTUAL MDBGPROT_INVOKE_FLAG_VIRTUAL
#define INVOKE_FLAG_DISABLE_BREAKPOINTS MDBGPROT_INVOKE_FLAG_DISABLE_BREAKPOINTS
#define INVOKE_FLAG_RETURN_OUT_THIS MDBGPROT_INVOKE_FLAG_RETURN_OUT_THIS
#define INVOKE_FLAG_RETURN_OUT_ARGS MDBGPROT_INVOKE_FLAG_RETURN_OUT_ARGS
#define MOD_KIND_ASSEMBLY_ONLY MDBGPROT_MOD_KIND_ASSEMBLY_ONLY
#define MOD_KIND_EXCEPTION_ONLY MDBGPROT_MOD_KIND_EXCEPTION_ONLY
#define MOD_KIND_NONE MDBGPROT_MOD_KIND_NONE
#define MOD_KIND_COUNT MDBGPROT_MOD_KIND_COUNT
#define MOD_KIND_THREAD_ONLY MDBGPROT_MOD_KIND_THREAD_ONLY
#define MOD_KIND_SOURCE_FILE_ONLY MDBGPROT_MOD_KIND_SOURCE_FILE_ONLY
#define MOD_KIND_TYPE_NAME_ONLY MDBGPROT_MOD_KIND_TYPE_NAME_ONLY
#define MOD_KIND_STEP MDBGPROT_MOD_KIND_STEP
#define MOD_KIND_LOCATION_ONLY MDBGPROT_MOD_KIND_LOCATION_ONLY
#define STEP_FILTER_DEBUGGER_HIDDEN MDBGPROT_STEP_FILTER_DEBUGGER_HIDDEN
#define STEP_FILTER_DEBUGGER_NON_USER_CODE MDBGPROT_STEP_FILTER_DEBUGGER_NON_USER_CODE
#define STEP_FILTER_DEBUGGER_STEP_THROUGH MDBGPROT_STEP_FILTER_DEBUGGER_STEP_THROUGH
#define STEP_FILTER_NONE MDBGPROT_STEP_FILTER_NONE
#define ERR_NONE MDBGPROT_ERR_NONE
#define ERR_INVOKE_ABORTED MDBGPROT_ERR_INVOKE_ABORTED
#define ERR_NOT_SUSPENDED MDBGPROT_ERR_NOT_SUSPENDED
#define ERR_INVALID_ARGUMENT MDBGPROT_ERR_INVALID_ARGUMENT
#define ERR_INVALID_OBJECT MDBGPROT_ERR_INVALID_OBJECT
#define ERR_UNLOADED MDBGPROT_ERR_UNLOADED
#define ERR_NOT_IMPLEMENTED MDBGPROT_ERR_NOT_IMPLEMENTED
#define ERR_LOADER_ERROR MDBGPROT_ERR_LOADER_ERROR
#define ERR_NO_INVOCATION MDBGPROT_ERR_NO_INVOCATION
#define ERR_NO_SEQ_POINT_AT_IL_OFFSET MDBGPROT_ERR_NO_SEQ_POINT_AT_IL_OFFSET
#define ERR_INVALID_FIELDID MDBGPROT_ERR_INVALID_FIELDID
#define ERR_INVALID_FRAMEID MDBGPROT_ERR_INVALID_FRAMEID
#define ERR_ABSENT_INFORMATION MDBGPROT_ERR_ABSENT_INFORMATION
#define VALUE_TYPE_ID_FIXED_ARRAY MDBGPROT_VALUE_TYPE_ID_FIXED_ARRAY
#define VALUE_TYPE_ID_NULL MDBGPROT_VALUE_TYPE_ID_NULL
#define VALUE_TYPE_ID_PARENT_VTYPE MDBGPROT_VALUE_TYPE_ID_PARENT_VTYPE
#define VALUE_TYPE_ID_TYPE MDBGPROT_VALUE_TYPE_ID_TYPE
#define CMD_SET_VM MDBGPROT_CMD_SET_VM
#define CMD_SET_OBJECT_REF MDBGPROT_CMD_SET_OBJECT_REF
#define CMD_SET_STRING_REF MDBGPROT_CMD_SET_STRING_REF
#define CMD_SET_THREAD MDBGPROT_CMD_SET_THREAD
#define CMD_SET_ARRAY_REF MDBGPROT_CMD_SET_ARRAY_REF
#define CMD_SET_EVENT_REQUEST MDBGPROT_CMD_SET_EVENT_REQUEST
#define CMD_SET_STACK_FRAME MDBGPROT_CMD_SET_STACK_FRAME
#define CMD_SET_APPDOMAIN MDBGPROT_CMD_SET_APPDOMAIN
#define CMD_SET_ASSEMBLY MDBGPROT_CMD_SET_ASSEMBLY
#define CMD_SET_METHOD MDBGPROT_CMD_SET_METHOD
#define CMD_SET_TYPE MDBGPROT_CMD_SET_TYPE
#define CMD_SET_MODULE MDBGPROT_CMD_SET_MODULE
#define CMD_SET_FIELD MDBGPROT_CMD_SET_FIELD
#define CMD_SET_POINTER MDBGPROT_CMD_SET_POINTER
#define CMD_SET_EVENT MDBGPROT_CMD_SET_EVENT
#define Buffer MdbgProtBuffer
#define ReplyPacket MdbgProtReplyPacket
#define buffer_init m_dbgprot_buffer_init
#define buffer_free m_dbgprot_buffer_free
#define buffer_add_int m_dbgprot_buffer_add_int
#define buffer_add_long m_dbgprot_buffer_add_long
#define buffer_add_string m_dbgprot_buffer_add_string
#define buffer_add_id m_dbgprot_buffer_add_id
#define buffer_add_byte m_dbgprot_buffer_add_byte
#define buffer_len m_dbgprot_buffer_len
#define buffer_add_buffer m_dbgprot_buffer_add_buffer
#define buffer_add_data m_dbgprot_buffer_add_data
#define buffer_add_utf16 m_dbgprot_buffer_add_utf16
#define buffer_add_byte_array m_dbgprot_buffer_add_byte_array
#define buffer_add_short m_dbgprot_buffer_add_short
#define decode_id m_dbgprot_decode_id
#define decode_int m_dbgprot_decode_int
#define decode_byte m_dbgprot_decode_byte
#define decode_long m_dbgprot_decode_long
#define decode_string m_dbgprot_decode_string
#define event_to_string m_dbgprot_event_to_string
#define ErrorCode MdbgProtErrorCode
#define FRAME_FLAG_DEBUGGER_INVOKE MDBGPROT_FRAME_FLAG_DEBUGGER_INVOKE
#define FRAME_FLAG_NATIVE_TRANSITION MDBGPROT_FRAME_FLAG_NATIVE_TRANSITION
/*
* Contains information about an inserted breakpoint.
*/
typedef struct {
long il_offset, native_offset;
guint8 *ip;
MonoJitInfo *ji;
MonoDomain *domain;
} BreakpointInstance;
/*
* OBJECT IDS
*/
/*
* Represents an object accessible by the debugger client.
*/
typedef struct {
/* Unique id used in the wire protocol to refer to objects */
int id;
/*
* A weakref gc handle pointing to the object. The gc handle is used to
* detect if the object was garbage collected.
*/
MonoGCHandle handle;
} ObjRef;
typedef struct
{
//Must be the first field to ensure pointer equivalence
DbgEngineStackFrame de;
int id;
guint32 il_offset;
/*
* If method is gshared, this is the actual instance, otherwise this is equal to
* method.
*/
MonoMethod *actual_method;
/*
* This is the method which is visible to debugger clients. Same as method,
* except for native-to-managed wrappers.
*/
MonoMethod *api_method;
MonoContext ctx;
MonoDebugMethodJitInfo *jit;
MonoInterpFrameHandle interp_frame;
gpointer frame_addr;
int flags;
host_mgreg_t *reg_locations [MONO_MAX_IREGS];
/*
* Whenever ctx is set. This is FALSE for the last frame of running threads, since
* the frame can become invalid.
*/
gboolean has_ctx;
} StackFrame;
#define DE_ERR_NONE 0
// WARNING WARNING WARNING
// Error codes MUST match those of sdb for now
#define DE_ERR_NOT_IMPLEMENTED 100
MonoGHashTable *
mono_debugger_get_thread_states (void);
gboolean
mono_debugger_is_disconnected (void);
gsize
mono_debugger_tls_thread_id (DebuggerTlsData *debuggerTlsData);
void
mono_debugger_set_thread_state (DebuggerTlsData *ref, MonoDebuggerThreadState expected, MonoDebuggerThreadState set);
MonoDebuggerThreadState
mono_debugger_get_thread_state (DebuggerTlsData *ref);
void mono_de_cleanup (void);
void mono_de_set_log_level (int level, FILE *file);
//locking - we expose the lock object from the debugging engine to ensure we keep the same locking semantics of sdb.
void mono_de_lock (void);
void mono_de_unlock (void);
// domain handling
void mono_de_foreach_domain (GHFunc func, gpointer user_data);
void mono_de_domain_add (MonoDomain *domain);
//breakpoints
void mono_de_clear_breakpoint (MonoBreakpoint *bp);
MonoBreakpoint* mono_de_set_breakpoint (MonoMethod *method, long il_offset, EventRequest *req, MonoError *error);
void mono_de_collect_breakpoints_by_sp (SeqPoint *sp, MonoJitInfo *ji, GPtrArray *ss_reqs, GPtrArray *bp_reqs);
void mono_de_clear_breakpoints_for_domain (MonoDomain *domain);
void mono_de_add_pending_breakpoints(MonoMethod* method, MonoJitInfo* ji);
//single stepping
void mono_de_start_single_stepping (void);
void mono_de_stop_single_stepping (void);
void mono_de_process_breakpoint (void *tls, gboolean from_signal);
void mono_de_process_single_step (void *tls, gboolean from_signal);
DbgEngineErrorCode mono_de_ss_create (MonoInternalThread *thread, StepSize size, StepDepth depth, StepFilter filter, EventRequest *req);
void mono_de_cancel_ss (SingleStepReq *req);
void mono_de_cancel_all_ss (void);
DbgEngineErrorCode mono_de_set_interp_var (MonoType *t, gpointer addr, guint8 *val_buf);
gboolean set_set_notification_for_wait_completion_flag (DbgEngineStackFrame *frame);
MonoClass * get_class_to_get_builder_field(DbgEngineStackFrame *frame);
gpointer get_async_method_builder (DbgEngineStackFrame *frame);
MonoMethod* get_notify_debugger_of_wait_completion_method (void);
MonoMethod* get_object_id_for_debugger_method (MonoClass* async_builder_class);
void mono_debugger_free_objref(gpointer value);
#ifdef HOST_ANDROID
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { g_print (__VA_ARGS__); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0)
#elif HOST_WASM
void wasm_debugger_log(int level, const gchar *format, ...);
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { wasm_debugger_log (level, __VA_ARGS__); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0)
#elif defined(HOST_WIN32) && !HAVE_API_SUPPORT_WIN32_CONSOLE
void win32_debugger_log(FILE *stream, const gchar *format, ...);
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { win32_debugger_log (log_file, __VA_ARGS__); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; } } while (0)
#else
#define PRINT_DEBUG_MSG(level, ...) do { if (G_UNLIKELY ((level) <= log_level)) { fprintf (log_file, __VA_ARGS__); fflush (log_file); } } while (0)
#define DEBUG(level,s) do { if (G_UNLIKELY ((level) <= log_level)) { s; fflush (log_file); } } while (0)
#endif
#endif
#if defined(HOST_WIN32) && !HAVE_API_SUPPORT_WIN32_CONSOLE
void win32_debugger_log(FILE *stream, const gchar *format, ...);
#define PRINT_ERROR_MSG(...) win32_debugger_log (log_file, __VA_ARGS__)
#define PRINT_MSG(...) win32_debugger_log (log_file, __VA_ARGS__)
#else
#define PRINT_ERROR_MSG(...) g_printerr (__VA_ARGS__)
#define PRINT_MSG(...) g_print (__VA_ARGS__)
#endif
void
mono_de_init(DebuggerEngineCallbacks* cbs);
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/public/mono/metadata/details/metadata-types.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
#ifndef _MONO_METADATA_TYPES_H
#define _MONO_METADATA_TYPES_H
#include <mono/utils/details/mono-publib-types.h>
#include <mono/utils/mono-forward.h>
#include <mono/metadata/blob.h>
#include <mono/metadata/row-indexes.h>
#include <mono/metadata/details/image-types.h>
#include <mono/metadata/object-forward.h>
MONO_BEGIN_DECLS
typedef enum {
MONO_EXCEPTION_CLAUSE_NONE,
MONO_EXCEPTION_CLAUSE_FILTER,
MONO_EXCEPTION_CLAUSE_FINALLY,
MONO_EXCEPTION_CLAUSE_FAULT = 4
} MonoExceptionEnum;
typedef enum {
MONO_CALL_DEFAULT,
MONO_CALL_C,
MONO_CALL_STDCALL,
MONO_CALL_THISCALL,
MONO_CALL_FASTCALL,
MONO_CALL_VARARG = 0x05,
/* unused, */
/* unused, */
/* unused, */
MONO_CALL_UNMANAGED_MD = 0x09, /* default unmanaged calling convention, with additional attributed encoded in modopts */
} MonoCallConvention;
/* ECMA lamespec: the old spec had more info... */
typedef enum {
MONO_NATIVE_BOOLEAN = 0x02, /* 4 bytes, 0 is false, != 0 is true */
MONO_NATIVE_I1 = 0x03,
MONO_NATIVE_U1 = 0x04,
MONO_NATIVE_I2 = 0x05,
MONO_NATIVE_U2 = 0x06,
MONO_NATIVE_I4 = 0x07,
MONO_NATIVE_U4 = 0x08,
MONO_NATIVE_I8 = 0x09,
MONO_NATIVE_U8 = 0x0a,
MONO_NATIVE_R4 = 0x0b,
MONO_NATIVE_R8 = 0x0c,
MONO_NATIVE_CURRENCY = 0x0f,
MONO_NATIVE_BSTR = 0x13, /* prefixed length, Unicode */
MONO_NATIVE_LPSTR = 0x14, /* ANSI, null terminated */
MONO_NATIVE_LPWSTR = 0x15, /* UNICODE, null terminated */
MONO_NATIVE_LPTSTR = 0x16, /* plattform dep., null terminated */
MONO_NATIVE_BYVALTSTR = 0x17,
MONO_NATIVE_IUNKNOWN = 0x19,
MONO_NATIVE_IDISPATCH = 0x1a,
MONO_NATIVE_STRUCT = 0x1b,
MONO_NATIVE_INTERFACE = 0x1c,
MONO_NATIVE_SAFEARRAY = 0x1d,
MONO_NATIVE_BYVALARRAY = 0x1e,
MONO_NATIVE_INT = 0x1f,
MONO_NATIVE_UINT = 0x20,
MONO_NATIVE_VBBYREFSTR = 0x22,
MONO_NATIVE_ANSIBSTR = 0x23, /* prefixed length, ANSI */
MONO_NATIVE_TBSTR = 0x24, /* prefixed length, plattform dep. */
MONO_NATIVE_VARIANTBOOL = 0x25,
MONO_NATIVE_FUNC = 0x26,
MONO_NATIVE_ASANY = 0x28,
MONO_NATIVE_LPARRAY = 0x2a,
MONO_NATIVE_LPSTRUCT = 0x2b,
MONO_NATIVE_CUSTOM = 0x2c,
MONO_NATIVE_ERROR = 0x2d,
// TODO: MONO_NATIVE_IINSPECTABLE = 0x2e
// TODO: MONO_NATIVE_HSTRING = 0x2f
MONO_NATIVE_UTF8STR = 0x30,
MONO_NATIVE_MAX = 0x50 /* no info */
} MonoMarshalNative;
/* Used only in context of SafeArray */
typedef enum {
MONO_VARIANT_EMPTY = 0x00,
MONO_VARIANT_NULL = 0x01,
MONO_VARIANT_I2 = 0x02,
MONO_VARIANT_I4 = 0x03,
MONO_VARIANT_R4 = 0x04,
MONO_VARIANT_R8 = 0x05,
MONO_VARIANT_CY = 0x06,
MONO_VARIANT_DATE = 0x07,
MONO_VARIANT_BSTR = 0x08,
MONO_VARIANT_DISPATCH = 0x09,
MONO_VARIANT_ERROR = 0x0a,
MONO_VARIANT_BOOL = 0x0b,
MONO_VARIANT_VARIANT = 0x0c,
MONO_VARIANT_UNKNOWN = 0x0d,
MONO_VARIANT_DECIMAL = 0x0e,
MONO_VARIANT_I1 = 0x10,
MONO_VARIANT_UI1 = 0x11,
MONO_VARIANT_UI2 = 0x12,
MONO_VARIANT_UI4 = 0x13,
MONO_VARIANT_I8 = 0x14,
MONO_VARIANT_UI8 = 0x15,
MONO_VARIANT_INT = 0x16,
MONO_VARIANT_UINT = 0x17,
MONO_VARIANT_VOID = 0x18,
MONO_VARIANT_HRESULT = 0x19,
MONO_VARIANT_PTR = 0x1a,
MONO_VARIANT_SAFEARRAY = 0x1b,
MONO_VARIANT_CARRAY = 0x1c,
MONO_VARIANT_USERDEFINED = 0x1d,
MONO_VARIANT_LPSTR = 0x1e,
MONO_VARIANT_LPWSTR = 0x1f,
MONO_VARIANT_RECORD = 0x24,
MONO_VARIANT_FILETIME = 0x40,
MONO_VARIANT_BLOB = 0x41,
MONO_VARIANT_STREAM = 0x42,
MONO_VARIANT_STORAGE = 0x43,
MONO_VARIANT_STREAMED_OBJECT = 0x44,
MONO_VARIANT_STORED_OBJECT = 0x45,
MONO_VARIANT_BLOB_OBJECT = 0x46,
MONO_VARIANT_CF = 0x47,
MONO_VARIANT_CLSID = 0x48,
MONO_VARIANT_VECTOR = 0x1000,
MONO_VARIANT_ARRAY = 0x2000,
MONO_VARIANT_BYREF = 0x4000
} MonoMarshalVariant;
typedef enum {
MONO_MARSHAL_CONV_NONE,
MONO_MARSHAL_CONV_BOOL_VARIANTBOOL,
MONO_MARSHAL_CONV_BOOL_I4,
MONO_MARSHAL_CONV_STR_BSTR,
MONO_MARSHAL_CONV_STR_LPSTR,
MONO_MARSHAL_CONV_LPSTR_STR,
MONO_MARSHAL_CONV_LPTSTR_STR,
MONO_MARSHAL_CONV_STR_LPWSTR,
MONO_MARSHAL_CONV_LPWSTR_STR,
MONO_MARSHAL_CONV_STR_LPTSTR,
MONO_MARSHAL_CONV_STR_ANSIBSTR,
MONO_MARSHAL_CONV_STR_TBSTR,
MONO_MARSHAL_CONV_STR_BYVALSTR,
MONO_MARSHAL_CONV_STR_BYVALWSTR,
MONO_MARSHAL_CONV_SB_LPSTR,
MONO_MARSHAL_CONV_SB_LPTSTR,
MONO_MARSHAL_CONV_SB_LPWSTR,
MONO_MARSHAL_CONV_LPSTR_SB,
MONO_MARSHAL_CONV_LPTSTR_SB,
MONO_MARSHAL_CONV_LPWSTR_SB,
MONO_MARSHAL_CONV_ARRAY_BYVALARRAY,
MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY,
MONO_MARSHAL_CONV_ARRAY_SAVEARRAY,
MONO_MARSHAL_CONV_ARRAY_LPARRAY,
MONO_MARSHAL_FREE_LPARRAY,
MONO_MARSHAL_CONV_OBJECT_INTERFACE,
MONO_MARSHAL_CONV_OBJECT_IDISPATCH,
MONO_MARSHAL_CONV_OBJECT_IUNKNOWN,
MONO_MARSHAL_CONV_OBJECT_STRUCT,
MONO_MARSHAL_CONV_DEL_FTN,
MONO_MARSHAL_CONV_FTN_DEL,
MONO_MARSHAL_FREE_ARRAY,
MONO_MARSHAL_CONV_BSTR_STR,
MONO_MARSHAL_CONV_SAFEHANDLE,
MONO_MARSHAL_CONV_HANDLEREF,
MONO_MARSHAL_CONV_STR_UTF8STR,
MONO_MARSHAL_CONV_SB_UTF8STR,
MONO_MARSHAL_CONV_UTF8STR_STR,
MONO_MARSHAL_CONV_UTF8STR_SB,
MONO_MARSHAL_CONV_FIXED_BUFFER,
MONO_MARSHAL_CONV_ANSIBSTR_STR,
MONO_MARSHAL_CONV_TBSTR_STR
} MonoMarshalConv;
#define MONO_MARSHAL_CONV_INVALID ((MonoMarshalConv)-1)
typedef struct {
MonoMarshalNative native;
union {
struct {
MonoMarshalNative elem_type;
int32_t num_elem; /* -1 if not set */
int16_t param_num; /* -1 if not set */
int16_t elem_mult; /* -1 if not set */
} array_data;
struct {
char *custom_name;
char *cookie;
MonoImage *image;
} custom_data;
struct {
MonoMarshalVariant elem_type;
int32_t num_elem;
} safearray_data;
} data;
} MonoMarshalSpec;
typedef struct {
uint32_t flags;
uint32_t try_offset;
uint32_t try_len;
uint32_t handler_offset;
uint32_t handler_len;
union {
uint32_t filter_offset;
MonoClass *catch_class;
} data;
} MonoExceptionClause;
typedef struct _MonoType MonoType;
typedef struct _MonoGenericInst MonoGenericInst;
typedef struct _MonoGenericClass MonoGenericClass;
typedef struct _MonoGenericContext MonoGenericContext;
typedef struct _MonoGenericContainer MonoGenericContainer;
typedef struct _MonoGenericParam MonoGenericParam;
typedef struct _MonoArrayType MonoArrayType;
typedef struct _MonoMethodSignature MonoMethodSignature;
/* FIXME: Keeping this name alive for now, since it is part of the exposed API, even though no entrypoint uses it. */
typedef struct invalid_name MonoGenericMethod;
typedef struct {
unsigned int required : 1;
unsigned int token : 31;
} MonoCustomMod;
typedef struct _MonoCustomModContainer {
uint8_t count; /* max 64 modifiers follow at the end */
MonoImage *image; /* Image containing types in modifiers array */
MonoCustomMod modifiers [1]; /* Actual length is count */
} MonoCustomModContainer;
struct _MonoArrayType {
MonoClass *eklass;
// Number of dimensions of the array
uint8_t rank;
// Arrays recording known upper and lower index bounds for each dimension
uint8_t numsizes;
uint8_t numlobounds;
int *sizes;
int *lobounds;
};
typedef struct _MonoMethodHeader MonoMethodHeader;
typedef enum {
MONO_PARSE_TYPE,
MONO_PARSE_MOD_TYPE,
MONO_PARSE_LOCAL,
MONO_PARSE_PARAM,
MONO_PARSE_RET,
MONO_PARSE_FIELD
} MonoParseTypeMode;
MONO_END_DECLS
#endif /* _MONO_METADATA_TYPES_H */
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
#ifndef _MONO_METADATA_TYPES_H
#define _MONO_METADATA_TYPES_H
#include <mono/utils/details/mono-publib-types.h>
#include <mono/utils/mono-forward.h>
#include <mono/metadata/blob.h>
#include <mono/metadata/row-indexes.h>
#include <mono/metadata/details/image-types.h>
#include <mono/metadata/object-forward.h>
MONO_BEGIN_DECLS
typedef enum {
MONO_EXCEPTION_CLAUSE_NONE,
MONO_EXCEPTION_CLAUSE_FILTER,
MONO_EXCEPTION_CLAUSE_FINALLY,
MONO_EXCEPTION_CLAUSE_FAULT = 4
} MonoExceptionEnum;
typedef enum {
MONO_CALL_DEFAULT,
MONO_CALL_C,
MONO_CALL_STDCALL,
MONO_CALL_THISCALL,
MONO_CALL_FASTCALL,
MONO_CALL_VARARG = 0x05,
/* unused, */
/* unused, */
/* unused, */
MONO_CALL_UNMANAGED_MD = 0x09, /* default unmanaged calling convention, with additional attributed encoded in modopts */
} MonoCallConvention;
/* ECMA lamespec: the old spec had more info... */
typedef enum {
MONO_NATIVE_BOOLEAN = 0x02, /* 4 bytes, 0 is false, != 0 is true */
MONO_NATIVE_I1 = 0x03,
MONO_NATIVE_U1 = 0x04,
MONO_NATIVE_I2 = 0x05,
MONO_NATIVE_U2 = 0x06,
MONO_NATIVE_I4 = 0x07,
MONO_NATIVE_U4 = 0x08,
MONO_NATIVE_I8 = 0x09,
MONO_NATIVE_U8 = 0x0a,
MONO_NATIVE_R4 = 0x0b,
MONO_NATIVE_R8 = 0x0c,
MONO_NATIVE_CURRENCY = 0x0f,
MONO_NATIVE_BSTR = 0x13, /* prefixed length, Unicode */
MONO_NATIVE_LPSTR = 0x14, /* ANSI, null terminated */
MONO_NATIVE_LPWSTR = 0x15, /* UNICODE, null terminated */
MONO_NATIVE_LPTSTR = 0x16, /* plattform dep., null terminated */
MONO_NATIVE_BYVALTSTR = 0x17,
MONO_NATIVE_IUNKNOWN = 0x19,
MONO_NATIVE_IDISPATCH = 0x1a,
MONO_NATIVE_STRUCT = 0x1b,
MONO_NATIVE_INTERFACE = 0x1c,
MONO_NATIVE_SAFEARRAY = 0x1d,
MONO_NATIVE_BYVALARRAY = 0x1e,
MONO_NATIVE_INT = 0x1f,
MONO_NATIVE_UINT = 0x20,
MONO_NATIVE_VBBYREFSTR = 0x22,
MONO_NATIVE_ANSIBSTR = 0x23, /* prefixed length, ANSI */
MONO_NATIVE_TBSTR = 0x24, /* prefixed length, plattform dep. */
MONO_NATIVE_VARIANTBOOL = 0x25,
MONO_NATIVE_FUNC = 0x26,
MONO_NATIVE_ASANY = 0x28,
MONO_NATIVE_LPARRAY = 0x2a,
MONO_NATIVE_LPSTRUCT = 0x2b,
MONO_NATIVE_CUSTOM = 0x2c,
MONO_NATIVE_ERROR = 0x2d,
// TODO: MONO_NATIVE_IINSPECTABLE = 0x2e
// TODO: MONO_NATIVE_HSTRING = 0x2f
MONO_NATIVE_UTF8STR = 0x30,
MONO_NATIVE_MAX = 0x50 /* no info */
} MonoMarshalNative;
/* Used only in context of SafeArray */
typedef enum {
MONO_VARIANT_EMPTY = 0x00,
MONO_VARIANT_NULL = 0x01,
MONO_VARIANT_I2 = 0x02,
MONO_VARIANT_I4 = 0x03,
MONO_VARIANT_R4 = 0x04,
MONO_VARIANT_R8 = 0x05,
MONO_VARIANT_CY = 0x06,
MONO_VARIANT_DATE = 0x07,
MONO_VARIANT_BSTR = 0x08,
MONO_VARIANT_DISPATCH = 0x09,
MONO_VARIANT_ERROR = 0x0a,
MONO_VARIANT_BOOL = 0x0b,
MONO_VARIANT_VARIANT = 0x0c,
MONO_VARIANT_UNKNOWN = 0x0d,
MONO_VARIANT_DECIMAL = 0x0e,
MONO_VARIANT_I1 = 0x10,
MONO_VARIANT_UI1 = 0x11,
MONO_VARIANT_UI2 = 0x12,
MONO_VARIANT_UI4 = 0x13,
MONO_VARIANT_I8 = 0x14,
MONO_VARIANT_UI8 = 0x15,
MONO_VARIANT_INT = 0x16,
MONO_VARIANT_UINT = 0x17,
MONO_VARIANT_VOID = 0x18,
MONO_VARIANT_HRESULT = 0x19,
MONO_VARIANT_PTR = 0x1a,
MONO_VARIANT_SAFEARRAY = 0x1b,
MONO_VARIANT_CARRAY = 0x1c,
MONO_VARIANT_USERDEFINED = 0x1d,
MONO_VARIANT_LPSTR = 0x1e,
MONO_VARIANT_LPWSTR = 0x1f,
MONO_VARIANT_RECORD = 0x24,
MONO_VARIANT_FILETIME = 0x40,
MONO_VARIANT_BLOB = 0x41,
MONO_VARIANT_STREAM = 0x42,
MONO_VARIANT_STORAGE = 0x43,
MONO_VARIANT_STREAMED_OBJECT = 0x44,
MONO_VARIANT_STORED_OBJECT = 0x45,
MONO_VARIANT_BLOB_OBJECT = 0x46,
MONO_VARIANT_CF = 0x47,
MONO_VARIANT_CLSID = 0x48,
MONO_VARIANT_VECTOR = 0x1000,
MONO_VARIANT_ARRAY = 0x2000,
MONO_VARIANT_BYREF = 0x4000
} MonoMarshalVariant;
typedef enum {
MONO_MARSHAL_CONV_NONE,
MONO_MARSHAL_CONV_BOOL_VARIANTBOOL,
MONO_MARSHAL_CONV_BOOL_I4,
MONO_MARSHAL_CONV_STR_BSTR,
MONO_MARSHAL_CONV_STR_LPSTR,
MONO_MARSHAL_CONV_LPSTR_STR,
MONO_MARSHAL_CONV_LPTSTR_STR,
MONO_MARSHAL_CONV_STR_LPWSTR,
MONO_MARSHAL_CONV_LPWSTR_STR,
MONO_MARSHAL_CONV_STR_LPTSTR,
MONO_MARSHAL_CONV_STR_ANSIBSTR,
MONO_MARSHAL_CONV_STR_TBSTR,
MONO_MARSHAL_CONV_STR_BYVALSTR,
MONO_MARSHAL_CONV_STR_BYVALWSTR,
MONO_MARSHAL_CONV_SB_LPSTR,
MONO_MARSHAL_CONV_SB_LPTSTR,
MONO_MARSHAL_CONV_SB_LPWSTR,
MONO_MARSHAL_CONV_LPSTR_SB,
MONO_MARSHAL_CONV_LPTSTR_SB,
MONO_MARSHAL_CONV_LPWSTR_SB,
MONO_MARSHAL_CONV_ARRAY_BYVALARRAY,
MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY,
MONO_MARSHAL_CONV_ARRAY_SAVEARRAY,
MONO_MARSHAL_CONV_ARRAY_LPARRAY,
MONO_MARSHAL_FREE_LPARRAY,
MONO_MARSHAL_CONV_OBJECT_INTERFACE,
MONO_MARSHAL_CONV_OBJECT_IDISPATCH,
MONO_MARSHAL_CONV_OBJECT_IUNKNOWN,
MONO_MARSHAL_CONV_OBJECT_STRUCT,
MONO_MARSHAL_CONV_DEL_FTN,
MONO_MARSHAL_CONV_FTN_DEL,
MONO_MARSHAL_FREE_ARRAY,
MONO_MARSHAL_CONV_BSTR_STR,
MONO_MARSHAL_CONV_SAFEHANDLE,
MONO_MARSHAL_CONV_HANDLEREF,
MONO_MARSHAL_CONV_STR_UTF8STR,
MONO_MARSHAL_CONV_SB_UTF8STR,
MONO_MARSHAL_CONV_UTF8STR_STR,
MONO_MARSHAL_CONV_UTF8STR_SB,
MONO_MARSHAL_CONV_FIXED_BUFFER,
MONO_MARSHAL_CONV_ANSIBSTR_STR,
MONO_MARSHAL_CONV_TBSTR_STR
} MonoMarshalConv;
#define MONO_MARSHAL_CONV_INVALID ((MonoMarshalConv)-1)
typedef struct {
MonoMarshalNative native;
union {
struct {
MonoMarshalNative elem_type;
int32_t num_elem; /* -1 if not set */
int16_t param_num; /* -1 if not set */
int16_t elem_mult; /* -1 if not set */
} array_data;
struct {
char *custom_name;
char *cookie;
MonoImage *image;
} custom_data;
struct {
MonoMarshalVariant elem_type;
int32_t num_elem;
} safearray_data;
} data;
} MonoMarshalSpec;
typedef struct {
uint32_t flags;
uint32_t try_offset;
uint32_t try_len;
uint32_t handler_offset;
uint32_t handler_len;
union {
uint32_t filter_offset;
MonoClass *catch_class;
} data;
} MonoExceptionClause;
typedef struct _MonoType MonoType;
typedef struct _MonoGenericInst MonoGenericInst;
typedef struct _MonoGenericClass MonoGenericClass;
typedef struct _MonoGenericContext MonoGenericContext;
typedef struct _MonoGenericContainer MonoGenericContainer;
typedef struct _MonoGenericParam MonoGenericParam;
typedef struct _MonoArrayType MonoArrayType;
typedef struct _MonoMethodSignature MonoMethodSignature;
/* FIXME: Keeping this name alive for now, since it is part of the exposed API, even though no entrypoint uses it. */
typedef struct invalid_name MonoGenericMethod;
typedef struct {
unsigned int required : 1;
unsigned int token : 31;
} MonoCustomMod;
typedef struct _MonoCustomModContainer {
uint8_t count; /* max 64 modifiers follow at the end */
MonoImage *image; /* Image containing types in modifiers array */
MonoCustomMod modifiers [1]; /* Actual length is count */
} MonoCustomModContainer;
struct _MonoArrayType {
MonoClass *eklass;
// Number of dimensions of the array
uint8_t rank;
// Arrays recording known upper and lower index bounds for each dimension
uint8_t numsizes;
uint8_t numlobounds;
int *sizes;
int *lobounds;
};
typedef struct _MonoMethodHeader MonoMethodHeader;
typedef enum {
MONO_PARSE_TYPE,
MONO_PARSE_MOD_TYPE,
MONO_PARSE_LOCAL,
MONO_PARSE_PARAM,
MONO_PARSE_RET,
MONO_PARSE_FIELD
} MonoParseTypeMode;
MONO_END_DECLS
#endif /* _MONO_METADATA_TYPES_H */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/utils/mono-threads-sunos.c | /**
* \file
*/
#include <config.h>
#if defined(__sun__)
#include <mono/utils/mono-threads.h>
#include <pthread.h>
#include <sys/syscall.h>
void
mono_threads_platform_get_stack_bounds (guint8 **staddr, size_t *stsize)
{
pthread_attr_t attr;
gint res;
*staddr = NULL;
*stsize = (size_t)-1;
res = pthread_attr_init (&attr);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_attr_init failed with \"%s\" (%d)", __func__, g_strerror (res), res);
res = pthread_attr_get_np (pthread_self (), &attr);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_getattr_np failed with \"%s\" (%d)", __func__, g_strerror (res), res);
res = pthread_attr_getstack (&attr, (void**)staddr, stsize);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_attr_getstack failed with \"%s\" (%d)", __func__, g_strerror (res), res);
res = pthread_attr_destroy (&attr);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_attr_destroy failed with \"%s\" (%d)", __func__, g_strerror (res), res);
}
guint64
mono_native_thread_os_id_get (void)
{
// TODO: investigate whether to use light weight process lwp ID of keep pthread_self()
// after the libraries and SDK ports are completed on illumos and/or Solaris platform.
return (guint64)pthread_self ();
}
#else
#include <mono/utils/mono-compiler.h>
MONO_EMPTY_SOURCE_FILE (mono_threads_sunos);
#endif
| /**
* \file
*/
#include <config.h>
#if defined(__sun__)
#include <mono/utils/mono-threads.h>
#include <pthread.h>
#include <sys/syscall.h>
void
mono_threads_platform_get_stack_bounds (guint8 **staddr, size_t *stsize)
{
pthread_attr_t attr;
gint res;
*staddr = NULL;
*stsize = (size_t)-1;
res = pthread_attr_init (&attr);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_attr_init failed with \"%s\" (%d)", __func__, g_strerror (res), res);
res = pthread_attr_get_np (pthread_self (), &attr);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_getattr_np failed with \"%s\" (%d)", __func__, g_strerror (res), res);
res = pthread_attr_getstack (&attr, (void**)staddr, stsize);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_attr_getstack failed with \"%s\" (%d)", __func__, g_strerror (res), res);
res = pthread_attr_destroy (&attr);
if (G_UNLIKELY (res != 0))
g_error ("%s: pthread_attr_destroy failed with \"%s\" (%d)", __func__, g_strerror (res), res);
}
guint64
mono_native_thread_os_id_get (void)
{
// TODO: investigate whether to use light weight process lwp ID of keep pthread_self()
// after the libraries and SDK ports are completed on illumos and/or Solaris platform.
return (guint64)pthread_self ();
}
#else
#include <mono/utils/mono-compiler.h>
MONO_EMPTY_SOURCE_FILE (mono_threads_sunos);
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/unit-tests/test-sgen-qsort.c | /*
* test-sgen-qsort.c: Unit test for quicksort.
*
* Copyright (C) 2013 Xamarin Inc
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "config.h"
#define HAVE_SGEN_GC
#include <mono/sgen/sgen-gc.h>
#include <mono/sgen/sgen-qsort.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <assert.h>
static int
compare_ints (const void *pa, const void *pb)
{
int a = *(const int*)pa;
int b = *(const int*)pb;
if (a < b)
return -1;
if (a == b)
return 0;
return 1;
}
typedef struct {
int key;
int val;
} teststruct_t;
static int
compare_teststructs (const void *pa, const void *pb)
{
int a = ((const teststruct_t*)pa)->key;
int b = ((const teststruct_t*)pb)->key;
if (a < b)
return -1;
if (a == b)
return 0;
return 1;
}
static int
compare_teststructs2 (const void *pa, const void *pb)
{
int a = (*((const teststruct_t**)pa))->key;
int b = (*((const teststruct_t**)pb))->key;
if (a < b)
return -1;
if (a == b)
return 0;
return 1;
}
DEF_QSORT_INLINE(test_struct, teststruct_t*, compare_teststructs)
static void
compare_sorts (void *base, size_t nel, size_t width, int (*compar) (const void*, const void*))
{
size_t len = nel * width;
void *b1 = malloc (len);
void *b2 = malloc (len);
memcpy (b1, base, len);
memcpy (b2, base, len);
mono_qsort (b1, nel, width, compar);
sgen_qsort (b2, nel, width, compar);
/* We can't assert that qsort and sgen_qsort produce the same results
* because qsort is not guaranteed to be stable, so they will tend to differ
* in adjacent equal elements. Instead, we assert that the array is sorted
* according to the comparator.
*/
for (size_t i = 0; i < nel - 1; ++i)
assert (compar ((char *)b2 + i * width, (char *)b2 + (i + 1) * width) <= 0);
free (b1);
free (b2);
}
static void
compare_sorts2 (void *base, size_t nel)
{
size_t width = sizeof (teststruct_t*);
size_t len = nel * width;
void *b1 = malloc (len);
void *b2 = malloc (len);
memcpy (b1, base, len);
memcpy (b2, base, len);
qsort (b1, nel, sizeof (teststruct_t*), compare_teststructs2);
qsort_test_struct ((teststruct_t **)b2, nel);
for (size_t i = 0; i < nel - 1; ++i)
assert (compare_teststructs2 ((char *)b2 + i * width, (char *)b2 + (i + 1) * width) <= 0);
free (b1);
free (b2);
}
#ifdef __cplusplus
extern "C"
#endif
int
test_sgen_qsort_main (void);
int
test_sgen_qsort_main (void)
{
int i;
for (i = 1; i < 4000; ++i) {
int a [i];
int j;
for (j = 0; j < i; ++j)
a [j] = i - j - 1;
compare_sorts (a, i, sizeof (int), compare_ints);
}
srandom (time (NULL));
for (i = 0; i < 2000; ++i) {
teststruct_t a [200];
int j;
for (j = 0; j < 200; ++j) {
a [j].key = random ();
a [j].val = random ();
}
compare_sorts (a, 200, sizeof (teststruct_t), compare_teststructs);
}
srandom (time (NULL));
for (i = 0; i < 2000; ++i) {
teststruct_t a [200];
teststruct_t *b [200];
int j;
for (j = 0; j < 200; ++j) {
a [j].key = random ();
a [j].val = random ();
b [j] = &a[j];
}
compare_sorts2 (b, 200);
}
return 0;
}
| /*
* test-sgen-qsort.c: Unit test for quicksort.
*
* Copyright (C) 2013 Xamarin Inc
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "config.h"
#define HAVE_SGEN_GC
#include <mono/sgen/sgen-gc.h>
#include <mono/sgen/sgen-qsort.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <assert.h>
static int
compare_ints (const void *pa, const void *pb)
{
int a = *(const int*)pa;
int b = *(const int*)pb;
if (a < b)
return -1;
if (a == b)
return 0;
return 1;
}
typedef struct {
int key;
int val;
} teststruct_t;
static int
compare_teststructs (const void *pa, const void *pb)
{
int a = ((const teststruct_t*)pa)->key;
int b = ((const teststruct_t*)pb)->key;
if (a < b)
return -1;
if (a == b)
return 0;
return 1;
}
static int
compare_teststructs2 (const void *pa, const void *pb)
{
int a = (*((const teststruct_t**)pa))->key;
int b = (*((const teststruct_t**)pb))->key;
if (a < b)
return -1;
if (a == b)
return 0;
return 1;
}
DEF_QSORT_INLINE(test_struct, teststruct_t*, compare_teststructs)
static void
compare_sorts (void *base, size_t nel, size_t width, int (*compar) (const void*, const void*))
{
size_t len = nel * width;
void *b1 = malloc (len);
void *b2 = malloc (len);
memcpy (b1, base, len);
memcpy (b2, base, len);
mono_qsort (b1, nel, width, compar);
sgen_qsort (b2, nel, width, compar);
/* We can't assert that qsort and sgen_qsort produce the same results
* because qsort is not guaranteed to be stable, so they will tend to differ
* in adjacent equal elements. Instead, we assert that the array is sorted
* according to the comparator.
*/
for (size_t i = 0; i < nel - 1; ++i)
assert (compar ((char *)b2 + i * width, (char *)b2 + (i + 1) * width) <= 0);
free (b1);
free (b2);
}
static void
compare_sorts2 (void *base, size_t nel)
{
size_t width = sizeof (teststruct_t*);
size_t len = nel * width;
void *b1 = malloc (len);
void *b2 = malloc (len);
memcpy (b1, base, len);
memcpy (b2, base, len);
qsort (b1, nel, sizeof (teststruct_t*), compare_teststructs2);
qsort_test_struct ((teststruct_t **)b2, nel);
for (size_t i = 0; i < nel - 1; ++i)
assert (compare_teststructs2 ((char *)b2 + i * width, (char *)b2 + (i + 1) * width) <= 0);
free (b1);
free (b2);
}
#ifdef __cplusplus
extern "C"
#endif
int
test_sgen_qsort_main (void);
int
test_sgen_qsort_main (void)
{
int i;
for (i = 1; i < 4000; ++i) {
int a [i];
int j;
for (j = 0; j < i; ++j)
a [j] = i - j - 1;
compare_sorts (a, i, sizeof (int), compare_ints);
}
srandom (time (NULL));
for (i = 0; i < 2000; ++i) {
teststruct_t a [200];
int j;
for (j = 0; j < 200; ++j) {
a [j].key = random ();
a [j].val = random ();
}
compare_sorts (a, 200, sizeof (teststruct_t), compare_teststructs);
}
srandom (time (NULL));
for (i = 0; i < 2000; ++i) {
teststruct_t a [200];
teststruct_t *b [200];
int j;
for (j = 0; j < 200; ++j) {
a [j].key = random ();
a [j].val = random ();
b [j] = &a[j];
}
compare_sorts2 (b, 200);
}
return 0;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/dlls/mscorpe/stdafx.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//*****************************************************************************
// stdafx.h
//
// Common include file for utility code.
//*****************************************************************************
#include <stdlib.h> // for qsort
#include <windows.h>
#include <time.h>
#include <assert.h>
#include <stdio.h>
#include <stddef.h>
#define FEATURE_NO_HOST // Do not use host interface
#include <utilcode.h>
#include <corpriv.h>
#include "pewriter.h"
#include "ceegen.h"
#include "ceefilegenwriter.h"
#include "ceesectionstring.h"
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//*****************************************************************************
// stdafx.h
//
// Common include file for utility code.
//*****************************************************************************
#include <stdlib.h> // for qsort
#include <windows.h>
#include <time.h>
#include <assert.h>
#include <stdio.h>
#include <stddef.h>
#define FEATURE_NO_HOST // Do not use host interface
#include <utilcode.h>
#include <corpriv.h>
#include "pewriter.h"
#include "ceegen.h"
#include "ceefilegenwriter.h"
#include "ceesectionstring.h"
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/corehost/host_startup_info.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef __HOST_STARTUP_INFO_H_
#define __HOST_STARTUP_INFO_H_
#include "pal.h"
#include "host_interface.h"
struct host_startup_info_t
{
host_startup_info_t() {}
host_startup_info_t(
const pal::char_t* host_path_value,
const pal::char_t* dotnet_root_value,
const pal::char_t* app_path_value);
void parse(
int argc,
const pal::char_t* argv[]);
bool is_valid(host_mode_t mode) const;
const pal::string_t get_app_name() const;
static int get_host_path(int argc, const pal::char_t* argv[], pal::string_t* host_path);
pal::string_t host_path; // The path to the current hosting binary.
pal::string_t dotnet_root; // The path to the framework.
pal::string_t app_path; // For apphost, the path to the app dll; for muxer, not applicable as this information is not yet parsed.
};
#endif // __HOST_STARTUP_INFO_H_
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef __HOST_STARTUP_INFO_H_
#define __HOST_STARTUP_INFO_H_
#include "pal.h"
#include "host_interface.h"
struct host_startup_info_t
{
host_startup_info_t() {}
host_startup_info_t(
const pal::char_t* host_path_value,
const pal::char_t* dotnet_root_value,
const pal::char_t* app_path_value);
void parse(
int argc,
const pal::char_t* argv[]);
bool is_valid(host_mode_t mode) const;
const pal::string_t get_app_name() const;
static int get_host_path(int argc, const pal::char_t* argv[], pal::string_t* host_path);
pal::string_t host_path; // The path to the current hosting binary.
pal::string_t dotnet_root; // The path to the framework.
pal::string_t app_path; // For apphost, the path to the app dll; for muxer, not applicable as this information is not yet parsed.
};
#endif // __HOST_STARTUP_INFO_H_
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/coredump/_UPT_access_fpreg.c | /* libunwind - a platform-independent unwind library
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "_UCD_lib.h"
#include "_UCD_internal.h"
int
_UCD_access_fpreg (unw_addr_space_t as, unw_regnum_t reg, unw_fpreg_t *val,
int write, void *arg)
{
print_error (__func__);
print_error (" not implemented\n");
return -UNW_EINVAL;
}
| /* libunwind - a platform-independent unwind library
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "_UCD_lib.h"
#include "_UCD_internal.h"
int
_UCD_access_fpreg (unw_addr_space_t as, unw_regnum_t reg, unw_fpreg_t *val,
int write, void *arg)
{
print_error (__func__);
print_error (" not implemented\n");
return -UNW_EINVAL;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/mips/Greg_states_iterate.c | /* libunwind - a platform-independent unwind library
Copyright (c) 2002-2003 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
Modified for x86_64 by Max Asbock <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
int
unw_reg_states_iterate (unw_cursor_t *cursor,
unw_reg_states_callback cb, void *token)
{
struct cursor *c = (struct cursor *) cursor;
return dwarf_reg_states_iterate (&c->dwarf, cb, token);
}
| /* libunwind - a platform-independent unwind library
Copyright (c) 2002-2003 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
Modified for x86_64 by Max Asbock <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
int
unw_reg_states_iterate (unw_cursor_t *cursor,
unw_reg_states_callback cb, void *token)
{
struct cursor *c = (struct cursor *) cursor;
return dwarf_reg_states_iterate (&c->dwarf, cb, token);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/arm/regname.c | #include "unwind_i.h"
static const char *regname[] =
{
/* 0. */
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
/* 8. */
"r8", "r9", "r10", "fp", "ip", "sp", "lr", "pc",
/* 16. Obsolete FPA names. */
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
/* 24. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 32. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 40. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 48. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 56. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 64. */
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
/* 72. */
"s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
/* 80. */
"s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
/* 88. */
"s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
/* 96. */
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
/* 104. */
"wCGR0", "wCGR1", "wCGR2", "wCGR3", "wCGR4", "wCGR5", "wCGR6", "wCGR7",
/* 112. */
"wR0", "wR1", "wR2", "wR3", "wR4", "wR5", "wR6", "wR7",
/* 128. */
"spsr", "spsr_fiq", "spsr_irq", "spsr_abt", "spsr_und", "spsr_svc", 0, 0,
/* 136. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 144. */
"r8_usr", "r9_usr", "r10_usr", "r11_usr", "r12_usr", "r13_usr", "r14_usr",
/* 151. */
"r8_fiq", "r9_fiq", "r10_fiq", "r11_fiq", "r12_fiq", "r13_fiq", "r14_fiq",
/* 158. */
"r13_irq", "r14_irq",
/* 160. */
"r13_abt", "r14_abt",
/* 162. */
"r13_und", "r14_und",
/* 164. */
"r13_svc", "r14_svc", 0, 0,
/* 168. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 176. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 184. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 192. */
"wC0", "wC1", "wC2", "wC3", "wC4", "wC5", "wC6", "wC7",
/* 200. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 208. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 216. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 224. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 232. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 240. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 248. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 256. */
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
/* 264. */
"d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
/* 272. */
"d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
/* 280. */
"d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
};
const char *
unw_regname (unw_regnum_t reg)
{
if (reg < (unw_regnum_t) ARRAY_SIZE (regname))
return regname[reg];
else
return "???";
}
| #include "unwind_i.h"
static const char *regname[] =
{
/* 0. */
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
/* 8. */
"r8", "r9", "r10", "fp", "ip", "sp", "lr", "pc",
/* 16. Obsolete FPA names. */
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
/* 24. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 32. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 40. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 48. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 56. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 64. */
"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
/* 72. */
"s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
/* 80. */
"s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
/* 88. */
"s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
/* 96. */
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
/* 104. */
"wCGR0", "wCGR1", "wCGR2", "wCGR3", "wCGR4", "wCGR5", "wCGR6", "wCGR7",
/* 112. */
"wR0", "wR1", "wR2", "wR3", "wR4", "wR5", "wR6", "wR7",
/* 128. */
"spsr", "spsr_fiq", "spsr_irq", "spsr_abt", "spsr_und", "spsr_svc", 0, 0,
/* 136. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 144. */
"r8_usr", "r9_usr", "r10_usr", "r11_usr", "r12_usr", "r13_usr", "r14_usr",
/* 151. */
"r8_fiq", "r9_fiq", "r10_fiq", "r11_fiq", "r12_fiq", "r13_fiq", "r14_fiq",
/* 158. */
"r13_irq", "r14_irq",
/* 160. */
"r13_abt", "r14_abt",
/* 162. */
"r13_und", "r14_und",
/* 164. */
"r13_svc", "r14_svc", 0, 0,
/* 168. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 176. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 184. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 192. */
"wC0", "wC1", "wC2", "wC3", "wC4", "wC5", "wC6", "wC7",
/* 200. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 208. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 216. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 224. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 232. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 240. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 248. */
0, 0, 0, 0, 0, 0, 0, 0,
/* 256. */
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
/* 264. */
"d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
/* 272. */
"d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
/* 280. */
"d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
};
const char *
unw_regname (unw_regnum_t reg)
{
if (reg < (unw_regnum_t) ARRAY_SIZE (regname))
return regname[reg];
else
return "???";
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/arm/Lglobal.c | #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gglobal.c"
#endif
| #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gglobal.c"
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/corehost/bundle/file_type.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef __FILE_TYPE_H__
#define __FILE_TYPE_H__
#include <cstdint>
namespace bundle
{
// FileType: Identifies the type of file embedded into the bundle.
//
// The bundler differentiates a few kinds of files via the manifest,
// with respect to the way in which they'll be used by the runtime.
//
// Currently all files are extracted out to the disk, but future
// implementations will process certain file_types directly from the bundle.
enum file_type_t : uint8_t
{
unknown,
assembly,
native_binary,
deps_json,
runtime_config_json,
symbols,
__last
};
}
#endif // __FILE_TYPE_H__
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef __FILE_TYPE_H__
#define __FILE_TYPE_H__
#include <cstdint>
namespace bundle
{
// FileType: Identifies the type of file embedded into the bundle.
//
// The bundler differentiates a few kinds of files via the manifest,
// with respect to the way in which they'll be used by the runtime.
//
// Currently all files are extracted out to the disk, but future
// implementations will process certain file_types directly from the bundle.
enum file_type_t : uint8_t
{
unknown,
assembly,
native_binary,
deps_json,
runtime_config_json,
symbols,
__last
};
}
#endif // __FILE_TYPE_H__
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/include/win/freebsd-elf32.h | /*-
* Copyright (c) 1996-1998 John D. Polstra.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/sys/elf32.h,v 1.8.14.2.2.1 2008/10/02 02:57:24 kensmith Exp $
*/
#ifndef _SYS_ELF32_H_
#define _SYS_ELF32_H_ 1
#include "freebsd-elf_common.h"
/*
* ELF definitions common to all 32-bit architectures.
*/
typedef uint32_t Elf32_Addr;
typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Off;
typedef int32_t Elf32_Sword;
typedef uint32_t Elf32_Word;
typedef uint64_t Elf32_Lword;
typedef Elf32_Word Elf32_Hashelt;
/* Non-standard class-dependent datatype used for abstraction. */
typedef Elf32_Word Elf32_Size;
typedef Elf32_Sword Elf32_Ssize;
/*
* ELF header.
*/
typedef struct {
unsigned char e_ident[EI_NIDENT]; /* File identification. */
Elf32_Half e_type; /* File type. */
Elf32_Half e_machine; /* Machine architecture. */
Elf32_Word e_version; /* ELF format version. */
Elf32_Addr e_entry; /* Entry point. */
Elf32_Off e_phoff; /* Program header file offset. */
Elf32_Off e_shoff; /* Section header file offset. */
Elf32_Word e_flags; /* Architecture-specific flags. */
Elf32_Half e_ehsize; /* Size of ELF header in bytes. */
Elf32_Half e_phentsize; /* Size of program header entry. */
Elf32_Half e_phnum; /* Number of program header entries. */
Elf32_Half e_shentsize; /* Size of section header entry. */
Elf32_Half e_shnum; /* Number of section header entries. */
Elf32_Half e_shstrndx; /* Section name strings section. */
} Elf32_Ehdr;
/*
* Section header.
*/
typedef struct {
Elf32_Word sh_name; /* Section name (index into the
section header string table). */
Elf32_Word sh_type; /* Section type. */
Elf32_Word sh_flags; /* Section flags. */
Elf32_Addr sh_addr; /* Address in memory image. */
Elf32_Off sh_offset; /* Offset in file. */
Elf32_Word sh_size; /* Size in bytes. */
Elf32_Word sh_link; /* Index of a related section. */
Elf32_Word sh_info; /* Depends on section type. */
Elf32_Word sh_addralign; /* Alignment in bytes. */
Elf32_Word sh_entsize; /* Size of each entry in section. */
} Elf32_Shdr;
/*
* Program header.
*/
typedef struct {
Elf32_Word p_type; /* Entry type. */
Elf32_Off p_offset; /* File offset of contents. */
Elf32_Addr p_vaddr; /* Virtual address in memory image. */
Elf32_Addr p_paddr; /* Physical address (not used). */
Elf32_Word p_filesz; /* Size of contents in file. */
Elf32_Word p_memsz; /* Size of contents in memory. */
Elf32_Word p_flags; /* Access permission flags. */
Elf32_Word p_align; /* Alignment in memory and file. */
} Elf32_Phdr;
/*
* Dynamic structure. The ".dynamic" section contains an array of them.
*/
typedef struct {
Elf32_Sword d_tag; /* Entry type. */
union {
Elf32_Word d_val; /* Integer value. */
Elf32_Addr d_ptr; /* Address value. */
} d_un;
} Elf32_Dyn;
/*
* Relocation entries.
*/
/* Relocations that don't need an addend field. */
typedef struct {
Elf32_Addr r_offset; /* Location to be relocated. */
Elf32_Word r_info; /* Relocation type and symbol index. */
} Elf32_Rel;
/* Relocations that need an addend field. */
typedef struct {
Elf32_Addr r_offset; /* Location to be relocated. */
Elf32_Word r_info; /* Relocation type and symbol index. */
Elf32_Sword r_addend; /* Addend. */
} Elf32_Rela;
/* Macros for accessing the fields of r_info. */
#define ELF32_R_SYM(info) ((info) >> 8)
#define ELF32_R_TYPE(info) ((unsigned char)(info))
/* Macro for constructing r_info from field values. */
#define ELF32_R_INFO(sym, type) (((sym) << 8) + (unsigned char)(type))
/*
* Note entry header
*/
typedef Elf_Note Elf32_Nhdr;
/*
* Move entry
*/
typedef struct {
Elf32_Lword m_value; /* symbol value */
Elf32_Word m_info; /* size + index */
Elf32_Word m_poffset; /* symbol offset */
Elf32_Half m_repeat; /* repeat count */
Elf32_Half m_stride; /* stride info */
} Elf32_Move;
/*
* The macros compose and decompose values for Move.r_info
*
* sym = ELF32_M_SYM(M.m_info)
* size = ELF32_M_SIZE(M.m_info)
* M.m_info = ELF32_M_INFO(sym, size)
*/
#define ELF32_M_SYM(info) ((info)>>8)
#define ELF32_M_SIZE(info) ((unsigned char)(info))
#define ELF32_M_INFO(sym, size) (((sym)<<8)+(unsigned char)(size))
/*
* Hardware/Software capabilities entry
*/
typedef struct {
Elf32_Word c_tag; /* how to interpret value */
union {
Elf32_Word c_val;
Elf32_Addr c_ptr;
} c_un;
} Elf32_Cap;
/*
* Symbol table entries.
*/
typedef struct {
Elf32_Word st_name; /* String table index of name. */
Elf32_Addr st_value; /* Symbol value. */
Elf32_Word st_size; /* Size of associated object. */
unsigned char st_info; /* Type and binding information. */
unsigned char st_other; /* Reserved (not used). */
Elf32_Half st_shndx; /* Section index of symbol. */
} Elf32_Sym;
/* Macros for accessing the fields of st_info. */
#define ELF32_ST_BIND(info) ((info) >> 4)
#define ELF32_ST_TYPE(info) ((info) & 0xf)
/* Macro for constructing st_info from field values. */
#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
/* Macro for accessing the fields of st_other. */
#define ELF32_ST_VISIBILITY(oth) ((oth) & 0x3)
/* Structures used by Sun & GNU symbol versioning. */
typedef struct
{
Elf32_Half vd_version;
Elf32_Half vd_flags;
Elf32_Half vd_ndx;
Elf32_Half vd_cnt;
Elf32_Word vd_hash;
Elf32_Word vd_aux;
Elf32_Word vd_next;
} Elf32_Verdef;
typedef struct
{
Elf32_Word vda_name;
Elf32_Word vda_next;
} Elf32_Verdaux;
typedef struct
{
Elf32_Half vn_version;
Elf32_Half vn_cnt;
Elf32_Word vn_file;
Elf32_Word vn_aux;
Elf32_Word vn_next;
} Elf32_Verneed;
typedef struct
{
Elf32_Word vna_hash;
Elf32_Half vna_flags;
Elf32_Half vna_other;
Elf32_Word vna_name;
Elf32_Word vna_next;
} Elf32_Vernaux;
typedef Elf32_Half Elf32_Versym;
typedef struct {
Elf32_Half si_boundto; /* direct bindings - symbol bound to */
Elf32_Half si_flags; /* per symbol flags */
} Elf32_Syminfo;
#endif /* !_SYS_ELF32_H_ */
| /*-
* Copyright (c) 1996-1998 John D. Polstra.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD: src/sys/sys/elf32.h,v 1.8.14.2.2.1 2008/10/02 02:57:24 kensmith Exp $
*/
#ifndef _SYS_ELF32_H_
#define _SYS_ELF32_H_ 1
#include "freebsd-elf_common.h"
/*
* ELF definitions common to all 32-bit architectures.
*/
typedef uint32_t Elf32_Addr;
typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Off;
typedef int32_t Elf32_Sword;
typedef uint32_t Elf32_Word;
typedef uint64_t Elf32_Lword;
typedef Elf32_Word Elf32_Hashelt;
/* Non-standard class-dependent datatype used for abstraction. */
typedef Elf32_Word Elf32_Size;
typedef Elf32_Sword Elf32_Ssize;
/*
* ELF header.
*/
typedef struct {
unsigned char e_ident[EI_NIDENT]; /* File identification. */
Elf32_Half e_type; /* File type. */
Elf32_Half e_machine; /* Machine architecture. */
Elf32_Word e_version; /* ELF format version. */
Elf32_Addr e_entry; /* Entry point. */
Elf32_Off e_phoff; /* Program header file offset. */
Elf32_Off e_shoff; /* Section header file offset. */
Elf32_Word e_flags; /* Architecture-specific flags. */
Elf32_Half e_ehsize; /* Size of ELF header in bytes. */
Elf32_Half e_phentsize; /* Size of program header entry. */
Elf32_Half e_phnum; /* Number of program header entries. */
Elf32_Half e_shentsize; /* Size of section header entry. */
Elf32_Half e_shnum; /* Number of section header entries. */
Elf32_Half e_shstrndx; /* Section name strings section. */
} Elf32_Ehdr;
/*
* Section header.
*/
typedef struct {
Elf32_Word sh_name; /* Section name (index into the
section header string table). */
Elf32_Word sh_type; /* Section type. */
Elf32_Word sh_flags; /* Section flags. */
Elf32_Addr sh_addr; /* Address in memory image. */
Elf32_Off sh_offset; /* Offset in file. */
Elf32_Word sh_size; /* Size in bytes. */
Elf32_Word sh_link; /* Index of a related section. */
Elf32_Word sh_info; /* Depends on section type. */
Elf32_Word sh_addralign; /* Alignment in bytes. */
Elf32_Word sh_entsize; /* Size of each entry in section. */
} Elf32_Shdr;
/*
* Program header.
*/
typedef struct {
Elf32_Word p_type; /* Entry type. */
Elf32_Off p_offset; /* File offset of contents. */
Elf32_Addr p_vaddr; /* Virtual address in memory image. */
Elf32_Addr p_paddr; /* Physical address (not used). */
Elf32_Word p_filesz; /* Size of contents in file. */
Elf32_Word p_memsz; /* Size of contents in memory. */
Elf32_Word p_flags; /* Access permission flags. */
Elf32_Word p_align; /* Alignment in memory and file. */
} Elf32_Phdr;
/*
* Dynamic structure. The ".dynamic" section contains an array of them.
*/
typedef struct {
Elf32_Sword d_tag; /* Entry type. */
union {
Elf32_Word d_val; /* Integer value. */
Elf32_Addr d_ptr; /* Address value. */
} d_un;
} Elf32_Dyn;
/*
* Relocation entries.
*/
/* Relocations that don't need an addend field. */
typedef struct {
Elf32_Addr r_offset; /* Location to be relocated. */
Elf32_Word r_info; /* Relocation type and symbol index. */
} Elf32_Rel;
/* Relocations that need an addend field. */
typedef struct {
Elf32_Addr r_offset; /* Location to be relocated. */
Elf32_Word r_info; /* Relocation type and symbol index. */
Elf32_Sword r_addend; /* Addend. */
} Elf32_Rela;
/* Macros for accessing the fields of r_info. */
#define ELF32_R_SYM(info) ((info) >> 8)
#define ELF32_R_TYPE(info) ((unsigned char)(info))
/* Macro for constructing r_info from field values. */
#define ELF32_R_INFO(sym, type) (((sym) << 8) + (unsigned char)(type))
/*
* Note entry header
*/
typedef Elf_Note Elf32_Nhdr;
/*
* Move entry
*/
typedef struct {
Elf32_Lword m_value; /* symbol value */
Elf32_Word m_info; /* size + index */
Elf32_Word m_poffset; /* symbol offset */
Elf32_Half m_repeat; /* repeat count */
Elf32_Half m_stride; /* stride info */
} Elf32_Move;
/*
* The macros compose and decompose values for Move.r_info
*
* sym = ELF32_M_SYM(M.m_info)
* size = ELF32_M_SIZE(M.m_info)
* M.m_info = ELF32_M_INFO(sym, size)
*/
#define ELF32_M_SYM(info) ((info)>>8)
#define ELF32_M_SIZE(info) ((unsigned char)(info))
#define ELF32_M_INFO(sym, size) (((sym)<<8)+(unsigned char)(size))
/*
* Hardware/Software capabilities entry
*/
typedef struct {
Elf32_Word c_tag; /* how to interpret value */
union {
Elf32_Word c_val;
Elf32_Addr c_ptr;
} c_un;
} Elf32_Cap;
/*
* Symbol table entries.
*/
typedef struct {
Elf32_Word st_name; /* String table index of name. */
Elf32_Addr st_value; /* Symbol value. */
Elf32_Word st_size; /* Size of associated object. */
unsigned char st_info; /* Type and binding information. */
unsigned char st_other; /* Reserved (not used). */
Elf32_Half st_shndx; /* Section index of symbol. */
} Elf32_Sym;
/* Macros for accessing the fields of st_info. */
#define ELF32_ST_BIND(info) ((info) >> 4)
#define ELF32_ST_TYPE(info) ((info) & 0xf)
/* Macro for constructing st_info from field values. */
#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))
/* Macro for accessing the fields of st_other. */
#define ELF32_ST_VISIBILITY(oth) ((oth) & 0x3)
/* Structures used by Sun & GNU symbol versioning. */
typedef struct
{
Elf32_Half vd_version;
Elf32_Half vd_flags;
Elf32_Half vd_ndx;
Elf32_Half vd_cnt;
Elf32_Word vd_hash;
Elf32_Word vd_aux;
Elf32_Word vd_next;
} Elf32_Verdef;
typedef struct
{
Elf32_Word vda_name;
Elf32_Word vda_next;
} Elf32_Verdaux;
typedef struct
{
Elf32_Half vn_version;
Elf32_Half vn_cnt;
Elf32_Word vn_file;
Elf32_Word vn_aux;
Elf32_Word vn_next;
} Elf32_Verneed;
typedef struct
{
Elf32_Word vna_hash;
Elf32_Half vna_flags;
Elf32_Half vna_other;
Elf32_Word vna_name;
Elf32_Word vna_next;
} Elf32_Vernaux;
typedef Elf32_Half Elf32_Versym;
typedef struct {
Elf32_Half si_boundto; /* direct bindings - symbol bound to */
Elf32_Half si_flags; /* per symbol flags */
} Elf32_Syminfo;
#endif /* !_SYS_ELF32_H_ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/arm64/excepcpu.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
//
#ifndef __excepcpu_h__
#define __excepcpu_h__
#define THROW_CONTROL_FOR_THREAD_FUNCTION RedirectForThreadAbort
EXTERN_C void RedirectForThreadAbort();
#define STATUS_CLR_GCCOVER_CODE STATUS_ILLEGAL_INSTRUCTION
class Thread;
class FaultingExceptionFrame;
#define INSTALL_EXCEPTION_HANDLING_RECORD(record)
#define UNINSTALL_EXCEPTION_HANDLING_RECORD(record)
//
// On ARM, the COMPlusFrameHandler's work is done by our personality routine.
//
#define DECLARE_CPFH_EH_RECORD(pCurThread)
//
// Retrieves the redirected CONTEXT* from the stack frame of one of the
// RedirectedHandledJITCaseForXXX_Stub's.
//
PTR_CONTEXT GetCONTEXTFromRedirectedStubStackFrame(T_DISPATCHER_CONTEXT * pDispatcherContext);
PTR_CONTEXT GetCONTEXTFromRedirectedStubStackFrame(T_CONTEXT * pContext);
//
// Retrieves the FaultingExceptionFrame* from the stack frame of
// RedirectForThrowControl or NakedThrowHelper.
//
FaultingExceptionFrame *GetFrameFromRedirectedStubStackFrame (T_DISPATCHER_CONTEXT *pDispatcherContext);
inline
PCODE GetAdjustedCallAddress(PCODE returnAddress)
{
LIMITED_METHOD_CONTRACT;
return returnAddress - 4;
}
BOOL AdjustContextForVirtualStub(EXCEPTION_RECORD *pExceptionRecord, T_CONTEXT *pContext);
#endif // __excepcpu_h__
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
//
#ifndef __excepcpu_h__
#define __excepcpu_h__
#define THROW_CONTROL_FOR_THREAD_FUNCTION RedirectForThreadAbort
EXTERN_C void RedirectForThreadAbort();
#define STATUS_CLR_GCCOVER_CODE STATUS_ILLEGAL_INSTRUCTION
class Thread;
class FaultingExceptionFrame;
#define INSTALL_EXCEPTION_HANDLING_RECORD(record)
#define UNINSTALL_EXCEPTION_HANDLING_RECORD(record)
//
// On ARM, the COMPlusFrameHandler's work is done by our personality routine.
//
#define DECLARE_CPFH_EH_RECORD(pCurThread)
//
// Retrieves the redirected CONTEXT* from the stack frame of one of the
// RedirectedHandledJITCaseForXXX_Stub's.
//
PTR_CONTEXT GetCONTEXTFromRedirectedStubStackFrame(T_DISPATCHER_CONTEXT * pDispatcherContext);
PTR_CONTEXT GetCONTEXTFromRedirectedStubStackFrame(T_CONTEXT * pContext);
//
// Retrieves the FaultingExceptionFrame* from the stack frame of
// RedirectForThrowControl or NakedThrowHelper.
//
FaultingExceptionFrame *GetFrameFromRedirectedStubStackFrame (T_DISPATCHER_CONTEXT *pDispatcherContext);
inline
PCODE GetAdjustedCallAddress(PCODE returnAddress)
{
LIMITED_METHOD_CONTRACT;
return returnAddress - 4;
}
BOOL AdjustContextForVirtualStub(EXCEPTION_RECORD *pExceptionRecord, T_CONTEXT *pContext);
#endif // __excepcpu_h__
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/mini/tramp-sparc.c | /**
* \file
* JIT trampoline code for Sparc
*
* Authors:
* Mark Crichton ([email protected])
* Dietmar Maurer ([email protected])
*
* (C) 2003 Ximian, Inc.
*/
#include <config.h>
#include <glib.h>
#include <mono/arch/sparc/sparc-codegen.h>
#include <mono/metadata/marshal.h>
#include <mono/metadata/tabledefs.h>
#include "mini.h"
#include "mini-sparc.h"
#include "jit-icalls.h"
#include "mono/utils/mono-tls-inline.h"
/*
* mono_arch_get_unbox_trampoline:
* @m: method pointer
* @addr: pointer to native code for @m
*
* when value type methods are called through the vtable we need to unbox the
* this argument. This method returns a pointer to a trampoline which does
* unboxing before calling the method
*/
gpointer
mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
{
MonoMemoryManager *mem_manager = m_method_get_mem_manager (m);
guint8 *code, *start;
int reg;
start = code = mono_mem_manager_code_reserve (mem_manager, 36);
/* This executes in the context of the caller, hence o0 */
sparc_add_imm (code, 0, sparc_o0, MONO_ABI_SIZEOF (MonoObject), sparc_o0);
#ifdef SPARCV9
reg = sparc_g4;
#else
reg = sparc_g1;
#endif
sparc_set (code, addr, reg);
sparc_jmpl (code, reg, sparc_g0, sparc_g0);
sparc_nop (code);
g_assert ((code - start) <= 36);
mono_arch_flush_icache (start, code - start);
MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m));
mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, NULL), NULL);
return start;
}
void
mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr)
{
if (sparc_inst_op (*(guint32*)code) == 0x1) {
sparc_call_simple (code, (guint8*)addr - (guint8*)code);
}
}
void
mono_arch_patch_plt_entry (guint8 *code, gpointer *got, host_mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
guchar*
mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *code, *tramp_addr;
guint32 lmf_offset, regs_offset, method_reg, i;
gboolean has_caller;
g_assert (!aot);
*info = NULL;
if (tramp_type == MONO_TRAMPOLINE_JUMP)
has_caller = FALSE;
else
has_caller = TRUE;
code = buf = mono_global_codeman_reserve (1024);
sparc_save_imm (code, sparc_sp, -1608, sparc_sp);
#ifdef SPARCV9
method_reg = sparc_g4;
#else
method_reg = sparc_g1;
#endif
regs_offset = MONO_SPARC_STACK_BIAS + 1000;
/* Save r1 needed by the IMT code */
sparc_sti_imm (code, sparc_g1, sparc_sp, regs_offset + (sparc_g1 * sizeof (target_mgreg_t)));
/*
* sparc_g5 contains the return address, the trampoline argument is stored in the
* instruction stream after the call.
*/
sparc_ld_imm (code, sparc_g5, 8, method_reg);
#ifdef SPARCV9
/* Save fp regs since they are not preserved by calls */
for (i = 0; i < 16; i ++)
sparc_stdf_imm (code, sparc_f0 + (i * 2), sparc_sp, MONO_SPARC_STACK_BIAS + 320 + (i * 8));
#endif
/* We receive the method address in %r1, so save it here */
sparc_sti_imm (code, method_reg, sparc_sp, MONO_SPARC_STACK_BIAS + 200);
/* Save lmf since compilation can raise exceptions */
lmf_offset = MONO_SPARC_STACK_BIAS - sizeof (MonoLMF);
/* Save the data for the parent (managed) frame */
/* Save ip */
sparc_sti_imm (code, sparc_i7, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, ip));
/* Save sp */
sparc_sti_imm (code, sparc_fp, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, sp));
/* Save fp */
/* Load previous fp from the saved register window */
sparc_flushw (code);
sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS + (sparc_i6 - 16) * sizeof (target_mgreg_t), sparc_o7);
sparc_sti_imm (code, sparc_o7, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, ebp));
/* Save method */
sparc_sti_imm (code, method_reg, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, method));
sparc_set (code, mono_get_lmf_addr, sparc_o7);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
code = mono_sparc_emit_save_lmf (code, lmf_offset);
if (has_caller) {
/* Load all registers of the caller into a table inside this frame */
/* first the out registers */
for (i = 0; i < 8; ++i)
sparc_sti_imm (code, sparc_i0 + i, sparc_sp, regs_offset + ((sparc_o0 + i) * sizeof (target_mgreg_t)));
/* then the in+local registers */
for (i = 0; i < 16; i ++) {
sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS + (i * sizeof (target_mgreg_t)), sparc_o7);
sparc_sti_imm (code, sparc_o7, sparc_sp, regs_offset + ((sparc_l0 + i) * sizeof (target_mgreg_t)));
}
}
tramp_addr = mono_get_trampoline_func (tramp_type);
sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 200, sparc_o2);
/* pass address of register table as third argument */
sparc_add_imm (code, FALSE, sparc_sp, regs_offset, sparc_o0);
sparc_set (code, tramp_addr, sparc_o7);
/* set %o1 to caller address */
if (has_caller)
sparc_mov_reg_reg (code, sparc_i7, sparc_o1);
else
sparc_set (code, 0, sparc_o1);
sparc_set (code, 0, sparc_o3);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
/* Save result */
sparc_sti_imm (code, sparc_o0, sparc_sp, MONO_SPARC_STACK_BIAS + 304);
/* Check for thread interruption */
sparc_set (code, (guint8*)mono_interruption_checkpoint_from_trampoline_deprecated, sparc_o7);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
/* Restore lmf */
code = mono_sparc_emit_restore_lmf (code, lmf_offset);
/* Reload result */
sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 304, sparc_o0);
#ifdef SPARCV9
/* Reload fp regs */
for (i = 0; i < 16; i ++)
sparc_lddf_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 320 + (i * 8), sparc_f0 + (i * 2));
#endif
sparc_jmpl (code, sparc_o0, sparc_g0, sparc_g0);
/* restore previous frame in delay slot */
sparc_restore_simple (code);
/*
{
gpointer addr;
sparc_save_imm (code, sparc_sp, -608, sparc_sp);
addr = code;
sparc_call_simple (code, 16);
sparc_nop (code);
sparc_rett_simple (code);
sparc_nop (code);
sparc_save_imm (code, sparc_sp, -608, sparc_sp);
sparc_ta (code, 1);
tramp_addr = &sparc_magic_trampoline;
sparc_call_simple (code, tramp_addr - code);
sparc_nop (code);
sparc_rett_simple (code);
sparc_nop (code);
}
*/
g_assert ((code - buf) <= 512);
mono_arch_flush_icache (buf, code - buf);
MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL));
return buf;
}
#define TRAMPOLINE_SIZE (SPARC_SET_MAX_SIZE + 3)
gpointer
mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len)
{
guint32 *code, *buf, *tramp;
tramp = mono_get_trampoline_code (tramp_type);
code = buf = mono_mem_manager_code_reserve (mem_manager, TRAMPOLINE_SIZE * 4);
/* We have to use g5 here because there is no other free register */
sparc_set (code, tramp, sparc_g5);
sparc_jmpl (code, sparc_g5, sparc_g0, sparc_g5);
sparc_nop (code);
#ifdef SPARCV9
g_assert_not_reached ();
#else
*code = (guint32)arg1;
code ++;
#endif
g_assert ((code - buf) <= TRAMPOLINE_SIZE);
if (code_len)
*code_len = (code - buf);
mono_arch_flush_icache ((guint8*)buf, (code - buf));
MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type)));
return buf;
}
gpointer
mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
{
/* FIXME: implement! */
g_assert_not_reached ();
return NULL;
}
| /**
* \file
* JIT trampoline code for Sparc
*
* Authors:
* Mark Crichton ([email protected])
* Dietmar Maurer ([email protected])
*
* (C) 2003 Ximian, Inc.
*/
#include <config.h>
#include <glib.h>
#include <mono/arch/sparc/sparc-codegen.h>
#include <mono/metadata/marshal.h>
#include <mono/metadata/tabledefs.h>
#include "mini.h"
#include "mini-sparc.h"
#include "jit-icalls.h"
#include "mono/utils/mono-tls-inline.h"
/*
* mono_arch_get_unbox_trampoline:
* @m: method pointer
* @addr: pointer to native code for @m
*
* when value type methods are called through the vtable we need to unbox the
* this argument. This method returns a pointer to a trampoline which does
* unboxing before calling the method
*/
gpointer
mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
{
MonoMemoryManager *mem_manager = m_method_get_mem_manager (m);
guint8 *code, *start;
int reg;
start = code = mono_mem_manager_code_reserve (mem_manager, 36);
/* This executes in the context of the caller, hence o0 */
sparc_add_imm (code, 0, sparc_o0, MONO_ABI_SIZEOF (MonoObject), sparc_o0);
#ifdef SPARCV9
reg = sparc_g4;
#else
reg = sparc_g1;
#endif
sparc_set (code, addr, reg);
sparc_jmpl (code, reg, sparc_g0, sparc_g0);
sparc_nop (code);
g_assert ((code - start) <= 36);
mono_arch_flush_icache (start, code - start);
MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m));
mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, NULL), NULL);
return start;
}
void
mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr)
{
if (sparc_inst_op (*(guint32*)code) == 0x1) {
sparc_call_simple (code, (guint8*)addr - (guint8*)code);
}
}
void
mono_arch_patch_plt_entry (guint8 *code, gpointer *got, host_mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
guchar*
mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *code, *tramp_addr;
guint32 lmf_offset, regs_offset, method_reg, i;
gboolean has_caller;
g_assert (!aot);
*info = NULL;
if (tramp_type == MONO_TRAMPOLINE_JUMP)
has_caller = FALSE;
else
has_caller = TRUE;
code = buf = mono_global_codeman_reserve (1024);
sparc_save_imm (code, sparc_sp, -1608, sparc_sp);
#ifdef SPARCV9
method_reg = sparc_g4;
#else
method_reg = sparc_g1;
#endif
regs_offset = MONO_SPARC_STACK_BIAS + 1000;
/* Save r1 needed by the IMT code */
sparc_sti_imm (code, sparc_g1, sparc_sp, regs_offset + (sparc_g1 * sizeof (target_mgreg_t)));
/*
* sparc_g5 contains the return address, the trampoline argument is stored in the
* instruction stream after the call.
*/
sparc_ld_imm (code, sparc_g5, 8, method_reg);
#ifdef SPARCV9
/* Save fp regs since they are not preserved by calls */
for (i = 0; i < 16; i ++)
sparc_stdf_imm (code, sparc_f0 + (i * 2), sparc_sp, MONO_SPARC_STACK_BIAS + 320 + (i * 8));
#endif
/* We receive the method address in %r1, so save it here */
sparc_sti_imm (code, method_reg, sparc_sp, MONO_SPARC_STACK_BIAS + 200);
/* Save lmf since compilation can raise exceptions */
lmf_offset = MONO_SPARC_STACK_BIAS - sizeof (MonoLMF);
/* Save the data for the parent (managed) frame */
/* Save ip */
sparc_sti_imm (code, sparc_i7, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, ip));
/* Save sp */
sparc_sti_imm (code, sparc_fp, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, sp));
/* Save fp */
/* Load previous fp from the saved register window */
sparc_flushw (code);
sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS + (sparc_i6 - 16) * sizeof (target_mgreg_t), sparc_o7);
sparc_sti_imm (code, sparc_o7, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, ebp));
/* Save method */
sparc_sti_imm (code, method_reg, sparc_fp, lmf_offset + G_STRUCT_OFFSET (MonoLMF, method));
sparc_set (code, mono_get_lmf_addr, sparc_o7);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
code = mono_sparc_emit_save_lmf (code, lmf_offset);
if (has_caller) {
/* Load all registers of the caller into a table inside this frame */
/* first the out registers */
for (i = 0; i < 8; ++i)
sparc_sti_imm (code, sparc_i0 + i, sparc_sp, regs_offset + ((sparc_o0 + i) * sizeof (target_mgreg_t)));
/* then the in+local registers */
for (i = 0; i < 16; i ++) {
sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS + (i * sizeof (target_mgreg_t)), sparc_o7);
sparc_sti_imm (code, sparc_o7, sparc_sp, regs_offset + ((sparc_l0 + i) * sizeof (target_mgreg_t)));
}
}
tramp_addr = mono_get_trampoline_func (tramp_type);
sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 200, sparc_o2);
/* pass address of register table as third argument */
sparc_add_imm (code, FALSE, sparc_sp, regs_offset, sparc_o0);
sparc_set (code, tramp_addr, sparc_o7);
/* set %o1 to caller address */
if (has_caller)
sparc_mov_reg_reg (code, sparc_i7, sparc_o1);
else
sparc_set (code, 0, sparc_o1);
sparc_set (code, 0, sparc_o3);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
/* Save result */
sparc_sti_imm (code, sparc_o0, sparc_sp, MONO_SPARC_STACK_BIAS + 304);
/* Check for thread interruption */
sparc_set (code, (guint8*)mono_interruption_checkpoint_from_trampoline_deprecated, sparc_o7);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
/* Restore lmf */
code = mono_sparc_emit_restore_lmf (code, lmf_offset);
/* Reload result */
sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 304, sparc_o0);
#ifdef SPARCV9
/* Reload fp regs */
for (i = 0; i < 16; i ++)
sparc_lddf_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 320 + (i * 8), sparc_f0 + (i * 2));
#endif
sparc_jmpl (code, sparc_o0, sparc_g0, sparc_g0);
/* restore previous frame in delay slot */
sparc_restore_simple (code);
/*
{
gpointer addr;
sparc_save_imm (code, sparc_sp, -608, sparc_sp);
addr = code;
sparc_call_simple (code, 16);
sparc_nop (code);
sparc_rett_simple (code);
sparc_nop (code);
sparc_save_imm (code, sparc_sp, -608, sparc_sp);
sparc_ta (code, 1);
tramp_addr = &sparc_magic_trampoline;
sparc_call_simple (code, tramp_addr - code);
sparc_nop (code);
sparc_rett_simple (code);
sparc_nop (code);
}
*/
g_assert ((code - buf) <= 512);
mono_arch_flush_icache (buf, code - buf);
MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL));
return buf;
}
#define TRAMPOLINE_SIZE (SPARC_SET_MAX_SIZE + 3)
gpointer
mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len)
{
guint32 *code, *buf, *tramp;
tramp = mono_get_trampoline_code (tramp_type);
code = buf = mono_mem_manager_code_reserve (mem_manager, TRAMPOLINE_SIZE * 4);
/* We have to use g5 here because there is no other free register */
sparc_set (code, tramp, sparc_g5);
sparc_jmpl (code, sparc_g5, sparc_g0, sparc_g5);
sparc_nop (code);
#ifdef SPARCV9
g_assert_not_reached ();
#else
*code = (guint32)arg1;
code ++;
#endif
g_assert ((code - buf) <= TRAMPOLINE_SIZE);
if (code_len)
*code_len = (code - buf);
mono_arch_flush_icache ((guint8*)buf, (code - buf));
MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type)));
return buf;
}
gpointer
mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
{
/* FIXME: implement! */
g_assert_not_reached ();
return NULL;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/md/inc/assemblymdinternaldisp.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//*****************************************************************************
// AssemblyMDInternalDispenser.h
//
//
// Contains utility code for MD directory
//
//*****************************************************************************
#ifndef __AssemblyMDInternalDispenser__h__
#define __AssemblyMDInternalDispenser__h__
#include "../runtime/mdinternalro.h"
#endif // __AssemblyMDInternalDispenser__h__
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//*****************************************************************************
// AssemblyMDInternalDispenser.h
//
//
// Contains utility code for MD directory
//
//*****************************************************************************
#ifndef __AssemblyMDInternalDispenser__h__
#define __AssemblyMDInternalDispenser__h__
#include "../runtime/mdinternalro.h"
#endif // __AssemblyMDInternalDispenser__h__
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/sgen/sgen-split-nursery.c | /**
* \file
* 3-space based nursery collector.
*
* Author:
* Rodrigo Kumpera Kumpera <[email protected]>
*
* Copyright 2001-2003 Ximian, Inc
* Copyright 2003-2010 Novell, Inc.
* Copyright 2011-2012 Xamarin Inc (http://www.xamarin.com)
* Copyright (C) 2012 Xamarin Inc
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "config.h"
#ifdef HAVE_SGEN_GC
#ifndef DISABLE_SGEN_SPLIT_NURSERY
#include <string.h>
#include <stdlib.h>
#include "mono/sgen/sgen-gc.h"
#include "mono/sgen/sgen-protocol.h"
#include "mono/sgen/sgen-layout-stats.h"
#include "mono/sgen/sgen-client.h"
#include "mono/utils/mono-memory-model.h"
/*
The nursery is logically divided into 3 spaces: Allocator space and two Survivor spaces.
Objects are born (allocated by the mutator) in the Allocator Space.
The Survivor spaces are divided in a copying collector style From and To spaces.
The hole of each space switch on each collection.
On each collection we process objects from the nursery this way:
Objects from the Allocator Space are evacuated into the To Space.
Objects from the Survivor From Space are evacuated into the old generation.
The nursery is physically divided in two parts, set by the promotion barrier.
The Allocator Space takes the botton part of the nursery.
The Survivor spaces are intermingled in the top part of the nursery. It's done
this way since the required size for the To Space depends on the survivor rate
of objects from the Allocator Space.
During a collection when the object scan function see a nursery object it must
determine if the object needs to be evacuated or left in place. Originally, this
check was done by checking if a forwarding pointer is installed, but now an object
can be in the To Space, it won't have a forwarding pointer and it must be left in place.
In order to solve that we classify nursery memory been either in the From Space or in
the To Space. Since the Allocator Space has the same behavior as the Survivor From Space
they are unified for this purpoise - a bit confusing at first.
This from/to classification is done on a larger granule than object to make the check efficient
and, due to that, we must make sure that all fragemnts used to allocate memory from the To Space
are naturally aligned in both ends to that granule to avoid wronly classifying a From Space object.
TODO:
-The promotion barrier is statically defined to 50% of the nursery, it should be dinamically adjusted based
on survival rates;
-We apply the same promotion policy to all objects, finalizable ones should age longer in the nursery;
-We apply the same promotion policy to all stages of a collection, maybe we should promote more aggressively
objects from non-stack roots, specially those found in the remembered set;
-Fix our major collection trigger to happen before we do a minor GC and collect the nursery only once.
-Make the serial fragment allocator fast path inlineable
-Make aging threshold be based on survival rates and survivor occupancy;
-Change promotion barrier to be size and not address based;
-Pre allocate memory for young ages to make sure that on overflow only the older suffer;
-Get rid of par_alloc_buffer_refill_mutex so to the parallel collection of the nursery doesn't suck;
*/
/*FIXME Move this to a separate header. */
#define _toi(ptr) ((size_t)ptr)
#define make_ptr_mask(bits) ((1 << bits) - 1)
#define align_down(ptr, bits) ((void*)(_toi(ptr) & ~make_ptr_mask (bits)))
#define align_up(ptr, bits) ((void*) ((_toi(ptr) + make_ptr_mask (bits)) & ~make_ptr_mask (bits)))
/*
Even though the effective max age is 255, aging that much doesn't make sense.
It might even make sense to use nimbles for age recording.
*/
#define MAX_AGE 15
/*
* Each age has its allocation buffer. Whenever an object is to be
* aged we try to fit it into its new age's allocation buffer. If
* that is not possible we get new space from the fragment allocator
* and set the allocation buffer to that space (minus the space
* required for the object).
*/
typedef struct {
char *next;
char *end;
} AgeAllocationBuffer;
/* Limits the ammount of memory the mutator can have. */
static char *promotion_barrier;
/*
Promotion age and alloc ratio are the two nursery knobs to control
how much effort we want to spend on young objects.
Allocation ratio should be the inverse of the expected survivor rate.
The more objects surviver, the smaller the alloc ratio much be so we can
age all objects.
Promote age depends on how much effort we want to spend aging objects before
we promote them to the old generation. If addional ages don't somewhat improve
mortality, it's better avoid as they increase the cost of minor collections.
*/
/*
If we're evacuating an object with this age or more, promote it.
Age is the number of surviving collections of an object.
*/
static int promote_age = 2;
/*
Initial ratio of allocation and survivor spaces.
This should be read as the fraction of the whole nursery dedicated
for the allocator space.
*/
static float alloc_ratio = 60.f/100.f;
static char *region_age;
static size_t region_age_size;
static AgeAllocationBuffer age_alloc_buffers [MAX_AGE];
/* The collector allocs from here. */
static SgenFragmentAllocator collector_allocator;
static int
get_object_age (GCObject *object)
{
size_t idx = ((char*)object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
return region_age [idx];
}
static void
set_age_in_range (char *start, char *end, int age)
{
char *region_start;
size_t region_idx, length;
region_idx = (start - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
region_start = ®ion_age [region_idx];
length = (end - start) >> SGEN_TO_SPACE_GRANULE_BITS;
memset (region_start, age, length);
}
static void
mark_bit (char *space_bitmap, char *pos)
{
size_t idx = (pos - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
size_t byte = idx / 8;
int bit = idx & 0x7;
g_assert (byte < sgen_space_bitmap_size);
space_bitmap [byte] |= 1 << bit;
}
static void
mark_bits_in_range (char *space_bitmap, char *start, char *end)
{
start = (char *)align_down (start, SGEN_TO_SPACE_GRANULE_BITS);
end = (char *)align_up (end, SGEN_TO_SPACE_GRANULE_BITS);
for (;start < end; start += SGEN_TO_SPACE_GRANULE_IN_BYTES)
mark_bit (space_bitmap, start);
}
/*
* This splits the fragments at the point of the promotion barrier.
* Two allocator are actually involved here: The mutator allocator and
* the collector allocator. This function is called with the
* collector, but it's a copy of the mutator allocator and contains
* all the fragments in the nursery. The fragments below the
* promotion barrier are left with the mutator allocator and the ones
* above are put into the collector allocator.
*/
static void
fragment_list_split (SgenFragmentAllocator *allocator)
{
SgenFragment *prev = NULL, *list = allocator->region_head;
while (list) {
if (list->fragment_end > promotion_barrier) {
if (list->fragment_start < promotion_barrier) {
SgenFragment *res = sgen_fragment_allocator_alloc ();
res->fragment_start = promotion_barrier;
res->fragment_next = promotion_barrier;
res->fragment_end = list->fragment_end;
res->next = list->next;
res->next_in_order = list->next_in_order;
g_assert (res->fragment_end > res->fragment_start);
list->fragment_end = promotion_barrier;
list->next = list->next_in_order = NULL;
set_age_in_range (list->fragment_start, list->fragment_end, 0);
allocator->region_head = allocator->alloc_head = res;
return;
} else {
if (prev)
prev->next = prev->next_in_order = NULL;
allocator->region_head = allocator->alloc_head = list;
return;
}
}
set_age_in_range (list->fragment_start, list->fragment_end, 0);
prev = list;
list = list->next;
}
allocator->region_head = allocator->alloc_head = NULL;
}
/******************************************Minor Collector API ************************************************/
#define AGE_ALLOC_BUFFER_MIN_SIZE SGEN_TO_SPACE_GRANULE_IN_BYTES
#define AGE_ALLOC_BUFFER_DESIRED_SIZE (SGEN_TO_SPACE_GRANULE_IN_BYTES * 8)
static char*
alloc_for_promotion_slow_path (int age, size_t objsize)
{
char *p;
size_t allocated_size;
size_t aligned_objsize = (size_t)align_up (objsize, SGEN_TO_SPACE_GRANULE_BITS);
p = (char *)sgen_fragment_allocator_serial_range_alloc (
&collector_allocator,
MAX (aligned_objsize, AGE_ALLOC_BUFFER_DESIRED_SIZE),
MAX (aligned_objsize, AGE_ALLOC_BUFFER_MIN_SIZE),
&allocated_size);
if (p) {
set_age_in_range (p, p + allocated_size, age);
sgen_clear_range (age_alloc_buffers [age].next, age_alloc_buffers [age].end);
age_alloc_buffers [age].next = p + objsize;
age_alloc_buffers [age].end = p + allocated_size;
}
return p;
}
static GCObject*
alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references)
{
char *p = NULL;
int age;
age = get_object_age (obj);
if (age >= promote_age) {
sgen_total_promoted_size += objsize;
return sgen_major_collector.alloc_object (vtable, objsize, has_references);
}
/* Promote! */
++age;
p = age_alloc_buffers [age].next;
if (G_LIKELY (p + objsize <= age_alloc_buffers [age].end)) {
age_alloc_buffers [age].next += objsize;
} else {
p = alloc_for_promotion_slow_path (age, objsize);
if (!p) {
sgen_total_promoted_size += objsize;
return sgen_major_collector.alloc_object (vtable, objsize, has_references);
}
}
/* FIXME: assumes object layout */
*(GCVTable*)p = vtable;
return (GCObject*)p;
}
static GCObject*
minor_alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references)
{
/*
We only need to check for a non-nursery object if we're doing a major collection.
*/
if (!sgen_ptr_in_nursery (obj))
return sgen_major_collector.alloc_object (vtable, objsize, has_references);
return alloc_for_promotion (vtable, obj, objsize, has_references);
}
static SgenFragment*
build_fragments_get_exclude_head (void)
{
int i;
for (i = 0; i < MAX_AGE; ++i) {
/*If we OOM'd on the last collection ->end might be null while ->next not.*/
if (age_alloc_buffers [i].end)
sgen_clear_range (age_alloc_buffers [i].next, age_alloc_buffers [i].end);
}
return collector_allocator.region_head;
}
static void
build_fragments_release_exclude_head (void)
{
sgen_fragment_allocator_release (&collector_allocator);
}
static void
build_fragments_finish (SgenFragmentAllocator *allocator)
{
/* We split the fragment list based on the promotion barrier. */
collector_allocator = *allocator;
fragment_list_split (&collector_allocator);
}
static void
prepare_to_space (char *to_space_bitmap, size_t space_bitmap_size)
{
SgenFragment **previous, *frag;
memset (to_space_bitmap, 0, space_bitmap_size);
memset (age_alloc_buffers, 0, sizeof (age_alloc_buffers));
previous = &collector_allocator.alloc_head;
for (frag = *previous; frag; frag = *previous) {
char *start = (char *)align_up (frag->fragment_next, SGEN_TO_SPACE_GRANULE_BITS);
char *end = (char *)align_down (frag->fragment_end, SGEN_TO_SPACE_GRANULE_BITS);
/* Fragment is too small to be usable. */
if ((end - start) < SGEN_MAX_NURSERY_WASTE) {
sgen_clear_range (frag->fragment_next, frag->fragment_end);
frag->fragment_next = frag->fragment_end = frag->fragment_start;
*previous = frag->next;
continue;
}
/*
We need to insert 3 phony objects so the fragments build step can correctly
walk the nursery.
*/
/* Clean the fragment range. */
sgen_clear_range (start, end);
/* We need a phony object in between the original fragment start and the effective one. */
if (start != frag->fragment_next)
sgen_clear_range (frag->fragment_next, start);
/* We need an phony object in between the new fragment end and the original fragment end. */
if (end != frag->fragment_end)
sgen_clear_range (end, frag->fragment_end);
frag->fragment_start = frag->fragment_next = start;
frag->fragment_end = end;
mark_bits_in_range (to_space_bitmap, start, end);
previous = &frag->next;
}
}
static void
clear_fragments (void)
{
sgen_clear_allocator_fragments (&collector_allocator);
}
static void
init_nursery (SgenFragmentAllocator *allocator, char *start, char *end)
{
int alloc_quote = (int)((end - start) * alloc_ratio);
promotion_barrier = (char *)align_down (start + alloc_quote, 3);
sgen_fragment_allocator_add (allocator, start, promotion_barrier);
sgen_fragment_allocator_add (&collector_allocator, promotion_barrier, end);
region_age_size = (end - start) >> SGEN_TO_SPACE_GRANULE_BITS;
region_age = (char *)g_malloc0 (region_age_size);
}
static gboolean
handle_gc_param (const char *opt)
{
if (g_str_has_prefix (opt, "alloc-ratio=")) {
const char *arg = strchr (opt, '=') + 1;
int percentage = atoi (arg);
if (percentage < 1 || percentage > 100) {
fprintf (stderr, "alloc-ratio must be an integer in the range 1-100.\n");
exit (1);
}
alloc_ratio = (float)percentage / 100.0f;
return TRUE;
}
if (g_str_has_prefix (opt, "promotion-age=")) {
const char *arg = strchr (opt, '=') + 1;
promote_age = atoi (arg);
if (promote_age < 1 || promote_age >= MAX_AGE) {
fprintf (stderr, "promotion-age must be an integer in the range 1-%d.\n", MAX_AGE - 1);
exit (1);
}
return TRUE;
}
return FALSE;
}
static void
print_gc_param_usage (void)
{
fprintf (stderr,
""
" alloc-ratio=P (where P is a percentage, an integer in 1-100)\n"
" promotion-age=P (where P is a number, an integer in 1-%d)\n",
MAX_AGE - 1
);
}
/******************************************Copy/Scan functins ************************************************/
#define collector_pin_object(obj, queue) sgen_pin_object (obj, queue);
#define COLLECTOR_SERIAL_ALLOC_FOR_PROMOTION alloc_for_promotion
#include "sgen-copy-object.h"
#define SGEN_SPLIT_NURSERY
#include "sgen-minor-copy-object.h"
#include "sgen-minor-scan-object.h"
static void
fill_serial_ops (SgenObjectOperations *ops)
{
ops->copy_or_mark_object = SERIAL_COPY_OBJECT;
FILL_MINOR_COLLECTOR_SCAN_OBJECT (ops);
}
#define SGEN_CONCURRENT_MAJOR
#include "sgen-minor-copy-object.h"
#include "sgen-minor-scan-object.h"
static void
fill_serial_with_concurrent_major_ops (SgenObjectOperations *ops)
{
ops->copy_or_mark_object = SERIAL_COPY_OBJECT;
FILL_MINOR_COLLECTOR_SCAN_OBJECT (ops);
}
void
sgen_split_nursery_init (SgenMinorCollector *collector)
{
collector->is_split = TRUE;
collector->is_parallel = FALSE;
collector->alloc_for_promotion = minor_alloc_for_promotion;
collector->prepare_to_space = prepare_to_space;
collector->clear_fragments = clear_fragments;
collector->build_fragments_get_exclude_head = build_fragments_get_exclude_head;
collector->build_fragments_release_exclude_head = build_fragments_release_exclude_head;
collector->build_fragments_finish = build_fragments_finish;
collector->init_nursery = init_nursery;
collector->handle_gc_param = handle_gc_param;
collector->print_gc_param_usage = print_gc_param_usage;
fill_serial_ops (&collector->serial_ops);
fill_serial_with_concurrent_major_ops (&collector->serial_ops_with_concurrent_major);
}
#else
#include <mono/utils/mono-compiler.h>
MONO_EMPTY_SOURCE_FILE (sgen_split_nursery);
#endif //#ifndef DISABLE_SGEN_SPLIT_NURSERY
#endif
| /**
* \file
* 3-space based nursery collector.
*
* Author:
* Rodrigo Kumpera Kumpera <[email protected]>
*
* Copyright 2001-2003 Ximian, Inc
* Copyright 2003-2010 Novell, Inc.
* Copyright 2011-2012 Xamarin Inc (http://www.xamarin.com)
* Copyright (C) 2012 Xamarin Inc
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "config.h"
#ifdef HAVE_SGEN_GC
#ifndef DISABLE_SGEN_SPLIT_NURSERY
#include <string.h>
#include <stdlib.h>
#include "mono/sgen/sgen-gc.h"
#include "mono/sgen/sgen-protocol.h"
#include "mono/sgen/sgen-layout-stats.h"
#include "mono/sgen/sgen-client.h"
#include "mono/utils/mono-memory-model.h"
/*
The nursery is logically divided into 3 spaces: Allocator space and two Survivor spaces.
Objects are born (allocated by the mutator) in the Allocator Space.
The Survivor spaces are divided in a copying collector style From and To spaces.
The hole of each space switch on each collection.
On each collection we process objects from the nursery this way:
Objects from the Allocator Space are evacuated into the To Space.
Objects from the Survivor From Space are evacuated into the old generation.
The nursery is physically divided in two parts, set by the promotion barrier.
The Allocator Space takes the botton part of the nursery.
The Survivor spaces are intermingled in the top part of the nursery. It's done
this way since the required size for the To Space depends on the survivor rate
of objects from the Allocator Space.
During a collection when the object scan function see a nursery object it must
determine if the object needs to be evacuated or left in place. Originally, this
check was done by checking if a forwarding pointer is installed, but now an object
can be in the To Space, it won't have a forwarding pointer and it must be left in place.
In order to solve that we classify nursery memory been either in the From Space or in
the To Space. Since the Allocator Space has the same behavior as the Survivor From Space
they are unified for this purpoise - a bit confusing at first.
This from/to classification is done on a larger granule than object to make the check efficient
and, due to that, we must make sure that all fragemnts used to allocate memory from the To Space
are naturally aligned in both ends to that granule to avoid wronly classifying a From Space object.
TODO:
-The promotion barrier is statically defined to 50% of the nursery, it should be dinamically adjusted based
on survival rates;
-We apply the same promotion policy to all objects, finalizable ones should age longer in the nursery;
-We apply the same promotion policy to all stages of a collection, maybe we should promote more aggressively
objects from non-stack roots, specially those found in the remembered set;
-Fix our major collection trigger to happen before we do a minor GC and collect the nursery only once.
-Make the serial fragment allocator fast path inlineable
-Make aging threshold be based on survival rates and survivor occupancy;
-Change promotion barrier to be size and not address based;
-Pre allocate memory for young ages to make sure that on overflow only the older suffer;
-Get rid of par_alloc_buffer_refill_mutex so to the parallel collection of the nursery doesn't suck;
*/
/*FIXME Move this to a separate header. */
#define _toi(ptr) ((size_t)ptr)
#define make_ptr_mask(bits) ((1 << bits) - 1)
#define align_down(ptr, bits) ((void*)(_toi(ptr) & ~make_ptr_mask (bits)))
#define align_up(ptr, bits) ((void*) ((_toi(ptr) + make_ptr_mask (bits)) & ~make_ptr_mask (bits)))
/*
Even though the effective max age is 255, aging that much doesn't make sense.
It might even make sense to use nimbles for age recording.
*/
#define MAX_AGE 15
/*
* Each age has its allocation buffer. Whenever an object is to be
* aged we try to fit it into its new age's allocation buffer. If
* that is not possible we get new space from the fragment allocator
* and set the allocation buffer to that space (minus the space
* required for the object).
*/
typedef struct {
char *next;
char *end;
} AgeAllocationBuffer;
/* Limits the ammount of memory the mutator can have. */
static char *promotion_barrier;
/*
Promotion age and alloc ratio are the two nursery knobs to control
how much effort we want to spend on young objects.
Allocation ratio should be the inverse of the expected survivor rate.
The more objects surviver, the smaller the alloc ratio much be so we can
age all objects.
Promote age depends on how much effort we want to spend aging objects before
we promote them to the old generation. If addional ages don't somewhat improve
mortality, it's better avoid as they increase the cost of minor collections.
*/
/*
If we're evacuating an object with this age or more, promote it.
Age is the number of surviving collections of an object.
*/
static int promote_age = 2;
/*
Initial ratio of allocation and survivor spaces.
This should be read as the fraction of the whole nursery dedicated
for the allocator space.
*/
static float alloc_ratio = 60.f/100.f;
static char *region_age;
static size_t region_age_size;
static AgeAllocationBuffer age_alloc_buffers [MAX_AGE];
/* The collector allocs from here. */
static SgenFragmentAllocator collector_allocator;
static int
get_object_age (GCObject *object)
{
size_t idx = ((char*)object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
return region_age [idx];
}
static void
set_age_in_range (char *start, char *end, int age)
{
char *region_start;
size_t region_idx, length;
region_idx = (start - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
region_start = ®ion_age [region_idx];
length = (end - start) >> SGEN_TO_SPACE_GRANULE_BITS;
memset (region_start, age, length);
}
static void
mark_bit (char *space_bitmap, char *pos)
{
size_t idx = (pos - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
size_t byte = idx / 8;
int bit = idx & 0x7;
g_assert (byte < sgen_space_bitmap_size);
space_bitmap [byte] |= 1 << bit;
}
static void
mark_bits_in_range (char *space_bitmap, char *start, char *end)
{
start = (char *)align_down (start, SGEN_TO_SPACE_GRANULE_BITS);
end = (char *)align_up (end, SGEN_TO_SPACE_GRANULE_BITS);
for (;start < end; start += SGEN_TO_SPACE_GRANULE_IN_BYTES)
mark_bit (space_bitmap, start);
}
/*
* This splits the fragments at the point of the promotion barrier.
* Two allocator are actually involved here: The mutator allocator and
* the collector allocator. This function is called with the
* collector, but it's a copy of the mutator allocator and contains
* all the fragments in the nursery. The fragments below the
* promotion barrier are left with the mutator allocator and the ones
* above are put into the collector allocator.
*/
static void
fragment_list_split (SgenFragmentAllocator *allocator)
{
SgenFragment *prev = NULL, *list = allocator->region_head;
while (list) {
if (list->fragment_end > promotion_barrier) {
if (list->fragment_start < promotion_barrier) {
SgenFragment *res = sgen_fragment_allocator_alloc ();
res->fragment_start = promotion_barrier;
res->fragment_next = promotion_barrier;
res->fragment_end = list->fragment_end;
res->next = list->next;
res->next_in_order = list->next_in_order;
g_assert (res->fragment_end > res->fragment_start);
list->fragment_end = promotion_barrier;
list->next = list->next_in_order = NULL;
set_age_in_range (list->fragment_start, list->fragment_end, 0);
allocator->region_head = allocator->alloc_head = res;
return;
} else {
if (prev)
prev->next = prev->next_in_order = NULL;
allocator->region_head = allocator->alloc_head = list;
return;
}
}
set_age_in_range (list->fragment_start, list->fragment_end, 0);
prev = list;
list = list->next;
}
allocator->region_head = allocator->alloc_head = NULL;
}
/******************************************Minor Collector API ************************************************/
#define AGE_ALLOC_BUFFER_MIN_SIZE SGEN_TO_SPACE_GRANULE_IN_BYTES
#define AGE_ALLOC_BUFFER_DESIRED_SIZE (SGEN_TO_SPACE_GRANULE_IN_BYTES * 8)
static char*
alloc_for_promotion_slow_path (int age, size_t objsize)
{
char *p;
size_t allocated_size;
size_t aligned_objsize = (size_t)align_up (objsize, SGEN_TO_SPACE_GRANULE_BITS);
p = (char *)sgen_fragment_allocator_serial_range_alloc (
&collector_allocator,
MAX (aligned_objsize, AGE_ALLOC_BUFFER_DESIRED_SIZE),
MAX (aligned_objsize, AGE_ALLOC_BUFFER_MIN_SIZE),
&allocated_size);
if (p) {
set_age_in_range (p, p + allocated_size, age);
sgen_clear_range (age_alloc_buffers [age].next, age_alloc_buffers [age].end);
age_alloc_buffers [age].next = p + objsize;
age_alloc_buffers [age].end = p + allocated_size;
}
return p;
}
static GCObject*
alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references)
{
char *p = NULL;
int age;
age = get_object_age (obj);
if (age >= promote_age) {
sgen_total_promoted_size += objsize;
return sgen_major_collector.alloc_object (vtable, objsize, has_references);
}
/* Promote! */
++age;
p = age_alloc_buffers [age].next;
if (G_LIKELY (p + objsize <= age_alloc_buffers [age].end)) {
age_alloc_buffers [age].next += objsize;
} else {
p = alloc_for_promotion_slow_path (age, objsize);
if (!p) {
sgen_total_promoted_size += objsize;
return sgen_major_collector.alloc_object (vtable, objsize, has_references);
}
}
/* FIXME: assumes object layout */
*(GCVTable*)p = vtable;
return (GCObject*)p;
}
static GCObject*
minor_alloc_for_promotion (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references)
{
/*
We only need to check for a non-nursery object if we're doing a major collection.
*/
if (!sgen_ptr_in_nursery (obj))
return sgen_major_collector.alloc_object (vtable, objsize, has_references);
return alloc_for_promotion (vtable, obj, objsize, has_references);
}
static SgenFragment*
build_fragments_get_exclude_head (void)
{
int i;
for (i = 0; i < MAX_AGE; ++i) {
/*If we OOM'd on the last collection ->end might be null while ->next not.*/
if (age_alloc_buffers [i].end)
sgen_clear_range (age_alloc_buffers [i].next, age_alloc_buffers [i].end);
}
return collector_allocator.region_head;
}
static void
build_fragments_release_exclude_head (void)
{
sgen_fragment_allocator_release (&collector_allocator);
}
static void
build_fragments_finish (SgenFragmentAllocator *allocator)
{
/* We split the fragment list based on the promotion barrier. */
collector_allocator = *allocator;
fragment_list_split (&collector_allocator);
}
static void
prepare_to_space (char *to_space_bitmap, size_t space_bitmap_size)
{
SgenFragment **previous, *frag;
memset (to_space_bitmap, 0, space_bitmap_size);
memset (age_alloc_buffers, 0, sizeof (age_alloc_buffers));
previous = &collector_allocator.alloc_head;
for (frag = *previous; frag; frag = *previous) {
char *start = (char *)align_up (frag->fragment_next, SGEN_TO_SPACE_GRANULE_BITS);
char *end = (char *)align_down (frag->fragment_end, SGEN_TO_SPACE_GRANULE_BITS);
/* Fragment is too small to be usable. */
if ((end - start) < SGEN_MAX_NURSERY_WASTE) {
sgen_clear_range (frag->fragment_next, frag->fragment_end);
frag->fragment_next = frag->fragment_end = frag->fragment_start;
*previous = frag->next;
continue;
}
/*
We need to insert 3 phony objects so the fragments build step can correctly
walk the nursery.
*/
/* Clean the fragment range. */
sgen_clear_range (start, end);
/* We need a phony object in between the original fragment start and the effective one. */
if (start != frag->fragment_next)
sgen_clear_range (frag->fragment_next, start);
/* We need an phony object in between the new fragment end and the original fragment end. */
if (end != frag->fragment_end)
sgen_clear_range (end, frag->fragment_end);
frag->fragment_start = frag->fragment_next = start;
frag->fragment_end = end;
mark_bits_in_range (to_space_bitmap, start, end);
previous = &frag->next;
}
}
static void
clear_fragments (void)
{
sgen_clear_allocator_fragments (&collector_allocator);
}
static void
init_nursery (SgenFragmentAllocator *allocator, char *start, char *end)
{
int alloc_quote = (int)((end - start) * alloc_ratio);
promotion_barrier = (char *)align_down (start + alloc_quote, 3);
sgen_fragment_allocator_add (allocator, start, promotion_barrier);
sgen_fragment_allocator_add (&collector_allocator, promotion_barrier, end);
region_age_size = (end - start) >> SGEN_TO_SPACE_GRANULE_BITS;
region_age = (char *)g_malloc0 (region_age_size);
}
static gboolean
handle_gc_param (const char *opt)
{
if (g_str_has_prefix (opt, "alloc-ratio=")) {
const char *arg = strchr (opt, '=') + 1;
int percentage = atoi (arg);
if (percentage < 1 || percentage > 100) {
fprintf (stderr, "alloc-ratio must be an integer in the range 1-100.\n");
exit (1);
}
alloc_ratio = (float)percentage / 100.0f;
return TRUE;
}
if (g_str_has_prefix (opt, "promotion-age=")) {
const char *arg = strchr (opt, '=') + 1;
promote_age = atoi (arg);
if (promote_age < 1 || promote_age >= MAX_AGE) {
fprintf (stderr, "promotion-age must be an integer in the range 1-%d.\n", MAX_AGE - 1);
exit (1);
}
return TRUE;
}
return FALSE;
}
static void
print_gc_param_usage (void)
{
fprintf (stderr,
""
" alloc-ratio=P (where P is a percentage, an integer in 1-100)\n"
" promotion-age=P (where P is a number, an integer in 1-%d)\n",
MAX_AGE - 1
);
}
/******************************************Copy/Scan functins ************************************************/
#define collector_pin_object(obj, queue) sgen_pin_object (obj, queue);
#define COLLECTOR_SERIAL_ALLOC_FOR_PROMOTION alloc_for_promotion
#include "sgen-copy-object.h"
#define SGEN_SPLIT_NURSERY
#include "sgen-minor-copy-object.h"
#include "sgen-minor-scan-object.h"
static void
fill_serial_ops (SgenObjectOperations *ops)
{
ops->copy_or_mark_object = SERIAL_COPY_OBJECT;
FILL_MINOR_COLLECTOR_SCAN_OBJECT (ops);
}
#define SGEN_CONCURRENT_MAJOR
#include "sgen-minor-copy-object.h"
#include "sgen-minor-scan-object.h"
static void
fill_serial_with_concurrent_major_ops (SgenObjectOperations *ops)
{
ops->copy_or_mark_object = SERIAL_COPY_OBJECT;
FILL_MINOR_COLLECTOR_SCAN_OBJECT (ops);
}
void
sgen_split_nursery_init (SgenMinorCollector *collector)
{
collector->is_split = TRUE;
collector->is_parallel = FALSE;
collector->alloc_for_promotion = minor_alloc_for_promotion;
collector->prepare_to_space = prepare_to_space;
collector->clear_fragments = clear_fragments;
collector->build_fragments_get_exclude_head = build_fragments_get_exclude_head;
collector->build_fragments_release_exclude_head = build_fragments_release_exclude_head;
collector->build_fragments_finish = build_fragments_finish;
collector->init_nursery = init_nursery;
collector->handle_gc_param = handle_gc_param;
collector->print_gc_param_usage = print_gc_param_usage;
fill_serial_ops (&collector->serial_ops);
fill_serial_with_concurrent_major_ops (&collector->serial_ops_with_concurrent_major);
}
#else
#include <mono/utils/mono-compiler.h>
MONO_EMPTY_SOURCE_FILE (sgen_split_nursery);
#endif //#ifndef DISABLE_SGEN_SPLIT_NURSERY
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/libs/System.Security.Cryptography.Native/apibridge_30_rev.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// Functions based on OpenSSL 3.0 API, used when building against/running with older versions.
#pragma once
#include "pal_types.h"
// For 3.0 to behave like previous versions.
void local_ERR_put_error(int32_t lib, int32_t func, int32_t reason, const char* file, int32_t line);
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// Functions based on OpenSSL 3.0 API, used when building against/running with older versions.
#pragma once
#include "pal_types.h"
// For 3.0 to behave like previous versions.
void local_ERR_put_error(int32_t lib, int32_t func, int32_t reason, const char* file, int32_t line);
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/wasi/mono-wasi-driver/synthetic-pthread.c | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include <assert.h>
#define SYNTHETIC_PTHREAD_KEYS_MAX 32
typedef struct {
int is_created;
const void* current_value;
void* destructor_func;
} synthetic_pthread_key;
// Since we're not really supporting multiple threads, there's just a single global list of pthread keys
// (If we did have real threads, there would be a separate set for each thread)
synthetic_pthread_key synthetic_key_list[SYNTHETIC_PTHREAD_KEYS_MAX];
int pthread_key_create(int *key_index, void* destructor) {
int i;
for (i = 0; i < SYNTHETIC_PTHREAD_KEYS_MAX; i++) {
if (!synthetic_key_list[i].is_created) {
break;
}
}
if (i == SYNTHETIC_PTHREAD_KEYS_MAX) {
return -1;
}
synthetic_key_list[i].is_created = 1;
synthetic_key_list[i].destructor_func = destructor; // Not really used since we never destroy keys
*key_index = i;
return 0;
}
int pthread_setspecific(int key_index, const void* value) {
if (!synthetic_key_list[key_index].is_created)
return -1;
synthetic_key_list[key_index].current_value = value;
return 0;
}
const void* pthread_getspecific(int key_index) {
assert (synthetic_key_list[key_index].is_created);
return synthetic_key_list[key_index].current_value;
}
// Since we're not really supporting threads, mutex operations are no-ops
// It would be more robust if we actually just aborted if you tried to lock an already-locked mutex
int pthread_mutex_lock(void *mutex) { /*printf("pthread_mutex_lock with mutex=%i\n", mutex);*/ return 0; }
int pthread_mutex_unlock(int *mutex) { /*printf("pthread_mutex_unlock with mutex=%i\n", mutex);*/ return 0; }
// Unused pthread APIs
int pthread_self() { assert(0); return 0; }
int pthread_cond_signal(int a) { assert(0); return 0; }
int pthread_cond_init(int a, int b) { return 0; }
int pthread_cond_wait(int a, int b) { return 0; }
int pthread_cond_destroy(int a) { return 0; }
int pthread_mutex_init(int a, int b) { return 0; }
int pthread_mutex_destroy(int a) { return 0; }
int pthread_cond_timedwait(int a, int b, int c) { return 0; }
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include <assert.h>
#define SYNTHETIC_PTHREAD_KEYS_MAX 32
typedef struct {
int is_created;
const void* current_value;
void* destructor_func;
} synthetic_pthread_key;
// Since we're not really supporting multiple threads, there's just a single global list of pthread keys
// (If we did have real threads, there would be a separate set for each thread)
synthetic_pthread_key synthetic_key_list[SYNTHETIC_PTHREAD_KEYS_MAX];
int pthread_key_create(int *key_index, void* destructor) {
int i;
for (i = 0; i < SYNTHETIC_PTHREAD_KEYS_MAX; i++) {
if (!synthetic_key_list[i].is_created) {
break;
}
}
if (i == SYNTHETIC_PTHREAD_KEYS_MAX) {
return -1;
}
synthetic_key_list[i].is_created = 1;
synthetic_key_list[i].destructor_func = destructor; // Not really used since we never destroy keys
*key_index = i;
return 0;
}
int pthread_setspecific(int key_index, const void* value) {
if (!synthetic_key_list[key_index].is_created)
return -1;
synthetic_key_list[key_index].current_value = value;
return 0;
}
const void* pthread_getspecific(int key_index) {
assert (synthetic_key_list[key_index].is_created);
return synthetic_key_list[key_index].current_value;
}
// Since we're not really supporting threads, mutex operations are no-ops
// It would be more robust if we actually just aborted if you tried to lock an already-locked mutex
int pthread_mutex_lock(void *mutex) { /*printf("pthread_mutex_lock with mutex=%i\n", mutex);*/ return 0; }
int pthread_mutex_unlock(int *mutex) { /*printf("pthread_mutex_unlock with mutex=%i\n", mutex);*/ return 0; }
// Unused pthread APIs
int pthread_self() { assert(0); return 0; }
int pthread_cond_signal(int a) { assert(0); return 0; }
int pthread_cond_init(int a, int b) { return 0; }
int pthread_cond_wait(int a, int b) { return 0; }
int pthread_cond_destroy(int a) { return 0; }
int pthread_mutex_init(int a, int b) { return 0; }
int pthread_mutex_destroy(int a) { return 0; }
int pthread_cond_timedwait(int a, int b, int c) { return 0; }
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/inc/rt/specstrings_undef.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/*
*/
#ifndef PAL_STDCPP_COMPAT
#undef __in
#undef __out
#endif // !PAL_STDCPP_COMPAT
#undef _At_
#undef _Deref_out_
#undef _Deref_out_opt_
#undef _Deref_opt_out_
#undef _Deref_opt_out_opt_
#undef _Deref_post_cap_
#undef _Deref_post_opt_cap_
#undef _Deref_post_bytecap_
#undef _Deref_post_opt_bytecap_
#undef _Deref_post_count_
#undef _Deref_post_opt_count_
#undef _Deref_post_bytecount_
#undef _Deref_post_opt_bytecount_
#undef _In_count_
#undef _In_opt_count_
#undef _In_bytecount_
#undef _In_opt_bytecount_
#undef _Out_cap_
#undef _Out_opt_cap_
#undef _Out_bytecap_
#undef _Out_opt_bytecap_
#undef _Outptr_
#undef _Outptr_result_maybenull_
#undef _Outptr_opt_
#undef _Outptr_opt_result_maybenull_
#undef _Outptr_result_z_
#undef _Outptr_opt_result_z_
#undef _Outptr_result_maybenull_z_
#undef _Outptr_opt_result_maybenull_z_
#undef _Outptr_result_nullonfailure_
#undef _Outptr_opt_result_nullonfailure_
#undef _COM_Outptr_
#undef _COM_Outptr_result_maybenull_
#undef _COM_Outptr_opt_
#undef _COM_Outptr_opt_result_maybenull_
#undef _Outptr_result_buffer_
#undef _Outptr_opt_result_buffer_
#undef _Outptr_result_buffer_to_
#undef _Outptr_opt_result_buffer_to_
#undef _Outptr_result_buffer_all_
#undef _Outptr_opt_result_buffer_all_
#undef _Outptr_result_buffer_maybenull_
#undef _Outptr_opt_result_buffer_maybenull_
#undef _Outptr_result_buffer_to_maybenull_
#undef _Outptr_opt_result_buffer_to_maybenull_
#undef _Outptr_result_buffer_all_maybenull_
#undef _Outptr_opt_result_buffer_all_maybenull_
#undef _Outptr_result_bytebuffer_
#undef _Outptr_opt_result_bytebuffer_
#undef _Outptr_result_bytebuffer_to_
#undef _Outptr_opt_result_bytebuffer_to_
#undef _Outptr_result_bytebuffer_all_
#undef _Outptr_opt_result_bytebuffer_all_
#undef _Outptr_result_bytebuffer_maybenull_
#undef _Outptr_opt_result_bytebuffer_maybenull_
#undef _Outptr_result_bytebuffer_to_maybenull_
#undef _Outptr_opt_result_bytebuffer_to_maybenull_
#undef _Outptr_result_bytebuffer_all_maybenull_
#undef _Outptr_opt_result_bytebuffer_all_maybenull_
#undef _When_
#undef __allocator
#undef __analysis_assert
#undef __analysis_assume
#undef __analysis_assume_nullterminated
#undef __analysis_hint
#undef __assume_bound
#undef __assume_validated
#undef __bcount
#undef __bcount_opt
#undef __blocksOn
#undef __bound
#undef __byte_readableTo
#undef __byte_writableTo
#undef __callback
#undef __checkReturn
#undef __class_code_content
#undef __control_entrypoint
#undef __data_entrypoint
#undef __deallocate
#undef __deallocate_opt
#undef __deref
#undef __deref_bcount
#undef __deref_bcount_opt
#undef __deref_ecount
#undef __deref_ecount_opt
#undef __deref_in
#undef __deref_in_bcount
#undef __deref_in_bcount_opt
#undef __deref_in_ecount
#undef __deref_in_ecount_opt
#undef __deref_in_ecount_iterator
#undef __deref_in_opt
#undef __deref_in_opt_out
#undef __deref_in_range
#undef __deref_in_xcount
#undef __deref_in_xcount_opt
#undef __deref_inout
#undef __deref_inout_bcount
#undef __deref_inout_bcount_full
#undef __deref_inout_bcount_full_opt
#undef __deref_inout_bcount_nz
#undef __deref_inout_bcount_nz_opt
#undef __deref_inout_bcount_opt
#undef __deref_inout_bcount_part
#undef __deref_inout_bcount_part_opt
#undef __deref_inout_bcount_z
#undef __deref_inout_bcount_z_opt
#undef __deref_inout_ecount
#undef __deref_inout_ecount_full
#undef __deref_inout_ecount_full_opt
#undef __deref_inout_ecount_nz
#undef __deref_inout_ecount_nz_opt
#undef __deref_inout_ecount_opt
#undef __deref_inout_ecount_part
#undef __deref_inout_ecount_part_opt
#undef __deref_inout_ecount_z
#undef __deref_inout_ecount_z_opt
#undef __deref_inout_ecount_iterator
#undef __deref_inout_nz
#undef __deref_inout_nz_opt
#undef __deref_inout_opt
#undef __deref_inout_range
#undef __deref_inout_xcount
#undef __deref_inout_xcount_full
#undef __deref_inout_xcount_full_opt
#undef __deref_inout_xcount_opt
#undef __deref_inout_xcount_part
#undef __deref_inout_xcount_part_opt
#undef __deref_inout_z
#undef __deref_inout_z_opt
#undef __deref_nonvolatile
#undef __deref_opt_bcount
#undef __deref_opt_bcount_opt
#undef __deref_opt_ecount
#undef __deref_opt_ecount_opt
#undef __deref_opt_in
#undef __deref_opt_in_bcount
#undef __deref_opt_in_bcount_opt
#undef __deref_opt_in_ecount
#undef __deref_opt_in_ecount_opt
#undef __deref_opt_in_opt
#undef __deref_opt_in_xcount
#undef __deref_opt_in_xcount_opt
#undef __deref_opt_inout
#undef __deref_opt_inout_bcount
#undef __deref_opt_inout_bcount_full
#undef __deref_opt_inout_bcount_full_opt
#undef __deref_opt_inout_bcount_nz
#undef __deref_opt_inout_bcount_nz_opt
#undef __deref_opt_inout_bcount_opt
#undef __deref_opt_inout_bcount_part
#undef __deref_opt_inout_bcount_part_opt
#undef __deref_opt_inout_bcount_z
#undef __deref_opt_inout_bcount_z_opt
#undef __deref_opt_inout_ecount
#undef __deref_opt_inout_ecount_full
#undef __deref_opt_inout_ecount_full_opt
#undef __deref_opt_inout_ecount_nz
#undef __deref_opt_inout_ecount_nz_opt
#undef __deref_opt_inout_ecount_opt
#undef __deref_opt_inout_ecount_part
#undef __deref_opt_inout_ecount_part_opt
#undef __deref_opt_inout_ecount_z
#undef __deref_opt_inout_ecount_z_opt
#undef __deref_opt_inout_nz
#undef __deref_opt_inout_nz_opt
#undef __deref_opt_inout_opt
#undef __deref_opt_inout_xcount
#undef __deref_opt_inout_xcount_full
#undef __deref_opt_inout_xcount_full_opt
#undef __deref_opt_inout_xcount_opt
#undef __deref_opt_inout_xcount_part
#undef __deref_opt_inout_xcount_part_opt
#undef __deref_opt_inout_z
#undef __deref_opt_inout_z_opt
#undef __deref_opt_out
#undef __deref_opt_out_bcount
#undef __deref_opt_out_bcount_full
#undef __deref_opt_out_bcount_full_opt
#undef __deref_opt_out_bcount_nz_opt
#undef __deref_opt_out_bcount_opt
#undef __deref_opt_out_bcount_part
#undef __deref_opt_out_bcount_part_opt
#undef __deref_opt_out_bcount_z_opt
#undef __deref_opt_out_ecount
#undef __deref_opt_out_ecount_full
#undef __deref_opt_out_ecount_full_opt
#undef __deref_opt_out_ecount_nz_opt
#undef __deref_opt_out_ecount_opt
#undef __deref_opt_out_ecount_part
#undef __deref_opt_out_ecount_part_opt
#undef __deref_opt_out_ecount_z_opt
#undef __deref_opt_out_nz_opt
#undef __deref_opt_out_opt
#undef __deref_opt_out_xcount
#undef __deref_opt_out_xcount_full
#undef __deref_opt_out_xcount_full_opt
#undef __deref_opt_out_xcount_opt
#undef __deref_opt_out_xcount_part
#undef __deref_opt_out_xcount_part_opt
#undef __deref_opt_out_z_opt
#undef __deref_opt_xcount
#undef __deref_opt_xcount_opt
#undef __deref_out
#undef __deref_out_bcount
#undef __deref_out_bcount_full
#undef __deref_out_bcount_full_opt
#undef __deref_out_bcount_nz
#undef __deref_out_bcount_nz_opt
#undef __deref_out_bcount_opt
#undef __deref_out_bcount_part
#undef __deref_out_bcount_part_opt
#undef __deref_out_bcount_z
#undef __deref_out_bcount_z_opt
#undef __deref_out_bound
#undef __deref_out_ecount
#undef __deref_out_ecount_full
#undef __deref_out_ecount_full_opt
#undef __deref_out_ecount_iterator
#undef __deref_out_ecount_nz
#undef __deref_out_ecount_nz_opt
#undef __deref_out_ecount_opt
#undef __deref_out_ecount_part
#undef __deref_out_ecount_part_opt
#undef __deref_out_ecount_z
#undef __deref_out_ecount_z_opt
#undef __deref_out_nz
#undef __deref_out_nz_opt
#undef __deref_out_opt
#undef __deref_out_range
#undef __deref_out_range
#undef __deref_out_xcount
#undef __deref_out_xcount
#undef __deref_out_xcount_full
#undef __deref_out_xcount_full_opt
#undef __deref_out_xcount_opt
#undef __deref_out_xcount_part
#undef __deref_out_xcount_part_opt
#undef __deref_out_z
#undef __deref_out_z_opt
#undef __deref_realloc_bcount
#undef __deref_volatile
#undef __deref_xcount
#undef __deref_xcount_opt
#undef __ecount
#undef __ecount_opt
#undef __elem_readableTo
#undef __elem_writableTo
#undef __encoded_array
#undef __encoded_pointer
#undef __exceptthat
#undef __fallthrough
#undef __field_bcount
#undef __field_bcount_full
#undef __field_bcount_full_opt
#undef __field_bcount_opt
#undef __field_bcount_part
#undef __field_bcount_part_opt
#undef __field_data_source
#undef __field_ecount
#undef __field_ecount_full
#undef __field_ecount_full_opt
#undef __field_ecount_opt
#undef __field_ecount_part
#undef __field_ecount_part_opt
#undef __field_encoded_array
#undef __field_encoded_pointer
#undef __field_nullterminated
#undef __field_range
#undef __field_xcount
#undef __field_xcount_full
#undef __field_xcount_full_opt
#undef __field_xcount_opt
#undef __field_xcount_part
#undef __field_xcount_part_opt
#undef __file_parser
#undef __file_parser_class
#undef __file_parser_library
#undef __format_string
#undef __format_string
#undef __gdi_entry
#undef __in_awcount
#undef __in_bcount
#undef __in_bcount_nz
#undef __in_bcount_nz_opt
#undef __in_bcount_opt
#undef __in_bcount_z
#undef __in_bcount_z_opt
#undef __in_bound
#undef __in_data_source
#undef __in_ecount
#undef __in_ecount_nz
#undef __in_ecount_nz_opt
#undef __in_ecount_opt
#undef __in_ecount_z
#undef __in_ecount_z_opt
#undef __in_nz
#undef __in_nz_opt
#undef __in_opt
#undef __in_range
#undef __in_xcount
#undef __in_xcount_opt
#undef __in_z
#undef __in_z_opt
#undef __inexpressible_readableTo
#undef __inexpressible_writableTo
#undef __inner_adt_add_prop
#undef __inner_adt_prop
#undef __inner_adt_remove_prop
#undef __inner_adt_transfer_prop
#undef __inner_adt_type_props
#undef __inner_analysis_assume_nulltermianted_dec
#undef __inner_analysis_assume_nullterminated
#undef __inner_assume_bound
#undef __inner_assume_bound_dec
#undef __inner_assume_validated
#undef __inner_assume_validated_dec
#undef __inner_blocksOn
#undef __inner_bound
#undef __inner_callback
#undef __inner_checkReturn
#undef __inner_compname_props
#undef __inner_control_entrypoint
#undef __inner_data_entrypoint
#undef __inner_data_source
#undef __inner_encoded
#undef __inner_nonvolatile
#undef __inner_out_validated
#undef __inner_override
#undef __inner_possibly_notnullterminated
#undef __inner_range
#undef __inner_success
#undef __inner_transfer
#undef __inner_typefix
#undef __inner_volatile
#undef __inout
#undef __inout_bcount
#undef __inout_bcount_full
#undef __inout_bcount_full_opt
#undef __inout_bcount_nz
#undef __inout_bcount_nz_opt
#undef __inout_bcount_opt
#undef __inout_bcount_part
#undef __inout_bcount_part_opt
#undef __inout_bcount_z
#undef __inout_bcount_z_opt
#undef __inout_ecount
#undef __inout_ecount_full
#undef __inout_ecount_full_opt
#undef __inout_ecount_nz
#undef __inout_ecount_nz_opt
#undef __inout_ecount_opt
#undef __inout_ecount_part
#undef __inout_ecount_part_opt
#undef __inout_ecount_z
#undef __inout_ecount_z_opt
#undef __inout_ecount_z_opt
#undef __inout_nz
#undef __inout_nz_opt
#undef __inout_opt
#undef __inout_xcount
#undef __inout_xcount_full
#undef __inout_xcount_full_opt
#undef __inout_xcount_opt
#undef __inout_xcount_part
#undef __inout_xcount_part_opt
#undef __inout_z
#undef __inout_z_opt
#undef __kernel_entry
#undef __maybenull
#undef __maybereadonly
#undef __maybevalid
#undef __range_max
#undef __range_min
#undef __nonvolatile
#undef __notnull
#undef __notreadonly
#undef __notvalid
#undef __null
#undef __nullnullterminated
#undef __nullterminated
#undef __out_awcount
#undef __out_bcount
#undef __out_bcount_full
#undef __out_bcount_full_opt
#undef __out_bcount_nz
#undef __out_bcount_nz_opt
#undef __out_bcount_opt
#undef __out_bcount_part
#undef __out_bcount_part_opt
#undef __out_bcount_z
#undef __out_bcount_z_opt
#undef __out_bound
#undef __out_data_source
#undef __out_ecount
#undef __out_ecount_full
#undef __out_ecount_full_opt
#undef __out_ecount_nz
#undef __out_ecount_nz_opt
#undef __out_ecount_opt
#undef __out_ecount_part
#undef __out_ecount_part_opt
#undef __out_ecount_z
#undef __out_ecount_z_opt
#undef __out_has_adt_prop
#undef __out_has_type_adt_props
#undef __out_not_has_adt_prop
#undef __out_nz
#undef __out_nz_opt
#undef __out_opt
#undef __out_range
#undef __out_transfer_adt_prop
#undef __out_validated
#undef __out_xcount
#undef __out_xcount_full
#undef __out_xcount_full_opt
#undef __out_xcount_opt
#undef __out_xcount_part
#undef __out_xcount_part_opt
#undef __out_z
#undef __override
#undef __possibly_notnullterminated
#undef __post
#undef __post_invalid
#undef __postcond
#undef __post_nullnullterminated
#undef __pre
#undef __precond
#undef __range
#undef __readableTo
#undef __readonly
#undef __refparam
#undef __clr_reserved
#undef __rpc_entry
#undef __source_code_content
#undef __struct_bcount
#undef __struct_xcount
#undef __success
#undef __this_out_data_source
#undef __this_out_validated
#undef __transfer
#undef __type_has_adt_prop
#undef __typefix
#undef __valid
#undef __volatile
#undef __writableTo
#undef __xcount
#undef __xcount_opt
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/*
*/
#ifndef PAL_STDCPP_COMPAT
#undef __in
#undef __out
#endif // !PAL_STDCPP_COMPAT
#undef _At_
#undef _Deref_out_
#undef _Deref_out_opt_
#undef _Deref_opt_out_
#undef _Deref_opt_out_opt_
#undef _Deref_post_cap_
#undef _Deref_post_opt_cap_
#undef _Deref_post_bytecap_
#undef _Deref_post_opt_bytecap_
#undef _Deref_post_count_
#undef _Deref_post_opt_count_
#undef _Deref_post_bytecount_
#undef _Deref_post_opt_bytecount_
#undef _In_count_
#undef _In_opt_count_
#undef _In_bytecount_
#undef _In_opt_bytecount_
#undef _Out_cap_
#undef _Out_opt_cap_
#undef _Out_bytecap_
#undef _Out_opt_bytecap_
#undef _Outptr_
#undef _Outptr_result_maybenull_
#undef _Outptr_opt_
#undef _Outptr_opt_result_maybenull_
#undef _Outptr_result_z_
#undef _Outptr_opt_result_z_
#undef _Outptr_result_maybenull_z_
#undef _Outptr_opt_result_maybenull_z_
#undef _Outptr_result_nullonfailure_
#undef _Outptr_opt_result_nullonfailure_
#undef _COM_Outptr_
#undef _COM_Outptr_result_maybenull_
#undef _COM_Outptr_opt_
#undef _COM_Outptr_opt_result_maybenull_
#undef _Outptr_result_buffer_
#undef _Outptr_opt_result_buffer_
#undef _Outptr_result_buffer_to_
#undef _Outptr_opt_result_buffer_to_
#undef _Outptr_result_buffer_all_
#undef _Outptr_opt_result_buffer_all_
#undef _Outptr_result_buffer_maybenull_
#undef _Outptr_opt_result_buffer_maybenull_
#undef _Outptr_result_buffer_to_maybenull_
#undef _Outptr_opt_result_buffer_to_maybenull_
#undef _Outptr_result_buffer_all_maybenull_
#undef _Outptr_opt_result_buffer_all_maybenull_
#undef _Outptr_result_bytebuffer_
#undef _Outptr_opt_result_bytebuffer_
#undef _Outptr_result_bytebuffer_to_
#undef _Outptr_opt_result_bytebuffer_to_
#undef _Outptr_result_bytebuffer_all_
#undef _Outptr_opt_result_bytebuffer_all_
#undef _Outptr_result_bytebuffer_maybenull_
#undef _Outptr_opt_result_bytebuffer_maybenull_
#undef _Outptr_result_bytebuffer_to_maybenull_
#undef _Outptr_opt_result_bytebuffer_to_maybenull_
#undef _Outptr_result_bytebuffer_all_maybenull_
#undef _Outptr_opt_result_bytebuffer_all_maybenull_
#undef _When_
#undef __allocator
#undef __analysis_assert
#undef __analysis_assume
#undef __analysis_assume_nullterminated
#undef __analysis_hint
#undef __assume_bound
#undef __assume_validated
#undef __bcount
#undef __bcount_opt
#undef __blocksOn
#undef __bound
#undef __byte_readableTo
#undef __byte_writableTo
#undef __callback
#undef __checkReturn
#undef __class_code_content
#undef __control_entrypoint
#undef __data_entrypoint
#undef __deallocate
#undef __deallocate_opt
#undef __deref
#undef __deref_bcount
#undef __deref_bcount_opt
#undef __deref_ecount
#undef __deref_ecount_opt
#undef __deref_in
#undef __deref_in_bcount
#undef __deref_in_bcount_opt
#undef __deref_in_ecount
#undef __deref_in_ecount_opt
#undef __deref_in_ecount_iterator
#undef __deref_in_opt
#undef __deref_in_opt_out
#undef __deref_in_range
#undef __deref_in_xcount
#undef __deref_in_xcount_opt
#undef __deref_inout
#undef __deref_inout_bcount
#undef __deref_inout_bcount_full
#undef __deref_inout_bcount_full_opt
#undef __deref_inout_bcount_nz
#undef __deref_inout_bcount_nz_opt
#undef __deref_inout_bcount_opt
#undef __deref_inout_bcount_part
#undef __deref_inout_bcount_part_opt
#undef __deref_inout_bcount_z
#undef __deref_inout_bcount_z_opt
#undef __deref_inout_ecount
#undef __deref_inout_ecount_full
#undef __deref_inout_ecount_full_opt
#undef __deref_inout_ecount_nz
#undef __deref_inout_ecount_nz_opt
#undef __deref_inout_ecount_opt
#undef __deref_inout_ecount_part
#undef __deref_inout_ecount_part_opt
#undef __deref_inout_ecount_z
#undef __deref_inout_ecount_z_opt
#undef __deref_inout_ecount_iterator
#undef __deref_inout_nz
#undef __deref_inout_nz_opt
#undef __deref_inout_opt
#undef __deref_inout_range
#undef __deref_inout_xcount
#undef __deref_inout_xcount_full
#undef __deref_inout_xcount_full_opt
#undef __deref_inout_xcount_opt
#undef __deref_inout_xcount_part
#undef __deref_inout_xcount_part_opt
#undef __deref_inout_z
#undef __deref_inout_z_opt
#undef __deref_nonvolatile
#undef __deref_opt_bcount
#undef __deref_opt_bcount_opt
#undef __deref_opt_ecount
#undef __deref_opt_ecount_opt
#undef __deref_opt_in
#undef __deref_opt_in_bcount
#undef __deref_opt_in_bcount_opt
#undef __deref_opt_in_ecount
#undef __deref_opt_in_ecount_opt
#undef __deref_opt_in_opt
#undef __deref_opt_in_xcount
#undef __deref_opt_in_xcount_opt
#undef __deref_opt_inout
#undef __deref_opt_inout_bcount
#undef __deref_opt_inout_bcount_full
#undef __deref_opt_inout_bcount_full_opt
#undef __deref_opt_inout_bcount_nz
#undef __deref_opt_inout_bcount_nz_opt
#undef __deref_opt_inout_bcount_opt
#undef __deref_opt_inout_bcount_part
#undef __deref_opt_inout_bcount_part_opt
#undef __deref_opt_inout_bcount_z
#undef __deref_opt_inout_bcount_z_opt
#undef __deref_opt_inout_ecount
#undef __deref_opt_inout_ecount_full
#undef __deref_opt_inout_ecount_full_opt
#undef __deref_opt_inout_ecount_nz
#undef __deref_opt_inout_ecount_nz_opt
#undef __deref_opt_inout_ecount_opt
#undef __deref_opt_inout_ecount_part
#undef __deref_opt_inout_ecount_part_opt
#undef __deref_opt_inout_ecount_z
#undef __deref_opt_inout_ecount_z_opt
#undef __deref_opt_inout_nz
#undef __deref_opt_inout_nz_opt
#undef __deref_opt_inout_opt
#undef __deref_opt_inout_xcount
#undef __deref_opt_inout_xcount_full
#undef __deref_opt_inout_xcount_full_opt
#undef __deref_opt_inout_xcount_opt
#undef __deref_opt_inout_xcount_part
#undef __deref_opt_inout_xcount_part_opt
#undef __deref_opt_inout_z
#undef __deref_opt_inout_z_opt
#undef __deref_opt_out
#undef __deref_opt_out_bcount
#undef __deref_opt_out_bcount_full
#undef __deref_opt_out_bcount_full_opt
#undef __deref_opt_out_bcount_nz_opt
#undef __deref_opt_out_bcount_opt
#undef __deref_opt_out_bcount_part
#undef __deref_opt_out_bcount_part_opt
#undef __deref_opt_out_bcount_z_opt
#undef __deref_opt_out_ecount
#undef __deref_opt_out_ecount_full
#undef __deref_opt_out_ecount_full_opt
#undef __deref_opt_out_ecount_nz_opt
#undef __deref_opt_out_ecount_opt
#undef __deref_opt_out_ecount_part
#undef __deref_opt_out_ecount_part_opt
#undef __deref_opt_out_ecount_z_opt
#undef __deref_opt_out_nz_opt
#undef __deref_opt_out_opt
#undef __deref_opt_out_xcount
#undef __deref_opt_out_xcount_full
#undef __deref_opt_out_xcount_full_opt
#undef __deref_opt_out_xcount_opt
#undef __deref_opt_out_xcount_part
#undef __deref_opt_out_xcount_part_opt
#undef __deref_opt_out_z_opt
#undef __deref_opt_xcount
#undef __deref_opt_xcount_opt
#undef __deref_out
#undef __deref_out_bcount
#undef __deref_out_bcount_full
#undef __deref_out_bcount_full_opt
#undef __deref_out_bcount_nz
#undef __deref_out_bcount_nz_opt
#undef __deref_out_bcount_opt
#undef __deref_out_bcount_part
#undef __deref_out_bcount_part_opt
#undef __deref_out_bcount_z
#undef __deref_out_bcount_z_opt
#undef __deref_out_bound
#undef __deref_out_ecount
#undef __deref_out_ecount_full
#undef __deref_out_ecount_full_opt
#undef __deref_out_ecount_iterator
#undef __deref_out_ecount_nz
#undef __deref_out_ecount_nz_opt
#undef __deref_out_ecount_opt
#undef __deref_out_ecount_part
#undef __deref_out_ecount_part_opt
#undef __deref_out_ecount_z
#undef __deref_out_ecount_z_opt
#undef __deref_out_nz
#undef __deref_out_nz_opt
#undef __deref_out_opt
#undef __deref_out_range
#undef __deref_out_range
#undef __deref_out_xcount
#undef __deref_out_xcount
#undef __deref_out_xcount_full
#undef __deref_out_xcount_full_opt
#undef __deref_out_xcount_opt
#undef __deref_out_xcount_part
#undef __deref_out_xcount_part_opt
#undef __deref_out_z
#undef __deref_out_z_opt
#undef __deref_realloc_bcount
#undef __deref_volatile
#undef __deref_xcount
#undef __deref_xcount_opt
#undef __ecount
#undef __ecount_opt
#undef __elem_readableTo
#undef __elem_writableTo
#undef __encoded_array
#undef __encoded_pointer
#undef __exceptthat
#undef __fallthrough
#undef __field_bcount
#undef __field_bcount_full
#undef __field_bcount_full_opt
#undef __field_bcount_opt
#undef __field_bcount_part
#undef __field_bcount_part_opt
#undef __field_data_source
#undef __field_ecount
#undef __field_ecount_full
#undef __field_ecount_full_opt
#undef __field_ecount_opt
#undef __field_ecount_part
#undef __field_ecount_part_opt
#undef __field_encoded_array
#undef __field_encoded_pointer
#undef __field_nullterminated
#undef __field_range
#undef __field_xcount
#undef __field_xcount_full
#undef __field_xcount_full_opt
#undef __field_xcount_opt
#undef __field_xcount_part
#undef __field_xcount_part_opt
#undef __file_parser
#undef __file_parser_class
#undef __file_parser_library
#undef __format_string
#undef __format_string
#undef __gdi_entry
#undef __in_awcount
#undef __in_bcount
#undef __in_bcount_nz
#undef __in_bcount_nz_opt
#undef __in_bcount_opt
#undef __in_bcount_z
#undef __in_bcount_z_opt
#undef __in_bound
#undef __in_data_source
#undef __in_ecount
#undef __in_ecount_nz
#undef __in_ecount_nz_opt
#undef __in_ecount_opt
#undef __in_ecount_z
#undef __in_ecount_z_opt
#undef __in_nz
#undef __in_nz_opt
#undef __in_opt
#undef __in_range
#undef __in_xcount
#undef __in_xcount_opt
#undef __in_z
#undef __in_z_opt
#undef __inexpressible_readableTo
#undef __inexpressible_writableTo
#undef __inner_adt_add_prop
#undef __inner_adt_prop
#undef __inner_adt_remove_prop
#undef __inner_adt_transfer_prop
#undef __inner_adt_type_props
#undef __inner_analysis_assume_nulltermianted_dec
#undef __inner_analysis_assume_nullterminated
#undef __inner_assume_bound
#undef __inner_assume_bound_dec
#undef __inner_assume_validated
#undef __inner_assume_validated_dec
#undef __inner_blocksOn
#undef __inner_bound
#undef __inner_callback
#undef __inner_checkReturn
#undef __inner_compname_props
#undef __inner_control_entrypoint
#undef __inner_data_entrypoint
#undef __inner_data_source
#undef __inner_encoded
#undef __inner_nonvolatile
#undef __inner_out_validated
#undef __inner_override
#undef __inner_possibly_notnullterminated
#undef __inner_range
#undef __inner_success
#undef __inner_transfer
#undef __inner_typefix
#undef __inner_volatile
#undef __inout
#undef __inout_bcount
#undef __inout_bcount_full
#undef __inout_bcount_full_opt
#undef __inout_bcount_nz
#undef __inout_bcount_nz_opt
#undef __inout_bcount_opt
#undef __inout_bcount_part
#undef __inout_bcount_part_opt
#undef __inout_bcount_z
#undef __inout_bcount_z_opt
#undef __inout_ecount
#undef __inout_ecount_full
#undef __inout_ecount_full_opt
#undef __inout_ecount_nz
#undef __inout_ecount_nz_opt
#undef __inout_ecount_opt
#undef __inout_ecount_part
#undef __inout_ecount_part_opt
#undef __inout_ecount_z
#undef __inout_ecount_z_opt
#undef __inout_ecount_z_opt
#undef __inout_nz
#undef __inout_nz_opt
#undef __inout_opt
#undef __inout_xcount
#undef __inout_xcount_full
#undef __inout_xcount_full_opt
#undef __inout_xcount_opt
#undef __inout_xcount_part
#undef __inout_xcount_part_opt
#undef __inout_z
#undef __inout_z_opt
#undef __kernel_entry
#undef __maybenull
#undef __maybereadonly
#undef __maybevalid
#undef __range_max
#undef __range_min
#undef __nonvolatile
#undef __notnull
#undef __notreadonly
#undef __notvalid
#undef __null
#undef __nullnullterminated
#undef __nullterminated
#undef __out_awcount
#undef __out_bcount
#undef __out_bcount_full
#undef __out_bcount_full_opt
#undef __out_bcount_nz
#undef __out_bcount_nz_opt
#undef __out_bcount_opt
#undef __out_bcount_part
#undef __out_bcount_part_opt
#undef __out_bcount_z
#undef __out_bcount_z_opt
#undef __out_bound
#undef __out_data_source
#undef __out_ecount
#undef __out_ecount_full
#undef __out_ecount_full_opt
#undef __out_ecount_nz
#undef __out_ecount_nz_opt
#undef __out_ecount_opt
#undef __out_ecount_part
#undef __out_ecount_part_opt
#undef __out_ecount_z
#undef __out_ecount_z_opt
#undef __out_has_adt_prop
#undef __out_has_type_adt_props
#undef __out_not_has_adt_prop
#undef __out_nz
#undef __out_nz_opt
#undef __out_opt
#undef __out_range
#undef __out_transfer_adt_prop
#undef __out_validated
#undef __out_xcount
#undef __out_xcount_full
#undef __out_xcount_full_opt
#undef __out_xcount_opt
#undef __out_xcount_part
#undef __out_xcount_part_opt
#undef __out_z
#undef __override
#undef __possibly_notnullterminated
#undef __post
#undef __post_invalid
#undef __postcond
#undef __post_nullnullterminated
#undef __pre
#undef __precond
#undef __range
#undef __readableTo
#undef __readonly
#undef __refparam
#undef __clr_reserved
#undef __rpc_entry
#undef __source_code_content
#undef __struct_bcount
#undef __struct_xcount
#undef __success
#undef __this_out_data_source
#undef __this_out_validated
#undef __transfer
#undef __type_has_adt_prop
#undef __typefix
#undef __valid
#undef __volatile
#undef __writableTo
#undef __xcount
#undef __xcount_opt
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/metadata/null-gc-handles.h | #ifndef __METADATA_NULL_GC_HANDLES_H__
#define __METADATA_NULL_GC_HANDLES_H__
void
null_gc_handles_init (void);
#endif /* __METADATA_NULL_GC_HANDLES_H__ */
| #ifndef __METADATA_NULL_GC_HANDLES_H__
#define __METADATA_NULL_GC_HANDLES_H__
void
null_gc_handles_init (void);
#endif /* __METADATA_NULL_GC_HANDLES_H__ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/jit/hostallocator.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
class HostAllocator final
{
private:
HostAllocator()
{
}
public:
template <typename T>
T* allocate(size_t count)
{
ClrSafeInt<size_t> safeElemSize(sizeof(T));
ClrSafeInt<size_t> safeCount(count);
ClrSafeInt<size_t> size = safeElemSize * safeCount;
if (size.IsOverflow())
{
return nullptr;
}
return static_cast<T*>(allocateHostMemory(size.Value()));
}
void deallocate(void* p)
{
freeHostMemory(p);
}
static HostAllocator getHostAllocator()
{
return HostAllocator();
}
private:
void* allocateHostMemory(size_t size);
void freeHostMemory(void* p);
};
// Global operator new overloads that work with HostAllocator
inline void* __cdecl operator new(size_t n, HostAllocator alloc)
{
return alloc.allocate<char>(n);
}
inline void* __cdecl operator new[](size_t n, HostAllocator alloc)
{
return alloc.allocate<char>(n);
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
class HostAllocator final
{
private:
HostAllocator()
{
}
public:
template <typename T>
T* allocate(size_t count)
{
ClrSafeInt<size_t> safeElemSize(sizeof(T));
ClrSafeInt<size_t> safeCount(count);
ClrSafeInt<size_t> size = safeElemSize * safeCount;
if (size.IsOverflow())
{
return nullptr;
}
return static_cast<T*>(allocateHostMemory(size.Value()));
}
void deallocate(void* p)
{
freeHostMemory(p);
}
static HostAllocator getHostAllocator()
{
return HostAllocator();
}
private:
void* allocateHostMemory(size_t size);
void freeHostMemory(void* p);
};
// Global operator new overloads that work with HostAllocator
inline void* __cdecl operator new(size_t n, HostAllocator alloc)
{
return alloc.allocate<char>(n);
}
inline void* __cdecl operator new[](size_t n, HostAllocator alloc)
{
return alloc.allocate<char>(n);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/zlib-intel/trees.h | /* header created automatically with -DGEN_TREES_H */
ZLIB_INTERNAL const ct_data static_ltree[L_CODES+2] = {
{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}},
{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}},
{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}},
{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}},
{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}},
{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}},
{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}},
{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}},
{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}},
{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}},
{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}},
{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}},
{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}},
{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}},
{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}},
{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}},
{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}},
{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}},
{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}},
{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}},
{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}},
{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}},
{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}},
{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}},
{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}},
{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}},
{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}},
{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}},
{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}},
{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}},
{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}},
{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}},
{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}},
{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}},
{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}},
{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}},
{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}},
{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}},
{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}},
{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}},
{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}},
{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}},
{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}},
{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}},
{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}},
{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}},
{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}},
{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}},
{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}},
{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}},
{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}},
{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}},
{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}},
{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}},
{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}},
{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}}
};
local const ct_data static_dtree[D_CODES] = {
{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
};
const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
};
const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
};
local const int base_length[LENGTH_CODES] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
64, 80, 96, 112, 128, 160, 192, 224, 0
};
local const int base_dist[D_CODES] = {
0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
};
| /* header created automatically with -DGEN_TREES_H */
ZLIB_INTERNAL const ct_data static_ltree[L_CODES+2] = {
{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}},
{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}},
{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}},
{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}},
{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}},
{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}},
{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}},
{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}},
{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}},
{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}},
{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}},
{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}},
{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}},
{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}},
{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}},
{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}},
{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}},
{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}},
{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}},
{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}},
{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}},
{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}},
{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}},
{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}},
{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}},
{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}},
{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}},
{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}},
{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}},
{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}},
{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}},
{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}},
{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}},
{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}},
{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}},
{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}},
{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}},
{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}},
{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}},
{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}},
{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}},
{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}},
{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}},
{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}},
{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}},
{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}},
{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}},
{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}},
{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}},
{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}},
{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}},
{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}},
{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}},
{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}},
{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}},
{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}}
};
local const ct_data static_dtree[D_CODES] = {
{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
};
const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
};
const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
};
local const int base_length[LENGTH_CODES] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
64, 80, 96, 112, 128, 160, 192, 224, 0
};
local const int base_dist[D_CODES] = {
0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
};
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/hppa/Gglobal.c | /* libunwind - a platform-independent unwind library
Copyright (c) 2004-2005 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
HIDDEN define_lock (hppa_lock);
HIDDEN atomic_bool tdep_init_done = 0;
HIDDEN void
tdep_init (void)
{
intrmask_t saved_mask;
sigfillset (&unwi_full_mask);
lock_acquire (&hppa_lock, saved_mask);
{
if (atomic_load(&tdep_init_done))
/* another thread else beat us to it... */
goto out;
mi_init ();
dwarf_init ();
#ifndef UNW_REMOTE_ONLY
hppa_local_addr_space_init ();
#endif
atomic_store(&tdep_init_done, 1); /* signal that we're initialized... */
}
out:
lock_release (&hppa_lock, saved_mask);
}
| /* libunwind - a platform-independent unwind library
Copyright (c) 2004-2005 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
HIDDEN define_lock (hppa_lock);
HIDDEN atomic_bool tdep_init_done = 0;
HIDDEN void
tdep_init (void)
{
intrmask_t saved_mask;
sigfillset (&unwi_full_mask);
lock_acquire (&hppa_lock, saved_mask);
{
if (atomic_load(&tdep_init_done))
/* another thread else beat us to it... */
goto out;
mi_init ();
dwarf_init ();
#ifndef UNW_REMOTE_ONLY
hppa_local_addr_space_init ();
#endif
atomic_store(&tdep_init_done, 1); /* signal that we're initialized... */
}
out:
lock_release (&hppa_lock, saved_mask);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/brotli/enc/command.h | /* Copyright 2013 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/* This class models a sequence of literals and a backward reference copy. */
#ifndef BROTLI_ENC_COMMAND_H_
#define BROTLI_ENC_COMMAND_H_
#include "../common/constants.h"
#include "../common/platform.h"
#include <brotli/types.h>
#include "./fast_log.h"
#include "./params.h"
#include "./prefix.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
BROTLI_INTERNAL extern const uint32_t
kBrotliInsBase[BROTLI_NUM_INS_COPY_CODES];
BROTLI_INTERNAL extern const uint32_t
kBrotliInsExtra[BROTLI_NUM_INS_COPY_CODES];
BROTLI_INTERNAL extern const uint32_t
kBrotliCopyBase[BROTLI_NUM_INS_COPY_CODES];
BROTLI_INTERNAL extern const uint32_t
kBrotliCopyExtra[BROTLI_NUM_INS_COPY_CODES];
static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
if (insertlen < 6) {
return (uint16_t)insertlen;
} else if (insertlen < 130) {
uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
} else if (insertlen < 2114) {
return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
} else if (insertlen < 6210) {
return 21u;
} else if (insertlen < 22594) {
return 22u;
} else {
return 23u;
}
}
static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
if (copylen < 10) {
return (uint16_t)(copylen - 2);
} else if (copylen < 134) {
uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
} else if (copylen < 2118) {
return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
} else {
return 23u;
}
}
static BROTLI_INLINE uint16_t CombineLengthCodes(
uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
uint16_t bits64 =
(uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3u));
if (use_last_distance && inscode < 8u && copycode < 16u) {
return (copycode < 8u) ? bits64 : (bits64 | 64u);
} else {
/* Specification: 5 Encoding of ... (last table) */
/* offset = 2 * index, where index is in range [0..8] */
uint32_t offset = 2u * ((copycode >> 3u) + 3u * (inscode >> 3u));
/* All values in specification are K * 64,
where K = [2, 3, 6, 4, 5, 8, 7, 9, 10],
i + 1 = [1, 2, 3, 4, 5, 6, 7, 8, 9],
K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1, 2] = D.
All values in D require only 2 bits to encode.
Magic constant is shifted 6 bits left, to avoid final multiplication. */
offset = (offset << 5u) + 0x40u + ((0x520D40u >> offset) & 0xC0u);
return (uint16_t)(offset | bits64);
}
}
static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
BROTLI_BOOL use_last_distance,
uint16_t* code) {
uint16_t inscode = GetInsertLengthCode(insertlen);
uint16_t copycode = GetCopyLengthCode(copylen);
*code = CombineLengthCodes(inscode, copycode, use_last_distance);
}
static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
return kBrotliInsBase[inscode];
}
static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
return kBrotliInsExtra[inscode];
}
static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
return kBrotliCopyBase[copycode];
}
static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
return kBrotliCopyExtra[copycode];
}
typedef struct Command {
uint32_t insert_len_;
/* Stores copy_len in low 25 bits and copy_code - copy_len in high 7 bit. */
uint32_t copy_len_;
/* Stores distance extra bits. */
uint32_t dist_extra_;
uint16_t cmd_prefix_;
/* Stores distance code in low 10 bits
and number of extra bits in high 6 bits. */
uint16_t dist_prefix_;
} Command;
/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
static BROTLI_INLINE void InitCommand(Command* self,
const BrotliDistanceParams* dist, size_t insertlen,
size_t copylen, int copylen_code_delta, size_t distance_code) {
/* Don't rely on signed int representation, use honest casts. */
uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
self->insert_len_ = (uint32_t)insertlen;
self->copy_len_ = (uint32_t)(copylen | (delta << 25));
/* The distance prefix and extra bits are stored in this Command as if
npostfix and ndirect were 0, they are only recomputed later after the
clustering if needed. */
PrefixEncodeCopyDistance(
distance_code, dist->num_direct_distance_codes,
dist->distance_postfix_bits, &self->dist_prefix_, &self->dist_extra_);
GetLengthCode(
insertlen, (size_t)((int)copylen + copylen_code_delta),
TO_BROTLI_BOOL((self->dist_prefix_ & 0x3FF) == 0), &self->cmd_prefix_);
}
static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
self->insert_len_ = (uint32_t)insertlen;
self->copy_len_ = 4 << 25;
self->dist_extra_ = 0;
self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
}
static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(
const Command* self, const BrotliDistanceParams* dist) {
if ((self->dist_prefix_ & 0x3FFu) <
BROTLI_NUM_DISTANCE_SHORT_CODES + dist->num_direct_distance_codes) {
return self->dist_prefix_ & 0x3FFu;
} else {
uint32_t dcode = self->dist_prefix_ & 0x3FFu;
uint32_t nbits = self->dist_prefix_ >> 10;
uint32_t extra = self->dist_extra_;
uint32_t postfix_mask = (1U << dist->distance_postfix_bits) - 1U;
uint32_t hcode = (dcode - dist->num_direct_distance_codes -
BROTLI_NUM_DISTANCE_SHORT_CODES) >>
dist->distance_postfix_bits;
uint32_t lcode = (dcode - dist->num_direct_distance_codes -
BROTLI_NUM_DISTANCE_SHORT_CODES) & postfix_mask;
uint32_t offset = ((2U + (hcode & 1U)) << nbits) - 4U;
return ((offset + extra) << dist->distance_postfix_bits) + lcode +
dist->num_direct_distance_codes + BROTLI_NUM_DISTANCE_SHORT_CODES;
}
}
static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
uint32_t r = self->cmd_prefix_ >> 6;
uint32_t c = self->cmd_prefix_ & 7;
if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
return c;
}
return 3;
}
static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
return self->copy_len_ & 0x1FFFFFF;
}
static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
uint32_t modifier = self->copy_len_ >> 25;
int32_t delta = (int8_t)((uint8_t)(modifier | ((modifier & 0x40) << 1)));
return (uint32_t)((int32_t)(self->copy_len_ & 0x1FFFFFF) + delta);
}
#if defined(__cplusplus) || defined(c_plusplus)
} /* extern "C" */
#endif
#endif /* BROTLI_ENC_COMMAND_H_ */
| /* Copyright 2013 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/* This class models a sequence of literals and a backward reference copy. */
#ifndef BROTLI_ENC_COMMAND_H_
#define BROTLI_ENC_COMMAND_H_
#include "../common/constants.h"
#include "../common/platform.h"
#include <brotli/types.h>
#include "./fast_log.h"
#include "./params.h"
#include "./prefix.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
BROTLI_INTERNAL extern const uint32_t
kBrotliInsBase[BROTLI_NUM_INS_COPY_CODES];
BROTLI_INTERNAL extern const uint32_t
kBrotliInsExtra[BROTLI_NUM_INS_COPY_CODES];
BROTLI_INTERNAL extern const uint32_t
kBrotliCopyBase[BROTLI_NUM_INS_COPY_CODES];
BROTLI_INTERNAL extern const uint32_t
kBrotliCopyExtra[BROTLI_NUM_INS_COPY_CODES];
static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
if (insertlen < 6) {
return (uint16_t)insertlen;
} else if (insertlen < 130) {
uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
} else if (insertlen < 2114) {
return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
} else if (insertlen < 6210) {
return 21u;
} else if (insertlen < 22594) {
return 22u;
} else {
return 23u;
}
}
static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
if (copylen < 10) {
return (uint16_t)(copylen - 2);
} else if (copylen < 134) {
uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
} else if (copylen < 2118) {
return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
} else {
return 23u;
}
}
static BROTLI_INLINE uint16_t CombineLengthCodes(
uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
uint16_t bits64 =
(uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3u));
if (use_last_distance && inscode < 8u && copycode < 16u) {
return (copycode < 8u) ? bits64 : (bits64 | 64u);
} else {
/* Specification: 5 Encoding of ... (last table) */
/* offset = 2 * index, where index is in range [0..8] */
uint32_t offset = 2u * ((copycode >> 3u) + 3u * (inscode >> 3u));
/* All values in specification are K * 64,
where K = [2, 3, 6, 4, 5, 8, 7, 9, 10],
i + 1 = [1, 2, 3, 4, 5, 6, 7, 8, 9],
K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1, 2] = D.
All values in D require only 2 bits to encode.
Magic constant is shifted 6 bits left, to avoid final multiplication. */
offset = (offset << 5u) + 0x40u + ((0x520D40u >> offset) & 0xC0u);
return (uint16_t)(offset | bits64);
}
}
static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
BROTLI_BOOL use_last_distance,
uint16_t* code) {
uint16_t inscode = GetInsertLengthCode(insertlen);
uint16_t copycode = GetCopyLengthCode(copylen);
*code = CombineLengthCodes(inscode, copycode, use_last_distance);
}
static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
return kBrotliInsBase[inscode];
}
static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
return kBrotliInsExtra[inscode];
}
static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
return kBrotliCopyBase[copycode];
}
static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
return kBrotliCopyExtra[copycode];
}
typedef struct Command {
uint32_t insert_len_;
/* Stores copy_len in low 25 bits and copy_code - copy_len in high 7 bit. */
uint32_t copy_len_;
/* Stores distance extra bits. */
uint32_t dist_extra_;
uint16_t cmd_prefix_;
/* Stores distance code in low 10 bits
and number of extra bits in high 6 bits. */
uint16_t dist_prefix_;
} Command;
/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
static BROTLI_INLINE void InitCommand(Command* self,
const BrotliDistanceParams* dist, size_t insertlen,
size_t copylen, int copylen_code_delta, size_t distance_code) {
/* Don't rely on signed int representation, use honest casts. */
uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
self->insert_len_ = (uint32_t)insertlen;
self->copy_len_ = (uint32_t)(copylen | (delta << 25));
/* The distance prefix and extra bits are stored in this Command as if
npostfix and ndirect were 0, they are only recomputed later after the
clustering if needed. */
PrefixEncodeCopyDistance(
distance_code, dist->num_direct_distance_codes,
dist->distance_postfix_bits, &self->dist_prefix_, &self->dist_extra_);
GetLengthCode(
insertlen, (size_t)((int)copylen + copylen_code_delta),
TO_BROTLI_BOOL((self->dist_prefix_ & 0x3FF) == 0), &self->cmd_prefix_);
}
static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
self->insert_len_ = (uint32_t)insertlen;
self->copy_len_ = 4 << 25;
self->dist_extra_ = 0;
self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
}
static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(
const Command* self, const BrotliDistanceParams* dist) {
if ((self->dist_prefix_ & 0x3FFu) <
BROTLI_NUM_DISTANCE_SHORT_CODES + dist->num_direct_distance_codes) {
return self->dist_prefix_ & 0x3FFu;
} else {
uint32_t dcode = self->dist_prefix_ & 0x3FFu;
uint32_t nbits = self->dist_prefix_ >> 10;
uint32_t extra = self->dist_extra_;
uint32_t postfix_mask = (1U << dist->distance_postfix_bits) - 1U;
uint32_t hcode = (dcode - dist->num_direct_distance_codes -
BROTLI_NUM_DISTANCE_SHORT_CODES) >>
dist->distance_postfix_bits;
uint32_t lcode = (dcode - dist->num_direct_distance_codes -
BROTLI_NUM_DISTANCE_SHORT_CODES) & postfix_mask;
uint32_t offset = ((2U + (hcode & 1U)) << nbits) - 4U;
return ((offset + extra) << dist->distance_postfix_bits) + lcode +
dist->num_direct_distance_codes + BROTLI_NUM_DISTANCE_SHORT_CODES;
}
}
static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
uint32_t r = self->cmd_prefix_ >> 6;
uint32_t c = self->cmd_prefix_ & 7;
if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
return c;
}
return 3;
}
static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
return self->copy_len_ & 0x1FFFFFF;
}
static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
uint32_t modifier = self->copy_len_ >> 25;
int32_t delta = (int8_t)((uint8_t)(modifier | ((modifier & 0x40) << 1)));
return (uint32_t)((int32_t)(self->copy_len_ & 0x1FFFFFF) + delta);
}
#if defined(__cplusplus) || defined(c_plusplus)
} /* extern "C" */
#endif
#endif /* BROTLI_ENC_COMMAND_H_ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/metadata/opcodes.c | /**
* \file
* CIL instruction information
*
* Author:
* Paolo Molaro ([email protected])
*
* Copyright 2002-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <mono/metadata/opcodes.h>
#include <stddef.h> /* for NULL */
#include <config.h>
#define MONO_PREFIX1_OFFSET MONO_CEE_ARGLIST
#define MONO_CUSTOM_PREFIX_OFFSET MONO_CEE_MONO_ICALL
#define OPDEF(a,b,c,d,e,f,g,h,i,j) \
{ Mono ## e, MONO_FLOW_ ## j, MONO_ ## a },
const MonoOpcode
mono_opcodes [MONO_CEE_LAST + 1] = {
#include "mono/cil/opcode.def"
{0}
};
#undef OPDEF
// This, instead of an array of pointers, to optimize away a pointer and a relocation per string.
#define MSGSTRFIELD(line) MSGSTRFIELD1(line)
#define MSGSTRFIELD1(line) str##line
static const struct msgstr_t {
#define OPDEF(a,b,c,d,e,f,g,h,i,j) char MSGSTRFIELD(__LINE__) [sizeof (b)];
#include "mono/cil/opcode.def"
#undef OPDEF
} opstr = {
#define OPDEF(a,b,c,d,e,f,g,h,i,j) b,
#include "mono/cil/opcode.def"
#undef OPDEF
};
static const int16_t opidx [] = {
#define OPDEF(a,b,c,d,e,f,g,h,i,j) offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
#include "mono/cil/opcode.def"
#undef OPDEF
};
/**
* mono_opcode_name:
*/
const char*
mono_opcode_name (int opcode)
{
return (const char*)&opstr + opidx [opcode];
}
MonoOpcodeEnum
mono_opcode_value (const mono_byte **ip, const mono_byte *end)
{
MonoOpcodeEnum res;
const mono_byte *p = *ip;
if (p >= end)
return MonoOpcodeEnum_Invalid;
if (*p == 0xfe) {
++p;
if (p >= end)
return MonoOpcodeEnum_Invalid;
res = (MonoOpcodeEnum)(*p + MONO_PREFIX1_OFFSET);
} else if (*p == MONO_CUSTOM_PREFIX) {
++p;
if (p >= end)
return MonoOpcodeEnum_Invalid;
res = (MonoOpcodeEnum)(*p + MONO_CUSTOM_PREFIX_OFFSET);
} else {
res = (MonoOpcodeEnum)*p;
}
*ip = p;
return res;
}
| /**
* \file
* CIL instruction information
*
* Author:
* Paolo Molaro ([email protected])
*
* Copyright 2002-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <mono/metadata/opcodes.h>
#include <stddef.h> /* for NULL */
#include <config.h>
#define MONO_PREFIX1_OFFSET MONO_CEE_ARGLIST
#define MONO_CUSTOM_PREFIX_OFFSET MONO_CEE_MONO_ICALL
#define OPDEF(a,b,c,d,e,f,g,h,i,j) \
{ Mono ## e, MONO_FLOW_ ## j, MONO_ ## a },
const MonoOpcode
mono_opcodes [MONO_CEE_LAST + 1] = {
#include "mono/cil/opcode.def"
{0}
};
#undef OPDEF
// This, instead of an array of pointers, to optimize away a pointer and a relocation per string.
#define MSGSTRFIELD(line) MSGSTRFIELD1(line)
#define MSGSTRFIELD1(line) str##line
static const struct msgstr_t {
#define OPDEF(a,b,c,d,e,f,g,h,i,j) char MSGSTRFIELD(__LINE__) [sizeof (b)];
#include "mono/cil/opcode.def"
#undef OPDEF
} opstr = {
#define OPDEF(a,b,c,d,e,f,g,h,i,j) b,
#include "mono/cil/opcode.def"
#undef OPDEF
};
static const int16_t opidx [] = {
#define OPDEF(a,b,c,d,e,f,g,h,i,j) offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
#include "mono/cil/opcode.def"
#undef OPDEF
};
/**
* mono_opcode_name:
*/
const char*
mono_opcode_name (int opcode)
{
return (const char*)&opstr + opidx [opcode];
}
MonoOpcodeEnum
mono_opcode_value (const mono_byte **ip, const mono_byte *end)
{
MonoOpcodeEnum res;
const mono_byte *p = *ip;
if (p >= end)
return MonoOpcodeEnum_Invalid;
if (*p == 0xfe) {
++p;
if (p >= end)
return MonoOpcodeEnum_Invalid;
res = (MonoOpcodeEnum)(*p + MONO_PREFIX1_OFFSET);
} else if (*p == MONO_CUSTOM_PREFIX) {
++p;
if (p >= end)
return MonoOpcodeEnum_Invalid;
res = (MonoOpcodeEnum)(*p + MONO_CUSTOM_PREFIX_OFFSET);
} else {
res = (MonoOpcodeEnum)*p;
}
*ip = p;
return res;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/Interop/COM/NativeClients/Dispatch/ClientTests.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include <xplatform.h>
#include <cassert>
#include <Server.Contracts.h>
#define COM_CLIENT
#include <Servers.h>
#define THROW_IF_FAILED(exp) { hr = exp; if (FAILED(hr)) { ::printf("FAILURE: 0x%08x = %s\n", hr, #exp); throw hr; } }
#define THROW_FAIL_IF_FALSE(exp) { if (!(exp)) { ::printf("FALSE: %s\n", #exp); throw E_FAIL; } }
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include <xplatform.h>
#include <cassert>
#include <Server.Contracts.h>
#define COM_CLIENT
#include <Servers.h>
#define THROW_IF_FAILED(exp) { hr = exp; if (FAILED(hr)) { ::printf("FAILURE: 0x%08x = %s\n", hr, #exp); throw hr; } }
#define THROW_FAIL_IF_FALSE(exp) { if (!(exp)) { ::printf("FALSE: %s\n", #exp); throw E_FAIL; } }
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/Interop/COM/Dynamic/Server/CollectionTest.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include <Contract.h>
#include "DispatchImpl.h"
#include <vector>
class CollectionTest : public DispatchImpl, public ICollectionTest
{
public:
CollectionTest()
: DispatchImpl(IID_ICollectionTest, static_cast<ICollectionTest *>(this))
, _dispatchCollection { nullptr }
{ }
~CollectionTest()
{
Clear();
if (_dispatchCollection != nullptr)
_dispatchCollection->Release();
}
public: // ICollectionTest
HRESULT STDMETHODCALLTYPE get_Count(
/* [retval][out] */ LONG *ret);
HRESULT STDMETHODCALLTYPE get_Item(
/* [in] */ ULONG index,
/* [retval][out] */ BSTR *ret);
HRESULT STDMETHODCALLTYPE put_Item(
/* [in] */ ULONG index,
/* [in] */ BSTR val);
HRESULT STDMETHODCALLTYPE get__NewEnum(
/* [retval][out] */ IUnknown **retval);
HRESULT STDMETHODCALLTYPE Add(
/* [in] */ BSTR val);
HRESULT STDMETHODCALLTYPE Remove(
/* [in] */ ULONG index);
HRESULT STDMETHODCALLTYPE Clear();
HRESULT STDMETHODCALLTYPE Array_PlusOne_InOut(
/* [out][in] */ SAFEARRAY **ret);
HRESULT STDMETHODCALLTYPE Array_PlusOne_Ret(
/* [in] */ SAFEARRAY *val,
/* [retval][out] */ SAFEARRAY **ret);
HRESULT STDMETHODCALLTYPE ArrayVariant_PlusOne_InOut(
/* [out][in] */ VARIANT *ret);
HRESULT STDMETHODCALLTYPE ArrayVariant_PlusOne_Ret(
/* [in] */ VARIANT val,
/* [retval][out] */ VARIANT *ret);
HRESULT STDMETHODCALLTYPE GetDispatchCollection(
/* [retval][out] */ IDispatchCollection **ret);
public: // IDispatch
DEFINE_DISPATCH();
public: // IUnknown
HRESULT STDMETHODCALLTYPE QueryInterface(
/* [in] */ REFIID riid,
/* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
{
return DoQueryInterface(riid, ppvObject,
static_cast<IDispatch *>(this),
static_cast<ICollectionTest *>(this));
}
DEFINE_REF_COUNTING();
private:
std::vector<BSTR> _strings;
IDispatchCollection *_dispatchCollection;
};
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include <Contract.h>
#include "DispatchImpl.h"
#include <vector>
class CollectionTest : public DispatchImpl, public ICollectionTest
{
public:
CollectionTest()
: DispatchImpl(IID_ICollectionTest, static_cast<ICollectionTest *>(this))
, _dispatchCollection { nullptr }
{ }
~CollectionTest()
{
Clear();
if (_dispatchCollection != nullptr)
_dispatchCollection->Release();
}
public: // ICollectionTest
HRESULT STDMETHODCALLTYPE get_Count(
/* [retval][out] */ LONG *ret);
HRESULT STDMETHODCALLTYPE get_Item(
/* [in] */ ULONG index,
/* [retval][out] */ BSTR *ret);
HRESULT STDMETHODCALLTYPE put_Item(
/* [in] */ ULONG index,
/* [in] */ BSTR val);
HRESULT STDMETHODCALLTYPE get__NewEnum(
/* [retval][out] */ IUnknown **retval);
HRESULT STDMETHODCALLTYPE Add(
/* [in] */ BSTR val);
HRESULT STDMETHODCALLTYPE Remove(
/* [in] */ ULONG index);
HRESULT STDMETHODCALLTYPE Clear();
HRESULT STDMETHODCALLTYPE Array_PlusOne_InOut(
/* [out][in] */ SAFEARRAY **ret);
HRESULT STDMETHODCALLTYPE Array_PlusOne_Ret(
/* [in] */ SAFEARRAY *val,
/* [retval][out] */ SAFEARRAY **ret);
HRESULT STDMETHODCALLTYPE ArrayVariant_PlusOne_InOut(
/* [out][in] */ VARIANT *ret);
HRESULT STDMETHODCALLTYPE ArrayVariant_PlusOne_Ret(
/* [in] */ VARIANT val,
/* [retval][out] */ VARIANT *ret);
HRESULT STDMETHODCALLTYPE GetDispatchCollection(
/* [retval][out] */ IDispatchCollection **ret);
public: // IDispatch
DEFINE_DISPATCH();
public: // IUnknown
HRESULT STDMETHODCALLTYPE QueryInterface(
/* [in] */ REFIID riid,
/* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
{
return DoQueryInterface(riid, ppvObject,
static_cast<IDispatch *>(this),
static_cast<ICollectionTest *>(this));
}
DEFINE_REF_COUNTING();
private:
std::vector<BSTR> _strings;
IDispatchCollection *_dispatchCollection;
};
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/tools/superpmi/superpmi-shared/crlwmlist.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//----------------------------------------------------------
// crlwmlist.h - List of all LightWeightMap in CompileResult.
// To use, #define LWM(map, key, value) to something.
// If you need to distinguish DenseLightWeightMap, #define DENSELWM(map, value) as well.
//----------------------------------------------------------
#ifndef LWM
#error Define LWM before including this file.
#endif
// If the key is needed, then DENSELWM must be defined.
#ifndef DENSELWM
#define DENSELWM(map, value) LWM(map, this_is_an_error, value)
#endif
LWM(AddressMap, DWORDLONG, Agnostic_AddressMap)
LWM(AllocGCInfo, DWORD, Agnostic_AllocGCInfo)
LWM(AllocMem, DWORD, Agnostic_AllocMemDetails)
DENSELWM(AllocUnwindInfo, Agnostic_AllocUnwindInfo)
DENSELWM(AssertLog, DWORD)
DENSELWM(CallLog, DWORD)
DENSELWM(ClassMustBeLoadedBeforeCodeIsRun, DWORDLONG)
LWM(CompileMethod, DWORD, Agnostic_CompileMethodResults)
DENSELWM(MessageLog, DWORD)
DENSELWM(MethodMustBeLoadedBeforeCodeIsRun, DWORDLONG)
DENSELWM(ProcessName, DWORD)
LWM(RecordCallSiteWithSignature, DWORD, Agnostic_RecordCallSite)
LWM(RecordCallSiteWithoutSignature, DWORD, DWORDLONG)
DENSELWM(RecordRelocation, Agnostic_RecordRelocation)
DENSELWM(ReportFatalError, DWORD)
DENSELWM(ReportInliningDecision, Agnostic_ReportInliningDecision)
DENSELWM(ReportTailCallDecision, Agnostic_ReportTailCallDecision)
DENSELWM(ReserveUnwindInfo, Agnostic_ReserveUnwindInfo)
LWM(SetBoundaries, DWORD, Agnostic_SetBoundaries)
LWM(SetEHcount, DWORD, DWORD)
LWM(SetEHinfo, DWORD, Agnostic_CORINFO_EH_CLAUSE)
LWM(SetMethodAttribs, DWORDLONG, DWORD)
LWM(SetVars, DWORD, Agnostic_SetVars)
LWM(SetPatchpointInfo, DWORD, Agnostic_SetPatchpointInfo)
DENSELWM(CrSigInstHandleMap, DWORDLONG)
#undef LWM
#undef DENSELWM
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//----------------------------------------------------------
// crlwmlist.h - List of all LightWeightMap in CompileResult.
// To use, #define LWM(map, key, value) to something.
// If you need to distinguish DenseLightWeightMap, #define DENSELWM(map, value) as well.
//----------------------------------------------------------
#ifndef LWM
#error Define LWM before including this file.
#endif
// If the key is needed, then DENSELWM must be defined.
#ifndef DENSELWM
#define DENSELWM(map, value) LWM(map, this_is_an_error, value)
#endif
LWM(AddressMap, DWORDLONG, Agnostic_AddressMap)
LWM(AllocGCInfo, DWORD, Agnostic_AllocGCInfo)
LWM(AllocMem, DWORD, Agnostic_AllocMemDetails)
DENSELWM(AllocUnwindInfo, Agnostic_AllocUnwindInfo)
DENSELWM(AssertLog, DWORD)
DENSELWM(CallLog, DWORD)
DENSELWM(ClassMustBeLoadedBeforeCodeIsRun, DWORDLONG)
LWM(CompileMethod, DWORD, Agnostic_CompileMethodResults)
DENSELWM(MessageLog, DWORD)
DENSELWM(MethodMustBeLoadedBeforeCodeIsRun, DWORDLONG)
DENSELWM(ProcessName, DWORD)
LWM(RecordCallSiteWithSignature, DWORD, Agnostic_RecordCallSite)
LWM(RecordCallSiteWithoutSignature, DWORD, DWORDLONG)
DENSELWM(RecordRelocation, Agnostic_RecordRelocation)
DENSELWM(ReportFatalError, DWORD)
DENSELWM(ReportInliningDecision, Agnostic_ReportInliningDecision)
DENSELWM(ReportTailCallDecision, Agnostic_ReportTailCallDecision)
DENSELWM(ReserveUnwindInfo, Agnostic_ReserveUnwindInfo)
LWM(SetBoundaries, DWORD, Agnostic_SetBoundaries)
LWM(SetEHcount, DWORD, DWORD)
LWM(SetEHinfo, DWORD, Agnostic_CORINFO_EH_CLAUSE)
LWM(SetMethodAttribs, DWORDLONG, DWORD)
LWM(SetVars, DWORD, Agnostic_SetVars)
LWM(SetPatchpointInfo, DWORD, Agnostic_SetPatchpointInfo)
DENSELWM(CrSigInstHandleMap, DWORDLONG)
#undef LWM
#undef DENSELWM
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/nativelibrarynative.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// File: NativeLibraryNative.h
//
//
// QCall's for the NativeLibrary class
//
#ifndef __NATIVELIBRARYNATIVE_H__
#define __NATIVELIBRARYNATIVE_H__
extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadFromPath(LPCWSTR path, BOOL throwOnError);
extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly,
BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag,
BOOL throwOnError);
extern "C" void QCALLTYPE NativeLibrary_FreeLib(INT_PTR handle);
extern "C" INT_PTR QCALLTYPE NativeLibrary_GetSymbol(INT_PTR handle, LPCWSTR symbolName, BOOL throwOnError);
#endif // __NATIVELIBRARYNATIVE_H__
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// File: NativeLibraryNative.h
//
//
// QCall's for the NativeLibrary class
//
#ifndef __NATIVELIBRARYNATIVE_H__
#define __NATIVELIBRARYNATIVE_H__
extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadFromPath(LPCWSTR path, BOOL throwOnError);
extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly,
BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag,
BOOL throwOnError);
extern "C" void QCALLTYPE NativeLibrary_FreeLib(INT_PTR handle);
extern "C" INT_PTR QCALLTYPE NativeLibrary_GetSymbol(INT_PTR handle, LPCWSTR symbolName, BOOL throwOnError);
#endif // __NATIVELIBRARYNATIVE_H__
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/prebuilt/inc/clrinternal.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 8.00.0603 */
/* @@MIDL_FILE_HEADING( ) */
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __clrinternal_h__
#define __clrinternal_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __IPrivateManagedExceptionReporting_FWD_DEFINED__
#define __IPrivateManagedExceptionReporting_FWD_DEFINED__
typedef interface IPrivateManagedExceptionReporting IPrivateManagedExceptionReporting;
#endif /* __IPrivateManagedExceptionReporting_FWD_DEFINED__ */
/* header files for imported files */
#include "unknwn.h"
#include "mscoree.h"
#ifdef __cplusplus
extern "C"{
#endif
/* interface __MIDL_itf_clrinternal_0000_0000 */
/* [local] */
EXTERN_GUID(CLR_ID_V4_DESKTOP, 0x267f3989, 0xd786, 0x4b9a, 0x9a, 0xf6, 0xd1, 0x9e, 0x42, 0xd5, 0x57, 0xec);
EXTERN_GUID(CLR_ID_CORECLR, 0x8CB8E075, 0x0A91, 0x408E, 0x92, 0x28, 0xD6, 0x6E, 0x00, 0xA3, 0xBF, 0xF6 );
EXTERN_GUID(CLR_ID_PHONE_CLR, 0xE7237E9C, 0x31C0, 0x488C, 0xAD, 0x48, 0x32, 0x4D, 0x3E, 0x7E, 0xD9, 0x2A);
EXTERN_GUID(CLR_ID_ONECORE_CLR, 0xb1ee760d, 0x6c4a, 0x4533, 0xba, 0x41, 0x6f, 0x4f, 0x66, 0x1f, 0xab, 0xaf);
EXTERN_GUID(IID_IPrivateManagedExceptionReporting, 0xad76a023, 0x332d, 0x4298, 0x80, 0x01, 0x07, 0xaa, 0x93, 0x50, 0xdc, 0xa4);
typedef void *CRITSEC_COOKIE;
typedef /* [public] */
enum __MIDL___MIDL_itf_clrinternal_0000_0000_0001
{
CRST_DEFAULT = 0,
CRST_REENTRANCY = 0x1,
CRST_UNSAFE_SAMELEVEL = 0x2,
CRST_UNSAFE_COOPGC = 0x4,
CRST_UNSAFE_ANYMODE = 0x8,
CRST_DEBUGGER_THREAD = 0x10,
CRST_HOST_BREAKABLE = 0x20,
CRST_TAKEN_DURING_SHUTDOWN = 0x80,
CRST_GC_NOTRIGGER_WHEN_TAKEN = 0x100,
CRST_DEBUG_ONLY_CHECK_FORBID_SUSPEND_THREAD = 0x200
} CrstFlags;
extern RPC_IF_HANDLE __MIDL_itf_clrinternal_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_clrinternal_0000_0000_v0_0_s_ifspec;
#ifndef __IPrivateManagedExceptionReporting_INTERFACE_DEFINED__
#define __IPrivateManagedExceptionReporting_INTERFACE_DEFINED__
/* interface IPrivateManagedExceptionReporting */
/* [object][local][unique][helpstring][uuid] */
EXTERN_C const IID IID_IPrivateManagedExceptionReporting;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("AD76A023-332D-4298-8001-07AA9350DCA4")
IPrivateManagedExceptionReporting : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetBucketParametersForCurrentException(
/* [out] */ BucketParameters *pParams) = 0;
};
#else /* C style interface */
typedef struct IPrivateManagedExceptionReportingVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IPrivateManagedExceptionReporting * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IPrivateManagedExceptionReporting * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IPrivateManagedExceptionReporting * This);
HRESULT ( STDMETHODCALLTYPE *GetBucketParametersForCurrentException )(
IPrivateManagedExceptionReporting * This,
/* [out] */ BucketParameters *pParams);
END_INTERFACE
} IPrivateManagedExceptionReportingVtbl;
interface IPrivateManagedExceptionReporting
{
CONST_VTBL struct IPrivateManagedExceptionReportingVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IPrivateManagedExceptionReporting_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IPrivateManagedExceptionReporting_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IPrivateManagedExceptionReporting_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IPrivateManagedExceptionReporting_GetBucketParametersForCurrentException(This,pParams) \
( (This)->lpVtbl -> GetBucketParametersForCurrentException(This,pParams) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IPrivateManagedExceptionReporting_INTERFACE_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 8.00.0603 */
/* @@MIDL_FILE_HEADING( ) */
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif /*COM_NO_WINDOWS_H*/
#ifndef __clrinternal_h__
#define __clrinternal_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __IPrivateManagedExceptionReporting_FWD_DEFINED__
#define __IPrivateManagedExceptionReporting_FWD_DEFINED__
typedef interface IPrivateManagedExceptionReporting IPrivateManagedExceptionReporting;
#endif /* __IPrivateManagedExceptionReporting_FWD_DEFINED__ */
/* header files for imported files */
#include "unknwn.h"
#include "mscoree.h"
#ifdef __cplusplus
extern "C"{
#endif
/* interface __MIDL_itf_clrinternal_0000_0000 */
/* [local] */
EXTERN_GUID(CLR_ID_V4_DESKTOP, 0x267f3989, 0xd786, 0x4b9a, 0x9a, 0xf6, 0xd1, 0x9e, 0x42, 0xd5, 0x57, 0xec);
EXTERN_GUID(CLR_ID_CORECLR, 0x8CB8E075, 0x0A91, 0x408E, 0x92, 0x28, 0xD6, 0x6E, 0x00, 0xA3, 0xBF, 0xF6 );
EXTERN_GUID(CLR_ID_PHONE_CLR, 0xE7237E9C, 0x31C0, 0x488C, 0xAD, 0x48, 0x32, 0x4D, 0x3E, 0x7E, 0xD9, 0x2A);
EXTERN_GUID(CLR_ID_ONECORE_CLR, 0xb1ee760d, 0x6c4a, 0x4533, 0xba, 0x41, 0x6f, 0x4f, 0x66, 0x1f, 0xab, 0xaf);
EXTERN_GUID(IID_IPrivateManagedExceptionReporting, 0xad76a023, 0x332d, 0x4298, 0x80, 0x01, 0x07, 0xaa, 0x93, 0x50, 0xdc, 0xa4);
typedef void *CRITSEC_COOKIE;
typedef /* [public] */
enum __MIDL___MIDL_itf_clrinternal_0000_0000_0001
{
CRST_DEFAULT = 0,
CRST_REENTRANCY = 0x1,
CRST_UNSAFE_SAMELEVEL = 0x2,
CRST_UNSAFE_COOPGC = 0x4,
CRST_UNSAFE_ANYMODE = 0x8,
CRST_DEBUGGER_THREAD = 0x10,
CRST_HOST_BREAKABLE = 0x20,
CRST_TAKEN_DURING_SHUTDOWN = 0x80,
CRST_GC_NOTRIGGER_WHEN_TAKEN = 0x100,
CRST_DEBUG_ONLY_CHECK_FORBID_SUSPEND_THREAD = 0x200
} CrstFlags;
extern RPC_IF_HANDLE __MIDL_itf_clrinternal_0000_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_clrinternal_0000_0000_v0_0_s_ifspec;
#ifndef __IPrivateManagedExceptionReporting_INTERFACE_DEFINED__
#define __IPrivateManagedExceptionReporting_INTERFACE_DEFINED__
/* interface IPrivateManagedExceptionReporting */
/* [object][local][unique][helpstring][uuid] */
EXTERN_C const IID IID_IPrivateManagedExceptionReporting;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("AD76A023-332D-4298-8001-07AA9350DCA4")
IPrivateManagedExceptionReporting : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetBucketParametersForCurrentException(
/* [out] */ BucketParameters *pParams) = 0;
};
#else /* C style interface */
typedef struct IPrivateManagedExceptionReportingVtbl
{
BEGIN_INTERFACE
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IPrivateManagedExceptionReporting * This,
/* [in] */ REFIID riid,
/* [annotation][iid_is][out] */
_COM_Outptr_ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IPrivateManagedExceptionReporting * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IPrivateManagedExceptionReporting * This);
HRESULT ( STDMETHODCALLTYPE *GetBucketParametersForCurrentException )(
IPrivateManagedExceptionReporting * This,
/* [out] */ BucketParameters *pParams);
END_INTERFACE
} IPrivateManagedExceptionReportingVtbl;
interface IPrivateManagedExceptionReporting
{
CONST_VTBL struct IPrivateManagedExceptionReportingVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define IPrivateManagedExceptionReporting_QueryInterface(This,riid,ppvObject) \
( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) )
#define IPrivateManagedExceptionReporting_AddRef(This) \
( (This)->lpVtbl -> AddRef(This) )
#define IPrivateManagedExceptionReporting_Release(This) \
( (This)->lpVtbl -> Release(This) )
#define IPrivateManagedExceptionReporting_GetBucketParametersForCurrentException(This,pParams) \
( (This)->lpVtbl -> GetBucketParametersForCurrentException(This,pParams) )
#endif /* COBJMACROS */
#endif /* C style interface */
#endif /* __IPrivateManagedExceptionReporting_INTERFACE_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/setjmp/longjmp.c | /* libunwind - a platform-independent unwind library
Copyright (C) 2003-2004 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#define UNW_LOCAL_ONLY
#undef _FORTIFY_SOURCE
#include <assert.h>
#include <libunwind.h>
#include <setjmp.h>
#include <signal.h>
#include <stdlib.h>
#include "jmpbuf.h"
#include "setjmp_i.h"
#if defined(__GLIBC__)
#if __GLIBC_PREREQ(2, 4)
/* Starting with glibc-2.4, {sig,}setjmp in GLIBC obfuscates the
register values in jmp_buf by XORing them with a "random"
canary value.
This makes it impossible to implement longjmp, as we
can never match wp[JB_SP], unless we decode the canary first.
Doing so is possible, but doesn't appear to be worth the trouble,
so we simply defer to glibc longjmp here. */
#define _longjmp __nonworking__longjmp
#define longjmp __nonworking_longjmp
static void _longjmp (jmp_buf env, int val);
static void longjmp (jmp_buf env, int val);
#endif
#endif /* __GLIBC__ */
void
_longjmp (jmp_buf env, int val)
{
extern int _UI_longjmp_cont;
unw_context_t uc;
unw_cursor_t c;
unw_word_t sp;
unw_word_t *wp = (unw_word_t *) env;
if (unw_getcontext (&uc) < 0 || unw_init_local (&c, &uc) < 0)
abort ();
do
{
if (unw_get_reg (&c, UNW_REG_SP, &sp) < 0)
abort ();
#ifdef __FreeBSD__
if (sp != wp[JB_SP] + sizeof(unw_word_t))
#else
if (sp != wp[JB_SP])
#endif
continue;
if (!bsp_match (&c, wp))
continue;
/* found the right frame: */
assert (UNW_NUM_EH_REGS >= 2);
if (unw_set_reg (&c, UNW_REG_EH + 0, wp[JB_RP]) < 0
|| unw_set_reg (&c, UNW_REG_EH + 1, val) < 0
|| unw_set_reg (&c, UNW_REG_IP,
(unw_word_t) (uintptr_t) &_UI_longjmp_cont))
abort ();
unw_resume (&c);
abort ();
}
while (unw_step (&c) > 0);
abort ();
}
#ifdef __GNUC__
#define STRINGIFY1(x) #x
#define STRINGIFY(x) STRINGIFY1(x)
void longjmp (jmp_buf env, int val)
__attribute__ ((alias (STRINGIFY(_longjmp))));
#else
void
longjmp (jmp_buf env, int val)
{
_longjmp (env, val);
}
#endif /* __GNUC__ */
| /* libunwind - a platform-independent unwind library
Copyright (C) 2003-2004 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#define UNW_LOCAL_ONLY
#undef _FORTIFY_SOURCE
#include <assert.h>
#include <libunwind.h>
#include <setjmp.h>
#include <signal.h>
#include <stdlib.h>
#include "jmpbuf.h"
#include "setjmp_i.h"
#if defined(__GLIBC__)
#if __GLIBC_PREREQ(2, 4)
/* Starting with glibc-2.4, {sig,}setjmp in GLIBC obfuscates the
register values in jmp_buf by XORing them with a "random"
canary value.
This makes it impossible to implement longjmp, as we
can never match wp[JB_SP], unless we decode the canary first.
Doing so is possible, but doesn't appear to be worth the trouble,
so we simply defer to glibc longjmp here. */
#define _longjmp __nonworking__longjmp
#define longjmp __nonworking_longjmp
static void _longjmp (jmp_buf env, int val);
static void longjmp (jmp_buf env, int val);
#endif
#endif /* __GLIBC__ */
void
_longjmp (jmp_buf env, int val)
{
extern int _UI_longjmp_cont;
unw_context_t uc;
unw_cursor_t c;
unw_word_t sp;
unw_word_t *wp = (unw_word_t *) env;
if (unw_getcontext (&uc) < 0 || unw_init_local (&c, &uc) < 0)
abort ();
do
{
if (unw_get_reg (&c, UNW_REG_SP, &sp) < 0)
abort ();
#ifdef __FreeBSD__
if (sp != wp[JB_SP] + sizeof(unw_word_t))
#else
if (sp != wp[JB_SP])
#endif
continue;
if (!bsp_match (&c, wp))
continue;
/* found the right frame: */
assert (UNW_NUM_EH_REGS >= 2);
if (unw_set_reg (&c, UNW_REG_EH + 0, wp[JB_RP]) < 0
|| unw_set_reg (&c, UNW_REG_EH + 1, val) < 0
|| unw_set_reg (&c, UNW_REG_IP,
(unw_word_t) (uintptr_t) &_UI_longjmp_cont))
abort ();
unw_resume (&c);
abort ();
}
while (unw_step (&c) > 0);
abort ();
}
#ifdef __GNUC__
#define STRINGIFY1(x) #x
#define STRINGIFY(x) STRINGIFY1(x)
void longjmp (jmp_buf env, int val)
__attribute__ ((alias (STRINGIFY(_longjmp))));
#else
void
longjmp (jmp_buf env, int val)
{
_longjmp (env, val);
}
#endif /* __GNUC__ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/include/tdep-ppc64/dwarf-config.h | /* libunwind - a platform-independent unwind library
Copyright (C) 2006-2007 IBM
Contributed by
Corey Ashford <[email protected]>
Jose Flavio Aguilar Paulino <[email protected]> <[email protected]>
Copied from libunwind-x86_64.h, modified slightly for building
frysk successfully on ppc64, by Wu Zhou <[email protected]>
Will be replaced when libunwind is ready on ppc64 platform.
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#ifndef dwarf_config_h
#define dwarf_config_h
/* For PPC64, 48 GPRs + 33 FPRs + 33 AltiVec + 1 SPE */
#define DWARF_NUM_PRESERVED_REGS 115
#define DWARF_REGNUM_MAP_LENGTH 115
/* Return TRUE if the ADDR_SPACE uses big-endian byte-order. */
#define dwarf_is_big_endian(addr_space) ((addr_space)->big_endian)
/* Convert a pointer to a dwarf_cursor structure to a pointer to
unw_cursor_t. */
#define dwarf_to_cursor(c) ((unw_cursor_t *) (c))
typedef struct dwarf_loc
{
unw_word_t val;
#ifndef UNW_LOCAL_ONLY
unw_word_t type; /* see X86_LOC_TYPE_* macros. */
#endif
}
dwarf_loc_t;
#endif /* dwarf_config_h */
| /* libunwind - a platform-independent unwind library
Copyright (C) 2006-2007 IBM
Contributed by
Corey Ashford <[email protected]>
Jose Flavio Aguilar Paulino <[email protected]> <[email protected]>
Copied from libunwind-x86_64.h, modified slightly for building
frysk successfully on ppc64, by Wu Zhou <[email protected]>
Will be replaced when libunwind is ready on ppc64 platform.
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#ifndef dwarf_config_h
#define dwarf_config_h
/* For PPC64, 48 GPRs + 33 FPRs + 33 AltiVec + 1 SPE */
#define DWARF_NUM_PRESERVED_REGS 115
#define DWARF_REGNUM_MAP_LENGTH 115
/* Return TRUE if the ADDR_SPACE uses big-endian byte-order. */
#define dwarf_is_big_endian(addr_space) ((addr_space)->big_endian)
/* Convert a pointer to a dwarf_cursor structure to a pointer to
unw_cursor_t. */
#define dwarf_to_cursor(c) ((unw_cursor_t *) (c))
typedef struct dwarf_loc
{
unw_word_t val;
#ifndef UNW_LOCAL_ONLY
unw_word_t type; /* see X86_LOC_TYPE_* macros. */
#endif
}
dwarf_loc_t;
#endif /* dwarf_config_h */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/aarch64/Gcreate_addr_space.c | /* libunwind - a platform-independent unwind library
Copyright (C) 2012 Tommi Rantala <[email protected]>
Copyright (C) 2013 Linaro Limited
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <string.h>
#include <stdlib.h>
#include "unwind_i.h"
unw_addr_space_t
unw_create_addr_space (unw_accessors_t *a, int byte_order)
{
#ifdef UNW_LOCAL_ONLY
return NULL;
#else
unw_addr_space_t as;
/* AArch64 supports little-endian and big-endian. */
if (byte_order != 0 && byte_order_is_valid(byte_order) == 0)
return NULL;
as = malloc (sizeof (*as));
if (!as)
return NULL;
memset (as, 0, sizeof (*as));
as->acc = *a;
/* Default to little-endian for AArch64. */
if (byte_order == 0 || byte_order == UNW_LITTLE_ENDIAN)
as->big_endian = 0;
else
as->big_endian = 1;
return as;
#endif
}
| /* libunwind - a platform-independent unwind library
Copyright (C) 2012 Tommi Rantala <[email protected]>
Copyright (C) 2013 Linaro Limited
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <string.h>
#include <stdlib.h>
#include "unwind_i.h"
unw_addr_space_t
unw_create_addr_space (unw_accessors_t *a, int byte_order)
{
#ifdef UNW_LOCAL_ONLY
return NULL;
#else
unw_addr_space_t as;
/* AArch64 supports little-endian and big-endian. */
if (byte_order != 0 && byte_order_is_valid(byte_order) == 0)
return NULL;
as = malloc (sizeof (*as));
if (!as)
return NULL;
memset (as, 0, sizeof (*as));
as->acc = *a;
/* Default to little-endian for AArch64. */
if (byte_order == 0 || byte_order == UNW_LITTLE_ENDIAN)
as->big_endian = 0;
else
as->big_endian = 1;
return as;
#endif
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/brotli/enc/write_bits.h | /* Copyright 2010 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/* Write bits into a byte array. */
#ifndef BROTLI_ENC_WRITE_BITS_H_
#define BROTLI_ENC_WRITE_BITS_H_
#include "../common/platform.h"
#include <brotli/types.h>
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/* This function writes bits into bytes in increasing addresses, and within
a byte least-significant-bit first.
The function can write up to 56 bits in one go with WriteBits
Example: let's assume that 3 bits (Rs below) have been written already:
BYTE-0 BYTE+1 BYTE+2
0000 0RRR 0000 0000 0000 0000
Now, we could write 5 or less bits in MSB by just shifting by 3
and OR'ing to BYTE-0.
For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
and locate the rest in BYTE+1, BYTE+2, etc. */
static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
uint64_t bits,
size_t* BROTLI_RESTRICT pos,
uint8_t* BROTLI_RESTRICT array) {
BROTLI_LOG(("WriteBits %2d 0x%08x%08x %10d\n", (int)n_bits,
(uint32_t)(bits >> 32), (uint32_t)(bits & 0xFFFFFFFF),
(int)*pos));
BROTLI_DCHECK((bits >> n_bits) == 0);
BROTLI_DCHECK(n_bits <= 56);
#if defined(BROTLI_LITTLE_ENDIAN)
/* This branch of the code can write up to 56 bits at a time,
7 bits are lost by being perhaps already in *p and at least
1 bit is needed to initialize the bit-stream ahead (i.e. if 7
bits are in *p and we write 57 bits, then the next write will
access a byte that was never initialized). */
{
uint8_t* p = &array[*pos >> 3];
uint64_t v = (uint64_t)(*p); /* Zero-extend 8 to 64 bits. */
v |= bits << (*pos & 7);
BROTLI_UNALIGNED_STORE64LE(p, v); /* Set some bits. */
*pos += n_bits;
}
#else
/* implicit & 0xFF is assumed for uint8_t arithmetics */
{
uint8_t* array_pos = &array[*pos >> 3];
const size_t bits_reserved_in_first_byte = (*pos & 7);
size_t bits_left_to_write;
bits <<= bits_reserved_in_first_byte;
*array_pos++ |= (uint8_t)bits;
for (bits_left_to_write = n_bits + bits_reserved_in_first_byte;
bits_left_to_write >= 9;
bits_left_to_write -= 8) {
bits >>= 8;
*array_pos++ = (uint8_t)bits;
}
*array_pos = 0;
*pos += n_bits;
}
#endif
}
static BROTLI_INLINE void BrotliWriteBitsPrepareStorage(
size_t pos, uint8_t* array) {
BROTLI_LOG(("WriteBitsPrepareStorage %10d\n", (int)pos));
BROTLI_DCHECK((pos & 7) == 0);
array[pos >> 3] = 0;
}
#if defined(__cplusplus) || defined(c_plusplus)
} /* extern "C" */
#endif
#endif /* BROTLI_ENC_WRITE_BITS_H_ */
| /* Copyright 2010 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/* Write bits into a byte array. */
#ifndef BROTLI_ENC_WRITE_BITS_H_
#define BROTLI_ENC_WRITE_BITS_H_
#include "../common/platform.h"
#include <brotli/types.h>
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/* This function writes bits into bytes in increasing addresses, and within
a byte least-significant-bit first.
The function can write up to 56 bits in one go with WriteBits
Example: let's assume that 3 bits (Rs below) have been written already:
BYTE-0 BYTE+1 BYTE+2
0000 0RRR 0000 0000 0000 0000
Now, we could write 5 or less bits in MSB by just shifting by 3
and OR'ing to BYTE-0.
For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
and locate the rest in BYTE+1, BYTE+2, etc. */
static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
uint64_t bits,
size_t* BROTLI_RESTRICT pos,
uint8_t* BROTLI_RESTRICT array) {
BROTLI_LOG(("WriteBits %2d 0x%08x%08x %10d\n", (int)n_bits,
(uint32_t)(bits >> 32), (uint32_t)(bits & 0xFFFFFFFF),
(int)*pos));
BROTLI_DCHECK((bits >> n_bits) == 0);
BROTLI_DCHECK(n_bits <= 56);
#if defined(BROTLI_LITTLE_ENDIAN)
/* This branch of the code can write up to 56 bits at a time,
7 bits are lost by being perhaps already in *p and at least
1 bit is needed to initialize the bit-stream ahead (i.e. if 7
bits are in *p and we write 57 bits, then the next write will
access a byte that was never initialized). */
{
uint8_t* p = &array[*pos >> 3];
uint64_t v = (uint64_t)(*p); /* Zero-extend 8 to 64 bits. */
v |= bits << (*pos & 7);
BROTLI_UNALIGNED_STORE64LE(p, v); /* Set some bits. */
*pos += n_bits;
}
#else
/* implicit & 0xFF is assumed for uint8_t arithmetics */
{
uint8_t* array_pos = &array[*pos >> 3];
const size_t bits_reserved_in_first_byte = (*pos & 7);
size_t bits_left_to_write;
bits <<= bits_reserved_in_first_byte;
*array_pos++ |= (uint8_t)bits;
for (bits_left_to_write = n_bits + bits_reserved_in_first_byte;
bits_left_to_write >= 9;
bits_left_to_write -= 8) {
bits >>= 8;
*array_pos++ = (uint8_t)bits;
}
*array_pos = 0;
*pos += n_bits;
}
#endif
}
static BROTLI_INLINE void BrotliWriteBitsPrepareStorage(
size_t pos, uint8_t* array) {
BROTLI_LOG(("WriteBitsPrepareStorage %10d\n", (int)pos));
BROTLI_DCHECK((pos & 7) == 0);
array[pos >> 3] = 0;
}
#if defined(__cplusplus) || defined(c_plusplus)
} /* extern "C" */
#endif
#endif /* BROTLI_ENC_WRITE_BITS_H_ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/eventpipe/ds-dump-protocol.c | #include "ds-rt-config.h"
#ifdef ENABLE_PERFTRACING
#if !defined(DS_INCLUDE_SOURCE_FILES) || defined(DS_FORCE_INCLUDE_SOURCE_FILES)
#define DS_IMPL_DUMP_PROTOCOL_GETTER_SETTER
#include "ds-protocol.h"
#include "ds-dump-protocol.h"
#include "ds-rt.h"
/*
* Forward declares of all static functions.
*/
static
uint8_t *
generate_core_dump_command_try_parse_payload (
uint8_t *buffer,
uint16_t buffer_len);
static
bool
dump_protocol_helper_generate_core_dump (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream);
static
bool
dump_protocol_helper_unknown_command (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream);
/*
* DiagnosticsGenerateCoreDumpCommandPayload
*/
static
uint8_t *
generate_core_dump_command_try_parse_payload (
uint8_t *buffer,
uint16_t buffer_len)
{
EP_ASSERT (buffer != NULL);
uint8_t * buffer_cursor = buffer;
uint32_t buffer_cursor_len = buffer_len;
DiagnosticsGenerateCoreDumpCommandPayload *instance = ds_generate_core_dump_command_payload_alloc ();
ep_raise_error_if_nok (instance != NULL);
instance->incoming_buffer = buffer;
if (!ds_ipc_message_try_parse_string_utf16_t (&buffer_cursor, &buffer_cursor_len, &instance->dump_name ) ||
!ds_ipc_message_try_parse_uint32_t (&buffer_cursor, &buffer_cursor_len, &instance->dump_type) ||
!ds_ipc_message_try_parse_uint32_t (&buffer_cursor, &buffer_cursor_len, &instance->flags))
ep_raise_error ();
ep_on_exit:
return (uint8_t *)instance;
ep_on_error:
ds_generate_core_dump_command_payload_free (instance);
instance = NULL;
ep_exit_error_handler ();
}
DiagnosticsGenerateCoreDumpCommandPayload *
ds_generate_core_dump_command_payload_alloc (void)
{
return ep_rt_object_alloc (DiagnosticsGenerateCoreDumpCommandPayload);
}
void
ds_generate_core_dump_command_payload_free (DiagnosticsGenerateCoreDumpCommandPayload *payload)
{
ep_return_void_if_nok (payload != NULL);
ep_rt_byte_array_free (payload->incoming_buffer);
ep_rt_object_free (payload);
}
/*
* DiagnosticsDumpProtocolHelper.
*/
static
bool
dump_protocol_helper_unknown_command (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream)
{
DS_LOG_WARNING_1 ("Received unknown request type (%d)", ds_ipc_header_get_commandset (ds_ipc_message_get_header_ref (message)));
ds_ipc_message_send_error (stream, DS_IPC_E_UNKNOWN_COMMAND);
ds_ipc_stream_free (stream);
return true;
}
static
bool
dump_protocol_helper_generate_core_dump (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream)
{
EP_ASSERT (message != NULL);
EP_ASSERT (stream != NULL);
if (!stream)
return false;
ds_ipc_result_t ipc_result = DS_IPC_E_FAIL;
DiagnosticsDumpCommandId commandId = (DiagnosticsDumpCommandId)ds_ipc_header_get_commandid (ds_ipc_message_get_header_ref (message));
DiagnosticsGenerateCoreDumpCommandPayload *payload;
payload = (DiagnosticsGenerateCoreDumpCommandPayload *)ds_ipc_message_try_parse_payload (message, generate_core_dump_command_try_parse_payload);
if (!payload) {
ds_ipc_message_send_error (stream, DS_IPC_E_BAD_ENCODING);
ep_raise_error ();
}
ipc_result = ds_rt_generate_core_dump (commandId, payload);
if (ipc_result != DS_IPC_S_OK) {
ds_ipc_message_send_error (stream, ipc_result);
ep_raise_error ();
} else {
ds_ipc_message_send_success (stream, ipc_result);
}
ep_on_exit:
ds_generate_core_dump_command_payload_free (payload);
ds_ipc_stream_free (stream);
return ipc_result == DS_IPC_S_OK;
ep_on_error:
EP_ASSERT (ipc_result != DS_IPC_S_OK);
ep_exit_error_handler ();
}
bool
ds_dump_protocol_helper_handle_ipc_message (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream)
{
EP_ASSERT (message != NULL);
EP_ASSERT (stream != NULL);
bool result = false;
switch ((DiagnosticsDumpCommandId)ds_ipc_header_get_commandid (ds_ipc_message_get_header_ref (message))) {
case DS_DUMP_COMMANDID_GENERATE_CORE_DUMP:
case DS_DUMP_COMMANDID_GENERATE_CORE_DUMP2:
result = dump_protocol_helper_generate_core_dump (message, stream);
break;
default:
result = dump_protocol_helper_unknown_command (message, stream);
break;
}
return result;
}
#endif /* !defined(DS_INCLUDE_SOURCE_FILES) || defined(DS_FORCE_INCLUDE_SOURCE_FILES) */
#endif /* ENABLE_PERFTRACING */
#ifndef DS_INCLUDE_SOURCE_FILES
extern const char quiet_linker_empty_file_warning_diagnostics_dump_protocol;
const char quiet_linker_empty_file_warning_diagnostics_dump_protocol = 0;
#endif
| #include "ds-rt-config.h"
#ifdef ENABLE_PERFTRACING
#if !defined(DS_INCLUDE_SOURCE_FILES) || defined(DS_FORCE_INCLUDE_SOURCE_FILES)
#define DS_IMPL_DUMP_PROTOCOL_GETTER_SETTER
#include "ds-protocol.h"
#include "ds-dump-protocol.h"
#include "ds-rt.h"
/*
* Forward declares of all static functions.
*/
static
uint8_t *
generate_core_dump_command_try_parse_payload (
uint8_t *buffer,
uint16_t buffer_len);
static
bool
dump_protocol_helper_generate_core_dump (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream);
static
bool
dump_protocol_helper_unknown_command (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream);
/*
* DiagnosticsGenerateCoreDumpCommandPayload
*/
static
uint8_t *
generate_core_dump_command_try_parse_payload (
uint8_t *buffer,
uint16_t buffer_len)
{
EP_ASSERT (buffer != NULL);
uint8_t * buffer_cursor = buffer;
uint32_t buffer_cursor_len = buffer_len;
DiagnosticsGenerateCoreDumpCommandPayload *instance = ds_generate_core_dump_command_payload_alloc ();
ep_raise_error_if_nok (instance != NULL);
instance->incoming_buffer = buffer;
if (!ds_ipc_message_try_parse_string_utf16_t (&buffer_cursor, &buffer_cursor_len, &instance->dump_name ) ||
!ds_ipc_message_try_parse_uint32_t (&buffer_cursor, &buffer_cursor_len, &instance->dump_type) ||
!ds_ipc_message_try_parse_uint32_t (&buffer_cursor, &buffer_cursor_len, &instance->flags))
ep_raise_error ();
ep_on_exit:
return (uint8_t *)instance;
ep_on_error:
ds_generate_core_dump_command_payload_free (instance);
instance = NULL;
ep_exit_error_handler ();
}
DiagnosticsGenerateCoreDumpCommandPayload *
ds_generate_core_dump_command_payload_alloc (void)
{
return ep_rt_object_alloc (DiagnosticsGenerateCoreDumpCommandPayload);
}
void
ds_generate_core_dump_command_payload_free (DiagnosticsGenerateCoreDumpCommandPayload *payload)
{
ep_return_void_if_nok (payload != NULL);
ep_rt_byte_array_free (payload->incoming_buffer);
ep_rt_object_free (payload);
}
/*
* DiagnosticsDumpProtocolHelper.
*/
static
bool
dump_protocol_helper_unknown_command (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream)
{
DS_LOG_WARNING_1 ("Received unknown request type (%d)", ds_ipc_header_get_commandset (ds_ipc_message_get_header_ref (message)));
ds_ipc_message_send_error (stream, DS_IPC_E_UNKNOWN_COMMAND);
ds_ipc_stream_free (stream);
return true;
}
static
bool
dump_protocol_helper_generate_core_dump (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream)
{
EP_ASSERT (message != NULL);
EP_ASSERT (stream != NULL);
if (!stream)
return false;
ds_ipc_result_t ipc_result = DS_IPC_E_FAIL;
DiagnosticsDumpCommandId commandId = (DiagnosticsDumpCommandId)ds_ipc_header_get_commandid (ds_ipc_message_get_header_ref (message));
DiagnosticsGenerateCoreDumpCommandPayload *payload;
payload = (DiagnosticsGenerateCoreDumpCommandPayload *)ds_ipc_message_try_parse_payload (message, generate_core_dump_command_try_parse_payload);
if (!payload) {
ds_ipc_message_send_error (stream, DS_IPC_E_BAD_ENCODING);
ep_raise_error ();
}
ipc_result = ds_rt_generate_core_dump (commandId, payload);
if (ipc_result != DS_IPC_S_OK) {
ds_ipc_message_send_error (stream, ipc_result);
ep_raise_error ();
} else {
ds_ipc_message_send_success (stream, ipc_result);
}
ep_on_exit:
ds_generate_core_dump_command_payload_free (payload);
ds_ipc_stream_free (stream);
return ipc_result == DS_IPC_S_OK;
ep_on_error:
EP_ASSERT (ipc_result != DS_IPC_S_OK);
ep_exit_error_handler ();
}
bool
ds_dump_protocol_helper_handle_ipc_message (
DiagnosticsIpcMessage *message,
DiagnosticsIpcStream *stream)
{
EP_ASSERT (message != NULL);
EP_ASSERT (stream != NULL);
bool result = false;
switch ((DiagnosticsDumpCommandId)ds_ipc_header_get_commandid (ds_ipc_message_get_header_ref (message))) {
case DS_DUMP_COMMANDID_GENERATE_CORE_DUMP:
case DS_DUMP_COMMANDID_GENERATE_CORE_DUMP2:
result = dump_protocol_helper_generate_core_dump (message, stream);
break;
default:
result = dump_protocol_helper_unknown_command (message, stream);
break;
}
return result;
}
#endif /* !defined(DS_INCLUDE_SOURCE_FILES) || defined(DS_FORCE_INCLUDE_SOURCE_FILES) */
#endif /* ENABLE_PERFTRACING */
#ifndef DS_INCLUDE_SOURCE_FILES
extern const char quiet_linker_empty_file_warning_diagnostics_dump_protocol;
const char quiet_linker_empty_file_warning_diagnostics_dump_protocol = 0;
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/exception/machexception.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/*++
Module Name:
machexception.h
Abstract:
Private mach exception handling utilities for SEH
--*/
#ifndef _MACHEXCEPTION_H_
#define _MACHEXCEPTION_H_
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <mach/thread_status.h>
#ifdef __cplusplus
extern "C"
{
#endif // __cplusplus
// List of exception types we will be watching for
// NOTE: if you change any of these, you need to adapt s_nMachExceptionPortsMax in thread.hpp
#define PAL_EXC_ILLEGAL_MASK (EXC_MASK_BAD_INSTRUCTION | EXC_MASK_EMULATION)
#define PAL_EXC_DEBUGGING_MASK (EXC_MASK_BREAKPOINT | EXC_MASK_SOFTWARE)
#define PAL_EXC_MANAGED_MASK (EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC)
#define PAL_EXC_ALL_MASK (PAL_EXC_ILLEGAL_MASK | PAL_EXC_DEBUGGING_MASK | PAL_EXC_MANAGED_MASK)
// Process and thread initialization/cleanup/context routines
BOOL SEHInitializeMachExceptions(DWORD flags);
void MachExceptionInitializeDebug(void);
PAL_NORETURN void MachSetThreadContext(CONTEXT *lpContext);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* _MACHEXCEPTION_H_ */
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/*++
Module Name:
machexception.h
Abstract:
Private mach exception handling utilities for SEH
--*/
#ifndef _MACHEXCEPTION_H_
#define _MACHEXCEPTION_H_
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <mach/thread_status.h>
#ifdef __cplusplus
extern "C"
{
#endif // __cplusplus
// List of exception types we will be watching for
// NOTE: if you change any of these, you need to adapt s_nMachExceptionPortsMax in thread.hpp
#define PAL_EXC_ILLEGAL_MASK (EXC_MASK_BAD_INSTRUCTION | EXC_MASK_EMULATION)
#define PAL_EXC_DEBUGGING_MASK (EXC_MASK_BREAKPOINT | EXC_MASK_SOFTWARE)
#define PAL_EXC_MANAGED_MASK (EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC)
#define PAL_EXC_ALL_MASK (PAL_EXC_ILLEGAL_MASK | PAL_EXC_DEBUGGING_MASK | PAL_EXC_MANAGED_MASK)
// Process and thread initialization/cleanup/context routines
BOOL SEHInitializeMachExceptions(DWORD flags);
void MachExceptionInitializeDebug(void);
PAL_NORETURN void MachSetThreadContext(CONTEXT *lpContext);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif /* _MACHEXCEPTION_H_ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/zlib/trees.c | /* trees.c -- output deflated data using Huffman coding
* Copyright (C) 1995-2017 Jean-loup Gailly
* detect_data_type() function provided freely by Cosmin Truta, 2006
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
* ALGORITHM
*
* The "deflation" process uses several Huffman trees. The more
* common source values are represented by shorter bit sequences.
*
* Each code tree is stored in a compressed form which is itself
* a Huffman encoding of the lengths of all the code strings (in
* ascending order by source values). The actual code strings are
* reconstructed from the lengths in the inflate process, as described
* in the deflate specification.
*
* REFERENCES
*
* Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
* Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
*
* Storer, James A.
* Data Compression: Methods and Theory, pp. 49-50.
* Computer Science Press, 1988. ISBN 0-7167-8156-5.
*
* Sedgewick, R.
* Algorithms, p290.
* Addison-Wesley, 1983. ISBN 0-201-06672-6.
*/
/* @(#) $Id$ */
/* #define GEN_TREES_H */
#include "deflate.h"
#ifdef ZLIB_DEBUG
# include <ctype.h>
#endif
/* ===========================================================================
* Constants
*/
#define MAX_BL_BITS 7
/* Bit length codes must not exceed MAX_BL_BITS bits */
#define END_BLOCK 256
/* end of block literal code */
#define REP_3_6 16
/* repeat previous bit length 3-6 times (2 bits of repeat count) */
#define REPZ_3_10 17
/* repeat a zero length 3-10 times (3 bits of repeat count) */
#define REPZ_11_138 18
/* repeat a zero length 11-138 times (7 bits of repeat count) */
local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
= {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
local const int extra_dbits[D_CODES] /* extra bits for each distance code */
= {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
local const uch bl_order[BL_CODES]
= {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
/* The lengths of the bit length codes are sent in order of decreasing
* probability, to avoid transmitting the lengths for unused bit length codes.
*/
/* ===========================================================================
* Local data. These are initialized only once.
*/
#define DIST_CODE_LEN 512 /* see definition of array dist_code below */
#if defined(GEN_TREES_H) || !defined(STDC)
/* non ANSI compilers may not accept trees.h */
local ct_data static_ltree[L_CODES+2];
/* The static literal tree. Since the bit lengths are imposed, there is no
* need for the L_CODES extra codes used during heap construction. However
* The codes 286 and 287 are needed to build a canonical tree (see _tr_init
* below).
*/
local ct_data static_dtree[D_CODES];
/* The static distance tree. (Actually a trivial tree since all codes use
* 5 bits.)
*/
uch _dist_code[DIST_CODE_LEN];
/* Distance codes. The first 256 values correspond to the distances
* 3 .. 258, the last 256 values correspond to the top 8 bits of
* the 15 bit distances.
*/
uch _length_code[MAX_MATCH-MIN_MATCH+1];
/* length code for each normalized match length (0 == MIN_MATCH) */
local int base_length[LENGTH_CODES];
/* First normalized length for each code (0 = MIN_MATCH) */
local int base_dist[D_CODES];
/* First normalized distance for each code (0 = distance of 1) */
#else
# include "trees.h"
#endif /* GEN_TREES_H */
struct static_tree_desc_s {
const ct_data *static_tree; /* static tree or NULL */
const intf *extra_bits; /* extra bits for each code or NULL */
int extra_base; /* base index for extra_bits */
int elems; /* max number of elements in the tree */
int max_length; /* max bit length for the codes */
};
local const static_tree_desc static_l_desc =
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
local const static_tree_desc static_d_desc =
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
local const static_tree_desc static_bl_desc =
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
/* ===========================================================================
* Local (static) routines in this file.
*/
local void tr_static_init OF((void));
local void init_block OF((deflate_state *s));
local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));
local void build_tree OF((deflate_state *s, tree_desc *desc));
local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
local int build_bl_tree OF((deflate_state *s));
local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
int blcodes));
local void compress_block OF((deflate_state *s, const ct_data *ltree,
const ct_data *dtree));
local int detect_data_type OF((deflate_state *s));
local unsigned bi_reverse OF((unsigned value, int length));
local void bi_windup OF((deflate_state *s));
local void bi_flush OF((deflate_state *s));
#ifdef GEN_TREES_H
local void gen_trees_header OF((void));
#endif
#ifndef ZLIB_DEBUG
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
/* Send a code of the given tree. c and tree must not have side effects */
#else /* !ZLIB_DEBUG */
# define send_code(s, c, tree) \
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
send_bits(s, tree[c].Code, tree[c].Len); }
#endif
/* ===========================================================================
* Output a short LSB first on the stream.
* IN assertion: there is enough room in pendingBuf.
*/
#define put_short(s, w) { \
put_byte(s, (uch)((w) & 0xff)); \
put_byte(s, (uch)((ush)(w) >> 8)); \
}
/* ===========================================================================
* Send a value on a given number of bits.
* IN assertion: length <= 16 and value fits in length bits.
*/
#ifdef ZLIB_DEBUG
local void send_bits OF((deflate_state *s, int value, int length));
local void send_bits(s, value, length)
deflate_state *s;
int value; /* value to send */
int length; /* number of bits */
{
Tracevv((stderr," l %2d v %4x ", length, value));
Assert(length > 0 && length <= 15, "invalid length");
s->bits_sent += (ulg)length;
/* If not enough room in bi_buf, use (valid) bits from bi_buf and
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
* unused bits in value.
*/
if (s->bi_valid > (int)Buf_size - length) {
s->bi_buf |= (ush)value << s->bi_valid;
put_short(s, s->bi_buf);
s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
s->bi_valid += length - Buf_size;
} else {
s->bi_buf |= (ush)value << s->bi_valid;
s->bi_valid += length;
}
}
#else /* !ZLIB_DEBUG */
#define send_bits(s, value, length) \
{ int len = length;\
if (s->bi_valid > (int)Buf_size - len) {\
int val = (int)value;\
s->bi_buf |= (ush)val << s->bi_valid;\
put_short(s, s->bi_buf);\
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
s->bi_valid += len - Buf_size;\
} else {\
s->bi_buf |= (ush)(value) << s->bi_valid;\
s->bi_valid += len;\
}\
}
#endif /* ZLIB_DEBUG */
/* the arguments must not have side effects */
/* ===========================================================================
* Initialize the various 'constant' tables.
*/
local void tr_static_init()
{
#if defined(GEN_TREES_H) || !defined(STDC)
static int static_init_done = 0;
int n; /* iterates over tree elements */
int bits; /* bit counter */
int length; /* length value */
int code; /* code value */
int dist; /* distance index */
ush bl_count[MAX_BITS+1];
/* number of codes at each bit length for an optimal tree */
if (static_init_done) return;
/* For some embedded targets, global variables are not initialized: */
#ifdef NO_INIT_GLOBAL_POINTERS
static_l_desc.static_tree = static_ltree;
static_l_desc.extra_bits = extra_lbits;
static_d_desc.static_tree = static_dtree;
static_d_desc.extra_bits = extra_dbits;
static_bl_desc.extra_bits = extra_blbits;
#endif
/* Initialize the mapping length (0..255) -> length code (0..28) */
length = 0;
for (code = 0; code < LENGTH_CODES-1; code++) {
base_length[code] = length;
for (n = 0; n < (1<<extra_lbits[code]); n++) {
_length_code[length++] = (uch)code;
}
}
Assert (length == 256, "tr_static_init: length != 256");
/* Note that the length 255 (match length 258) can be represented
* in two different ways: code 284 + 5 bits or code 285, so we
* overwrite length_code[255] to use the best encoding:
*/
_length_code[length-1] = (uch)code;
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */
dist = 0;
for (code = 0 ; code < 16; code++) {
base_dist[code] = dist;
for (n = 0; n < (1<<extra_dbits[code]); n++) {
_dist_code[dist++] = (uch)code;
}
}
Assert (dist == 256, "tr_static_init: dist != 256");
dist >>= 7; /* from now on, all distances are divided by 128 */
for ( ; code < D_CODES; code++) {
base_dist[code] = dist << 7;
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
_dist_code[256 + dist++] = (uch)code;
}
}
Assert (dist == 256, "tr_static_init: 256+dist != 512");
/* Construct the codes of the static literal tree */
for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
n = 0;
while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
/* Codes 286 and 287 do not exist, but we must include them in the
* tree construction to get a canonical Huffman tree (longest code
* all ones)
*/
gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
/* The static distance tree is trivial: */
for (n = 0; n < D_CODES; n++) {
static_dtree[n].Len = 5;
static_dtree[n].Code = bi_reverse((unsigned)n, 5);
}
static_init_done = 1;
# ifdef GEN_TREES_H
gen_trees_header();
# endif
#endif /* defined(GEN_TREES_H) || !defined(STDC) */
}
/* ===========================================================================
* Genererate the file trees.h describing the static trees.
*/
#ifdef GEN_TREES_H
# ifndef ZLIB_DEBUG
# include <stdio.h>
# endif
# define SEPARATOR(i, last, width) \
((i) == (last)? "\n};\n\n" : \
((i) % (width) == (width)-1 ? ",\n" : ", "))
void gen_trees_header()
{
FILE *header = fopen("trees.h", "w");
int i;
Assert (header != NULL, "Can't open trees.h");
fprintf(header,
"/* header created automatically with -DGEN_TREES_H */\n\n");
fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
for (i = 0; i < L_CODES+2; i++) {
fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
}
fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
for (i = 0; i < D_CODES; i++) {
fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
}
fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
for (i = 0; i < DIST_CODE_LEN; i++) {
fprintf(header, "%2u%s", _dist_code[i],
SEPARATOR(i, DIST_CODE_LEN-1, 20));
}
fprintf(header,
"const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
fprintf(header, "%2u%s", _length_code[i],
SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
}
fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
for (i = 0; i < LENGTH_CODES; i++) {
fprintf(header, "%1u%s", base_length[i],
SEPARATOR(i, LENGTH_CODES-1, 20));
}
fprintf(header, "local const int base_dist[D_CODES] = {\n");
for (i = 0; i < D_CODES; i++) {
fprintf(header, "%5u%s", base_dist[i],
SEPARATOR(i, D_CODES-1, 10));
}
fclose(header);
}
#endif /* GEN_TREES_H */
/* ===========================================================================
* Initialize the tree data structures for a new zlib stream.
*/
void ZLIB_INTERNAL _tr_init(s)
deflate_state *s;
{
tr_static_init();
s->l_desc.dyn_tree = s->dyn_ltree;
s->l_desc.stat_desc = &static_l_desc;
s->d_desc.dyn_tree = s->dyn_dtree;
s->d_desc.stat_desc = &static_d_desc;
s->bl_desc.dyn_tree = s->bl_tree;
s->bl_desc.stat_desc = &static_bl_desc;
s->bi_buf = 0;
s->bi_valid = 0;
#ifdef ZLIB_DEBUG
s->compressed_len = 0L;
s->bits_sent = 0L;
#endif
/* Initialize the first block of the first file: */
init_block(s);
}
/* ===========================================================================
* Initialize a new block.
*/
local void init_block(s)
deflate_state *s;
{
int n; /* iterates over tree elements */
/* Initialize the trees. */
for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
s->dyn_ltree[END_BLOCK].Freq = 1;
s->opt_len = s->static_len = 0L;
s->last_lit = s->matches = 0;
}
#define SMALLEST 1
/* Index within the heap array of least frequent node in the Huffman tree */
/* ===========================================================================
* Remove the smallest element from the heap and recreate the heap with
* one less element. Updates heap and heap_len.
*/
#define pqremove(s, tree, top) \
{\
top = s->heap[SMALLEST]; \
s->heap[SMALLEST] = s->heap[s->heap_len--]; \
pqdownheap(s, tree, SMALLEST); \
}
/* ===========================================================================
* Compares to subtrees, using the tree depth as tie breaker when
* the subtrees have equal frequency. This minimizes the worst case length.
*/
#define smaller(tree, n, m, depth) \
(tree[n].Freq < tree[m].Freq || \
(tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
/* ===========================================================================
* Restore the heap property by moving down the tree starting at node k,
* exchanging a node with the smallest of its two sons if necessary, stopping
* when the heap property is re-established (each father smaller than its
* two sons).
*/
local void pqdownheap(s, tree, k)
deflate_state *s;
ct_data *tree; /* the tree to restore */
int k; /* node to move down */
{
int v = s->heap[k];
int j = k << 1; /* left son of k */
while (j <= s->heap_len) {
/* Set j to the smallest of the two sons: */
if (j < s->heap_len &&
smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
j++;
}
/* Exit if v is smaller than both sons */
if (smaller(tree, v, s->heap[j], s->depth)) break;
/* Exchange v with the smallest son */
s->heap[k] = s->heap[j]; k = j;
/* And continue down the tree, setting j to the left son of k */
j <<= 1;
}
s->heap[k] = v;
}
/* ===========================================================================
* Compute the optimal bit lengths for a tree and update the total bit length
* for the current block.
* IN assertion: the fields freq and dad are set, heap[heap_max] and
* above are the tree nodes sorted by increasing frequency.
* OUT assertions: the field len is set to the optimal bit length, the
* array bl_count contains the frequencies for each bit length.
* The length opt_len is updated; static_len is also updated if stree is
* not null.
*/
local void gen_bitlen(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
int max_code = desc->max_code;
const ct_data *stree = desc->stat_desc->static_tree;
const intf *extra = desc->stat_desc->extra_bits;
int base = desc->stat_desc->extra_base;
int max_length = desc->stat_desc->max_length;
int h; /* heap index */
int n, m; /* iterate over the tree elements */
int bits; /* bit length */
int xbits; /* extra bits */
ush f; /* frequency */
int overflow = 0; /* number of elements with bit length too large */
for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
/* In a first pass, compute the optimal bit lengths (which may
* overflow in the case of the bit length tree).
*/
tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
n = s->heap[h];
bits = tree[tree[n].Dad].Len + 1;
if (bits > max_length) bits = max_length, overflow++;
tree[n].Len = (ush)bits;
/* We overwrite tree[n].Dad which is no longer needed */
if (n > max_code) continue; /* not a leaf node */
s->bl_count[bits]++;
xbits = 0;
if (n >= base) xbits = extra[n-base];
f = tree[n].Freq;
s->opt_len += (ulg)f * (unsigned)(bits + xbits);
if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
}
if (overflow == 0) return;
Tracev((stderr,"\nbit length overflow\n"));
/* This happens for example on obj2 and pic of the Calgary corpus */
/* Find the first bit length which could increase: */
do {
bits = max_length-1;
while (s->bl_count[bits] == 0) bits--;
s->bl_count[bits]--; /* move one leaf down the tree */
s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
s->bl_count[max_length]--;
/* The brother of the overflow item also moves one step up,
* but this does not affect bl_count[max_length]
*/
overflow -= 2;
} while (overflow > 0);
/* Now recompute all bit lengths, scanning in increasing frequency.
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
* lengths instead of fixing only the wrong ones. This idea is taken
* from 'ar' written by Haruhiko Okumura.)
*/
for (bits = max_length; bits != 0; bits--) {
n = s->bl_count[bits];
while (n != 0) {
m = s->heap[--h];
if (m > max_code) continue;
if ((unsigned) tree[m].Len != (unsigned) bits) {
Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
tree[m].Len = (ush)bits;
}
n--;
}
}
}
/* ===========================================================================
* Generate the codes for a given tree and bit counts (which need not be
* optimal).
* IN assertion: the array bl_count contains the bit length statistics for
* the given tree and the field len is set for all tree elements.
* OUT assertion: the field code is set for all tree elements of non
* zero code length.
*/
local void gen_codes (tree, max_code, bl_count)
ct_data *tree; /* the tree to decorate */
int max_code; /* largest code with non zero frequency */
ushf *bl_count; /* number of codes at each bit length */
{
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
unsigned code = 0; /* running code value */
int bits; /* bit index */
int n; /* code index */
/* The distribution counts are first used to generate the code values
* without bit reversal.
*/
for (bits = 1; bits <= MAX_BITS; bits++) {
code = (code + bl_count[bits-1]) << 1;
next_code[bits] = (ush)code;
}
/* Check that the bit counts in bl_count are consistent. The last code
* must be all ones.
*/
Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
"inconsistent bit counts");
Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
for (n = 0; n <= max_code; n++) {
int len = tree[n].Len;
if (len == 0) continue;
/* Now reverse the bits */
tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
}
}
/* ===========================================================================
* Construct one Huffman tree and assigns the code bit strings and lengths.
* Update the total bit length for the current block.
* IN assertion: the field freq is set for all tree elements.
* OUT assertions: the fields len and code are set to the optimal bit length
* and corresponding code. The length opt_len is updated; static_len is
* also updated if stree is not null. The field max_code is set.
*/
local void build_tree(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
int elems = desc->stat_desc->elems;
int n, m; /* iterate over heap elements */
int max_code = -1; /* largest code with non zero frequency */
int node; /* new node being created */
/* Construct the initial heap, with least frequent element in
* heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
* heap[0] is not used.
*/
s->heap_len = 0, s->heap_max = HEAP_SIZE;
for (n = 0; n < elems; n++) {
if (tree[n].Freq != 0) {
s->heap[++(s->heap_len)] = max_code = n;
s->depth[n] = 0;
} else {
tree[n].Len = 0;
}
}
/* The pkzip format requires that at least one distance code exists,
* and that at least one bit should be sent even if there is only one
* possible code. So to avoid special checks later on we force at least
* two codes of non zero frequency.
*/
while (s->heap_len < 2) {
node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
tree[node].Freq = 1;
s->depth[node] = 0;
s->opt_len--; if (stree) s->static_len -= stree[node].Len;
/* node is 0 or 1 so it does not have extra bits */
}
desc->max_code = max_code;
/* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
* establish sub-heaps of increasing lengths:
*/
for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
/* Construct the Huffman tree by repeatedly combining the least two
* frequent nodes.
*/
node = elems; /* next internal node of the tree */
do {
pqremove(s, tree, n); /* n = node of least frequency */
m = s->heap[SMALLEST]; /* m = node of next least frequency */
s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
s->heap[--(s->heap_max)] = m;
/* Create a new node father of n and m */
tree[node].Freq = tree[n].Freq + tree[m].Freq;
s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
s->depth[n] : s->depth[m]) + 1);
tree[n].Dad = tree[m].Dad = (ush)node;
#ifdef DUMP_BL_TREE
if (tree == s->bl_tree) {
fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
}
#endif
/* and insert the new node in the heap */
s->heap[SMALLEST] = node++;
pqdownheap(s, tree, SMALLEST);
} while (s->heap_len >= 2);
s->heap[--(s->heap_max)] = s->heap[SMALLEST];
/* At this point, the fields freq and dad are set. We can now
* generate the bit lengths.
*/
gen_bitlen(s, (tree_desc *)desc);
/* The field len is now set, we can generate the bit codes */
gen_codes ((ct_data *)tree, max_code, s->bl_count);
}
/* ===========================================================================
* Scan a literal or distance tree to determine the frequencies of the codes
* in the bit length tree.
*/
local void scan_tree (s, tree, max_code)
deflate_state *s;
ct_data *tree; /* the tree to be scanned */
int max_code; /* and its largest code of non zero frequency */
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
int curlen; /* length of current code */
int nextlen = tree[0].Len; /* length of next code */
int count = 0; /* repeat count of the current code */
int max_count = 7; /* max repeat count */
int min_count = 4; /* min repeat count */
if (nextlen == 0) max_count = 138, min_count = 3;
tree[max_code+1].Len = (ush)0xffff; /* guard */
for (n = 0; n <= max_code; n++) {
curlen = nextlen; nextlen = tree[n+1].Len;
if (++count < max_count && curlen == nextlen) {
continue;
} else if (count < min_count) {
s->bl_tree[curlen].Freq += count;
} else if (curlen != 0) {
if (curlen != prevlen) s->bl_tree[curlen].Freq++;
s->bl_tree[REP_3_6].Freq++;
} else if (count <= 10) {
s->bl_tree[REPZ_3_10].Freq++;
} else {
s->bl_tree[REPZ_11_138].Freq++;
}
count = 0; prevlen = curlen;
if (nextlen == 0) {
max_count = 138, min_count = 3;
} else if (curlen == nextlen) {
max_count = 6, min_count = 3;
} else {
max_count = 7, min_count = 4;
}
}
}
/* ===========================================================================
* Send a literal or distance tree in compressed form, using the codes in
* bl_tree.
*/
local void send_tree (s, tree, max_code)
deflate_state *s;
ct_data *tree; /* the tree to be scanned */
int max_code; /* and its largest code of non zero frequency */
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
int curlen; /* length of current code */
int nextlen = tree[0].Len; /* length of next code */
int count = 0; /* repeat count of the current code */
int max_count = 7; /* max repeat count */
int min_count = 4; /* min repeat count */
/* tree[max_code+1].Len = -1; */ /* guard already set */
if (nextlen == 0) max_count = 138, min_count = 3;
for (n = 0; n <= max_code; n++) {
curlen = nextlen; nextlen = tree[n+1].Len;
if (++count < max_count && curlen == nextlen) {
continue;
} else if (count < min_count) {
do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
} else if (curlen != 0) {
if (curlen != prevlen) {
send_code(s, curlen, s->bl_tree); count--;
}
Assert(count >= 3 && count <= 6, " 3_6?");
send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
} else if (count <= 10) {
send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
} else {
send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
}
count = 0; prevlen = curlen;
if (nextlen == 0) {
max_count = 138, min_count = 3;
} else if (curlen == nextlen) {
max_count = 6, min_count = 3;
} else {
max_count = 7, min_count = 4;
}
}
}
/* ===========================================================================
* Construct the Huffman tree for the bit lengths and return the index in
* bl_order of the last bit length code to send.
*/
local int build_bl_tree(s)
deflate_state *s;
{
int max_blindex; /* index of last bit length code of non zero freq */
/* Determine the bit length frequencies for literal and distance trees */
scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
/* Build the bit length tree: */
build_tree(s, (tree_desc *)(&(s->bl_desc)));
/* opt_len now includes the length of the tree representations, except
* the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
*/
/* Determine the number of bit length codes to send. The pkzip format
* requires that at least 4 bit length codes be sent. (appnote.txt says
* 3 but the actual value used is 4.)
*/
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
}
/* Update opt_len to include the bit length tree and counts */
s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
s->opt_len, s->static_len));
return max_blindex;
}
/* ===========================================================================
* Send the header for a block using dynamic Huffman trees: the counts, the
* lengths of the bit length codes, the literal tree and the distance tree.
* IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
*/
local void send_all_trees(s, lcodes, dcodes, blcodes)
deflate_state *s;
int lcodes, dcodes, blcodes; /* number of codes for each tree */
{
int rank; /* index in bl_order */
Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
"too many codes");
Tracev((stderr, "\nbl counts: "));
send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
send_bits(s, dcodes-1, 5);
send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
for (rank = 0; rank < blcodes; rank++) {
Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
}
Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
}
/* ===========================================================================
* Send a stored block
*/
void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
deflate_state *s;
charf *buf; /* input block */
ulg stored_len; /* length of input block */
int last; /* one if this is the last block for a file */
{
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
bi_windup(s); /* align on byte boundary */
put_short(s, (ush)stored_len);
put_short(s, (ush)~stored_len);
zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
s->pending += stored_len;
#ifdef ZLIB_DEBUG
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
s->compressed_len += (stored_len + 4) << 3;
s->bits_sent += 2*16;
s->bits_sent += stored_len<<3;
#endif
}
/* ===========================================================================
* Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
*/
void ZLIB_INTERNAL _tr_flush_bits(s)
deflate_state *s;
{
bi_flush(s);
}
/* ===========================================================================
* Send one empty static block to give enough lookahead for inflate.
* This takes 10 bits, of which 7 may remain in the bit buffer.
*/
void ZLIB_INTERNAL _tr_align(s)
deflate_state *s;
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
}
/* ===========================================================================
* Determine the best encoding for the current block: dynamic trees, static
* trees or store, and write out the encoded block.
*/
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
deflate_state *s;
charf *buf; /* input block, or NULL if too old */
ulg stored_len; /* length of input block */
int last; /* one if this is the last block for a file */
{
ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
int max_blindex = 0; /* index of last bit length code of non zero freq */
/* Build the Huffman trees unless a stored block is forced */
if (s->level > 0) {
/* Check if the file is binary or text */
if (s->strm->data_type == Z_UNKNOWN)
s->strm->data_type = detect_data_type(s);
/* Construct the literal and distance trees */
build_tree(s, (tree_desc *)(&(s->l_desc)));
Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
s->static_len));
build_tree(s, (tree_desc *)(&(s->d_desc)));
Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
s->static_len));
/* At this point, opt_len and static_len are the total bit lengths of
* the compressed block data, excluding the tree representations.
*/
/* Build the bit length tree for the above two trees, and get the index
* in bl_order of the last bit length code to send.
*/
max_blindex = build_bl_tree(s);
/* Determine the best encoding. Compute the block lengths in bytes. */
opt_lenb = (s->opt_len+3+7)>>3;
static_lenb = (s->static_len+3+7)>>3;
Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
s->last_lit));
if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
} else {
Assert(buf != (char*)0, "lost buf");
opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
}
#ifdef FORCE_STORED
if (buf != (char*)0) { /* force stored block */
#else
if (stored_len+4 <= opt_lenb && buf != (char*)0) {
/* 4: two words for the lengths */
#endif
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
* Otherwise we can't have processed more than WSIZE input bytes since
* the last block flush, because compression would have been
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
* transform a block into a stored block.
*/
_tr_stored_block(s, buf, stored_len, last);
#ifdef FORCE_STATIC
} else if (static_lenb >= 0) { /* force static trees */
#else
} else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
#endif
send_bits(s, (STATIC_TREES<<1)+last, 3);
compress_block(s, (const ct_data *)static_ltree,
(const ct_data *)static_dtree);
#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->static_len;
#endif
} else {
send_bits(s, (DYN_TREES<<1)+last, 3);
send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
max_blindex+1);
compress_block(s, (const ct_data *)s->dyn_ltree,
(const ct_data *)s->dyn_dtree);
#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->opt_len;
#endif
}
Assert (s->compressed_len == s->bits_sent, "bad compressed size");
/* The above check is made mod 2^32, for files larger than 512 MB
* and uLong implemented on 32 bits.
*/
init_block(s);
if (last) {
bi_windup(s);
#ifdef ZLIB_DEBUG
s->compressed_len += 7; /* align on byte boundary */
#endif
}
Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
s->compressed_len-7*last));
}
/* ===========================================================================
* Save the match info and tally the frequency counts. Return true if
* the current block must be flushed.
*/
int ZLIB_INTERNAL _tr_tally (s, dist, lc)
deflate_state *s;
unsigned dist; /* distance of matched string */
unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
{
s->d_buf[s->last_lit] = (ush)dist;
s->l_buf[s->last_lit++] = (uch)lc;
if (dist == 0) {
/* lc is the unmatched char */
s->dyn_ltree[lc].Freq++;
} else {
s->matches++;
/* Here, lc is the match length - MIN_MATCH */
dist--; /* dist = match distance - 1 */
Assert((ush)dist < (ush)MAX_DIST(s) &&
(ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
(ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
s->dyn_dtree[d_code(dist)].Freq++;
}
#ifdef TRUNCATE_BLOCK
/* Try to guess if it is profitable to stop the current block here */
if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
/* Compute an upper bound for the compressed length */
ulg out_length = (ulg)s->last_lit*8L;
ulg in_length = (ulg)((long)s->strstart - s->block_start);
int dcode;
for (dcode = 0; dcode < D_CODES; dcode++) {
out_length += (ulg)s->dyn_dtree[dcode].Freq *
(5L+extra_dbits[dcode]);
}
out_length >>= 3;
Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
s->last_lit, in_length, out_length,
100L - out_length*100L/in_length));
if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
}
#endif
return (s->last_lit == s->lit_bufsize-1);
/* We avoid equality with lit_bufsize because of wraparound at 64K
* on 16 bit machines and because stored blocks are restricted to
* 64K-1 bytes.
*/
}
/* ===========================================================================
* Send the block data compressed using the given Huffman trees
*/
local void compress_block(s, ltree, dtree)
deflate_state *s;
const ct_data *ltree; /* literal tree */
const ct_data *dtree; /* distance tree */
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
unsigned lx = 0; /* running index in l_buf */
unsigned code; /* the code to send */
int extra; /* number of extra bits to send */
if (s->last_lit != 0) do {
dist = s->d_buf[lx];
lc = s->l_buf[lx++];
if (dist == 0) {
send_code(s, lc, ltree); /* send a literal byte */
Tracecv(isgraph(lc), (stderr," '%c' ", lc));
} else {
/* Here, lc is the match length - MIN_MATCH */
code = _length_code[lc];
send_code(s, code+LITERALS+1, ltree); /* send the length code */
extra = extra_lbits[code];
if (extra != 0) {
lc -= base_length[code];
send_bits(s, lc, extra); /* send the extra length bits */
}
dist--; /* dist is now the match distance - 1 */
code = d_code(dist);
Assert (code < D_CODES, "bad d_code");
send_code(s, code, dtree); /* send the distance code */
extra = extra_dbits[code];
if (extra != 0) {
dist -= (unsigned)base_dist[code];
send_bits(s, dist, extra); /* send the extra distance bits */
}
} /* literal or match pair ? */
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
"pendingBuf overflow");
} while (lx < s->last_lit);
send_code(s, END_BLOCK, ltree);
}
/* ===========================================================================
* Check if the data type is TEXT or BINARY, using the following algorithm:
* - TEXT if the two conditions below are satisfied:
* a) There are no non-portable control characters belonging to the
* "black list" (0..6, 14..25, 28..31).
* b) There is at least one printable character belonging to the
* "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
* - BINARY otherwise.
* - The following partially-portable control characters form a
* "gray list" that is ignored in this detection algorithm:
* (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
* IN assertion: the fields Freq of dyn_ltree are set.
*/
local int detect_data_type(s)
deflate_state *s;
{
/* black_mask is the bit mask of black-listed bytes
* set bits 0..6, 14..25, and 28..31
* 0xf3ffc07f = binary 11110011111111111100000001111111
*/
unsigned long black_mask = 0xf3ffc07fUL;
int n;
/* Check for non-textual ("black-listed") bytes. */
for (n = 0; n <= 31; n++, black_mask >>= 1)
if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
return Z_BINARY;
/* Check for textual ("white-listed") bytes. */
if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
|| s->dyn_ltree[13].Freq != 0)
return Z_TEXT;
for (n = 32; n < LITERALS; n++)
if (s->dyn_ltree[n].Freq != 0)
return Z_TEXT;
/* There are no "black-listed" or "white-listed" bytes:
* this stream either is empty or has tolerated ("gray-listed") bytes only.
*/
return Z_BINARY;
}
/* ===========================================================================
* Reverse the first len bits of a code, using straightforward code (a faster
* method would use a table)
* IN assertion: 1 <= len <= 15
*/
local unsigned bi_reverse(code, len)
unsigned code; /* the value to invert */
int len; /* its bit length */
{
register unsigned res = 0;
do {
res |= code & 1;
code >>= 1, res <<= 1;
} while (--len > 0);
return res >> 1;
}
/* ===========================================================================
* Flush the bit buffer, keeping at most 7 bits in it.
*/
local void bi_flush(s)
deflate_state *s;
{
if (s->bi_valid == 16) {
put_short(s, s->bi_buf);
s->bi_buf = 0;
s->bi_valid = 0;
} else if (s->bi_valid >= 8) {
put_byte(s, (Byte)s->bi_buf);
s->bi_buf >>= 8;
s->bi_valid -= 8;
}
}
/* ===========================================================================
* Flush the bit buffer and align the output on a byte boundary
*/
local void bi_windup(s)
deflate_state *s;
{
if (s->bi_valid > 8) {
put_short(s, s->bi_buf);
} else if (s->bi_valid > 0) {
put_byte(s, (Byte)s->bi_buf);
}
s->bi_buf = 0;
s->bi_valid = 0;
#ifdef ZLIB_DEBUG
s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
| /* trees.c -- output deflated data using Huffman coding
* Copyright (C) 1995-2017 Jean-loup Gailly
* detect_data_type() function provided freely by Cosmin Truta, 2006
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
* ALGORITHM
*
* The "deflation" process uses several Huffman trees. The more
* common source values are represented by shorter bit sequences.
*
* Each code tree is stored in a compressed form which is itself
* a Huffman encoding of the lengths of all the code strings (in
* ascending order by source values). The actual code strings are
* reconstructed from the lengths in the inflate process, as described
* in the deflate specification.
*
* REFERENCES
*
* Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
* Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
*
* Storer, James A.
* Data Compression: Methods and Theory, pp. 49-50.
* Computer Science Press, 1988. ISBN 0-7167-8156-5.
*
* Sedgewick, R.
* Algorithms, p290.
* Addison-Wesley, 1983. ISBN 0-201-06672-6.
*/
/* @(#) $Id$ */
/* #define GEN_TREES_H */
#include "deflate.h"
#ifdef ZLIB_DEBUG
# include <ctype.h>
#endif
/* ===========================================================================
* Constants
*/
#define MAX_BL_BITS 7
/* Bit length codes must not exceed MAX_BL_BITS bits */
#define END_BLOCK 256
/* end of block literal code */
#define REP_3_6 16
/* repeat previous bit length 3-6 times (2 bits of repeat count) */
#define REPZ_3_10 17
/* repeat a zero length 3-10 times (3 bits of repeat count) */
#define REPZ_11_138 18
/* repeat a zero length 11-138 times (7 bits of repeat count) */
local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
= {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
local const int extra_dbits[D_CODES] /* extra bits for each distance code */
= {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
local const uch bl_order[BL_CODES]
= {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
/* The lengths of the bit length codes are sent in order of decreasing
* probability, to avoid transmitting the lengths for unused bit length codes.
*/
/* ===========================================================================
* Local data. These are initialized only once.
*/
#define DIST_CODE_LEN 512 /* see definition of array dist_code below */
#if defined(GEN_TREES_H) || !defined(STDC)
/* non ANSI compilers may not accept trees.h */
local ct_data static_ltree[L_CODES+2];
/* The static literal tree. Since the bit lengths are imposed, there is no
* need for the L_CODES extra codes used during heap construction. However
* The codes 286 and 287 are needed to build a canonical tree (see _tr_init
* below).
*/
local ct_data static_dtree[D_CODES];
/* The static distance tree. (Actually a trivial tree since all codes use
* 5 bits.)
*/
uch _dist_code[DIST_CODE_LEN];
/* Distance codes. The first 256 values correspond to the distances
* 3 .. 258, the last 256 values correspond to the top 8 bits of
* the 15 bit distances.
*/
uch _length_code[MAX_MATCH-MIN_MATCH+1];
/* length code for each normalized match length (0 == MIN_MATCH) */
local int base_length[LENGTH_CODES];
/* First normalized length for each code (0 = MIN_MATCH) */
local int base_dist[D_CODES];
/* First normalized distance for each code (0 = distance of 1) */
#else
# include "trees.h"
#endif /* GEN_TREES_H */
struct static_tree_desc_s {
const ct_data *static_tree; /* static tree or NULL */
const intf *extra_bits; /* extra bits for each code or NULL */
int extra_base; /* base index for extra_bits */
int elems; /* max number of elements in the tree */
int max_length; /* max bit length for the codes */
};
local const static_tree_desc static_l_desc =
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
local const static_tree_desc static_d_desc =
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
local const static_tree_desc static_bl_desc =
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
/* ===========================================================================
* Local (static) routines in this file.
*/
local void tr_static_init OF((void));
local void init_block OF((deflate_state *s));
local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));
local void build_tree OF((deflate_state *s, tree_desc *desc));
local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
local int build_bl_tree OF((deflate_state *s));
local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
int blcodes));
local void compress_block OF((deflate_state *s, const ct_data *ltree,
const ct_data *dtree));
local int detect_data_type OF((deflate_state *s));
local unsigned bi_reverse OF((unsigned value, int length));
local void bi_windup OF((deflate_state *s));
local void bi_flush OF((deflate_state *s));
#ifdef GEN_TREES_H
local void gen_trees_header OF((void));
#endif
#ifndef ZLIB_DEBUG
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
/* Send a code of the given tree. c and tree must not have side effects */
#else /* !ZLIB_DEBUG */
# define send_code(s, c, tree) \
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
send_bits(s, tree[c].Code, tree[c].Len); }
#endif
/* ===========================================================================
* Output a short LSB first on the stream.
* IN assertion: there is enough room in pendingBuf.
*/
#define put_short(s, w) { \
put_byte(s, (uch)((w) & 0xff)); \
put_byte(s, (uch)((ush)(w) >> 8)); \
}
/* ===========================================================================
* Send a value on a given number of bits.
* IN assertion: length <= 16 and value fits in length bits.
*/
#ifdef ZLIB_DEBUG
local void send_bits OF((deflate_state *s, int value, int length));
local void send_bits(s, value, length)
deflate_state *s;
int value; /* value to send */
int length; /* number of bits */
{
Tracevv((stderr," l %2d v %4x ", length, value));
Assert(length > 0 && length <= 15, "invalid length");
s->bits_sent += (ulg)length;
/* If not enough room in bi_buf, use (valid) bits from bi_buf and
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
* unused bits in value.
*/
if (s->bi_valid > (int)Buf_size - length) {
s->bi_buf |= (ush)value << s->bi_valid;
put_short(s, s->bi_buf);
s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
s->bi_valid += length - Buf_size;
} else {
s->bi_buf |= (ush)value << s->bi_valid;
s->bi_valid += length;
}
}
#else /* !ZLIB_DEBUG */
#define send_bits(s, value, length) \
{ int len = length;\
if (s->bi_valid > (int)Buf_size - len) {\
int val = (int)value;\
s->bi_buf |= (ush)val << s->bi_valid;\
put_short(s, s->bi_buf);\
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
s->bi_valid += len - Buf_size;\
} else {\
s->bi_buf |= (ush)(value) << s->bi_valid;\
s->bi_valid += len;\
}\
}
#endif /* ZLIB_DEBUG */
/* the arguments must not have side effects */
/* ===========================================================================
* Initialize the various 'constant' tables.
*/
local void tr_static_init()
{
#if defined(GEN_TREES_H) || !defined(STDC)
static int static_init_done = 0;
int n; /* iterates over tree elements */
int bits; /* bit counter */
int length; /* length value */
int code; /* code value */
int dist; /* distance index */
ush bl_count[MAX_BITS+1];
/* number of codes at each bit length for an optimal tree */
if (static_init_done) return;
/* For some embedded targets, global variables are not initialized: */
#ifdef NO_INIT_GLOBAL_POINTERS
static_l_desc.static_tree = static_ltree;
static_l_desc.extra_bits = extra_lbits;
static_d_desc.static_tree = static_dtree;
static_d_desc.extra_bits = extra_dbits;
static_bl_desc.extra_bits = extra_blbits;
#endif
/* Initialize the mapping length (0..255) -> length code (0..28) */
length = 0;
for (code = 0; code < LENGTH_CODES-1; code++) {
base_length[code] = length;
for (n = 0; n < (1<<extra_lbits[code]); n++) {
_length_code[length++] = (uch)code;
}
}
Assert (length == 256, "tr_static_init: length != 256");
/* Note that the length 255 (match length 258) can be represented
* in two different ways: code 284 + 5 bits or code 285, so we
* overwrite length_code[255] to use the best encoding:
*/
_length_code[length-1] = (uch)code;
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */
dist = 0;
for (code = 0 ; code < 16; code++) {
base_dist[code] = dist;
for (n = 0; n < (1<<extra_dbits[code]); n++) {
_dist_code[dist++] = (uch)code;
}
}
Assert (dist == 256, "tr_static_init: dist != 256");
dist >>= 7; /* from now on, all distances are divided by 128 */
for ( ; code < D_CODES; code++) {
base_dist[code] = dist << 7;
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
_dist_code[256 + dist++] = (uch)code;
}
}
Assert (dist == 256, "tr_static_init: 256+dist != 512");
/* Construct the codes of the static literal tree */
for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
n = 0;
while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
/* Codes 286 and 287 do not exist, but we must include them in the
* tree construction to get a canonical Huffman tree (longest code
* all ones)
*/
gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
/* The static distance tree is trivial: */
for (n = 0; n < D_CODES; n++) {
static_dtree[n].Len = 5;
static_dtree[n].Code = bi_reverse((unsigned)n, 5);
}
static_init_done = 1;
# ifdef GEN_TREES_H
gen_trees_header();
# endif
#endif /* defined(GEN_TREES_H) || !defined(STDC) */
}
/* ===========================================================================
* Genererate the file trees.h describing the static trees.
*/
#ifdef GEN_TREES_H
# ifndef ZLIB_DEBUG
# include <stdio.h>
# endif
# define SEPARATOR(i, last, width) \
((i) == (last)? "\n};\n\n" : \
((i) % (width) == (width)-1 ? ",\n" : ", "))
void gen_trees_header()
{
FILE *header = fopen("trees.h", "w");
int i;
Assert (header != NULL, "Can't open trees.h");
fprintf(header,
"/* header created automatically with -DGEN_TREES_H */\n\n");
fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
for (i = 0; i < L_CODES+2; i++) {
fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
}
fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
for (i = 0; i < D_CODES; i++) {
fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
}
fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
for (i = 0; i < DIST_CODE_LEN; i++) {
fprintf(header, "%2u%s", _dist_code[i],
SEPARATOR(i, DIST_CODE_LEN-1, 20));
}
fprintf(header,
"const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
fprintf(header, "%2u%s", _length_code[i],
SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
}
fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
for (i = 0; i < LENGTH_CODES; i++) {
fprintf(header, "%1u%s", base_length[i],
SEPARATOR(i, LENGTH_CODES-1, 20));
}
fprintf(header, "local const int base_dist[D_CODES] = {\n");
for (i = 0; i < D_CODES; i++) {
fprintf(header, "%5u%s", base_dist[i],
SEPARATOR(i, D_CODES-1, 10));
}
fclose(header);
}
#endif /* GEN_TREES_H */
/* ===========================================================================
* Initialize the tree data structures for a new zlib stream.
*/
void ZLIB_INTERNAL _tr_init(s)
deflate_state *s;
{
tr_static_init();
s->l_desc.dyn_tree = s->dyn_ltree;
s->l_desc.stat_desc = &static_l_desc;
s->d_desc.dyn_tree = s->dyn_dtree;
s->d_desc.stat_desc = &static_d_desc;
s->bl_desc.dyn_tree = s->bl_tree;
s->bl_desc.stat_desc = &static_bl_desc;
s->bi_buf = 0;
s->bi_valid = 0;
#ifdef ZLIB_DEBUG
s->compressed_len = 0L;
s->bits_sent = 0L;
#endif
/* Initialize the first block of the first file: */
init_block(s);
}
/* ===========================================================================
* Initialize a new block.
*/
local void init_block(s)
deflate_state *s;
{
int n; /* iterates over tree elements */
/* Initialize the trees. */
for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
s->dyn_ltree[END_BLOCK].Freq = 1;
s->opt_len = s->static_len = 0L;
s->last_lit = s->matches = 0;
}
#define SMALLEST 1
/* Index within the heap array of least frequent node in the Huffman tree */
/* ===========================================================================
* Remove the smallest element from the heap and recreate the heap with
* one less element. Updates heap and heap_len.
*/
#define pqremove(s, tree, top) \
{\
top = s->heap[SMALLEST]; \
s->heap[SMALLEST] = s->heap[s->heap_len--]; \
pqdownheap(s, tree, SMALLEST); \
}
/* ===========================================================================
* Compares to subtrees, using the tree depth as tie breaker when
* the subtrees have equal frequency. This minimizes the worst case length.
*/
#define smaller(tree, n, m, depth) \
(tree[n].Freq < tree[m].Freq || \
(tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
/* ===========================================================================
* Restore the heap property by moving down the tree starting at node k,
* exchanging a node with the smallest of its two sons if necessary, stopping
* when the heap property is re-established (each father smaller than its
* two sons).
*/
local void pqdownheap(s, tree, k)
deflate_state *s;
ct_data *tree; /* the tree to restore */
int k; /* node to move down */
{
int v = s->heap[k];
int j = k << 1; /* left son of k */
while (j <= s->heap_len) {
/* Set j to the smallest of the two sons: */
if (j < s->heap_len &&
smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
j++;
}
/* Exit if v is smaller than both sons */
if (smaller(tree, v, s->heap[j], s->depth)) break;
/* Exchange v with the smallest son */
s->heap[k] = s->heap[j]; k = j;
/* And continue down the tree, setting j to the left son of k */
j <<= 1;
}
s->heap[k] = v;
}
/* ===========================================================================
* Compute the optimal bit lengths for a tree and update the total bit length
* for the current block.
* IN assertion: the fields freq and dad are set, heap[heap_max] and
* above are the tree nodes sorted by increasing frequency.
* OUT assertions: the field len is set to the optimal bit length, the
* array bl_count contains the frequencies for each bit length.
* The length opt_len is updated; static_len is also updated if stree is
* not null.
*/
local void gen_bitlen(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
int max_code = desc->max_code;
const ct_data *stree = desc->stat_desc->static_tree;
const intf *extra = desc->stat_desc->extra_bits;
int base = desc->stat_desc->extra_base;
int max_length = desc->stat_desc->max_length;
int h; /* heap index */
int n, m; /* iterate over the tree elements */
int bits; /* bit length */
int xbits; /* extra bits */
ush f; /* frequency */
int overflow = 0; /* number of elements with bit length too large */
for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
/* In a first pass, compute the optimal bit lengths (which may
* overflow in the case of the bit length tree).
*/
tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
n = s->heap[h];
bits = tree[tree[n].Dad].Len + 1;
if (bits > max_length) bits = max_length, overflow++;
tree[n].Len = (ush)bits;
/* We overwrite tree[n].Dad which is no longer needed */
if (n > max_code) continue; /* not a leaf node */
s->bl_count[bits]++;
xbits = 0;
if (n >= base) xbits = extra[n-base];
f = tree[n].Freq;
s->opt_len += (ulg)f * (unsigned)(bits + xbits);
if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
}
if (overflow == 0) return;
Tracev((stderr,"\nbit length overflow\n"));
/* This happens for example on obj2 and pic of the Calgary corpus */
/* Find the first bit length which could increase: */
do {
bits = max_length-1;
while (s->bl_count[bits] == 0) bits--;
s->bl_count[bits]--; /* move one leaf down the tree */
s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
s->bl_count[max_length]--;
/* The brother of the overflow item also moves one step up,
* but this does not affect bl_count[max_length]
*/
overflow -= 2;
} while (overflow > 0);
/* Now recompute all bit lengths, scanning in increasing frequency.
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
* lengths instead of fixing only the wrong ones. This idea is taken
* from 'ar' written by Haruhiko Okumura.)
*/
for (bits = max_length; bits != 0; bits--) {
n = s->bl_count[bits];
while (n != 0) {
m = s->heap[--h];
if (m > max_code) continue;
if ((unsigned) tree[m].Len != (unsigned) bits) {
Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
tree[m].Len = (ush)bits;
}
n--;
}
}
}
/* ===========================================================================
* Generate the codes for a given tree and bit counts (which need not be
* optimal).
* IN assertion: the array bl_count contains the bit length statistics for
* the given tree and the field len is set for all tree elements.
* OUT assertion: the field code is set for all tree elements of non
* zero code length.
*/
local void gen_codes (tree, max_code, bl_count)
ct_data *tree; /* the tree to decorate */
int max_code; /* largest code with non zero frequency */
ushf *bl_count; /* number of codes at each bit length */
{
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
unsigned code = 0; /* running code value */
int bits; /* bit index */
int n; /* code index */
/* The distribution counts are first used to generate the code values
* without bit reversal.
*/
for (bits = 1; bits <= MAX_BITS; bits++) {
code = (code + bl_count[bits-1]) << 1;
next_code[bits] = (ush)code;
}
/* Check that the bit counts in bl_count are consistent. The last code
* must be all ones.
*/
Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
"inconsistent bit counts");
Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
for (n = 0; n <= max_code; n++) {
int len = tree[n].Len;
if (len == 0) continue;
/* Now reverse the bits */
tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
}
}
/* ===========================================================================
* Construct one Huffman tree and assigns the code bit strings and lengths.
* Update the total bit length for the current block.
* IN assertion: the field freq is set for all tree elements.
* OUT assertions: the fields len and code are set to the optimal bit length
* and corresponding code. The length opt_len is updated; static_len is
* also updated if stree is not null. The field max_code is set.
*/
local void build_tree(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
int elems = desc->stat_desc->elems;
int n, m; /* iterate over heap elements */
int max_code = -1; /* largest code with non zero frequency */
int node; /* new node being created */
/* Construct the initial heap, with least frequent element in
* heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
* heap[0] is not used.
*/
s->heap_len = 0, s->heap_max = HEAP_SIZE;
for (n = 0; n < elems; n++) {
if (tree[n].Freq != 0) {
s->heap[++(s->heap_len)] = max_code = n;
s->depth[n] = 0;
} else {
tree[n].Len = 0;
}
}
/* The pkzip format requires that at least one distance code exists,
* and that at least one bit should be sent even if there is only one
* possible code. So to avoid special checks later on we force at least
* two codes of non zero frequency.
*/
while (s->heap_len < 2) {
node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
tree[node].Freq = 1;
s->depth[node] = 0;
s->opt_len--; if (stree) s->static_len -= stree[node].Len;
/* node is 0 or 1 so it does not have extra bits */
}
desc->max_code = max_code;
/* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
* establish sub-heaps of increasing lengths:
*/
for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
/* Construct the Huffman tree by repeatedly combining the least two
* frequent nodes.
*/
node = elems; /* next internal node of the tree */
do {
pqremove(s, tree, n); /* n = node of least frequency */
m = s->heap[SMALLEST]; /* m = node of next least frequency */
s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
s->heap[--(s->heap_max)] = m;
/* Create a new node father of n and m */
tree[node].Freq = tree[n].Freq + tree[m].Freq;
s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
s->depth[n] : s->depth[m]) + 1);
tree[n].Dad = tree[m].Dad = (ush)node;
#ifdef DUMP_BL_TREE
if (tree == s->bl_tree) {
fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
}
#endif
/* and insert the new node in the heap */
s->heap[SMALLEST] = node++;
pqdownheap(s, tree, SMALLEST);
} while (s->heap_len >= 2);
s->heap[--(s->heap_max)] = s->heap[SMALLEST];
/* At this point, the fields freq and dad are set. We can now
* generate the bit lengths.
*/
gen_bitlen(s, (tree_desc *)desc);
/* The field len is now set, we can generate the bit codes */
gen_codes ((ct_data *)tree, max_code, s->bl_count);
}
/* ===========================================================================
* Scan a literal or distance tree to determine the frequencies of the codes
* in the bit length tree.
*/
local void scan_tree (s, tree, max_code)
deflate_state *s;
ct_data *tree; /* the tree to be scanned */
int max_code; /* and its largest code of non zero frequency */
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
int curlen; /* length of current code */
int nextlen = tree[0].Len; /* length of next code */
int count = 0; /* repeat count of the current code */
int max_count = 7; /* max repeat count */
int min_count = 4; /* min repeat count */
if (nextlen == 0) max_count = 138, min_count = 3;
tree[max_code+1].Len = (ush)0xffff; /* guard */
for (n = 0; n <= max_code; n++) {
curlen = nextlen; nextlen = tree[n+1].Len;
if (++count < max_count && curlen == nextlen) {
continue;
} else if (count < min_count) {
s->bl_tree[curlen].Freq += count;
} else if (curlen != 0) {
if (curlen != prevlen) s->bl_tree[curlen].Freq++;
s->bl_tree[REP_3_6].Freq++;
} else if (count <= 10) {
s->bl_tree[REPZ_3_10].Freq++;
} else {
s->bl_tree[REPZ_11_138].Freq++;
}
count = 0; prevlen = curlen;
if (nextlen == 0) {
max_count = 138, min_count = 3;
} else if (curlen == nextlen) {
max_count = 6, min_count = 3;
} else {
max_count = 7, min_count = 4;
}
}
}
/* ===========================================================================
* Send a literal or distance tree in compressed form, using the codes in
* bl_tree.
*/
local void send_tree (s, tree, max_code)
deflate_state *s;
ct_data *tree; /* the tree to be scanned */
int max_code; /* and its largest code of non zero frequency */
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
int curlen; /* length of current code */
int nextlen = tree[0].Len; /* length of next code */
int count = 0; /* repeat count of the current code */
int max_count = 7; /* max repeat count */
int min_count = 4; /* min repeat count */
/* tree[max_code+1].Len = -1; */ /* guard already set */
if (nextlen == 0) max_count = 138, min_count = 3;
for (n = 0; n <= max_code; n++) {
curlen = nextlen; nextlen = tree[n+1].Len;
if (++count < max_count && curlen == nextlen) {
continue;
} else if (count < min_count) {
do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
} else if (curlen != 0) {
if (curlen != prevlen) {
send_code(s, curlen, s->bl_tree); count--;
}
Assert(count >= 3 && count <= 6, " 3_6?");
send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
} else if (count <= 10) {
send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
} else {
send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
}
count = 0; prevlen = curlen;
if (nextlen == 0) {
max_count = 138, min_count = 3;
} else if (curlen == nextlen) {
max_count = 6, min_count = 3;
} else {
max_count = 7, min_count = 4;
}
}
}
/* ===========================================================================
* Construct the Huffman tree for the bit lengths and return the index in
* bl_order of the last bit length code to send.
*/
local int build_bl_tree(s)
deflate_state *s;
{
int max_blindex; /* index of last bit length code of non zero freq */
/* Determine the bit length frequencies for literal and distance trees */
scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
/* Build the bit length tree: */
build_tree(s, (tree_desc *)(&(s->bl_desc)));
/* opt_len now includes the length of the tree representations, except
* the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
*/
/* Determine the number of bit length codes to send. The pkzip format
* requires that at least 4 bit length codes be sent. (appnote.txt says
* 3 but the actual value used is 4.)
*/
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
}
/* Update opt_len to include the bit length tree and counts */
s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
s->opt_len, s->static_len));
return max_blindex;
}
/* ===========================================================================
* Send the header for a block using dynamic Huffman trees: the counts, the
* lengths of the bit length codes, the literal tree and the distance tree.
* IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
*/
local void send_all_trees(s, lcodes, dcodes, blcodes)
deflate_state *s;
int lcodes, dcodes, blcodes; /* number of codes for each tree */
{
int rank; /* index in bl_order */
Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
"too many codes");
Tracev((stderr, "\nbl counts: "));
send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
send_bits(s, dcodes-1, 5);
send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
for (rank = 0; rank < blcodes; rank++) {
Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
}
Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
}
/* ===========================================================================
* Send a stored block
*/
void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
deflate_state *s;
charf *buf; /* input block */
ulg stored_len; /* length of input block */
int last; /* one if this is the last block for a file */
{
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
bi_windup(s); /* align on byte boundary */
put_short(s, (ush)stored_len);
put_short(s, (ush)~stored_len);
zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
s->pending += stored_len;
#ifdef ZLIB_DEBUG
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
s->compressed_len += (stored_len + 4) << 3;
s->bits_sent += 2*16;
s->bits_sent += stored_len<<3;
#endif
}
/* ===========================================================================
* Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
*/
void ZLIB_INTERNAL _tr_flush_bits(s)
deflate_state *s;
{
bi_flush(s);
}
/* ===========================================================================
* Send one empty static block to give enough lookahead for inflate.
* This takes 10 bits, of which 7 may remain in the bit buffer.
*/
void ZLIB_INTERNAL _tr_align(s)
deflate_state *s;
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
}
/* ===========================================================================
* Determine the best encoding for the current block: dynamic trees, static
* trees or store, and write out the encoded block.
*/
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
deflate_state *s;
charf *buf; /* input block, or NULL if too old */
ulg stored_len; /* length of input block */
int last; /* one if this is the last block for a file */
{
ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
int max_blindex = 0; /* index of last bit length code of non zero freq */
/* Build the Huffman trees unless a stored block is forced */
if (s->level > 0) {
/* Check if the file is binary or text */
if (s->strm->data_type == Z_UNKNOWN)
s->strm->data_type = detect_data_type(s);
/* Construct the literal and distance trees */
build_tree(s, (tree_desc *)(&(s->l_desc)));
Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
s->static_len));
build_tree(s, (tree_desc *)(&(s->d_desc)));
Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
s->static_len));
/* At this point, opt_len and static_len are the total bit lengths of
* the compressed block data, excluding the tree representations.
*/
/* Build the bit length tree for the above two trees, and get the index
* in bl_order of the last bit length code to send.
*/
max_blindex = build_bl_tree(s);
/* Determine the best encoding. Compute the block lengths in bytes. */
opt_lenb = (s->opt_len+3+7)>>3;
static_lenb = (s->static_len+3+7)>>3;
Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
s->last_lit));
if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
} else {
Assert(buf != (char*)0, "lost buf");
opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
}
#ifdef FORCE_STORED
if (buf != (char*)0) { /* force stored block */
#else
if (stored_len+4 <= opt_lenb && buf != (char*)0) {
/* 4: two words for the lengths */
#endif
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
* Otherwise we can't have processed more than WSIZE input bytes since
* the last block flush, because compression would have been
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
* transform a block into a stored block.
*/
_tr_stored_block(s, buf, stored_len, last);
#ifdef FORCE_STATIC
} else if (static_lenb >= 0) { /* force static trees */
#else
} else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
#endif
send_bits(s, (STATIC_TREES<<1)+last, 3);
compress_block(s, (const ct_data *)static_ltree,
(const ct_data *)static_dtree);
#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->static_len;
#endif
} else {
send_bits(s, (DYN_TREES<<1)+last, 3);
send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
max_blindex+1);
compress_block(s, (const ct_data *)s->dyn_ltree,
(const ct_data *)s->dyn_dtree);
#ifdef ZLIB_DEBUG
s->compressed_len += 3 + s->opt_len;
#endif
}
Assert (s->compressed_len == s->bits_sent, "bad compressed size");
/* The above check is made mod 2^32, for files larger than 512 MB
* and uLong implemented on 32 bits.
*/
init_block(s);
if (last) {
bi_windup(s);
#ifdef ZLIB_DEBUG
s->compressed_len += 7; /* align on byte boundary */
#endif
}
Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
s->compressed_len-7*last));
}
/* ===========================================================================
* Save the match info and tally the frequency counts. Return true if
* the current block must be flushed.
*/
int ZLIB_INTERNAL _tr_tally (s, dist, lc)
deflate_state *s;
unsigned dist; /* distance of matched string */
unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
{
s->d_buf[s->last_lit] = (ush)dist;
s->l_buf[s->last_lit++] = (uch)lc;
if (dist == 0) {
/* lc is the unmatched char */
s->dyn_ltree[lc].Freq++;
} else {
s->matches++;
/* Here, lc is the match length - MIN_MATCH */
dist--; /* dist = match distance - 1 */
Assert((ush)dist < (ush)MAX_DIST(s) &&
(ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
(ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
s->dyn_dtree[d_code(dist)].Freq++;
}
#ifdef TRUNCATE_BLOCK
/* Try to guess if it is profitable to stop the current block here */
if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
/* Compute an upper bound for the compressed length */
ulg out_length = (ulg)s->last_lit*8L;
ulg in_length = (ulg)((long)s->strstart - s->block_start);
int dcode;
for (dcode = 0; dcode < D_CODES; dcode++) {
out_length += (ulg)s->dyn_dtree[dcode].Freq *
(5L+extra_dbits[dcode]);
}
out_length >>= 3;
Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
s->last_lit, in_length, out_length,
100L - out_length*100L/in_length));
if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
}
#endif
return (s->last_lit == s->lit_bufsize-1);
/* We avoid equality with lit_bufsize because of wraparound at 64K
* on 16 bit machines and because stored blocks are restricted to
* 64K-1 bytes.
*/
}
/* ===========================================================================
* Send the block data compressed using the given Huffman trees
*/
local void compress_block(s, ltree, dtree)
deflate_state *s;
const ct_data *ltree; /* literal tree */
const ct_data *dtree; /* distance tree */
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
unsigned lx = 0; /* running index in l_buf */
unsigned code; /* the code to send */
int extra; /* number of extra bits to send */
if (s->last_lit != 0) do {
dist = s->d_buf[lx];
lc = s->l_buf[lx++];
if (dist == 0) {
send_code(s, lc, ltree); /* send a literal byte */
Tracecv(isgraph(lc), (stderr," '%c' ", lc));
} else {
/* Here, lc is the match length - MIN_MATCH */
code = _length_code[lc];
send_code(s, code+LITERALS+1, ltree); /* send the length code */
extra = extra_lbits[code];
if (extra != 0) {
lc -= base_length[code];
send_bits(s, lc, extra); /* send the extra length bits */
}
dist--; /* dist is now the match distance - 1 */
code = d_code(dist);
Assert (code < D_CODES, "bad d_code");
send_code(s, code, dtree); /* send the distance code */
extra = extra_dbits[code];
if (extra != 0) {
dist -= (unsigned)base_dist[code];
send_bits(s, dist, extra); /* send the extra distance bits */
}
} /* literal or match pair ? */
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
"pendingBuf overflow");
} while (lx < s->last_lit);
send_code(s, END_BLOCK, ltree);
}
/* ===========================================================================
* Check if the data type is TEXT or BINARY, using the following algorithm:
* - TEXT if the two conditions below are satisfied:
* a) There are no non-portable control characters belonging to the
* "black list" (0..6, 14..25, 28..31).
* b) There is at least one printable character belonging to the
* "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
* - BINARY otherwise.
* - The following partially-portable control characters form a
* "gray list" that is ignored in this detection algorithm:
* (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
* IN assertion: the fields Freq of dyn_ltree are set.
*/
local int detect_data_type(s)
deflate_state *s;
{
/* black_mask is the bit mask of black-listed bytes
* set bits 0..6, 14..25, and 28..31
* 0xf3ffc07f = binary 11110011111111111100000001111111
*/
unsigned long black_mask = 0xf3ffc07fUL;
int n;
/* Check for non-textual ("black-listed") bytes. */
for (n = 0; n <= 31; n++, black_mask >>= 1)
if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
return Z_BINARY;
/* Check for textual ("white-listed") bytes. */
if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
|| s->dyn_ltree[13].Freq != 0)
return Z_TEXT;
for (n = 32; n < LITERALS; n++)
if (s->dyn_ltree[n].Freq != 0)
return Z_TEXT;
/* There are no "black-listed" or "white-listed" bytes:
* this stream either is empty or has tolerated ("gray-listed") bytes only.
*/
return Z_BINARY;
}
/* ===========================================================================
* Reverse the first len bits of a code, using straightforward code (a faster
* method would use a table)
* IN assertion: 1 <= len <= 15
*/
local unsigned bi_reverse(code, len)
unsigned code; /* the value to invert */
int len; /* its bit length */
{
register unsigned res = 0;
do {
res |= code & 1;
code >>= 1, res <<= 1;
} while (--len > 0);
return res >> 1;
}
/* ===========================================================================
* Flush the bit buffer, keeping at most 7 bits in it.
*/
local void bi_flush(s)
deflate_state *s;
{
if (s->bi_valid == 16) {
put_short(s, s->bi_buf);
s->bi_buf = 0;
s->bi_valid = 0;
} else if (s->bi_valid >= 8) {
put_byte(s, (Byte)s->bi_buf);
s->bi_buf >>= 8;
s->bi_valid -= 8;
}
}
/* ===========================================================================
* Flush the bit buffer and align the output on a byte boundary
*/
local void bi_windup(s)
deflate_state *s;
{
if (s->bi_valid > 8) {
put_short(s, s->bi_buf);
} else if (s->bi_valid > 0) {
put_byte(s, (Byte)s->bi_buf);
}
s->bi_buf = 0;
s->bi_valid = 0;
#ifdef ZLIB_DEBUG
s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/tools/superpmi/superpmi-shared/agnostic.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//----------------------------------------------------------
// agnostic.h - Definition of platform-agnostic data types used by SuperPMI.
// MethodContext and CompileResult types use these.
//----------------------------------------------------------
#ifndef _Agnostic
#define _Agnostic
#pragma pack(push, 1)
struct Agnostic_CORINFO_SIG_INFO
{
DWORD callConv;
DWORDLONG retTypeClass;
DWORDLONG retTypeSigClass;
DWORD retType;
DWORD flags;
DWORD numArgs;
DWORD sigInst_classInstCount;
DWORD sigInst_classInst_Index;
DWORD sigInst_methInstCount;
DWORD sigInst_methInst_Index;
DWORDLONG args;
DWORD pSig_Index;
DWORD cbSig;
DWORDLONG methodSignature;
DWORDLONG scope;
DWORD token;
};
struct Agnostic_CORINFO_METHOD_INFO
{
DWORDLONG ftn;
DWORDLONG scope;
DWORD ILCode_offset;
DWORD ILCodeSize;
DWORD maxStack;
DWORD EHcount;
DWORD options;
DWORD regionKind;
Agnostic_CORINFO_SIG_INFO args;
Agnostic_CORINFO_SIG_INFO locals;
};
struct Agnostic_CompileMethod
{
Agnostic_CORINFO_METHOD_INFO info;
DWORD flags;
DWORD os;
};
struct Agnostic_InitClass
{
DWORDLONG field;
DWORDLONG method;
DWORDLONG context;
};
struct DLDL
{
DWORDLONG A;
DWORDLONG B;
};
struct Agnostic_CanInline
{
DWORD result;
DWORD exceptionCode;
};
struct Agnostic_GetClassGClayout
{
DWORD gcPtrs_Index;
DWORD len;
DWORD valCount;
};
struct DLD
{
DWORDLONG A;
DWORD B;
};
struct DLDD
{
DWORDLONG A;
DWORD B;
DWORD C;
};
struct Agnostic_CORINFO_METHODNAME_TOKENin
{
DWORDLONG ftn;
DWORD className;
DWORD namespaceName;
DWORD enclosingClassName;
};
struct Agnostic_CORINFO_METHODNAME_TOKENout
{
DWORD methodName;
DWORD className;
DWORD namespaceName;
DWORD enclosingClassName;
};
struct Agnostic_CORINFO_RESOLVED_TOKENin
{
DWORDLONG tokenContext;
DWORDLONG tokenScope;
DWORD token;
DWORD tokenType;
};
struct Agnostic_CORINFO_RESOLVED_TOKENout
{
DWORDLONG hClass;
DWORDLONG hMethod;
DWORDLONG hField;
DWORD pTypeSpec_Index;
DWORD cbTypeSpec;
DWORD pMethodSpec_Index;
DWORD cbMethodSpec;
};
struct Agnostic_GetArgType_Key
{
// Partial CORINFO_SIG_INFO data
DWORD flags;
DWORD numArgs;
DWORD sigInst_classInstCount;
DWORD sigInst_classInst_Index;
DWORD sigInst_methInstCount;
DWORD sigInst_methInst_Index;
DWORDLONG methodSignature;
DWORDLONG scope;
// Other getArgType() arguments
DWORDLONG args;
};
struct Agnostic_GetArgClass_Key
{
DWORD sigInst_classInstCount;
DWORD sigInst_classInst_Index;
DWORD sigInst_methInstCount;
DWORD sigInst_methInst_Index;
DWORDLONG methodSignature;
DWORDLONG scope;
DWORDLONG args;
};
struct Agnostic_GetBoundaries
{
DWORD cILOffsets;
DWORD pILOffset_offset;
DWORD implicitBoundaries;
};
struct Agnostic_CORINFO_EE_INFO
{
struct Agnostic_InlinedCallFrameInfo
{
DWORD size;
DWORD offsetOfGSCookie;
DWORD offsetOfFrameVptr;
DWORD offsetOfFrameLink;
DWORD offsetOfCallSiteSP;
DWORD offsetOfCalleeSavedFP;
DWORD offsetOfCallTarget;
DWORD offsetOfReturnAddress;
} inlinedCallFrameInfo;
DWORD offsetOfThreadFrame;
DWORD offsetOfGCState;
DWORD offsetOfDelegateInstance;
DWORD offsetOfDelegateFirstTarget;
DWORD offsetOfWrapperDelegateIndirectCell;
DWORD sizeOfReversePInvokeFrame;
DWORD osPageSize;
DWORD maxUncheckedOffsetForNullObject;
DWORD targetAbi;
DWORD osType;
};
struct Agnostic_GetOSRInfo
{
DWORD index;
unsigned ilOffset;
};
struct Agnostic_GetFieldAddress
{
DWORDLONG ppIndirection;
DWORDLONG fieldAddress;
DWORD fieldValue;
};
struct Agnostic_GetStaticFieldCurrentClass
{
DWORDLONG classHandle;
bool isSpeculative;
};
struct Agnostic_CORINFO_RESOLVED_TOKEN
{
Agnostic_CORINFO_RESOLVED_TOKENin inValue;
Agnostic_CORINFO_RESOLVED_TOKENout outValue;
};
struct Agnostic_GetFieldInfo
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
DWORDLONG callerHandle;
DWORD flags;
};
struct Agnostic_CORINFO_HELPER_ARG
{
DWORDLONG constant; // one view of a large union of ptr size
DWORD argType;
};
struct Agnostic_CORINFO_HELPER_DESC
{
DWORD helperNum;
DWORD numArgs;
Agnostic_CORINFO_HELPER_ARG args[CORINFO_ACCESS_ALLOWED_MAX_ARGS];
};
struct Agnostic_CORINFO_CONST_LOOKUP
{
DWORD accessType;
DWORDLONG handle; // actually a union of two pointer sized things
};
struct Agnostic_CORINFO_LOOKUP_KIND
{
DWORD needsRuntimeLookup;
DWORD runtimeLookupKind;
WORD runtimeLookupFlags;
};
struct Agnostic_CORINFO_RUNTIME_LOOKUP
{
DWORDLONG signature;
DWORD helper;
DWORD indirections;
DWORD testForNull;
DWORD testForFixup;
WORD sizeOffset;
DWORDLONG offsets[CORINFO_MAXINDIRECTIONS];
DWORD indirectFirstOffset;
DWORD indirectSecondOffset;
};
struct Agnostic_CORINFO_LOOKUP
{
Agnostic_CORINFO_LOOKUP_KIND lookupKind;
Agnostic_CORINFO_RUNTIME_LOOKUP runtimeLookup; // This and constLookup actually a union, but with different
// layouts.. :-| copy the right one based on lookupKinds value
Agnostic_CORINFO_CONST_LOOKUP constLookup;
};
struct Agnostic_CORINFO_FIELD_INFO
{
DWORD fieldAccessor;
DWORD fieldFlags;
DWORD helper;
DWORD offset;
DWORD fieldType;
DWORDLONG structType;
DWORD accessAllowed;
Agnostic_CORINFO_HELPER_DESC accessCalloutHelper;
Agnostic_CORINFO_CONST_LOOKUP fieldLookup;
};
struct DD
{
DWORD A;
DWORD B;
};
struct DDD
{
DWORD A;
DWORD B;
DWORD C;
};
struct Agnostic_CanTailCall
{
DWORDLONG callerHnd;
DWORDLONG declaredCalleeHnd;
DWORDLONG exactCalleeHnd;
WORD fIsTailPrefix;
};
struct Agnostic_Environment
{
DWORD name_index;
;
DWORD val_index;
};
struct Agnostic_GetCallInfo
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
Agnostic_CORINFO_RESOLVED_TOKEN ConstrainedResolvedToken;
DWORDLONG callerHandle;
DWORD flags;
};
struct Agnostic_CORINFO_CALL_INFO
{
DWORDLONG hMethod;
DWORD methodFlags;
DWORD classFlags;
Agnostic_CORINFO_SIG_INFO sig;
DWORD verMethodFlags;
Agnostic_CORINFO_SIG_INFO verSig;
DWORD accessAllowed;
Agnostic_CORINFO_HELPER_DESC callsiteCalloutHelper;
DWORD thisTransform;
DWORD kind;
DWORD nullInstanceCheck;
DWORDLONG contextHandle;
DWORD exactContextNeedsRuntimeLookup;
Agnostic_CORINFO_LOOKUP stubLookup; // first view of union. others are matching or subordinate
Agnostic_CORINFO_CONST_LOOKUP instParamLookup;
DWORD wrapperDelegateInvoke;
DWORD exceptionCode;
};
struct Agnostic_GetMethodInfo
{
Agnostic_CORINFO_METHOD_INFO info;
bool result;
DWORD exceptionCode;
};
struct Agnostic_FindSig
{
DWORDLONG module;
DWORD sigTOK;
DWORDLONG context;
};
struct MethodOrSigInfoValue
{
DWORDLONG method;
DWORD pSig_Index;
DWORD cbSig;
DWORDLONG scope;
};
struct Agnostic_CORINFO_EH_CLAUSE
{
DWORD Flags;
DWORD TryOffset;
DWORD TryLength;
DWORD HandlerOffset;
DWORD HandlerLength;
DWORD ClassToken; // first view of a two dword union
};
struct Agnostic_GetVars
{
DWORD cVars;
DWORD vars_offset;
DWORD extendOthers;
};
struct Agnostic_CanAccessClassIn
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
DWORDLONG callerHandle;
};
struct Agnostic_CanAccessClassOut
{
Agnostic_CORINFO_HELPER_DESC AccessHelper;
DWORD result;
};
struct Agnostic_AppendClassName
{
DWORDLONG classHandle;
DWORD fNamespace;
DWORD fFullInst;
DWORD fAssembly;
};
struct Agnostic_CheckMethodModifier
{
DWORDLONG hMethod;
DWORD modifier;
DWORD fOptional;
};
struct Agnostic_EmbedGenericHandle
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
DWORD fEmbedParent;
};
struct Agnostic_CORINFO_GENERICHANDLE_RESULT
{
Agnostic_CORINFO_LOOKUP lookup;
DWORDLONG compileTimeHandle;
DWORD handleType;
};
struct Agnostic_GetDelegateCtorIn
{
DWORDLONG methHnd;
DWORDLONG clsHnd;
DWORDLONG targetMethodHnd;
};
struct Agnostic_DelegateCtorArgs
{
DWORDLONG pMethod;
DWORDLONG pArg3;
DWORDLONG pArg4;
DWORDLONG pArg5;
};
struct Agnostic_GetDelegateCtorOut
{
Agnostic_DelegateCtorArgs CtorData;
DWORDLONG result;
};
struct Agnostic_FindCallSiteSig
{
DWORDLONG module;
DWORD methTok;
DWORDLONG context;
};
struct Agnostic_GetNewHelper
{
DWORDLONG hClass;
DWORDLONG callerHandle;
};
struct Agnostic_GetCastingHelper
{
DWORDLONG hClass;
DWORD fThrowing;
};
struct Agnostic_GetClassModuleIdForStatics
{
DWORDLONG Module;
DWORDLONG pIndirection;
DWORDLONG result;
};
struct Agnostic_IsCompatibleDelegate
{
DWORDLONG objCls;
DWORDLONG methodParentCls;
DWORDLONG method;
DWORDLONG delegateCls;
};
struct Agnostic_PgoInstrumentationSchema
{
DWORDLONG Offset; // size_t
DWORD InstrumentationKind; // ICorJitInfo::PgoInstrumentationKind
DWORD ILOffset; // int32_t
DWORD Count; // int32_t
DWORD Other; // int32_t
};
struct Agnostic_AllocPgoInstrumentationBySchema
{
DWORDLONG instrumentationDataAddress;
DWORD schema_index;
DWORD countSchemaItems;
DWORD result;
};
struct Agnostic_GetPgoInstrumentationResults
{
DWORD countSchemaItems;
DWORD schema_index;
DWORD data_index;
DWORD dataByteCount;
DWORD result;
DWORD pgoSource;
};
struct Agnostic_GetProfilingHandle
{
DWORD bHookFunction;
DWORDLONG ProfilerHandle;
DWORD bIndirectedHandles;
};
struct Agnostic_GetTailCallHelpers
{
Agnostic_CORINFO_RESOLVED_TOKEN callToken;
Agnostic_CORINFO_SIG_INFO sig;
DWORD flags;
};
struct Agnostic_CORINFO_TAILCALL_HELPERS
{
bool result;
DWORD flags;
DWORDLONG hStoreArgs;
DWORDLONG hCallTarget;
DWORDLONG hDispatcher;
};
struct Agnostic_GetArgClass_Value
{
DWORDLONG result;
DWORD exceptionCode;
};
struct Agnostic_GetArgType_Value
{
DWORDLONG vcTypeRet;
DWORD result;
DWORD exceptionCode;
};
// Agnostic_ConfigIntInfo combines as a single key the name
// and defaultValue of a integer config query.
// Note: nameIndex is treated as a DWORD index to the name string.
struct Agnostic_ConfigIntInfo
{
DWORD nameIndex;
DWORD defaultValue;
};
// SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR
struct Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor
{
DWORD passedInRegisters; // Whether the struct is passable/passed (this includes struct returning) in registers.
DWORD eightByteCount; // Number of eightbytes for this struct.
DWORD eightByteClassifications[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The eightbytes type
// classification.
DWORD eightByteSizes[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The size of the eightbytes (an
// eightbyte could include padding.
// This represents the no padding
// size of the eightbyte).
DWORD eightByteOffsets[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The start offset of the
// eightbytes (in bytes).
DWORD result;
};
struct Agnostic_ResolveVirtualMethodKey
{
DWORDLONG virtualMethod;
DWORDLONG objClass;
DWORDLONG context;
DWORD pResolvedTokenVirtualMethodNonNull;
Agnostic_CORINFO_RESOLVED_TOKEN pResolvedTokenVirtualMethod;
};
struct Agnostic_ResolveVirtualMethodResult
{
bool returnValue;
DWORDLONG devirtualizedMethod;
bool requiresInstMethodTableArg;
DWORDLONG exactContext;
DWORD detail;
Agnostic_CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedMethod;
Agnostic_CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedUnboxedMethod;
};
struct ResolveTokenValue
{
Agnostic_CORINFO_RESOLVED_TOKENout tokenOut;
DWORD exceptionCode;
};
struct TryResolveTokenValue
{
Agnostic_CORINFO_RESOLVED_TOKENout tokenOut;
DWORD success;
};
struct GetTokenTypeAsHandleValue
{
DWORDLONG hMethod;
DWORDLONG hField;
};
struct GetVarArgsHandleValue
{
DWORD cbSig;
DWORD pSig_Index;
DWORDLONG scope;
DWORD token;
};
struct CanGetVarArgsHandleValue
{
DWORDLONG scope;
DWORD token;
};
struct GetCookieForPInvokeCalliSigValue
{
DWORD cbSig;
DWORD pSig_Index;
DWORDLONG scope;
DWORD token;
};
struct CanGetCookieForPInvokeCalliSigValue
{
DWORDLONG scope;
DWORD token;
};
struct GetReadyToRunHelper_TOKENin
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
Agnostic_CORINFO_LOOKUP_KIND GenericLookupKind;
DWORD id;
};
struct GetReadyToRunHelper_TOKENout
{
Agnostic_CORINFO_CONST_LOOKUP Lookup;
bool result;
};
struct GetReadyToRunDelegateCtorHelper_TOKENIn
{
Agnostic_CORINFO_RESOLVED_TOKEN TargetMethod;
DWORDLONG delegateType;
};
struct Agnostic_RecordRelocation
{
DWORDLONG location;
DWORDLONG target;
DWORD fRelocType;
DWORD slotNum;
DWORD addlDelta;
};
struct Capture_AllocMemDetails
{
ULONG hotCodeSize;
ULONG coldCodeSize;
ULONG roDataSize;
ULONG xcptnsCount;
CorJitAllocMemFlag flag;
void* hotCodeBlock;
void* coldCodeBlock;
void* roDataBlock;
};
struct allocGCInfoDetails
{
size_t size;
void* retval;
};
struct Agnostic_AddressMap
{
DWORDLONG Address;
DWORD size;
};
struct Agnostic_AllocGCInfo
{
DWORDLONG size;
DWORD retval_offset;
};
struct Agnostic_AllocMemDetails
{
DWORD hotCodeSize;
DWORD coldCodeSize;
DWORD roDataSize;
DWORD xcptnsCount;
DWORD flag;
DWORD hotCodeBlock_offset;
DWORD coldCodeBlock_offset;
DWORD roDataBlock_offset;
DWORDLONG hotCodeBlock;
DWORDLONG coldCodeBlock;
DWORDLONG roDataBlock;
};
struct Agnostic_AllocUnwindInfo
{
DWORDLONG pHotCode;
DWORDLONG pColdCode;
DWORD startOffset;
DWORD endOffset;
DWORD unwindSize;
DWORD pUnwindBlock_index;
DWORD funcKind;
};
struct Agnostic_CompileMethodResults
{
DWORDLONG nativeEntry;
DWORD nativeSizeOfCode;
DWORD CorJitResult;
};
struct Agnostic_ReportInliningDecision
{
DWORDLONG inlinerHnd;
DWORDLONG inlineeHnd;
DWORD inlineResult;
DWORD reason_offset;
};
struct Agnostic_ReportTailCallDecision
{
DWORDLONG callerHnd;
DWORDLONG calleeHnd;
DWORD fIsTailPrefix;
DWORD tailCallResult;
DWORD reason_index;
};
struct Agnostic_ReserveUnwindInfo
{
DWORD isFunclet;
DWORD isColdCode;
DWORD unwindSize;
};
struct Agnostic_SetBoundaries
{
DWORDLONG ftn;
DWORD cMap;
DWORD pMap_offset;
};
struct Agnostic_SetVars
{
DWORDLONG ftn;
DWORD cVars;
DWORD vars_offset;
};
struct Agnostic_SetPatchpointInfo
{
DWORD index;
};
struct Agnostic_RecordCallSite
{
Agnostic_CORINFO_SIG_INFO callSig;
DWORDLONG methodHandle;
};
#pragma pack(pop)
#endif // _Agnostic
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//----------------------------------------------------------
// agnostic.h - Definition of platform-agnostic data types used by SuperPMI.
// MethodContext and CompileResult types use these.
//----------------------------------------------------------
#ifndef _Agnostic
#define _Agnostic
#pragma pack(push, 1)
struct Agnostic_CORINFO_SIG_INFO
{
DWORD callConv;
DWORDLONG retTypeClass;
DWORDLONG retTypeSigClass;
DWORD retType;
DWORD flags;
DWORD numArgs;
DWORD sigInst_classInstCount;
DWORD sigInst_classInst_Index;
DWORD sigInst_methInstCount;
DWORD sigInst_methInst_Index;
DWORDLONG args;
DWORD pSig_Index;
DWORD cbSig;
DWORDLONG methodSignature;
DWORDLONG scope;
DWORD token;
};
struct Agnostic_CORINFO_METHOD_INFO
{
DWORDLONG ftn;
DWORDLONG scope;
DWORD ILCode_offset;
DWORD ILCodeSize;
DWORD maxStack;
DWORD EHcount;
DWORD options;
DWORD regionKind;
Agnostic_CORINFO_SIG_INFO args;
Agnostic_CORINFO_SIG_INFO locals;
};
struct Agnostic_CompileMethod
{
Agnostic_CORINFO_METHOD_INFO info;
DWORD flags;
DWORD os;
};
struct Agnostic_InitClass
{
DWORDLONG field;
DWORDLONG method;
DWORDLONG context;
};
struct DLDL
{
DWORDLONG A;
DWORDLONG B;
};
struct Agnostic_CanInline
{
DWORD result;
DWORD exceptionCode;
};
struct Agnostic_GetClassGClayout
{
DWORD gcPtrs_Index;
DWORD len;
DWORD valCount;
};
struct DLD
{
DWORDLONG A;
DWORD B;
};
struct DLDD
{
DWORDLONG A;
DWORD B;
DWORD C;
};
struct Agnostic_CORINFO_METHODNAME_TOKENin
{
DWORDLONG ftn;
DWORD className;
DWORD namespaceName;
DWORD enclosingClassName;
};
struct Agnostic_CORINFO_METHODNAME_TOKENout
{
DWORD methodName;
DWORD className;
DWORD namespaceName;
DWORD enclosingClassName;
};
struct Agnostic_CORINFO_RESOLVED_TOKENin
{
DWORDLONG tokenContext;
DWORDLONG tokenScope;
DWORD token;
DWORD tokenType;
};
struct Agnostic_CORINFO_RESOLVED_TOKENout
{
DWORDLONG hClass;
DWORDLONG hMethod;
DWORDLONG hField;
DWORD pTypeSpec_Index;
DWORD cbTypeSpec;
DWORD pMethodSpec_Index;
DWORD cbMethodSpec;
};
struct Agnostic_GetArgType_Key
{
// Partial CORINFO_SIG_INFO data
DWORD flags;
DWORD numArgs;
DWORD sigInst_classInstCount;
DWORD sigInst_classInst_Index;
DWORD sigInst_methInstCount;
DWORD sigInst_methInst_Index;
DWORDLONG methodSignature;
DWORDLONG scope;
// Other getArgType() arguments
DWORDLONG args;
};
struct Agnostic_GetArgClass_Key
{
DWORD sigInst_classInstCount;
DWORD sigInst_classInst_Index;
DWORD sigInst_methInstCount;
DWORD sigInst_methInst_Index;
DWORDLONG methodSignature;
DWORDLONG scope;
DWORDLONG args;
};
struct Agnostic_GetBoundaries
{
DWORD cILOffsets;
DWORD pILOffset_offset;
DWORD implicitBoundaries;
};
struct Agnostic_CORINFO_EE_INFO
{
struct Agnostic_InlinedCallFrameInfo
{
DWORD size;
DWORD offsetOfGSCookie;
DWORD offsetOfFrameVptr;
DWORD offsetOfFrameLink;
DWORD offsetOfCallSiteSP;
DWORD offsetOfCalleeSavedFP;
DWORD offsetOfCallTarget;
DWORD offsetOfReturnAddress;
} inlinedCallFrameInfo;
DWORD offsetOfThreadFrame;
DWORD offsetOfGCState;
DWORD offsetOfDelegateInstance;
DWORD offsetOfDelegateFirstTarget;
DWORD offsetOfWrapperDelegateIndirectCell;
DWORD sizeOfReversePInvokeFrame;
DWORD osPageSize;
DWORD maxUncheckedOffsetForNullObject;
DWORD targetAbi;
DWORD osType;
};
struct Agnostic_GetOSRInfo
{
DWORD index;
unsigned ilOffset;
};
struct Agnostic_GetFieldAddress
{
DWORDLONG ppIndirection;
DWORDLONG fieldAddress;
DWORD fieldValue;
};
struct Agnostic_GetStaticFieldCurrentClass
{
DWORDLONG classHandle;
bool isSpeculative;
};
struct Agnostic_CORINFO_RESOLVED_TOKEN
{
Agnostic_CORINFO_RESOLVED_TOKENin inValue;
Agnostic_CORINFO_RESOLVED_TOKENout outValue;
};
struct Agnostic_GetFieldInfo
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
DWORDLONG callerHandle;
DWORD flags;
};
struct Agnostic_CORINFO_HELPER_ARG
{
DWORDLONG constant; // one view of a large union of ptr size
DWORD argType;
};
struct Agnostic_CORINFO_HELPER_DESC
{
DWORD helperNum;
DWORD numArgs;
Agnostic_CORINFO_HELPER_ARG args[CORINFO_ACCESS_ALLOWED_MAX_ARGS];
};
struct Agnostic_CORINFO_CONST_LOOKUP
{
DWORD accessType;
DWORDLONG handle; // actually a union of two pointer sized things
};
struct Agnostic_CORINFO_LOOKUP_KIND
{
DWORD needsRuntimeLookup;
DWORD runtimeLookupKind;
WORD runtimeLookupFlags;
};
struct Agnostic_CORINFO_RUNTIME_LOOKUP
{
DWORDLONG signature;
DWORD helper;
DWORD indirections;
DWORD testForNull;
DWORD testForFixup;
WORD sizeOffset;
DWORDLONG offsets[CORINFO_MAXINDIRECTIONS];
DWORD indirectFirstOffset;
DWORD indirectSecondOffset;
};
struct Agnostic_CORINFO_LOOKUP
{
Agnostic_CORINFO_LOOKUP_KIND lookupKind;
Agnostic_CORINFO_RUNTIME_LOOKUP runtimeLookup; // This and constLookup actually a union, but with different
// layouts.. :-| copy the right one based on lookupKinds value
Agnostic_CORINFO_CONST_LOOKUP constLookup;
};
struct Agnostic_CORINFO_FIELD_INFO
{
DWORD fieldAccessor;
DWORD fieldFlags;
DWORD helper;
DWORD offset;
DWORD fieldType;
DWORDLONG structType;
DWORD accessAllowed;
Agnostic_CORINFO_HELPER_DESC accessCalloutHelper;
Agnostic_CORINFO_CONST_LOOKUP fieldLookup;
};
struct DD
{
DWORD A;
DWORD B;
};
struct DDD
{
DWORD A;
DWORD B;
DWORD C;
};
struct Agnostic_CanTailCall
{
DWORDLONG callerHnd;
DWORDLONG declaredCalleeHnd;
DWORDLONG exactCalleeHnd;
WORD fIsTailPrefix;
};
struct Agnostic_Environment
{
DWORD name_index;
;
DWORD val_index;
};
struct Agnostic_GetCallInfo
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
Agnostic_CORINFO_RESOLVED_TOKEN ConstrainedResolvedToken;
DWORDLONG callerHandle;
DWORD flags;
};
struct Agnostic_CORINFO_CALL_INFO
{
DWORDLONG hMethod;
DWORD methodFlags;
DWORD classFlags;
Agnostic_CORINFO_SIG_INFO sig;
DWORD verMethodFlags;
Agnostic_CORINFO_SIG_INFO verSig;
DWORD accessAllowed;
Agnostic_CORINFO_HELPER_DESC callsiteCalloutHelper;
DWORD thisTransform;
DWORD kind;
DWORD nullInstanceCheck;
DWORDLONG contextHandle;
DWORD exactContextNeedsRuntimeLookup;
Agnostic_CORINFO_LOOKUP stubLookup; // first view of union. others are matching or subordinate
Agnostic_CORINFO_CONST_LOOKUP instParamLookup;
DWORD wrapperDelegateInvoke;
DWORD exceptionCode;
};
struct Agnostic_GetMethodInfo
{
Agnostic_CORINFO_METHOD_INFO info;
bool result;
DWORD exceptionCode;
};
struct Agnostic_FindSig
{
DWORDLONG module;
DWORD sigTOK;
DWORDLONG context;
};
struct MethodOrSigInfoValue
{
DWORDLONG method;
DWORD pSig_Index;
DWORD cbSig;
DWORDLONG scope;
};
struct Agnostic_CORINFO_EH_CLAUSE
{
DWORD Flags;
DWORD TryOffset;
DWORD TryLength;
DWORD HandlerOffset;
DWORD HandlerLength;
DWORD ClassToken; // first view of a two dword union
};
struct Agnostic_GetVars
{
DWORD cVars;
DWORD vars_offset;
DWORD extendOthers;
};
struct Agnostic_CanAccessClassIn
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
DWORDLONG callerHandle;
};
struct Agnostic_CanAccessClassOut
{
Agnostic_CORINFO_HELPER_DESC AccessHelper;
DWORD result;
};
struct Agnostic_AppendClassName
{
DWORDLONG classHandle;
DWORD fNamespace;
DWORD fFullInst;
DWORD fAssembly;
};
struct Agnostic_CheckMethodModifier
{
DWORDLONG hMethod;
DWORD modifier;
DWORD fOptional;
};
struct Agnostic_EmbedGenericHandle
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
DWORD fEmbedParent;
};
struct Agnostic_CORINFO_GENERICHANDLE_RESULT
{
Agnostic_CORINFO_LOOKUP lookup;
DWORDLONG compileTimeHandle;
DWORD handleType;
};
struct Agnostic_GetDelegateCtorIn
{
DWORDLONG methHnd;
DWORDLONG clsHnd;
DWORDLONG targetMethodHnd;
};
struct Agnostic_DelegateCtorArgs
{
DWORDLONG pMethod;
DWORDLONG pArg3;
DWORDLONG pArg4;
DWORDLONG pArg5;
};
struct Agnostic_GetDelegateCtorOut
{
Agnostic_DelegateCtorArgs CtorData;
DWORDLONG result;
};
struct Agnostic_FindCallSiteSig
{
DWORDLONG module;
DWORD methTok;
DWORDLONG context;
};
struct Agnostic_GetNewHelper
{
DWORDLONG hClass;
DWORDLONG callerHandle;
};
struct Agnostic_GetCastingHelper
{
DWORDLONG hClass;
DWORD fThrowing;
};
struct Agnostic_GetClassModuleIdForStatics
{
DWORDLONG Module;
DWORDLONG pIndirection;
DWORDLONG result;
};
struct Agnostic_IsCompatibleDelegate
{
DWORDLONG objCls;
DWORDLONG methodParentCls;
DWORDLONG method;
DWORDLONG delegateCls;
};
struct Agnostic_PgoInstrumentationSchema
{
DWORDLONG Offset; // size_t
DWORD InstrumentationKind; // ICorJitInfo::PgoInstrumentationKind
DWORD ILOffset; // int32_t
DWORD Count; // int32_t
DWORD Other; // int32_t
};
struct Agnostic_AllocPgoInstrumentationBySchema
{
DWORDLONG instrumentationDataAddress;
DWORD schema_index;
DWORD countSchemaItems;
DWORD result;
};
struct Agnostic_GetPgoInstrumentationResults
{
DWORD countSchemaItems;
DWORD schema_index;
DWORD data_index;
DWORD dataByteCount;
DWORD result;
DWORD pgoSource;
};
struct Agnostic_GetProfilingHandle
{
DWORD bHookFunction;
DWORDLONG ProfilerHandle;
DWORD bIndirectedHandles;
};
struct Agnostic_GetTailCallHelpers
{
Agnostic_CORINFO_RESOLVED_TOKEN callToken;
Agnostic_CORINFO_SIG_INFO sig;
DWORD flags;
};
struct Agnostic_CORINFO_TAILCALL_HELPERS
{
bool result;
DWORD flags;
DWORDLONG hStoreArgs;
DWORDLONG hCallTarget;
DWORDLONG hDispatcher;
};
struct Agnostic_GetArgClass_Value
{
DWORDLONG result;
DWORD exceptionCode;
};
struct Agnostic_GetArgType_Value
{
DWORDLONG vcTypeRet;
DWORD result;
DWORD exceptionCode;
};
// Agnostic_ConfigIntInfo combines as a single key the name
// and defaultValue of a integer config query.
// Note: nameIndex is treated as a DWORD index to the name string.
struct Agnostic_ConfigIntInfo
{
DWORD nameIndex;
DWORD defaultValue;
};
// SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR
struct Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor
{
DWORD passedInRegisters; // Whether the struct is passable/passed (this includes struct returning) in registers.
DWORD eightByteCount; // Number of eightbytes for this struct.
DWORD eightByteClassifications[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The eightbytes type
// classification.
DWORD eightByteSizes[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The size of the eightbytes (an
// eightbyte could include padding.
// This represents the no padding
// size of the eightbyte).
DWORD eightByteOffsets[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The start offset of the
// eightbytes (in bytes).
DWORD result;
};
struct Agnostic_ResolveVirtualMethodKey
{
DWORDLONG virtualMethod;
DWORDLONG objClass;
DWORDLONG context;
DWORD pResolvedTokenVirtualMethodNonNull;
Agnostic_CORINFO_RESOLVED_TOKEN pResolvedTokenVirtualMethod;
};
struct Agnostic_ResolveVirtualMethodResult
{
bool returnValue;
DWORDLONG devirtualizedMethod;
bool requiresInstMethodTableArg;
DWORDLONG exactContext;
DWORD detail;
Agnostic_CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedMethod;
Agnostic_CORINFO_RESOLVED_TOKEN resolvedTokenDevirtualizedUnboxedMethod;
};
struct ResolveTokenValue
{
Agnostic_CORINFO_RESOLVED_TOKENout tokenOut;
DWORD exceptionCode;
};
struct TryResolveTokenValue
{
Agnostic_CORINFO_RESOLVED_TOKENout tokenOut;
DWORD success;
};
struct GetTokenTypeAsHandleValue
{
DWORDLONG hMethod;
DWORDLONG hField;
};
struct GetVarArgsHandleValue
{
DWORD cbSig;
DWORD pSig_Index;
DWORDLONG scope;
DWORD token;
};
struct CanGetVarArgsHandleValue
{
DWORDLONG scope;
DWORD token;
};
struct GetCookieForPInvokeCalliSigValue
{
DWORD cbSig;
DWORD pSig_Index;
DWORDLONG scope;
DWORD token;
};
struct CanGetCookieForPInvokeCalliSigValue
{
DWORDLONG scope;
DWORD token;
};
struct GetReadyToRunHelper_TOKENin
{
Agnostic_CORINFO_RESOLVED_TOKEN ResolvedToken;
Agnostic_CORINFO_LOOKUP_KIND GenericLookupKind;
DWORD id;
};
struct GetReadyToRunHelper_TOKENout
{
Agnostic_CORINFO_CONST_LOOKUP Lookup;
bool result;
};
struct GetReadyToRunDelegateCtorHelper_TOKENIn
{
Agnostic_CORINFO_RESOLVED_TOKEN TargetMethod;
DWORDLONG delegateType;
};
struct Agnostic_RecordRelocation
{
DWORDLONG location;
DWORDLONG target;
DWORD fRelocType;
DWORD slotNum;
DWORD addlDelta;
};
struct Capture_AllocMemDetails
{
ULONG hotCodeSize;
ULONG coldCodeSize;
ULONG roDataSize;
ULONG xcptnsCount;
CorJitAllocMemFlag flag;
void* hotCodeBlock;
void* coldCodeBlock;
void* roDataBlock;
};
struct allocGCInfoDetails
{
size_t size;
void* retval;
};
struct Agnostic_AddressMap
{
DWORDLONG Address;
DWORD size;
};
struct Agnostic_AllocGCInfo
{
DWORDLONG size;
DWORD retval_offset;
};
struct Agnostic_AllocMemDetails
{
DWORD hotCodeSize;
DWORD coldCodeSize;
DWORD roDataSize;
DWORD xcptnsCount;
DWORD flag;
DWORD hotCodeBlock_offset;
DWORD coldCodeBlock_offset;
DWORD roDataBlock_offset;
DWORDLONG hotCodeBlock;
DWORDLONG coldCodeBlock;
DWORDLONG roDataBlock;
};
struct Agnostic_AllocUnwindInfo
{
DWORDLONG pHotCode;
DWORDLONG pColdCode;
DWORD startOffset;
DWORD endOffset;
DWORD unwindSize;
DWORD pUnwindBlock_index;
DWORD funcKind;
};
struct Agnostic_CompileMethodResults
{
DWORDLONG nativeEntry;
DWORD nativeSizeOfCode;
DWORD CorJitResult;
};
struct Agnostic_ReportInliningDecision
{
DWORDLONG inlinerHnd;
DWORDLONG inlineeHnd;
DWORD inlineResult;
DWORD reason_offset;
};
struct Agnostic_ReportTailCallDecision
{
DWORDLONG callerHnd;
DWORDLONG calleeHnd;
DWORD fIsTailPrefix;
DWORD tailCallResult;
DWORD reason_index;
};
struct Agnostic_ReserveUnwindInfo
{
DWORD isFunclet;
DWORD isColdCode;
DWORD unwindSize;
};
struct Agnostic_SetBoundaries
{
DWORDLONG ftn;
DWORD cMap;
DWORD pMap_offset;
};
struct Agnostic_SetVars
{
DWORDLONG ftn;
DWORD cVars;
DWORD vars_offset;
};
struct Agnostic_SetPatchpointInfo
{
DWORD index;
};
struct Agnostic_RecordCallSite
{
Agnostic_CORINFO_SIG_INFO callSig;
DWORDLONG methodHandle;
};
#pragma pack(pop)
#endif // _Agnostic
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/ptrace/_UPT_access_mem.c | /* libunwind - a platform-independent unwind library
Copyright (C) 2003-2004 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
Copyright (C) 2010 Konstantin Belousov <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "_UPT_internal.h"
#if HAVE_DECL_PTRACE_POKEDATA || HAVE_TTRACE
int
_UPT_access_mem (unw_addr_space_t as, unw_word_t addr, unw_word_t *val,
int write, void *arg)
{
struct UPT_info *ui = arg;
int i, end;
unw_word_t tmp_val;
if (!ui)
return -UNW_EINVAL;
pid_t pid = ui->pid;
// Some 32-bit archs have to define a 64-bit unw_word_t.
// Callers of this function therefore expect a 64-bit
// return value, but ptrace only returns a 32-bit value
// in such cases.
if (sizeof(long) == 4 && sizeof(unw_word_t) == 8)
end = 2;
else
end = 1;
for (i = 0; i < end; i++)
{
unw_word_t tmp_addr = i == 0 ? addr : addr + 4;
errno = 0;
if (write)
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
tmp_val = i == 0 ? *val : *val >> 32;
#else
tmp_val = i == 0 && end == 2 ? *val >> 32 : *val;
#endif
Debug (16, "mem[%lx] <- %lx\n", (long) tmp_addr, (long) tmp_val);
#ifdef HAVE_TTRACE
# warning No support for ttrace() yet.
#else
ptrace (PTRACE_POKEDATA, pid, tmp_addr, tmp_val);
if (errno)
return -UNW_EINVAL;
#endif
}
else
{
#ifdef HAVE_TTRACE
# warning No support for ttrace() yet.
#else
tmp_val = (unsigned long) ptrace (PTRACE_PEEKDATA, pid, tmp_addr, 0);
if (i == 0)
*val = 0;
#if __BYTE_ORDER == __LITTLE_ENDIAN
*val |= tmp_val << (i * 32);
#else
*val |= i == 0 && end == 2 ? tmp_val << 32 : tmp_val;
#endif
if (errno)
return -UNW_EINVAL;
#endif
Debug (16, "mem[%lx] -> %lx\n", (long) tmp_addr, (long) tmp_val);
}
}
return 0;
}
#elif HAVE_DECL_PT_IO
int
_UPT_access_mem (unw_addr_space_t as, unw_word_t addr, unw_word_t *val,
int write, void *arg)
{
struct UPT_info *ui = arg;
if (!ui)
return -UNW_EINVAL;
pid_t pid = ui->pid;
struct ptrace_io_desc iod;
iod.piod_offs = (void *)addr;
iod.piod_addr = val;
iod.piod_len = sizeof(*val);
iod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D;
if (write)
Debug (16, "mem[%lx] <- %lx\n", (long) addr, (long) *val);
if (ptrace(PT_IO, pid, (caddr_t)&iod, 0) == -1)
return -UNW_EINVAL;
if (!write)
Debug (16, "mem[%lx] -> %lx\n", (long) addr, (long) *val);
return 0;
}
#else
#error Fix me
#endif
| /* libunwind - a platform-independent unwind library
Copyright (C) 2003-2004 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
Copyright (C) 2010 Konstantin Belousov <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "_UPT_internal.h"
#if HAVE_DECL_PTRACE_POKEDATA || HAVE_TTRACE
int
_UPT_access_mem (unw_addr_space_t as, unw_word_t addr, unw_word_t *val,
int write, void *arg)
{
struct UPT_info *ui = arg;
int i, end;
unw_word_t tmp_val;
if (!ui)
return -UNW_EINVAL;
pid_t pid = ui->pid;
// Some 32-bit archs have to define a 64-bit unw_word_t.
// Callers of this function therefore expect a 64-bit
// return value, but ptrace only returns a 32-bit value
// in such cases.
if (sizeof(long) == 4 && sizeof(unw_word_t) == 8)
end = 2;
else
end = 1;
for (i = 0; i < end; i++)
{
unw_word_t tmp_addr = i == 0 ? addr : addr + 4;
errno = 0;
if (write)
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
tmp_val = i == 0 ? *val : *val >> 32;
#else
tmp_val = i == 0 && end == 2 ? *val >> 32 : *val;
#endif
Debug (16, "mem[%lx] <- %lx\n", (long) tmp_addr, (long) tmp_val);
#ifdef HAVE_TTRACE
# warning No support for ttrace() yet.
#else
ptrace (PTRACE_POKEDATA, pid, tmp_addr, tmp_val);
if (errno)
return -UNW_EINVAL;
#endif
}
else
{
#ifdef HAVE_TTRACE
# warning No support for ttrace() yet.
#else
tmp_val = (unsigned long) ptrace (PTRACE_PEEKDATA, pid, tmp_addr, 0);
if (i == 0)
*val = 0;
#if __BYTE_ORDER == __LITTLE_ENDIAN
*val |= tmp_val << (i * 32);
#else
*val |= i == 0 && end == 2 ? tmp_val << 32 : tmp_val;
#endif
if (errno)
return -UNW_EINVAL;
#endif
Debug (16, "mem[%lx] -> %lx\n", (long) tmp_addr, (long) tmp_val);
}
}
return 0;
}
#elif HAVE_DECL_PT_IO
int
_UPT_access_mem (unw_addr_space_t as, unw_word_t addr, unw_word_t *val,
int write, void *arg)
{
struct UPT_info *ui = arg;
if (!ui)
return -UNW_EINVAL;
pid_t pid = ui->pid;
struct ptrace_io_desc iod;
iod.piod_offs = (void *)addr;
iod.piod_addr = val;
iod.piod_len = sizeof(*val);
iod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D;
if (write)
Debug (16, "mem[%lx] <- %lx\n", (long) addr, (long) *val);
if (ptrace(PT_IO, pid, (caddr_t)&iod, 0) == -1)
return -UNW_EINVAL;
if (!write)
Debug (16, "mem[%lx] -> %lx\n", (long) addr, (long) *val);
return 0;
}
#else
#error Fix me
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/include/libunwind-s390x.h | /* libunwind - a platform-independent unwind library
Copyright (C) 2002-2004 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
Modified for s390x by Michael Munday <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#ifndef LIBUNWIND_H
#define LIBUNWIND_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include <sys/types.h>
#include <inttypes.h>
#include <ucontext.h>
#define UNW_TARGET s390x
#define UNW_TARGET_S390X 1
#define _U_TDEP_QP_TRUE 0 /* see libunwind-dynamic.h */
/* This needs to be big enough to accommodate "struct cursor", while
leaving some slack for future expansion. Changing this value will
require recompiling all users of this library. Stack allocation is
relatively cheap and unwind-state copying is relatively rare, so we
want to err on making it rather too big than too small. */
#define UNW_TDEP_CURSOR_LEN 384
typedef uint64_t unw_word_t;
typedef int64_t unw_sword_t;
typedef double unw_tdep_fpreg_t;
typedef enum
{
/* general purpose registers */
UNW_S390X_R0,
UNW_S390X_R1,
UNW_S390X_R2,
UNW_S390X_R3,
UNW_S390X_R4,
UNW_S390X_R5,
UNW_S390X_R6,
UNW_S390X_R7,
UNW_S390X_R8,
UNW_S390X_R9,
UNW_S390X_R10,
UNW_S390X_R11,
UNW_S390X_R12,
UNW_S390X_R13,
UNW_S390X_R14,
UNW_S390X_R15,
/* floating point registers */
UNW_S390X_F0,
UNW_S390X_F1,
UNW_S390X_F2,
UNW_S390X_F3,
UNW_S390X_F4,
UNW_S390X_F5,
UNW_S390X_F6,
UNW_S390X_F7,
UNW_S390X_F8,
UNW_S390X_F9,
UNW_S390X_F10,
UNW_S390X_F11,
UNW_S390X_F12,
UNW_S390X_F13,
UNW_S390X_F14,
UNW_S390X_F15,
/* PSW */
UNW_S390X_IP,
UNW_TDEP_LAST_REG = UNW_S390X_IP,
/* TODO: access, vector registers */
/* frame info (read-only) */
UNW_S390X_CFA,
UNW_TDEP_IP = UNW_S390X_IP,
UNW_TDEP_SP = UNW_S390X_R15,
/* TODO: placeholders */
UNW_TDEP_EH = UNW_S390X_R0,
}
s390x_regnum_t;
#define UNW_TDEP_NUM_EH_REGS 2 /* XXX Not sure what this means */
typedef struct unw_tdep_save_loc
{
/* Additional target-dependent info on a save location. */
char unused;
}
unw_tdep_save_loc_t;
/* On s390x, we can directly use ucontext_t as the unwind context. */
typedef ucontext_t unw_tdep_context_t;
typedef struct
{
/* no s390x-specific auxiliary proc-info */
char unused;
}
unw_tdep_proc_info_t;
#include "libunwind-dynamic.h"
#include "libunwind-common.h"
#define unw_tdep_getcontext UNW_ARCH_OBJ(getcontext)
#define unw_tdep_is_fpreg UNW_ARCH_OBJ(is_fpreg)
extern int unw_tdep_getcontext (unw_tdep_context_t *);
extern int unw_tdep_is_fpreg (int);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif /* LIBUNWIND_H */
| /* libunwind - a platform-independent unwind library
Copyright (C) 2002-2004 Hewlett-Packard Co
Contributed by David Mosberger-Tang <[email protected]>
Modified for s390x by Michael Munday <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#ifndef LIBUNWIND_H
#define LIBUNWIND_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#include <sys/types.h>
#include <inttypes.h>
#include <ucontext.h>
#define UNW_TARGET s390x
#define UNW_TARGET_S390X 1
#define _U_TDEP_QP_TRUE 0 /* see libunwind-dynamic.h */
/* This needs to be big enough to accommodate "struct cursor", while
leaving some slack for future expansion. Changing this value will
require recompiling all users of this library. Stack allocation is
relatively cheap and unwind-state copying is relatively rare, so we
want to err on making it rather too big than too small. */
#define UNW_TDEP_CURSOR_LEN 384
typedef uint64_t unw_word_t;
typedef int64_t unw_sword_t;
typedef double unw_tdep_fpreg_t;
typedef enum
{
/* general purpose registers */
UNW_S390X_R0,
UNW_S390X_R1,
UNW_S390X_R2,
UNW_S390X_R3,
UNW_S390X_R4,
UNW_S390X_R5,
UNW_S390X_R6,
UNW_S390X_R7,
UNW_S390X_R8,
UNW_S390X_R9,
UNW_S390X_R10,
UNW_S390X_R11,
UNW_S390X_R12,
UNW_S390X_R13,
UNW_S390X_R14,
UNW_S390X_R15,
/* floating point registers */
UNW_S390X_F0,
UNW_S390X_F1,
UNW_S390X_F2,
UNW_S390X_F3,
UNW_S390X_F4,
UNW_S390X_F5,
UNW_S390X_F6,
UNW_S390X_F7,
UNW_S390X_F8,
UNW_S390X_F9,
UNW_S390X_F10,
UNW_S390X_F11,
UNW_S390X_F12,
UNW_S390X_F13,
UNW_S390X_F14,
UNW_S390X_F15,
/* PSW */
UNW_S390X_IP,
UNW_TDEP_LAST_REG = UNW_S390X_IP,
/* TODO: access, vector registers */
/* frame info (read-only) */
UNW_S390X_CFA,
UNW_TDEP_IP = UNW_S390X_IP,
UNW_TDEP_SP = UNW_S390X_R15,
/* TODO: placeholders */
UNW_TDEP_EH = UNW_S390X_R0,
}
s390x_regnum_t;
#define UNW_TDEP_NUM_EH_REGS 2 /* XXX Not sure what this means */
typedef struct unw_tdep_save_loc
{
/* Additional target-dependent info on a save location. */
char unused;
}
unw_tdep_save_loc_t;
/* On s390x, we can directly use ucontext_t as the unwind context. */
typedef ucontext_t unw_tdep_context_t;
typedef struct
{
/* no s390x-specific auxiliary proc-info */
char unused;
}
unw_tdep_proc_info_t;
#include "libunwind-dynamic.h"
#include "libunwind-common.h"
#define unw_tdep_getcontext UNW_ARCH_OBJ(getcontext)
#define unw_tdep_is_fpreg UNW_ARCH_OBJ(is_fpreg)
extern int unw_tdep_getcontext (unw_tdep_context_t *);
extern int unw_tdep_is_fpreg (int);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif /* LIBUNWIND_H */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/tools/aot/jitinterface/corinfoexception.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include <string.h>
#ifdef TARGET_UNIX
typedef char16_t WCHAR;
#else
typedef wchar_t WCHAR;
#endif
class CorInfoExceptionClass
{
public:
CorInfoExceptionClass(const WCHAR* message, int messageLength)
{
this->message = new WCHAR[messageLength + 1];
memcpy(this->message, message, messageLength * sizeof(WCHAR));
this->message[messageLength] = L'\0';
}
~CorInfoExceptionClass()
{
if (message != nullptr)
{
delete[] message;
message = nullptr;
}
}
const WCHAR* GetMessage() const
{
return message;
}
private:
WCHAR* message;
};
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include <string.h>
#ifdef TARGET_UNIX
typedef char16_t WCHAR;
#else
typedef wchar_t WCHAR;
#endif
class CorInfoExceptionClass
{
public:
CorInfoExceptionClass(const WCHAR* message, int messageLength)
{
this->message = new WCHAR[messageLength + 1];
memcpy(this->message, message, messageLength * sizeof(WCHAR));
this->message[messageLength] = L'\0';
}
~CorInfoExceptionClass()
{
if (message != nullptr)
{
delete[] message;
message = nullptr;
}
}
const WCHAR* GetMessage() const
{
return message;
}
private:
WCHAR* message;
};
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/utils/mach-support-arm64.c | /**
* \file
* mach support for ARM
*
* Authors:
* Geoff Norton ([email protected])
* Rodrigo Kumpera ([email protected])
*
* (C) 2010 Novell, Inc.
* (C) 2011 Xamarin, Inc.
*/
#include <config.h>
#if defined(__MACH__)
#include <stdint.h>
#include <glib.h>
#include <pthread.h>
#include "utils/mono-sigcontext.h"
#include "utils/mono-compiler.h"
#include "mach-support.h"
/* _mcontext.h now defines __darwin_mcontext32, not __darwin_mcontext, starting with Xcode 5.1 */
#ifdef _STRUCT_MCONTEXT32
#define __darwin_mcontext __darwin_mcontext32
#endif
int
mono_mach_arch_get_mcontext_size ()
{
return sizeof (struct __darwin_mcontext64);
}
void
mono_mach_arch_thread_states_to_mcontext (thread_state_t state, thread_state_t fpstate, void *context)
{
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t*) fpstate;
struct __darwin_mcontext64 *ctx = (struct __darwin_mcontext64 *) context;
ctx->__ss = arch_state->ts_64;
ctx->__ns = *arch_fpstate;
}
void
mono_mach_arch_mcontext_to_thread_states (void *context, thread_state_t state, thread_state_t fpstate)
{
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t*) fpstate;
struct __darwin_mcontext64 *ctx = (struct __darwin_mcontext64 *) context;
arch_state->ts_64 = ctx->__ss;
*arch_fpstate = ctx->__ns;
}
void
mono_mach_arch_thread_states_to_mono_context (thread_state_t state, thread_state_t fpstate, MonoContext *context)
{
int i;
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t*) fpstate;
for (i = 0; i < 29; ++i)
context->regs [i] = arch_state->ts_64.__x [i];
#if __has_feature(ptrauth_calls)
/* arm64e */
context->regs [ARMREG_R29] = __darwin_arm_thread_state64_get_fp (arch_state->ts_64);
context->regs [ARMREG_R30] = __darwin_arm_thread_state64_get_lr (arch_state->ts_64);
context->regs [ARMREG_SP] = __darwin_arm_thread_state64_get_sp (arch_state->ts_64);
context->pc = (host_mgreg_t)__darwin_arm_thread_state64_get_pc_fptr (arch_state->ts_64);
#else
context->regs [ARMREG_R29] = arch_state->ts_64.__fp;
context->regs [ARMREG_R30] = arch_state->ts_64.__lr;
context->regs [ARMREG_SP] = arch_state->ts_64.__sp;
context->pc = arch_state->ts_64.__pc;
#endif
for (i = 0; i < 32; ++i)
context->fregs [i] = arch_fpstate->__v [i];
}
int
mono_mach_arch_get_thread_state_size ()
{
return sizeof (arm_unified_thread_state_t);
}
int
mono_mach_arch_get_thread_fpstate_size ()
{
return sizeof (arm_neon_state64_t);
}
kern_return_t
mono_mach_arch_get_thread_states (thread_port_t thread, thread_state_t state, mach_msg_type_number_t *count, thread_state_t fpstate, mach_msg_type_number_t *fpcount)
{
#if defined(HOST_WATCHOS)
g_error ("thread_get_state() is not supported by this platform");
#else
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t *) fpstate;
kern_return_t ret;
*count = ARM_UNIFIED_THREAD_STATE_COUNT;
ret = thread_get_state (thread, ARM_UNIFIED_THREAD_STATE, (thread_state_t) arch_state, count);
if (ret != KERN_SUCCESS)
return ret;
*fpcount = ARM_NEON_STATE64_COUNT;
ret = thread_get_state (thread, ARM_NEON_STATE64, (thread_state_t) arch_fpstate, fpcount);
return ret;
#endif
}
kern_return_t
mono_mach_arch_set_thread_states (thread_port_t thread, thread_state_t state, mach_msg_type_number_t count, thread_state_t fpstate, mach_msg_type_number_t fpcount)
{
#if defined(HOST_WATCHOS)
g_error ("thread_set_state() is not supported by this platform");
#else
kern_return_t ret;
ret = thread_set_state (thread, ARM_UNIFIED_THREAD_STATE, state, count);
if (ret != KERN_SUCCESS)
return ret;
ret = thread_set_state (thread, ARM_NEON_STATE64, fpstate, fpcount);
return ret;
#endif
}
#endif
| /**
* \file
* mach support for ARM
*
* Authors:
* Geoff Norton ([email protected])
* Rodrigo Kumpera ([email protected])
*
* (C) 2010 Novell, Inc.
* (C) 2011 Xamarin, Inc.
*/
#include <config.h>
#if defined(__MACH__)
#include <stdint.h>
#include <glib.h>
#include <pthread.h>
#include "utils/mono-sigcontext.h"
#include "utils/mono-compiler.h"
#include "mach-support.h"
/* _mcontext.h now defines __darwin_mcontext32, not __darwin_mcontext, starting with Xcode 5.1 */
#ifdef _STRUCT_MCONTEXT32
#define __darwin_mcontext __darwin_mcontext32
#endif
int
mono_mach_arch_get_mcontext_size ()
{
return sizeof (struct __darwin_mcontext64);
}
void
mono_mach_arch_thread_states_to_mcontext (thread_state_t state, thread_state_t fpstate, void *context)
{
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t*) fpstate;
struct __darwin_mcontext64 *ctx = (struct __darwin_mcontext64 *) context;
ctx->__ss = arch_state->ts_64;
ctx->__ns = *arch_fpstate;
}
void
mono_mach_arch_mcontext_to_thread_states (void *context, thread_state_t state, thread_state_t fpstate)
{
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t*) fpstate;
struct __darwin_mcontext64 *ctx = (struct __darwin_mcontext64 *) context;
arch_state->ts_64 = ctx->__ss;
*arch_fpstate = ctx->__ns;
}
void
mono_mach_arch_thread_states_to_mono_context (thread_state_t state, thread_state_t fpstate, MonoContext *context)
{
int i;
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t*) fpstate;
for (i = 0; i < 29; ++i)
context->regs [i] = arch_state->ts_64.__x [i];
#if __has_feature(ptrauth_calls)
/* arm64e */
context->regs [ARMREG_R29] = __darwin_arm_thread_state64_get_fp (arch_state->ts_64);
context->regs [ARMREG_R30] = __darwin_arm_thread_state64_get_lr (arch_state->ts_64);
context->regs [ARMREG_SP] = __darwin_arm_thread_state64_get_sp (arch_state->ts_64);
context->pc = (host_mgreg_t)__darwin_arm_thread_state64_get_pc_fptr (arch_state->ts_64);
#else
context->regs [ARMREG_R29] = arch_state->ts_64.__fp;
context->regs [ARMREG_R30] = arch_state->ts_64.__lr;
context->regs [ARMREG_SP] = arch_state->ts_64.__sp;
context->pc = arch_state->ts_64.__pc;
#endif
for (i = 0; i < 32; ++i)
context->fregs [i] = arch_fpstate->__v [i];
}
int
mono_mach_arch_get_thread_state_size ()
{
return sizeof (arm_unified_thread_state_t);
}
int
mono_mach_arch_get_thread_fpstate_size ()
{
return sizeof (arm_neon_state64_t);
}
kern_return_t
mono_mach_arch_get_thread_states (thread_port_t thread, thread_state_t state, mach_msg_type_number_t *count, thread_state_t fpstate, mach_msg_type_number_t *fpcount)
{
#if defined(HOST_WATCHOS)
g_error ("thread_get_state() is not supported by this platform");
#else
arm_unified_thread_state_t *arch_state = (arm_unified_thread_state_t *) state;
arm_neon_state64_t *arch_fpstate = (arm_neon_state64_t *) fpstate;
kern_return_t ret;
*count = ARM_UNIFIED_THREAD_STATE_COUNT;
ret = thread_get_state (thread, ARM_UNIFIED_THREAD_STATE, (thread_state_t) arch_state, count);
if (ret != KERN_SUCCESS)
return ret;
*fpcount = ARM_NEON_STATE64_COUNT;
ret = thread_get_state (thread, ARM_NEON_STATE64, (thread_state_t) arch_fpstate, fpcount);
return ret;
#endif
}
kern_return_t
mono_mach_arch_set_thread_states (thread_port_t thread, thread_state_t state, mach_msg_type_number_t count, thread_state_t fpstate, mach_msg_type_number_t fpcount)
{
#if defined(HOST_WATCHOS)
g_error ("thread_set_state() is not supported by this platform");
#else
kern_return_t ret;
ret = thread_set_state (thread, ARM_UNIFIED_THREAD_STATE, state, count);
if (ret != KERN_SUCCESS)
return ret;
ret = thread_set_state (thread, ARM_NEON_STATE64, fpstate, fpcount);
return ret;
#endif
}
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/ppc64/Lglobal.c | #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gglobal.c"
#endif
| #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gglobal.c"
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/public/mono/metadata/details/opcodes-types.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
#ifndef _MONO_OPCODES_TYPES_H
#define _MONO_OPCODES_TYPES_H
#include <mono/utils/details/mono-publib-types.h>
MONO_BEGIN_DECLS
#define MONO_CUSTOM_PREFIX 0xf0
#define OPDEF(a,b,c,d,e,f,g,h,i,j) \
MONO_ ## a,
typedef enum MonoOpcodeEnum {
MonoOpcodeEnum_Invalid = -1,
#include "mono/cil/opcode.def"
MONO_CEE_LAST
} MonoOpcodeEnum;
#undef OPDEF
enum {
MONO_FLOW_NEXT,
MONO_FLOW_BRANCH,
MONO_FLOW_COND_BRANCH,
MONO_FLOW_ERROR,
MONO_FLOW_CALL,
MONO_FLOW_RETURN,
MONO_FLOW_META
};
enum {
MonoInlineNone = 0,
MonoInlineType = 1,
MonoInlineField = 2,
MonoInlineMethod = 3,
MonoInlineTok = 4,
MonoInlineString = 5,
MonoInlineSig = 6,
MonoInlineVar = 7,
MonoShortInlineVar = 8,
MonoInlineBrTarget = 9,
MonoShortInlineBrTarget = 10,
MonoInlineSwitch = 11,
MonoInlineR = 12,
MonoShortInlineR = 13,
MonoInlineI = 14,
MonoShortInlineI = 15,
MonoInlineI8 = 16,
};
typedef struct {
unsigned char argument;
unsigned char flow_type;
unsigned short opval;
} MonoOpcode;
MONO_END_DECLS
#endif /* _MONO_OPCODES_TYPES_H */
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
#ifndef _MONO_OPCODES_TYPES_H
#define _MONO_OPCODES_TYPES_H
#include <mono/utils/details/mono-publib-types.h>
MONO_BEGIN_DECLS
#define MONO_CUSTOM_PREFIX 0xf0
#define OPDEF(a,b,c,d,e,f,g,h,i,j) \
MONO_ ## a,
typedef enum MonoOpcodeEnum {
MonoOpcodeEnum_Invalid = -1,
#include "mono/cil/opcode.def"
MONO_CEE_LAST
} MonoOpcodeEnum;
#undef OPDEF
enum {
MONO_FLOW_NEXT,
MONO_FLOW_BRANCH,
MONO_FLOW_COND_BRANCH,
MONO_FLOW_ERROR,
MONO_FLOW_CALL,
MONO_FLOW_RETURN,
MONO_FLOW_META
};
enum {
MonoInlineNone = 0,
MonoInlineType = 1,
MonoInlineField = 2,
MonoInlineMethod = 3,
MonoInlineTok = 4,
MonoInlineString = 5,
MonoInlineSig = 6,
MonoInlineVar = 7,
MonoShortInlineVar = 8,
MonoInlineBrTarget = 9,
MonoShortInlineBrTarget = 10,
MonoInlineSwitch = 11,
MonoInlineR = 12,
MonoShortInlineR = 13,
MonoInlineI = 14,
MonoShortInlineI = 15,
MonoInlineI8 = 16,
};
typedef struct {
unsigned char argument;
unsigned char flow_type;
unsigned short opval;
} MonoOpcode;
MONO_END_DECLS
#endif /* _MONO_OPCODES_TYPES_H */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/mini/mini-windows-dllmain.c | /**
* \file
* DllMain entry point.
*
* (C) 2002-2003 Ximian, Inc.
* (C) 2003-2006 Novell, Inc.
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "mini-runtime.h"
#ifdef HOST_WIN32
#include "mini-windows.h"
#include <windows.h>
MONO_EXTERN_C
BOOL APIENTRY DllMain (HMODULE module_handle, DWORD reason, LPVOID reserved);
MONO_EXTERN_C
BOOL APIENTRY DllMain (HMODULE module_handle, DWORD reason, LPVOID reserved)
{
return mono_win32_runtime_tls_callback (module_handle, reason, reserved, MONO_WIN32_TLS_CALLBACK_TYPE_DLL);
}
#endif
| /**
* \file
* DllMain entry point.
*
* (C) 2002-2003 Ximian, Inc.
* (C) 2003-2006 Novell, Inc.
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include "mini-runtime.h"
#ifdef HOST_WIN32
#include "mini-windows.h"
#include <windows.h>
MONO_EXTERN_C
BOOL APIENTRY DllMain (HMODULE module_handle, DWORD reason, LPVOID reserved);
MONO_EXTERN_C
BOOL APIENTRY DllMain (HMODULE module_handle, DWORD reason, LPVOID reserved)
{
return mono_win32_runtime_tls_callback (module_handle, reason, reserved, MONO_WIN32_TLS_CALLBACK_TYPE_DLL);
}
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/gcdesc.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include "../gc/gcdesc.h"
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include "../gc/gcdesc.h"
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/mini/mini-ppc.h | /**
* \file
*/
#ifndef __MONO_MINI_PPC_H__
#define __MONO_MINI_PPC_H__
#include <mono/arch/ppc/ppc-codegen.h>
#include <mono/utils/mono-sigcontext.h>
#include <mono/utils/mono-context.h>
#include <mono/metadata/object.h>
#include <glib.h>
#ifdef __mono_ppc64__
#define MONO_ARCH_CPU_SPEC mono_ppc64_cpu_desc
#else
#define MONO_ARCH_CPU_SPEC mono_ppcg4
#endif
#define MONO_MAX_IREGS 32
#define MONO_MAX_FREGS 32
#define MONO_SAVED_GREGS 19
#define MONO_SAVED_FREGS 18
#define MONO_PPC_FIRST_SAVED_GREG ppc_r13
#define MONO_PPC_FIRST_SAVED_FREG ppc_f14
#define MONO_ARCH_FRAME_ALIGNMENT 16
/* fixme: align to 16byte instead of 32byte (we align to 32byte to get
* reproduceable results for benchmarks */
#define MONO_ARCH_CODE_ALIGNMENT 32
#ifdef __mono_ppc64__
#define THUNK_SIZE ((2 + 5) * 4)
#else
#define THUNK_SIZE ((2 + 2) * 4)
#endif
void ppc_patch (guchar *code, const guchar *target);
struct MonoLMF {
/*
* If the second lowest bit is set to 1, then this is a MonoLMFExt structure, and
* the other fields are not valid.
*/
gpointer previous_lmf;
gpointer lmf_addr;
MonoMethod *method;
gulong ebp;
gulong eip;
/* Add a dummy field to force iregs to be aligned when cross compiling from x86 */
gulong dummy;
host_mgreg_t iregs [MONO_SAVED_GREGS]; /* 13..31 */
gdouble fregs [MONO_SAVED_FREGS]; /* 14..31 */
};
typedef struct MonoCompileArch {
int fp_conv_var_offset;
guint8 *thunks;
int thunks_size;
} MonoCompileArch;
/*
* ILP32 uses a version of the ppc64 abi with sizeof(void*)==sizeof(long)==4.
* To support this, code needs to follow the following conventions:
* - for the size of a pointer use sizeof (gpointer)
* - for the size of a register/stack slot use SIZEOF_REGISTER.
* - for variables which contain values of registers, use host_mgreg_t or target_mgreg_t.
* - for loading/saving pointers/ints, use the normal ppc_load_reg/ppc_save_reg ()
* macros.
* - for loading/saving register sized quantities, use the ppc_ldr/ppc_str
* macros.
* - make sure to not mix the two kinds of macros for the same memory location,
* since ppc is big endian, so a 8 byte store followed by a 4 byte load will
* load the upper 32 bit of the value.
* - use OP_LOADR_MEMBASE/OP_STORER_MEMBASE to load/store register sized
* quantities.
*/
#ifdef __mono_ppc64__
#define MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS
#define MONO_ARCH_NO_EMULATE_LONG_MUL_OPTS
/* ELFv2 ABI doesn't use function descriptors. */
#if _CALL_ELF == 2
#undef PPC_USES_FUNCTION_DESCRIPTOR
#else
#define PPC_USES_FUNCTION_DESCRIPTOR
#endif
#else /* must be __mono_ppc__ */
#if defined(_AIX)
/* 32 and 64 bit AIX use function descriptors */
#define PPC_USES_FUNCTION_DESCRIPTOR
#endif
#define MONO_ARCH_EMULATE_FCONV_TO_I8 1
#define MONO_ARCH_EMULATE_LCONV_TO_R8 1
#define MONO_ARCH_EMULATE_LCONV_TO_R4 1
#endif
#define MONO_ARCH_EMULATE_FCONV_TO_U4 1
#define MONO_ARCH_EMULATE_FCONV_TO_U8 1
#define MONO_ARCH_EMULATE_LCONV_TO_R8_UN 1
#define MONO_ARCH_EMULATE_FREM 1
#define MONO_ARCH_GC_MAPS_SUPPORTED 1
/* Parameters used by the register allocator */
#define MONO_ARCH_CALLEE_REGS ((0xff << ppc_r3) | (1 << ppc_r12) | (1 << ppc_r11))
#define MONO_ARCH_CALLEE_SAVED_REGS (0xfffff << ppc_r13) /* ppc_13 - ppc_31 */
#if defined(__APPLE__) || defined(__mono_ppc64__)
#define MONO_ARCH_CALLEE_FREGS (0x1fff << ppc_f1)
#else
#define MONO_ARCH_CALLEE_FREGS (0xff << ppc_f1)
#endif
#define MONO_ARCH_CALLEE_SAVED_FREGS (~(MONO_ARCH_CALLEE_FREGS | 1))
#define MONO_ARCH_USE_FPSTACK FALSE
#ifdef __mono_ppc64__
#define MONO_ARCH_INST_FIXED_REG(desc) (((desc) == 'a')? ppc_r3:\
((desc) == 'g'? ppc_f1:-1))
#define MONO_ARCH_INST_IS_REGPAIR(desc) FALSE
#define MONO_ARCH_INST_REGPAIR_REG2(desc,hreg1) (-1)
#else
#define MONO_ARCH_INST_FIXED_REG(desc) (((desc) == 'a')? ppc_r3:\
((desc) == 'l')? ppc_r4:\
((desc) == 'g'? ppc_f1:-1))
#define MONO_ARCH_INST_IS_REGPAIR(desc) (desc == 'l')
#define MONO_ARCH_INST_REGPAIR_REG2(desc,hreg1) (desc == 'l' ? ppc_r3 : -1)
#endif
#define MONO_ARCH_INST_SREG2_MASK(ins) (0)
#define MONO_ARCH_INST_IS_FLOAT(desc) ((desc == 'f') || (desc == 'g'))
/* deal with some of the ABI differences here */
#ifdef __APPLE__
#define PPC_RET_ADDR_OFFSET 8
#define PPC_STACK_PARAM_OFFSET 24
#define PPC_MINIMAL_STACK_SIZE 24
#define PPC_MINIMAL_PARAM_AREA_SIZE 0
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_FIRST_ARG_REG ppc_r3
#define PPC_LAST_ARG_REG ppc_r10
#define PPC_FIRST_FPARG_REG ppc_f1
#define PPC_LAST_FPARG_REG ppc_f13
#define PPC_PASS_STRUCTS_BY_VALUE 1
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#elif defined(_AIX)
/* FIXME: are these values valid? on 32-bit? */
#define PPC_RET_ADDR_OFFSET 16
#if defined(__mono_ppc64__)
#define PPC_STACK_PARAM_OFFSET 112
#define PPC_MINIMAL_STACK_SIZE 112
#else
#define PPC_STACK_PARAM_OFFSET 56
#define PPC_MINIMAL_STACK_SIZE 56
#endif
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#define MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK 1
#define PPC_MINIMAL_PARAM_AREA_SIZE 64
#define PPC_LAST_FPARG_REG ppc_f13
#define PPC_PASS_STRUCTS_BY_VALUE 1
#define PPC_THREAD_PTR_REG ppc_r13
#define PPC_FIRST_ARG_REG ppc_r3
#define PPC_LAST_ARG_REG ppc_r10
#define PPC_FIRST_FPARG_REG ppc_f1
#else
/* Linux */
#ifdef __mono_ppc64__
#define PPC_RET_ADDR_OFFSET 16
// Power LE abvi2
#if (_CALL_ELF == 2)
#define PPC_STACK_PARAM_OFFSET 32
#define PPC_MINIMAL_STACK_SIZE 32
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 16
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 8
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 1
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 1
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 1
// Define "DEBUG_ELFABIV2" to allow for debugging output for ELF ABI v2 function call and return codegen
// #define DEBUG_ELFABIV2
#define MONO_ARCH_LLVM_SUPPORTED 1
#else
#define PPC_STACK_PARAM_OFFSET 48
#define PPC_MINIMAL_STACK_SIZE 48
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#endif
#define MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK 1
#define PPC_MINIMAL_PARAM_AREA_SIZE 64
#define PPC_LAST_FPARG_REG ppc_f13
#define PPC_PASS_STRUCTS_BY_VALUE 1
#define PPC_THREAD_PTR_REG ppc_r13
#else
#define PPC_RET_ADDR_OFFSET 4
#define PPC_STACK_PARAM_OFFSET 8
#define PPC_MINIMAL_STACK_SIZE 8
#define PPC_MINIMAL_PARAM_AREA_SIZE 0
#define PPC_LAST_FPARG_REG ppc_f8
#define PPC_PASS_STRUCTS_BY_VALUE 0
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#define PPC_THREAD_PTR_REG ppc_r2
#endif
#define PPC_FIRST_ARG_REG ppc_r3
#define PPC_LAST_ARG_REG ppc_r10
#define PPC_FIRST_FPARG_REG ppc_f1
#endif
#define PPC_CALL_REG ppc_r12
#if defined(HAVE_WORKING_SIGALTSTACK) && !defined(__APPLE__)
#define MONO_ARCH_SIGSEGV_ON_ALTSTACK 1
#define MONO_ARCH_SIGNAL_STACK_SIZE (12 * 1024)
#endif /* HAVE_WORKING_SIGALTSTACK */
#define MONO_ARCH_IMT_REG ppc_r11
#define MONO_ARCH_VTABLE_REG ppc_r11
#define MONO_ARCH_RGCTX_REG MONO_ARCH_IMT_REG
#define MONO_ARCH_HAVE_SETUP_RESUME_FROM_SIGNAL_HANDLER_CTX 1
#define MONO_ARCH_NO_IOV_CHECK 1
#define MONO_ARCH_HAVE_DECOMPOSE_OPTS 1
#define MONO_ARCH_HAVE_DECOMPOSE_LONG_OPTS 1
#define MONO_ARCH_HAVE_GENERALIZED_IMT_TRAMPOLINE 1
#define MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES 1
#define MONO_ARCH_GSHARED_SUPPORTED 1
#define MONO_ARCH_NEED_DIV_CHECK 1
#define MONO_ARCH_AOT_SUPPORTED 1
#define MONO_ARCH_NEED_GOT_VAR 1
#if !defined(MONO_CROSS_COMPILE) && !defined(TARGET_PS3)
#define MONO_ARCH_SOFT_DEBUG_SUPPORTED 1
#endif
// Does the ABI have a volatile non-parameter register, so tailcall
// can pass context to generics or interfaces?
#define MONO_ARCH_HAVE_VOLATILE_NON_PARAM_REGISTER 0 // FIXME?
#if defined(_AIX)
/*
* HACK: AIX always allows accessing page 0! We can't rely on SIGSEGV
* to save us when a null dereference in managed code occurs, so we
* always have to check for null.
*/
#define MONO_ARCH_EXPLICIT_NULL_CHECKS 1
#endif
#define PPC_NUM_REG_ARGS (PPC_LAST_ARG_REG-PPC_FIRST_ARG_REG+1)
#define PPC_NUM_REG_FPARGS (PPC_LAST_FPARG_REG-PPC_FIRST_FPARG_REG+1)
#ifdef MONO_CROSS_COMPILE
typedef struct {
unsigned long sp;
unsigned long unused1;
unsigned long lr;
} MonoPPCStackFrame;
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) g_assert_not_reached ()
#elif defined (__APPLE__)
typedef struct {
unsigned long sp;
unsigned long unused1;
unsigned long lr;
} MonoPPCStackFrame;
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) do { \
gpointer r1; \
__asm__ volatile("mr %0,r1" : "=r" (r1)); \
MONO_CONTEXT_SET_BP ((ctx), r1); \
MONO_CONTEXT_SET_IP ((ctx), (start_func)); \
} while (0)
#else
typedef struct {
host_mgreg_t sp;
#ifdef __mono_ppc64__
host_mgreg_t cr;
#endif
host_mgreg_t lr;
} MonoPPCStackFrame;
#ifdef G_COMPILER_CODEWARRIOR
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) do { \
register gpointer r1_var; \
asm { mr r1_var, r1 }; \
MONO_CONTEXT_SET_BP ((ctx), r1); \
MONO_CONTEXT_SET_IP ((ctx), (start_func)); \
} while (0)
#else
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) do { \
gpointer r1; \
__asm__ volatile("mr %0,1" : "=r" (r1)); \
MONO_CONTEXT_SET_BP ((ctx), r1); \
MONO_CONTEXT_SET_IP ((ctx), (start_func)); \
} while (0)
#endif
#endif
#define MONO_ARCH_INIT_TOP_LMF_ENTRY(lmf) do { (lmf)->ebp = -1; } while (0)
typedef struct {
gint8 reg;
gint8 size;
int vtsize;
int offset;
} MonoPPCArgInfo;
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
typedef struct {
gpointer code;
gpointer toc;
gpointer env;
} MonoPPCFunctionDescriptor;
#define PPC_FTNPTR_SIZE sizeof (MonoPPCFunctionDescriptor)
extern guint8* mono_ppc_create_pre_code_ftnptr (guint8 *code);
#else
#define PPC_FTNPTR_SIZE 0
#define mono_ppc_create_pre_code_ftnptr(c) c
#endif
#if defined(__linux__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined (__APPLE__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined(__NetBSD__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined(__FreeBSD__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined (_AIX)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined(MONO_CROSS_COMPILE)
typedef MonoContext ucontext_t;
/* typedef struct {
int dummy;
} ucontext_t;*/
#define UCONTEXT_REG_Rn(ctx, n)
#define UCONTEXT_REG_FPRn(ctx, n)
#define UCONTEXT_REG_NIP(ctx)
#define UCONTEXT_REG_LNK(ctx)
#else
#error No OS definition for MONO_ARCH_USE_SIGACTION.
#endif
gboolean
mono_ppc_tailcall_supported (MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig);
void
mono_ppc_patch (guchar *code, const guchar *target);
void
mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, host_mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow, gboolean preserve_ips);
#ifdef __mono_ppc64__
#define MONO_PPC_32_64_CASE(c32,c64) c64
extern void mono_ppc_emitted (guint8 *code, gint64 length, const char *format, ...);
#else
#define MONO_PPC_32_64_CASE(c32,c64) c32
#endif
gboolean mono_ppc_is_direct_call_sequence (guint32 *code);
// Debugging macros for ELF ABI v2
#ifdef DEBUG_ELFABIV2
#define DEBUG_ELFABIV2_printf(a, ...) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { printf(a, ##__VA_ARGS__); fflush(stdout); g_free (debug_env); } }
#define DEBUG_ELFABIV2_mono_print_ins(a) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { if (!a) {printf("null\n");} else {mono_print_ins(a);} fflush(stdout); g_free (debug_env); } }
extern char* mono_type_full_name (MonoType *type);
#define DEBUG_ELFABIV2_mono_print_type(a) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { printf("%s, size: %d\n", mono_type_get_name(a), mini_type_stack_size (a, 0)); fflush(stdout); g_free (debug_env); } }
#define DEBUG_ELFABIV2_mono_print_class(a) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { printf("%s\n", mono_type_get_name(m_class_get_byval_arg (a))); fflush(stdout); g_free (debug_env); } }
#else
#define DEBUG_ELFABIV2_printf(a, ...)
#define DEBUG_ELFABIV2_mono_print_ins(a)
#define DEBUG_ELFABIV2_mono_print_type(a)
#define DEBUG_ELFABIV2_mono_print_class(a)
#endif
#endif /* __MONO_MINI_PPC_H__ */
| /**
* \file
*/
#ifndef __MONO_MINI_PPC_H__
#define __MONO_MINI_PPC_H__
#include <mono/arch/ppc/ppc-codegen.h>
#include <mono/utils/mono-sigcontext.h>
#include <mono/utils/mono-context.h>
#include <mono/metadata/object.h>
#include <glib.h>
#ifdef __mono_ppc64__
#define MONO_ARCH_CPU_SPEC mono_ppc64_cpu_desc
#else
#define MONO_ARCH_CPU_SPEC mono_ppcg4
#endif
#define MONO_MAX_IREGS 32
#define MONO_MAX_FREGS 32
#define MONO_SAVED_GREGS 19
#define MONO_SAVED_FREGS 18
#define MONO_PPC_FIRST_SAVED_GREG ppc_r13
#define MONO_PPC_FIRST_SAVED_FREG ppc_f14
#define MONO_ARCH_FRAME_ALIGNMENT 16
/* fixme: align to 16byte instead of 32byte (we align to 32byte to get
* reproduceable results for benchmarks */
#define MONO_ARCH_CODE_ALIGNMENT 32
#ifdef __mono_ppc64__
#define THUNK_SIZE ((2 + 5) * 4)
#else
#define THUNK_SIZE ((2 + 2) * 4)
#endif
void ppc_patch (guchar *code, const guchar *target);
struct MonoLMF {
/*
* If the second lowest bit is set to 1, then this is a MonoLMFExt structure, and
* the other fields are not valid.
*/
gpointer previous_lmf;
gpointer lmf_addr;
MonoMethod *method;
gulong ebp;
gulong eip;
/* Add a dummy field to force iregs to be aligned when cross compiling from x86 */
gulong dummy;
host_mgreg_t iregs [MONO_SAVED_GREGS]; /* 13..31 */
gdouble fregs [MONO_SAVED_FREGS]; /* 14..31 */
};
typedef struct MonoCompileArch {
int fp_conv_var_offset;
guint8 *thunks;
int thunks_size;
} MonoCompileArch;
/*
* ILP32 uses a version of the ppc64 abi with sizeof(void*)==sizeof(long)==4.
* To support this, code needs to follow the following conventions:
* - for the size of a pointer use sizeof (gpointer)
* - for the size of a register/stack slot use SIZEOF_REGISTER.
* - for variables which contain values of registers, use host_mgreg_t or target_mgreg_t.
* - for loading/saving pointers/ints, use the normal ppc_load_reg/ppc_save_reg ()
* macros.
* - for loading/saving register sized quantities, use the ppc_ldr/ppc_str
* macros.
* - make sure to not mix the two kinds of macros for the same memory location,
* since ppc is big endian, so a 8 byte store followed by a 4 byte load will
* load the upper 32 bit of the value.
* - use OP_LOADR_MEMBASE/OP_STORER_MEMBASE to load/store register sized
* quantities.
*/
#ifdef __mono_ppc64__
#define MONO_ARCH_NO_EMULATE_LONG_SHIFT_OPS
#define MONO_ARCH_NO_EMULATE_LONG_MUL_OPTS
/* ELFv2 ABI doesn't use function descriptors. */
#if _CALL_ELF == 2
#undef PPC_USES_FUNCTION_DESCRIPTOR
#else
#define PPC_USES_FUNCTION_DESCRIPTOR
#endif
#else /* must be __mono_ppc__ */
#if defined(_AIX)
/* 32 and 64 bit AIX use function descriptors */
#define PPC_USES_FUNCTION_DESCRIPTOR
#endif
#define MONO_ARCH_EMULATE_FCONV_TO_I8 1
#define MONO_ARCH_EMULATE_LCONV_TO_R8 1
#define MONO_ARCH_EMULATE_LCONV_TO_R4 1
#endif
#define MONO_ARCH_EMULATE_FCONV_TO_U4 1
#define MONO_ARCH_EMULATE_FCONV_TO_U8 1
#define MONO_ARCH_EMULATE_LCONV_TO_R8_UN 1
#define MONO_ARCH_EMULATE_FREM 1
#define MONO_ARCH_GC_MAPS_SUPPORTED 1
/* Parameters used by the register allocator */
#define MONO_ARCH_CALLEE_REGS ((0xff << ppc_r3) | (1 << ppc_r12) | (1 << ppc_r11))
#define MONO_ARCH_CALLEE_SAVED_REGS (0xfffff << ppc_r13) /* ppc_13 - ppc_31 */
#if defined(__APPLE__) || defined(__mono_ppc64__)
#define MONO_ARCH_CALLEE_FREGS (0x1fff << ppc_f1)
#else
#define MONO_ARCH_CALLEE_FREGS (0xff << ppc_f1)
#endif
#define MONO_ARCH_CALLEE_SAVED_FREGS (~(MONO_ARCH_CALLEE_FREGS | 1))
#define MONO_ARCH_USE_FPSTACK FALSE
#ifdef __mono_ppc64__
#define MONO_ARCH_INST_FIXED_REG(desc) (((desc) == 'a')? ppc_r3:\
((desc) == 'g'? ppc_f1:-1))
#define MONO_ARCH_INST_IS_REGPAIR(desc) FALSE
#define MONO_ARCH_INST_REGPAIR_REG2(desc,hreg1) (-1)
#else
#define MONO_ARCH_INST_FIXED_REG(desc) (((desc) == 'a')? ppc_r3:\
((desc) == 'l')? ppc_r4:\
((desc) == 'g'? ppc_f1:-1))
#define MONO_ARCH_INST_IS_REGPAIR(desc) (desc == 'l')
#define MONO_ARCH_INST_REGPAIR_REG2(desc,hreg1) (desc == 'l' ? ppc_r3 : -1)
#endif
#define MONO_ARCH_INST_SREG2_MASK(ins) (0)
#define MONO_ARCH_INST_IS_FLOAT(desc) ((desc == 'f') || (desc == 'g'))
/* deal with some of the ABI differences here */
#ifdef __APPLE__
#define PPC_RET_ADDR_OFFSET 8
#define PPC_STACK_PARAM_OFFSET 24
#define PPC_MINIMAL_STACK_SIZE 24
#define PPC_MINIMAL_PARAM_AREA_SIZE 0
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_FIRST_ARG_REG ppc_r3
#define PPC_LAST_ARG_REG ppc_r10
#define PPC_FIRST_FPARG_REG ppc_f1
#define PPC_LAST_FPARG_REG ppc_f13
#define PPC_PASS_STRUCTS_BY_VALUE 1
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#elif defined(_AIX)
/* FIXME: are these values valid? on 32-bit? */
#define PPC_RET_ADDR_OFFSET 16
#if defined(__mono_ppc64__)
#define PPC_STACK_PARAM_OFFSET 112
#define PPC_MINIMAL_STACK_SIZE 112
#else
#define PPC_STACK_PARAM_OFFSET 56
#define PPC_MINIMAL_STACK_SIZE 56
#endif
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#define MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK 1
#define PPC_MINIMAL_PARAM_AREA_SIZE 64
#define PPC_LAST_FPARG_REG ppc_f13
#define PPC_PASS_STRUCTS_BY_VALUE 1
#define PPC_THREAD_PTR_REG ppc_r13
#define PPC_FIRST_ARG_REG ppc_r3
#define PPC_LAST_ARG_REG ppc_r10
#define PPC_FIRST_FPARG_REG ppc_f1
#else
/* Linux */
#ifdef __mono_ppc64__
#define PPC_RET_ADDR_OFFSET 16
// Power LE abvi2
#if (_CALL_ELF == 2)
#define PPC_STACK_PARAM_OFFSET 32
#define PPC_MINIMAL_STACK_SIZE 32
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 16
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 8
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 1
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 1
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 1
// Define "DEBUG_ELFABIV2" to allow for debugging output for ELF ABI v2 function call and return codegen
// #define DEBUG_ELFABIV2
#define MONO_ARCH_LLVM_SUPPORTED 1
#else
#define PPC_STACK_PARAM_OFFSET 48
#define PPC_MINIMAL_STACK_SIZE 48
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#endif
#define MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK 1
#define PPC_MINIMAL_PARAM_AREA_SIZE 64
#define PPC_LAST_FPARG_REG ppc_f13
#define PPC_PASS_STRUCTS_BY_VALUE 1
#define PPC_THREAD_PTR_REG ppc_r13
#else
#define PPC_RET_ADDR_OFFSET 4
#define PPC_STACK_PARAM_OFFSET 8
#define PPC_MINIMAL_STACK_SIZE 8
#define PPC_MINIMAL_PARAM_AREA_SIZE 0
#define PPC_LAST_FPARG_REG ppc_f8
#define PPC_PASS_STRUCTS_BY_VALUE 0
#define PPC_LARGEST_STRUCT_SIZE_TO_RETURN_VIA_REGISTERS 0
#define PPC_MOST_FLOAT_STRUCT_MEMBERS_TO_RETURN_VIA_REGISTERS 0
#define PPC_PASS_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_FLOAT_STRUCTS_IN_FR_REGS 0
#define PPC_RETURN_SMALL_STRUCTS_IN_REGS 0
#define PPC_THREAD_PTR_REG ppc_r2
#endif
#define PPC_FIRST_ARG_REG ppc_r3
#define PPC_LAST_ARG_REG ppc_r10
#define PPC_FIRST_FPARG_REG ppc_f1
#endif
#define PPC_CALL_REG ppc_r12
#if defined(HAVE_WORKING_SIGALTSTACK) && !defined(__APPLE__)
#define MONO_ARCH_SIGSEGV_ON_ALTSTACK 1
#define MONO_ARCH_SIGNAL_STACK_SIZE (12 * 1024)
#endif /* HAVE_WORKING_SIGALTSTACK */
#define MONO_ARCH_IMT_REG ppc_r11
#define MONO_ARCH_VTABLE_REG ppc_r11
#define MONO_ARCH_RGCTX_REG MONO_ARCH_IMT_REG
#define MONO_ARCH_HAVE_SETUP_RESUME_FROM_SIGNAL_HANDLER_CTX 1
#define MONO_ARCH_NO_IOV_CHECK 1
#define MONO_ARCH_HAVE_DECOMPOSE_OPTS 1
#define MONO_ARCH_HAVE_DECOMPOSE_LONG_OPTS 1
#define MONO_ARCH_HAVE_GENERALIZED_IMT_TRAMPOLINE 1
#define MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES 1
#define MONO_ARCH_GSHARED_SUPPORTED 1
#define MONO_ARCH_NEED_DIV_CHECK 1
#define MONO_ARCH_AOT_SUPPORTED 1
#define MONO_ARCH_NEED_GOT_VAR 1
#if !defined(MONO_CROSS_COMPILE) && !defined(TARGET_PS3)
#define MONO_ARCH_SOFT_DEBUG_SUPPORTED 1
#endif
// Does the ABI have a volatile non-parameter register, so tailcall
// can pass context to generics or interfaces?
#define MONO_ARCH_HAVE_VOLATILE_NON_PARAM_REGISTER 0 // FIXME?
#if defined(_AIX)
/*
* HACK: AIX always allows accessing page 0! We can't rely on SIGSEGV
* to save us when a null dereference in managed code occurs, so we
* always have to check for null.
*/
#define MONO_ARCH_EXPLICIT_NULL_CHECKS 1
#endif
#define PPC_NUM_REG_ARGS (PPC_LAST_ARG_REG-PPC_FIRST_ARG_REG+1)
#define PPC_NUM_REG_FPARGS (PPC_LAST_FPARG_REG-PPC_FIRST_FPARG_REG+1)
#ifdef MONO_CROSS_COMPILE
typedef struct {
unsigned long sp;
unsigned long unused1;
unsigned long lr;
} MonoPPCStackFrame;
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) g_assert_not_reached ()
#elif defined (__APPLE__)
typedef struct {
unsigned long sp;
unsigned long unused1;
unsigned long lr;
} MonoPPCStackFrame;
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) do { \
gpointer r1; \
__asm__ volatile("mr %0,r1" : "=r" (r1)); \
MONO_CONTEXT_SET_BP ((ctx), r1); \
MONO_CONTEXT_SET_IP ((ctx), (start_func)); \
} while (0)
#else
typedef struct {
host_mgreg_t sp;
#ifdef __mono_ppc64__
host_mgreg_t cr;
#endif
host_mgreg_t lr;
} MonoPPCStackFrame;
#ifdef G_COMPILER_CODEWARRIOR
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) do { \
register gpointer r1_var; \
asm { mr r1_var, r1 }; \
MONO_CONTEXT_SET_BP ((ctx), r1); \
MONO_CONTEXT_SET_IP ((ctx), (start_func)); \
} while (0)
#else
#define MONO_INIT_CONTEXT_FROM_FUNC(ctx,start_func) do { \
gpointer r1; \
__asm__ volatile("mr %0,1" : "=r" (r1)); \
MONO_CONTEXT_SET_BP ((ctx), r1); \
MONO_CONTEXT_SET_IP ((ctx), (start_func)); \
} while (0)
#endif
#endif
#define MONO_ARCH_INIT_TOP_LMF_ENTRY(lmf) do { (lmf)->ebp = -1; } while (0)
typedef struct {
gint8 reg;
gint8 size;
int vtsize;
int offset;
} MonoPPCArgInfo;
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
typedef struct {
gpointer code;
gpointer toc;
gpointer env;
} MonoPPCFunctionDescriptor;
#define PPC_FTNPTR_SIZE sizeof (MonoPPCFunctionDescriptor)
extern guint8* mono_ppc_create_pre_code_ftnptr (guint8 *code);
#else
#define PPC_FTNPTR_SIZE 0
#define mono_ppc_create_pre_code_ftnptr(c) c
#endif
#if defined(__linux__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined (__APPLE__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined(__NetBSD__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined(__FreeBSD__)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined (_AIX)
#define MONO_ARCH_USE_SIGACTION 1
#elif defined(MONO_CROSS_COMPILE)
typedef MonoContext ucontext_t;
/* typedef struct {
int dummy;
} ucontext_t;*/
#define UCONTEXT_REG_Rn(ctx, n)
#define UCONTEXT_REG_FPRn(ctx, n)
#define UCONTEXT_REG_NIP(ctx)
#define UCONTEXT_REG_LNK(ctx)
#else
#error No OS definition for MONO_ARCH_USE_SIGACTION.
#endif
gboolean
mono_ppc_tailcall_supported (MonoMethodSignature *caller_sig, MonoMethodSignature *callee_sig);
void
mono_ppc_patch (guchar *code, const guchar *target);
void
mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, host_mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow, gboolean preserve_ips);
#ifdef __mono_ppc64__
#define MONO_PPC_32_64_CASE(c32,c64) c64
extern void mono_ppc_emitted (guint8 *code, gint64 length, const char *format, ...);
#else
#define MONO_PPC_32_64_CASE(c32,c64) c32
#endif
gboolean mono_ppc_is_direct_call_sequence (guint32 *code);
// Debugging macros for ELF ABI v2
#ifdef DEBUG_ELFABIV2
#define DEBUG_ELFABIV2_printf(a, ...) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { printf(a, ##__VA_ARGS__); fflush(stdout); g_free (debug_env); } }
#define DEBUG_ELFABIV2_mono_print_ins(a) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { if (!a) {printf("null\n");} else {mono_print_ins(a);} fflush(stdout); g_free (debug_env); } }
extern char* mono_type_full_name (MonoType *type);
#define DEBUG_ELFABIV2_mono_print_type(a) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { printf("%s, size: %d\n", mono_type_get_name(a), mini_type_stack_size (a, 0)); fflush(stdout); g_free (debug_env); } }
#define DEBUG_ELFABIV2_mono_print_class(a) \
{char *debug_env; if (debug_env = getenv("DEBUG_ELFABIV2")) { printf("%s\n", mono_type_get_name(m_class_get_byval_arg (a))); fflush(stdout); g_free (debug_env); } }
#else
#define DEBUG_ELFABIV2_printf(a, ...)
#define DEBUG_ELFABIV2_mono_print_ins(a)
#define DEBUG_ELFABIV2_mono_print_type(a)
#define DEBUG_ELFABIV2_mono_print_class(a)
#endif
#endif /* __MONO_MINI_PPC_H__ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/tools/superpmi/superpmi/cycletimer.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef _CycleTimer
#define _CycleTimer
#include "errorhandling.h"
class CycleTimer
{
public:
CycleTimer();
~CycleTimer();
void Start();
void Stop();
unsigned __int64 GetCycles();
unsigned __int64 QueryOverhead();
private:
// Cycles
unsigned __int64 start;
unsigned __int64 stop;
unsigned __int64 overhead;
};
#endif
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#ifndef _CycleTimer
#define _CycleTimer
#include "errorhandling.h"
class CycleTimer
{
public:
CycleTimer();
~CycleTimer();
void Start();
void Stop();
unsigned __int64 GetCycles();
unsigned __int64 QueryOverhead();
private:
// Cycles
unsigned __int64 start;
unsigned __int64 stop;
unsigned __int64 overhead;
};
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/metasig.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// METASIG.H
//
//
// All literal MetaData signatures should be defined here.
//
// Generic sig's based on types.
// All sigs are alphabetized by the signature string and given a canonical name. Do not
// give them "meaningful" names because we want to share them aggressively. Do not add
// duplicates!
// The canonical form:
//
// <what>(<type>*, <name>*)
//
// where <what> is:
//
// Fld -- field
// IM -- instance method (HASTHIS == TRUE)
// SM -- static method
//
// and <name> -- <type> is:
//
// a -- Arr -- array
// P -- Ptr -- a pointer
// r -- Ref -- a byref
// Ret -- indicates function return type
//
// Var -- Variant
//
// b -- Byte -- (unsigned) byte
// u -- Char -- character (2 byte unsigned unicode)
// d -- Dbl -- double
// f -- Flt -- float
// i -- Int -- integer
// K -- UInt -- unsigned integer
// I -- IntPtr -- agnostic integer
// U -- UIntPtr -- agnostic unsigned integer
// l -- Long -- long integer
// L -- ULong -- unsigned long integer
// h -- Shrt -- short integer
// H -- UShrt -- unsigned short integer
// v -- Void -- Void
// B -- SByt -- signed byte
// F -- Bool -- boolean
// j -- Obj -- System.Object
// s -- Str -- System.String
// C -- -- class
// g -- -- struct
// T -- TypedReference -- TypedReference
// G -- -- Generic type variable
// M -- -- Generic method variable
// GI -- -- Generic type instantiation
// Q -- modreq
//#DEFINE_METASIG
// Use DEFINE_METASIG for signatures that does not reference other types
// Use DEFINE_METASIG_T for signatures that reference other types (contains C or g)
// This part of the file is included multiple times with different macro definitions
// to generate the hardcoded metasigs.
// SM, IM and Fld macros have often a very similar definitions. METASIG_BODY is
// a helper to avoid these redundant SM, IM and Fld definitions.
#ifdef METASIG_BODY
#ifndef DEFINE_METASIG
// See code:#DEFINE_METASIG
#define DEFINE_METASIG(body) body
#endif
#define SM(varname, args, retval) METASIG_BODY( SM_ ## varname, args retval )
#define IM(varname, args, retval) METASIG_BODY( IM_ ## varname, args retval )
#define GM(varname, n, conv, args, retval) METASIG_BODY( GM_ ## varname, args retval )
#define Fld(varname, val) METASIG_BODY( Fld_ ## varname, val )
#endif
#ifdef DEFINE_METASIG
// Use default if undefined
// See code:#DEFINE_METASIG
#ifndef DEFINE_METASIG_T
#define DEFINE_METASIG_T(body) DEFINE_METASIG(body)
#endif
// One letter shortcuts are defined for all types that can occur in the signature.
// The shortcuts are defined indirectly through METASIG_ATOM. METASIG_ATOM is
// designed to control whether to generate the initializer for the signature or
// just compute the size of the signature.
#define b METASIG_ATOM(ELEMENT_TYPE_U1)
#define u METASIG_ATOM(ELEMENT_TYPE_CHAR)
#define d METASIG_ATOM(ELEMENT_TYPE_R8)
#define f METASIG_ATOM(ELEMENT_TYPE_R4)
#define i METASIG_ATOM(ELEMENT_TYPE_I4)
#define K METASIG_ATOM(ELEMENT_TYPE_U4)
#define I METASIG_ATOM(ELEMENT_TYPE_I)
#define U METASIG_ATOM(ELEMENT_TYPE_U)
#define l METASIG_ATOM(ELEMENT_TYPE_I8)
#define L METASIG_ATOM(ELEMENT_TYPE_U8)
#define h METASIG_ATOM(ELEMENT_TYPE_I2)
#define H METASIG_ATOM(ELEMENT_TYPE_U2)
#define v METASIG_ATOM(ELEMENT_TYPE_VOID)
#define B METASIG_ATOM(ELEMENT_TYPE_I1)
#define F METASIG_ATOM(ELEMENT_TYPE_BOOLEAN)
#define j METASIG_ATOM(ELEMENT_TYPE_OBJECT)
#define s METASIG_ATOM(ELEMENT_TYPE_STRING)
#define T METASIG_ATOM(ELEMENT_TYPE_TYPEDBYREF)
// METASIG_RECURSE controls whether to recurse into the complex types
// in the macro expansion. METASIG_RECURSE is designed to control
// whether to compute the byte size of the signature or just compute
// the number of arguments in the signature.
#if METASIG_RECURSE
#define a(x) METASIG_ATOM(ELEMENT_TYPE_SZARRAY) x
#define P(x) METASIG_ATOM(ELEMENT_TYPE_PTR) x
#define r(x) METASIG_ATOM(ELEMENT_TYPE_BYREF) x
#define G(n) METASIG_ATOM(ELEMENT_TYPE_VAR) METASIG_ATOM(n)
#define M(n) METASIG_ATOM(ELEMENT_TYPE_MVAR) METASIG_ATOM(n)
#define GI(type, n, x) METASIG_ATOM(ELEMENT_TYPE_GENERICINST) type METASIG_ATOM(n) x
// The references to other types have special definition in some cases
#ifndef C
#define C(x) METASIG_ATOM(ELEMENT_TYPE_CLASS) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100)
#endif
#ifndef g
#define g(x) METASIG_ATOM(ELEMENT_TYPE_VALUETYPE) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100)
#endif
#ifndef Q
#define Q(x) METASIG_ATOM(ELEMENT_TYPE_CMOD_REQD) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100)
#endif
#else
#define a(x) METASIG_ATOM(ELEMENT_TYPE_SZARRAY)
#define P(x) METASIG_ATOM(ELEMENT_TYPE_PTR)
#define r(x) METASIG_ATOM(ELEMENT_TYPE_BYREF)
#define G(n) METASIG_ATOM(ELEMENT_TYPE_VAR)
#define M(n) METASIG_ATOM(ELEMENT_TYPE_MVAR)
#define GI(type, n, x) METASIG_ATOM(ELEMENT_TYPE_GENERICINST)
// The references to other types have special definition in some cases
#ifndef C
#define C(x) METASIG_ATOM(ELEMENT_TYPE_CLASS)
#endif
#ifndef g
#define g(x) METASIG_ATOM(ELEMENT_TYPE_VALUETYPE)
#endif
#define Q(x)
#endif
// to avoid empty arguments for macros
#define _
// static methods:
DEFINE_METASIG_T(SM(Int_IntPtr_Obj_RetException, i I j, C(EXCEPTION)))
DEFINE_METASIG_T(SM(Type_ArrType_IntPtr_int_RetType, C(TYPE) a(C(TYPE)) I i, C(TYPE) ))
DEFINE_METASIG_T(SM(Type_RetIntPtr, C(TYPE), I))
DEFINE_METASIG(SM(RefIntPtr_IntPtr_IntPtr_Int_RetObj, r(I) I I i, j))
DEFINE_METASIG(SM(Obj_IntPtr_RetIntPtr, j I, I))
DEFINE_METASIG(SM(Obj_IntPtr_RetObj, j I, j))
DEFINE_METASIG(SM(Obj_RefIntPtr_RetVoid, j r(I), v))
DEFINE_METASIG(SM(Obj_IntPtr_RetVoid, j I, v))
DEFINE_METASIG(SM(Obj_IntPtr_RetBool, j I, F))
DEFINE_METASIG(SM(Obj_IntPtr_IntPtr_Int_RetIntPtr, j I I i, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_RefIntPtr_RetObj, I I r(I), j))
#ifdef FEATURE_COMINTEROP
DEFINE_METASIG(SM(Obj_IntPtr_RefIntPtr_RefBool_RetIntPtr, j I r(I) r(F), I))
DEFINE_METASIG(SM(Obj_IntPtr_RefIntPtr_RetIntPtr, j I r(I), I))
#endif // FEATURE_COMINTEROP
#ifdef FEATURE_COMWRAPPERS
DEFINE_METASIG_T(SM(Scenario_ComWrappers_Obj_CreateFlags_RefInt_RetPtrVoid, g(COMWRAPPERSSCENARIO) C(COMWRAPPERS) j g(CREATECOMINTERFACEFLAGS) r(i), P(v)))
DEFINE_METASIG_T(SM(Scenario_ComWrappers_IntPtr_CreateFlags_RetObj, g(COMWRAPPERSSCENARIO) C(COMWRAPPERS) I g(CREATEOBJECTFLAGS), j))
DEFINE_METASIG_T(SM(ComWrappers_IEnumerable_RetVoid, C(COMWRAPPERS) C(IENUMERABLE), v))
DEFINE_METASIG_T(SM(Obj_RefGuid_RefIntPtr_RetInt, j r(g(GUID)) r(I), i))
#endif // FEATURE_COMWRAPPERS
#ifdef FEATURE_OBJCMARSHAL
DEFINE_METASIG_T(SM(Exception_Obj_RefIntPtr_RetVoidPtr, C(EXCEPTION) j r(I), P(v)))
#endif // FEATURE_OBJCMARSHAL
DEFINE_METASIG(SM(Int_RetVoid, i, v))
DEFINE_METASIG(SM(Int_Int_RetVoid, i i, v))
DEFINE_METASIG(SM(Str_RetIntPtr, s, I))
DEFINE_METASIG(SM(Str_RetBool, s, F))
DEFINE_METASIG(SM(IntPtr_IntPtr_RetVoid, I I, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetIntPtr, I I j, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Obj_RetIntPtr, I I i j, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_RetVoid, I I I, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_UShrt_IntPtr_RetVoid, I I I H I, v))
DEFINE_METASIG(SM(IntPtr_Int_IntPtr_RetIntPtr, I i I, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_IntPtr_RetVoid, I I i I, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetVoid, I I j, v))
DEFINE_METASIG(SM(Obj_ArrObject_RetVoid, j a(j), v))
DEFINE_METASIG(SM(Obj_IntPtr_Obj_RetVoid, j I j, v))
DEFINE_METASIG(SM(RetUIntPtr, _, U))
DEFINE_METASIG(SM(RetIntPtr, _, I))
DEFINE_METASIG(SM(RetBool, _, F))
DEFINE_METASIG(SM(IntPtr_RetStr, I, s))
DEFINE_METASIG(SM(IntPtr_RetBool, I, F))
DEFINE_METASIG_T(SM(RuntimeType_RuntimeMethodHandleInternal_RetMethodBase, C(CLASS) g(METHOD_HANDLE_INTERNAL), C(METHOD_BASE) ))
DEFINE_METASIG_T(SM(RuntimeType_IRuntimeFieldInfo_RetFieldInfo, C(CLASS) C(I_RT_FIELD_INFO), C(FIELD_INFO) ))
DEFINE_METASIG_T(SM(RuntimeType_Int_RetPropertyInfo, C(CLASS) i, C(PROPERTY_INFO) ))
DEFINE_METASIG(SM(Char_Bool_Bool_RetByte, u F F, b))
DEFINE_METASIG(SM(Byte_RetChar, b, u))
DEFINE_METASIG(SM(Str_Bool_Bool_RefInt_RetIntPtr, s F F r(i), I))
DEFINE_METASIG(SM(IntPtr_Int_RetStr, I i, s))
DEFINE_METASIG_T(SM(Obj_PtrByte_RefCleanupWorkListElement_RetVoid, j P(b) r(C(CLEANUP_WORK_LIST_ELEMENT)), v))
DEFINE_METASIG_T(SM(SafeHandle_RefCleanupWorkListElement_RetIntPtr, C(SAFE_HANDLE) r(C(CLEANUP_WORK_LIST_ELEMENT)), I))
DEFINE_METASIG(SM(Obj_PtrByte_RetVoid, j P(b), v))
DEFINE_METASIG(SM(PtrByte_IntPtr_RetVoid, P(b) I, v))
DEFINE_METASIG(SM(Str_Bool_Bool_RefInt_RetArrByte, s F F r(i), a(b) ))
DEFINE_METASIG(SM(ArrByte_Int_PtrByte_Int_Int_RetVoid, a(b) i P(b) i i, v))
DEFINE_METASIG(SM(PtrByte_Int_ArrByte_Int_Int_RetVoid, P(b) i a(b) i i, v))
DEFINE_METASIG(SM(PtrByte_RetInt, P(b), i))
DEFINE_METASIG(SM(PtrSByt_RetInt, P(B), i))
DEFINE_METASIG(SM(IntPtr_RetIntPtr, I, I))
DEFINE_METASIG(SM(UIntPtr_RetIntPtr, U, I))
DEFINE_METASIG(SM(PtrByte_PtrByte_Int_RetVoid, P(b) P(b) i, v))
DEFINE_METASIG(SM(PtrVoid_Byte_UInt_RetVoid, P(v) b K, v))
DEFINE_METASIG(SM(RefObj_IntPtr_RetVoid, r(j) I, v))
DEFINE_METASIG(SM(RefObj_RefIntPtr_RetVoid, r(j) r(I), v))
DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_RetVoid, I r(j) I, v))
DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_Int_RetVoid, I r(j) I i,v))
DEFINE_METASIG(SM(IntPtr_Int_IntPtr_Int_Int_Int_RetVoid, I i I i i i, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Int_IntPtr_RetVoid, I I i i I, v))
DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_Obj_RetVoid, I r(j) I j, v))
DEFINE_METASIG(SM(Obj_Int_RetVoid, j i,v))
DEFINE_METASIG(SM(PtrVoid_Obj_RetObj, P(v) j, j))
DEFINE_METASIG(SM(PtrVoid_Obj_RetRefByte, P(v) j, r(b)))
DEFINE_METASIG(SM(Flt_RetFlt, f, f))
DEFINE_METASIG(SM(Dbl_RetDbl, d, d))
DEFINE_METASIG(SM(RefDbl_Dbl_RetDbl, r(d) d, d))
DEFINE_METASIG(SM(RefDbl_Dbl_Dbl_RetDbl, r(d) d d, d))
DEFINE_METASIG(SM(RefLong_Long_RetLong, r(l) l, l))
DEFINE_METASIG(SM(RefLong_Long_Long_RetLong, r(l) l l, l))
DEFINE_METASIG(SM(RefFlt_Flt_RetFlt, r(f) f, f))
DEFINE_METASIG(SM(RefFlt_Flt_Flt_RetFlt, r(f) f f, f))
DEFINE_METASIG(SM(RefInt_Int_RetInt, r(i) i, i))
DEFINE_METASIG(SM(RefInt_Int_Int_RetInt, r(i) i i, i))
DEFINE_METASIG(SM(RefInt_Int_Int_RefBool_RetInt, r(i) i i r(F), i))
DEFINE_METASIG(SM(RefIntPtr_IntPtr_RetIntPtr, r(I) I, I))
DEFINE_METASIG(SM(RefIntPtr_IntPtr_IntPtr_RetIntPtr, r(I) I I, I))
DEFINE_METASIG(SM(RefObj_Obj_RetObj, r(j) j, j))
DEFINE_METASIG(SM(RefObj_Obj_Obj_RetObj, r(j) j j, j))
DEFINE_METASIG(SM(ObjIntPtr_RetVoid, j I, v))
DEFINE_METASIG(SM(RefBool_RetBool, r(F), F))
DEFINE_METASIG(SM(RefBool_Bool, r(F) F, v))
DEFINE_METASIG(SM(RefSByt_RetSByt, r(B), B))
DEFINE_METASIG(SM(RefSByt_SByt, r(B) B, v))
DEFINE_METASIG(SM(RefByte_RetByte, r(b), b))
DEFINE_METASIG(SM(RefByte_Byte, r(b) b, v))
DEFINE_METASIG(SM(RefByte_RefByte_UInt_RetVoid, r(b) r(b) K, v))
DEFINE_METASIG(SM(RefByte_Byte_UInt_RetVoid, r(b) b K, v))
DEFINE_METASIG(SM(RefShrt_RetShrt, r(h), h))
DEFINE_METASIG(SM(RefShrt_Shrt, r(h) h, v))
DEFINE_METASIG(SM(RefUShrt_RetUShrt, r(H), H))
DEFINE_METASIG(SM(RefUShrt_UShrt, r(H) H, v))
DEFINE_METASIG(SM(RefInt_RetInt, r(i), i))
DEFINE_METASIG(SM(RefInt_Int, r(i) i, v))
DEFINE_METASIG(SM(RefUInt_RetUInt, r(K), K))
DEFINE_METASIG(SM(RefUInt_UInt, r(K) K, v))
DEFINE_METASIG(SM(RefLong_RetLong, r(l), l))
DEFINE_METASIG(SM(RefLong_Long, r(l) l, v))
DEFINE_METASIG(SM(RefULong_RetULong, r(L), L))
DEFINE_METASIG(SM(RefULong_ULong, r(L) L, v))
DEFINE_METASIG(SM(RefIntPtr_RetIntPtr, r(I), I))
DEFINE_METASIG(SM(RefIntPtr_IntPtr, r(I) I, v))
DEFINE_METASIG(SM(RefUIntPtr_RetUIntPtr, r(U), U))
DEFINE_METASIG(SM(RefUIntPtr_UIntPtr, r(U) U, v))
DEFINE_METASIG(SM(RefFlt_RetFlt, r(f), f))
DEFINE_METASIG(SM(RefFlt_Flt, r(f) f, v))
DEFINE_METASIG(SM(RefDbl_RetDbl, r(d), d))
DEFINE_METASIG(SM(RefDbl_Dbl, r(d) d, v))
DEFINE_METASIG(GM(RefT_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), M(0)))
DEFINE_METASIG(GM(RefT_T, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) M(0), v))
DEFINE_METASIG(GM(RefByte_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(b), M(0)))
DEFINE_METASIG(GM(RefByte_T_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(b) M(0), v))
DEFINE_METASIG(GM(PtrVoid_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v), M(0)))
DEFINE_METASIG(GM(PtrVoid_T_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) M(0), v))
DEFINE_METASIG(GM(RefT_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), r(M(0))))
DEFINE_METASIG(GM(VoidPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v), r(M(0))))
DEFINE_METASIG(GM(RefTFrom_RetRefTTo, IMAGE_CEE_CS_CALLCONV_DEFAULT, 2, r(M(0)), r(M(1))))
DEFINE_METASIG(GM(Obj_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, j, M(0)))
DEFINE_METASIG(GM(RefT_Int_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) i, r(M(0))))
DEFINE_METASIG(GM(RefT_IntPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) I, r(M(0))))
DEFINE_METASIG(GM(RefT_UIntPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) U, r(M(0))))
DEFINE_METASIG(GM(PtrVoid_Int_RetPtrVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) i, P(v)))
DEFINE_METASIG(GM(RefT_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), v))
DEFINE_METASIG(GM(PtrVoid_RefT_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) r(M(0)), v))
DEFINE_METASIG(GM(RefT_PtrVoid_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) P(v), v))
DEFINE_METASIG(GM(ArrT_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, a(M(0)), r(M(0))))
DEFINE_METASIG_T(SM(Array_RetRefByte, C(ARRAY), r(b)))
DEFINE_METASIG_T(SM(SafeHandle_RefBool_RetIntPtr, C(SAFE_HANDLE) r(F), I ))
DEFINE_METASIG_T(SM(SafeHandle_RetVoid, C(SAFE_HANDLE), v ))
DEFINE_METASIG_T(SM(RetMethodBase, _, C(METHOD_BASE)))
DEFINE_METASIG(SM(RetVoid, _, v))
DEFINE_METASIG(SM(Str_IntPtr_Int_RetVoid, s I i, v))
DEFINE_METASIG(SM(Int_RetIntPtr, i, I))
DEFINE_METASIG(SM(Int_IntPtr_RetIntPtr, i I, I))
DEFINE_METASIG_T(SM(DateTime_RetDbl, g(DATE_TIME), d))
DEFINE_METASIG(SM(Dbl_RetLong, d, l))
DEFINE_METASIG(SM(IntPtr_RetObj, I, j))
DEFINE_METASIG_T(SM(Int_RetException, i, C(EXCEPTION)))
DEFINE_METASIG_T(SM(RetException, _, C(EXCEPTION)))
DEFINE_METASIG(SM(Int_IntPtr_RetObj, i I, j))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetVoid, I I i, v))
DEFINE_METASIG_T(SM(Exception_RetInt, C(EXCEPTION), i))
DEFINE_METASIG(SM(IntPtr_RetVoid, I, v))
DEFINE_METASIG(SM(IntPtr_Bool_RetVoid, I F, v))
DEFINE_METASIG(SM(IntPtr_UInt_IntPtr_RetVoid, I K I, v))
DEFINE_METASIG(SM(IntPtr_RetUInt, I, K))
DEFINE_METASIG(SM(PtrChar_RetInt, P(u), i))
DEFINE_METASIG(SM(IntPtr_IntPtr_RetIntPtr, I I, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetIntPtr, I I i, I))
DEFINE_METASIG(SM(PtrVoid_PtrVoid_RetVoid, P(v) P(v), v))
DEFINE_METASIG(SM(PtrVoid_PtrVoid_UInt_RetVoid, P(v) P(v) K, v))
DEFINE_METASIG(IM(Obj_RetBool, j, F))
DEFINE_METASIG(SM(Obj_RetVoid, j, v))
DEFINE_METASIG(SM(Obj_RetInt, j, i))
DEFINE_METASIG(SM(Obj_RetIntPtr, j, I))
DEFINE_METASIG(SM(Obj_RetObj, j, j))
DEFINE_METASIG(SM(Obj_RetArrByte, j, a(b)))
DEFINE_METASIG(SM(Obj_Bool_RetArrByte, j F, a(b)))
DEFINE_METASIG(SM(Obj_Obj_RefArrByte_RetArrByte, j j r(a(b)), a(b)))
#ifdef FEATURE_COMINTEROP
DEFINE_METASIG_T(SM(Obj_Int_RefVariant_RetVoid, j i r(g(VARIANT)), v))
DEFINE_METASIG_T(SM(Obj_RefVariant_RetVoid, j r(g(VARIANT)), v))
DEFINE_METASIG_T(SM(RefVariant_RetObject, r(g(VARIANT)), j))
DEFINE_METASIG_T(IM(RuntimeTypeHandle_RefBool_RefIntPtr_RetVoid, g(RT_TYPE_HANDLE) r(F) r(I), v))
#endif
DEFINE_METASIG(SM(Str_RetInt, s, i))
DEFINE_METASIG_T(SM(Str_RetICustomMarshaler, s, C(ICUSTOM_MARSHALER)))
DEFINE_METASIG(SM(Int_Str_RetIntPtr, i s, I))
DEFINE_METASIG(SM(Int_Str_IntPtr_RetIntPtr, i s I, I))
DEFINE_METASIG(SM(Int_Str_IntPtr_Int_RetVoid, i s I i, v))
DEFINE_METASIG(SM(Str_IntPtr_RetIntPtr, s I, I))
DEFINE_METASIG(SM(Str_Bool_Int_RetV, s F i, v))
DEFINE_METASIG_T(SM(Type_RetObj, C(TYPE), j))
DEFINE_METASIG_T(SM(Type_RetInt, C(TYPE), i))
DEFINE_METASIG(SM(ArrByte_RetObj, a(b), j))
DEFINE_METASIG(SM(ArrByte_Bool_RetObj, a(b) F, j))
DEFINE_METASIG(SM(ArrByte_ArrByte_RefObj_RetObj, a(b) a(b) r(j), j))
DEFINE_METASIG_T(SM(UInt_UInt_PtrNativeOverlapped_RetVoid, K K P(g(NATIVEOVERLAPPED)), v))
DEFINE_METASIG(IM(Long_RetVoid, l, v))
DEFINE_METASIG(IM(IntPtr_Int_RetVoid, I i, v))
DEFINE_METASIG(IM(IntInt_RetArrByte, i i, a(b)))
DEFINE_METASIG(IM(RetIntPtr, _, I))
DEFINE_METASIG(IM(RetInt, _, i))
DEFINE_METASIG_T(IM(RetAssemblyName, _, C(ASSEMBLY_NAME)))
DEFINE_METASIG_T(IM(RetAssemblyBase, _, C(ASSEMBLYBASE)))
DEFINE_METASIG_T(IM(RetModule, _, C(MODULE)))
DEFINE_METASIG_T(IM(Str_ArrB_ArrB_Ver_CI_AHA_AVC_Str_ANF_RetV,
s a(b) a(b) C(VERSION) C(CULTURE_INFO) g(ASSEMBLY_HASH_ALGORITHM) g(ASSEMBLY_VERSION_COMPATIBILITY) s g(ASSEMBLY_NAME_FLAGS), v))
DEFINE_METASIG_T(IM(PEK_IFM_RetV,
g(PORTABLE_EXECUTABLE_KINDS) g(IMAGE_FILE_MACHINE), v))
DEFINE_METASIG(IM(RetObj, _, j))
DEFINE_METASIG(SM(RetObj, _, j))
DEFINE_METASIG_T(IM(RetIEnumerator, _, C(IENUMERATOR)))
DEFINE_METASIG(IM(RetStr, _, s))
DEFINE_METASIG(IM(RetLong, _, l))
DEFINE_METASIG_T(IM(RetType, _, C(TYPE)))
DEFINE_METASIG(IM(RetVoid, _, v))
DEFINE_METASIG(IM(RetBool, _, F))
DEFINE_METASIG(IM(RetArrByte, _, a(b)))
DEFINE_METASIG_T(IM(RetArrParameterInfo, _, a(C(PARAMETER))))
DEFINE_METASIG_T(IM(RetCultureInfo, _, C(CULTURE_INFO)))
DEFINE_METASIG(IM(Bool_RetIntPtr, F, I))
DEFINE_METASIG_T(IM(Bool_RetMethodInfo, F, C(METHOD_INFO)))
DEFINE_METASIG(SM(Bool_RetStr, F, s))
DEFINE_METASIG(IM(Bool_Bool_RetStr, F F, s))
DEFINE_METASIG(IM(PtrChar_RetVoid, P(u), v))
DEFINE_METASIG(IM(PtrChar_Int_Int_RetVoid, P(u) i i, v))
DEFINE_METASIG_T(IM(ReadOnlySpanOfByte_RetVoid, GI(g(READONLY_SPAN), 1, b), v))
DEFINE_METASIG_T(IM(ReadOnlySpanOfChar_RetVoid, GI(g(READONLY_SPAN), 1, u), v))
DEFINE_METASIG(IM(PtrSByt_RetVoid, P(B), v))
DEFINE_METASIG(IM(PtrSByt_Int_Int_RetVoid, P(B) i i, v))
DEFINE_METASIG_T(IM(PtrSByt_Int_Int_Encoding_RetVoid, P(B) i i C(ENCODING), v))
DEFINE_METASIG(IM(PtrChar_Int_RetVoid, P(u) i, v))
DEFINE_METASIG(IM(PtrSByt_Int_RetVoid, P(B) i, v))
DEFINE_METASIG(SM(ArrChar_RetStr, a(u), s))
DEFINE_METASIG(SM(ArrChar_Int_Int_RetStr, a(u) i i, s))
DEFINE_METASIG(SM(Char_Int_RetStr, u i, s))
DEFINE_METASIG(SM(PtrChar_RetStr, P(u), s))
DEFINE_METASIG(SM(PtrChar_Int_Int_RetStr, P(u) i i, s))
DEFINE_METASIG_T(SM(ReadOnlySpanOfChar_RetStr, GI(g(READONLY_SPAN), 1, u), s))
DEFINE_METASIG(SM(PtrSByt_RetStr, P(B), s))
DEFINE_METASIG(SM(PtrSByt_Int_Int_RetStr, P(B) i i, s))
DEFINE_METASIG_T(SM(PtrSByt_Int_Int_Encoding_RetStr, P(B) i i C(ENCODING), s))
DEFINE_METASIG(IM(Obj_Int_RetIntPtr, j i, I))
DEFINE_METASIG(IM(ArrByte_Int_Int_RetVoid, a(b) i i, v))
DEFINE_METASIG(IM(PtrByte_RetVoid, P(b), v))
DEFINE_METASIG(IM(Char_Char_RetStr, u u, s))
DEFINE_METASIG(IM(Char_Int_RetVoid, u i, v))
DEFINE_METASIG_T(SM(RetCultureInfo, _, C(CULTURE_INFO)))
DEFINE_METASIG_T(SM(CultureInfo_RetVoid, C(CULTURE_INFO), v))
DEFINE_METASIG(IM(Dbl_RetVoid, d, v))
DEFINE_METASIG(IM(Flt_RetVoid, f, v))
DEFINE_METASIG(IM(Int_RetInt, i, i))
DEFINE_METASIG(IM(Int_RefIntPtr_RefIntPtr_RefIntPtr_RetVoid, i r(I) r(I) r(I), v))
DEFINE_METASIG(IM(Int_RetStr, i, s))
DEFINE_METASIG(IM(Int_RetVoid, i, v))
DEFINE_METASIG(IM(Int_RetBool, i, F))
DEFINE_METASIG(IM(Int_Int_RetVoid, i i, v))
DEFINE_METASIG(IM(Int_Int_Int_RetVoid, i i i, v))
DEFINE_METASIG(IM(Int_Int_Int_Int_RetVoid, i i i i, v))
DEFINE_METASIG_T(IM(Obj_EventArgs_RetVoid, j C(EVENT_ARGS), v))
DEFINE_METASIG_T(IM(Obj_UnhandledExceptionEventArgs_RetVoid, j C(UNHANDLED_EVENTARGS), v))
DEFINE_METASIG_T(IM(Assembly_RetBool, C(ASSEMBLY), F))
DEFINE_METASIG_T(IM(AssemblyBase_RetBool, C(ASSEMBLYBASE), F))
DEFINE_METASIG_T(IM(Exception_RetVoid, C(EXCEPTION), v))
DEFINE_METASIG(IM(IntPtr_RetObj, I, j))
DEFINE_METASIG(IM(IntPtr_RetVoid, I, v))
DEFINE_METASIG(IM(IntPtr_PtrVoid_RetVoid, I P(v), v))
DEFINE_METASIG_T(IM(RefGuid_RetIntPtr, r(g(GUID)), I))
DEFINE_METASIG(IM(Obj_RetInt, j, i))
DEFINE_METASIG(IM(Obj_RetIntPtr, j, I))
DEFINE_METASIG(IM(Obj_RetVoid, j, v))
DEFINE_METASIG(IM(Obj_RetObj, j, j))
DEFINE_METASIG(IM(Obj_IntPtr_RetVoid, j I, v))
DEFINE_METASIG(IM(Obj_UIntPtr_RetVoid, j U, v))
DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_RetVoid, j I I, v))
DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_IntPtr_RetVoid, j I I I, v))
DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_IntPtr_IntPtr_RetVoid, j I I I I, v))
DEFINE_METASIG(IM(IntPtr_UInt_IntPtr_IntPtr_RetVoid, I K I I, v))
DEFINE_METASIG(IM(Obj_Bool_RetVoid, j F, v))
#ifdef FEATURE_COMINTEROP
DEFINE_METASIG(SM(Obj_RetStr, j, s))
DEFINE_METASIG_T(IM(Str_BindingFlags_Obj_ArrObj_ArrBool_ArrInt_ArrType_Type_RetObj, s g(BINDING_FLAGS) j a(j) a(F) a(i) a(C(TYPE)) C(TYPE), j))
#endif // FEATURE_COMINTEROP
DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) C(CULTURE_INFO), v))
DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), v))
DEFINE_METASIG_T(IM(Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetObj, j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), j))
DEFINE_METASIG(IM(IntPtr_ArrObj_Obj_RefArrObj_RetObj, I a(j) j r(a(j)), j))
DEFINE_METASIG(IM(RefObject_RetBool, r(j), F))
DEFINE_METASIG_T(IM(Class_RetObj, C(CLASS), j))
DEFINE_METASIG(IM(Int_VoidPtr_RetVoid, i P(v), v))
DEFINE_METASIG(IM(VoidPtr_RetVoid, P(v), v))
DEFINE_METASIG(SM(VoidPtr_RetObj, P(v), j))
DEFINE_METASIG_T(IM(Str_RetModule, s, C(MODULE)))
DEFINE_METASIG_T(SM(Assembly_Str_RetAssembly, C(ASSEMBLY) s, C(ASSEMBLY)))
DEFINE_METASIG_T(SM(Str_Bool_RetAssembly, s F, C(ASSEMBLY)))
DEFINE_METASIG(IM(Str_Str_Obj_RetVoid, s s j, v))
DEFINE_METASIG(IM(Str_Str_Str_Obj_RetVoid, s s s j, v))
DEFINE_METASIG(IM(Str_Str_Str_Obj_Bool_RetVoid, s s s j F, v))
DEFINE_METASIG(IM(Str_Str_RefObj_RetVoid, s s r(j), v))
DEFINE_METASIG(SM(Str_RetStr, s, s))
DEFINE_METASIG_T(SM(Str_CultureInfo_RetStr, s C(CULTURE_INFO), s))
DEFINE_METASIG_T(SM(Str_CultureInfo_RefBool_RetStr, s C(CULTURE_INFO) r(F), s))
DEFINE_METASIG(SM(PtrPtrChar_PtrPtrChar_Int_RetVoid, P(P(u)) P(P(u)) i, v))
DEFINE_METASIG(SM(ArrStr_RetVoid, a(s), v))
DEFINE_METASIG(IM(Str_RetVoid, s, v))
DEFINE_METASIG(SM(RefBool_RefBool_RetVoid, r(F) r(F), v))
DEFINE_METASIG_T(IM(Str_Exception_RetVoid, s C(EXCEPTION), v))
DEFINE_METASIG(IM(Str_Obj_RetVoid, s j, v))
DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_ArrType_ArrParameterModifier_RetMethodInfo, \
s g(BINDING_FLAGS) C(BINDER) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(METHOD_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Type_ArrType_ArrParameterModifier_RetPropertyInfo, \
s g(BINDING_FLAGS) C(BINDER) C(TYPE) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(PROPERTY_INFO)))
DEFINE_METASIG(IM(Str_Str_RetStr, s s, s))
DEFINE_METASIG(IM(Str_Str_RetVoid, s s, v))
DEFINE_METASIG(IM(Str_Str_Str_RetVoid, s s s, v))
DEFINE_METASIG(IM(Str_Int_RetVoid, s i, v))
DEFINE_METASIG(IM(Str_Str_Int_RetVoid, s s i, v))
DEFINE_METASIG(IM(Str_Str_Str_Int_RetVoid, s s s i, v))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetFieldInfo, s g(BINDING_FLAGS), C(FIELD_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetMemberInfo, s g(BINDING_FLAGS), a(C(MEMBER))))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetMethodInfo, s g(BINDING_FLAGS), C(METHOD_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetPropertyInfo, s g(BINDING_FLAGS), C(PROPERTY_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Obj_ArrObj_ArrParameterModifier_CultureInfo_ArrStr_RetObj, \
s g(BINDING_FLAGS) C(BINDER) j a(j) a(g(PARAMETER_MODIFIER)) C(CULTURE_INFO) a(s), j))
DEFINE_METASIG_T(IM(Str_Type_Str_RetVoid, s C(TYPE) s, v))
DEFINE_METASIG_T(SM(Delegate_RetIntPtr, C(DELEGATE), I))
DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetType, g(RT_TYPE_HANDLE), C(TYPE)))
DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetIntPtr, g(RT_TYPE_HANDLE), I))
DEFINE_METASIG_T(SM(RuntimeMethodHandle_RetIntPtr, g(METHOD_HANDLE), I))
DEFINE_METASIG_T(SM(IntPtr_Type_RetDelegate, I C(TYPE), C(DELEGATE)))
DEFINE_METASIG(IM(RetRefByte, _, r(b)))
DEFINE_METASIG_T(IM(Type_RetArrObj, C(TYPE) F, a(j)))
DEFINE_METASIG(IM(Bool_RetVoid, F, v))
DEFINE_METASIG_T(IM(BindingFlags_RetArrFieldInfo, g(BINDING_FLAGS), a(C(FIELD_INFO))))
DEFINE_METASIG_T(IM(BindingFlags_RetArrMemberInfo, g(BINDING_FLAGS), a(C(MEMBER))))
DEFINE_METASIG_T(IM(BindingFlags_RetArrMethodInfo, g(BINDING_FLAGS), a(C(METHOD_INFO))))
DEFINE_METASIG_T(IM(BindingFlags_RetArrPropertyInfo, g(BINDING_FLAGS), a(C(PROPERTY_INFO))))
DEFINE_METASIG(IM(ArrByte_RetVoid, a(b), v))
DEFINE_METASIG(IM(ArrChar_RetVoid, a(u), v))
DEFINE_METASIG(IM(ArrChar_Int_Int_RetVoid, a(u) i i, v))
DEFINE_METASIG_T(IM(ArrType_ArrException_Str_RetVoid, a(C(TYPE)) a(C(EXCEPTION)) s, v))
DEFINE_METASIG(IM(RefInt_RefInt_RefInt_RetArrByte, r(i) r(i) r(i), a(b)))
DEFINE_METASIG_T(IM(RefInt_RetRuntimeType, r(i) , C(CLASS)))
DEFINE_METASIG_T(IM(RuntimeType_RetVoid, C(CLASS) , v))
DEFINE_METASIG_T(SM(ArrException_PtrInt_RetVoid, a(C(EXCEPTION)) P(i), v))
DEFINE_METASIG_T(IM(RuntimeArgumentHandle_PtrVoid_RetVoid, g(ARGUMENT_HANDLE) P(v), v))
DEFINE_METASIG_T(SM(Assembly_RetVoid, C(ASSEMBLY), v))
DEFINE_METASIG_T(SM(Assembly_Str_RetArrAssembly, C(ASSEMBLY) s, a(C(ASSEMBLY))))
DEFINE_METASIG(SM(Str_RetArrStr, s, a(s)))
// Execution Context
DEFINE_METASIG_T(SM(SyncCtx_ArrIntPtr_Bool_Int_RetInt, C(SYNCHRONIZATION_CONTEXT) a(I) F i, i))
#ifdef FEATURE_COMINTEROP
// The signature of the method System.Runtime.InteropServices.ICustomQueryInterface.GetInterface
DEFINE_METASIG_T(IM(RefGuid_OutIntPtr_RetCustomQueryInterfaceResult, r(g(GUID)) r(I), g(CUSTOMQUERYINTERFACERESULT)))
#endif //FEATURE_COMINTEROP
// Assembly Load Context
DEFINE_METASIG_T(SM(RefGuid_RefGuid_RetVoid, r(g(GUID)) r(g(GUID)) , v))
DEFINE_METASIG_T(SM(RefGuid_RetVoid, r(g(GUID)), v))
DEFINE_METASIG_T(SM(IntPtr_AssemblyName_RetAssemblyBase, I C(ASSEMBLY_NAME), C(ASSEMBLYBASE)))
DEFINE_METASIG_T(SM(Str_AssemblyBase_IntPtr_RetIntPtr, s C(ASSEMBLYBASE) I, I))
DEFINE_METASIG_T(SM(Str_AssemblyBase_Bool_UInt_RetIntPtr, s C(ASSEMBLYBASE) F K, I))
// ThreadPool
DEFINE_METASIG_T(SM(_ThreadPoolWaitOrTimerCallback_Bool_RetVoid, C(TPWAITORTIMER_HELPER) F, v))
// For FailFast
DEFINE_METASIG(SM(Str_RetVoid, s, v))
DEFINE_METASIG_T(SM(Str_Exception_RetVoid, s C(EXCEPTION), v))
DEFINE_METASIG_T(SM(Str_Exception_Str_RetVoid, s C(EXCEPTION) s, v))
// fields - e.g.:
// DEFINE_METASIG(Fld(PtrVoid, P(v)))
// Runtime Helpers
DEFINE_METASIG(SM(Obj_Obj_Bool_RetVoid, j j F, v))
DEFINE_METASIG_T(IM(Dec_RetVoid, g(DECIMAL), v))
DEFINE_METASIG_T(IM(Currency_RetVoid, g(CURRENCY), v))
DEFINE_METASIG_T(SM(RefDec_RetVoid, r(g(DECIMAL)), v))
DEFINE_METASIG(GM(RefT_T_T_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) M(0) M(0), M(0)))
DEFINE_METASIG(SM(RefObject_Object_Object_RetObject, r(j) j j, j))
DEFINE_METASIG_T(SM(RefCleanupWorkListElement_RetVoid, r(C(CLEANUP_WORK_LIST_ELEMENT)), v))
DEFINE_METASIG_T(SM(RefCleanupWorkListElement_SafeHandle_RetIntPtr, r(C(CLEANUP_WORK_LIST_ELEMENT)) C(SAFE_HANDLE), I))
DEFINE_METASIG_T(SM(RefCleanupWorkListElement_Obj_RetVoid, r(C(CLEANUP_WORK_LIST_ELEMENT)) j, v))
#ifdef FEATURE_ICASTABLE
DEFINE_METASIG_T(SM(ICastable_RtType_RefException_RetBool, C(ICASTABLE) C(CLASS) r(C(EXCEPTION)), F))
DEFINE_METASIG_T(SM(ICastable_RtType_RetRtType, C(ICASTABLE) C(CLASS), C(CLASS)))
#endif // FEATURE_ICASTABLE
DEFINE_METASIG_T(SM(IDynamicInterfaceCastable_RuntimeType_Bool_RetBool, C(IDYNAMICINTERFACECASTABLE) C(CLASS) F, F))
DEFINE_METASIG_T(SM(IDynamicInterfaceCastable_RuntimeType_RetRtType, C(IDYNAMICINTERFACECASTABLE) C(CLASS), C(CLASS)))
DEFINE_METASIG_T(IM(ArrByte_Int_Int_AsyncCallback_Object_RetIAsyncResult, a(b) i i C(ASYNCCALLBACK) j, C(IASYNCRESULT)))
DEFINE_METASIG_T(IM(IAsyncResult_RetInt, C(IASYNCRESULT), i))
DEFINE_METASIG_T(IM(IAsyncResult_RetVoid, C(IASYNCRESULT), v))
DEFINE_METASIG(IM(Int_RetRefT, i, r(G(0))))
DEFINE_METASIG_T(IM(Int_RetReadOnlyRefT, i, Q(INATTRIBUTE) r(G(0))))
DEFINE_METASIG(GM(RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, _, M(0)))
DEFINE_METASIG_T(SM(Array_Int_Array_Int_Int_RetVoid, C(ARRAY) i C(ARRAY) i i, v))
DEFINE_METASIG_T(SM(Array_Int_Obj_RetVoid, C(ARRAY) i j, v))
DEFINE_METASIG_T(SM(Array_Int_PtrVoid_RetRefObj, C(ARRAY) i P(v), r(j)))
DEFINE_METASIG(SM(Obj_IntPtr_Bool_RetVoid, j I F, v))
DEFINE_METASIG(SM(IntPtr_Obj_RetVoid, I j, v))
DEFINE_METASIG_T(SM(IntPtr_Type_RetVoid, I C(TYPE), v))
// Undefine macros in case we include the file again in the compilation unit
#undef DEFINE_METASIG
#undef DEFINE_METASIG_T
#undef METASIG_BODY
#undef METASIG_ATOM
#undef METASIG_RECURSE
#undef SM
#undef IM
#undef GM
#undef Fld
#undef a
#undef P
#undef r
#undef b
#undef u
#undef d
#undef f
#undef i
#undef K
#undef I
#undef U
#undef l
#undef L
#undef h
#undef H
#undef v
#undef B
#undef F
#undef j
#undef s
#undef C
#undef g
#undef T
#undef G
#undef M
#undef GI
#undef Q
#undef _
#endif // DEFINE_METASIG
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// METASIG.H
//
//
// All literal MetaData signatures should be defined here.
//
// Generic sig's based on types.
// All sigs are alphabetized by the signature string and given a canonical name. Do not
// give them "meaningful" names because we want to share them aggressively. Do not add
// duplicates!
// The canonical form:
//
// <what>(<type>*, <name>*)
//
// where <what> is:
//
// Fld -- field
// IM -- instance method (HASTHIS == TRUE)
// SM -- static method
//
// and <name> -- <type> is:
//
// a -- Arr -- array
// P -- Ptr -- a pointer
// r -- Ref -- a byref
// Ret -- indicates function return type
//
// Var -- Variant
//
// b -- Byte -- (unsigned) byte
// u -- Char -- character (2 byte unsigned unicode)
// d -- Dbl -- double
// f -- Flt -- float
// i -- Int -- integer
// K -- UInt -- unsigned integer
// I -- IntPtr -- agnostic integer
// U -- UIntPtr -- agnostic unsigned integer
// l -- Long -- long integer
// L -- ULong -- unsigned long integer
// h -- Shrt -- short integer
// H -- UShrt -- unsigned short integer
// v -- Void -- Void
// B -- SByt -- signed byte
// F -- Bool -- boolean
// j -- Obj -- System.Object
// s -- Str -- System.String
// C -- -- class
// g -- -- struct
// T -- TypedReference -- TypedReference
// G -- -- Generic type variable
// M -- -- Generic method variable
// GI -- -- Generic type instantiation
// Q -- modreq
//#DEFINE_METASIG
// Use DEFINE_METASIG for signatures that does not reference other types
// Use DEFINE_METASIG_T for signatures that reference other types (contains C or g)
// This part of the file is included multiple times with different macro definitions
// to generate the hardcoded metasigs.
// SM, IM and Fld macros have often a very similar definitions. METASIG_BODY is
// a helper to avoid these redundant SM, IM and Fld definitions.
#ifdef METASIG_BODY
#ifndef DEFINE_METASIG
// See code:#DEFINE_METASIG
#define DEFINE_METASIG(body) body
#endif
#define SM(varname, args, retval) METASIG_BODY( SM_ ## varname, args retval )
#define IM(varname, args, retval) METASIG_BODY( IM_ ## varname, args retval )
#define GM(varname, n, conv, args, retval) METASIG_BODY( GM_ ## varname, args retval )
#define Fld(varname, val) METASIG_BODY( Fld_ ## varname, val )
#endif
#ifdef DEFINE_METASIG
// Use default if undefined
// See code:#DEFINE_METASIG
#ifndef DEFINE_METASIG_T
#define DEFINE_METASIG_T(body) DEFINE_METASIG(body)
#endif
// One letter shortcuts are defined for all types that can occur in the signature.
// The shortcuts are defined indirectly through METASIG_ATOM. METASIG_ATOM is
// designed to control whether to generate the initializer for the signature or
// just compute the size of the signature.
#define b METASIG_ATOM(ELEMENT_TYPE_U1)
#define u METASIG_ATOM(ELEMENT_TYPE_CHAR)
#define d METASIG_ATOM(ELEMENT_TYPE_R8)
#define f METASIG_ATOM(ELEMENT_TYPE_R4)
#define i METASIG_ATOM(ELEMENT_TYPE_I4)
#define K METASIG_ATOM(ELEMENT_TYPE_U4)
#define I METASIG_ATOM(ELEMENT_TYPE_I)
#define U METASIG_ATOM(ELEMENT_TYPE_U)
#define l METASIG_ATOM(ELEMENT_TYPE_I8)
#define L METASIG_ATOM(ELEMENT_TYPE_U8)
#define h METASIG_ATOM(ELEMENT_TYPE_I2)
#define H METASIG_ATOM(ELEMENT_TYPE_U2)
#define v METASIG_ATOM(ELEMENT_TYPE_VOID)
#define B METASIG_ATOM(ELEMENT_TYPE_I1)
#define F METASIG_ATOM(ELEMENT_TYPE_BOOLEAN)
#define j METASIG_ATOM(ELEMENT_TYPE_OBJECT)
#define s METASIG_ATOM(ELEMENT_TYPE_STRING)
#define T METASIG_ATOM(ELEMENT_TYPE_TYPEDBYREF)
// METASIG_RECURSE controls whether to recurse into the complex types
// in the macro expansion. METASIG_RECURSE is designed to control
// whether to compute the byte size of the signature or just compute
// the number of arguments in the signature.
#if METASIG_RECURSE
#define a(x) METASIG_ATOM(ELEMENT_TYPE_SZARRAY) x
#define P(x) METASIG_ATOM(ELEMENT_TYPE_PTR) x
#define r(x) METASIG_ATOM(ELEMENT_TYPE_BYREF) x
#define G(n) METASIG_ATOM(ELEMENT_TYPE_VAR) METASIG_ATOM(n)
#define M(n) METASIG_ATOM(ELEMENT_TYPE_MVAR) METASIG_ATOM(n)
#define GI(type, n, x) METASIG_ATOM(ELEMENT_TYPE_GENERICINST) type METASIG_ATOM(n) x
// The references to other types have special definition in some cases
#ifndef C
#define C(x) METASIG_ATOM(ELEMENT_TYPE_CLASS) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100)
#endif
#ifndef g
#define g(x) METASIG_ATOM(ELEMENT_TYPE_VALUETYPE) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100)
#endif
#ifndef Q
#define Q(x) METASIG_ATOM(ELEMENT_TYPE_CMOD_REQD) METASIG_ATOM(CLASS__ ## x % 0x100) METASIG_ATOM(CLASS__ ## x / 0x100)
#endif
#else
#define a(x) METASIG_ATOM(ELEMENT_TYPE_SZARRAY)
#define P(x) METASIG_ATOM(ELEMENT_TYPE_PTR)
#define r(x) METASIG_ATOM(ELEMENT_TYPE_BYREF)
#define G(n) METASIG_ATOM(ELEMENT_TYPE_VAR)
#define M(n) METASIG_ATOM(ELEMENT_TYPE_MVAR)
#define GI(type, n, x) METASIG_ATOM(ELEMENT_TYPE_GENERICINST)
// The references to other types have special definition in some cases
#ifndef C
#define C(x) METASIG_ATOM(ELEMENT_TYPE_CLASS)
#endif
#ifndef g
#define g(x) METASIG_ATOM(ELEMENT_TYPE_VALUETYPE)
#endif
#define Q(x)
#endif
// to avoid empty arguments for macros
#define _
// static methods:
DEFINE_METASIG_T(SM(Int_IntPtr_Obj_RetException, i I j, C(EXCEPTION)))
DEFINE_METASIG_T(SM(Type_ArrType_IntPtr_int_RetType, C(TYPE) a(C(TYPE)) I i, C(TYPE) ))
DEFINE_METASIG_T(SM(Type_RetIntPtr, C(TYPE), I))
DEFINE_METASIG(SM(RefIntPtr_IntPtr_IntPtr_Int_RetObj, r(I) I I i, j))
DEFINE_METASIG(SM(Obj_IntPtr_RetIntPtr, j I, I))
DEFINE_METASIG(SM(Obj_IntPtr_RetObj, j I, j))
DEFINE_METASIG(SM(Obj_RefIntPtr_RetVoid, j r(I), v))
DEFINE_METASIG(SM(Obj_IntPtr_RetVoid, j I, v))
DEFINE_METASIG(SM(Obj_IntPtr_RetBool, j I, F))
DEFINE_METASIG(SM(Obj_IntPtr_IntPtr_Int_RetIntPtr, j I I i, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_RefIntPtr_RetObj, I I r(I), j))
#ifdef FEATURE_COMINTEROP
DEFINE_METASIG(SM(Obj_IntPtr_RefIntPtr_RefBool_RetIntPtr, j I r(I) r(F), I))
DEFINE_METASIG(SM(Obj_IntPtr_RefIntPtr_RetIntPtr, j I r(I), I))
#endif // FEATURE_COMINTEROP
#ifdef FEATURE_COMWRAPPERS
DEFINE_METASIG_T(SM(Scenario_ComWrappers_Obj_CreateFlags_RefInt_RetPtrVoid, g(COMWRAPPERSSCENARIO) C(COMWRAPPERS) j g(CREATECOMINTERFACEFLAGS) r(i), P(v)))
DEFINE_METASIG_T(SM(Scenario_ComWrappers_IntPtr_CreateFlags_RetObj, g(COMWRAPPERSSCENARIO) C(COMWRAPPERS) I g(CREATEOBJECTFLAGS), j))
DEFINE_METASIG_T(SM(ComWrappers_IEnumerable_RetVoid, C(COMWRAPPERS) C(IENUMERABLE), v))
DEFINE_METASIG_T(SM(Obj_RefGuid_RefIntPtr_RetInt, j r(g(GUID)) r(I), i))
#endif // FEATURE_COMWRAPPERS
#ifdef FEATURE_OBJCMARSHAL
DEFINE_METASIG_T(SM(Exception_Obj_RefIntPtr_RetVoidPtr, C(EXCEPTION) j r(I), P(v)))
#endif // FEATURE_OBJCMARSHAL
DEFINE_METASIG(SM(Int_RetVoid, i, v))
DEFINE_METASIG(SM(Int_Int_RetVoid, i i, v))
DEFINE_METASIG(SM(Str_RetIntPtr, s, I))
DEFINE_METASIG(SM(Str_RetBool, s, F))
DEFINE_METASIG(SM(IntPtr_IntPtr_RetVoid, I I, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetIntPtr, I I j, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Obj_RetIntPtr, I I i j, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_RetVoid, I I I, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_UShrt_IntPtr_RetVoid, I I I H I, v))
DEFINE_METASIG(SM(IntPtr_Int_IntPtr_RetIntPtr, I i I, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_IntPtr_RetVoid, I I i I, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetVoid, I I j, v))
DEFINE_METASIG(SM(Obj_ArrObject_RetVoid, j a(j), v))
DEFINE_METASIG(SM(Obj_IntPtr_Obj_RetVoid, j I j, v))
DEFINE_METASIG(SM(RetUIntPtr, _, U))
DEFINE_METASIG(SM(RetIntPtr, _, I))
DEFINE_METASIG(SM(RetBool, _, F))
DEFINE_METASIG(SM(IntPtr_RetStr, I, s))
DEFINE_METASIG(SM(IntPtr_RetBool, I, F))
DEFINE_METASIG_T(SM(RuntimeType_RuntimeMethodHandleInternal_RetMethodBase, C(CLASS) g(METHOD_HANDLE_INTERNAL), C(METHOD_BASE) ))
DEFINE_METASIG_T(SM(RuntimeType_IRuntimeFieldInfo_RetFieldInfo, C(CLASS) C(I_RT_FIELD_INFO), C(FIELD_INFO) ))
DEFINE_METASIG_T(SM(RuntimeType_Int_RetPropertyInfo, C(CLASS) i, C(PROPERTY_INFO) ))
DEFINE_METASIG(SM(Char_Bool_Bool_RetByte, u F F, b))
DEFINE_METASIG(SM(Byte_RetChar, b, u))
DEFINE_METASIG(SM(Str_Bool_Bool_RefInt_RetIntPtr, s F F r(i), I))
DEFINE_METASIG(SM(IntPtr_Int_RetStr, I i, s))
DEFINE_METASIG_T(SM(Obj_PtrByte_RefCleanupWorkListElement_RetVoid, j P(b) r(C(CLEANUP_WORK_LIST_ELEMENT)), v))
DEFINE_METASIG_T(SM(SafeHandle_RefCleanupWorkListElement_RetIntPtr, C(SAFE_HANDLE) r(C(CLEANUP_WORK_LIST_ELEMENT)), I))
DEFINE_METASIG(SM(Obj_PtrByte_RetVoid, j P(b), v))
DEFINE_METASIG(SM(PtrByte_IntPtr_RetVoid, P(b) I, v))
DEFINE_METASIG(SM(Str_Bool_Bool_RefInt_RetArrByte, s F F r(i), a(b) ))
DEFINE_METASIG(SM(ArrByte_Int_PtrByte_Int_Int_RetVoid, a(b) i P(b) i i, v))
DEFINE_METASIG(SM(PtrByte_Int_ArrByte_Int_Int_RetVoid, P(b) i a(b) i i, v))
DEFINE_METASIG(SM(PtrByte_RetInt, P(b), i))
DEFINE_METASIG(SM(PtrSByt_RetInt, P(B), i))
DEFINE_METASIG(SM(IntPtr_RetIntPtr, I, I))
DEFINE_METASIG(SM(UIntPtr_RetIntPtr, U, I))
DEFINE_METASIG(SM(PtrByte_PtrByte_Int_RetVoid, P(b) P(b) i, v))
DEFINE_METASIG(SM(PtrVoid_Byte_UInt_RetVoid, P(v) b K, v))
DEFINE_METASIG(SM(RefObj_IntPtr_RetVoid, r(j) I, v))
DEFINE_METASIG(SM(RefObj_RefIntPtr_RetVoid, r(j) r(I), v))
DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_RetVoid, I r(j) I, v))
DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_Int_RetVoid, I r(j) I i,v))
DEFINE_METASIG(SM(IntPtr_Int_IntPtr_Int_Int_Int_RetVoid, I i I i i i, v))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Int_IntPtr_RetVoid, I I i i I, v))
DEFINE_METASIG(SM(IntPtr_RefObj_IntPtr_Obj_RetVoid, I r(j) I j, v))
DEFINE_METASIG(SM(Obj_Int_RetVoid, j i,v))
DEFINE_METASIG(SM(PtrVoid_Obj_RetObj, P(v) j, j))
DEFINE_METASIG(SM(PtrVoid_Obj_RetRefByte, P(v) j, r(b)))
DEFINE_METASIG(SM(Flt_RetFlt, f, f))
DEFINE_METASIG(SM(Dbl_RetDbl, d, d))
DEFINE_METASIG(SM(RefDbl_Dbl_RetDbl, r(d) d, d))
DEFINE_METASIG(SM(RefDbl_Dbl_Dbl_RetDbl, r(d) d d, d))
DEFINE_METASIG(SM(RefLong_Long_RetLong, r(l) l, l))
DEFINE_METASIG(SM(RefLong_Long_Long_RetLong, r(l) l l, l))
DEFINE_METASIG(SM(RefFlt_Flt_RetFlt, r(f) f, f))
DEFINE_METASIG(SM(RefFlt_Flt_Flt_RetFlt, r(f) f f, f))
DEFINE_METASIG(SM(RefInt_Int_RetInt, r(i) i, i))
DEFINE_METASIG(SM(RefInt_Int_Int_RetInt, r(i) i i, i))
DEFINE_METASIG(SM(RefInt_Int_Int_RefBool_RetInt, r(i) i i r(F), i))
DEFINE_METASIG(SM(RefIntPtr_IntPtr_RetIntPtr, r(I) I, I))
DEFINE_METASIG(SM(RefIntPtr_IntPtr_IntPtr_RetIntPtr, r(I) I I, I))
DEFINE_METASIG(SM(RefObj_Obj_RetObj, r(j) j, j))
DEFINE_METASIG(SM(RefObj_Obj_Obj_RetObj, r(j) j j, j))
DEFINE_METASIG(SM(ObjIntPtr_RetVoid, j I, v))
DEFINE_METASIG(SM(RefBool_RetBool, r(F), F))
DEFINE_METASIG(SM(RefBool_Bool, r(F) F, v))
DEFINE_METASIG(SM(RefSByt_RetSByt, r(B), B))
DEFINE_METASIG(SM(RefSByt_SByt, r(B) B, v))
DEFINE_METASIG(SM(RefByte_RetByte, r(b), b))
DEFINE_METASIG(SM(RefByte_Byte, r(b) b, v))
DEFINE_METASIG(SM(RefByte_RefByte_UInt_RetVoid, r(b) r(b) K, v))
DEFINE_METASIG(SM(RefByte_Byte_UInt_RetVoid, r(b) b K, v))
DEFINE_METASIG(SM(RefShrt_RetShrt, r(h), h))
DEFINE_METASIG(SM(RefShrt_Shrt, r(h) h, v))
DEFINE_METASIG(SM(RefUShrt_RetUShrt, r(H), H))
DEFINE_METASIG(SM(RefUShrt_UShrt, r(H) H, v))
DEFINE_METASIG(SM(RefInt_RetInt, r(i), i))
DEFINE_METASIG(SM(RefInt_Int, r(i) i, v))
DEFINE_METASIG(SM(RefUInt_RetUInt, r(K), K))
DEFINE_METASIG(SM(RefUInt_UInt, r(K) K, v))
DEFINE_METASIG(SM(RefLong_RetLong, r(l), l))
DEFINE_METASIG(SM(RefLong_Long, r(l) l, v))
DEFINE_METASIG(SM(RefULong_RetULong, r(L), L))
DEFINE_METASIG(SM(RefULong_ULong, r(L) L, v))
DEFINE_METASIG(SM(RefIntPtr_RetIntPtr, r(I), I))
DEFINE_METASIG(SM(RefIntPtr_IntPtr, r(I) I, v))
DEFINE_METASIG(SM(RefUIntPtr_RetUIntPtr, r(U), U))
DEFINE_METASIG(SM(RefUIntPtr_UIntPtr, r(U) U, v))
DEFINE_METASIG(SM(RefFlt_RetFlt, r(f), f))
DEFINE_METASIG(SM(RefFlt_Flt, r(f) f, v))
DEFINE_METASIG(SM(RefDbl_RetDbl, r(d), d))
DEFINE_METASIG(SM(RefDbl_Dbl, r(d) d, v))
DEFINE_METASIG(GM(RefT_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), M(0)))
DEFINE_METASIG(GM(RefT_T, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) M(0), v))
DEFINE_METASIG(GM(RefByte_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(b), M(0)))
DEFINE_METASIG(GM(RefByte_T_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(b) M(0), v))
DEFINE_METASIG(GM(PtrVoid_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v), M(0)))
DEFINE_METASIG(GM(PtrVoid_T_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) M(0), v))
DEFINE_METASIG(GM(RefT_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), r(M(0))))
DEFINE_METASIG(GM(VoidPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v), r(M(0))))
DEFINE_METASIG(GM(RefTFrom_RetRefTTo, IMAGE_CEE_CS_CALLCONV_DEFAULT, 2, r(M(0)), r(M(1))))
DEFINE_METASIG(GM(Obj_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, j, M(0)))
DEFINE_METASIG(GM(RefT_Int_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) i, r(M(0))))
DEFINE_METASIG(GM(RefT_IntPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) I, r(M(0))))
DEFINE_METASIG(GM(RefT_UIntPtr_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) U, r(M(0))))
DEFINE_METASIG(GM(PtrVoid_Int_RetPtrVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) i, P(v)))
DEFINE_METASIG(GM(RefT_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)), v))
DEFINE_METASIG(GM(PtrVoid_RefT_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, P(v) r(M(0)), v))
DEFINE_METASIG(GM(RefT_PtrVoid_RetVoid, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) P(v), v))
DEFINE_METASIG(GM(ArrT_RetRefT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, a(M(0)), r(M(0))))
DEFINE_METASIG_T(SM(Array_RetRefByte, C(ARRAY), r(b)))
DEFINE_METASIG_T(SM(SafeHandle_RefBool_RetIntPtr, C(SAFE_HANDLE) r(F), I ))
DEFINE_METASIG_T(SM(SafeHandle_RetVoid, C(SAFE_HANDLE), v ))
DEFINE_METASIG_T(SM(RetMethodBase, _, C(METHOD_BASE)))
DEFINE_METASIG(SM(RetVoid, _, v))
DEFINE_METASIG(SM(Str_IntPtr_Int_RetVoid, s I i, v))
DEFINE_METASIG(SM(Int_RetIntPtr, i, I))
DEFINE_METASIG(SM(Int_IntPtr_RetIntPtr, i I, I))
DEFINE_METASIG_T(SM(DateTime_RetDbl, g(DATE_TIME), d))
DEFINE_METASIG(SM(Dbl_RetLong, d, l))
DEFINE_METASIG(SM(IntPtr_RetObj, I, j))
DEFINE_METASIG_T(SM(Int_RetException, i, C(EXCEPTION)))
DEFINE_METASIG_T(SM(RetException, _, C(EXCEPTION)))
DEFINE_METASIG(SM(Int_IntPtr_RetObj, i I, j))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetVoid, I I i, v))
DEFINE_METASIG_T(SM(Exception_RetInt, C(EXCEPTION), i))
DEFINE_METASIG(SM(IntPtr_RetVoid, I, v))
DEFINE_METASIG(SM(IntPtr_Bool_RetVoid, I F, v))
DEFINE_METASIG(SM(IntPtr_UInt_IntPtr_RetVoid, I K I, v))
DEFINE_METASIG(SM(IntPtr_RetUInt, I, K))
DEFINE_METASIG(SM(PtrChar_RetInt, P(u), i))
DEFINE_METASIG(SM(IntPtr_IntPtr_RetIntPtr, I I, I))
DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetIntPtr, I I i, I))
DEFINE_METASIG(SM(PtrVoid_PtrVoid_RetVoid, P(v) P(v), v))
DEFINE_METASIG(SM(PtrVoid_PtrVoid_UInt_RetVoid, P(v) P(v) K, v))
DEFINE_METASIG(IM(Obj_RetBool, j, F))
DEFINE_METASIG(SM(Obj_RetVoid, j, v))
DEFINE_METASIG(SM(Obj_RetInt, j, i))
DEFINE_METASIG(SM(Obj_RetIntPtr, j, I))
DEFINE_METASIG(SM(Obj_RetObj, j, j))
DEFINE_METASIG(SM(Obj_RetArrByte, j, a(b)))
DEFINE_METASIG(SM(Obj_Bool_RetArrByte, j F, a(b)))
DEFINE_METASIG(SM(Obj_Obj_RefArrByte_RetArrByte, j j r(a(b)), a(b)))
#ifdef FEATURE_COMINTEROP
DEFINE_METASIG_T(SM(Obj_Int_RefVariant_RetVoid, j i r(g(VARIANT)), v))
DEFINE_METASIG_T(SM(Obj_RefVariant_RetVoid, j r(g(VARIANT)), v))
DEFINE_METASIG_T(SM(RefVariant_RetObject, r(g(VARIANT)), j))
DEFINE_METASIG_T(IM(RuntimeTypeHandle_RefBool_RefIntPtr_RetVoid, g(RT_TYPE_HANDLE) r(F) r(I), v))
#endif
DEFINE_METASIG(SM(Str_RetInt, s, i))
DEFINE_METASIG_T(SM(Str_RetICustomMarshaler, s, C(ICUSTOM_MARSHALER)))
DEFINE_METASIG(SM(Int_Str_RetIntPtr, i s, I))
DEFINE_METASIG(SM(Int_Str_IntPtr_RetIntPtr, i s I, I))
DEFINE_METASIG(SM(Int_Str_IntPtr_Int_RetVoid, i s I i, v))
DEFINE_METASIG(SM(Str_IntPtr_RetIntPtr, s I, I))
DEFINE_METASIG(SM(Str_Bool_Int_RetV, s F i, v))
DEFINE_METASIG_T(SM(Type_RetObj, C(TYPE), j))
DEFINE_METASIG_T(SM(Type_RetInt, C(TYPE), i))
DEFINE_METASIG(SM(ArrByte_RetObj, a(b), j))
DEFINE_METASIG(SM(ArrByte_Bool_RetObj, a(b) F, j))
DEFINE_METASIG(SM(ArrByte_ArrByte_RefObj_RetObj, a(b) a(b) r(j), j))
DEFINE_METASIG_T(SM(UInt_UInt_PtrNativeOverlapped_RetVoid, K K P(g(NATIVEOVERLAPPED)), v))
DEFINE_METASIG(IM(Long_RetVoid, l, v))
DEFINE_METASIG(IM(IntPtr_Int_RetVoid, I i, v))
DEFINE_METASIG(IM(IntInt_RetArrByte, i i, a(b)))
DEFINE_METASIG(IM(RetIntPtr, _, I))
DEFINE_METASIG(IM(RetInt, _, i))
DEFINE_METASIG_T(IM(RetAssemblyName, _, C(ASSEMBLY_NAME)))
DEFINE_METASIG_T(IM(RetAssemblyBase, _, C(ASSEMBLYBASE)))
DEFINE_METASIG_T(IM(RetModule, _, C(MODULE)))
DEFINE_METASIG_T(IM(Str_ArrB_ArrB_Ver_CI_AHA_AVC_Str_ANF_RetV,
s a(b) a(b) C(VERSION) C(CULTURE_INFO) g(ASSEMBLY_HASH_ALGORITHM) g(ASSEMBLY_VERSION_COMPATIBILITY) s g(ASSEMBLY_NAME_FLAGS), v))
DEFINE_METASIG_T(IM(PEK_IFM_RetV,
g(PORTABLE_EXECUTABLE_KINDS) g(IMAGE_FILE_MACHINE), v))
DEFINE_METASIG(IM(RetObj, _, j))
DEFINE_METASIG(SM(RetObj, _, j))
DEFINE_METASIG_T(IM(RetIEnumerator, _, C(IENUMERATOR)))
DEFINE_METASIG(IM(RetStr, _, s))
DEFINE_METASIG(IM(RetLong, _, l))
DEFINE_METASIG_T(IM(RetType, _, C(TYPE)))
DEFINE_METASIG(IM(RetVoid, _, v))
DEFINE_METASIG(IM(RetBool, _, F))
DEFINE_METASIG(IM(RetArrByte, _, a(b)))
DEFINE_METASIG_T(IM(RetArrParameterInfo, _, a(C(PARAMETER))))
DEFINE_METASIG_T(IM(RetCultureInfo, _, C(CULTURE_INFO)))
DEFINE_METASIG(IM(Bool_RetIntPtr, F, I))
DEFINE_METASIG_T(IM(Bool_RetMethodInfo, F, C(METHOD_INFO)))
DEFINE_METASIG(SM(Bool_RetStr, F, s))
DEFINE_METASIG(IM(Bool_Bool_RetStr, F F, s))
DEFINE_METASIG(IM(PtrChar_RetVoid, P(u), v))
DEFINE_METASIG(IM(PtrChar_Int_Int_RetVoid, P(u) i i, v))
DEFINE_METASIG_T(IM(ReadOnlySpanOfByte_RetVoid, GI(g(READONLY_SPAN), 1, b), v))
DEFINE_METASIG_T(IM(ReadOnlySpanOfChar_RetVoid, GI(g(READONLY_SPAN), 1, u), v))
DEFINE_METASIG(IM(PtrSByt_RetVoid, P(B), v))
DEFINE_METASIG(IM(PtrSByt_Int_Int_RetVoid, P(B) i i, v))
DEFINE_METASIG_T(IM(PtrSByt_Int_Int_Encoding_RetVoid, P(B) i i C(ENCODING), v))
DEFINE_METASIG(IM(PtrChar_Int_RetVoid, P(u) i, v))
DEFINE_METASIG(IM(PtrSByt_Int_RetVoid, P(B) i, v))
DEFINE_METASIG(SM(ArrChar_RetStr, a(u), s))
DEFINE_METASIG(SM(ArrChar_Int_Int_RetStr, a(u) i i, s))
DEFINE_METASIG(SM(Char_Int_RetStr, u i, s))
DEFINE_METASIG(SM(PtrChar_RetStr, P(u), s))
DEFINE_METASIG(SM(PtrChar_Int_Int_RetStr, P(u) i i, s))
DEFINE_METASIG_T(SM(ReadOnlySpanOfChar_RetStr, GI(g(READONLY_SPAN), 1, u), s))
DEFINE_METASIG(SM(PtrSByt_RetStr, P(B), s))
DEFINE_METASIG(SM(PtrSByt_Int_Int_RetStr, P(B) i i, s))
DEFINE_METASIG_T(SM(PtrSByt_Int_Int_Encoding_RetStr, P(B) i i C(ENCODING), s))
DEFINE_METASIG(IM(Obj_Int_RetIntPtr, j i, I))
DEFINE_METASIG(IM(ArrByte_Int_Int_RetVoid, a(b) i i, v))
DEFINE_METASIG(IM(PtrByte_RetVoid, P(b), v))
DEFINE_METASIG(IM(Char_Char_RetStr, u u, s))
DEFINE_METASIG(IM(Char_Int_RetVoid, u i, v))
DEFINE_METASIG_T(SM(RetCultureInfo, _, C(CULTURE_INFO)))
DEFINE_METASIG_T(SM(CultureInfo_RetVoid, C(CULTURE_INFO), v))
DEFINE_METASIG(IM(Dbl_RetVoid, d, v))
DEFINE_METASIG(IM(Flt_RetVoid, f, v))
DEFINE_METASIG(IM(Int_RetInt, i, i))
DEFINE_METASIG(IM(Int_RefIntPtr_RefIntPtr_RefIntPtr_RetVoid, i r(I) r(I) r(I), v))
DEFINE_METASIG(IM(Int_RetStr, i, s))
DEFINE_METASIG(IM(Int_RetVoid, i, v))
DEFINE_METASIG(IM(Int_RetBool, i, F))
DEFINE_METASIG(IM(Int_Int_RetVoid, i i, v))
DEFINE_METASIG(IM(Int_Int_Int_RetVoid, i i i, v))
DEFINE_METASIG(IM(Int_Int_Int_Int_RetVoid, i i i i, v))
DEFINE_METASIG_T(IM(Obj_EventArgs_RetVoid, j C(EVENT_ARGS), v))
DEFINE_METASIG_T(IM(Obj_UnhandledExceptionEventArgs_RetVoid, j C(UNHANDLED_EVENTARGS), v))
DEFINE_METASIG_T(IM(Assembly_RetBool, C(ASSEMBLY), F))
DEFINE_METASIG_T(IM(AssemblyBase_RetBool, C(ASSEMBLYBASE), F))
DEFINE_METASIG_T(IM(Exception_RetVoid, C(EXCEPTION), v))
DEFINE_METASIG(IM(IntPtr_RetObj, I, j))
DEFINE_METASIG(IM(IntPtr_RetVoid, I, v))
DEFINE_METASIG(IM(IntPtr_PtrVoid_RetVoid, I P(v), v))
DEFINE_METASIG_T(IM(RefGuid_RetIntPtr, r(g(GUID)), I))
DEFINE_METASIG(IM(Obj_RetInt, j, i))
DEFINE_METASIG(IM(Obj_RetIntPtr, j, I))
DEFINE_METASIG(IM(Obj_RetVoid, j, v))
DEFINE_METASIG(IM(Obj_RetObj, j, j))
DEFINE_METASIG(IM(Obj_IntPtr_RetVoid, j I, v))
DEFINE_METASIG(IM(Obj_UIntPtr_RetVoid, j U, v))
DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_RetVoid, j I I, v))
DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_IntPtr_RetVoid, j I I I, v))
DEFINE_METASIG(IM(Obj_IntPtr_IntPtr_IntPtr_IntPtr_RetVoid, j I I I I, v))
DEFINE_METASIG(IM(IntPtr_UInt_IntPtr_IntPtr_RetVoid, I K I I, v))
DEFINE_METASIG(IM(Obj_Bool_RetVoid, j F, v))
#ifdef FEATURE_COMINTEROP
DEFINE_METASIG(SM(Obj_RetStr, j, s))
DEFINE_METASIG_T(IM(Str_BindingFlags_Obj_ArrObj_ArrBool_ArrInt_ArrType_Type_RetObj, s g(BINDING_FLAGS) j a(j) a(F) a(i) a(C(TYPE)) C(TYPE), j))
#endif // FEATURE_COMINTEROP
DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) C(CULTURE_INFO), v))
DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), v))
DEFINE_METASIG_T(IM(Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetObj, j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), j))
DEFINE_METASIG(IM(IntPtr_ArrObj_Obj_RefArrObj_RetObj, I a(j) j r(a(j)), j))
DEFINE_METASIG(IM(RefObject_RetBool, r(j), F))
DEFINE_METASIG_T(IM(Class_RetObj, C(CLASS), j))
DEFINE_METASIG(IM(Int_VoidPtr_RetVoid, i P(v), v))
DEFINE_METASIG(IM(VoidPtr_RetVoid, P(v), v))
DEFINE_METASIG(SM(VoidPtr_RetObj, P(v), j))
DEFINE_METASIG_T(IM(Str_RetModule, s, C(MODULE)))
DEFINE_METASIG_T(SM(Assembly_Str_RetAssembly, C(ASSEMBLY) s, C(ASSEMBLY)))
DEFINE_METASIG_T(SM(Str_Bool_RetAssembly, s F, C(ASSEMBLY)))
DEFINE_METASIG(IM(Str_Str_Obj_RetVoid, s s j, v))
DEFINE_METASIG(IM(Str_Str_Str_Obj_RetVoid, s s s j, v))
DEFINE_METASIG(IM(Str_Str_Str_Obj_Bool_RetVoid, s s s j F, v))
DEFINE_METASIG(IM(Str_Str_RefObj_RetVoid, s s r(j), v))
DEFINE_METASIG(SM(Str_RetStr, s, s))
DEFINE_METASIG_T(SM(Str_CultureInfo_RetStr, s C(CULTURE_INFO), s))
DEFINE_METASIG_T(SM(Str_CultureInfo_RefBool_RetStr, s C(CULTURE_INFO) r(F), s))
DEFINE_METASIG(SM(PtrPtrChar_PtrPtrChar_Int_RetVoid, P(P(u)) P(P(u)) i, v))
DEFINE_METASIG(SM(ArrStr_RetVoid, a(s), v))
DEFINE_METASIG(IM(Str_RetVoid, s, v))
DEFINE_METASIG(SM(RefBool_RefBool_RetVoid, r(F) r(F), v))
DEFINE_METASIG_T(IM(Str_Exception_RetVoid, s C(EXCEPTION), v))
DEFINE_METASIG(IM(Str_Obj_RetVoid, s j, v))
DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_ArrType_ArrParameterModifier_RetMethodInfo, \
s g(BINDING_FLAGS) C(BINDER) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(METHOD_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Type_ArrType_ArrParameterModifier_RetPropertyInfo, \
s g(BINDING_FLAGS) C(BINDER) C(TYPE) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(PROPERTY_INFO)))
DEFINE_METASIG(IM(Str_Str_RetStr, s s, s))
DEFINE_METASIG(IM(Str_Str_RetVoid, s s, v))
DEFINE_METASIG(IM(Str_Str_Str_RetVoid, s s s, v))
DEFINE_METASIG(IM(Str_Int_RetVoid, s i, v))
DEFINE_METASIG(IM(Str_Str_Int_RetVoid, s s i, v))
DEFINE_METASIG(IM(Str_Str_Str_Int_RetVoid, s s s i, v))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetFieldInfo, s g(BINDING_FLAGS), C(FIELD_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetMemberInfo, s g(BINDING_FLAGS), a(C(MEMBER))))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetMethodInfo, s g(BINDING_FLAGS), C(METHOD_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_RetPropertyInfo, s g(BINDING_FLAGS), C(PROPERTY_INFO)))
DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Obj_ArrObj_ArrParameterModifier_CultureInfo_ArrStr_RetObj, \
s g(BINDING_FLAGS) C(BINDER) j a(j) a(g(PARAMETER_MODIFIER)) C(CULTURE_INFO) a(s), j))
DEFINE_METASIG_T(IM(Str_Type_Str_RetVoid, s C(TYPE) s, v))
DEFINE_METASIG_T(SM(Delegate_RetIntPtr, C(DELEGATE), I))
DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetType, g(RT_TYPE_HANDLE), C(TYPE)))
DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetIntPtr, g(RT_TYPE_HANDLE), I))
DEFINE_METASIG_T(SM(RuntimeMethodHandle_RetIntPtr, g(METHOD_HANDLE), I))
DEFINE_METASIG_T(SM(IntPtr_Type_RetDelegate, I C(TYPE), C(DELEGATE)))
DEFINE_METASIG(IM(RetRefByte, _, r(b)))
DEFINE_METASIG_T(IM(Type_RetArrObj, C(TYPE) F, a(j)))
DEFINE_METASIG(IM(Bool_RetVoid, F, v))
DEFINE_METASIG_T(IM(BindingFlags_RetArrFieldInfo, g(BINDING_FLAGS), a(C(FIELD_INFO))))
DEFINE_METASIG_T(IM(BindingFlags_RetArrMemberInfo, g(BINDING_FLAGS), a(C(MEMBER))))
DEFINE_METASIG_T(IM(BindingFlags_RetArrMethodInfo, g(BINDING_FLAGS), a(C(METHOD_INFO))))
DEFINE_METASIG_T(IM(BindingFlags_RetArrPropertyInfo, g(BINDING_FLAGS), a(C(PROPERTY_INFO))))
DEFINE_METASIG(IM(ArrByte_RetVoid, a(b), v))
DEFINE_METASIG(IM(ArrChar_RetVoid, a(u), v))
DEFINE_METASIG(IM(ArrChar_Int_Int_RetVoid, a(u) i i, v))
DEFINE_METASIG_T(IM(ArrType_ArrException_Str_RetVoid, a(C(TYPE)) a(C(EXCEPTION)) s, v))
DEFINE_METASIG(IM(RefInt_RefInt_RefInt_RetArrByte, r(i) r(i) r(i), a(b)))
DEFINE_METASIG_T(IM(RefInt_RetRuntimeType, r(i) , C(CLASS)))
DEFINE_METASIG_T(IM(RuntimeType_RetVoid, C(CLASS) , v))
DEFINE_METASIG_T(SM(ArrException_PtrInt_RetVoid, a(C(EXCEPTION)) P(i), v))
DEFINE_METASIG_T(IM(RuntimeArgumentHandle_PtrVoid_RetVoid, g(ARGUMENT_HANDLE) P(v), v))
DEFINE_METASIG_T(SM(Assembly_RetVoid, C(ASSEMBLY), v))
DEFINE_METASIG_T(SM(Assembly_Str_RetArrAssembly, C(ASSEMBLY) s, a(C(ASSEMBLY))))
DEFINE_METASIG(SM(Str_RetArrStr, s, a(s)))
// Execution Context
DEFINE_METASIG_T(SM(SyncCtx_ArrIntPtr_Bool_Int_RetInt, C(SYNCHRONIZATION_CONTEXT) a(I) F i, i))
#ifdef FEATURE_COMINTEROP
// The signature of the method System.Runtime.InteropServices.ICustomQueryInterface.GetInterface
DEFINE_METASIG_T(IM(RefGuid_OutIntPtr_RetCustomQueryInterfaceResult, r(g(GUID)) r(I), g(CUSTOMQUERYINTERFACERESULT)))
#endif //FEATURE_COMINTEROP
// Assembly Load Context
DEFINE_METASIG_T(SM(RefGuid_RefGuid_RetVoid, r(g(GUID)) r(g(GUID)) , v))
DEFINE_METASIG_T(SM(RefGuid_RetVoid, r(g(GUID)), v))
DEFINE_METASIG_T(SM(IntPtr_AssemblyName_RetAssemblyBase, I C(ASSEMBLY_NAME), C(ASSEMBLYBASE)))
DEFINE_METASIG_T(SM(Str_AssemblyBase_IntPtr_RetIntPtr, s C(ASSEMBLYBASE) I, I))
DEFINE_METASIG_T(SM(Str_AssemblyBase_Bool_UInt_RetIntPtr, s C(ASSEMBLYBASE) F K, I))
// ThreadPool
DEFINE_METASIG_T(SM(_ThreadPoolWaitOrTimerCallback_Bool_RetVoid, C(TPWAITORTIMER_HELPER) F, v))
// For FailFast
DEFINE_METASIG(SM(Str_RetVoid, s, v))
DEFINE_METASIG_T(SM(Str_Exception_RetVoid, s C(EXCEPTION), v))
DEFINE_METASIG_T(SM(Str_Exception_Str_RetVoid, s C(EXCEPTION) s, v))
// fields - e.g.:
// DEFINE_METASIG(Fld(PtrVoid, P(v)))
// Runtime Helpers
DEFINE_METASIG(SM(Obj_Obj_Bool_RetVoid, j j F, v))
DEFINE_METASIG_T(IM(Dec_RetVoid, g(DECIMAL), v))
DEFINE_METASIG_T(IM(Currency_RetVoid, g(CURRENCY), v))
DEFINE_METASIG_T(SM(RefDec_RetVoid, r(g(DECIMAL)), v))
DEFINE_METASIG(GM(RefT_T_T_RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, r(M(0)) M(0) M(0), M(0)))
DEFINE_METASIG(SM(RefObject_Object_Object_RetObject, r(j) j j, j))
DEFINE_METASIG_T(SM(RefCleanupWorkListElement_RetVoid, r(C(CLEANUP_WORK_LIST_ELEMENT)), v))
DEFINE_METASIG_T(SM(RefCleanupWorkListElement_SafeHandle_RetIntPtr, r(C(CLEANUP_WORK_LIST_ELEMENT)) C(SAFE_HANDLE), I))
DEFINE_METASIG_T(SM(RefCleanupWorkListElement_Obj_RetVoid, r(C(CLEANUP_WORK_LIST_ELEMENT)) j, v))
#ifdef FEATURE_ICASTABLE
DEFINE_METASIG_T(SM(ICastable_RtType_RefException_RetBool, C(ICASTABLE) C(CLASS) r(C(EXCEPTION)), F))
DEFINE_METASIG_T(SM(ICastable_RtType_RetRtType, C(ICASTABLE) C(CLASS), C(CLASS)))
#endif // FEATURE_ICASTABLE
DEFINE_METASIG_T(SM(IDynamicInterfaceCastable_RuntimeType_Bool_RetBool, C(IDYNAMICINTERFACECASTABLE) C(CLASS) F, F))
DEFINE_METASIG_T(SM(IDynamicInterfaceCastable_RuntimeType_RetRtType, C(IDYNAMICINTERFACECASTABLE) C(CLASS), C(CLASS)))
DEFINE_METASIG_T(IM(ArrByte_Int_Int_AsyncCallback_Object_RetIAsyncResult, a(b) i i C(ASYNCCALLBACK) j, C(IASYNCRESULT)))
DEFINE_METASIG_T(IM(IAsyncResult_RetInt, C(IASYNCRESULT), i))
DEFINE_METASIG_T(IM(IAsyncResult_RetVoid, C(IASYNCRESULT), v))
DEFINE_METASIG(IM(Int_RetRefT, i, r(G(0))))
DEFINE_METASIG_T(IM(Int_RetReadOnlyRefT, i, Q(INATTRIBUTE) r(G(0))))
DEFINE_METASIG(GM(RetT, IMAGE_CEE_CS_CALLCONV_DEFAULT, 1, _, M(0)))
DEFINE_METASIG_T(SM(Array_Int_Array_Int_Int_RetVoid, C(ARRAY) i C(ARRAY) i i, v))
DEFINE_METASIG_T(SM(Array_Int_Obj_RetVoid, C(ARRAY) i j, v))
DEFINE_METASIG_T(SM(Array_Int_PtrVoid_RetRefObj, C(ARRAY) i P(v), r(j)))
DEFINE_METASIG(SM(Obj_IntPtr_Bool_RetVoid, j I F, v))
DEFINE_METASIG(SM(IntPtr_Obj_RetVoid, I j, v))
DEFINE_METASIG_T(SM(IntPtr_Type_RetVoid, I C(TYPE), v))
// Undefine macros in case we include the file again in the compilation unit
#undef DEFINE_METASIG
#undef DEFINE_METASIG_T
#undef METASIG_BODY
#undef METASIG_ATOM
#undef METASIG_RECURSE
#undef SM
#undef IM
#undef GM
#undef Fld
#undef a
#undef P
#undef r
#undef b
#undef u
#undef d
#undef f
#undef i
#undef K
#undef I
#undef U
#undef l
#undef L
#undef h
#undef H
#undef v
#undef B
#undef F
#undef j
#undef s
#undef C
#undef g
#undef T
#undef G
#undef M
#undef GI
#undef Q
#undef _
#endif // DEFINE_METASIG
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/md/datasource/remotemdinternalrwsource.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//*****************************************************************************
// RemoteMDInternalRWSource.h
//
//
//*****************************************************************************
#ifndef _REMOTE_MDINTERNALRW_SOURCE_
#define _REMOTE_MDINTERNALRW_SOURCE_
#include "targettypes.h"
class RemoteMDInternalRWSource : IMDCustomDataSource
{
public:
RemoteMDInternalRWSource();
virtual ~RemoteMDInternalRWSource();
//*****************************************************************************
// IUnknown methods
//*****************************************************************************
STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
//*****************************************************************************
// IMDCustomDataSource methods
//*****************************************************************************
STDMETHODIMP GetSchema(CMiniMdSchema* pSchema);
STDMETHODIMP GetTableDef(ULONG32 tableIndex, CMiniTableDef* pTableDef);
STDMETHODIMP GetBlobHeap(MetaData::DataBlob* pBlobHeapData);
STDMETHODIMP GetGuidHeap(MetaData::DataBlob* pGuidHeapData);
STDMETHODIMP GetStringHeap(MetaData::DataBlob* pStringHeapData);
STDMETHODIMP GetUserStringHeap(MetaData::DataBlob* pUserStringHeapData);
STDMETHODIMP GetTableRecords(ULONG32 tableIndex, MetaData::DataBlob* pTableRecordData);
STDMETHODIMP GetTableSortable(ULONG32 tableIndex, BOOL* pSortable);
STDMETHODIMP GetStorageSignature(MetaData::DataBlob* pStorageSignature);
//*****************************************************************************
// public non-COM methods
//*****************************************************************************
HRESULT InitFromTarget(TADDR remoteMDInternalRWAddress, ICorDebugDataTarget* pDataTarget, DWORD defines, DWORD dataStructureVersion);
private:
Target_MDInternalRW m_targetData;
CMiniMdSchema m_Schema;
CMiniTableDef m_TableDefs[TBL_COUNT];
MetaData::DataBlob m_StringHeap;
MetaData::DataBlob m_UserStringHeap;
MetaData::DataBlob m_BlobHeap;
MetaData::DataBlob m_GuidHeap;
MetaData::DataBlob m_TableRecords[TBL_COUNT];
BOOL m_bSortable[TBL_COUNT];
MetaData::DataBlob m_Sig;
NewArrayHolder<BYTE> m_StringHeapStorage;
NewArrayHolder<BYTE> m_UserStringHeapStorage;
NewArrayHolder<BYTE> m_BlobHeapStorage;
NewArrayHolder<BYTE> m_GuidHeapStorage;
NewArrayHolder<BYTE> m_TableRecordsStorage[TBL_COUNT];
NewArrayHolder<BYTE> m_SigStorage;
volatile LONG m_cRef;
};
#endif
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//*****************************************************************************
// RemoteMDInternalRWSource.h
//
//
//*****************************************************************************
#ifndef _REMOTE_MDINTERNALRW_SOURCE_
#define _REMOTE_MDINTERNALRW_SOURCE_
#include "targettypes.h"
class RemoteMDInternalRWSource : IMDCustomDataSource
{
public:
RemoteMDInternalRWSource();
virtual ~RemoteMDInternalRWSource();
//*****************************************************************************
// IUnknown methods
//*****************************************************************************
STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
//*****************************************************************************
// IMDCustomDataSource methods
//*****************************************************************************
STDMETHODIMP GetSchema(CMiniMdSchema* pSchema);
STDMETHODIMP GetTableDef(ULONG32 tableIndex, CMiniTableDef* pTableDef);
STDMETHODIMP GetBlobHeap(MetaData::DataBlob* pBlobHeapData);
STDMETHODIMP GetGuidHeap(MetaData::DataBlob* pGuidHeapData);
STDMETHODIMP GetStringHeap(MetaData::DataBlob* pStringHeapData);
STDMETHODIMP GetUserStringHeap(MetaData::DataBlob* pUserStringHeapData);
STDMETHODIMP GetTableRecords(ULONG32 tableIndex, MetaData::DataBlob* pTableRecordData);
STDMETHODIMP GetTableSortable(ULONG32 tableIndex, BOOL* pSortable);
STDMETHODIMP GetStorageSignature(MetaData::DataBlob* pStorageSignature);
//*****************************************************************************
// public non-COM methods
//*****************************************************************************
HRESULT InitFromTarget(TADDR remoteMDInternalRWAddress, ICorDebugDataTarget* pDataTarget, DWORD defines, DWORD dataStructureVersion);
private:
Target_MDInternalRW m_targetData;
CMiniMdSchema m_Schema;
CMiniTableDef m_TableDefs[TBL_COUNT];
MetaData::DataBlob m_StringHeap;
MetaData::DataBlob m_UserStringHeap;
MetaData::DataBlob m_BlobHeap;
MetaData::DataBlob m_GuidHeap;
MetaData::DataBlob m_TableRecords[TBL_COUNT];
BOOL m_bSortable[TBL_COUNT];
MetaData::DataBlob m_Sig;
NewArrayHolder<BYTE> m_StringHeapStorage;
NewArrayHolder<BYTE> m_UserStringHeapStorage;
NewArrayHolder<BYTE> m_BlobHeapStorage;
NewArrayHolder<BYTE> m_GuidHeapStorage;
NewArrayHolder<BYTE> m_TableRecordsStorage[TBL_COUNT];
NewArrayHolder<BYTE> m_SigStorage;
volatile LONG m_cRef;
};
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/external/brotli/enc/block_encoder_inc.h | /* NOLINT(build/header_guard) */
/* Copyright 2014 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/* template parameters: FN */
#define HistogramType FN(Histogram)
/* Creates entropy codes for all block types and stores them to the bit
stream. */
static void FN(BuildAndStoreEntropyCodes)(MemoryManager* m, BlockEncoder* self,
const HistogramType* histograms, const size_t histograms_size,
const size_t alphabet_size, HuffmanTree* tree,
size_t* storage_ix, uint8_t* storage) {
const size_t table_size = histograms_size * self->histogram_length_;
self->depths_ = BROTLI_ALLOC(m, uint8_t, table_size);
self->bits_ = BROTLI_ALLOC(m, uint16_t, table_size);
if (BROTLI_IS_OOM(m)) return;
{
size_t i;
for (i = 0; i < histograms_size; ++i) {
size_t ix = i * self->histogram_length_;
BuildAndStoreHuffmanTree(&histograms[i].data_[0], self->histogram_length_,
alphabet_size, tree, &self->depths_[ix], &self->bits_[ix],
storage_ix, storage);
}
}
}
#undef HistogramType
| /* NOLINT(build/header_guard) */
/* Copyright 2014 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/* template parameters: FN */
#define HistogramType FN(Histogram)
/* Creates entropy codes for all block types and stores them to the bit
stream. */
static void FN(BuildAndStoreEntropyCodes)(MemoryManager* m, BlockEncoder* self,
const HistogramType* histograms, const size_t histograms_size,
const size_t alphabet_size, HuffmanTree* tree,
size_t* storage_ix, uint8_t* storage) {
const size_t table_size = histograms_size * self->histogram_length_;
self->depths_ = BROTLI_ALLOC(m, uint8_t, table_size);
self->bits_ = BROTLI_ALLOC(m, uint16_t, table_size);
if (BROTLI_IS_OOM(m)) return;
{
size_t i;
for (i = 0; i < histograms_size; ++i) {
size_t ix = i * self->histogram_length_;
BuildAndStoreHuffmanTree(&histograms[i].data_[0], self->histogram_length_,
alphabet_size, tree, &self->depths_[ix], &self->bits_[ix],
storage_ix, storage);
}
}
}
#undef HistogramType
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/metadata/dynamic-stream.c | /**
* \file
* MonoDynamicStream
* Copyright 2016 Microsoft
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <glib.h>
#include "mono/metadata/dynamic-stream-internals.h"
#include "mono/metadata/metadata-internals.h"
#include "mono/utils/checked-build.h"
#include "mono/utils/mono-error-internals.h"
#include "object-internals.h"
void
mono_dynstream_init (MonoDynamicStream *sh)
{
MONO_REQ_GC_NEUTRAL_MODE;
sh->index = 0;
sh->alloc_size = 4096;
sh->data = (char *)g_malloc (4096);
sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
mono_dynstream_insert_string (sh, "");
}
static void
make_room_in_stream (MonoDynamicStream *stream, int size)
{
MONO_REQ_GC_NEUTRAL_MODE;
if (size <= stream->alloc_size)
return;
while (stream->alloc_size <= size) {
if (stream->alloc_size < 4096)
stream->alloc_size = 4096;
else
stream->alloc_size *= 2;
}
stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
}
guint32
mono_dynstream_insert_string (MonoDynamicStream *sh, const char *str)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 idx;
guint32 len;
gpointer oldkey, oldval;
if (g_hash_table_lookup_extended (sh->hash, str, &oldkey, &oldval))
return GPOINTER_TO_UINT (oldval);
len = strlen (str) + 1;
idx = sh->index;
make_room_in_stream (sh, idx + len);
/*
* We strdup the string even if we already copy them in sh->data
* so that the string pointers in the hash remain valid even if
* we need to realloc sh->data. We may want to avoid that later.
*/
g_hash_table_insert (sh->hash, g_strdup (str), GUINT_TO_POINTER (idx));
memcpy (sh->data + idx, str, len);
sh->index += len;
return idx;
}
guint32
mono_dynstream_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
error_init (error);
char *name = mono_string_to_utf8_checked_internal (str, error);
return_val_if_nok (error, -1);
guint32 idx;
idx = mono_dynstream_insert_string (sh, name);
g_free (name);
return idx;
}
guint32
mono_dynstream_add_data (MonoDynamicStream *stream, gconstpointer data, guint32 len)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 idx;
make_room_in_stream (stream, stream->index + len);
memcpy (stream->data + stream->index, data, len);
idx = stream->index;
stream->index += len;
/*
* align index? Not without adding an additional param that controls it since
* we may store a blob value in pieces.
*/
return idx;
}
guint32
mono_dynstream_add_zero (MonoDynamicStream *stream, guint32 len)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 idx;
make_room_in_stream (stream, stream->index + len);
memset (stream->data + stream->index, 0, len);
idx = stream->index;
stream->index += len;
return idx;
}
void
mono_dynstream_data_align (MonoDynamicStream *stream)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 count = stream->index % 4;
/* we assume the stream data will be aligned */
if (count)
mono_dynstream_add_zero (stream, 4 - count);
}
| /**
* \file
* MonoDynamicStream
* Copyright 2016 Microsoft
*
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <glib.h>
#include "mono/metadata/dynamic-stream-internals.h"
#include "mono/metadata/metadata-internals.h"
#include "mono/utils/checked-build.h"
#include "mono/utils/mono-error-internals.h"
#include "object-internals.h"
void
mono_dynstream_init (MonoDynamicStream *sh)
{
MONO_REQ_GC_NEUTRAL_MODE;
sh->index = 0;
sh->alloc_size = 4096;
sh->data = (char *)g_malloc (4096);
sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
mono_dynstream_insert_string (sh, "");
}
static void
make_room_in_stream (MonoDynamicStream *stream, int size)
{
MONO_REQ_GC_NEUTRAL_MODE;
if (size <= stream->alloc_size)
return;
while (stream->alloc_size <= size) {
if (stream->alloc_size < 4096)
stream->alloc_size = 4096;
else
stream->alloc_size *= 2;
}
stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
}
guint32
mono_dynstream_insert_string (MonoDynamicStream *sh, const char *str)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 idx;
guint32 len;
gpointer oldkey, oldval;
if (g_hash_table_lookup_extended (sh->hash, str, &oldkey, &oldval))
return GPOINTER_TO_UINT (oldval);
len = strlen (str) + 1;
idx = sh->index;
make_room_in_stream (sh, idx + len);
/*
* We strdup the string even if we already copy them in sh->data
* so that the string pointers in the hash remain valid even if
* we need to realloc sh->data. We may want to avoid that later.
*/
g_hash_table_insert (sh->hash, g_strdup (str), GUINT_TO_POINTER (idx));
memcpy (sh->data + idx, str, len);
sh->index += len;
return idx;
}
guint32
mono_dynstream_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error)
{
MONO_REQ_GC_UNSAFE_MODE;
error_init (error);
char *name = mono_string_to_utf8_checked_internal (str, error);
return_val_if_nok (error, -1);
guint32 idx;
idx = mono_dynstream_insert_string (sh, name);
g_free (name);
return idx;
}
guint32
mono_dynstream_add_data (MonoDynamicStream *stream, gconstpointer data, guint32 len)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 idx;
make_room_in_stream (stream, stream->index + len);
memcpy (stream->data + stream->index, data, len);
idx = stream->index;
stream->index += len;
/*
* align index? Not without adding an additional param that controls it since
* we may store a blob value in pieces.
*/
return idx;
}
guint32
mono_dynstream_add_zero (MonoDynamicStream *stream, guint32 len)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 idx;
make_room_in_stream (stream, stream->index + len);
memset (stream->data + stream->index, 0, len);
idx = stream->index;
stream->index += len;
return idx;
}
void
mono_dynstream_data_align (MonoDynamicStream *stream)
{
MONO_REQ_GC_NEUTRAL_MODE;
guint32 count = stream->index % 4;
/* we assume the stream data will be aligned */
if (count)
mono_dynstream_add_zero (stream, 4 - count);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/ppc32/regname.c | /* libunwind - a platform-independent unwind library
Copyright (C) 2006-2007 IBM
Contributed by
Corey Ashford <[email protected]>
Jose Flavio Aguilar Paulino <[email protected]> <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
static const char *regname[] =
{
[UNW_PPC32_R0]="GPR0",
[UNW_PPC32_R1]="GPR1",
[UNW_PPC32_R2]="GPR2",
[UNW_PPC32_R3]="GPR3",
[UNW_PPC32_R4]="GPR4",
[UNW_PPC32_R5]="GPR5",
[UNW_PPC32_R6]="GPR6",
[UNW_PPC32_R7]="GPR7",
[UNW_PPC32_R8]="GPR8",
[UNW_PPC32_R9]="GPR9",
[UNW_PPC32_R10]="GPR10",
[UNW_PPC32_R11]="GPR11",
[UNW_PPC32_R12]="GPR12",
[UNW_PPC32_R13]="GPR13",
[UNW_PPC32_R14]="GPR14",
[UNW_PPC32_R15]="GPR15",
[UNW_PPC32_R16]="GPR16",
[UNW_PPC32_R17]="GPR17",
[UNW_PPC32_R18]="GPR18",
[UNW_PPC32_R19]="GPR19",
[UNW_PPC32_R20]="GPR20",
[UNW_PPC32_R21]="GPR21",
[UNW_PPC32_R22]="GPR22",
[UNW_PPC32_R23]="GPR23",
[UNW_PPC32_R24]="GPR24",
[UNW_PPC32_R25]="GPR25",
[UNW_PPC32_R26]="GPR26",
[UNW_PPC32_R27]="GPR27",
[UNW_PPC32_R28]="GPR28",
[UNW_PPC32_R29]="GPR29",
[UNW_PPC32_R30]="GPR30",
[UNW_PPC32_R31]="GPR31",
[UNW_PPC32_CTR]="CTR",
[UNW_PPC32_XER]="XER",
[UNW_PPC32_CCR]="CCR",
[UNW_PPC32_LR]="LR",
[UNW_PPC32_FPSCR]="FPSCR",
[UNW_PPC32_F0]="FPR0",
[UNW_PPC32_F1]="FPR1",
[UNW_PPC32_F2]="FPR2",
[UNW_PPC32_F3]="FPR3",
[UNW_PPC32_F4]="FPR4",
[UNW_PPC32_F5]="FPR5",
[UNW_PPC32_F6]="FPR6",
[UNW_PPC32_F7]="FPR7",
[UNW_PPC32_F8]="FPR8",
[UNW_PPC32_F9]="FPR9",
[UNW_PPC32_F10]="FPR10",
[UNW_PPC32_F11]="FPR11",
[UNW_PPC32_F12]="FPR12",
[UNW_PPC32_F13]="FPR13",
[UNW_PPC32_F14]="FPR14",
[UNW_PPC32_F15]="FPR15",
[UNW_PPC32_F16]="FPR16",
[UNW_PPC32_F17]="FPR17",
[UNW_PPC32_F18]="FPR18",
[UNW_PPC32_F19]="FPR19",
[UNW_PPC32_F20]="FPR20",
[UNW_PPC32_F21]="FPR21",
[UNW_PPC32_F22]="FPR22",
[UNW_PPC32_F23]="FPR23",
[UNW_PPC32_F24]="FPR24",
[UNW_PPC32_F25]="FPR25",
[UNW_PPC32_F26]="FPR26",
[UNW_PPC32_F27]="FPR27",
[UNW_PPC32_F28]="FPR28",
[UNW_PPC32_F29]="FPR29",
[UNW_PPC32_F30]="FPR30",
[UNW_PPC32_F31]="FPR31"
};
const char *
unw_regname (unw_regnum_t reg)
{
if (reg < (unw_regnum_t) ARRAY_SIZE (regname))
return regname[reg];
else
return "???";
}
| /* libunwind - a platform-independent unwind library
Copyright (C) 2006-2007 IBM
Contributed by
Corey Ashford <[email protected]>
Jose Flavio Aguilar Paulino <[email protected]> <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
static const char *regname[] =
{
[UNW_PPC32_R0]="GPR0",
[UNW_PPC32_R1]="GPR1",
[UNW_PPC32_R2]="GPR2",
[UNW_PPC32_R3]="GPR3",
[UNW_PPC32_R4]="GPR4",
[UNW_PPC32_R5]="GPR5",
[UNW_PPC32_R6]="GPR6",
[UNW_PPC32_R7]="GPR7",
[UNW_PPC32_R8]="GPR8",
[UNW_PPC32_R9]="GPR9",
[UNW_PPC32_R10]="GPR10",
[UNW_PPC32_R11]="GPR11",
[UNW_PPC32_R12]="GPR12",
[UNW_PPC32_R13]="GPR13",
[UNW_PPC32_R14]="GPR14",
[UNW_PPC32_R15]="GPR15",
[UNW_PPC32_R16]="GPR16",
[UNW_PPC32_R17]="GPR17",
[UNW_PPC32_R18]="GPR18",
[UNW_PPC32_R19]="GPR19",
[UNW_PPC32_R20]="GPR20",
[UNW_PPC32_R21]="GPR21",
[UNW_PPC32_R22]="GPR22",
[UNW_PPC32_R23]="GPR23",
[UNW_PPC32_R24]="GPR24",
[UNW_PPC32_R25]="GPR25",
[UNW_PPC32_R26]="GPR26",
[UNW_PPC32_R27]="GPR27",
[UNW_PPC32_R28]="GPR28",
[UNW_PPC32_R29]="GPR29",
[UNW_PPC32_R30]="GPR30",
[UNW_PPC32_R31]="GPR31",
[UNW_PPC32_CTR]="CTR",
[UNW_PPC32_XER]="XER",
[UNW_PPC32_CCR]="CCR",
[UNW_PPC32_LR]="LR",
[UNW_PPC32_FPSCR]="FPSCR",
[UNW_PPC32_F0]="FPR0",
[UNW_PPC32_F1]="FPR1",
[UNW_PPC32_F2]="FPR2",
[UNW_PPC32_F3]="FPR3",
[UNW_PPC32_F4]="FPR4",
[UNW_PPC32_F5]="FPR5",
[UNW_PPC32_F6]="FPR6",
[UNW_PPC32_F7]="FPR7",
[UNW_PPC32_F8]="FPR8",
[UNW_PPC32_F9]="FPR9",
[UNW_PPC32_F10]="FPR10",
[UNW_PPC32_F11]="FPR11",
[UNW_PPC32_F12]="FPR12",
[UNW_PPC32_F13]="FPR13",
[UNW_PPC32_F14]="FPR14",
[UNW_PPC32_F15]="FPR15",
[UNW_PPC32_F16]="FPR16",
[UNW_PPC32_F17]="FPR17",
[UNW_PPC32_F18]="FPR18",
[UNW_PPC32_F19]="FPR19",
[UNW_PPC32_F20]="FPR20",
[UNW_PPC32_F21]="FPR21",
[UNW_PPC32_F22]="FPR22",
[UNW_PPC32_F23]="FPR23",
[UNW_PPC32_F24]="FPR24",
[UNW_PPC32_F25]="FPR25",
[UNW_PPC32_F26]="FPR26",
[UNW_PPC32_F27]="FPR27",
[UNW_PPC32_F28]="FPR28",
[UNW_PPC32_F29]="FPR29",
[UNW_PPC32_F30]="FPR30",
[UNW_PPC32_F31]="FPR31"
};
const char *
unw_regname (unw_regnum_t reg)
{
if (reg < (unw_regnum_t) ARRAY_SIZE (regname))
return regname[reg];
else
return "???";
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/native/eventpipe/ep-sample-profiler.h | #ifndef __EVENTPIPE_SAMPLE_PROFILER_H__
#define __EVENTPIPE_SAMPLE_PROFILER_H__
#include "ep-rt-config.h"
#ifdef ENABLE_PERFTRACING
#include "ep-types.h"
#undef EP_IMPL_GETTER_SETTER
#ifdef EP_IMPL_SAMPLE_PROFILER_GETTER_SETTER
#define EP_IMPL_GETTER_SETTER
#endif
#include "ep-getter-setter.h"
/*
* EventPipeSampleProfiler.
*/
void
ep_sample_profiler_init (EventPipeProviderCallbackDataQueue *provider_callback_data_queue);
void
ep_sample_profiler_shutdown (void);
void
ep_sample_profiler_enable (void);
void
ep_sample_profiler_disable (void);
void
ep_sample_profiler_can_start_sampling (void);
void
ep_sample_profiler_set_sampling_rate (uint64_t nanoseconds);
uint64_t
ep_sample_profiler_get_sampling_rate (void);
#endif /* ENABLE_PERFTRACING */
#endif /* __EVENTPIPE_SAMPLE_PROFILER_H__ */
| #ifndef __EVENTPIPE_SAMPLE_PROFILER_H__
#define __EVENTPIPE_SAMPLE_PROFILER_H__
#include "ep-rt-config.h"
#ifdef ENABLE_PERFTRACING
#include "ep-types.h"
#undef EP_IMPL_GETTER_SETTER
#ifdef EP_IMPL_SAMPLE_PROFILER_GETTER_SETTER
#define EP_IMPL_GETTER_SETTER
#endif
#include "ep-getter-setter.h"
/*
* EventPipeSampleProfiler.
*/
void
ep_sample_profiler_init (EventPipeProviderCallbackDataQueue *provider_callback_data_queue);
void
ep_sample_profiler_shutdown (void);
void
ep_sample_profiler_enable (void);
void
ep_sample_profiler_disable (void);
void
ep_sample_profiler_can_start_sampling (void);
void
ep_sample_profiler_set_sampling_rate (uint64_t nanoseconds);
uint64_t
ep_sample_profiler_get_sampling_rate (void);
#endif /* ENABLE_PERFTRACING */
#endif /* __EVENTPIPE_SAMPLE_PROFILER_H__ */
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/utils/bsearch.h | /**
* \file
*/
#ifndef __MONO_BSEARCH_H__
#define __MONO_BSEARCH_H__
#include <stdlib.h>
#include "mono/utils/mono-compiler.h"
typedef int (* BinarySearchComparer) (const void *key, const void *member);
void *
mono_binary_search (
const void *key,
const void *array,
size_t array_length,
size_t member_size,
BinarySearchComparer comparer);
#endif
| /**
* \file
*/
#ifndef __MONO_BSEARCH_H__
#define __MONO_BSEARCH_H__
#include <stdlib.h>
#include "mono/utils/mono-compiler.h"
typedef int (* BinarySearchComparer) (const void *key, const void *member);
void *
mono_binary_search (
const void *key,
const void *array,
size_t array_length,
size_t member_size,
BinarySearchComparer comparer);
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/sh/Greg_states_iterate.c | /* libunwind - a platform-independent unwind library
Copyright (c) 2002-2003 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
Modified for x86_64 by Max Asbock <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
int
unw_reg_states_iterate (unw_cursor_t *cursor,
unw_reg_states_callback cb, void *token)
{
struct cursor *c = (struct cursor *) cursor;
return dwarf_reg_states_iterate (&c->dwarf, cb, token);
}
| /* libunwind - a platform-independent unwind library
Copyright (c) 2002-2003 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
Modified for x86_64 by Max Asbock <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
int
unw_reg_states_iterate (unw_cursor_t *cursor,
unw_reg_states_callback cb, void *token)
{
struct cursor *c = (struct cursor *) cursor;
return dwarf_reg_states_iterate (&c->dwarf, cb, token);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/JIT/Directed/StructABI/StructABI.c | // Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#include <stdint.h>
#ifdef _MSC_VER
#define DLLEXPORT __declspec(dllexport)
#else
#define DLLEXPORT __attribute__((visibility("default")))
#ifdef HOST_64BIT
#define __int64 long
#else // HOST_64BIT
#define __int64 long long
#endif // HOST_64BIT
#define __int32 int
#define __int16 short int
#define __int8 char // assumes char is signed
#endif // _MSC_VER
struct SingleByte
{
uint8_t Byte;
};
struct SingleLong
{
uint64_t Long;
};
struct SingleFloat
{
float Float;
};
struct SingleDouble
{
double Double;
};
struct ByteAndFloat
{
uint8_t Byte;
float Float;
};
struct FloatAndByte
{
float Float;
uint8_t Byte;
};
struct LongAndFloat
{
uint64_t Long;
float Float;
};
struct ByteAndDouble
{
uint8_t Byte;
double Double;
};
struct DoubleAndByte
{
double Double;
uint8_t Byte;
};
struct PointerAndByte
{
void* Pointer;
uint8_t Byte;
};
struct ByteAndPointer
{
uint8_t Byte;
void* Pointer;
};
struct ByteFloatAndPointer
{
uint8_t Byte;
float Float;
void* Pointer;
};
struct PointerFloatAndByte
{
void* Pointer;
float Float;
uint8_t Byte;
};
struct ShortIntFloatIntPtr
{
__int16 Short;
__int32 Int;
float Float;
__int32* Pointer;
};
struct TwoLongs
{
uint64_t Long1;
uint64_t Long2;
};
struct TwoFloats
{
float Float1;
float Float2;
};
struct TwoDoubles
{
double Double1;
double Double2;
};
struct FourLongs
{
uint64_t Long1;
uint64_t Long2;
uint64_t Long3;
uint64_t Long4;
};
struct FourDoubles
{
double Double1;
double Double2;
double Double3;
double Double4;
};
struct InlineArray1
{
uint8_t Array[16];
};
struct InlineArray2
{
float Array[4];
};
struct InlineArray3
{
float Array[3];
};
struct InlineArray4
{
uint16_t Array[5];
};
struct InlineArray5
{
uint8_t Array[9];
};
struct InlineArray6
{
double Array[1];
};
struct Nested1
{
struct LongAndFloat Field1;
struct LongAndFloat Field2;
};
struct Nested2
{
struct ByteAndFloat Field1;
struct FloatAndByte Field2;
};
struct Nested3
{
void* Field1;
struct FloatAndByte Field2;
};
struct Nested4
{
struct InlineArray5 Field1;
uint16_t Field2;
};
struct Nested5
{
uint16_t Field1;
struct InlineArray5 Field2;
};
struct Nested6
{
struct InlineArray4 Field1;
uint32_t Field2;
};
struct Nested7
{
uint32_t Field1;
struct InlineArray4 Field2;
};
struct Nested8
{
struct InlineArray4 Field1;
uint16_t Field2;
};
struct Nested9
{
uint16_t Field1;
struct InlineArray4 Field2;
};
DLLEXPORT struct SingleByte EchoSingleByte(struct SingleByte value)
{
return value;
}
DLLEXPORT struct SingleLong EchoSingleLong(struct SingleLong value)
{
return value;
}
DLLEXPORT struct SingleFloat EchoSingleFloat(struct SingleFloat value)
{
return value;
}
DLLEXPORT struct SingleDouble EchoSingleDouble(struct SingleDouble value)
{
return value;
}
DLLEXPORT struct ByteAndFloat EchoByteAndFloat(struct ByteAndFloat value)
{
return value;
}
DLLEXPORT struct LongAndFloat EchoLongAndFloat(struct LongAndFloat value)
{
return value;
}
DLLEXPORT struct ByteAndDouble EchoByteAndDouble(struct ByteAndDouble value)
{
return value;
}
DLLEXPORT struct DoubleAndByte EchoDoubleAndByte(struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct PointerAndByte EchoPointerAndByte(struct PointerAndByte value)
{
return value;
}
DLLEXPORT struct ByteAndPointer EchoByteAndPointer(struct ByteAndPointer value)
{
return value;
}
DLLEXPORT struct ByteFloatAndPointer EchoByteFloatAndPointer(struct ByteFloatAndPointer value)
{
return value;
}
DLLEXPORT struct PointerFloatAndByte EchoPointerFloatAndByte(struct PointerFloatAndByte value)
{
return value;
}
DLLEXPORT struct ShortIntFloatIntPtr EchoShortIntFloatIntPtr(struct ShortIntFloatIntPtr value)
{
return value;
}
DLLEXPORT struct TwoLongs EchoTwoLongs(struct TwoLongs value)
{
return value;
}
DLLEXPORT struct TwoFloats EchoTwoFloats(struct TwoFloats value)
{
return value;
}
DLLEXPORT struct TwoDoubles EchoTwoDoubles(struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct FourLongs EchoFourLongs(struct FourLongs value)
{
return value;
}
DLLEXPORT struct FourDoubles EchoFourDoubles(struct FourDoubles value)
{
return value;
}
DLLEXPORT struct InlineArray1 EchoInlineArray1(struct InlineArray1 value)
{
return value;
}
DLLEXPORT struct InlineArray2 EchoInlineArray2(struct InlineArray2 value)
{
return value;
}
DLLEXPORT struct InlineArray3 EchoInlineArray3(struct InlineArray3 value)
{
return value;
}
DLLEXPORT struct InlineArray4 EchoInlineArray4(struct InlineArray4 value)
{
return value;
}
DLLEXPORT struct InlineArray5 EchoInlineArray5(struct InlineArray5 value)
{
return value;
}
DLLEXPORT struct InlineArray6 EchoInlineArray6(struct InlineArray6 value)
{
return value;
}
DLLEXPORT struct Nested1 EchoNested1(struct Nested1 value)
{
return value;
}
DLLEXPORT struct Nested2 EchoNested2(struct Nested2 value)
{
return value;
}
DLLEXPORT struct Nested3 EchoNested3(struct Nested3 value)
{
return value;
}
DLLEXPORT struct Nested4 EchoNested4(struct Nested4 value)
{
return value;
}
DLLEXPORT struct Nested5 EchoNested5(struct Nested5 value)
{
return value;
}
DLLEXPORT struct Nested6 EchoNested6(struct Nested6 value)
{
return value;
}
DLLEXPORT struct Nested7 EchoNested7(struct Nested7 value)
{
return value;
}
DLLEXPORT struct Nested8 EchoNested8(struct Nested8 value)
{
return value;
}
DLLEXPORT struct Nested9 EchoNested9(struct Nested9 value)
{
return value;
}
DLLEXPORT struct TwoLongs NotEnoughRegistersSysV1(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, struct TwoLongs value)
{
return value;
}
DLLEXPORT struct TwoLongs NotEnoughRegistersSysV2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, struct TwoLongs value)
{
return value;
}
DLLEXPORT struct DoubleAndByte NotEnoughRegistersSysV3(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct TwoDoubles NotEnoughRegistersSysV4(double a, double b, double c, double d, double e, double f, double g, double h, struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct TwoDoubles NotEnoughRegistersSysV5(double a, double b, double c, double d, double e, double f, double g, struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct DoubleAndByte NotEnoughRegistersSysV6(double a, double b, double c, double d, double e, double f, double g, double h, struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct TwoDoubles EnoughRegistersSysV1(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct DoubleAndByte EnoughRegistersSysV2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct TwoLongs EnoughRegistersSysV3(double a, double b, double c, double d, double e, double f, double g, double h, struct TwoLongs value)
{
return value;
}
DLLEXPORT struct DoubleAndByte EnoughRegistersSysV4(double a, double b, double c, double d, double e, double f, double g, struct DoubleAndByte value)
{
return value;
}
| // Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
#include <stdint.h>
#ifdef _MSC_VER
#define DLLEXPORT __declspec(dllexport)
#else
#define DLLEXPORT __attribute__((visibility("default")))
#ifdef HOST_64BIT
#define __int64 long
#else // HOST_64BIT
#define __int64 long long
#endif // HOST_64BIT
#define __int32 int
#define __int16 short int
#define __int8 char // assumes char is signed
#endif // _MSC_VER
struct SingleByte
{
uint8_t Byte;
};
struct SingleLong
{
uint64_t Long;
};
struct SingleFloat
{
float Float;
};
struct SingleDouble
{
double Double;
};
struct ByteAndFloat
{
uint8_t Byte;
float Float;
};
struct FloatAndByte
{
float Float;
uint8_t Byte;
};
struct LongAndFloat
{
uint64_t Long;
float Float;
};
struct ByteAndDouble
{
uint8_t Byte;
double Double;
};
struct DoubleAndByte
{
double Double;
uint8_t Byte;
};
struct PointerAndByte
{
void* Pointer;
uint8_t Byte;
};
struct ByteAndPointer
{
uint8_t Byte;
void* Pointer;
};
struct ByteFloatAndPointer
{
uint8_t Byte;
float Float;
void* Pointer;
};
struct PointerFloatAndByte
{
void* Pointer;
float Float;
uint8_t Byte;
};
struct ShortIntFloatIntPtr
{
__int16 Short;
__int32 Int;
float Float;
__int32* Pointer;
};
struct TwoLongs
{
uint64_t Long1;
uint64_t Long2;
};
struct TwoFloats
{
float Float1;
float Float2;
};
struct TwoDoubles
{
double Double1;
double Double2;
};
struct FourLongs
{
uint64_t Long1;
uint64_t Long2;
uint64_t Long3;
uint64_t Long4;
};
struct FourDoubles
{
double Double1;
double Double2;
double Double3;
double Double4;
};
struct InlineArray1
{
uint8_t Array[16];
};
struct InlineArray2
{
float Array[4];
};
struct InlineArray3
{
float Array[3];
};
struct InlineArray4
{
uint16_t Array[5];
};
struct InlineArray5
{
uint8_t Array[9];
};
struct InlineArray6
{
double Array[1];
};
struct Nested1
{
struct LongAndFloat Field1;
struct LongAndFloat Field2;
};
struct Nested2
{
struct ByteAndFloat Field1;
struct FloatAndByte Field2;
};
struct Nested3
{
void* Field1;
struct FloatAndByte Field2;
};
struct Nested4
{
struct InlineArray5 Field1;
uint16_t Field2;
};
struct Nested5
{
uint16_t Field1;
struct InlineArray5 Field2;
};
struct Nested6
{
struct InlineArray4 Field1;
uint32_t Field2;
};
struct Nested7
{
uint32_t Field1;
struct InlineArray4 Field2;
};
struct Nested8
{
struct InlineArray4 Field1;
uint16_t Field2;
};
struct Nested9
{
uint16_t Field1;
struct InlineArray4 Field2;
};
DLLEXPORT struct SingleByte EchoSingleByte(struct SingleByte value)
{
return value;
}
DLLEXPORT struct SingleLong EchoSingleLong(struct SingleLong value)
{
return value;
}
DLLEXPORT struct SingleFloat EchoSingleFloat(struct SingleFloat value)
{
return value;
}
DLLEXPORT struct SingleDouble EchoSingleDouble(struct SingleDouble value)
{
return value;
}
DLLEXPORT struct ByteAndFloat EchoByteAndFloat(struct ByteAndFloat value)
{
return value;
}
DLLEXPORT struct LongAndFloat EchoLongAndFloat(struct LongAndFloat value)
{
return value;
}
DLLEXPORT struct ByteAndDouble EchoByteAndDouble(struct ByteAndDouble value)
{
return value;
}
DLLEXPORT struct DoubleAndByte EchoDoubleAndByte(struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct PointerAndByte EchoPointerAndByte(struct PointerAndByte value)
{
return value;
}
DLLEXPORT struct ByteAndPointer EchoByteAndPointer(struct ByteAndPointer value)
{
return value;
}
DLLEXPORT struct ByteFloatAndPointer EchoByteFloatAndPointer(struct ByteFloatAndPointer value)
{
return value;
}
DLLEXPORT struct PointerFloatAndByte EchoPointerFloatAndByte(struct PointerFloatAndByte value)
{
return value;
}
DLLEXPORT struct ShortIntFloatIntPtr EchoShortIntFloatIntPtr(struct ShortIntFloatIntPtr value)
{
return value;
}
DLLEXPORT struct TwoLongs EchoTwoLongs(struct TwoLongs value)
{
return value;
}
DLLEXPORT struct TwoFloats EchoTwoFloats(struct TwoFloats value)
{
return value;
}
DLLEXPORT struct TwoDoubles EchoTwoDoubles(struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct FourLongs EchoFourLongs(struct FourLongs value)
{
return value;
}
DLLEXPORT struct FourDoubles EchoFourDoubles(struct FourDoubles value)
{
return value;
}
DLLEXPORT struct InlineArray1 EchoInlineArray1(struct InlineArray1 value)
{
return value;
}
DLLEXPORT struct InlineArray2 EchoInlineArray2(struct InlineArray2 value)
{
return value;
}
DLLEXPORT struct InlineArray3 EchoInlineArray3(struct InlineArray3 value)
{
return value;
}
DLLEXPORT struct InlineArray4 EchoInlineArray4(struct InlineArray4 value)
{
return value;
}
DLLEXPORT struct InlineArray5 EchoInlineArray5(struct InlineArray5 value)
{
return value;
}
DLLEXPORT struct InlineArray6 EchoInlineArray6(struct InlineArray6 value)
{
return value;
}
DLLEXPORT struct Nested1 EchoNested1(struct Nested1 value)
{
return value;
}
DLLEXPORT struct Nested2 EchoNested2(struct Nested2 value)
{
return value;
}
DLLEXPORT struct Nested3 EchoNested3(struct Nested3 value)
{
return value;
}
DLLEXPORT struct Nested4 EchoNested4(struct Nested4 value)
{
return value;
}
DLLEXPORT struct Nested5 EchoNested5(struct Nested5 value)
{
return value;
}
DLLEXPORT struct Nested6 EchoNested6(struct Nested6 value)
{
return value;
}
DLLEXPORT struct Nested7 EchoNested7(struct Nested7 value)
{
return value;
}
DLLEXPORT struct Nested8 EchoNested8(struct Nested8 value)
{
return value;
}
DLLEXPORT struct Nested9 EchoNested9(struct Nested9 value)
{
return value;
}
DLLEXPORT struct TwoLongs NotEnoughRegistersSysV1(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, struct TwoLongs value)
{
return value;
}
DLLEXPORT struct TwoLongs NotEnoughRegistersSysV2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, struct TwoLongs value)
{
return value;
}
DLLEXPORT struct DoubleAndByte NotEnoughRegistersSysV3(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct TwoDoubles NotEnoughRegistersSysV4(double a, double b, double c, double d, double e, double f, double g, double h, struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct TwoDoubles NotEnoughRegistersSysV5(double a, double b, double c, double d, double e, double f, double g, struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct DoubleAndByte NotEnoughRegistersSysV6(double a, double b, double c, double d, double e, double f, double g, double h, struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct TwoDoubles EnoughRegistersSysV1(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, struct TwoDoubles value)
{
return value;
}
DLLEXPORT struct DoubleAndByte EnoughRegistersSysV2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, struct DoubleAndByte value)
{
return value;
}
DLLEXPORT struct TwoLongs EnoughRegistersSysV3(double a, double b, double c, double d, double e, double f, double g, double h, struct TwoLongs value)
{
return value;
}
DLLEXPORT struct DoubleAndByte EnoughRegistersSysV4(double a, double b, double c, double d, double e, double f, double g, struct DoubleAndByte value)
{
return value;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/profiler/native/nullprofiler/nullprofiler.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include "../profiler.h"
class NullProfiler : public Profiler
{
private:
std::atomic<uint32_t> _failures;
public:
NullProfiler() :
Profiler(),
_failures(0)
{
}
static GUID GetClsid();
virtual HRESULT STDMETHODCALLTYPE Initialize(IUnknown* pICorProfilerInfoUnk);
virtual HRESULT STDMETHODCALLTYPE Shutdown();
};
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma once
#include "../profiler.h"
class NullProfiler : public Profiler
{
private:
std::atomic<uint32_t> _failures;
public:
NullProfiler() :
Profiler(),
_failures(0)
{
}
static GUID GetClsid();
virtual HRESULT STDMETHODCALLTYPE Initialize(IUnknown* pICorProfilerInfoUnk);
virtual HRESULT STDMETHODCALLTYPE Shutdown();
};
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/mono/mono/metadata/class-init.c | /**
* \file MonoClass construction and initialization
*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Copyright 2012 Xamarin Inc (http://www.xamarin.com)
* Copyright 2018 Microsoft
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <mono/metadata/class-init.h>
#include <mono/metadata/class-init-internals.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/custom-attrs-internals.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/exception-internals.h>
#include <mono/metadata/gc-internals.h>
#include <mono/metadata/object-internals.h>
#include <mono/metadata/profiler-private.h>
#include <mono/metadata/verify-internals.h>
#include <mono/metadata/abi-details.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/marshal.h>
#include <mono/utils/checked-build.h>
#include <mono/utils/mono-counters.h>
#include <mono/utils/mono-error-internals.h>
#include <mono/utils/mono-logger-internals.h>
#include <mono/utils/mono-memory-model.h>
#include <mono/utils/unlocked.h>
#ifdef MONO_CLASS_DEF_PRIVATE
/* Class initialization gets to see the fields of MonoClass */
#define REALLY_INCLUDE_CLASS_DEF 1
#include <mono/metadata/class-private-definition.h>
#undef REALLY_INCLUDE_CLASS_DEF
#endif
#define FEATURE_COVARIANT_RETURNS
gboolean mono_print_vtable = FALSE;
gboolean mono_align_small_structs = FALSE;
/* Set by the EE */
gint32 mono_simd_register_size;
/* Statistics */
static gint32 classes_size;
static gint32 inflated_classes_size;
gint32 mono_inflated_methods_size;
static gint32 class_def_count, class_gtd_count, class_ginst_count, class_gparam_count, class_array_count, class_pointer_count;
/* Low level lock which protects data structures in this module */
static mono_mutex_t classes_mutex;
static gboolean class_kind_may_contain_generic_instances (MonoTypeKind kind);
static void mono_generic_class_setup_parent (MonoClass *klass, MonoClass *gtd);
static int generic_array_methods (MonoClass *klass);
static void setup_generic_array_ifaces (MonoClass *klass, MonoClass *iface, MonoMethod **methods, int pos, GHashTable *cache);
static gboolean class_has_isbyreflike_attribute (MonoClass *klass);
static
GENERATE_TRY_GET_CLASS_WITH_CACHE(icollection, "System.Collections.Generic", "ICollection`1");
static
GENERATE_TRY_GET_CLASS_WITH_CACHE(ienumerable, "System.Collections.Generic", "IEnumerable`1");
static
GENERATE_TRY_GET_CLASS_WITH_CACHE(ireadonlycollection, "System.Collections.Generic", "IReadOnlyCollection`1");
/* This TLS variable points to a GSList of classes which have setup_fields () executing */
static MonoNativeTlsKey setup_fields_tls_id;
static MonoNativeTlsKey init_pending_tls_id;
static void
classes_lock (void)
{
mono_locks_os_acquire (&classes_mutex, ClassesLock);
}
static void
classes_unlock (void)
{
mono_locks_os_release (&classes_mutex, ClassesLock);
}
/*
We use gclass recording to allow recursive system f types to be referenced by a parent.
Given the following type hierarchy:
class TextBox : TextBoxBase<TextBox> {}
class TextBoxBase<T> : TextInput<TextBox> where T : TextBoxBase<T> {}
class TextInput<T> : Input<T> where T: TextInput<T> {}
class Input<T> {}
The runtime tries to load TextBoxBase<>.
To load TextBoxBase<> to do so it must resolve the parent which is TextInput<TextBox>.
To instantiate TextInput<TextBox> it must resolve TextInput<> and TextBox.
To load TextBox it must resolve the parent which is TextBoxBase<TextBox>.
At this point the runtime must instantiate TextBoxBase<TextBox>. Both types are partially loaded
at this point, iow, both are registered in the type map and both and a NULL parent. This means
that the resulting generic instance will have a NULL parent, which is wrong and will cause breakage.
To fix that what we do is to record all generic instantes created while resolving the parent of
any generic type definition and, after resolved, correct the parent field if needed.
*/
static int record_gclass_instantiation;
static GSList *gclass_recorded_list;
typedef gboolean (*gclass_record_func) (MonoClass*, void*);
/*
* LOCKING: loader lock must be held until pairing disable_gclass_recording is called.
*/
static void
enable_gclass_recording (void)
{
++record_gclass_instantiation;
}
/*
* LOCKING: loader lock must be held since pairing enable_gclass_recording was called.
*/
static void
disable_gclass_recording (gclass_record_func func, void *user_data)
{
GSList **head = &gclass_recorded_list;
g_assert (record_gclass_instantiation > 0);
--record_gclass_instantiation;
while (*head) {
GSList *node = *head;
if (func ((MonoClass*)node->data, user_data)) {
*head = node->next;
g_slist_free_1 (node);
} else {
head = &node->next;
}
}
/* We automatically discard all recorded gclasses when disabled. */
if (!record_gclass_instantiation && gclass_recorded_list) {
g_slist_free (gclass_recorded_list);
gclass_recorded_list = NULL;
}
}
#define mono_class_new0(klass,struct_type, n_structs) \
((struct_type *) mono_class_alloc0 ((klass), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
/**
* mono_class_setup_basic_field_info:
* \param class The class to initialize
*
* Initializes the following fields in MonoClass:
* * klass->fields (only field->parent and field->name)
* * klass->field.count
* * klass->first_field_idx
* LOCKING: Acquires the loader lock
*/
void
mono_class_setup_basic_field_info (MonoClass *klass)
{
MonoGenericClass *gklass;
MonoClassField *field;
MonoClassField *fields;
MonoClass *gtd;
MonoImage *image;
int i, top;
if (klass->fields)
return;
gklass = mono_class_try_get_generic_class (klass);
gtd = gklass ? mono_class_get_generic_type_definition (klass) : NULL;
image = klass->image;
if (gklass && image_is_dynamic (gklass->container_class->image) && !gklass->container_class->wastypebuilder) {
/*
* This happens when a generic instance of an unfinished generic typebuilder
* is used as an element type for creating an array type. We can't initialize
* the fields of this class using the fields of gklass, since gklass is not
* finished yet, fields could be added to it later.
*/
return;
}
if (gtd) {
mono_class_setup_basic_field_info (gtd);
mono_loader_lock ();
mono_class_set_field_count (klass, mono_class_get_field_count (gtd));
mono_loader_unlock ();
}
top = mono_class_get_field_count (klass);
fields = (MonoClassField *)mono_class_alloc0 (klass, sizeof (MonoClassField) * top);
/*
* Fetch all the field information.
*/
int first_field_idx = mono_class_has_static_metadata (klass) ? mono_class_get_first_field_idx (klass) : 0;
for (i = 0; i < top; i++) {
field = &fields [i];
m_field_set_parent (field, klass);
if (gtd) {
field->name = mono_field_get_name (>d->fields [i]);
} else {
int idx = first_field_idx + i;
/* first_field_idx and idx points into the fieldptr table */
guint32 name_idx = mono_metadata_decode_table_row_col (image, MONO_TABLE_FIELD, idx, MONO_FIELD_NAME);
/* The name is needed for fieldrefs */
field->name = mono_metadata_string_heap (image, name_idx);
}
}
mono_memory_barrier ();
mono_loader_lock ();
if (!klass->fields)
klass->fields = fields;
mono_loader_unlock ();
}
/**
* mono_class_setup_fields:
* \p klass The class to initialize
*
* Initializes klass->fields, computes class layout and sizes.
* typebuilder_setup_fields () is the corresponding function for dynamic classes.
* Sets the following fields in \p klass:
* - all the fields initialized by mono_class_init_sizes ()
* - element_class/cast_class (for enums)
* - sizes:element_size (for arrays)
* - field->type/offset for all fields
* - fields_inited
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_fields (MonoClass *klass)
{
ERROR_DECL (error);
MonoImage *m = klass->image;
int top;
guint32 layout = mono_class_get_flags (klass) & TYPE_ATTRIBUTE_LAYOUT_MASK;
int i;
guint32 real_size = 0;
guint32 packing_size = 0;
int instance_size;
gboolean explicit_size;
MonoClassField *field;
MonoGenericClass *gklass = mono_class_try_get_generic_class (klass);
MonoClass *gtd = gklass ? mono_class_get_generic_type_definition (klass) : NULL;
if (klass->fields_inited)
return;
if (gklass && image_is_dynamic (gklass->container_class->image) && !gklass->container_class->wastypebuilder) {
/*
* This happens when a generic instance of an unfinished generic typebuilder
* is used as an element type for creating an array type. We can't initialize
* the fields of this class using the fields of gklass, since gklass is not
* finished yet, fields could be added to it later.
*/
return;
}
mono_class_setup_basic_field_info (klass);
top = mono_class_get_field_count (klass);
if (gtd) {
mono_class_setup_fields (gtd);
if (mono_class_set_type_load_failure_causedby_class (klass, gtd, "Generic type definition failed"))
return;
}
instance_size = 0;
if (klass->parent) {
/* For generic instances, klass->parent might not have been initialized */
mono_class_init_internal (klass->parent);
mono_class_setup_fields (klass->parent);
if (mono_class_set_type_load_failure_causedby_class (klass, klass->parent, "Could not set up parent class"))
return;
instance_size = klass->parent->instance_size;
} else {
instance_size = MONO_ABI_SIZEOF (MonoObject);
}
/* Get the real size */
explicit_size = mono_metadata_packing_from_typedef (klass->image, klass->type_token, &packing_size, &real_size);
if (explicit_size)
instance_size += real_size;
if (mono_is_corlib_image (klass->image) && !strcmp (klass->name_space, "System.Numerics") && !strcmp (klass->name, "Register")) {
if (mono_simd_register_size)
instance_size += mono_simd_register_size;
}
/*
* This function can recursively call itself.
* Prevent infinite recursion by using a list in TLS.
*/
GSList *init_list = (GSList *)mono_native_tls_get_value (setup_fields_tls_id);
if (g_slist_find (init_list, klass))
return;
init_list = g_slist_prepend (init_list, klass);
mono_native_tls_set_value (setup_fields_tls_id, init_list);
/*
* Fetch all the field information.
*/
int first_field_idx = mono_class_has_static_metadata (klass) ? mono_class_get_first_field_idx (klass) : 0;
for (i = 0; i < top; i++) {
int idx = first_field_idx + i;
field = &klass->fields [i];
if (!field->type) {
mono_field_resolve_type (field, error);
if (!is_ok (error)) {
/*mono_field_resolve_type already failed class*/
mono_error_cleanup (error);
break;
}
if (!field->type)
g_error ("could not resolve %s:%s\n", mono_type_get_full_name(klass), field->name);
g_assert (field->type);
}
if (!mono_type_get_underlying_type (field->type)) {
mono_class_set_type_load_failure (klass, "Field '%s' is an enum type with a bad underlying type", field->name);
break;
}
if (mono_field_is_deleted (field))
continue;
if (layout == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
guint32 uoffset;
mono_metadata_field_info (m, idx, &uoffset, NULL, NULL);
int offset = uoffset;
if (offset == (guint32)-1 && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
mono_class_set_type_load_failure (klass, "Missing field layout info for %s", field->name);
break;
}
if (m_type_is_byref (field->type) && (offset % MONO_ABI_ALIGNOF (gpointer) != 0)) {
mono_class_set_type_load_failure (klass, "Field '%s' has an invalid offset", field->name);
break;
}
if (offset < -1) { /*-1 is used to encode special static fields */
mono_class_set_type_load_failure (klass, "Field '%s' has a negative offset %d", field->name, offset);
break;
}
if (mono_class_is_gtd (klass)) {
mono_class_set_type_load_failure (klass, "Generic class cannot have explicit layout.");
break;
}
}
if (mono_type_has_exceptions (field->type)) {
char *class_name = mono_type_get_full_name (klass);
char *type_name = mono_type_full_name (field->type);
mono_class_set_type_load_failure (klass, "Invalid type %s for instance field %s:%s", type_name, class_name, field->name);
g_free (class_name);
g_free (type_name);
break;
}
if (m_type_is_byref (field->type)) {
if (!m_class_is_byreflike (klass)) {
char *class_name = mono_type_get_full_name (klass);
mono_class_set_type_load_failure (klass, "Type %s is not a ByRefLike type so ref field, '%s', is invalid", class_name, field->name);
g_free (class_name);
break;
}
}
/* The def_value of fields is compute lazily during vtable creation */
}
if (!mono_class_has_failure (klass)) {
mono_loader_lock ();
mono_class_layout_fields (klass, instance_size, packing_size, real_size, FALSE);
mono_loader_unlock ();
}
init_list = g_slist_remove (init_list, klass);
mono_native_tls_set_value (setup_fields_tls_id, init_list);
}
static gboolean
discard_gclass_due_to_failure (MonoClass *gclass, void *user_data)
{
return mono_class_get_generic_class (gclass)->container_class == user_data;
}
static gboolean
fix_gclass_incomplete_instantiation (MonoClass *gclass, void *user_data)
{
MonoClass *gtd = (MonoClass*)user_data;
/* Only try to fix generic instances of @gtd */
if (mono_class_get_generic_class (gclass)->container_class != gtd)
return FALSE;
/* Check if the generic instance has no parent. */
if (gtd->parent && !gclass->parent)
mono_generic_class_setup_parent (gclass, gtd);
return TRUE;
}
static void
mono_class_set_failure_and_error (MonoClass *klass, MonoError *error, const char *msg)
{
mono_class_set_type_load_failure (klass, "%s", msg);
mono_error_set_type_load_class (error, klass, "%s", msg);
}
/**
* mono_class_create_from_typedef:
* \param image: image where the token is valid
* \param type_token: typedef token
* \param error: used to return any error found while creating the type
*
* Create the MonoClass* representing the specified type token.
* \p type_token must be a TypeDef token.
*
* FIXME: don't return NULL on failure, just let the caller figure it out.
*/
MonoClass *
mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError *error)
{
MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
MonoClass *klass, *parent = NULL;
guint32 cols [MONO_TYPEDEF_SIZE];
guint32 cols_next [MONO_TYPEDEF_SIZE];
guint tidx = mono_metadata_token_index (type_token);
MonoGenericContext *context = NULL;
const char *name, *nspace;
guint icount = 0;
MonoClass **interfaces;
guint32 field_last, method_last;
guint32 nesting_tokeen;
error_init (error);
/* FIXME: metadata-update - this function needs extensive work */
if (mono_metadata_token_table (type_token) != MONO_TABLE_TYPEDEF || mono_metadata_table_bounds_check (image, MONO_TABLE_TYPEDEF, tidx)) {
mono_error_set_bad_image (error, image, "Invalid typedef token %x", type_token);
return NULL;
}
mono_loader_lock ();
if ((klass = (MonoClass *)mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
mono_loader_unlock ();
return klass;
}
mono_metadata_decode_row (tt, tidx - 1, cols, MONO_TYPEDEF_SIZE);
name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
if (mono_metadata_has_generic_params (image, type_token)) {
klass = (MonoClass*)mono_image_alloc0 (image, sizeof (MonoClassGtd));
klass->class_kind = MONO_CLASS_GTD;
UnlockedAdd (&classes_size, sizeof (MonoClassGtd));
++class_gtd_count;
} else {
klass = (MonoClass*)mono_image_alloc0 (image, sizeof (MonoClassDef));
klass->class_kind = MONO_CLASS_DEF;
UnlockedAdd (&classes_size, sizeof (MonoClassDef));
++class_def_count;
}
klass->name = name;
klass->name_space = nspace;
MONO_PROFILER_RAISE (class_loading, (klass));
klass->image = image;
klass->type_token = type_token;
mono_class_set_flags (klass, cols [MONO_TYPEDEF_FLAGS]);
mono_internal_hash_table_insert (&image->class_cache, GUINT_TO_POINTER (type_token), klass);
/*
* Check whether we're a generic type definition.
*/
if (mono_class_is_gtd (klass)) {
MonoGenericContainer *generic_container = mono_metadata_load_generic_params (image, klass->type_token, NULL, klass);
context = &generic_container->context;
mono_class_set_generic_container (klass, generic_container);
MonoType *canonical_inst = &((MonoClassGtd*)klass)->canonical_inst;
canonical_inst->type = MONO_TYPE_GENERICINST;
canonical_inst->data.generic_class = mono_metadata_lookup_generic_class (klass, context->class_inst, FALSE);
enable_gclass_recording ();
}
if (cols [MONO_TYPEDEF_EXTENDS]) {
MonoClass *tmp;
guint32 parent_token = mono_metadata_token_from_dor (cols [MONO_TYPEDEF_EXTENDS]);
if (mono_metadata_token_table (parent_token) == MONO_TABLE_TYPESPEC) {
/*WARNING: this must satisfy mono_metadata_type_hash*/
klass->this_arg.byref__ = 1;
klass->this_arg.data.klass = klass;
klass->this_arg.type = MONO_TYPE_CLASS;
klass->_byval_arg.data.klass = klass;
klass->_byval_arg.type = MONO_TYPE_CLASS;
}
parent = mono_class_get_checked (image, parent_token, error);
if (parent && context) /* Always inflate */
parent = mono_class_inflate_generic_class_checked (parent, context, error);
if (parent == NULL) {
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
goto parent_failure;
}
for (tmp = parent; tmp; tmp = tmp->parent) {
if (tmp == klass) {
mono_class_set_failure_and_error (klass, error, "Cycle found while resolving parent");
goto parent_failure;
}
if (mono_class_is_gtd (klass) && mono_class_is_ginst (tmp) && mono_class_get_generic_class (tmp)->container_class == klass) {
mono_class_set_failure_and_error (klass, error, "Parent extends generic instance of this type");
goto parent_failure;
}
}
}
mono_class_setup_parent (klass, parent);
/* uses ->valuetype, which is initialized by mono_class_setup_parent above */
mono_class_setup_mono_type (klass);
if (mono_class_is_gtd (klass))
disable_gclass_recording (fix_gclass_incomplete_instantiation, klass);
/*
* This might access klass->_byval_arg for recursion generated by generic constraints,
* so it has to come after setup_mono_type ().
*/
if ((nesting_tokeen = mono_metadata_nested_in_typedef (image, type_token))) {
klass->nested_in = mono_class_create_from_typedef (image, nesting_tokeen, error);
if (!is_ok (error)) {
/*FIXME implement a mono_class_set_failure_from_mono_error */
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
}
if ((mono_class_get_flags (klass) & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_UNICODE_CLASS)
klass->unicode = 1;
#ifdef HOST_WIN32
if ((mono_class_get_flags (klass) & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_AUTO_CLASS)
klass->unicode = 1;
#endif
klass->cast_class = klass->element_class = klass;
if (mono_is_corlib_image (klass->image)) {
switch (m_class_get_byval_arg (klass)->type) {
case MONO_TYPE_I1:
if (mono_defaults.byte_class)
klass->cast_class = mono_defaults.byte_class;
break;
case MONO_TYPE_U1:
if (mono_defaults.sbyte_class)
mono_defaults.sbyte_class = klass;
break;
case MONO_TYPE_I2:
if (mono_defaults.uint16_class)
mono_defaults.uint16_class = klass;
break;
case MONO_TYPE_U2:
if (mono_defaults.int16_class)
klass->cast_class = mono_defaults.int16_class;
break;
case MONO_TYPE_I4:
if (mono_defaults.uint32_class)
mono_defaults.uint32_class = klass;
break;
case MONO_TYPE_U4:
if (mono_defaults.int32_class)
klass->cast_class = mono_defaults.int32_class;
break;
case MONO_TYPE_I8:
if (mono_defaults.uint64_class)
mono_defaults.uint64_class = klass;
break;
case MONO_TYPE_U8:
if (mono_defaults.int64_class)
klass->cast_class = mono_defaults.int64_class;
break;
default:
break;
}
}
if (!klass->enumtype) {
if (!mono_metadata_interfaces_from_typedef_full (
image, type_token, &interfaces, &icount, FALSE, context, error)){
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
/* This is required now that it is possible for more than 2^16 interfaces to exist. */
g_assert(icount <= 65535);
klass->interfaces = interfaces;
klass->interface_count = icount;
klass->interfaces_inited = 1;
}
/*g_print ("Load class %s\n", name);*/
/*
* Compute the field and method lists
*/
/*
* EnC metadata-update: new classes are added with method and field indices set to 0, new
* methods are added using the EnCLog AddMethod or AddField functions that will be added to
* MonoClassMetadataUpdateInfo
*/
if (G_LIKELY (cols [MONO_TYPEDEF_FIELD_LIST] != 0 || cols [MONO_TYPEDEF_METHOD_LIST] != 0)) {
int first_field_idx;
first_field_idx = cols [MONO_TYPEDEF_FIELD_LIST] - 1;
mono_class_set_first_field_idx (klass, first_field_idx);
int first_method_idx;
first_method_idx = cols [MONO_TYPEDEF_METHOD_LIST] - 1;
mono_class_set_first_method_idx (klass, first_method_idx);
if (table_info_get_rows (tt) > tidx) {
mono_metadata_decode_row (tt, tidx, cols_next, MONO_TYPEDEF_SIZE);
field_last = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
method_last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
} else {
field_last = table_info_get_rows (&image->tables [MONO_TABLE_FIELD]);
method_last = table_info_get_rows (&image->tables [MONO_TABLE_METHOD]);
}
if (cols [MONO_TYPEDEF_FIELD_LIST] &&
cols [MONO_TYPEDEF_FIELD_LIST] <= table_info_get_rows (&image->tables [MONO_TABLE_FIELD]))
mono_class_set_field_count (klass, field_last - first_field_idx);
if (cols [MONO_TYPEDEF_METHOD_LIST] <= table_info_get_rows (&image->tables [MONO_TABLE_METHOD]))
mono_class_set_method_count (klass, method_last - first_method_idx);
}
/* reserve space to store vector pointer in arrays */
if (mono_is_corlib_image (image) && !strcmp (nspace, "System") && !strcmp (name, "Array")) {
klass->instance_size += 2 * TARGET_SIZEOF_VOID_P;
/* TODO: check that array has 0 non-const fields */
}
if (klass->enumtype) {
MonoType *enum_basetype = mono_class_find_enum_basetype (klass, error);
if (!enum_basetype) {
/*set it to a default value as the whole runtime can't handle this to be null*/
klass->cast_class = klass->element_class = mono_defaults.int32_class;
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
klass->cast_class = klass->element_class = mono_class_from_mono_type_internal (enum_basetype);
}
/*
* If we're a generic type definition, load the constraints.
* We must do this after the class has been constructed to make certain recursive scenarios
* work.
*/
if (mono_class_is_gtd (klass) && !mono_metadata_load_generic_param_constraints_checked (image, type_token, mono_class_get_generic_container (klass), error)) {
mono_class_set_type_load_failure (klass, "Could not load generic parameter constrains due to %s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
if (klass->image->assembly_name && !strcmp (klass->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
if (!strncmp (name, "Vector", 6))
klass->simd_type = !strcmp (name + 6, "2d") || !strcmp (name + 6, "2ul") || !strcmp (name + 6, "2l") || !strcmp (name + 6, "4f") || !strcmp (name + 6, "4ui") || !strcmp (name + 6, "4i") || !strcmp (name + 6, "8s") || !strcmp (name + 6, "8us") || !strcmp (name + 6, "16b") || !strcmp (name + 6, "16sb");
} else if (klass->image->assembly_name && !strcmp (klass->image->assembly_name, "System.Numerics") && !strcmp (nspace, "System.Numerics")) {
/* The JIT can't handle SIMD types with != 16 size yet */
//if (!strcmp (name, "Vector2") || !strcmp (name, "Vector3") || !strcmp (name, "Vector4"))
if (!strcmp (name, "Vector4"))
klass->simd_type = 1;
}
// compute is_byreflike
if (m_class_is_valuetype (klass))
if (class_has_isbyreflike_attribute (klass))
klass->is_byreflike = 1;
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_loaded, (klass));
return klass;
parent_failure:
if (mono_class_is_gtd (klass))
disable_gclass_recording (discard_gclass_due_to_failure, klass);
mono_class_setup_mono_type (klass);
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
static void
mono_generic_class_setup_parent (MonoClass *klass, MonoClass *gtd)
{
if (gtd->parent) {
ERROR_DECL (error);
MonoGenericClass *gclass = mono_class_get_generic_class (klass);
klass->parent = mono_class_inflate_generic_class_checked (gtd->parent, mono_generic_class_get_context (gclass), error);
if (!is_ok (error)) {
/*Set parent to something safe as the runtime doesn't handle well this kind of failure.*/
klass->parent = mono_defaults.object_class;
mono_class_set_type_load_failure (klass, "Parent is a generic type instantiation that failed due to: %s", mono_error_get_message (error));
mono_error_cleanup (error);
}
}
mono_loader_lock ();
if (klass->parent)
mono_class_setup_parent (klass, klass->parent);
if (klass->enumtype) {
klass->cast_class = gtd->cast_class;
klass->element_class = gtd->element_class;
}
mono_loader_unlock ();
}
struct FoundAttrUD {
/* inputs */
const char *nspace;
const char *name;
gboolean in_corlib;
/* output */
gboolean has_attr;
};
static gboolean
has_wellknown_attribute_func (MonoImage *image, guint32 typeref_scope_token, const char *nspace, const char *name, guint32 method_token, gpointer user_data)
{
struct FoundAttrUD *has_attr = (struct FoundAttrUD *)user_data;
if (!strcmp (name, has_attr->name) && !strcmp (nspace, has_attr->nspace)) {
has_attr->has_attr = TRUE;
return TRUE;
}
/* TODO: use typeref_scope_token to check that attribute comes from
* corlib if in_corlib is TRUE, without triggering an assembly load.
* If we're inside corlib, expect the scope to be
* MONO_RESOLUTION_SCOPE_MODULE I think, if we're outside it'll be an
* MONO_RESOLUTION_SCOPE_ASSEMBLYREF and we'll need to check the
* name.*/
return FALSE;
}
static gboolean
class_has_wellknown_attribute (MonoClass *klass, const char *nspace, const char *name, gboolean in_corlib)
{
struct FoundAttrUD has_attr;
has_attr.nspace = nspace;
has_attr.name = name;
has_attr.in_corlib = in_corlib;
has_attr.has_attr = FALSE;
mono_class_metadata_foreach_custom_attr (klass, has_wellknown_attribute_func, &has_attr);
return has_attr.has_attr;
}
static gboolean
method_has_wellknown_attribute (MonoMethod *method, const char *nspace, const char *name, gboolean in_corlib)
{
struct FoundAttrUD has_attr;
has_attr.nspace = nspace;
has_attr.name = name;
has_attr.in_corlib = in_corlib;
has_attr.has_attr = FALSE;
mono_method_metadata_foreach_custom_attr (method, has_wellknown_attribute_func, &has_attr);
return has_attr.has_attr;
}
static gboolean
class_has_isbyreflike_attribute (MonoClass *klass)
{
return class_has_wellknown_attribute (klass, "System.Runtime.CompilerServices", "IsByRefLikeAttribute", TRUE);
}
gboolean
mono_class_setup_method_has_preserve_base_overrides_attribute (MonoMethod *method)
{
MonoImage *image = m_class_get_image (method->klass);
/* FIXME: implement well known attribute check for dynamic images */
if (image_is_dynamic (image))
return FALSE;
return method_has_wellknown_attribute (method, "System.Runtime.CompilerServices", "PreserveBaseOverridesAttribute", TRUE);
}
static gboolean
check_valid_generic_inst_arguments (MonoGenericInst *inst, MonoError *error)
{
for (int i = 0; i < inst->type_argc; i++) {
if (!mono_type_is_valid_generic_argument (inst->type_argv [i])) {
char *type_name = mono_type_full_name (inst->type_argv [i]);
mono_error_set_invalid_program (error, "generic type cannot be instantiated with type '%s'", type_name);
g_free (type_name);
return FALSE;
}
}
return TRUE;
}
/*
* Create the `MonoClass' for an instantiation of a generic type.
* We only do this if we actually need it.
* This will sometimes return a GTD due to checking the cached_class.
*/
MonoClass*
mono_class_create_generic_inst (MonoGenericClass *gclass)
{
MonoClass *klass, *gklass;
if (gclass->cached_class)
return gclass->cached_class;
klass = (MonoClass *)mono_mem_manager_alloc0 ((MonoMemoryManager*)gclass->owner, sizeof (MonoClassGenericInst));
gklass = gclass->container_class;
if (gklass->nested_in) {
/* The nested_in type should not be inflated since it's possible to produce a nested type with less generic arguments*/
klass->nested_in = gklass->nested_in;
}
klass->name = gklass->name;
klass->name_space = gklass->name_space;
klass->image = gklass->image;
klass->type_token = gklass->type_token;
klass->class_kind = MONO_CLASS_GINST;
//FIXME add setter
((MonoClassGenericInst*)klass)->generic_class = gclass;
klass->_byval_arg.type = MONO_TYPE_GENERICINST;
klass->this_arg.type = m_class_get_byval_arg (klass)->type;
klass->this_arg.data.generic_class = klass->_byval_arg.data.generic_class = gclass;
klass->this_arg.byref__ = TRUE;
klass->enumtype = gklass->enumtype;
klass->valuetype = gklass->valuetype;
if (gklass->image->assembly_name && !strcmp (gklass->image->assembly_name, "System.Numerics.Vectors") && !strcmp (gklass->name_space, "System.Numerics") && !strcmp (gklass->name, "Vector`1")) {
g_assert (gclass->context.class_inst);
g_assert (gclass->context.class_inst->type_argc > 0);
if (mono_type_is_primitive (gclass->context.class_inst->type_argv [0]))
klass->simd_type = 1;
}
if (mono_is_corlib_image (gklass->image) &&
(!strcmp (gklass->name, "Vector`1") || !strcmp (gklass->name, "Vector64`1") || !strcmp (gklass->name, "Vector128`1") || !strcmp (gklass->name, "Vector256`1"))) {
MonoType *etype = gclass->context.class_inst->type_argv [0];
if (mono_type_is_primitive (etype) && etype->type != MONO_TYPE_CHAR && etype->type != MONO_TYPE_BOOLEAN)
klass->simd_type = 1;
}
klass->is_array_special_interface = gklass->is_array_special_interface;
klass->cast_class = klass->element_class = klass;
if (m_class_is_valuetype (klass)) {
klass->is_byreflike = gklass->is_byreflike;
}
if (gclass->is_dynamic) {
/*
* We don't need to do any init workf with unbaked typebuilders. Generic instances created at this point will be later unregistered and/or fixed.
* This is to avoid work that would probably give wrong results as fields change as we build the TypeBuilder.
* See remove_instantiations_of_and_ensure_contents in reflection.c and its usage in reflection.c to understand the fixup stage of SRE banking.
*/
if (!gklass->wastypebuilder)
klass->inited = 1;
if (klass->enumtype) {
/*
* For enums, gklass->fields might not been set, but instance_size etc. is
* already set in mono_reflection_create_internal_class (). For non-enums,
* these will be computed normally in mono_class_layout_fields ().
*/
klass->instance_size = gklass->instance_size;
klass->sizes.class_size = gklass->sizes.class_size;
klass->size_inited = 1;
}
}
{
ERROR_DECL (error_inst);
if (!check_valid_generic_inst_arguments (gclass->context.class_inst, error_inst)) {
char *gklass_name = mono_type_get_full_name (gklass);
mono_class_set_type_load_failure (klass, "Could not instantiate %s due to %s", gklass_name, mono_error_get_message (error_inst));
g_free (gklass_name);
mono_error_cleanup (error_inst);
}
}
mono_loader_lock ();
if (gclass->cached_class) {
mono_loader_unlock ();
return gclass->cached_class;
}
if (record_gclass_instantiation > 0)
gclass_recorded_list = g_slist_append (gclass_recorded_list, klass);
if (mono_class_is_nullable (klass))
klass->cast_class = klass->element_class = mono_class_get_nullable_param_internal (klass);
MONO_PROFILER_RAISE (class_loading, (klass));
mono_generic_class_setup_parent (klass, gklass);
if (gclass->is_dynamic)
mono_class_setup_supertypes (klass);
mono_memory_barrier ();
gclass->cached_class = klass;
MONO_PROFILER_RAISE (class_loaded, (klass));
++class_ginst_count;
inflated_classes_size += sizeof (MonoClassGenericInst);
mono_loader_unlock ();
return klass;
}
/*
* For a composite class like uint32[], uint32*, set MonoClass:cast_class to the corresponding "intermediate type" (for
* arrays) or "verification type" (for pointers) in the sense of ECMA I.8.7.3. This will be used by
* mono_class_is_assignable_from.
*
* Assumes MonoClass:cast_class is already set (for example if it's an array of
* some enum) and adjusts it.
*/
static void
class_composite_fixup_cast_class (MonoClass *klass, gboolean for_ptr)
{
switch (m_class_get_byval_arg (m_class_get_cast_class (klass))->type) {
case MONO_TYPE_BOOLEAN:
if (!for_ptr)
break;
klass->cast_class = mono_defaults.byte_class;
break;
case MONO_TYPE_I1:
klass->cast_class = mono_defaults.byte_class;
break;
case MONO_TYPE_U2:
klass->cast_class = mono_defaults.int16_class;
break;
case MONO_TYPE_U4:
#if TARGET_SIZEOF_VOID_P == 4
case MONO_TYPE_I:
case MONO_TYPE_U:
#endif
klass->cast_class = mono_defaults.int32_class;
break;
case MONO_TYPE_U8:
#if TARGET_SIZEOF_VOID_P == 8
case MONO_TYPE_I:
case MONO_TYPE_U:
#endif
klass->cast_class = mono_defaults.int64_class;
break;
default:
break;
}
}
static gboolean
class_kind_may_contain_generic_instances (MonoTypeKind kind)
{
/* classes of type generic inst may contain generic arguments from other images,
* as well as arrays and pointers whose element types (recursively) may be a generic inst */
return (kind == MONO_CLASS_GINST || kind == MONO_CLASS_ARRAY || kind == MONO_CLASS_POINTER);
}
/**
* mono_class_create_bounded_array:
* \param element_class element class
* \param rank the dimension of the array class
* \param bounded whenever the array has non-zero bounds
* \returns A class object describing the array with element type \p element_type and
* dimension \p rank.
*/
MonoClass *
mono_class_create_bounded_array (MonoClass *eclass, guint32 rank, gboolean bounded)
{
MonoImage *image;
MonoClass *klass, *cached, *k;
MonoClass *parent = NULL;
GSList *list, *rootlist = NULL;
int nsize;
char *name;
MonoMemoryManager *mm;
if (rank > 1)
/* bounded only matters for one-dimensional arrays */
bounded = FALSE;
image = eclass->image;
// FIXME: Optimize this
mm = class_kind_may_contain_generic_instances ((MonoTypeKind)eclass->class_kind) ? mono_metadata_get_mem_manager_for_class (eclass) : NULL;
/* Check cache */
cached = NULL;
if (rank == 1 && !bounded) {
if (mm) {
mono_mem_manager_lock (mm);
if (!mm->szarray_cache)
mm->szarray_cache = g_hash_table_new_full (mono_aligned_addr_hash, NULL, NULL, NULL);
cached = (MonoClass *)g_hash_table_lookup (mm->szarray_cache, eclass);
mono_mem_manager_unlock (mm);
} else {
/*
* This case is very frequent not just during compilation because of calls
* from mono_class_from_mono_type_internal (), mono_array_new (),
* Array:CreateInstance (), etc, so use a separate cache + a separate lock.
*/
mono_os_mutex_lock (&image->szarray_cache_lock);
if (!image->szarray_cache)
image->szarray_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
cached = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
}
} else {
if (mm) {
mono_mem_manager_lock (mm);
if (!mm->array_cache)
mm->array_cache = g_hash_table_new_full (mono_aligned_addr_hash, NULL, NULL, NULL);
rootlist = (GSList *)g_hash_table_lookup (mm->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
mono_mem_manager_unlock (mm);
} else {
mono_loader_lock ();
if (!image->array_cache)
image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
rootlist = (GSList *)g_hash_table_lookup (image->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
mono_loader_unlock ();
}
}
if (cached)
return cached;
parent = mono_defaults.array_class;
if (!parent->inited)
mono_class_init_internal (parent);
klass = mm ? (MonoClass *)mono_mem_manager_alloc0 (mm, sizeof (MonoClassArray)) : (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClassArray));
klass->image = image;
klass->name_space = eclass->name_space;
klass->class_kind = MONO_CLASS_ARRAY;
nsize = strlen (eclass->name);
int maxrank = MIN (rank, 32);
name = (char *)g_malloc (nsize + 2 + maxrank + 1);
memcpy (name, eclass->name, nsize);
name [nsize] = '[';
if (maxrank > 1)
memset (name + nsize + 1, ',', maxrank - 1);
if (bounded)
name [nsize + maxrank] = '*';
name [nsize + maxrank + bounded] = ']';
name [nsize + maxrank + bounded + 1] = 0;
klass->name = mm ? mono_mem_manager_strdup (mm, name) : mono_image_strdup (image, name);
g_free (name);
klass->type_token = 0;
klass->parent = parent;
klass->instance_size = mono_class_instance_size (klass->parent);
klass->rank = rank;
klass->element_class = eclass;
if (m_class_get_byval_arg (eclass)->type == MONO_TYPE_TYPEDBYREF) {
/*Arrays of those two types are invalid.*/
ERROR_DECL (prepared_error);
mono_error_set_invalid_program (prepared_error, "Arrays of System.TypedReference types are invalid.");
mono_class_set_failure (klass, mono_error_box (prepared_error, klass->image));
mono_error_cleanup (prepared_error);
} else if (m_class_is_byreflike (eclass)) {
/* .NET Core throws a type load exception: "Could not create array type 'fullname[]'" */
char *full_name = mono_type_get_full_name (eclass);
mono_class_set_type_load_failure (klass, "Could not create array type '%s[]'", full_name);
g_free (full_name);
} else if (eclass->enumtype && !mono_class_enum_basetype_internal (eclass)) {
MonoGCHandle ref_info_handle = mono_class_get_ref_info_handle (eclass);
if (!ref_info_handle || eclass->wastypebuilder) {
g_warning ("Only incomplete TypeBuilder objects are allowed to be an enum without base_type");
g_assert (ref_info_handle && !eclass->wastypebuilder);
}
/* element_size -1 is ok as this is not an instantitable type*/
klass->sizes.element_size = -1;
} else
klass->sizes.element_size = -1;
mono_class_setup_supertypes (klass);
if (mono_class_is_ginst (eclass))
mono_class_init_internal (eclass);
if (!eclass->size_inited)
mono_class_setup_fields (eclass);
mono_class_set_type_load_failure_causedby_class (klass, eclass, "Could not load array element type");
/*FIXME we fail the array type, but we have to let other fields be set.*/
klass->has_references = MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (eclass)) || m_class_has_references (eclass)? TRUE: FALSE;
if (eclass->enumtype)
klass->cast_class = eclass->element_class;
else
klass->cast_class = eclass;
class_composite_fixup_cast_class (klass, FALSE);
if ((rank > 1) || bounded) {
MonoArrayType *at = mm ? (MonoArrayType *)mono_mem_manager_alloc0 (mm, sizeof (MonoArrayType)) : (MonoArrayType *)mono_image_alloc0 (image, sizeof (MonoArrayType));
klass->_byval_arg.type = MONO_TYPE_ARRAY;
klass->_byval_arg.data.array = at;
at->eklass = eclass;
at->rank = rank;
/* FIXME: complete.... */
} else {
klass->_byval_arg.type = MONO_TYPE_SZARRAY;
klass->_byval_arg.data.klass = eclass;
}
klass->this_arg = klass->_byval_arg;
klass->this_arg.byref__ = 1;
if (rank > 32) {
ERROR_DECL (prepared_error);
name = mono_type_get_full_name (klass);
mono_error_set_type_load_class (prepared_error, klass, "%s has too many dimensions.", name);
mono_class_set_failure (klass, mono_error_box (prepared_error, klass->image));
mono_error_cleanup (prepared_error);
g_free (name);
}
mono_loader_lock ();
/* Check cache again */
cached = NULL;
if (rank == 1 && !bounded) {
if (mm) {
mono_mem_manager_lock (mm);
cached = (MonoClass *)g_hash_table_lookup (mm->szarray_cache, eclass);
mono_mem_manager_unlock (mm);
} else {
mono_os_mutex_lock (&image->szarray_cache_lock);
cached = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
}
} else {
if (mm) {
mono_mem_manager_lock (mm);
rootlist = (GSList *)g_hash_table_lookup (mm->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
mono_mem_manager_unlock (mm);
} else {
rootlist = (GSList *)g_hash_table_lookup (image->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
}
}
if (cached) {
mono_loader_unlock ();
return cached;
}
MONO_PROFILER_RAISE (class_loading, (klass));
UnlockedAdd (&classes_size, sizeof (MonoClassArray));
++class_array_count;
if (rank == 1 && !bounded) {
if (mm) {
mono_mem_manager_lock (mm);
g_hash_table_insert (mm->szarray_cache, eclass, klass);
mono_mem_manager_unlock (mm);
} else {
mono_os_mutex_lock (&image->szarray_cache_lock);
g_hash_table_insert (image->szarray_cache, eclass, klass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
}
} else {
if (mm) {
mono_mem_manager_lock (mm);
list = g_slist_append (rootlist, klass);
g_hash_table_insert (mm->array_cache, eclass, list);
mono_mem_manager_unlock (mm);
} else {
list = g_slist_append (rootlist, klass);
g_hash_table_insert (image->array_cache, eclass, list);
}
}
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_loaded, (klass));
return klass;
}
/**
* mono_class_create_array:
* \param element_class element class
* \param rank the dimension of the array class
* \returns A class object describing the array with element type \p element_type and
* dimension \p rank.
*/
MonoClass *
mono_class_create_array (MonoClass *eclass, guint32 rank)
{
return mono_class_create_bounded_array (eclass, rank, FALSE);
}
// This is called by mono_class_create_generic_parameter when a new class must be created.
static MonoClass*
make_generic_param_class (MonoGenericParam *param)
{
MonoClass *klass, **ptr;
int count, pos, i, min_align;
MonoGenericParamInfo *pinfo = mono_generic_param_info (param);
MonoGenericContainer *container = mono_generic_param_owner (param);
g_assert_checked (container);
MonoImage *image = mono_get_image_for_generic_param (param);
gboolean is_mvar = container->is_method;
gboolean is_anonymous = container->is_anonymous;
klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClassGenericParam));
klass->class_kind = MONO_CLASS_GPARAM;
UnlockedAdd (&classes_size, sizeof (MonoClassGenericParam));
UnlockedIncrement (&class_gparam_count);
if (!is_anonymous) {
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name , pinfo->name );
} else {
int n = mono_generic_param_num (param);
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->name , mono_make_generic_name_string (image, n) );
}
if (is_anonymous) {
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , "" );
} else if (is_mvar) {
MonoMethod *omethod = container->owner.method;
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , (omethod && omethod->klass) ? omethod->klass->name_space : "" );
} else {
MonoClass *oklass = container->owner.klass;
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , oklass ? oklass->name_space : "" );
}
MONO_PROFILER_RAISE (class_loading, (klass));
// Count non-NULL items in pinfo->constraints
count = 0;
if (!is_anonymous)
for (ptr = pinfo->constraints; ptr && *ptr; ptr++, count++)
;
pos = 0;
if ((count > 0) && !MONO_CLASS_IS_INTERFACE_INTERNAL (pinfo->constraints [0])) {
CHECKED_METADATA_WRITE_PTR ( klass->parent , pinfo->constraints [0] );
pos++;
} else if (pinfo && pinfo->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) {
CHECKED_METADATA_WRITE_PTR ( klass->parent , mono_class_load_from_name (mono_defaults.corlib, "System", "ValueType") );
} else {
CHECKED_METADATA_WRITE_PTR ( klass->parent , mono_defaults.object_class );
}
if (count - pos > 0) {
klass->interface_count = count - pos;
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->interfaces , (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos)) );
klass->interfaces_inited = TRUE;
for (i = pos; i < count; i++)
CHECKED_METADATA_WRITE_PTR ( klass->interfaces [i - pos] , pinfo->constraints [i] );
}
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->image , image );
klass->inited = TRUE;
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->cast_class , klass );
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->element_class , klass );
MonoTypeEnum t = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR;
klass->_byval_arg.type = t;
klass->this_arg.type = t;
CHECKED_METADATA_WRITE_PTR ( klass->this_arg.data.generic_param , param );
CHECKED_METADATA_WRITE_PTR ( klass->_byval_arg.data.generic_param , param );
klass->this_arg.byref__ = TRUE;
/* We don't use type_token for VAR since only classes can use it (not arrays, pointer, VARs, etc) */
klass->sizes.generic_param_token = !is_anonymous ? pinfo->token : 0;
if (param->gshared_constraint) {
MonoClass *constraint_class = mono_class_from_mono_type_internal (param->gshared_constraint);
mono_class_init_sizes (constraint_class);
klass->has_references = m_class_has_references (constraint_class);
}
/*
* This makes sure the the value size of this class is equal to the size of the types the gparam is
* constrained to, the JIT depends on this.
*/
klass->instance_size = MONO_ABI_SIZEOF (MonoObject) + mono_type_size (m_class_get_byval_arg (klass), &min_align);
klass->min_align = min_align;
mono_memory_barrier ();
klass->size_inited = 1;
mono_class_setup_supertypes (klass);
if (count - pos > 0) {
mono_class_setup_vtable (klass->parent);
if (mono_class_has_failure (klass->parent))
mono_class_set_type_load_failure (klass, "Failed to setup parent interfaces");
else
mono_class_setup_interface_offsets_internal (klass, klass->parent->vtable_size, TRUE);
}
return klass;
}
/*
* LOCKING: Acquires the image lock (@image).
*/
MonoClass *
mono_class_create_generic_parameter (MonoGenericParam *param)
{
MonoImage *image = mono_get_image_for_generic_param (param);
MonoGenericParamInfo *pinfo = mono_generic_param_info (param);
MonoClass *klass, *klass2;
// If a klass already exists for this object and is cached, return it.
klass = pinfo->pklass;
if (klass)
return klass;
// Create a new klass
klass = make_generic_param_class (param);
// Now we need to cache the klass we created.
// But since we wait to grab the lock until after creating the klass, we need to check to make sure
// another thread did not get in and cache a klass ahead of us. In that case, return their klass
// and allow our newly-created klass object to just leak.
mono_memory_barrier ();
mono_image_lock (image);
// Here "klass2" refers to the klass potentially created by the other thread.
klass2 = pinfo->pklass;
if (klass2) {
klass = klass2;
} else {
pinfo->pklass = klass;
}
mono_image_unlock (image);
/* FIXME: Should this go inside 'make_generic_param_klass'? */
if (klass2)
MONO_PROFILER_RAISE (class_failed, (klass2));
else
MONO_PROFILER_RAISE (class_loaded, (klass));
return klass;
}
/**
* mono_class_create_ptr:
*/
MonoClass *
mono_class_create_ptr (MonoType *type)
{
MonoClass *result;
MonoClass *el_class;
MonoImage *image;
char *name;
MonoMemoryManager *mm;
el_class = mono_class_from_mono_type_internal (type);
image = el_class->image;
// FIXME: Optimize this
mm = class_kind_may_contain_generic_instances ((MonoTypeKind)el_class->class_kind) ? mono_metadata_get_mem_manager_for_class (el_class) : NULL;
if (mm) {
mono_mem_manager_lock (mm);
if (!mm->ptr_cache)
mm->ptr_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
result = (MonoClass *)g_hash_table_lookup (mm->ptr_cache, el_class);
mono_mem_manager_unlock (mm);
if (result)
return result;
} else {
mono_image_lock (image);
if (image->ptr_cache) {
if ((result = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) {
mono_image_unlock (image);
return result;
}
}
mono_image_unlock (image);
}
result = mm ? (MonoClass *)mono_mem_manager_alloc0 (mm, sizeof (MonoClassPointer)) : (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClassPointer));
UnlockedAdd (&classes_size, sizeof (MonoClassPointer));
++class_pointer_count;
result->parent = NULL; /* no parent for PTR types */
result->name_space = el_class->name_space;
name = g_strdup_printf ("%s*", el_class->name);
result->name = mm ? mono_mem_manager_strdup (mm, name) : mono_image_strdup (image, name);
result->class_kind = MONO_CLASS_POINTER;
g_free (name);
MONO_PROFILER_RAISE (class_loading, (result));
result->image = el_class->image;
result->inited = TRUE;
result->instance_size = MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer);
result->min_align = sizeof (gpointer);
result->element_class = el_class;
result->blittable = TRUE;
if (el_class->enumtype)
result->cast_class = el_class->element_class;
else
result->cast_class = el_class;
class_composite_fixup_cast_class (result, TRUE);
result->this_arg.type = result->_byval_arg.type = MONO_TYPE_PTR;
result->this_arg.data.type = result->_byval_arg.data.type = m_class_get_byval_arg (el_class);
result->this_arg.byref__ = TRUE;
mono_class_setup_supertypes (result);
if (mm) {
mono_mem_manager_lock (mm);
MonoClass *result2;
result2 = (MonoClass *)g_hash_table_lookup (mm->ptr_cache, el_class);
if (!result2)
g_hash_table_insert (mm->ptr_cache, el_class, result);
mono_mem_manager_unlock (mm);
if (result2) {
MONO_PROFILER_RAISE (class_failed, (result));
return result2;
}
} else {
mono_image_lock (image);
if (image->ptr_cache) {
MonoClass *result2;
if ((result2 = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) {
mono_image_unlock (image);
MONO_PROFILER_RAISE (class_failed, (result));
return result2;
}
} else {
image->ptr_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
}
g_hash_table_insert (image->ptr_cache, el_class, result);
mono_image_unlock (image);
}
MONO_PROFILER_RAISE (class_loaded, (result));
return result;
}
MonoClass *
mono_class_create_fnptr (MonoMethodSignature *sig)
{
MonoClass *result, *cached;
static GHashTable *ptr_hash = NULL;
/* FIXME: These should be allocate from a mempool as well, but which one ? */
mono_loader_lock ();
if (!ptr_hash)
ptr_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
cached = (MonoClass *)g_hash_table_lookup (ptr_hash, sig);
mono_loader_unlock ();
if (cached)
return cached;
result = g_new0 (MonoClass, 1);
result->parent = NULL; /* no parent for PTR types */
result->name_space = "System";
result->name = "MonoFNPtrFakeClass";
result->class_kind = MONO_CLASS_POINTER;
result->image = mono_defaults.corlib; /* need to fix... */
result->instance_size = MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer);
result->min_align = sizeof (gpointer);
result->cast_class = result->element_class = result;
result->this_arg.type = result->_byval_arg.type = MONO_TYPE_FNPTR;
result->this_arg.data.method = result->_byval_arg.data.method = sig;
result->this_arg.byref__ = TRUE;
result->blittable = TRUE;
result->inited = TRUE;
mono_class_setup_supertypes (result);
mono_loader_lock ();
cached = (MonoClass *)g_hash_table_lookup (ptr_hash, sig);
if (cached) {
g_free (result);
mono_loader_unlock ();
return cached;
}
MONO_PROFILER_RAISE (class_loading, (result));
UnlockedAdd (&classes_size, sizeof (MonoClassPointer));
++class_pointer_count;
g_hash_table_insert (ptr_hash, sig, result);
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_loaded, (result));
return result;
}
static gboolean
method_is_reabstracted (guint16 flags)
{
if ((flags & METHOD_ATTRIBUTE_ABSTRACT && flags & METHOD_ATTRIBUTE_FINAL))
return TRUE;
return FALSE;
}
/**
* mono_class_setup_count_virtual_methods:
*
* Return the number of virtual methods.
* Even for interfaces we can't simply return the number of methods as all CLR types are allowed to have static methods.
* Return -1 on failure.
* FIXME It would be nice if this information could be cached somewhere.
*/
int
mono_class_setup_count_virtual_methods (MonoClass *klass)
{
int i, mcount, vcount = 0;
guint32 flags;
klass = mono_class_get_generic_type_definition (klass); /*We can find this information by looking at the GTD*/
if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass)) {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass))
return -1;
mcount = mono_class_get_method_count (klass);
for (i = 0; i < mcount; ++i) {
flags = klass->methods [i]->flags;
if ((flags & METHOD_ATTRIBUTE_VIRTUAL)) {
if (method_is_reabstracted (flags))
continue;
++vcount;
}
}
} else {
int first_idx = mono_class_get_first_method_idx (klass);
mcount = mono_class_get_method_count (klass);
for (i = 0; i < mcount; ++i) {
flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, first_idx + i, MONO_METHOD_FLAGS);
if ((flags & METHOD_ATTRIBUTE_VIRTUAL)) {
if (method_is_reabstracted (flags))
continue;
++vcount;
}
}
}
return vcount;
}
#ifdef COMPRESSED_INTERFACE_BITMAP
/*
* Compressed interface bitmap design.
*
* Interface bitmaps take a large amount of memory, because their size is
* linear with the maximum interface id assigned in the process (each interface
* is assigned a unique id as it is loaded). The number of interface classes
* is high because of the many implicit interfaces implemented by arrays (we'll
* need to lazy-load them in the future).
* Most classes implement a very small number of interfaces, so the bitmap is
* sparse. This bitmap needs to be checked by interface casts, so access to the
* needed bit must be fast and doable with few jit instructions.
*
* The current compression format is as follows:
* *) it is a sequence of one or more two-byte elements
* *) the first byte in the element is the count of empty bitmap bytes
* at the current bitmap position
* *) the second byte in the element is an actual bitmap byte at the current
* bitmap position
*
* As an example, the following compressed bitmap bytes:
* 0x07 0x01 0x00 0x7
* correspond to the following bitmap:
* 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x07
*
* Each two-byte element can represent up to 2048 bitmap bits, but as few as a single
* bitmap byte for non-sparse sequences. In practice the interface bitmaps created
* during a gmcs bootstrap are reduced to less tha 5% of the original size.
*/
/**
* mono_compress_bitmap:
* \param dest destination buffer
* \param bitmap bitmap buffer
* \param size size of \p bitmap in bytes
*
* This is a mono internal function.
* The \p bitmap data is compressed into a format that is small but
* still searchable in few instructions by the JIT and runtime.
* The compressed data is stored in the buffer pointed to by the
* \p dest array. Passing a NULL value for \p dest allows to just compute
* the size of the buffer.
* This compression algorithm assumes the bits set in the bitmap are
* few and far between, like in interface bitmaps.
* \returns The size of the compressed bitmap in bytes.
*/
int
mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size)
{
int numz = 0;
int res = 0;
const uint8_t *end = bitmap + size;
while (bitmap < end) {
if (*bitmap || numz == 255) {
if (dest) {
*dest++ = numz;
*dest++ = *bitmap;
}
res += 2;
numz = 0;
bitmap++;
continue;
}
bitmap++;
numz++;
}
if (numz) {
res += 2;
if (dest) {
*dest++ = numz;
*dest++ = 0;
}
}
return res;
}
/**
* mono_class_interface_match:
* \param bitmap a compressed bitmap buffer
* \param id the index to check in the bitmap
*
* This is a mono internal function.
* Checks if a bit is set in a compressed interface bitmap. \p id must
* be already checked for being smaller than the maximum id encoded in the
* bitmap.
*
* \returns A non-zero value if bit \p id is set in the bitmap \p bitmap,
* FALSE otherwise.
*/
int
mono_class_interface_match (const uint8_t *bitmap, int id)
{
while (TRUE) {
id -= bitmap [0] * 8;
if (id < 8) {
if (id < 0)
return 0;
return bitmap [1] & (1 << id);
}
bitmap += 2;
id -= 8;
}
}
#endif
static char*
concat_two_strings_with_zero (MonoImage *image, const char *s1, const char *s2)
{
int null_length = strlen ("(null)");
int len = (s1 ? strlen (s1) : null_length) + (s2 ? strlen (s2) : null_length) + 2;
char *s = (char *)mono_image_alloc (image, len);
int result;
result = g_snprintf (s, len, "%s%c%s", s1 ? s1 : "(null)", '\0', s2 ? s2 : "(null)");
g_assert (result == len - 1);
return s;
}
static void
init_sizes_with_info (MonoClass *klass, MonoCachedClassInfo *cached_info)
{
if (cached_info) {
mono_loader_lock ();
klass->instance_size = cached_info->instance_size;
klass->sizes.class_size = cached_info->class_size;
klass->packing_size = cached_info->packing_size;
klass->min_align = cached_info->min_align;
klass->blittable = cached_info->blittable;
klass->has_references = cached_info->has_references;
klass->has_static_refs = cached_info->has_static_refs;
klass->no_special_static_fields = cached_info->no_special_static_fields;
klass->has_weak_fields = cached_info->has_weak_fields;
mono_loader_unlock ();
}
else {
if (!klass->size_inited)
mono_class_setup_fields (klass);
}
}
/*
* mono_class_init_sizes:
*
* Initializes the size related fields of @klass without loading all field data if possible.
* Sets the following fields in @klass:
* - instance_size
* - sizes.class_size
* - packing_size
* - min_align
* - blittable
* - has_references
* - has_static_refs
* - size_inited
* Can fail the class.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_init_sizes (MonoClass *klass)
{
MonoCachedClassInfo cached_info;
gboolean has_cached_info;
if (klass->size_inited)
return;
has_cached_info = mono_class_get_cached_class_info (klass, &cached_info);
init_sizes_with_info (klass, has_cached_info ? &cached_info : NULL);
}
static gboolean
class_has_references (MonoClass *klass)
{
mono_class_init_sizes (klass);
/*
* has_references is not set if this is called recursively, but this is not a problem since this is only used
* during field layout, and instance fields are initialized before static fields, and instance fields can't
* embed themselves.
*/
return klass->has_references;
}
static gboolean
type_has_references (MonoClass *klass, MonoType *ftype)
{
if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (klass, ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && class_has_references (mono_class_from_mono_type_internal (ftype)))))
return TRUE;
if (!m_type_is_byref (ftype) && (ftype->type == MONO_TYPE_VAR || ftype->type == MONO_TYPE_MVAR)) {
MonoGenericParam *gparam = ftype->data.generic_param;
if (gparam->gshared_constraint)
return class_has_references (mono_class_from_mono_type_internal (gparam->gshared_constraint));
}
return FALSE;
}
static gboolean
class_has_ref_fields (MonoClass *klass)
{
/*
* has_ref_fields is not set if this is called recursively, but this is not a problem since this is only used
* during field layout, and instance fields are initialized before static fields, and instance fields can't
* embed themselves.
*/
return klass->has_ref_fields;
}
static gboolean
class_is_byreference (MonoClass* klass)
{
const char* klass_name_space = m_class_get_name_space (klass);
const char* klass_name = m_class_get_name (klass);
MonoImage* klass_image = m_class_get_image (klass);
gboolean in_corlib = klass_image == mono_defaults.corlib;
if (in_corlib &&
!strcmp (klass_name_space, "System") &&
!strcmp (klass_name, "ByReference`1")) {
return TRUE;
}
return FALSE;
}
static gboolean
type_has_ref_fields (MonoType *ftype)
{
if (m_type_is_byref (ftype) || (MONO_TYPE_ISSTRUCT (ftype) && class_has_ref_fields (mono_class_from_mono_type_internal (ftype))))
return TRUE;
/* Check for the ByReference`1 type */
if (MONO_TYPE_ISSTRUCT (ftype)) {
MonoClass* klass = mono_class_from_mono_type_internal (ftype);
return class_is_byreference (klass);
}
return FALSE;
}
/**
* mono_class_is_gparam_with_nonblittable_parent:
* \param klass a generic parameter
*
* \returns TRUE if \p klass is definitely not blittable.
*
* A parameter is definitely not blittable if it has the IL 'reference'
* constraint, or if it has a class specified as a parent. If it has an IL
* 'valuetype' constraint or no constraint at all or only interfaces as
* constraints, we return FALSE because the parameter may be instantiated both
* with blittable and non-blittable types.
*
* If the paramter is a generic sharing parameter, we look at its gshared_constraint->blittable bit.
*/
static gboolean
mono_class_is_gparam_with_nonblittable_parent (MonoClass *klass)
{
MonoType *type = m_class_get_byval_arg (klass);
g_assert (mono_type_is_generic_parameter (type));
MonoGenericParam *gparam = type->data.generic_param;
if ((mono_generic_param_info (gparam)->flags & GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT) != 0)
return TRUE;
if ((mono_generic_param_info (gparam)->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) != 0)
return FALSE;
if (gparam->gshared_constraint) {
MonoClass *constraint_class = mono_class_from_mono_type_internal (gparam->gshared_constraint);
return !m_class_is_blittable (constraint_class);
}
if (mono_generic_param_owner (gparam)->is_anonymous)
return FALSE;
/* We could have: T : U, U : Base. So have to follow the constraints. */
MonoClass *parent_class = mono_generic_param_get_base_type (klass);
g_assert (!MONO_CLASS_IS_INTERFACE_INTERNAL (parent_class));
/* Parent can only be: System.Object, System.ValueType or some specific base class.
*
* If the parent_class is ValueType, the valuetype constraint would be set, above, so
* we wouldn't get here.
*
* If there was a reference constraint, the parent_class would be System.Object,
* but we would have returned early above.
*
* So if we get here, there is either no base class constraint at all,
* in which case parent_class would be set to System.Object, or there is none at all.
*/
return parent_class != mono_defaults.object_class;
}
/**
* Checks if there are any overlapping object and non-object fields.
* The alignment of object reference fields is checked elswhere and this function assumes
* that all references are aligned correctly.
*
* \param layout_check A buffer to check which bytes hold object references or values
* \param klass Checked struct
* \param field_offsets Offsets of the klass' fields relative to the start of layout_check
* \param field_count Count of klass fields
* \param invalid_field_offset When the layout is invalid it will be set to the offset of the field which is invalid
*
* \return True if the layout of the struct is valid, otherwise false.
*/
static gboolean
validate_struct_fields_overlaps (guint8 *layout_check, int layout_size, MonoClass *klass, const int *field_offsets, const int field_count, int *invalid_field_offset)
{
MonoClassField *field;
MonoType *ftype;
int field_offset;
for (int i = 0; i < field_count && !mono_class_has_failure (klass); i++) {
// using mono_class_get_fields_internal isn't appropriate here because it will
// try to call mono_class_setup_fields which is what we're doing already
field = &m_class_get_fields (klass) [i];
field_offset = field_offsets [i];
if (!field)
continue;
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (mono_type_is_struct (ftype)) {
// recursively check the layout of the embedded struct
MonoClass *embedded_class = mono_class_from_mono_type_internal (ftype);
mono_class_setup_fields (embedded_class);
const int embedded_fields_count = mono_class_get_field_count (embedded_class);
int *embedded_offsets = g_new0 (int, embedded_fields_count);
for (int j = 0; j < embedded_fields_count; ++j) {
embedded_offsets [j] = field_offset + m_class_get_fields (embedded_class) [j].offset - MONO_ABI_SIZEOF (MonoObject);
}
gboolean is_valid = validate_struct_fields_overlaps (layout_check, layout_size, embedded_class, embedded_offsets, embedded_fields_count, invalid_field_offset);
g_free (embedded_offsets);
if (!is_valid) {
// overwrite whatever was in the invalid_field_offset with the offset of the currently checked field
// we want to return the outer most invalid field
*invalid_field_offset = field_offset;
return FALSE;
}
} else {
int align = 0;
int size = mono_type_size (field->type, &align);
guint8 type = type_has_references (klass, ftype) ? 1 : (m_type_is_byref (ftype) || class_is_byreference (klass)) ? 2 : 3;
// Mark the bytes used by this fields type based on if it contains references or not.
// Make sure there are no overlaps between object and non-object fields.
for (int j = 0; j < size; j++) {
int checked_byte = field_offset + j;
g_assert(checked_byte < layout_size);
if (layout_check [checked_byte] != 0 && layout_check [checked_byte] != type) {
*invalid_field_offset = field_offset;
return FALSE;
}
layout_check [checked_byte] = type;
}
}
}
return TRUE;
}
/*
* mono_class_layout_fields:
* @class: a class
* @base_instance_size: base instance size
* @packing_size:
*
* This contains the common code for computing the layout of classes and sizes.
* This should only be called from mono_class_setup_fields () and
* typebuilder_setup_fields ().
*
* LOCKING: Acquires the loader lock
*/
void
mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_size, int explicit_size, gboolean sre)
{
int i;
const int top = mono_class_get_field_count (klass);
guint32 layout = mono_class_get_flags (klass) & TYPE_ATTRIBUTE_LAYOUT_MASK;
guint32 pass, passes, real_size;
gboolean gc_aware_layout = FALSE;
gboolean has_static_fields = FALSE;
gboolean has_references = FALSE;
gboolean has_ref_fields = FALSE;
gboolean has_static_refs = FALSE;
MonoClassField *field;
gboolean blittable;
gboolean any_field_has_auto_layout;
int instance_size = base_instance_size;
int element_size = -1;
int class_size, min_align;
int *field_offsets;
gboolean *fields_has_references;
/*
* We want to avoid doing complicated work inside locks, so we compute all the required
* information and write it to @klass inside a lock.
*/
if (klass->fields_inited)
return;
if ((packing_size & 0xffffff00) != 0) {
mono_class_set_type_load_failure (klass, "Could not load struct '%s' with packing size %d >= 256", klass->name, packing_size);
return;
}
if (klass->parent) {
min_align = klass->parent->min_align;
/* we use | since it may have been set already */
has_references = klass->has_references | klass->parent->has_references;
has_ref_fields = klass->has_ref_fields | klass->parent->has_ref_fields;
} else {
min_align = 1;
}
/* We can't really enable 16 bytes alignment until the GC supports it.
The whole layout/instance size code must be reviewed because we do alignment calculation in terms of the
boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type.
Bug #506144 is an example of this issue.
if (klass->simd_type)
min_align = 16;
*/
/* Respect the specified packing size at least to the extent necessary to align double variables.
* This should avoid any GC problems, and will allow packing_size to be respected to support
* CreateSpan<T>
*/
min_align = MIN (MONO_ABI_ALIGNOF (double), MAX (min_align, packing_size));
/*
* When we do generic sharing we need to have layout
* information for open generic classes (either with a generic
* context containing type variables or with a generic
* container), so we don't return in that case anymore.
*/
if (klass->enumtype) {
for (i = 0; i < top; i++) {
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
klass->cast_class = klass->element_class = mono_class_from_mono_type_internal (field->type);
break;
}
}
if (!mono_class_enum_basetype_internal (klass)) {
mono_class_set_type_load_failure (klass, "The enumeration's base type is invalid.");
return;
}
}
/*
* Enable GC aware auto layout: in this mode, reference
* fields are grouped together inside objects, increasing collector
* performance.
* Requires that all classes whose layout is known to native code be annotated
* with [StructLayout (LayoutKind.Sequential)]
* Value types have gc_aware_layout disabled by default, as per
* what the default is for other runtimes.
*/
/* corlib is missing [StructLayout] directives in many places */
if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
if (!klass->valuetype)
gc_aware_layout = TRUE;
}
/* Compute klass->blittable and klass->any_field_has_auto_layout */
blittable = TRUE;
any_field_has_auto_layout = FALSE;
if (klass->parent) {
blittable = klass->parent->blittable;
any_field_has_auto_layout = klass->parent->any_field_has_auto_layout;
}
if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT && !(mono_is_corlib_image (klass->image) && !strcmp (klass->name_space, "System") && !strcmp (klass->name, "ValueType")) && top) {
blittable = FALSE;
any_field_has_auto_layout = TRUE; // If a type is auto-layout, treat it as having an auto-layout field in its layout.
}
for (i = 0; i < top; i++) {
field = &klass->fields [i];
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
if (blittable) {
if (m_type_is_byref (field->type) || MONO_TYPE_IS_REFERENCE (field->type)) {
blittable = FALSE;
} else if (mono_type_is_generic_parameter (field->type) &&
mono_class_is_gparam_with_nonblittable_parent (mono_class_from_mono_type_internal (field->type))) {
blittable = FALSE;
} else {
MonoClass *field_class = mono_class_from_mono_type_internal (field->type);
if (field_class) {
mono_class_setup_fields (field_class);
if (mono_class_has_failure (field_class)) {
ERROR_DECL (field_error);
mono_error_set_for_class_failure (field_error, field_class);
mono_class_set_type_load_failure (klass, "Could not set up field '%s' due to: %s", field->name, mono_error_get_message (field_error));
mono_error_cleanup (field_error);
break;
}
}
if (!field_class || !field_class->blittable)
blittable = FALSE;
}
}
if (!any_field_has_auto_layout && field->type->type == MONO_TYPE_VALUETYPE && m_class_any_field_has_auto_layout (mono_class_from_mono_type_internal (field->type)))
any_field_has_auto_layout = TRUE;
}
if (klass->enumtype) {
blittable = klass->element_class->blittable;
any_field_has_auto_layout = klass->element_class->any_field_has_auto_layout;
}
if (mono_class_has_failure (klass))
return;
if (klass == mono_defaults.string_class)
blittable = FALSE;
/* Compute klass->has_references and klass->has_ref_fields */
/*
* Process non-static fields first, since static fields might recursively
* refer to the class itself.
*/
for (i = 0; i < top; i++) {
MonoType *ftype;
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (type_has_references (klass, ftype))
has_references = TRUE;
if (type_has_ref_fields (ftype))
has_ref_fields = TRUE;
}
}
/*
* Compute field layout and total size (not considering static fields)
*/
field_offsets = g_new0 (int, top);
fields_has_references = g_new0 (gboolean, top);
int first_field_idx = mono_class_has_static_metadata (klass) ? mono_class_get_first_field_idx (klass) : 0;
switch (layout) {
case TYPE_ATTRIBUTE_AUTO_LAYOUT:
case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
if (gc_aware_layout)
passes = 2;
else
passes = 1;
if (layout != TYPE_ATTRIBUTE_AUTO_LAYOUT)
passes = 1;
if (klass->parent) {
mono_class_setup_fields (klass->parent);
if (mono_class_set_type_load_failure_causedby_class (klass, klass->parent, "Cannot initialize parent class"))
return;
real_size = klass->parent->instance_size;
} else {
real_size = MONO_ABI_SIZEOF (MonoObject);
}
for (pass = 0; pass < passes; ++pass) {
for (i = 0; i < top; i++){
gint32 align;
guint32 size;
MonoType *ftype;
field = &klass->fields [i];
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (gc_aware_layout) {
fields_has_references [i] = type_has_references (klass, ftype);
if (fields_has_references [i]) {
if (pass == 1)
continue;
} else {
if (pass == 0)
continue;
}
}
if ((top == 1) && (instance_size == MONO_ABI_SIZEOF (MonoObject)) &&
(strcmp (mono_field_get_name (field), "$PRIVATE$") == 0)) {
/* This field is a hack inserted by MCS to empty structures */
continue;
}
size = mono_type_size (field->type, &align);
/* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
align = packing_size ? MIN (packing_size, align): align;
/* if the field has managed references, we need to force-align it
* see bug #77788
*/
if (type_has_references (klass, ftype))
align = MAX (align, TARGET_SIZEOF_VOID_P);
min_align = MAX (align, min_align);
field_offsets [i] = real_size;
if (align) {
field_offsets [i] += align - 1;
field_offsets [i] &= ~(align - 1);
}
/*TypeBuilders produce all sort of weird things*/
g_assert (image_is_dynamic (klass->image) || field_offsets [i] > 0);
real_size = field_offsets [i] + size;
}
instance_size = MAX (real_size, instance_size);
if (instance_size & (min_align - 1)) {
instance_size += min_align - 1;
instance_size &= ~(min_align - 1);
}
}
break;
case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT: {
real_size = 0;
for (i = 0; i < top; i++) {
gint32 align;
guint32 size;
MonoType *ftype;
field = &klass->fields [i];
/*
* There must be info about all the fields in a type if it
* uses explicit layout.
*/
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
size = mono_type_size (field->type, &align);
align = packing_size ? MIN (packing_size, align): align;
min_align = MAX (align, min_align);
if (sre) {
/* Already set by typebuilder_setup_fields () */
field_offsets [i] = field->offset + MONO_ABI_SIZEOF (MonoObject);
} else {
int idx = first_field_idx + i;
guint32 offset;
mono_metadata_field_info (klass->image, idx, &offset, NULL, NULL);
field_offsets [i] = offset + MONO_ABI_SIZEOF (MonoObject);
}
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (type_has_references (klass, ftype) || m_type_is_byref (ftype)) {
if (field_offsets [i] % TARGET_SIZEOF_VOID_P) {
mono_class_set_type_load_failure (klass, "Reference typed field '%s' has explicit offset that is not pointer-size aligned.", field->name);
}
}
/*
* Calc max size.
*/
real_size = MAX (real_size, size + field_offsets [i]);
}
/* check for incorrectly aligned or overlapped by a non-object field */
guint8 *layout_check;
if (has_references || has_ref_fields) {
layout_check = g_new0 (guint8, real_size);
int invalid_field_offset;
if (!validate_struct_fields_overlaps (layout_check, real_size, klass, field_offsets, top, &invalid_field_offset)) {
mono_class_set_type_load_failure (klass, "Could not load type '%s' because it contains an object field at offset %d that is incorrectly aligned or overlapped by a non-object field.", klass->name, invalid_field_offset);
}
g_free (layout_check);
}
instance_size = MAX (real_size, instance_size);
if (!((layout == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) && explicit_size)) {
if (instance_size & (min_align - 1)) {
instance_size += min_align - 1;
instance_size &= ~(min_align - 1);
}
}
break;
}
}
if (layout != TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
/*
* This leads to all kinds of problems with nested structs, so only
* enable it when a MONO_DEBUG property is set.
*
* For small structs, set min_align to at least the struct size to improve
* performance, and since the JIT memset/memcpy code assumes this and generates
* unaligned accesses otherwise. See #78990 for a testcase.
*/
if (mono_align_small_structs && top) {
if (instance_size <= MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer))
min_align = MAX (min_align, instance_size - MONO_ABI_SIZEOF (MonoObject));
}
}
MonoType *klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_VAR || klass_byval_arg->type == MONO_TYPE_MVAR)
instance_size = MONO_ABI_SIZEOF (MonoObject) + mono_type_size (klass_byval_arg, &min_align);
else if (klass_byval_arg->type == MONO_TYPE_PTR)
instance_size = MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer);
if (klass_byval_arg->type == MONO_TYPE_SZARRAY || klass_byval_arg->type == MONO_TYPE_ARRAY)
element_size = mono_class_array_element_size (klass->element_class);
/* Publish the data */
mono_loader_lock ();
if (klass->instance_size && !klass->image->dynamic && klass_byval_arg->type != MONO_TYPE_FNPTR) {
/* Might be already set using cached info */
if (klass->instance_size != instance_size) {
/* Emit info to help debugging */
g_print ("%s\n", mono_class_full_name (klass));
g_print ("%d %d %d %d\n", klass->instance_size, instance_size, klass->blittable, blittable);
g_print ("%d %d %d %d\n", klass->has_references, has_references, klass->has_ref_fields, has_ref_fields);
g_print ("%d %d %d %d\n", klass->packing_size, packing_size, klass->min_align, min_align);
for (i = 0; i < top; ++i) {
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
printf (" %s %d %d %d\n", klass->fields [i].name, klass->fields [i].offset, field_offsets [i], fields_has_references [i]);
}
}
g_assert (klass->instance_size == instance_size);
} else {
klass->instance_size = instance_size;
}
klass->blittable = blittable;
klass->has_references = has_references;
klass->has_ref_fields = has_ref_fields;
klass->packing_size = packing_size;
klass->min_align = min_align;
klass->any_field_has_auto_layout = any_field_has_auto_layout;
for (i = 0; i < top; ++i) {
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
klass->fields [i].offset = field_offsets [i];
}
if (klass_byval_arg->type == MONO_TYPE_SZARRAY || klass_byval_arg->type == MONO_TYPE_ARRAY)
klass->sizes.element_size = element_size;
mono_memory_barrier ();
klass->size_inited = 1;
mono_loader_unlock ();
/*
* Compute static field layout and size
* Static fields can reference the class itself, so this has to be
* done after instance_size etc. are initialized.
*/
class_size = 0;
for (i = 0; i < top; i++) {
gint32 align;
guint32 size;
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
continue;
if (mono_field_is_deleted (field))
continue;
/* Type may not be initialized yet. Don't initialize it. If
it's a reference type we can get the size without
recursing */
if (mono_type_has_exceptions (field->type)) {
mono_class_set_type_load_failure (klass, "Field '%s' has an invalid type.", field->name);
break;
}
has_static_fields = TRUE;
size = mono_type_size (field->type, &align);
/* Check again in case initializing the field's type caused a failure */
if (mono_type_has_exceptions (field->type)) {
mono_class_set_type_load_failure (klass, "Field '%s' has an invalid type.", field->name);
break;
}
field_offsets [i] = class_size;
/*align is always non-zero here*/
field_offsets [i] += align - 1;
field_offsets [i] &= ~(align - 1);
class_size = field_offsets [i] + size;
}
if (has_static_fields && class_size == 0)
/* Simplify code which depends on class_size != 0 if the class has static fields */
class_size = 8;
/* Compute klass->has_static_refs */
has_static_refs = FALSE;
for (i = 0; i < top; i++) {
MonoType *ftype;
field = &klass->fields [i];
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (type_has_references (klass, ftype))
has_static_refs = TRUE;
}
}
/*valuetypes can't be neither bigger than 1Mb or empty. */
if (klass->valuetype && (klass->instance_size <= 0 || klass->instance_size > (0x100000 + MONO_ABI_SIZEOF (MonoObject)))) {
/* Special case compiler generated types */
/* Hard to check for [CompilerGenerated] here */
if (!strstr (klass->name, "StaticArrayInitTypeSize") && !strstr (klass->name, "$ArrayType"))
mono_class_set_type_load_failure (klass, "Value type instance size (%d) cannot be zero, negative, or bigger than 1Mb", klass->instance_size);
}
// Weak field support
//
// FIXME:
// - generic instances
// - Disallow on structs/static fields/nonref fields
gboolean has_weak_fields = FALSE;
if (mono_class_has_static_metadata (klass)) {
for (MonoClass *p = klass; p != NULL; p = p->parent) {
gpointer iter = NULL;
guint32 first_field_idx = mono_class_get_first_field_idx (p);
while ((field = mono_class_get_fields_internal (p, &iter))) {
guint32 field_idx = first_field_idx + (field - p->fields);
if (MONO_TYPE_IS_REFERENCE (field->type) && mono_assembly_is_weak_field (p->image, field_idx + 1)) {
has_weak_fields = TRUE;
mono_trace_message (MONO_TRACE_TYPE, "Field %s:%s at offset %x is weak.", m_field_get_parent (field)->name, field->name, field->offset);
}
}
}
}
/*
* Check that any fields of IsByRefLike type are instance
* fields and only inside other IsByRefLike structs.
*
* (Has to be done late because we call
* mono_class_from_mono_type_internal which may recursively
* refer to the current class)
*/
gboolean allow_isbyreflike_fields = m_class_is_byreflike (klass);
for (i = 0; i < top; i++) {
field = &klass->fields [i];
if (mono_field_is_deleted (field))
continue;
if ((field->type->attrs & FIELD_ATTRIBUTE_LITERAL))
continue;
MonoClass *field_class = NULL;
/* have to be careful not to recursively invoke mono_class_init on a static field.
* for example - if the field is an array of a subclass of klass, we can loop.
*/
switch (field->type->type) {
case MONO_TYPE_TYPEDBYREF:
case MONO_TYPE_VALUETYPE:
case MONO_TYPE_GENERICINST:
field_class = mono_class_from_mono_type_internal (field->type);
break;
default:
break;
}
if (!field_class || !m_class_is_byreflike (field_class))
continue;
if ((field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
mono_class_set_type_load_failure (klass, "Static ByRefLike field '%s' is not allowed", field->name);
return;
} else {
/* instance field */
if (allow_isbyreflike_fields)
continue;
mono_class_set_type_load_failure (klass, "Instance ByRefLike field '%s' not in a ref struct", field->name);
return;
}
}
/* Publish the data */
mono_loader_lock ();
if (!klass->rank)
klass->sizes.class_size = class_size;
klass->has_static_refs = has_static_refs;
klass->has_weak_fields = has_weak_fields;
for (i = 0; i < top; ++i) {
field = &klass->fields [i];
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
field->offset = field_offsets [i];
}
mono_memory_barrier ();
klass->fields_inited = 1;
mono_loader_unlock ();
g_free (field_offsets);
g_free (fields_has_references);
}
static int finalize_slot = -1;
static void
initialize_object_slots (MonoClass *klass)
{
int i;
if (klass != mono_defaults.object_class || finalize_slot >= 0)
return;
mono_class_setup_vtable (klass);
for (i = 0; i < klass->vtable_size; ++i) {
if (!strcmp (klass->vtable [i]->name, "Finalize")) {
int const j = finalize_slot;
g_assert (j == -1 || j == i);
finalize_slot = i;
}
}
g_assert (finalize_slot >= 0);
}
int
mono_class_get_object_finalize_slot ()
{
return finalize_slot;
}
MonoMethod *
mono_class_get_default_finalize_method ()
{
int const i = finalize_slot;
return (i < 0) ? NULL : mono_defaults.object_class->vtable [i];
}
typedef struct {
MonoMethod *array_method;
char *name;
} GenericArrayMethodInfo;
static int generic_array_method_num = 0;
static GenericArrayMethodInfo *generic_array_method_info = NULL;
static void
setup_generic_array_ifaces (MonoClass *klass, MonoClass *iface, MonoMethod **methods, int pos, GHashTable *cache)
{
MonoGenericContext tmp_context;
MonoGenericClass *gclass;
int i;
// The interface can sometimes be a GTD in cases like IList
// See: https://github.com/mono/mono/issues/7095#issuecomment-470465597
if (mono_class_is_gtd (iface)) {
MonoType *ty = mono_class_gtd_get_canonical_inst (iface);
g_assert (ty->type == MONO_TYPE_GENERICINST);
gclass = ty->data.generic_class;
} else
gclass = mono_class_get_generic_class (iface);
tmp_context.class_inst = NULL;
tmp_context.method_inst = gclass->context.class_inst;
//g_print ("setting up array interface: %s\n", mono_type_get_name_full (m_class_get_byval_arg (iface), 0));
for (i = 0; i < generic_array_method_num; i++) {
ERROR_DECL (error);
MonoMethod *m = generic_array_method_info [i].array_method;
MonoMethod *inflated, *helper;
inflated = mono_class_inflate_generic_method_checked (m, &tmp_context, error);
mono_error_assert_ok (error);
helper = (MonoMethod*)g_hash_table_lookup (cache, inflated);
if (!helper) {
helper = mono_marshal_get_generic_array_helper (klass, generic_array_method_info [i].name, inflated);
g_hash_table_insert (cache, inflated, helper);
}
methods [pos ++] = helper;
}
}
static gboolean
check_method_exists (MonoClass *iface, const char *method_name)
{
g_assert (iface != NULL);
ERROR_DECL (method_lookup_error);
gboolean found = NULL != mono_class_get_method_from_name_checked (iface, method_name, -1, 0, method_lookup_error);
mono_error_cleanup (method_lookup_error);
return found;
}
static int
generic_array_methods (MonoClass *klass)
{
int i, count_generic = 0, mcount;
GList *list = NULL, *tmp;
if (generic_array_method_num)
return generic_array_method_num;
mono_class_setup_methods (klass->parent); /*This is setting up System.Array*/
g_assert (!mono_class_has_failure (klass->parent)); /*So hitting this assert is a huge problem*/
mcount = mono_class_get_method_count (klass->parent);
for (i = 0; i < mcount; i++) {
MonoMethod *m = klass->parent->methods [i];
if (!strncmp (m->name, "InternalArray__", 15)) {
count_generic++;
list = g_list_prepend (list, m);
}
}
list = g_list_reverse (list);
generic_array_method_info = (GenericArrayMethodInfo *)mono_image_alloc (mono_defaults.corlib, sizeof (GenericArrayMethodInfo) * count_generic);
i = 0;
for (tmp = list; tmp; tmp = tmp->next) {
const char *mname, *iname;
gchar *name;
MonoMethod *m = (MonoMethod *)tmp->data;
const char *ireadonlylist_prefix = "InternalArray__IReadOnlyList_";
const char *ireadonlycollection_prefix = "InternalArray__IReadOnlyCollection_";
MonoClass *iface = NULL;
if (!strncmp (m->name, "InternalArray__ICollection_", 27)) {
iname = "System.Collections.Generic.ICollection`1.";
mname = m->name + 27;
iface = mono_class_try_get_icollection_class ();
} else if (!strncmp (m->name, "InternalArray__IEnumerable_", 27)) {
iname = "System.Collections.Generic.IEnumerable`1.";
mname = m->name + 27;
iface = mono_class_try_get_ienumerable_class ();
} else if (!strncmp (m->name, ireadonlylist_prefix, strlen (ireadonlylist_prefix))) {
iname = "System.Collections.Generic.IReadOnlyList`1.";
mname = m->name + strlen (ireadonlylist_prefix);
iface = mono_defaults.generic_ireadonlylist_class;
} else if (!strncmp (m->name, ireadonlycollection_prefix, strlen (ireadonlycollection_prefix))) {
iname = "System.Collections.Generic.IReadOnlyCollection`1.";
mname = m->name + strlen (ireadonlycollection_prefix);
iface = mono_class_try_get_ireadonlycollection_class ();
} else if (!strncmp (m->name, "InternalArray__", 15)) {
iname = "System.Collections.Generic.IList`1.";
mname = m->name + 15;
iface = mono_defaults.generic_ilist_class;
} else {
g_assert_not_reached ();
}
if (!iface || !check_method_exists (iface, mname))
continue;
generic_array_method_info [i].array_method = m;
name = (gchar *)mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1);
strcpy (name, iname);
strcpy (name + strlen (iname), mname);
generic_array_method_info [i].name = name;
i++;
}
/*g_print ("array generic methods: %d\n", count_generic);*/
/* only count the methods we actually added, not the ones that we
* skipped if they implement an interface method that was trimmed.
*/
generic_array_method_num = i;
g_list_free (list);
return generic_array_method_num;
}
static int array_get_method_count (MonoClass *klass)
{
MonoType *klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_ARRAY)
/* Regular array */
/* ctor([int32]*rank) */
/* ctor([int32]*rank*2) */
/* Get */
/* Set */
/* Address */
return 5;
else if (klass_byval_arg->type == MONO_TYPE_SZARRAY && klass->rank == 1 && klass->element_class->rank)
/* Jagged arrays are typed as MONO_TYPE_SZARRAY but have an extra ctor in .net which creates an array of arrays */
/* ctor([int32]) */
/* ctor([int32], [int32]) */
/* Get */
/* Set */
/* Address */
return 5;
else
/* Vectors don't have additional constructor since a zero lower bound is assumed */
/* ctor([int32]*rank) */
/* Get */
/* Set */
/* Address */
return 4;
}
static gboolean array_supports_additional_ctor_method (MonoClass *klass)
{
MonoType *klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_ARRAY)
/* Regular array */
return TRUE;
else if (klass_byval_arg->type == MONO_TYPE_SZARRAY && klass->rank == 1 && klass->element_class->rank)
/* Jagged array */
return TRUE;
else
/* Vector */
return FALSE;
}
/*
* Global pool of interface IDs, represented as a bitset.
* LOCKING: Protected by the classes lock.
*/
static MonoBitSet *global_interface_bitset = NULL;
/*
* mono_unload_interface_ids:
* @bitset: bit set of interface IDs
*
* When an image is unloaded, the interface IDs associated with
* the image are put back in the global pool of IDs so the numbers
* can be reused.
*/
void
mono_unload_interface_ids (MonoBitSet *bitset)
{
classes_lock ();
mono_bitset_sub (global_interface_bitset, bitset);
classes_unlock ();
}
void
mono_unload_interface_id (MonoClass *klass)
{
if (global_interface_bitset && klass->interface_id) {
classes_lock ();
mono_bitset_clear (global_interface_bitset, klass->interface_id);
classes_unlock ();
}
}
/**
* mono_get_unique_iid:
* \param klass interface
*
* Assign a unique integer ID to the interface represented by \p klass.
* The ID will positive and as small as possible.
* LOCKING: Acquires the classes lock.
* \returns The new ID.
*/
static guint32
mono_get_unique_iid (MonoClass *klass)
{
int iid;
g_assert (MONO_CLASS_IS_INTERFACE_INTERNAL (klass));
classes_lock ();
if (!global_interface_bitset) {
global_interface_bitset = mono_bitset_new (128, 0);
mono_bitset_set (global_interface_bitset, 0); //don't let 0 be a valid iid
}
iid = mono_bitset_find_first_unset (global_interface_bitset, -1);
if (iid < 0) {
int old_size = mono_bitset_size (global_interface_bitset);
MonoBitSet *new_set = mono_bitset_clone (global_interface_bitset, old_size * 2);
mono_bitset_free (global_interface_bitset);
global_interface_bitset = new_set;
iid = old_size;
}
mono_bitset_set (global_interface_bitset, iid);
/* set the bit also in the per-image set */
if (!mono_class_is_ginst (klass)) {
if (klass->image->interface_bitset) {
if (iid >= mono_bitset_size (klass->image->interface_bitset)) {
MonoBitSet *new_set = mono_bitset_clone (klass->image->interface_bitset, iid + 1);
mono_bitset_free (klass->image->interface_bitset);
klass->image->interface_bitset = new_set;
}
} else {
klass->image->interface_bitset = mono_bitset_new (iid + 1, 0);
}
mono_bitset_set (klass->image->interface_bitset, iid);
}
classes_unlock ();
#ifndef MONO_SMALL_CONFIG
if (mono_print_vtable) {
int generic_id;
char *type_name = mono_type_full_name (m_class_get_byval_arg (klass));
MonoGenericClass *gklass = mono_class_try_get_generic_class (klass);
if (gklass && !gklass->context.class_inst->is_open) {
generic_id = gklass->context.class_inst->id;
g_assert (generic_id != 0);
} else {
generic_id = 0;
}
printf ("Interface: assigned id %d to %s|%s|%d\n", iid, klass->image->assembly_name, type_name, generic_id);
g_free (type_name);
}
#endif
/* I've confirmed iids safe past 16 bits, however bitset code uses a signed int while testing.
* Once this changes, it should be safe for us to allow 2^32-1 interfaces, until then 2^31-2 is the max. */
g_assert (iid < INT_MAX);
return iid;
}
/**
* mono_class_init_internal:
* \param klass the class to initialize
*
* Compute the \c instance_size, \c class_size and other infos that cannot be
* computed at \c mono_class_get time. Also compute vtable_size if possible.
* Initializes the following fields in \p klass:
* - all the fields initialized by \c mono_class_init_sizes
* - has_cctor
* - ghcimpl
* - inited
*
* LOCKING: Acquires the loader lock.
*
* \returns TRUE on success or FALSE if there was a problem in loading
* the type (incorrect assemblies, missing assemblies, methods, etc).
*/
gboolean
mono_class_init_internal (MonoClass *klass)
{
int i, vtable_size = 0, array_method_count = 0;
MonoCachedClassInfo cached_info;
gboolean has_cached_info;
gboolean locked = FALSE;
gboolean ghcimpl = FALSE;
gboolean has_cctor = FALSE;
int first_iface_slot = 0;
g_assert (klass);
/* Double-checking locking pattern */
if (klass->inited || mono_class_has_failure (klass))
return !mono_class_has_failure (klass);
/*g_print ("Init class %s\n", mono_type_get_full_name (klass));*/
/*
* This function can recursively call itself.
*/
GSList *init_list = (GSList *)mono_native_tls_get_value (init_pending_tls_id);
if (g_slist_find (init_list, klass)) {
mono_class_set_type_load_failure (klass, "Recursive type definition detected %s.%s", klass->name_space, klass->name);
goto leave_no_init_pending;
}
init_list = g_slist_prepend (init_list, klass);
mono_native_tls_set_value (init_pending_tls_id, init_list);
/*
* We want to avoid doing complicated work inside locks, so we compute all the required
* information and write it to @klass inside a lock.
*/
MonoType *klass_byval_arg;
klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_ARRAY || klass_byval_arg->type == MONO_TYPE_SZARRAY) {
MonoClass *element_class = klass->element_class;
MonoClass *cast_class = klass->cast_class;
if (!element_class->inited)
mono_class_init_internal (element_class);
if (mono_class_set_type_load_failure_causedby_class (klass, element_class, "Could not load array element class"))
goto leave;
if (!cast_class->inited)
mono_class_init_internal (cast_class);
if (mono_class_set_type_load_failure_causedby_class (klass, cast_class, "Could not load array cast class"))
goto leave;
}
UnlockedIncrement (&mono_stats.initialized_class_count);
if (mono_class_is_ginst (klass) && !mono_class_get_generic_class (klass)->is_dynamic) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_init_internal (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic Type Definition failed to init"))
goto leave;
if (MONO_CLASS_IS_INTERFACE_INTERNAL (klass))
mono_class_setup_interface_id (klass);
}
if (klass->parent && !klass->parent->inited)
mono_class_init_internal (klass->parent);
has_cached_info = mono_class_get_cached_class_info (klass, &cached_info);
/* Compute instance size etc. */
init_sizes_with_info (klass, has_cached_info ? &cached_info : NULL);
if (mono_class_has_failure (klass))
goto leave;
mono_class_setup_supertypes (klass);
initialize_object_slots (klass);
/*
* Initialize the rest of the data without creating a generic vtable if possible.
* If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
* also avoid computing a generic vtable.
*/
if (has_cached_info) {
/* AOT case */
vtable_size = cached_info.vtable_size;
ghcimpl = cached_info.ghcimpl;
has_cctor = cached_info.has_cctor;
} else if (klass->rank == 1 && klass_byval_arg->type == MONO_TYPE_SZARRAY) {
/* SZARRAY can have 3 vtable layouts, with and without the stelemref method and enum element type
* The first slot if for array with.
*/
static int szarray_vtable_size[3] = { 0 };
int slot;
if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (m_class_get_element_class (klass))))
slot = 0;
else if (klass->element_class->enumtype)
slot = 1;
else
slot = 2;
/* SZARRAY case */
if (!szarray_vtable_size [slot]) {
mono_class_setup_vtable (klass);
szarray_vtable_size [slot] = klass->vtable_size;
vtable_size = klass->vtable_size;
} else {
vtable_size = szarray_vtable_size[slot];
}
} else if (mono_class_is_ginst (klass) && !MONO_CLASS_IS_INTERFACE_INTERNAL (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
/* Generic instance case */
ghcimpl = gklass->ghcimpl;
has_cctor = gklass->has_cctor;
mono_class_setup_vtable (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to init"))
goto leave;
vtable_size = gklass->vtable_size;
} else {
/* General case */
/* C# doesn't allow interfaces to have cctors */
if (!MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || klass->image != mono_defaults.corlib) {
MonoMethod *cmethod = NULL;
if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
/* Generic instance case */
ghcimpl = gklass->ghcimpl;
has_cctor = gklass->has_cctor;
} else if (klass->type_token && !image_is_dynamic(klass->image)) {
cmethod = mono_find_method_in_metadata (klass, ".cctor", 0, METHOD_ATTRIBUTE_SPECIAL_NAME);
/* The find_method function ignores the 'flags' argument */
if (cmethod && (cmethod->flags & METHOD_ATTRIBUTE_SPECIAL_NAME))
has_cctor = 1;
} else {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass))
goto leave;
int mcount = mono_class_get_method_count (klass);
for (i = 0; i < mcount; ++i) {
MonoMethod *method = klass->methods [i];
if ((method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) &&
(strcmp (".cctor", method->name) == 0)) {
has_cctor = 1;
break;
}
}
}
}
}
if (klass->rank) {
array_method_count = array_get_method_count (klass);
if (klass->interface_count) {
int count_generic = generic_array_methods (klass);
array_method_count += klass->interface_count * count_generic;
}
}
if (klass->parent) {
if (!klass->parent->vtable_size)
mono_class_setup_vtable (klass->parent);
if (mono_class_set_type_load_failure_causedby_class (klass, klass->parent, "Parent class vtable failed to initialize"))
goto leave;
g_assert (klass->parent->vtable_size);
first_iface_slot = klass->parent->vtable_size;
if (mono_class_setup_need_stelemref_method (klass))
++first_iface_slot;
}
/*
* Do the actual changes to @klass inside the loader lock
*/
mono_loader_lock ();
locked = TRUE;
if (klass->inited || mono_class_has_failure (klass)) {
/* Somebody might have gotten in before us */
goto leave;
}
UnlockedIncrement (&mono_stats.initialized_class_count);
if (mono_class_is_ginst (klass) && !mono_class_get_generic_class (klass)->is_dynamic)
UnlockedIncrement (&mono_stats.generic_class_count);
if (mono_class_is_ginst (klass) || image_is_dynamic (klass->image) || !klass->type_token || (has_cached_info && !cached_info.has_nested_classes))
klass->nested_classes_inited = TRUE;
klass->ghcimpl = ghcimpl;
klass->has_cctor = has_cctor;
if (vtable_size)
klass->vtable_size = vtable_size;
if (has_cached_info) {
klass->has_finalize = cached_info.has_finalize;
klass->has_finalize_inited = TRUE;
}
if (klass->rank)
mono_class_set_method_count (klass, array_method_count);
mono_loader_unlock ();
locked = FALSE;
mono_class_setup_interface_offsets_internal (klass, first_iface_slot, TRUE);
if (mono_class_is_ginst (klass) && !mono_verifier_class_is_valid_generic_instantiation (klass))
mono_class_set_type_load_failure (klass, "Invalid generic instantiation");
goto leave;
leave:
init_list = (GSList*)mono_native_tls_get_value (init_pending_tls_id);
init_list = g_slist_remove (init_list, klass);
mono_native_tls_set_value (init_pending_tls_id, init_list);
leave_no_init_pending:
if (locked)
mono_loader_unlock ();
/* Leave this for last */
mono_loader_lock ();
klass->inited = 1;
mono_loader_unlock ();
return !mono_class_has_failure (klass);
}
gboolean
mono_class_init_checked (MonoClass *klass, MonoError *error)
{
error_init (error);
gboolean const success = mono_class_init_internal (klass);
if (!success)
mono_error_set_for_class_failure (error, klass);
return success;
}
#ifndef DISABLE_COM
/*
* COM initialization is delayed until needed.
* However when a [ComImport] attribute is present on a type it will trigger
* the initialization. This is not a problem unless the BCL being executed
* lacks the types that COM depends on (e.g. Variant on Silverlight).
*/
static void
init_com_from_comimport (MonoClass *klass)
{
/* FIXME : we should add an extra checks to ensure COM can be initialized properly before continuing */
}
#endif /*DISABLE_COM*/
/*
* LOCKING: this assumes the loader lock is held
*/
void
mono_class_setup_parent (MonoClass *klass, MonoClass *parent)
{
gboolean system_namespace;
gboolean is_corlib = mono_is_corlib_image (klass->image);
system_namespace = !strcmp (klass->name_space, "System") && is_corlib;
/* if root of the hierarchy */
if (system_namespace && !strcmp (klass->name, "Object")) {
klass->parent = NULL;
klass->instance_size = MONO_ABI_SIZEOF (MonoObject);
return;
}
if (!strcmp (klass->name, "<Module>")) {
klass->parent = NULL;
klass->instance_size = 0;
return;
}
if (!MONO_CLASS_IS_INTERFACE_INTERNAL (klass)) {
/* Imported COM Objects always derive from __ComObject. */
#ifndef DISABLE_COM
if (MONO_CLASS_IS_IMPORT (klass)) {
init_com_from_comimport (klass);
if (parent == mono_defaults.object_class)
parent = mono_class_get_com_object_class ();
}
#endif
if (!parent) {
/* set the parent to something useful and safe, but mark the type as broken */
parent = mono_defaults.object_class;
mono_class_set_type_load_failure (klass, "");
g_assert (parent);
}
klass->parent = parent;
if (mono_class_is_ginst (parent) && !parent->name) {
/*
* If the parent is a generic instance, we may get
* called before it is fully initialized, especially
* before it has its name.
*/
return;
}
klass->delegate = parent->delegate;
if (MONO_CLASS_IS_IMPORT (klass) || mono_class_is_com_object (parent))
mono_class_set_is_com_object (klass);
if (system_namespace) {
if (klass->name [0] == 'D' && !strcmp (klass->name, "Delegate"))
klass->delegate = 1;
}
if (klass->parent->enumtype || (mono_is_corlib_image (klass->parent->image) && (strcmp (klass->parent->name, "ValueType") == 0) &&
(strcmp (klass->parent->name_space, "System") == 0)))
klass->valuetype = 1;
if (mono_is_corlib_image (klass->parent->image) && ((strcmp (klass->parent->name, "Enum") == 0) && (strcmp (klass->parent->name_space, "System") == 0))) {
klass->valuetype = klass->enumtype = 1;
}
/*klass->enumtype = klass->parent->enumtype; */
} else {
/* initialize com types if COM interfaces are present */
#ifndef DISABLE_COM
if (MONO_CLASS_IS_IMPORT (klass))
init_com_from_comimport (klass);
#endif
klass->parent = NULL;
}
}
/* Locking: must be called with the loader lock held. */
void
mono_class_setup_interface_id_nolock (MonoClass *klass)
{
if (!MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || klass->interface_id)
return;
klass->interface_id = mono_get_unique_iid (klass);
if (mono_is_corlib_image (klass->image) && !strcmp (m_class_get_name_space (klass), "System.Collections.Generic")) {
//FIXME IEnumerator needs to be special because GetEnumerator uses magic under the hood
/* FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
* MS returns diferrent types based on which instance is called. For example:
* object obj = new byte[10][];
* Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
* Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
* a != b ==> true
*/
const char *name = m_class_get_name (klass);
if (!strcmp (name, "IList`1") || !strcmp (name, "ICollection`1") || !strcmp (name, "IEnumerable`1") || !strcmp (name, "IEnumerator`1"))
klass->is_array_special_interface = 1;
}
}
/*
* LOCKING: this assumes the loader lock is held
*/
void
mono_class_setup_mono_type (MonoClass *klass)
{
const char *name = klass->name;
const char *nspace = klass->name_space;
gboolean is_corlib = mono_is_corlib_image (klass->image);
klass->this_arg.byref__ = 1;
klass->this_arg.data.klass = klass;
klass->this_arg.type = MONO_TYPE_CLASS;
klass->_byval_arg.data.klass = klass;
klass->_byval_arg.type = MONO_TYPE_CLASS;
if (is_corlib && !strcmp (nspace, "System")) {
if (!strcmp (name, "ValueType")) {
/*
* do not set the valuetype bit for System.ValueType.
* klass->valuetype = 1;
*/
klass->blittable = TRUE;
} else if (!strcmp (name, "Enum")) {
/*
* do not set the valuetype bit for System.Enum.
* klass->valuetype = 1;
*/
klass->valuetype = 0;
klass->enumtype = 0;
} else if (!strcmp (name, "Object")) {
klass->_byval_arg.type = MONO_TYPE_OBJECT;
klass->this_arg.type = MONO_TYPE_OBJECT;
} else if (!strcmp (name, "String")) {
klass->_byval_arg.type = MONO_TYPE_STRING;
klass->this_arg.type = MONO_TYPE_STRING;
} else if (!strcmp (name, "TypedReference")) {
klass->_byval_arg.type = MONO_TYPE_TYPEDBYREF;
klass->this_arg.type = MONO_TYPE_TYPEDBYREF;
}
}
if (klass->valuetype) {
int t = MONO_TYPE_VALUETYPE;
if (is_corlib && !strcmp (nspace, "System")) {
switch (*name) {
case 'B':
if (!strcmp (name, "Boolean")) {
t = MONO_TYPE_BOOLEAN;
} else if (!strcmp(name, "Byte")) {
t = MONO_TYPE_U1;
klass->blittable = TRUE;
}
break;
case 'C':
if (!strcmp (name, "Char")) {
t = MONO_TYPE_CHAR;
}
break;
case 'D':
if (!strcmp (name, "Double")) {
t = MONO_TYPE_R8;
klass->blittable = TRUE;
}
break;
case 'I':
if (!strcmp (name, "Int32")) {
t = MONO_TYPE_I4;
klass->blittable = TRUE;
} else if (!strcmp(name, "Int16")) {
t = MONO_TYPE_I2;
klass->blittable = TRUE;
} else if (!strcmp(name, "Int64")) {
t = MONO_TYPE_I8;
klass->blittable = TRUE;
} else if (!strcmp(name, "IntPtr")) {
t = MONO_TYPE_I;
klass->blittable = TRUE;
}
break;
case 'S':
if (!strcmp (name, "Single")) {
t = MONO_TYPE_R4;
klass->blittable = TRUE;
} else if (!strcmp(name, "SByte")) {
t = MONO_TYPE_I1;
klass->blittable = TRUE;
}
break;
case 'U':
if (!strcmp (name, "UInt32")) {
t = MONO_TYPE_U4;
klass->blittable = TRUE;
} else if (!strcmp(name, "UInt16")) {
t = MONO_TYPE_U2;
klass->blittable = TRUE;
} else if (!strcmp(name, "UInt64")) {
t = MONO_TYPE_U8;
klass->blittable = TRUE;
} else if (!strcmp(name, "UIntPtr")) {
t = MONO_TYPE_U;
klass->blittable = TRUE;
}
break;
case 'T':
if (!strcmp (name, "TypedReference")) {
t = MONO_TYPE_TYPEDBYREF;
klass->blittable = TRUE;
}
break;
case 'V':
if (!strcmp (name, "Void")) {
t = MONO_TYPE_VOID;
}
break;
default:
break;
}
}
klass->_byval_arg.type = (MonoTypeEnum)t;
klass->this_arg.type = (MonoTypeEnum)t;
}
mono_class_setup_interface_id_nolock (klass);
}
static MonoMethod*
create_array_method (MonoClass *klass, const char *name, MonoMethodSignature *sig)
{
MonoMethod *method;
method = (MonoMethod *) mono_image_alloc0 (klass->image, sizeof (MonoMethodPInvoke));
method->klass = klass;
method->flags = METHOD_ATTRIBUTE_PUBLIC;
method->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
method->signature = sig;
method->name = name;
method->slot = -1;
/* .ctor */
if (name [0] == '.') {
method->flags |= METHOD_ATTRIBUTE_RT_SPECIAL_NAME | METHOD_ATTRIBUTE_SPECIAL_NAME;
} else {
method->iflags |= METHOD_IMPL_ATTRIBUTE_RUNTIME;
}
return method;
}
/*
* mono_class_setup_methods:
* @class: a class
*
* Initializes the 'methods' array in CLASS.
* Calling this method should be avoided if possible since it allocates a lot
* of long-living MonoMethod structures.
* Methods belonging to an interface are assigned a sequential slot starting
* from 0.
*
* On failure this function sets klass->has_failure and stores a MonoErrorBoxed with details
*/
void
mono_class_setup_methods (MonoClass *klass)
{
int i, count;
MonoMethod **methods;
if (klass->methods)
return;
if (mono_class_is_ginst (klass)) {
ERROR_DECL (error);
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_init_internal (gklass);
if (!mono_class_has_failure (gklass))
mono_class_setup_methods (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to load"))
return;
/* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
count = mono_class_get_method_count (gklass);
methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * (count + 1));
for (i = 0; i < count; i++) {
methods [i] = mono_class_inflate_generic_method_full_checked (
gklass->methods [i], klass, mono_class_get_context (klass), error);
if (!is_ok (error)) {
char *method = mono_method_full_name (gklass->methods [i], TRUE);
mono_class_set_type_load_failure (klass, "Could not inflate method %s due to %s", method, mono_error_get_message (error));
g_free (method);
mono_error_cleanup (error);
return;
}
}
} else if (klass->rank) {
ERROR_DECL (error);
MonoMethod *amethod;
MonoMethodSignature *sig;
int count_generic = 0, first_generic = 0;
int method_num = 0;
count = array_get_method_count (klass);
mono_class_setup_interfaces (klass, error);
g_assert (is_ok (error)); /*FIXME can this fail for array types?*/
if (klass->interface_count) {
count_generic = generic_array_methods (klass);
first_generic = count;
count += klass->interface_count * count_generic;
}
methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * count);
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = mono_get_void_type ();
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, ".ctor", sig);
methods [method_num++] = amethod;
if (array_supports_additional_ctor_method (klass)) {
sig = mono_metadata_signature_alloc (klass->image, klass->rank * 2);
sig->ret = mono_get_void_type ();
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank * 2; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, ".ctor", sig);
methods [method_num++] = amethod;
}
/* element Get (idx11, [idx2, ...]) */
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = m_class_get_byval_arg (m_class_get_element_class (klass));
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, "Get", sig);
methods [method_num++] = amethod;
/* element& Address (idx11, [idx2, ...]) */
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = &klass->element_class->this_arg;
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, "Address", sig);
methods [method_num++] = amethod;
/* void Set (idx11, [idx2, ...], element) */
sig = mono_metadata_signature_alloc (klass->image, klass->rank + 1);
sig->ret = mono_get_void_type ();
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
sig->params [i] = m_class_get_byval_arg (m_class_get_element_class (klass));
amethod = create_array_method (klass, "Set", sig);
methods [method_num++] = amethod;
GHashTable *cache = g_hash_table_new (NULL, NULL);
for (i = 0; i < klass->interface_count; i++)
setup_generic_array_ifaces (klass, klass->interfaces [i], methods, first_generic + i * count_generic, cache);
g_hash_table_destroy (cache);
} else if (mono_class_has_static_metadata (klass)) {
ERROR_DECL (error);
int first_idx = mono_class_get_first_method_idx (klass);
count = mono_class_get_method_count (klass);
methods = (MonoMethod **)mono_class_alloc (klass, sizeof (MonoMethod*) * count);
for (i = 0; i < count; ++i) {
int idx = mono_metadata_translate_token_index (klass->image, MONO_TABLE_METHOD, first_idx + i + 1);
methods [i] = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | idx, klass, NULL, error);
if (!methods [i]) {
mono_class_set_type_load_failure (klass, "Could not load method %d due to %s", i, mono_error_get_message (error));
mono_error_cleanup (error);
}
}
} else {
methods = (MonoMethod **)mono_class_alloc (klass, sizeof (MonoMethod*) * 1);
count = 0;
}
if (MONO_CLASS_IS_INTERFACE_INTERNAL (klass)) {
int slot = 0;
/*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/
for (i = 0; i < count; ++i) {
if (methods [i]->flags & METHOD_ATTRIBUTE_VIRTUAL)
{
if (method_is_reabstracted (methods[i]->flags)) {
if (!methods [i]->is_inflated)
mono_method_set_is_reabstracted (methods [i]);
continue;
}
methods [i]->slot = slot++;
}
}
}
mono_image_lock (klass->image);
if (!klass->methods) {
mono_class_set_method_count (klass, count);
/* Needed because of the double-checking locking pattern */
mono_memory_barrier ();
klass->methods = methods;
}
mono_image_unlock (klass->image);
}
/*
* mono_class_setup_properties:
*
* Initialize klass->ext.property and klass->ext.properties.
*
* This method can fail the class.
*/
void
mono_class_setup_properties (MonoClass *klass)
{
guint startm, endm, i, j;
guint32 cols [MONO_PROPERTY_SIZE];
MonoTableInfo *msemt = &klass->image->tables [MONO_TABLE_METHODSEMANTICS];
MonoProperty *properties;
guint32 last;
int first, count;
MonoClassPropertyInfo *info;
info = mono_class_get_property_info (klass);
if (info)
return;
if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_init_internal (gklass);
mono_class_setup_properties (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to load"))
return;
MonoClassPropertyInfo *ginfo = mono_class_get_property_info (gklass);
properties = mono_class_new0 (klass, MonoProperty, ginfo->count + 1);
for (i = 0; i < ginfo->count; i++) {
ERROR_DECL (error);
MonoProperty *prop = &properties [i];
*prop = ginfo->properties [i];
if (prop->get)
prop->get = mono_class_inflate_generic_method_full_checked (
prop->get, klass, mono_class_get_context (klass), error);
if (prop->set)
prop->set = mono_class_inflate_generic_method_full_checked (
prop->set, klass, mono_class_get_context (klass), error);
g_assert (is_ok (error)); /*FIXME proper error handling*/
prop->parent = klass;
}
first = ginfo->first;
count = ginfo->count;
} else {
first = mono_metadata_properties_from_typedef (klass->image, mono_metadata_token_index (klass->type_token) - 1, &last);
count = last - first;
if (count) {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass))
return;
}
properties = (MonoProperty *)mono_class_alloc0 (klass, sizeof (MonoProperty) * count);
for (i = first; i < last; ++i) {
mono_metadata_decode_table_row (klass->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
properties [i - first].parent = klass;
properties [i - first].attrs = cols [MONO_PROPERTY_FLAGS];
properties [i - first].name = mono_metadata_string_heap (klass->image, cols [MONO_PROPERTY_NAME]);
startm = mono_metadata_methods_from_property (klass->image, i, &endm);
int first_idx = mono_class_get_first_method_idx (klass);
for (j = startm; j < endm; ++j) {
MonoMethod *method;
mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
if (klass->image->uncompressed_metadata) {
ERROR_DECL (error);
/* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
method = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], klass, NULL, error);
mono_error_cleanup (error); /* FIXME don't swallow this error */
} else {
method = klass->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - first_idx];
}
switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
case METHOD_SEMANTIC_SETTER:
properties [i - first].set = method;
break;
case METHOD_SEMANTIC_GETTER:
properties [i - first].get = method;
break;
default:
break;
}
}
}
}
info = (MonoClassPropertyInfo*)mono_class_alloc0 (klass, sizeof (MonoClassPropertyInfo));
info->first = first;
info->count = count;
info->properties = properties;
mono_memory_barrier ();
/* This might leak 'info' which was allocated from the image mempool */
mono_class_set_property_info (klass, info);
}
static MonoMethod**
inflate_method_listz (MonoMethod **methods, MonoClass *klass, MonoGenericContext *context)
{
MonoMethod **om, **retval;
int count;
for (om = methods, count = 0; *om; ++om, ++count)
;
retval = g_new0 (MonoMethod*, count + 1);
count = 0;
for (om = methods, count = 0; *om; ++om, ++count) {
ERROR_DECL (error);
retval [count] = mono_class_inflate_generic_method_full_checked (*om, klass, context, error);
g_assert (is_ok (error)); /*FIXME proper error handling*/
}
return retval;
}
/*This method can fail the class.*/
void
mono_class_setup_events (MonoClass *klass)
{
int first, count;
guint startm, endm, i, j;
guint32 cols [MONO_EVENT_SIZE];
MonoTableInfo *msemt = &klass->image->tables [MONO_TABLE_METHODSEMANTICS];
guint32 last;
MonoEvent *events;
MonoClassEventInfo *info = mono_class_get_event_info (klass);
if (info)
return;
if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
MonoGenericContext *context = NULL;
mono_class_setup_events (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to load"))
return;
MonoClassEventInfo *ginfo = mono_class_get_event_info (gklass);
first = ginfo->first;
count = ginfo->count;
events = mono_class_new0 (klass, MonoEvent, count);
if (count)
context = mono_class_get_context (klass);
for (i = 0; i < count; i++) {
ERROR_DECL (error);
MonoEvent *event = &events [i];
MonoEvent *gevent = &ginfo->events [i];
event->parent = klass;
event->name = gevent->name;
event->add = gevent->add ? mono_class_inflate_generic_method_full_checked (gevent->add, klass, context, error) : NULL;
g_assert (is_ok (error)); /*FIXME proper error handling*/
event->remove = gevent->remove ? mono_class_inflate_generic_method_full_checked (gevent->remove, klass, context, error) : NULL;
g_assert (is_ok (error)); /*FIXME proper error handling*/
event->raise = gevent->raise ? mono_class_inflate_generic_method_full_checked (gevent->raise, klass, context, error) : NULL;
g_assert (is_ok (error)); /*FIXME proper error handling*/
#ifndef MONO_SMALL_CONFIG
event->other = gevent->other ? inflate_method_listz (gevent->other, klass, context) : NULL;
#endif
event->attrs = gevent->attrs;
}
} else {
first = mono_metadata_events_from_typedef (klass->image, mono_metadata_token_index (klass->type_token) - 1, &last);
count = last - first;
if (count) {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass)) {
return;
}
}
events = (MonoEvent *)mono_class_alloc0 (klass, sizeof (MonoEvent) * count);
for (i = first; i < last; ++i) {
MonoEvent *event = &events [i - first];
mono_metadata_decode_table_row (klass->image, MONO_TABLE_EVENT, i, cols, MONO_EVENT_SIZE);
event->parent = klass;
event->attrs = cols [MONO_EVENT_FLAGS];
event->name = mono_metadata_string_heap (klass->image, cols [MONO_EVENT_NAME]);
startm = mono_metadata_methods_from_event (klass->image, i, &endm);
int first_idx = mono_class_get_first_method_idx (klass);
for (j = startm; j < endm; ++j) {
MonoMethod *method;
mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
if (klass->image->uncompressed_metadata) {
ERROR_DECL (error);
/* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
method = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], klass, NULL, error);
mono_error_cleanup (error); /* FIXME don't swallow this error */
} else {
method = klass->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - first_idx];
}
switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
case METHOD_SEMANTIC_ADD_ON:
event->add = method;
break;
case METHOD_SEMANTIC_REMOVE_ON:
event->remove = method;
break;
case METHOD_SEMANTIC_FIRE:
event->raise = method;
break;
case METHOD_SEMANTIC_OTHER: {
#ifndef MONO_SMALL_CONFIG
int n = 0;
if (event->other == NULL) {
event->other = g_new0 (MonoMethod*, 2);
} else {
while (event->other [n])
n++;
event->other = (MonoMethod **)g_realloc (event->other, (n + 2) * sizeof (MonoMethod*));
}
event->other [n] = method;
/* NULL terminated */
event->other [n + 1] = NULL;
#endif
break;
}
default:
break;
}
}
}
}
info = (MonoClassEventInfo*)mono_class_alloc0 (klass, sizeof (MonoClassEventInfo));
info->events = events;
info->first = first;
info->count = count;
mono_memory_barrier ();
mono_class_set_event_info (klass, info);
}
/*
* mono_class_setup_interface_id:
*
* Initializes MonoClass::interface_id if required.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_interface_id (MonoClass *klass)
{
g_assert (MONO_CLASS_IS_INTERFACE_INTERNAL (klass));
mono_loader_lock ();
mono_class_setup_interface_id_nolock (klass);
mono_loader_unlock ();
}
/*
* mono_class_setup_interfaces:
*
* Initialize klass->interfaces/interfaces_count.
* LOCKING: Acquires the loader lock.
* This function can fail the type.
*/
void
mono_class_setup_interfaces (MonoClass *klass, MonoError *error)
{
int i, interface_count;
MonoClass *iface, **interfaces;
error_init (error);
if (klass->interfaces_inited)
return;
if (klass->rank == 1 && m_class_get_byval_arg (klass)->type != MONO_TYPE_ARRAY) {
MonoType *args [1];
MonoClass *array_ifaces [16];
/*
* Arrays implement IList and IReadOnlyList or their base interfaces if they are not linked out.
* For arrays of enums, they implement the interfaces for the base type as well.
*/
interface_count = 0;
if (mono_defaults.generic_ilist_class) {
array_ifaces [interface_count ++] = mono_defaults.generic_ilist_class;
} else {
iface = mono_class_try_get_icollection_class ();
if (iface)
array_ifaces [interface_count ++] = iface;
}
if (mono_defaults.generic_ireadonlylist_class) {
array_ifaces [interface_count ++] = mono_defaults.generic_ireadonlylist_class;
} else {
iface = mono_class_try_get_ireadonlycollection_class ();
if (iface)
array_ifaces [interface_count ++] = iface;
}
if (!mono_defaults.generic_ilist_class && !mono_defaults.generic_ireadonlylist_class) {
iface = mono_class_try_get_ienumerable_class ();
if (iface)
array_ifaces [interface_count ++] = iface;
}
int mult = klass->element_class->enumtype ? 2 : 1;
interfaces = (MonoClass **)mono_image_alloc0 (klass->image, sizeof (MonoClass*) * interface_count * mult);
int itf_idx = 0;
args [0] = m_class_get_byval_arg (m_class_get_element_class (klass));
for (int i = 0; i < interface_count; ++i)
interfaces [itf_idx++] = mono_class_bind_generic_parameters (array_ifaces [i], 1, args, FALSE);
if (klass->element_class->enumtype) {
args [0] = mono_class_enum_basetype_internal (klass->element_class);
for (int i = 0; i < interface_count; ++i)
interfaces [itf_idx++] = mono_class_bind_generic_parameters (array_ifaces [i], 1, args, FALSE);
}
interface_count *= mult;
g_assert (itf_idx == interface_count);
} else if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_setup_interfaces (gklass, error);
if (!is_ok (error)) {
mono_class_set_type_load_failure (klass, "Could not setup the interfaces");
return;
}
interface_count = gklass->interface_count;
interfaces = mono_class_new0 (klass, MonoClass *, interface_count);
for (i = 0; i < interface_count; i++) {
interfaces [i] = mono_class_inflate_generic_class_checked (gklass->interfaces [i], mono_generic_class_get_context (mono_class_get_generic_class (klass)), error);
if (!is_ok (error)) {
mono_class_set_type_load_failure (klass, "Could not setup the interfaces");
return;
}
}
} else {
interface_count = 0;
interfaces = NULL;
}
mono_loader_lock ();
if (!klass->interfaces_inited) {
klass->interface_count = interface_count;
klass->interfaces = interfaces;
mono_memory_barrier ();
klass->interfaces_inited = TRUE;
}
mono_loader_unlock ();
}
/*
* mono_class_setup_has_finalizer:
*
* Initialize klass->has_finalizer if it isn't already initialized.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_has_finalizer (MonoClass *klass)
{
gboolean has_finalize = FALSE;
if (m_class_is_has_finalize_inited (klass))
return;
/* Interfaces and valuetypes are not supposed to have finalizers */
if (!(MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || m_class_is_valuetype (klass))) {
MonoMethod *cmethod = NULL;
if (m_class_get_rank (klass) == 1 && m_class_get_byval_arg (klass)->type == MONO_TYPE_SZARRAY) {
} else if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
has_finalize = mono_class_has_finalizer (gklass);
} else if (m_class_get_parent (klass) && m_class_has_finalize (m_class_get_parent (klass))) {
has_finalize = TRUE;
} else {
if (m_class_get_parent (klass)) {
/*
* Can't search in metadata for a method named Finalize, because that
* ignores overrides.
*/
mono_class_setup_vtable (klass);
if (mono_class_has_failure (klass))
cmethod = NULL;
else
cmethod = m_class_get_vtable (klass) [mono_class_get_object_finalize_slot ()];
}
if (cmethod) {
g_assert (m_class_get_vtable_size (klass) > mono_class_get_object_finalize_slot ());
if (m_class_get_parent (klass)) {
if (cmethod->is_inflated)
cmethod = ((MonoMethodInflated*)cmethod)->declaring;
if (cmethod != mono_class_get_default_finalize_method ())
has_finalize = TRUE;
}
}
}
}
mono_loader_lock ();
if (!m_class_is_has_finalize_inited (klass)) {
klass->has_finalize = has_finalize ? 1 : 0;
mono_memory_barrier ();
klass->has_finalize_inited = TRUE;
}
mono_loader_unlock ();
}
/*
* mono_class_setup_supertypes:
* @class: a class
*
* Build the data structure needed to make fast type checks work.
* This currently sets two fields in @class:
* - idepth: distance between @class and System.Object in the type
* hierarchy + 1
* - supertypes: array of classes: each element has a class in the hierarchy
* starting from @class up to System.Object
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_supertypes (MonoClass *klass)
{
int ms, idepth;
MonoClass **supertypes;
mono_atomic_load_acquire (supertypes, MonoClass **, &klass->supertypes);
if (supertypes)
return;
if (klass->parent && !klass->parent->supertypes)
mono_class_setup_supertypes (klass->parent);
if (klass->parent)
idepth = klass->parent->idepth + 1;
else
idepth = 1;
ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, idepth);
supertypes = (MonoClass **)mono_class_alloc0 (klass, sizeof (MonoClass *) * ms);
if (klass->parent) {
CHECKED_METADATA_WRITE_PTR ( supertypes [idepth - 1] , klass );
int supertype_idx;
for (supertype_idx = 0; supertype_idx < klass->parent->idepth; supertype_idx++)
CHECKED_METADATA_WRITE_PTR ( supertypes [supertype_idx] , klass->parent->supertypes [supertype_idx] );
} else {
CHECKED_METADATA_WRITE_PTR ( supertypes [0] , klass );
}
mono_memory_barrier ();
mono_loader_lock ();
klass->idepth = idepth;
/* Needed so idepth is visible before supertypes is set */
mono_memory_barrier ();
klass->supertypes = supertypes;
mono_loader_unlock ();
}
/* mono_class_setup_nested_types:
*
* Initialize the nested_classes property for the given MonoClass if it hasn't already been initialized.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_nested_types (MonoClass *klass)
{
ERROR_DECL (error);
GList *classes, *nested_classes, *l;
int i;
if (klass->nested_classes_inited)
return;
if (!klass->type_token) {
mono_loader_lock ();
klass->nested_classes_inited = TRUE;
mono_loader_unlock ();
return;
}
i = mono_metadata_nesting_typedef (klass->image, klass->type_token, 1);
classes = NULL;
while (i) {
MonoClass* nclass;
guint32 cols [MONO_NESTED_CLASS_SIZE];
mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED], error);
if (!is_ok (error)) {
/*FIXME don't swallow the error message*/
mono_error_cleanup (error);
i = mono_metadata_nesting_typedef (klass->image, klass->type_token, i + 1);
continue;
}
classes = g_list_prepend (classes, nclass);
i = mono_metadata_nesting_typedef (klass->image, klass->type_token, i + 1);
}
nested_classes = NULL;
for (l = classes; l; l = l->next)
nested_classes = mono_g_list_prepend_image (klass->image, nested_classes, l->data);
g_list_free (classes);
mono_loader_lock ();
if (!klass->nested_classes_inited) {
mono_class_set_nested_classes_property (klass, nested_classes);
mono_memory_barrier ();
klass->nested_classes_inited = TRUE;
}
mono_loader_unlock ();
}
/**
* mono_class_create_array_fill_type:
*
* Returns a \c MonoClass that is used by SGen to fill out nursery fragments before a collection.
*/
MonoClass *
mono_class_create_array_fill_type (void)
{
static MonoClassArray aklass;
aklass.klass.class_kind = MONO_CLASS_GC_FILLER;
aklass.klass.element_class = mono_defaults.int64_class;
aklass.klass.rank = 1;
aklass.klass.instance_size = MONO_SIZEOF_MONO_ARRAY;
aklass.klass.sizes.element_size = 8;
aklass.klass.size_inited = 1;
aklass.klass.name = "array_filler_type";
return &aklass.klass;
}
void
mono_class_set_runtime_vtable (MonoClass *klass, MonoVTable *vtable)
{
klass->runtime_vtable = vtable;
}
/**
* mono_classes_init:
*
* Initialize the resources used by this module.
* Known racy counters: `class_gparam_count`, `classes_size` and `mono_inflated_methods_size`
*/
MONO_NO_SANITIZE_THREAD
void
mono_classes_init (void)
{
mono_os_mutex_init (&classes_mutex);
mono_native_tls_alloc (&setup_fields_tls_id, NULL);
mono_native_tls_alloc (&init_pending_tls_id, NULL);
mono_counters_register ("MonoClassDef count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_def_count);
mono_counters_register ("MonoClassGtd count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_gtd_count);
mono_counters_register ("MonoClassGenericInst count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_ginst_count);
mono_counters_register ("MonoClassGenericParam count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_gparam_count);
mono_counters_register ("MonoClassArray count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_array_count);
mono_counters_register ("MonoClassPointer count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_pointer_count);
mono_counters_register ("Inflated methods size",
MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &mono_inflated_methods_size);
mono_counters_register ("Inflated classes size",
MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &inflated_classes_size);
mono_counters_register ("MonoClass size",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &classes_size);
}
| /**
* \file MonoClass construction and initialization
*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
* Copyright 2012 Xamarin Inc (http://www.xamarin.com)
* Copyright 2018 Microsoft
* Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <mono/metadata/class-init.h>
#include <mono/metadata/class-init-internals.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/custom-attrs-internals.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/exception-internals.h>
#include <mono/metadata/gc-internals.h>
#include <mono/metadata/object-internals.h>
#include <mono/metadata/profiler-private.h>
#include <mono/metadata/verify-internals.h>
#include <mono/metadata/abi-details.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/marshal.h>
#include <mono/utils/checked-build.h>
#include <mono/utils/mono-counters.h>
#include <mono/utils/mono-error-internals.h>
#include <mono/utils/mono-logger-internals.h>
#include <mono/utils/mono-memory-model.h>
#include <mono/utils/unlocked.h>
#ifdef MONO_CLASS_DEF_PRIVATE
/* Class initialization gets to see the fields of MonoClass */
#define REALLY_INCLUDE_CLASS_DEF 1
#include <mono/metadata/class-private-definition.h>
#undef REALLY_INCLUDE_CLASS_DEF
#endif
#define FEATURE_COVARIANT_RETURNS
gboolean mono_print_vtable = FALSE;
gboolean mono_align_small_structs = FALSE;
/* Set by the EE */
gint32 mono_simd_register_size;
/* Statistics */
static gint32 classes_size;
static gint32 inflated_classes_size;
gint32 mono_inflated_methods_size;
static gint32 class_def_count, class_gtd_count, class_ginst_count, class_gparam_count, class_array_count, class_pointer_count;
/* Low level lock which protects data structures in this module */
static mono_mutex_t classes_mutex;
static gboolean class_kind_may_contain_generic_instances (MonoTypeKind kind);
static void mono_generic_class_setup_parent (MonoClass *klass, MonoClass *gtd);
static int generic_array_methods (MonoClass *klass);
static void setup_generic_array_ifaces (MonoClass *klass, MonoClass *iface, MonoMethod **methods, int pos, GHashTable *cache);
static gboolean class_has_isbyreflike_attribute (MonoClass *klass);
static
GENERATE_TRY_GET_CLASS_WITH_CACHE(icollection, "System.Collections.Generic", "ICollection`1");
static
GENERATE_TRY_GET_CLASS_WITH_CACHE(ienumerable, "System.Collections.Generic", "IEnumerable`1");
static
GENERATE_TRY_GET_CLASS_WITH_CACHE(ireadonlycollection, "System.Collections.Generic", "IReadOnlyCollection`1");
/* This TLS variable points to a GSList of classes which have setup_fields () executing */
static MonoNativeTlsKey setup_fields_tls_id;
static MonoNativeTlsKey init_pending_tls_id;
static void
classes_lock (void)
{
mono_locks_os_acquire (&classes_mutex, ClassesLock);
}
static void
classes_unlock (void)
{
mono_locks_os_release (&classes_mutex, ClassesLock);
}
/*
We use gclass recording to allow recursive system f types to be referenced by a parent.
Given the following type hierarchy:
class TextBox : TextBoxBase<TextBox> {}
class TextBoxBase<T> : TextInput<TextBox> where T : TextBoxBase<T> {}
class TextInput<T> : Input<T> where T: TextInput<T> {}
class Input<T> {}
The runtime tries to load TextBoxBase<>.
To load TextBoxBase<> to do so it must resolve the parent which is TextInput<TextBox>.
To instantiate TextInput<TextBox> it must resolve TextInput<> and TextBox.
To load TextBox it must resolve the parent which is TextBoxBase<TextBox>.
At this point the runtime must instantiate TextBoxBase<TextBox>. Both types are partially loaded
at this point, iow, both are registered in the type map and both and a NULL parent. This means
that the resulting generic instance will have a NULL parent, which is wrong and will cause breakage.
To fix that what we do is to record all generic instantes created while resolving the parent of
any generic type definition and, after resolved, correct the parent field if needed.
*/
static int record_gclass_instantiation;
static GSList *gclass_recorded_list;
typedef gboolean (*gclass_record_func) (MonoClass*, void*);
/*
* LOCKING: loader lock must be held until pairing disable_gclass_recording is called.
*/
static void
enable_gclass_recording (void)
{
++record_gclass_instantiation;
}
/*
* LOCKING: loader lock must be held since pairing enable_gclass_recording was called.
*/
static void
disable_gclass_recording (gclass_record_func func, void *user_data)
{
GSList **head = &gclass_recorded_list;
g_assert (record_gclass_instantiation > 0);
--record_gclass_instantiation;
while (*head) {
GSList *node = *head;
if (func ((MonoClass*)node->data, user_data)) {
*head = node->next;
g_slist_free_1 (node);
} else {
head = &node->next;
}
}
/* We automatically discard all recorded gclasses when disabled. */
if (!record_gclass_instantiation && gclass_recorded_list) {
g_slist_free (gclass_recorded_list);
gclass_recorded_list = NULL;
}
}
#define mono_class_new0(klass,struct_type, n_structs) \
((struct_type *) mono_class_alloc0 ((klass), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
/**
* mono_class_setup_basic_field_info:
* \param class The class to initialize
*
* Initializes the following fields in MonoClass:
* * klass->fields (only field->parent and field->name)
* * klass->field.count
* * klass->first_field_idx
* LOCKING: Acquires the loader lock
*/
void
mono_class_setup_basic_field_info (MonoClass *klass)
{
MonoGenericClass *gklass;
MonoClassField *field;
MonoClassField *fields;
MonoClass *gtd;
MonoImage *image;
int i, top;
if (klass->fields)
return;
gklass = mono_class_try_get_generic_class (klass);
gtd = gklass ? mono_class_get_generic_type_definition (klass) : NULL;
image = klass->image;
if (gklass && image_is_dynamic (gklass->container_class->image) && !gklass->container_class->wastypebuilder) {
/*
* This happens when a generic instance of an unfinished generic typebuilder
* is used as an element type for creating an array type. We can't initialize
* the fields of this class using the fields of gklass, since gklass is not
* finished yet, fields could be added to it later.
*/
return;
}
if (gtd) {
mono_class_setup_basic_field_info (gtd);
mono_loader_lock ();
mono_class_set_field_count (klass, mono_class_get_field_count (gtd));
mono_loader_unlock ();
}
top = mono_class_get_field_count (klass);
fields = (MonoClassField *)mono_class_alloc0 (klass, sizeof (MonoClassField) * top);
/*
* Fetch all the field information.
*/
int first_field_idx = mono_class_has_static_metadata (klass) ? mono_class_get_first_field_idx (klass) : 0;
for (i = 0; i < top; i++) {
field = &fields [i];
m_field_set_parent (field, klass);
if (gtd) {
field->name = mono_field_get_name (>d->fields [i]);
} else {
int idx = first_field_idx + i;
/* first_field_idx and idx points into the fieldptr table */
guint32 name_idx = mono_metadata_decode_table_row_col (image, MONO_TABLE_FIELD, idx, MONO_FIELD_NAME);
/* The name is needed for fieldrefs */
field->name = mono_metadata_string_heap (image, name_idx);
}
}
mono_memory_barrier ();
mono_loader_lock ();
if (!klass->fields)
klass->fields = fields;
mono_loader_unlock ();
}
/**
* mono_class_setup_fields:
* \p klass The class to initialize
*
* Initializes klass->fields, computes class layout and sizes.
* typebuilder_setup_fields () is the corresponding function for dynamic classes.
* Sets the following fields in \p klass:
* - all the fields initialized by mono_class_init_sizes ()
* - element_class/cast_class (for enums)
* - sizes:element_size (for arrays)
* - field->type/offset for all fields
* - fields_inited
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_fields (MonoClass *klass)
{
ERROR_DECL (error);
MonoImage *m = klass->image;
int top;
guint32 layout = mono_class_get_flags (klass) & TYPE_ATTRIBUTE_LAYOUT_MASK;
int i;
guint32 real_size = 0;
guint32 packing_size = 0;
int instance_size;
gboolean explicit_size;
MonoClassField *field;
MonoGenericClass *gklass = mono_class_try_get_generic_class (klass);
MonoClass *gtd = gklass ? mono_class_get_generic_type_definition (klass) : NULL;
if (klass->fields_inited)
return;
if (gklass && image_is_dynamic (gklass->container_class->image) && !gklass->container_class->wastypebuilder) {
/*
* This happens when a generic instance of an unfinished generic typebuilder
* is used as an element type for creating an array type. We can't initialize
* the fields of this class using the fields of gklass, since gklass is not
* finished yet, fields could be added to it later.
*/
return;
}
mono_class_setup_basic_field_info (klass);
top = mono_class_get_field_count (klass);
if (gtd) {
mono_class_setup_fields (gtd);
if (mono_class_set_type_load_failure_causedby_class (klass, gtd, "Generic type definition failed"))
return;
}
instance_size = 0;
if (klass->parent) {
/* For generic instances, klass->parent might not have been initialized */
mono_class_init_internal (klass->parent);
mono_class_setup_fields (klass->parent);
if (mono_class_set_type_load_failure_causedby_class (klass, klass->parent, "Could not set up parent class"))
return;
instance_size = klass->parent->instance_size;
} else {
instance_size = MONO_ABI_SIZEOF (MonoObject);
}
/* Get the real size */
explicit_size = mono_metadata_packing_from_typedef (klass->image, klass->type_token, &packing_size, &real_size);
if (explicit_size)
instance_size += real_size;
if (mono_is_corlib_image (klass->image) && !strcmp (klass->name_space, "System.Numerics") && !strcmp (klass->name, "Register")) {
if (mono_simd_register_size)
instance_size += mono_simd_register_size;
}
/*
* This function can recursively call itself.
* Prevent infinite recursion by using a list in TLS.
*/
GSList *init_list = (GSList *)mono_native_tls_get_value (setup_fields_tls_id);
if (g_slist_find (init_list, klass))
return;
init_list = g_slist_prepend (init_list, klass);
mono_native_tls_set_value (setup_fields_tls_id, init_list);
/*
* Fetch all the field information.
*/
int first_field_idx = mono_class_has_static_metadata (klass) ? mono_class_get_first_field_idx (klass) : 0;
for (i = 0; i < top; i++) {
int idx = first_field_idx + i;
field = &klass->fields [i];
if (!field->type) {
mono_field_resolve_type (field, error);
if (!is_ok (error)) {
/*mono_field_resolve_type already failed class*/
mono_error_cleanup (error);
break;
}
if (!field->type)
g_error ("could not resolve %s:%s\n", mono_type_get_full_name(klass), field->name);
g_assert (field->type);
}
if (!mono_type_get_underlying_type (field->type)) {
mono_class_set_type_load_failure (klass, "Field '%s' is an enum type with a bad underlying type", field->name);
break;
}
if (mono_field_is_deleted (field))
continue;
if (layout == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
guint32 uoffset;
mono_metadata_field_info (m, idx, &uoffset, NULL, NULL);
int offset = uoffset;
if (offset == (guint32)-1 && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
mono_class_set_type_load_failure (klass, "Missing field layout info for %s", field->name);
break;
}
if (m_type_is_byref (field->type) && (offset % MONO_ABI_ALIGNOF (gpointer) != 0)) {
mono_class_set_type_load_failure (klass, "Field '%s' has an invalid offset", field->name);
break;
}
if (offset < -1) { /*-1 is used to encode special static fields */
mono_class_set_type_load_failure (klass, "Field '%s' has a negative offset %d", field->name, offset);
break;
}
if (mono_class_is_gtd (klass)) {
mono_class_set_type_load_failure (klass, "Generic class cannot have explicit layout.");
break;
}
}
if (mono_type_has_exceptions (field->type)) {
char *class_name = mono_type_get_full_name (klass);
char *type_name = mono_type_full_name (field->type);
mono_class_set_type_load_failure (klass, "Invalid type %s for instance field %s:%s", type_name, class_name, field->name);
g_free (class_name);
g_free (type_name);
break;
}
if (m_type_is_byref (field->type)) {
if (!m_class_is_byreflike (klass)) {
char *class_name = mono_type_get_full_name (klass);
mono_class_set_type_load_failure (klass, "Type %s is not a ByRefLike type so ref field, '%s', is invalid", class_name, field->name);
g_free (class_name);
break;
}
}
/* The def_value of fields is compute lazily during vtable creation */
}
if (!mono_class_has_failure (klass)) {
mono_loader_lock ();
mono_class_layout_fields (klass, instance_size, packing_size, real_size, FALSE);
mono_loader_unlock ();
}
init_list = g_slist_remove (init_list, klass);
mono_native_tls_set_value (setup_fields_tls_id, init_list);
}
static gboolean
discard_gclass_due_to_failure (MonoClass *gclass, void *user_data)
{
return mono_class_get_generic_class (gclass)->container_class == user_data;
}
static gboolean
fix_gclass_incomplete_instantiation (MonoClass *gclass, void *user_data)
{
MonoClass *gtd = (MonoClass*)user_data;
/* Only try to fix generic instances of @gtd */
if (mono_class_get_generic_class (gclass)->container_class != gtd)
return FALSE;
/* Check if the generic instance has no parent. */
if (gtd->parent && !gclass->parent)
mono_generic_class_setup_parent (gclass, gtd);
return TRUE;
}
static void
mono_class_set_failure_and_error (MonoClass *klass, MonoError *error, const char *msg)
{
mono_class_set_type_load_failure (klass, "%s", msg);
mono_error_set_type_load_class (error, klass, "%s", msg);
}
/**
* mono_class_create_from_typedef:
* \param image: image where the token is valid
* \param type_token: typedef token
* \param error: used to return any error found while creating the type
*
* Create the MonoClass* representing the specified type token.
* \p type_token must be a TypeDef token.
*
* FIXME: don't return NULL on failure, just let the caller figure it out.
*/
MonoClass *
mono_class_create_from_typedef (MonoImage *image, guint32 type_token, MonoError *error)
{
MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
MonoClass *klass, *parent = NULL;
guint32 cols [MONO_TYPEDEF_SIZE];
guint32 cols_next [MONO_TYPEDEF_SIZE];
guint tidx = mono_metadata_token_index (type_token);
MonoGenericContext *context = NULL;
const char *name, *nspace;
guint icount = 0;
MonoClass **interfaces;
guint32 field_last, method_last;
guint32 nesting_tokeen;
error_init (error);
/* FIXME: metadata-update - this function needs extensive work */
if (mono_metadata_token_table (type_token) != MONO_TABLE_TYPEDEF || mono_metadata_table_bounds_check (image, MONO_TABLE_TYPEDEF, tidx)) {
mono_error_set_bad_image (error, image, "Invalid typedef token %x", type_token);
return NULL;
}
mono_loader_lock ();
if ((klass = (MonoClass *)mono_internal_hash_table_lookup (&image->class_cache, GUINT_TO_POINTER (type_token)))) {
mono_loader_unlock ();
return klass;
}
mono_metadata_decode_row (tt, tidx - 1, cols, MONO_TYPEDEF_SIZE);
name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
if (mono_metadata_has_generic_params (image, type_token)) {
klass = (MonoClass*)mono_image_alloc0 (image, sizeof (MonoClassGtd));
klass->class_kind = MONO_CLASS_GTD;
UnlockedAdd (&classes_size, sizeof (MonoClassGtd));
++class_gtd_count;
} else {
klass = (MonoClass*)mono_image_alloc0 (image, sizeof (MonoClassDef));
klass->class_kind = MONO_CLASS_DEF;
UnlockedAdd (&classes_size, sizeof (MonoClassDef));
++class_def_count;
}
klass->name = name;
klass->name_space = nspace;
MONO_PROFILER_RAISE (class_loading, (klass));
klass->image = image;
klass->type_token = type_token;
mono_class_set_flags (klass, cols [MONO_TYPEDEF_FLAGS]);
mono_internal_hash_table_insert (&image->class_cache, GUINT_TO_POINTER (type_token), klass);
/*
* Check whether we're a generic type definition.
*/
if (mono_class_is_gtd (klass)) {
MonoGenericContainer *generic_container = mono_metadata_load_generic_params (image, klass->type_token, NULL, klass);
context = &generic_container->context;
mono_class_set_generic_container (klass, generic_container);
MonoType *canonical_inst = &((MonoClassGtd*)klass)->canonical_inst;
canonical_inst->type = MONO_TYPE_GENERICINST;
canonical_inst->data.generic_class = mono_metadata_lookup_generic_class (klass, context->class_inst, FALSE);
enable_gclass_recording ();
}
if (cols [MONO_TYPEDEF_EXTENDS]) {
MonoClass *tmp;
guint32 parent_token = mono_metadata_token_from_dor (cols [MONO_TYPEDEF_EXTENDS]);
if (mono_metadata_token_table (parent_token) == MONO_TABLE_TYPESPEC) {
/*WARNING: this must satisfy mono_metadata_type_hash*/
klass->this_arg.byref__ = 1;
klass->this_arg.data.klass = klass;
klass->this_arg.type = MONO_TYPE_CLASS;
klass->_byval_arg.data.klass = klass;
klass->_byval_arg.type = MONO_TYPE_CLASS;
}
parent = mono_class_get_checked (image, parent_token, error);
if (parent && context) /* Always inflate */
parent = mono_class_inflate_generic_class_checked (parent, context, error);
if (parent == NULL) {
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
goto parent_failure;
}
for (tmp = parent; tmp; tmp = tmp->parent) {
if (tmp == klass) {
mono_class_set_failure_and_error (klass, error, "Cycle found while resolving parent");
goto parent_failure;
}
if (mono_class_is_gtd (klass) && mono_class_is_ginst (tmp) && mono_class_get_generic_class (tmp)->container_class == klass) {
mono_class_set_failure_and_error (klass, error, "Parent extends generic instance of this type");
goto parent_failure;
}
}
}
mono_class_setup_parent (klass, parent);
/* uses ->valuetype, which is initialized by mono_class_setup_parent above */
mono_class_setup_mono_type (klass);
if (mono_class_is_gtd (klass))
disable_gclass_recording (fix_gclass_incomplete_instantiation, klass);
/*
* This might access klass->_byval_arg for recursion generated by generic constraints,
* so it has to come after setup_mono_type ().
*/
if ((nesting_tokeen = mono_metadata_nested_in_typedef (image, type_token))) {
klass->nested_in = mono_class_create_from_typedef (image, nesting_tokeen, error);
if (!is_ok (error)) {
/*FIXME implement a mono_class_set_failure_from_mono_error */
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
}
if ((mono_class_get_flags (klass) & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_UNICODE_CLASS)
klass->unicode = 1;
#ifdef HOST_WIN32
if ((mono_class_get_flags (klass) & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_AUTO_CLASS)
klass->unicode = 1;
#endif
klass->cast_class = klass->element_class = klass;
if (mono_is_corlib_image (klass->image)) {
switch (m_class_get_byval_arg (klass)->type) {
case MONO_TYPE_I1:
if (mono_defaults.byte_class)
klass->cast_class = mono_defaults.byte_class;
break;
case MONO_TYPE_U1:
if (mono_defaults.sbyte_class)
mono_defaults.sbyte_class = klass;
break;
case MONO_TYPE_I2:
if (mono_defaults.uint16_class)
mono_defaults.uint16_class = klass;
break;
case MONO_TYPE_U2:
if (mono_defaults.int16_class)
klass->cast_class = mono_defaults.int16_class;
break;
case MONO_TYPE_I4:
if (mono_defaults.uint32_class)
mono_defaults.uint32_class = klass;
break;
case MONO_TYPE_U4:
if (mono_defaults.int32_class)
klass->cast_class = mono_defaults.int32_class;
break;
case MONO_TYPE_I8:
if (mono_defaults.uint64_class)
mono_defaults.uint64_class = klass;
break;
case MONO_TYPE_U8:
if (mono_defaults.int64_class)
klass->cast_class = mono_defaults.int64_class;
break;
default:
break;
}
}
if (!klass->enumtype) {
if (!mono_metadata_interfaces_from_typedef_full (
image, type_token, &interfaces, &icount, FALSE, context, error)){
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
/* This is required now that it is possible for more than 2^16 interfaces to exist. */
g_assert(icount <= 65535);
klass->interfaces = interfaces;
klass->interface_count = icount;
klass->interfaces_inited = 1;
}
/*g_print ("Load class %s\n", name);*/
/*
* Compute the field and method lists
*/
/*
* EnC metadata-update: new classes are added with method and field indices set to 0, new
* methods are added using the EnCLog AddMethod or AddField functions that will be added to
* MonoClassMetadataUpdateInfo
*/
if (G_LIKELY (cols [MONO_TYPEDEF_FIELD_LIST] != 0 || cols [MONO_TYPEDEF_METHOD_LIST] != 0)) {
int first_field_idx;
first_field_idx = cols [MONO_TYPEDEF_FIELD_LIST] - 1;
mono_class_set_first_field_idx (klass, first_field_idx);
int first_method_idx;
first_method_idx = cols [MONO_TYPEDEF_METHOD_LIST] - 1;
mono_class_set_first_method_idx (klass, first_method_idx);
if (table_info_get_rows (tt) > tidx) {
mono_metadata_decode_row (tt, tidx, cols_next, MONO_TYPEDEF_SIZE);
field_last = cols_next [MONO_TYPEDEF_FIELD_LIST] - 1;
method_last = cols_next [MONO_TYPEDEF_METHOD_LIST] - 1;
} else {
field_last = table_info_get_rows (&image->tables [MONO_TABLE_FIELD]);
method_last = table_info_get_rows (&image->tables [MONO_TABLE_METHOD]);
}
if (cols [MONO_TYPEDEF_FIELD_LIST] &&
cols [MONO_TYPEDEF_FIELD_LIST] <= table_info_get_rows (&image->tables [MONO_TABLE_FIELD]))
mono_class_set_field_count (klass, field_last - first_field_idx);
if (cols [MONO_TYPEDEF_METHOD_LIST] <= table_info_get_rows (&image->tables [MONO_TABLE_METHOD]))
mono_class_set_method_count (klass, method_last - first_method_idx);
}
/* reserve space to store vector pointer in arrays */
if (mono_is_corlib_image (image) && !strcmp (nspace, "System") && !strcmp (name, "Array")) {
klass->instance_size += 2 * TARGET_SIZEOF_VOID_P;
/* TODO: check that array has 0 non-const fields */
}
if (klass->enumtype) {
MonoType *enum_basetype = mono_class_find_enum_basetype (klass, error);
if (!enum_basetype) {
/*set it to a default value as the whole runtime can't handle this to be null*/
klass->cast_class = klass->element_class = mono_defaults.int32_class;
mono_class_set_type_load_failure (klass, "%s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
klass->cast_class = klass->element_class = mono_class_from_mono_type_internal (enum_basetype);
}
/*
* If we're a generic type definition, load the constraints.
* We must do this after the class has been constructed to make certain recursive scenarios
* work.
*/
if (mono_class_is_gtd (klass) && !mono_metadata_load_generic_param_constraints_checked (image, type_token, mono_class_get_generic_container (klass), error)) {
mono_class_set_type_load_failure (klass, "Could not load generic parameter constrains due to %s", mono_error_get_message (error));
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
if (klass->image->assembly_name && !strcmp (klass->image->assembly_name, "Mono.Simd") && !strcmp (nspace, "Mono.Simd")) {
if (!strncmp (name, "Vector", 6))
klass->simd_type = !strcmp (name + 6, "2d") || !strcmp (name + 6, "2ul") || !strcmp (name + 6, "2l") || !strcmp (name + 6, "4f") || !strcmp (name + 6, "4ui") || !strcmp (name + 6, "4i") || !strcmp (name + 6, "8s") || !strcmp (name + 6, "8us") || !strcmp (name + 6, "16b") || !strcmp (name + 6, "16sb");
} else if (klass->image->assembly_name && !strcmp (klass->image->assembly_name, "System.Numerics") && !strcmp (nspace, "System.Numerics")) {
/* The JIT can't handle SIMD types with != 16 size yet */
//if (!strcmp (name, "Vector2") || !strcmp (name, "Vector3") || !strcmp (name, "Vector4"))
if (!strcmp (name, "Vector4"))
klass->simd_type = 1;
}
// compute is_byreflike
if (m_class_is_valuetype (klass))
if (class_has_isbyreflike_attribute (klass))
klass->is_byreflike = 1;
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_loaded, (klass));
return klass;
parent_failure:
if (mono_class_is_gtd (klass))
disable_gclass_recording (discard_gclass_due_to_failure, klass);
mono_class_setup_mono_type (klass);
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_failed, (klass));
return NULL;
}
static void
mono_generic_class_setup_parent (MonoClass *klass, MonoClass *gtd)
{
if (gtd->parent) {
ERROR_DECL (error);
MonoGenericClass *gclass = mono_class_get_generic_class (klass);
klass->parent = mono_class_inflate_generic_class_checked (gtd->parent, mono_generic_class_get_context (gclass), error);
if (!is_ok (error)) {
/*Set parent to something safe as the runtime doesn't handle well this kind of failure.*/
klass->parent = mono_defaults.object_class;
mono_class_set_type_load_failure (klass, "Parent is a generic type instantiation that failed due to: %s", mono_error_get_message (error));
mono_error_cleanup (error);
}
}
mono_loader_lock ();
if (klass->parent)
mono_class_setup_parent (klass, klass->parent);
if (klass->enumtype) {
klass->cast_class = gtd->cast_class;
klass->element_class = gtd->element_class;
}
mono_loader_unlock ();
}
struct FoundAttrUD {
/* inputs */
const char *nspace;
const char *name;
gboolean in_corlib;
/* output */
gboolean has_attr;
};
static gboolean
has_wellknown_attribute_func (MonoImage *image, guint32 typeref_scope_token, const char *nspace, const char *name, guint32 method_token, gpointer user_data)
{
struct FoundAttrUD *has_attr = (struct FoundAttrUD *)user_data;
if (!strcmp (name, has_attr->name) && !strcmp (nspace, has_attr->nspace)) {
has_attr->has_attr = TRUE;
return TRUE;
}
/* TODO: use typeref_scope_token to check that attribute comes from
* corlib if in_corlib is TRUE, without triggering an assembly load.
* If we're inside corlib, expect the scope to be
* MONO_RESOLUTION_SCOPE_MODULE I think, if we're outside it'll be an
* MONO_RESOLUTION_SCOPE_ASSEMBLYREF and we'll need to check the
* name.*/
return FALSE;
}
static gboolean
class_has_wellknown_attribute (MonoClass *klass, const char *nspace, const char *name, gboolean in_corlib)
{
struct FoundAttrUD has_attr;
has_attr.nspace = nspace;
has_attr.name = name;
has_attr.in_corlib = in_corlib;
has_attr.has_attr = FALSE;
mono_class_metadata_foreach_custom_attr (klass, has_wellknown_attribute_func, &has_attr);
return has_attr.has_attr;
}
static gboolean
method_has_wellknown_attribute (MonoMethod *method, const char *nspace, const char *name, gboolean in_corlib)
{
struct FoundAttrUD has_attr;
has_attr.nspace = nspace;
has_attr.name = name;
has_attr.in_corlib = in_corlib;
has_attr.has_attr = FALSE;
mono_method_metadata_foreach_custom_attr (method, has_wellknown_attribute_func, &has_attr);
return has_attr.has_attr;
}
static gboolean
class_has_isbyreflike_attribute (MonoClass *klass)
{
return class_has_wellknown_attribute (klass, "System.Runtime.CompilerServices", "IsByRefLikeAttribute", TRUE);
}
gboolean
mono_class_setup_method_has_preserve_base_overrides_attribute (MonoMethod *method)
{
MonoImage *image = m_class_get_image (method->klass);
/* FIXME: implement well known attribute check for dynamic images */
if (image_is_dynamic (image))
return FALSE;
return method_has_wellknown_attribute (method, "System.Runtime.CompilerServices", "PreserveBaseOverridesAttribute", TRUE);
}
static gboolean
check_valid_generic_inst_arguments (MonoGenericInst *inst, MonoError *error)
{
for (int i = 0; i < inst->type_argc; i++) {
if (!mono_type_is_valid_generic_argument (inst->type_argv [i])) {
char *type_name = mono_type_full_name (inst->type_argv [i]);
mono_error_set_invalid_program (error, "generic type cannot be instantiated with type '%s'", type_name);
g_free (type_name);
return FALSE;
}
}
return TRUE;
}
/*
* Create the `MonoClass' for an instantiation of a generic type.
* We only do this if we actually need it.
* This will sometimes return a GTD due to checking the cached_class.
*/
MonoClass*
mono_class_create_generic_inst (MonoGenericClass *gclass)
{
MonoClass *klass, *gklass;
if (gclass->cached_class)
return gclass->cached_class;
klass = (MonoClass *)mono_mem_manager_alloc0 ((MonoMemoryManager*)gclass->owner, sizeof (MonoClassGenericInst));
gklass = gclass->container_class;
if (gklass->nested_in) {
/* The nested_in type should not be inflated since it's possible to produce a nested type with less generic arguments*/
klass->nested_in = gklass->nested_in;
}
klass->name = gklass->name;
klass->name_space = gklass->name_space;
klass->image = gklass->image;
klass->type_token = gklass->type_token;
klass->class_kind = MONO_CLASS_GINST;
//FIXME add setter
((MonoClassGenericInst*)klass)->generic_class = gclass;
klass->_byval_arg.type = MONO_TYPE_GENERICINST;
klass->this_arg.type = m_class_get_byval_arg (klass)->type;
klass->this_arg.data.generic_class = klass->_byval_arg.data.generic_class = gclass;
klass->this_arg.byref__ = TRUE;
klass->enumtype = gklass->enumtype;
klass->valuetype = gklass->valuetype;
if (gklass->image->assembly_name && !strcmp (gklass->image->assembly_name, "System.Numerics.Vectors") && !strcmp (gklass->name_space, "System.Numerics") && !strcmp (gklass->name, "Vector`1")) {
g_assert (gclass->context.class_inst);
g_assert (gclass->context.class_inst->type_argc > 0);
if (mono_type_is_primitive (gclass->context.class_inst->type_argv [0]))
klass->simd_type = 1;
}
if (mono_is_corlib_image (gklass->image) &&
(!strcmp (gklass->name, "Vector`1") || !strcmp (gklass->name, "Vector64`1") || !strcmp (gklass->name, "Vector128`1") || !strcmp (gklass->name, "Vector256`1"))) {
MonoType *etype = gclass->context.class_inst->type_argv [0];
if (mono_type_is_primitive (etype) && etype->type != MONO_TYPE_CHAR && etype->type != MONO_TYPE_BOOLEAN)
klass->simd_type = 1;
}
klass->is_array_special_interface = gklass->is_array_special_interface;
klass->cast_class = klass->element_class = klass;
if (m_class_is_valuetype (klass)) {
klass->is_byreflike = gklass->is_byreflike;
}
if (gclass->is_dynamic) {
/*
* We don't need to do any init workf with unbaked typebuilders. Generic instances created at this point will be later unregistered and/or fixed.
* This is to avoid work that would probably give wrong results as fields change as we build the TypeBuilder.
* See remove_instantiations_of_and_ensure_contents in reflection.c and its usage in reflection.c to understand the fixup stage of SRE banking.
*/
if (!gklass->wastypebuilder)
klass->inited = 1;
if (klass->enumtype) {
/*
* For enums, gklass->fields might not been set, but instance_size etc. is
* already set in mono_reflection_create_internal_class (). For non-enums,
* these will be computed normally in mono_class_layout_fields ().
*/
klass->instance_size = gklass->instance_size;
klass->sizes.class_size = gklass->sizes.class_size;
klass->size_inited = 1;
}
}
{
ERROR_DECL (error_inst);
if (!check_valid_generic_inst_arguments (gclass->context.class_inst, error_inst)) {
char *gklass_name = mono_type_get_full_name (gklass);
mono_class_set_type_load_failure (klass, "Could not instantiate %s due to %s", gklass_name, mono_error_get_message (error_inst));
g_free (gklass_name);
mono_error_cleanup (error_inst);
}
}
mono_loader_lock ();
if (gclass->cached_class) {
mono_loader_unlock ();
return gclass->cached_class;
}
if (record_gclass_instantiation > 0)
gclass_recorded_list = g_slist_append (gclass_recorded_list, klass);
if (mono_class_is_nullable (klass))
klass->cast_class = klass->element_class = mono_class_get_nullable_param_internal (klass);
MONO_PROFILER_RAISE (class_loading, (klass));
mono_generic_class_setup_parent (klass, gklass);
if (gclass->is_dynamic)
mono_class_setup_supertypes (klass);
mono_memory_barrier ();
gclass->cached_class = klass;
MONO_PROFILER_RAISE (class_loaded, (klass));
++class_ginst_count;
inflated_classes_size += sizeof (MonoClassGenericInst);
mono_loader_unlock ();
return klass;
}
/*
* For a composite class like uint32[], uint32*, set MonoClass:cast_class to the corresponding "intermediate type" (for
* arrays) or "verification type" (for pointers) in the sense of ECMA I.8.7.3. This will be used by
* mono_class_is_assignable_from.
*
* Assumes MonoClass:cast_class is already set (for example if it's an array of
* some enum) and adjusts it.
*/
static void
class_composite_fixup_cast_class (MonoClass *klass, gboolean for_ptr)
{
switch (m_class_get_byval_arg (m_class_get_cast_class (klass))->type) {
case MONO_TYPE_BOOLEAN:
if (!for_ptr)
break;
klass->cast_class = mono_defaults.byte_class;
break;
case MONO_TYPE_I1:
klass->cast_class = mono_defaults.byte_class;
break;
case MONO_TYPE_U2:
klass->cast_class = mono_defaults.int16_class;
break;
case MONO_TYPE_U4:
#if TARGET_SIZEOF_VOID_P == 4
case MONO_TYPE_I:
case MONO_TYPE_U:
#endif
klass->cast_class = mono_defaults.int32_class;
break;
case MONO_TYPE_U8:
#if TARGET_SIZEOF_VOID_P == 8
case MONO_TYPE_I:
case MONO_TYPE_U:
#endif
klass->cast_class = mono_defaults.int64_class;
break;
default:
break;
}
}
static gboolean
class_kind_may_contain_generic_instances (MonoTypeKind kind)
{
/* classes of type generic inst may contain generic arguments from other images,
* as well as arrays and pointers whose element types (recursively) may be a generic inst */
return (kind == MONO_CLASS_GINST || kind == MONO_CLASS_ARRAY || kind == MONO_CLASS_POINTER);
}
/**
* mono_class_create_bounded_array:
* \param element_class element class
* \param rank the dimension of the array class
* \param bounded whenever the array has non-zero bounds
* \returns A class object describing the array with element type \p element_type and
* dimension \p rank.
*/
MonoClass *
mono_class_create_bounded_array (MonoClass *eclass, guint32 rank, gboolean bounded)
{
MonoImage *image;
MonoClass *klass, *cached, *k;
MonoClass *parent = NULL;
GSList *list, *rootlist = NULL;
int nsize;
char *name;
MonoMemoryManager *mm;
if (rank > 1)
/* bounded only matters for one-dimensional arrays */
bounded = FALSE;
image = eclass->image;
// FIXME: Optimize this
mm = class_kind_may_contain_generic_instances ((MonoTypeKind)eclass->class_kind) ? mono_metadata_get_mem_manager_for_class (eclass) : NULL;
/* Check cache */
cached = NULL;
if (rank == 1 && !bounded) {
if (mm) {
mono_mem_manager_lock (mm);
if (!mm->szarray_cache)
mm->szarray_cache = g_hash_table_new_full (mono_aligned_addr_hash, NULL, NULL, NULL);
cached = (MonoClass *)g_hash_table_lookup (mm->szarray_cache, eclass);
mono_mem_manager_unlock (mm);
} else {
/*
* This case is very frequent not just during compilation because of calls
* from mono_class_from_mono_type_internal (), mono_array_new (),
* Array:CreateInstance (), etc, so use a separate cache + a separate lock.
*/
mono_os_mutex_lock (&image->szarray_cache_lock);
if (!image->szarray_cache)
image->szarray_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
cached = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
}
} else {
if (mm) {
mono_mem_manager_lock (mm);
if (!mm->array_cache)
mm->array_cache = g_hash_table_new_full (mono_aligned_addr_hash, NULL, NULL, NULL);
rootlist = (GSList *)g_hash_table_lookup (mm->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
mono_mem_manager_unlock (mm);
} else {
mono_loader_lock ();
if (!image->array_cache)
image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
rootlist = (GSList *)g_hash_table_lookup (image->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
mono_loader_unlock ();
}
}
if (cached)
return cached;
parent = mono_defaults.array_class;
if (!parent->inited)
mono_class_init_internal (parent);
klass = mm ? (MonoClass *)mono_mem_manager_alloc0 (mm, sizeof (MonoClassArray)) : (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClassArray));
klass->image = image;
klass->name_space = eclass->name_space;
klass->class_kind = MONO_CLASS_ARRAY;
nsize = strlen (eclass->name);
int maxrank = MIN (rank, 32);
name = (char *)g_malloc (nsize + 2 + maxrank + 1);
memcpy (name, eclass->name, nsize);
name [nsize] = '[';
if (maxrank > 1)
memset (name + nsize + 1, ',', maxrank - 1);
if (bounded)
name [nsize + maxrank] = '*';
name [nsize + maxrank + bounded] = ']';
name [nsize + maxrank + bounded + 1] = 0;
klass->name = mm ? mono_mem_manager_strdup (mm, name) : mono_image_strdup (image, name);
g_free (name);
klass->type_token = 0;
klass->parent = parent;
klass->instance_size = mono_class_instance_size (klass->parent);
klass->rank = rank;
klass->element_class = eclass;
if (m_class_get_byval_arg (eclass)->type == MONO_TYPE_TYPEDBYREF) {
/*Arrays of those two types are invalid.*/
ERROR_DECL (prepared_error);
mono_error_set_invalid_program (prepared_error, "Arrays of System.TypedReference types are invalid.");
mono_class_set_failure (klass, mono_error_box (prepared_error, klass->image));
mono_error_cleanup (prepared_error);
} else if (m_class_is_byreflike (eclass)) {
/* .NET Core throws a type load exception: "Could not create array type 'fullname[]'" */
char *full_name = mono_type_get_full_name (eclass);
mono_class_set_type_load_failure (klass, "Could not create array type '%s[]'", full_name);
g_free (full_name);
} else if (eclass->enumtype && !mono_class_enum_basetype_internal (eclass)) {
MonoGCHandle ref_info_handle = mono_class_get_ref_info_handle (eclass);
if (!ref_info_handle || eclass->wastypebuilder) {
g_warning ("Only incomplete TypeBuilder objects are allowed to be an enum without base_type");
g_assert (ref_info_handle && !eclass->wastypebuilder);
}
/* element_size -1 is ok as this is not an instantitable type*/
klass->sizes.element_size = -1;
} else
klass->sizes.element_size = -1;
mono_class_setup_supertypes (klass);
if (mono_class_is_ginst (eclass))
mono_class_init_internal (eclass);
if (!eclass->size_inited)
mono_class_setup_fields (eclass);
mono_class_set_type_load_failure_causedby_class (klass, eclass, "Could not load array element type");
/*FIXME we fail the array type, but we have to let other fields be set.*/
klass->has_references = MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (eclass)) || m_class_has_references (eclass)? TRUE: FALSE;
if (eclass->enumtype)
klass->cast_class = eclass->element_class;
else
klass->cast_class = eclass;
class_composite_fixup_cast_class (klass, FALSE);
if ((rank > 1) || bounded) {
MonoArrayType *at = mm ? (MonoArrayType *)mono_mem_manager_alloc0 (mm, sizeof (MonoArrayType)) : (MonoArrayType *)mono_image_alloc0 (image, sizeof (MonoArrayType));
klass->_byval_arg.type = MONO_TYPE_ARRAY;
klass->_byval_arg.data.array = at;
at->eklass = eclass;
at->rank = rank;
/* FIXME: complete.... */
} else {
klass->_byval_arg.type = MONO_TYPE_SZARRAY;
klass->_byval_arg.data.klass = eclass;
}
klass->this_arg = klass->_byval_arg;
klass->this_arg.byref__ = 1;
if (rank > 32) {
ERROR_DECL (prepared_error);
name = mono_type_get_full_name (klass);
mono_error_set_type_load_class (prepared_error, klass, "%s has too many dimensions.", name);
mono_class_set_failure (klass, mono_error_box (prepared_error, klass->image));
mono_error_cleanup (prepared_error);
g_free (name);
}
mono_loader_lock ();
/* Check cache again */
cached = NULL;
if (rank == 1 && !bounded) {
if (mm) {
mono_mem_manager_lock (mm);
cached = (MonoClass *)g_hash_table_lookup (mm->szarray_cache, eclass);
mono_mem_manager_unlock (mm);
} else {
mono_os_mutex_lock (&image->szarray_cache_lock);
cached = (MonoClass *)g_hash_table_lookup (image->szarray_cache, eclass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
}
} else {
if (mm) {
mono_mem_manager_lock (mm);
rootlist = (GSList *)g_hash_table_lookup (mm->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
mono_mem_manager_unlock (mm);
} else {
rootlist = (GSList *)g_hash_table_lookup (image->array_cache, eclass);
for (list = rootlist; list; list = list->next) {
k = (MonoClass *)list->data;
if ((m_class_get_rank (k) == rank) && (m_class_get_byval_arg (k)->type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
cached = k;
break;
}
}
}
}
if (cached) {
mono_loader_unlock ();
return cached;
}
MONO_PROFILER_RAISE (class_loading, (klass));
UnlockedAdd (&classes_size, sizeof (MonoClassArray));
++class_array_count;
if (rank == 1 && !bounded) {
if (mm) {
mono_mem_manager_lock (mm);
g_hash_table_insert (mm->szarray_cache, eclass, klass);
mono_mem_manager_unlock (mm);
} else {
mono_os_mutex_lock (&image->szarray_cache_lock);
g_hash_table_insert (image->szarray_cache, eclass, klass);
mono_os_mutex_unlock (&image->szarray_cache_lock);
}
} else {
if (mm) {
mono_mem_manager_lock (mm);
list = g_slist_append (rootlist, klass);
g_hash_table_insert (mm->array_cache, eclass, list);
mono_mem_manager_unlock (mm);
} else {
list = g_slist_append (rootlist, klass);
g_hash_table_insert (image->array_cache, eclass, list);
}
}
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_loaded, (klass));
return klass;
}
/**
* mono_class_create_array:
* \param element_class element class
* \param rank the dimension of the array class
* \returns A class object describing the array with element type \p element_type and
* dimension \p rank.
*/
MonoClass *
mono_class_create_array (MonoClass *eclass, guint32 rank)
{
return mono_class_create_bounded_array (eclass, rank, FALSE);
}
// This is called by mono_class_create_generic_parameter when a new class must be created.
static MonoClass*
make_generic_param_class (MonoGenericParam *param)
{
MonoClass *klass, **ptr;
int count, pos, i, min_align;
MonoGenericParamInfo *pinfo = mono_generic_param_info (param);
MonoGenericContainer *container = mono_generic_param_owner (param);
g_assert_checked (container);
MonoImage *image = mono_get_image_for_generic_param (param);
gboolean is_mvar = container->is_method;
gboolean is_anonymous = container->is_anonymous;
klass = (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClassGenericParam));
klass->class_kind = MONO_CLASS_GPARAM;
UnlockedAdd (&classes_size, sizeof (MonoClassGenericParam));
UnlockedIncrement (&class_gparam_count);
if (!is_anonymous) {
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name , pinfo->name );
} else {
int n = mono_generic_param_num (param);
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->name , mono_make_generic_name_string (image, n) );
}
if (is_anonymous) {
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , "" );
} else if (is_mvar) {
MonoMethod *omethod = container->owner.method;
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , (omethod && omethod->klass) ? omethod->klass->name_space : "" );
} else {
MonoClass *oklass = container->owner.klass;
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->name_space , oklass ? oklass->name_space : "" );
}
MONO_PROFILER_RAISE (class_loading, (klass));
// Count non-NULL items in pinfo->constraints
count = 0;
if (!is_anonymous)
for (ptr = pinfo->constraints; ptr && *ptr; ptr++, count++)
;
pos = 0;
if ((count > 0) && !MONO_CLASS_IS_INTERFACE_INTERNAL (pinfo->constraints [0])) {
CHECKED_METADATA_WRITE_PTR ( klass->parent , pinfo->constraints [0] );
pos++;
} else if (pinfo && pinfo->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) {
CHECKED_METADATA_WRITE_PTR ( klass->parent , mono_class_load_from_name (mono_defaults.corlib, "System", "ValueType") );
} else {
CHECKED_METADATA_WRITE_PTR ( klass->parent , mono_defaults.object_class );
}
if (count - pos > 0) {
klass->interface_count = count - pos;
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->interfaces , (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos)) );
klass->interfaces_inited = TRUE;
for (i = pos; i < count; i++)
CHECKED_METADATA_WRITE_PTR ( klass->interfaces [i - pos] , pinfo->constraints [i] );
}
CHECKED_METADATA_WRITE_PTR_EXEMPT ( klass->image , image );
klass->inited = TRUE;
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->cast_class , klass );
CHECKED_METADATA_WRITE_PTR_LOCAL ( klass->element_class , klass );
MonoTypeEnum t = is_mvar ? MONO_TYPE_MVAR : MONO_TYPE_VAR;
klass->_byval_arg.type = t;
klass->this_arg.type = t;
CHECKED_METADATA_WRITE_PTR ( klass->this_arg.data.generic_param , param );
CHECKED_METADATA_WRITE_PTR ( klass->_byval_arg.data.generic_param , param );
klass->this_arg.byref__ = TRUE;
/* We don't use type_token for VAR since only classes can use it (not arrays, pointer, VARs, etc) */
klass->sizes.generic_param_token = !is_anonymous ? pinfo->token : 0;
if (param->gshared_constraint) {
MonoClass *constraint_class = mono_class_from_mono_type_internal (param->gshared_constraint);
mono_class_init_sizes (constraint_class);
klass->has_references = m_class_has_references (constraint_class);
}
/*
* This makes sure the the value size of this class is equal to the size of the types the gparam is
* constrained to, the JIT depends on this.
*/
klass->instance_size = MONO_ABI_SIZEOF (MonoObject) + mono_type_size (m_class_get_byval_arg (klass), &min_align);
klass->min_align = min_align;
mono_memory_barrier ();
klass->size_inited = 1;
mono_class_setup_supertypes (klass);
if (count - pos > 0) {
mono_class_setup_vtable (klass->parent);
if (mono_class_has_failure (klass->parent))
mono_class_set_type_load_failure (klass, "Failed to setup parent interfaces");
else
mono_class_setup_interface_offsets_internal (klass, klass->parent->vtable_size, TRUE);
}
return klass;
}
/*
* LOCKING: Acquires the image lock (@image).
*/
MonoClass *
mono_class_create_generic_parameter (MonoGenericParam *param)
{
MonoImage *image = mono_get_image_for_generic_param (param);
MonoGenericParamInfo *pinfo = mono_generic_param_info (param);
MonoClass *klass, *klass2;
// If a klass already exists for this object and is cached, return it.
klass = pinfo->pklass;
if (klass)
return klass;
// Create a new klass
klass = make_generic_param_class (param);
// Now we need to cache the klass we created.
// But since we wait to grab the lock until after creating the klass, we need to check to make sure
// another thread did not get in and cache a klass ahead of us. In that case, return their klass
// and allow our newly-created klass object to just leak.
mono_memory_barrier ();
mono_image_lock (image);
// Here "klass2" refers to the klass potentially created by the other thread.
klass2 = pinfo->pklass;
if (klass2) {
klass = klass2;
} else {
pinfo->pklass = klass;
}
mono_image_unlock (image);
/* FIXME: Should this go inside 'make_generic_param_klass'? */
if (klass2)
MONO_PROFILER_RAISE (class_failed, (klass2));
else
MONO_PROFILER_RAISE (class_loaded, (klass));
return klass;
}
/**
* mono_class_create_ptr:
*/
MonoClass *
mono_class_create_ptr (MonoType *type)
{
MonoClass *result;
MonoClass *el_class;
MonoImage *image;
char *name;
MonoMemoryManager *mm;
el_class = mono_class_from_mono_type_internal (type);
image = el_class->image;
// FIXME: Optimize this
mm = class_kind_may_contain_generic_instances ((MonoTypeKind)el_class->class_kind) ? mono_metadata_get_mem_manager_for_class (el_class) : NULL;
if (mm) {
mono_mem_manager_lock (mm);
if (!mm->ptr_cache)
mm->ptr_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
result = (MonoClass *)g_hash_table_lookup (mm->ptr_cache, el_class);
mono_mem_manager_unlock (mm);
if (result)
return result;
} else {
mono_image_lock (image);
if (image->ptr_cache) {
if ((result = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) {
mono_image_unlock (image);
return result;
}
}
mono_image_unlock (image);
}
result = mm ? (MonoClass *)mono_mem_manager_alloc0 (mm, sizeof (MonoClassPointer)) : (MonoClass *)mono_image_alloc0 (image, sizeof (MonoClassPointer));
UnlockedAdd (&classes_size, sizeof (MonoClassPointer));
++class_pointer_count;
result->parent = NULL; /* no parent for PTR types */
result->name_space = el_class->name_space;
name = g_strdup_printf ("%s*", el_class->name);
result->name = mm ? mono_mem_manager_strdup (mm, name) : mono_image_strdup (image, name);
result->class_kind = MONO_CLASS_POINTER;
g_free (name);
MONO_PROFILER_RAISE (class_loading, (result));
result->image = el_class->image;
result->inited = TRUE;
result->instance_size = MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer);
result->min_align = sizeof (gpointer);
result->element_class = el_class;
result->blittable = TRUE;
if (el_class->enumtype)
result->cast_class = el_class->element_class;
else
result->cast_class = el_class;
class_composite_fixup_cast_class (result, TRUE);
result->this_arg.type = result->_byval_arg.type = MONO_TYPE_PTR;
result->this_arg.data.type = result->_byval_arg.data.type = m_class_get_byval_arg (el_class);
result->this_arg.byref__ = TRUE;
mono_class_setup_supertypes (result);
if (mm) {
mono_mem_manager_lock (mm);
MonoClass *result2;
result2 = (MonoClass *)g_hash_table_lookup (mm->ptr_cache, el_class);
if (!result2)
g_hash_table_insert (mm->ptr_cache, el_class, result);
mono_mem_manager_unlock (mm);
if (result2) {
MONO_PROFILER_RAISE (class_failed, (result));
return result2;
}
} else {
mono_image_lock (image);
if (image->ptr_cache) {
MonoClass *result2;
if ((result2 = (MonoClass *)g_hash_table_lookup (image->ptr_cache, el_class))) {
mono_image_unlock (image);
MONO_PROFILER_RAISE (class_failed, (result));
return result2;
}
} else {
image->ptr_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
}
g_hash_table_insert (image->ptr_cache, el_class, result);
mono_image_unlock (image);
}
MONO_PROFILER_RAISE (class_loaded, (result));
return result;
}
MonoClass *
mono_class_create_fnptr (MonoMethodSignature *sig)
{
MonoClass *result, *cached;
static GHashTable *ptr_hash = NULL;
/* FIXME: These should be allocate from a mempool as well, but which one ? */
mono_loader_lock ();
if (!ptr_hash)
ptr_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
cached = (MonoClass *)g_hash_table_lookup (ptr_hash, sig);
mono_loader_unlock ();
if (cached)
return cached;
result = g_new0 (MonoClass, 1);
result->parent = NULL; /* no parent for PTR types */
result->name_space = "System";
result->name = "MonoFNPtrFakeClass";
result->class_kind = MONO_CLASS_POINTER;
result->image = mono_defaults.corlib; /* need to fix... */
result->instance_size = MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer);
result->min_align = sizeof (gpointer);
result->cast_class = result->element_class = result;
result->this_arg.type = result->_byval_arg.type = MONO_TYPE_FNPTR;
result->this_arg.data.method = result->_byval_arg.data.method = sig;
result->this_arg.byref__ = TRUE;
result->blittable = TRUE;
result->inited = TRUE;
mono_class_setup_supertypes (result);
mono_loader_lock ();
cached = (MonoClass *)g_hash_table_lookup (ptr_hash, sig);
if (cached) {
g_free (result);
mono_loader_unlock ();
return cached;
}
MONO_PROFILER_RAISE (class_loading, (result));
UnlockedAdd (&classes_size, sizeof (MonoClassPointer));
++class_pointer_count;
g_hash_table_insert (ptr_hash, sig, result);
mono_loader_unlock ();
MONO_PROFILER_RAISE (class_loaded, (result));
return result;
}
static gboolean
method_is_reabstracted (guint16 flags)
{
if ((flags & METHOD_ATTRIBUTE_ABSTRACT && flags & METHOD_ATTRIBUTE_FINAL))
return TRUE;
return FALSE;
}
/**
* mono_class_setup_count_virtual_methods:
*
* Return the number of virtual methods.
* Even for interfaces we can't simply return the number of methods as all CLR types are allowed to have static methods.
* Return -1 on failure.
* FIXME It would be nice if this information could be cached somewhere.
*/
int
mono_class_setup_count_virtual_methods (MonoClass *klass)
{
int i, mcount, vcount = 0;
guint32 flags;
klass = mono_class_get_generic_type_definition (klass); /*We can find this information by looking at the GTD*/
if (klass->methods || !MONO_CLASS_HAS_STATIC_METADATA (klass)) {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass))
return -1;
mcount = mono_class_get_method_count (klass);
for (i = 0; i < mcount; ++i) {
flags = klass->methods [i]->flags;
if ((flags & METHOD_ATTRIBUTE_VIRTUAL)) {
if (method_is_reabstracted (flags))
continue;
++vcount;
}
}
} else {
int first_idx = mono_class_get_first_method_idx (klass);
mcount = mono_class_get_method_count (klass);
for (i = 0; i < mcount; ++i) {
flags = mono_metadata_decode_table_row_col (klass->image, MONO_TABLE_METHOD, first_idx + i, MONO_METHOD_FLAGS);
if ((flags & METHOD_ATTRIBUTE_VIRTUAL)) {
if (method_is_reabstracted (flags))
continue;
++vcount;
}
}
}
return vcount;
}
#ifdef COMPRESSED_INTERFACE_BITMAP
/*
* Compressed interface bitmap design.
*
* Interface bitmaps take a large amount of memory, because their size is
* linear with the maximum interface id assigned in the process (each interface
* is assigned a unique id as it is loaded). The number of interface classes
* is high because of the many implicit interfaces implemented by arrays (we'll
* need to lazy-load them in the future).
* Most classes implement a very small number of interfaces, so the bitmap is
* sparse. This bitmap needs to be checked by interface casts, so access to the
* needed bit must be fast and doable with few jit instructions.
*
* The current compression format is as follows:
* *) it is a sequence of one or more two-byte elements
* *) the first byte in the element is the count of empty bitmap bytes
* at the current bitmap position
* *) the second byte in the element is an actual bitmap byte at the current
* bitmap position
*
* As an example, the following compressed bitmap bytes:
* 0x07 0x01 0x00 0x7
* correspond to the following bitmap:
* 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x07
*
* Each two-byte element can represent up to 2048 bitmap bits, but as few as a single
* bitmap byte for non-sparse sequences. In practice the interface bitmaps created
* during a gmcs bootstrap are reduced to less tha 5% of the original size.
*/
/**
* mono_compress_bitmap:
* \param dest destination buffer
* \param bitmap bitmap buffer
* \param size size of \p bitmap in bytes
*
* This is a mono internal function.
* The \p bitmap data is compressed into a format that is small but
* still searchable in few instructions by the JIT and runtime.
* The compressed data is stored in the buffer pointed to by the
* \p dest array. Passing a NULL value for \p dest allows to just compute
* the size of the buffer.
* This compression algorithm assumes the bits set in the bitmap are
* few and far between, like in interface bitmaps.
* \returns The size of the compressed bitmap in bytes.
*/
int
mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size)
{
int numz = 0;
int res = 0;
const uint8_t *end = bitmap + size;
while (bitmap < end) {
if (*bitmap || numz == 255) {
if (dest) {
*dest++ = numz;
*dest++ = *bitmap;
}
res += 2;
numz = 0;
bitmap++;
continue;
}
bitmap++;
numz++;
}
if (numz) {
res += 2;
if (dest) {
*dest++ = numz;
*dest++ = 0;
}
}
return res;
}
/**
* mono_class_interface_match:
* \param bitmap a compressed bitmap buffer
* \param id the index to check in the bitmap
*
* This is a mono internal function.
* Checks if a bit is set in a compressed interface bitmap. \p id must
* be already checked for being smaller than the maximum id encoded in the
* bitmap.
*
* \returns A non-zero value if bit \p id is set in the bitmap \p bitmap,
* FALSE otherwise.
*/
int
mono_class_interface_match (const uint8_t *bitmap, int id)
{
while (TRUE) {
id -= bitmap [0] * 8;
if (id < 8) {
if (id < 0)
return 0;
return bitmap [1] & (1 << id);
}
bitmap += 2;
id -= 8;
}
}
#endif
static char*
concat_two_strings_with_zero (MonoImage *image, const char *s1, const char *s2)
{
int null_length = strlen ("(null)");
int len = (s1 ? strlen (s1) : null_length) + (s2 ? strlen (s2) : null_length) + 2;
char *s = (char *)mono_image_alloc (image, len);
int result;
result = g_snprintf (s, len, "%s%c%s", s1 ? s1 : "(null)", '\0', s2 ? s2 : "(null)");
g_assert (result == len - 1);
return s;
}
static void
init_sizes_with_info (MonoClass *klass, MonoCachedClassInfo *cached_info)
{
if (cached_info) {
mono_loader_lock ();
klass->instance_size = cached_info->instance_size;
klass->sizes.class_size = cached_info->class_size;
klass->packing_size = cached_info->packing_size;
klass->min_align = cached_info->min_align;
klass->blittable = cached_info->blittable;
klass->has_references = cached_info->has_references;
klass->has_static_refs = cached_info->has_static_refs;
klass->no_special_static_fields = cached_info->no_special_static_fields;
klass->has_weak_fields = cached_info->has_weak_fields;
mono_loader_unlock ();
}
else {
if (!klass->size_inited)
mono_class_setup_fields (klass);
}
}
/*
* mono_class_init_sizes:
*
* Initializes the size related fields of @klass without loading all field data if possible.
* Sets the following fields in @klass:
* - instance_size
* - sizes.class_size
* - packing_size
* - min_align
* - blittable
* - has_references
* - has_static_refs
* - size_inited
* Can fail the class.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_init_sizes (MonoClass *klass)
{
MonoCachedClassInfo cached_info;
gboolean has_cached_info;
if (klass->size_inited)
return;
has_cached_info = mono_class_get_cached_class_info (klass, &cached_info);
init_sizes_with_info (klass, has_cached_info ? &cached_info : NULL);
}
static gboolean
class_has_references (MonoClass *klass)
{
mono_class_init_sizes (klass);
/*
* has_references is not set if this is called recursively, but this is not a problem since this is only used
* during field layout, and instance fields are initialized before static fields, and instance fields can't
* embed themselves.
*/
return klass->has_references;
}
static gboolean
type_has_references (MonoClass *klass, MonoType *ftype)
{
if (MONO_TYPE_IS_REFERENCE (ftype) || IS_GC_REFERENCE (klass, ftype) || ((MONO_TYPE_ISSTRUCT (ftype) && class_has_references (mono_class_from_mono_type_internal (ftype)))))
return TRUE;
if (!m_type_is_byref (ftype) && (ftype->type == MONO_TYPE_VAR || ftype->type == MONO_TYPE_MVAR)) {
MonoGenericParam *gparam = ftype->data.generic_param;
if (gparam->gshared_constraint)
return class_has_references (mono_class_from_mono_type_internal (gparam->gshared_constraint));
}
return FALSE;
}
static gboolean
class_has_ref_fields (MonoClass *klass)
{
/*
* has_ref_fields is not set if this is called recursively, but this is not a problem since this is only used
* during field layout, and instance fields are initialized before static fields, and instance fields can't
* embed themselves.
*/
return klass->has_ref_fields;
}
static gboolean
class_is_byreference (MonoClass* klass)
{
const char* klass_name_space = m_class_get_name_space (klass);
const char* klass_name = m_class_get_name (klass);
MonoImage* klass_image = m_class_get_image (klass);
gboolean in_corlib = klass_image == mono_defaults.corlib;
if (in_corlib &&
!strcmp (klass_name_space, "System") &&
!strcmp (klass_name, "ByReference`1")) {
return TRUE;
}
return FALSE;
}
static gboolean
type_has_ref_fields (MonoType *ftype)
{
if (m_type_is_byref (ftype) || (MONO_TYPE_ISSTRUCT (ftype) && class_has_ref_fields (mono_class_from_mono_type_internal (ftype))))
return TRUE;
/* Check for the ByReference`1 type */
if (MONO_TYPE_ISSTRUCT (ftype)) {
MonoClass* klass = mono_class_from_mono_type_internal (ftype);
return class_is_byreference (klass);
}
return FALSE;
}
/**
* mono_class_is_gparam_with_nonblittable_parent:
* \param klass a generic parameter
*
* \returns TRUE if \p klass is definitely not blittable.
*
* A parameter is definitely not blittable if it has the IL 'reference'
* constraint, or if it has a class specified as a parent. If it has an IL
* 'valuetype' constraint or no constraint at all or only interfaces as
* constraints, we return FALSE because the parameter may be instantiated both
* with blittable and non-blittable types.
*
* If the paramter is a generic sharing parameter, we look at its gshared_constraint->blittable bit.
*/
static gboolean
mono_class_is_gparam_with_nonblittable_parent (MonoClass *klass)
{
MonoType *type = m_class_get_byval_arg (klass);
g_assert (mono_type_is_generic_parameter (type));
MonoGenericParam *gparam = type->data.generic_param;
if ((mono_generic_param_info (gparam)->flags & GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT) != 0)
return TRUE;
if ((mono_generic_param_info (gparam)->flags & GENERIC_PARAMETER_ATTRIBUTE_VALUE_TYPE_CONSTRAINT) != 0)
return FALSE;
if (gparam->gshared_constraint) {
MonoClass *constraint_class = mono_class_from_mono_type_internal (gparam->gshared_constraint);
return !m_class_is_blittable (constraint_class);
}
if (mono_generic_param_owner (gparam)->is_anonymous)
return FALSE;
/* We could have: T : U, U : Base. So have to follow the constraints. */
MonoClass *parent_class = mono_generic_param_get_base_type (klass);
g_assert (!MONO_CLASS_IS_INTERFACE_INTERNAL (parent_class));
/* Parent can only be: System.Object, System.ValueType or some specific base class.
*
* If the parent_class is ValueType, the valuetype constraint would be set, above, so
* we wouldn't get here.
*
* If there was a reference constraint, the parent_class would be System.Object,
* but we would have returned early above.
*
* So if we get here, there is either no base class constraint at all,
* in which case parent_class would be set to System.Object, or there is none at all.
*/
return parent_class != mono_defaults.object_class;
}
/**
* Checks if there are any overlapping object and non-object fields.
* The alignment of object reference fields is checked elswhere and this function assumes
* that all references are aligned correctly.
*
* \param layout_check A buffer to check which bytes hold object references or values
* \param klass Checked struct
* \param field_offsets Offsets of the klass' fields relative to the start of layout_check
* \param field_count Count of klass fields
* \param invalid_field_offset When the layout is invalid it will be set to the offset of the field which is invalid
*
* \return True if the layout of the struct is valid, otherwise false.
*/
static gboolean
validate_struct_fields_overlaps (guint8 *layout_check, int layout_size, MonoClass *klass, const int *field_offsets, const int field_count, int *invalid_field_offset)
{
MonoClassField *field;
MonoType *ftype;
int field_offset;
for (int i = 0; i < field_count && !mono_class_has_failure (klass); i++) {
// using mono_class_get_fields_internal isn't appropriate here because it will
// try to call mono_class_setup_fields which is what we're doing already
field = &m_class_get_fields (klass) [i];
field_offset = field_offsets [i];
if (!field)
continue;
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (mono_type_is_struct (ftype)) {
// recursively check the layout of the embedded struct
MonoClass *embedded_class = mono_class_from_mono_type_internal (ftype);
mono_class_setup_fields (embedded_class);
const int embedded_fields_count = mono_class_get_field_count (embedded_class);
int *embedded_offsets = g_new0 (int, embedded_fields_count);
for (int j = 0; j < embedded_fields_count; ++j) {
embedded_offsets [j] = field_offset + m_class_get_fields (embedded_class) [j].offset - MONO_ABI_SIZEOF (MonoObject);
}
gboolean is_valid = validate_struct_fields_overlaps (layout_check, layout_size, embedded_class, embedded_offsets, embedded_fields_count, invalid_field_offset);
g_free (embedded_offsets);
if (!is_valid) {
// overwrite whatever was in the invalid_field_offset with the offset of the currently checked field
// we want to return the outer most invalid field
*invalid_field_offset = field_offset;
return FALSE;
}
} else {
int align = 0;
int size = mono_type_size (field->type, &align);
guint8 type = type_has_references (klass, ftype) ? 1 : (m_type_is_byref (ftype) || class_is_byreference (klass)) ? 2 : 3;
// Mark the bytes used by this fields type based on if it contains references or not.
// Make sure there are no overlaps between object and non-object fields.
for (int j = 0; j < size; j++) {
int checked_byte = field_offset + j;
g_assert(checked_byte < layout_size);
if (layout_check [checked_byte] != 0 && layout_check [checked_byte] != type) {
*invalid_field_offset = field_offset;
return FALSE;
}
layout_check [checked_byte] = type;
}
}
}
return TRUE;
}
/*
* mono_class_layout_fields:
* @class: a class
* @base_instance_size: base instance size
* @packing_size:
*
* This contains the common code for computing the layout of classes and sizes.
* This should only be called from mono_class_setup_fields () and
* typebuilder_setup_fields ().
*
* LOCKING: Acquires the loader lock
*/
void
mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_size, int explicit_size, gboolean sre)
{
int i;
const int top = mono_class_get_field_count (klass);
guint32 layout = mono_class_get_flags (klass) & TYPE_ATTRIBUTE_LAYOUT_MASK;
guint32 pass, passes, real_size;
gboolean gc_aware_layout = FALSE;
gboolean has_static_fields = FALSE;
gboolean has_references = FALSE;
gboolean has_ref_fields = FALSE;
gboolean has_static_refs = FALSE;
MonoClassField *field;
gboolean blittable;
gboolean any_field_has_auto_layout;
int instance_size = base_instance_size;
int element_size = -1;
int class_size, min_align;
int *field_offsets;
gboolean *fields_has_references;
/*
* We want to avoid doing complicated work inside locks, so we compute all the required
* information and write it to @klass inside a lock.
*/
if (klass->fields_inited)
return;
if ((packing_size & 0xffffff00) != 0) {
mono_class_set_type_load_failure (klass, "Could not load struct '%s' with packing size %d >= 256", klass->name, packing_size);
return;
}
if (klass->parent) {
min_align = klass->parent->min_align;
/* we use | since it may have been set already */
has_references = klass->has_references | klass->parent->has_references;
has_ref_fields = klass->has_ref_fields | klass->parent->has_ref_fields;
} else {
min_align = 1;
}
/* We can't really enable 16 bytes alignment until the GC supports it.
The whole layout/instance size code must be reviewed because we do alignment calculation in terms of the
boxed instance, which leads to unexplainable holes at the beginning of an object embedding a simd type.
Bug #506144 is an example of this issue.
if (klass->simd_type)
min_align = 16;
*/
/* Respect the specified packing size at least to the extent necessary to align double variables.
* This should avoid any GC problems, and will allow packing_size to be respected to support
* CreateSpan<T>
*/
min_align = MIN (MONO_ABI_ALIGNOF (double), MAX (min_align, packing_size));
/*
* When we do generic sharing we need to have layout
* information for open generic classes (either with a generic
* context containing type variables or with a generic
* container), so we don't return in that case anymore.
*/
if (klass->enumtype) {
for (i = 0; i < top; i++) {
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
klass->cast_class = klass->element_class = mono_class_from_mono_type_internal (field->type);
break;
}
}
if (!mono_class_enum_basetype_internal (klass)) {
mono_class_set_type_load_failure (klass, "The enumeration's base type is invalid.");
return;
}
}
/*
* Enable GC aware auto layout: in this mode, reference
* fields are grouped together inside objects, increasing collector
* performance.
* Requires that all classes whose layout is known to native code be annotated
* with [StructLayout (LayoutKind.Sequential)]
* Value types have gc_aware_layout disabled by default, as per
* what the default is for other runtimes.
*/
/* corlib is missing [StructLayout] directives in many places */
if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT) {
if (!klass->valuetype)
gc_aware_layout = TRUE;
}
/* Compute klass->blittable and klass->any_field_has_auto_layout */
blittable = TRUE;
any_field_has_auto_layout = FALSE;
if (klass->parent) {
blittable = klass->parent->blittable;
any_field_has_auto_layout = klass->parent->any_field_has_auto_layout;
}
if (layout == TYPE_ATTRIBUTE_AUTO_LAYOUT && !(mono_is_corlib_image (klass->image) && !strcmp (klass->name_space, "System") && !strcmp (klass->name, "ValueType")) && top) {
blittable = FALSE;
any_field_has_auto_layout = TRUE; // If a type is auto-layout, treat it as having an auto-layout field in its layout.
}
for (i = 0; i < top; i++) {
field = &klass->fields [i];
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
if (blittable) {
if (m_type_is_byref (field->type) || MONO_TYPE_IS_REFERENCE (field->type)) {
blittable = FALSE;
} else if (mono_type_is_generic_parameter (field->type) &&
mono_class_is_gparam_with_nonblittable_parent (mono_class_from_mono_type_internal (field->type))) {
blittable = FALSE;
} else {
MonoClass *field_class = mono_class_from_mono_type_internal (field->type);
if (field_class) {
mono_class_setup_fields (field_class);
if (mono_class_has_failure (field_class)) {
ERROR_DECL (field_error);
mono_error_set_for_class_failure (field_error, field_class);
mono_class_set_type_load_failure (klass, "Could not set up field '%s' due to: %s", field->name, mono_error_get_message (field_error));
mono_error_cleanup (field_error);
break;
}
}
if (!field_class || !field_class->blittable)
blittable = FALSE;
}
}
if (!any_field_has_auto_layout && field->type->type == MONO_TYPE_VALUETYPE && m_class_any_field_has_auto_layout (mono_class_from_mono_type_internal (field->type)))
any_field_has_auto_layout = TRUE;
}
if (klass->enumtype) {
blittable = klass->element_class->blittable;
any_field_has_auto_layout = klass->element_class->any_field_has_auto_layout;
}
if (mono_class_has_failure (klass))
return;
if (klass == mono_defaults.string_class)
blittable = FALSE;
/* Compute klass->has_references and klass->has_ref_fields */
/*
* Process non-static fields first, since static fields might recursively
* refer to the class itself.
*/
for (i = 0; i < top; i++) {
MonoType *ftype;
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (type_has_references (klass, ftype))
has_references = TRUE;
if (type_has_ref_fields (ftype))
has_ref_fields = TRUE;
}
}
/*
* Compute field layout and total size (not considering static fields)
*/
field_offsets = g_new0 (int, top);
fields_has_references = g_new0 (gboolean, top);
int first_field_idx = mono_class_has_static_metadata (klass) ? mono_class_get_first_field_idx (klass) : 0;
switch (layout) {
case TYPE_ATTRIBUTE_AUTO_LAYOUT:
case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
if (gc_aware_layout)
passes = 2;
else
passes = 1;
if (layout != TYPE_ATTRIBUTE_AUTO_LAYOUT)
passes = 1;
if (klass->parent) {
mono_class_setup_fields (klass->parent);
if (mono_class_set_type_load_failure_causedby_class (klass, klass->parent, "Cannot initialize parent class"))
return;
real_size = klass->parent->instance_size;
} else {
real_size = MONO_ABI_SIZEOF (MonoObject);
}
for (pass = 0; pass < passes; ++pass) {
for (i = 0; i < top; i++){
gint32 align;
guint32 size;
MonoType *ftype;
field = &klass->fields [i];
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (gc_aware_layout) {
fields_has_references [i] = type_has_references (klass, ftype);
if (fields_has_references [i]) {
if (pass == 1)
continue;
} else {
if (pass == 0)
continue;
}
}
if ((top == 1) && (instance_size == MONO_ABI_SIZEOF (MonoObject)) &&
(strcmp (mono_field_get_name (field), "$PRIVATE$") == 0)) {
/* This field is a hack inserted by MCS to empty structures */
continue;
}
size = mono_type_size (field->type, &align);
/* FIXME (LAMESPEC): should we also change the min alignment according to pack? */
align = packing_size ? MIN (packing_size, align): align;
/* if the field has managed references, we need to force-align it
* see bug #77788
*/
if (type_has_references (klass, ftype))
align = MAX (align, TARGET_SIZEOF_VOID_P);
min_align = MAX (align, min_align);
field_offsets [i] = real_size;
if (align) {
field_offsets [i] += align - 1;
field_offsets [i] &= ~(align - 1);
}
/*TypeBuilders produce all sort of weird things*/
g_assert (image_is_dynamic (klass->image) || field_offsets [i] > 0);
real_size = field_offsets [i] + size;
}
instance_size = MAX (real_size, instance_size);
if (instance_size & (min_align - 1)) {
instance_size += min_align - 1;
instance_size &= ~(min_align - 1);
}
}
break;
case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT: {
real_size = 0;
for (i = 0; i < top; i++) {
gint32 align;
guint32 size;
MonoType *ftype;
field = &klass->fields [i];
/*
* There must be info about all the fields in a type if it
* uses explicit layout.
*/
if (mono_field_is_deleted (field))
continue;
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
size = mono_type_size (field->type, &align);
align = packing_size ? MIN (packing_size, align): align;
min_align = MAX (align, min_align);
if (sre) {
/* Already set by typebuilder_setup_fields () */
field_offsets [i] = field->offset + MONO_ABI_SIZEOF (MonoObject);
} else {
int idx = first_field_idx + i;
guint32 offset;
mono_metadata_field_info (klass->image, idx, &offset, NULL, NULL);
field_offsets [i] = offset + MONO_ABI_SIZEOF (MonoObject);
}
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (type_has_references (klass, ftype) || m_type_is_byref (ftype)) {
if (field_offsets [i] % TARGET_SIZEOF_VOID_P) {
mono_class_set_type_load_failure (klass, "Reference typed field '%s' has explicit offset that is not pointer-size aligned.", field->name);
}
}
/*
* Calc max size.
*/
real_size = MAX (real_size, size + field_offsets [i]);
}
/* check for incorrectly aligned or overlapped by a non-object field */
guint8 *layout_check;
if (has_references || has_ref_fields) {
layout_check = g_new0 (guint8, real_size);
int invalid_field_offset;
if (!validate_struct_fields_overlaps (layout_check, real_size, klass, field_offsets, top, &invalid_field_offset)) {
mono_class_set_type_load_failure (klass, "Could not load type '%s' because it contains an object field at offset %d that is incorrectly aligned or overlapped by a non-object field.", klass->name, invalid_field_offset);
}
g_free (layout_check);
}
instance_size = MAX (real_size, instance_size);
if (!((layout == TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) && explicit_size)) {
if (instance_size & (min_align - 1)) {
instance_size += min_align - 1;
instance_size &= ~(min_align - 1);
}
}
break;
}
}
if (layout != TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
/*
* This leads to all kinds of problems with nested structs, so only
* enable it when a MONO_DEBUG property is set.
*
* For small structs, set min_align to at least the struct size to improve
* performance, and since the JIT memset/memcpy code assumes this and generates
* unaligned accesses otherwise. See #78990 for a testcase.
*/
if (mono_align_small_structs && top) {
if (instance_size <= MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer))
min_align = MAX (min_align, instance_size - MONO_ABI_SIZEOF (MonoObject));
}
}
MonoType *klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_VAR || klass_byval_arg->type == MONO_TYPE_MVAR)
instance_size = MONO_ABI_SIZEOF (MonoObject) + mono_type_size (klass_byval_arg, &min_align);
else if (klass_byval_arg->type == MONO_TYPE_PTR)
instance_size = MONO_ABI_SIZEOF (MonoObject) + MONO_ABI_SIZEOF (gpointer);
if (klass_byval_arg->type == MONO_TYPE_SZARRAY || klass_byval_arg->type == MONO_TYPE_ARRAY)
element_size = mono_class_array_element_size (klass->element_class);
/* Publish the data */
mono_loader_lock ();
if (klass->instance_size && !klass->image->dynamic && klass_byval_arg->type != MONO_TYPE_FNPTR) {
/* Might be already set using cached info */
if (klass->instance_size != instance_size) {
/* Emit info to help debugging */
g_print ("%s\n", mono_class_full_name (klass));
g_print ("%d %d %d %d\n", klass->instance_size, instance_size, klass->blittable, blittable);
g_print ("%d %d %d %d\n", klass->has_references, has_references, klass->has_ref_fields, has_ref_fields);
g_print ("%d %d %d %d\n", klass->packing_size, packing_size, klass->min_align, min_align);
for (i = 0; i < top; ++i) {
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
printf (" %s %d %d %d\n", klass->fields [i].name, klass->fields [i].offset, field_offsets [i], fields_has_references [i]);
}
}
g_assert (klass->instance_size == instance_size);
} else {
klass->instance_size = instance_size;
}
klass->blittable = blittable;
klass->has_references = has_references;
klass->has_ref_fields = has_ref_fields;
klass->packing_size = packing_size;
klass->min_align = min_align;
klass->any_field_has_auto_layout = any_field_has_auto_layout;
for (i = 0; i < top; ++i) {
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
klass->fields [i].offset = field_offsets [i];
}
if (klass_byval_arg->type == MONO_TYPE_SZARRAY || klass_byval_arg->type == MONO_TYPE_ARRAY)
klass->sizes.element_size = element_size;
mono_memory_barrier ();
klass->size_inited = 1;
mono_loader_unlock ();
/*
* Compute static field layout and size
* Static fields can reference the class itself, so this has to be
* done after instance_size etc. are initialized.
*/
class_size = 0;
for (i = 0; i < top; i++) {
gint32 align;
guint32 size;
field = &klass->fields [i];
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC) || field->type->attrs & FIELD_ATTRIBUTE_LITERAL)
continue;
if (mono_field_is_deleted (field))
continue;
/* Type may not be initialized yet. Don't initialize it. If
it's a reference type we can get the size without
recursing */
if (mono_type_has_exceptions (field->type)) {
mono_class_set_type_load_failure (klass, "Field '%s' has an invalid type.", field->name);
break;
}
has_static_fields = TRUE;
size = mono_type_size (field->type, &align);
/* Check again in case initializing the field's type caused a failure */
if (mono_type_has_exceptions (field->type)) {
mono_class_set_type_load_failure (klass, "Field '%s' has an invalid type.", field->name);
break;
}
field_offsets [i] = class_size;
/*align is always non-zero here*/
field_offsets [i] += align - 1;
field_offsets [i] &= ~(align - 1);
class_size = field_offsets [i] + size;
}
if (has_static_fields && class_size == 0)
/* Simplify code which depends on class_size != 0 if the class has static fields */
class_size = 8;
/* Compute klass->has_static_refs */
has_static_refs = FALSE;
for (i = 0; i < top; i++) {
MonoType *ftype;
field = &klass->fields [i];
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) {
ftype = mono_type_get_underlying_type (field->type);
ftype = mono_type_get_basic_type_from_generic (ftype);
if (type_has_references (klass, ftype))
has_static_refs = TRUE;
}
}
/*valuetypes can't be neither bigger than 1Mb or empty. */
if (klass->valuetype && (klass->instance_size <= 0 || klass->instance_size > (0x100000 + MONO_ABI_SIZEOF (MonoObject)))) {
/* Special case compiler generated types */
/* Hard to check for [CompilerGenerated] here */
if (!strstr (klass->name, "StaticArrayInitTypeSize") && !strstr (klass->name, "$ArrayType"))
mono_class_set_type_load_failure (klass, "Value type instance size (%d) cannot be zero, negative, or bigger than 1Mb", klass->instance_size);
}
// Weak field support
//
// FIXME:
// - generic instances
// - Disallow on structs/static fields/nonref fields
gboolean has_weak_fields = FALSE;
if (mono_class_has_static_metadata (klass)) {
for (MonoClass *p = klass; p != NULL; p = p->parent) {
gpointer iter = NULL;
guint32 first_field_idx = mono_class_get_first_field_idx (p);
while ((field = mono_class_get_fields_internal (p, &iter))) {
guint32 field_idx = first_field_idx + (field - p->fields);
if (MONO_TYPE_IS_REFERENCE (field->type) && mono_assembly_is_weak_field (p->image, field_idx + 1)) {
has_weak_fields = TRUE;
mono_trace_message (MONO_TRACE_TYPE, "Field %s:%s at offset %x is weak.", m_field_get_parent (field)->name, field->name, field->offset);
}
}
}
}
/*
* Check that any fields of IsByRefLike type are instance
* fields and only inside other IsByRefLike structs.
*
* (Has to be done late because we call
* mono_class_from_mono_type_internal which may recursively
* refer to the current class)
*/
gboolean allow_isbyreflike_fields = m_class_is_byreflike (klass);
for (i = 0; i < top; i++) {
field = &klass->fields [i];
if (mono_field_is_deleted (field))
continue;
if ((field->type->attrs & FIELD_ATTRIBUTE_LITERAL))
continue;
MonoClass *field_class = NULL;
/* have to be careful not to recursively invoke mono_class_init on a static field.
* for example - if the field is an array of a subclass of klass, we can loop.
*/
switch (field->type->type) {
case MONO_TYPE_TYPEDBYREF:
case MONO_TYPE_VALUETYPE:
case MONO_TYPE_GENERICINST:
field_class = mono_class_from_mono_type_internal (field->type);
break;
default:
break;
}
if (!field_class || !m_class_is_byreflike (field_class))
continue;
if ((field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
mono_class_set_type_load_failure (klass, "Static ByRefLike field '%s' is not allowed", field->name);
return;
} else {
/* instance field */
if (allow_isbyreflike_fields)
continue;
mono_class_set_type_load_failure (klass, "Instance ByRefLike field '%s' not in a ref struct", field->name);
return;
}
}
/* Publish the data */
mono_loader_lock ();
if (!klass->rank)
klass->sizes.class_size = class_size;
klass->has_static_refs = has_static_refs;
klass->has_weak_fields = has_weak_fields;
for (i = 0; i < top; ++i) {
field = &klass->fields [i];
if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
field->offset = field_offsets [i];
}
mono_memory_barrier ();
klass->fields_inited = 1;
mono_loader_unlock ();
g_free (field_offsets);
g_free (fields_has_references);
}
static int finalize_slot = -1;
static void
initialize_object_slots (MonoClass *klass)
{
int i;
if (klass != mono_defaults.object_class || finalize_slot >= 0)
return;
mono_class_setup_vtable (klass);
for (i = 0; i < klass->vtable_size; ++i) {
if (!strcmp (klass->vtable [i]->name, "Finalize")) {
int const j = finalize_slot;
g_assert (j == -1 || j == i);
finalize_slot = i;
}
}
g_assert (finalize_slot >= 0);
}
int
mono_class_get_object_finalize_slot ()
{
return finalize_slot;
}
MonoMethod *
mono_class_get_default_finalize_method ()
{
int const i = finalize_slot;
return (i < 0) ? NULL : mono_defaults.object_class->vtable [i];
}
typedef struct {
MonoMethod *array_method;
char *name;
} GenericArrayMethodInfo;
static int generic_array_method_num = 0;
static GenericArrayMethodInfo *generic_array_method_info = NULL;
static void
setup_generic_array_ifaces (MonoClass *klass, MonoClass *iface, MonoMethod **methods, int pos, GHashTable *cache)
{
MonoGenericContext tmp_context;
MonoGenericClass *gclass;
int i;
// The interface can sometimes be a GTD in cases like IList
// See: https://github.com/mono/mono/issues/7095#issuecomment-470465597
if (mono_class_is_gtd (iface)) {
MonoType *ty = mono_class_gtd_get_canonical_inst (iface);
g_assert (ty->type == MONO_TYPE_GENERICINST);
gclass = ty->data.generic_class;
} else
gclass = mono_class_get_generic_class (iface);
tmp_context.class_inst = NULL;
tmp_context.method_inst = gclass->context.class_inst;
//g_print ("setting up array interface: %s\n", mono_type_get_name_full (m_class_get_byval_arg (iface), 0));
for (i = 0; i < generic_array_method_num; i++) {
ERROR_DECL (error);
MonoMethod *m = generic_array_method_info [i].array_method;
MonoMethod *inflated, *helper;
inflated = mono_class_inflate_generic_method_checked (m, &tmp_context, error);
mono_error_assert_ok (error);
helper = (MonoMethod*)g_hash_table_lookup (cache, inflated);
if (!helper) {
helper = mono_marshal_get_generic_array_helper (klass, generic_array_method_info [i].name, inflated);
g_hash_table_insert (cache, inflated, helper);
}
methods [pos ++] = helper;
}
}
static gboolean
check_method_exists (MonoClass *iface, const char *method_name)
{
g_assert (iface != NULL);
ERROR_DECL (method_lookup_error);
gboolean found = NULL != mono_class_get_method_from_name_checked (iface, method_name, -1, 0, method_lookup_error);
mono_error_cleanup (method_lookup_error);
return found;
}
static int
generic_array_methods (MonoClass *klass)
{
int i, count_generic = 0, mcount;
GList *list = NULL, *tmp;
if (generic_array_method_num)
return generic_array_method_num;
mono_class_setup_methods (klass->parent); /*This is setting up System.Array*/
g_assert (!mono_class_has_failure (klass->parent)); /*So hitting this assert is a huge problem*/
mcount = mono_class_get_method_count (klass->parent);
for (i = 0; i < mcount; i++) {
MonoMethod *m = klass->parent->methods [i];
if (!strncmp (m->name, "InternalArray__", 15)) {
count_generic++;
list = g_list_prepend (list, m);
}
}
list = g_list_reverse (list);
generic_array_method_info = (GenericArrayMethodInfo *)mono_image_alloc (mono_defaults.corlib, sizeof (GenericArrayMethodInfo) * count_generic);
i = 0;
for (tmp = list; tmp; tmp = tmp->next) {
const char *mname, *iname;
gchar *name;
MonoMethod *m = (MonoMethod *)tmp->data;
const char *ireadonlylist_prefix = "InternalArray__IReadOnlyList_";
const char *ireadonlycollection_prefix = "InternalArray__IReadOnlyCollection_";
MonoClass *iface = NULL;
if (!strncmp (m->name, "InternalArray__ICollection_", 27)) {
iname = "System.Collections.Generic.ICollection`1.";
mname = m->name + 27;
iface = mono_class_try_get_icollection_class ();
} else if (!strncmp (m->name, "InternalArray__IEnumerable_", 27)) {
iname = "System.Collections.Generic.IEnumerable`1.";
mname = m->name + 27;
iface = mono_class_try_get_ienumerable_class ();
} else if (!strncmp (m->name, ireadonlylist_prefix, strlen (ireadonlylist_prefix))) {
iname = "System.Collections.Generic.IReadOnlyList`1.";
mname = m->name + strlen (ireadonlylist_prefix);
iface = mono_defaults.generic_ireadonlylist_class;
} else if (!strncmp (m->name, ireadonlycollection_prefix, strlen (ireadonlycollection_prefix))) {
iname = "System.Collections.Generic.IReadOnlyCollection`1.";
mname = m->name + strlen (ireadonlycollection_prefix);
iface = mono_class_try_get_ireadonlycollection_class ();
} else if (!strncmp (m->name, "InternalArray__", 15)) {
iname = "System.Collections.Generic.IList`1.";
mname = m->name + 15;
iface = mono_defaults.generic_ilist_class;
} else {
g_assert_not_reached ();
}
if (!iface || !check_method_exists (iface, mname))
continue;
generic_array_method_info [i].array_method = m;
name = (gchar *)mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1);
strcpy (name, iname);
strcpy (name + strlen (iname), mname);
generic_array_method_info [i].name = name;
i++;
}
/*g_print ("array generic methods: %d\n", count_generic);*/
/* only count the methods we actually added, not the ones that we
* skipped if they implement an interface method that was trimmed.
*/
generic_array_method_num = i;
g_list_free (list);
return generic_array_method_num;
}
static int array_get_method_count (MonoClass *klass)
{
MonoType *klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_ARRAY)
/* Regular array */
/* ctor([int32]*rank) */
/* ctor([int32]*rank*2) */
/* Get */
/* Set */
/* Address */
return 5;
else if (klass_byval_arg->type == MONO_TYPE_SZARRAY && klass->rank == 1 && klass->element_class->rank)
/* Jagged arrays are typed as MONO_TYPE_SZARRAY but have an extra ctor in .net which creates an array of arrays */
/* ctor([int32]) */
/* ctor([int32], [int32]) */
/* Get */
/* Set */
/* Address */
return 5;
else
/* Vectors don't have additional constructor since a zero lower bound is assumed */
/* ctor([int32]*rank) */
/* Get */
/* Set */
/* Address */
return 4;
}
static gboolean array_supports_additional_ctor_method (MonoClass *klass)
{
MonoType *klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_ARRAY)
/* Regular array */
return TRUE;
else if (klass_byval_arg->type == MONO_TYPE_SZARRAY && klass->rank == 1 && klass->element_class->rank)
/* Jagged array */
return TRUE;
else
/* Vector */
return FALSE;
}
/*
* Global pool of interface IDs, represented as a bitset.
* LOCKING: Protected by the classes lock.
*/
static MonoBitSet *global_interface_bitset = NULL;
/*
* mono_unload_interface_ids:
* @bitset: bit set of interface IDs
*
* When an image is unloaded, the interface IDs associated with
* the image are put back in the global pool of IDs so the numbers
* can be reused.
*/
void
mono_unload_interface_ids (MonoBitSet *bitset)
{
classes_lock ();
mono_bitset_sub (global_interface_bitset, bitset);
classes_unlock ();
}
void
mono_unload_interface_id (MonoClass *klass)
{
if (global_interface_bitset && klass->interface_id) {
classes_lock ();
mono_bitset_clear (global_interface_bitset, klass->interface_id);
classes_unlock ();
}
}
/**
* mono_get_unique_iid:
* \param klass interface
*
* Assign a unique integer ID to the interface represented by \p klass.
* The ID will positive and as small as possible.
* LOCKING: Acquires the classes lock.
* \returns The new ID.
*/
static guint32
mono_get_unique_iid (MonoClass *klass)
{
int iid;
g_assert (MONO_CLASS_IS_INTERFACE_INTERNAL (klass));
classes_lock ();
if (!global_interface_bitset) {
global_interface_bitset = mono_bitset_new (128, 0);
mono_bitset_set (global_interface_bitset, 0); //don't let 0 be a valid iid
}
iid = mono_bitset_find_first_unset (global_interface_bitset, -1);
if (iid < 0) {
int old_size = mono_bitset_size (global_interface_bitset);
MonoBitSet *new_set = mono_bitset_clone (global_interface_bitset, old_size * 2);
mono_bitset_free (global_interface_bitset);
global_interface_bitset = new_set;
iid = old_size;
}
mono_bitset_set (global_interface_bitset, iid);
/* set the bit also in the per-image set */
if (!mono_class_is_ginst (klass)) {
if (klass->image->interface_bitset) {
if (iid >= mono_bitset_size (klass->image->interface_bitset)) {
MonoBitSet *new_set = mono_bitset_clone (klass->image->interface_bitset, iid + 1);
mono_bitset_free (klass->image->interface_bitset);
klass->image->interface_bitset = new_set;
}
} else {
klass->image->interface_bitset = mono_bitset_new (iid + 1, 0);
}
mono_bitset_set (klass->image->interface_bitset, iid);
}
classes_unlock ();
#ifndef MONO_SMALL_CONFIG
if (mono_print_vtable) {
int generic_id;
char *type_name = mono_type_full_name (m_class_get_byval_arg (klass));
MonoGenericClass *gklass = mono_class_try_get_generic_class (klass);
if (gklass && !gklass->context.class_inst->is_open) {
generic_id = gklass->context.class_inst->id;
g_assert (generic_id != 0);
} else {
generic_id = 0;
}
printf ("Interface: assigned id %d to %s|%s|%d\n", iid, klass->image->assembly_name, type_name, generic_id);
g_free (type_name);
}
#endif
/* I've confirmed iids safe past 16 bits, however bitset code uses a signed int while testing.
* Once this changes, it should be safe for us to allow 2^32-1 interfaces, until then 2^31-2 is the max. */
g_assert (iid < INT_MAX);
return iid;
}
/**
* mono_class_init_internal:
* \param klass the class to initialize
*
* Compute the \c instance_size, \c class_size and other infos that cannot be
* computed at \c mono_class_get time. Also compute vtable_size if possible.
* Initializes the following fields in \p klass:
* - all the fields initialized by \c mono_class_init_sizes
* - has_cctor
* - ghcimpl
* - inited
*
* LOCKING: Acquires the loader lock.
*
* \returns TRUE on success or FALSE if there was a problem in loading
* the type (incorrect assemblies, missing assemblies, methods, etc).
*/
gboolean
mono_class_init_internal (MonoClass *klass)
{
int i, vtable_size = 0, array_method_count = 0;
MonoCachedClassInfo cached_info;
gboolean has_cached_info;
gboolean locked = FALSE;
gboolean ghcimpl = FALSE;
gboolean has_cctor = FALSE;
int first_iface_slot = 0;
g_assert (klass);
/* Double-checking locking pattern */
if (klass->inited || mono_class_has_failure (klass))
return !mono_class_has_failure (klass);
/*g_print ("Init class %s\n", mono_type_get_full_name (klass));*/
/*
* This function can recursively call itself.
*/
GSList *init_list = (GSList *)mono_native_tls_get_value (init_pending_tls_id);
if (g_slist_find (init_list, klass)) {
mono_class_set_type_load_failure (klass, "Recursive type definition detected %s.%s", klass->name_space, klass->name);
goto leave_no_init_pending;
}
init_list = g_slist_prepend (init_list, klass);
mono_native_tls_set_value (init_pending_tls_id, init_list);
/*
* We want to avoid doing complicated work inside locks, so we compute all the required
* information and write it to @klass inside a lock.
*/
MonoType *klass_byval_arg;
klass_byval_arg = m_class_get_byval_arg (klass);
if (klass_byval_arg->type == MONO_TYPE_ARRAY || klass_byval_arg->type == MONO_TYPE_SZARRAY) {
MonoClass *element_class = klass->element_class;
MonoClass *cast_class = klass->cast_class;
if (!element_class->inited)
mono_class_init_internal (element_class);
if (mono_class_set_type_load_failure_causedby_class (klass, element_class, "Could not load array element class"))
goto leave;
if (!cast_class->inited)
mono_class_init_internal (cast_class);
if (mono_class_set_type_load_failure_causedby_class (klass, cast_class, "Could not load array cast class"))
goto leave;
}
UnlockedIncrement (&mono_stats.initialized_class_count);
if (mono_class_is_ginst (klass) && !mono_class_get_generic_class (klass)->is_dynamic) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_init_internal (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic Type Definition failed to init"))
goto leave;
if (MONO_CLASS_IS_INTERFACE_INTERNAL (klass))
mono_class_setup_interface_id (klass);
}
if (klass->parent && !klass->parent->inited)
mono_class_init_internal (klass->parent);
has_cached_info = mono_class_get_cached_class_info (klass, &cached_info);
/* Compute instance size etc. */
init_sizes_with_info (klass, has_cached_info ? &cached_info : NULL);
if (mono_class_has_failure (klass))
goto leave;
mono_class_setup_supertypes (klass);
initialize_object_slots (klass);
/*
* Initialize the rest of the data without creating a generic vtable if possible.
* If possible, also compute vtable_size, so mono_class_create_runtime_vtable () can
* also avoid computing a generic vtable.
*/
if (has_cached_info) {
/* AOT case */
vtable_size = cached_info.vtable_size;
ghcimpl = cached_info.ghcimpl;
has_cctor = cached_info.has_cctor;
} else if (klass->rank == 1 && klass_byval_arg->type == MONO_TYPE_SZARRAY) {
/* SZARRAY can have 3 vtable layouts, with and without the stelemref method and enum element type
* The first slot if for array with.
*/
static int szarray_vtable_size[3] = { 0 };
int slot;
if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (m_class_get_element_class (klass))))
slot = 0;
else if (klass->element_class->enumtype)
slot = 1;
else
slot = 2;
/* SZARRAY case */
if (!szarray_vtable_size [slot]) {
mono_class_setup_vtable (klass);
szarray_vtable_size [slot] = klass->vtable_size;
vtable_size = klass->vtable_size;
} else {
vtable_size = szarray_vtable_size[slot];
}
} else if (mono_class_is_ginst (klass) && !MONO_CLASS_IS_INTERFACE_INTERNAL (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
/* Generic instance case */
ghcimpl = gklass->ghcimpl;
has_cctor = gklass->has_cctor;
mono_class_setup_vtable (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to init"))
goto leave;
vtable_size = gklass->vtable_size;
} else {
/* General case */
/* C# doesn't allow interfaces to have cctors */
if (!MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || klass->image != mono_defaults.corlib) {
MonoMethod *cmethod = NULL;
if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
/* Generic instance case */
ghcimpl = gklass->ghcimpl;
has_cctor = gklass->has_cctor;
} else if (klass->type_token && !image_is_dynamic(klass->image)) {
cmethod = mono_find_method_in_metadata (klass, ".cctor", 0, METHOD_ATTRIBUTE_SPECIAL_NAME);
/* The find_method function ignores the 'flags' argument */
if (cmethod && (cmethod->flags & METHOD_ATTRIBUTE_SPECIAL_NAME))
has_cctor = 1;
} else {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass))
goto leave;
int mcount = mono_class_get_method_count (klass);
for (i = 0; i < mcount; ++i) {
MonoMethod *method = klass->methods [i];
if ((method->flags & METHOD_ATTRIBUTE_SPECIAL_NAME) &&
(strcmp (".cctor", method->name) == 0)) {
has_cctor = 1;
break;
}
}
}
}
}
if (klass->rank) {
array_method_count = array_get_method_count (klass);
if (klass->interface_count) {
int count_generic = generic_array_methods (klass);
array_method_count += klass->interface_count * count_generic;
}
}
if (klass->parent) {
if (!klass->parent->vtable_size)
mono_class_setup_vtable (klass->parent);
if (mono_class_set_type_load_failure_causedby_class (klass, klass->parent, "Parent class vtable failed to initialize"))
goto leave;
g_assert (klass->parent->vtable_size);
first_iface_slot = klass->parent->vtable_size;
if (mono_class_setup_need_stelemref_method (klass))
++first_iface_slot;
}
/*
* Do the actual changes to @klass inside the loader lock
*/
mono_loader_lock ();
locked = TRUE;
if (klass->inited || mono_class_has_failure (klass)) {
/* Somebody might have gotten in before us */
goto leave;
}
UnlockedIncrement (&mono_stats.initialized_class_count);
if (mono_class_is_ginst (klass) && !mono_class_get_generic_class (klass)->is_dynamic)
UnlockedIncrement (&mono_stats.generic_class_count);
if (mono_class_is_ginst (klass) || image_is_dynamic (klass->image) || !klass->type_token || (has_cached_info && !cached_info.has_nested_classes))
klass->nested_classes_inited = TRUE;
klass->ghcimpl = ghcimpl;
klass->has_cctor = has_cctor;
if (vtable_size)
klass->vtable_size = vtable_size;
if (has_cached_info) {
klass->has_finalize = cached_info.has_finalize;
klass->has_finalize_inited = TRUE;
}
if (klass->rank)
mono_class_set_method_count (klass, array_method_count);
mono_loader_unlock ();
locked = FALSE;
mono_class_setup_interface_offsets_internal (klass, first_iface_slot, TRUE);
if (mono_class_is_ginst (klass) && !mono_verifier_class_is_valid_generic_instantiation (klass))
mono_class_set_type_load_failure (klass, "Invalid generic instantiation");
goto leave;
leave:
init_list = (GSList*)mono_native_tls_get_value (init_pending_tls_id);
init_list = g_slist_remove (init_list, klass);
mono_native_tls_set_value (init_pending_tls_id, init_list);
leave_no_init_pending:
if (locked)
mono_loader_unlock ();
/* Leave this for last */
mono_loader_lock ();
klass->inited = 1;
mono_loader_unlock ();
return !mono_class_has_failure (klass);
}
gboolean
mono_class_init_checked (MonoClass *klass, MonoError *error)
{
error_init (error);
gboolean const success = mono_class_init_internal (klass);
if (!success)
mono_error_set_for_class_failure (error, klass);
return success;
}
#ifndef DISABLE_COM
/*
* COM initialization is delayed until needed.
* However when a [ComImport] attribute is present on a type it will trigger
* the initialization. This is not a problem unless the BCL being executed
* lacks the types that COM depends on (e.g. Variant on Silverlight).
*/
static void
init_com_from_comimport (MonoClass *klass)
{
/* FIXME : we should add an extra checks to ensure COM can be initialized properly before continuing */
}
#endif /*DISABLE_COM*/
/*
* LOCKING: this assumes the loader lock is held
*/
void
mono_class_setup_parent (MonoClass *klass, MonoClass *parent)
{
gboolean system_namespace;
gboolean is_corlib = mono_is_corlib_image (klass->image);
system_namespace = !strcmp (klass->name_space, "System") && is_corlib;
/* if root of the hierarchy */
if (system_namespace && !strcmp (klass->name, "Object")) {
klass->parent = NULL;
klass->instance_size = MONO_ABI_SIZEOF (MonoObject);
return;
}
if (!strcmp (klass->name, "<Module>")) {
klass->parent = NULL;
klass->instance_size = 0;
return;
}
if (!MONO_CLASS_IS_INTERFACE_INTERNAL (klass)) {
/* Imported COM Objects always derive from __ComObject. */
#ifndef DISABLE_COM
if (MONO_CLASS_IS_IMPORT (klass)) {
init_com_from_comimport (klass);
if (parent == mono_defaults.object_class)
parent = mono_class_get_com_object_class ();
}
#endif
if (!parent) {
/* set the parent to something useful and safe, but mark the type as broken */
parent = mono_defaults.object_class;
mono_class_set_type_load_failure (klass, "");
g_assert (parent);
}
klass->parent = parent;
if (mono_class_is_ginst (parent) && !parent->name) {
/*
* If the parent is a generic instance, we may get
* called before it is fully initialized, especially
* before it has its name.
*/
return;
}
klass->delegate = parent->delegate;
if (MONO_CLASS_IS_IMPORT (klass) || mono_class_is_com_object (parent))
mono_class_set_is_com_object (klass);
if (system_namespace) {
if (klass->name [0] == 'D' && !strcmp (klass->name, "Delegate"))
klass->delegate = 1;
}
if (klass->parent->enumtype || (mono_is_corlib_image (klass->parent->image) && (strcmp (klass->parent->name, "ValueType") == 0) &&
(strcmp (klass->parent->name_space, "System") == 0)))
klass->valuetype = 1;
if (mono_is_corlib_image (klass->parent->image) && ((strcmp (klass->parent->name, "Enum") == 0) && (strcmp (klass->parent->name_space, "System") == 0))) {
klass->valuetype = klass->enumtype = 1;
}
/*klass->enumtype = klass->parent->enumtype; */
} else {
/* initialize com types if COM interfaces are present */
#ifndef DISABLE_COM
if (MONO_CLASS_IS_IMPORT (klass))
init_com_from_comimport (klass);
#endif
klass->parent = NULL;
}
}
/* Locking: must be called with the loader lock held. */
void
mono_class_setup_interface_id_nolock (MonoClass *klass)
{
if (!MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || klass->interface_id)
return;
klass->interface_id = mono_get_unique_iid (klass);
if (mono_is_corlib_image (klass->image) && !strcmp (m_class_get_name_space (klass), "System.Collections.Generic")) {
//FIXME IEnumerator needs to be special because GetEnumerator uses magic under the hood
/* FIXME: System.Array/InternalEnumerator don't need all this interface fabrication machinery.
* MS returns diferrent types based on which instance is called. For example:
* object obj = new byte[10][];
* Type a = ((IEnumerable<byte[]>)obj).GetEnumerator ().GetType ();
* Type b = ((IEnumerable<IList<byte>>)obj).GetEnumerator ().GetType ();
* a != b ==> true
*/
const char *name = m_class_get_name (klass);
if (!strcmp (name, "IList`1") || !strcmp (name, "ICollection`1") || !strcmp (name, "IEnumerable`1") || !strcmp (name, "IEnumerator`1"))
klass->is_array_special_interface = 1;
}
}
/*
* LOCKING: this assumes the loader lock is held
*/
void
mono_class_setup_mono_type (MonoClass *klass)
{
const char *name = klass->name;
const char *nspace = klass->name_space;
gboolean is_corlib = mono_is_corlib_image (klass->image);
klass->this_arg.byref__ = 1;
klass->this_arg.data.klass = klass;
klass->this_arg.type = MONO_TYPE_CLASS;
klass->_byval_arg.data.klass = klass;
klass->_byval_arg.type = MONO_TYPE_CLASS;
if (is_corlib && !strcmp (nspace, "System")) {
if (!strcmp (name, "ValueType")) {
/*
* do not set the valuetype bit for System.ValueType.
* klass->valuetype = 1;
*/
klass->blittable = TRUE;
} else if (!strcmp (name, "Enum")) {
/*
* do not set the valuetype bit for System.Enum.
* klass->valuetype = 1;
*/
klass->valuetype = 0;
klass->enumtype = 0;
} else if (!strcmp (name, "Object")) {
klass->_byval_arg.type = MONO_TYPE_OBJECT;
klass->this_arg.type = MONO_TYPE_OBJECT;
} else if (!strcmp (name, "String")) {
klass->_byval_arg.type = MONO_TYPE_STRING;
klass->this_arg.type = MONO_TYPE_STRING;
} else if (!strcmp (name, "TypedReference")) {
klass->_byval_arg.type = MONO_TYPE_TYPEDBYREF;
klass->this_arg.type = MONO_TYPE_TYPEDBYREF;
}
}
if (klass->valuetype) {
int t = MONO_TYPE_VALUETYPE;
if (is_corlib && !strcmp (nspace, "System")) {
switch (*name) {
case 'B':
if (!strcmp (name, "Boolean")) {
t = MONO_TYPE_BOOLEAN;
} else if (!strcmp(name, "Byte")) {
t = MONO_TYPE_U1;
klass->blittable = TRUE;
}
break;
case 'C':
if (!strcmp (name, "Char")) {
t = MONO_TYPE_CHAR;
}
break;
case 'D':
if (!strcmp (name, "Double")) {
t = MONO_TYPE_R8;
klass->blittable = TRUE;
}
break;
case 'I':
if (!strcmp (name, "Int32")) {
t = MONO_TYPE_I4;
klass->blittable = TRUE;
} else if (!strcmp(name, "Int16")) {
t = MONO_TYPE_I2;
klass->blittable = TRUE;
} else if (!strcmp(name, "Int64")) {
t = MONO_TYPE_I8;
klass->blittable = TRUE;
} else if (!strcmp(name, "IntPtr")) {
t = MONO_TYPE_I;
klass->blittable = TRUE;
}
break;
case 'S':
if (!strcmp (name, "Single")) {
t = MONO_TYPE_R4;
klass->blittable = TRUE;
} else if (!strcmp(name, "SByte")) {
t = MONO_TYPE_I1;
klass->blittable = TRUE;
}
break;
case 'U':
if (!strcmp (name, "UInt32")) {
t = MONO_TYPE_U4;
klass->blittable = TRUE;
} else if (!strcmp(name, "UInt16")) {
t = MONO_TYPE_U2;
klass->blittable = TRUE;
} else if (!strcmp(name, "UInt64")) {
t = MONO_TYPE_U8;
klass->blittable = TRUE;
} else if (!strcmp(name, "UIntPtr")) {
t = MONO_TYPE_U;
klass->blittable = TRUE;
}
break;
case 'T':
if (!strcmp (name, "TypedReference")) {
t = MONO_TYPE_TYPEDBYREF;
klass->blittable = TRUE;
}
break;
case 'V':
if (!strcmp (name, "Void")) {
t = MONO_TYPE_VOID;
}
break;
default:
break;
}
}
klass->_byval_arg.type = (MonoTypeEnum)t;
klass->this_arg.type = (MonoTypeEnum)t;
}
mono_class_setup_interface_id_nolock (klass);
}
static MonoMethod*
create_array_method (MonoClass *klass, const char *name, MonoMethodSignature *sig)
{
MonoMethod *method;
method = (MonoMethod *) mono_image_alloc0 (klass->image, sizeof (MonoMethodPInvoke));
method->klass = klass;
method->flags = METHOD_ATTRIBUTE_PUBLIC;
method->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
method->signature = sig;
method->name = name;
method->slot = -1;
/* .ctor */
if (name [0] == '.') {
method->flags |= METHOD_ATTRIBUTE_RT_SPECIAL_NAME | METHOD_ATTRIBUTE_SPECIAL_NAME;
} else {
method->iflags |= METHOD_IMPL_ATTRIBUTE_RUNTIME;
}
return method;
}
/*
* mono_class_setup_methods:
* @class: a class
*
* Initializes the 'methods' array in CLASS.
* Calling this method should be avoided if possible since it allocates a lot
* of long-living MonoMethod structures.
* Methods belonging to an interface are assigned a sequential slot starting
* from 0.
*
* On failure this function sets klass->has_failure and stores a MonoErrorBoxed with details
*/
void
mono_class_setup_methods (MonoClass *klass)
{
int i, count;
MonoMethod **methods;
if (klass->methods)
return;
if (mono_class_is_ginst (klass)) {
ERROR_DECL (error);
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_init_internal (gklass);
if (!mono_class_has_failure (gklass))
mono_class_setup_methods (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to load"))
return;
/* The + 1 makes this always non-NULL to pass the check in mono_class_setup_methods () */
count = mono_class_get_method_count (gklass);
methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * (count + 1));
for (i = 0; i < count; i++) {
methods [i] = mono_class_inflate_generic_method_full_checked (
gklass->methods [i], klass, mono_class_get_context (klass), error);
if (!is_ok (error)) {
char *method = mono_method_full_name (gklass->methods [i], TRUE);
mono_class_set_type_load_failure (klass, "Could not inflate method %s due to %s", method, mono_error_get_message (error));
g_free (method);
mono_error_cleanup (error);
return;
}
}
} else if (klass->rank) {
ERROR_DECL (error);
MonoMethod *amethod;
MonoMethodSignature *sig;
int count_generic = 0, first_generic = 0;
int method_num = 0;
count = array_get_method_count (klass);
mono_class_setup_interfaces (klass, error);
g_assert (is_ok (error)); /*FIXME can this fail for array types?*/
if (klass->interface_count) {
count_generic = generic_array_methods (klass);
first_generic = count;
count += klass->interface_count * count_generic;
}
methods = (MonoMethod **)mono_class_alloc0 (klass, sizeof (MonoMethod*) * count);
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = mono_get_void_type ();
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, ".ctor", sig);
methods [method_num++] = amethod;
if (array_supports_additional_ctor_method (klass)) {
sig = mono_metadata_signature_alloc (klass->image, klass->rank * 2);
sig->ret = mono_get_void_type ();
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank * 2; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, ".ctor", sig);
methods [method_num++] = amethod;
}
/* element Get (idx11, [idx2, ...]) */
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = m_class_get_byval_arg (m_class_get_element_class (klass));
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, "Get", sig);
methods [method_num++] = amethod;
/* element& Address (idx11, [idx2, ...]) */
sig = mono_metadata_signature_alloc (klass->image, klass->rank);
sig->ret = &klass->element_class->this_arg;
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
amethod = create_array_method (klass, "Address", sig);
methods [method_num++] = amethod;
/* void Set (idx11, [idx2, ...], element) */
sig = mono_metadata_signature_alloc (klass->image, klass->rank + 1);
sig->ret = mono_get_void_type ();
sig->pinvoke = TRUE;
sig->hasthis = TRUE;
for (i = 0; i < klass->rank; ++i)
sig->params [i] = mono_get_int32_type ();
sig->params [i] = m_class_get_byval_arg (m_class_get_element_class (klass));
amethod = create_array_method (klass, "Set", sig);
methods [method_num++] = amethod;
GHashTable *cache = g_hash_table_new (NULL, NULL);
for (i = 0; i < klass->interface_count; i++)
setup_generic_array_ifaces (klass, klass->interfaces [i], methods, first_generic + i * count_generic, cache);
g_hash_table_destroy (cache);
} else if (mono_class_has_static_metadata (klass)) {
ERROR_DECL (error);
int first_idx = mono_class_get_first_method_idx (klass);
count = mono_class_get_method_count (klass);
methods = (MonoMethod **)mono_class_alloc (klass, sizeof (MonoMethod*) * count);
for (i = 0; i < count; ++i) {
int idx = mono_metadata_translate_token_index (klass->image, MONO_TABLE_METHOD, first_idx + i + 1);
methods [i] = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | idx, klass, NULL, error);
if (!methods [i]) {
mono_class_set_type_load_failure (klass, "Could not load method %d due to %s", i, mono_error_get_message (error));
mono_error_cleanup (error);
}
}
} else {
methods = (MonoMethod **)mono_class_alloc (klass, sizeof (MonoMethod*) * 1);
count = 0;
}
if (MONO_CLASS_IS_INTERFACE_INTERNAL (klass)) {
int slot = 0;
/*Only assign slots to virtual methods as interfaces are allowed to have static methods.*/
for (i = 0; i < count; ++i) {
if (methods [i]->flags & METHOD_ATTRIBUTE_VIRTUAL)
{
if (method_is_reabstracted (methods[i]->flags)) {
if (!methods [i]->is_inflated)
mono_method_set_is_reabstracted (methods [i]);
continue;
}
methods [i]->slot = slot++;
}
}
}
mono_image_lock (klass->image);
if (!klass->methods) {
mono_class_set_method_count (klass, count);
/* Needed because of the double-checking locking pattern */
mono_memory_barrier ();
klass->methods = methods;
}
mono_image_unlock (klass->image);
}
/*
* mono_class_setup_properties:
*
* Initialize klass->ext.property and klass->ext.properties.
*
* This method can fail the class.
*/
void
mono_class_setup_properties (MonoClass *klass)
{
guint startm, endm, i, j;
guint32 cols [MONO_PROPERTY_SIZE];
MonoTableInfo *msemt = &klass->image->tables [MONO_TABLE_METHODSEMANTICS];
MonoProperty *properties;
guint32 last;
int first, count;
MonoClassPropertyInfo *info;
info = mono_class_get_property_info (klass);
if (info)
return;
if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_init_internal (gklass);
mono_class_setup_properties (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to load"))
return;
MonoClassPropertyInfo *ginfo = mono_class_get_property_info (gklass);
properties = mono_class_new0 (klass, MonoProperty, ginfo->count + 1);
for (i = 0; i < ginfo->count; i++) {
ERROR_DECL (error);
MonoProperty *prop = &properties [i];
*prop = ginfo->properties [i];
if (prop->get)
prop->get = mono_class_inflate_generic_method_full_checked (
prop->get, klass, mono_class_get_context (klass), error);
if (prop->set)
prop->set = mono_class_inflate_generic_method_full_checked (
prop->set, klass, mono_class_get_context (klass), error);
g_assert (is_ok (error)); /*FIXME proper error handling*/
prop->parent = klass;
}
first = ginfo->first;
count = ginfo->count;
} else {
first = mono_metadata_properties_from_typedef (klass->image, mono_metadata_token_index (klass->type_token) - 1, &last);
count = last - first;
if (count) {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass))
return;
}
properties = (MonoProperty *)mono_class_alloc0 (klass, sizeof (MonoProperty) * count);
for (i = first; i < last; ++i) {
mono_metadata_decode_table_row (klass->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
properties [i - first].parent = klass;
properties [i - first].attrs = cols [MONO_PROPERTY_FLAGS];
properties [i - first].name = mono_metadata_string_heap (klass->image, cols [MONO_PROPERTY_NAME]);
startm = mono_metadata_methods_from_property (klass->image, i, &endm);
int first_idx = mono_class_get_first_method_idx (klass);
for (j = startm; j < endm; ++j) {
MonoMethod *method;
mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
if (klass->image->uncompressed_metadata) {
ERROR_DECL (error);
/* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
method = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], klass, NULL, error);
mono_error_cleanup (error); /* FIXME don't swallow this error */
} else {
method = klass->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - first_idx];
}
switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
case METHOD_SEMANTIC_SETTER:
properties [i - first].set = method;
break;
case METHOD_SEMANTIC_GETTER:
properties [i - first].get = method;
break;
default:
break;
}
}
}
}
info = (MonoClassPropertyInfo*)mono_class_alloc0 (klass, sizeof (MonoClassPropertyInfo));
info->first = first;
info->count = count;
info->properties = properties;
mono_memory_barrier ();
/* This might leak 'info' which was allocated from the image mempool */
mono_class_set_property_info (klass, info);
}
static MonoMethod**
inflate_method_listz (MonoMethod **methods, MonoClass *klass, MonoGenericContext *context)
{
MonoMethod **om, **retval;
int count;
for (om = methods, count = 0; *om; ++om, ++count)
;
retval = g_new0 (MonoMethod*, count + 1);
count = 0;
for (om = methods, count = 0; *om; ++om, ++count) {
ERROR_DECL (error);
retval [count] = mono_class_inflate_generic_method_full_checked (*om, klass, context, error);
g_assert (is_ok (error)); /*FIXME proper error handling*/
}
return retval;
}
/*This method can fail the class.*/
void
mono_class_setup_events (MonoClass *klass)
{
int first, count;
guint startm, endm, i, j;
guint32 cols [MONO_EVENT_SIZE];
MonoTableInfo *msemt = &klass->image->tables [MONO_TABLE_METHODSEMANTICS];
guint32 last;
MonoEvent *events;
MonoClassEventInfo *info = mono_class_get_event_info (klass);
if (info)
return;
if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
MonoGenericContext *context = NULL;
mono_class_setup_events (gklass);
if (mono_class_set_type_load_failure_causedby_class (klass, gklass, "Generic type definition failed to load"))
return;
MonoClassEventInfo *ginfo = mono_class_get_event_info (gklass);
first = ginfo->first;
count = ginfo->count;
events = mono_class_new0 (klass, MonoEvent, count);
if (count)
context = mono_class_get_context (klass);
for (i = 0; i < count; i++) {
ERROR_DECL (error);
MonoEvent *event = &events [i];
MonoEvent *gevent = &ginfo->events [i];
event->parent = klass;
event->name = gevent->name;
event->add = gevent->add ? mono_class_inflate_generic_method_full_checked (gevent->add, klass, context, error) : NULL;
g_assert (is_ok (error)); /*FIXME proper error handling*/
event->remove = gevent->remove ? mono_class_inflate_generic_method_full_checked (gevent->remove, klass, context, error) : NULL;
g_assert (is_ok (error)); /*FIXME proper error handling*/
event->raise = gevent->raise ? mono_class_inflate_generic_method_full_checked (gevent->raise, klass, context, error) : NULL;
g_assert (is_ok (error)); /*FIXME proper error handling*/
#ifndef MONO_SMALL_CONFIG
event->other = gevent->other ? inflate_method_listz (gevent->other, klass, context) : NULL;
#endif
event->attrs = gevent->attrs;
}
} else {
first = mono_metadata_events_from_typedef (klass->image, mono_metadata_token_index (klass->type_token) - 1, &last);
count = last - first;
if (count) {
mono_class_setup_methods (klass);
if (mono_class_has_failure (klass)) {
return;
}
}
events = (MonoEvent *)mono_class_alloc0 (klass, sizeof (MonoEvent) * count);
for (i = first; i < last; ++i) {
MonoEvent *event = &events [i - first];
mono_metadata_decode_table_row (klass->image, MONO_TABLE_EVENT, i, cols, MONO_EVENT_SIZE);
event->parent = klass;
event->attrs = cols [MONO_EVENT_FLAGS];
event->name = mono_metadata_string_heap (klass->image, cols [MONO_EVENT_NAME]);
startm = mono_metadata_methods_from_event (klass->image, i, &endm);
int first_idx = mono_class_get_first_method_idx (klass);
for (j = startm; j < endm; ++j) {
MonoMethod *method;
mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
if (klass->image->uncompressed_metadata) {
ERROR_DECL (error);
/* It seems like the MONO_METHOD_SEMA_METHOD column needs no remapping */
method = mono_get_method_checked (klass->image, MONO_TOKEN_METHOD_DEF | cols [MONO_METHOD_SEMA_METHOD], klass, NULL, error);
mono_error_cleanup (error); /* FIXME don't swallow this error */
} else {
method = klass->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - first_idx];
}
switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
case METHOD_SEMANTIC_ADD_ON:
event->add = method;
break;
case METHOD_SEMANTIC_REMOVE_ON:
event->remove = method;
break;
case METHOD_SEMANTIC_FIRE:
event->raise = method;
break;
case METHOD_SEMANTIC_OTHER: {
#ifndef MONO_SMALL_CONFIG
int n = 0;
if (event->other == NULL) {
event->other = g_new0 (MonoMethod*, 2);
} else {
while (event->other [n])
n++;
event->other = (MonoMethod **)g_realloc (event->other, (n + 2) * sizeof (MonoMethod*));
}
event->other [n] = method;
/* NULL terminated */
event->other [n + 1] = NULL;
#endif
break;
}
default:
break;
}
}
}
}
info = (MonoClassEventInfo*)mono_class_alloc0 (klass, sizeof (MonoClassEventInfo));
info->events = events;
info->first = first;
info->count = count;
mono_memory_barrier ();
mono_class_set_event_info (klass, info);
}
/*
* mono_class_setup_interface_id:
*
* Initializes MonoClass::interface_id if required.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_interface_id (MonoClass *klass)
{
g_assert (MONO_CLASS_IS_INTERFACE_INTERNAL (klass));
mono_loader_lock ();
mono_class_setup_interface_id_nolock (klass);
mono_loader_unlock ();
}
/*
* mono_class_setup_interfaces:
*
* Initialize klass->interfaces/interfaces_count.
* LOCKING: Acquires the loader lock.
* This function can fail the type.
*/
void
mono_class_setup_interfaces (MonoClass *klass, MonoError *error)
{
int i, interface_count;
MonoClass *iface, **interfaces;
error_init (error);
if (klass->interfaces_inited)
return;
if (klass->rank == 1 && m_class_get_byval_arg (klass)->type != MONO_TYPE_ARRAY) {
MonoType *args [1];
MonoClass *array_ifaces [16];
/*
* Arrays implement IList and IReadOnlyList or their base interfaces if they are not linked out.
* For arrays of enums, they implement the interfaces for the base type as well.
*/
interface_count = 0;
if (mono_defaults.generic_ilist_class) {
array_ifaces [interface_count ++] = mono_defaults.generic_ilist_class;
} else {
iface = mono_class_try_get_icollection_class ();
if (iface)
array_ifaces [interface_count ++] = iface;
}
if (mono_defaults.generic_ireadonlylist_class) {
array_ifaces [interface_count ++] = mono_defaults.generic_ireadonlylist_class;
} else {
iface = mono_class_try_get_ireadonlycollection_class ();
if (iface)
array_ifaces [interface_count ++] = iface;
}
if (!mono_defaults.generic_ilist_class && !mono_defaults.generic_ireadonlylist_class) {
iface = mono_class_try_get_ienumerable_class ();
if (iface)
array_ifaces [interface_count ++] = iface;
}
int mult = klass->element_class->enumtype ? 2 : 1;
interfaces = (MonoClass **)mono_image_alloc0 (klass->image, sizeof (MonoClass*) * interface_count * mult);
int itf_idx = 0;
args [0] = m_class_get_byval_arg (m_class_get_element_class (klass));
for (int i = 0; i < interface_count; ++i)
interfaces [itf_idx++] = mono_class_bind_generic_parameters (array_ifaces [i], 1, args, FALSE);
if (klass->element_class->enumtype) {
args [0] = mono_class_enum_basetype_internal (klass->element_class);
for (int i = 0; i < interface_count; ++i)
interfaces [itf_idx++] = mono_class_bind_generic_parameters (array_ifaces [i], 1, args, FALSE);
}
interface_count *= mult;
g_assert (itf_idx == interface_count);
} else if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
mono_class_setup_interfaces (gklass, error);
if (!is_ok (error)) {
mono_class_set_type_load_failure (klass, "Could not setup the interfaces");
return;
}
interface_count = gklass->interface_count;
interfaces = mono_class_new0 (klass, MonoClass *, interface_count);
for (i = 0; i < interface_count; i++) {
interfaces [i] = mono_class_inflate_generic_class_checked (gklass->interfaces [i], mono_generic_class_get_context (mono_class_get_generic_class (klass)), error);
if (!is_ok (error)) {
mono_class_set_type_load_failure (klass, "Could not setup the interfaces");
return;
}
}
} else {
interface_count = 0;
interfaces = NULL;
}
mono_loader_lock ();
if (!klass->interfaces_inited) {
klass->interface_count = interface_count;
klass->interfaces = interfaces;
mono_memory_barrier ();
klass->interfaces_inited = TRUE;
}
mono_loader_unlock ();
}
/*
* mono_class_setup_has_finalizer:
*
* Initialize klass->has_finalizer if it isn't already initialized.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_has_finalizer (MonoClass *klass)
{
gboolean has_finalize = FALSE;
if (m_class_is_has_finalize_inited (klass))
return;
/* Interfaces and valuetypes are not supposed to have finalizers */
if (!(MONO_CLASS_IS_INTERFACE_INTERNAL (klass) || m_class_is_valuetype (klass))) {
MonoMethod *cmethod = NULL;
if (m_class_get_rank (klass) == 1 && m_class_get_byval_arg (klass)->type == MONO_TYPE_SZARRAY) {
} else if (mono_class_is_ginst (klass)) {
MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
has_finalize = mono_class_has_finalizer (gklass);
} else if (m_class_get_parent (klass) && m_class_has_finalize (m_class_get_parent (klass))) {
has_finalize = TRUE;
} else {
if (m_class_get_parent (klass)) {
/*
* Can't search in metadata for a method named Finalize, because that
* ignores overrides.
*/
mono_class_setup_vtable (klass);
if (mono_class_has_failure (klass))
cmethod = NULL;
else
cmethod = m_class_get_vtable (klass) [mono_class_get_object_finalize_slot ()];
}
if (cmethod) {
g_assert (m_class_get_vtable_size (klass) > mono_class_get_object_finalize_slot ());
if (m_class_get_parent (klass)) {
if (cmethod->is_inflated)
cmethod = ((MonoMethodInflated*)cmethod)->declaring;
if (cmethod != mono_class_get_default_finalize_method ())
has_finalize = TRUE;
}
}
}
}
mono_loader_lock ();
if (!m_class_is_has_finalize_inited (klass)) {
klass->has_finalize = has_finalize ? 1 : 0;
mono_memory_barrier ();
klass->has_finalize_inited = TRUE;
}
mono_loader_unlock ();
}
/*
* mono_class_setup_supertypes:
* @class: a class
*
* Build the data structure needed to make fast type checks work.
* This currently sets two fields in @class:
* - idepth: distance between @class and System.Object in the type
* hierarchy + 1
* - supertypes: array of classes: each element has a class in the hierarchy
* starting from @class up to System.Object
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_supertypes (MonoClass *klass)
{
int ms, idepth;
MonoClass **supertypes;
mono_atomic_load_acquire (supertypes, MonoClass **, &klass->supertypes);
if (supertypes)
return;
if (klass->parent && !klass->parent->supertypes)
mono_class_setup_supertypes (klass->parent);
if (klass->parent)
idepth = klass->parent->idepth + 1;
else
idepth = 1;
ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, idepth);
supertypes = (MonoClass **)mono_class_alloc0 (klass, sizeof (MonoClass *) * ms);
if (klass->parent) {
CHECKED_METADATA_WRITE_PTR ( supertypes [idepth - 1] , klass );
int supertype_idx;
for (supertype_idx = 0; supertype_idx < klass->parent->idepth; supertype_idx++)
CHECKED_METADATA_WRITE_PTR ( supertypes [supertype_idx] , klass->parent->supertypes [supertype_idx] );
} else {
CHECKED_METADATA_WRITE_PTR ( supertypes [0] , klass );
}
mono_memory_barrier ();
mono_loader_lock ();
klass->idepth = idepth;
/* Needed so idepth is visible before supertypes is set */
mono_memory_barrier ();
klass->supertypes = supertypes;
mono_loader_unlock ();
}
/* mono_class_setup_nested_types:
*
* Initialize the nested_classes property for the given MonoClass if it hasn't already been initialized.
*
* LOCKING: Acquires the loader lock.
*/
void
mono_class_setup_nested_types (MonoClass *klass)
{
ERROR_DECL (error);
GList *classes, *nested_classes, *l;
int i;
if (klass->nested_classes_inited)
return;
if (!klass->type_token) {
mono_loader_lock ();
klass->nested_classes_inited = TRUE;
mono_loader_unlock ();
return;
}
i = mono_metadata_nesting_typedef (klass->image, klass->type_token, 1);
classes = NULL;
while (i) {
MonoClass* nclass;
guint32 cols [MONO_NESTED_CLASS_SIZE];
mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED], error);
if (!is_ok (error)) {
/*FIXME don't swallow the error message*/
mono_error_cleanup (error);
i = mono_metadata_nesting_typedef (klass->image, klass->type_token, i + 1);
continue;
}
classes = g_list_prepend (classes, nclass);
i = mono_metadata_nesting_typedef (klass->image, klass->type_token, i + 1);
}
nested_classes = NULL;
for (l = classes; l; l = l->next)
nested_classes = mono_g_list_prepend_image (klass->image, nested_classes, l->data);
g_list_free (classes);
mono_loader_lock ();
if (!klass->nested_classes_inited) {
mono_class_set_nested_classes_property (klass, nested_classes);
mono_memory_barrier ();
klass->nested_classes_inited = TRUE;
}
mono_loader_unlock ();
}
/**
* mono_class_create_array_fill_type:
*
* Returns a \c MonoClass that is used by SGen to fill out nursery fragments before a collection.
*/
MonoClass *
mono_class_create_array_fill_type (void)
{
static MonoClassArray aklass;
aklass.klass.class_kind = MONO_CLASS_GC_FILLER;
aklass.klass.element_class = mono_defaults.int64_class;
aklass.klass.rank = 1;
aklass.klass.instance_size = MONO_SIZEOF_MONO_ARRAY;
aklass.klass.sizes.element_size = 8;
aklass.klass.size_inited = 1;
aklass.klass.name = "array_filler_type";
return &aklass.klass;
}
void
mono_class_set_runtime_vtable (MonoClass *klass, MonoVTable *vtable)
{
klass->runtime_vtable = vtable;
}
/**
* mono_classes_init:
*
* Initialize the resources used by this module.
* Known racy counters: `class_gparam_count`, `classes_size` and `mono_inflated_methods_size`
*/
MONO_NO_SANITIZE_THREAD
void
mono_classes_init (void)
{
mono_os_mutex_init (&classes_mutex);
mono_native_tls_alloc (&setup_fields_tls_id, NULL);
mono_native_tls_alloc (&init_pending_tls_id, NULL);
mono_counters_register ("MonoClassDef count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_def_count);
mono_counters_register ("MonoClassGtd count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_gtd_count);
mono_counters_register ("MonoClassGenericInst count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_ginst_count);
mono_counters_register ("MonoClassGenericParam count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_gparam_count);
mono_counters_register ("MonoClassArray count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_array_count);
mono_counters_register ("MonoClassPointer count",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_pointer_count);
mono_counters_register ("Inflated methods size",
MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &mono_inflated_methods_size);
mono_counters_register ("Inflated classes size",
MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &inflated_classes_size);
mono_counters_register ("MonoClass size",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &classes_size);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/riscv/Lget_save_loc.c | #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gget_save_loc.c"
#endif
| #define UNW_LOCAL_ONLY
#include <libunwind.h>
#if defined(UNW_LOCAL_ONLY) && !defined(UNW_REMOTE_ONLY)
#include "Gget_save_loc.c"
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/tilegx/offsets.h | /* Linux-specific definitions: */
/* Define various structure offsets to simplify cross-compilation. */
/* Offsets for TILEGX Linux "ucontext_t": */
#define LINUX_UC_FLAGS_OFF 0x0
#define LINUX_UC_LINK_OFF 0x8
#define LINUX_UC_STACK_OFF 0x10
#define LINUX_UC_MCONTEXT_OFF 0x28
#define LINUX_UC_SIGMASK_OFF 0x228
#define LINUX_UC_MCONTEXT_GREGS 0x28
| /* Linux-specific definitions: */
/* Define various structure offsets to simplify cross-compilation. */
/* Offsets for TILEGX Linux "ucontext_t": */
#define LINUX_UC_FLAGS_OFF 0x0
#define LINUX_UC_LINK_OFF 0x8
#define LINUX_UC_STACK_OFF 0x10
#define LINUX_UC_MCONTEXT_OFF 0x28
#define LINUX_UC_SIGMASK_OFF 0x228
#define LINUX_UC_MCONTEXT_GREGS 0x28
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/pal/src/libunwind/src/riscv/Gapply_reg_state.c | /* libunwind - a platform-independent unwind library
Copyright (c) 2002-2003 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
Copyright (c) 2004 Max Asbock <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
int
unw_apply_reg_state (unw_cursor_t *cursor,
void *reg_states_data)
{
struct cursor *c = (struct cursor *) cursor;
return dwarf_apply_reg_state (&c->dwarf, (dwarf_reg_state_t *)reg_states_data);
}
| /* libunwind - a platform-independent unwind library
Copyright (c) 2002-2003 Hewlett-Packard Development Company, L.P.
Contributed by David Mosberger-Tang <[email protected]>
Copyright (c) 2004 Max Asbock <[email protected]>
This file is part of libunwind.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include "unwind_i.h"
int
unw_apply_reg_state (unw_cursor_t *cursor,
void *reg_states_data)
{
struct cursor *c = (struct cursor *) cursor;
return dwarf_apply_reg_state (&c->dwarf, (dwarf_reg_state_t *)reg_states_data);
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/Loader/classloader/TypeGeneratorTests/TypeGeneratorTest947/Generated947.il | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) .ver 4:0:0:0 }
.assembly extern TestFramework { .publickeytoken = ( B0 3F 5F 7F 11 D5 0A 3A ) }
//TYPES IN FORWARDER ASSEMBLIES:
//TEST ASSEMBLY:
.assembly Generated947 { .hash algorithm 0x00008004 }
.assembly extern xunit.core {}
.class public BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class public BaseClass1
extends BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void BaseClass0::.ctor()
ret
}
}
.class public G3_C1419`1<T0>
extends class G2_C448`2<class BaseClass0,!T0>
implements class IBase1`1<!T0>
{
.method public hidebysig newslot virtual instance string Method4() cil managed noinlining {
ldstr "G3_C1419::Method4.16071()"
ret
}
.method public hidebysig newslot virtual instance string Method5() cil managed noinlining {
ldstr "G3_C1419::Method5.16072()"
ret
}
.method public hidebysig virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G3_C1419::Method6.16073<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod4229<M0>() cil managed noinlining {
ldstr "G3_C1419::ClassMethod4229.16074<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'G2_C448<class BaseClass0,T0>.ClassMethod2257'<M0>() cil managed noinlining {
.override method instance string class G2_C448`2<class BaseClass0,!T0>::ClassMethod2257<[1]>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G2_C448`2<class BaseClass0,!T0>::.ctor()
ret
}
}
.class public abstract G2_C448`2<T0, T1>
extends class G1_C8`2<!T0,!T1>
implements class IBase2`2<!T1,!T0>, class IBase1`1<!T0>
{
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G2_C448::Method7.9035<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method4() cil managed noinlining {
ldstr "G2_C448::Method4.9036()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method4'() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method4()
ldstr "G2_C448::Method4.MI.9037()"
ret
}
.method public hidebysig virtual instance string Method5() cil managed noinlining {
ldstr "G2_C448::Method5.9038()"
ret
}
.method public hidebysig virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G2_C448::Method6.9039<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method6'<M0>() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method6<[1]>()
ldstr "G2_C448::Method6.MI.9040<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod2256() cil managed noinlining {
ldstr "G2_C448::ClassMethod2256.9041()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod2257<M0>() cil managed noinlining {
ldstr "G2_C448::ClassMethod2257.9042<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod2258<M0>() cil managed noinlining {
ldstr "G2_C448::ClassMethod2258.9043<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G1_C8`2<!T0,!T1>::.ctor()
ret
}
}
.class interface public abstract IBase1`1<+T0>
{
.method public hidebysig newslot abstract virtual instance string Method4() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method5() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method6<M0>() cil managed { }
}
.class public G1_C8`2<T0, T1>
implements class IBase2`2<!T0,!T1>, IBase0
{
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G1_C8::Method7.4821<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase2<T0,T1>.Method7'<M0>() cil managed noinlining {
.override method instance string class IBase2`2<!T0,!T1>::Method7<[1]>()
ldstr "G1_C8::Method7.MI.4822<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method0() cil managed noinlining {
ldstr "G1_C8::Method0.4823()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase0.Method0'() cil managed noinlining {
.override method instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ret
}
.method public hidebysig virtual instance string Method1() cil managed noinlining {
ldstr "G1_C8::Method1.4825()"
ret
}
.method public hidebysig newslot virtual instance string Method2<M0>() cil managed noinlining {
ldstr "G1_C8::Method2.4826<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase0.Method2'<M0>() cil managed noinlining {
.override method instance string IBase0::Method2<[1]>()
ldstr "G1_C8::Method2.MI.4827<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method3<M0>() cil managed noinlining {
ldstr "G1_C8::Method3.4828<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1332() cil managed noinlining {
ldstr "G1_C8::ClassMethod1332.4829()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1333() cil managed noinlining {
ldstr "G1_C8::ClassMethod1333.4830()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1334<M0>() cil managed noinlining {
ldstr "G1_C8::ClassMethod1334.4831<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1335<M0>() cil managed noinlining {
ldstr "G1_C8::ClassMethod1335.4832<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class interface public abstract IBase2`2<+T0, -T1>
{
.method public hidebysig newslot abstract virtual instance string Method7<M0>() cil managed { }
}
.class interface public abstract IBase0
{
.method public hidebysig newslot abstract virtual instance string Method0() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method1() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method2<M0>() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method3<M0>() cil managed { }
}
.class public auto ansi beforefieldinit Generated947 {
.method static void M.BaseClass0<(BaseClass0)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass0<(BaseClass0)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.BaseClass1<(BaseClass1)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass1<(BaseClass1)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1419.T<T0,(class G3_C1419`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 21
.locals init (string[] actualResults)
ldc.i4.s 16
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1419.T<T0,(class G3_C1419`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 16
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod4229<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 15
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1419.A<(class G3_C1419`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 21
.locals init (string[] actualResults)
ldc.i4.s 16
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1419.A<(class G3_C1419`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 16
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod4229<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 15
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1419.B<(class G3_C1419`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 21
.locals init (string[] actualResults)
ldc.i4.s 16
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1419.B<(class G3_C1419`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 16
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod4229<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 15
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.T.T<T0,T1,(class G2_C448`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.T.T<T0,T1,(class G2_C448`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.A.T<T1,(class G2_C448`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.A.T<T1,(class G2_C448`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.A.A<(class G2_C448`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.A.A<(class G2_C448`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.A.B<(class G2_C448`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.A.B<(class G2_C448`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.B.T<T1,(class G2_C448`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.B.T<T1,(class G2_C448`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.B.A<(class G2_C448`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.B.A<(class G2_C448`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.B.B<(class G2_C448`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.B.B<(class G2_C448`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.T.T<T0,T1,(class G1_C8`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.T.T<T0,T1,(class G1_C8`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.A.T<T1,(class G1_C8`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.A.T<T1,(class G1_C8`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.A.A<(class G1_C8`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.A.A<(class G1_C8`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.A.B<(class G1_C8`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.A.B<(class G1_C8`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.B.T<T1,(class G1_C8`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.B.T<T1,(class G1_C8`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.B.A<(class G1_C8`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.B.A<(class G1_C8`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.B.B<(class G1_C8`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.B.B<(class G1_C8`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase0<(IBase0)W>(!!W inst, string exp) cil managed {
.maxstack 9
.locals init (string[] actualResults)
ldc.i4.s 4
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase0<(IBase0)W>(!!W inst, string exp)"
ldc.i4.s 4
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method3<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method public hidebysig static void MethodCallingTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calling Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1419`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method5()
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method4()
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod4229<object>()
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G3_C1419`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method5()
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method4()
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod4229<object>()
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void ConstrainedCallsTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Constrained Calls Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1419`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
newobj instance void class G3_C1419`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.A<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.T<class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.A<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.A<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.B<class G1_C8`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass0,class BaseClass1>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass1,class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.T<class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.A<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.A<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.B<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass1,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.B<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.B<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void StructConstrainedInterfaceCallsTest() cil managed
{
.maxstack 10
ldstr "===================== Struct Constrained Interface Calls Test ====================="
call void [mscorlib]System.Console::WriteLine(string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void CalliTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calli Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1419`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod4229<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G3_C1419`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod4229<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static int32 Main() cil managed
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
.maxstack 10
call void Generated947::MethodCallingTest()
call void Generated947::ConstrainedCallsTest()
call void Generated947::StructConstrainedInterfaceCallsTest()
call void Generated947::CalliTest()
ldc.i4 100
ret
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) .ver 4:0:0:0 }
.assembly extern TestFramework { .publickeytoken = ( B0 3F 5F 7F 11 D5 0A 3A ) }
//TYPES IN FORWARDER ASSEMBLIES:
//TEST ASSEMBLY:
.assembly Generated947 { .hash algorithm 0x00008004 }
.assembly extern xunit.core {}
.class public BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class public BaseClass1
extends BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void BaseClass0::.ctor()
ret
}
}
.class public G3_C1419`1<T0>
extends class G2_C448`2<class BaseClass0,!T0>
implements class IBase1`1<!T0>
{
.method public hidebysig newslot virtual instance string Method4() cil managed noinlining {
ldstr "G3_C1419::Method4.16071()"
ret
}
.method public hidebysig newslot virtual instance string Method5() cil managed noinlining {
ldstr "G3_C1419::Method5.16072()"
ret
}
.method public hidebysig virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G3_C1419::Method6.16073<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod4229<M0>() cil managed noinlining {
ldstr "G3_C1419::ClassMethod4229.16074<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'G2_C448<class BaseClass0,T0>.ClassMethod2257'<M0>() cil managed noinlining {
.override method instance string class G2_C448`2<class BaseClass0,!T0>::ClassMethod2257<[1]>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G2_C448`2<class BaseClass0,!T0>::.ctor()
ret
}
}
.class public abstract G2_C448`2<T0, T1>
extends class G1_C8`2<!T0,!T1>
implements class IBase2`2<!T1,!T0>, class IBase1`1<!T0>
{
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G2_C448::Method7.9035<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method4() cil managed noinlining {
ldstr "G2_C448::Method4.9036()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method4'() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method4()
ldstr "G2_C448::Method4.MI.9037()"
ret
}
.method public hidebysig virtual instance string Method5() cil managed noinlining {
ldstr "G2_C448::Method5.9038()"
ret
}
.method public hidebysig virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G2_C448::Method6.9039<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method6'<M0>() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method6<[1]>()
ldstr "G2_C448::Method6.MI.9040<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod2256() cil managed noinlining {
ldstr "G2_C448::ClassMethod2256.9041()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod2257<M0>() cil managed noinlining {
ldstr "G2_C448::ClassMethod2257.9042<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod2258<M0>() cil managed noinlining {
ldstr "G2_C448::ClassMethod2258.9043<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G1_C8`2<!T0,!T1>::.ctor()
ret
}
}
.class interface public abstract IBase1`1<+T0>
{
.method public hidebysig newslot abstract virtual instance string Method4() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method5() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method6<M0>() cil managed { }
}
.class public G1_C8`2<T0, T1>
implements class IBase2`2<!T0,!T1>, IBase0
{
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G1_C8::Method7.4821<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase2<T0,T1>.Method7'<M0>() cil managed noinlining {
.override method instance string class IBase2`2<!T0,!T1>::Method7<[1]>()
ldstr "G1_C8::Method7.MI.4822<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method0() cil managed noinlining {
ldstr "G1_C8::Method0.4823()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase0.Method0'() cil managed noinlining {
.override method instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ret
}
.method public hidebysig virtual instance string Method1() cil managed noinlining {
ldstr "G1_C8::Method1.4825()"
ret
}
.method public hidebysig newslot virtual instance string Method2<M0>() cil managed noinlining {
ldstr "G1_C8::Method2.4826<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase0.Method2'<M0>() cil managed noinlining {
.override method instance string IBase0::Method2<[1]>()
ldstr "G1_C8::Method2.MI.4827<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method3<M0>() cil managed noinlining {
ldstr "G1_C8::Method3.4828<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1332() cil managed noinlining {
ldstr "G1_C8::ClassMethod1332.4829()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1333() cil managed noinlining {
ldstr "G1_C8::ClassMethod1333.4830()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1334<M0>() cil managed noinlining {
ldstr "G1_C8::ClassMethod1334.4831<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1335<M0>() cil managed noinlining {
ldstr "G1_C8::ClassMethod1335.4832<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class interface public abstract IBase2`2<+T0, -T1>
{
.method public hidebysig newslot abstract virtual instance string Method7<M0>() cil managed { }
}
.class interface public abstract IBase0
{
.method public hidebysig newslot abstract virtual instance string Method0() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method1() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method2<M0>() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method3<M0>() cil managed { }
}
.class public auto ansi beforefieldinit Generated947 {
.method static void M.BaseClass0<(BaseClass0)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass0<(BaseClass0)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.BaseClass1<(BaseClass1)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass1<(BaseClass1)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1419.T<T0,(class G3_C1419`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 21
.locals init (string[] actualResults)
ldc.i4.s 16
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1419.T<T0,(class G3_C1419`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 16
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::ClassMethod4229<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 15
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<!!T0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1419.A<(class G3_C1419`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 21
.locals init (string[] actualResults)
ldc.i4.s 16
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1419.A<(class G3_C1419`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 16
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod4229<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 15
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1419.B<(class G3_C1419`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 21
.locals init (string[] actualResults)
ldc.i4.s 16
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1419.B<(class G3_C1419`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 16
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod4229<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 15
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1419`1<class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.T.T<T0,T1,(class G2_C448`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.T.T<T0,T1,(class G2_C448`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.A.T<T1,(class G2_C448`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.A.T<T1,(class G2_C448`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.A.A<(class G2_C448`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.A.A<(class G2_C448`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.A.B<(class G2_C448`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.A.B<(class G2_C448`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.B.T<T1,(class G2_C448`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.B.T<T1,(class G2_C448`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.B.A<(class G2_C448`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.B.A<(class G2_C448`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C448.B.B<(class G2_C448`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 20
.locals init (string[] actualResults)
ldc.i4.s 15
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C448.B.B<(class G2_C448`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 15
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod2256()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod2257<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::ClassMethod2258<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 13
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 14
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C448`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.T.T<T0,T1,(class G1_C8`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.T.T<T0,T1,(class G1_C8`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.A.T<T1,(class G1_C8`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.A.T<T1,(class G1_C8`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.A.A<(class G1_C8`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.A.A<(class G1_C8`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.A.B<(class G1_C8`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.A.B<(class G1_C8`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.B.T<T1,(class G1_C8`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.B.T<T1,(class G1_C8`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.B.A<(class G1_C8`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.B.A<(class G1_C8`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C8.B.B<(class G1_C8`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 14
.locals init (string[] actualResults)
ldc.i4.s 9
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C8.B.B<(class G1_C8`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 9
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase0<(IBase0)W>(!!W inst, string exp) cil managed {
.maxstack 9
.locals init (string[] actualResults)
ldc.i4.s 4
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase0<(IBase0)W>(!!W inst, string exp)"
ldc.i4.s 4
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method3<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method public hidebysig static void MethodCallingTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calling Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1419`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method5()
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method4()
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod4229<object>()
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass0>
callvirt instance string class G3_C1419`1<class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G3_C1419`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method5()
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method4()
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
callvirt instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod4229<object>()
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2258<object>()
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2257<object>()
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod2256()
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method7<object>()
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1419`1<class BaseClass1>
callvirt instance string class G3_C1419`1<class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method2<object>()
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method0()
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void ConstrainedCallsTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Constrained Calls Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1419`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.T<class BaseClass0,class G3_C1419`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.A<class G3_C1419`1<class BaseClass0>>(!!0,string)
newobj instance void class G3_C1419`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G1_C8.A.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.T.T<class BaseClass0,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G2_C448::Method4.9036()#G2_C448::Method5.9038()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G2_C448.A.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.A<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.T<class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.A<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.IBase2.B.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G2_C448::ClassMethod2256.9041()#G3_C1419::ClassMethod2257.MI.16075<System.Object>()#G2_C448::ClassMethod2258.9043<System.Object>()#G3_C1419::ClassMethod4229.16074<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#G2_C448::Method7.9035<System.Object>()#"
call void Generated947::M.G3_C1419.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.T<class BaseClass1,class G3_C1419`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1419::Method4.16071()#G3_C1419::Method5.16072()#G3_C1419::Method6.16073<System.Object>()#"
call void Generated947::M.IBase1.B<class G3_C1419`1<class BaseClass1>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.A<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass0,class BaseClass0>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.T<class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.A.B<class G1_C8`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass0,class BaseClass1>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass1,class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.T<class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.A<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.A<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass0,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.A<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.B<class G1_C8`2<class BaseClass1,class BaseClass0>>(!!0,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.T.T<class BaseClass1,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::ClassMethod1332.4829()#G1_C8::ClassMethod1333.4830()#G1_C8::ClassMethod1334.4831<System.Object>()#G1_C8::ClassMethod1335.4832<System.Object>()#G1_C8::Method0.4823()#G1_C8::Method1.4825()#G1_C8::Method2.4826<System.Object>()#G1_C8::Method3.4828<System.Object>()#G1_C8::Method7.4821<System.Object>()#"
call void Generated947::M.G1_C8.B.B<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.B.B<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method0.MI.4824()#G1_C8::Method1.4825()#G1_C8::Method2.MI.4827<System.Object>()#G1_C8::Method3.4828<System.Object>()#"
call void Generated947::M.IBase0<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.T<class BaseClass1,class G1_C8`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C8::Method7.MI.4822<System.Object>()#"
call void Generated947::M.IBase2.A.B<class G1_C8`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void StructConstrainedInterfaceCallsTest() cil managed
{
.maxstack 10
ldstr "===================== Struct Constrained Interface Calls Test ====================="
call void [mscorlib]System.Console::WriteLine(string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void CalliTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calli Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1419`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass0>::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod4229<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method1()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass0>::Method0()
calli default string(class G3_C1419`1<class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass0> on type class G3_C1419`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G3_C1419`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method5.9038()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method4.9036()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C448`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C448`2<class BaseClass0,class BaseClass1>::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G2_C448`2<class BaseClass0,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod4229<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::ClassMethod4229.16074<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod2258<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2258.9043<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod2257<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::ClassMethod2257.MI.16075<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod2256()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::ClassMethod2256.9041()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method7<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G2_C448::Method7.9035<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1335<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1334<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1333()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::ClassMethod1332()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method3<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method2<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method1()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1419`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1419`1<class BaseClass1>::Method0()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G3_C1419`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method4.16071()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method5.16072()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1419`1<class BaseClass1>)
ldstr "G3_C1419::Method6.16073<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1419`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C8`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1335<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1335.4832<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1334<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1334.4831<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1333()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1333.4830()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::ClassMethod1332()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::ClassMethod1332.4829()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method2.4826<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method0.4823()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C8`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C8`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method7.4821<System.Object>()"
ldstr "class G1_C8`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method0.MI.4824()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method1.4825()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method2.MI.4827<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method3.4828<System.Object>()"
ldstr "IBase0 on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C8`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C8::Method7.MI.4822<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C8`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static int32 Main() cil managed
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
.maxstack 10
call void Generated947::MethodCallingTest()
call void Generated947::ConstrainedCallsTest()
call void Generated947::StructConstrainedInterfaceCallsTest()
call void Generated947::CalliTest()
ldc.i4 100
ret
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/Loader/classloader/TypeGeneratorTests/TypeGeneratorTest673/Generated673.il | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) .ver 4:0:0:0 }
.assembly extern TestFramework { .publickeytoken = ( B0 3F 5F 7F 11 D5 0A 3A ) }
//TYPES IN FORWARDER ASSEMBLIES:
//TEST ASSEMBLY:
.assembly Generated673 { .hash algorithm 0x00008004 }
.assembly extern xunit.core {}
.class public BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class public BaseClass1
extends BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void BaseClass0::.ctor()
ret
}
}
.class public G3_C1145`1<T0>
extends class G2_C201`1<class BaseClass0>
implements class IBase1`1<!T0>
{
.method public hidebysig virtual instance string Method4() cil managed noinlining {
ldstr "G3_C1145::Method4.14577()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method4'() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ret
}
.method public hidebysig newslot virtual instance string Method5() cil managed noinlining {
ldstr "G3_C1145::Method5.14579()"
ret
}
.method public hidebysig newslot virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G3_C1145::Method6.14580<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method6'<M0>() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method6<[1]>()
ldstr "G3_C1145::Method6.MI.14581<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod3683() cil managed noinlining {
ldstr "G3_C1145::ClassMethod3683.14582()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod3684() cil managed noinlining {
ldstr "G3_C1145::ClassMethod3684.14583()"
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G2_C201`1<class BaseClass0>::.ctor()
ret
}
}
.class public G2_C201`1<T0>
extends class G1_C14`2<class BaseClass1,class BaseClass1>
implements IBase0, class IBase2`2<class BaseClass0,class BaseClass0>
{
.method public hidebysig newslot virtual instance string Method0() cil managed noinlining {
ldstr "G2_C201::Method0.6653()"
ret
}
.method public hidebysig virtual instance string Method1() cil managed noinlining {
ldstr "G2_C201::Method1.6654()"
ret
}
.method public hidebysig newslot virtual instance string Method2<M0>() cil managed noinlining {
ldstr "G2_C201::Method2.6655<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase0.Method2'<M0>() cil managed noinlining {
.override method instance string IBase0::Method2<[1]>()
ldstr "G2_C201::Method2.MI.6656<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method3<M0>() cil managed noinlining {
ldstr "G2_C201::Method3.6657<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G2_C201::Method7.6658<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase2<class BaseClass0,class BaseClass0>.Method7'<M0>() cil managed noinlining {
.override method instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<[1]>()
ldstr "G2_C201::Method7.MI.6659<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1733() cil managed noinlining {
ldstr "G2_C201::ClassMethod1733.6660()"
ret
}
.method public hidebysig newslot virtual instance string 'G1_C14<class BaseClass1,class BaseClass1>.ClassMethod1351'<M0>() cil managed noinlining {
.override method instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<[1]>()
ldstr "G2_C201::ClassMethod1351.MI.6661<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
ret
}
}
.class interface public abstract IBase1`1<+T0>
{
.method public hidebysig newslot abstract virtual instance string Method4() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method5() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method6<M0>() cil managed { }
}
.class public G1_C14`2<T0, T1>
implements class IBase2`2<!T1,class BaseClass1>, class IBase1`1<class BaseClass1>
{
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G1_C14::Method7.4878<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method4() cil managed noinlining {
ldstr "G1_C14::Method4.4879()"
ret
}
.method public hidebysig newslot virtual instance string Method5() cil managed noinlining {
ldstr "G1_C14::Method5.4880()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<class BaseClass1>.Method5'() cil managed noinlining {
.override method instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ret
}
.method public hidebysig virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G1_C14::Method6.4882<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1350<M0>() cil managed noinlining {
ldstr "G1_C14::ClassMethod1350.4883<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1351<M0>() cil managed noinlining {
ldstr "G1_C14::ClassMethod1351.4884<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class interface public abstract IBase0
{
.method public hidebysig newslot abstract virtual instance string Method0() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method1() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method2<M0>() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method3<M0>() cil managed { }
}
.class interface public abstract IBase2`2<+T0, -T1>
{
.method public hidebysig newslot abstract virtual instance string Method7<M0>() cil managed { }
}
.class public auto ansi beforefieldinit Generated673 {
.method static void M.BaseClass0<(BaseClass0)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass0<(BaseClass0)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.BaseClass1<(BaseClass1)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass1<(BaseClass1)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1145.T<T0,(class G3_C1145`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 18
.locals init (string[] actualResults)
ldc.i4.s 13
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1145.T<T0,(class G3_C1145`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 13
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod3683()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod3684()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1145.A<(class G3_C1145`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 18
.locals init (string[] actualResults)
ldc.i4.s 13
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1145.A<(class G3_C1145`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 13
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3683()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3684()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1145.B<(class G3_C1145`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 18
.locals init (string[] actualResults)
ldc.i4.s 13
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1145.B<(class G3_C1145`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 13
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3683()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3684()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C201.T<T0,(class G2_C201`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 16
.locals init (string[] actualResults)
ldc.i4.s 11
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C201.T<T0,(class G2_C201`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 11
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C201.A<(class G2_C201`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 16
.locals init (string[] actualResults)
ldc.i4.s 11
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C201.A<(class G2_C201`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 11
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C201.B<(class G2_C201`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 16
.locals init (string[] actualResults)
ldc.i4.s 11
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C201.B<(class G2_C201`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 11
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.T.T<T0,T1,(class G1_C14`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.T.T<T0,T1,(class G1_C14`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.A.T<T1,(class G1_C14`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.A.T<T1,(class G1_C14`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.A.A<(class G1_C14`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.A.A<(class G1_C14`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.A.B<(class G1_C14`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.A.B<(class G1_C14`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.B.T<T1,(class G1_C14`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.B.T<T1,(class G1_C14`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.B.A<(class G1_C14`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.B.A<(class G1_C14`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.B.B<(class G1_C14`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.B.B<(class G1_C14`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase0<(IBase0)W>(!!W inst, string exp) cil managed {
.maxstack 9
.locals init (string[] actualResults)
ldc.i4.s 4
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase0<(IBase0)W>(!!W inst, string exp)"
ldc.i4.s 4
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method3<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method public hidebysig static void MethodCallingTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calling Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1145`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3684()
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3683()
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G3_C1145`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3684()
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3683()
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G2_C201`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G2_C201`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void ConstrainedCallsTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Constrained Calls Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1145`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.14577()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.14577()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
newobj instance void class G3_C1145`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.A<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.A<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
newobj instance void class G2_C201`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass0,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.A<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G2_C201`1<class BaseClass0>>(!!0,string)
newobj instance void class G2_C201`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G2_C201`1<class BaseClass1>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass0,class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.T<class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.A<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.A<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void StructConstrainedInterfaceCallsTest() cil managed
{
.maxstack 10
ldstr "===================== Struct Constrained Interface Calls Test ====================="
call void [mscorlib]System.Console::WriteLine(string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void CalliTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calli Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1145`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method1()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method0()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod3684()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod3683()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method1()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method0()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G3_C1145`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method1()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method0()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod3684()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod3683()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method1()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method0()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G2_C201`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method3<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method2<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method1()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method0()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G2_C201`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::ClassMethod1733()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method3<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method2<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method1()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method0()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static int32 Main() cil managed
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
.maxstack 10
call void Generated673::MethodCallingTest()
call void Generated673::ConstrainedCallsTest()
call void Generated673::StructConstrainedInterfaceCallsTest()
call void Generated673::CalliTest()
ldc.i4 100
ret
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern mscorlib { .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) .ver 4:0:0:0 }
.assembly extern TestFramework { .publickeytoken = ( B0 3F 5F 7F 11 D5 0A 3A ) }
//TYPES IN FORWARDER ASSEMBLIES:
//TEST ASSEMBLY:
.assembly Generated673 { .hash algorithm 0x00008004 }
.assembly extern xunit.core {}
.class public BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class public BaseClass1
extends BaseClass0
{
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void BaseClass0::.ctor()
ret
}
}
.class public G3_C1145`1<T0>
extends class G2_C201`1<class BaseClass0>
implements class IBase1`1<!T0>
{
.method public hidebysig virtual instance string Method4() cil managed noinlining {
ldstr "G3_C1145::Method4.14577()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method4'() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ret
}
.method public hidebysig newslot virtual instance string Method5() cil managed noinlining {
ldstr "G3_C1145::Method5.14579()"
ret
}
.method public hidebysig newslot virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G3_C1145::Method6.14580<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<T0>.Method6'<M0>() cil managed noinlining {
.override method instance string class IBase1`1<!T0>::Method6<[1]>()
ldstr "G3_C1145::Method6.MI.14581<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod3683() cil managed noinlining {
ldstr "G3_C1145::ClassMethod3683.14582()"
ret
}
.method public hidebysig newslot virtual instance string ClassMethod3684() cil managed noinlining {
ldstr "G3_C1145::ClassMethod3684.14583()"
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G2_C201`1<class BaseClass0>::.ctor()
ret
}
}
.class public G2_C201`1<T0>
extends class G1_C14`2<class BaseClass1,class BaseClass1>
implements IBase0, class IBase2`2<class BaseClass0,class BaseClass0>
{
.method public hidebysig newslot virtual instance string Method0() cil managed noinlining {
ldstr "G2_C201::Method0.6653()"
ret
}
.method public hidebysig virtual instance string Method1() cil managed noinlining {
ldstr "G2_C201::Method1.6654()"
ret
}
.method public hidebysig newslot virtual instance string Method2<M0>() cil managed noinlining {
ldstr "G2_C201::Method2.6655<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase0.Method2'<M0>() cil managed noinlining {
.override method instance string IBase0::Method2<[1]>()
ldstr "G2_C201::Method2.MI.6656<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method3<M0>() cil managed noinlining {
ldstr "G2_C201::Method3.6657<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G2_C201::Method7.6658<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string 'IBase2<class BaseClass0,class BaseClass0>.Method7'<M0>() cil managed noinlining {
.override method instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<[1]>()
ldstr "G2_C201::Method7.MI.6659<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1733() cil managed noinlining {
ldstr "G2_C201::ClassMethod1733.6660()"
ret
}
.method public hidebysig newslot virtual instance string 'G1_C14<class BaseClass1,class BaseClass1>.ClassMethod1351'<M0>() cil managed noinlining {
.override method instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<[1]>()
ldstr "G2_C201::ClassMethod1351.MI.6661<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
ret
}
}
.class interface public abstract IBase1`1<+T0>
{
.method public hidebysig newslot abstract virtual instance string Method4() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method5() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method6<M0>() cil managed { }
}
.class public G1_C14`2<T0, T1>
implements class IBase2`2<!T1,class BaseClass1>, class IBase1`1<class BaseClass1>
{
.method public hidebysig virtual instance string Method7<M0>() cil managed noinlining {
ldstr "G1_C14::Method7.4878<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string Method4() cil managed noinlining {
ldstr "G1_C14::Method4.4879()"
ret
}
.method public hidebysig newslot virtual instance string Method5() cil managed noinlining {
ldstr "G1_C14::Method5.4880()"
ret
}
.method public hidebysig newslot virtual instance string 'IBase1<class BaseClass1>.Method5'() cil managed noinlining {
.override method instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ret
}
.method public hidebysig virtual instance string Method6<M0>() cil managed noinlining {
ldstr "G1_C14::Method6.4882<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1350<M0>() cil managed noinlining {
ldstr "G1_C14::ClassMethod1350.4883<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig newslot virtual instance string ClassMethod1351<M0>() cil managed noinlining {
ldstr "G1_C14::ClassMethod1351.4884<"
ldtoken !!M0
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
call string [mscorlib]System.String::Concat(object,object)
ldstr ">()"
call string [mscorlib]System.String::Concat(object,object)
ret
}
.method public hidebysig specialname rtspecialname instance void .ctor() cil managed {
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
}
}
.class interface public abstract IBase0
{
.method public hidebysig newslot abstract virtual instance string Method0() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method1() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method2<M0>() cil managed { }
.method public hidebysig newslot abstract virtual instance string Method3<M0>() cil managed { }
}
.class interface public abstract IBase2`2<+T0, -T1>
{
.method public hidebysig newslot abstract virtual instance string Method7<M0>() cil managed { }
}
.class public auto ansi beforefieldinit Generated673 {
.method static void M.BaseClass0<(BaseClass0)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass0<(BaseClass0)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.BaseClass1<(BaseClass1)W>(!!W inst, string exp) cil managed {
.maxstack 5
.locals init (string[] actualResults)
ldc.i4.s 0
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.BaseClass1<(BaseClass1)W>(!!W inst, string exp)"
ldc.i4.s 0
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1145.T<T0,(class G3_C1145`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 18
.locals init (string[] actualResults)
ldc.i4.s 13
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1145.T<T0,(class G3_C1145`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 13
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod3683()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::ClassMethod3684()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<!!T0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1145.A<(class G3_C1145`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 18
.locals init (string[] actualResults)
ldc.i4.s 13
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1145.A<(class G3_C1145`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 13
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3683()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3684()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G3_C1145.B<(class G3_C1145`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 18
.locals init (string[] actualResults)
ldc.i4.s 13
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G3_C1145.B<(class G3_C1145`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 13
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3683()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3684()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 11
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 12
ldarga.s 0
constrained. !!W
callvirt instance string class G3_C1145`1<class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C201.T<T0,(class G2_C201`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 16
.locals init (string[] actualResults)
ldc.i4.s 11
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C201.T<T0,(class G2_C201`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 11
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<!!T0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C201.A<(class G2_C201`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 16
.locals init (string[] actualResults)
ldc.i4.s 11
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C201.A<(class G2_C201`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 11
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G2_C201.B<(class G2_C201`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 16
.locals init (string[] actualResults)
ldc.i4.s 11
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G2_C201.B<(class G2_C201`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 11
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1733()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 6
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method3<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 7
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 8
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 9
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 10
ldarga.s 0
constrained. !!W
callvirt instance string class G2_C201`1<class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.T<T0,(class IBase1`1<!!T0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<!!T0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.A<(class IBase1`1<class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 8
.locals init (string[] actualResults)
ldc.i4.s 3
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase1.B<(class IBase1`1<class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 3
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.T.T<T0,T1,(class G1_C14`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.T.T<T0,T1,(class G1_C14`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.A.T<T1,(class G1_C14`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.A.T<T1,(class G1_C14`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.A.A<(class G1_C14`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.A.A<(class G1_C14`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.A.B<(class G1_C14`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.A.B<(class G1_C14`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.B.T<T1,(class G1_C14`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.B.T<T1,(class G1_C14`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.B.A<(class G1_C14`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.B.A<(class G1_C14`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.G1_C14.B.B<(class G1_C14`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 11
.locals init (string[] actualResults)
ldc.i4.s 6
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.G1_C14.B.B<(class G1_C14`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 6
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
stelem.ref
ldloc.s actualResults
ldc.i4.s 4
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 5
ldarga.s 0
constrained. !!W
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase0<(IBase0)W>(!!W inst, string exp) cil managed {
.maxstack 9
.locals init (string[] actualResults)
ldc.i4.s 4
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase0<(IBase0)W>(!!W inst, string exp)"
ldc.i4.s 4
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method0()
stelem.ref
ldloc.s actualResults
ldc.i4.s 1
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method1()
stelem.ref
ldloc.s actualResults
ldc.i4.s 2
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method2<object>()
stelem.ref
ldloc.s actualResults
ldc.i4.s 3
ldarga.s 0
constrained. !!W
callvirt instance string IBase0::Method3<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.T.T<T0,T1,(class IBase2`2<!!T0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<!!T0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.T<T1,(class IBase2`2<class BaseClass0,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.A<(class IBase2`2<class BaseClass0,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.A.B<(class IBase2`2<class BaseClass0,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.T<T1,(class IBase2`2<class BaseClass1,!!T1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,!!T1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.A<(class IBase2`2<class BaseClass1,class BaseClass0>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass0>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method static void M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp) cil managed {
.maxstack 6
.locals init (string[] actualResults)
ldc.i4.s 1
newarr string
stloc.s actualResults
ldarg.1
ldstr "M.IBase2.B.B<(class IBase2`2<class BaseClass1,class BaseClass1>)W>(!!W 'inst', string exp)"
ldc.i4.s 1
ldloc.s actualResults
ldc.i4.s 0
ldarga.s 0
constrained. !!W
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
stelem.ref
ldloc.s actualResults
call void [TestFramework]TestFramework::MethodCallTest(string,string,int32,string[])
ret
}
.method public hidebysig static void MethodCallingTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calling Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1145`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3684()
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod3683()
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass0>
callvirt instance string class G3_C1145`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G3_C1145`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3684()
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod3683()
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method6<object>()
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method5()
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method4()
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G3_C1145`1<class BaseClass1>
callvirt instance string class G3_C1145`1<class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G2_C201`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass0>
callvirt instance string class G2_C201`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G2_C201`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1733()
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method7<object>()
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method2<object>()
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1351<object>()
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G2_C201`1<class BaseClass1>
callvirt instance string class G2_C201`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string IBase0::Method0()
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method1()
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method2<object>()
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string IBase0::Method3<object>()
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
callvirt instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass1>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldloc.0
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method4()
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method5()
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
dup
callvirt instance string class IBase1`1<class BaseClass0>::Method6<object>()
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
pop
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void ConstrainedCallsTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Constrained Calls Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1145`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.14577()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.14577()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.T<class BaseClass0,class G3_C1145`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.A<class G3_C1145`1<class BaseClass0>>(!!0,string)
newobj instance void class G3_C1145`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G3_C1145::Method4.MI.14578()#G3_C1145::Method5.14579()#G3_C1145::Method6.MI.14581<System.Object>()#"
call void Generated673::M.IBase1.A<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.A<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G3_C1145`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.T<class BaseClass1,class G3_C1145`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G3_C1145::ClassMethod3683.14582()#G3_C1145::ClassMethod3684.14583()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G3_C1145::Method4.14577()#G3_C1145::Method5.14579()#G3_C1145::Method6.14580<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G3_C1145.B<class G3_C1145`1<class BaseClass1>>(!!0,string)
newobj instance void class G2_C201`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass0,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.A<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G2_C201`1<class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G2_C201`1<class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G2_C201`1<class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G2_C201`1<class BaseClass0>>(!!0,string)
newobj instance void class G2_C201`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.T<class BaseClass1,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G2_C201::ClassMethod1351.MI.6661<System.Object>()#G2_C201::ClassMethod1733.6660()#G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.6655<System.Object>()#G2_C201::Method3.6657<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G2_C201::Method7.6658<System.Object>()#"
call void Generated673::M.G2_C201.B<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method0.6653()#G2_C201::Method1.6654()#G2_C201::Method2.MI.6656<System.Object>()#G2_C201::Method3.6657<System.Object>()#"
call void Generated673::M.IBase0<class G2_C201`1<class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass0,class G2_C201`1<class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass0,class G2_C201`1<class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G2_C201::Method7.MI.6659<System.Object>()#"
call void Generated673::M.IBase2.A.A<class G2_C201`1<class BaseClass1>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass0,class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.T<class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.A<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass0,class BaseClass0>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.A.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass0,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass0,class BaseClass1>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.A<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass0>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass1,class BaseClass0>>(!!0,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.T.T<class BaseClass1,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()#G1_C14::ClassMethod1351.4884<System.Object>()#G1_C14::Method4.4879()#G1_C14::Method5.4880()#G1_C14::Method6.4882<System.Object>()#G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.G1_C14.B.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass1,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.B.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.T.T<class BaseClass0,class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!2,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.T<class BaseClass1,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method7.4878<System.Object>()#"
call void Generated673::M.IBase2.A.B<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.T<class BaseClass0,class G1_C14`2<class BaseClass1,class BaseClass1>>(!!1,string)
ldloc.0
ldstr "G1_C14::Method4.4879()#G1_C14::Method5.MI.4881()#G1_C14::Method6.4882<System.Object>()#"
call void Generated673::M.IBase1.A<class G1_C14`2<class BaseClass1,class BaseClass1>>(!!0,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void StructConstrainedInterfaceCallsTest() cil managed
{
.maxstack 10
ldstr "===================== Struct Constrained Interface Calls Test ====================="
call void [mscorlib]System.Console::WriteLine(string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static void CalliTest() cil managed
{
.maxstack 10
.locals init (object V_0)
ldstr "========================== Method Calli Test =========================="
call void [mscorlib]System.Console::WriteLine(string)
newobj instance void class G3_C1145`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method1()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method0()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod3684()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod3683()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method1()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::Method0()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass0> on type class G3_C1145`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G3_C1145`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.MI.14578()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method6.MI.14581<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method1()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method0()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G2_C201`1<class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod3684()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::ClassMethod3684.14583()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod3683()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::ClassMethod3683.14582()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method6<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method6.14580<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method5()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method5.14579()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method4()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G3_C1145::Method4.14577()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod1733()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method7<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method3<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method2<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method1()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::Method0()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod1351<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G3_C1145`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G3_C1145`1<class BaseClass1>::ClassMethod1350<object>()
calli default string(class G3_C1145`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G3_C1145`1<class BaseClass1> on type class G3_C1145`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G2_C201`1<class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1733()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method3<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method2<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method1()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method0()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method5()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass0>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass0>::Method4()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass0>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G2_C201`1<class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::ClassMethod1733()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1733.6660()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.6658<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method3<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method2<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method2.6655<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method1()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method0()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::ClassMethod1351<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::ClassMethod1351.MI.6661<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::ClassMethod1350<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method6<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method5()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G2_C201`1<class BaseClass1>
ldloc.0
ldvirtftn instance string class G2_C201`1<class BaseClass1>::Method4()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G2_C201`1<class BaseClass1> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method0()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method0.6653()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method1()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method1.6654()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method2<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method2.MI.6656<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string IBase0::Method3<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method3.6657<System.Object>()"
ldstr "IBase0 on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G2_C201`1<class BaseClass1>)
ldstr "G2_C201::Method7.MI.6659<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass0> on type class G2_C201`1<class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass0>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass0,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass0,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass0,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass0,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass0>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass0>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass0>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass0>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass0>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
newobj instance void class G1_C14`2<class BaseClass1,class BaseClass1>::.ctor()
stloc.0
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1351<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::ClassMethod1351.4884<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::ClassMethod1350<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::ClassMethod1350.4883<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method5.4880()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
castclass class G1_C14`2<class BaseClass1,class BaseClass1>
ldloc.0
ldvirtftn instance string class G1_C14`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class G1_C14`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass1,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass1,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass1>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase2`2<class BaseClass0,class BaseClass1>::Method7<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method7.4878<System.Object>()"
ldstr "class IBase2`2<class BaseClass0,class BaseClass1> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method4()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method4.4879()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method5()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method5.MI.4881()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldloc.0
ldloc.0
ldvirtftn instance string class IBase1`1<class BaseClass0>::Method6<object>()
calli default string(class G1_C14`2<class BaseClass1,class BaseClass1>)
ldstr "G1_C14::Method6.4882<System.Object>()"
ldstr "class IBase1`1<class BaseClass0> on type class G1_C14`2<class BaseClass1,class BaseClass1>"
call void [TestFramework]TestFramework::MethodCallTest(string,string,string)
ldstr "========================================================================\n\n"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
.method public hidebysig static int32 Main() cil managed
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
.maxstack 10
call void Generated673::MethodCallingTest()
call void Generated673::ConstrainedCallsTest()
call void Generated673::StructConstrainedInterfaceCallsTest()
call void Generated673::CalliTest()
ldc.i4 100
ret
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Private.Xml/src/System/Xml/Xsl/XsltOld/ActionFrame.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Xml.Xsl.XsltOld
{
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Xml;
using System.Xml.XPath;
using MS.Internal.Xml.XPath;
internal sealed class ActionFrame
{
private int _state; // Action execution state
private int _counter; // Counter, for the use of particular action
private object[]? _variables; // Store for template local variable values
private Hashtable? _withParams;
private Action? _action; // Action currently being executed
private ActionFrame? _container; // Frame of enclosing container action and index within it
private int _currentAction;
private XPathNodeIterator? _nodeSet; // Current node set
private XPathNodeIterator? _newNodeSet; // Node set for processing children or other templates
// Variables to store action data between states:
private PrefixQName? _calulatedName; // Used in ElementAction and AttributeAction
private string? _storedOutput; // Used in NumberAction, CopyOfAction, ValueOfAction and ProcessingInstructionAction
internal PrefixQName? CalulatedName
{
get { return _calulatedName; }
set { _calulatedName = value; }
}
internal string? StoredOutput
{
get { return _storedOutput; }
set { _storedOutput = value; }
}
internal int State
{
get { return _state; }
set { _state = value; }
}
internal int Counter
{
get { return _counter; }
set { _counter = value; }
}
internal ActionFrame? Container
{
get { return _container; }
}
internal XPathNavigator? Node
{
get
{
if (_nodeSet != null)
{
return _nodeSet.Current;
}
return null;
}
}
internal XPathNodeIterator? NodeSet
{
get { return _nodeSet; }
}
internal XPathNodeIterator? NewNodeSet
{
get { return _newNodeSet; }
}
internal int IncrementCounter()
{
return ++_counter;
}
internal void AllocateVariables(int count)
{
if (0 < count)
{
_variables = new object[count];
}
else
{
_variables = null;
}
}
internal object GetVariable(int index)
{
Debug.Assert(_variables != null && index < _variables.Length);
return _variables[index];
}
internal void SetVariable(int index, object value)
{
Debug.Assert(_variables != null && index < _variables.Length);
_variables[index] = value;
}
internal void SetParameter(XmlQualifiedName name, object value)
{
if (_withParams == null)
{
_withParams = new Hashtable();
}
Debug.Assert(!_withParams.Contains(name), "We should check duplicate params at compile time");
_withParams[name] = value;
}
internal void ResetParams()
{
if (_withParams != null)
_withParams.Clear();
}
internal object? GetParameter(XmlQualifiedName name)
{
if (_withParams != null)
{
return _withParams[name];
}
return null;
}
internal void InitNodeSet(XPathNodeIterator nodeSet)
{
Debug.Assert(nodeSet != null);
_nodeSet = nodeSet;
}
[MemberNotNull(nameof(_newNodeSet))]
internal void InitNewNodeSet(XPathNodeIterator nodeSet)
{
Debug.Assert(nodeSet != null);
_newNodeSet = nodeSet;
}
[MemberNotNull(nameof(_newNodeSet))]
internal void SortNewNodeSet(Processor proc, ArrayList sortarray)
{
Debug.Assert(0 < sortarray.Count);
int numSorts = sortarray.Count;
XPathSortComparer comparer = new XPathSortComparer(numSorts);
for (int i = 0; i < numSorts; i++)
{
Sort sort = (Sort)sortarray[i]!;
Query expr = proc.GetCompiledQuery(sort.select);
comparer.AddSort(expr, new XPathComparerHelper(sort.order, sort.caseOrder, sort.lang, sort.dataType));
}
List<SortKey> results = new List<SortKey>();
Debug.Assert(proc.ActionStack.Peek() == this, "the trick we are doing with proc.Current will work only if this is topmost frame");
while (NewNextNode(proc))
{
XPathNodeIterator? savedNodeset = _nodeSet;
_nodeSet = _newNodeSet; // trick proc.Current node
SortKey key = new SortKey(numSorts, /*originalPosition:*/results.Count, _newNodeSet!.Current!.Clone());
for (int j = 0; j < numSorts; j++)
{
key[j] = comparer.Expression(j).Evaluate(_newNodeSet);
}
results.Add(key);
_nodeSet = savedNodeset; // restore proc.Current node
}
results.Sort(comparer);
_newNodeSet = new XPathSortArrayIterator(results);
}
// Finished
internal void Finished()
{
State = Action.Finished;
}
internal void Inherit(ActionFrame parent)
{
Debug.Assert(parent != null);
_variables = parent._variables;
}
private void Init(Action? action, ActionFrame? container, XPathNodeIterator? nodeSet)
{
_state = Action.Initialized;
_action = action;
_container = container;
_currentAction = 0;
_nodeSet = nodeSet;
_newNodeSet = null;
}
internal void Init(Action action, XPathNodeIterator? nodeSet)
{
Init(action, null, nodeSet);
}
internal void Init(ActionFrame containerFrame, XPathNodeIterator? nodeSet)
{
Init(containerFrame.GetAction(0), containerFrame, nodeSet);
}
internal void SetAction(Action action)
{
SetAction(action, Action.Initialized);
}
internal void SetAction(Action action, int state)
{
_action = action;
_state = state;
}
private Action? GetAction(int actionIndex)
{
Debug.Assert(_action is ContainerAction);
return ((ContainerAction)_action).GetAction(actionIndex);
}
internal void Exit()
{
Finished();
_container = null;
}
/*
* Execute
* return values: true - pop, false - nothing
*/
[MemberNotNullWhen(false, nameof(_action))]
internal bool Execute(Processor processor)
{
if (_action == null)
{
return true;
}
// Execute the action
_action.Execute(processor, this);
// Process results
if (State == Action.Finished)
{
// Advanced to next action
if (_container != null)
{
_currentAction++;
_action = _container.GetAction(_currentAction);
State = Action.Initialized;
}
else
{
_action = null;
}
return _action == null;
}
return false; // Do not pop, unless specified otherwise
}
internal bool NextNode(Processor proc)
{
bool next = _nodeSet!.MoveNext();
if (next && proc.Stylesheet.Whitespace)
{
XPathNodeType type = _nodeSet.Current!.NodeType;
if (type == XPathNodeType.Whitespace)
{
XPathNavigator nav = _nodeSet.Current.Clone();
bool flag;
do
{
nav.MoveTo(_nodeSet.Current);
nav.MoveToParent();
flag = !proc.Stylesheet.PreserveWhiteSpace(proc, nav) && (next = _nodeSet.MoveNext());
type = _nodeSet.Current.NodeType;
}
while (flag && (type == XPathNodeType.Whitespace));
}
}
return next;
}
internal bool NewNextNode(Processor proc)
{
bool next = _newNodeSet!.MoveNext();
if (next && proc.Stylesheet.Whitespace)
{
XPathNodeType type = _newNodeSet.Current!.NodeType;
if (type == XPathNodeType.Whitespace)
{
XPathNavigator nav = _newNodeSet.Current.Clone();
bool flag;
do
{
nav.MoveTo(_newNodeSet.Current);
nav.MoveToParent();
flag = !proc.Stylesheet.PreserveWhiteSpace(proc, nav) && (next = _newNodeSet.MoveNext());
type = _newNodeSet.Current.NodeType;
}
while (flag && (type == XPathNodeType.Whitespace));
}
}
return next;
}
// special array iterator that iterates over ArrayList of SortKey
private sealed class XPathSortArrayIterator : XPathArrayIterator
{
public XPathSortArrayIterator(List<SortKey> list) : base(list) { }
public XPathSortArrayIterator(XPathSortArrayIterator it) : base(it) { }
public override XPathNodeIterator Clone()
{
return new XPathSortArrayIterator(this);
}
public override XPathNavigator Current
{
get
{
Debug.Assert(index > 0, "MoveNext() wasn't called");
return ((SortKey)this.list[this.index - 1]!).Node;
}
}
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Xml.Xsl.XsltOld
{
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Xml;
using System.Xml.XPath;
using MS.Internal.Xml.XPath;
internal sealed class ActionFrame
{
private int _state; // Action execution state
private int _counter; // Counter, for the use of particular action
private object[]? _variables; // Store for template local variable values
private Hashtable? _withParams;
private Action? _action; // Action currently being executed
private ActionFrame? _container; // Frame of enclosing container action and index within it
private int _currentAction;
private XPathNodeIterator? _nodeSet; // Current node set
private XPathNodeIterator? _newNodeSet; // Node set for processing children or other templates
// Variables to store action data between states:
private PrefixQName? _calulatedName; // Used in ElementAction and AttributeAction
private string? _storedOutput; // Used in NumberAction, CopyOfAction, ValueOfAction and ProcessingInstructionAction
internal PrefixQName? CalulatedName
{
get { return _calulatedName; }
set { _calulatedName = value; }
}
internal string? StoredOutput
{
get { return _storedOutput; }
set { _storedOutput = value; }
}
internal int State
{
get { return _state; }
set { _state = value; }
}
internal int Counter
{
get { return _counter; }
set { _counter = value; }
}
internal ActionFrame? Container
{
get { return _container; }
}
internal XPathNavigator? Node
{
get
{
if (_nodeSet != null)
{
return _nodeSet.Current;
}
return null;
}
}
internal XPathNodeIterator? NodeSet
{
get { return _nodeSet; }
}
internal XPathNodeIterator? NewNodeSet
{
get { return _newNodeSet; }
}
internal int IncrementCounter()
{
return ++_counter;
}
internal void AllocateVariables(int count)
{
if (0 < count)
{
_variables = new object[count];
}
else
{
_variables = null;
}
}
internal object GetVariable(int index)
{
Debug.Assert(_variables != null && index < _variables.Length);
return _variables[index];
}
internal void SetVariable(int index, object value)
{
Debug.Assert(_variables != null && index < _variables.Length);
_variables[index] = value;
}
internal void SetParameter(XmlQualifiedName name, object value)
{
if (_withParams == null)
{
_withParams = new Hashtable();
}
Debug.Assert(!_withParams.Contains(name), "We should check duplicate params at compile time");
_withParams[name] = value;
}
internal void ResetParams()
{
if (_withParams != null)
_withParams.Clear();
}
internal object? GetParameter(XmlQualifiedName name)
{
if (_withParams != null)
{
return _withParams[name];
}
return null;
}
internal void InitNodeSet(XPathNodeIterator nodeSet)
{
Debug.Assert(nodeSet != null);
_nodeSet = nodeSet;
}
[MemberNotNull(nameof(_newNodeSet))]
internal void InitNewNodeSet(XPathNodeIterator nodeSet)
{
Debug.Assert(nodeSet != null);
_newNodeSet = nodeSet;
}
[MemberNotNull(nameof(_newNodeSet))]
internal void SortNewNodeSet(Processor proc, ArrayList sortarray)
{
Debug.Assert(0 < sortarray.Count);
int numSorts = sortarray.Count;
XPathSortComparer comparer = new XPathSortComparer(numSorts);
for (int i = 0; i < numSorts; i++)
{
Sort sort = (Sort)sortarray[i]!;
Query expr = proc.GetCompiledQuery(sort.select);
comparer.AddSort(expr, new XPathComparerHelper(sort.order, sort.caseOrder, sort.lang, sort.dataType));
}
List<SortKey> results = new List<SortKey>();
Debug.Assert(proc.ActionStack.Peek() == this, "the trick we are doing with proc.Current will work only if this is topmost frame");
while (NewNextNode(proc))
{
XPathNodeIterator? savedNodeset = _nodeSet;
_nodeSet = _newNodeSet; // trick proc.Current node
SortKey key = new SortKey(numSorts, /*originalPosition:*/results.Count, _newNodeSet!.Current!.Clone());
for (int j = 0; j < numSorts; j++)
{
key[j] = comparer.Expression(j).Evaluate(_newNodeSet);
}
results.Add(key);
_nodeSet = savedNodeset; // restore proc.Current node
}
results.Sort(comparer);
_newNodeSet = new XPathSortArrayIterator(results);
}
// Finished
internal void Finished()
{
State = Action.Finished;
}
internal void Inherit(ActionFrame parent)
{
Debug.Assert(parent != null);
_variables = parent._variables;
}
private void Init(Action? action, ActionFrame? container, XPathNodeIterator? nodeSet)
{
_state = Action.Initialized;
_action = action;
_container = container;
_currentAction = 0;
_nodeSet = nodeSet;
_newNodeSet = null;
}
internal void Init(Action action, XPathNodeIterator? nodeSet)
{
Init(action, null, nodeSet);
}
internal void Init(ActionFrame containerFrame, XPathNodeIterator? nodeSet)
{
Init(containerFrame.GetAction(0), containerFrame, nodeSet);
}
internal void SetAction(Action action)
{
SetAction(action, Action.Initialized);
}
internal void SetAction(Action action, int state)
{
_action = action;
_state = state;
}
private Action? GetAction(int actionIndex)
{
Debug.Assert(_action is ContainerAction);
return ((ContainerAction)_action).GetAction(actionIndex);
}
internal void Exit()
{
Finished();
_container = null;
}
/*
* Execute
* return values: true - pop, false - nothing
*/
[MemberNotNullWhen(false, nameof(_action))]
internal bool Execute(Processor processor)
{
if (_action == null)
{
return true;
}
// Execute the action
_action.Execute(processor, this);
// Process results
if (State == Action.Finished)
{
// Advanced to next action
if (_container != null)
{
_currentAction++;
_action = _container.GetAction(_currentAction);
State = Action.Initialized;
}
else
{
_action = null;
}
return _action == null;
}
return false; // Do not pop, unless specified otherwise
}
internal bool NextNode(Processor proc)
{
bool next = _nodeSet!.MoveNext();
if (next && proc.Stylesheet.Whitespace)
{
XPathNodeType type = _nodeSet.Current!.NodeType;
if (type == XPathNodeType.Whitespace)
{
XPathNavigator nav = _nodeSet.Current.Clone();
bool flag;
do
{
nav.MoveTo(_nodeSet.Current);
nav.MoveToParent();
flag = !proc.Stylesheet.PreserveWhiteSpace(proc, nav) && (next = _nodeSet.MoveNext());
type = _nodeSet.Current.NodeType;
}
while (flag && (type == XPathNodeType.Whitespace));
}
}
return next;
}
internal bool NewNextNode(Processor proc)
{
bool next = _newNodeSet!.MoveNext();
if (next && proc.Stylesheet.Whitespace)
{
XPathNodeType type = _newNodeSet.Current!.NodeType;
if (type == XPathNodeType.Whitespace)
{
XPathNavigator nav = _newNodeSet.Current.Clone();
bool flag;
do
{
nav.MoveTo(_newNodeSet.Current);
nav.MoveToParent();
flag = !proc.Stylesheet.PreserveWhiteSpace(proc, nav) && (next = _newNodeSet.MoveNext());
type = _newNodeSet.Current.NodeType;
}
while (flag && (type == XPathNodeType.Whitespace));
}
}
return next;
}
// special array iterator that iterates over ArrayList of SortKey
private sealed class XPathSortArrayIterator : XPathArrayIterator
{
public XPathSortArrayIterator(List<SortKey> list) : base(list) { }
public XPathSortArrayIterator(XPathSortArrayIterator it) : base(it) { }
public override XPathNodeIterator Clone()
{
return new XPathSortArrayIterator(this);
}
public override XPathNavigator Current
{
get
{
Debug.Assert(index > 0, "MoveNext() wasn't called");
return ((SortKey)this.list[this.index - 1]!).Node;
}
}
}
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/genericdict.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// File: genericdict.h
//
//
// Definitions for "dictionaries" used to encapsulate generic instantiations
// and instantiation-specific information for shared-code generics
//
//
// ============================================================================
#ifndef _GENERICDICT_H
#define _GENERICDICT_H
// DICTIONARIES
//
// A dictionary is a cache of handles associated with particular
// instantiations of generic classes and generic methods, containing
// - the instantiation itself (a list of TypeHandles)
// - handles created on demand at runtime when code shared between
// multiple instantiations needs to lookup an instantiation-specific
// handle (for example, in newobj C<!0> and castclass !!0[])
//
// DICTIONARY ENTRIES
//
// Dictionary entries (abstracted as the type DictionaryEntry) can be:
// a TypeHandle (for type arguments and entries associated with a TypeSpec token)
// a MethodDesc* (for entries associated with a method MemberRef or MethodSpec token)
// a FieldDesc* (for entries associated with a field MemberRef token)
// a code pointer (e.g. for entries associated with an EntryPointAnnotation annotated token)
// a dispatch stub address (for entries associated with an StubAddrAnnotation annotated token)
//
// DICTIONARY LAYOUTS
//
// A dictionary layout describes the layout of all dictionaries that can be
// accessed from the same shared code. For example, Hashtable<string,int> and
// Hashtable<object,int> share one layout, and Hashtable<int,string> and Hashtable<int,object>
// share another layout. For generic types, the dictionary layout is stored in the EEClass
// that is shared across compatible instantiations. For generic methods, the layout
// is stored in the InstantiatedMethodDesc associated with the shared generic code itself.
//
class TypeHandleList;
class Module;
class BaseDomain;
class SigTypeContext;
class SigBuilder;
enum DictionaryEntryKind
{
EmptySlot = 0,
TypeHandleSlot = 1,
MethodDescSlot = 2,
MethodEntrySlot = 3,
ConstrainedMethodEntrySlot = 4,
DispatchStubAddrSlot = 5,
FieldDescSlot = 6,
DeclaringTypeHandleSlot = 7,
};
enum DictionaryEntrySignatureSource : BYTE
{
FromZapImage = 0,
FromReadyToRunImage = 1,
FromJIT = 2,
};
class DictionaryEntryLayout
{
public:
DictionaryEntryLayout(PTR_VOID signature)
{ LIMITED_METHOD_CONTRACT; m_signature = signature; }
DictionaryEntryKind GetKind();
PTR_VOID m_signature;
DictionaryEntrySignatureSource m_signatureSource;
};
typedef DPTR(DictionaryEntryLayout) PTR_DictionaryEntryLayout;
class DictionaryLayout;
typedef DPTR(DictionaryLayout) PTR_DictionaryLayout;
// Number of slots to initially allocate in a generic method dictionary layout.
#if _DEBUG
#define NUM_DICTIONARY_SLOTS 1 // Smaller number to stress the dictionary expansion logic
#else
#define NUM_DICTIONARY_SLOTS 4
#endif
// The type of dictionary layouts. We don't include the number of type
// arguments as this is obtained elsewhere
class DictionaryLayout
{
friend class Dictionary;
private:
// Current number of non-type-argument slots
WORD m_numSlots;
// Number of non-type-argument slots of the initial layout before any expansion
WORD m_numInitialSlots;
// m_numSlots of these
DictionaryEntryLayout m_slots[1];
static BOOL FindTokenWorker(LoaderAllocator* pAllocator,
DWORD numGenericArgs,
DictionaryLayout* pDictLayout,
SigBuilder* pSigBuilder,
BYTE* pSig,
DWORD cbSig,
int nFirstOffset,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut,
DWORD scanFromSlot,
BOOL useEmptySlotIfFound);
static DictionaryLayout* ExpandDictionaryLayout(LoaderAllocator* pAllocator,
DictionaryLayout* pCurrentDictLayout,
DWORD numGenericArgs,
SigBuilder* pSigBuilder,
BYTE* pSig,
int nFirstOffset,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut);
static PVOID CreateSignatureWithSlotData(SigBuilder* pSigBuilder, LoaderAllocator* pAllocator, WORD slot);
public:
// Create an initial dictionary layout containing numSlots slots
static DictionaryLayout* Allocate(WORD numSlots, LoaderAllocator *pAllocator, AllocMemTracker *pamTracker);
// Total number of bytes used for this dictionary, which might be stored inline in
// another structure (e.g. MethodTable). This may include the final back-pointer
// to previous dictionaries after dictionary expansion; pSlotSize is used to return
// the size to be stored in the "size slot" of the dictionary.
static DWORD GetDictionarySizeFromLayout(DWORD numGenericArgs, PTR_DictionaryLayout pDictLayout, DWORD *pSlotSize);
static BOOL FindToken(MethodTable* pMT,
LoaderAllocator* pAllocator,
int nFirstOffset,
SigBuilder* pSigBuilder,
BYTE* pSig,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut);
static BOOL FindToken(MethodDesc* pMD,
LoaderAllocator* pAllocator,
int nFirstOffset,
SigBuilder* pSigBuilder,
BYTE* pSig,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut);
DWORD GetMaxSlots();
DWORD GetNumInitialSlots();
DWORD GetNumUsedSlots();
PTR_DictionaryEntryLayout GetEntryLayout(DWORD i)
{
LIMITED_METHOD_CONTRACT;
_ASSERTE(i >= 0 && i < GetMaxSlots());
return dac_cast<PTR_DictionaryEntryLayout>(
dac_cast<TADDR>(this) + offsetof(DictionaryLayout, m_slots) + sizeof(DictionaryEntryLayout) * i);
}
};
// The type of dictionaries. This is just an abstraction around an open-ended array
class Dictionary
{
private:
// First N entries are generic instantiations arguments.
// The rest of the open array are normal pointers (no optional indirection) and may be NULL.
DictionaryEntry m_pEntries[1];
TADDR EntryAddr(ULONG32 idx)
{
LIMITED_METHOD_CONTRACT;
SUPPORTS_DAC;
return PTR_HOST_MEMBER_TADDR(Dictionary, this, m_pEntries) +
idx * sizeof(m_pEntries[0]);
}
public:
inline DPTR(TypeHandle) GetInstantiation()
{
LIMITED_METHOD_CONTRACT;
SUPPORTS_DAC;
return dac_cast<DPTR(TypeHandle)>(EntryAddr(0));
}
#ifndef DACCESS_COMPILE
inline void* AsPtr()
{
LIMITED_METHOD_CONTRACT;
return (void*)m_pEntries;
}
#endif // #ifndef DACCESS_COMPILE
private:
#ifndef DACCESS_COMPILE
inline TypeHandle GetTypeHandleSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetTypeHandleSlotAddr(numGenericArgs, i);
}
inline MethodDesc* GetMethodDescSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetMethodDescSlotAddr(numGenericArgs, i);
}
inline FieldDesc* GetFieldDescSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetFieldDescSlotAddr(numGenericArgs, i);
}
inline TypeHandle* GetTypeHandleSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((TypeHandle*)&m_pEntries[numGenericArgs + i]);
}
inline MethodDesc** GetMethodDescSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((MethodDesc**)&m_pEntries[numGenericArgs + i]);
}
inline FieldDesc** GetFieldDescSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((FieldDesc**)&m_pEntries[numGenericArgs + i]);
}
inline DictionaryEntry* GetSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((void**)&m_pEntries[numGenericArgs + i]);
}
inline DictionaryEntry GetSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetSlotAddr(numGenericArgs, i);
}
inline BOOL IsSlotEmpty(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return GetSlot(numGenericArgs, i) == NULL;
}
inline DWORD GetDictionarySlotsSize(DWORD numGenericArgs)
{
LIMITED_METHOD_CONTRACT;
return VolatileLoadWithoutBarrier((DWORD*)GetSlotAddr(numGenericArgs, 0));
}
inline Dictionary **GetBackPointerSlot(DWORD numGenericArgs)
{
LIMITED_METHOD_CONTRACT;
return (Dictionary **)((uint8_t *)m_pEntries + GetDictionarySlotsSize(numGenericArgs));
}
#endif // #ifndef DACCESS_COMPILE
public:
#ifndef DACCESS_COMPILE
static DictionaryEntry PopulateEntry(MethodDesc * pMD,
MethodTable * pMT,
LPVOID signature,
BOOL nonExpansive,
DictionaryEntry ** ppSlot,
DWORD dictionaryIndexAndSlot = -1,
Module * pModule = NULL);
private:
static Dictionary* GetTypeDictionaryWithSizeCheck(MethodTable* pMT, ULONG slotIndex);
static Dictionary* GetMethodDictionaryWithSizeCheck(MethodDesc* pMD, ULONG slotIndex);
#endif // #ifndef DACCESS_COMPILE
};
#endif
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// File: genericdict.h
//
//
// Definitions for "dictionaries" used to encapsulate generic instantiations
// and instantiation-specific information for shared-code generics
//
//
// ============================================================================
#ifndef _GENERICDICT_H
#define _GENERICDICT_H
// DICTIONARIES
//
// A dictionary is a cache of handles associated with particular
// instantiations of generic classes and generic methods, containing
// - the instantiation itself (a list of TypeHandles)
// - handles created on demand at runtime when code shared between
// multiple instantiations needs to lookup an instantiation-specific
// handle (for example, in newobj C<!0> and castclass !!0[])
//
// DICTIONARY ENTRIES
//
// Dictionary entries (abstracted as the type DictionaryEntry) can be:
// a TypeHandle (for type arguments and entries associated with a TypeSpec token)
// a MethodDesc* (for entries associated with a method MemberRef or MethodSpec token)
// a FieldDesc* (for entries associated with a field MemberRef token)
// a code pointer (e.g. for entries associated with an EntryPointAnnotation annotated token)
// a dispatch stub address (for entries associated with an StubAddrAnnotation annotated token)
//
// DICTIONARY LAYOUTS
//
// A dictionary layout describes the layout of all dictionaries that can be
// accessed from the same shared code. For example, Hashtable<string,int> and
// Hashtable<object,int> share one layout, and Hashtable<int,string> and Hashtable<int,object>
// share another layout. For generic types, the dictionary layout is stored in the EEClass
// that is shared across compatible instantiations. For generic methods, the layout
// is stored in the InstantiatedMethodDesc associated with the shared generic code itself.
//
class TypeHandleList;
class Module;
class BaseDomain;
class SigTypeContext;
class SigBuilder;
enum DictionaryEntryKind
{
EmptySlot = 0,
TypeHandleSlot = 1,
MethodDescSlot = 2,
MethodEntrySlot = 3,
ConstrainedMethodEntrySlot = 4,
DispatchStubAddrSlot = 5,
FieldDescSlot = 6,
DeclaringTypeHandleSlot = 7,
};
enum DictionaryEntrySignatureSource : BYTE
{
FromZapImage = 0,
FromReadyToRunImage = 1,
FromJIT = 2,
};
class DictionaryEntryLayout
{
public:
DictionaryEntryLayout(PTR_VOID signature)
{ LIMITED_METHOD_CONTRACT; m_signature = signature; }
DictionaryEntryKind GetKind();
PTR_VOID m_signature;
DictionaryEntrySignatureSource m_signatureSource;
};
typedef DPTR(DictionaryEntryLayout) PTR_DictionaryEntryLayout;
class DictionaryLayout;
typedef DPTR(DictionaryLayout) PTR_DictionaryLayout;
// Number of slots to initially allocate in a generic method dictionary layout.
#if _DEBUG
#define NUM_DICTIONARY_SLOTS 1 // Smaller number to stress the dictionary expansion logic
#else
#define NUM_DICTIONARY_SLOTS 4
#endif
// The type of dictionary layouts. We don't include the number of type
// arguments as this is obtained elsewhere
class DictionaryLayout
{
friend class Dictionary;
private:
// Current number of non-type-argument slots
WORD m_numSlots;
// Number of non-type-argument slots of the initial layout before any expansion
WORD m_numInitialSlots;
// m_numSlots of these
DictionaryEntryLayout m_slots[1];
static BOOL FindTokenWorker(LoaderAllocator* pAllocator,
DWORD numGenericArgs,
DictionaryLayout* pDictLayout,
SigBuilder* pSigBuilder,
BYTE* pSig,
DWORD cbSig,
int nFirstOffset,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut,
DWORD scanFromSlot,
BOOL useEmptySlotIfFound);
static DictionaryLayout* ExpandDictionaryLayout(LoaderAllocator* pAllocator,
DictionaryLayout* pCurrentDictLayout,
DWORD numGenericArgs,
SigBuilder* pSigBuilder,
BYTE* pSig,
int nFirstOffset,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut);
static PVOID CreateSignatureWithSlotData(SigBuilder* pSigBuilder, LoaderAllocator* pAllocator, WORD slot);
public:
// Create an initial dictionary layout containing numSlots slots
static DictionaryLayout* Allocate(WORD numSlots, LoaderAllocator *pAllocator, AllocMemTracker *pamTracker);
// Total number of bytes used for this dictionary, which might be stored inline in
// another structure (e.g. MethodTable). This may include the final back-pointer
// to previous dictionaries after dictionary expansion; pSlotSize is used to return
// the size to be stored in the "size slot" of the dictionary.
static DWORD GetDictionarySizeFromLayout(DWORD numGenericArgs, PTR_DictionaryLayout pDictLayout, DWORD *pSlotSize);
static BOOL FindToken(MethodTable* pMT,
LoaderAllocator* pAllocator,
int nFirstOffset,
SigBuilder* pSigBuilder,
BYTE* pSig,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut);
static BOOL FindToken(MethodDesc* pMD,
LoaderAllocator* pAllocator,
int nFirstOffset,
SigBuilder* pSigBuilder,
BYTE* pSig,
DictionaryEntrySignatureSource signatureSource,
CORINFO_RUNTIME_LOOKUP* pResult,
WORD* pSlotOut);
DWORD GetMaxSlots();
DWORD GetNumInitialSlots();
DWORD GetNumUsedSlots();
PTR_DictionaryEntryLayout GetEntryLayout(DWORD i)
{
LIMITED_METHOD_CONTRACT;
_ASSERTE(i >= 0 && i < GetMaxSlots());
return dac_cast<PTR_DictionaryEntryLayout>(
dac_cast<TADDR>(this) + offsetof(DictionaryLayout, m_slots) + sizeof(DictionaryEntryLayout) * i);
}
};
// The type of dictionaries. This is just an abstraction around an open-ended array
class Dictionary
{
private:
// First N entries are generic instantiations arguments.
// The rest of the open array are normal pointers (no optional indirection) and may be NULL.
DictionaryEntry m_pEntries[1];
TADDR EntryAddr(ULONG32 idx)
{
LIMITED_METHOD_CONTRACT;
SUPPORTS_DAC;
return PTR_HOST_MEMBER_TADDR(Dictionary, this, m_pEntries) +
idx * sizeof(m_pEntries[0]);
}
public:
inline DPTR(TypeHandle) GetInstantiation()
{
LIMITED_METHOD_CONTRACT;
SUPPORTS_DAC;
return dac_cast<DPTR(TypeHandle)>(EntryAddr(0));
}
#ifndef DACCESS_COMPILE
inline void* AsPtr()
{
LIMITED_METHOD_CONTRACT;
return (void*)m_pEntries;
}
#endif // #ifndef DACCESS_COMPILE
private:
#ifndef DACCESS_COMPILE
inline TypeHandle GetTypeHandleSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetTypeHandleSlotAddr(numGenericArgs, i);
}
inline MethodDesc* GetMethodDescSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetMethodDescSlotAddr(numGenericArgs, i);
}
inline FieldDesc* GetFieldDescSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetFieldDescSlotAddr(numGenericArgs, i);
}
inline TypeHandle* GetTypeHandleSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((TypeHandle*)&m_pEntries[numGenericArgs + i]);
}
inline MethodDesc** GetMethodDescSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((MethodDesc**)&m_pEntries[numGenericArgs + i]);
}
inline FieldDesc** GetFieldDescSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((FieldDesc**)&m_pEntries[numGenericArgs + i]);
}
inline DictionaryEntry* GetSlotAddr(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return ((void**)&m_pEntries[numGenericArgs + i]);
}
inline DictionaryEntry GetSlot(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return *GetSlotAddr(numGenericArgs, i);
}
inline BOOL IsSlotEmpty(DWORD numGenericArgs, DWORD i)
{
LIMITED_METHOD_CONTRACT;
return GetSlot(numGenericArgs, i) == NULL;
}
inline DWORD GetDictionarySlotsSize(DWORD numGenericArgs)
{
LIMITED_METHOD_CONTRACT;
return VolatileLoadWithoutBarrier((DWORD*)GetSlotAddr(numGenericArgs, 0));
}
inline Dictionary **GetBackPointerSlot(DWORD numGenericArgs)
{
LIMITED_METHOD_CONTRACT;
return (Dictionary **)((uint8_t *)m_pEntries + GetDictionarySlotsSize(numGenericArgs));
}
#endif // #ifndef DACCESS_COMPILE
public:
#ifndef DACCESS_COMPILE
static DictionaryEntry PopulateEntry(MethodDesc * pMD,
MethodTable * pMT,
LPVOID signature,
BOOL nonExpansive,
DictionaryEntry ** ppSlot,
DWORD dictionaryIndexAndSlot = -1,
Module * pModule = NULL);
private:
static Dictionary* GetTypeDictionaryWithSizeCheck(MethodTable* pMT, ULONG slotIndex);
static Dictionary* GetMethodDictionaryWithSizeCheck(MethodDesc* pMD, ULONG slotIndex);
#endif // #ifndef DACCESS_COMPILE
};
#endif
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/JIT/IL_Conformance/Old/Conformance_Base/ldc_sub_ovf_u2.ilproj | <Project Sdk="Microsoft.NET.Sdk.IL">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="ldc_sub_ovf_u2.il" />
</ItemGroup>
</Project>
| <Project Sdk="Microsoft.NET.Sdk.IL">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="ldc_sub_ovf_u2.il" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/customattribute.cpp | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include "common.h"
#include "customattribute.h"
#include "invokeutil.h"
#include "method.hpp"
#include "threads.h"
#include "excep.h"
#include "corerror.h"
#include "classnames.h"
#include "fcall.h"
#include "assemblynative.hpp"
#include "typeparse.h"
#include "reflectioninvocation.h"
#include "runtimehandles.h"
#include "typestring.h"
typedef InlineFactory<InlineSString<64>, 16> SStringFactory;
/*static*/
TypeHandle Attribute::GetTypeForEnum(LPCUTF8 szEnumName, COUNT_T cbEnumName, DomainAssembly* pDomainAssembly)
{
CONTRACTL
{
PRECONDITION(CheckPointer(pDomainAssembly));
PRECONDITION(CheckPointer(szEnumName));
PRECONDITION(cbEnumName);
THROWS;
GC_TRIGGERS;
MODE_ANY;
}
CONTRACTL_END;
StackScratchBuffer buff;
StackSString sszEnumName(SString::Utf8, szEnumName, cbEnumName);
return TypeName::GetTypeUsingCASearchRules(sszEnumName.GetUTF8(buff), pDomainAssembly->GetAssembly());
}
/*static*/
HRESULT Attribute::ParseCaType(
CustomAttributeParser &ca,
CaType* pCaType,
DomainAssembly* pDomainAssembly,
StackSString* ss)
{
WRAPPER_NO_CONTRACT;
HRESULT hr = S_OK;
IfFailGo(::ParseEncodedType(ca, pCaType));
if (pCaType->tag == SERIALIZATION_TYPE_ENUM ||
(pCaType->tag == SERIALIZATION_TYPE_SZARRAY && pCaType->arrayType == SERIALIZATION_TYPE_ENUM ))
{
TypeHandle th = Attribute::GetTypeForEnum(pCaType->szEnumName, pCaType->cEnumName, pDomainAssembly);
if (!th.IsNull() && th.IsEnum())
{
pCaType->enumType = (CorSerializationType)th.GetVerifierCorElementType();
// The assembly qualified name of th might not equal pCaType->szEnumName.
// e.g. th could be "MyEnum, MyAssembly, Version=4.0.0.0" while
// pCaType->szEnumName is "MyEnum, MyAssembly, Version=3.0.0.0"
if (ss)
{
DWORD format = TypeString::FormatNamespace | TypeString::FormatFullInst | TypeString::FormatAssembly;
TypeString::AppendType(*ss, th, format);
}
}
else
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, pCaType->szEnumName, pCaType->cEnumName)
IfFailGo(PostError(META_E_CA_UNEXPECTED_TYPE, wcslen(pWideStr), pWideStr));
}
}
ErrExit:
return hr;
}
/*static*/
void Attribute::SetBlittableCaValue(CustomAttributeValue* pVal, CaValue* pCaVal, BOOL* pbAllBlittableCa)
{
WRAPPER_NO_CONTRACT;
CorSerializationType type = pCaVal->type.tag;
pVal->m_type.m_tag = pCaVal->type.tag;
pVal->m_type.m_arrayType = pCaVal->type.arrayType;
pVal->m_type.m_enumType = pCaVal->type.enumType;
pVal->m_rawValue = 0;
if (type == SERIALIZATION_TYPE_STRING ||
type == SERIALIZATION_TYPE_SZARRAY ||
type == SERIALIZATION_TYPE_TYPE)
{
*pbAllBlittableCa = FALSE;
}
else
{
// Enum arg -> Object param
if (type == SERIALIZATION_TYPE_ENUM && pCaVal->type.cEnumName)
*pbAllBlittableCa = FALSE;
pVal->m_rawValue = pCaVal->i8;
}
}
/*static*/
void Attribute::SetManagedValue(CustomAttributeManagedValues gc, CustomAttributeValue* pValue)
{
WRAPPER_NO_CONTRACT;
CorSerializationType type = pValue->m_type.m_tag;
if (type == SERIALIZATION_TYPE_TYPE || type == SERIALIZATION_TYPE_STRING)
{
SetObjectReference((OBJECTREF*)&pValue->m_enumOrTypeName, gc.string);
}
else if (type == SERIALIZATION_TYPE_ENUM)
{
SetObjectReference((OBJECTREF*)&pValue->m_type.m_enumName, gc.string);
}
else if (type == SERIALIZATION_TYPE_SZARRAY)
{
SetObjectReference((OBJECTREF*)&pValue->m_value, gc.array);
if (pValue->m_type.m_arrayType == SERIALIZATION_TYPE_ENUM)
SetObjectReference((OBJECTREF*)&pValue->m_type.m_enumName, gc.string);
}
}
/*static*/
CustomAttributeManagedValues Attribute::GetManagedCaValue(CaValue* pCaVal)
{
WRAPPER_NO_CONTRACT;
CustomAttributeManagedValues gc;
ZeroMemory(&gc, sizeof(gc));
GCPROTECT_BEGIN(gc)
{
CorSerializationType type = pCaVal->type.tag;
if (type == SERIALIZATION_TYPE_ENUM)
{
gc.string = StringObject::NewString(pCaVal->type.szEnumName, pCaVal->type.cEnumName);
}
else if (type == SERIALIZATION_TYPE_STRING)
{
gc.string = NULL;
if (pCaVal->str.pStr)
gc.string = StringObject::NewString(pCaVal->str.pStr, pCaVal->str.cbStr);
}
else if (type == SERIALIZATION_TYPE_TYPE)
{
gc.string = StringObject::NewString(pCaVal->str.pStr, pCaVal->str.cbStr);
}
else if (type == SERIALIZATION_TYPE_SZARRAY)
{
CorSerializationType arrayType = pCaVal->type.arrayType;
ULONG length = pCaVal->arr.length;
BOOL bAllBlittableCa = arrayType != SERIALIZATION_TYPE_ENUM;
if (arrayType == SERIALIZATION_TYPE_ENUM)
gc.string = StringObject::NewString(pCaVal->type.szEnumName, pCaVal->type.cEnumName);
if (length != (ULONG)-1)
{
gc.array = (CaValueArrayREF)AllocateSzArray(TypeHandle(CoreLibBinder::GetClass(CLASS__CUSTOM_ATTRIBUTE_ENCODED_ARGUMENT)).MakeSZArray(), length);
CustomAttributeValue* pValues = gc.array->GetDirectPointerToNonObjectElements();
for (COUNT_T i = 0; i < length; i ++)
Attribute::SetBlittableCaValue(&pValues[i], &pCaVal->arr[i], &bAllBlittableCa);
if (!bAllBlittableCa)
{
for (COUNT_T i = 0; i < length; i ++)
{
CustomAttributeManagedValues managedCaValue = Attribute::GetManagedCaValue(&pCaVal->arr[i]);
Attribute::SetManagedValue(
managedCaValue,
&gc.array->GetDirectPointerToNonObjectElements()[i]);
}
}
}
}
}
GCPROTECT_END();
return gc;
}
/*static*/
HRESULT Attribute::ParseAttributeArgumentValues(
void* pCa,
INT32 cCa,
CaValueArrayFactory* pCaValueArrayFactory,
CaArg* pCaArgs,
COUNT_T cArgs,
CaNamedArg* pCaNamedArgs,
COUNT_T cNamedArgs,
DomainAssembly* pDomainAssembly)
{
WRAPPER_NO_CONTRACT;
HRESULT hr = S_OK;
CustomAttributeParser cap(pCa, cCa);
IfFailGo(Attribute::ParseCaCtorArgs(cap, pCaArgs, cArgs, pCaValueArrayFactory, pDomainAssembly));
IfFailGo(Attribute::ParseCaNamedArgs(cap, pCaNamedArgs, cNamedArgs, pCaValueArrayFactory, pDomainAssembly));
ErrExit:
return hr;
}
//---------------------------------------------------------------------------------------
//
// Helper to parse the values for the ctor argument list and the named argument list.
//
HRESULT Attribute::ParseCaValue(
CustomAttributeParser &ca,
CaValue* pCaArg,
CaType* pCaParam,
CaValueArrayFactory* pCaValueArrayFactory,
DomainAssembly* pDomainAssembly)
{
CONTRACTL
{
PRECONDITION(CheckPointer(pCaArg));
PRECONDITION(CheckPointer(pCaParam));
PRECONDITION(CheckPointer(pCaValueArrayFactory));
THROWS;
}
CONTRACTL_END;
HRESULT hr = S_OK;
CorSerializationType underlyingType;
CaType elementType;
if (pCaParam->tag == SERIALIZATION_TYPE_TAGGED_OBJECT)
IfFailGo(Attribute::ParseCaType(ca, &pCaArg->type, pDomainAssembly));
else
pCaArg->type = *pCaParam;
underlyingType = pCaArg->type.tag == SERIALIZATION_TYPE_ENUM ? pCaArg->type.enumType : pCaArg->type.tag;
// Grab the value.
switch (underlyingType)
{
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
IfFailGo(ca.GetU1(&pCaArg->u1));
break;
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
IfFailGo(ca.GetU2(&pCaArg->u2));
break;
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
IfFailGo(ca.GetU4(&pCaArg->u4));
break;
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
IfFailGo(ca.GetU8(&pCaArg->u8));
break;
case SERIALIZATION_TYPE_R4:
IfFailGo(ca.GetR4(&pCaArg->r4));
break;
case SERIALIZATION_TYPE_R8:
IfFailGo(ca.GetR8(&pCaArg->r8));
break;
case SERIALIZATION_TYPE_STRING:
case SERIALIZATION_TYPE_TYPE:
IfFailGo(ca.GetString(&pCaArg->str.pStr, &pCaArg->str.cbStr));
break;
case SERIALIZATION_TYPE_SZARRAY:
UINT32 len;
IfFailGo(ca.GetU4(&len));
pCaArg->arr.length = len;
pCaArg->arr.pSArray = NULL;
if (pCaArg->arr.length == (ULONG)-1)
break;
IfNullGo(pCaArg->arr.pSArray = pCaValueArrayFactory->Create());
elementType.Init(pCaArg->type.arrayType, SERIALIZATION_TYPE_UNDEFINED,
pCaArg->type.enumType, pCaArg->type.szEnumName, pCaArg->type.cEnumName);
for (ULONG i = 0; i < pCaArg->arr.length; i++)
IfFailGo(Attribute::ParseCaValue(ca, &*pCaArg->arr.pSArray->Append(), &elementType, pCaValueArrayFactory, pDomainAssembly));
break;
default:
// The format of the custom attribute record is invalid.
hr = E_FAIL;
break;
} // End switch
ErrExit:
return hr;
}
/*static*/
HRESULT Attribute::ParseCaCtorArgs(
CustomAttributeParser &ca,
CaArg* pArgs,
ULONG cArgs,
CaValueArrayFactory* pCaValueArrayFactory,
DomainAssembly* pDomainAssembly)
{
WRAPPER_NO_CONTRACT;
HRESULT hr = S_OK; // A result.
ULONG ix; // Loop control.
// If there is a blob, check the prolog.
if (FAILED(ca.ValidateProlog()))
{
IfFailGo(PostError(META_E_CA_INVALID_BLOB));
}
// For each expected arg...
for (ix=0; ix<cArgs; ++ix)
{
CaArg* pArg = &pArgs[ix];
IfFailGo(Attribute::ParseCaValue(ca, &pArg->val, &pArg->type, pCaValueArrayFactory, pDomainAssembly));
}
ErrExit:
return hr;
}
//---------------------------------------------------------------------------------------
//
// Because ParseKnowCaNamedArgs MD cannot have VM dependency, we have our own implementation here:
// 1. It needs to load the assemblies that contain the enum types for the named arguments,
// 2. It Compares the enum type name with that of the loaded enum type, not the one in the CA record.
//
/*static*/
HRESULT Attribute::ParseCaNamedArgs(
CustomAttributeParser &ca,
CaNamedArg *pNamedParams,
ULONG cNamedParams,
CaValueArrayFactory* pCaValueArrayFactory,
DomainAssembly* pDomainAssembly)
{
CONTRACTL {
PRECONDITION(CheckPointer(pCaValueArrayFactory));
PRECONDITION(CheckPointer(pDomainAssembly));
THROWS;
} CONTRACTL_END;
HRESULT hr = S_OK;
ULONG ixParam;
INT32 ixArg;
INT16 cActualArgs;
CaNamedArgCtor namedArg;
CaNamedArg* pNamedParam;
// Get actual count of named arguments.
if (FAILED(ca.GetI2(&cActualArgs)))
cActualArgs = 0; // Everett behavior
for (ixParam = 0; ixParam < cNamedParams; ixParam++)
pNamedParams[ixParam].val.type.tag = SERIALIZATION_TYPE_UNDEFINED;
// For each named argument...
for (ixArg = 0; ixArg < cActualArgs; ixArg++)
{
// Field or property?
IfFailGo(ca.GetTag(&namedArg.propertyOrField));
if (namedArg.propertyOrField != SERIALIZATION_TYPE_FIELD && namedArg.propertyOrField != SERIALIZATION_TYPE_PROPERTY)
IfFailGo(PostError(META_E_CA_INVALID_ARGTYPE));
// Get argument type information
CaType* pNamedArgType = &namedArg.type;
StackSString ss;
IfFailGo(Attribute::ParseCaType(ca, pNamedArgType, pDomainAssembly, &ss));
LPCSTR szLoadedEnumName = NULL;
StackScratchBuffer buff;
if (pNamedArgType->tag == SERIALIZATION_TYPE_ENUM ||
(pNamedArgType->tag == SERIALIZATION_TYPE_SZARRAY && pNamedArgType->arrayType == SERIALIZATION_TYPE_ENUM ))
{
szLoadedEnumName = ss.GetUTF8(buff);
}
// Get name of Arg.
if (FAILED(ca.GetNonEmptyString(&namedArg.szName, &namedArg.cName)))
IfFailGo(PostError(META_E_CA_INVALID_BLOB));
// Match arg by name and type
for (ixParam = 0; ixParam < cNamedParams; ixParam++)
{
pNamedParam = &pNamedParams[ixParam];
// Match type
if (pNamedParam->type.tag != SERIALIZATION_TYPE_TAGGED_OBJECT)
{
if (namedArg.type.tag != pNamedParam->type.tag)
continue;
// Match array type
if (namedArg.type.tag == SERIALIZATION_TYPE_SZARRAY &&
pNamedParam->type.arrayType != SERIALIZATION_TYPE_TAGGED_OBJECT &&
namedArg.type.arrayType != pNamedParam->type.arrayType)
continue;
}
// Match name (and its length to avoid substring matching)
if ((pNamedParam->cName != namedArg.cName) ||
(strncmp(pNamedParam->szName, namedArg.szName, namedArg.cName) != 0))
{
continue;
}
// If enum, match enum name.
if (pNamedParam->type.tag == SERIALIZATION_TYPE_ENUM ||
(pNamedParam->type.tag == SERIALIZATION_TYPE_SZARRAY && pNamedParam->type.arrayType == SERIALIZATION_TYPE_ENUM ))
{
// pNamedParam->type.szEnumName: module->CA record->ctor token->loaded type->field/property->field/property type->field/property type name
// namedArg.type.szEnumName: module->CA record->named arg->enum type name
// szLoadedEnumName: module->CA record->named arg->enum type name->loaded enum type->loaded enum type name
// Comparing pNamedParam->type.szEnumName against namedArg.type.szEnumName could fail if we loaded a different version
// of the enum type than the one specified in the CA record. So we are comparing it against szLoadedEnumName instead.
if (strncmp(pNamedParam->type.szEnumName, szLoadedEnumName, pNamedParam->type.cEnumName) != 0)
continue;
if (namedArg.type.enumType != pNamedParam->type.enumType)
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, pNamedParam->type.szEnumName, pNamedParam->type.cEnumName)
IfFailGo(PostError(META_E_CA_UNEXPECTED_TYPE, wcslen(pWideStr), pWideStr));
}
// TODO: For now assume the property\field array size is correct - later we should verify this
}
// Found a match.
break;
}
// Better have found an argument.
if (ixParam == cNamedParams)
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, namedArg.szName, namedArg.cName)
IfFailGo(PostError(META_E_CA_UNKNOWN_ARGUMENT, wcslen(pWideStr), pWideStr));
}
// Argument had better not have been seen already.
if (pNamedParams[ixParam].val.type.tag != SERIALIZATION_TYPE_UNDEFINED)
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, namedArg.szName, namedArg.cName)
IfFailGo(PostError(META_E_CA_REPEATED_ARG, wcslen(pWideStr), pWideStr));
}
IfFailGo(Attribute::ParseCaValue(ca, &pNamedParams[ixParam].val, &namedArg.type, pCaValueArrayFactory, pDomainAssembly));
}
ErrExit:
return hr;
}
/*static*/
HRESULT Attribute::InitCaType(CustomAttributeType* pType, Factory<SString>* pSstringFactory, Factory<StackScratchBuffer>* pStackScratchBufferFactory, CaType* pCaType)
{
CONTRACTL {
THROWS;
PRECONDITION(CheckPointer(pType));
PRECONDITION(CheckPointer(pSstringFactory));
PRECONDITION(CheckPointer(pStackScratchBufferFactory));
PRECONDITION(CheckPointer(pCaType));
} CONTRACTL_END;
HRESULT hr = S_OK;
SString* psszName = NULL;
StackScratchBuffer* scratchBuffer = NULL;
IfNullGo(psszName = pSstringFactory->Create());
IfNullGo(scratchBuffer = pStackScratchBufferFactory->Create());
psszName->Set(pType->m_enumName == NULL ? NULL : pType->m_enumName->GetBuffer());
pCaType->Init(
pType->m_tag,
pType->m_arrayType,
pType->m_enumType,
psszName->GetUTF8(*scratchBuffer),
(ULONG)psszName->GetCount());
ErrExit:
return hr;
}
FCIMPL5(VOID, Attribute::ParseAttributeArguments, void* pCa, INT32 cCa,
CaArgArrayREF* ppCustomAttributeArguments,
CaNamedArgArrayREF* ppCustomAttributeNamedArguments,
AssemblyBaseObject* pAssemblyUNSAFE)
{
FCALL_CONTRACT;
ASSEMBLYREF refAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pAssemblyUNSAFE);
HELPER_METHOD_FRAME_BEGIN_1(refAssembly)
{
DomainAssembly *pDomainAssembly = refAssembly->GetDomainAssembly();
struct
{
CustomAttributeArgument* pArgs;
CustomAttributeNamedArgument* pNamedArgs;
} gc;
gc.pArgs = NULL;
gc.pNamedArgs = NULL;
HRESULT hr = S_OK;
GCPROTECT_BEGININTERIOR(gc);
BOOL bAllBlittableCa = TRUE;
COUNT_T cArgs = 0;
COUNT_T cNamedArgs = 0;
CaArg* pCaArgs = NULL;
CaNamedArg* pCaNamedArgs = NULL;
#ifdef __GNUC__
// When compiling under GCC we have to use the -fstack-check option to ensure we always spot stack
// overflow. But this option is intolerant of locals growing too large, so we have to cut back a bit
// on what we can allocate inline here. Leave the Windows versions alone to retain the perf benefits
// since we don't have the same constraints.
NewHolder<CaValueArrayFactory> pCaValueArrayFactory = new InlineFactory<SArray<CaValue>, 4>();
InlineFactory<StackScratchBuffer, 4> stackScratchBufferFactory;
InlineFactory<SString, 4> sstringFactory;
#else // __GNUC__
// Preallocate 4 elements in each of the following factories for optimal performance.
// 4 is enough for 4 typed args or 2 named args which are enough for 99% of the cases.
// SArray<CaValue> is only needed if a argument is an array, don't preallocate any memory as arrays are rare.
// Need one per (ctor or named) arg + one per array element
InlineFactory<SArray<CaValue>, 4> caValueArrayFactory;
InlineFactory<SArray<CaValue>, 4> *pCaValueArrayFactory = &caValueArrayFactory;
// Need one StackScratchBuffer per ctor arg and two per named arg
InlineFactory<StackScratchBuffer, 4> stackScratchBufferFactory;
// Need one SString per ctor arg and two per named arg
InlineFactory<SString, 4> sstringFactory;
#endif // __GNUC__
cArgs = (*ppCustomAttributeArguments)->GetNumComponents();
if (cArgs)
{
gc.pArgs = (*ppCustomAttributeArguments)->GetDirectPointerToNonObjectElements();
size_t size = sizeof(CaArg) * cArgs;
if ((size / sizeof(CaArg)) != cArgs) // uint over/underflow
IfFailGo(E_INVALIDARG);
pCaArgs = (CaArg*)_alloca(size);
for (COUNT_T i = 0; i < cArgs; i ++)
{
CaType caType;
IfFailGo(Attribute::InitCaType(&gc.pArgs[i].m_type, &sstringFactory, &stackScratchBufferFactory, &caType));
pCaArgs[i].Init(caType);
}
}
cNamedArgs = (*ppCustomAttributeNamedArguments)->GetNumComponents();
if (cNamedArgs)
{
gc.pNamedArgs = (*ppCustomAttributeNamedArguments)->GetDirectPointerToNonObjectElements();
size_t size = sizeof(CaNamedArg) * cNamedArgs;
if ((size / sizeof(CaNamedArg)) != cNamedArgs) // uint over/underflow
IfFailGo(E_INVALIDARG);
pCaNamedArgs = (CaNamedArg*)_alloca(size);
for (COUNT_T i = 0; i < cNamedArgs; i ++)
{
CustomAttributeNamedArgument* pNamedArg = &gc.pNamedArgs[i];
CaType caType;
IfFailGo(Attribute::InitCaType(&pNamedArg->m_type, &sstringFactory, &stackScratchBufferFactory, &caType));
SString* psszName = NULL;
IfNullGo(psszName = sstringFactory.Create());
psszName->Set(pNamedArg->m_argumentName->GetBuffer());
StackScratchBuffer* scratchBuffer = NULL;
IfNullGo(scratchBuffer = stackScratchBufferFactory.Create());
pCaNamedArgs[i].Init(
psszName->GetUTF8(*scratchBuffer),
pNamedArg->m_propertyOrField,
caType);
}
}
// This call maps the named parameters (fields and arguments) and ctor parameters with the arguments in the CA record
// and retrieve their values.
IfFailGo(Attribute::ParseAttributeArgumentValues(pCa, cCa, pCaValueArrayFactory, pCaArgs, cArgs, pCaNamedArgs, cNamedArgs, pDomainAssembly));
for (COUNT_T i = 0; i < cArgs; i ++)
Attribute::SetBlittableCaValue(&gc.pArgs[i].m_value, &pCaArgs[i].val, &bAllBlittableCa);
for (COUNT_T i = 0; i < cNamedArgs; i ++)
Attribute::SetBlittableCaValue(&gc.pNamedArgs[i].m_value, &pCaNamedArgs[i].val, &bAllBlittableCa);
if (!bAllBlittableCa)
{
for (COUNT_T i = 0; i < cArgs; i ++)
{
CustomAttributeManagedValues managedCaValue = Attribute::GetManagedCaValue(&pCaArgs[i].val);
Attribute::SetManagedValue(managedCaValue, &(gc.pArgs[i].m_value));
}
for (COUNT_T i = 0; i < cNamedArgs; i++)
{
CustomAttributeManagedValues managedCaValue = Attribute::GetManagedCaValue(&pCaNamedArgs[i].val);
Attribute::SetManagedValue(managedCaValue, &(gc.pNamedArgs[i].m_value));
}
}
ErrExit:
; // Need empty statement to get GCPROTECT_END below to work.
GCPROTECT_END();
if (hr != S_OK)
{
if ((hr == E_OUTOFMEMORY) || (hr == NTE_NO_MEMORY))
{
COMPlusThrow(kOutOfMemoryException);
}
else
{
COMPlusThrow(kCustomAttributeFormatException);
}
}
}
HELPER_METHOD_FRAME_END();
}
FCIMPLEND
FCIMPL6(LPVOID, COMCustomAttribute::CreateCaObject, ReflectModuleBaseObject* pAttributedModuleUNSAFE, ReflectClassBaseObject* pCaTypeUNSAFE, ReflectMethodObject *pMethodUNSAFE, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs)
{
FCALL_CONTRACT;
struct
{
REFLECTCLASSBASEREF refCaType;
OBJECTREF ca;
REFLECTMETHODREF refCtor;
REFLECTMODULEBASEREF refAttributedModule;
} gc;
gc.refCaType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pCaTypeUNSAFE);
TypeHandle th = gc.refCaType->GetType();
gc.ca = NULL;
gc.refCtor = (REFLECTMETHODREF)ObjectToOBJECTREF(pMethodUNSAFE);
gc.refAttributedModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(pAttributedModuleUNSAFE);
if(gc.refAttributedModule == NULL)
FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
MethodDesc* pCtorMD = gc.refCtor->GetMethod();
HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
{
MethodDescCallSite ctorCallSite(pCtorMD, th);
MetaSig* pSig = ctorCallSite.GetMetaSig();
BYTE* pBlob = *ppBlob;
// get the number of arguments and allocate an array for the args
ARG_SLOT *args = NULL;
UINT cArgs = pSig->NumFixedArgs() + 1; // make room for the this pointer
UINT i = 1; // used to flag that we actually get the right number of arg from the blob
args = (ARG_SLOT*)_alloca(cArgs * sizeof(ARG_SLOT));
memset((void*)args, 0, cArgs * sizeof(ARG_SLOT));
OBJECTREF *argToProtect = (OBJECTREF*)_alloca(cArgs * sizeof(OBJECTREF));
memset((void*)argToProtect, 0, cArgs * sizeof(OBJECTREF));
// load the this pointer
argToProtect[0] = gc.refCaType->GetType().GetMethodTable()->Allocate(); // this is the value to return after the ctor invocation
if (pBlob)
{
if (pBlob < pEndBlob)
{
if (pBlob + 2 > pEndBlob)
{
COMPlusThrow(kCustomAttributeFormatException);
}
INT16 prolog = GET_UNALIGNED_VAL16(pBlob);
if (prolog != 1)
COMPlusThrow(kCustomAttributeFormatException);
pBlob += 2;
}
if (cArgs > 1)
{
GCPROTECT_ARRAY_BEGIN(*argToProtect, cArgs);
{
// loop through the args
for (i = 1; i < cArgs; i++) {
CorElementType type = pSig->NextArg();
if (type == ELEMENT_TYPE_END)
break;
BOOL bObjectCreated = FALSE;
TypeHandle th = pSig->GetLastTypeHandleThrowing();
if (th.IsArray())
// get the array element
th = th.GetArrayElementTypeHandle();
ARG_SLOT data = GetDataFromBlob(pCtorMD->GetAssembly(), (CorSerializationType)type, th, &pBlob, pEndBlob, gc.refAttributedModule->GetModule(), &bObjectCreated);
if (bObjectCreated)
argToProtect[i] = ArgSlotToObj(data);
else
args[i] = data;
}
}
GCPROTECT_END();
// We have borrowed the signature from MethodDescCallSite. We have to put it back into the initial position
// because of that's where MethodDescCallSite expects to find it below.
pSig->Reset();
for (i = 1; i < cArgs; i++)
{
if (argToProtect[i] != NULL)
{
_ASSERTE(args[i] == NULL);
args[i] = ObjToArgSlot(argToProtect[i]);
}
}
}
}
args[0] = ObjToArgSlot(argToProtect[0]);
if (i != cArgs)
COMPlusThrow(kCustomAttributeFormatException);
// check if there are any named properties to invoke,
// if so set the by ref int passed in to point
// to the blob position where name properties start
*pcNamedArgs = 0;
if (pBlob && pBlob != pEndBlob)
{
if (pBlob + 2 > pEndBlob)
COMPlusThrow(kCustomAttributeFormatException);
*pcNamedArgs = GET_UNALIGNED_VAL16(pBlob);
pBlob += 2;
}
*ppBlob = pBlob;
if (*pcNamedArgs == 0 && pBlob != pEndBlob)
COMPlusThrow(kCustomAttributeFormatException);
// make the invocation to the ctor
gc.ca = ArgSlotToObj(args[0]);
if (pCtorMD->GetMethodTable()->IsValueType())
args[0] = PtrToArgSlot(OBJECTREFToObject(gc.ca)->UnBox());
ctorCallSite.CallWithValueTypes(args);
}
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(gc.ca);
}
FCIMPLEND
FCIMPL5(VOID, COMCustomAttribute::ParseAttributeUsageAttribute, PVOID pData, ULONG cData, ULONG* pTargets, CLR_BOOL* pInherited, CLR_BOOL* pAllowMultiple)
{
FCALL_CONTRACT;
int inherited = 0;
int allowMultiple = 1;
{
CustomAttributeParser ca(pData, cData);
CaArg args[1];
args[0].InitEnum(SERIALIZATION_TYPE_I4, 0);
if (FAILED(::ParseKnownCaArgs(ca, args, ARRAY_SIZE(args))))
{
HELPER_METHOD_FRAME_BEGIN_0();
COMPlusThrow(kCustomAttributeFormatException);
HELPER_METHOD_FRAME_END();
}
*pTargets = args[0].val.u4;
CaNamedArg namedArgs[2];
CaType namedArgTypes[2];
namedArgTypes[inherited].Init(SERIALIZATION_TYPE_BOOLEAN);
namedArgTypes[allowMultiple].Init(SERIALIZATION_TYPE_BOOLEAN);
namedArgs[inherited].Init("Inherited", SERIALIZATION_TYPE_PROPERTY, namedArgTypes[inherited], TRUE);
namedArgs[allowMultiple].Init("AllowMultiple", SERIALIZATION_TYPE_PROPERTY, namedArgTypes[allowMultiple], FALSE);
if (FAILED(::ParseKnownCaNamedArgs(ca, namedArgs, ARRAY_SIZE(namedArgs))))
{
HELPER_METHOD_FRAME_BEGIN_0();
COMPlusThrow(kCustomAttributeFormatException);
HELPER_METHOD_FRAME_END();
}
*pInherited = namedArgs[inherited].val.boolean == TRUE;
*pAllowMultiple = namedArgs[allowMultiple].val.boolean == TRUE;
}
}
FCIMPLEND
FCIMPL7(void, COMCustomAttribute::GetPropertyOrFieldData, ReflectModuleBaseObject *pModuleUNSAFE, BYTE** ppBlobStart, BYTE* pBlobEnd, STRINGREF* pName, CLR_BOOL* pbIsProperty, OBJECTREF* pType, OBJECTREF* value)
{
FCALL_CONTRACT;
BYTE* pBlob = *ppBlobStart;
*pType = NULL;
REFLECTMODULEBASEREF refModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(pModuleUNSAFE);
if(refModule == NULL)
FCThrowResVoid(kArgumentNullException, W("Arg_InvalidHandle"));
Module *pModule = refModule->GetModule();
HELPER_METHOD_FRAME_BEGIN_1(refModule);
{
Assembly *pCtorAssembly = NULL;
MethodTable *pMTValue = NULL;
CorSerializationType arrayType = SERIALIZATION_TYPE_BOOLEAN;
BOOL bObjectCreated = FALSE;
TypeHandle nullTH;
if (pBlob + 2 > pBlobEnd)
COMPlusThrow(kCustomAttributeFormatException);
// get whether it is a field or a property
CorSerializationType propOrField = (CorSerializationType)*pBlob;
pBlob++;
if (propOrField == SERIALIZATION_TYPE_FIELD)
*pbIsProperty = FALSE;
else if (propOrField == SERIALIZATION_TYPE_PROPERTY)
*pbIsProperty = TRUE;
else
COMPlusThrow(kCustomAttributeFormatException);
// get the type of the field
CorSerializationType fieldType = (CorSerializationType)*pBlob;
pBlob++;
if (fieldType == SERIALIZATION_TYPE_SZARRAY)
{
arrayType = (CorSerializationType)*pBlob;
if (pBlob + 1 > pBlobEnd)
COMPlusThrow(kCustomAttributeFormatException);
pBlob++;
}
if (fieldType == SERIALIZATION_TYPE_ENUM || arrayType == SERIALIZATION_TYPE_ENUM)
{
// get the enum type
ReflectClassBaseObject *pEnum =
(ReflectClassBaseObject*)OBJECTREFToObject(ArgSlotToObj(GetDataFromBlob(
pCtorAssembly, SERIALIZATION_TYPE_TYPE, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated)));
if (pEnum == NULL)
COMPlusThrow(kCustomAttributeFormatException);
_ASSERTE(bObjectCreated);
TypeHandle th = pEnum->GetType();
_ASSERTE(th.IsEnum());
pMTValue = th.AsMethodTable();
if (fieldType == SERIALIZATION_TYPE_ENUM)
// load the enum type to pass it back
*pType = th.GetManagedClassObject();
else
nullTH = th;
}
// get the string representing the field/property name
*pName = ArgSlotToString(GetDataFromBlob(
pCtorAssembly, SERIALIZATION_TYPE_STRING, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated));
_ASSERTE(bObjectCreated || *pName == NULL);
// create the object and return it
switch (fieldType)
{
case SERIALIZATION_TYPE_TAGGED_OBJECT:
*pType = g_pObjectClass->GetManagedClassObject();
FALLTHROUGH;
case SERIALIZATION_TYPE_TYPE:
case SERIALIZATION_TYPE_STRING:
*value = ArgSlotToObj(GetDataFromBlob(
pCtorAssembly, fieldType, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated));
_ASSERTE(bObjectCreated || *value == NULL);
if (*value == NULL)
{
// load the proper type so that code in managed knows which property to load
if (fieldType == SERIALIZATION_TYPE_STRING)
*pType = CoreLibBinder::GetElementType(ELEMENT_TYPE_STRING)->GetManagedClassObject();
else if (fieldType == SERIALIZATION_TYPE_TYPE)
*pType = CoreLibBinder::GetClass(CLASS__TYPE)->GetManagedClassObject();
}
break;
case SERIALIZATION_TYPE_SZARRAY:
{
*value = NULL;
int arraySize = (int)GetDataFromBlob(pCtorAssembly, SERIALIZATION_TYPE_I4, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated);
if (arraySize != -1)
{
_ASSERTE(!bObjectCreated);
if (arrayType == SERIALIZATION_TYPE_STRING)
nullTH = TypeHandle(CoreLibBinder::GetElementType(ELEMENT_TYPE_STRING));
else if (arrayType == SERIALIZATION_TYPE_TYPE)
nullTH = TypeHandle(CoreLibBinder::GetClass(CLASS__TYPE));
else if (arrayType == SERIALIZATION_TYPE_TAGGED_OBJECT)
nullTH = TypeHandle(g_pObjectClass);
ReadArray(pCtorAssembly, arrayType, arraySize, nullTH, &pBlob, pBlobEnd, pModule, (BASEARRAYREF*)value);
}
if (*value == NULL)
{
TypeHandle arrayTH;
switch (arrayType)
{
case SERIALIZATION_TYPE_STRING:
arrayTH = TypeHandle(CoreLibBinder::GetElementType(ELEMENT_TYPE_STRING));
break;
case SERIALIZATION_TYPE_TYPE:
arrayTH = TypeHandle(CoreLibBinder::GetClass(CLASS__TYPE));
break;
case SERIALIZATION_TYPE_TAGGED_OBJECT:
arrayTH = TypeHandle(g_pObjectClass);
break;
default:
if (SERIALIZATION_TYPE_BOOLEAN <= arrayType && arrayType <= SERIALIZATION_TYPE_R8)
arrayTH = TypeHandle(CoreLibBinder::GetElementType((CorElementType)arrayType));
}
if (!arrayTH.IsNull())
{
arrayTH = ClassLoader::LoadArrayTypeThrowing(arrayTH);
*pType = arrayTH.GetManagedClassObject();
}
}
break;
}
default:
if (SERIALIZATION_TYPE_BOOLEAN <= fieldType && fieldType <= SERIALIZATION_TYPE_R8)
pMTValue = CoreLibBinder::GetElementType((CorElementType)fieldType);
else if(fieldType == SERIALIZATION_TYPE_ENUM)
fieldType = (CorSerializationType)pMTValue->GetInternalCorElementType();
else
COMPlusThrow(kCustomAttributeFormatException);
ARG_SLOT val = GetDataFromBlob(pCtorAssembly, fieldType, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated);
_ASSERTE(!bObjectCreated);
*value = pMTValue->Box((void*)ArgSlotEndianessFixup(&val, pMTValue->GetNumInstanceFieldBytes()));
}
*ppBlobStart = pBlob;
}
HELPER_METHOD_FRAME_END();
}
FCIMPLEND
/*static*/
TypeHandle COMCustomAttribute::GetTypeHandleFromBlob(Assembly *pCtorAssembly,
CorSerializationType objType,
BYTE **pBlob,
const BYTE *endBlob,
Module *pModule)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
// we must box which means we must get the method table, switch again on the element type
MethodTable *pMTType = NULL;
TypeHandle nullTH;
TypeHandle RtnTypeHnd;
switch ((DWORD)objType) {
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
case SERIALIZATION_TYPE_R4:
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
case SERIALIZATION_TYPE_R8:
case SERIALIZATION_TYPE_STRING:
pMTType = CoreLibBinder::GetElementType((CorElementType)objType);
RtnTypeHnd = TypeHandle(pMTType);
break;
case ELEMENT_TYPE_CLASS:
pMTType = CoreLibBinder::GetClass(CLASS__TYPE);
RtnTypeHnd = TypeHandle(pMTType);
break;
case SERIALIZATION_TYPE_TAGGED_OBJECT:
pMTType = g_pObjectClass;
RtnTypeHnd = TypeHandle(pMTType);
break;
case SERIALIZATION_TYPE_TYPE:
{
int size = GetStringSize(pBlob, endBlob);
if (size == -1)
return nullTH;
if ((size+1 <= 1) || (size > endBlob - *pBlob))
COMPlusThrow(kCustomAttributeFormatException);
LPUTF8 szName = (LPUTF8)_alloca(size + 1);
memcpy(szName, *pBlob, size);
*pBlob += size;
szName[size] = 0;
RtnTypeHnd = TypeName::GetTypeUsingCASearchRules(szName, pModule->GetAssembly(), NULL, FALSE);
break;
}
case SERIALIZATION_TYPE_ENUM:
{
// get the enum type
BOOL isObject = FALSE;
ReflectClassBaseObject *pType = (ReflectClassBaseObject*)OBJECTREFToObject(ArgSlotToObj(GetDataFromBlob(pCtorAssembly,
SERIALIZATION_TYPE_TYPE,
nullTH,
pBlob,
endBlob,
pModule,
&isObject)));
if (pType != NULL)
{
_ASSERTE(isObject);
RtnTypeHnd = pType->GetType();
_ASSERTE((objType == SERIALIZATION_TYPE_ENUM) ? RtnTypeHnd.GetMethodTable()->IsEnum() : TRUE);
}
else
{
RtnTypeHnd = TypeHandle();
}
break;
}
default:
COMPlusThrow(kCustomAttributeFormatException);
}
return RtnTypeHnd;
}
// retrieve the string size in a CA blob. Advance the blob pointer to point to
// the beginning of the string immediately following the size
/*static*/
int COMCustomAttribute::GetStringSize(BYTE **pBlob, const BYTE *endBlob)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
if (*pBlob >= endBlob )
{ // No buffer at all, or buffer overrun
COMPlusThrow(kCustomAttributeFormatException);
}
if (**pBlob == 0xFF)
{ // Special case null string.
++(*pBlob);
return -1;
}
ULONG ulSize;
if (FAILED(CPackedLen::SafeGetData((BYTE const *)*pBlob, (BYTE const *)endBlob, (ULONG *)&ulSize, (BYTE const **)pBlob)))
{
COMPlusThrow(kCustomAttributeFormatException);
}
return (int)ulSize;
}
// copy the values of an array of integers from a CA blob
// (i.e., always stored in little-endian, and needs not be aligned).
// Returns TRUE on success, FALSE if the blob was not big enough.
// Advances *pBlob by the amount copied.
/*static*/
template < typename T >
BOOL COMCustomAttribute::CopyArrayVAL(BASEARRAYREF pArray, int nElements, BYTE **pBlob, const BYTE *endBlob)
{
int sizeData; // = size * 2; with integer overflow check
if (!ClrSafeInt<int>::multiply(nElements, sizeof(T), sizeData))
return FALSE;
if (*pBlob + sizeData < *pBlob) // integer overflow check
return FALSE;
if (*pBlob + sizeData > endBlob)
return FALSE;
#if BIGENDIAN
T *ptDest = reinterpret_cast<T *>(pArray->GetDataPtr());
for (int iElement = 0; iElement < nElements; iElement++)
{
T tValue;
BYTE *pbSrc = *pBlob + iElement * sizeof(T);
BYTE *pbDest = reinterpret_cast<BYTE *>(&tValue);
for (size_t iByte = 0; iByte < sizeof(T); iByte++)
{
pbDest[sizeof(T) - 1 - iByte] = pbSrc[iByte];
}
ptDest[iElement] = tValue;
}
#else // BIGENDIAN
memcpyNoGCRefs(pArray->GetDataPtr(), *pBlob, sizeData);
#endif // BIGENDIAN
*pBlob += sizeData;
return TRUE;
}
// read the whole array as a chunk
/*static*/
void COMCustomAttribute::ReadArray(Assembly *pCtorAssembly,
CorSerializationType arrayType,
int size,
TypeHandle th,
BYTE **pBlob,
const BYTE *endBlob,
Module *pModule,
BASEARRAYREF *pArray)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
ARG_SLOT element = 0;
switch ((DWORD)arrayType) {
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<BYTE>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
{
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<UINT16>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
}
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
case SERIALIZATION_TYPE_R4:
{
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<UINT32>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
}
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
case SERIALIZATION_TYPE_R8:
{
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<UINT64>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
}
case ELEMENT_TYPE_CLASS:
case SERIALIZATION_TYPE_TYPE:
case SERIALIZATION_TYPE_STRING:
case SERIALIZATION_TYPE_SZARRAY:
case SERIALIZATION_TYPE_TAGGED_OBJECT:
{
BOOL isObject;
// If we haven't figured out the type of the array, throw bad blob exception
if (th.IsNull())
goto badBlob;
*pArray = (BASEARRAYREF)AllocateObjectArray(size, th);
if (arrayType == SERIALIZATION_TYPE_SZARRAY)
// switch the th to be the proper one
th = th.GetArrayElementTypeHandle();
for (int i = 0; i < size; i++) {
element = GetDataFromBlob(pCtorAssembly, arrayType, th, pBlob, endBlob, pModule, &isObject);
_ASSERTE(isObject || element == NULL);
((PTRARRAYREF)(*pArray))->SetAt(i, ArgSlotToObj(element));
}
break;
}
case SERIALIZATION_TYPE_ENUM:
{
INT32 bounds = size;
// If we haven't figured out the type of the array, throw bad blob exception
if (th.IsNull())
goto badBlob;
unsigned elementSize = th.GetSize();
TypeHandle arrayHandle = ClassLoader::LoadArrayTypeThrowing(th);
if (arrayHandle.IsNull())
goto badBlob;
*pArray = (BASEARRAYREF)AllocateSzArray(arrayHandle, bounds);
BOOL fSuccess;
switch (elementSize)
{
case 1:
fSuccess = CopyArrayVAL<BYTE>(*pArray, size, pBlob, endBlob);
break;
case 2:
fSuccess = CopyArrayVAL<UINT16>(*pArray, size, pBlob, endBlob);
break;
case 4:
fSuccess = CopyArrayVAL<UINT32>(*pArray, size, pBlob, endBlob);
break;
case 8:
fSuccess = CopyArrayVAL<UINT64>(*pArray, size, pBlob, endBlob);
break;
default:
fSuccess = FALSE;
}
if (!fSuccess)
goto badBlob;
break;
}
default:
badBlob:
COMPlusThrow(kCustomAttributeFormatException);
}
}
// get data out of the blob according to a CorElementType
/*static*/
ARG_SLOT COMCustomAttribute::GetDataFromBlob(Assembly *pCtorAssembly,
CorSerializationType type,
TypeHandle th,
BYTE **pBlob,
const BYTE *endBlob,
Module *pModule,
BOOL *bObjectCreated)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
ARG_SLOT retValue = 0;
*bObjectCreated = FALSE;
TypeHandle nullTH;
TypeHandle typeHnd;
switch ((DWORD)type) {
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
if (*pBlob + 1 <= endBlob) {
retValue = (ARG_SLOT)**pBlob;
*pBlob += 1;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
if (*pBlob + 2 <= endBlob) {
retValue = (ARG_SLOT)GET_UNALIGNED_VAL16(*pBlob);
*pBlob += 2;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
case SERIALIZATION_TYPE_R4:
if (*pBlob + 4 <= endBlob) {
retValue = (ARG_SLOT)GET_UNALIGNED_VAL32(*pBlob);
*pBlob += 4;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
case SERIALIZATION_TYPE_R8:
if (*pBlob + 8 <= endBlob) {
retValue = (ARG_SLOT)GET_UNALIGNED_VAL64(*pBlob);
*pBlob += 8;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_STRING:
stringType:
{
int size = GetStringSize(pBlob, endBlob);
*bObjectCreated = TRUE;
if (size > 0) {
if (*pBlob + size < *pBlob) // integer overflow check
goto badBlob;
if (*pBlob + size > endBlob)
goto badBlob;
retValue = ObjToArgSlot(StringObject::NewString((LPCUTF8)*pBlob, size));
*pBlob += size;
}
else if (size == 0)
retValue = ObjToArgSlot(StringObject::NewString(0));
else
*bObjectCreated = FALSE;
break;
}
// this is coming back from sig but it's not a serialization type,
// essentialy the type in the blob and the type in the sig don't match
case ELEMENT_TYPE_VALUETYPE:
{
if (!th.IsEnum())
goto badBlob;
CorSerializationType enumType = (CorSerializationType)th.GetInternalCorElementType();
BOOL cannotBeObject = FALSE;
retValue = GetDataFromBlob(pCtorAssembly, enumType, nullTH, pBlob, endBlob, pModule, &cannotBeObject);
_ASSERTE(!cannotBeObject);
break;
}
// this is coming back from sig but it's not a serialization type,
// essentialy the type in the blob and the type in the sig don't match
case ELEMENT_TYPE_CLASS:
if (th.IsArray())
goto typeArray;
else {
MethodTable *pMT = th.AsMethodTable();
if (pMT == g_pStringClass)
goto stringType;
else if (pMT == g_pObjectClass)
goto typeObject;
else if (CoreLibBinder::IsClass(pMT, CLASS__TYPE))
goto typeType;
}
goto badBlob;
case SERIALIZATION_TYPE_TYPE:
typeType:
{
typeHnd = GetTypeHandleFromBlob(pCtorAssembly, SERIALIZATION_TYPE_TYPE, pBlob, endBlob, pModule);
if (!typeHnd.IsNull())
retValue = ObjToArgSlot(typeHnd.GetManagedClassObject());
*bObjectCreated = TRUE;
break;
}
// this is coming back from sig but it's not a serialization type,
// essentialy the type in the blob and the type in the sig don't match
case ELEMENT_TYPE_OBJECT:
case SERIALIZATION_TYPE_TAGGED_OBJECT:
typeObject:
{
// get the byte representing the real type and call GetDataFromBlob again
if (*pBlob + 1 > endBlob)
goto badBlob;
CorSerializationType objType = (CorSerializationType)**pBlob;
*pBlob += 1;
switch (objType) {
case SERIALIZATION_TYPE_SZARRAY:
{
if (*pBlob + 1 > endBlob)
goto badBlob;
CorSerializationType arrayType = (CorSerializationType)**pBlob;
*pBlob += 1;
if (arrayType == SERIALIZATION_TYPE_TYPE)
arrayType = (CorSerializationType)ELEMENT_TYPE_CLASS;
// grab the array type and make a type handle for it
nullTH = GetTypeHandleFromBlob(pCtorAssembly, arrayType, pBlob, endBlob, pModule);
FALLTHROUGH;
}
case SERIALIZATION_TYPE_TYPE:
case SERIALIZATION_TYPE_STRING:
// notice that the nullTH is actually not null in the array case (see case above)
retValue = GetDataFromBlob(pCtorAssembly, objType, nullTH, pBlob, endBlob, pModule, bObjectCreated);
_ASSERTE(*bObjectCreated || retValue == 0);
break;
case SERIALIZATION_TYPE_ENUM:
{
//
// get the enum type
typeHnd = GetTypeHandleFromBlob(pCtorAssembly, SERIALIZATION_TYPE_ENUM, pBlob, endBlob, pModule);
_ASSERTE(typeHnd.IsTypeDesc() == false);
// ok we have the class, now we go and read the data
MethodTable *pMT = typeHnd.AsMethodTable();
PREFIX_ASSUME(pMT != NULL);
CorSerializationType objNormType = (CorSerializationType)pMT->GetInternalCorElementType();
BOOL isObject = FALSE;
retValue = GetDataFromBlob(pCtorAssembly, objNormType, nullTH, pBlob, endBlob, pModule, &isObject);
_ASSERTE(!isObject);
retValue= ObjToArgSlot(pMT->Box((void*)&retValue));
*bObjectCreated = TRUE;
break;
}
default:
{
// the common primitive type case. We need to box the primitive
typeHnd = GetTypeHandleFromBlob(pCtorAssembly, objType, pBlob, endBlob, pModule);
_ASSERTE(typeHnd.IsTypeDesc() == false);
retValue = GetDataFromBlob(pCtorAssembly, objType, nullTH, pBlob, endBlob, pModule, bObjectCreated);
_ASSERTE(!*bObjectCreated);
retValue= ObjToArgSlot(typeHnd.AsMethodTable()->Box((void*)&retValue));
*bObjectCreated = TRUE;
break;
}
}
break;
}
case SERIALIZATION_TYPE_SZARRAY:
typeArray:
{
// read size
BOOL isObject = FALSE;
int size = (int)GetDataFromBlob(pCtorAssembly, SERIALIZATION_TYPE_I4, nullTH, pBlob, endBlob, pModule, &isObject);
_ASSERTE(!isObject);
if (size != -1) {
CorSerializationType arrayType;
if (th.IsEnum())
arrayType = SERIALIZATION_TYPE_ENUM;
else
arrayType = (CorSerializationType)th.GetInternalCorElementType();
BASEARRAYREF array = NULL;
GCPROTECT_BEGIN(array);
ReadArray(pCtorAssembly, arrayType, size, th, pBlob, endBlob, pModule, &array);
retValue = ObjToArgSlot(array);
GCPROTECT_END();
}
*bObjectCreated = TRUE;
break;
}
default:
badBlob:
//<TODO> generate a reasonable text string ("invalid blob or constructor")</TODO>
COMPlusThrow(kCustomAttributeFormatException);
}
return retValue;
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#include "common.h"
#include "customattribute.h"
#include "invokeutil.h"
#include "method.hpp"
#include "threads.h"
#include "excep.h"
#include "corerror.h"
#include "classnames.h"
#include "fcall.h"
#include "assemblynative.hpp"
#include "typeparse.h"
#include "reflectioninvocation.h"
#include "runtimehandles.h"
#include "typestring.h"
typedef InlineFactory<InlineSString<64>, 16> SStringFactory;
/*static*/
TypeHandle Attribute::GetTypeForEnum(LPCUTF8 szEnumName, COUNT_T cbEnumName, DomainAssembly* pDomainAssembly)
{
CONTRACTL
{
PRECONDITION(CheckPointer(pDomainAssembly));
PRECONDITION(CheckPointer(szEnumName));
PRECONDITION(cbEnumName);
THROWS;
GC_TRIGGERS;
MODE_ANY;
}
CONTRACTL_END;
StackScratchBuffer buff;
StackSString sszEnumName(SString::Utf8, szEnumName, cbEnumName);
return TypeName::GetTypeUsingCASearchRules(sszEnumName.GetUTF8(buff), pDomainAssembly->GetAssembly());
}
/*static*/
HRESULT Attribute::ParseCaType(
CustomAttributeParser &ca,
CaType* pCaType,
DomainAssembly* pDomainAssembly,
StackSString* ss)
{
WRAPPER_NO_CONTRACT;
HRESULT hr = S_OK;
IfFailGo(::ParseEncodedType(ca, pCaType));
if (pCaType->tag == SERIALIZATION_TYPE_ENUM ||
(pCaType->tag == SERIALIZATION_TYPE_SZARRAY && pCaType->arrayType == SERIALIZATION_TYPE_ENUM ))
{
TypeHandle th = Attribute::GetTypeForEnum(pCaType->szEnumName, pCaType->cEnumName, pDomainAssembly);
if (!th.IsNull() && th.IsEnum())
{
pCaType->enumType = (CorSerializationType)th.GetVerifierCorElementType();
// The assembly qualified name of th might not equal pCaType->szEnumName.
// e.g. th could be "MyEnum, MyAssembly, Version=4.0.0.0" while
// pCaType->szEnumName is "MyEnum, MyAssembly, Version=3.0.0.0"
if (ss)
{
DWORD format = TypeString::FormatNamespace | TypeString::FormatFullInst | TypeString::FormatAssembly;
TypeString::AppendType(*ss, th, format);
}
}
else
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, pCaType->szEnumName, pCaType->cEnumName)
IfFailGo(PostError(META_E_CA_UNEXPECTED_TYPE, wcslen(pWideStr), pWideStr));
}
}
ErrExit:
return hr;
}
/*static*/
void Attribute::SetBlittableCaValue(CustomAttributeValue* pVal, CaValue* pCaVal, BOOL* pbAllBlittableCa)
{
WRAPPER_NO_CONTRACT;
CorSerializationType type = pCaVal->type.tag;
pVal->m_type.m_tag = pCaVal->type.tag;
pVal->m_type.m_arrayType = pCaVal->type.arrayType;
pVal->m_type.m_enumType = pCaVal->type.enumType;
pVal->m_rawValue = 0;
if (type == SERIALIZATION_TYPE_STRING ||
type == SERIALIZATION_TYPE_SZARRAY ||
type == SERIALIZATION_TYPE_TYPE)
{
*pbAllBlittableCa = FALSE;
}
else
{
// Enum arg -> Object param
if (type == SERIALIZATION_TYPE_ENUM && pCaVal->type.cEnumName)
*pbAllBlittableCa = FALSE;
pVal->m_rawValue = pCaVal->i8;
}
}
/*static*/
void Attribute::SetManagedValue(CustomAttributeManagedValues gc, CustomAttributeValue* pValue)
{
WRAPPER_NO_CONTRACT;
CorSerializationType type = pValue->m_type.m_tag;
if (type == SERIALIZATION_TYPE_TYPE || type == SERIALIZATION_TYPE_STRING)
{
SetObjectReference((OBJECTREF*)&pValue->m_enumOrTypeName, gc.string);
}
else if (type == SERIALIZATION_TYPE_ENUM)
{
SetObjectReference((OBJECTREF*)&pValue->m_type.m_enumName, gc.string);
}
else if (type == SERIALIZATION_TYPE_SZARRAY)
{
SetObjectReference((OBJECTREF*)&pValue->m_value, gc.array);
if (pValue->m_type.m_arrayType == SERIALIZATION_TYPE_ENUM)
SetObjectReference((OBJECTREF*)&pValue->m_type.m_enumName, gc.string);
}
}
/*static*/
CustomAttributeManagedValues Attribute::GetManagedCaValue(CaValue* pCaVal)
{
WRAPPER_NO_CONTRACT;
CustomAttributeManagedValues gc;
ZeroMemory(&gc, sizeof(gc));
GCPROTECT_BEGIN(gc)
{
CorSerializationType type = pCaVal->type.tag;
if (type == SERIALIZATION_TYPE_ENUM)
{
gc.string = StringObject::NewString(pCaVal->type.szEnumName, pCaVal->type.cEnumName);
}
else if (type == SERIALIZATION_TYPE_STRING)
{
gc.string = NULL;
if (pCaVal->str.pStr)
gc.string = StringObject::NewString(pCaVal->str.pStr, pCaVal->str.cbStr);
}
else if (type == SERIALIZATION_TYPE_TYPE)
{
gc.string = StringObject::NewString(pCaVal->str.pStr, pCaVal->str.cbStr);
}
else if (type == SERIALIZATION_TYPE_SZARRAY)
{
CorSerializationType arrayType = pCaVal->type.arrayType;
ULONG length = pCaVal->arr.length;
BOOL bAllBlittableCa = arrayType != SERIALIZATION_TYPE_ENUM;
if (arrayType == SERIALIZATION_TYPE_ENUM)
gc.string = StringObject::NewString(pCaVal->type.szEnumName, pCaVal->type.cEnumName);
if (length != (ULONG)-1)
{
gc.array = (CaValueArrayREF)AllocateSzArray(TypeHandle(CoreLibBinder::GetClass(CLASS__CUSTOM_ATTRIBUTE_ENCODED_ARGUMENT)).MakeSZArray(), length);
CustomAttributeValue* pValues = gc.array->GetDirectPointerToNonObjectElements();
for (COUNT_T i = 0; i < length; i ++)
Attribute::SetBlittableCaValue(&pValues[i], &pCaVal->arr[i], &bAllBlittableCa);
if (!bAllBlittableCa)
{
for (COUNT_T i = 0; i < length; i ++)
{
CustomAttributeManagedValues managedCaValue = Attribute::GetManagedCaValue(&pCaVal->arr[i]);
Attribute::SetManagedValue(
managedCaValue,
&gc.array->GetDirectPointerToNonObjectElements()[i]);
}
}
}
}
}
GCPROTECT_END();
return gc;
}
/*static*/
HRESULT Attribute::ParseAttributeArgumentValues(
void* pCa,
INT32 cCa,
CaValueArrayFactory* pCaValueArrayFactory,
CaArg* pCaArgs,
COUNT_T cArgs,
CaNamedArg* pCaNamedArgs,
COUNT_T cNamedArgs,
DomainAssembly* pDomainAssembly)
{
WRAPPER_NO_CONTRACT;
HRESULT hr = S_OK;
CustomAttributeParser cap(pCa, cCa);
IfFailGo(Attribute::ParseCaCtorArgs(cap, pCaArgs, cArgs, pCaValueArrayFactory, pDomainAssembly));
IfFailGo(Attribute::ParseCaNamedArgs(cap, pCaNamedArgs, cNamedArgs, pCaValueArrayFactory, pDomainAssembly));
ErrExit:
return hr;
}
//---------------------------------------------------------------------------------------
//
// Helper to parse the values for the ctor argument list and the named argument list.
//
HRESULT Attribute::ParseCaValue(
CustomAttributeParser &ca,
CaValue* pCaArg,
CaType* pCaParam,
CaValueArrayFactory* pCaValueArrayFactory,
DomainAssembly* pDomainAssembly)
{
CONTRACTL
{
PRECONDITION(CheckPointer(pCaArg));
PRECONDITION(CheckPointer(pCaParam));
PRECONDITION(CheckPointer(pCaValueArrayFactory));
THROWS;
}
CONTRACTL_END;
HRESULT hr = S_OK;
CorSerializationType underlyingType;
CaType elementType;
if (pCaParam->tag == SERIALIZATION_TYPE_TAGGED_OBJECT)
IfFailGo(Attribute::ParseCaType(ca, &pCaArg->type, pDomainAssembly));
else
pCaArg->type = *pCaParam;
underlyingType = pCaArg->type.tag == SERIALIZATION_TYPE_ENUM ? pCaArg->type.enumType : pCaArg->type.tag;
// Grab the value.
switch (underlyingType)
{
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
IfFailGo(ca.GetU1(&pCaArg->u1));
break;
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
IfFailGo(ca.GetU2(&pCaArg->u2));
break;
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
IfFailGo(ca.GetU4(&pCaArg->u4));
break;
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
IfFailGo(ca.GetU8(&pCaArg->u8));
break;
case SERIALIZATION_TYPE_R4:
IfFailGo(ca.GetR4(&pCaArg->r4));
break;
case SERIALIZATION_TYPE_R8:
IfFailGo(ca.GetR8(&pCaArg->r8));
break;
case SERIALIZATION_TYPE_STRING:
case SERIALIZATION_TYPE_TYPE:
IfFailGo(ca.GetString(&pCaArg->str.pStr, &pCaArg->str.cbStr));
break;
case SERIALIZATION_TYPE_SZARRAY:
UINT32 len;
IfFailGo(ca.GetU4(&len));
pCaArg->arr.length = len;
pCaArg->arr.pSArray = NULL;
if (pCaArg->arr.length == (ULONG)-1)
break;
IfNullGo(pCaArg->arr.pSArray = pCaValueArrayFactory->Create());
elementType.Init(pCaArg->type.arrayType, SERIALIZATION_TYPE_UNDEFINED,
pCaArg->type.enumType, pCaArg->type.szEnumName, pCaArg->type.cEnumName);
for (ULONG i = 0; i < pCaArg->arr.length; i++)
IfFailGo(Attribute::ParseCaValue(ca, &*pCaArg->arr.pSArray->Append(), &elementType, pCaValueArrayFactory, pDomainAssembly));
break;
default:
// The format of the custom attribute record is invalid.
hr = E_FAIL;
break;
} // End switch
ErrExit:
return hr;
}
/*static*/
HRESULT Attribute::ParseCaCtorArgs(
CustomAttributeParser &ca,
CaArg* pArgs,
ULONG cArgs,
CaValueArrayFactory* pCaValueArrayFactory,
DomainAssembly* pDomainAssembly)
{
WRAPPER_NO_CONTRACT;
HRESULT hr = S_OK; // A result.
ULONG ix; // Loop control.
// If there is a blob, check the prolog.
if (FAILED(ca.ValidateProlog()))
{
IfFailGo(PostError(META_E_CA_INVALID_BLOB));
}
// For each expected arg...
for (ix=0; ix<cArgs; ++ix)
{
CaArg* pArg = &pArgs[ix];
IfFailGo(Attribute::ParseCaValue(ca, &pArg->val, &pArg->type, pCaValueArrayFactory, pDomainAssembly));
}
ErrExit:
return hr;
}
//---------------------------------------------------------------------------------------
//
// Because ParseKnowCaNamedArgs MD cannot have VM dependency, we have our own implementation here:
// 1. It needs to load the assemblies that contain the enum types for the named arguments,
// 2. It Compares the enum type name with that of the loaded enum type, not the one in the CA record.
//
/*static*/
HRESULT Attribute::ParseCaNamedArgs(
CustomAttributeParser &ca,
CaNamedArg *pNamedParams,
ULONG cNamedParams,
CaValueArrayFactory* pCaValueArrayFactory,
DomainAssembly* pDomainAssembly)
{
CONTRACTL {
PRECONDITION(CheckPointer(pCaValueArrayFactory));
PRECONDITION(CheckPointer(pDomainAssembly));
THROWS;
} CONTRACTL_END;
HRESULT hr = S_OK;
ULONG ixParam;
INT32 ixArg;
INT16 cActualArgs;
CaNamedArgCtor namedArg;
CaNamedArg* pNamedParam;
// Get actual count of named arguments.
if (FAILED(ca.GetI2(&cActualArgs)))
cActualArgs = 0; // Everett behavior
for (ixParam = 0; ixParam < cNamedParams; ixParam++)
pNamedParams[ixParam].val.type.tag = SERIALIZATION_TYPE_UNDEFINED;
// For each named argument...
for (ixArg = 0; ixArg < cActualArgs; ixArg++)
{
// Field or property?
IfFailGo(ca.GetTag(&namedArg.propertyOrField));
if (namedArg.propertyOrField != SERIALIZATION_TYPE_FIELD && namedArg.propertyOrField != SERIALIZATION_TYPE_PROPERTY)
IfFailGo(PostError(META_E_CA_INVALID_ARGTYPE));
// Get argument type information
CaType* pNamedArgType = &namedArg.type;
StackSString ss;
IfFailGo(Attribute::ParseCaType(ca, pNamedArgType, pDomainAssembly, &ss));
LPCSTR szLoadedEnumName = NULL;
StackScratchBuffer buff;
if (pNamedArgType->tag == SERIALIZATION_TYPE_ENUM ||
(pNamedArgType->tag == SERIALIZATION_TYPE_SZARRAY && pNamedArgType->arrayType == SERIALIZATION_TYPE_ENUM ))
{
szLoadedEnumName = ss.GetUTF8(buff);
}
// Get name of Arg.
if (FAILED(ca.GetNonEmptyString(&namedArg.szName, &namedArg.cName)))
IfFailGo(PostError(META_E_CA_INVALID_BLOB));
// Match arg by name and type
for (ixParam = 0; ixParam < cNamedParams; ixParam++)
{
pNamedParam = &pNamedParams[ixParam];
// Match type
if (pNamedParam->type.tag != SERIALIZATION_TYPE_TAGGED_OBJECT)
{
if (namedArg.type.tag != pNamedParam->type.tag)
continue;
// Match array type
if (namedArg.type.tag == SERIALIZATION_TYPE_SZARRAY &&
pNamedParam->type.arrayType != SERIALIZATION_TYPE_TAGGED_OBJECT &&
namedArg.type.arrayType != pNamedParam->type.arrayType)
continue;
}
// Match name (and its length to avoid substring matching)
if ((pNamedParam->cName != namedArg.cName) ||
(strncmp(pNamedParam->szName, namedArg.szName, namedArg.cName) != 0))
{
continue;
}
// If enum, match enum name.
if (pNamedParam->type.tag == SERIALIZATION_TYPE_ENUM ||
(pNamedParam->type.tag == SERIALIZATION_TYPE_SZARRAY && pNamedParam->type.arrayType == SERIALIZATION_TYPE_ENUM ))
{
// pNamedParam->type.szEnumName: module->CA record->ctor token->loaded type->field/property->field/property type->field/property type name
// namedArg.type.szEnumName: module->CA record->named arg->enum type name
// szLoadedEnumName: module->CA record->named arg->enum type name->loaded enum type->loaded enum type name
// Comparing pNamedParam->type.szEnumName against namedArg.type.szEnumName could fail if we loaded a different version
// of the enum type than the one specified in the CA record. So we are comparing it against szLoadedEnumName instead.
if (strncmp(pNamedParam->type.szEnumName, szLoadedEnumName, pNamedParam->type.cEnumName) != 0)
continue;
if (namedArg.type.enumType != pNamedParam->type.enumType)
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, pNamedParam->type.szEnumName, pNamedParam->type.cEnumName)
IfFailGo(PostError(META_E_CA_UNEXPECTED_TYPE, wcslen(pWideStr), pWideStr));
}
// TODO: For now assume the property\field array size is correct - later we should verify this
}
// Found a match.
break;
}
// Better have found an argument.
if (ixParam == cNamedParams)
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, namedArg.szName, namedArg.cName)
IfFailGo(PostError(META_E_CA_UNKNOWN_ARGUMENT, wcslen(pWideStr), pWideStr));
}
// Argument had better not have been seen already.
if (pNamedParams[ixParam].val.type.tag != SERIALIZATION_TYPE_UNDEFINED)
{
MAKE_WIDEPTR_FROMUTF8N(pWideStr, namedArg.szName, namedArg.cName)
IfFailGo(PostError(META_E_CA_REPEATED_ARG, wcslen(pWideStr), pWideStr));
}
IfFailGo(Attribute::ParseCaValue(ca, &pNamedParams[ixParam].val, &namedArg.type, pCaValueArrayFactory, pDomainAssembly));
}
ErrExit:
return hr;
}
/*static*/
HRESULT Attribute::InitCaType(CustomAttributeType* pType, Factory<SString>* pSstringFactory, Factory<StackScratchBuffer>* pStackScratchBufferFactory, CaType* pCaType)
{
CONTRACTL {
THROWS;
PRECONDITION(CheckPointer(pType));
PRECONDITION(CheckPointer(pSstringFactory));
PRECONDITION(CheckPointer(pStackScratchBufferFactory));
PRECONDITION(CheckPointer(pCaType));
} CONTRACTL_END;
HRESULT hr = S_OK;
SString* psszName = NULL;
StackScratchBuffer* scratchBuffer = NULL;
IfNullGo(psszName = pSstringFactory->Create());
IfNullGo(scratchBuffer = pStackScratchBufferFactory->Create());
psszName->Set(pType->m_enumName == NULL ? NULL : pType->m_enumName->GetBuffer());
pCaType->Init(
pType->m_tag,
pType->m_arrayType,
pType->m_enumType,
psszName->GetUTF8(*scratchBuffer),
(ULONG)psszName->GetCount());
ErrExit:
return hr;
}
FCIMPL5(VOID, Attribute::ParseAttributeArguments, void* pCa, INT32 cCa,
CaArgArrayREF* ppCustomAttributeArguments,
CaNamedArgArrayREF* ppCustomAttributeNamedArguments,
AssemblyBaseObject* pAssemblyUNSAFE)
{
FCALL_CONTRACT;
ASSEMBLYREF refAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pAssemblyUNSAFE);
HELPER_METHOD_FRAME_BEGIN_1(refAssembly)
{
DomainAssembly *pDomainAssembly = refAssembly->GetDomainAssembly();
struct
{
CustomAttributeArgument* pArgs;
CustomAttributeNamedArgument* pNamedArgs;
} gc;
gc.pArgs = NULL;
gc.pNamedArgs = NULL;
HRESULT hr = S_OK;
GCPROTECT_BEGININTERIOR(gc);
BOOL bAllBlittableCa = TRUE;
COUNT_T cArgs = 0;
COUNT_T cNamedArgs = 0;
CaArg* pCaArgs = NULL;
CaNamedArg* pCaNamedArgs = NULL;
#ifdef __GNUC__
// When compiling under GCC we have to use the -fstack-check option to ensure we always spot stack
// overflow. But this option is intolerant of locals growing too large, so we have to cut back a bit
// on what we can allocate inline here. Leave the Windows versions alone to retain the perf benefits
// since we don't have the same constraints.
NewHolder<CaValueArrayFactory> pCaValueArrayFactory = new InlineFactory<SArray<CaValue>, 4>();
InlineFactory<StackScratchBuffer, 4> stackScratchBufferFactory;
InlineFactory<SString, 4> sstringFactory;
#else // __GNUC__
// Preallocate 4 elements in each of the following factories for optimal performance.
// 4 is enough for 4 typed args or 2 named args which are enough for 99% of the cases.
// SArray<CaValue> is only needed if a argument is an array, don't preallocate any memory as arrays are rare.
// Need one per (ctor or named) arg + one per array element
InlineFactory<SArray<CaValue>, 4> caValueArrayFactory;
InlineFactory<SArray<CaValue>, 4> *pCaValueArrayFactory = &caValueArrayFactory;
// Need one StackScratchBuffer per ctor arg and two per named arg
InlineFactory<StackScratchBuffer, 4> stackScratchBufferFactory;
// Need one SString per ctor arg and two per named arg
InlineFactory<SString, 4> sstringFactory;
#endif // __GNUC__
cArgs = (*ppCustomAttributeArguments)->GetNumComponents();
if (cArgs)
{
gc.pArgs = (*ppCustomAttributeArguments)->GetDirectPointerToNonObjectElements();
size_t size = sizeof(CaArg) * cArgs;
if ((size / sizeof(CaArg)) != cArgs) // uint over/underflow
IfFailGo(E_INVALIDARG);
pCaArgs = (CaArg*)_alloca(size);
for (COUNT_T i = 0; i < cArgs; i ++)
{
CaType caType;
IfFailGo(Attribute::InitCaType(&gc.pArgs[i].m_type, &sstringFactory, &stackScratchBufferFactory, &caType));
pCaArgs[i].Init(caType);
}
}
cNamedArgs = (*ppCustomAttributeNamedArguments)->GetNumComponents();
if (cNamedArgs)
{
gc.pNamedArgs = (*ppCustomAttributeNamedArguments)->GetDirectPointerToNonObjectElements();
size_t size = sizeof(CaNamedArg) * cNamedArgs;
if ((size / sizeof(CaNamedArg)) != cNamedArgs) // uint over/underflow
IfFailGo(E_INVALIDARG);
pCaNamedArgs = (CaNamedArg*)_alloca(size);
for (COUNT_T i = 0; i < cNamedArgs; i ++)
{
CustomAttributeNamedArgument* pNamedArg = &gc.pNamedArgs[i];
CaType caType;
IfFailGo(Attribute::InitCaType(&pNamedArg->m_type, &sstringFactory, &stackScratchBufferFactory, &caType));
SString* psszName = NULL;
IfNullGo(psszName = sstringFactory.Create());
psszName->Set(pNamedArg->m_argumentName->GetBuffer());
StackScratchBuffer* scratchBuffer = NULL;
IfNullGo(scratchBuffer = stackScratchBufferFactory.Create());
pCaNamedArgs[i].Init(
psszName->GetUTF8(*scratchBuffer),
pNamedArg->m_propertyOrField,
caType);
}
}
// This call maps the named parameters (fields and arguments) and ctor parameters with the arguments in the CA record
// and retrieve their values.
IfFailGo(Attribute::ParseAttributeArgumentValues(pCa, cCa, pCaValueArrayFactory, pCaArgs, cArgs, pCaNamedArgs, cNamedArgs, pDomainAssembly));
for (COUNT_T i = 0; i < cArgs; i ++)
Attribute::SetBlittableCaValue(&gc.pArgs[i].m_value, &pCaArgs[i].val, &bAllBlittableCa);
for (COUNT_T i = 0; i < cNamedArgs; i ++)
Attribute::SetBlittableCaValue(&gc.pNamedArgs[i].m_value, &pCaNamedArgs[i].val, &bAllBlittableCa);
if (!bAllBlittableCa)
{
for (COUNT_T i = 0; i < cArgs; i ++)
{
CustomAttributeManagedValues managedCaValue = Attribute::GetManagedCaValue(&pCaArgs[i].val);
Attribute::SetManagedValue(managedCaValue, &(gc.pArgs[i].m_value));
}
for (COUNT_T i = 0; i < cNamedArgs; i++)
{
CustomAttributeManagedValues managedCaValue = Attribute::GetManagedCaValue(&pCaNamedArgs[i].val);
Attribute::SetManagedValue(managedCaValue, &(gc.pNamedArgs[i].m_value));
}
}
ErrExit:
; // Need empty statement to get GCPROTECT_END below to work.
GCPROTECT_END();
if (hr != S_OK)
{
if ((hr == E_OUTOFMEMORY) || (hr == NTE_NO_MEMORY))
{
COMPlusThrow(kOutOfMemoryException);
}
else
{
COMPlusThrow(kCustomAttributeFormatException);
}
}
}
HELPER_METHOD_FRAME_END();
}
FCIMPLEND
FCIMPL6(LPVOID, COMCustomAttribute::CreateCaObject, ReflectModuleBaseObject* pAttributedModuleUNSAFE, ReflectClassBaseObject* pCaTypeUNSAFE, ReflectMethodObject *pMethodUNSAFE, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs)
{
FCALL_CONTRACT;
struct
{
REFLECTCLASSBASEREF refCaType;
OBJECTREF ca;
REFLECTMETHODREF refCtor;
REFLECTMODULEBASEREF refAttributedModule;
} gc;
gc.refCaType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pCaTypeUNSAFE);
TypeHandle th = gc.refCaType->GetType();
gc.ca = NULL;
gc.refCtor = (REFLECTMETHODREF)ObjectToOBJECTREF(pMethodUNSAFE);
gc.refAttributedModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(pAttributedModuleUNSAFE);
if(gc.refAttributedModule == NULL)
FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle"));
MethodDesc* pCtorMD = gc.refCtor->GetMethod();
HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc);
{
MethodDescCallSite ctorCallSite(pCtorMD, th);
MetaSig* pSig = ctorCallSite.GetMetaSig();
BYTE* pBlob = *ppBlob;
// get the number of arguments and allocate an array for the args
ARG_SLOT *args = NULL;
UINT cArgs = pSig->NumFixedArgs() + 1; // make room for the this pointer
UINT i = 1; // used to flag that we actually get the right number of arg from the blob
args = (ARG_SLOT*)_alloca(cArgs * sizeof(ARG_SLOT));
memset((void*)args, 0, cArgs * sizeof(ARG_SLOT));
OBJECTREF *argToProtect = (OBJECTREF*)_alloca(cArgs * sizeof(OBJECTREF));
memset((void*)argToProtect, 0, cArgs * sizeof(OBJECTREF));
// load the this pointer
argToProtect[0] = gc.refCaType->GetType().GetMethodTable()->Allocate(); // this is the value to return after the ctor invocation
if (pBlob)
{
if (pBlob < pEndBlob)
{
if (pBlob + 2 > pEndBlob)
{
COMPlusThrow(kCustomAttributeFormatException);
}
INT16 prolog = GET_UNALIGNED_VAL16(pBlob);
if (prolog != 1)
COMPlusThrow(kCustomAttributeFormatException);
pBlob += 2;
}
if (cArgs > 1)
{
GCPROTECT_ARRAY_BEGIN(*argToProtect, cArgs);
{
// loop through the args
for (i = 1; i < cArgs; i++) {
CorElementType type = pSig->NextArg();
if (type == ELEMENT_TYPE_END)
break;
BOOL bObjectCreated = FALSE;
TypeHandle th = pSig->GetLastTypeHandleThrowing();
if (th.IsArray())
// get the array element
th = th.GetArrayElementTypeHandle();
ARG_SLOT data = GetDataFromBlob(pCtorMD->GetAssembly(), (CorSerializationType)type, th, &pBlob, pEndBlob, gc.refAttributedModule->GetModule(), &bObjectCreated);
if (bObjectCreated)
argToProtect[i] = ArgSlotToObj(data);
else
args[i] = data;
}
}
GCPROTECT_END();
// We have borrowed the signature from MethodDescCallSite. We have to put it back into the initial position
// because of that's where MethodDescCallSite expects to find it below.
pSig->Reset();
for (i = 1; i < cArgs; i++)
{
if (argToProtect[i] != NULL)
{
_ASSERTE(args[i] == NULL);
args[i] = ObjToArgSlot(argToProtect[i]);
}
}
}
}
args[0] = ObjToArgSlot(argToProtect[0]);
if (i != cArgs)
COMPlusThrow(kCustomAttributeFormatException);
// check if there are any named properties to invoke,
// if so set the by ref int passed in to point
// to the blob position where name properties start
*pcNamedArgs = 0;
if (pBlob && pBlob != pEndBlob)
{
if (pBlob + 2 > pEndBlob)
COMPlusThrow(kCustomAttributeFormatException);
*pcNamedArgs = GET_UNALIGNED_VAL16(pBlob);
pBlob += 2;
}
*ppBlob = pBlob;
if (*pcNamedArgs == 0 && pBlob != pEndBlob)
COMPlusThrow(kCustomAttributeFormatException);
// make the invocation to the ctor
gc.ca = ArgSlotToObj(args[0]);
if (pCtorMD->GetMethodTable()->IsValueType())
args[0] = PtrToArgSlot(OBJECTREFToObject(gc.ca)->UnBox());
ctorCallSite.CallWithValueTypes(args);
}
HELPER_METHOD_FRAME_END();
return OBJECTREFToObject(gc.ca);
}
FCIMPLEND
FCIMPL5(VOID, COMCustomAttribute::ParseAttributeUsageAttribute, PVOID pData, ULONG cData, ULONG* pTargets, CLR_BOOL* pInherited, CLR_BOOL* pAllowMultiple)
{
FCALL_CONTRACT;
int inherited = 0;
int allowMultiple = 1;
{
CustomAttributeParser ca(pData, cData);
CaArg args[1];
args[0].InitEnum(SERIALIZATION_TYPE_I4, 0);
if (FAILED(::ParseKnownCaArgs(ca, args, ARRAY_SIZE(args))))
{
HELPER_METHOD_FRAME_BEGIN_0();
COMPlusThrow(kCustomAttributeFormatException);
HELPER_METHOD_FRAME_END();
}
*pTargets = args[0].val.u4;
CaNamedArg namedArgs[2];
CaType namedArgTypes[2];
namedArgTypes[inherited].Init(SERIALIZATION_TYPE_BOOLEAN);
namedArgTypes[allowMultiple].Init(SERIALIZATION_TYPE_BOOLEAN);
namedArgs[inherited].Init("Inherited", SERIALIZATION_TYPE_PROPERTY, namedArgTypes[inherited], TRUE);
namedArgs[allowMultiple].Init("AllowMultiple", SERIALIZATION_TYPE_PROPERTY, namedArgTypes[allowMultiple], FALSE);
if (FAILED(::ParseKnownCaNamedArgs(ca, namedArgs, ARRAY_SIZE(namedArgs))))
{
HELPER_METHOD_FRAME_BEGIN_0();
COMPlusThrow(kCustomAttributeFormatException);
HELPER_METHOD_FRAME_END();
}
*pInherited = namedArgs[inherited].val.boolean == TRUE;
*pAllowMultiple = namedArgs[allowMultiple].val.boolean == TRUE;
}
}
FCIMPLEND
FCIMPL7(void, COMCustomAttribute::GetPropertyOrFieldData, ReflectModuleBaseObject *pModuleUNSAFE, BYTE** ppBlobStart, BYTE* pBlobEnd, STRINGREF* pName, CLR_BOOL* pbIsProperty, OBJECTREF* pType, OBJECTREF* value)
{
FCALL_CONTRACT;
BYTE* pBlob = *ppBlobStart;
*pType = NULL;
REFLECTMODULEBASEREF refModule = (REFLECTMODULEBASEREF)ObjectToOBJECTREF(pModuleUNSAFE);
if(refModule == NULL)
FCThrowResVoid(kArgumentNullException, W("Arg_InvalidHandle"));
Module *pModule = refModule->GetModule();
HELPER_METHOD_FRAME_BEGIN_1(refModule);
{
Assembly *pCtorAssembly = NULL;
MethodTable *pMTValue = NULL;
CorSerializationType arrayType = SERIALIZATION_TYPE_BOOLEAN;
BOOL bObjectCreated = FALSE;
TypeHandle nullTH;
if (pBlob + 2 > pBlobEnd)
COMPlusThrow(kCustomAttributeFormatException);
// get whether it is a field or a property
CorSerializationType propOrField = (CorSerializationType)*pBlob;
pBlob++;
if (propOrField == SERIALIZATION_TYPE_FIELD)
*pbIsProperty = FALSE;
else if (propOrField == SERIALIZATION_TYPE_PROPERTY)
*pbIsProperty = TRUE;
else
COMPlusThrow(kCustomAttributeFormatException);
// get the type of the field
CorSerializationType fieldType = (CorSerializationType)*pBlob;
pBlob++;
if (fieldType == SERIALIZATION_TYPE_SZARRAY)
{
arrayType = (CorSerializationType)*pBlob;
if (pBlob + 1 > pBlobEnd)
COMPlusThrow(kCustomAttributeFormatException);
pBlob++;
}
if (fieldType == SERIALIZATION_TYPE_ENUM || arrayType == SERIALIZATION_TYPE_ENUM)
{
// get the enum type
ReflectClassBaseObject *pEnum =
(ReflectClassBaseObject*)OBJECTREFToObject(ArgSlotToObj(GetDataFromBlob(
pCtorAssembly, SERIALIZATION_TYPE_TYPE, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated)));
if (pEnum == NULL)
COMPlusThrow(kCustomAttributeFormatException);
_ASSERTE(bObjectCreated);
TypeHandle th = pEnum->GetType();
_ASSERTE(th.IsEnum());
pMTValue = th.AsMethodTable();
if (fieldType == SERIALIZATION_TYPE_ENUM)
// load the enum type to pass it back
*pType = th.GetManagedClassObject();
else
nullTH = th;
}
// get the string representing the field/property name
*pName = ArgSlotToString(GetDataFromBlob(
pCtorAssembly, SERIALIZATION_TYPE_STRING, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated));
_ASSERTE(bObjectCreated || *pName == NULL);
// create the object and return it
switch (fieldType)
{
case SERIALIZATION_TYPE_TAGGED_OBJECT:
*pType = g_pObjectClass->GetManagedClassObject();
FALLTHROUGH;
case SERIALIZATION_TYPE_TYPE:
case SERIALIZATION_TYPE_STRING:
*value = ArgSlotToObj(GetDataFromBlob(
pCtorAssembly, fieldType, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated));
_ASSERTE(bObjectCreated || *value == NULL);
if (*value == NULL)
{
// load the proper type so that code in managed knows which property to load
if (fieldType == SERIALIZATION_TYPE_STRING)
*pType = CoreLibBinder::GetElementType(ELEMENT_TYPE_STRING)->GetManagedClassObject();
else if (fieldType == SERIALIZATION_TYPE_TYPE)
*pType = CoreLibBinder::GetClass(CLASS__TYPE)->GetManagedClassObject();
}
break;
case SERIALIZATION_TYPE_SZARRAY:
{
*value = NULL;
int arraySize = (int)GetDataFromBlob(pCtorAssembly, SERIALIZATION_TYPE_I4, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated);
if (arraySize != -1)
{
_ASSERTE(!bObjectCreated);
if (arrayType == SERIALIZATION_TYPE_STRING)
nullTH = TypeHandle(CoreLibBinder::GetElementType(ELEMENT_TYPE_STRING));
else if (arrayType == SERIALIZATION_TYPE_TYPE)
nullTH = TypeHandle(CoreLibBinder::GetClass(CLASS__TYPE));
else if (arrayType == SERIALIZATION_TYPE_TAGGED_OBJECT)
nullTH = TypeHandle(g_pObjectClass);
ReadArray(pCtorAssembly, arrayType, arraySize, nullTH, &pBlob, pBlobEnd, pModule, (BASEARRAYREF*)value);
}
if (*value == NULL)
{
TypeHandle arrayTH;
switch (arrayType)
{
case SERIALIZATION_TYPE_STRING:
arrayTH = TypeHandle(CoreLibBinder::GetElementType(ELEMENT_TYPE_STRING));
break;
case SERIALIZATION_TYPE_TYPE:
arrayTH = TypeHandle(CoreLibBinder::GetClass(CLASS__TYPE));
break;
case SERIALIZATION_TYPE_TAGGED_OBJECT:
arrayTH = TypeHandle(g_pObjectClass);
break;
default:
if (SERIALIZATION_TYPE_BOOLEAN <= arrayType && arrayType <= SERIALIZATION_TYPE_R8)
arrayTH = TypeHandle(CoreLibBinder::GetElementType((CorElementType)arrayType));
}
if (!arrayTH.IsNull())
{
arrayTH = ClassLoader::LoadArrayTypeThrowing(arrayTH);
*pType = arrayTH.GetManagedClassObject();
}
}
break;
}
default:
if (SERIALIZATION_TYPE_BOOLEAN <= fieldType && fieldType <= SERIALIZATION_TYPE_R8)
pMTValue = CoreLibBinder::GetElementType((CorElementType)fieldType);
else if(fieldType == SERIALIZATION_TYPE_ENUM)
fieldType = (CorSerializationType)pMTValue->GetInternalCorElementType();
else
COMPlusThrow(kCustomAttributeFormatException);
ARG_SLOT val = GetDataFromBlob(pCtorAssembly, fieldType, nullTH, &pBlob, pBlobEnd, pModule, &bObjectCreated);
_ASSERTE(!bObjectCreated);
*value = pMTValue->Box((void*)ArgSlotEndianessFixup(&val, pMTValue->GetNumInstanceFieldBytes()));
}
*ppBlobStart = pBlob;
}
HELPER_METHOD_FRAME_END();
}
FCIMPLEND
/*static*/
TypeHandle COMCustomAttribute::GetTypeHandleFromBlob(Assembly *pCtorAssembly,
CorSerializationType objType,
BYTE **pBlob,
const BYTE *endBlob,
Module *pModule)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
// we must box which means we must get the method table, switch again on the element type
MethodTable *pMTType = NULL;
TypeHandle nullTH;
TypeHandle RtnTypeHnd;
switch ((DWORD)objType) {
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
case SERIALIZATION_TYPE_R4:
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
case SERIALIZATION_TYPE_R8:
case SERIALIZATION_TYPE_STRING:
pMTType = CoreLibBinder::GetElementType((CorElementType)objType);
RtnTypeHnd = TypeHandle(pMTType);
break;
case ELEMENT_TYPE_CLASS:
pMTType = CoreLibBinder::GetClass(CLASS__TYPE);
RtnTypeHnd = TypeHandle(pMTType);
break;
case SERIALIZATION_TYPE_TAGGED_OBJECT:
pMTType = g_pObjectClass;
RtnTypeHnd = TypeHandle(pMTType);
break;
case SERIALIZATION_TYPE_TYPE:
{
int size = GetStringSize(pBlob, endBlob);
if (size == -1)
return nullTH;
if ((size+1 <= 1) || (size > endBlob - *pBlob))
COMPlusThrow(kCustomAttributeFormatException);
LPUTF8 szName = (LPUTF8)_alloca(size + 1);
memcpy(szName, *pBlob, size);
*pBlob += size;
szName[size] = 0;
RtnTypeHnd = TypeName::GetTypeUsingCASearchRules(szName, pModule->GetAssembly(), NULL, FALSE);
break;
}
case SERIALIZATION_TYPE_ENUM:
{
// get the enum type
BOOL isObject = FALSE;
ReflectClassBaseObject *pType = (ReflectClassBaseObject*)OBJECTREFToObject(ArgSlotToObj(GetDataFromBlob(pCtorAssembly,
SERIALIZATION_TYPE_TYPE,
nullTH,
pBlob,
endBlob,
pModule,
&isObject)));
if (pType != NULL)
{
_ASSERTE(isObject);
RtnTypeHnd = pType->GetType();
_ASSERTE((objType == SERIALIZATION_TYPE_ENUM) ? RtnTypeHnd.GetMethodTable()->IsEnum() : TRUE);
}
else
{
RtnTypeHnd = TypeHandle();
}
break;
}
default:
COMPlusThrow(kCustomAttributeFormatException);
}
return RtnTypeHnd;
}
// retrieve the string size in a CA blob. Advance the blob pointer to point to
// the beginning of the string immediately following the size
/*static*/
int COMCustomAttribute::GetStringSize(BYTE **pBlob, const BYTE *endBlob)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
if (*pBlob >= endBlob )
{ // No buffer at all, or buffer overrun
COMPlusThrow(kCustomAttributeFormatException);
}
if (**pBlob == 0xFF)
{ // Special case null string.
++(*pBlob);
return -1;
}
ULONG ulSize;
if (FAILED(CPackedLen::SafeGetData((BYTE const *)*pBlob, (BYTE const *)endBlob, (ULONG *)&ulSize, (BYTE const **)pBlob)))
{
COMPlusThrow(kCustomAttributeFormatException);
}
return (int)ulSize;
}
// copy the values of an array of integers from a CA blob
// (i.e., always stored in little-endian, and needs not be aligned).
// Returns TRUE on success, FALSE if the blob was not big enough.
// Advances *pBlob by the amount copied.
/*static*/
template < typename T >
BOOL COMCustomAttribute::CopyArrayVAL(BASEARRAYREF pArray, int nElements, BYTE **pBlob, const BYTE *endBlob)
{
int sizeData; // = size * 2; with integer overflow check
if (!ClrSafeInt<int>::multiply(nElements, sizeof(T), sizeData))
return FALSE;
if (*pBlob + sizeData < *pBlob) // integer overflow check
return FALSE;
if (*pBlob + sizeData > endBlob)
return FALSE;
#if BIGENDIAN
T *ptDest = reinterpret_cast<T *>(pArray->GetDataPtr());
for (int iElement = 0; iElement < nElements; iElement++)
{
T tValue;
BYTE *pbSrc = *pBlob + iElement * sizeof(T);
BYTE *pbDest = reinterpret_cast<BYTE *>(&tValue);
for (size_t iByte = 0; iByte < sizeof(T); iByte++)
{
pbDest[sizeof(T) - 1 - iByte] = pbSrc[iByte];
}
ptDest[iElement] = tValue;
}
#else // BIGENDIAN
memcpyNoGCRefs(pArray->GetDataPtr(), *pBlob, sizeData);
#endif // BIGENDIAN
*pBlob += sizeData;
return TRUE;
}
// read the whole array as a chunk
/*static*/
void COMCustomAttribute::ReadArray(Assembly *pCtorAssembly,
CorSerializationType arrayType,
int size,
TypeHandle th,
BYTE **pBlob,
const BYTE *endBlob,
Module *pModule,
BASEARRAYREF *pArray)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
ARG_SLOT element = 0;
switch ((DWORD)arrayType) {
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<BYTE>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
{
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<UINT16>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
}
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
case SERIALIZATION_TYPE_R4:
{
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<UINT32>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
}
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
case SERIALIZATION_TYPE_R8:
{
*pArray = (BASEARRAYREF)AllocatePrimitiveArray((CorElementType)arrayType, size);
if (!CopyArrayVAL<UINT64>(*pArray, size, pBlob, endBlob))
goto badBlob;
break;
}
case ELEMENT_TYPE_CLASS:
case SERIALIZATION_TYPE_TYPE:
case SERIALIZATION_TYPE_STRING:
case SERIALIZATION_TYPE_SZARRAY:
case SERIALIZATION_TYPE_TAGGED_OBJECT:
{
BOOL isObject;
// If we haven't figured out the type of the array, throw bad blob exception
if (th.IsNull())
goto badBlob;
*pArray = (BASEARRAYREF)AllocateObjectArray(size, th);
if (arrayType == SERIALIZATION_TYPE_SZARRAY)
// switch the th to be the proper one
th = th.GetArrayElementTypeHandle();
for (int i = 0; i < size; i++) {
element = GetDataFromBlob(pCtorAssembly, arrayType, th, pBlob, endBlob, pModule, &isObject);
_ASSERTE(isObject || element == NULL);
((PTRARRAYREF)(*pArray))->SetAt(i, ArgSlotToObj(element));
}
break;
}
case SERIALIZATION_TYPE_ENUM:
{
INT32 bounds = size;
// If we haven't figured out the type of the array, throw bad blob exception
if (th.IsNull())
goto badBlob;
unsigned elementSize = th.GetSize();
TypeHandle arrayHandle = ClassLoader::LoadArrayTypeThrowing(th);
if (arrayHandle.IsNull())
goto badBlob;
*pArray = (BASEARRAYREF)AllocateSzArray(arrayHandle, bounds);
BOOL fSuccess;
switch (elementSize)
{
case 1:
fSuccess = CopyArrayVAL<BYTE>(*pArray, size, pBlob, endBlob);
break;
case 2:
fSuccess = CopyArrayVAL<UINT16>(*pArray, size, pBlob, endBlob);
break;
case 4:
fSuccess = CopyArrayVAL<UINT32>(*pArray, size, pBlob, endBlob);
break;
case 8:
fSuccess = CopyArrayVAL<UINT64>(*pArray, size, pBlob, endBlob);
break;
default:
fSuccess = FALSE;
}
if (!fSuccess)
goto badBlob;
break;
}
default:
badBlob:
COMPlusThrow(kCustomAttributeFormatException);
}
}
// get data out of the blob according to a CorElementType
/*static*/
ARG_SLOT COMCustomAttribute::GetDataFromBlob(Assembly *pCtorAssembly,
CorSerializationType type,
TypeHandle th,
BYTE **pBlob,
const BYTE *endBlob,
Module *pModule,
BOOL *bObjectCreated)
{
CONTRACTL
{
THROWS;
}
CONTRACTL_END;
ARG_SLOT retValue = 0;
*bObjectCreated = FALSE;
TypeHandle nullTH;
TypeHandle typeHnd;
switch ((DWORD)type) {
case SERIALIZATION_TYPE_BOOLEAN:
case SERIALIZATION_TYPE_I1:
case SERIALIZATION_TYPE_U1:
if (*pBlob + 1 <= endBlob) {
retValue = (ARG_SLOT)**pBlob;
*pBlob += 1;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_CHAR:
case SERIALIZATION_TYPE_I2:
case SERIALIZATION_TYPE_U2:
if (*pBlob + 2 <= endBlob) {
retValue = (ARG_SLOT)GET_UNALIGNED_VAL16(*pBlob);
*pBlob += 2;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_I4:
case SERIALIZATION_TYPE_U4:
case SERIALIZATION_TYPE_R4:
if (*pBlob + 4 <= endBlob) {
retValue = (ARG_SLOT)GET_UNALIGNED_VAL32(*pBlob);
*pBlob += 4;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_I8:
case SERIALIZATION_TYPE_U8:
case SERIALIZATION_TYPE_R8:
if (*pBlob + 8 <= endBlob) {
retValue = (ARG_SLOT)GET_UNALIGNED_VAL64(*pBlob);
*pBlob += 8;
break;
}
goto badBlob;
case SERIALIZATION_TYPE_STRING:
stringType:
{
int size = GetStringSize(pBlob, endBlob);
*bObjectCreated = TRUE;
if (size > 0) {
if (*pBlob + size < *pBlob) // integer overflow check
goto badBlob;
if (*pBlob + size > endBlob)
goto badBlob;
retValue = ObjToArgSlot(StringObject::NewString((LPCUTF8)*pBlob, size));
*pBlob += size;
}
else if (size == 0)
retValue = ObjToArgSlot(StringObject::NewString(0));
else
*bObjectCreated = FALSE;
break;
}
// this is coming back from sig but it's not a serialization type,
// essentialy the type in the blob and the type in the sig don't match
case ELEMENT_TYPE_VALUETYPE:
{
if (!th.IsEnum())
goto badBlob;
CorSerializationType enumType = (CorSerializationType)th.GetInternalCorElementType();
BOOL cannotBeObject = FALSE;
retValue = GetDataFromBlob(pCtorAssembly, enumType, nullTH, pBlob, endBlob, pModule, &cannotBeObject);
_ASSERTE(!cannotBeObject);
break;
}
// this is coming back from sig but it's not a serialization type,
// essentialy the type in the blob and the type in the sig don't match
case ELEMENT_TYPE_CLASS:
if (th.IsArray())
goto typeArray;
else {
MethodTable *pMT = th.AsMethodTable();
if (pMT == g_pStringClass)
goto stringType;
else if (pMT == g_pObjectClass)
goto typeObject;
else if (CoreLibBinder::IsClass(pMT, CLASS__TYPE))
goto typeType;
}
goto badBlob;
case SERIALIZATION_TYPE_TYPE:
typeType:
{
typeHnd = GetTypeHandleFromBlob(pCtorAssembly, SERIALIZATION_TYPE_TYPE, pBlob, endBlob, pModule);
if (!typeHnd.IsNull())
retValue = ObjToArgSlot(typeHnd.GetManagedClassObject());
*bObjectCreated = TRUE;
break;
}
// this is coming back from sig but it's not a serialization type,
// essentialy the type in the blob and the type in the sig don't match
case ELEMENT_TYPE_OBJECT:
case SERIALIZATION_TYPE_TAGGED_OBJECT:
typeObject:
{
// get the byte representing the real type and call GetDataFromBlob again
if (*pBlob + 1 > endBlob)
goto badBlob;
CorSerializationType objType = (CorSerializationType)**pBlob;
*pBlob += 1;
switch (objType) {
case SERIALIZATION_TYPE_SZARRAY:
{
if (*pBlob + 1 > endBlob)
goto badBlob;
CorSerializationType arrayType = (CorSerializationType)**pBlob;
*pBlob += 1;
if (arrayType == SERIALIZATION_TYPE_TYPE)
arrayType = (CorSerializationType)ELEMENT_TYPE_CLASS;
// grab the array type and make a type handle for it
nullTH = GetTypeHandleFromBlob(pCtorAssembly, arrayType, pBlob, endBlob, pModule);
FALLTHROUGH;
}
case SERIALIZATION_TYPE_TYPE:
case SERIALIZATION_TYPE_STRING:
// notice that the nullTH is actually not null in the array case (see case above)
retValue = GetDataFromBlob(pCtorAssembly, objType, nullTH, pBlob, endBlob, pModule, bObjectCreated);
_ASSERTE(*bObjectCreated || retValue == 0);
break;
case SERIALIZATION_TYPE_ENUM:
{
//
// get the enum type
typeHnd = GetTypeHandleFromBlob(pCtorAssembly, SERIALIZATION_TYPE_ENUM, pBlob, endBlob, pModule);
_ASSERTE(typeHnd.IsTypeDesc() == false);
// ok we have the class, now we go and read the data
MethodTable *pMT = typeHnd.AsMethodTable();
PREFIX_ASSUME(pMT != NULL);
CorSerializationType objNormType = (CorSerializationType)pMT->GetInternalCorElementType();
BOOL isObject = FALSE;
retValue = GetDataFromBlob(pCtorAssembly, objNormType, nullTH, pBlob, endBlob, pModule, &isObject);
_ASSERTE(!isObject);
retValue= ObjToArgSlot(pMT->Box((void*)&retValue));
*bObjectCreated = TRUE;
break;
}
default:
{
// the common primitive type case. We need to box the primitive
typeHnd = GetTypeHandleFromBlob(pCtorAssembly, objType, pBlob, endBlob, pModule);
_ASSERTE(typeHnd.IsTypeDesc() == false);
retValue = GetDataFromBlob(pCtorAssembly, objType, nullTH, pBlob, endBlob, pModule, bObjectCreated);
_ASSERTE(!*bObjectCreated);
retValue= ObjToArgSlot(typeHnd.AsMethodTable()->Box((void*)&retValue));
*bObjectCreated = TRUE;
break;
}
}
break;
}
case SERIALIZATION_TYPE_SZARRAY:
typeArray:
{
// read size
BOOL isObject = FALSE;
int size = (int)GetDataFromBlob(pCtorAssembly, SERIALIZATION_TYPE_I4, nullTH, pBlob, endBlob, pModule, &isObject);
_ASSERTE(!isObject);
if (size != -1) {
CorSerializationType arrayType;
if (th.IsEnum())
arrayType = SERIALIZATION_TYPE_ENUM;
else
arrayType = (CorSerializationType)th.GetInternalCorElementType();
BASEARRAYREF array = NULL;
GCPROTECT_BEGIN(array);
ReadArray(pCtorAssembly, arrayType, size, th, pBlob, endBlob, pModule, &array);
retValue = ObjToArgSlot(array);
GCPROTECT_END();
}
*bObjectCreated = TRUE;
break;
}
default:
badBlob:
//<TODO> generate a reasonable text string ("invalid blob or constructor")</TODO>
COMPlusThrow(kCustomAttributeFormatException);
}
return retValue;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/stdinterfaces_wrapper.cpp | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//---------------------------------------------------------------------------------
// stdinterfaces_wrapper.cpp
//
// Defines various standard com interfaces
//---------------------------------------------------------------------------------
#include "common.h"
#include <ole2.h>
#include <guidfromname.h>
#include <olectl.h>
#include <objsafe.h> // IID_IObjectSafe
#include "vars.hpp"
#include "object.h"
#include "excep.h"
#include "frames.h"
#include "vars.hpp"
#include "runtimecallablewrapper.h"
#include "comcallablewrapper.h"
#include "field.h"
#include "threads.h"
#include "interoputil.h"
#include "comdelegate.h"
#include "olevariant.h"
#include "eeconfig.h"
#include "typehandle.h"
#include "posterror.h"
#include <corerror.h>
#include <mscoree.h>
#include "mtx.h"
#include "cgencpu.h"
#include "interopconverter.h"
#include "cominterfacemarshaler.h"
#include "stdinterfaces.h"
#include "stdinterfaces_internal.h"
#include "interoputil.inl"
interface IEnumConnectionPoints;
// IUnknown is part of IDispatch
// Common vtables for well-known COM interfaces
// shared by all COM+ callable wrappers.
// All Com+ created vtables have well known IUnknown methods, which is used to identify
// the type of the interface
// For e.g. all com+ created tear-offs have the same QI method in their IUnknown portion
// Unknown_QueryInterface is the QI method for all the tear-offs created from COM+
//
// Tearoff interfaces created for std. interfaces such as IProvideClassInfo, IErrorInfo etc.
// have the AddRef & Release function point to Unknown_AddRefSpecial & Unknown_ReleaseSpecial
//
// Inner unknown, or the original unknown for a wrapper has
// AddRef & Release point to a Unknown_AddRefInner & Unknown_ReleaseInner
// global inner Unknown vtable
const StdInterfaceDesc<3> g_InnerUnknown =
{
enum_InnerUnknown,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefInner, // special addref to distinguish inner unk
(UINT_PTR*)Unknown_ReleaseInner, // special release to distinguish inner unknown
}
};
// global IProvideClassInfo vtable
const StdInterfaceDesc<4> g_IProvideClassInfo =
{
enum_IProvideClassInfo,
{
(UINT_PTR*)Unknown_QueryInterface, // don't change this
(UINT_PTR*)Unknown_AddRefSpecial, // special addref for std. interface
(UINT_PTR*)Unknown_ReleaseSpecial, // special release for std. interface
(UINT_PTR*)ClassInfo_GetClassInfo_Wrapper // GetClassInfo
}
};
// global IMarshal vtable
const StdInterfaceDesc<9> g_IMarshal =
{
enum_IMarshal,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)Marshal_GetUnmarshalClass_Wrapper,
(UINT_PTR*)Marshal_GetMarshalSizeMax_Wrapper,
(UINT_PTR*)Marshal_MarshalInterface_Wrapper,
(UINT_PTR*)Marshal_UnmarshalInterface_Wrapper,
(UINT_PTR*)Marshal_ReleaseMarshalData_Wrapper,
(UINT_PTR*)Marshal_DisconnectObject_Wrapper
}
};
// global ISupportsErrorInfo vtable
const StdInterfaceDesc<4> g_ISupportsErrorInfo =
{
enum_ISupportsErrorInfo,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)SupportsErroInfo_IntfSupportsErrorInfo_Wrapper
}
};
// global IErrorInfo vtable
const StdInterfaceDesc<8> g_IErrorInfo =
{
enum_IErrorInfo,
{
(UINT_PTR*)Unknown_QueryInterface_IErrorInfo,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial_IErrorInfo,
(UINT_PTR*)ErrorInfo_GetGUID_Wrapper,
(UINT_PTR*)ErrorInfo_GetSource_Wrapper,
(UINT_PTR*)ErrorInfo_GetDescription_Wrapper,
(UINT_PTR*)ErrorInfo_GetHelpFile_Wrapper,
(UINT_PTR*)ErrorInfo_GetHelpContext_Wrapper
}
};
// global IConnectionPointContainer vtable
const StdInterfaceDesc<5> g_IConnectionPointContainer =
{
enum_IConnectionPointContainer,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)ConnectionPointContainer_EnumConnectionPoints_Wrapper,
(UINT_PTR*)ConnectionPointContainer_FindConnectionPoint_Wrapper
}
};
// global IObjectSafety vtable
const StdInterfaceDesc<5> g_IObjectSafety =
{
enum_IObjectSafety,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)ObjectSafety_GetInterfaceSafetyOptions_Wrapper,
(UINT_PTR*)ObjectSafety_SetInterfaceSafetyOptions_Wrapper
}
};
// global IDispatchEx vtable
const StdInterfaceDesc<15> g_IDispatchEx =
{
enum_IDispatchEx,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)DispatchEx_GetTypeInfoCount_Wrapper,
(UINT_PTR*)DispatchEx_GetTypeInfo_Wrapper,
(UINT_PTR*)DispatchEx_GetIDsOfNames_Wrapper,
(UINT_PTR*)DispatchEx_Invoke_Wrapper,
(UINT_PTR*)DispatchEx_GetDispID_Wrapper,
(UINT_PTR*)DispatchEx_InvokeEx_Wrapper,
(UINT_PTR*)DispatchEx_DeleteMemberByName_Wrapper,
(UINT_PTR*)DispatchEx_DeleteMemberByDispID_Wrapper,
(UINT_PTR*)DispatchEx_GetMemberProperties_Wrapper,
(UINT_PTR*)DispatchEx_GetMemberName_Wrapper,
(UINT_PTR*)DispatchEx_GetNextDispID_Wrapper,
(UINT_PTR*)DispatchEx_GetNameSpaceParent_Wrapper
}
};
// global IAgileObject vtable
const StdInterfaceDesc<3> g_IAgileObject =
{
enum_IAgileObject,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial
}
};
// Generic helper to check if AppDomain matches and perform a DoCallBack otherwise
inline BOOL IsCurrentDomainValid(ComCallWrapper* pWrap, Thread* pThread)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_ANY;
PRECONDITION(CheckPointer(pWrap));
PRECONDITION(CheckPointer(pThread));
}
CONTRACTL_END;
_ASSERTE(pWrap != NULL);
PREFIX_ASSUME(pWrap != NULL);
// If we are finalizing all alive objects, or after this stage, we do not allow
// a thread to enter EE.
if ((g_fEEShutDown & ShutDown_Finalize2) || g_fForbidEnterEE)
return FALSE;
return TRUE;
}
BOOL IsCurrentDomainValid(ComCallWrapper* pWrap)
{
CONTRACTL { NOTHROW; GC_TRIGGERS; MODE_ANY; } CONTRACTL_END;
return IsCurrentDomainValid(pWrap, GetThread());
}
struct AppDomainSwitchToPreemptiveHelperArgs
{
ADCallBackFcnType pRealCallback;
void* pRealArgs;
};
VOID __stdcall AppDomainSwitchToPreemptiveHelper(LPVOID pv)
{
AppDomainSwitchToPreemptiveHelperArgs* pArgs = (AppDomainSwitchToPreemptiveHelperArgs*)pv;
CONTRACTL
{
GC_TRIGGERS;
MODE_ANY;
PRECONDITION(CheckPointer(pv));
VOID __stdcall Dispatch_Invoke_CallBack(LPVOID ptr);
if (pArgs->pRealCallback == Dispatch_Invoke_CallBack) THROWS; else NOTHROW;
}
CONTRACTL_END;
GCX_PREEMP();
pArgs->pRealCallback(pArgs->pRealArgs);
}
VOID AppDomainDoCallBack(ComCallWrapper* pWrap, ADCallBackFcnType pTarget, LPVOID pArgs, HRESULT* phr)
{
CONTRACTL
{
DISABLED(NOTHROW);
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pWrap));
PRECONDITION(CheckPointer(pTarget));
PRECONDITION(CheckPointer(pArgs));
PRECONDITION(CheckPointer(phr));
}
CONTRACTL_END;
// If we are finalizing all alive objects, or after this stage, we do not allow
// a thread to enter EE.
if ((g_fEEShutDown & ShutDown_Finalize2) || g_fForbidEnterEE)
{
*phr = E_FAIL;
return;
}
BEGIN_EXTERNAL_ENTRYPOINT(phr)
{
// make the call directly not forgetting to switch to preemptive GC mode
GCX_PREEMP();
((ADCallBackFcnType)pTarget)(pArgs);
}
END_EXTERNAL_ENTRYPOINT;
}
//-------------------------------------------------------------------------
// IUnknown methods
struct QIArgs
{
ComCallWrapper* pWrap;
IUnknown* pUnk;
const IID* riid;
void** ppv;
HRESULT* hr;
};
VOID __stdcall Unknown_QueryInterface_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
QIArgs* pArgs = (QIArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Unknown_QueryInterface_Internal(pArgs->pWrap, pArgs->pUnk, *pArgs->riid, pArgs->ppv);
}
else
{
AppDomainDoCallBack(pWrap, Unknown_QueryInterface_CallBack, pArgs, pArgs->hr);;
}
}
HRESULT __stdcall Unknown_QueryInterface(IUnknown* pUnk, REFIID riid, void** ppv)
{
SetupThreadForComCall(E_OUTOFMEMORY);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppv, NULL_OK));
}
CONTRACTL_END;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pUnk);
if (IsCurrentDomainValid(pWrap, GET_THREAD()))
{
return Unknown_QueryInterface_Internal(pWrap, pUnk, riid, ppv);
}
else
{
HRESULT hr = S_OK;
QIArgs args = {pWrap, pUnk, &riid, ppv, &hr};
Unknown_QueryInterface_CallBack(&args);
return hr;
}
}
struct AddRefReleaseArgs
{
IUnknown* pUnk;
ULONG* pLong;
HRESULT* hr;
};
ULONG __stdcall Unknown_AddRef(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked increment on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Allow addrefs to go through, coz we are allowing
// all releases to go through, otherwise we would
// have a mismatch of ref-counts
return Unknown_AddRef_Internal(pUnk);
}
ULONG __stdcall Unknown_Release(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked decrement on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_Release_Internal(pUnk);
}
ULONG __stdcall Unknown_AddRefInner(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked increment on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Allow addrefs to go through, coz we are allowing
// all releases to go through, otherwise we would
// have a mismatch of ref-counts
return Unknown_AddRefInner_Internal(pUnk);
}
ULONG __stdcall Unknown_ReleaseInner(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked decrement on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_ReleaseInner_Internal(pUnk);
}
ULONG __stdcall Unknown_AddRefSpecial(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked increment on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Allow addrefs to go through, coz we are allowing
// all releases to go through, otherwise we would
// have a mismatch of ref-counts
return Unknown_AddRefSpecial_Internal(pUnk);
}
ULONG __stdcall Unknown_ReleaseSpecial(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked decrement on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_ReleaseSpecial_Internal(pUnk);
}
HRESULT __stdcall Unknown_QueryInterface_IErrorInfo(IUnknown* pUnk, REFIID riid, void** ppv)
{
SetupForComCallHR();
WRAPPER_NO_CONTRACT;
// otherwise do a regular QI
return Unknown_QueryInterface(pUnk, riid, ppv);
}
// ---------------------------------------------------------------------------
// Release for IErrorInfo that takes into account that this can be called
// while holding the loader lock
// ---------------------------------------------------------------------------
ULONG __stdcall Unknown_ReleaseSpecial_IErrorInfo(IUnknown* pUnk)
{
SetupForComCallDWORD();
WRAPPER_NO_CONTRACT;
CONTRACT_VIOLATION(GCViolation);
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_ReleaseSpecial_IErrorInfo_Internal(pUnk);
}
//-------------------------------------------------------------------------
// IProvideClassInfo methods
struct GetClassInfoArgs
{
IUnknown* pUnk;
ITypeInfo** ppTI; //Address of output variable that receives the type info.
HRESULT* hr;
};
VOID __stdcall ClassInfo_GetClassInfo_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetClassInfoArgs* pArgs = (GetClassInfoArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ClassInfo_GetClassInfo(pArgs->pUnk, pArgs->ppTI);
}
else
{
AppDomainDoCallBack(pWrap, ClassInfo_GetClassInfo_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ClassInfo_GetClassInfo_Wrapper(IUnknown* pUnk, ITypeInfo** ppTI)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppTI, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetClassInfoArgs args = {pUnk, ppTI, &hr};
ClassInfo_GetClassInfo_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface ISupportsErrorInfo
struct IntfSupportsErrorInfoArgs
{
IUnknown* pUnk;
const IID* riid;
HRESULT* hr;
};
VOID __stdcall SupportsErroInfo_IntfSupportsErrorInfo_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
IntfSupportsErrorInfoArgs* pArgs = (IntfSupportsErrorInfoArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = SupportsErroInfo_IntfSupportsErrorInfo(pArgs->pUnk, *pArgs->riid);
}
else
{
AppDomainDoCallBack(pWrap, SupportsErroInfo_IntfSupportsErrorInfo_CallBack, pArgs, pArgs->hr);;
}
}
HRESULT __stdcall
SupportsErroInfo_IntfSupportsErrorInfo_Wrapper(IUnknown* pUnk, REFIID riid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
}
CONTRACTL_END;
HRESULT hr = S_OK;
IntfSupportsErrorInfoArgs args = {pUnk, &riid, &hr};
SupportsErroInfo_IntfSupportsErrorInfo_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IErrorInfo
struct GetDescriptionArgs
{
IUnknown* pUnk;
BSTR* pbstDescription;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetDescription_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetDescriptionArgs* pArgs = (GetDescriptionArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetDescription(pArgs->pUnk, pArgs->pbstDescription);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetDescription_CallBack, pArgs, pArgs->hr);;
}
}
HRESULT __stdcall ErrorInfo_GetDescription_Wrapper(IUnknown* pUnk, BSTR* pbstrDescription)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pbstrDescription, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetDescriptionArgs args = {pUnk, pbstrDescription, &hr};
ErrorInfo_GetDescription_CallBack(&args);
return hr;
}
struct GetGUIDArgs
{
IUnknown* pUnk;
GUID* pguid;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetGUID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetGUIDArgs* pArgs = (GetGUIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetGUID(pArgs->pUnk, pArgs->pguid);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetGUID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ErrorInfo_GetGUID_Wrapper(IUnknown* pUnk, GUID* pguid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pguid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetGUIDArgs args = {pUnk, pguid, &hr};
ErrorInfo_GetGUID_CallBack(&args);
return hr;
}
struct GetHelpContextArgs
{
IUnknown* pUnk;
DWORD* pdwHelpCtxt;
HRESULT* hr;
};
VOID _stdcall ErrorInfo_GetHelpContext_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetHelpContextArgs* pArgs = (GetHelpContextArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetHelpContext(pArgs->pUnk, pArgs->pdwHelpCtxt);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetHelpContext_CallBack, pArgs, pArgs->hr);
}
}
HRESULT _stdcall ErrorInfo_GetHelpContext_Wrapper(IUnknown* pUnk, DWORD* pdwHelpCtxt)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pdwHelpCtxt, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetHelpContextArgs args = {pUnk, pdwHelpCtxt, &hr};
ErrorInfo_GetHelpContext_CallBack(&args);
return hr;
}
struct GetHelpFileArgs
{
IUnknown* pUnk;
BSTR* pbstrHelpFile;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetHelpFile_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetHelpFileArgs* pArgs = (GetHelpFileArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetHelpFile(pArgs->pUnk, pArgs->pbstrHelpFile);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetHelpFile_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ErrorInfo_GetHelpFile_Wrapper(IUnknown* pUnk, BSTR* pbstrHelpFile)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pbstrHelpFile, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetHelpFileArgs args = {pUnk, pbstrHelpFile, &hr};
ErrorInfo_GetHelpFile_CallBack(&args);
return hr;
}
struct GetSourceArgs
{
IUnknown* pUnk;
BSTR* pbstrSource;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetSource_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetSourceArgs* pArgs = (GetSourceArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetSource(pArgs->pUnk, pArgs->pbstrSource);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetSource_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ErrorInfo_GetSource_Wrapper(IUnknown* pUnk, BSTR* pbstrSource)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pbstrSource, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetSourceArgs args = {pUnk, pbstrSource, &hr};
ErrorInfo_GetSource_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IDispatch
//
// IDispatch methods for COM+ objects. These methods dispatch's to the
// appropriate implementation based on the flags of the class that
// implements them.
struct GetTypeInfoCountArgs
{
IDispatch* pUnk;
unsigned int *pctinfo;
HRESULT* hr;
};
VOID __stdcall Dispatch_GetTypeInfoCount_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoCountArgs* pArgs = (GetTypeInfoCountArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_GetTypeInfoCount(pArgs->pUnk, pArgs->pctinfo);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_GetTypeInfoCount_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_GetTypeInfoCount_Wrapper(IDispatch* pDisp, unsigned int *pctinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pctinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoCountArgs args = {pDisp, pctinfo, &hr};
Dispatch_GetTypeInfoCount_CallBack(&args);
return hr;
}
struct GetTypeInfoArgs
{
IDispatch* pUnk;
unsigned int itinfo;
LCID lcid;
ITypeInfo **pptinfo;
HRESULT* hr;
};
VOID __stdcall Dispatch_GetTypeInfo_CallBack (LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoArgs* pArgs = (GetTypeInfoArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_GetTypeInfo(pArgs->pUnk, pArgs->itinfo, pArgs->lcid, pArgs->pptinfo);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_GetTypeInfo_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_GetTypeInfo_Wrapper(IDispatch* pDisp, unsigned int itinfo, LCID lcid, ITypeInfo **pptinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pptinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoArgs args = {pDisp, itinfo, lcid, pptinfo, &hr};
Dispatch_GetTypeInfo_CallBack(&args);
return hr;
}
struct GetIDsOfNamesArgs
{
IDispatch* pUnk;
const IID* riid;
OLECHAR **rgszNames;
unsigned int cNames;
LCID lcid;
DISPID *rgdispid;
HRESULT* hr;
};
VOID __stdcall Dispatch_GetIDsOfNames_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetIDsOfNamesArgs* pArgs = (GetIDsOfNamesArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_GetIDsOfNames(pArgs->pUnk, *pArgs->riid, pArgs->rgszNames,
pArgs->cNames, pArgs->lcid, pArgs->rgdispid);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_GetIDsOfNames_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_GetIDsOfNames_Wrapper(IDispatch* pDisp, REFIID riid, _In_reads_(cNames) OLECHAR **rgszNames,
unsigned int cNames, LCID lcid, DISPID *rgdispid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(rgszNames, NULL_OK));
PRECONDITION(CheckPointer(rgdispid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetIDsOfNamesArgs args = {pDisp, &riid, rgszNames, cNames, lcid, rgdispid, &hr};
Dispatch_GetIDsOfNames_CallBack(&args);
return hr;
}
VOID __stdcall InternalDispatchImpl_GetIDsOfNames_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetIDsOfNamesArgs* pArgs = (GetIDsOfNamesArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = InternalDispatchImpl_GetIDsOfNames(pArgs->pUnk, *pArgs->riid, pArgs->rgszNames,
pArgs->cNames, pArgs->lcid, pArgs->rgdispid);
}
else
{
AppDomainDoCallBack(pWrap, InternalDispatchImpl_GetIDsOfNames_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall InternalDispatchImpl_GetIDsOfNames_Wrapper(IDispatch* pDisp, REFIID riid, _In_reads_(cNames) OLECHAR **rgszNames,
unsigned int cNames, LCID lcid, DISPID *rgdispid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(rgszNames, NULL_OK));
PRECONDITION(CheckPointer(rgdispid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetIDsOfNamesArgs args = {pDisp, &riid, rgszNames, cNames, lcid, rgdispid, &hr};
InternalDispatchImpl_GetIDsOfNames_CallBack(&args);
return hr;
}
struct InvokeArgs
{
IDispatch* pUnk;
DISPID dispidMember;
const IID* riid;
LCID lcid;
unsigned short wFlags;
DISPPARAMS *pdispparams;
VARIANT *pvarResult;
EXCEPINFO *pexcepinfo;
unsigned int *puArgErr;
HRESULT* hr;
};
VOID __stdcall Dispatch_Invoke_CallBack(LPVOID ptr)
{
CONTRACTL
{
THROWS; // Dispatch_Invoke can throw
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
InvokeArgs* pArgs = (InvokeArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_Invoke(pArgs->pUnk, pArgs->dispidMember, *pArgs->riid,
pArgs->lcid, pArgs->wFlags, pArgs->pdispparams, pArgs->pvarResult,
pArgs->pexcepinfo, pArgs->puArgErr);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_Invoke_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_Invoke_Wrapper(IDispatch* pDisp, DISPID dispidMember, REFIID riid, LCID lcid, unsigned short wFlags,
DISPPARAMS *pdispparams, VARIANT *pvarResult, EXCEPINFO *pexcepinfo, unsigned int *puArgErr)
{
HRESULT hrRetVal = S_OK;
SetupForComCallHR();
CONTRACTL
{
THROWS; // Dispatch_Invoke_CallBack can throw
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdispparams, NULL_OK));
PRECONDITION(CheckPointer(pvarResult, NULL_OK));
PRECONDITION(CheckPointer(pexcepinfo, NULL_OK));
PRECONDITION(CheckPointer(puArgErr, NULL_OK));
}
CONTRACTL_END;
InvokeArgs args = {pDisp, dispidMember, &riid, lcid, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr, &hrRetVal};
Dispatch_Invoke_CallBack(&args);
return hrRetVal;
}
VOID __stdcall InternalDispatchImpl_Invoke_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
InvokeArgs* pArgs = (InvokeArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = InternalDispatchImpl_Invoke(pArgs->pUnk, pArgs->dispidMember, *pArgs->riid,
pArgs->lcid, pArgs->wFlags, pArgs->pdispparams, pArgs->pvarResult,
pArgs->pexcepinfo, pArgs->puArgErr);
}
else
{
AppDomainDoCallBack(pWrap, InternalDispatchImpl_Invoke_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall InternalDispatchImpl_Invoke_Wrapper(IDispatch* pDisp, DISPID dispidMember, REFIID riid, LCID lcid,
unsigned short wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult,
EXCEPINFO *pexcepinfo, unsigned int *puArgErr)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdispparams, NULL_OK));
PRECONDITION(CheckPointer(pvarResult, NULL_OK));
PRECONDITION(CheckPointer(pexcepinfo, NULL_OK));
PRECONDITION(CheckPointer(puArgErr, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
InvokeArgs args = {pDisp, dispidMember, &riid, lcid, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr, &hr};
InternalDispatchImpl_Invoke_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IDispatchEx
struct GetTypeInfoCountExArgs
{
IDispatchEx* pUnk;
unsigned int *pctinfo;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetTypeInfoCount_CallBack (LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoCountExArgs* pArgs = (GetTypeInfoCountExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetTypeInfoCount(pArgs->pUnk, pArgs->pctinfo);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetTypeInfoCount_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetTypeInfoCount_Wrapper(IDispatchEx* pDisp, unsigned int *pctinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pctinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoCountExArgs args = {pDisp, pctinfo, &hr};
DispatchEx_GetTypeInfoCount_CallBack(&args);
return hr;
}
struct GetTypeInfoExArgs
{
IDispatch* pUnk;
unsigned int itinfo;
LCID lcid;
ITypeInfo **pptinfo;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetTypeInfo_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoExArgs* pArgs = (GetTypeInfoExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetTypeInfo(pArgs->pUnk, pArgs->itinfo, pArgs->lcid, pArgs->pptinfo);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetTypeInfo_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetTypeInfo_Wrapper(IDispatchEx* pDisp, unsigned int itinfo, LCID lcid, ITypeInfo **pptinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pptinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoExArgs args = {pDisp, itinfo, lcid, pptinfo, &hr};
DispatchEx_GetTypeInfo_CallBack(&args);
return hr;
}
struct GetIDsOfNamesExArgs
{
IDispatchEx* pUnk;
const IID* riid;
OLECHAR **rgszNames;
unsigned int cNames;
LCID lcid;
DISPID *rgdispid;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetIDsOfNames_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetIDsOfNamesExArgs* pArgs = (GetIDsOfNamesExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetIDsOfNames(pArgs->pUnk, *pArgs->riid, pArgs->rgszNames,
pArgs->cNames, pArgs->lcid, pArgs->rgdispid);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetIDsOfNames_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetIDsOfNames_Wrapper(IDispatchEx* pDisp, REFIID riid, _In_reads_(cNames) OLECHAR **rgszNames,
unsigned int cNames, LCID lcid, DISPID *rgdispid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(rgszNames, NULL_OK));
PRECONDITION(CheckPointer(rgdispid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetIDsOfNamesExArgs args = {pDisp, &riid, rgszNames, cNames, lcid, rgdispid, &hr};
DispatchEx_GetIDsOfNames_CallBack(&args);
return hr;
}
struct DispExInvokeArgs
{
IDispatchEx* pUnk;
DISPID dispidMember;
const IID* riid;
LCID lcid;
unsigned short wFlags;
DISPPARAMS *pdispparams;
VARIANT *pvarResult;
EXCEPINFO *pexcepinfo;
unsigned int *puArgErr;
HRESULT* hr;
};
VOID __stdcall DispatchEx_Invoke_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DispExInvokeArgs* pArgs = (DispExInvokeArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_Invoke(pArgs->pUnk, pArgs->dispidMember, *pArgs->riid,
pArgs->lcid, pArgs->wFlags, pArgs->pdispparams, pArgs->pvarResult,
pArgs->pexcepinfo, pArgs->puArgErr);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_Invoke_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_Invoke_Wrapper(IDispatchEx* pDisp, DISPID dispidMember, REFIID riid, LCID lcid,
unsigned short wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult,
EXCEPINFO *pexcepinfo, unsigned int *puArgErr)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdispparams, NULL_OK));
PRECONDITION(CheckPointer(pvarResult, NULL_OK));
PRECONDITION(CheckPointer(pexcepinfo, NULL_OK));
PRECONDITION(CheckPointer(puArgErr, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DispExInvokeArgs args = {pDisp, dispidMember, &riid, lcid, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr, &hr};
DispatchEx_Invoke_CallBack(&args);
return hr;
}
struct DeleteMemberByDispIDArgs
{
IDispatchEx* pDisp;
DISPID id;
HRESULT* hr;
};
VOID __stdcall DispatchEx_DeleteMemberByDispID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DeleteMemberByDispIDArgs* pArgs = (DeleteMemberByDispIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_DeleteMemberByDispID(pArgs->pDisp, pArgs->id);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_DeleteMemberByDispID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_DeleteMemberByDispID_Wrapper(IDispatchEx* pDisp, DISPID id)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DeleteMemberByDispIDArgs args = {pDisp, id, &hr};
DispatchEx_DeleteMemberByDispID_CallBack(&args);
return hr;
}
struct DeleteMemberByNameArgs
{
IDispatchEx* pDisp;
BSTR bstrName;
DWORD grfdex;
HRESULT* hr;
};
VOID __stdcall DispatchEx_DeleteMemberByName_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DeleteMemberByNameArgs* pArgs = (DeleteMemberByNameArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_DeleteMemberByName(pArgs->pDisp, pArgs->bstrName, pArgs->grfdex);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_DeleteMemberByName_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_DeleteMemberByName_Wrapper(IDispatchEx* pDisp, BSTR bstrName, DWORD grfdex)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DeleteMemberByNameArgs args = {pDisp, bstrName, grfdex, &hr};
DispatchEx_DeleteMemberByName_CallBack(&args);
return hr;
}
struct GetMemberNameArgs
{
IDispatchEx* pDisp;
DISPID id;
BSTR *pbstrName;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetMemberName_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetMemberNameArgs* pArgs = (GetMemberNameArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetMemberName(pArgs->pDisp, pArgs->id, pArgs->pbstrName);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetMemberName_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetMemberName_Wrapper(IDispatchEx* pDisp, DISPID id, BSTR *pbstrName)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pbstrName, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetMemberNameArgs args = {pDisp, id, pbstrName, &hr};
DispatchEx_GetMemberName_CallBack(&args);
return hr;
}
struct GetDispIDArgs
{
IDispatchEx* pDisp;
BSTR bstrName;
DWORD grfdex;
DISPID *pid;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetDispID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetDispIDArgs* pArgs = (GetDispIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetDispID(pArgs->pDisp, pArgs->bstrName, pArgs->grfdex, pArgs->pid);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetDispID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetDispID_Wrapper(IDispatchEx* pDisp, BSTR bstrName, DWORD grfdex, DISPID *pid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetDispIDArgs args = {pDisp, bstrName, grfdex, pid, &hr};
DispatchEx_GetDispID_CallBack(&args);
return hr;
}
struct GetMemberPropertiesArgs
{
IDispatchEx* pDisp;
DISPID id;
DWORD grfdexFetch;
DWORD *pgrfdex;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetMemberProperties_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetMemberPropertiesArgs* pArgs = (GetMemberPropertiesArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetMemberProperties(pArgs->pDisp, pArgs->id, pArgs->grfdexFetch,
pArgs->pgrfdex);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetMemberProperties_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetMemberProperties_Wrapper(IDispatchEx* pDisp, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pgrfdex, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetMemberPropertiesArgs args = {pDisp, id, grfdexFetch, pgrfdex, &hr};
DispatchEx_GetMemberProperties_CallBack(&args);
return hr;
}
struct GetNameSpaceParentArgs
{
IDispatchEx* pDisp;
IUnknown **ppunk;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetNameSpaceParent_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetNameSpaceParentArgs* pArgs = (GetNameSpaceParentArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetNameSpaceParent(pArgs->pDisp, pArgs->ppunk);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetNameSpaceParent_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetNameSpaceParent_Wrapper(IDispatchEx* pDisp, IUnknown **ppunk)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(ppunk, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetNameSpaceParentArgs args = {pDisp, ppunk, &hr};
DispatchEx_GetNameSpaceParent_CallBack(&args);
return hr;
}
struct GetNextDispIDArgs
{
IDispatchEx* pDisp;
DWORD grfdex;
DISPID id;
DISPID *pid;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetNextDispID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetNextDispIDArgs* pArgs = (GetNextDispIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetNextDispID(pArgs->pDisp, pArgs->grfdex, pArgs->id, pArgs->pid);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetNextDispID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetNextDispID_Wrapper(IDispatchEx* pDisp, DWORD grfdex, DISPID id, DISPID *pid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetNextDispIDArgs args = {pDisp, grfdex, id, pid, &hr};
DispatchEx_GetNextDispID_CallBack(&args);
return hr;
}
struct DispExInvokeExArgs
{
IDispatchEx* pDisp;
DISPID id;
LCID lcid;
WORD wFlags;
DISPPARAMS *pdp;
VARIANT *pVarRes;
EXCEPINFO *pei;
IServiceProvider *pspCaller;
HRESULT* hr;
};
VOID __stdcall DispatchEx_InvokeEx_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DispExInvokeExArgs* pArgs = (DispExInvokeExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_InvokeEx(pArgs->pDisp, pArgs->id,
pArgs->lcid, pArgs->wFlags, pArgs->pdp, pArgs->pVarRes,
pArgs->pei, pArgs->pspCaller);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_InvokeEx_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_InvokeEx_Wrapper(IDispatchEx* pDisp, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pVarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdp, NULL_OK));
PRECONDITION(CheckPointer(pVarRes, NULL_OK));
PRECONDITION(CheckPointer(pei, NULL_OK));
PRECONDITION(CheckPointer(pspCaller, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DispExInvokeExArgs args = {pDisp, id, lcid, wFlags, pdp, pVarRes, pei, pspCaller, &hr};
DispatchEx_InvokeEx_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IMarshal
struct GetUnmarshalClassArgs
{
IMarshal* pUnk;
const IID* riid;
void * pv;
ULONG dwDestContext;
void * pvDestContext;
ULONG mshlflags;
LPCLSID pclsid;
HRESULT* hr;
};
VOID __stdcall Marshal_GetUnmarshalClass_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetUnmarshalClassArgs* pArgs = (GetUnmarshalClassArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_GetUnmarshalClass(pArgs->pUnk, *(pArgs->riid), pArgs->pv,
pArgs->dwDestContext, pArgs->pvDestContext, pArgs->mshlflags,
pArgs->pclsid);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_GetUnmarshalClass_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_GetUnmarshalClass_Wrapper(IMarshal* pMarsh, REFIID riid, void * pv, ULONG dwDestContext,
void * pvDestContext, ULONG mshlflags, LPCLSID pclsid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pv, NULL_OK));
PRECONDITION(CheckPointer(pvDestContext, NULL_OK));
PRECONDITION(CheckPointer(pclsid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetUnmarshalClassArgs args = {pMarsh, &riid, pv, dwDestContext, pvDestContext,
mshlflags, pclsid, &hr};
Marshal_GetUnmarshalClass_CallBack(&args);
return hr;
}
struct GetMarshalSizeMaxArgs
{
IMarshal* pUnk;
const IID* riid;
void * pv;
ULONG dwDestContext;
void * pvDestContext;
ULONG mshlflags;
ULONG * pSize;
HRESULT* hr;
};
VOID __stdcall Marshal_GetMarshalSizeMax_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetMarshalSizeMaxArgs* pArgs = (GetMarshalSizeMaxArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_GetMarshalSizeMax(pArgs->pUnk, *(pArgs->riid), pArgs->pv,
pArgs->dwDestContext, pArgs->pvDestContext, pArgs->mshlflags,
pArgs->pSize);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_GetMarshalSizeMax_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_GetMarshalSizeMax_Wrapper(IMarshal* pMarsh, REFIID riid, void * pv, ULONG dwDestContext,
void * pvDestContext, ULONG mshlflags, ULONG * pSize)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pv, NULL_OK));
PRECONDITION(CheckPointer(pvDestContext, NULL_OK));
PRECONDITION(CheckPointer(pSize, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetMarshalSizeMaxArgs args = {pMarsh, &riid, pv, dwDestContext, pvDestContext,
mshlflags, pSize, &hr};
Marshal_GetMarshalSizeMax_CallBack(&args);
return hr;
}
struct MarshalInterfaceArgs
{
IMarshal* pUnk;
LPSTREAM pStm;
const IID* riid;
void * pv;
ULONG dwDestContext;
void * pvDestContext;
ULONG mshlflags;
HRESULT* hr;
};
VOID __stdcall Marshal_MarshalInterface_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
MarshalInterfaceArgs* pArgs = (MarshalInterfaceArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_MarshalInterface(pArgs->pUnk, pArgs->pStm, *(pArgs->riid), pArgs->pv,
pArgs->dwDestContext, pArgs->pvDestContext, pArgs->mshlflags);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_MarshalInterface_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_MarshalInterface_Wrapper(IMarshal* pMarsh, LPSTREAM pStm, REFIID riid, void * pv,
ULONG dwDestContext, LPVOID pvDestContext, ULONG mshlflags)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pv, NULL_OK));
PRECONDITION(CheckPointer(pvDestContext, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
MarshalInterfaceArgs args = {pMarsh, pStm, &riid, pv, dwDestContext, pvDestContext,
mshlflags, &hr};
Marshal_MarshalInterface_CallBack(&args);
return hr;
}
struct UnmarshalInterfaceArgs
{
IMarshal* pUnk;
LPSTREAM pStm;
const IID* riid;
void ** ppvObj;
HRESULT* hr;
};
VOID __stdcall Marshal_UnmarshalInterface_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
UnmarshalInterfaceArgs* pArgs = (UnmarshalInterfaceArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_UnmarshalInterface(pArgs->pUnk, pArgs->pStm, *(pArgs->riid), pArgs->ppvObj);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_UnmarshalInterface_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_UnmarshalInterface_Wrapper(IMarshal* pMarsh, LPSTREAM pStm, REFIID riid, void ** ppvObj)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pStm, NULL_OK));
PRECONDITION(CheckPointer(ppvObj, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
UnmarshalInterfaceArgs args = {pMarsh, pStm, &riid, ppvObj, &hr};
Marshal_UnmarshalInterface_CallBack(&args);
return hr;
}
struct ReleaseMarshalDataArgs
{
IMarshal* pUnk;
LPSTREAM pStm;
HRESULT* hr;
};
VOID __stdcall Marshal_ReleaseMarshalData_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
ReleaseMarshalDataArgs* pArgs = (ReleaseMarshalDataArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_ReleaseMarshalData(pArgs->pUnk, pArgs->pStm);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_ReleaseMarshalData_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_ReleaseMarshalData_Wrapper(IMarshal* pMarsh, LPSTREAM pStm)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pStm, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
ReleaseMarshalDataArgs args = {pMarsh, pStm, &hr};
Marshal_ReleaseMarshalData_CallBack(&args);
return hr;
}
struct DisconnectObjectArgs
{
IMarshal* pUnk;
ULONG dwReserved;
HRESULT* hr;
};
VOID __stdcall Marshal_DisconnectObject_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DisconnectObjectArgs* pArgs = (DisconnectObjectArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_DisconnectObject(pArgs->pUnk, pArgs->dwReserved);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_DisconnectObject_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_DisconnectObject_Wrapper(IMarshal* pMarsh, ULONG dwReserved)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DisconnectObjectArgs args = {pMarsh, dwReserved, &hr};
Marshal_DisconnectObject_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IConnectionPointContainer
struct EnumConnectionPointsArgs
{
IUnknown* pUnk;
IEnumConnectionPoints **ppEnum;
HRESULT* hr;
};
VOID __stdcall ConnectionPointContainer_EnumConnectionPoints_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
EnumConnectionPointsArgs* pArgs = (EnumConnectionPointsArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ConnectionPointContainer_EnumConnectionPoints(pArgs->pUnk, pArgs->ppEnum);
}
else
{
AppDomainDoCallBack(pWrap, ConnectionPointContainer_EnumConnectionPoints_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ConnectionPointContainer_EnumConnectionPoints_Wrapper(IUnknown* pUnk, IEnumConnectionPoints **ppEnum)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppEnum, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
EnumConnectionPointsArgs args = {pUnk, ppEnum, &hr};
ConnectionPointContainer_EnumConnectionPoints_CallBack(&args);
return hr;
}
struct FindConnectionPointArgs
{
IUnknown* pUnk;
const IID* riid;
IConnectionPoint **ppCP;
HRESULT* hr;
};
VOID __stdcall ConnectionPointContainer_FindConnectionPoint_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
FindConnectionPointArgs* pArgs = (FindConnectionPointArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ConnectionPointContainer_FindConnectionPoint(pArgs->pUnk, *(pArgs->riid),
pArgs->ppCP);
}
else
{
AppDomainDoCallBack(pWrap, ConnectionPointContainer_FindConnectionPoint_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ConnectionPointContainer_FindConnectionPoint_Wrapper(IUnknown* pUnk, REFIID riid, IConnectionPoint **ppCP)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppCP, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
FindConnectionPointArgs args = {pUnk, &riid, ppCP, &hr};
ConnectionPointContainer_FindConnectionPoint_CallBack(&args);
return hr;
}
//------------------------------------------------------------------------------------------
// IObjectSafety methods for COM+ objects
struct GetInterfaceSafetyArgs
{
IUnknown* pUnk;
const IID* riid;
DWORD *pdwSupportedOptions;
DWORD *pdwEnabledOptions;
HRESULT* hr;
};
VOID __stdcall ObjectSafety_GetInterfaceSafetyOptions_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetInterfaceSafetyArgs* pArgs = (GetInterfaceSafetyArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ObjectSafety_GetInterfaceSafetyOptions(pArgs->pUnk, *(pArgs->riid),
pArgs->pdwSupportedOptions,
pArgs->pdwEnabledOptions);
}
else
{
AppDomainDoCallBack(pWrap, ObjectSafety_GetInterfaceSafetyOptions_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ObjectSafety_GetInterfaceSafetyOptions_Wrapper(IUnknown* pUnk, REFIID riid,
DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pdwSupportedOptions, NULL_OK));
PRECONDITION(CheckPointer(pdwEnabledOptions, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetInterfaceSafetyArgs args = {pUnk, &riid, pdwSupportedOptions, pdwEnabledOptions, &hr};
ObjectSafety_GetInterfaceSafetyOptions_CallBack(&args);
return hr;
}
struct SetInterfaceSafetyArgs
{
IUnknown* pUnk;
const IID* riid;
DWORD dwOptionSetMask;
DWORD dwEnabledOptions;
HRESULT* hr;
};
VOID __stdcall ObjectSafety_SetInterfaceSafetyOptions_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
SetInterfaceSafetyArgs* pArgs = (SetInterfaceSafetyArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ObjectSafety_SetInterfaceSafetyOptions(pArgs->pUnk, *(pArgs->riid),
pArgs->dwOptionSetMask,
pArgs->dwEnabledOptions
);
}
else
{
AppDomainDoCallBack(pWrap, ObjectSafety_SetInterfaceSafetyOptions_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ObjectSafety_SetInterfaceSafetyOptions_Wrapper(IUnknown* pUnk, REFIID riid,
DWORD dwOptionSetMask, DWORD dwEnabledOptions)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
}
CONTRACTL_END;
HRESULT hr = S_OK;
SetInterfaceSafetyArgs args = {pUnk, &riid, dwOptionSetMask, dwEnabledOptions, &hr};
ObjectSafety_SetInterfaceSafetyOptions_CallBack(&args);
return hr;
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//---------------------------------------------------------------------------------
// stdinterfaces_wrapper.cpp
//
// Defines various standard com interfaces
//---------------------------------------------------------------------------------
#include "common.h"
#include <ole2.h>
#include <guidfromname.h>
#include <olectl.h>
#include <objsafe.h> // IID_IObjectSafe
#include "vars.hpp"
#include "object.h"
#include "excep.h"
#include "frames.h"
#include "vars.hpp"
#include "runtimecallablewrapper.h"
#include "comcallablewrapper.h"
#include "field.h"
#include "threads.h"
#include "interoputil.h"
#include "comdelegate.h"
#include "olevariant.h"
#include "eeconfig.h"
#include "typehandle.h"
#include "posterror.h"
#include <corerror.h>
#include <mscoree.h>
#include "mtx.h"
#include "cgencpu.h"
#include "interopconverter.h"
#include "cominterfacemarshaler.h"
#include "stdinterfaces.h"
#include "stdinterfaces_internal.h"
#include "interoputil.inl"
interface IEnumConnectionPoints;
// IUnknown is part of IDispatch
// Common vtables for well-known COM interfaces
// shared by all COM+ callable wrappers.
// All Com+ created vtables have well known IUnknown methods, which is used to identify
// the type of the interface
// For e.g. all com+ created tear-offs have the same QI method in their IUnknown portion
// Unknown_QueryInterface is the QI method for all the tear-offs created from COM+
//
// Tearoff interfaces created for std. interfaces such as IProvideClassInfo, IErrorInfo etc.
// have the AddRef & Release function point to Unknown_AddRefSpecial & Unknown_ReleaseSpecial
//
// Inner unknown, or the original unknown for a wrapper has
// AddRef & Release point to a Unknown_AddRefInner & Unknown_ReleaseInner
// global inner Unknown vtable
const StdInterfaceDesc<3> g_InnerUnknown =
{
enum_InnerUnknown,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefInner, // special addref to distinguish inner unk
(UINT_PTR*)Unknown_ReleaseInner, // special release to distinguish inner unknown
}
};
// global IProvideClassInfo vtable
const StdInterfaceDesc<4> g_IProvideClassInfo =
{
enum_IProvideClassInfo,
{
(UINT_PTR*)Unknown_QueryInterface, // don't change this
(UINT_PTR*)Unknown_AddRefSpecial, // special addref for std. interface
(UINT_PTR*)Unknown_ReleaseSpecial, // special release for std. interface
(UINT_PTR*)ClassInfo_GetClassInfo_Wrapper // GetClassInfo
}
};
// global IMarshal vtable
const StdInterfaceDesc<9> g_IMarshal =
{
enum_IMarshal,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)Marshal_GetUnmarshalClass_Wrapper,
(UINT_PTR*)Marshal_GetMarshalSizeMax_Wrapper,
(UINT_PTR*)Marshal_MarshalInterface_Wrapper,
(UINT_PTR*)Marshal_UnmarshalInterface_Wrapper,
(UINT_PTR*)Marshal_ReleaseMarshalData_Wrapper,
(UINT_PTR*)Marshal_DisconnectObject_Wrapper
}
};
// global ISupportsErrorInfo vtable
const StdInterfaceDesc<4> g_ISupportsErrorInfo =
{
enum_ISupportsErrorInfo,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)SupportsErroInfo_IntfSupportsErrorInfo_Wrapper
}
};
// global IErrorInfo vtable
const StdInterfaceDesc<8> g_IErrorInfo =
{
enum_IErrorInfo,
{
(UINT_PTR*)Unknown_QueryInterface_IErrorInfo,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial_IErrorInfo,
(UINT_PTR*)ErrorInfo_GetGUID_Wrapper,
(UINT_PTR*)ErrorInfo_GetSource_Wrapper,
(UINT_PTR*)ErrorInfo_GetDescription_Wrapper,
(UINT_PTR*)ErrorInfo_GetHelpFile_Wrapper,
(UINT_PTR*)ErrorInfo_GetHelpContext_Wrapper
}
};
// global IConnectionPointContainer vtable
const StdInterfaceDesc<5> g_IConnectionPointContainer =
{
enum_IConnectionPointContainer,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)ConnectionPointContainer_EnumConnectionPoints_Wrapper,
(UINT_PTR*)ConnectionPointContainer_FindConnectionPoint_Wrapper
}
};
// global IObjectSafety vtable
const StdInterfaceDesc<5> g_IObjectSafety =
{
enum_IObjectSafety,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)ObjectSafety_GetInterfaceSafetyOptions_Wrapper,
(UINT_PTR*)ObjectSafety_SetInterfaceSafetyOptions_Wrapper
}
};
// global IDispatchEx vtable
const StdInterfaceDesc<15> g_IDispatchEx =
{
enum_IDispatchEx,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial,
(UINT_PTR*)DispatchEx_GetTypeInfoCount_Wrapper,
(UINT_PTR*)DispatchEx_GetTypeInfo_Wrapper,
(UINT_PTR*)DispatchEx_GetIDsOfNames_Wrapper,
(UINT_PTR*)DispatchEx_Invoke_Wrapper,
(UINT_PTR*)DispatchEx_GetDispID_Wrapper,
(UINT_PTR*)DispatchEx_InvokeEx_Wrapper,
(UINT_PTR*)DispatchEx_DeleteMemberByName_Wrapper,
(UINT_PTR*)DispatchEx_DeleteMemberByDispID_Wrapper,
(UINT_PTR*)DispatchEx_GetMemberProperties_Wrapper,
(UINT_PTR*)DispatchEx_GetMemberName_Wrapper,
(UINT_PTR*)DispatchEx_GetNextDispID_Wrapper,
(UINT_PTR*)DispatchEx_GetNameSpaceParent_Wrapper
}
};
// global IAgileObject vtable
const StdInterfaceDesc<3> g_IAgileObject =
{
enum_IAgileObject,
{
(UINT_PTR*)Unknown_QueryInterface,
(UINT_PTR*)Unknown_AddRefSpecial,
(UINT_PTR*)Unknown_ReleaseSpecial
}
};
// Generic helper to check if AppDomain matches and perform a DoCallBack otherwise
inline BOOL IsCurrentDomainValid(ComCallWrapper* pWrap, Thread* pThread)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_ANY;
PRECONDITION(CheckPointer(pWrap));
PRECONDITION(CheckPointer(pThread));
}
CONTRACTL_END;
_ASSERTE(pWrap != NULL);
PREFIX_ASSUME(pWrap != NULL);
// If we are finalizing all alive objects, or after this stage, we do not allow
// a thread to enter EE.
if ((g_fEEShutDown & ShutDown_Finalize2) || g_fForbidEnterEE)
return FALSE;
return TRUE;
}
BOOL IsCurrentDomainValid(ComCallWrapper* pWrap)
{
CONTRACTL { NOTHROW; GC_TRIGGERS; MODE_ANY; } CONTRACTL_END;
return IsCurrentDomainValid(pWrap, GetThread());
}
struct AppDomainSwitchToPreemptiveHelperArgs
{
ADCallBackFcnType pRealCallback;
void* pRealArgs;
};
VOID __stdcall AppDomainSwitchToPreemptiveHelper(LPVOID pv)
{
AppDomainSwitchToPreemptiveHelperArgs* pArgs = (AppDomainSwitchToPreemptiveHelperArgs*)pv;
CONTRACTL
{
GC_TRIGGERS;
MODE_ANY;
PRECONDITION(CheckPointer(pv));
VOID __stdcall Dispatch_Invoke_CallBack(LPVOID ptr);
if (pArgs->pRealCallback == Dispatch_Invoke_CallBack) THROWS; else NOTHROW;
}
CONTRACTL_END;
GCX_PREEMP();
pArgs->pRealCallback(pArgs->pRealArgs);
}
VOID AppDomainDoCallBack(ComCallWrapper* pWrap, ADCallBackFcnType pTarget, LPVOID pArgs, HRESULT* phr)
{
CONTRACTL
{
DISABLED(NOTHROW);
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pWrap));
PRECONDITION(CheckPointer(pTarget));
PRECONDITION(CheckPointer(pArgs));
PRECONDITION(CheckPointer(phr));
}
CONTRACTL_END;
// If we are finalizing all alive objects, or after this stage, we do not allow
// a thread to enter EE.
if ((g_fEEShutDown & ShutDown_Finalize2) || g_fForbidEnterEE)
{
*phr = E_FAIL;
return;
}
BEGIN_EXTERNAL_ENTRYPOINT(phr)
{
// make the call directly not forgetting to switch to preemptive GC mode
GCX_PREEMP();
((ADCallBackFcnType)pTarget)(pArgs);
}
END_EXTERNAL_ENTRYPOINT;
}
//-------------------------------------------------------------------------
// IUnknown methods
struct QIArgs
{
ComCallWrapper* pWrap;
IUnknown* pUnk;
const IID* riid;
void** ppv;
HRESULT* hr;
};
VOID __stdcall Unknown_QueryInterface_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
QIArgs* pArgs = (QIArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Unknown_QueryInterface_Internal(pArgs->pWrap, pArgs->pUnk, *pArgs->riid, pArgs->ppv);
}
else
{
AppDomainDoCallBack(pWrap, Unknown_QueryInterface_CallBack, pArgs, pArgs->hr);;
}
}
HRESULT __stdcall Unknown_QueryInterface(IUnknown* pUnk, REFIID riid, void** ppv)
{
SetupThreadForComCall(E_OUTOFMEMORY);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppv, NULL_OK));
}
CONTRACTL_END;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pUnk);
if (IsCurrentDomainValid(pWrap, GET_THREAD()))
{
return Unknown_QueryInterface_Internal(pWrap, pUnk, riid, ppv);
}
else
{
HRESULT hr = S_OK;
QIArgs args = {pWrap, pUnk, &riid, ppv, &hr};
Unknown_QueryInterface_CallBack(&args);
return hr;
}
}
struct AddRefReleaseArgs
{
IUnknown* pUnk;
ULONG* pLong;
HRESULT* hr;
};
ULONG __stdcall Unknown_AddRef(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked increment on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Allow addrefs to go through, coz we are allowing
// all releases to go through, otherwise we would
// have a mismatch of ref-counts
return Unknown_AddRef_Internal(pUnk);
}
ULONG __stdcall Unknown_Release(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked decrement on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_Release_Internal(pUnk);
}
ULONG __stdcall Unknown_AddRefInner(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked increment on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Allow addrefs to go through, coz we are allowing
// all releases to go through, otherwise we would
// have a mismatch of ref-counts
return Unknown_AddRefInner_Internal(pUnk);
}
ULONG __stdcall Unknown_ReleaseInner(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked decrement on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_ReleaseInner_Internal(pUnk);
}
ULONG __stdcall Unknown_AddRefSpecial(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked increment on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Allow addrefs to go through, coz we are allowing
// all releases to go through, otherwise we would
// have a mismatch of ref-counts
return Unknown_AddRefSpecial_Internal(pUnk);
}
ULONG __stdcall Unknown_ReleaseSpecial(IUnknown* pUnk)
{
// Ensure the Thread is available for contracts and other users of the Thread, but don't do any of
// the other "entering managed code" work like checking for reentrancy.
// We don't really need to "enter" the runtime to do an interlocked decrement on a refcount, so
// all of that stuff should be isolated to rare paths here.
SetupThreadForComCall(-1);
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
ENTRY_POINT;
}
CONTRACTL_END;
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_ReleaseSpecial_Internal(pUnk);
}
HRESULT __stdcall Unknown_QueryInterface_IErrorInfo(IUnknown* pUnk, REFIID riid, void** ppv)
{
SetupForComCallHR();
WRAPPER_NO_CONTRACT;
// otherwise do a regular QI
return Unknown_QueryInterface(pUnk, riid, ppv);
}
// ---------------------------------------------------------------------------
// Release for IErrorInfo that takes into account that this can be called
// while holding the loader lock
// ---------------------------------------------------------------------------
ULONG __stdcall Unknown_ReleaseSpecial_IErrorInfo(IUnknown* pUnk)
{
SetupForComCallDWORD();
WRAPPER_NO_CONTRACT;
CONTRACT_VIOLATION(GCViolation);
// Don't switch domains since we need to allow release calls to go through
// even after the AD has been unlaoded. Furthermore release doesn't require
// us to transition into the domain to work properly.
return Unknown_ReleaseSpecial_IErrorInfo_Internal(pUnk);
}
//-------------------------------------------------------------------------
// IProvideClassInfo methods
struct GetClassInfoArgs
{
IUnknown* pUnk;
ITypeInfo** ppTI; //Address of output variable that receives the type info.
HRESULT* hr;
};
VOID __stdcall ClassInfo_GetClassInfo_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetClassInfoArgs* pArgs = (GetClassInfoArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ClassInfo_GetClassInfo(pArgs->pUnk, pArgs->ppTI);
}
else
{
AppDomainDoCallBack(pWrap, ClassInfo_GetClassInfo_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ClassInfo_GetClassInfo_Wrapper(IUnknown* pUnk, ITypeInfo** ppTI)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppTI, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetClassInfoArgs args = {pUnk, ppTI, &hr};
ClassInfo_GetClassInfo_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface ISupportsErrorInfo
struct IntfSupportsErrorInfoArgs
{
IUnknown* pUnk;
const IID* riid;
HRESULT* hr;
};
VOID __stdcall SupportsErroInfo_IntfSupportsErrorInfo_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
IntfSupportsErrorInfoArgs* pArgs = (IntfSupportsErrorInfoArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = SupportsErroInfo_IntfSupportsErrorInfo(pArgs->pUnk, *pArgs->riid);
}
else
{
AppDomainDoCallBack(pWrap, SupportsErroInfo_IntfSupportsErrorInfo_CallBack, pArgs, pArgs->hr);;
}
}
HRESULT __stdcall
SupportsErroInfo_IntfSupportsErrorInfo_Wrapper(IUnknown* pUnk, REFIID riid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
}
CONTRACTL_END;
HRESULT hr = S_OK;
IntfSupportsErrorInfoArgs args = {pUnk, &riid, &hr};
SupportsErroInfo_IntfSupportsErrorInfo_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IErrorInfo
struct GetDescriptionArgs
{
IUnknown* pUnk;
BSTR* pbstDescription;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetDescription_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetDescriptionArgs* pArgs = (GetDescriptionArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetDescription(pArgs->pUnk, pArgs->pbstDescription);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetDescription_CallBack, pArgs, pArgs->hr);;
}
}
HRESULT __stdcall ErrorInfo_GetDescription_Wrapper(IUnknown* pUnk, BSTR* pbstrDescription)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pbstrDescription, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetDescriptionArgs args = {pUnk, pbstrDescription, &hr};
ErrorInfo_GetDescription_CallBack(&args);
return hr;
}
struct GetGUIDArgs
{
IUnknown* pUnk;
GUID* pguid;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetGUID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetGUIDArgs* pArgs = (GetGUIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetGUID(pArgs->pUnk, pArgs->pguid);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetGUID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ErrorInfo_GetGUID_Wrapper(IUnknown* pUnk, GUID* pguid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pguid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetGUIDArgs args = {pUnk, pguid, &hr};
ErrorInfo_GetGUID_CallBack(&args);
return hr;
}
struct GetHelpContextArgs
{
IUnknown* pUnk;
DWORD* pdwHelpCtxt;
HRESULT* hr;
};
VOID _stdcall ErrorInfo_GetHelpContext_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetHelpContextArgs* pArgs = (GetHelpContextArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetHelpContext(pArgs->pUnk, pArgs->pdwHelpCtxt);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetHelpContext_CallBack, pArgs, pArgs->hr);
}
}
HRESULT _stdcall ErrorInfo_GetHelpContext_Wrapper(IUnknown* pUnk, DWORD* pdwHelpCtxt)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pdwHelpCtxt, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetHelpContextArgs args = {pUnk, pdwHelpCtxt, &hr};
ErrorInfo_GetHelpContext_CallBack(&args);
return hr;
}
struct GetHelpFileArgs
{
IUnknown* pUnk;
BSTR* pbstrHelpFile;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetHelpFile_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetHelpFileArgs* pArgs = (GetHelpFileArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetHelpFile(pArgs->pUnk, pArgs->pbstrHelpFile);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetHelpFile_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ErrorInfo_GetHelpFile_Wrapper(IUnknown* pUnk, BSTR* pbstrHelpFile)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pbstrHelpFile, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetHelpFileArgs args = {pUnk, pbstrHelpFile, &hr};
ErrorInfo_GetHelpFile_CallBack(&args);
return hr;
}
struct GetSourceArgs
{
IUnknown* pUnk;
BSTR* pbstrSource;
HRESULT* hr;
};
VOID __stdcall ErrorInfo_GetSource_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetSourceArgs* pArgs = (GetSourceArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ErrorInfo_GetSource(pArgs->pUnk, pArgs->pbstrSource);
}
else
{
AppDomainDoCallBack(pWrap, ErrorInfo_GetSource_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ErrorInfo_GetSource_Wrapper(IUnknown* pUnk, BSTR* pbstrSource)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pbstrSource, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetSourceArgs args = {pUnk, pbstrSource, &hr};
ErrorInfo_GetSource_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IDispatch
//
// IDispatch methods for COM+ objects. These methods dispatch's to the
// appropriate implementation based on the flags of the class that
// implements them.
struct GetTypeInfoCountArgs
{
IDispatch* pUnk;
unsigned int *pctinfo;
HRESULT* hr;
};
VOID __stdcall Dispatch_GetTypeInfoCount_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoCountArgs* pArgs = (GetTypeInfoCountArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_GetTypeInfoCount(pArgs->pUnk, pArgs->pctinfo);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_GetTypeInfoCount_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_GetTypeInfoCount_Wrapper(IDispatch* pDisp, unsigned int *pctinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pctinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoCountArgs args = {pDisp, pctinfo, &hr};
Dispatch_GetTypeInfoCount_CallBack(&args);
return hr;
}
struct GetTypeInfoArgs
{
IDispatch* pUnk;
unsigned int itinfo;
LCID lcid;
ITypeInfo **pptinfo;
HRESULT* hr;
};
VOID __stdcall Dispatch_GetTypeInfo_CallBack (LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoArgs* pArgs = (GetTypeInfoArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_GetTypeInfo(pArgs->pUnk, pArgs->itinfo, pArgs->lcid, pArgs->pptinfo);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_GetTypeInfo_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_GetTypeInfo_Wrapper(IDispatch* pDisp, unsigned int itinfo, LCID lcid, ITypeInfo **pptinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pptinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoArgs args = {pDisp, itinfo, lcid, pptinfo, &hr};
Dispatch_GetTypeInfo_CallBack(&args);
return hr;
}
struct GetIDsOfNamesArgs
{
IDispatch* pUnk;
const IID* riid;
OLECHAR **rgszNames;
unsigned int cNames;
LCID lcid;
DISPID *rgdispid;
HRESULT* hr;
};
VOID __stdcall Dispatch_GetIDsOfNames_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetIDsOfNamesArgs* pArgs = (GetIDsOfNamesArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_GetIDsOfNames(pArgs->pUnk, *pArgs->riid, pArgs->rgszNames,
pArgs->cNames, pArgs->lcid, pArgs->rgdispid);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_GetIDsOfNames_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_GetIDsOfNames_Wrapper(IDispatch* pDisp, REFIID riid, _In_reads_(cNames) OLECHAR **rgszNames,
unsigned int cNames, LCID lcid, DISPID *rgdispid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(rgszNames, NULL_OK));
PRECONDITION(CheckPointer(rgdispid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetIDsOfNamesArgs args = {pDisp, &riid, rgszNames, cNames, lcid, rgdispid, &hr};
Dispatch_GetIDsOfNames_CallBack(&args);
return hr;
}
VOID __stdcall InternalDispatchImpl_GetIDsOfNames_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetIDsOfNamesArgs* pArgs = (GetIDsOfNamesArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = InternalDispatchImpl_GetIDsOfNames(pArgs->pUnk, *pArgs->riid, pArgs->rgszNames,
pArgs->cNames, pArgs->lcid, pArgs->rgdispid);
}
else
{
AppDomainDoCallBack(pWrap, InternalDispatchImpl_GetIDsOfNames_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall InternalDispatchImpl_GetIDsOfNames_Wrapper(IDispatch* pDisp, REFIID riid, _In_reads_(cNames) OLECHAR **rgszNames,
unsigned int cNames, LCID lcid, DISPID *rgdispid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(rgszNames, NULL_OK));
PRECONDITION(CheckPointer(rgdispid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetIDsOfNamesArgs args = {pDisp, &riid, rgszNames, cNames, lcid, rgdispid, &hr};
InternalDispatchImpl_GetIDsOfNames_CallBack(&args);
return hr;
}
struct InvokeArgs
{
IDispatch* pUnk;
DISPID dispidMember;
const IID* riid;
LCID lcid;
unsigned short wFlags;
DISPPARAMS *pdispparams;
VARIANT *pvarResult;
EXCEPINFO *pexcepinfo;
unsigned int *puArgErr;
HRESULT* hr;
};
VOID __stdcall Dispatch_Invoke_CallBack(LPVOID ptr)
{
CONTRACTL
{
THROWS; // Dispatch_Invoke can throw
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
InvokeArgs* pArgs = (InvokeArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Dispatch_Invoke(pArgs->pUnk, pArgs->dispidMember, *pArgs->riid,
pArgs->lcid, pArgs->wFlags, pArgs->pdispparams, pArgs->pvarResult,
pArgs->pexcepinfo, pArgs->puArgErr);
}
else
{
AppDomainDoCallBack(pWrap, Dispatch_Invoke_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Dispatch_Invoke_Wrapper(IDispatch* pDisp, DISPID dispidMember, REFIID riid, LCID lcid, unsigned short wFlags,
DISPPARAMS *pdispparams, VARIANT *pvarResult, EXCEPINFO *pexcepinfo, unsigned int *puArgErr)
{
HRESULT hrRetVal = S_OK;
SetupForComCallHR();
CONTRACTL
{
THROWS; // Dispatch_Invoke_CallBack can throw
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdispparams, NULL_OK));
PRECONDITION(CheckPointer(pvarResult, NULL_OK));
PRECONDITION(CheckPointer(pexcepinfo, NULL_OK));
PRECONDITION(CheckPointer(puArgErr, NULL_OK));
}
CONTRACTL_END;
InvokeArgs args = {pDisp, dispidMember, &riid, lcid, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr, &hrRetVal};
Dispatch_Invoke_CallBack(&args);
return hrRetVal;
}
VOID __stdcall InternalDispatchImpl_Invoke_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
InvokeArgs* pArgs = (InvokeArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = InternalDispatchImpl_Invoke(pArgs->pUnk, pArgs->dispidMember, *pArgs->riid,
pArgs->lcid, pArgs->wFlags, pArgs->pdispparams, pArgs->pvarResult,
pArgs->pexcepinfo, pArgs->puArgErr);
}
else
{
AppDomainDoCallBack(pWrap, InternalDispatchImpl_Invoke_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall InternalDispatchImpl_Invoke_Wrapper(IDispatch* pDisp, DISPID dispidMember, REFIID riid, LCID lcid,
unsigned short wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult,
EXCEPINFO *pexcepinfo, unsigned int *puArgErr)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdispparams, NULL_OK));
PRECONDITION(CheckPointer(pvarResult, NULL_OK));
PRECONDITION(CheckPointer(pexcepinfo, NULL_OK));
PRECONDITION(CheckPointer(puArgErr, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
InvokeArgs args = {pDisp, dispidMember, &riid, lcid, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr, &hr};
InternalDispatchImpl_Invoke_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IDispatchEx
struct GetTypeInfoCountExArgs
{
IDispatchEx* pUnk;
unsigned int *pctinfo;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetTypeInfoCount_CallBack (LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoCountExArgs* pArgs = (GetTypeInfoCountExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetTypeInfoCount(pArgs->pUnk, pArgs->pctinfo);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetTypeInfoCount_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetTypeInfoCount_Wrapper(IDispatchEx* pDisp, unsigned int *pctinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pctinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoCountExArgs args = {pDisp, pctinfo, &hr};
DispatchEx_GetTypeInfoCount_CallBack(&args);
return hr;
}
struct GetTypeInfoExArgs
{
IDispatch* pUnk;
unsigned int itinfo;
LCID lcid;
ITypeInfo **pptinfo;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetTypeInfo_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetTypeInfoExArgs* pArgs = (GetTypeInfoExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetTypeInfo(pArgs->pUnk, pArgs->itinfo, pArgs->lcid, pArgs->pptinfo);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetTypeInfo_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetTypeInfo_Wrapper(IDispatchEx* pDisp, unsigned int itinfo, LCID lcid, ITypeInfo **pptinfo)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pptinfo, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetTypeInfoExArgs args = {pDisp, itinfo, lcid, pptinfo, &hr};
DispatchEx_GetTypeInfo_CallBack(&args);
return hr;
}
struct GetIDsOfNamesExArgs
{
IDispatchEx* pUnk;
const IID* riid;
OLECHAR **rgszNames;
unsigned int cNames;
LCID lcid;
DISPID *rgdispid;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetIDsOfNames_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetIDsOfNamesExArgs* pArgs = (GetIDsOfNamesExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetIDsOfNames(pArgs->pUnk, *pArgs->riid, pArgs->rgszNames,
pArgs->cNames, pArgs->lcid, pArgs->rgdispid);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetIDsOfNames_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetIDsOfNames_Wrapper(IDispatchEx* pDisp, REFIID riid, _In_reads_(cNames) OLECHAR **rgszNames,
unsigned int cNames, LCID lcid, DISPID *rgdispid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(rgszNames, NULL_OK));
PRECONDITION(CheckPointer(rgdispid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetIDsOfNamesExArgs args = {pDisp, &riid, rgszNames, cNames, lcid, rgdispid, &hr};
DispatchEx_GetIDsOfNames_CallBack(&args);
return hr;
}
struct DispExInvokeArgs
{
IDispatchEx* pUnk;
DISPID dispidMember;
const IID* riid;
LCID lcid;
unsigned short wFlags;
DISPPARAMS *pdispparams;
VARIANT *pvarResult;
EXCEPINFO *pexcepinfo;
unsigned int *puArgErr;
HRESULT* hr;
};
VOID __stdcall DispatchEx_Invoke_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DispExInvokeArgs* pArgs = (DispExInvokeArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_Invoke(pArgs->pUnk, pArgs->dispidMember, *pArgs->riid,
pArgs->lcid, pArgs->wFlags, pArgs->pdispparams, pArgs->pvarResult,
pArgs->pexcepinfo, pArgs->puArgErr);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_Invoke_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_Invoke_Wrapper(IDispatchEx* pDisp, DISPID dispidMember, REFIID riid, LCID lcid,
unsigned short wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult,
EXCEPINFO *pexcepinfo, unsigned int *puArgErr)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdispparams, NULL_OK));
PRECONDITION(CheckPointer(pvarResult, NULL_OK));
PRECONDITION(CheckPointer(pexcepinfo, NULL_OK));
PRECONDITION(CheckPointer(puArgErr, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DispExInvokeArgs args = {pDisp, dispidMember, &riid, lcid, wFlags, pdispparams,
pvarResult, pexcepinfo, puArgErr, &hr};
DispatchEx_Invoke_CallBack(&args);
return hr;
}
struct DeleteMemberByDispIDArgs
{
IDispatchEx* pDisp;
DISPID id;
HRESULT* hr;
};
VOID __stdcall DispatchEx_DeleteMemberByDispID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DeleteMemberByDispIDArgs* pArgs = (DeleteMemberByDispIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_DeleteMemberByDispID(pArgs->pDisp, pArgs->id);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_DeleteMemberByDispID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_DeleteMemberByDispID_Wrapper(IDispatchEx* pDisp, DISPID id)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DeleteMemberByDispIDArgs args = {pDisp, id, &hr};
DispatchEx_DeleteMemberByDispID_CallBack(&args);
return hr;
}
struct DeleteMemberByNameArgs
{
IDispatchEx* pDisp;
BSTR bstrName;
DWORD grfdex;
HRESULT* hr;
};
VOID __stdcall DispatchEx_DeleteMemberByName_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DeleteMemberByNameArgs* pArgs = (DeleteMemberByNameArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_DeleteMemberByName(pArgs->pDisp, pArgs->bstrName, pArgs->grfdex);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_DeleteMemberByName_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_DeleteMemberByName_Wrapper(IDispatchEx* pDisp, BSTR bstrName, DWORD grfdex)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DeleteMemberByNameArgs args = {pDisp, bstrName, grfdex, &hr};
DispatchEx_DeleteMemberByName_CallBack(&args);
return hr;
}
struct GetMemberNameArgs
{
IDispatchEx* pDisp;
DISPID id;
BSTR *pbstrName;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetMemberName_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetMemberNameArgs* pArgs = (GetMemberNameArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetMemberName(pArgs->pDisp, pArgs->id, pArgs->pbstrName);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetMemberName_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetMemberName_Wrapper(IDispatchEx* pDisp, DISPID id, BSTR *pbstrName)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pbstrName, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetMemberNameArgs args = {pDisp, id, pbstrName, &hr};
DispatchEx_GetMemberName_CallBack(&args);
return hr;
}
struct GetDispIDArgs
{
IDispatchEx* pDisp;
BSTR bstrName;
DWORD grfdex;
DISPID *pid;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetDispID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetDispIDArgs* pArgs = (GetDispIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetDispID(pArgs->pDisp, pArgs->bstrName, pArgs->grfdex, pArgs->pid);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetDispID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetDispID_Wrapper(IDispatchEx* pDisp, BSTR bstrName, DWORD grfdex, DISPID *pid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetDispIDArgs args = {pDisp, bstrName, grfdex, pid, &hr};
DispatchEx_GetDispID_CallBack(&args);
return hr;
}
struct GetMemberPropertiesArgs
{
IDispatchEx* pDisp;
DISPID id;
DWORD grfdexFetch;
DWORD *pgrfdex;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetMemberProperties_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetMemberPropertiesArgs* pArgs = (GetMemberPropertiesArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetMemberProperties(pArgs->pDisp, pArgs->id, pArgs->grfdexFetch,
pArgs->pgrfdex);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetMemberProperties_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetMemberProperties_Wrapper(IDispatchEx* pDisp, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pgrfdex, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetMemberPropertiesArgs args = {pDisp, id, grfdexFetch, pgrfdex, &hr};
DispatchEx_GetMemberProperties_CallBack(&args);
return hr;
}
struct GetNameSpaceParentArgs
{
IDispatchEx* pDisp;
IUnknown **ppunk;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetNameSpaceParent_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetNameSpaceParentArgs* pArgs = (GetNameSpaceParentArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetNameSpaceParent(pArgs->pDisp, pArgs->ppunk);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetNameSpaceParent_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetNameSpaceParent_Wrapper(IDispatchEx* pDisp, IUnknown **ppunk)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(ppunk, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetNameSpaceParentArgs args = {pDisp, ppunk, &hr};
DispatchEx_GetNameSpaceParent_CallBack(&args);
return hr;
}
struct GetNextDispIDArgs
{
IDispatchEx* pDisp;
DWORD grfdex;
DISPID id;
DISPID *pid;
HRESULT* hr;
};
VOID __stdcall DispatchEx_GetNextDispID_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetNextDispIDArgs* pArgs = (GetNextDispIDArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_GetNextDispID(pArgs->pDisp, pArgs->grfdex, pArgs->id, pArgs->pid);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_GetNextDispID_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_GetNextDispID_Wrapper(IDispatchEx* pDisp, DWORD grfdex, DISPID id, DISPID *pid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetNextDispIDArgs args = {pDisp, grfdex, id, pid, &hr};
DispatchEx_GetNextDispID_CallBack(&args);
return hr;
}
struct DispExInvokeExArgs
{
IDispatchEx* pDisp;
DISPID id;
LCID lcid;
WORD wFlags;
DISPPARAMS *pdp;
VARIANT *pVarRes;
EXCEPINFO *pei;
IServiceProvider *pspCaller;
HRESULT* hr;
};
VOID __stdcall DispatchEx_InvokeEx_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DispExInvokeExArgs* pArgs = (DispExInvokeExArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pDisp);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = DispatchEx_InvokeEx(pArgs->pDisp, pArgs->id,
pArgs->lcid, pArgs->wFlags, pArgs->pdp, pArgs->pVarRes,
pArgs->pei, pArgs->pspCaller);
}
else
{
AppDomainDoCallBack(pWrap, DispatchEx_InvokeEx_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall DispatchEx_InvokeEx_Wrapper(IDispatchEx* pDisp, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pVarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pDisp));
PRECONDITION(CheckPointer(pdp, NULL_OK));
PRECONDITION(CheckPointer(pVarRes, NULL_OK));
PRECONDITION(CheckPointer(pei, NULL_OK));
PRECONDITION(CheckPointer(pspCaller, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DispExInvokeExArgs args = {pDisp, id, lcid, wFlags, pdp, pVarRes, pei, pspCaller, &hr};
DispatchEx_InvokeEx_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IMarshal
struct GetUnmarshalClassArgs
{
IMarshal* pUnk;
const IID* riid;
void * pv;
ULONG dwDestContext;
void * pvDestContext;
ULONG mshlflags;
LPCLSID pclsid;
HRESULT* hr;
};
VOID __stdcall Marshal_GetUnmarshalClass_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetUnmarshalClassArgs* pArgs = (GetUnmarshalClassArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_GetUnmarshalClass(pArgs->pUnk, *(pArgs->riid), pArgs->pv,
pArgs->dwDestContext, pArgs->pvDestContext, pArgs->mshlflags,
pArgs->pclsid);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_GetUnmarshalClass_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_GetUnmarshalClass_Wrapper(IMarshal* pMarsh, REFIID riid, void * pv, ULONG dwDestContext,
void * pvDestContext, ULONG mshlflags, LPCLSID pclsid)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pv, NULL_OK));
PRECONDITION(CheckPointer(pvDestContext, NULL_OK));
PRECONDITION(CheckPointer(pclsid, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetUnmarshalClassArgs args = {pMarsh, &riid, pv, dwDestContext, pvDestContext,
mshlflags, pclsid, &hr};
Marshal_GetUnmarshalClass_CallBack(&args);
return hr;
}
struct GetMarshalSizeMaxArgs
{
IMarshal* pUnk;
const IID* riid;
void * pv;
ULONG dwDestContext;
void * pvDestContext;
ULONG mshlflags;
ULONG * pSize;
HRESULT* hr;
};
VOID __stdcall Marshal_GetMarshalSizeMax_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetMarshalSizeMaxArgs* pArgs = (GetMarshalSizeMaxArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_GetMarshalSizeMax(pArgs->pUnk, *(pArgs->riid), pArgs->pv,
pArgs->dwDestContext, pArgs->pvDestContext, pArgs->mshlflags,
pArgs->pSize);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_GetMarshalSizeMax_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_GetMarshalSizeMax_Wrapper(IMarshal* pMarsh, REFIID riid, void * pv, ULONG dwDestContext,
void * pvDestContext, ULONG mshlflags, ULONG * pSize)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pv, NULL_OK));
PRECONDITION(CheckPointer(pvDestContext, NULL_OK));
PRECONDITION(CheckPointer(pSize, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetMarshalSizeMaxArgs args = {pMarsh, &riid, pv, dwDestContext, pvDestContext,
mshlflags, pSize, &hr};
Marshal_GetMarshalSizeMax_CallBack(&args);
return hr;
}
struct MarshalInterfaceArgs
{
IMarshal* pUnk;
LPSTREAM pStm;
const IID* riid;
void * pv;
ULONG dwDestContext;
void * pvDestContext;
ULONG mshlflags;
HRESULT* hr;
};
VOID __stdcall Marshal_MarshalInterface_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
MarshalInterfaceArgs* pArgs = (MarshalInterfaceArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_MarshalInterface(pArgs->pUnk, pArgs->pStm, *(pArgs->riid), pArgs->pv,
pArgs->dwDestContext, pArgs->pvDestContext, pArgs->mshlflags);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_MarshalInterface_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_MarshalInterface_Wrapper(IMarshal* pMarsh, LPSTREAM pStm, REFIID riid, void * pv,
ULONG dwDestContext, LPVOID pvDestContext, ULONG mshlflags)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pv, NULL_OK));
PRECONDITION(CheckPointer(pvDestContext, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
MarshalInterfaceArgs args = {pMarsh, pStm, &riid, pv, dwDestContext, pvDestContext,
mshlflags, &hr};
Marshal_MarshalInterface_CallBack(&args);
return hr;
}
struct UnmarshalInterfaceArgs
{
IMarshal* pUnk;
LPSTREAM pStm;
const IID* riid;
void ** ppvObj;
HRESULT* hr;
};
VOID __stdcall Marshal_UnmarshalInterface_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
UnmarshalInterfaceArgs* pArgs = (UnmarshalInterfaceArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_UnmarshalInterface(pArgs->pUnk, pArgs->pStm, *(pArgs->riid), pArgs->ppvObj);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_UnmarshalInterface_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_UnmarshalInterface_Wrapper(IMarshal* pMarsh, LPSTREAM pStm, REFIID riid, void ** ppvObj)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pStm, NULL_OK));
PRECONDITION(CheckPointer(ppvObj, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
UnmarshalInterfaceArgs args = {pMarsh, pStm, &riid, ppvObj, &hr};
Marshal_UnmarshalInterface_CallBack(&args);
return hr;
}
struct ReleaseMarshalDataArgs
{
IMarshal* pUnk;
LPSTREAM pStm;
HRESULT* hr;
};
VOID __stdcall Marshal_ReleaseMarshalData_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
ReleaseMarshalDataArgs* pArgs = (ReleaseMarshalDataArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_ReleaseMarshalData(pArgs->pUnk, pArgs->pStm);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_ReleaseMarshalData_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_ReleaseMarshalData_Wrapper(IMarshal* pMarsh, LPSTREAM pStm)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
PRECONDITION(CheckPointer(pStm, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
ReleaseMarshalDataArgs args = {pMarsh, pStm, &hr};
Marshal_ReleaseMarshalData_CallBack(&args);
return hr;
}
struct DisconnectObjectArgs
{
IMarshal* pUnk;
ULONG dwReserved;
HRESULT* hr;
};
VOID __stdcall Marshal_DisconnectObject_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
DisconnectObjectArgs* pArgs = (DisconnectObjectArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = Marshal_DisconnectObject(pArgs->pUnk, pArgs->dwReserved);
}
else
{
AppDomainDoCallBack(pWrap, Marshal_DisconnectObject_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall Marshal_DisconnectObject_Wrapper(IMarshal* pMarsh, ULONG dwReserved)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pMarsh));
}
CONTRACTL_END;
HRESULT hr = S_OK;
DisconnectObjectArgs args = {pMarsh, dwReserved, &hr};
Marshal_DisconnectObject_CallBack(&args);
return hr;
}
// ---------------------------------------------------------------------------
// Interface IConnectionPointContainer
struct EnumConnectionPointsArgs
{
IUnknown* pUnk;
IEnumConnectionPoints **ppEnum;
HRESULT* hr;
};
VOID __stdcall ConnectionPointContainer_EnumConnectionPoints_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
EnumConnectionPointsArgs* pArgs = (EnumConnectionPointsArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ConnectionPointContainer_EnumConnectionPoints(pArgs->pUnk, pArgs->ppEnum);
}
else
{
AppDomainDoCallBack(pWrap, ConnectionPointContainer_EnumConnectionPoints_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ConnectionPointContainer_EnumConnectionPoints_Wrapper(IUnknown* pUnk, IEnumConnectionPoints **ppEnum)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppEnum, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
EnumConnectionPointsArgs args = {pUnk, ppEnum, &hr};
ConnectionPointContainer_EnumConnectionPoints_CallBack(&args);
return hr;
}
struct FindConnectionPointArgs
{
IUnknown* pUnk;
const IID* riid;
IConnectionPoint **ppCP;
HRESULT* hr;
};
VOID __stdcall ConnectionPointContainer_FindConnectionPoint_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
FindConnectionPointArgs* pArgs = (FindConnectionPointArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ConnectionPointContainer_FindConnectionPoint(pArgs->pUnk, *(pArgs->riid),
pArgs->ppCP);
}
else
{
AppDomainDoCallBack(pWrap, ConnectionPointContainer_FindConnectionPoint_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ConnectionPointContainer_FindConnectionPoint_Wrapper(IUnknown* pUnk, REFIID riid, IConnectionPoint **ppCP)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(ppCP, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
FindConnectionPointArgs args = {pUnk, &riid, ppCP, &hr};
ConnectionPointContainer_FindConnectionPoint_CallBack(&args);
return hr;
}
//------------------------------------------------------------------------------------------
// IObjectSafety methods for COM+ objects
struct GetInterfaceSafetyArgs
{
IUnknown* pUnk;
const IID* riid;
DWORD *pdwSupportedOptions;
DWORD *pdwEnabledOptions;
HRESULT* hr;
};
VOID __stdcall ObjectSafety_GetInterfaceSafetyOptions_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
GetInterfaceSafetyArgs* pArgs = (GetInterfaceSafetyArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ObjectSafety_GetInterfaceSafetyOptions(pArgs->pUnk, *(pArgs->riid),
pArgs->pdwSupportedOptions,
pArgs->pdwEnabledOptions);
}
else
{
AppDomainDoCallBack(pWrap, ObjectSafety_GetInterfaceSafetyOptions_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ObjectSafety_GetInterfaceSafetyOptions_Wrapper(IUnknown* pUnk, REFIID riid,
DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
PRECONDITION(CheckPointer(pdwSupportedOptions, NULL_OK));
PRECONDITION(CheckPointer(pdwEnabledOptions, NULL_OK));
}
CONTRACTL_END;
HRESULT hr = S_OK;
GetInterfaceSafetyArgs args = {pUnk, &riid, pdwSupportedOptions, pdwEnabledOptions, &hr};
ObjectSafety_GetInterfaceSafetyOptions_CallBack(&args);
return hr;
}
struct SetInterfaceSafetyArgs
{
IUnknown* pUnk;
const IID* riid;
DWORD dwOptionSetMask;
DWORD dwEnabledOptions;
HRESULT* hr;
};
VOID __stdcall ObjectSafety_SetInterfaceSafetyOptions_CallBack(LPVOID ptr)
{
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(ptr));
}
CONTRACTL_END;
SetInterfaceSafetyArgs* pArgs = (SetInterfaceSafetyArgs*)ptr;
ComCallWrapper* pWrap = MapIUnknownToWrapper(pArgs->pUnk);
if (IsCurrentDomainValid(pWrap))
{
*(pArgs->hr) = ObjectSafety_SetInterfaceSafetyOptions(pArgs->pUnk, *(pArgs->riid),
pArgs->dwOptionSetMask,
pArgs->dwEnabledOptions
);
}
else
{
AppDomainDoCallBack(pWrap, ObjectSafety_SetInterfaceSafetyOptions_CallBack, pArgs, pArgs->hr);
}
}
HRESULT __stdcall ObjectSafety_SetInterfaceSafetyOptions_Wrapper(IUnknown* pUnk, REFIID riid,
DWORD dwOptionSetMask, DWORD dwEnabledOptions)
{
SetupForComCallHR();
CONTRACTL
{
NOTHROW;
GC_TRIGGERS;
MODE_PREEMPTIVE;
PRECONDITION(CheckPointer(pUnk));
}
CONTRACTL_END;
HRESULT hr = S_OK;
SetInterfaceSafetyArgs args = {pUnk, &riid, dwOptionSetMask, dwEnabledOptions, &hr};
ObjectSafety_SetInterfaceSafetyOptions_CallBack(&args);
return hr;
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/BuildWasmApps/testassets/SatelliteAssemblyInMain/resx/words.ja-JP.resx | <?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="bye" xml:space="preserve">
<value>さようなら</value>
</data>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="hello" xml:space="preserve">
<value>こんにちは</value>
</data>
</root>
| <?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="bye" xml:space="preserve">
<value>さようなら</value>
</data>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="hello" xml:space="preserve">
<value>こんにちは</value>
</data>
</root>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Net.Security/src/System.Net.Security.csproj | <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Android;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-iOS;$(NetCoreAppCurrent)-tvOS;$(NetCoreAppCurrent)</TargetFrameworks>
<!-- This is needed so that code for TlsCipherSuite will have no namespace (causes compile errors) when used within T4 template -->
<DefineConstants>$(DefineConstants);PRODUCT</DefineConstants>
<Nullable>enable</Nullable>
</PropertyGroup>
<!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
<PropertyGroup>
<TargetPlatformIdentifier>$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)'))</TargetPlatformIdentifier>
<GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetPlatformIdentifier)' == ''">SR.SystemNetSecurity_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
<DefineConstants Condition="'$(TargetPlatformIdentifier)' == 'windows'">$(DefineConstants);TARGET_WINDOWS</DefineConstants>
<UseAndroidCrypto Condition="'$(TargetPlatformIdentifier)' == 'Android'">true</UseAndroidCrypto>
<UseAppleCrypto Condition="'$(TargetPlatformIdentifier)' == 'OSX' or '$(TargetPlatformIdentifier)' == 'iOS' or '$(TargetPlatformIdentifier)' == 'tvOS'">true</UseAppleCrypto>
<DefineConstants Condition="'$(UseAndroidCrypto)' == 'true' or '$(UseAppleCrypto)' == 'true'">$(DefineConstants);SYSNETSECURITY_NO_OPENSSL</DefineConstants>
</PropertyGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != ''">
<Compile Include="System\Net\CertificateValidationPal.cs" />
<Compile Include="System\Net\Logging\NetEventSource.cs" />
<Compile Include="System\Net\SslStreamContext.cs" />
<Compile Include="System\Net\Security\AuthenticatedStream.cs" />
<Compile Include="System\Security\Authentication\AuthenticationException.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicy.cs" />
<Compile Include="System\Net\Security\NetEventSource.Security.cs" />
<Compile Include="System\Net\Security\NetSecurityTelemetry.cs" />
<Compile Include="System\Net\Security\ReadWriteAdapter.cs" />
<Compile Include="System\Net\Security\ProtectionLevel.cs" />
<Compile Include="System\Net\Security\SslApplicationProtocol.cs" />
<Compile Include="System\Net\Security\SslAuthenticationOptions.cs" />
<Compile Include="System\Net\Security\SslCertificateTrust.cs" />
<Compile Include="System\Net\Security\SslClientAuthenticationOptions.cs" />
<Compile Include="System\Net\Security\SslClientHelloInfo.cs" />
<Compile Include="System\Net\Security\SslServerAuthenticationOptions.cs" />
<Compile Include="System\Net\Security\SecureChannel.cs" />
<Compile Include="System\Net\Security\SslSessionsCache.cs" />
<Compile Include="System\Net\Security\SslStream.cs" />
<Compile Include="System\Net\Security\SslStream.Implementation.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.cs" />
<Compile Include="System\Net\Security\StreamSizes.cs" />
<Compile Include="System\Net\Security\TlsAlertType.cs" />
<Compile Include="System\Net\Security\TlsAlertMessage.cs" />
<Compile Include="System\Net\Security\TlsFrameHelper.cs" />
<!-- NegotiateStream -->
<Compile Include="System\Net\NTAuthentication.cs" />
<Compile Include="System\Net\StreamFramer.cs" />
<Compile Include="System\Net\Security\NegotiateStream.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\ExtendedProtectionPolicy.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\PolicyEnforcement.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\ProtectionScenario.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\ServiceNameCollection.cs" />
<!-- Common sources -->
<Compile Include="$(CommonPath)DisableRuntimeMarshalling.cs"
Link="Common\DisableRuntimeMarshalling.cs" />
<!-- Logging -->
<Compile Include="$(CommonPath)System\Net\Logging\NetEventSource.Common.cs"
Link="Common\System\Net\Logging\NetEventSource.Common.cs" />
<Compile Include="$(CommonPath)System\Net\InternalException.cs"
Link="Common\System\Net\InternalException.cs" />
<Compile Include="$(CommonPath)Extensions\ValueStopwatch\ValueStopwatch.cs"
Link="Common\Extensions\ValueStopwatch\ValueStopwatch.cs" />
<!-- Debug only -->
<Compile Include="$(CommonPath)System\Net\DebugSafeHandle.cs"
Link="Common\System\Net\DebugSafeHandle.cs" />
<Compile Include="$(CommonPath)System\Net\DebugSafeHandleZeroOrMinusOneIsInvalid.cs"
Link="Common\System\Net\DebugSafeHandleZeroOrMinusOneIsInvalid.cs" />
<!-- System.Net common -->
<Compile Include="$(CommonPath)System\Net\ArrayBuffer.cs">
<Link>Common\System\Net\ArrayBuffer.cs</Link>
</Compile>
<Compile Include="$(CommonPath)System\Net\ExceptionCheck.cs"
Link="Common\System\Net\ExceptionCheck.cs" />
<Compile Include="$(CommonPath)System\Net\SecurityProtocol.cs"
Link="Common\System\Net\SecurityProtocol.cs" />
<Compile Include="$(CommonPath)System\Net\UriScheme.cs"
Link="Common\System\Net\UriScheme.cs" />
<!-- Common -->
<Compile Include="$(CommonPath)System\NotImplemented.cs"
Link="Common\System\NotImplemented.cs" />
<Compile Include="$(CommonPath)System\Threading\Tasks\TaskToApm.cs"
Link="Common\System\Threading\Tasks\TaskToApm.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SafeCredentialReference.cs"
Link="Common\System\Net\Security\SafeCredentialReference.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SSPIHandleCache.cs"
Link="Common\System\Net\Security\SSPIHandleCache.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsPal.cs"
Link="Common\System\Net\ContextFlagsPal.cs" />
<Compile Include="$(CommonPath)System\Net\NegotiationInfoClass.cs"
Link="Common\System\Net\NegotiationInfoClass.cs" />
<Compile Include="$(CommonPath)System\Net\NTAuthentication.Common.cs"
Link="Common\System\Net\NTAuthentication.Common.cs" />
<Compile Include="$(CommonPath)System\Net\SecurityStatusPal.cs"
Link="Common\System\Net\SecurityStatusPal.cs" />
<Compile Include="$(CommonPath)System\HexConverter.cs"
Link="Common\System\HexConverter.cs" />
</ItemGroup>
<!-- This file depends on IANA registry. We do not want anyone's build to break after the update -->
<!-- or if they don't have internet connection - explicit opt-in required -->
<!-- To expose newly generated APIs, generated file have to be deliberately copied -->
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != ''">
<Compile Include="System\Net\Security\TlsCipherSuite.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>TlsCipherSuite.tt</DependentUpon>
</Compile>
<None Include="System\Net\Security\TlsCipherSuiteNameParser.ttinclude" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows'">
<Compile Include="System\Net\Security\TlsCipherSuiteData.Lookup.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>TlsCipherSuiteData.Lookup.tt</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">
<None Include="System\Net\Security\TlsCipherSuiteData.Lookup.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>TlsCipherSuiteData.Lookup.tt</DependentUpon>
</None>
</ItemGroup>
<ItemGroup Condition="'$(AllowTlsCipherSuiteGeneration)' == 'true'">
<None Include="System\Net\Security\TlsCipherSuite.tt">
<Generator>TextTemplatingFileGenerator</Generator>
<LastGenOutput>TlsCipherSuite.cs</LastGenOutput>
</None>
<None Include="System\Net\Security\TlsCipherSuiteData.Lookup.tt">
<Generator>TextTemplatingFileGenerator</Generator>
<LastGenOutput>TlsCipherSuiteData.Lookup.cs</LastGenOutput>
</None>
</ItemGroup>
<ItemGroup Condition="'$(AllowTlsCipherSuiteGeneration)' != 'true'">
<None Include="System\Net\Security\TlsCipherSuite.tt" />
<None Include="System\Net\Security\TlsCipherSuiteData.Lookup.tt" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">
<Compile Include="System\Net\CertificateValidationPal.Windows.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.Windows.cs" />
<Compile Include="System\Net\Security\NegotiateStreamPal.Windows.cs" />
<Compile Include="System\Net\Security\NetEventSource.Security.Windows.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.Windows.cs" />
<Compile Include="System\Net\Security\SslStreamPal.Windows.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Windows.cs" />
<Compile Include="System\Net\Security\StreamSizes.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\CertificateValidation.Windows.cs"
Link="Common\System\Net\Security\CertificateValidation.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SecurityBuffer.Windows.cs"
Link="Common\System\Net\Security\SecurityBuffer.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SecurityBufferType.Windows.cs"
Link="Common\System\Net\Security\SecurityBufferType.Windows.cs" />
<!-- NegotiateStream -->
<Compile Include="$(CommonPath)System\Net\SecurityStatusAdapterPal.Windows.cs"
Link="Common\System\Net\SecurityStatusAdapterPal.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsAdapterPal.Windows.cs"
Link="Common\System\Net\ContextFlagsAdapterPal.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\NegotiateStreamPal.Windows.cs"
Link="Common\System\Net\Security\NegotiateStreamPal.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SecurityContextTokenHandle.cs"
Link="Common\System\Net\Security\SecurityContextTokenHandle.cs" />
<!-- Interop -->
<Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs"
Link="Common\Interop\Windows\Interop.BOOL.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
Link="Common\Interop\Windows\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Interop.UNICODE_STRING.cs"
Link="Common\Interop\Windows\Interop.UNICODE_STRING.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CERT_CONTEXT.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CERT_CONTEXT.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CERT_INFO.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CERT_INFO.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CERT_PUBLIC_KEY_INFO.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CERT_PUBLIC_KEY_INFO.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CRYPT_ALGORITHM_IDENTIFIER.cs"
Link="Common\Interop\Windows\Crypt32\Interop.Interop.CRYPT_ALGORITHM_IDENTIFIER.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CRYPT_BIT_BLOB.cs"
Link="Common\Interop\Windows\Crypt32\Interop.Interop.CRYPT_BIT_BLOB.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.DATA_BLOB.cs"
Link="Common\Interop\Windows\Crypt32\Interop.DATA_BLOB.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.certificates.cs"
Link="Common\Interop\Windows\Crypt32\Interop.certificates.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.certificates_types.cs"
Link="Common\Interop\Windows\Crypt32\Interop.certificates_types.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CertEnumCertificatesInStore.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CertEnumCertificatesInStore.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.MsgEncodingType.cs"
Link="Common\Interop\Windows\Crypt32\Interop.Interop.MsgEncodingType.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.CloseHandle.cs"
Link="Common\Interop\Windows\Kernel32\Interop.CloseHandle.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.Alerts.cs"
Link="Common\Interop\Windows\SChannel\Interop.Alerts.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.SchProtocols.cs"
Link="Common\Interop\Windows\SChannel\Interop.SchProtocols.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.SECURITY_STATUS.cs"
Link="Common\Interop\Windows\SChannel\Interop.SECURITY_STATUS.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\SecPkgContext_ConnectionInfo.cs"
Link="Common\Interop\Windows\SChannel\SecPkgContext_ConnectionInfo.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\SecPkgContext_CipherInfo.cs"
Link="Common\Interop\Windows\SChannel\SecPkgContext_CipherInfo.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.SecPkgContext_ApplicationProtocol.cs"
Link="Common\Interop\Windows\SChannel\Interop.SecPkgContext_ApplicationProtocol.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.Sec_Application_Protocols.cs"
Link="Common\Interop\Windows\SChannel\Interop.Sec_Application_Protocols.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\UnmanagedCertificateContext.cs"
Link="Common\Interop\Windows\SChannel\UnmanagedCertificateContext.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\UnmanagedCertificateContext.IntPtr.cs"
Link="Common\Interop\Windows\SChannel\UnmanagedCertificateContext.IntPtr.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_Bindings.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_Bindings.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\GlobalSSPI.cs"
Link="Common\Interop\Windows\SspiCli\GlobalSSPI.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\Interop.SSPI.cs"
Link="Common\Interop\Windows\SspiCli\Interop.SSPI.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_NegotiationInfoW.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_NegotiationInfoW.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\NegotiationInfoClass.cs"
Link="Common\Interop\Windows\SspiCli\NegotiationInfoClass.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_Sizes.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_Sizes.cs" />
<Compile Include="$(CommonPath)System\Collections\Generic\BidirectionalDictionary.cs"
Link="Common\System\Collections\Generic\BidirectionalDictionary.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SafeDeleteContext.cs"
Link="Common\Interop\Windows\SspiCli\SafeDeleteContext.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecurityPackageInfo.cs"
Link="Common\Interop\Windows\SspiCli\SecurityPackageInfo.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecurityPackageInfoClass.cs"
Link="Common\Interop\Windows\SspiCli\SecurityPackageInfoClass.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecuritySafeHandles.cs"
Link="Common\Interop\Windows\SspiCli\SecuritySafeHandles.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SSPIAuthType.cs"
Link="Common\Interop\Windows\SspiCli\SSPIAuthType.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\ISSPIInterface.cs"
Link="Common\Interop\Windows\SspiCli\ISSPIInterface.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SSPISecureChannelType.cs"
Link="Common\Interop\Windows\SspiCli\SSPISecureChannelType.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SSPIWrapper.cs"
Link="Common\Interop\Windows\SspiCli\SSPIWrapper.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_StreamSizes.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_StreamSizes.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows'">
<Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs"
Link="Common\Interop\Unix\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\Unix\Interop.Errors.cs"
Link="Common\Interop\Unix\Interop.Errors.cs" />
<Compile Include="$(CommonPath)System\Net\Http\TlsCertificateExtensions.cs"
Link="Common\System\Net\Http\TlsCertificateExtensions.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.GssFlags.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.GssFlags.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.Status.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.Status.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeDeleteContext.cs"
Link="Common\System\Net\Security\Unix\SafeDeleteContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeCredentials.cs"
Link="Common\System\Net\Security\Unix\SafeFreeCredentials.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SecChannelBindings.cs"
Link="Common\System\Net\Security\Unix\SecChannelBindings.cs" />
<Compile Include="System\Net\Security\Pal.Managed\EndpointChannelBindingToken.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SafeChannelBindingHandle.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Unix.cs" />
<Compile Include="System\Net\Security\TlsCipherSuiteData.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows' and '$(TargetPlatformIdentifier)' != 'tvOS'">
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\GssSafeHandles.cs"
Link="Common\Microsoft\Win32\SafeHandles\GssSafeHandles.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeDeleteNegoContext.cs"
Link="Common\System\Net\Security\Unix\SafeDeleteNegoContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeNegoCredentials.cs"
Link="Common\System\Net\Security\Unix\SafeFreeNegoCredentials.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsAdapterPal.Unix.cs"
Link="Common\System\Net\ContextFlagsAdapterPal.Unix.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.Initialization.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.Initialization.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.GssApiException.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.GssApiException.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.GssBuffer.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.GssBuffer.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.IsNtlmInstalled.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.IsNtlmInstalled.cs" />
<Compile Include="$(CommonPath)System\Net\Security\NegotiateStreamPal.Unix.cs"
Link="Common\System\Net\Security\NegotiateStreamPal.Unix.cs" />
<Compile Include="System\Net\Security\NegotiateStreamPal.Unix.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'tvOS'">
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\GssSafeHandles.PlatformNotSupported.cs"
Link="Common\Microsoft\Win32\SafeHandles\GssSafeHandles.PlatformNotSupported.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsAdapterPal.PlatformNotSupported.cs"
Link="Common\System\Net\ContextFlagsAdapterPal.PlatformNotSupported.cs" />
<Compile Include="$(CommonPath)System\Net\Security\NegotiateStreamPal.PlatformNotSupported.cs"
Link="Common\System\Net\Security\NegotiateStreamPal.PlatformNotSupported.cs" />
<Compile Include="System\Net\Security\NegotiateStreamPal.PlatformNotSupported.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows' and '$(UseAndroidCrypto)' != 'true' and '$(UseAppleCrypto)' != 'true'">
<Compile Include="System\Net\CertificateValidationPal.Unix.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.Linux.cs" />
<Compile Include="System\Net\Security\SslStreamPal.Unix.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Linux.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.Linux.cs" />
<Compile Include="System\Net\Security\StreamSizes.Unix.cs" />
<Compile Include="$(CommonPath)System\Net\Security\CertificateValidation.Unix.cs"
Link="Common\System\Net\Security\CertificateValidation.Unix.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.Initialization.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.Initialization.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtx.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtx.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.SetProtocolOptions.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.SetProtocolOptions.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtxOptions.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtxOptions.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509Name.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509Name.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509Ext.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509Ext.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509Stack.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509Stack.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509StoreCtx.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509StoreCtx.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeX509Handles.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeX509Handles.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\X509ExtensionSafeHandles.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\X509ExtensionSafeHandles.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeInteriorHandle.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeInteriorHandle.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeBioHandle.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeBioHandle.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\Asn1SafeHandles.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\Asn1SafeHandles.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeHandleCache.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeHandleCache.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeDeleteSslContext.cs"
Link="Common\System\Net\Security\Unix\SafeDeleteSslContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeCertContext.cs"
Link="Common\System\Net\Security\Unix\SafeFreeCertContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeSslCredentials.cs"
Link="Common\System\Net\Security\Unix\SafeFreeSslCredentials.cs" />
</ItemGroup>
<ItemGroup Condition="'$(UseAndroidCrypto)' == 'true'">
<Compile Include="$(CommonPath)Interop\Android\Interop.Libraries.cs"
Link="Common\Interop\Android\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\Android\Interop.JObjectLifetime.cs"
Link="Common\Interop\Android\Interop.JObjectLifetime.cs" />
<Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.cs"
Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.cs" />
<Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.ProtocolSupport.cs"
Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.ProtocolSupport.cs" />
<Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.X509.cs"
Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.X509.cs" />
<Compile Include="System\Net\CertificateValidationPal.Android.cs" />
<Compile Include="System\Net\Security\MD4.cs" />
<Compile Include="System\Net\Security\Pal.Android\SafeDeleteSslContext.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SafeFreeSslCredentials.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SslProtocolsValidation.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Android.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.Android.cs" />
<Compile Include="System\Net\Security\SslStreamPal.Android.cs" />
<Compile Include="System\Net\Security\StreamSizes.Unix.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.Android.cs" />
</ItemGroup>
<ItemGroup Condition="'$(UseAppleCrypto)' == 'true'">
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFArray.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFArray.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFData.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFData.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFDate.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFDate.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFError.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFError.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFString.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFString.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.Libraries.cs"
Link="Common\Interop\OSX\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SecErrMessage.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SecErrMessage.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SslErr.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SslErr.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.Ssl.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.Ssl.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.X509Chain.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.X509Chain.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeCreateHandle.OSX.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeCreateHandle.OSX.cs" />
<Compile Include="System\Net\CertificateValidationPal.OSX.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SafeFreeSslCredentials.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SslProtocolsValidation.cs" />
<Compile Include="System\Net\Security\Pal.OSX\SafeDeleteSslContext.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.OSX.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.OSX.cs" />
<Compile Include="System\Net\Security\SslStreamPal.OSX.cs" />
<Compile Include="System\Net\Security\StreamSizes.OSX.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.OSX.cs" />
</ItemGroup>
<ItemGroup>
<Reference Include="Microsoft.Win32.Primitives" />
<Reference Include="System.Collections" />
<Reference Include="System.Collections.Concurrent" />
<Reference Include="System.Collections.NonGeneric" />
<Reference Include="System.Console" Condition="'$(Configuration)' == 'Debug'" />
<Reference Include="System.Diagnostics.Tracing" />
<Reference Include="System.Linq" />
<Reference Include="System.Memory" />
<Reference Include="System.Net.Primitives" />
<Reference Include="System.Net.Sockets" />
<Reference Include="System.Runtime" />
<Reference Include="System.Runtime.Extensions" />
<Reference Include="System.Runtime.CompilerServices.Unsafe" />
<Reference Include="System.Runtime.InteropServices" />
<Reference Include="System.Security.Claims" />
<Reference Include="System.Security.Cryptography" />
<Reference Include="System.Security.Cryptography.OpenSsl" />
<Reference Include="System.Security.Cryptography.X509Certificates" />
<Reference Include="System.Security.Principal" />
<Reference Include="System.Security.Principal.Windows" />
<Reference Include="System.Threading" />
<Reference Include="System.Threading.ThreadPool" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows'">
<Reference Include="System.Diagnostics.StackTrace" />
<Reference Include="System.Security.Cryptography.Algorithms" />
<Reference Include="System.Security.Cryptography" />
</ItemGroup>
</Project>
| <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<TargetFrameworks>$(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-Unix;$(NetCoreAppCurrent)-Android;$(NetCoreAppCurrent)-OSX;$(NetCoreAppCurrent)-iOS;$(NetCoreAppCurrent)-tvOS;$(NetCoreAppCurrent)</TargetFrameworks>
<!-- This is needed so that code for TlsCipherSuite will have no namespace (causes compile errors) when used within T4 template -->
<DefineConstants>$(DefineConstants);PRODUCT</DefineConstants>
<Nullable>enable</Nullable>
</PropertyGroup>
<!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
<PropertyGroup>
<TargetPlatformIdentifier>$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)'))</TargetPlatformIdentifier>
<GeneratePlatformNotSupportedAssemblyMessage Condition="'$(TargetPlatformIdentifier)' == ''">SR.SystemNetSecurity_PlatformNotSupported</GeneratePlatformNotSupportedAssemblyMessage>
<DefineConstants Condition="'$(TargetPlatformIdentifier)' == 'windows'">$(DefineConstants);TARGET_WINDOWS</DefineConstants>
<UseAndroidCrypto Condition="'$(TargetPlatformIdentifier)' == 'Android'">true</UseAndroidCrypto>
<UseAppleCrypto Condition="'$(TargetPlatformIdentifier)' == 'OSX' or '$(TargetPlatformIdentifier)' == 'iOS' or '$(TargetPlatformIdentifier)' == 'tvOS'">true</UseAppleCrypto>
<DefineConstants Condition="'$(UseAndroidCrypto)' == 'true' or '$(UseAppleCrypto)' == 'true'">$(DefineConstants);SYSNETSECURITY_NO_OPENSSL</DefineConstants>
</PropertyGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != ''">
<Compile Include="System\Net\CertificateValidationPal.cs" />
<Compile Include="System\Net\Logging\NetEventSource.cs" />
<Compile Include="System\Net\SslStreamContext.cs" />
<Compile Include="System\Net\Security\AuthenticatedStream.cs" />
<Compile Include="System\Security\Authentication\AuthenticationException.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicy.cs" />
<Compile Include="System\Net\Security\NetEventSource.Security.cs" />
<Compile Include="System\Net\Security\NetSecurityTelemetry.cs" />
<Compile Include="System\Net\Security\ReadWriteAdapter.cs" />
<Compile Include="System\Net\Security\ProtectionLevel.cs" />
<Compile Include="System\Net\Security\SslApplicationProtocol.cs" />
<Compile Include="System\Net\Security\SslAuthenticationOptions.cs" />
<Compile Include="System\Net\Security\SslCertificateTrust.cs" />
<Compile Include="System\Net\Security\SslClientAuthenticationOptions.cs" />
<Compile Include="System\Net\Security\SslClientHelloInfo.cs" />
<Compile Include="System\Net\Security\SslServerAuthenticationOptions.cs" />
<Compile Include="System\Net\Security\SecureChannel.cs" />
<Compile Include="System\Net\Security\SslSessionsCache.cs" />
<Compile Include="System\Net\Security\SslStream.cs" />
<Compile Include="System\Net\Security\SslStream.Implementation.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.cs" />
<Compile Include="System\Net\Security\StreamSizes.cs" />
<Compile Include="System\Net\Security\TlsAlertType.cs" />
<Compile Include="System\Net\Security\TlsAlertMessage.cs" />
<Compile Include="System\Net\Security\TlsFrameHelper.cs" />
<!-- NegotiateStream -->
<Compile Include="System\Net\NTAuthentication.cs" />
<Compile Include="System\Net\StreamFramer.cs" />
<Compile Include="System\Net\Security\NegotiateStream.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\ExtendedProtectionPolicy.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\PolicyEnforcement.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\ProtectionScenario.cs" />
<Compile Include="System\Security\Authentication\ExtendedProtection\ServiceNameCollection.cs" />
<!-- Common sources -->
<Compile Include="$(CommonPath)DisableRuntimeMarshalling.cs"
Link="Common\DisableRuntimeMarshalling.cs" />
<!-- Logging -->
<Compile Include="$(CommonPath)System\Net\Logging\NetEventSource.Common.cs"
Link="Common\System\Net\Logging\NetEventSource.Common.cs" />
<Compile Include="$(CommonPath)System\Net\InternalException.cs"
Link="Common\System\Net\InternalException.cs" />
<Compile Include="$(CommonPath)Extensions\ValueStopwatch\ValueStopwatch.cs"
Link="Common\Extensions\ValueStopwatch\ValueStopwatch.cs" />
<!-- Debug only -->
<Compile Include="$(CommonPath)System\Net\DebugSafeHandle.cs"
Link="Common\System\Net\DebugSafeHandle.cs" />
<Compile Include="$(CommonPath)System\Net\DebugSafeHandleZeroOrMinusOneIsInvalid.cs"
Link="Common\System\Net\DebugSafeHandleZeroOrMinusOneIsInvalid.cs" />
<!-- System.Net common -->
<Compile Include="$(CommonPath)System\Net\ArrayBuffer.cs">
<Link>Common\System\Net\ArrayBuffer.cs</Link>
</Compile>
<Compile Include="$(CommonPath)System\Net\ExceptionCheck.cs"
Link="Common\System\Net\ExceptionCheck.cs" />
<Compile Include="$(CommonPath)System\Net\SecurityProtocol.cs"
Link="Common\System\Net\SecurityProtocol.cs" />
<Compile Include="$(CommonPath)System\Net\UriScheme.cs"
Link="Common\System\Net\UriScheme.cs" />
<!-- Common -->
<Compile Include="$(CommonPath)System\NotImplemented.cs"
Link="Common\System\NotImplemented.cs" />
<Compile Include="$(CommonPath)System\Threading\Tasks\TaskToApm.cs"
Link="Common\System\Threading\Tasks\TaskToApm.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SafeCredentialReference.cs"
Link="Common\System\Net\Security\SafeCredentialReference.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SSPIHandleCache.cs"
Link="Common\System\Net\Security\SSPIHandleCache.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsPal.cs"
Link="Common\System\Net\ContextFlagsPal.cs" />
<Compile Include="$(CommonPath)System\Net\NegotiationInfoClass.cs"
Link="Common\System\Net\NegotiationInfoClass.cs" />
<Compile Include="$(CommonPath)System\Net\NTAuthentication.Common.cs"
Link="Common\System\Net\NTAuthentication.Common.cs" />
<Compile Include="$(CommonPath)System\Net\SecurityStatusPal.cs"
Link="Common\System\Net\SecurityStatusPal.cs" />
<Compile Include="$(CommonPath)System\HexConverter.cs"
Link="Common\System\HexConverter.cs" />
</ItemGroup>
<!-- This file depends on IANA registry. We do not want anyone's build to break after the update -->
<!-- or if they don't have internet connection - explicit opt-in required -->
<!-- To expose newly generated APIs, generated file have to be deliberately copied -->
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != ''">
<Compile Include="System\Net\Security\TlsCipherSuite.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>TlsCipherSuite.tt</DependentUpon>
</Compile>
<None Include="System\Net\Security\TlsCipherSuiteNameParser.ttinclude" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows'">
<Compile Include="System\Net\Security\TlsCipherSuiteData.Lookup.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>TlsCipherSuiteData.Lookup.tt</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">
<None Include="System\Net\Security\TlsCipherSuiteData.Lookup.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>TlsCipherSuiteData.Lookup.tt</DependentUpon>
</None>
</ItemGroup>
<ItemGroup Condition="'$(AllowTlsCipherSuiteGeneration)' == 'true'">
<None Include="System\Net\Security\TlsCipherSuite.tt">
<Generator>TextTemplatingFileGenerator</Generator>
<LastGenOutput>TlsCipherSuite.cs</LastGenOutput>
</None>
<None Include="System\Net\Security\TlsCipherSuiteData.Lookup.tt">
<Generator>TextTemplatingFileGenerator</Generator>
<LastGenOutput>TlsCipherSuiteData.Lookup.cs</LastGenOutput>
</None>
</ItemGroup>
<ItemGroup Condition="'$(AllowTlsCipherSuiteGeneration)' != 'true'">
<None Include="System\Net\Security\TlsCipherSuite.tt" />
<None Include="System\Net\Security\TlsCipherSuiteData.Lookup.tt" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">
<Compile Include="System\Net\CertificateValidationPal.Windows.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.Windows.cs" />
<Compile Include="System\Net\Security\NegotiateStreamPal.Windows.cs" />
<Compile Include="System\Net\Security\NetEventSource.Security.Windows.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.Windows.cs" />
<Compile Include="System\Net\Security\SslStreamPal.Windows.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Windows.cs" />
<Compile Include="System\Net\Security\StreamSizes.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\CertificateValidation.Windows.cs"
Link="Common\System\Net\Security\CertificateValidation.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SecurityBuffer.Windows.cs"
Link="Common\System\Net\Security\SecurityBuffer.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SecurityBufferType.Windows.cs"
Link="Common\System\Net\Security\SecurityBufferType.Windows.cs" />
<!-- NegotiateStream -->
<Compile Include="$(CommonPath)System\Net\SecurityStatusAdapterPal.Windows.cs"
Link="Common\System\Net\SecurityStatusAdapterPal.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsAdapterPal.Windows.cs"
Link="Common\System\Net\ContextFlagsAdapterPal.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\NegotiateStreamPal.Windows.cs"
Link="Common\System\Net\Security\NegotiateStreamPal.Windows.cs" />
<Compile Include="$(CommonPath)System\Net\Security\SecurityContextTokenHandle.cs"
Link="Common\System\Net\Security\SecurityContextTokenHandle.cs" />
<!-- Interop -->
<Compile Include="$(CommonPath)Interop\Windows\Interop.BOOL.cs"
Link="Common\Interop\Windows\Interop.BOOL.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Interop.Libraries.cs"
Link="Common\Interop\Windows\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Interop.UNICODE_STRING.cs"
Link="Common\Interop\Windows\Interop.UNICODE_STRING.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CERT_CONTEXT.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CERT_CONTEXT.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CERT_INFO.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CERT_INFO.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CERT_PUBLIC_KEY_INFO.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CERT_PUBLIC_KEY_INFO.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CRYPT_ALGORITHM_IDENTIFIER.cs"
Link="Common\Interop\Windows\Crypt32\Interop.Interop.CRYPT_ALGORITHM_IDENTIFIER.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CRYPT_BIT_BLOB.cs"
Link="Common\Interop\Windows\Crypt32\Interop.Interop.CRYPT_BIT_BLOB.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.DATA_BLOB.cs"
Link="Common\Interop\Windows\Crypt32\Interop.DATA_BLOB.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.certificates.cs"
Link="Common\Interop\Windows\Crypt32\Interop.certificates.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.certificates_types.cs"
Link="Common\Interop\Windows\Crypt32\Interop.certificates_types.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.CertEnumCertificatesInStore.cs"
Link="Common\Interop\Windows\Crypt32\Interop.CertEnumCertificatesInStore.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Crypt32\Interop.MsgEncodingType.cs"
Link="Common\Interop\Windows\Crypt32\Interop.Interop.MsgEncodingType.cs" />
<Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.CloseHandle.cs"
Link="Common\Interop\Windows\Kernel32\Interop.CloseHandle.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.Alerts.cs"
Link="Common\Interop\Windows\SChannel\Interop.Alerts.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.SchProtocols.cs"
Link="Common\Interop\Windows\SChannel\Interop.SchProtocols.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.SECURITY_STATUS.cs"
Link="Common\Interop\Windows\SChannel\Interop.SECURITY_STATUS.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\SecPkgContext_ConnectionInfo.cs"
Link="Common\Interop\Windows\SChannel\SecPkgContext_ConnectionInfo.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\SecPkgContext_CipherInfo.cs"
Link="Common\Interop\Windows\SChannel\SecPkgContext_CipherInfo.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.SecPkgContext_ApplicationProtocol.cs"
Link="Common\Interop\Windows\SChannel\Interop.SecPkgContext_ApplicationProtocol.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\Interop.Sec_Application_Protocols.cs"
Link="Common\Interop\Windows\SChannel\Interop.Sec_Application_Protocols.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\UnmanagedCertificateContext.cs"
Link="Common\Interop\Windows\SChannel\UnmanagedCertificateContext.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SChannel\UnmanagedCertificateContext.IntPtr.cs"
Link="Common\Interop\Windows\SChannel\UnmanagedCertificateContext.IntPtr.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_Bindings.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_Bindings.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\GlobalSSPI.cs"
Link="Common\Interop\Windows\SspiCli\GlobalSSPI.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\Interop.SSPI.cs"
Link="Common\Interop\Windows\SspiCli\Interop.SSPI.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_NegotiationInfoW.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_NegotiationInfoW.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\NegotiationInfoClass.cs"
Link="Common\Interop\Windows\SspiCli\NegotiationInfoClass.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_Sizes.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_Sizes.cs" />
<Compile Include="$(CommonPath)System\Collections\Generic\BidirectionalDictionary.cs"
Link="Common\System\Collections\Generic\BidirectionalDictionary.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SafeDeleteContext.cs"
Link="Common\Interop\Windows\SspiCli\SafeDeleteContext.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecurityPackageInfo.cs"
Link="Common\Interop\Windows\SspiCli\SecurityPackageInfo.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecurityPackageInfoClass.cs"
Link="Common\Interop\Windows\SspiCli\SecurityPackageInfoClass.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecuritySafeHandles.cs"
Link="Common\Interop\Windows\SspiCli\SecuritySafeHandles.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SSPIAuthType.cs"
Link="Common\Interop\Windows\SspiCli\SSPIAuthType.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\ISSPIInterface.cs"
Link="Common\Interop\Windows\SspiCli\ISSPIInterface.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SSPISecureChannelType.cs"
Link="Common\Interop\Windows\SspiCli\SSPISecureChannelType.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SSPIWrapper.cs"
Link="Common\Interop\Windows\SspiCli\SSPIWrapper.cs" />
<Compile Include="$(CommonPath)Interop\Windows\SspiCli\SecPkgContext_StreamSizes.cs"
Link="Common\Interop\Windows\SspiCli\SecPkgContext_StreamSizes.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows'">
<Compile Include="$(CommonPath)Interop\Unix\Interop.Libraries.cs"
Link="Common\Interop\Unix\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\Unix\Interop.Errors.cs"
Link="Common\Interop\Unix\Interop.Errors.cs" />
<Compile Include="$(CommonPath)System\Net\Http\TlsCertificateExtensions.cs"
Link="Common\System\Net\Http\TlsCertificateExtensions.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.GssFlags.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.GssFlags.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.Status.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.Status.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeDeleteContext.cs"
Link="Common\System\Net\Security\Unix\SafeDeleteContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeCredentials.cs"
Link="Common\System\Net\Security\Unix\SafeFreeCredentials.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SecChannelBindings.cs"
Link="Common\System\Net\Security\Unix\SecChannelBindings.cs" />
<Compile Include="System\Net\Security\Pal.Managed\EndpointChannelBindingToken.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SafeChannelBindingHandle.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Unix.cs" />
<Compile Include="System\Net\Security\TlsCipherSuiteData.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows' and '$(TargetPlatformIdentifier)' != 'tvOS'">
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\GssSafeHandles.cs"
Link="Common\Microsoft\Win32\SafeHandles\GssSafeHandles.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeDeleteNegoContext.cs"
Link="Common\System\Net\Security\Unix\SafeDeleteNegoContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeNegoCredentials.cs"
Link="Common\System\Net\Security\Unix\SafeFreeNegoCredentials.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsAdapterPal.Unix.cs"
Link="Common\System\Net\ContextFlagsAdapterPal.Unix.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.Initialization.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.Initialization.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.GssApiException.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.GssApiException.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.GssBuffer.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.GssBuffer.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.IsNtlmInstalled.cs"
Link="Common\Interop\Unix\System.Net.Security.Native\Interop.NetSecurityNative.IsNtlmInstalled.cs" />
<Compile Include="$(CommonPath)System\Net\Security\NegotiateStreamPal.Unix.cs"
Link="Common\System\Net\Security\NegotiateStreamPal.Unix.cs" />
<Compile Include="System\Net\Security\NegotiateStreamPal.Unix.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'tvOS'">
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\GssSafeHandles.PlatformNotSupported.cs"
Link="Common\Microsoft\Win32\SafeHandles\GssSafeHandles.PlatformNotSupported.cs" />
<Compile Include="$(CommonPath)System\Net\ContextFlagsAdapterPal.PlatformNotSupported.cs"
Link="Common\System\Net\ContextFlagsAdapterPal.PlatformNotSupported.cs" />
<Compile Include="$(CommonPath)System\Net\Security\NegotiateStreamPal.PlatformNotSupported.cs"
Link="Common\System\Net\Security\NegotiateStreamPal.PlatformNotSupported.cs" />
<Compile Include="System\Net\Security\NegotiateStreamPal.PlatformNotSupported.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows' and '$(UseAndroidCrypto)' != 'true' and '$(UseAppleCrypto)' != 'true'">
<Compile Include="System\Net\CertificateValidationPal.Unix.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.Linux.cs" />
<Compile Include="System\Net\Security\SslStreamPal.Unix.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Linux.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.Linux.cs" />
<Compile Include="System\Net\Security\StreamSizes.Unix.cs" />
<Compile Include="$(CommonPath)System\Net\Security\CertificateValidation.Unix.cs"
Link="Common\System\Net\Security\CertificateValidation.Unix.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.BIO.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.Initialization.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.Initialization.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtx.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtx.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.SetProtocolOptions.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.SetProtocolOptions.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtxOptions.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtxOptions.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509Name.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509Name.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509Ext.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509Ext.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509Stack.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509Stack.cs" />
<Compile Include="$(CommonPath)Interop\Unix\System.Security.Cryptography.Native\Interop.X509StoreCtx.cs"
Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.X509StoreCtx.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeX509Handles.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeX509Handles.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\X509ExtensionSafeHandles.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\X509ExtensionSafeHandles.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeInteriorHandle.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeInteriorHandle.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeBioHandle.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeBioHandle.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\Asn1SafeHandles.Unix.cs"
Link="Common\Microsoft\Win32\SafeHandles\Asn1SafeHandles.Unix.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeHandleCache.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeHandleCache.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeDeleteSslContext.cs"
Link="Common\System\Net\Security\Unix\SafeDeleteSslContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeCertContext.cs"
Link="Common\System\Net\Security\Unix\SafeFreeCertContext.cs" />
<Compile Include="$(CommonPath)System\Net\Security\Unix\SafeFreeSslCredentials.cs"
Link="Common\System\Net\Security\Unix\SafeFreeSslCredentials.cs" />
</ItemGroup>
<ItemGroup Condition="'$(UseAndroidCrypto)' == 'true'">
<Compile Include="$(CommonPath)Interop\Android\Interop.Libraries.cs"
Link="Common\Interop\Android\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\Android\Interop.JObjectLifetime.cs"
Link="Common\Interop\Android\Interop.JObjectLifetime.cs" />
<Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.cs"
Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.cs" />
<Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.ProtocolSupport.cs"
Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.Ssl.ProtocolSupport.cs" />
<Compile Include="$(CommonPath)Interop\Android\System.Security.Cryptography.Native.Android\Interop.X509.cs"
Link="Common\Interop\Android\System.Security.Cryptography.Native.Android\Interop.X509.cs" />
<Compile Include="System\Net\CertificateValidationPal.Android.cs" />
<Compile Include="System\Net\Security\MD4.cs" />
<Compile Include="System\Net\Security\Pal.Android\SafeDeleteSslContext.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SafeFreeSslCredentials.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SslProtocolsValidation.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.Android.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.Android.cs" />
<Compile Include="System\Net\Security\SslStreamPal.Android.cs" />
<Compile Include="System\Net\Security\StreamSizes.Unix.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.Android.cs" />
</ItemGroup>
<ItemGroup Condition="'$(UseAppleCrypto)' == 'true'">
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFArray.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFArray.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFData.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFData.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFDate.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFDate.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFError.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFError.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.CoreFoundation.CFString.cs"
Link="Common\Interop\OSX\Interop.CoreFoundation.CFString.cs" />
<Compile Include="$(CommonPath)Interop\OSX\Interop.Libraries.cs"
Link="Common\Interop\OSX\Interop.Libraries.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SecErrMessage.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SecErrMessage.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SslErr.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.SslErr.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.Ssl.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.Ssl.cs" />
<Compile Include="$(CommonPath)Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.X509Chain.cs"
Link="Common\Interop\OSX\System.Security.Cryptography.Native.Apple\Interop.X509Chain.cs" />
<Compile Include="$(CommonPath)Microsoft\Win32\SafeHandles\SafeCreateHandle.OSX.cs"
Link="Common\Microsoft\Win32\SafeHandles\SafeCreateHandle.OSX.cs" />
<Compile Include="System\Net\CertificateValidationPal.OSX.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SafeFreeSslCredentials.cs" />
<Compile Include="System\Net\Security\Pal.Managed\SslProtocolsValidation.cs" />
<Compile Include="System\Net\Security\Pal.OSX\SafeDeleteSslContext.cs" />
<Compile Include="System\Net\Security\SslConnectionInfo.OSX.cs" />
<Compile Include="System\Net\Security\SslStreamCertificateContext.OSX.cs" />
<Compile Include="System\Net\Security\SslStreamPal.OSX.cs" />
<Compile Include="System\Net\Security\StreamSizes.OSX.cs" />
<Compile Include="System\Net\Security\CipherSuitesPolicyPal.OSX.cs" />
</ItemGroup>
<ItemGroup>
<Reference Include="Microsoft.Win32.Primitives" />
<Reference Include="System.Collections" />
<Reference Include="System.Collections.Concurrent" />
<Reference Include="System.Collections.NonGeneric" />
<Reference Include="System.Console" Condition="'$(Configuration)' == 'Debug'" />
<Reference Include="System.Diagnostics.Tracing" />
<Reference Include="System.Linq" />
<Reference Include="System.Memory" />
<Reference Include="System.Net.Primitives" />
<Reference Include="System.Net.Sockets" />
<Reference Include="System.Runtime" />
<Reference Include="System.Runtime.Extensions" />
<Reference Include="System.Runtime.CompilerServices.Unsafe" />
<Reference Include="System.Runtime.InteropServices" />
<Reference Include="System.Security.Claims" />
<Reference Include="System.Security.Cryptography" />
<Reference Include="System.Security.Cryptography.OpenSsl" />
<Reference Include="System.Security.Cryptography.X509Certificates" />
<Reference Include="System.Security.Principal" />
<Reference Include="System.Security.Principal.Windows" />
<Reference Include="System.Threading" />
<Reference Include="System.Threading.ThreadPool" />
</ItemGroup>
<ItemGroup Condition="'$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformIdentifier)' != 'windows'">
<Reference Include="System.Diagnostics.StackTrace" />
<Reference Include="System.Security.Cryptography.Algorithms" />
<Reference Include="System.Security.Cryptography" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/JIT/Directed/cmov/Int_And_Op_cs_d.csproj | <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="Int_And_Op.cs" />
</ItemGroup>
</Project>
| <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<PropertyGroup>
<DebugType>Full</DebugType>
<Optimize>False</Optimize>
</PropertyGroup>
<ItemGroup>
<Compile Include="Int_And_Op.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Rijndael.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Versioning;
using Internal.Cryptography;
namespace System.Security.Cryptography
{
[Obsolete(Obsoletions.RijndaelMessage, DiagnosticId = Obsoletions.RijndaelDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
[EditorBrowsable(EditorBrowsableState.Never)]
public abstract class Rijndael : SymmetricAlgorithm
{
[UnsupportedOSPlatform("browser")]
public static new Rijndael Create()
{
return new RijndaelImplementation();
}
[RequiresUnreferencedCode(CryptoConfig.CreateFromNameUnreferencedCodeMessage)]
public static new Rijndael? Create(string algName)
{
return (Rijndael?)CryptoConfig.CreateFromName(algName);
}
protected Rijndael()
{
LegalBlockSizesValue = s_legalBlockSizes.CloneKeySizesArray();
LegalKeySizesValue = s_legalKeySizes.CloneKeySizesArray();
KeySizeValue = 256;
BlockSizeValue = 128;
FeedbackSizeValue = BlockSizeValue;
}
private static readonly KeySizes[] s_legalBlockSizes =
{
new KeySizes(minSize: 128, maxSize: 256, skipSize: 64)
};
private static readonly KeySizes[] s_legalKeySizes =
{
new KeySizes(minSize: 128, maxSize: 256, skipSize: 64)
};
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Versioning;
using Internal.Cryptography;
namespace System.Security.Cryptography
{
[Obsolete(Obsoletions.RijndaelMessage, DiagnosticId = Obsoletions.RijndaelDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
[EditorBrowsable(EditorBrowsableState.Never)]
public abstract class Rijndael : SymmetricAlgorithm
{
[UnsupportedOSPlatform("browser")]
public static new Rijndael Create()
{
return new RijndaelImplementation();
}
[RequiresUnreferencedCode(CryptoConfig.CreateFromNameUnreferencedCodeMessage)]
public static new Rijndael? Create(string algName)
{
return (Rijndael?)CryptoConfig.CreateFromName(algName);
}
protected Rijndael()
{
LegalBlockSizesValue = s_legalBlockSizes.CloneKeySizesArray();
LegalKeySizesValue = s_legalKeySizes.CloneKeySizesArray();
KeySizeValue = 256;
BlockSizeValue = 128;
FeedbackSizeValue = BlockSizeValue;
}
private static readonly KeySizes[] s_legalBlockSizes =
{
new KeySizes(minSize: 128, maxSize: 256, skipSize: 64)
};
private static readonly KeySizes[] s_legalKeySizes =
{
new KeySizes(minSize: 128, maxSize: 256, skipSize: 64)
};
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.DirectoryServices.AccountManagement/src/System/DirectoryServices/AccountManagement/IdentityType.cs | // 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 System.Collections.Generic;
namespace System.DirectoryServices.AccountManagement
{
public enum IdentityType
{
SamAccountName = 0,
Name = 1,
UserPrincipalName = 2,
DistinguishedName = 3,
Sid = 4,
Guid = 5
}
internal static class IdentMap
{
internal static object[,] StringMap = {
{IdentityType.SamAccountName, IdentityTypeStringMap.SamAccount},
{IdentityType.Name, IdentityTypeStringMap.Name},
{IdentityType.UserPrincipalName, IdentityTypeStringMap.Upn},
{IdentityType.DistinguishedName, IdentityTypeStringMap.DistinguishedName},
{IdentityType.Sid, IdentityTypeStringMap.Sid},
{IdentityType.Guid, IdentityTypeStringMap.Guid}
};
}
internal static class IdentityTypeStringMap
{
public const string Guid = "ms-guid";
public const string Sid = "ms-sid";
public const string DistinguishedName = "ldap-dn";
public const string SamAccount = "ms-nt4account";
public const string Upn = "ms-upn";
public const string Name = "ms-name";
}
}
| // 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 System.Collections.Generic;
namespace System.DirectoryServices.AccountManagement
{
public enum IdentityType
{
SamAccountName = 0,
Name = 1,
UserPrincipalName = 2,
DistinguishedName = 3,
Sid = 4,
Guid = 5
}
internal static class IdentMap
{
internal static object[,] StringMap = {
{IdentityType.SamAccountName, IdentityTypeStringMap.SamAccount},
{IdentityType.Name, IdentityTypeStringMap.Name},
{IdentityType.UserPrincipalName, IdentityTypeStringMap.Upn},
{IdentityType.DistinguishedName, IdentityTypeStringMap.DistinguishedName},
{IdentityType.Sid, IdentityTypeStringMap.Sid},
{IdentityType.Guid, IdentityTypeStringMap.Guid}
};
}
internal static class IdentityTypeStringMap
{
public const string Guid = "ms-guid";
public const string Sid = "ms-sid";
public const string DistinguishedName = "ldap-dn";
public const string SamAccount = "ms-nt4account";
public const string Upn = "ms-upn";
public const string Name = "ms-name";
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Net.WebSockets/tests/WebSocketDeflateOptionsTests.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.Net.WebSockets.Tests
{
public class WebSocketDeflateOptionsTests
{
[Fact]
public void ClientMaxWindowBits()
{
WebSocketDeflateOptions options = new();
Assert.Equal(15, options.ClientMaxWindowBits);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ClientMaxWindowBits = 8);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ClientMaxWindowBits = 16);
options.ClientMaxWindowBits = 14;
Assert.Equal(14, options.ClientMaxWindowBits);
}
[Fact]
public void ServerMaxWindowBits()
{
WebSocketDeflateOptions options = new();
Assert.Equal(15, options.ServerMaxWindowBits);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ServerMaxWindowBits = 8);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ServerMaxWindowBits = 16);
options.ServerMaxWindowBits = 14;
Assert.Equal(14, options.ServerMaxWindowBits);
}
[Fact]
public void ContextTakeover()
{
WebSocketDeflateOptions options = new();
Assert.True(options.ClientContextTakeover);
Assert.True(options.ServerContextTakeover);
options.ClientContextTakeover = false;
Assert.False(options.ClientContextTakeover);
options.ServerContextTakeover = false;
Assert.False(options.ServerContextTakeover);
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace System.Net.WebSockets.Tests
{
public class WebSocketDeflateOptionsTests
{
[Fact]
public void ClientMaxWindowBits()
{
WebSocketDeflateOptions options = new();
Assert.Equal(15, options.ClientMaxWindowBits);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ClientMaxWindowBits = 8);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ClientMaxWindowBits = 16);
options.ClientMaxWindowBits = 14;
Assert.Equal(14, options.ClientMaxWindowBits);
}
[Fact]
public void ServerMaxWindowBits()
{
WebSocketDeflateOptions options = new();
Assert.Equal(15, options.ServerMaxWindowBits);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ServerMaxWindowBits = 8);
Assert.Throws<ArgumentOutOfRangeException>(() => options.ServerMaxWindowBits = 16);
options.ServerMaxWindowBits = 14;
Assert.Equal(14, options.ServerMaxWindowBits);
}
[Fact]
public void ContextTakeover()
{
WebSocketDeflateOptions options = new();
Assert.True(options.ClientContextTakeover);
Assert.True(options.ServerContextTakeover);
options.ClientContextTakeover = false;
Assert.False(options.ClientContextTakeover);
options.ServerContextTakeover = false;
Assert.False(options.ServerContextTakeover);
}
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Text.Json/gen/Reflection/AssemblyWrapper.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Reflection;
using Microsoft.CodeAnalysis;
namespace System.Text.Json.Reflection
{
internal class AssemblyWrapper : Assembly
{
private readonly MetadataLoadContextInternal _metadataLoadContext;
public AssemblyWrapper(IAssemblySymbol assembly, MetadataLoadContextInternal metadataLoadContext)
{
Symbol = assembly;
_metadataLoadContext = metadataLoadContext;
}
internal IAssemblySymbol Symbol { get; }
public override string FullName => Symbol.Identity.Name;
public override Type[] GetExportedTypes()
{
return GetTypes();
}
public override Type[] GetTypes()
{
var types = new List<Type>();
var stack = new Stack<INamespaceSymbol>();
stack.Push(Symbol.GlobalNamespace);
while (stack.Count > 0)
{
INamespaceSymbol current = stack.Pop();
foreach (INamedTypeSymbol type in current.GetTypeMembers())
{
types.Add(type.AsType(_metadataLoadContext));
}
foreach (INamespaceSymbol ns in current.GetNamespaceMembers())
{
stack.Push(ns);
}
}
return types.ToArray();
}
public override Type GetType(string name)
{
return Symbol.GetTypeByMetadataName(name)!.AsType(_metadataLoadContext);
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Reflection;
using Microsoft.CodeAnalysis;
namespace System.Text.Json.Reflection
{
internal class AssemblyWrapper : Assembly
{
private readonly MetadataLoadContextInternal _metadataLoadContext;
public AssemblyWrapper(IAssemblySymbol assembly, MetadataLoadContextInternal metadataLoadContext)
{
Symbol = assembly;
_metadataLoadContext = metadataLoadContext;
}
internal IAssemblySymbol Symbol { get; }
public override string FullName => Symbol.Identity.Name;
public override Type[] GetExportedTypes()
{
return GetTypes();
}
public override Type[] GetTypes()
{
var types = new List<Type>();
var stack = new Stack<INamespaceSymbol>();
stack.Push(Symbol.GlobalNamespace);
while (stack.Count > 0)
{
INamespaceSymbol current = stack.Pop();
foreach (INamedTypeSymbol type in current.GetTypeMembers())
{
types.Add(type.AsType(_metadataLoadContext));
}
foreach (INamespaceSymbol ns in current.GetNamespaceMembers())
{
stack.Push(ns);
}
}
return types.ToArray();
}
public override Type GetType(string name)
{
return Symbol.GetTypeByMetadataName(name)!.AsType(_metadataLoadContext);
}
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/.nuget/Microsoft.NETCore.TestHost/Microsoft.NETCore.TestHost.pkgproj | <Project DefaultTargets="Build">
<Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
<PropertyGroup>
<!-- This is not a product assembly, nor is it a shipping package. It's only meant for testing consumption in upstack repos.-->
<IsShipping>false</IsShipping>
<PackageDescription>CoreCLR application host for test applications.</PackageDescription>
</PropertyGroup>
<PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
<IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
<PackageTargetRuntime Condition="'$(_packageTargetOSGroup)' == 'windows'">$(MinOSForArch)-$(PackagePlatform)</PackageTargetRuntime>
</PropertyGroup>
<ItemGroup>
<NativeBinary Include="$(RuntimeBinDir)corerun$(ExeSuffix)" />
</ItemGroup>
<Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
</Project>
| <Project DefaultTargets="Build">
<Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
<PropertyGroup>
<!-- This is not a product assembly, nor is it a shipping package. It's only meant for testing consumption in upstack repos.-->
<IsShipping>false</IsShipping>
<PackageDescription>CoreCLR application host for test applications.</PackageDescription>
</PropertyGroup>
<PropertyGroup Condition="'$(PackageTargetRuntime)' == ''">
<IsLineupPackage Condition="'$(IsLineupPackage)' == ''">true</IsLineupPackage>
<PackageTargetRuntime Condition="'$(_packageTargetOSGroup)' == 'windows'">$(MinOSForArch)-$(PackagePlatform)</PackageTargetRuntime>
</PropertyGroup>
<ItemGroup>
<NativeBinary Include="$(RuntimeBinDir)corerun$(ExeSuffix)" />
</ItemGroup>
<Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
</Project>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/Loader/classloader/TypeGeneratorTests/TypeGeneratorTest107/Generated107.ilproj | <Project Sdk="Microsoft.NET.Sdk.IL">
<PropertyGroup>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="Generated107.il" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\TestFramework\TestFramework.csproj" />
</ItemGroup>
</Project>
| <Project Sdk="Microsoft.NET.Sdk.IL">
<PropertyGroup>
<CLRTestPriority>1</CLRTestPriority>
</PropertyGroup>
<ItemGroup>
<Compile Include="Generated107.il" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\TestFramework\TestFramework.csproj" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/JIT/Generics/Instantiation/Classes/baseclass01.csproj | <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>PdbOnly</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Include="BaseClass01.cs" />
</ItemGroup>
</Project>
| <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
</PropertyGroup>
<PropertyGroup>
<DebugType>PdbOnly</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Include="BaseClass01.cs" />
</ItemGroup>
</Project>
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncIteratorStateMachineAttribute.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Runtime.CompilerServices
{
/// <summary>Indicates whether a method is an asynchronous iterator.</summary>
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public sealed class AsyncIteratorStateMachineAttribute : StateMachineAttribute
{
/// <summary>Initializes a new instance of the <see cref="AsyncIteratorStateMachineAttribute"/> class.</summary>
/// <param name="stateMachineType">The type object for the underlying state machine type that's used to implement a state machine method.</param>
public AsyncIteratorStateMachineAttribute(Type stateMachineType)
: base(stateMachineType)
{
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
namespace System.Runtime.CompilerServices
{
/// <summary>Indicates whether a method is an asynchronous iterator.</summary>
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public sealed class AsyncIteratorStateMachineAttribute : StateMachineAttribute
{
/// <summary>Initializes a new instance of the <see cref="AsyncIteratorStateMachineAttribute"/> class.</summary>
/// <param name="stateMachineType">The type object for the underlying state machine type that's used to implement a state machine method.</param>
public AsyncIteratorStateMachineAttribute(Type stateMachineType)
: base(stateMachineType)
{
}
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/Common/src/Interop/Unix/System.Native/Interop.FSync.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
internal static partial class Interop
{
internal static partial class Sys
{
[GeneratedDllImport(Libraries.SystemNative, EntryPoint = "SystemNative_FSync", SetLastError = true)]
internal static partial int FSync(SafeFileHandle fd);
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
internal static partial class Interop
{
internal static partial class Sys
{
[GeneratedDllImport(Libraries.SystemNative, EntryPoint = "SystemNative_FSync", SetLastError = true)]
internal static partial int FSync(SafeFileHandle fd);
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/coreclr/vm/stubgen.h | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// File: StubGen.h
//
//
#ifndef __STUBGEN_H__
#define __STUBGEN_H__
#include "stublink.h"
struct ILStubEHClause;
class ILStubLinker;
#ifndef DACCESS_COMPILE
struct StructMarshalStubs
{
static const DWORD MANAGED_STRUCT_ARGIDX = 0;
static const DWORD NATIVE_STRUCT_ARGIDX = 1;
static const DWORD OPERATION_ARGIDX = 2;
static const DWORD CLEANUP_WORK_LIST_ARGIDX = 3;
enum MarshalOperation
{
Marshal,
Unmarshal,
Cleanup
};
};
struct LocalDesc
{
const static size_t MAX_LOCALDESC_ELEMENTS = 8;
BYTE ElementType[MAX_LOCALDESC_ELEMENTS];
size_t cbType;
TypeHandle InternalToken; // only valid with ELEMENT_TYPE_INTERNAL
// used only for E_T_FNPTR and E_T_ARRAY
PCCOR_SIGNATURE pSig;
union
{
Module* pSigModule;
size_t cbArrayBoundsInfo;
BOOL bIsCopyConstructed; // used for E_T_PTR
};
LocalDesc()
{
}
inline LocalDesc(CorElementType elemType)
{
ElementType[0] = static_cast<BYTE>(elemType);
cbType = 1;
bIsCopyConstructed = FALSE;
}
inline LocalDesc(TypeHandle thType)
{
ElementType[0] = ELEMENT_TYPE_INTERNAL;
cbType = 1;
InternalToken = thType;
bIsCopyConstructed = FALSE;
}
inline LocalDesc(MethodTable *pMT)
{
WRAPPER_NO_CONTRACT;
ElementType[0] = ELEMENT_TYPE_INTERNAL;
cbType = 1;
InternalToken = TypeHandle(pMT);
bIsCopyConstructed = FALSE;
}
void MakeByRef()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_BYREF);
}
void MakePinned()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_PINNED);
}
void MakeArray()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_SZARRAY);
}
// makes the LocalDesc semantically equivalent to ET_TYPE_CMOD_REQD<IsCopyConstructed>/ET_TYPE_CMOD_REQD<NeedsCopyConstructorModifier>
void MakeCopyConstructedPointer()
{
LIMITED_METHOD_CONTRACT;
MakePointer();
bIsCopyConstructed = TRUE;
}
void MakePointer()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_PTR);
}
void ChangeType(CorElementType elemType)
{
LIMITED_METHOD_CONTRACT;
PREFIX_ASSUME((MAX_LOCALDESC_ELEMENTS-1) >= cbType);
for (size_t i = cbType; i >= 1; i--)
{
ElementType[i] = ElementType[i-1];
}
ElementType[0] = static_cast<BYTE>(elemType);
cbType += 1;
}
bool IsValueClass()
{
CONTRACTL
{
THROWS;
GC_TRIGGERS;
MODE_ANY;
}
CONTRACTL_END;
bool lastElementTypeIsValueType = false;
if (ElementType[cbType - 1] == ELEMENT_TYPE_VALUETYPE)
{
lastElementTypeIsValueType = true;
}
else if ((ElementType[cbType - 1] == ELEMENT_TYPE_INTERNAL) &&
(InternalToken.IsNativeValueType() ||
InternalToken.GetMethodTable()->IsValueType()))
{
lastElementTypeIsValueType = true;
}
if (!lastElementTypeIsValueType)
{
return false;
}
// verify that the prefix element types don't make the type a non-value type
// this only works on LocalDescs with the prefixes exposed in the Add* methods above.
for (size_t i = 0; i < cbType - 1; i++)
{
if (ElementType[i] == ELEMENT_TYPE_BYREF
|| ElementType[i] == ELEMENT_TYPE_SZARRAY
|| ElementType[i] == ELEMENT_TYPE_PTR)
{
return false;
}
}
return true;
}
};
class StubSigBuilder
{
public:
StubSigBuilder();
DWORD Append(LocalDesc* pLoc);
protected:
CQuickBytes m_qbSigBuffer;
uint32_t m_nItems;
BYTE* m_pbSigCursor;
size_t m_cbSig;
enum Constants { INITIAL_BUFFER_SIZE = 256 };
void EnsureEnoughQuickBytes(size_t cbToAppend);
};
//---------------------------------------------------------------------------------------
//
class LocalSigBuilder : protected StubSigBuilder
{
public:
DWORD NewLocal(LocalDesc * pLoc)
{
CONTRACTL
{
THROWS;
GC_TRIGGERS;
MODE_ANY;
PRECONDITION(CheckPointer(pLoc));
}
CONTRACTL_END;
return Append(pLoc);
}
DWORD GetSigSize();
DWORD GetSig(BYTE * pbSig, DWORD cbBuffer);
}; // class LocalSigBuilder
//---------------------------------------------------------------------------------------
//
class FunctionSigBuilder : protected StubSigBuilder
{
public:
FunctionSigBuilder();
DWORD NewArg(LocalDesc * pArg)
{
WRAPPER_NO_CONTRACT;
return Append(pArg);
}
DWORD GetNumArgs()
{
LIMITED_METHOD_CONTRACT;
return m_nItems;
}
void SetCallingConv(CorCallingConvention callingConv)
{
LIMITED_METHOD_CONTRACT;
m_callingConv = callingConv;
}
void AddCallConvModOpt(mdToken token);
CorCallingConvention GetCallingConv()
{
LIMITED_METHOD_CONTRACT;
return m_callingConv;
}
void SetSig(PCCOR_SIGNATURE pSig, DWORD cSig);
DWORD GetSigSize();
DWORD GetSig(BYTE * pbSig, DWORD cbBuffer);
void SetReturnType(LocalDesc* pLoc);
CorElementType GetReturnElementType()
{
LIMITED_METHOD_CONTRACT;
CONSISTENCY_CHECK(m_qbReturnSig.Size() > 0);
return *(CorElementType *)m_qbReturnSig.Ptr();
}
PCCOR_SIGNATURE GetReturnSig()
{
LIMITED_METHOD_CONTRACT;
CONSISTENCY_CHECK(m_qbReturnSig.Size() > 0);
return (PCCOR_SIGNATURE)m_qbReturnSig.Ptr();
}
protected:
CorCallingConvention m_callingConv;
CQuickBytes m_qbReturnSig;
CQuickBytes m_qbCallConvModOpts;
}; // class FunctionSigBuilder
#endif // DACCESS_COMPILE
#ifdef _DEBUG
// exercise the resize code
#define TOKEN_LOOKUP_MAP_SIZE (8*sizeof(void*))
#else // _DEBUG
#define TOKEN_LOOKUP_MAP_SIZE (64*sizeof(void*))
#endif // _DEBUG
//---------------------------------------------------------------------------------------
//
class TokenLookupMap
{
public:
TokenLookupMap()
{
STANDARD_VM_CONTRACT;
m_qbEntries.AllocThrows(TOKEN_LOOKUP_MAP_SIZE);
m_nextAvailableRid = 0;
}
// copy ctor
TokenLookupMap(TokenLookupMap* pSrc)
{
STANDARD_VM_CONTRACT;
m_nextAvailableRid = pSrc->m_nextAvailableRid;
size_t size = pSrc->m_qbEntries.Size();
m_qbEntries.AllocThrows(size);
memcpy(m_qbEntries.Ptr(), pSrc->m_qbEntries.Ptr(), size);
m_signatures.Preallocate(pSrc->m_signatures.GetCount());
for (COUNT_T i = 0; i < pSrc->m_signatures.GetCount(); i++)
{
const CQuickBytesSpecifySize<16>& src = pSrc->m_signatures[i];
CQuickBytesSpecifySize<16>& dst = *m_signatures.Append();
dst.AllocThrows(src.Size());
memcpy(dst.Ptr(), src.Ptr(), src.Size());
}
}
TypeHandle LookupTypeDef(mdToken token)
{
WRAPPER_NO_CONTRACT;
return LookupTokenWorker<mdtTypeDef, MethodTable*>(token);
}
MethodDesc* LookupMethodDef(mdToken token)
{
WRAPPER_NO_CONTRACT;
return LookupTokenWorker<mdtMethodDef, MethodDesc*>(token);
}
FieldDesc* LookupFieldDef(mdToken token)
{
WRAPPER_NO_CONTRACT;
return LookupTokenWorker<mdtFieldDef, FieldDesc*>(token);
}
SigPointer LookupSig(mdToken token)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(RidFromToken(token)-1 < m_signatures.GetCount());
PRECONDITION(RidFromToken(token) != 0);
PRECONDITION(TypeFromToken(token) == mdtSignature);
}
CONTRACTL_END;
CQuickBytesSpecifySize<16>& sigData = m_signatures[static_cast<COUNT_T>(RidFromToken(token)-1)];
PCCOR_SIGNATURE pSig = (PCCOR_SIGNATURE)sigData.Ptr();
DWORD cbSig = static_cast<DWORD>(sigData.Size());
return SigPointer(pSig, cbSig);
}
mdToken GetToken(TypeHandle pMT)
{
WRAPPER_NO_CONTRACT;
return GetTokenWorker<mdtTypeDef, TypeHandle>(pMT);
}
mdToken GetToken(MethodDesc* pMD)
{
WRAPPER_NO_CONTRACT;
return GetTokenWorker<mdtMethodDef, MethodDesc*>(pMD);
}
mdToken GetToken(FieldDesc* pFieldDesc)
{
WRAPPER_NO_CONTRACT;
return GetTokenWorker<mdtFieldDef, FieldDesc*>(pFieldDesc);
}
mdToken GetSigToken(PCCOR_SIGNATURE pSig, DWORD cbSig)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(pSig != NULL);
}
CONTRACTL_END;
mdToken token = TokenFromRid(m_signatures.GetCount(), mdtSignature)+1;
CQuickBytesSpecifySize<16>& sigData = *m_signatures.Append();
sigData.AllocThrows(cbSig);
memcpy(sigData.Ptr(), pSig, cbSig);
return token;
}
protected:
template<mdToken TokenType, typename HandleType>
HandleType LookupTokenWorker(mdToken token)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(RidFromToken(token)-1 < m_nextAvailableRid);
PRECONDITION(RidFromToken(token) != 0);
PRECONDITION(TypeFromToken(token) == TokenType);
}
CONTRACTL_END;
return ((HandleType*)m_qbEntries.Ptr())[RidFromToken(token)-1];
}
template<mdToken TokenType, typename HandleType>
mdToken GetTokenWorker(HandleType handle)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(handle != NULL);
}
CONTRACTL_END;
if (m_qbEntries.Size() <= (sizeof(handle) * m_nextAvailableRid))
{
m_qbEntries.ReSizeThrows(2 * m_qbEntries.Size());
}
mdToken token = TokenFromRid(m_nextAvailableRid++, TokenType)+1;
((HandleType*)m_qbEntries.Ptr())[RidFromToken(token)-1] = handle;
return token;
}
unsigned int m_nextAvailableRid;
CQuickBytesSpecifySize<TOKEN_LOOKUP_MAP_SIZE> m_qbEntries;
SArray<CQuickBytesSpecifySize<16>, FALSE> m_signatures;
};
class ILCodeLabel;
class ILCodeStream;
#ifndef DACCESS_COMPILE
struct ILStubEHClause
{
enum Kind { kNone, kTypedCatch, kFinally };
DWORD kind;
DWORD dwTryBeginOffset;
DWORD cbTryLength;
DWORD dwHandlerBeginOffset;
DWORD cbHandlerLength;
DWORD dwTypeToken;
};
struct ILStubEHClauseBuilder
{
DWORD kind;
ILCodeLabel* tryBeginLabel;
ILCodeLabel* tryEndLabel;
ILCodeLabel* handlerBeginLabel;
ILCodeLabel* handlerEndLabel;
DWORD typeToken;
};
enum ILStubLinkerFlags
{
ILSTUB_LINKER_FLAG_NONE = 0x00,
ILSTUB_LINKER_FLAG_TARGET_HAS_THIS = 0x01,
ILSTUB_LINKER_FLAG_STUB_HAS_THIS = 0x02,
ILSTUB_LINKER_FLAG_NDIRECT = 0x04,
ILSTUB_LINKER_FLAG_REVERSE = 0x08,
ILSTUB_LINKER_FLAG_SUPPRESSGCTRANSITION = 0x10,
};
//---------------------------------------------------------------------------------------
//
class ILStubLinker
{
friend class ILCodeLabel;
friend class ILCodeStream;
public:
ILStubLinker(Module* pModule, const Signature &signature, SigTypeContext *pTypeContext, MethodDesc *pMD, ILStubLinkerFlags flags);
~ILStubLinker();
void GenerateCode(BYTE* pbBuffer, size_t cbBufferSize);
void ClearCode();
void SetStubMethodDesc(MethodDesc *pMD);
protected:
void DeleteCodeLabels();
void DeleteCodeStreams();
struct ILInstruction
{
UINT16 uInstruction;
INT16 iStackDelta;
UINT_PTR uArg;
};
static void PatchInstructionArgument(ILCodeLabel* pLabel, UINT_PTR uNewArg
DEBUG_ARG(UINT16 uExpectedInstruction));
#ifdef _DEBUG
bool IsInCodeStreamList(ILCodeStream* pcs);
#endif // _DEBUG
public:
void SetHasThis (bool fHasThis);
bool HasThis () { LIMITED_METHOD_CONTRACT; return m_fHasThis; }
DWORD GetLocalSigSize();
DWORD GetLocalSig(BYTE * pbLocalSig, DWORD cbBuffer);
DWORD GetStubTargetMethodSigSize();
DWORD GetStubTargetMethodSig(BYTE * pbLocalSig, DWORD cbBuffer);
void SetStubTargetMethodSig(PCCOR_SIGNATURE pSig, DWORD cSig);
void GetStubTargetReturnType(LocalDesc * pLoc);
void GetStubTargetReturnType(LocalDesc * pLoc, Module * pModule);
void GetStubArgType(LocalDesc * pLoc);
void GetStubArgType(LocalDesc * pLoc, Module * pModule);
void GetStubReturnType(LocalDesc * pLoc);
void GetStubReturnType(LocalDesc * pLoc, Module * pModule);
CorCallingConvention GetStubTargetCallingConv();
CorElementType GetStubTargetReturnElementType() { WRAPPER_NO_CONTRACT; return m_nativeFnSigBuilder.GetReturnElementType(); }
static void GetManagedTypeHelper(LocalDesc* pLoc, Module* pModule, PCCOR_SIGNATURE pSig, SigTypeContext *pTypeContext, MethodDesc *pMD);
BOOL StubHasVoidReturnType();
Stub *Link(LoaderHeap *pHeap, UINT *pcbSize /* = NULL*/, BOOL fMC);
size_t Link(UINT* puMaxStack);
size_t GetNumEHClauses();
// Write out EH clauses. Number of items written out will be GetNumEHCLauses().
void WriteEHClauses(COR_ILMETHOD_SECT_EH* sect);
TokenLookupMap* GetTokenLookupMap() { LIMITED_METHOD_CONTRACT; return &m_tokenMap; }
enum CodeStreamType
{
kSetup,
kMarshal,
kDispatch,
kReturnUnmarshal,
kUnmarshal,
kExceptionCleanup,
kCleanup,
kExceptionHandler,
};
ILCodeStream* NewCodeStream(CodeStreamType codeStreamType);
MethodDesc *GetTargetMD() { LIMITED_METHOD_CONTRACT; return m_pMD; }
Signature GetStubSignature() { LIMITED_METHOD_CONTRACT; return m_stubSig; }
void ClearCodeStreams();
void LogILStub(CORJIT_FLAGS jitFlags, SString *pDumpILStubCode = NULL);
protected:
void DumpIL_FormatToken(mdToken token, SString &strTokenFormatting);
void LogILStubWorker(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode, INT* piCurStack, SString *pDumpILStubCode = NULL);
void LogILInstruction(size_t curOffset, bool isLabeled, INT iCurStack, ILInstruction* pInstruction, SString *pDumpILStubCode = NULL);
private:
ILCodeStream* m_pCodeStreamList;
TokenLookupMap m_tokenMap;
LocalSigBuilder m_localSigBuilder;
FunctionSigBuilder m_nativeFnSigBuilder;
BYTE m_rgbBuffer[sizeof(COR_ILMETHOD_DECODER)];
Signature m_stubSig; // managed sig of stub
SigTypeContext* m_pTypeContext; // type context for m_stubSig
SigPointer m_managedSigPtr;
void* m_pCode;
Module* m_pStubSigModule;
ILCodeLabel* m_pLabelList;
bool FirstPassLink(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode, INT* piCurStack, UINT* puMaxStack);
void SecondPassLink(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pCurCodeOffset);
BYTE* GenerateCodeWorker(BYTE* pbBuffer, ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode);
static ILCodeStream* FindLastCodeStream(ILCodeStream* pList);
protected:
//
// the public entrypoints for these methods are in ILCodeStream
//
ILCodeLabel* NewCodeLabel();
int GetToken(MethodDesc* pMD);
int GetToken(MethodTable* pMT);
int GetToken(TypeHandle th);
int GetToken(FieldDesc* pFD);
int GetSigToken(PCCOR_SIGNATURE pSig, DWORD cbSig);
DWORD NewLocal(CorElementType typ = ELEMENT_TYPE_I);
DWORD NewLocal(LocalDesc loc);
DWORD SetStubTargetArgType(CorElementType typ, bool fConsumeStubArg = true);
DWORD SetStubTargetArgType(LocalDesc* pLoc = NULL, bool fConsumeStubArg = true); // passing pLoc = NULL means "use stub arg type"
void SetStubTargetReturnType(CorElementType typ);
void SetStubTargetReturnType(LocalDesc* pLoc);
void SetStubTargetCallingConv(CorCallingConvention uNativeCallingConv);
void SetStubTargetCallingConv(CorInfoCallConvExtension callConv);
bool ReturnOpcodePopsStack()
{
if ((!m_fIsReverseStub && m_StubHasVoidReturnType) || (m_fIsReverseStub && m_StubTargetHasVoidReturnType))
{
return false;
}
return true;
}
void TransformArgForJIT(LocalDesc *pLoc);
Module * GetStubSigModule();
SigTypeContext *GetStubSigTypeContext();
BOOL m_StubHasVoidReturnType;
BOOL m_StubTargetHasVoidReturnType;
BOOL m_fIsReverseStub;
INT m_iTargetStackDelta;
DWORD m_cbCurrentCompressedSigLen;
DWORD m_nLocals;
bool m_fHasThis;
// We need this MethodDesc so we can reconstruct the generics
// SigTypeContext info, if needed.
MethodDesc * m_pMD;
}; // class ILStubLinker
//---------------------------------------------------------------------------------------
//
class ILCodeLabel
{
friend class ILStubLinker;
friend class ILCodeStream;
public:
ILCodeLabel();
~ILCodeLabel();
size_t GetCodeOffset();
private:
void SetCodeOffset(size_t codeOffset);
ILCodeLabel* m_pNext;
ILStubLinker* m_pOwningStubLinker;
ILCodeStream* m_pCodeStreamOfLabel; // this is the ILCodeStream that the index is relative to
size_t m_codeOffset; // this is the absolute resolved IL offset after linking
UINT m_idxLabeledInstruction; // this is the index within the instruction buffer of the owning ILCodeStream
};
class ILCodeStream
{
friend class ILStubLinker;
public:
enum ILInstrEnum
{
#define OPDEF(name,string,pop,push,oprType,opcType,l,s1,s2,ctrl) \
name,
#include "opcode.def"
#undef OPDEF
};
private:
static ILInstrEnum LowerOpcode(ILInstrEnum instr, ILStubLinker::ILInstruction* pInstr);
#ifdef _DEBUG
static bool IsSupportedInstruction(ILInstrEnum instr);
#endif // _DEBUG
static bool IsBranchInstruction(ILInstrEnum instr)
{
LIMITED_METHOD_CONTRACT;
return ((instr >= CEE_BR) && (instr <= CEE_BLT_UN)) || (instr == CEE_LEAVE);
}
void BeginHandler (DWORD kind, DWORD typeToken);
void EndHandler (DWORD kind);
public:
void BeginTryBlock ();
void EndTryBlock ();
void BeginCatchBlock(int token);
void EndCatchBlock ();
void BeginFinallyBlock();
void EndFinallyBlock();
void EmitADD ();
void EmitADD_OVF ();
void EmitAND ();
void EmitARGLIST ();
void EmitBEQ (ILCodeLabel* pCodeLabel);
void EmitBGE (ILCodeLabel* pCodeLabel);
void EmitBGE_UN (ILCodeLabel* pCodeLabel);
void EmitBGT (ILCodeLabel* pCodeLabel);
void EmitBLE (ILCodeLabel* pCodeLabel);
void EmitBLE_UN (ILCodeLabel* pCodeLabel);
void EmitBLT (ILCodeLabel* pCodeLabel);
void EmitBNE_UN (ILCodeLabel* pCodeLabel);
void EmitBR (ILCodeLabel* pCodeLabel);
void EmitBREAK ();
void EmitBRFALSE (ILCodeLabel* pCodeLabel);
void EmitBRTRUE (ILCodeLabel* pCodeLabel);
void EmitCALL (int token, int numInArgs, int numRetArgs);
void EmitCALLI (int token, int numInArgs, int numRetArgs);
void EmitCALLVIRT (int token, int numInArgs, int numRetArgs);
void EmitCEQ ();
void EmitCGT ();
void EmitCGT_UN ();
void EmitCLT ();
void EmitCLT_UN ();
void EmitCONV_I ();
void EmitCONV_I1 ();
void EmitCONV_I2 ();
void EmitCONV_I4 ();
void EmitCONV_I8 ();
void EmitCONV_U ();
void EmitCONV_U1 ();
void EmitCONV_U2 ();
void EmitCONV_U4 ();
void EmitCONV_U8 ();
void EmitCONV_R4 ();
void EmitCONV_R8 ();
void EmitCONV_OVF_I4();
void EmitCONV_T (CorElementType type);
void EmitCPBLK ();
void EmitCPOBJ (int token);
void EmitDUP ();
void EmitENDFINALLY ();
void EmitINITBLK ();
void EmitINITOBJ (int token);
void EmitJMP (int token);
void EmitLDARG (unsigned uArgIdx);
void EmitLDARGA (unsigned uArgIdx);
void EmitLDC (DWORD_PTR uConst);
void EmitLDC_R4 (UINT32 uConst);
void EmitLDC_R8 (UINT64 uConst);
void EmitLDELEMA (int token);
void EmitLDELEM_REF ();
void EmitLDFLD (int token);
void EmitLDFLDA (int token);
void EmitLDFTN (int token);
void EmitLDIND_I ();
void EmitLDIND_I1 ();
void EmitLDIND_I2 ();
void EmitLDIND_I4 ();
void EmitLDIND_I8 ();
void EmitLDIND_R4 ();
void EmitLDIND_R8 ();
void EmitLDIND_REF ();
void EmitLDIND_T (LocalDesc* pType);
void EmitLDIND_U1 ();
void EmitLDIND_U2 ();
void EmitLDIND_U4 ();
void EmitLDLEN ();
void EmitLDLOC (DWORD dwLocalNum);
void EmitLDLOCA (DWORD dwLocalNum);
void EmitLDNULL ();
void EmitLDOBJ (int token);
void EmitLDSFLD (int token);
void EmitLDSFLDA (int token);
void EmitLDTOKEN (int token);
void EmitLEAVE (ILCodeLabel* pCodeLabel);
void EmitLOCALLOC ();
void EmitMUL ();
void EmitMUL_OVF ();
void EmitNEWOBJ (int token, int numInArgs);
void EmitNOP (LPCSTR pszNopComment);
void EmitPOP ();
void EmitRET ();
void EmitSHR_UN ();
void EmitSTARG (unsigned uArgIdx);
void EmitSTELEM_REF ();
void EmitSTIND_I ();
void EmitSTIND_I1 ();
void EmitSTIND_I2 ();
void EmitSTIND_I4 ();
void EmitSTIND_I8 ();
void EmitSTIND_R4 ();
void EmitSTIND_R8 ();
void EmitSTIND_REF ();
void EmitSTIND_T (LocalDesc* pType);
void EmitSTFLD (int token);
void EmitSTLOC (DWORD dwLocalNum);
void EmitSTOBJ (int token);
void EmitSTSFLD (int token);
void EmitSUB ();
void EmitTHROW ();
void EmitUNALIGNED (BYTE alignment);
// Overloads to simplify common usage patterns
void EmitNEWOBJ (BinderMethodID id, int numInArgs);
void EmitCALL (BinderMethodID id, int numInArgs, int numRetArgs);
void EmitLDFLD (BinderFieldID id);
void EmitSTFLD (BinderFieldID id);
void EmitLDFLDA (BinderFieldID id);
void EmitLabel(ILCodeLabel* pLabel);
void EmitLoadThis ();
void EmitLoadNullPtr();
void EmitArgIteratorCreateAndLoad();
ILCodeLabel* NewCodeLabel();
void ClearCode();
//
// these functions just forward to the owning ILStubLinker
//
int GetToken(MethodDesc* pMD);
int GetToken(MethodTable* pMT);
int GetToken(TypeHandle th);
int GetToken(FieldDesc* pFD);
int GetSigToken(PCCOR_SIGNATURE pSig, DWORD cbSig);
DWORD NewLocal(CorElementType typ = ELEMENT_TYPE_I);
DWORD NewLocal(LocalDesc loc);
DWORD SetStubTargetArgType(CorElementType typ, bool fConsumeStubArg = true);
DWORD SetStubTargetArgType(LocalDesc* pLoc = NULL, bool fConsumeStubArg = true); // passing pLoc = NULL means "use stub arg type"
void SetStubTargetReturnType(CorElementType typ);
void SetStubTargetReturnType(LocalDesc* pLoc);
//
// ctors/dtor
//
ILCodeStream(ILStubLinker* pOwner, ILStubLinker::CodeStreamType codeStreamType) :
m_pNextStream(NULL),
m_pOwner(pOwner),
m_pqbILInstructions(NULL),
m_uCurInstrIdx(0),
m_codeStreamType(codeStreamType)
{
}
~ILCodeStream()
{
CONTRACTL
{
MODE_ANY;
NOTHROW;
GC_TRIGGERS;
}
CONTRACTL_END;
if (NULL != m_pqbILInstructions)
{
delete m_pqbILInstructions;
m_pqbILInstructions = NULL;
}
}
ILStubLinker::CodeStreamType GetStreamType() { return m_codeStreamType; }
LPCSTR GetStreamDescription(ILStubLinker::CodeStreamType streamType);
protected:
void Emit(ILInstrEnum instr, INT16 iStackDelta, UINT_PTR uArg);
enum Constants
{
INITIAL_NUM_IL_INSTRUCTIONS = 64,
INITIAL_IL_INSTRUCTION_BUFFER_SIZE = INITIAL_NUM_IL_INSTRUCTIONS * sizeof(ILStubLinker::ILInstruction),
};
typedef CQuickBytesSpecifySize<INITIAL_IL_INSTRUCTION_BUFFER_SIZE> ILCodeStreamBuffer;
ILCodeStream* m_pNextStream;
ILStubLinker* m_pOwner;
ILCodeStreamBuffer* m_pqbILInstructions;
UINT m_uCurInstrIdx;
ILStubLinker::CodeStreamType m_codeStreamType; // Type of the ILCodeStream
SArray<ILStubEHClauseBuilder> m_buildingEHClauses;
SArray<ILStubEHClauseBuilder> m_finishedEHClauses;
#ifndef TARGET_64BIT
const static UINT32 SPECIAL_VALUE_NAN_64_ON_32 = 0xFFFFFFFF;
#endif // TARGET_64BIT
};
#endif // DACCESS_COMPILE
#define TOKEN_ILSTUB_TARGET_SIG (TokenFromRid(0xFFFFFF, mdtSignature))
#endif // __STUBGEN_H__
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
//
// File: StubGen.h
//
//
#ifndef __STUBGEN_H__
#define __STUBGEN_H__
#include "stublink.h"
struct ILStubEHClause;
class ILStubLinker;
#ifndef DACCESS_COMPILE
struct StructMarshalStubs
{
static const DWORD MANAGED_STRUCT_ARGIDX = 0;
static const DWORD NATIVE_STRUCT_ARGIDX = 1;
static const DWORD OPERATION_ARGIDX = 2;
static const DWORD CLEANUP_WORK_LIST_ARGIDX = 3;
enum MarshalOperation
{
Marshal,
Unmarshal,
Cleanup
};
};
struct LocalDesc
{
const static size_t MAX_LOCALDESC_ELEMENTS = 8;
BYTE ElementType[MAX_LOCALDESC_ELEMENTS];
size_t cbType;
TypeHandle InternalToken; // only valid with ELEMENT_TYPE_INTERNAL
// used only for E_T_FNPTR and E_T_ARRAY
PCCOR_SIGNATURE pSig;
union
{
Module* pSigModule;
size_t cbArrayBoundsInfo;
BOOL bIsCopyConstructed; // used for E_T_PTR
};
LocalDesc()
{
}
inline LocalDesc(CorElementType elemType)
{
ElementType[0] = static_cast<BYTE>(elemType);
cbType = 1;
bIsCopyConstructed = FALSE;
}
inline LocalDesc(TypeHandle thType)
{
ElementType[0] = ELEMENT_TYPE_INTERNAL;
cbType = 1;
InternalToken = thType;
bIsCopyConstructed = FALSE;
}
inline LocalDesc(MethodTable *pMT)
{
WRAPPER_NO_CONTRACT;
ElementType[0] = ELEMENT_TYPE_INTERNAL;
cbType = 1;
InternalToken = TypeHandle(pMT);
bIsCopyConstructed = FALSE;
}
void MakeByRef()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_BYREF);
}
void MakePinned()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_PINNED);
}
void MakeArray()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_SZARRAY);
}
// makes the LocalDesc semantically equivalent to ET_TYPE_CMOD_REQD<IsCopyConstructed>/ET_TYPE_CMOD_REQD<NeedsCopyConstructorModifier>
void MakeCopyConstructedPointer()
{
LIMITED_METHOD_CONTRACT;
MakePointer();
bIsCopyConstructed = TRUE;
}
void MakePointer()
{
LIMITED_METHOD_CONTRACT;
ChangeType(ELEMENT_TYPE_PTR);
}
void ChangeType(CorElementType elemType)
{
LIMITED_METHOD_CONTRACT;
PREFIX_ASSUME((MAX_LOCALDESC_ELEMENTS-1) >= cbType);
for (size_t i = cbType; i >= 1; i--)
{
ElementType[i] = ElementType[i-1];
}
ElementType[0] = static_cast<BYTE>(elemType);
cbType += 1;
}
bool IsValueClass()
{
CONTRACTL
{
THROWS;
GC_TRIGGERS;
MODE_ANY;
}
CONTRACTL_END;
bool lastElementTypeIsValueType = false;
if (ElementType[cbType - 1] == ELEMENT_TYPE_VALUETYPE)
{
lastElementTypeIsValueType = true;
}
else if ((ElementType[cbType - 1] == ELEMENT_TYPE_INTERNAL) &&
(InternalToken.IsNativeValueType() ||
InternalToken.GetMethodTable()->IsValueType()))
{
lastElementTypeIsValueType = true;
}
if (!lastElementTypeIsValueType)
{
return false;
}
// verify that the prefix element types don't make the type a non-value type
// this only works on LocalDescs with the prefixes exposed in the Add* methods above.
for (size_t i = 0; i < cbType - 1; i++)
{
if (ElementType[i] == ELEMENT_TYPE_BYREF
|| ElementType[i] == ELEMENT_TYPE_SZARRAY
|| ElementType[i] == ELEMENT_TYPE_PTR)
{
return false;
}
}
return true;
}
};
class StubSigBuilder
{
public:
StubSigBuilder();
DWORD Append(LocalDesc* pLoc);
protected:
CQuickBytes m_qbSigBuffer;
uint32_t m_nItems;
BYTE* m_pbSigCursor;
size_t m_cbSig;
enum Constants { INITIAL_BUFFER_SIZE = 256 };
void EnsureEnoughQuickBytes(size_t cbToAppend);
};
//---------------------------------------------------------------------------------------
//
class LocalSigBuilder : protected StubSigBuilder
{
public:
DWORD NewLocal(LocalDesc * pLoc)
{
CONTRACTL
{
THROWS;
GC_TRIGGERS;
MODE_ANY;
PRECONDITION(CheckPointer(pLoc));
}
CONTRACTL_END;
return Append(pLoc);
}
DWORD GetSigSize();
DWORD GetSig(BYTE * pbSig, DWORD cbBuffer);
}; // class LocalSigBuilder
//---------------------------------------------------------------------------------------
//
class FunctionSigBuilder : protected StubSigBuilder
{
public:
FunctionSigBuilder();
DWORD NewArg(LocalDesc * pArg)
{
WRAPPER_NO_CONTRACT;
return Append(pArg);
}
DWORD GetNumArgs()
{
LIMITED_METHOD_CONTRACT;
return m_nItems;
}
void SetCallingConv(CorCallingConvention callingConv)
{
LIMITED_METHOD_CONTRACT;
m_callingConv = callingConv;
}
void AddCallConvModOpt(mdToken token);
CorCallingConvention GetCallingConv()
{
LIMITED_METHOD_CONTRACT;
return m_callingConv;
}
void SetSig(PCCOR_SIGNATURE pSig, DWORD cSig);
DWORD GetSigSize();
DWORD GetSig(BYTE * pbSig, DWORD cbBuffer);
void SetReturnType(LocalDesc* pLoc);
CorElementType GetReturnElementType()
{
LIMITED_METHOD_CONTRACT;
CONSISTENCY_CHECK(m_qbReturnSig.Size() > 0);
return *(CorElementType *)m_qbReturnSig.Ptr();
}
PCCOR_SIGNATURE GetReturnSig()
{
LIMITED_METHOD_CONTRACT;
CONSISTENCY_CHECK(m_qbReturnSig.Size() > 0);
return (PCCOR_SIGNATURE)m_qbReturnSig.Ptr();
}
protected:
CorCallingConvention m_callingConv;
CQuickBytes m_qbReturnSig;
CQuickBytes m_qbCallConvModOpts;
}; // class FunctionSigBuilder
#endif // DACCESS_COMPILE
#ifdef _DEBUG
// exercise the resize code
#define TOKEN_LOOKUP_MAP_SIZE (8*sizeof(void*))
#else // _DEBUG
#define TOKEN_LOOKUP_MAP_SIZE (64*sizeof(void*))
#endif // _DEBUG
//---------------------------------------------------------------------------------------
//
class TokenLookupMap
{
public:
TokenLookupMap()
{
STANDARD_VM_CONTRACT;
m_qbEntries.AllocThrows(TOKEN_LOOKUP_MAP_SIZE);
m_nextAvailableRid = 0;
}
// copy ctor
TokenLookupMap(TokenLookupMap* pSrc)
{
STANDARD_VM_CONTRACT;
m_nextAvailableRid = pSrc->m_nextAvailableRid;
size_t size = pSrc->m_qbEntries.Size();
m_qbEntries.AllocThrows(size);
memcpy(m_qbEntries.Ptr(), pSrc->m_qbEntries.Ptr(), size);
m_signatures.Preallocate(pSrc->m_signatures.GetCount());
for (COUNT_T i = 0; i < pSrc->m_signatures.GetCount(); i++)
{
const CQuickBytesSpecifySize<16>& src = pSrc->m_signatures[i];
CQuickBytesSpecifySize<16>& dst = *m_signatures.Append();
dst.AllocThrows(src.Size());
memcpy(dst.Ptr(), src.Ptr(), src.Size());
}
}
TypeHandle LookupTypeDef(mdToken token)
{
WRAPPER_NO_CONTRACT;
return LookupTokenWorker<mdtTypeDef, MethodTable*>(token);
}
MethodDesc* LookupMethodDef(mdToken token)
{
WRAPPER_NO_CONTRACT;
return LookupTokenWorker<mdtMethodDef, MethodDesc*>(token);
}
FieldDesc* LookupFieldDef(mdToken token)
{
WRAPPER_NO_CONTRACT;
return LookupTokenWorker<mdtFieldDef, FieldDesc*>(token);
}
SigPointer LookupSig(mdToken token)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(RidFromToken(token)-1 < m_signatures.GetCount());
PRECONDITION(RidFromToken(token) != 0);
PRECONDITION(TypeFromToken(token) == mdtSignature);
}
CONTRACTL_END;
CQuickBytesSpecifySize<16>& sigData = m_signatures[static_cast<COUNT_T>(RidFromToken(token)-1)];
PCCOR_SIGNATURE pSig = (PCCOR_SIGNATURE)sigData.Ptr();
DWORD cbSig = static_cast<DWORD>(sigData.Size());
return SigPointer(pSig, cbSig);
}
mdToken GetToken(TypeHandle pMT)
{
WRAPPER_NO_CONTRACT;
return GetTokenWorker<mdtTypeDef, TypeHandle>(pMT);
}
mdToken GetToken(MethodDesc* pMD)
{
WRAPPER_NO_CONTRACT;
return GetTokenWorker<mdtMethodDef, MethodDesc*>(pMD);
}
mdToken GetToken(FieldDesc* pFieldDesc)
{
WRAPPER_NO_CONTRACT;
return GetTokenWorker<mdtFieldDef, FieldDesc*>(pFieldDesc);
}
mdToken GetSigToken(PCCOR_SIGNATURE pSig, DWORD cbSig)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(pSig != NULL);
}
CONTRACTL_END;
mdToken token = TokenFromRid(m_signatures.GetCount(), mdtSignature)+1;
CQuickBytesSpecifySize<16>& sigData = *m_signatures.Append();
sigData.AllocThrows(cbSig);
memcpy(sigData.Ptr(), pSig, cbSig);
return token;
}
protected:
template<mdToken TokenType, typename HandleType>
HandleType LookupTokenWorker(mdToken token)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(RidFromToken(token)-1 < m_nextAvailableRid);
PRECONDITION(RidFromToken(token) != 0);
PRECONDITION(TypeFromToken(token) == TokenType);
}
CONTRACTL_END;
return ((HandleType*)m_qbEntries.Ptr())[RidFromToken(token)-1];
}
template<mdToken TokenType, typename HandleType>
mdToken GetTokenWorker(HandleType handle)
{
CONTRACTL
{
THROWS;
MODE_ANY;
GC_NOTRIGGER;
PRECONDITION(handle != NULL);
}
CONTRACTL_END;
if (m_qbEntries.Size() <= (sizeof(handle) * m_nextAvailableRid))
{
m_qbEntries.ReSizeThrows(2 * m_qbEntries.Size());
}
mdToken token = TokenFromRid(m_nextAvailableRid++, TokenType)+1;
((HandleType*)m_qbEntries.Ptr())[RidFromToken(token)-1] = handle;
return token;
}
unsigned int m_nextAvailableRid;
CQuickBytesSpecifySize<TOKEN_LOOKUP_MAP_SIZE> m_qbEntries;
SArray<CQuickBytesSpecifySize<16>, FALSE> m_signatures;
};
class ILCodeLabel;
class ILCodeStream;
#ifndef DACCESS_COMPILE
struct ILStubEHClause
{
enum Kind { kNone, kTypedCatch, kFinally };
DWORD kind;
DWORD dwTryBeginOffset;
DWORD cbTryLength;
DWORD dwHandlerBeginOffset;
DWORD cbHandlerLength;
DWORD dwTypeToken;
};
struct ILStubEHClauseBuilder
{
DWORD kind;
ILCodeLabel* tryBeginLabel;
ILCodeLabel* tryEndLabel;
ILCodeLabel* handlerBeginLabel;
ILCodeLabel* handlerEndLabel;
DWORD typeToken;
};
enum ILStubLinkerFlags
{
ILSTUB_LINKER_FLAG_NONE = 0x00,
ILSTUB_LINKER_FLAG_TARGET_HAS_THIS = 0x01,
ILSTUB_LINKER_FLAG_STUB_HAS_THIS = 0x02,
ILSTUB_LINKER_FLAG_NDIRECT = 0x04,
ILSTUB_LINKER_FLAG_REVERSE = 0x08,
ILSTUB_LINKER_FLAG_SUPPRESSGCTRANSITION = 0x10,
};
//---------------------------------------------------------------------------------------
//
class ILStubLinker
{
friend class ILCodeLabel;
friend class ILCodeStream;
public:
ILStubLinker(Module* pModule, const Signature &signature, SigTypeContext *pTypeContext, MethodDesc *pMD, ILStubLinkerFlags flags);
~ILStubLinker();
void GenerateCode(BYTE* pbBuffer, size_t cbBufferSize);
void ClearCode();
void SetStubMethodDesc(MethodDesc *pMD);
protected:
void DeleteCodeLabels();
void DeleteCodeStreams();
struct ILInstruction
{
UINT16 uInstruction;
INT16 iStackDelta;
UINT_PTR uArg;
};
static void PatchInstructionArgument(ILCodeLabel* pLabel, UINT_PTR uNewArg
DEBUG_ARG(UINT16 uExpectedInstruction));
#ifdef _DEBUG
bool IsInCodeStreamList(ILCodeStream* pcs);
#endif // _DEBUG
public:
void SetHasThis (bool fHasThis);
bool HasThis () { LIMITED_METHOD_CONTRACT; return m_fHasThis; }
DWORD GetLocalSigSize();
DWORD GetLocalSig(BYTE * pbLocalSig, DWORD cbBuffer);
DWORD GetStubTargetMethodSigSize();
DWORD GetStubTargetMethodSig(BYTE * pbLocalSig, DWORD cbBuffer);
void SetStubTargetMethodSig(PCCOR_SIGNATURE pSig, DWORD cSig);
void GetStubTargetReturnType(LocalDesc * pLoc);
void GetStubTargetReturnType(LocalDesc * pLoc, Module * pModule);
void GetStubArgType(LocalDesc * pLoc);
void GetStubArgType(LocalDesc * pLoc, Module * pModule);
void GetStubReturnType(LocalDesc * pLoc);
void GetStubReturnType(LocalDesc * pLoc, Module * pModule);
CorCallingConvention GetStubTargetCallingConv();
CorElementType GetStubTargetReturnElementType() { WRAPPER_NO_CONTRACT; return m_nativeFnSigBuilder.GetReturnElementType(); }
static void GetManagedTypeHelper(LocalDesc* pLoc, Module* pModule, PCCOR_SIGNATURE pSig, SigTypeContext *pTypeContext, MethodDesc *pMD);
BOOL StubHasVoidReturnType();
Stub *Link(LoaderHeap *pHeap, UINT *pcbSize /* = NULL*/, BOOL fMC);
size_t Link(UINT* puMaxStack);
size_t GetNumEHClauses();
// Write out EH clauses. Number of items written out will be GetNumEHCLauses().
void WriteEHClauses(COR_ILMETHOD_SECT_EH* sect);
TokenLookupMap* GetTokenLookupMap() { LIMITED_METHOD_CONTRACT; return &m_tokenMap; }
enum CodeStreamType
{
kSetup,
kMarshal,
kDispatch,
kReturnUnmarshal,
kUnmarshal,
kExceptionCleanup,
kCleanup,
kExceptionHandler,
};
ILCodeStream* NewCodeStream(CodeStreamType codeStreamType);
MethodDesc *GetTargetMD() { LIMITED_METHOD_CONTRACT; return m_pMD; }
Signature GetStubSignature() { LIMITED_METHOD_CONTRACT; return m_stubSig; }
void ClearCodeStreams();
void LogILStub(CORJIT_FLAGS jitFlags, SString *pDumpILStubCode = NULL);
protected:
void DumpIL_FormatToken(mdToken token, SString &strTokenFormatting);
void LogILStubWorker(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode, INT* piCurStack, SString *pDumpILStubCode = NULL);
void LogILInstruction(size_t curOffset, bool isLabeled, INT iCurStack, ILInstruction* pInstruction, SString *pDumpILStubCode = NULL);
private:
ILCodeStream* m_pCodeStreamList;
TokenLookupMap m_tokenMap;
LocalSigBuilder m_localSigBuilder;
FunctionSigBuilder m_nativeFnSigBuilder;
BYTE m_rgbBuffer[sizeof(COR_ILMETHOD_DECODER)];
Signature m_stubSig; // managed sig of stub
SigTypeContext* m_pTypeContext; // type context for m_stubSig
SigPointer m_managedSigPtr;
void* m_pCode;
Module* m_pStubSigModule;
ILCodeLabel* m_pLabelList;
bool FirstPassLink(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode, INT* piCurStack, UINT* puMaxStack);
void SecondPassLink(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pCurCodeOffset);
BYTE* GenerateCodeWorker(BYTE* pbBuffer, ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode);
static ILCodeStream* FindLastCodeStream(ILCodeStream* pList);
protected:
//
// the public entrypoints for these methods are in ILCodeStream
//
ILCodeLabel* NewCodeLabel();
int GetToken(MethodDesc* pMD);
int GetToken(MethodTable* pMT);
int GetToken(TypeHandle th);
int GetToken(FieldDesc* pFD);
int GetSigToken(PCCOR_SIGNATURE pSig, DWORD cbSig);
DWORD NewLocal(CorElementType typ = ELEMENT_TYPE_I);
DWORD NewLocal(LocalDesc loc);
DWORD SetStubTargetArgType(CorElementType typ, bool fConsumeStubArg = true);
DWORD SetStubTargetArgType(LocalDesc* pLoc = NULL, bool fConsumeStubArg = true); // passing pLoc = NULL means "use stub arg type"
void SetStubTargetReturnType(CorElementType typ);
void SetStubTargetReturnType(LocalDesc* pLoc);
void SetStubTargetCallingConv(CorCallingConvention uNativeCallingConv);
void SetStubTargetCallingConv(CorInfoCallConvExtension callConv);
bool ReturnOpcodePopsStack()
{
if ((!m_fIsReverseStub && m_StubHasVoidReturnType) || (m_fIsReverseStub && m_StubTargetHasVoidReturnType))
{
return false;
}
return true;
}
void TransformArgForJIT(LocalDesc *pLoc);
Module * GetStubSigModule();
SigTypeContext *GetStubSigTypeContext();
BOOL m_StubHasVoidReturnType;
BOOL m_StubTargetHasVoidReturnType;
BOOL m_fIsReverseStub;
INT m_iTargetStackDelta;
DWORD m_cbCurrentCompressedSigLen;
DWORD m_nLocals;
bool m_fHasThis;
// We need this MethodDesc so we can reconstruct the generics
// SigTypeContext info, if needed.
MethodDesc * m_pMD;
}; // class ILStubLinker
//---------------------------------------------------------------------------------------
//
class ILCodeLabel
{
friend class ILStubLinker;
friend class ILCodeStream;
public:
ILCodeLabel();
~ILCodeLabel();
size_t GetCodeOffset();
private:
void SetCodeOffset(size_t codeOffset);
ILCodeLabel* m_pNext;
ILStubLinker* m_pOwningStubLinker;
ILCodeStream* m_pCodeStreamOfLabel; // this is the ILCodeStream that the index is relative to
size_t m_codeOffset; // this is the absolute resolved IL offset after linking
UINT m_idxLabeledInstruction; // this is the index within the instruction buffer of the owning ILCodeStream
};
class ILCodeStream
{
friend class ILStubLinker;
public:
enum ILInstrEnum
{
#define OPDEF(name,string,pop,push,oprType,opcType,l,s1,s2,ctrl) \
name,
#include "opcode.def"
#undef OPDEF
};
private:
static ILInstrEnum LowerOpcode(ILInstrEnum instr, ILStubLinker::ILInstruction* pInstr);
#ifdef _DEBUG
static bool IsSupportedInstruction(ILInstrEnum instr);
#endif // _DEBUG
static bool IsBranchInstruction(ILInstrEnum instr)
{
LIMITED_METHOD_CONTRACT;
return ((instr >= CEE_BR) && (instr <= CEE_BLT_UN)) || (instr == CEE_LEAVE);
}
void BeginHandler (DWORD kind, DWORD typeToken);
void EndHandler (DWORD kind);
public:
void BeginTryBlock ();
void EndTryBlock ();
void BeginCatchBlock(int token);
void EndCatchBlock ();
void BeginFinallyBlock();
void EndFinallyBlock();
void EmitADD ();
void EmitADD_OVF ();
void EmitAND ();
void EmitARGLIST ();
void EmitBEQ (ILCodeLabel* pCodeLabel);
void EmitBGE (ILCodeLabel* pCodeLabel);
void EmitBGE_UN (ILCodeLabel* pCodeLabel);
void EmitBGT (ILCodeLabel* pCodeLabel);
void EmitBLE (ILCodeLabel* pCodeLabel);
void EmitBLE_UN (ILCodeLabel* pCodeLabel);
void EmitBLT (ILCodeLabel* pCodeLabel);
void EmitBNE_UN (ILCodeLabel* pCodeLabel);
void EmitBR (ILCodeLabel* pCodeLabel);
void EmitBREAK ();
void EmitBRFALSE (ILCodeLabel* pCodeLabel);
void EmitBRTRUE (ILCodeLabel* pCodeLabel);
void EmitCALL (int token, int numInArgs, int numRetArgs);
void EmitCALLI (int token, int numInArgs, int numRetArgs);
void EmitCALLVIRT (int token, int numInArgs, int numRetArgs);
void EmitCEQ ();
void EmitCGT ();
void EmitCGT_UN ();
void EmitCLT ();
void EmitCLT_UN ();
void EmitCONV_I ();
void EmitCONV_I1 ();
void EmitCONV_I2 ();
void EmitCONV_I4 ();
void EmitCONV_I8 ();
void EmitCONV_U ();
void EmitCONV_U1 ();
void EmitCONV_U2 ();
void EmitCONV_U4 ();
void EmitCONV_U8 ();
void EmitCONV_R4 ();
void EmitCONV_R8 ();
void EmitCONV_OVF_I4();
void EmitCONV_T (CorElementType type);
void EmitCPBLK ();
void EmitCPOBJ (int token);
void EmitDUP ();
void EmitENDFINALLY ();
void EmitINITBLK ();
void EmitINITOBJ (int token);
void EmitJMP (int token);
void EmitLDARG (unsigned uArgIdx);
void EmitLDARGA (unsigned uArgIdx);
void EmitLDC (DWORD_PTR uConst);
void EmitLDC_R4 (UINT32 uConst);
void EmitLDC_R8 (UINT64 uConst);
void EmitLDELEMA (int token);
void EmitLDELEM_REF ();
void EmitLDFLD (int token);
void EmitLDFLDA (int token);
void EmitLDFTN (int token);
void EmitLDIND_I ();
void EmitLDIND_I1 ();
void EmitLDIND_I2 ();
void EmitLDIND_I4 ();
void EmitLDIND_I8 ();
void EmitLDIND_R4 ();
void EmitLDIND_R8 ();
void EmitLDIND_REF ();
void EmitLDIND_T (LocalDesc* pType);
void EmitLDIND_U1 ();
void EmitLDIND_U2 ();
void EmitLDIND_U4 ();
void EmitLDLEN ();
void EmitLDLOC (DWORD dwLocalNum);
void EmitLDLOCA (DWORD dwLocalNum);
void EmitLDNULL ();
void EmitLDOBJ (int token);
void EmitLDSFLD (int token);
void EmitLDSFLDA (int token);
void EmitLDTOKEN (int token);
void EmitLEAVE (ILCodeLabel* pCodeLabel);
void EmitLOCALLOC ();
void EmitMUL ();
void EmitMUL_OVF ();
void EmitNEWOBJ (int token, int numInArgs);
void EmitNOP (LPCSTR pszNopComment);
void EmitPOP ();
void EmitRET ();
void EmitSHR_UN ();
void EmitSTARG (unsigned uArgIdx);
void EmitSTELEM_REF ();
void EmitSTIND_I ();
void EmitSTIND_I1 ();
void EmitSTIND_I2 ();
void EmitSTIND_I4 ();
void EmitSTIND_I8 ();
void EmitSTIND_R4 ();
void EmitSTIND_R8 ();
void EmitSTIND_REF ();
void EmitSTIND_T (LocalDesc* pType);
void EmitSTFLD (int token);
void EmitSTLOC (DWORD dwLocalNum);
void EmitSTOBJ (int token);
void EmitSTSFLD (int token);
void EmitSUB ();
void EmitTHROW ();
void EmitUNALIGNED (BYTE alignment);
// Overloads to simplify common usage patterns
void EmitNEWOBJ (BinderMethodID id, int numInArgs);
void EmitCALL (BinderMethodID id, int numInArgs, int numRetArgs);
void EmitLDFLD (BinderFieldID id);
void EmitSTFLD (BinderFieldID id);
void EmitLDFLDA (BinderFieldID id);
void EmitLabel(ILCodeLabel* pLabel);
void EmitLoadThis ();
void EmitLoadNullPtr();
void EmitArgIteratorCreateAndLoad();
ILCodeLabel* NewCodeLabel();
void ClearCode();
//
// these functions just forward to the owning ILStubLinker
//
int GetToken(MethodDesc* pMD);
int GetToken(MethodTable* pMT);
int GetToken(TypeHandle th);
int GetToken(FieldDesc* pFD);
int GetSigToken(PCCOR_SIGNATURE pSig, DWORD cbSig);
DWORD NewLocal(CorElementType typ = ELEMENT_TYPE_I);
DWORD NewLocal(LocalDesc loc);
DWORD SetStubTargetArgType(CorElementType typ, bool fConsumeStubArg = true);
DWORD SetStubTargetArgType(LocalDesc* pLoc = NULL, bool fConsumeStubArg = true); // passing pLoc = NULL means "use stub arg type"
void SetStubTargetReturnType(CorElementType typ);
void SetStubTargetReturnType(LocalDesc* pLoc);
//
// ctors/dtor
//
ILCodeStream(ILStubLinker* pOwner, ILStubLinker::CodeStreamType codeStreamType) :
m_pNextStream(NULL),
m_pOwner(pOwner),
m_pqbILInstructions(NULL),
m_uCurInstrIdx(0),
m_codeStreamType(codeStreamType)
{
}
~ILCodeStream()
{
CONTRACTL
{
MODE_ANY;
NOTHROW;
GC_TRIGGERS;
}
CONTRACTL_END;
if (NULL != m_pqbILInstructions)
{
delete m_pqbILInstructions;
m_pqbILInstructions = NULL;
}
}
ILStubLinker::CodeStreamType GetStreamType() { return m_codeStreamType; }
LPCSTR GetStreamDescription(ILStubLinker::CodeStreamType streamType);
protected:
void Emit(ILInstrEnum instr, INT16 iStackDelta, UINT_PTR uArg);
enum Constants
{
INITIAL_NUM_IL_INSTRUCTIONS = 64,
INITIAL_IL_INSTRUCTION_BUFFER_SIZE = INITIAL_NUM_IL_INSTRUCTIONS * sizeof(ILStubLinker::ILInstruction),
};
typedef CQuickBytesSpecifySize<INITIAL_IL_INSTRUCTION_BUFFER_SIZE> ILCodeStreamBuffer;
ILCodeStream* m_pNextStream;
ILStubLinker* m_pOwner;
ILCodeStreamBuffer* m_pqbILInstructions;
UINT m_uCurInstrIdx;
ILStubLinker::CodeStreamType m_codeStreamType; // Type of the ILCodeStream
SArray<ILStubEHClauseBuilder> m_buildingEHClauses;
SArray<ILStubEHClauseBuilder> m_finishedEHClauses;
#ifndef TARGET_64BIT
const static UINT32 SPECIAL_VALUE_NAN_64_ON_32 = 0xFFFFFFFF;
#endif // TARGET_64BIT
};
#endif // DACCESS_COMPILE
#define TOKEN_ILSTUB_TARGET_SIG (TokenFromRid(0xFFFFFF, mdtSignature))
#endif // __STUBGEN_H__
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/JIT/HardwareIntrinsics/General/Vector256/CreateScalarUnsafe.Double.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\General\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void CreateScalarUnsafeDouble()
{
var test = new VectorCreate__CreateScalarUnsafeDouble();
// Validates basic functionality works
test.RunBasicScenario();
// Validates calling via reflection works
test.RunReflectionScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorCreate__CreateScalarUnsafeDouble
{
private static readonly int LargestVectorSize = 32;
private static readonly int ElementCount = Unsafe.SizeOf<Vector256<Double>>() / sizeof(Double);
public bool Succeeded { get; set; } = true;
public void RunBasicScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario));
Double value = TestLibrary.Generator.GetDouble();
Vector256<Double> result = Vector256.CreateScalarUnsafe(value);
ValidateResult(result, value);
}
public void RunReflectionScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario));
Double value = TestLibrary.Generator.GetDouble();
object result = typeof(Vector256)
.GetMethod(nameof(Vector256.CreateScalarUnsafe), new Type[] { typeof(Double) })
.Invoke(null, new object[] { value });
ValidateResult((Vector256<Double>)(result), value);
}
private void ValidateResult(Vector256<Double> result, Double expectedValue, [CallerMemberName] string method = "")
{
Double[] resultElements = new Double[ElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref resultElements[0]), result);
ValidateResult(resultElements, expectedValue, method);
}
private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (resultElements[0] != expectedValue)
{
succeeded = false;
}
else
{
for (var i = 1; i < ElementCount; i++)
{
if (false /* value is uninitialized */)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Double): {method} failed:");
TestLibrary.TestFramework.LogInformation($" value: {expectedValue}");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", resultElements)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
/******************************************************************************
* This file is auto-generated from a template file by the GenerateTests.csx *
* script in tests\src\JIT\HardwareIntrinsics\General\Shared. In order to make *
* changes, please update the corresponding template and run according to the *
* directions listed in the file. *
******************************************************************************/
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
namespace JIT.HardwareIntrinsics.General
{
public static partial class Program
{
private static void CreateScalarUnsafeDouble()
{
var test = new VectorCreate__CreateScalarUnsafeDouble();
// Validates basic functionality works
test.RunBasicScenario();
// Validates calling via reflection works
test.RunReflectionScenario();
if (!test.Succeeded)
{
throw new Exception("One or more scenarios did not complete as expected.");
}
}
}
public sealed unsafe class VectorCreate__CreateScalarUnsafeDouble
{
private static readonly int LargestVectorSize = 32;
private static readonly int ElementCount = Unsafe.SizeOf<Vector256<Double>>() / sizeof(Double);
public bool Succeeded { get; set; } = true;
public void RunBasicScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario));
Double value = TestLibrary.Generator.GetDouble();
Vector256<Double> result = Vector256.CreateScalarUnsafe(value);
ValidateResult(result, value);
}
public void RunReflectionScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario));
Double value = TestLibrary.Generator.GetDouble();
object result = typeof(Vector256)
.GetMethod(nameof(Vector256.CreateScalarUnsafe), new Type[] { typeof(Double) })
.Invoke(null, new object[] { value });
ValidateResult((Vector256<Double>)(result), value);
}
private void ValidateResult(Vector256<Double> result, Double expectedValue, [CallerMemberName] string method = "")
{
Double[] resultElements = new Double[ElementCount];
Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref resultElements[0]), result);
ValidateResult(resultElements, expectedValue, method);
}
private void ValidateResult(Double[] resultElements, Double expectedValue, [CallerMemberName] string method = "")
{
bool succeeded = true;
if (resultElements[0] != expectedValue)
{
succeeded = false;
}
else
{
for (var i = 1; i < ElementCount; i++)
{
if (false /* value is uninitialized */)
{
succeeded = false;
break;
}
}
}
if (!succeeded)
{
TestLibrary.TestFramework.LogInformation($"Vector256.CreateScalarUnsafe(Double): {method} failed:");
TestLibrary.TestFramework.LogInformation($" value: {expectedValue}");
TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", resultElements)})");
TestLibrary.TestFramework.LogInformation(string.Empty);
Succeeded = false;
}
}
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/Microsoft.Extensions.FileSystemGlobbing/tests/FilePatternMatchTests.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace Microsoft.Extensions.FileSystemGlobbing.Tests
{
public class FilePatternMatchTests
{
[Fact]
public void TestGetHashCode()
{
FilePatternMatch match1 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "sub2/bar/baz/three.txt");
FilePatternMatch match2 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "sub2/bar/baz/three.txt");
FilePatternMatch match3 = new FilePatternMatch("sub/sub2/bar/baz/one.txt", "sub2/bar/baz/three.txt");
FilePatternMatch match4 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "sub2/bar/baz/one.txt");
Assert.Equal(match1.GetHashCode(), match2.GetHashCode());
Assert.NotEqual(match1.GetHashCode(), match3.GetHashCode());
Assert.NotEqual(match1.GetHashCode(), match4.GetHashCode());
// FilePatternMatch is case insensitive
FilePatternMatch matchCase1 = new FilePatternMatch("Sub/Sub2/bar/baz/three.txt", "sub2/bar/baz/three.txt");
FilePatternMatch matchCase2 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "Sub2/bar/baz/thrEE.txt");
Assert.Equal(matchCase1.GetHashCode(), matchCase2.GetHashCode());
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Xunit;
namespace Microsoft.Extensions.FileSystemGlobbing.Tests
{
public class FilePatternMatchTests
{
[Fact]
public void TestGetHashCode()
{
FilePatternMatch match1 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "sub2/bar/baz/three.txt");
FilePatternMatch match2 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "sub2/bar/baz/three.txt");
FilePatternMatch match3 = new FilePatternMatch("sub/sub2/bar/baz/one.txt", "sub2/bar/baz/three.txt");
FilePatternMatch match4 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "sub2/bar/baz/one.txt");
Assert.Equal(match1.GetHashCode(), match2.GetHashCode());
Assert.NotEqual(match1.GetHashCode(), match3.GetHashCode());
Assert.NotEqual(match1.GetHashCode(), match4.GetHashCode());
// FilePatternMatch is case insensitive
FilePatternMatch matchCase1 = new FilePatternMatch("Sub/Sub2/bar/baz/three.txt", "sub2/bar/baz/three.txt");
FilePatternMatch matchCase2 = new FilePatternMatch("sub/sub2/bar/baz/three.txt", "Sub2/bar/baz/thrEE.txt");
Assert.Equal(matchCase1.GetHashCode(), matchCase2.GetHashCode());
}
}
}
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/tests/JIT/jit64/mcc/interop/mcc_i57.il | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern System.Runtime.Extensions { auto }
.assembly extern xunit.core {}
.assembly extern mscorlib { auto }
.assembly 'mcc_i57' {}
.namespace MCCTest
{
.class MyClass
{
.method assembly static pinvokeimpl("native_i5s" as "#1" stdcall)
valuetype MCCTest.VType5 Sum(unsigned int64, valuetype MCCTest.VType5, float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5, unsigned int16, valuetype MCCTest.VType5, unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5, int64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5, int16, valuetype MCCTest.VType5) cil managed preservesig {
}
.method private valuetype MCCTest.VType5 GetSum()
{
.maxstack 64
.locals init (
[0] valuetype MCCTest.VType5 v1,
[1] valuetype MCCTest.VType5 v2,
[2] valuetype MCCTest.VType5 v3,
[3] valuetype MCCTest.VType5 v4,
[4] valuetype MCCTest.VType5 v5,
[5] valuetype MCCTest.VType5 v6,
[6] valuetype MCCTest.VType5 v7,
[7] valuetype MCCTest.VType5 v8,
[8] valuetype MCCTest.VType5 v9,
[9] valuetype MCCTest.VType5 v10,
[10] valuetype MCCTest.VType5 v11,
[11] valuetype MCCTest.VType5 v12
)
// Initialize v1 thru v12
ldloca.s v1
call instance void MCCTest.VType5::Init()
ldloca.s v2
call instance void MCCTest.VType5::Init()
ldloca.s v3
call instance void MCCTest.VType5::Init()
ldloca.s v4
call instance void MCCTest.VType5::Init()
ldloca.s v5
call instance void MCCTest.VType5::Init()
ldloca.s v6
call instance void MCCTest.VType5::Init()
ldloca.s v7
call instance void MCCTest.VType5::Init()
ldloca.s v8
call instance void MCCTest.VType5::Init()
ldloca.s v9
call instance void MCCTest.VType5::Init()
ldloca.s v10
call instance void MCCTest.VType5::Init()
ldloca.s v11
call instance void MCCTest.VType5::Init()
ldloca.s v12
call instance void MCCTest.VType5::Init()
ldc.i8 1
ldloc.s v1
ldc.r8 2
ldloc.s v2
ldc.r4 3
ldloc.s v3
ldc.i4 4
ldloc.s v4
ldc.i8 5
conv.u2
ldloc.s v5
ldc.i4 6
ldloc.s v6
ldc.r4 7
ldloc.s v7
ldc.i8 8
ldloc.s v8
ldc.r4 9
ldloc.s v9
ldc.r8 10
ldloc.s v10
ldc.r4 11
ldloc.s v11
ldc.i8 12
conv.i2
ldloc.s v12
call valuetype MCCTest.VType5 MCCTest.MyClass::GetSum2( unsigned int64, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5,
unsigned int16, valuetype MCCTest.VType5,
unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
int64, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
int16, valuetype MCCTest.VType5)
ret
}
.method private static valuetype MCCTest.VType5 GetSum2(unsigned int64, valuetype MCCTest.VType5, float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5, unsigned int16, valuetype MCCTest.VType5, unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5, int64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5, int16, valuetype MCCTest.VType5)
{
jmp valuetype MCCTest.VType5 MCCTest.MyClass::Sum(unsigned int64, valuetype MCCTest.VType5, float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5, unsigned int16, valuetype MCCTest.VType5, unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5, int64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5, int16, valuetype MCCTest.VType5)
}
.method public specialname rtspecialname instance void .ctor()
{
.maxstack 1
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
} // end of method MyClass::.ctor
.method private static int32 Main(string[] args)
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
.maxstack 64
.locals init (
[0] class MCCTest.MyClass me,
[1] valuetype MCCTest.VType5 res,
[2] int32 rc
)
newobj instance void MCCTest.MyClass::.ctor()
stloc.s me
ldloc.s me
call instance valuetype MCCTest.VType5 MCCTest.MyClass::GetSum()
stloc.s res
// Check Result
ldloc.s res
ldc.i4 12
call int32 MCCTest.Common::CheckResult(valuetype MCCTest.VType5, int32)
stloc.s rc
ldloc.s rc
ret
} // end of method MyClass::Main
} // end of class MyClass
} // end of namespace MCCTest
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
.assembly extern System.Runtime.Extensions { auto }
.assembly extern xunit.core {}
.assembly extern mscorlib { auto }
.assembly 'mcc_i57' {}
.namespace MCCTest
{
.class MyClass
{
.method assembly static pinvokeimpl("native_i5s" as "#1" stdcall)
valuetype MCCTest.VType5 Sum(unsigned int64, valuetype MCCTest.VType5, float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5, unsigned int16, valuetype MCCTest.VType5, unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5, int64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5, int16, valuetype MCCTest.VType5) cil managed preservesig {
}
.method private valuetype MCCTest.VType5 GetSum()
{
.maxstack 64
.locals init (
[0] valuetype MCCTest.VType5 v1,
[1] valuetype MCCTest.VType5 v2,
[2] valuetype MCCTest.VType5 v3,
[3] valuetype MCCTest.VType5 v4,
[4] valuetype MCCTest.VType5 v5,
[5] valuetype MCCTest.VType5 v6,
[6] valuetype MCCTest.VType5 v7,
[7] valuetype MCCTest.VType5 v8,
[8] valuetype MCCTest.VType5 v9,
[9] valuetype MCCTest.VType5 v10,
[10] valuetype MCCTest.VType5 v11,
[11] valuetype MCCTest.VType5 v12
)
// Initialize v1 thru v12
ldloca.s v1
call instance void MCCTest.VType5::Init()
ldloca.s v2
call instance void MCCTest.VType5::Init()
ldloca.s v3
call instance void MCCTest.VType5::Init()
ldloca.s v4
call instance void MCCTest.VType5::Init()
ldloca.s v5
call instance void MCCTest.VType5::Init()
ldloca.s v6
call instance void MCCTest.VType5::Init()
ldloca.s v7
call instance void MCCTest.VType5::Init()
ldloca.s v8
call instance void MCCTest.VType5::Init()
ldloca.s v9
call instance void MCCTest.VType5::Init()
ldloca.s v10
call instance void MCCTest.VType5::Init()
ldloca.s v11
call instance void MCCTest.VType5::Init()
ldloca.s v12
call instance void MCCTest.VType5::Init()
ldc.i8 1
ldloc.s v1
ldc.r8 2
ldloc.s v2
ldc.r4 3
ldloc.s v3
ldc.i4 4
ldloc.s v4
ldc.i8 5
conv.u2
ldloc.s v5
ldc.i4 6
ldloc.s v6
ldc.r4 7
ldloc.s v7
ldc.i8 8
ldloc.s v8
ldc.r4 9
ldloc.s v9
ldc.r8 10
ldloc.s v10
ldc.r4 11
ldloc.s v11
ldc.i8 12
conv.i2
ldloc.s v12
call valuetype MCCTest.VType5 MCCTest.MyClass::GetSum2( unsigned int64, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5,
unsigned int16, valuetype MCCTest.VType5,
unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
int64, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5,
int16, valuetype MCCTest.VType5)
ret
}
.method private static valuetype MCCTest.VType5 GetSum2(unsigned int64, valuetype MCCTest.VType5, float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5, unsigned int16, valuetype MCCTest.VType5, unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5, int64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5, int16, valuetype MCCTest.VType5)
{
jmp valuetype MCCTest.VType5 MCCTest.MyClass::Sum(unsigned int64, valuetype MCCTest.VType5, float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
int32, valuetype MCCTest.VType5, unsigned int16, valuetype MCCTest.VType5, unsigned int32, valuetype MCCTest.VType5,
float32, valuetype MCCTest.VType5, int64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5,
float64, valuetype MCCTest.VType5, float32, valuetype MCCTest.VType5, int16, valuetype MCCTest.VType5)
}
.method public specialname rtspecialname instance void .ctor()
{
.maxstack 1
ldarg.0
call instance void [mscorlib]System.Object::.ctor()
ret
} // end of method MyClass::.ctor
.method private static int32 Main(string[] args)
{
.custom instance void [xunit.core]Xunit.FactAttribute::.ctor() = (
01 00 00 00
)
.entrypoint
.maxstack 64
.locals init (
[0] class MCCTest.MyClass me,
[1] valuetype MCCTest.VType5 res,
[2] int32 rc
)
newobj instance void MCCTest.MyClass::.ctor()
stloc.s me
ldloc.s me
call instance valuetype MCCTest.VType5 MCCTest.MyClass::GetSum()
stloc.s res
// Check Result
ldloc.s res
ldc.i4 12
call int32 MCCTest.Common::CheckResult(valuetype MCCTest.VType5, int32)
stloc.s rc
ldloc.s rc
ret
} // end of method MyClass::Main
} // end of class MyClass
} // end of namespace MCCTest
| -1 |
dotnet/runtime | 66,006 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…" | Reverts this as x86 still uses it.
| vargaz | 2022-03-01T15:15:53Z | 2022-03-01T20:09:47Z | af71404d9a3b38e63408af47cc847ac1a1fcf4e1 | 2dd232a53c38ac874b15fe504df275b660988294 | Revert "[mono][jit] Remove support for -O=-float32, i.e. treating r4 values a…". Reverts this as x86 still uses it.
| ./src/libraries/System.Drawing.Common/src/System/Drawing/Printing/MarginsConverter.cs | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
namespace System.Drawing.Printing
{
/// <summary>
/// Provides a type converter to convert <see cref='System.Drawing.Printing.Margins'/> to and from various other representations, such as a string.
/// </summary>
public class MarginsConverter : ExpandableObjectConverter
{
/// <summary>
/// Determines if a converter can convert an object of the given source
/// type to the native type of the converter.
/// </summary>
public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
{
if (sourceType == typeof(string))
{
return true;
}
return base.CanConvertFrom(context, sourceType);
}
/// <summary>
/// Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.
/// </summary>
public override bool CanConvertTo(ITypeDescriptorContext? context, [NotNullWhen(true)] Type? destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
{
return true;
}
return base.CanConvertTo(context, destinationType);
}
/// <summary>
/// Converts the given object to the converter's native type.
/// </summary>
public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value)
{
if (value is string strValue)
{
string text = strValue.Trim();
if (text.Length == 0)
{
return null;
}
else
{
// Parse 4 integer values.
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
char sep = culture.TextInfo.ListSeparator[0];
string[] tokens = text.Split(sep);
int[] values = new int[tokens.Length];
TypeConverter intConverter = GetIntConverter();
for (int i = 0; i < values.Length; i++)
{
// Note: ConvertFromString will raise exception if value cannot be converted.
values[i] = (int)intConverter.ConvertFromString(context, culture, tokens[i])!;
}
if (values.Length != 4)
{
throw new ArgumentException(SR.Format(SR.TextParseFailedFormat, text, "left, right, top, bottom"));
}
return new Margins(values[0], values[1], values[2], values[3]);
}
}
return base.ConvertFrom(context, culture, value);
}
[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
Justification = "TypeDescriptor.GetConverter is safe for primitive types.")]
private static TypeConverter GetIntConverter() => TypeDescriptor.GetConverter(typeof(int));
/// <summary>
/// Converts the given object to another type. The most common types to convert
/// are to and from a string object. The default implementation will make a call
/// to ToString on the object if the object is valid and if the destination
/// type is string. If this cannot convert to the desitnation type, this will
/// throw a NotSupportedException.
/// </summary>
public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType!!)
{
if (value is Margins margins)
{
if (destinationType == typeof(string))
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string sep = culture.TextInfo.ListSeparator + " ";
TypeConverter intConverter = GetIntConverter();
string?[] args = new string[4];
int nArg = 0;
// Note: ConvertToString will raise exception if value cannot be converted.
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Left);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Right);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Top);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Bottom);
return string.Join(sep, args);
}
if (destinationType == typeof(InstanceDescriptor))
{
ConstructorInfo? ctor = typeof(Margins).GetConstructor(new Type[] {
typeof(int), typeof(int), typeof(int), typeof(int)});
if (ctor != null)
{
return new InstanceDescriptor(ctor, new object[] {
margins.Left, margins.Right, margins.Top, margins.Bottom});
}
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Determines if changing a value on this object should require a call to
/// CreateInstance to create a new value.
/// </summary>
public override bool GetCreateInstanceSupported(ITypeDescriptorContext? context) => true;
/// <summary>
/// Creates an instance of this type given a set of property values
/// for the object. This is useful for objects that are immutable, but still
/// want to provide changable properties.
/// </summary>
public override object CreateInstance(ITypeDescriptorContext? context, IDictionary propertyValues!!)
{
object? left = propertyValues["Left"];
object? right = propertyValues["Right"];
object? top = propertyValues["Top"];
object? bottom = propertyValues["Bottom"];
if (left == null || right == null || bottom == null || top == null ||
!(left is int) || !(right is int) || !(bottom is int) || !(top is int))
{
throw new ArgumentException(SR.PropertyValueInvalidEntry);
}
return new Margins((int)left,
(int)right,
(int)top,
(int)bottom);
}
}
}
| // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
namespace System.Drawing.Printing
{
/// <summary>
/// Provides a type converter to convert <see cref='System.Drawing.Printing.Margins'/> to and from various other representations, such as a string.
/// </summary>
public class MarginsConverter : ExpandableObjectConverter
{
/// <summary>
/// Determines if a converter can convert an object of the given source
/// type to the native type of the converter.
/// </summary>
public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
{
if (sourceType == typeof(string))
{
return true;
}
return base.CanConvertFrom(context, sourceType);
}
/// <summary>
/// Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.
/// </summary>
public override bool CanConvertTo(ITypeDescriptorContext? context, [NotNullWhen(true)] Type? destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
{
return true;
}
return base.CanConvertTo(context, destinationType);
}
/// <summary>
/// Converts the given object to the converter's native type.
/// </summary>
public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value)
{
if (value is string strValue)
{
string text = strValue.Trim();
if (text.Length == 0)
{
return null;
}
else
{
// Parse 4 integer values.
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
char sep = culture.TextInfo.ListSeparator[0];
string[] tokens = text.Split(sep);
int[] values = new int[tokens.Length];
TypeConverter intConverter = GetIntConverter();
for (int i = 0; i < values.Length; i++)
{
// Note: ConvertFromString will raise exception if value cannot be converted.
values[i] = (int)intConverter.ConvertFromString(context, culture, tokens[i])!;
}
if (values.Length != 4)
{
throw new ArgumentException(SR.Format(SR.TextParseFailedFormat, text, "left, right, top, bottom"));
}
return new Margins(values[0], values[1], values[2], values[3]);
}
}
return base.ConvertFrom(context, culture, value);
}
[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode",
Justification = "TypeDescriptor.GetConverter is safe for primitive types.")]
private static TypeConverter GetIntConverter() => TypeDescriptor.GetConverter(typeof(int));
/// <summary>
/// Converts the given object to another type. The most common types to convert
/// are to and from a string object. The default implementation will make a call
/// to ToString on the object if the object is valid and if the destination
/// type is string. If this cannot convert to the desitnation type, this will
/// throw a NotSupportedException.
/// </summary>
public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType!!)
{
if (value is Margins margins)
{
if (destinationType == typeof(string))
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string sep = culture.TextInfo.ListSeparator + " ";
TypeConverter intConverter = GetIntConverter();
string?[] args = new string[4];
int nArg = 0;
// Note: ConvertToString will raise exception if value cannot be converted.
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Left);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Right);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Top);
args[nArg++] = intConverter.ConvertToString(context, culture, margins.Bottom);
return string.Join(sep, args);
}
if (destinationType == typeof(InstanceDescriptor))
{
ConstructorInfo? ctor = typeof(Margins).GetConstructor(new Type[] {
typeof(int), typeof(int), typeof(int), typeof(int)});
if (ctor != null)
{
return new InstanceDescriptor(ctor, new object[] {
margins.Left, margins.Right, margins.Top, margins.Bottom});
}
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
/// <summary>
/// Determines if changing a value on this object should require a call to
/// CreateInstance to create a new value.
/// </summary>
public override bool GetCreateInstanceSupported(ITypeDescriptorContext? context) => true;
/// <summary>
/// Creates an instance of this type given a set of property values
/// for the object. This is useful for objects that are immutable, but still
/// want to provide changable properties.
/// </summary>
public override object CreateInstance(ITypeDescriptorContext? context, IDictionary propertyValues!!)
{
object? left = propertyValues["Left"];
object? right = propertyValues["Right"];
object? top = propertyValues["Top"];
object? bottom = propertyValues["Bottom"];
if (left == null || right == null || bottom == null || top == null ||
!(left is int) || !(right is int) || !(bottom is int) || !(top is int))
{
throw new ArgumentException(SR.PropertyValueInvalidEntry);
}
return new Margins((int)left,
(int)right,
(int)top,
(int)bottom);
}
}
}
| -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.