| //===---------- Assembly.h - Definition of an assembly --------------------===// |
| // |
| // N3 |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| |
| #ifndef N3_ASSEMBLY_H |
| #define N3_ASSEMBLY_H |
| |
| #include <vector> |
| |
| #include "types.h" |
| |
| #include "mvm/Object.h" |
| #include "mvm/Threads/Locks.h" |
| #include "mvm/Threads/Cond.h" |
| |
| #include "llvm/DerivedTypes.h" |
| #include "llvm/Type.h" |
| |
| #include "VMArray.h" |
| |
| namespace llvm { |
| class GenericValue; |
| } |
| |
| namespace mvm { |
| class UTF8; |
| class UTF8Map; |
| } |
| |
| namespace n3 { |
| |
| using mvm::UTF8; |
| using mvm::UTF8Map; |
| |
| class ArrayChar; |
| class ArrayObject; |
| class Assembly; |
| class ClassNameMap; |
| class ClassTokenMap; |
| class FieldTokenMap; |
| class MethodTokenMap; |
| class N3; |
| class Param; |
| class Property; |
| class Reader; |
| class VMClass; |
| class VMGenericClass; |
| class VMClassArray; |
| class VMClassPointer; |
| class VMCommonClass; |
| class VMField; |
| class VMMethod; |
| class VMObject; |
| class VMGenericClass; |
| class VMGenericMethod; |
| class ByteCode; |
| |
| class Section : public mvm::PermanentObject { |
| public: |
| virtual void print(mvm::PrintBuffer* buf) const; |
| |
| char* name; |
| uint32 virtualSize; |
| uint32 virtualAddress; |
| uint32 rawSize; |
| uint32 rawAddress; |
| uint32 relocAddress; |
| uint32 lineNumbers; |
| uint32 relocationsNumber; |
| uint32 lineNumbersNumber; |
| uint32 characteristics; |
| |
| void read(Reader* reader, N3* vm); |
| }; |
| |
| class Stream : public mvm::PermanentObject { |
| public: |
| virtual void print(mvm::PrintBuffer* buf) const; |
| |
| char* name; |
| uint32 realOffset; |
| uint32 size; |
| }; |
| |
| class Table : public mvm::PermanentObject { |
| public: |
| virtual void print(mvm::PrintBuffer* buf) const; |
| |
| uint32 offset; |
| uint32 rowsNumber; |
| uint32 rowSize; |
| uint32 count; |
| uint32 sizeMask; |
| |
| void readRow(uint32* result, uint32 row, ByteCode* array); |
| uint32 readIndexInRow(uint32 row, uint32 index, ByteCode* array); |
| |
| }; |
| |
| |
| class Header : public mvm::PermanentObject { |
| public: |
| virtual void print(mvm::PrintBuffer* buf) const; |
| |
| uint32 signature; |
| uint32 major; |
| uint32 minor; |
| uint32 reserved; |
| uint32 versionLength; |
| uint32 flags; |
| uint32 nbStreams; |
| |
| const UTF8* versionName; |
| Stream* tildStream; |
| Stream* stringStream; |
| Stream* usStream; |
| Stream* blobStream; |
| Stream* guidStream; |
| std::vector<Table*, gc_allocator<Table*> > tables; |
| |
| void read(mvm::BumpPtrAllocator &allocator, Reader* reader, N3* vm); |
| }; |
| |
| typedef void (*maskVector_t)(uint32 index, |
| std::vector<Table*, gc_allocator<Table*> >& tables, |
| uint32 heapSizes); |
| |
| typedef VMCommonClass* (*signatureVector_t)(uint32 op, Assembly* ass, |
| uint32& offset, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| |
| class Assembly : public mvm::PermanentObject { |
| public: |
| virtual void print(mvm::PrintBuffer* buf) const; |
| virtual void TRACER; |
| |
| VMClassPointer* constructPointer(VMCommonClass* base, uint32 dims); |
| VMClassArray* constructArray(VMCommonClass* base, uint32 dims); |
| VMClassArray* constructArray(const UTF8* name, const UTF8* nameSpace, |
| uint32 dims); |
| VMClass* constructClass(const UTF8* name, |
| const UTF8* nameSpace, uint32 token); |
| VMGenericClass* constructGenericClass(const UTF8* name, |
| const UTF8* nameSpace, |
| std::vector<VMCommonClass*> genArgs, |
| uint32 token); |
| VMField* constructField(VMClass* cl, const UTF8* name, |
| VMCommonClass* signature, uint32 token, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMMethod* constructMethod(VMClass* cl, const UTF8* name, |
| uint32 token, bool generic, std::vector<VMCommonClass*>* genMethodInstantiation, VMGenericClass* genClass); |
| VMCommonClass* lookupClassFromName(const UTF8* name, const UTF8* nameSpace); |
| VMCommonClass* lookupClassFromToken(uint32 token); |
| VMMethod* lookupMethodFromToken(uint32 token); |
| VMField* lookupFieldFromToken(uint32 token); |
| |
| VMObject* getAssemblyDelegatee(); |
| |
| ClassNameMap* loadedNameClasses; |
| ClassTokenMap* loadedTokenClasses; |
| MethodTokenMap* loadedTokenMethods; |
| FieldTokenMap* loadedTokenFields; |
| |
| N3* vm; |
| mvm::Lock* lockVar; |
| mvm::Cond* condVar; |
| const UTF8* name; |
| ByteCode* bytes; |
| Section* textSection; |
| Section* rsrcSection; |
| Section* relocSection; |
| Header* CLIHeader; |
| VMObject* ooo_delegatee; |
| Assembly** assemblyRefs; |
| |
| uint32 CLIHeaderLocation; |
| volatile bool isRead; |
| uint32 cb; |
| uint32 major; |
| uint32 minor; |
| uint32 mdRva; |
| uint32 mdSize; |
| uint32 flags; |
| uint32 entryPoint; |
| uint32 resRva; |
| uint32 resSize; |
| |
| mvm::BumpPtrAllocator &allocator; |
| |
| Assembly(mvm::BumpPtrAllocator &Alloc, N3 *vm, const UTF8* name); |
| |
| int open(const char *ext); |
| int resolve(int doResolve, const char *ext); |
| |
| static const UTF8* readUTF8(N3* vm, uint32 len, Reader* reader); |
| static const UTF8* readUTF8(N3* vm, uint32 len, ByteCode* bytes, uint32& offset); |
| static const ArrayChar* readUTF16(N3* vm, uint32 len, Reader* reader); |
| static const ArrayChar* readUTF16(N3* vm, uint32 len, ByteCode* bytes, uint32& offset); |
| const UTF8* readString(N3* vm, uint32 offset); |
| void readTables(Reader* reader); |
| |
| static maskVector_t maskVector[64]; |
| static const char* maskVectorName[64]; |
| static signatureVector_t signatureVector[0x46]; |
| static const char* signatureNames[0x46]; |
| |
| |
| Reader *newReader(ByteCode* array, uint32 start = 0, uint32 end = 0); |
| |
| uint32 uncompressSignature(uint32& offset); |
| uint32 getTypeDefTokenFromMethod(uint32 token); |
| VMCommonClass* loadType(N3* vm, uint32 token, bool resolveFunc, bool resolve, |
| bool clinit, bool dothrow, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMCommonClass* loadType(N3* vm, uint32 token, bool resolveFunc, bool resolve, |
| bool clinit, bool dothrow, std::vector<VMCommonClass*> genArgs, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| |
| VMCommonClass* loadTypeFromName(const UTF8* name, const UTF8* nameSpace, |
| bool resolveFunc, bool resolve, |
| bool clinit, bool dothrow); |
| void readClass(VMCommonClass* cl, VMGenericMethod* genMethod); |
| void getProperties(VMCommonClass* cl, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| Property* readProperty(uint32 index, VMCommonClass* cl, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMMethod* readMethodDef(uint32 index, VMCommonClass* cl, |
| std::vector<VMCommonClass*>* genMethodInstantiation, VMGenericClass* genClass); |
| VMMethod* readMethodSpec(uint32 token, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMField* readField(uint32 index, VMCommonClass* cl, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| Param* readParam(uint32 index, VMMethod* meth); |
| VMClass* readTypeDef(N3* vm, uint32 index); |
| VMClass* readTypeDef(N3* vm, uint32 index, std::vector<VMCommonClass*> genArgs); |
| VMCommonClass* readTypeSpec(N3* vm, uint32 index, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| Assembly* readAssemblyRef(N3* vm, uint32 index); |
| VMCommonClass* readTypeRef(N3* vm, uint32 index); |
| void readSignature(uint32 offset, std::vector<VMCommonClass*>& locals, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| |
| void getInterfacesFromTokenType(std::vector<uint32>& tokens, uint32 token); |
| |
| bool extractMethodSignature(uint32& offset, VMCommonClass* cl, |
| std::vector<VMCommonClass*> ¶ms, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| bool isGenericMethod(uint32& offset); |
| void localVarSignature(uint32& offset, |
| std::vector<VMCommonClass*>& locals, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| void methodSpecSignature(uint32& offset, |
| std::vector<VMCommonClass*>& genArgs, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMCommonClass* extractFieldSignature(uint32& offset, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMCommonClass* extractTypeInSignature(uint32& offset, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| VMCommonClass* exploreType(uint32& offset, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| |
| VMCommonClass* getClassFromName(N3* vm, const UTF8* name, const UTF8* nameSpace); |
| |
| VMField* getFieldFromToken(uint32 token, bool stat, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| uint32 getTypedefTokenFromField(uint32 token); |
| VMField* readMemberRefAsField(uint32 token, bool stat, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| |
| VMMethod* getMethodFromToken(uint32 token, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| uint32 getTypedefTokenFromMethod(uint32 token); |
| VMMethod* readMemberRefAsMethod(uint32 token, std::vector<VMCommonClass*>* genArgs, VMGenericClass* genClass, VMGenericMethod* genMethod); |
| |
| const ArrayChar* readUserString(uint32 token); |
| uint32 getExplicitLayout(uint32 token); |
| uint32 getRVAFromField(uint32 token); |
| |
| static Assembly* getCallingAssembly(); |
| static Assembly* getExecutingAssembly(); |
| |
| void readCustomAttributes(uint32 offset, std::vector<llvm::GenericValue>& args, VMMethod* meth); |
| ArrayObject* getCustomAttributes(uint32 token, VMCommonClass* cl); |
| private: |
| VMMethod *instantiateGenericMethod(std::vector<VMCommonClass*> *genArgs, VMCommonClass *type, const UTF8 *& name, std::vector<VMCommonClass*> & args, uint32 token, bool virt, VMGenericClass* genClass); |
| |
| }; |
| |
| |
| #define CONSTANT_Assembly 0x20 |
| #define CONSTANT_AssemblyOS 0x22 |
| #define CONSTANT_AssemblyProcessor 0x21 |
| #define CONSTANT_AssemblyRef 0x23 |
| #define CONSTANT_AssemblyRefOS 0x25 |
| #define CONSTANT_AssemblyRefProcessor 0x24 |
| #define CONSTANT_ClassLayout 0x0F |
| #define CONSTANT_Constant 0x0B |
| #define CONSTANT_CustomAttribute 0x0C |
| #define CONSTANT_DeclSecurity 0x0E |
| #define CONSTANT_EventMap 0x12 |
| #define CONSTANT_Event 0x14 |
| #define CONSTANT_ExportedType 0x27 |
| #define CONSTANT_Field 0x04 |
| #define CONSTANT_FieldLayout 0x10 |
| #define CONSTANT_FieldMarshal 0x0D |
| #define CONSTANT_FieldRVA 0x1D |
| #define CONSTANT_File 0x26 |
| #define CONSTANT_GenericParam 0x2A |
| #define CONSTANT_GenericParamConstraint 0x2C |
| #define CONSTANT_ImplMap 0x1C |
| #define CONSTANT_InterfaceImpl 0x09 |
| #define CONSTANT_ManifestResource 0x28 |
| #define CONSTANT_MemberRef 0x0A |
| #define CONSTANT_MethodDef 0x06 |
| #define CONSTANT_MethodImpl 0x19 |
| #define CONSTANT_MethodSemantics 0x18 |
| #define CONSTANT_MethodSpec 0x2B |
| #define CONSTANT_Module 0x00 |
| #define CONSTANT_ModuleRef 0x1A |
| #define CONSTANT_NestedClass 0x29 |
| #define CONSTANT_Param 0x08 |
| #define CONSTANT_Property 0x17 |
| #define CONSTANT_PropertyMap 0x15 |
| #define CONSTANT_StandaloneSig 0x11 |
| #define CONSTANT_TypeDef 0x02 |
| #define CONSTANT_TypeRef 0x01 |
| #define CONSTANT_TypeSpec 0x1B |
| |
| |
| #define CONSTANT_HasThis 0x20 |
| #define CONSTANT_ExplicitThis 0x40 |
| #define CONSTANT_Default 0x0 |
| #define CONSTANT_Vararg 0x5 |
| #define CONSTANT_C 0x1 |
| #define CONSTANT_StdCall 0x2 |
| #define CONSTANT_ThisCall 0x3 |
| #define CONSTANT_FastCall 0x4 |
| #define CONSTANT_Generic 0x10 |
| #define CONSTANT_Sentinel 0x41 |
| |
| |
| #define CONSTANT_CorILMethod_TinyFormat 0x2 |
| #define CONSTANT_CorILMethod_FatFormat 0x3 |
| #define CONSTANT_CorILMethod_MoreSects 0x8 |
| #define CONSTANT_CorILMethod_InitLocals 0x10 |
| #define CONSTANT_CorILMethod_Sect_FatFormat 0x40 |
| #define CONSTANT_COR_ILEXCEPTION_CLAUSE_EXCEPTION 0x0000 |
| #define CONSTANT_COR_ILEXCEPTION_CLAUSE_FILTER 0x0001 |
| #define CONSTANT_COR_ILEXCEPTION_CLAUSE_FINALLY 0x0002 |
| #define CONSTANT_COR_ILEXCEPTION_CLAUSE_FAULT 0x0004 |
| |
| |
| #define CLI_HEADER 0x168 |
| #define TEXT_SECTION_HEADER 0x178 |
| #define RSRC_SECTION_HEADER 0x178 |
| #define RELOC_SECTION_HEADER 0x178 |
| #define SECTION_NAME_LENGTH 8 |
| #define TABLE_MAX 64 |
| #define NB_TABLES 41 |
| |
| #define INT16(offset) \ |
| rowSize += 2; \ |
| bitmask = bitmask | (1 << (offset << 1)); |
| |
| #define INT32(offset) \ |
| rowSize += 4; \ |
| bitmask = bitmask | (3 << (offset << 1)); |
| |
| |
| #define STRING(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (heapSizes & 0x01) { \ |
| fieldSize = 4; \ |
| } else { \ |
| fieldSize = 2; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define GUID(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (heapSizes & 0x02) { \ |
| fieldSize = 4; \ |
| } else { \ |
| fieldSize = 2; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define BLOB(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (heapSizes & 0x04) { \ |
| fieldSize = 4; \ |
| } else { \ |
| fieldSize = 2; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define TABLE(table, offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[table]->rowsNumber < 0x10000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| |
| #define TYPEDEF_OR_REF(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_TypeDef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_TypeRef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_TypeSpec]->rowsNumber < 0x4000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| |
| #define HAS_CONSTANT(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_Field]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_Param]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_Property]->rowsNumber < 0x4000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define HAS_CUSTOM_ATTRIBUTE(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_MethodDef]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_Field]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_TypeRef]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_TypeDef]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_Param]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_InterfaceImpl]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_MemberRef]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_Module]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_DeclSecurity]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_Property]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_Event]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_StandaloneSig]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_ModuleRef]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_TypeSpec]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_Assembly]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_AssemblyRef]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_File]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_ExportedType]->rowsNumber < 0x800 && \ |
| tables[CONSTANT_ManifestResource]->rowsNumber < 0x800) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define HAS_FIELD_MARSHAL(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_Field]->rowsNumber < 0x8000 && \ |
| tables[CONSTANT_Param]->rowsNumber < 0x8000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define HAS_DECL_SECURITY(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_TypeDef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_MethodDef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_Assembly]->rowsNumber < 0x4000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define MEMBER_REF_PARENT(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_TypeDef]->rowsNumber < 0x2000 && \ |
| tables[CONSTANT_TypeRef]->rowsNumber < 0x2000 && \ |
| tables[CONSTANT_ModuleRef]->rowsNumber < 0x2000 && \ |
| tables[CONSTANT_MethodDef]->rowsNumber < 0x2000 && \ |
| tables[CONSTANT_TypeSpec]->rowsNumber < 0x2000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define HAS_SEMANTICS(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_Event]->rowsNumber < 0x8000 && \ |
| tables[CONSTANT_Property]->rowsNumber < 0x8000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define METHODDEF_OR_REF(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_MethodDef]->rowsNumber < 0x8000 && \ |
| tables[CONSTANT_MemberRef]->rowsNumber < 0x8000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define MEMBER_FORWARDED(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_Field]->rowsNumber < 0x8000 && \ |
| tables[CONSTANT_MethodDef]->rowsNumber < 0x8000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define IMPLEMENTATION(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_File]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_AssemblyRef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_ExportedType]->rowsNumber < 0x4000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| // Some encodings are not used here |
| #define CUSTOM_ATTRIBUTE_TYPE(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_MethodDef]->rowsNumber < 0x2000 && \ |
| tables[CONSTANT_MemberRef]->rowsNumber < 0x2000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define RESOLUTION_SCOPE(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_Module]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_ModuleRef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_AssemblyRef]->rowsNumber < 0x4000 && \ |
| tables[CONSTANT_TypeRef]->rowsNumber < 0x4000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| #define TYPE_OR_METHODDEF(offset) { \ |
| uint32 fieldSize = 0; \ |
| if (tables[CONSTANT_TypeDef]->rowsNumber < 0x8000 && \ |
| tables[CONSTANT_MethodDef]->rowsNumber < 0x8000) { \ |
| fieldSize = 2; \ |
| } else { \ |
| fieldSize = 4; \ |
| } \ |
| rowSize += fieldSize; \ |
| bitmask = bitmask | ((fieldSize - 1) << (offset << 1)); \ |
| } |
| |
| |
| #define CONSTANT_MODULE_GENERATION 0 |
| #define CONSTANT_MODULE_NAME 1 |
| #define CONSTANT_MODULE_MVID 2 |
| #define CONSTANT_MODULE_ENCID 3 |
| #define CONSTANT_MODULE_ENCBASEID 4 |
| |
| |
| #define CONSTANT_TYPEREF_RESOLUTION_SCOPE 0 |
| #define CONSTANT_TYPEREF_NAME 1 |
| #define CONSTANT_TYPEREF_NAMESPACE 2 |
| |
| #define CONSTANT_TYPEDEF_FLAGS 0 |
| #define CONSTANT_TYPEDEF_NAME 1 |
| #define CONSTANT_TYPEDEF_NAMESPACE 2 |
| #define CONSTANT_TYPEDEF_EXTENDS 3 |
| #define CONSTANT_TYPEDEF_FIELDLIST 4 |
| #define CONSTANT_TYPEDEF_METHODLIST 5 |
| |
| #define CONSTANT_METHODDEF_RVA 0 |
| #define CONSTANT_METHODDEF_IMPLFLAGS 1 |
| #define CONSTANT_METHODDEF_FLAGS 2 |
| #define CONSTANT_METHODDEF_NAME 3 |
| #define CONSTANT_METHODDEF_SIGNATURE 4 |
| #define CONSTANT_METHODDEF_PARAMLIST 5 |
| |
| #define CONSTANT_PARAM_FLAGS 0 |
| #define CONSTANT_PARAM_SEQUENCE 1 |
| #define CONSTANT_PARAM_NAME 2 |
| |
| #define CONSTANT_MEMBERREF_CLASS 0 |
| #define CONSTANT_MEMBERREF_NAME 1 |
| #define CONSTANT_MEMBERREF_SIGNATURE 2 |
| |
| #define CONSTANT_CUSTOM_ATTRIBUTE_PARENT 0 |
| #define CONSTANT_CUSTOM_ATTRIBUTE_TYPE 1 |
| #define CONSTANT_CUSTOM_ATTRIBUTE_VALUE 2 |
| |
| #define CONSTANT_STANDALONE_SIG_SIGNATURE 0 |
| |
| #define CONSTANT_TYPESPEC_SIGNATURE 0 |
| |
| #define CONSTANT_ASSEMBLY_HASH_ALG_ID 0 |
| #define CONSTANT_ASSEMBLY_MAJOR 1 |
| #define CONSTANT_ASSEMBLY_MINOR 2 |
| #define CONSTANT_ASSEMBLY_BUILD 3 |
| #define CONSTANT_ASSEMBLY_REVISION 4 |
| #define CONSTANT_ASSEMBLY_FLAGS 5 |
| #define CONSTANT_ASSEMBLY_PUBLIC_KEY 6 |
| #define CONSTANT_ASSEMBLY_NAME 7 |
| #define CONSTANT_ASSEMBLY_CULTURE 8 |
| |
| #define CONSTANT_ASSEMBLY_REF_MAJOR 0 |
| #define CONSTANT_ASSEMBLY_REF_MINOR 1 |
| #define CONSTANT_ASSEMBLY_REF_BUILD 2 |
| #define CONSTANT_ASSEMBLY_REF_REVISION 3 |
| #define CONSTANT_ASSEMBLY_REF_FLAGS 4 |
| #define CONSTANT_ASSEMBLY_REF_PUBLIC_KEY 5 |
| #define CONSTANT_ASSEMBLY_REF_NAME 6 |
| #define CONSTANT_ASSEMBLY_REF_CULTURE 7 |
| #define CONSTANT_ASSEMBLY_REF_HASH_VALUE 8 |
| |
| #define CONSTANT_FIELD_FLAGS 0 |
| #define CONSTANT_FIELD_NAME 1 |
| #define CONSTANT_FIELD_SIGNATURE 2 |
| |
| #define CONSTANT_INTERFACE_IMPL_CLASS 0 |
| #define CONSTANT_INTERFACE_IMPL_INTERFACE 1 |
| |
| #define CONSTANT_NESTED_CLASS_NESTED_CLASS 0 |
| #define CONSTANT_NESTED_CLASS_ENCLOSING_CLASS 1 |
| |
| #define CONSTANT_METHOD_SPEC_METHOD 0 |
| #define CONSTANT_METHOD_SPEC_INSTANTIATION 1 |
| |
| #define CONSTANT_GENERIC_PARAM_CONSTRAINT_OWNER 0 |
| #define CONSTANT_GENERIC_PARAM_CONSTRAINT_CONSTRAINT 1 |
| |
| #define CONSTANT_CONSTANT_TYPE 0 |
| #define CONSTANT_CONSTANT_PARENT 1 |
| #define CONSTANT_CONSTANT_VALUE 2 |
| |
| #define CONSTANT_FIELD_MARSHAL_PARENT 0 |
| #define CONSTANT_FIELD_MARSHAL_NATIVE_TYPE 1 |
| |
| #define CONSTANT_DECL_SECURITY_ACTION 0 |
| #define CONSTANT_DECL_SECURITY_PARENT 1 |
| #define CONSTANT_DECL_SECURITY_PERMISSION_SET 2 |
| |
| #define CONSTANT_CLASS_LAYOUT_PACKING_SIZE 0 |
| #define CONSTANT_CLASS_LAYOUT_CLASS_SIZE 1 |
| #define CONSTANT_CLASS_LAYOUT_PARENT 2 |
| |
| #define CONSTANT_FIELD_LAYOUT_OFFSET 0 |
| #define CONSTANT_FIELD_LAYOUT_FIELD 1 |
| |
| #define CONSTANT_EVENT_MAP_PARENT 0 |
| #define CONSTANT_EVEN_MAP_EVENT_LIST 1 |
| |
| #define CONSTANT_EVENT_EVENT_FLAGS 0 |
| #define CONSTANT_EVENT_NAME 1 |
| #define CONSTANT_EVENT_TYPE 2 |
| |
| #define CONSTANT_PROPERTY_MAP_PARENT 0 |
| #define CONSTANT_PROPERTY_MAP_PROPERTY_LIST 1 |
| |
| #define CONSTANT_PROPERTY_FLAGS 0 |
| #define CONSTANT_PROPERTY_NAME 1 |
| #define CONSTANT_PROPERTY_TYPE 2 |
| |
| #define CONSTANT_METHOD_SEMANTICS_SEMANTICS 0 |
| #define CONSTANT_METHOD_SEMANTICS_METHOD 1 |
| #define CONSTANT_METHOD_SEMANTICS_ASSOCIATION 2 |
| |
| #define CONSTANT_METHOD_IMPL_CLASS 0 |
| #define CONSTANT_METHOD_IMPL_METHOD_BODY 1 |
| #define CONSTANT_METHOD_IMPL_METHOD_DECLARATION 2 |
| |
| #define CONSTANT_MODULE_REF_NAME 0 |
| |
| #define CONSTANT_IMPL_MAP_MAPPING_FLAGS 0 |
| #define CONSTANT_IMPL_MAP_MEMBER_FORWARDED 1 |
| #define CONSTANT_IMPL_MAP_IMPORT_NAME 2 |
| #define CONSTANT_IMPL_MAP_IMPORT_SCOPE 3 |
| |
| #define CONSTANT_FIELD_RVA_RVA 0 |
| #define CONSTANT_FIELD_RVA_FIELD 1 |
| |
| #define CONSTANT_MANIFEST_RESOURCE_OFFSET 0 |
| #define CONSTANT_MANIFEST_RESOURCE_FLAGS 1 |
| #define CONSTANT_MANIFEST_RESOURCE_NAME 2 |
| #define CONSTANT_MANIFEST_RESOURCE_IMPLEMENTATION 3 |
| |
| #define CONSTANT_ASSEMBLY_PROCESSOR_PROCESSOR 0 |
| |
| #define CONSTANT_ASSEMBLY_OS_PLATFORM_ID 0 |
| #define CONSTANT_ASSEMBLY_OS_MAJOR_VERSION 1 |
| #define CONSTANT_ASSEMBLY_OS_MINOR_VERSION 2 |
| |
| #define CONSTANT_FILE_FLAGS 0 |
| #define CONSTANT_FILE_NAME 1 |
| #define CONSTANT_FILE_HASH_VALUE 2 |
| |
| #define CONSTANT_GENERIC_PARAM_NUMBER 0 |
| #define CONSTANT_GENERIC_PARAM_FLAGS 1 |
| #define CONSTANT_GENERIC_PARAM_OWNER 2 |
| #define CONSTANT_GENERIC_PARAM_NAME 3 |
| |
| } // end namespace n3 |
| |
| #endif |
| |
