summaryrefslogtreecommitdiff
path: root/src/inc/corhlpr.cpp
diff options
context:
space:
mode:
authorJiyoung Yun <jy910.yun@samsung.com>2016-11-23 10:09:09 (GMT)
committerJiyoung Yun <jy910.yun@samsung.com>2016-11-23 10:09:09 (GMT)
commit4b4aad7217d3292650e77eec2cf4c198ea9c3b4b (patch)
tree98110734c91668dfdbb126fcc0e15ddbd93738ca /src/inc/corhlpr.cpp
parentfa45f57ed55137c75ac870356a1b8f76c84b229c (diff)
downloadcoreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.zip
coreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.tar.gz
coreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.tar.bz2
Imported Upstream version 1.1.0upstream/1.1.0
Diffstat (limited to 'src/inc/corhlpr.cpp')
-rw-r--r--src/inc/corhlpr.cpp307
1 files changed, 307 insertions, 0 deletions
diff --git a/src/inc/corhlpr.cpp b/src/inc/corhlpr.cpp
new file mode 100644
index 0000000..ba803a5
--- /dev/null
+++ b/src/inc/corhlpr.cpp
@@ -0,0 +1,307 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/****************************************************************************
+ ** **
+ ** Corhlpr.h - signature helpers. **
+ ** **
+ ****************************************************************************/
+#ifndef SOS_INCLUDE
+
+#ifdef _BLD_CLR
+#include "utilcode.h"
+#endif
+#include "corhlpr.h"
+#include <stdlib.h>
+
+#endif // !SOS_INCLUDE
+
+
+//*****************************************************************************
+//
+//***** File format helper classes
+//
+//*****************************************************************************
+
+extern "C" {
+
+/***************************************************************************/
+/* Note that this construtor does not set the LocalSig, but has the
+ advantage that it does not have any dependancy on EE structures.
+ inside the EE use the FunctionDesc constructor */
+
+void __stdcall DecoderInit(void *pThis, COR_ILMETHOD *header)
+{
+ COR_ILMETHOD_DECODER *decoder = (COR_ILMETHOD_DECODER *)pThis;
+
+ memset(decoder, 0, sizeof(COR_ILMETHOD_DECODER));
+ if (header->Tiny.IsTiny())
+ {
+ decoder->SetMaxStack(header->Tiny.GetMaxStack());
+ decoder->Code = header->Tiny.GetCode();
+ decoder->SetCodeSize(header->Tiny.GetCodeSize());
+ decoder->SetFlags(CorILMethod_TinyFormat);
+ return;
+ }
+ if (header->Fat.IsFat())
+ {
+#ifdef _WIN64
+ if((((size_t) header) & 3) == 0) // header is aligned
+#else
+ _ASSERTE((((size_t) header) & 3) == 0); // header is aligned
+#endif
+ {
+ *((COR_ILMETHOD_FAT *)decoder) = header->Fat;
+ decoder->Code = header->Fat.GetCode();
+ if (header->Fat.GetSize() >= (sizeof(COR_ILMETHOD_FAT) / 4)) // Size if valid
+ {
+ decoder->Sect = header->Fat.GetSect();
+ if ((decoder->Sect != NULL) && (decoder->Sect->Kind() == CorILMethod_Sect_EHTable))
+ {
+ decoder->EH = (COR_ILMETHOD_SECT_EH *)decoder->Sect;
+ decoder->Sect = decoder->Sect->Next();
+ }
+ }
+ }
+ return;
+ }
+} // DecoderInit
+
+// Calculate the total method size. First get address of end of code. If there are no sections, then
+// the end of code addr marks end of COR_ILMETHOD. Otherwise find addr of end of last section and use it
+// to mark end of COR_ILMETHOD. Assumes that the code is directly followed
+// by each section in the on-disk format
+int __stdcall DecoderGetOnDiskSize(void * pThis, COR_ILMETHOD* header)
+{
+ COR_ILMETHOD_DECODER* decoder = (COR_ILMETHOD_DECODER*)pThis;
+
+ if (decoder->Code == NULL)
+ return 0;
+
+ BYTE *lastAddr = (BYTE*)decoder->Code + decoder->GetCodeSize(); // addr of end of code
+ const COR_ILMETHOD_SECT *sect = decoder->EH;
+ if (sect != 0 && sect->Next() == 0)
+ {
+ lastAddr = (BYTE *)sect + sect->DataSize();
+ }
+ else
+ {
+ const COR_ILMETHOD_SECT *nextSect;
+ for (sect = decoder->Sect; sect; sect = nextSect)
+ {
+ nextSect = sect->Next();
+ if (nextSect == 0)
+ {
+ // sect points to the last section, so set lastAddr
+ lastAddr = (BYTE *)sect + sect->DataSize();
+ break;
+ }
+ }
+ }
+ return (int)(lastAddr - (BYTE*)header);
+}
+
+/*********************************************************************/
+/* APIs for emitting sections etc */
+
+unsigned __stdcall IlmethodSize(COR_ILMETHOD_FAT* header, BOOL moreSections)
+{
+ if (header->GetMaxStack() <= 8 && (header->GetFlags() & ~CorILMethod_FormatMask) == 0
+ && header->GetLocalVarSigTok() == 0 && header->GetCodeSize() < 64 && !moreSections)
+ return(sizeof(COR_ILMETHOD_TINY));
+
+ return(sizeof(COR_ILMETHOD_FAT));
+}
+
+/*********************************************************************/
+ // emit the header (bestFormat) return amount emitted
+unsigned __stdcall IlmethodEmit(unsigned size, COR_ILMETHOD_FAT* header,
+ BOOL moreSections, BYTE* outBuff)
+{
+#ifndef SOS_INCLUDE
+#ifdef _DEBUG
+ BYTE* origBuff = outBuff;
+#endif
+#endif // !SOS_INCLUDE
+ if (size == 1) {
+ // Tiny format
+ *outBuff++ = (BYTE) (CorILMethod_TinyFormat | (header->GetCodeSize() << 2));
+ }
+ else {
+ // Fat format
+ _ASSERTE((((size_t) outBuff) & 3) == 0); // header is dword aligned
+ COR_ILMETHOD_FAT* fatHeader = (COR_ILMETHOD_FAT*) outBuff;
+ outBuff += sizeof(COR_ILMETHOD_FAT);
+ *fatHeader = *header;
+ fatHeader->SetFlags(fatHeader->GetFlags() | CorILMethod_FatFormat);
+ _ASSERTE((fatHeader->GetFlags() & CorILMethod_FormatMask) == CorILMethod_FatFormat);
+ if (moreSections)
+ fatHeader->SetFlags(fatHeader->GetFlags() | CorILMethod_MoreSects);
+ fatHeader->SetSize(sizeof(COR_ILMETHOD_FAT) / 4);
+ }
+#ifndef SOS_INCLUDE
+ _ASSERTE(&origBuff[size] == outBuff);
+#endif // !SOS_INCLUDE
+ return(size);
+}
+
+/*********************************************************************/
+/* static */
+IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT* __stdcall SectEH_EHClause(void *pSectEH, unsigned idx, IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT* buff)
+{
+ if (((COR_ILMETHOD_SECT_EH *)pSectEH)->IsFat())
+ return(&(((COR_ILMETHOD_SECT_EH *)pSectEH)->Fat.Clauses[idx]));
+
+ COR_ILMETHOD_SECT_EH_CLAUSE_FAT* fatClause = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)buff;
+ COR_ILMETHOD_SECT_EH_CLAUSE_SMALL* smallClause = (COR_ILMETHOD_SECT_EH_CLAUSE_SMALL*)&((COR_ILMETHOD_SECT_EH *)pSectEH)->Small.Clauses[idx];
+
+ // mask to remove sign extension - cast just wouldn't work
+ fatClause->SetFlags((CorExceptionFlag)(smallClause->GetFlags()&0x0000ffff));
+ fatClause->SetClassToken(smallClause->GetClassToken());
+ fatClause->SetTryOffset(smallClause->GetTryOffset());
+ fatClause->SetTryLength(smallClause->GetTryLength());
+ fatClause->SetHandlerLength(smallClause->GetHandlerLength());
+ fatClause->SetHandlerOffset(smallClause->GetHandlerOffset());
+ return(buff);
+}
+/*********************************************************************/
+ // compute the size of the section (best format)
+ // codeSize is the size of the method
+ // deprecated
+unsigned __stdcall SectEH_SizeWithCode(unsigned ehCount, unsigned codeSize)
+{
+ return((ehCount)? SectEH_SizeWorst(ehCount) : 0);
+}
+
+ // will return worse-case size and then Emit will return actual size
+unsigned __stdcall SectEH_SizeWorst(unsigned ehCount)
+{
+ return((ehCount)? (COR_ILMETHOD_SECT_EH_FAT::Size(ehCount)) : 0);
+}
+
+ // will return exact size which will match the size returned by Emit
+unsigned __stdcall SectEH_SizeExact(unsigned ehCount, IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT* clauses)
+{
+ if (ehCount == 0)
+ return(0);
+
+ unsigned smallSize = COR_ILMETHOD_SECT_EH_SMALL::Size(ehCount);
+ if (smallSize > COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE)
+ return(COR_ILMETHOD_SECT_EH_FAT::Size(ehCount));
+ for (unsigned i = 0; i < ehCount; i++) {
+ COR_ILMETHOD_SECT_EH_CLAUSE_FAT* fatClause = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)&clauses[i];
+ if (fatClause->GetTryOffset() > 0xFFFF ||
+ fatClause->GetTryLength() > 0xFF ||
+ fatClause->GetHandlerOffset() > 0xFFFF ||
+ fatClause->GetHandlerLength() > 0xFF) {
+ return(COR_ILMETHOD_SECT_EH_FAT::Size(ehCount));
+ }
+ }
+ return smallSize;
+}
+
+/*********************************************************************/
+
+ // emit the section (best format);
+unsigned __stdcall SectEH_Emit(unsigned size, unsigned ehCount,
+ IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT* clauses,
+ BOOL moreSections, BYTE* outBuff,
+ ULONG* ehTypeOffsets)
+{
+ if (size == 0)
+ return(0);
+
+ _ASSERTE((((size_t) outBuff) & 3) == 0); // header is dword aligned
+ BYTE* origBuff = outBuff;
+ if (ehCount <= 0)
+ return 0;
+
+ // Initialize the ehTypeOffsets array.
+ if (ehTypeOffsets)
+ {
+ for (unsigned int i = 0; i < ehCount; i++)
+ ehTypeOffsets[i] = (ULONG) -1;
+ }
+
+ if (COR_ILMETHOD_SECT_EH_SMALL::Size(ehCount) < COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE) {
+ COR_ILMETHOD_SECT_EH_SMALL* EHSect = (COR_ILMETHOD_SECT_EH_SMALL*) outBuff;
+ unsigned i;
+ for (i = 0; i < ehCount; i++) {
+ COR_ILMETHOD_SECT_EH_CLAUSE_FAT* fatClause = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)&clauses[i];
+ if (fatClause->GetTryOffset() > 0xFFFF ||
+ fatClause->GetTryLength() > 0xFF ||
+ fatClause->GetHandlerOffset() > 0xFFFF ||
+ fatClause->GetHandlerLength() > 0xFF) {
+ break; // fall through and generate as FAT
+ }
+ _ASSERTE((fatClause->GetFlags() & ~0xFFFF) == 0);
+ _ASSERTE((fatClause->GetTryOffset() & ~0xFFFF) == 0);
+ _ASSERTE((fatClause->GetTryLength() & ~0xFF) == 0);
+ _ASSERTE((fatClause->GetHandlerOffset() & ~0xFFFF) == 0);
+ _ASSERTE((fatClause->GetHandlerLength() & ~0xFF) == 0);
+
+ COR_ILMETHOD_SECT_EH_CLAUSE_SMALL* smallClause = (COR_ILMETHOD_SECT_EH_CLAUSE_SMALL*)&EHSect->Clauses[i];
+ smallClause->SetFlags((CorExceptionFlag) fatClause->GetFlags());
+ smallClause->SetTryOffset(fatClause->GetTryOffset());
+ smallClause->SetTryLength(fatClause->GetTryLength());
+ smallClause->SetHandlerOffset(fatClause->GetHandlerOffset());
+ smallClause->SetHandlerLength(fatClause->GetHandlerLength());
+ smallClause->SetClassToken(fatClause->GetClassToken());
+ }
+ if (i >= ehCount) {
+ // if actually got through all the clauses and they are small enough
+ EHSect->Kind = CorILMethod_Sect_EHTable;
+ if (moreSections)
+ EHSect->Kind |= CorILMethod_Sect_MoreSects;
+#ifndef SOS_INCLUDE
+ EHSect->DataSize = EHSect->Size(ehCount);
+#else
+ EHSect->DataSize = (BYTE) EHSect->Size(ehCount);
+#endif // !SOS_INCLUDE
+ EHSect->Reserved = 0;
+ _ASSERTE(EHSect->DataSize == EHSect->Size(ehCount)); // make sure didn't overflow
+ outBuff = (BYTE*) &EHSect->Clauses[ehCount];
+ // Set the offsets for the exception type tokens.
+ if (ehTypeOffsets)
+ {
+ for (i = 0; i < ehCount; i++) {
+ COR_ILMETHOD_SECT_EH_CLAUSE_SMALL* smallClause = (COR_ILMETHOD_SECT_EH_CLAUSE_SMALL*)&EHSect->Clauses[i];
+ if (smallClause->GetFlags() == COR_ILEXCEPTION_CLAUSE_NONE)
+ {
+ _ASSERTE(! IsNilToken(smallClause->GetClassToken()));
+ ehTypeOffsets[i] = (ULONG)((BYTE *)&smallClause->ClassToken - origBuff);
+ }
+ }
+ }
+ return(size);
+ }
+ }
+ // either total size too big or one of constituent elements too big (eg. offset or length)
+ COR_ILMETHOD_SECT_EH_FAT* EHSect = (COR_ILMETHOD_SECT_EH_FAT*) outBuff;
+ EHSect->SetKind(CorILMethod_Sect_EHTable | CorILMethod_Sect_FatFormat);
+ if (moreSections)
+ EHSect->SetKind(EHSect->GetKind() | CorILMethod_Sect_MoreSects);
+
+ EHSect->SetDataSize(EHSect->Size(ehCount));
+ memcpy(EHSect->Clauses, clauses, ehCount * sizeof(COR_ILMETHOD_SECT_EH_CLAUSE_FAT));
+ outBuff = (BYTE*) &EHSect->Clauses[ehCount];
+ _ASSERTE(&origBuff[size] == outBuff);
+ // Set the offsets for the exception type tokens.
+ if (ehTypeOffsets)
+ {
+ for (unsigned int i = 0; i < ehCount; i++) {
+ COR_ILMETHOD_SECT_EH_CLAUSE_FAT* fatClause = (COR_ILMETHOD_SECT_EH_CLAUSE_FAT*)&EHSect->Clauses[i];
+ if (fatClause->GetFlags() == COR_ILEXCEPTION_CLAUSE_NONE)
+ {
+ _ASSERTE(! IsNilToken(fatClause->GetClassToken()));
+ ehTypeOffsets[i] = (ULONG)((BYTE *)&fatClause->ClassToken - origBuff);
+ }
+ }
+ }
+ return(size);
+}
+
+} // extern "C"
+
+