diff options
Diffstat (limited to 'core/il.cc')
| -rw-r--r-- | core/il.cc | 7841 |
1 files changed, 7841 insertions, 0 deletions
diff --git a/core/il.cc b/core/il.cc new file mode 100644 index 0000000..ee8f896 --- /dev/null +++ b/core/il.cc @@ -0,0 +1,7841 @@ +#include "../runtime/common.h" +#include "../runtime/crypto.h" +#include "objects.h" +#include "osutils.h" +#include "streams.h" +#include "files.h" +#include "processors.h" +#include "lang.h" +#include "core.h" +#include "pefile.h" +#include "packer.h" +#include "dotnet.h" +#include "dotnetfile.h" +#include "il.h" + +/** + * ILCommand + */ + +ILCommand::ILCommand(IFunction *owner, OperandSize size, uint64_t address) + : BaseCommand(owner), address_(address), size_(size), type_(icUnknown), operand_value_(0), original_dump_size_(0), + section_options_(0), operand_pos_(0), token_reference_(NULL), ext_vm_entry_(NULL), param_(0), fixup_(NULL) +{ + if (address_) + include_option(roClearOriginalCode); +} + +ILCommand::ILCommand(IFunction *owner, OperandSize size, ILCommandType type, uint64_t operand_value, IFixup *fixup) + : BaseCommand(owner), address_(0), size_(size), type_(type), operand_value_(operand_value), original_dump_size_(0), + section_options_(0), operand_pos_(0), token_reference_(NULL), ext_vm_entry_(NULL), param_(0), fixup_(fixup) +{ + +} + +ILCommand::ILCommand(IFunction *owner, OperandSize size, const std::string &value) + : BaseCommand(owner, value), address_(0), size_(size), type_(icUnknown), operand_value_(0), original_dump_size_(0), + section_options_(0), operand_pos_(0), token_reference_(NULL), ext_vm_entry_(NULL), param_(0), fixup_(NULL) +{ + type_ = icData; +} + +ILCommand::ILCommand(IFunction *owner, OperandSize size, const Data &value) + : BaseCommand(owner, value), address_(0), size_(size), type_(icUnknown), operand_value_(0), original_dump_size_(0), + section_options_(0), operand_pos_(0), token_reference_(NULL), ext_vm_entry_(NULL), param_(0), fixup_(NULL) +{ + type_ = icData; +} + +ILCommand::ILCommand(IFunction *owner, const ILCommand &src) + : BaseCommand(owner, src), section_options_(0), ext_vm_entry_(NULL), fixup_(NULL) +{ + address_ = src.address_; + size_ = src.size_; + type_ = src.type_; + operand_value_ = src.operand_value_; + original_dump_size_ = src.original_dump_size_; + operand_pos_ = src.operand_pos_; + token_reference_ = src.token_reference_; + param_ = src.param_; +} + +void ILCommand::Init(ILCommandType type, uint64_t operand_value, TokenReference *token_reference) +{ + type_ = type; + operand_value_ = operand_value; + token_reference_ = token_reference; +} + +void ILCommand::clear() +{ + type_ = icUnknown; + operand_value_ = 0; + original_dump_size_ = 0; + operand_pos_ = 0; + token_reference_ = NULL; + BaseCommand::clear(); +} + +void ILCommand::InitUnknown() +{ + clear(); + type_ = icUnknown; + PushByte(0); +} + +void ILCommand::InitComment(const std::string &comment) +{ + type_ = icComment; + set_comment(CommentInfo(ttNone, comment)); +} + +ISEHandler * ILCommand::seh_handler() const +{ + throw std::runtime_error("The method or operation is not implemented."); +} + +void ILCommand::set_seh_handler(ISEHandler *handler) +{ + throw std::runtime_error("The method or operation is not implemented."); +} + +std::string ILCommand::text() const +{ + std::string res; + + const ILOpCode opcode = ILOpCodes[type_]; + + res = (type_ == icComment) ? comment_text() : opcode.name; + if (type_ == icData) { + for (size_t i = 0; i < dump_size(); i++) { + if (i > 0) + res.append(","); + res.append(string_format(" %.2X", dump(i))); + } + } else { + switch (opcode.operand_type) { + case InlineNone: + case InlinePhi: + case Inline8: + // do nothing + break; + case ShortInlineI: + case ShortInlineVar: + res.append(string_format(" %.2X", static_cast<uint8_t>(operand_value_))); + break; + case InlineVar: + res.append(string_format(" %.4X", static_cast<uint16_t>(operand_value_))); + break; + case InlineI8: + case InlineR: + res.append(string_format(" %.16llX", operand_value_)); + break; + case InlineSwitch: + break; + case ShortInlineBrTarget: + case InlineBrTarget: + res.append(string_format(" %.8X", static_cast<uint32_t>(operand_value_))); + break; + default: + res.append(string_format(" %.8X", static_cast<uint32_t>(operand_value_))); + break; + } + } + + return res; +} + +CommentInfo ILCommand::comment() +{ + CommentInfo res = BaseCommand::comment(); + if (res.type != ttUnknown) + return res; + + res.type = ttNone; + NETArchitecture *file = owner()->owner() ? dynamic_cast<NETArchitecture *>(owner()->owner()->owner()) : NULL; + if (file) { + switch (ILOpCodes[type_].operand_type) { + case InlineBrTarget: + case ShortInlineBrTarget: + res.value = (next_address() > operand_value_) ? char(2) : char(4); + res.type = ttJmp; + break; + + case InlineType: + case InlineField: + case InlineTok: + case InlineSig: + case InlineString: + case InlineMethod: + if (ILToken *token = token_reference_ ? token_reference_->owner()->owner() : NULL) { + switch (token->type()) { + case ttTypeRef: + { + ILTypeRef *type = reinterpret_cast<ILTypeRef *>(token); + std::string name = type->full_name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = ttImport; + } + break; + case ttTypeDef: + { + ILTypeDef *type = reinterpret_cast<ILTypeDef *>(token); + std::string name = type->full_name(); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = ttFunction; + } + break; + case ttTypeSpec: + { + ILTypeSpec *type = reinterpret_cast<ILTypeSpec *>(token); + std::string name = type->name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = ttFunction; + } + break; + case ttField: + { + ILField *field = reinterpret_cast<ILField *>(token); + std::string name = field->full_name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = ttFunction; + } + break; + case ttMemberRef: + { + ILMemberRef *member = reinterpret_cast<ILMemberRef *>(token); + std::string name = member->full_name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = (member->declaring_type() && member->declaring_type()->type() == ttTypeRef) ? ttImport : ttFunction; + } + break; + case ttStandAloneSig: + { + ILStandAloneSig *signature = reinterpret_cast<ILStandAloneSig*>(token); + std::string name = signature->name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = ttFunction; + } + break; + case ttUserString: + { + ILUserString *str = reinterpret_cast<ILUserString*>(token); + res.value = string_format("%c \"%s\"", 3, str->name().c_str()); + res.type = ttString; + } + break; + case ttMethodDef: + { + ILMethodDef *method = reinterpret_cast<ILMethodDef*>(token); + std::string name = method->full_name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = ttFunction; + } + break; + case ttMethodSpec: + { + ILMethodSpec *method_spec = reinterpret_cast<ILMethodSpec*>(token); + std::string name = method_spec->full_name(true); + res.value = string_format("%c %s", 3, name.c_str()); + res.type = (method_spec->parent() && method_spec->parent()->type() == ttMethodDef) ? ttFunction : ttImport; + } + break; + } + if (res.type == ttFunction && ILOpCodes[type_].operand_type == InlineField) + res.type = ttVariable; + } + break; + } + + set_comment(res); + } + return res; +} + +void ILCommand::CompileToNative() +{ + if (type_ == icComment || type_ == icData) + return; + + BaseCommand::clear(); + + switch (type_) { + case icByte: break; + case icWord: break; + case icDword: break; + case icQword: break; + case icCase: break; + case icNop: PushByte(0x00); break; + case icBreak: PushByte(0x01); break; + case icLdarg_0: PushByte(0x02); break; + case icLdarg_1: PushByte(0x03); break; + case icLdarg_2: PushByte(0x04); break; + case icLdarg_3: PushByte(0x05); break; + case icLdloc_0: PushByte(0x06); break; + case icLdloc_1: PushByte(0x07); break; + case icLdloc_2: PushByte(0x08); break; + case icLdloc_3: PushByte(0x09); break; + case icStloc_0: PushByte(0x0a); break; + case icStloc_1: PushByte(0x0b); break; + case icStloc_2: PushByte(0x0c); break; + case icStloc_3: PushByte(0x0d); break; + case icLdarg_s: PushByte(0x0e); break; + case icLdarga_s: PushByte(0x0f); break; + case icStarg_s: PushByte(0x10); break; + case icLdloc_s: PushByte(0x11); break; + case icLdloca_s: PushByte(0x12); break; + case icStloc_s: PushByte(0x13); break; + case icLdnull: PushByte(0x14); break; + case icLdc_i4_m1: PushByte(0x15); break; + case icLdc_i4_0: PushByte(0x16); break; + case icLdc_i4_1: PushByte(0x17); break; + case icLdc_i4_2: PushByte(0x18); break; + case icLdc_i4_3: PushByte(0x19); break; + case icLdc_i4_4: PushByte(0x1a); break; + case icLdc_i4_5: PushByte(0x1b); break; + case icLdc_i4_6: PushByte(0x1c); break; + case icLdc_i4_7: PushByte(0x1d); break; + case icLdc_i4_8: PushByte(0x1e); break; + case icLdc_i4_s: PushByte(0x1f); break; + case icLdc_i4: PushByte(0x20); break; + case icLdc_i8: PushByte(0x21); break; + case icLdc_r4: PushByte(0x22); break; + case icLdc_r8: PushByte(0x23); break; + case icDup: PushByte(0x25); break; + case icPop: PushByte(0x26); break; + case icJmp: PushByte(0x27); break; + case icCall: PushByte(0x28); break; + case icCalli: PushByte(0x29); break; + case icRet: PushByte(0x2a); break; + case icBr_s: PushByte(0x2b); break; + case icBrfalse_s: PushByte(0x2c); break; + case icBrtrue_s: PushByte(0x2d); break; + case icBeq_s: PushByte(0x2e); break; + case icBge_s: PushByte(0x2f); break; + case icBgt_s: PushByte(0x30); break; + case icBle_s: PushByte(0x31); break; + case icBlt_s: PushByte(0x32); break; + case icBne_un_s: PushByte(0x33); break; + case icBge_un_s: PushByte(0x34); break; + case icBgt_un_s: PushByte(0x35); break; + case icBle_un_s: PushByte(0x36); break; + case icBlt_un_s: PushByte(0x37); break; + case icBr: PushByte(0x38); break; + case icBrfalse: PushByte(0x39); break; + case icBrtrue: PushByte(0x3a); break; + case icBeq: PushByte(0x3b); break; + case icBge: PushByte(0x3c); break; + case icBgt: PushByte(0x3d); break; + case icBle: PushByte(0x3e); break; + case icBlt: PushByte(0x3f); break; + case icBne_un: PushByte(0x40); break; + case icBge_un: PushByte(0x41); break; + case icBgt_un: PushByte(0x42); break; + case icBle_un: PushByte(0x43); break; + case icBlt_un: PushByte(0x44); break; + case icSwitch: PushByte(0x45); break; + case icLdind_i1: PushByte(0x46); break; + case icLdind_u1: PushByte(0x47); break; + case icLdind_i2: PushByte(0x48); break; + case icLdind_u2: PushByte(0x49); break; + case icLdind_i4: PushByte(0x4a); break; + case icLdind_u4: PushByte(0x4b); break; + case icLdind_i8: PushByte(0x4c); break; + case icLdind_i: PushByte(0x4d); break; + case icLdind_r4: PushByte(0x4e); break; + case icLdind_r8: PushByte(0x4f); break; + case icLdind_ref: PushByte(0x50); break; + case icStind_ref: PushByte(0x51); break; + case icStind_i1: PushByte(0x52); break; + case icStind_i2: PushByte(0x53); break; + case icStind_i4: PushByte(0x54); break; + case icStind_i8: PushByte(0x55); break; + case icStind_r4: PushByte(0x56); break; + case icStind_r8: PushByte(0x57); break; + case icAdd: PushByte(0x58); break; + case icSub: PushByte(0x59); break; + case icMul: PushByte(0x5a); break; + case icDiv: PushByte(0x5b); break; + case icDiv_un: PushByte(0x5c); break; + case icRem: PushByte(0x5d); break; + case icRem_un: PushByte(0x5e); break; + case icAnd: PushByte(0x5f); break; + case icOr: PushByte(0x60); break; + case icXor: PushByte(0x61); break; + case icShl: PushByte(0x62); break; + case icShr: PushByte(0x63); break; + case icShr_un: PushByte(0x64); break; + case icNeg: PushByte(0x65); break; + case icNot: PushByte(0x66); break; + case icConv_i1: PushByte(0x67); break; + case icConv_i2: PushByte(0x68); break; + case icConv_i4: PushByte(0x69); break; + case icConv_i8: PushByte(0x6a); break; + case icConv_r4: PushByte(0x6b); break; + case icConv_r8: PushByte(0x6c); break; + case icConv_u4: PushByte(0x6d); break; + case icConv_u8: PushByte(0x6e); break; + case icCallvirt: PushByte(0x6f); break; + case icCpobj: PushByte(0x70); break; + case icLdobj: PushByte(0x71); break; + case icLdstr: PushByte(0x72); break; + case icNewobj: PushByte(0x73); break; + case icCastclass: PushByte(0x74); break; + case icIsinst: PushByte(0x75); break; + case icConv_r_un: PushByte(0x76); break; + case icUnbox: PushByte(0x79); break; + case icThrow: PushByte(0x7a); break; + case icLdfld: PushByte(0x7b); break; + case icLdflda: PushByte(0x7c); break; + case icStfld: PushByte(0x7d); break; + case icLdsfld: PushByte(0x7e); break; + case icLdsflda: PushByte(0x7f); break; + case icStsfld: PushByte(0x80); break; + case icStobj: PushByte(0x81); break; + case icConv_ovf_i1_un: PushByte(0x82); break; + case icConv_ovf_i2_un: PushByte(0x83); break; + case icConv_ovf_i4_un: PushByte(0x84); break; + case icConv_ovf_i8_un: PushByte(0x85); break; + case icConv_ovf_u1_un: PushByte(0x86); break; + case icConv_ovf_u2_un: PushByte(0x87); break; + case icConv_ovf_u4_un: PushByte(0x88); break; + case icConv_ovf_u8_un: PushByte(0x89); break; + case icConv_ovf_i_un: PushByte(0x8a); break; + case icConv_ovf_u_un: PushByte(0x8b); break; + case icBox: PushByte(0x8c); break; + case icNewarr: PushByte(0x8d); break; + case icLdlen: PushByte(0x8e); break; + case icLdelema: PushByte(0x8f); break; + case icLdelem_i1: PushByte(0x90); break; + case icLdelem_u1: PushByte(0x91); break; + case icLdelem_i2: PushByte(0x92); break; + case icLdelem_u2: PushByte(0x93); break; + case icLdelem_i4: PushByte(0x94); break; + case icLdelem_u4: PushByte(0x95); break; + case icLdelem_i8: PushByte(0x96); break; + case icLdelem_i: PushByte(0x97); break; + case icLdelem_r4: PushByte(0x98); break; + case icLdelem_r8: PushByte(0x99); break; + case icLdelem_ref: PushByte(0x9a); break; + case icStelem_i: PushByte(0x9b); break; + case icStelem_i1: PushByte(0x9c); break; + case icStelem_i2: PushByte(0x9d); break; + case icStelem_i4: PushByte(0x9e); break; + case icStelem_i8: PushByte(0x9f); break; + case icStelem_r4: PushByte(0xa0); break; + case icStelem_r8: PushByte(0xa1); break; + case icStelem_ref: PushByte(0xa2); break; + case icLdelem: PushByte(0xa3); break; + case icStelem: PushByte(0xa4); break; + case icUnbox_any: PushByte(0xa5); break; + case icConv_ovf_i1: PushByte(0xb3); break; + case icConv_ovf_u1: PushByte(0xb4); break; + case icConv_ovf_i2: PushByte(0xb5); break; + case icConv_ovf_u2: PushByte(0xb6); break; + case icConv_ovf_i4: PushByte(0xb7); break; + case icConv_ovf_u4: PushByte(0xb8); break; + case icConv_ovf_i8: PushByte(0xb9); break; + case icConv_ovf_u8: PushByte(0xba); break; + case icLdtoken: PushByte(0xd0); break; + case icConv_u2: PushByte(0xd1); break; + case icConv_u1: PushByte(0xd2); break; + case icConv_i: PushByte(0xd3); break; + case icConv_ovf_i: PushByte(0xd4); break; + case icConv_ovf_u: PushByte(0xd5); break; + case icAdd_ovf: PushByte(0xd6); break; + case icAdd_ovf_un: PushByte(0xd7); break; + case icMul_ovf: PushByte(0xd8); break; + case icMul_ovf_un: PushByte(0xd9); break; + case icSub_ovf: PushByte(0xda); break; + case icSub_ovf_un: PushByte(0xdb); break; + case icEndfinally: PushByte(0xdc); break; + case icLeave: PushByte(0xdd); break; + case icLeave_s: PushByte(0xde); break; + case icStind_i: PushByte(0xdf); break; + case icConv_u: PushByte(0xe0); break; + case icArglist: PushByte(0xfe); PushByte(0x00); break; + case icCeq: PushByte(0xfe); PushByte(0x01); break; + case icCgt: PushByte(0xfe); PushByte(0x02); break; + case icCgt_un: PushByte(0xfe); PushByte(0x03); break; + case icClt: PushByte(0xfe); PushByte(0x04); break; + case icClt_un: PushByte(0xfe); PushByte(0x05); break; + case icLdftn: PushByte(0xfe); PushByte(0x06); break; + case icLdvirtftn: PushByte(0xfe); PushByte(0x07); break; + case icLdarg: PushByte(0xfe); PushByte(0x09); break; + case icLdarga: PushByte(0xfe); PushByte(0x0a); break; + case icStarg: PushByte(0xfe); PushByte(0x0b); break; + case icLdloc: PushByte(0xfe); PushByte(0x0c); break; + case icLdloca: PushByte(0xfe); PushByte(0x0d); break; + case icStloc: PushByte(0xfe); PushByte(0x0e); break; + case icLocalloc: PushByte(0xfe); PushByte(0x0f); break; + case icEndfilter: PushByte(0xfe); PushByte(0x11); break; + case icUnaligned: PushByte(0xfe); PushByte(0x12); break; + case icVolatile: PushByte(0xfe); PushByte(0x13); break; + case icTail: PushByte(0xfe); PushByte(0x14); break; + case icInitobj: PushByte(0xfe); PushByte(0x15); break; + case icConstrained: PushByte(0xfe); PushByte(0x16); break; + case icCpblk: PushByte(0xfe); PushByte(0x17); break; + case icInitblk: PushByte(0xfe); PushByte(0x18); break; + case icNo: PushByte(0xfe); PushByte(0x19); break; + case icRethrow: PushByte(0xfe); PushByte(0x1a); break; + case icSizeof: PushByte(0xfe); PushByte(0x1c); break; + case icRefanytype: PushByte(0xfe); PushByte(0x1d); break; + case icReadonly: PushByte(0xfe); PushByte(0x1e); break; + default: + throw std::runtime_error("Runtime error at CompileToNative: " + text()); + } + + operand_pos_ = dump_size(); + + switch (ILOpCodes[type_].operand_type) { + case InlineNone: + case InlinePhi: + case Inline8: + // do nothing + break; + case ShortInlineI: + case ShortInlineVar: + PushByte(static_cast<uint8_t>(operand_value_)); + break; + case InlineVar: + PushWord(static_cast<uint16_t>(operand_value_)); + break; + case InlineI8: + case InlineR: + PushQWord(operand_value_); + break; + case InlineSwitch: + PushDWord(static_cast<uint32_t>(operand_value_)); + break; + case ShortInlineBrTarget: + PushByte(static_cast<uint8_t>(operand_value_ - next_address() - 1)); + break; + case InlineBrTarget: + PushDWord(static_cast<uint32_t>(operand_value_ - next_address() - 4)); + break; + default: + PushDWord(static_cast<uint32_t>(operand_value_)); + break; + } + + if (options() & roFillNop) { + for (size_t j = dump_size(); j < original_dump_size_; j++) { + PushByte(0x00); + } + } +} + +void ILCommand::CompileLink(const CompileContext &ctx) +{ + uint64_t value; + + if (block()->type() & mtExecutable) { + // native block + if (!link() || link()->operand_index() == -1) + return; + + ICommand *to_command = link()->to_command(); + if (to_command) { + value = (to_command->block()->type() & mtExecutable) ? to_command->address() : to_command->ext_vm_address(); + } else if (link()->type() == ltDelta) { + value = link()->to_address(); + } else { + return; + } + + switch (link()->type()) { + case ltDelta: + value -= address(); + break; + case ltCase: + value -= link()->parent_command()->next_address() + reinterpret_cast<ILCommand *>(link()->parent_command())->operand_value() * sizeof(uint32_t); + break; + } + set_operand_value(link()->operand_index(), link()->Encrypt(value)); + CompileToNative(); + } else { + // VM block + for (size_t i = 0; i < internal_links_.count(); i++) { + InternalLink *internal_link = internal_links_.item(i); + ILVMCommand *vm_command = reinterpret_cast<ILVMCommand *>(internal_link->from_command()); + + switch (internal_link->type()) { + case vlCRCTableAddress: + value = reinterpret_cast<ILFunctionList *>(ctx.file->function_list())->runtime_crc_table()->entry()->address() - ctx.file->image_base(); + break; + case vlCRCTableCount: + value = reinterpret_cast<ILFunctionList *>(ctx.file->function_list())->runtime_crc_table()->region_count(); + break; + default: + ILCommand *command = reinterpret_cast<ILCommand*>(internal_link->to_command()); + if (!command) + continue; + + value = command->vm_address() - ctx.file->image_base(); + } + vm_command->set_value(value); + vm_command->Compile(); + } + + if (vm_links_.empty()) + return; + + ICommand *to_command = link()->to_command(); + ICommand *next_command = link()->next_command(); + uint64_t image_base = ctx.file->image_base(); + + switch (link()->type()) { + case ltJmp: + case ltCase: + set_link_value(0, to_command->vm_address() - image_base); + break; + case ltJmpWithFlag: + set_link_value(0, to_command->vm_address() - image_base); + set_link_value(1, next_command->vm_address() - image_base); + break; + case ltOffset: + if (to_command) { + value = (section_options_ & rtLinkedFromOtherType) ? to_command->address() : to_command->vm_address(); + set_link_value(0, link()->Encrypt(value)); + } + break; + case ltSwitch: + set_link_value(0, vm_links_[4]->address() - image_base); + set_link_value(1, vm_links_[2]->address() - image_base); + set_link_value(3, next_command->vm_address() - image_base); + set_link_value(5, to_command->vm_address() - image_base); + break; + case ltCall: + if (section_options_ & rtLinkedFrom) + set_link_value(0, to_command->vm_address() - image_base); + break; + } + } +} + +void ILCommand::PrepareLink(const CompileContext &ctx) +{ + bool from_native = block() && (block()->type() & mtExecutable) ? true : owner()->compilation_type() == ctMutation; + ICommand *to_command = link()->to_command(); + if (to_command) { + bool to_native = to_command->block() && (to_command->block()->type() & mtExecutable) ? true : to_command->owner()->compilation_type() == ctMutation; + if (from_native == to_native) { + section_options_ |= rtLinkedFrom; + } else { + section_options_ |= rtLinkedFromOtherType; + } + + if ((section_options_ & rtLinkedFromOtherType) + || link()->type() == ltSEHBlock + || link()->type() == ltFinallyBlock + || (link()->type() == ltJmp && (type_ == icLeave || type_ == icLeave_s))) { + to_command->include_section_option(rtLinkedToExt); + } + else { + to_command->include_section_option(rtLinkedToInt); + } + } + + if (from_native) + return; + + bool need_next_command = false; + ICommand *next_command; + + switch (link()->type()) { + case ltJmpWithFlag: + case ltSwitch: + need_next_command = true; + break; + } + + if (need_next_command) { + size_t j = owner()->IndexOf(this) + 1; + if (type_ == icSwitch) + j += static_cast<uint32_t>(operand_value_); + if (j < owner()->count()) { + next_command = owner()->item(j); + include_section_option(rtLinkedNext); + link()->set_next_command(next_command); + next_command->include_section_option(rtLinkedToInt); + } + } +} + +void ILCommand::set_link_value(size_t link_index, uint64_t value) +{ + ILVMCommand *vm_command = vm_links_[link_index]; + vm_command->set_value(value); + vm_command->Compile(); +} + +void ILCommand::set_operand_value(size_t operand_index, uint64_t value) +{ + operand_value_ = value; +} + +void ILCommand::set_operand_fixup(IFixup *fixup) +{ + fixup_ = fixup; +} + +void ILCommand::set_address(uint64_t address) +{ + address_ = address; + + switch (ILOpCodes[type_].operand_type) { + case ShortInlineBrTarget: + case InlineBrTarget: + CompileToNative(); + break; + } +} + +void ILCommand::ReadFromBuffer(Buffer &buffer, IArchitecture &file) +{ + size_t i, r; + + r = buffer.ReadByte(); + address_ = buffer.ReadDWord() + file.image_base(); + type_ = static_cast<ILCommandType>(buffer.ReadWord()); + BaseCommand::ReadFromBuffer(buffer, file); + + original_dump_size_ = (r & 0x10) ? buffer.ReadWord() : buffer.ReadByte(); + if (type_ == icComment) { + for (i = 0; i < original_dump_size_; i++) { + PushByte(buffer.ReadByte()); + } + } else { + for (i = 0; i < original_dump_size_; i++) { + PushByte(0); + } + } + if (r & 1) { + operand_value_ = buffer.ReadQWord(); + } + if (r & 0x08) { + uint32_t value = static_cast<uint32_t>(operand_value_); + ILMetaData *meta = dynamic_cast<NETArchitecture &>(file).command_list(); + ILToken *token = meta->token(value); + if (!token && TOKEN_TYPE(value) == ttUserString) + token = meta->us_table()->Add(value); + if (token) { + uint64_t reference_address = address() + original_dump_size_ - sizeof(uint32_t); + if (type_ == icComment) { + token_reference_ = token->reference_list()->GetReferenceByAddress(reference_address); + if (!token_reference_) + throw std::runtime_error("Invalid token reference"); + } + else + token_reference_ = token->reference_list()->Add(reference_address); + } + } +} + +void ILCommand::WriteToFile(IArchitecture &file) +{ + if (fixup_) { + if (fixup_ == NEED_FIXUP) { + ISection *segment = file.segment_list()->GetSectionByAddress(address_); + fixup_ = file.fixup_list()->AddDefault(file.cpu_address_size(), segment && (segment->memory_type() & mtExecutable) != 0); + } + fixup_->set_address(address_ + operand_pos_); + } + + BaseCommand::WriteToFile(file); +} + +void ILCommand::Rebase(uint64_t delta_base) +{ + if (!address_) + return; + + switch (ILOpCodes[type_].operand_type) { + case ShortInlineBrTarget: + case InlineBrTarget: + operand_value_ += delta_base; + break; + } + + address_ += delta_base; +} + +ILCommand * ILCommand::Clone(IFunction *owner) const +{ + ILCommand *command = new ILCommand(owner, *this); + return command; +} + +bool ILCommand::Merge(ICommand *command) +{ + return false; +} + +bool ILCommand::is_data() const +{ + return (type_ == icByte || type_ == icWord || type_ == icDword || type_ == icData); +} + +bool ILCommand::is_end() const +{ + ILFlowControl flow_type = ILOpCodes[type_].flow_type; + return (flow_type == Branch || flow_type == Return || flow_type == Throw); +} + +bool ILCommand::is_prefix() const +{ + return (ILOpCodes[type_].opcode_type == Prefix); +} + +std::string ILCommand::dump_str() const +{ + std::string res; + if (type_ == icUnknown) { + for (size_t i = 0; i < dump_size(); i++) { + res += "??"; + } + return res; + } + + res = BaseCommand::dump_str(); + + size_t value_size; + const ILOpCode opcode = ILOpCodes[type_]; + switch (opcode.operand_type) { + case InlineNone: + case InlinePhi: + case Inline8: + value_size = 0; + break; + case ShortInlineI: + case ShortInlineVar: + case ShortInlineBrTarget: + value_size = sizeof(uint8_t); + break; + case InlineVar: + value_size = sizeof(uint16_t); + break; + case InlineI8: + case InlineR: + value_size = sizeof(uint64_t); + break; + default: + value_size = sizeof(uint32_t); + break; + } + + if (value_size) { + size_t end = dump_size(); + while (end > operand_pos_) { + res.insert((end - value_size) * 2, " "); + end -= value_size; + } + } + + return res; +} + +std::string ILCommand::display_address() const +{ + return DisplayValue(size(), address()); +} + +size_t ILCommand::ReadFromFile(IArchitecture & file) +{ + clear(); + + switch (ReadByte(file)) { + case 0x00: type_ = icNop; break; + case 0x01: type_ = icBreak; break; + case 0x02: type_ = icLdarg_0; break; + case 0x03: type_ = icLdarg_1; break; + case 0x04: type_ = icLdarg_2; break; + case 0x05: type_ = icLdarg_3; break; + case 0x06: type_ = icLdloc_0; break; + case 0x07: type_ = icLdloc_1; break; + case 0x08: type_ = icLdloc_2; break; + case 0x09: type_ = icLdloc_3; break; + case 0x0a: type_ = icStloc_0; break; + case 0x0b: type_ = icStloc_1; break; + case 0x0c: type_ = icStloc_2; break; + case 0x0d: type_ = icStloc_3; break; + case 0x0e: type_ = icLdarg_s; break; + case 0x0f: type_ = icLdarga_s; break; + case 0x10: type_ = icStarg_s; break; + case 0x11: type_ = icLdloc_s; break; + case 0x12: type_ = icLdloca_s; break; + case 0x13: type_ = icStloc_s; break; + case 0x14: type_ = icLdnull; break; + case 0x15: type_ = icLdc_i4_m1; break; + case 0x16: type_ = icLdc_i4_0; break; + case 0x17: type_ = icLdc_i4_1; break; + case 0x18: type_ = icLdc_i4_2; break; + case 0x19: type_ = icLdc_i4_3; break; + case 0x1a: type_ = icLdc_i4_4; break; + case 0x1b: type_ = icLdc_i4_5; break; + case 0x1c: type_ = icLdc_i4_6; break; + case 0x1d: type_ = icLdc_i4_7; break; + case 0x1e: type_ = icLdc_i4_8; break; + case 0x1f: type_ = icLdc_i4_s; break; + case 0x20: type_ = icLdc_i4; break; + case 0x21: type_ = icLdc_i8; break; + case 0x22: type_ = icLdc_r4; break; + case 0x23: type_ = icLdc_r8; break; + // 0x24 reserved for standardization + case 0x25: type_ = icDup; break; + case 0x26: type_ = icPop; break; + case 0x27: type_ = icJmp; break; + case 0x28: type_ = icCall; break; + case 0x29: type_ = icCalli; break; + case 0x2a: type_ = icRet; break; + case 0x2b: type_ = icBr_s; break; + case 0x2c: type_ = icBrfalse_s; break; + case 0x2d: type_ = icBrtrue_s; break; + case 0x2e: type_ = icBeq_s; break; + case 0x2f: type_ = icBge_s; break; + case 0x30: type_ = icBgt_s; break; + case 0x31: type_ = icBle_s; break; + case 0x32: type_ = icBlt_s; break; + case 0x33: type_ = icBne_un_s; break; + case 0x34: type_ = icBge_un_s; break; + case 0x35: type_ = icBgt_un_s; break; + case 0x36: type_ = icBle_un_s; break; + case 0x37: type_ = icBlt_un_s; break; + case 0x38: type_ = icBr; break; + case 0x39: type_ = icBrfalse; break; + case 0x3a: type_ = icBrtrue; break; + case 0x3b: type_ = icBeq; break; + case 0x3c: type_ = icBge; break; + case 0x3d: type_ = icBgt; break; + case 0x3e: type_ = icBle; break; + case 0x3f: type_ = icBlt; break; + case 0x40: type_ = icBne_un; break; + case 0x41: type_ = icBge_un; break; + case 0x42: type_ = icBgt_un; break; + case 0x43: type_ = icBle_un; break; + case 0x44: type_ = icBlt_un; break; + case 0x45: type_ = icSwitch; break; + case 0x46: type_ = icLdind_i1; break; + case 0x47: type_ = icLdind_u1; break; + case 0x48: type_ = icLdind_i2; break; + case 0x49: type_ = icLdind_u2; break; + case 0x4a: type_ = icLdind_i4; break; + case 0x4b: type_ = icLdind_u4; break; + case 0x4c: type_ = icLdind_i8; break; + case 0x4d: type_ = icLdind_i; break; + case 0x4e: type_ = icLdind_r4; break; + case 0x4f: type_ = icLdind_r8; break; + case 0x50: type_ = icLdind_ref; break; + case 0x51: type_ = icStind_ref; break; + case 0x52: type_ = icStind_i1; break; + case 0x53: type_ = icStind_i2; break; + case 0x54: type_ = icStind_i4; break; + case 0x55: type_ = icStind_i8; break; + case 0x56: type_ = icStind_r4; break; + case 0x57: type_ = icStind_r8; break; + case 0x58: type_ = icAdd; break; + case 0x59: type_ = icSub; break; + case 0x5a: type_ = icMul; break; + case 0x5b: type_ = icDiv; break; + case 0x5c: type_ = icDiv_un; break; + case 0x5d: type_ = icRem; break; + case 0x5e: type_ = icRem_un; break; + case 0x5f: type_ = icAnd; break; + case 0x60: type_ = icOr; break; + case 0x61: type_ = icXor; break; + case 0x62: type_ = icShl; break; + case 0x63: type_ = icShr; break; + case 0x64: type_ = icShr_un; break; + case 0x65: type_ = icNeg; break; + case 0x66: type_ = icNot; break; + case 0x67: type_ = icConv_i1; break; + case 0x68: type_ = icConv_i2; break; + case 0x69: type_ = icConv_i4; break; + case 0x6a: type_ = icConv_i8; break; + case 0x6b: type_ = icConv_r4; break; + case 0x6c: type_ = icConv_r8; break; + case 0x6d: type_ = icConv_u4; break; + case 0x6e: type_ = icConv_u8; break; + case 0x6f: type_ = icCallvirt; break; + case 0x70: type_ = icCpobj; break; + case 0x71: type_ = icLdobj; break; + case 0x72: type_ = icLdstr; break; + case 0x73: type_ = icNewobj; break; + case 0x74: type_ = icCastclass; break; + case 0x75: type_ = icIsinst; break; + case 0x76: type_ = icConv_r_un; break; + // 0x77-0x78 reserved for standardization + case 0x79: type_ = icUnbox; break; + case 0x7a: type_ = icThrow; break; + case 0x7b: type_ = icLdfld; break; + case 0x7c: type_ = icLdflda; break; + case 0x7d: type_ = icStfld; break; + case 0x7e: type_ = icLdsfld; break; + case 0x7f: type_ = icLdsflda; break; + case 0x80: type_ = icStsfld; break; + case 0x81: type_ = icStobj; break; + case 0x82: type_ = icConv_ovf_i1_un; break; + case 0x83: type_ = icConv_ovf_i2_un; break; + case 0x84: type_ = icConv_ovf_i4_un; break; + case 0x85: type_ = icConv_ovf_i8_un; break; + case 0x86: type_ = icConv_ovf_u1_un; break; + case 0x87: type_ = icConv_ovf_u2_un; break; + case 0x88: type_ = icConv_ovf_u4_un; break; + case 0x89: type_ = icConv_ovf_u8_un; break; + case 0x8a: type_ = icConv_ovf_i_un; break; + case 0x8b: type_ = icConv_ovf_u_un; break; + case 0x8c: type_ = icBox; break; + case 0x8d: type_ = icNewarr; break; + case 0x8e: type_ = icLdlen; break; + case 0x8f: type_ = icLdelema; break; + case 0x90: type_ = icLdelem_i1; break; + case 0x91: type_ = icLdelem_u1; break; + case 0x92: type_ = icLdelem_i2; break; + case 0x93: type_ = icLdelem_u2; break; + case 0x94: type_ = icLdelem_i4; break; + case 0x95: type_ = icLdelem_u4; break; + case 0x96: type_ = icLdelem_i8; break; + case 0x97: type_ = icLdelem_i; break; + case 0x98: type_ = icLdelem_r4; break; + case 0x99: type_ = icLdelem_r8; break; + case 0x9a: type_ = icLdelem_ref; break; + case 0x9b: type_ = icStelem_i; break; + case 0x9c: type_ = icStelem_i1; break; + case 0x9d: type_ = icStelem_i2; break; + case 0x9e: type_ = icStelem_i4; break; + case 0x9f: type_ = icStelem_i8; break; + case 0xa0: type_ = icStelem_r4; break; + case 0xa1: type_ = icStelem_r8; break; + case 0xa2: type_ = icStelem_ref; break; + case 0xa3: type_ = icLdelem; break; + case 0xa4: type_ = icStelem; break; + case 0xa5: type_ = icUnbox_any; break; + // 0xA6-0xB2 reserved for standardization + case 0xb3: type_ = icConv_ovf_i1; break; + case 0xb4: type_ = icConv_ovf_u1; break; + case 0xb5: type_ = icConv_ovf_i2; break; + case 0xb6: type_ = icConv_ovf_u2; break; + case 0xb7: type_ = icConv_ovf_i4; break; + case 0xb8: type_ = icConv_ovf_u4; break; + case 0xb9: type_ = icConv_ovf_i8; break; + case 0xba: type_ = icConv_ovf_u8; break; + // 0xBB-0xC1 reserved for standardization + case 0xc2: type_ = icRefanyval; break; + case 0xc3: type_ = icCkfinite; break; + // 0xC4-0xC5 reserved for standardization + case 0xc6: type_ = icMkrefany; break; + // 0xC7-0xCF reserved for standardization + case 0xd0: type_ = icLdtoken; break; + case 0xd1: type_ = icConv_u2; break; + case 0xd2: type_ = icConv_u1; break; + case 0xd3: type_ = icConv_i; break; + case 0xd4: type_ = icConv_ovf_i; break; + case 0xd5: type_ = icConv_ovf_u; break; + case 0xd6: type_ = icAdd_ovf; break; + case 0xd7: type_ = icAdd_ovf_un; break; + case 0xd8: type_ = icMul_ovf; break; + case 0xd9: type_ = icMul_ovf_un; break; + case 0xda: type_ = icSub_ovf; break; + case 0xdb: type_ = icSub_ovf_un; break; + case 0xdc: type_ = icEndfinally; break; + case 0xdd: type_ = icLeave; break; + case 0xde: type_ = icLeave_s; break; + case 0xdf: type_ = icStind_i; break; + case 0xe0: type_ = icConv_u; break; + // 0xE1-0xEF reserved for standardization + // 0xF0-0xFB are ecma_experimental + // 0xFC-0xFD reserved for standardization + case 0xfe: + //two-byte opcodes + switch (ReadByte(file)) { + case 0x00: type_ = icArglist; break; + case 0x01: type_ = icCeq; break; + case 0x02: type_ = icCgt; break; + case 0x03: type_ = icCgt_un; break; + case 0x04: type_ = icClt; break; + case 0x05: type_ = icClt_un; break; + case 0x06: type_ = icLdftn; break; + case 0x07: type_ = icLdvirtftn; break; + // 0xFE08 reserved for standardization + case 0x09: type_ = icLdarg; break; + case 0x0a: type_ = icLdarga; break; + case 0x0b: type_ = icStarg; break; + case 0x0c: type_ = icLdloc; break; + case 0x0d: type_ = icLdloca; break; + case 0x0e: type_ = icStloc; break; + case 0x0f: type_ = icLocalloc; break; + // 0xFE10 reserved for standardization + case 0x11: type_ = icEndfilter; break; + case 0x12: type_ = icUnaligned; break; + case 0x13: type_ = icVolatile; break; + case 0x14: type_ = icTail; break; + case 0x15: type_ = icInitobj; break; + case 0x16: type_ = icConstrained; break; + case 0x17: type_ = icCpblk; break; + case 0x18: type_ = icInitblk; break; + case 0x19: type_ = icNo; break; + case 0x1a: type_ = icRethrow; break; + // 0xFE1B reserved for standardization + case 0x1c: type_ = icSizeof; break; + case 0x1d: type_ = icRefanytype; break; + case 0x1e: type_ = icReadonly; break; + } + break; + // 0xFF reserved for standardization + } + + operand_pos_ = dump_size(); + + switch (ILOpCodes[type_].operand_type) + { + case InlineNone: // No operand + case InlinePhi: // Obsolete. The operand is reserved and should not be used. + case Inline8: // not used + // all read already + break; + case ShortInlineI: // 8-bit integer + operand_value_ = static_cast<int8_t>(ReadByte(file)); + break; + case ShortInlineVar: // 8-bit integer containing the ordinal of a local variable or an argument + operand_value_ = ReadByte(file); + break; + case InlineVar: // 16-bit integer containing the ordinal of a local variable or an argument + operand_value_ = ReadWord(file); + break; + case InlineI8: // 64-bit integer + case InlineR: // 64-bit IEEE floating point number + operand_value_ = ReadQWord(file); + break; + case InlineSwitch: + operand_value_ = ReadDWord(file); + break; + case ShortInlineBrTarget: // 8-bit integer branch target + operand_value_ = static_cast<int8_t>(ReadByte(file)); + operand_value_ += next_address(); + break; + case InlineBrTarget: // 32-bit integer branch target + operand_value_ = static_cast<int32_t>(ReadDWord(file)); + operand_value_ += next_address(); + break; + case InlineField: + case InlineMethod: + case InlineSig: + case InlineTok: + case InlineType: + case InlineString: + operand_value_ = ReadDWord(file); + { + ILToken *token = dynamic_cast<NETArchitecture &>(file).command_list()->token(static_cast<uint32_t>(operand_value_)); + if (token) + token_reference_ = token->reference_list()->GetReferenceByAddress(address() + operand_pos_); + } + break; + default: // 4 byte + operand_value_ = ReadDWord(file); + break; + } + + original_dump_size_ = dump_size(); + + return original_dump_size_; +} + +uint64_t ILCommand::ReadValueFromFile(IArchitecture &file, OperandSize value_size, bool is_token) +{ + switch (value_size) { + case osByte: + type_ = icByte; + operand_value_ = ReadByte(file); + break; + case osWord: + type_ = icWord; + operand_value_ = ReadWord(file); + break; + case osDWord: + type_ = icDword; + operand_value_ = ReadDWord(file); + break; + default: + throw std::runtime_error("Invalid value size"); + } + + if (is_token) { + ILToken *token = dynamic_cast<NETArchitecture &>(file).command_list()->token(static_cast<uint32_t>(operand_value_)); + if (token) + token_reference_ = token->reference_list()->GetReferenceByAddress(address_); + } + + return operand_value_; +} + +void ILCommand::ReadString(IArchitecture &file, size_t len) +{ + type_ = icData; + Read(file, len); +} + +void ILCommand::ReadCaseCommand(IArchitecture &file) +{ + type_ = icCase; + operand_value_ = DWordToInt64(ReadDWord(file)); +} + +int ILCommand::GetStackLevel(size_t *pop_ref) const +{ + if (type_ == icRet) + return 0; + + size_t push = 0; + size_t pop = 0; + if (ILOpCodes[type_].flow_type == Call) { + ILToken *token = token_reference_->owner()->owner(); + if (token->type() == ttMethodSpec) + token = reinterpret_cast<ILMethodSpec *>(token)->parent(); + + ILSignature *signature; + switch (token->type()) { + case ttMethodDef: + signature = reinterpret_cast<ILMethodDef *>(token)->signature(); + break; + case ttMemberRef: + signature = reinterpret_cast<ILMemberRef *>(token)->signature(); + break; + case ttStandAloneSig: + signature = reinterpret_cast<ILStandAloneSig *>(token)->signature(); + break; + default: + throw std::runtime_error("Invalid token type: " + text()); + } + if (type_ != icNewobj && signature->has_this() && !signature->explicit_this()) + pop += 1; + if (type_ == icCalli) + pop += 1; + pop += static_cast<int>(signature->count()); + if (type_ == icNewobj || signature->ret()->type() != ELEMENT_TYPE_VOID) + push += 1; + } + else { + switch (ILOpCodes[type_].pop) { + case Pop0: + break; + case Pop1: + case Popi: + case Popref: + pop += 1; + break; + case Pop1_pop1: + case Popi_pop1: + case Popi_popi: + case Popi_popi8: + case Popi_popr4: + case Popi_popr8: + case Popref_pop1: + case Popref_popi: + pop += 2; + break; + case Popi_popi_popi: + case Popref_popi_popi: + case Popref_popi_popi8: + case Popref_popi_popr4: + case Popref_popi_popr8: + case Popref_popi_popref: + case Popref_popi_pop1: + pop += 3; + break; + } + + switch (ILOpCodes[type_].push) { + case Push0: + break; + case Push1: + case Pushi: + case Pushi8: + case Pushr4: + case Pushr8: + case Pushref: + push += 1; + break; + case Push1_push1: + push += 2; + break; + } + } + + if (pop_ref) + *pop_ref = pop; + + return (int)(push - pop); +} + +ILVMCommand *ILCommand::AddVMCommand(const CompileContext &ctx, ILCommandType command_type, uint64_t value, uint32_t options, TokenReference *token_reference, ILCommand *to_command) +{ + ILVMCommand *vm_command = NULL; +#ifdef ULTIMATE + if ((owner()->compilation_options() & coLockToKey) && command_type == icLdc_i4 && (options & voNoCryptValue) == 0) { + vm_command = new ILVMCommand(this, command_type, value, token_reference); + vm_command->set_crypt_command(icAdd, osDWord, ctx.options.licensing_manager->product_code()); + } +#endif + if (!vm_command) + vm_command = new ILVMCommand(this, command_type, value, token_reference); + AddObject(vm_command); + if (options & voLinkCommand) + vm_links_.push_back(vm_command); + + switch (command_type) { + case icBr: + case icRet: + section_options_ |= rtCloseSection; + break; + } + + if (to_command) + internal_links_.Add(vlNone, vm_command, to_command); + + uint32_t new_options = (options & voSectionCommand); + if (vm_command->crypt_command() == icAdd) { + new_options |= voNoCryptValue; + + size_t i; + ILVMCommand *cur_command = vm_command; + ILToken *type = reinterpret_cast<NETArchitecture *>(ctx.file)->command_list()->ImportType(ELEMENT_TYPE_U4); + // add session key + uint64_t address = ctx.runtime->export_list()->GetAddressByType(atLoaderData); + ILFunction *loader_data_func = reinterpret_cast<ILFunction *>(ctx.runtime->function_list()->GetFunctionByAddress(address)); + ILCommand *field_command = loader_data_func->item(1); + AddVMCommand(ctx, icLdnull, 0, new_options); + AddVMCommand(ctx, icLdc_i4, field_command->operand_value(), new_options, field_command->token_reference()); + AddVMCommand(ctx, icLdfld, 0, new_options); + AddVMCommand(ctx, icLdc_i4, ctx.runtime_var_index[VAR_SESSION_KEY], new_options); + AddVMCommand(ctx, icLdc_i4, type->id(), new_options, type->reference_list()->Add(0)); + AddVMCommand(ctx, icLdelem_ref, 0, new_options); + AddVMCommand(ctx, icAdd, 0, new_options); + for (i = 1; i < 4; i++) { + cur_command->set_link_command(AddVMCommand(ctx, icLdc_i4, 0, new_options)); + // add session key + AddVMCommand(ctx, icLdnull, 0, new_options); + AddVMCommand(ctx, icLdc_i4, field_command->operand_value(), new_options, field_command->token_reference()); + AddVMCommand(ctx, icLdfld, 0, new_options); + AddVMCommand(ctx, icLdc_i4, ctx.runtime_var_index[VAR_SESSION_KEY], new_options); + AddVMCommand(ctx, icLdc_i4, type->id(), new_options, type->reference_list()->Add(0)); + AddVMCommand(ctx, icLdelem_ref, 0, new_options); + AddVMCommand(ctx, icAdd, 0, new_options); + cur_command = cur_command->link_command(); + } + address = ctx.runtime->export_list()->GetAddressByType(atDecryptBuffer); + ILVMCommand *from_command = AddVMCommand(ctx, icLdc_i4, 0, new_options); + ICommand *to_command = ctx.file->function_list()->GetCommandByAddress(address, true); + if (to_command) + internal_links_.Add(vlNone, from_command, to_command); + AddVMCommand(ctx, icCallvm, 0, new_options); + // add session key + AddVMCommand(ctx, icLdnull, 0, new_options); + AddVMCommand(ctx, icLdc_i4, field_command->operand_value(), new_options, field_command->token_reference()); + AddVMCommand(ctx, icLdfld, 0, new_options); + AddVMCommand(ctx, icLdc_i4, ctx.runtime_var_index[VAR_SESSION_KEY], new_options); + AddVMCommand(ctx, icLdc_i4, type->id(), new_options, type->reference_list()->Add(0)); + AddVMCommand(ctx, icLdelem_ref, 0, new_options); + AddVMCommand(ctx, icAdd, 0, new_options); + } + + return vm_command; +} + +void ILCommand::AddCmpSection(const CompileContext &ctx, ILCommandType cmp_command) +{ + ILCommandType cmp_type; + switch (cmp_command) { + case icBne_un: + case icClt_un: + case icBlt_un: + case icBle_un: + case icCgt_un: + case icBgt_un: + case icBge_un: + cmp_type = icCmp_un; + break; + default: + cmp_type = icCmp; + break; + } + + switch (cmp_command) { + case icCeq: + case icBeq: + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, cmp_type, 0); + AddVMCommand(ctx, icNot, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAnd, 0); + break; + case icBne_un: + AddVMCommand(ctx, icLdc_i4, 0); + AddVMCommand(ctx, cmp_type, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAnd, 0); + break; + case icClt: + case icClt_un: + case icBlt: + case icBlt_un: + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, cmp_type, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icShr_un, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAnd, 0); + break; + case icBle: + case icBle_un: + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, cmp_type, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icNot, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icShr_un, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAnd, 0); + break; + case icCgt: + case icCgt_un: + case icBgt: + case icBgt_un: + AddVMCommand(ctx, icLdc_i4, static_cast<uint32_t>(-1)); + AddVMCommand(ctx, cmp_type, 0); + AddVMCommand(ctx, icNot, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icShr_un, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAnd, 0); + break; + case icBge: + case icBge_un: + AddVMCommand(ctx, icLdc_i4, static_cast<uint32_t>(-1)); + AddVMCommand(ctx, cmp_type, 0); + AddVMCommand(ctx, icNot, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icShr_un, 0); + AddVMCommand(ctx, icLdc_i4, 1); + AddVMCommand(ctx, icAnd, 0); + break; + } +} + +void ILCommand::AddJmpWithFlagSection(const CompileContext &ctx, bool is_true) +{ + ILToken *type = reinterpret_cast<NETArchitecture *>(ctx.file)->command_list()->ImportType(ELEMENT_TYPE_BOOLEAN); + + AddVMCommand(ctx, icLdc_i4, type->id(), 0, type->reference_list()->Add(0)); + AddVMCommand(ctx, icConv, 0); + AddVMCommand(ctx, icNeg, 0); + if (!is_true) + AddVMCommand(ctx, icNot, 0); + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icAnd, 0); + AddVMCommand(ctx, icDup, 0); + AddVMCommand(ctx, icLdc_i4, type->id(), 0, type->reference_list()->Add(0)); + AddVMCommand(ctx, icConv, 0); + AddVMCommand(ctx, icNeg, 0); + AddVMCommand(ctx, icNot, 0); + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icAnd, 0); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icBr, 0); +} + +void ILCommand::CompileToVM(const CompileContext &ctx) +{ + ILToken *internal_type = NULL; + TokenReference *internal_token_reference = NULL; + + switch (type_) { + case icLdelem_i: + case icLdelem_i1: + case icLdelem_i2: + case icLdelem_i4: + case icLdelem_i8: + case icLdelem_u1: + case icLdelem_u2: + case icLdelem_u4: + case icLdelem_r4: + case icLdelem_r8: + case icLdelem_ref: + case icStelem_i: + case icStelem_i1: + case icStelem_i2: + case icStelem_i4: + case icStelem_i8: + case icStelem_r4: + case icStelem_r8: + case icStelem_ref: + case icLdind_i: + case icLdind_i1: + case icLdind_i2: + case icLdind_i4: + case icLdind_i8: + case icLdind_u1: + case icLdind_u2: + case icLdind_u4: + case icLdind_r4: + case icLdind_r8: + case icLdind_ref: + case icStind_i: + case icStind_i1: + case icStind_i2: + case icStind_i4: + case icStind_i8: + case icStind_r4: + case icStind_r8: + case icStind_ref: + case icConv_i: + case icConv_u: + case icConv_i1: + case icConv_u1: + case icConv_i2: + case icConv_u2: + case icConv_i4: + case icConv_u4: + case icConv_i8: + case icConv_u8: + case icConv_r4: + case icConv_r8: + case icConv_r_un: + case icConv_ovf_i: + case icConv_ovf_u: + case icConv_ovf_i1: + case icConv_ovf_u1: + case icConv_ovf_i2: + case icConv_ovf_u2: + case icConv_ovf_i4: + case icConv_ovf_u4: + case icConv_ovf_i8: + case icConv_ovf_u8: + case icConv_ovf_i_un: + case icConv_ovf_u_un: + case icConv_ovf_i1_un: + case icConv_ovf_u1_un: + case icConv_ovf_i2_un: + case icConv_ovf_u2_un: + case icConv_ovf_i4_un: + case icConv_ovf_u4_un: + case icConv_ovf_i8_un: + case icConv_ovf_u8_un: + { + CorElementType element_type; + switch (type_) { + case icLdelem_i1: + case icStelem_i1: + case icLdind_i1: + case icStind_i1: + case icConv_i1: + case icConv_ovf_i1: + case icConv_ovf_i1_un: + element_type = ELEMENT_TYPE_I1; + break; + case icLdelem_i2: + case icStelem_i2: + case icLdind_i2: + case icStind_i2: + case icConv_i2: + case icConv_ovf_i2: + case icConv_ovf_i2_un: + element_type = ELEMENT_TYPE_I2; + break; + case icLdelem_i4: + case icStelem_i4: + case icLdind_i4: + case icStind_i4: + case icConv_i4: + case icConv_ovf_i4: + case icConv_ovf_i4_un: + element_type = ELEMENT_TYPE_I4; + break; + case icLdelem_i8: + case icStelem_i8: + case icLdind_i8: + case icStind_i8: + case icConv_i8: + case icConv_ovf_i8: + case icConv_ovf_i8_un: + element_type = ELEMENT_TYPE_I8; + break; + case icLdelem_u1: + case icLdind_u1: + case icConv_u1: + case icConv_ovf_u1: + case icConv_ovf_u1_un: + element_type = ELEMENT_TYPE_U1; + break; + case icLdelem_u2: + case icLdind_u2: + case icConv_u2: + case icConv_ovf_u2: + case icConv_ovf_u2_un: + element_type = ELEMENT_TYPE_U2; + break; + case icLdelem_u4: + case icLdind_u4: + case icConv_u4: + case icConv_ovf_u4: + case icConv_ovf_u4_un: + element_type = ELEMENT_TYPE_U4; + break; + case icConv_u8: + case icConv_ovf_u8: + case icConv_ovf_u8_un: + element_type = ELEMENT_TYPE_U8; + break; + case icLdelem_r4: + case icStelem_r4: + case icLdind_r4: + case icStind_r4: + case icConv_r4: + element_type = ELEMENT_TYPE_R4; + break; + case icLdelem_r8: + case icStelem_r8: + case icLdind_r8: + case icStind_r8: + case icConv_r8: + case icConv_r_un: + element_type = ELEMENT_TYPE_R8; + break; + case icLdelem_ref: + case icStelem_ref: + case icLdind_ref: + case icStind_ref: + element_type = ELEMENT_TYPE_OBJECT; + break; + case icConv_u: + case icConv_ovf_u: + case icConv_ovf_u_un: + element_type = ELEMENT_TYPE_U; + break; + default: + element_type = ELEMENT_TYPE_I; + break; + } + internal_type = reinterpret_cast<NETArchitecture *>(ctx.file)->command_list()->ImportType(element_type); + internal_token_reference = internal_type->reference_list()->Add(0); + } + break; + } + + switch (type_) { + case icNop: + break; + case icLdarg: + case icLdarg_s: + case icLdarg_0: + case icLdarg_1: + case icLdarg_2: + case icLdarg_3: + AddVMCommand(ctx, icLdarg, param_); + break; + case icLdarga: + case icLdarga_s: + AddVMCommand(ctx, icLdarga, param_); + break; + case icStarg: + case icStarg_s: + AddVMCommand(ctx, icStarg, param_); + break; + case icLdloc: + case icLdloc_s: + case icLdloc_0: + case icLdloc_1: + case icLdloc_2: + case icLdloc_3: + AddVMCommand(ctx, icLdarg, param_); + break; + case icLdloca: + case icLdloca_s: + AddVMCommand(ctx, icLdarga, param_); + break; + case icStloc: + case icStloc_s: + case icStloc_0: + case icStloc_1: + case icStloc_2: + case icStloc_3: + AddVMCommand(ctx, icStarg, param_); + break; + case icLdc_i4_0: + AddVMCommand(ctx, icLdc_i4, 0); + break; + case icLdc_i4_1: + AddVMCommand(ctx, icLdc_i4, 1); + break; + case icLdc_i4_2: + AddVMCommand(ctx, icLdc_i4, 2); + break; + case icLdc_i4_3: + AddVMCommand(ctx, icLdc_i4, 3); + break; + case icLdc_i4_4: + AddVMCommand(ctx, icLdc_i4, 4); + break; + case icLdc_i4_5: + AddVMCommand(ctx, icLdc_i4, 5); + break; + case icLdc_i4_6: + AddVMCommand(ctx, icLdc_i4, 6); + break; + case icLdc_i4_7: + AddVMCommand(ctx, icLdc_i4, 7); + break; + case icLdc_i4_8: + AddVMCommand(ctx, icLdc_i4, 8); + break; + case icLdc_i4: + case icLdc_i4_s: + AddVMCommand(ctx, icLdc_i4, operand_value_, (link() && link()->operand_index() == 0) ? voLinkCommand : 0); + break; + case icLdc_i4_m1: + AddVMCommand(ctx, icLdc_i4, static_cast<uint32_t>(-1)); + break; + case icLdc_i8: + AddVMCommand(ctx, icLdc_i8, operand_value_); + break; + case icLdc_r4: + AddVMCommand(ctx, icLdc_r4, operand_value_); + break; + case icLdc_r8: + AddVMCommand(ctx, icLdc_r8, operand_value_); + break; + case icLdnull: + AddVMCommand(ctx, icLdnull, 0); + break; + case icConv_i: + case icConv_u: + case icConv_i1: + case icConv_u1: + case icConv_i2: + case icConv_u2: + case icConv_i4: + case icConv_u4: + case icConv_i8: + case icConv_u8: + case icConv_r4: + case icConv_r8: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icConv, 0); + break; + case icConv_ovf_i: + case icConv_ovf_u: + case icConv_ovf_i1: + case icConv_ovf_u1: + case icConv_ovf_i2: + case icConv_ovf_u2: + case icConv_ovf_i4: + case icConv_ovf_u4: + case icConv_ovf_i8: + case icConv_ovf_u8: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icConv_ovf, 0); + break; + case icConv_ovf_i_un: + case icConv_ovf_u_un: + case icConv_ovf_i1_un: + case icConv_ovf_u1_un: + case icConv_ovf_i2_un: + case icConv_ovf_u2_un: + case icConv_ovf_i4_un: + case icConv_ovf_u4_un: + case icConv_ovf_i8_un: + case icConv_ovf_u8_un: + case icConv_r_un: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icConv_ovf_un, 0); + break; + case icRem: + AddVMCommand(ctx, icRem, 0); + break; + case icRem_un: + AddVMCommand(ctx, icRem_un, 0); + break; + case icAdd: + AddVMCommand(ctx, icAdd, 0); + break; + case icSub: + AddVMCommand(ctx, icSub, 0); + break; + case icDiv: + AddVMCommand(ctx, icDiv, 0); + break; + case icDiv_un: + AddVMCommand(ctx, icDiv_un, 0); + break; + case icMul: + AddVMCommand(ctx, icMul, 0); + break; + case icAnd: + AddVMCommand(ctx, icAnd, 0); + break; + case icOr: + AddVMCommand(ctx, icOr, 0); + break; + case icXor: + AddVMCommand(ctx, icXor, 0); + break; + case icShl: + AddVMCommand(ctx, icShl, 0); + break; + case icShr: + AddVMCommand(ctx, icShr, 0); + break; + case icShr_un: + AddVMCommand(ctx, icShr_un, 0); + break; + case icNeg: + AddVMCommand(ctx, icNeg, 0); + break; + case icNot: + AddVMCommand(ctx, icNot, 0); + break; + case icAdd_ovf: + AddVMCommand(ctx, icAdd_ovf, 0); + break; + case icAdd_ovf_un: + AddVMCommand(ctx, icAdd_ovf_un, 0); + break; + case icMul_ovf: + AddVMCommand(ctx, icMul_ovf, 0); + break; + case icMul_ovf_un: + AddVMCommand(ctx, icMul_ovf_un, 0); + break; + case icSub_ovf: + AddVMCommand(ctx, icSub_ovf, 0); + break; + case icSub_ovf_un: + AddVMCommand(ctx, icSub_ovf_un, 0); + break; + case icCeq: + AddCmpSection(ctx, icCeq); + break; + case icClt: + AddCmpSection(ctx, icClt); + break; + case icClt_un: + AddCmpSection(ctx, icClt_un); + break; + case icCgt: + AddCmpSection(ctx, icCgt); + break; + case icCgt_un: + AddCmpSection(ctx, icCgt_un); + break; + case icCall: + if (section_options_ & rtLinkedFrom) { + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icCallvm, 0); + } + else { + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icCall, 0); + } + break; + case icCallvirt: + if (section_options_ & rtLinkedFrom) { + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icCallvmvirt, 0); + } + else { + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icCallvirt, 0); + } + break; + case icNewobj: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icNewobj, 0); + break; + case icNewarr: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icNewarr, 0); + break; + case icInitobj: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icInitobj, 0); + break; + case icConstrained: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icConstrained, 0); + break; + case icStelem_i: + case icStelem_i1: + case icStelem_i2: + case icStelem_i4: + case icStelem_i8: + case icStelem_r4: + case icStelem_r8: + case icStelem_ref: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icStelem_ref, 0); + break; + case icStelem: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icStelem_ref, 0); + break; + case icLdelem_i: + case icLdelem_i1: + case icLdelem_u1: + case icLdelem_i2: + case icLdelem_u2: + case icLdelem_i4: + case icLdelem_u4: + case icLdelem_i8: + case icLdelem_r4: + case icLdelem_r8: + case icLdelem_ref: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icLdelem_ref, 0); + break; + case icLdelem: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdelem_ref, 0); + break; + case icLdelema: + AddVMCommand(ctx, icLdelema, 0); + break; + case icLdlen: + AddVMCommand(ctx, icLdlen, 0); + break; + case icLdfld: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdfld, 0); + break; + case icLdsfld: + AddVMCommand(ctx, icLdnull, 0); + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdfld, 0); + break; + case icLdflda: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdflda, 0); + break; + case icLdsflda: + AddVMCommand(ctx, icLdnull, 0); + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdflda, 0); + break; + case icStfld: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icStfld, 0); + break; + case icStsfld: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icStsfld, 0); + break; + case icLdstr: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdstr, 0); + break; + case icLdftn: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdftn, 0); + break; + case icLdvirtftn: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdvirtftn, 0); + break; + case icStind_i: + case icStind_i1: + case icStind_i2: + case icStind_i4: + case icStind_i8: + case icStind_r4: + case icStind_r8: + case icStind_ref: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icStind_ref, 0); + break; + case icStobj: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icStind_ref, 0); + break; + case icLdind_i: + case icLdind_i1: + case icLdind_i2: + case icLdind_i4: + case icLdind_i8: + case icLdind_u1: + case icLdind_u2: + case icLdind_u4: + case icLdind_r4: + case icLdind_r8: + case icLdind_ref: + AddVMCommand(ctx, icLdc_i4, internal_type->id(), 0, internal_token_reference); + AddVMCommand(ctx, icLdind_ref, 0); + break; + case icLdobj: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdind_ref, 0); + break; + case icPop: + AddVMCommand(ctx, icPop, 0); + break; + case icDup: + AddVMCommand(ctx, icDup, 0); + break; + case icBox: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icBox, 0); + break; + case icUnbox: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icUnbox, 0); + break; + case icUnbox_any: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icUnbox_any, 0); + break; + case icLdtoken: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icLdtoken, 0); + break; + case icBr: + case icBr_s: + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icBr, 0); + break; + case icBeq: + case icBeq_s: + AddCmpSection(ctx, icBeq); + AddJmpWithFlagSection(ctx, true); + break; + case icBne_un: + case icBne_un_s: + AddCmpSection(ctx, icBne_un); + AddJmpWithFlagSection(ctx, true); + break; + case icBlt: + case icBlt_s: + AddCmpSection(ctx, icBlt); + AddJmpWithFlagSection(ctx, true); + break; + case icBlt_un: + case icBlt_un_s: + AddCmpSection(ctx, icBlt_un); + AddJmpWithFlagSection(ctx, true); + break; + case icBle: + case icBle_s: + AddCmpSection(ctx, icBle); + AddJmpWithFlagSection(ctx, true); + break; + case icBle_un: + case icBle_un_s: + AddCmpSection(ctx, icBle_un); + AddJmpWithFlagSection(ctx, true); + break; + case icBgt: + case icBgt_s: + AddCmpSection(ctx, icBgt); + AddJmpWithFlagSection(ctx, true); + break; + case icBgt_un: + case icBgt_un_s: + AddCmpSection(ctx, icBgt_un); + AddJmpWithFlagSection(ctx, true); + break; + case icBge: + case icBge_s: + AddCmpSection(ctx, icBge); + AddJmpWithFlagSection(ctx, true); + break; + case icBge_un: + case icBge_un_s: + AddCmpSection(ctx, icBge_un); + AddJmpWithFlagSection(ctx, true); + break; + case icBrtrue: + case icBrtrue_s: + AddJmpWithFlagSection(ctx, true); + break; + case icBrfalse: + case icBrfalse_s: + AddJmpWithFlagSection(ctx, false); + break; + case icLeave: + case icLeave_s: + AddVMCommand(ctx, icLdc_i4, static_cast<uint32_t>(operand_value_ - ctx.file->image_base())); + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icLeave, 0); + break; + case icSwitch: + AddVMCommand(ctx, icDup, 0); + AddVMCommand(ctx, icLdc_i4, operand_value_); + AddCmpSection(ctx, icBlt_un); + AddJmpWithFlagSection(ctx, true); + + AddVMCommand(ctx, icPop, 0, voLinkCommand); + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icBr, 0); + + AddVMCommand(ctx, icLdc_i4, 2, voLinkCommand); + AddVMCommand(ctx, icShl, 0); + AddVMCommand(ctx, icLdc_i4, 0, voLinkCommand); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icLdmem_i4, 0); + AddVMCommand(ctx, icBr, 0); + break; + case icCase: + AddVMCommand(ctx, icDword, 0, voLinkCommand); + break; + case icEndfinally: + AddVMCommand(ctx, icEndfinally, 0); + break; + case icEndfilter: + AddVMCommand(ctx, icEndfilter, 0); + break; + case icRet: + if (operand_value_) { + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icBox, 0); + } + else + AddVMCommand(ctx, icLdnull, 0); + + AddVMCommand(ctx, icLdc_i4, 0); + if ((ctx.options.flags & cpMemoryProtection) && owner()->tag() != ftLoader) { + ILVMCommand *vm_command = AddVMCommand(ctx, icLdc_i4, 0); + uint64_t address = ctx.runtime->export_list()->GetAddressByType(atRandom); + ICommand *to_command = ctx.file->function_list()->GetCommandByAddress(address, true); + internal_links_.Add(vlNone, vm_command, to_command); + AddVMCommand(ctx, icCallvm, 0); + AddVMCommand(ctx, icLdc_i4, rand32()); + AddVMCommand(ctx, icAdd, 0); + vm_command = AddVMCommand(ctx, icLdc_i4, 0); + internal_links_.Add(vlCRCTableCount, vm_command, NULL); + AddVMCommand(ctx, icRem_un, 0); + AddVMCommand(ctx, icLdc_i4, sizeof(CRCInfo::POD)); + AddVMCommand(ctx, icMul, 0); + vm_command = AddVMCommand(ctx, icLdc_i4, 0); + internal_links_.Add(vlCRCTableAddress, vm_command, NULL); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icStarg, param_); + AddVMCommand(ctx, icLdarg, param_); + AddVMCommand(ctx, icLdmem_i4, 0); + AddCryptorSection(ctx, ctx.file->function_list()->crc_cryptor(), true); + AddVMCommand(ctx, icLdarg, param_); + AddVMCommand(ctx, icLdc_i4, offsetof(CRCInfo::POD, size)); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icLdmem_i4, 0); + AddCryptorSection(ctx, ctx.file->function_list()->crc_cryptor(), true); + vm_command = AddVMCommand(ctx, icLdc_i4, 0); + address = ctx.runtime->export_list()->GetAddressByType(atCalcCRC); + to_command = ctx.file->function_list()->GetCommandByAddress(address, true); + internal_links_.Add(vlNone, vm_command, to_command); + AddVMCommand(ctx, icCallvm, 0); + AddVMCommand(ctx, icLdarg, param_); + AddVMCommand(ctx, icLdc_i4, offsetof(CRCInfo::POD, hash)); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icLdmem_i4, 0); + AddVMCommand(ctx, icAdd, 0); + AddVMCommand(ctx, icAdd, 0); + } + AddVMCommand(ctx, icBr, 0); + break; + case icThrow: + AddVMCommand(ctx, icThrow, 0); + break; + case icRethrow: + AddVMCommand(ctx, icRethrow, 0); + break; + case icCastclass: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icCastclass, 0); + break; + case icIsinst: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icIsinst, 0); + break; + case icCkfinite: + AddVMCommand(ctx, icCkfinite, 0); + break; + case icLocalloc: + AddVMCommand(ctx, icLocalloc, 0); + break; + case icSizeof: + AddVMCommand(ctx, icLdc_i4, operand_value_, 0, token_reference_); + AddVMCommand(ctx, icSizeof, 0); + break; + default: + throw std::runtime_error("Runtime error at CompileToVM: " + text()); + } +} + +void ILCommand::AddExtSection(const CompileContext &ctx) +{ + ext_vm_entry_ = AddVMCommand(ctx, icLdc_i4, 0); + AddVMCommand(ctx, icPop, 0); +} + +void ILCommand::AddCryptorSection(const CompileContext &ctx, ValueCryptor *cryptor, bool is_decrypt) +{ + if (!cryptor) + return; + + CompileContext new_ctx = ctx; + new_ctx.options.flags &= ~cpMemoryProtection; + + for (size_t i = 0; i < cryptor->count(); i++) { + ValueCommand *value_command = cryptor->item(i); + AddVMCommand(new_ctx, icLdc_i4, value_command->value()); + switch (value_command->type(is_decrypt)) { + case ccDec: + AddVMCommand(new_ctx, icSub, 0); + break; + case ccInc: + AddVMCommand(new_ctx, icAdd, 0); + break; + case ccSub: + AddVMCommand(new_ctx, icSub, 0); + break; + case ccAdd: + AddVMCommand(new_ctx, icAdd, 0); + break; + case ccXor: + AddVMCommand(new_ctx, icXor, 0); + break; + default: + throw 1; + } + } +} + +/** +* ILVMCommand +*/ + +ILVMCommand::ILVMCommand(ILCommand *owner, ILCommandType command_type, uint64_t value, TokenReference *token_reference) + : BaseVMCommand(owner), command_type_(command_type), value_(value), token_reference_(token_reference), address_(0), + crypt_command_(icUnknown), crypt_size_(osDWord), crypt_key_(0), link_command_(NULL) +{ + +} + +void ILVMCommand::Compile() +{ + reinterpret_cast<ILVirtualMachine *>(owner()->block()->virtual_machine())->CompileCommand(*this); +} + +void ILVMCommand::WriteToFile(IArchitecture &file) +{ + if (!dump_.size()) + return; + + file.Write(dump_.data(), dump_.size()); +} + +/** + * ILFunction + */ + +ILFunction::ILFunction(IFunctionList *owner, const FunctionName &name, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder) + : BaseFunction(owner, name, compilation_type, compilation_options, need_compile, folder) +{ + +} + +ILFunction::ILFunction(IFunctionList *owner /*= NULL*/) + : BaseFunction(owner, FunctionName(""), ctVirtualization, 0, true, NULL) +{ + +} + +ILFunction::ILFunction(IFunctionList *owner, OperandSize cpu_address_size, IFunction *parent) + : BaseFunction(owner, cpu_address_size, parent) +{ + +} + +ILFunction::ILFunction(IFunctionList *owner, const ILFunction &src) + : BaseFunction(owner, src) +{ + +} + +bool ILFunction::Prepare(const CompileContext &ctx) +{ + size_t i, j; + + if (type() == otString) { + IArchitecture *file = from_runtime() ? ctx.runtime : ctx.file; + MapFunction *map_function = file->map_function_list()->GetFunctionByAddress(address()); + if (map_function) { + uint64_t address = ctx.runtime->export_list()->GetAddressByType(atDecryptStringA); + if (!address) + return false; + + NETRuntimeFunctionList *runtime_function_list = reinterpret_cast<NETRuntimeFunctionList *>(ctx.file->runtime_function_list()); + ILMetaData *meta = reinterpret_cast<ILMetaData *>(ctx.runtime->command_list()); + ILMethodDef *decrypt_method = meta->GetMethod(address); + if (!decrypt_method) + return false; + + ILFunction *decrypt_func = reinterpret_cast<ILFunction*>(ctx.runtime->function_list()->GetFunctionByAddress(address)); + if (!decrypt_func) + return false; + + size_t orig_count = count(); + ILTable *table = meta->table(ttMethodDef); + for (i = 0; i < orig_count; i++) { + ILMethodDef *method = reinterpret_cast<ILMethodDef*>(decrypt_method->Clone(meta, table)); + method->set_deleted(false); + method->declaring_type()->AddMethod(method); + + size_t old_count = count(); + for (j = 0; j < decrypt_func->count(); j++) { + ILCommand *src_command = decrypt_func->item(j); + ILCommand *dst_command = reinterpret_cast<ILCommand*>(src_command->Clone(this)); + dst_command->set_address(0); + if (static_cast<uint32_t>(dst_command->operand_value()) == FACE_STORAGE_INFO) + dst_command->set_operand_value(0, item(i)->address() - ctx.file->image_base()); + AddObject(dst_command); + + CommandLink *src_link = src_command->link(); + if (src_link) { + CommandLink *dst_link = src_link->Clone(link_list()); + dst_link->set_from_command(dst_command); + link_list()->AddObject(dst_link); + + if (src_link->parent_command()) + dst_link->set_parent_command(GetCommandByAddress(src_link->parent_command()->address())); + } + + if (dst_command->token_reference()) { + TokenReference *token_reference = dst_command->token_reference()->Clone(dst_command->token_reference()->owner()); + token_reference->owner()->AddObject(token_reference); + dst_command->set_token_reference(token_reference); + } + } + + for (j = 0; j < decrypt_func->function_info_list()->count(); j++) { + FunctionInfo *src_info = decrypt_func->function_info_list()->item(j); + FunctionInfo *dst_info = src_info->Clone(function_info_list()); + function_info_list()->AddObject(dst_info); + if (dst_info->entry()) + dst_info->set_entry(item(old_count + decrypt_func->IndexOf(dst_info->entry()))); + dst_info->set_source(runtime_function_list->Add(0, 0, 0, method)); + } + + AddressRange *address_range = function_info_list()->item(0)->Add(0, 0, NULL, NULL, NULL); + for (j = old_count; j < count(); j++) { + ILCommand *command = item(j); + command->set_address_range(address_range); + command->CompileToNative(); + } + + ILCommand *src_command = item(i); + for (j = 0; j < map_function->reference_list()->count(); j++) { + Reference *reference = map_function->reference_list()->item(j); + if (reference->operand_address() != src_command->address()) + continue; + + address = reference->address(); + ILCommand *command = reinterpret_cast<ILCommand *>(ctx.file->function_list()->GetCommandByAddress(address, true)); + if (!command) { + if (!ctx.file->AddressSeek(address)) + return false; + + CommandBlock *block = AddBlock(count(), true); + block->set_address(address); + + command = Add(address); + command->ReadFromFile(*file); + command->set_block(block); + command->exclude_option(roClearOriginalCode); + } + if (command->token_reference()) + command->token_reference()->set_deleted(true); + command->Init(icCall, method->id()); + command->set_token_reference(method->reference_list()->Add(address + 1)); + command->CompileToNative(); + } + } + } + } + else { + for (i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + if (!info->source()) + continue; + + std::map<size_t, size_t> variable_map; + NETRuntimeFunction *runtime_func = reinterpret_cast<NETRuntimeFunction *>(info->source()); + + ILStandAloneSig *locals = runtime_func->method()->locals(); + std::vector<ILMethodDef *> method_list = runtime_func->method_list(); + if (locals) { + if (locals->reference_list()->count() > 1) { + ILStandAloneSig *old_locals = locals; + locals = locals->Clone(locals->meta(), locals->owner()); + locals->owner()->AddObject(locals); + locals->reference_list()->clear(); + for (j = 0; j < method_list.size(); j++) { + method_list[j]->set_locals(locals); + } + for (j = old_locals->reference_list()->count(); j > 0; j--) { + TokenReference *token_reference = old_locals->reference_list()->item(j - 1); + if (item(IndexOf(info->entry()) + 1)->token_reference() == token_reference) + token_reference->set_owner(locals->reference_list()); + } + } + } + else if (compilation_type() != ctVirtualization) { + ILData data; + data.push_back(stLocal); + data.push_back(0); + locals = runtime_func->method()->meta()->AddStandAloneSig(data); + for (j = 0; j < method_list.size(); j++) { + method_list[j]->set_locals(locals); + } + + ILCommand *command = new ILCommand(this, osDWord, icComment, 0); + size_t insert_index = IndexOf(info->entry()) + 1; + InsertObject(insert_index, command); + command->set_token_reference(locals->reference_list()->Add(0)); + command->set_address_range(info->entry()->address_range()); + uint32_t dump = 0; + command->set_dump(&dump, sizeof(dump)); + for (j = 0; j < block_list()->count(); j++) { + CommandBlock *block = block_list()->item(j); + if (block->start_index() >= insert_index) { + block->set_start_index(block->start_index() + 1); + block->set_end_index(block->end_index() + 1); + } + } + } + else + continue; + + if (compilation_type() != ctMutation) + locals->set_deleted(true); + + ILSignature *signature = locals->signature(); + size_t old_count = signature->count(); + ILElement *random_variable = new ILElement(locals->meta(), signature); + { + ILData data; + data.push_back(ELEMENT_TYPE_U4); + random_variable->Parse(data); + } + random_variable->set_is_predicate(true); + signature->AddObject(random_variable); + + std::vector<ILElement *> element_list; + std::vector<size_t> index_list; + while (signature->count()) { + ILElement *element = signature->item(0); + signature->RemoveObject(element); + index_list.push_back(element_list.size()); + element_list.push_back(element); + } + + for (j = 0; j < index_list.size(); j++) { + std::swap(index_list[j], index_list[rand() % index_list.size()]); + } + + for (j = 0; j < index_list.size(); j++) { + size_t old_index = index_list[j]; + if (old_index < old_count) + variable_map[old_index] = j; + signature->AddObject(element_list[old_index]); + } + + if (variable_map.empty()) + continue; + + std::map<size_t, size_t>::const_iterator it; + for (j = IndexOf(info->entry()) + 2; j < count(); j++) { + ILCommand *command = item(j); + switch (command->type()) { + case icLdloc: + case icLdloc_s: + it = variable_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icLdloc, it->second); + command->CompileToNative(); + break; + case icLdloca: + case icLdloca_s: + it = variable_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icLdloca, it->second); + command->CompileToNative(); + break; + case icStloc: + case icStloc_s: + it = variable_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icStloc, it->second); + command->CompileToNative(); + break; + case icLdloc_0: + it = variable_map.find(0); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icLdloc, it->second); + command->CompileToNative(); + break; + case icLdloc_1: + it = variable_map.find(1); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icLdloc, it->second); + command->CompileToNative(); + break; + case icLdloc_2: + it = variable_map.find(2); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icLdloc, it->second); + command->CompileToNative(); + break; + case icLdloc_3: + it = variable_map.find(3); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icLdloc, it->second); + command->CompileToNative(); + break; + case icStloc_0: + it = variable_map.find(0); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icStloc, it->second); + command->CompileToNative(); + break; + case icStloc_1: + it = variable_map.find(1); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icStloc, it->second); + command->CompileToNative(); + break; + case icStloc_2: + it = variable_map.find(2); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icStloc, it->second); + command->CompileToNative(); + break; + case icStloc_3: + it = variable_map.find(3); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->Init(icStloc, it->second); + command->CompileToNative(); + break; + } + + if (command->is_data() || command->type() == icComment) + break; + } + } + } + + if (tag() == ftProcessor) { + if (ctx.runtime) + return true; + } + + return BaseFunction::Prepare(ctx); +} + +void ILFunction::CompileLinks(const CompileContext &ctx) +{ + BaseFunction::CompileLinks(ctx); +} + +void ILFunction::CompileInfo(const CompileContext &ctx) +{ + BaseFunction::CompileInfo(ctx); + + size_t i; + FunctionInfo *info; + AddressRange *range; + ILCommand *command; + + for (i = 0; i < function_info_list()->count(); i++) { + info = function_info_list()->item(i); + if (!info->begin()) + continue; + + if (info->entry()) { + uint32_t code_size = static_cast<uint32_t>(info->end() - info->begin()); + command = reinterpret_cast<ILCommand *>(info->entry()); + Data data; + for (size_t k = 0; k < command->dump_size(); k++) { + data.PushByte(command->dump(k)); + } + if (command->dump_size() == 1) { + code_size--; + data[0] = CorILMethod_TinyFormat | (code_size << CorILMethod_FormatShift); + } else { + code_size -= (data[1] >> 4) * sizeof(uint32_t); + data.WriteDWord(offsetof(IMAGE_COR_ILMETHOD_FAT, CodeSize), code_size); + } + command->set_dump(data.data(), data.size()); + } + } + + for (i = 0; i < range_list()->count(); i++) { + range = range_list()->item(i); + info = function_info_list()->GetItemByAddress(range->begin()); + if (!info) + continue; + + uint64_t base_value = info->begin() + info->base_value(); + + if (range->begin_entry()) { + command = reinterpret_cast<ILCommand *>(range->begin_entry()); + command->set_operand_value(0, range->begin() - base_value); + command->CompileToNative(); + } + if (range->size_entry()) { + command = reinterpret_cast<ILCommand *>(range->size_entry()); + command->set_operand_value(0, range->end() - range->begin()); + command->CompileToNative(); + } + } +} + +void ILFunction::ReadFromBuffer(Buffer &buffer, IArchitecture &file) +{ + BaseFunction::ReadFromBuffer(buffer, file); +} + +void ILFunction::ParseBeginCommands(IArchitecture &) +{ + +} + +void ILFunction::ParseEndCommands(IArchitecture &file) +{ + if (type() != otString) { + size_t i; + size_t use_address_count = 0; + for (i = 0; i < file.map_function_list()->count(); i++) { + if (file.map_function_list()->item(i)->address() == address()) { + use_address_count++; + } + } + + if (use_address_count > 1) { + for (i = 0; i < count(); i++) { + item(i)->exclude_option(roClearOriginalCode); + } + } + } +} + +void ILFunction::CreateBlocks() +{ + CommandBlock *cur_block = NULL; + for (size_t i = 0; i < count(); i++) { + ILCommand *command = item(i); + if (command->block() || (command->options() & roNeedCompile) == 0) { + cur_block = NULL; + continue; + } + + if ((!cur_block || (command->options() & roCreateNewBlock) || item(cur_block->end_index())->is_data() != command->is_data())) + cur_block = AddBlock(i, true); + + cur_block->set_end_index(i); + + command->set_block(cur_block); + + if (command->is_end()) + cur_block = NULL; + } +} + +void ILFunction::CalcStack(std::map<ILCommand *, int> &stack_map) +{ + size_t i, j; + ILCommand *command, *entry, *link_command; + std::set<ILCommand *> entry_stack, link_list; + + for (i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + if (!info->source()) + continue; + + entry = reinterpret_cast<ILCommand *>(info->entry()); + entry_stack.insert(entry); + stack_map[entry] = 0; + } + for (i = 0; i < this->link_list()->count(); i++) { + CommandLink *link = this->link_list()->item(i); + switch (link->type()) { + case ltSEHBlock: + entry = reinterpret_cast<ILCommand *>(link->to_command()); + entry_stack.insert(entry); + stack_map[entry] = 1; + break; + case ltFinallyBlock: + entry = reinterpret_cast<ILCommand *>(link->to_command()); + entry_stack.insert(entry); + stack_map[entry] = 0; + break; + } + } + + int stack; + while (!entry_stack.empty()) { + entry = *entry_stack.begin(); + j = IndexOf(entry); + std::map<ILCommand *, int>::const_iterator s = stack_map.find(entry); + if (s == stack_map.end()) + throw std::runtime_error("Incorrect stack"); + stack = s->second; + for (i = j; i < count(); i++) { + command = item(i); + std::set<ILCommand *>::const_iterator c = entry_stack.find(command); + if (c != entry_stack.end()) + entry_stack.erase(c); + + if (command->type() == icComment || command->type() == icCase || command->is_data()) + continue; + + s = stack_map.find(command); + if (s != stack_map.end()) { + if (s->second != stack) + throw std::runtime_error("Incorrect stack"); + } + else + stack_map[command] = stack; + + stack += command->GetStackLevel(); + + link_list.clear(); + if (command->type() == icSwitch) { + size_t case_count = static_cast<uint32_t>(command->operand_value()); + for (j = 0; j < case_count; j++) { + ILCommand *case_command = item(i + 1 + j); + link_list.insert(reinterpret_cast<ILCommand *>(case_command->link()->to_command())); + } + } + else { + if (command->link() && (command->link()->type() == ltJmp || command->link()->type() == ltJmpWithFlag)) + link_list.insert(reinterpret_cast<ILCommand *>(command->link()->to_command())); + } + for (std::set<ILCommand *>::const_iterator l = link_list.begin(); l != link_list.end(); l++) { + link_command = *l; + s = stack_map.find(link_command); + if (s != stack_map.end()) { + if (s->second != stack) + throw std::runtime_error("Incorrect stack"); + } + else { + entry_stack.insert(link_command); + stack_map[link_command] = stack; + } + } + + if (command->is_end()) + break; + } + } +} + +void ILFunction::Mutate(const CompileContext &ctx) +{ + size_t i, j, index; + ILCommand *command, *insert_command, *entry; + std::map<ILCommand *, ILSignature *> variables_map; + uint32_t value, old_value, bit_mask; + std::map<ILCommand *, int> stack_map; + + for (i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + if (!info->source()) + continue; + + ILStandAloneSig *locals = reinterpret_cast<NETRuntimeFunction *>(info->source())->method()->locals(); + entry = reinterpret_cast<ILCommand *>(info->entry()); + variables_map[entry] = locals ? locals->signature() : NULL; + stack_map[entry] = 0; + } + + CalcStack(stack_map); + + int stack; + std::list<ICommand *> new_command_list; + std::vector<ILCommand *> insert_command_list; + std::vector<size_t> predicate_list; + std::map<size_t, uint32_t> value_list; + std::map<ILCommand *, std::map<size_t, uint32_t> > value_list_map; + ILSignature *variables = NULL; + size_t orig_count = count(); + std::vector<CommandLink *> insert_link_list; + for (i = 0; i < orig_count; i++) { + command = item(i); + new_command_list.push_back(command); + + if ((command->options() & roNoProgress) == 0) + ctx.file->StepProgress(); + + if (is_breaked_address(command->address())) + continue; + + if (command->block()) { + CommandBlock *block = command->block(); + size_t insert_count = new_command_list.size() - 1 - i; + for (j = block->start_index() + 1; j <= block->end_index(); j++) { + new_command_list.push_back(item(j)); + } + i = block->end_index(); + if (insert_count) { + block->set_start_index(block->start_index() + insert_count); + block->set_end_index(block->end_index() + insert_count); + } + ctx.file->StepProgress(block->end_index() - block->start_index()); + continue; + } + else if ((command->options() & roNeedCompile) == 0) + continue; + + std::map<ILCommand *, ILSignature *>::const_iterator it = variables_map.find(command); + if (it != variables_map.end()) { + predicate_list.clear(); + variables = it->second; + if (variables) { + for (j = 0; j < variables->count(); j++) { + ILElement *variable = variables->item(j); + if (variable->is_predicate()) + predicate_list.push_back(j); + } + } + } + + if (command->type() == icComment || command->type() == icCase || command->is_data()) + continue; + + insert_command_list.clear(); + new_command_list.pop_back(); + AddressRange *address_range = command->address_range(); + ILCommand *link_command = (command->link() && (command->link()->type() == ltJmp || command->link()->type() == ltJmpWithFlag)) ? reinterpret_cast<ILCommand *>(command->link()->to_command()) : NULL; + + if (command->section_options() & (rtLinkedToInt | rtLinkedToExt)) { + std::map<size_t, uint32_t> dst_value_list; + if ((command->section_options() & rtLinkedToExt) == 0) { + std::map<ILCommand *, std::map<size_t, uint32_t> >::iterator it = value_list_map.find(command); + if (it != value_list_map.end()) { + dst_value_list = it->second; + if (!new_command_list.empty() && !new_command_list.back()->is_end()) { + for (std::map<size_t, uint32_t>::const_iterator d = dst_value_list.begin(); d != dst_value_list.end(); d++) { + index = d->first; + value = d->second; + std::map<size_t, uint32_t>::const_iterator v = value_list.find(index); + if (v == value_list.end()) { + insert_command_list.push_back(AddCommand(icLdc_i4, value)); + } + else { + insert_command_list.push_back(AddCommand(icLdloc, index)); + old_value = v->second; + if (rand() & 1) { + insert_command_list.push_back(AddCommand(icLdc_i4, value - old_value)); + insert_command_list.push_back(AddCommand(icAdd, 0)); + } + else { + insert_command_list.push_back(AddCommand(icLdc_i4, value ^ old_value)); + insert_command_list.push_back(AddCommand(icXor, 0)); + } + } + insert_command_list.push_back(AddCommand(icStloc, index)); + } + } + for (j = 0; j < insert_command_list.size(); j++) { + insert_command = insert_command_list[j]; + insert_command->set_address_range(address_range); + insert_command->CompileToNative(); + insert_command->include_option(roNoProgress); + new_command_list.push_back(insert_command); + } + if (!insert_command_list.empty()) { + insert_command = insert_command_list[0]; + for (j = 0; j < link_list()->count(); j++) { + CommandLink *link = link_list()->item(j); + if (link->next_command() == command) + link->set_next_command(insert_command); + } + } + insert_command_list.clear(); + } + else if (!value_list.empty()) { + value_list_map[command] = value_list; + dst_value_list = value_list; + } + } + value_list = dst_value_list; + } + + if (!predicate_list.empty() && !command->is_end()) { + if (rand() & 1) { + // modify predicate + value = rand32(); + bit_mask = 0x1f; + index = predicate_list[rand() % predicate_list.size()]; + std::map<size_t, uint32_t>::const_iterator it = value_list.find(index); + if (it != value_list.end()) { + old_value = it->second; + if (rand() & 1) { + insert_command_list.push_back(AddCommand(icLdc_i4, value)); + insert_command_list.push_back(AddCommand(icLdloc, index)); + } + else { + insert_command_list.push_back(AddCommand(icLdloc, index)); + insert_command_list.push_back(AddCommand(icLdc_i4, value)); + std::swap(value, old_value); + } + switch (rand() % (8 + (old_value != 0 ? 2 : 0))) { + case 0: + value += old_value; + insert_command_list.push_back(AddCommand(icAdd, 0)); + break; + case 1: + value -= old_value; + insert_command_list.push_back(AddCommand(icSub, 0)); + break; + case 2: + old_value &= bit_mask; + if (insert_command_list.back()->type() == icLdc_i4) + insert_command_list.back()->set_operand_value(0, old_value); + else { + insert_command_list.push_back(AddCommand(icLdc_i4, bit_mask)); + insert_command_list.push_back(AddCommand(icAnd, 0)); + } + value >>= old_value; + insert_command_list.push_back(AddCommand(icShr_un, 0)); + break; + case 3: + old_value &= bit_mask; + if (insert_command_list.back()->type() == icLdc_i4) + insert_command_list.back()->set_operand_value(0, old_value); + else { + insert_command_list.push_back(AddCommand(icLdc_i4, bit_mask)); + insert_command_list.push_back(AddCommand(icAnd, 0)); + } + value <<= old_value; + insert_command_list.push_back(AddCommand(icShl, 0)); + break; + case 4: + value |= old_value; + insert_command_list.push_back(AddCommand(icOr, 0)); + break; + case 5: + value &= old_value; + insert_command_list.push_back(AddCommand(icAnd, 0)); + break; + case 6: + value *= old_value; + insert_command_list.push_back(AddCommand(icMul, 0)); + break; + case 8: + value /= old_value; + insert_command_list.push_back(AddCommand(icDiv_un, 0)); + break; + case 9: + value %= old_value; + insert_command_list.push_back(AddCommand(icRem_un, 0)); + break; + default: + value ^= old_value; + insert_command_list.push_back(AddCommand(icXor, 0)); + break; + } + } + else { + insert_command_list.push_back(AddCommand(icLdc_i4, value)); + } + insert_command_list.push_back(AddCommand(icStloc, index)); + value_list[index] = value; + } + } + + if (!value_list.empty()) { + index = NOT_ID; + for (std::map<size_t, uint32_t>::const_iterator it = value_list.begin(); it != value_list.end(); it++) { + index = it->first; + if (rand() & 1) + break; + } + value = value_list[index]; + if (command->link() == NULL && (command->type() == icLdc_i4 || command->type() == icLdc_i4_s + || command->type() == icLdc_i4_0 || command->type() == icLdc_i4_1 || command->type() == icLdc_i4_2 || command->type() == icLdc_i4_3 + || command->type() == icLdc_i4_4 || command->type() == icLdc_i4_5 || command->type() == icLdc_i4_6 || command->type() == icLdc_i4_7 + || command->type() == icLdc_i4_8 || command->type() == icLdc_i4_m1)) { + switch (command->type()) { + case icLdc_i4_0: + old_value = 0; + break; + case icLdc_i4_1: + old_value = 1; + break; + case icLdc_i4_2: + old_value = 2; + break; + case icLdc_i4_3: + old_value = 3; + break; + case icLdc_i4_4: + old_value = 4; + break; + case icLdc_i4_5: + old_value = 5; + break; + case icLdc_i4_6: + old_value = 6; + break; + case icLdc_i4_7: + old_value = 7; + break; + case icLdc_i4_8: + old_value = 8; + break; + case icLdc_i4_m1: + old_value = static_cast<uint32_t>(-1); + break; + case icLdc_i4_s: + old_value = static_cast<int8_t>(command->operand_value()); + break; + default: + old_value = static_cast<uint32_t>(command->operand_value()); + break; + } + + insert_command_list.push_back(AddCommand(icLdloc, index)); + switch (rand() & 3) { + case 0: + insert_command_list.push_back(AddCommand(icLdc_i4, old_value - value)); + insert_command_list.push_back(AddCommand(icAdd, 0)); + break; + case 1: + insert_command_list.push_back(AddCommand(icLdc_i4, value - old_value)); + insert_command_list.push_back(AddCommand(icSub, 0)); + break; + default: + insert_command_list.push_back(AddCommand(icLdc_i4, old_value ^ value)); + insert_command_list.push_back(AddCommand(icXor, 0)); + break; + } + + command->clear(); + command->Init(icNop); + } + else if (rand() & 1) { + stack = stack_map[command]; + if (stack < 1) + { + ILCommand *random_command = NULL; + for (j = 0; j < orig_count; j++) { + insert_command = item(j); + if (insert_command->type() == icComment || insert_command->type() == icCase || insert_command->is_data()) + continue; + if (insert_command != command && insert_command->address_range() == address_range) { + if (stack == stack_map[insert_command]) { + random_command = insert_command; + if (rand() & 1) + break; + } + } + while (insert_command->is_prefix() && j < orig_count) { + insert_command = item(++j); + } + } + + if (random_command) { + old_value = rand32(); + bit_mask = 0x1f; + if (rand() & 1) { + insert_command_list.push_back(AddCommand(icLdloc, index)); + insert_command_list.push_back(AddCommand(icLdc_i4, old_value)); + } + else { + insert_command_list.push_back(AddCommand(icLdc_i4, old_value)); + insert_command_list.push_back(AddCommand(icLdloc, index)); + std::swap(value, old_value); + } + + ILCommandType branch_type; + if (rand() & 1) { + switch (rand() % 3) { + case 0: + branch_type = (value < old_value) ? icBge_un : icBlt_un; + break; + case 1: + branch_type = (value > old_value) ? icBle_un : icBgt_un; + break; + default: + branch_type = (value != old_value) ? icBeq : icBne_un; + break; + } + } + else { + switch (rand() % (8 + (old_value != 0 ? 2 : 0))) { + case 0: + value += old_value; + insert_command_list.push_back(AddCommand(icAdd, 0)); + break; + case 1: + value -= old_value; + insert_command_list.push_back(AddCommand(icSub, 0)); + break; + case 2: + old_value &= bit_mask; + if (insert_command_list.back()->type() == icLdc_i4) + insert_command_list.back()->set_operand_value(0, old_value); + else { + insert_command_list.push_back(AddCommand(icLdc_i4, bit_mask)); + insert_command_list.push_back(AddCommand(icAnd, 0)); + } + value >>= old_value; + insert_command_list.push_back(AddCommand(icShr_un, 0)); + break; + case 3: + old_value &= bit_mask; + if (insert_command_list.back()->type() == icLdc_i4) + insert_command_list.back()->set_operand_value(0, old_value); + else { + insert_command_list.push_back(AddCommand(icLdc_i4, bit_mask)); + insert_command_list.push_back(AddCommand(icAnd, 0)); + } + value <<= old_value; + insert_command_list.push_back(AddCommand(icShl, 0)); + break; + case 5: + value &= old_value; + insert_command_list.push_back(AddCommand(icAnd, 0)); + break; + case 6: + value *= old_value; + insert_command_list.push_back(AddCommand(icMul, 0)); + break; + case 8: + value /= old_value; + insert_command_list.push_back(AddCommand(icDiv_un, 0)); + break; + case 9: + value %= old_value; + insert_command_list.push_back(AddCommand(icRem_un, 0)); + break; + default: + value ^= old_value; + insert_command_list.push_back(AddCommand(icXor, 0)); + break; + } + branch_type = value ? icBrfalse : icBrtrue; + } + insert_command = AddCommand(branch_type, 0); + insert_link_list.push_back(insert_command->AddLink(0, ltJmpWithFlag, random_command)); + insert_command_list.push_back(insert_command); + } + } + } + } + + if (command->type() == icSwitch) { + size_t case_count = static_cast<uint32_t>(command->operand_value()); + std::set<ILCommand *> link_command_list; + for (j = 0; j < case_count; j++) { + ILCommand *case_command = item(i + 1 + j); + link_command_list.insert(reinterpret_cast<ILCommand *>(case_command->link()->to_command())); + } + for (std::set<ILCommand *>::const_iterator l = link_command_list.begin(); l != link_command_list.end(); l++) { + link_command = *l; + if (link_command && (link_command->section_options() & rtLinkedToExt) == 0) { + std::map<ILCommand *, std::map<size_t, uint32_t> >::const_iterator it = value_list_map.find(link_command); + if (it == value_list_map.end()) + value_list_map[link_command] = value_list; + else + value_list_map.erase(it); + } + } + } else if (link_command && (link_command->section_options() & rtLinkedToExt) == 0) { + std::map<ILCommand *, std::map<size_t, uint32_t> >::const_iterator it = value_list_map.find(link_command); + if (it == value_list_map.end()) + value_list_map[link_command] = value_list; + else { + // syncronize predicates + std::map<size_t, uint32_t> dst_value_list = it->second; + for (std::map<size_t, uint32_t>::const_iterator d = dst_value_list.begin(); d != dst_value_list.end(); d++) { + index = d->first; + value = d->second; + std::map<size_t, uint32_t>::const_iterator v = value_list.find(index); + if (v == value_list.end()) { + insert_command_list.push_back(AddCommand(icLdc_i4, value)); + } + else { + insert_command_list.push_back(AddCommand(icLdloc, index)); + old_value = v->second; + if (rand() & 1) { + insert_command_list.push_back(AddCommand(icLdc_i4, value - old_value)); + insert_command_list.push_back(AddCommand(icAdd, 0)); + } + else { + insert_command_list.push_back(AddCommand(icLdc_i4, value ^ old_value)); + insert_command_list.push_back(AddCommand(icXor, 0)); + } + } + insert_command_list.push_back(AddCommand(icStloc, index)); + value_list[index] = value; + } + } + } + + if (!insert_command_list.empty()) { + if (command->type() == icNop) { + new_command_list.push_back(command); + command = NULL; + } else if (command->section_options() & (rtLinkedToInt | rtLinkedToExt)) { + insert_command = command->Clone(this); + if (command->link()) + command->link()->set_from_command(insert_command); + command->clear(); + command->Init(icNop); + new_command_list.push_back(command); + command = insert_command; + } + + for (j = 0; j < insert_command_list.size(); j++) { + insert_command = insert_command_list[j]; + insert_command->set_address_range(address_range); + insert_command->CompileToNative(); + new_command_list.push_back(insert_command); + } + } + if (command) { + new_command_list.push_back(command); + while (command->is_prefix() && i < orig_count) { + command = item(++i); + new_command_list.push_back(command); + } + if (command->is_end()) + value_list.clear(); + } + } + + assign(new_command_list); + + for (i = 0; i < insert_link_list.size(); i++) { + insert_link_list[i]->from_command()->PrepareLink(ctx); + } +} + +void ILFunction::CompileToNative(const CompileContext &ctx) +{ + size_t i, j, k; + ILCommand *command; + uint16_t variable_index; + uint16_t add_stack = (compilation_type() == ctMutation) ? 20 : 0; + + for (i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + ILCommand *entry = reinterpret_cast<ILCommand *>(info->entry()); + if (entry) { + ILStandAloneSig *locals = reinterpret_cast<NETRuntimeFunction *>(info->source())->method()->locals(); + Data data; + if (entry->dump_size() == 1) { + data.PushByte(CorILMethod_InitLocals | CorILMethod_FatFormat); + data.PushByte(0x30); + data.PushWord(0x08 + add_stack); + } + else { + data.PushByte(entry->dump(0)); + data.PushByte(entry->dump(1)); + data.PushWord(static_cast<uint16_t>(entry->dump_value(2, osWord)) + add_stack); + } + data.PushDWord(0x0); + if (!locals) + data.PushDWord(0x0); + entry->set_dump(data.data(), data.size()); + } + + ILCommand *data_entry = reinterpret_cast<ILCommand *>(info->data_entry()); + if (!data_entry) + continue; + + uint32_t flags = static_cast<uint32_t>(data_entry->operand_value()); + bool fat = (flags & CorILMethod_Sect_FatFormat) != 0; + if (fat) + continue; + + if (flags & CorILMethod_Sect_EHTable) { + // convert EHTable to fat format + uint32_t data_size = fat ? (flags >> 8) : static_cast<uint8_t>(flags >> 8); + uint32_t clauses = (data_size - sizeof(uint32_t)) / (fat ? 24 : 12); + k = IndexOf(data_entry) + 1; + for (j = 0; j < clauses * 6; j++) { + command = item(k + j); + command->Init(icDword, command->operand_value(), command->token_reference()); + command->CompileToNative(); + } + data_size = sizeof(uint32_t) + clauses * 6 * sizeof(uint32_t); + data_entry->set_operand_value(0, (data_size << 8) | (flags & 0xff) | CorILMethod_Sect_FatFormat); + data_entry->CompileToNative(); + } + } + + for (i = 0; i < count(); i++) { + command = item(i); + + switch (command->type()) { + case icBr_s: + command->Init(icBr, command->operand_value()); + command->CompileToNative(); + break; + case icBrfalse_s: + command->Init(icBrfalse, command->operand_value()); + command->CompileToNative(); + break; + case icBrtrue_s: + command->Init(icBrtrue, command->operand_value()); + command->CompileToNative(); + break; + case icBeq_s: + command->Init(icBeq, command->operand_value()); + command->CompileToNative(); + break; + case icBge_s: + command->Init(icBge, command->operand_value()); + command->CompileToNative(); + break; + case icBgt_s: + command->Init(icBgt, command->operand_value()); + command->CompileToNative(); + break; + case icBle_s: + command->Init(icBle, command->operand_value()); + command->CompileToNative(); + break; + case icBlt_s: + command->Init(icBlt, command->operand_value()); + command->CompileToNative(); + break; + case icBne_un_s: + command->Init(icBne_un, command->operand_value()); + command->CompileToNative(); + break; + case icBge_un_s: + command->Init(icBge_un, command->operand_value()); + command->CompileToNative(); + break; + case icBgt_un_s: + command->Init(icBgt_un, command->operand_value()); + command->CompileToNative(); + break; + case icBle_un_s: + command->Init(icBle_un, command->operand_value()); + command->CompileToNative(); + break; + case icBlt_un_s: + command->Init(icBlt_un, command->operand_value()); + command->CompileToNative(); + break; + case icLeave_s: + command->Init(icLeave, command->operand_value()); + command->CompileToNative(); + break; + case icLdloc: + variable_index = static_cast<uint16_t>(command->operand_value()); + switch (variable_index) { + case 0: + command->Init(icLdloc_0, 0); + command->CompileToNative(); + break; + case 1: + command->Init(icLdloc_1, 0); + command->CompileToNative(); + break; + case 2: + command->Init(icLdloc_2, 0); + command->CompileToNative(); + break; + case 3: + command->Init(icLdloc_3, 0); + command->CompileToNative(); + break; + default: + if (variable_index < 0x100) { + command->Init(icLdloc_s, variable_index); + command->CompileToNative(); + } + break; + } + break; + case icLdloca: + variable_index = static_cast<uint16_t>(command->operand_value()); + if (variable_index < 0x100) { + command->Init(icLdloca_s, variable_index); + command->CompileToNative(); + } + break; + case icStloc: + variable_index = static_cast<uint16_t>(command->operand_value()); + switch (variable_index) { + case 0: + command->Init(icStloc_0, 0); + command->CompileToNative(); + break; + case 1: + command->Init(icStloc_1, 0); + command->CompileToNative(); + break; + case 2: + command->Init(icStloc_2, 0); + command->CompileToNative(); + break; + case 3: + command->Init(icStloc_3, 0); + command->CompileToNative(); + break; + default: + if (variable_index < 0x100) { + command->Init(icStloc_s, variable_index); + command->CompileToNative(); + } + break; + } + break; + } + } + + CreateBlocks(); +} + +bool IsBoxedElementType(CorElementType type) +{ + switch (type) { + case ELEMENT_TYPE_BOOLEAN: case ELEMENT_TYPE_CHAR: case ELEMENT_TYPE_I1: case ELEMENT_TYPE_U1: + case ELEMENT_TYPE_I2: case ELEMENT_TYPE_U2: case ELEMENT_TYPE_I4: case ELEMENT_TYPE_U4: + case ELEMENT_TYPE_I8: case ELEMENT_TYPE_U8: case ELEMENT_TYPE_R4: case ELEMENT_TYPE_R8: + case ELEMENT_TYPE_I: case ELEMENT_TYPE_U: case ELEMENT_TYPE_VALUETYPE: + return true; + } + return false; +} + +void ILFunction::CompileToVM(const CompileContext &ctx) +{ + if (function_info_list()->count() == 0) + return; + + struct FunctionEntryInfo { + ILMethodDef *method; + ILToken *ret; + std::vector<ILElement *> param_list; + ILSignature *locals; + ILCommand *data_entry; + FunctionEntryInfo() + : method(NULL), ret(NULL), locals(NULL), data_entry(NULL) + { + + } + FunctionEntryInfo(ILMethodDef *method_, ILToken *ret_, std::vector<ILElement *> param_list_, ILSignature *locals_, ILCommand *data_entry_) + { + method = method_; + ret = ret_; + param_list = param_list_; + locals = locals_; + data_entry = data_entry_; + } + }; + + size_t i, j, c, k; + ILCommand *command, *data_entry; + CommandLink *link; + CommandBlock *cur_block; + std::string type_name; + ILToken *type, *type_ret; + ILSignature *locals; + ILMetaData *meta; + ILElement *element; + ILMethodDef *method; + std::map<ICommand *, FunctionEntryInfo> entry_map; + + // create internal links + c = link_list()->count(); + for (i = 0; i < count(); i++) { + command = item(i); + if (command->block() || (command->options() & roNeedCompile) == 0) + continue; + + switch (command->type()) { + case icSwitch: + command->AddLink(0, ltSwitch, item(i + 1)); + break; + } + } + for (i = c; i < link_list()->count(); i++) { + link_list()->item(i)->from_command()->PrepareLink(ctx); + } + + ILVirtualMachine *virtual_machine = reinterpret_cast<ILVirtualMachine *>(BaseFunction::virtual_machine(ctx.file->virtual_machine_list(), NULL)); + + for (k = 0; k < function_info_list()->count(); k++) { + FunctionInfo *info = function_info_list()->item(k); + if (!info->source() || info->entry()->block()) + continue; + + ICommand *entry = info->entry(); + data_entry = reinterpret_cast<ILCommand *>(info->data_entry()); + method = reinterpret_cast<NETRuntimeFunction *>(info->source())->method(); + ILSignature *signature = method->signature(); + if (!signature->ret()) + throw std::runtime_error("Invalid method signature"); + + locals = method->locals() ? method->locals()->signature() : NULL; + meta = method->meta(); + ILElement object_element(NULL, NULL); + { + ILData data; + data.push_back(ELEMENT_TYPE_OBJECT); + object_element.Parse(data); + } + + ILToken *type_object = meta->ImportType(object_element); + type_ret = (signature->ret()->type() == ELEMENT_TYPE_VOID) ? NULL : meta->ImportType(*signature->ret()); + + bool need_try_finally = false; + size_t try_start_index = 0; + size_t try_end_index = 0; + size_t finally_start_index = 0; + size_t finally_end_index = 0; + size_t newarr_index = 0; + + std::vector<ILElement *> param_list; + for (i = 0; i < signature->count(); i++) { + element = signature->item(i); + if (element->is_ref()) + need_try_finally = true; + param_list.push_back(element); + } + if ((method->flags() & mdStatic) == 0) + param_list.insert(param_list.begin(), &object_element); + + if (!method->is_deleted()) { + cur_block = AddBlock(count(), true); + + // header + Data data; + data.PushByte(CorILMethod_InitLocals | CorILMethod_FatFormat | (need_try_finally ? CorILMethod_MoreSects : 0)); + data.PushByte(0x30); + data.PushWord(0x08); + data.PushDWord(0x0); + command = AddCommand(data); + command->set_alignment(sizeof(uint32_t)); + + info = function_info_list()->Add(info->begin(), info->begin(), btValue, command->dump_size() + sizeof(uint32_t), 0, 0, info->source(), command); + + // locals + if (need_try_finally) { + ILData locals_data; + locals_data.push_back(stLocal); + locals_data.push_back(1 + ((signature->ret()->type() == ELEMENT_TYPE_VOID) ? 0 : 1)); + locals_data.push_back(ELEMENT_TYPE_SZARRAY); + locals_data.push_back(ELEMENT_TYPE_OBJECT); + if (signature->ret()->type() != ELEMENT_TYPE_VOID) + signature->ret()->WriteToData(locals_data); + ILStandAloneSig *new_locals = meta->AddStandAloneSig(locals_data); + command = AddCommand(icDword, new_locals->id()); + command->set_token_reference(new_locals->reference_list()->Add(0)); + } + else { + AddCommand(icDword, 0); + } + + newarr_index = count(); + if (!param_list.empty()) { + // load args + AddCommand(icLdc_i4, param_list.size()); + command = AddCommand(icNewarr, type_object->id()); + command->set_token_reference(type_object->reference_list()->Add(0)); + + for (i = 0; i < param_list.size(); i++) { + AddCommand(icDup, 0); + switch (i) { + case 0: AddCommand(icLdc_i4_0, 0); break; + case 1: AddCommand(icLdc_i4_1, 0); break; + case 2: AddCommand(icLdc_i4_2, 0); break; + case 3: AddCommand(icLdc_i4_3, 0); break; + case 4: AddCommand(icLdc_i4_4, 0); break; + case 5: AddCommand(icLdc_i4_5, 0); break; + case 6: AddCommand(icLdc_i4_6, 0); break; + case 7: AddCommand(icLdc_i4_7, 0); break; + case 8: AddCommand(icLdc_i4_8, 0); break; + default: AddCommand(icLdc_i4, i); break; + } + switch (i) { + case 0: AddCommand(icLdarg_0, 0); break; + case 1: AddCommand(icLdarg_1, 0); break; + case 2: AddCommand(icLdarg_2, 0); break; + case 3: AddCommand(icLdarg_3, 0); break; + default: AddCommand(icLdarg_s, i); break; + } + + element = param_list[i]; + if (element->is_ref()) { + switch (element->type()) { + case ELEMENT_TYPE_BOOLEAN: + case ELEMENT_TYPE_I1: + AddCommand(icLdind_i1, 0); + break; + case ELEMENT_TYPE_U1: + AddCommand(icLdind_u1, 0); + break; + case ELEMENT_TYPE_I2: + AddCommand(icLdind_i2, 0); + break; + case ELEMENT_TYPE_CHAR: + case ELEMENT_TYPE_U2: + AddCommand(icLdind_u2, 0); + break; + case ELEMENT_TYPE_I4: + AddCommand(icLdind_i4, 0); + break; + case ELEMENT_TYPE_U4: + AddCommand(icLdind_u4, 0); + break; + case ELEMENT_TYPE_I8: + AddCommand(icLdind_i8, 0); + break; + case ELEMENT_TYPE_R4: + AddCommand(icLdind_r4, 0); + break; + case ELEMENT_TYPE_R8: + AddCommand(icLdind_r8, 0); + break; + case ELEMENT_TYPE_I: + case ELEMENT_TYPE_U: + AddCommand(icLdind_i, 0); + break; + default: + AddCommand(icLdind_ref, 0); + break; + } + } + + type = meta->ImportType(*element); + if (element->type() == ELEMENT_TYPE_PTR) { + uint64_t address = ctx.vm_runtime->export_list()->GetAddressByType(atBoxPointer); + ILFunction *func = reinterpret_cast<ILFunction *>(ctx.vm_runtime->function_list()->GetFunctionByAddress(address)); + for (j = 0; j < func->count(); j++) { + ILCommand *src_command = func->item(j); + if (src_command->type() == icComment || src_command->type() == icLdarg_0) + continue; + if (src_command->type() == icRet) + break; + command = src_command->Clone(this); + if (command->type() == icLdtoken) { + command->set_operand_value(0, type->id()); + command->set_token_reference(type->reference_list()->Add(0)); + } else if (command->token_reference()) + command->set_token_reference(command->token_reference()->owner()->Add(0)); + AddObject(command); + } + } else if (IsBoxedElementType(element->type())) { + command = AddCommand(icBox, type->id()); + command->set_token_reference(type->reference_list()->Add(0)); + } + AddCommand(icStelem_ref, 0); + } + if (need_try_finally) + AddCommand(icStloc_0, 0); + } + + if (need_try_finally || param_list.empty()) { + try_start_index = count(); + command = AddCommand(icNewobj, virtual_machine->ctor()->id()); + command->set_token_reference(virtual_machine->ctor()->reference_list()->Add(0)); + if (param_list.empty()) + AddCommand(icLdnull, 0); + else + AddCommand(icLdloc_0, 0); + } + else { + command = new ILCommand(this, cpu_address_size(), icNewobj, virtual_machine->ctor()->id()); + command->set_token_reference(virtual_machine->ctor()->reference_list()->Add(0)); + InsertObject(newarr_index, command); + } + command = AddCommand(icLdc_i4, 0); + link = command->AddLink(0, ltOffset, entry); + entry->include_section_option(rtLinkedToExt); + link->set_sub_value(ctx.file->image_base()); + + command = AddCommand(icCall, virtual_machine->invoke()->id()); + command->set_token_reference(virtual_machine->invoke()->reference_list()->Add(0)); + + if (!type_ret) + AddCommand(icPop, 0); + else { + if (signature->ret()->type() == ELEMENT_TYPE_PTR) { + uint64_t address = ctx.vm_runtime->export_list()->GetAddressByType(atUnboxPointer); + ILFunction *func = reinterpret_cast<ILFunction *>(ctx.vm_runtime->function_list()->GetFunctionByAddress(address)); + for (j = 0; j < func->count(); j++) { + ILCommand *src_command = func->item(j); + if (src_command->type() == icComment || src_command->type() == icLdarg_0) + continue; + if (src_command->type() == icRet) + break; + command = src_command->Clone(this); + if (command->token_reference()) + command->set_token_reference(command->token_reference()->owner()->Add(0)); + AddObject(command); + } + } else { + command = AddCommand(IsBoxedElementType(signature->ret()->type()) ? icUnbox_any : icCastclass, type_ret->id()); + command->set_token_reference(type_ret->reference_list()->Add(0)); + } + if (need_try_finally) + AddCommand(icStloc_1, 0); + } + + if (need_try_finally) { + command = AddCommand(icLeave, 0); + command->AddLink(0, ltJmp); + try_end_index = count() - 1; + + if (!param_list.empty()) { + // save out args + finally_start_index = count(); + for (i = 0; i < param_list.size(); i++) { + element = param_list[i]; + if (!element->is_ref()) + continue; + + switch (i) { + case 0: AddCommand(icLdarg_0, 0); break; + case 1: AddCommand(icLdarg_1, 0); break; + case 2: AddCommand(icLdarg_2, 0); break; + case 3: AddCommand(icLdarg_3, 0); break; + default: AddCommand(icLdarg_s, i); break; + } + AddCommand(icLdloc_0, 0); + switch (i) { + case 0: AddCommand(icLdc_i4_0, 0); break; + case 1: AddCommand(icLdc_i4_1, 0); break; + case 2: AddCommand(icLdc_i4_2, 0); break; + case 3: AddCommand(icLdc_i4_3, 0); break; + case 4: AddCommand(icLdc_i4_4, 0); break; + case 5: AddCommand(icLdc_i4_5, 0); break; + case 6: AddCommand(icLdc_i4_6, 0); break; + case 7: AddCommand(icLdc_i4_7, 0); break; + case 8: AddCommand(icLdc_i4_8, 0); break; + default: AddCommand(icLdc_i4, i); break; + } + AddCommand(icLdelem_ref, 0); + if (IsBoxedElementType(element->type())) { + type = meta->ImportType(*element); + command = AddCommand(icUnbox_any, type->id()); + command->set_token_reference(type->reference_list()->Add(0)); + } + switch (element->type()) { + case ELEMENT_TYPE_BOOLEAN: + case ELEMENT_TYPE_I1: + case ELEMENT_TYPE_U1: + AddCommand(icStind_i1, 0); + break; + case ELEMENT_TYPE_CHAR: + case ELEMENT_TYPE_I2: + case ELEMENT_TYPE_U2: + AddCommand(icStind_i2, 0); + break; + case ELEMENT_TYPE_I4: + case ELEMENT_TYPE_U4: + AddCommand(icStind_i4, 0); + break; + case ELEMENT_TYPE_I8: + AddCommand(icStind_i8, 0); + break; + case ELEMENT_TYPE_R4: + AddCommand(icStind_r4, 0); + break; + case ELEMENT_TYPE_R8: + AddCommand(icStind_r8, 0); + break; + case ELEMENT_TYPE_I: + case ELEMENT_TYPE_U: + AddCommand(icStind_i, 0); + break; + default: + AddCommand(icStind_ref, 0); + break; + } + } + AddCommand(icEndfinally, 0); + finally_end_index = count() - 1; + + if (type_ret) + AddCommand(icLdloc_1, 0); + } + } + AddCommand(icRet, 0); + + AddressRange *address_range = info->Add(0, 0, NULL, NULL, NULL); + for (i = cur_block->start_index(); i < count(); i++) { + command = item(i); + command->set_block(cur_block); + command->set_address_range(address_range); + command->CompileToNative(); + cur_block->set_end_index(i); + } + + if (need_try_finally) { + item(try_end_index)->link()->set_to_command(item(finally_end_index + 1)); + address_range = function_info_list()->Add(info->begin() + 1, info->begin() + 1, btValue, 0, 0, 0, NULL, NULL)->Add(0, 0, NULL, NULL, NULL); + + cur_block = AddBlock(count(), true); + command = AddCommand(icDword, (0x1c << 8) | CorILMethod_Sect_FatFormat | CorILMethod_Sect_EHTable); + command->set_alignment(sizeof(uint32_t)); + AddCommand(icDword, COR_ILEXCEPTION_CLAUSE_FINALLY); + ILCommand *try_entry = AddCommand(icDword, 0); + ILCommand *try_length = AddCommand(icDword, 0); + ILCommand *finally_entry = AddCommand(icDword, 0); + link = finally_entry->AddLink(0, ltFinallyBlock, item(finally_start_index)); + link->set_base_function_info(info); + ILCommand *finally_length = AddCommand(icDword, 0); + AddCommand(icDword, 0); + for (i = cur_block->start_index(); i < count(); i++) { + command = item(i); + command->set_block(cur_block); + command->set_address_range(address_range); + command->CompileToNative(); + cur_block->set_end_index(i); + } + + address_range = range_list()->Add(0, 0, try_entry, NULL, try_length); + for (i = try_start_index; i <= try_end_index; i++) { + command = item(i); + command->set_address_range(address_range); + } + address_range = range_list()->Add(0, 0, finally_entry, NULL, finally_length); + for (i = finally_start_index; i <= finally_end_index; i++) { + command = item(i); + command->set_address_range(address_range); + } + } + } + + entry_map[entry] = FunctionEntryInfo(method, type_ret, param_list, locals, data_entry); + } + + cur_block = NULL; + uint64_t image_base = ctx.file->image_base(); + std::set<uint64_t> try_list; + std::map<uint32_t, uint32_t> variable_map, param_map; + size_t temp_variable_index = NOT_ID; + for (i = 0; i < count(); i++) { + command = item(i); + if ((command->options() & roNoProgress) == 0) + ctx.file->StepProgress(); + + if (command->block() || (command->options() & roNeedCompile) == 0) { + cur_block = NULL; + continue; + } + + if (command->is_data()) { + cur_block = NULL; + continue; + } + + if (!cur_block) { + cur_block = AddBlock(i, false); + cur_block->set_virtual_machine(virtual_machine); + } + + cur_block->set_end_index(i); + command->set_block(cur_block); + + if (command->type() == icComment) { + if (command->token_reference()) + command->token_reference()->set_deleted(true); + std::map<ICommand *, FunctionEntryInfo>::const_iterator it = entry_map.find(command); + if (it != entry_map.end()) { + try_list.clear(); + type_ret = it->second.ret; + method = it->second.method; + meta = method->meta(); + locals = it->second.locals; + data_entry = it->second.data_entry; + std::vector<ILElement *> param_list = it->second.param_list; + variable_map.clear(); + param_map.clear(); + + if (command->section_options() & rtLinkedToInt) { + command->AddVMCommand(ctx, icWord, param_list.size(), 0); + for (j = param_list.size(); j > 0; j--) { + element = param_list[j - 1]; + type = meta->ImportType(*element); + command->AddVMCommand(ctx, icDword, type->id(), 0, type->reference_list()->Add(0)); + } + if (type_ret) + command->AddVMCommand(ctx, icDword, type_ret->id(), 0, type_ret->reference_list()->Add(0)); + else + command->AddVMCommand(ctx, icDword, 0, 0); + + if (command->section_options() & rtLinkedToExt) + command->AddExtSection(ctx); + } + + if (data_entry) { + uint32_t flags = static_cast<uint32_t>(data_entry->operand_value()); + if (flags & CorILMethod_Sect_EHTable) { + bool fat = (flags & CorILMethod_Sect_FatFormat) != 0; + uint32_t data_size = fat ? (flags >> 8) : static_cast<uint8_t>(flags >> 8); + uint32_t clauses = (data_size - sizeof(uint32_t)) / (fat ? 24 : 12); + k = IndexOf(data_entry) + 1; + for (j = 0; j < clauses; j++) { + ILCommand *catch_flags = item(k++); + ILCommand *catch_try_offset = item(k++); + ILCommand *catch_try_length = item(k++); + ILCommand *catch_handler_offset = item(k++); + ILCommand *catch_handler_length = item(k++); + ILCommand *catch_filter = item(k++); + + command->AddVMCommand(ctx, icInitcatchblock, 0); + command->AddVMCommand(ctx, icByte, static_cast<uint8_t>(catch_flags->operand_value())); + uint64_t try_address = method->address() + method->fat_size() + catch_try_offset->operand_value(); + try_list.insert(try_address); + command->AddVMCommand(ctx, icDword, static_cast<uint32_t>(try_address - image_base)); + command->AddVMCommand(ctx, icDword, static_cast<uint32_t>(try_address - image_base + catch_try_length->operand_value())); + command->AddVMCommand(ctx, icDword, 0, 0, NULL, catch_handler_offset->link() ? reinterpret_cast<ILCommand *>(catch_handler_offset->link()->to_command()) : NULL); + if (catch_filter->link()) { + command->AddVMCommand(ctx, icDword, 0, 0, NULL, reinterpret_cast<ILCommand *>(catch_filter->link()->to_command())); + } + else { + command->AddVMCommand(ctx, icDword, catch_filter->operand_value(), 0, catch_filter->token_reference()); + } + } + } + } + + // merge params and locals + std::vector<ILElement *> arg_list; + for (j = 0; j < param_list.size(); j++) { + arg_list.push_back(param_list[j]); + } + if (locals) { + for (j = 0; j < locals->count(); j++) { + arg_list.push_back(locals->item(j)); + } + } + for (j = 0; j < arg_list.size(); j++) { + std::swap(arg_list[j], arg_list[rand() % arg_list.size()]); + } + + for (j = 0; j < arg_list.size(); j++) { + element = arg_list[j]; + type = meta->ImportType(*element); + uint32_t index; + std::vector<ILElement *>::const_iterator it = std::find(param_list.begin(), param_list.end(), element); + if (it != param_list.end()) { + index = static_cast<uint32_t>(it - param_list.begin()); + command->AddVMCommand(ctx, icDup, 0); + command->AddVMCommand(ctx, icLdc_i4, static_cast<uint32_t>(index)); + command->AddVMCommand(ctx, icLdelema, 0); + command->AddVMCommand(ctx, element->is_ref() ? icDup : icLdc_i4, 0); + command->AddVMCommand(ctx, icLdc_i4, type->id(), 0, type->reference_list()->Add(0)); + command->AddVMCommand(ctx, icInitarg, 0); + param_map[index] = static_cast<uint32_t>(j); + } + else { + index = static_cast<uint32_t>(locals->IndexOf(element)); + command->AddVMCommand(ctx, icLdnull, 0); + command->AddVMCommand(ctx, icLdc_i4, element->is_ref() ? 1 : 0); + command->AddVMCommand(ctx, icLdc_i4, type->id(), 0, type->reference_list()->Add(0)); + command->AddVMCommand(ctx, icInitarg, 0); + variable_map[index] = static_cast<uint32_t>(j); + } + } + if ((ctx.options.flags & cpMemoryProtection) && tag() != ftLoader) { + temp_variable_index = arg_list.size(); + type = meta->ImportType(ELEMENT_TYPE_I4); + command->AddVMCommand(ctx, icLdnull, 0); + command->AddVMCommand(ctx, icDup, 0); + command->AddVMCommand(ctx, icLdc_i4, type->id(), 0, type->reference_list()->Add(0)); + command->AddVMCommand(ctx, icInitarg, 0); + } + command->AddVMCommand(ctx, icPop, 0); + } + continue; + } + else { + std::map<uint32_t, uint32_t>::const_iterator it; + switch (command->type()) { + case icRet: + if (type_ret) { + command->set_operand_value(0, type_ret->id()); + command->set_token_reference(type_ret->reference_list()->Add(0)); + } + command->set_param(static_cast<uint32_t>(temp_variable_index)); + break; + case icLdloc: + case icLdloc_s: + it = variable_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icLdloca: + case icLdloca_s: + it = variable_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icStloc: + case icStloc_s: + it = variable_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icLdloc_0: + it = variable_map.find(0); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icLdloc_1: + it = variable_map.find(1); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icLdloc_2: + it = variable_map.find(2); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icLdloc_3: + it = variable_map.find(3); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icStloc_0: + it = variable_map.find(0); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icStloc_1: + it = variable_map.find(1); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icStloc_2: + it = variable_map.find(2); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icStloc_3: + it = variable_map.find(3); + if (it == variable_map.end()) + throw std::runtime_error("Invalid variable index"); + command->set_param(it->second); + break; + case icLdarg: + case icLdarg_s: + it = param_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + case icLdarga: + case icLdarga_s: + it = param_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + case icStarg: + case icStarg_s: + it = param_map.find(static_cast<uint16_t>(command->operand_value())); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + case icLdarg_0: + it = param_map.find(0); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + case icLdarg_1: + it = param_map.find(1); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + case icLdarg_2: + it = param_map.find(2); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + case icLdarg_3: + it = param_map.find(3); + if (it == param_map.end()) + throw std::runtime_error("Invalid param index"); + command->set_param(it->second); + break; + } + } + + std::set<uint64_t>::const_iterator it = try_list.find(command->address()); + if (it != try_list.end()) { + command->AddVMCommand(ctx, icLdc_i4, static_cast<uint32_t>(command->address() - image_base)); + command->AddVMCommand(ctx, icEntertry, 0); + } + + command->CompileToVM(ctx); + + if (command->section_options() & rtCloseSection) + cur_block = NULL; + } +} + +bool ILFunction::Compile(const CompileContext &ctx) +{ + if (compilation_type() != ctMutation) { + for (size_t i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + if (!info->source() || info->entry()->block()) + continue; + + ILSignature *signature = reinterpret_cast<NETRuntimeFunction *>(info->source())->method()->signature(); + bool is_generic = (signature->ret()->type() == ELEMENT_TYPE_VAR || signature->ret()->type() == ELEMENT_TYPE_MVAR); + for (size_t j = 0; j < signature->count(); j++) { + ILElement *element = signature->item(j); + if (element->type() == ELEMENT_TYPE_VAR || element->type() == ELEMENT_TYPE_MVAR) { + is_generic = true; + break; + } + } + if (is_generic) { + ctx.file->Notify(mtError, this, "Method with generic parameters can't be virtualized"); + return false; + } + } + } + + switch (compilation_type()) { + case ctMutation: + Mutate(ctx); + CompileToNative(ctx); + break; + case ctVirtualization: + CompileToVM(ctx); + break; + case ctUltra: + Mutate(ctx); + CompileToVM(ctx); + break; + default: + return false; + } + + return BaseFunction::Compile(ctx); +} + +void ILFunction::AfterCompile(const CompileContext &ctx) +{ + for (size_t i = 0; i < count(); i++) { + ILCommand *command = item(i); + if (!command->block()) + continue; + + TokenReference *reference = command->token_reference(); + if (reference) { + if (command->options() & roClearOriginalCode) + reference->set_address(0); + } + } + + BaseFunction::AfterCompile(ctx); +} + +ILCommand *ILFunction::ParseCommand(IArchitecture &file, uint64_t address, bool dump_mode /*= false*/) +{ + NETRuntimeFunction *runtime_func = reinterpret_cast<NETRuntimeFunction *>(file.runtime_function_list()->GetFunctionByAddress(address)); + + ILCommand *command; + if (dump_mode) { + command = Add(address); + if (!file.AddressSeek(address)) + command->InitUnknown(); + else if (!runtime_func || address < runtime_func->start() || (file.selected_segment()->memory_type() & mtExecutable) == 0) + command->ReadValueFromFile(file, osByte); + else { + command->ReadFromFile(file); + /*switch (command->type()) { + case cmJmp: + case cmCall: + case cmJmpWithFlag: case cmJCXZ: case cmLoop: case cmLoope: case cmLoopne: + if ((command->options() & roFar) == 0 && command->operand(0).type == otValue) + command->AddLink(0, ltNone, command->operand(0).value); + break; + } + */ + } + return command; + } else { + if (!runtime_func) + return NULL; + + if (address == runtime_func->begin() && file.AddressSeek(address)) { + size_t index = count(); + command = Add(address); + command->set_alignment(sizeof(uint32_t)); + uint8_t format = static_cast<uint8_t>(command->ReadValueFromFile(file, osByte)); + + FunctionInfo *info = function_info_list()->Add(runtime_func->begin(), runtime_func->end(), btValue, runtime_func->method()->fat_size(), 0, 0, runtime_func, command); + + switch (format & CorILMethod_FormatMask) { + case CorILMethod_TinyFormat: + command->InitComment(string_format(".maxstack %d", 8)); + break; + case CorILMethod_FatFormat: + { + ILStandAloneSig *locals = runtime_func->method()->locals(); + + command->ReadValueFromFile(file, osByte); + uint16_t max_stack = static_cast<uint16_t>(command->ReadValueFromFile(file, osWord)); + command->ReadValueFromFile(file, osDWord); + if (!locals) + command->ReadValueFromFile(file, osDWord); + command->InitComment(string_format(".maxstack %d", max_stack)); + address = command->next_address(); + + if (locals) { + command = Add(address); + command->ReadValueFromFile(file, osDWord, true); + command->InitComment(string_format(".locals init %s", locals ? locals->name(true).c_str() : "()")); + address = command->next_address(); + } + + if (format & CorILMethod_MoreSects) { + size_t old_count = count(); + uint64_t start_address = address; + address = AlignValue(runtime_func->end(), sizeof(uint32_t)); + file.AddressSeek(address); + uint64_t data_address = address; + command = Add(address); + command->set_alignment(sizeof(uint32_t)); + uint32_t flags = static_cast<uint32_t>(command->ReadValueFromFile(file, osDWord)); + bool fat = (flags & CorILMethod_Sect_FatFormat) != 0; + uint32_t data_size = fat ? (flags >> 8) : static_cast<uint8_t>(flags >> 8); + command->set_comment(CommentInfo(ttComment, string_format("Kind: %.2X; DataSize: %.8X", flags & CorILMethod_Sect_KindMask, data_size))); + address = command->next_address(); + info->set_data_entry(command); + if (flags & CorILMethod_Sect_EHTable) { + CommandLink *link; + uint64_t value; + size_t clauses = (data_size - sizeof(uint32_t)) / (fat ? 24 : 12); + for (size_t i = 0; i < clauses; i++) { + command = Add(address); + flags = static_cast<uint32_t>(command->ReadValueFromFile(file, fat ? osDWord : osWord)); + command->set_comment(CommentInfo(ttComment, "Flags")); + address = command->next_address(); + + ILCommand *try_entry = Add(address); + value = try_entry->ReadValueFromFile(file, fat ? osDWord : osWord); + try_entry->set_comment(CommentInfo(ttComment, "TryOffset")); + address = try_entry->next_address(); + uint64_t try_begin = start_address + value; + + ILCommand *try_size = Add(address); + value = try_size->ReadValueFromFile(file, fat ? osDWord : osByte); + try_size->set_comment(CommentInfo(ttComment, "TryLength")); + address = try_size->next_address(); + uint64_t try_end = try_begin + value; + + range_list()->Add(try_begin, try_end, try_entry, NULL, try_size); + + ILCommand *handler_entry = Add(address); + value = handler_entry->ReadValueFromFile(file, fat ? osDWord : osWord); + handler_entry->set_comment(CommentInfo(ttComment, "HandlerOffset")); + address = handler_entry->next_address(); + link = handler_entry->AddLink(0, (flags & COR_ILEXCEPTION_CLAUSE_FINALLY) ? ltFinallyBlock : ltSEHBlock, start_address + value); + link->set_base_function_info(info); + uint64_t handler_begin = start_address + value; + + ILCommand *handler_size = Add(address); + value = handler_size->ReadValueFromFile(file, fat ? osDWord : osByte); + handler_size->set_comment(CommentInfo(ttComment, "HandlerLength")); + address = handler_size->next_address(); + uint64_t handler_end = handler_begin + value; + + range_list()->Add(handler_begin, handler_end, handler_entry, NULL, handler_size); + + if (flags & COR_ILEXCEPTION_CLAUSE_FILTER) { + command = Add(address); + value = command->ReadValueFromFile(file, osDWord); + command->set_comment(CommentInfo(ttComment, "FilterOffset")); + address = command->next_address(); + link = command->AddLink(0, ltSEHBlock, start_address + value); + link->set_base_function_info(info); + } else { + command = Add(address); + command->ReadValueFromFile(file, osDWord, true); + command->set_comment(CommentInfo(ttComment, "ClassToken")); + address = command->next_address(); + } + } + } + function_info_list()->Add(data_address, data_address + data_size, btValue, 0, 0, 0, NULL, NULL); + + for (size_t i = old_count; i < count(); i++) { + command = item(i); + //command->exclude_option(roNeedCompile); + command->exclude_option(roClearOriginalCode); + } + } + } + break; + } + + return item(index); + } + + if (address < runtime_func->start()) + address = runtime_func->start(); + + if (!file.AddressSeek(address)) + return NULL; + } + + command = Add(address); + command->ReadFromFile(file); + + switch (command->type()) { + case icBrfalse_s: case icBrtrue_s: case icBeq_s: case icBge_s: case icBgt_s: + case icBle_s: case icBlt_s: case icBne_un_s: case icBge_un_s: case icBgt_un_s: case icBle_un_s: + case icBlt_un_s: case icBrfalse: case icBrtrue: case icBeq: case icBge: case icBgt: + case icBle: case icBlt: case icBne_un: case icBge_un: case icBgt_un: case icBle_un: case icBlt_un: + command->AddLink(0, ltJmpWithFlag, command->operand_value()); + break; + case icBr: case icBr_s: case icJmp: case icLeave: case icLeave_s: + command->AddLink(0, ltJmp, command->operand_value()); + break; + case icSwitch: + { + address = command->next_address(); + uint32_t case_count = static_cast<uint32_t>(command->operand_value()); + uint64_t add_value = address + case_count * sizeof(uint32_t); + ILCommand *case_command = NULL; + for (size_t i = 0; i < case_count; i++) { + case_command = Add(address); + case_command->ReadCaseCommand(file); + case_command->set_comment(CommentInfo(ttComment, "Case")); + CommandLink *link = case_command->AddLink(0, ltCase, case_command->operand_value() + add_value); + link->set_parent_command(command); + + address = case_command->next_address(); + } + if (case_command) + command = case_command; + } + break; + case icCall: case icCallvirt: case icLdftn: case icLdvirtftn: case icNewobj: + { + ILToken *token = reinterpret_cast<NETArchitecture&>(file).command_list()->token(static_cast<uint32_t>(command->operand_value())); + uint64_t to_address = 0; + LinkType link_type = ltNone; + if (token && token->type() == ttMethodDef) { + ILMethodDef *method = reinterpret_cast<ILMethodDef*>(token); + if ((method->impl_flags() & miCodeTypeMask) == miIL && method->address()) { + to_address = method->address(); + if (command->type() == icCall || (command->type() == icCallvirt && (method->flags() & mdVirtual) == 0)) + link_type = ltCall; + } + } + + if (to_address) + command->AddLink(-1, link_type, to_address); + } + break; + } + + return command; +} + +ILCommand *ILFunction::AddCommand(const std::string &value) +{ + ILCommand *command = new ILCommand(this, cpu_address_size(), value); + AddObject(command); + return command; +} + +ILCommand *ILFunction::AddCommand(const Data &value) +{ + ILCommand *command = new ILCommand(this, cpu_address_size(), value); + AddObject(command); + return command; +} + +ILCommand *ILFunction::AddCommand(OperandSize value_size, uint64_t value) +{ + ILCommandType command_type; + switch (value_size) { + case osWord: + command_type = icWord; + break; + case osDWord: + command_type = icDword; + break; + default: + return NULL; + } + + return AddCommand(command_type, value); +} + +ILCommand *ILFunction::CreateCommand() +{ + return new ILCommand(this, cpu_address_size()); +} + +ILCommand *ILFunction::AddCommand(ILCommandType type, uint64_t operand_value, IFixup *fixup) +{ + ILCommand *command = new ILCommand(this, cpu_address_size(), type, operand_value, fixup); + AddObject(command); + return command; +} + +ILFunction *ILFunction::Clone(IFunctionList *owner) const +{ + ILFunction *func = new ILFunction(owner, *this); + return func; +} + +ILCommand *ILFunction::GetCommandByAddress(uint64_t address) const +{ + return reinterpret_cast<ILCommand *>(BaseFunction::GetCommandByAddress(address)); +} + +ILCommand *ILFunction::GetCommandByNearAddress(uint64_t address) const +{ + return reinterpret_cast<ILCommand *>(BaseFunction::GetCommandByNearAddress(address)); +} + +ILCommand *ILFunction::ParseString(IArchitecture &file, uint64_t address, size_t len) +{ + if (!file.AddressSeek(address)) + return NULL; + + ILCommand *command = Add(address); + command->ReadString(file, len); + command->exclude_option(roNeedCompile); + command->exclude_option(roClearOriginalCode); + return command; +} + +ILCommand *ILFunction::Add(uint64_t address) +{ + ILCommand *command = new ILCommand(this, cpu_address_size(), address); + AddObject(command); + return command; +} + +/** + * ILFunctionList + */ + +ILFunctionList::ILFunctionList(IArchitecture *owner) + : BaseFunctionList(owner), crc_table_(NULL), runtime_crc_table_(NULL), import_(NULL) +{ + crc_cryptor_ = new ValueCryptor(); +} + +ILFunctionList::ILFunctionList(IArchitecture *owner, const ILFunctionList &src) + : BaseFunctionList(owner, src), crc_table_(NULL), runtime_crc_table_(NULL), import_(NULL) +{ + crc_cryptor_ = new ValueCryptor(); +} + +ILFunctionList::~ILFunctionList() +{ + delete crc_cryptor_; +} + +ILFunction *ILFunctionList::item(size_t index) const +{ + return reinterpret_cast<ILFunction *>(BaseFunctionList::item(index)); +} + +ILFunction *ILFunctionList::GetFunctionByAddress(uint64_t address) const +{ + return reinterpret_cast<ILFunction *>(BaseFunctionList::GetFunctionByAddress(address)); +} + +bool ILFunctionList::Prepare(const CompileContext &ctx) +{ + OperandSize cpu_address_size = ctx.file->cpu_address_size(); + + crc_cryptor_->clear(); + crc_cryptor_->set_size(osDWord); + crc_cryptor_->Add(ccXor, rand32()); + + if ((ctx.options.flags | ctx.options.sdk_flags) & cpMemoryProtection) { + crc_table_ = AddCRCTable(cpu_address_size); + } else { + crc_table_ = NULL; + } + + if (ctx.runtime) { + ILFunctionList *function_list = reinterpret_cast<ILFunctionList *>(ctx.runtime->function_list()); + ILFunction *func; + size_t i, j; + + // remove DecryptString template + uint64_t address = ctx.runtime->export_list()->GetAddressByType(atDecryptStringA); + if (address) { + func = function_list->GetFunctionByAddress(address); + if (func) + func->set_need_compile(false); + } + + NETArchitecture *runtime = reinterpret_cast<NETArchitecture *>(ctx.runtime); + NETRuntimeFunctionList *runtime_function_list = runtime->runtime_function_list(); + + for (i = 0; i < function_list->count(); i++) { + func = function_list->item(i); + if (func->compilation_type() != ctMutation && func->entry_type() == etNone) { + NETRuntimeFunction *runtime_func = runtime_function_list->GetFunctionByAddress(func->address()); + if (runtime_func) { + std::vector<ILMethodDef *> method_list = runtime_func->method_list(); + for (j = 0; j < method_list.size(); j++) { + ILMethodDef *method = method_list[j]; + if (method->flags() & mdSpecialName) + return false; + method->set_deleted(true); + } + } + } + } + + APIType crc_helpers[] = { atRandom, atCalcCRC }; + if (ctx.runtime->segment_list()->count() > 0) { + // add runtime functions + for (i = 0; i < function_list->count(); i++) { + func = function_list->item(i); + + if (func->tag() == ftProcessor) + continue; + + if (func->need_compile()) { + func = func->Clone(this); + AddObject(func); + + if (func->compilation_type() != ctMutation && func->entry_type() == etNone) + func->entry()->include_section_option(rtLinkedToInt); + + for (j = 0; j < func->count(); j++) { + ILCommand *command = func->item(j); + if (command->type() == icLdstr) { + ILData dump = runtime->command_list()->GetUserData(TOKEN_VALUE(command->operand_value()), &address); + + for (size_t k = 0; k < MESSAGE_COUNT; k++) { + os::unicode_string unicode_message = +#ifdef VMP_GNU + os::FromUTF8(default_message[k]); +#else + default_message[k]; +#endif + + if (dump.size() == unicode_message.size() * sizeof(os::unicode_char) && memcmp(dump.data(), unicode_message.c_str(), dump.size()) == 0) { + MapFunction *map_function = runtime->map_function_list()->Add(address, address + dump.size(), otString, FunctionName()); + map_function->reference_list()->Add(command->address(), address); + ILFunction *str_function = reinterpret_cast<ILFunction *>(function_list->AddByAddress(address, ctVirtualization, 0, true, NULL)); + if (str_function) { + str_function->set_from_runtime(true); + os::unicode_string str = os::FromUTF8(ctx.options.messages[k]); + if (str.empty()) + str.push_back(0); + str_function->item(0)->set_dump(reinterpret_cast<const uint8_t*>(str.c_str()), str.size() * sizeof(os::unicode_char)); + } + break; + } + } + } + } + + for (j = 0; j < func->count(); j++) { + func->item(j)->CompileToNative(); + } + } else { + if (func->tag() != ftLoader) { + NETRuntimeFunction *runtime_func = runtime_function_list->GetFunctionByAddress(func->address()); + if (runtime_func) { + std::vector<ILMethodDef *> method_list = runtime_func->method_list(); + for (j = 0; j < method_list.size(); j++) { + method_list[j]->set_deleted(true); + } + } + } + + if (!func->FreeByManager(ctx)) + return false; + } + } + + for (i = 0; i < _countof(crc_helpers); i++) { + address = ctx.runtime->export_list()->GetAddressByType(crc_helpers[i]); + func = reinterpret_cast<ILFunction *>(ctx.file->function_list()->GetFunctionByAddress(address)); + if (!func) + return false; + // exclude from memory protection + func->entry()->include_section_option(rtLinkedToInt); + func->set_tag(ftLoader); + } + + AddRuntimeData(cpu_address_size); + } + else { + // remove references to VMProtect.Core + address = ctx.runtime->export_list()->GetAddressByType(atSetupImage); + func = function_list->GetFunctionByAddress(address); + if (!func) + return false; + + for (i = 0; i < func->count(); i++) { + ILCommand *command = func->item(i); + if (command->token_reference()) { + ILToken *token = command->token_reference()->owner()->owner(); + switch (token->type()) { + case ttField: + if (reinterpret_cast<ILField *>(token)->declaring_type()->full_name() == "VMProtect.Core") + command->Init(icNop); + break; + case ttMethodDef: + if (reinterpret_cast<ILMethodDef *>(token)->declaring_type()->full_name() == "VMProtect.Core") + command->Init(icNop); + break; + } + } + } + + if (ctx.options.flags & cpMemoryProtection) { + // add CRC helpers + for (i = 0; i < _countof(crc_helpers); i++) { + address = ctx.runtime->export_list()->GetAddressByType(crc_helpers[i]); + func = function_list->GetFunctionByAddress(address); + if (!func) + return false; + + func = func->Clone(this); + AddObject(func); + for (j = 0; j < func->count(); j++) { + ILCommand *command = func->item(j); + command->exclude_option(roClearOriginalCode); + command->CompileToNative(); + } + + // exclude from memory protection + func->entry()->include_section_option(rtLinkedToInt); + func->set_tag(ftLoader); + } + } + } + } + + if (ctx.options.flags & cpImportProtection) { + import_ = AddImport(cpu_address_size); + } else { + import_ = NULL; + } + + AddSDK(cpu_address_size); + + AddWatermark(cpu_address_size, ctx.options.watermark, ctx.runtime ? 8 : 10); + + return BaseFunctionList::Prepare(ctx); +} + +void ILFunctionList::CompileLinks(const CompileContext &ctx) +{ + if (ctx.options.flags & cpMemoryProtection) { + runtime_crc_table_ = AddRuntimeCRCTable(ctx.file->cpu_address_size()); + runtime_crc_table_->Compile(ctx); + } + else { + runtime_crc_table_ = NULL; + } + + return BaseFunctionList::CompileLinks(ctx); +} + +void ILFunctionList::CompileInfo(const CompileContext &ctx) +{ + return BaseFunctionList::CompileInfo(ctx); +} + +void ILFunctionList::ReadFromBuffer(Buffer &buffer, IArchitecture &file) +{ + BaseFunctionList::ReadFromBuffer(buffer, file); + + // add loader stubs + size_t i, j; + std::set<ILTypeDef*> class_list; + for (i = 0; i < count(); i++) { + ILFunction *func = item(i); + if (func->tag() != ftLoader) + continue; + + for (j = 0; j < func->count(); j++) { + ILCommand *command = func->item(j); + if (command->token_reference()) { + ILToken *token = command->token_reference()->owner()->owner(); + if (token->type() == ttMethodDef) + class_list.insert(reinterpret_cast<ILMethodDef*>(token)->declaring_type()); + } + } + } + + for (std::set<ILTypeDef*>::const_iterator it = class_list.begin(); it != class_list.end(); ) { + ILTypeDef *type_def = *it; + if (type_def->full_name() == "VMProtect.Core") { + class_list.erase(it++); + continue; + } + it++; + } + + ILTable *method_table = reinterpret_cast<NETArchitecture&>(file).command_list()->table(ttMethodDef); + for (i = 0; i < method_table->count(); i++) { + ILMethodDef *method = reinterpret_cast<ILMethodDef*>(method_table->item(i)); + uint64_t address = method->address(); + if (!address || class_list.find(method->declaring_type()) == class_list.end() || GetFunctionByAddress(address)) + continue; + + ILFunction *new_func = reinterpret_cast<ILFunction *>(AddByAddress(address, ctMutation, 0, false, NULL)); + if (new_func) { + new_func->set_tag(ftLoader); + for (j = 0; j < new_func->count(); j++) { + new_func->item(j)->exclude_option(roClearOriginalCode); + } + } + } +} + +ILFunction *ILFunctionList::Add(const std::string &name, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder) +{ + ILFunction *func = new ILFunction(this, name, compilation_type, compilation_options, need_compile, folder); + AddObject(func); + return func; +} + +ILFunctionList * ILFunctionList::Clone(IArchitecture *owner) const +{ + ILFunctionList *list = new ILFunctionList(owner, *this); + return list; +} + +IFunction * ILFunctionList::CreateFunction(OperandSize cpu_address_size) +{ + return new ILFunction(this, cpu_address_size); +} + +bool ILFunctionList::Compile(const CompileContext &ctx) +{ + return BaseFunctionList::Compile(ctx); +} + +ILSDK *ILFunctionList::AddSDK(OperandSize cpu_address_size) +{ + ILSDK *func = new ILSDK(this, cpu_address_size); + AddObject(func); + return func; +} + +ILRuntimeData *ILFunctionList::AddRuntimeData(OperandSize cpu_address_size) +{ + ILRuntimeData *func = new ILRuntimeData(this, cpu_address_size); + AddObject(func); + return func; +} + +ILCRCTable *ILFunctionList::AddCRCTable(OperandSize cpu_address_size) +{ + ILCRCTable *func = new ILCRCTable(this, cpu_address_size); + AddObject(func); + return func; +} + +ILImport *ILFunctionList::AddImport(OperandSize cpu_address_size) +{ + ILImport *func = new ILImport(this, cpu_address_size); + AddObject(func); + return func; +} + +ILFunction *ILFunctionList::AddWatermark(OperandSize cpu_address_size, Watermark *watermark, int copy_count) +{ + ILFunction *func = new ILFunction(this, cpu_address_size); + func->set_compilation_type(ctMutation); + func->set_memory_type(mtNone); + func->AddWatermark(watermark, copy_count); + AddObject(func); + return func; +} + +ILRuntimeCRCTable *ILFunctionList::AddRuntimeCRCTable(OperandSize cpu_address_size) +{ + ILRuntimeCRCTable *func = new ILRuntimeCRCTable(this, cpu_address_size); + AddObject(func); + return func; +} + +ILVirtualMachineProcessor *ILFunctionList::AddProcessor(OperandSize cpu_address_size) +{ + ILVirtualMachineProcessor *func = new ILVirtualMachineProcessor(this, cpu_address_size); + AddObject(func); + return func; +} + +/** + * ILSDK + */ + +ILSDK::ILSDK(IFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size) +{ + set_compilation_type(ctMutation); +} + +bool ILSDK::Init(const CompileContext &ctx) +{ + MapFunctionList *map_function_list; + MapFunction *map_function; + IFunctionList *function_list; + size_t i, c, j, n, f; + uint64_t address; + IArchitecture *file; + IImportList *import_list; + IImport *import; + IImportFunction *import_function; + ILCommand *command; + CommandBlock *block; + uint64_t api_address; + + f = (ctx.runtime && ctx.runtime->segment_list()->count() > 0) ? 2 : 1; + for (n = 0; n < f; n++) { + file = (n == 0) ? ctx.file : ctx.runtime; + map_function_list = file->map_function_list(); + function_list = file->function_list(); + import_list = file->import_list(); + for (i = 0; i < import_list->count(); i++) { + import = import_list->item(i); + if (!import->is_sdk()) + continue; + + for (j = 0; j < import->count(); j++) { + import_function = import->item(j); + if (import_function->type() == atNone) + continue; + + map_function = import_function->map_function(); + for (c = 0; c < map_function->reference_list()->count(); c++) { + address = map_function->reference_list()->item(c)->address(); + + command = reinterpret_cast<ILCommand *>(ctx.file->function_list()->GetCommandByNearAddress(address, true)); + if (command) { + delete command->link(); + } else { + if (!file->AddressSeek(address)) + return false; + + block = AddBlock(count(), true); + block->set_address(address); + + command = Add(address); + command->ReadFromFile(*file); + command->set_block(block); + command->include_option(roFillNop); + command->exclude_option(roClearOriginalCode); + } + + if (command->token_reference()) { + command->token_reference()->set_deleted(true); + command->set_token_reference(NULL); + } + + switch (import_function->type()) { + case atBegin: + command->Init(icPop); + break; + + case atEnd: + command->Init(icNop); + break; + + case atDecryptStringA: + case atDecryptStringW: + command->Init(icNop); + break; + + case atFreeString: + Notify(mtWarning, command, "VMProtect.SDK.FreeString is deprecated"); + // fall through + case atIsDebuggerPresent: + case atIsVirtualMachinePresent: + case atIsValidImageCRC: + case atActivateLicense: + case atDeactivateLicense: + case atGetOfflineActivationString: + case atGetOfflineDeactivationString: + case atSetSerialNumber: + case atGetSerialNumberState: + case atGetSerialNumberData: + case atGetCurrentHWID: + case atIsProtected: + if (!ctx.runtime || ctx.runtime->segment_list()->count() == 0) { + switch (import_function->type()) { + case atFreeString: + command->Init(icNop); + break; + case atIsProtected: + command->Init(icLdc_i4_1); + break; + default: + // other APIs can not work without runtime + return false; + } + } else { + api_address = ctx.runtime->export_list()->GetAddressByType(import_function->type()); + if (!api_address) + return false; + + ILMethodDef *method = reinterpret_cast<ILMetaData *>(ctx.runtime->command_list())->GetMethod(api_address); + if (!method) + return false; + + command->set_operand_value(0, method->id()); + command->set_token_reference(method->reference_list()->Add(command->address() + 1)); + } + break; + + default: + throw std::runtime_error("Unknown API from SDK: " + import_function->name()); + } + + command->CompileToNative(); + } + } + } + } + + for (i = 0; i < count(); i++) { + item(i)->CompileToNative(); + } + + return true; +} + +/** + * ILCRCTable + */ + +ILCRCTable::ILCRCTable(IFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size) +{ + set_compilation_type(ctMutation); +} + +bool ILCRCTable::Init(const CompileContext &ctx) +{ + size_t i, c, n, f; + + c = 10; + f = (ctx.runtime && ctx.runtime->segment_list()->count() > 0) ? 2 : 1; + for (n = 0; n < f; n++) { + IArchitecture *file = (n == 0) ? ctx.file : ctx.runtime; + c += ctx.file->segment_list()->count(); + } + + for (i = 0; i < c; i++) { + AddCommand(icDword, 0); + AddCommand(icDword, 0); + AddCommand(icDword, 0); + } + + size_entry_ = AddCommand(icDword, 0); + size_entry_->include_option(roCreateNewBlock); + + hash_entry_ = AddCommand(icDword, 0); + hash_entry_->include_option(roCreateNewBlock); + + for (i = 0; i < count(); i++) { + ILCommand *command = item(i); + command->CompileToNative(); + command->include_option(roWritable); + } + + return true; +} + +/** + * ILRuntimeData + */ + +ILRuntimeData::ILRuntimeData(IFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size), strings_entry_(NULL), strings_size_(0), trial_hwid_entry_(NULL), trial_hwid_size_(0), + resources_entry_(NULL), resources_size_(0) +#ifdef ULTIMATE + , license_data_entry_(NULL), license_data_size_(0) +#endif +{ + set_compilation_type(ctMutation); + rc5_key_.Create(); +} + +bool ILRuntimeData::CommandCompareHelper::operator()(const ILCommand *left, ILCommand *right) const +{ + return (left->address() < right->address()); +} + +bool ILRuntimeData::Init(const CompileContext &ctx) +{ + ILFunctionList *function_list; + size_t i, j, index; + std::vector<ILCommand *> string_command_list; + ILCommand *command, *string_command; + CommandLink *link; + ILCommand *key_entry; + Data key; + uint32_t data_key; + uint64_t image_base = ctx.file->image_base(); + + key.PushBuff(rc5_key_.Value, sizeof(rc5_key_.Value)); + data_key = key.ReadDWord(0); + + resources_entry_ = NULL; + resources_size_ = 0; +#ifdef ULTIMATE + if (ctx.options.file_manager) { + FileManager *file_manager = ctx.options.file_manager; + if (!file_manager->OpenFiles()) + return false; + + InternalFile *internal_file; + index = count(); + // write entry + for (i = 0; i < file_manager->count(); i++) { + internal_file = file_manager->item(i); + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + AddCommand(osDWord, internal_file->stream()->Size()); + AddCommand(osDWord, 0); + } + + // end entry + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + + resources_entry_ = item(index); + resources_entry_->include_option(roCreateNewBlock); + resources_size_ = static_cast<uint32_t>((count() - index) * OperandSizeToValue(osDWord)); + + PEFile pe_file; + for (i = 0; i < file_manager->count(); i++) { + internal_file = file_manager->item(i); + std::string file_name = internal_file->absolute_file_name(); + std::string assembly_name; + try + { + if (pe_file.Open(file_name.c_str(), foRead | foHeaderOnly) == osSuccess && pe_file.count() > 1) + assembly_name = reinterpret_cast<NETArchitecture *>(pe_file.item(1))->full_name(); + } + catch (...) + { + + } + pe_file.Close(); + if (assembly_name.empty()) { + Notify(mtError, internal_file, string_format(language[lsFileHasIncorrectFormat].c_str(), file_name.c_str(), ".NET")); + file_manager->CloseFiles(); + return false; + } + + // write name + Data data; + os::unicode_string name = os::FromUTF8(assembly_name.c_str()); + const os::unicode_char *p = name.c_str(); + for (j = 0; j < name.size() + 1; j++) { + data.PushWord(static_cast<uint16_t>(p[j] ^ (_rotl32(data_key, static_cast<int>(j)) + j))); + } + command = AddCommand(data); + command->include_option(roCreateNewBlock); + link = item(index + i * 4)->AddLink(0, ltOffset, command); + link->set_sub_value(image_base); + + // write data + Notify(mtInformation, NULL, string_format("%s %s", language[lsLoading].c_str(), os::ExtractFileName(file_name.c_str()).c_str())); + data.resize(static_cast<size_t>(internal_file->stream()->Size())); + internal_file->stream()->Read(&data[0], data.size()); + for (j = 0; j < data.size(); j++) { + data[j] = (data[j] ^ static_cast<uint8_t>(_rotl32(data_key, static_cast<int>(j)) + j)); + } + command = AddCommand(data); + command->include_option(roCreateNewBlock); + link = item(index + i * 4 + 1)->AddLink(0, ltOffset, command); + link->set_sub_value(image_base); + } + + file_manager->CloseFiles(); + } +#endif + + if ((ctx.options.flags & cpResourceProtection) && ctx.file->resource_list()->count()) { + std::string assembly_name; + NETArchitecture *file = reinterpret_cast<NETArchitecture *>(ctx.file); + while (true) { + assembly_name = string_format("%.8X", rand32()); + if (!file->command_list()->GetAssemblyRef(assembly_name)) + break; + } + Data data; + if (file->WriteResources(assembly_name, data)) { + ILAssemblyRef *assembly_ref = file->command_list()->GetAssemblyRef(assembly_name); + if (!assembly_ref) + return false; + + if (resources_entry_) { + index = IndexOf(resources_entry_) + (resources_size_ - 4 * sizeof(uint32_t)) / sizeof(uint32_t); + + // insert entry + InsertObject(index + 0, new ILCommand(this, cpu_address_size(), icDword, 0)); + InsertObject(index + 1, new ILCommand(this, cpu_address_size(), icDword, 0)); + InsertObject(index + 2, new ILCommand(this, cpu_address_size(), icDword, data.size())); + InsertObject(index + 3, new ILCommand(this, cpu_address_size(), icDword, 0)); + + resources_size_ += 4 * sizeof(uint32_t); + } + else { + // write entry + index = count(); + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + AddCommand(osDWord, data.size()); + AddCommand(osDWord, 0); // action + + // end entry + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + AddCommand(osDWord, 0); + + resources_entry_ = item(index); + resources_entry_->include_option(roCreateNewBlock); + resources_size_ = static_cast<uint32_t>((count() - index) * OperandSizeToValue(osDWord)); + } + + // write name + Data str; + os::unicode_string name = os::FromUTF8(assembly_ref->full_name().c_str()); + const os::unicode_char *p = name.c_str(); + for (i = 0; i < name.size() + 1; i++) { + str.PushWord(static_cast<uint16_t>(p[i] ^ (_rotl32(data_key, static_cast<int>(i)) + i))); + } + command = AddCommand(str); + command->include_option(roCreateNewBlock); + link = item(index)->AddLink(0, ltOffset, command); + link->set_sub_value(image_base); + + // write data + for (i = 0; i < data.size(); i++) { + data[i] = data[i] ^ static_cast<uint8_t>(_rotl32(data_key, static_cast<int>(i)) + i); + } + command = AddCommand(data); + command->include_option(roCreateNewBlock); + link = item(index + 1)->AddLink(0, ltOffset, command); + link->set_sub_value(image_base); + } + } + + function_list = reinterpret_cast<ILFunctionList *>(ctx.file->function_list()); + for (i = 0; i < function_list->count(); i++) { + ILFunction *func = function_list->item(i); + if (func->need_compile() && func->type() == otString) { + for (j = 0; j < func->count(); j++) { + string_command_list.push_back(func->item(j)); + } + } + } + + key_entry = AddCommand(key); + key_entry->include_option(roCreateNewBlock); + + strings_entry_ = NULL; + strings_size_ = 0; + if (string_command_list.size()) { + std::sort(string_command_list.begin(), string_command_list.end(), CommandCompareHelper()); + index = count(); + + // create directory + AddCommand(osDWord, string_command_list.size()); + AddCommand(osDWord, 0); + + for (i = 0; i < string_command_list.size(); i++) { + string_command = string_command_list[i]; + + // create string entry + AddCommand(osDWord, string_command->address() - ctx.file->image_base()); + command = AddCommand(osDWord, 0); + link = command->AddLink(0, ltOffset); + link->set_sub_value(ctx.file->image_base()); + AddCommand(osDWord, string_command->dump_size()); + AddCommand(osDWord, 0); + } + strings_entry_ = item(index); + strings_entry_->include_option(roCreateNewBlock); + strings_size_ = static_cast<uint32_t>((count() - index) * OperandSizeToValue(osDWord)); + i = AlignValue(strings_size_, 8); + if (i > strings_size_) { + Data tmp; + tmp.resize(i - strings_size_, 0); + AddCommand(tmp); + strings_size_ = (uint32_t)i; + } + + // create string values + Data data; + for (i = 0; i < string_command_list.size(); i++) { + string_command = string_command_list[i]; + + data.clear(); + for (j = 0; j < string_command->dump_size(); j++) { + data.PushByte(string_command->dump(j) ^ static_cast<uint8_t>(_rotl32(data_key, static_cast<int>(j)) + j)); + } + + command = AddCommand(data); + command->include_option(roCreateNewBlock); + + item(index + 2 + i * 4 + 1)->link()->set_to_command(command); + } + } + +#ifdef ULTIMATE + license_data_entry_ = NULL; + license_data_size_ = 0; + if (ctx.options.licensing_manager) { + Data license_data; + if (ctx.options.licensing_manager->GetLicenseData(license_data)) { + license_data_entry_ = AddCommand(license_data); + license_data_entry_->include_option(roCreateNewBlock); + license_data_size_ = static_cast<uint32_t>(license_data.size()); + } + } +#endif + + trial_hwid_entry_ = NULL; + trial_hwid_size_ = 0; +#ifdef DEMO + if (true) +#else + if (ctx.options.flags & cpUnregisteredVersion) +#endif + { + size_t size = VMProtectGetCurrentHWID(NULL, 0); + std::vector<char> hwid; + hwid.resize(size); + VMProtectGetCurrentHWID(hwid.data(), (int)hwid.size()); + + std::vector<uint8_t> binary; + binary.resize(size); + Base64Decode(hwid.data(), hwid.size(), binary.data(), size); + + Data data; + data.PushBuff(binary.data(), binary.size()); + data.resize(64); + + trial_hwid_size_ = static_cast<uint32_t>(std::min(size, data.size())); + trial_hwid_entry_ = AddCommand(data); + trial_hwid_entry_->include_option(roCreateNewBlock); + } +#ifdef ULTIMATE + else if (!ctx.options.hwid.empty()) { + std::string hwid = ctx.options.hwid; + size_t size = hwid.size(); + + std::vector<uint8_t> binary; + binary.resize(size); + Base64Decode(hwid.data(), hwid.size(), binary.data(), size); + if (size & 3) { + Notify(mtError, NULL, "Invalid HWID"); + return false; + } + + Data data; + data.PushBuff(binary.data(), binary.size()); + data.resize(64); + + trial_hwid_size_ = static_cast<uint32_t>(std::min(size, data.size())); + trial_hwid_entry_ = AddCommand(data); + trial_hwid_entry_->include_option(roCreateNewBlock); + } +#endif + + for (i = 0; i < count(); i++) { + item(i)->CompileToNative(); + } + + // setup faces for common runtime functions + ILCRCTable *il_crc = reinterpret_cast<ILFunctionList *>(ctx.file->function_list())->crc_table(); + for (i = 0; i < function_list->count(); i++) { + ILFunction *func = function_list->item(i); + if (!func->from_runtime()) + continue; + + for (j = 0; j < func->count(); j++) { + ILCommand *command = func->item(j); + if (command->type() != icLdc_i4) + continue; + + uint32_t value = static_cast<uint32_t>(command->operand_value()); + if ((value & 0xFFFF0000) == 0xFACE0000) { + switch (value) { + case FACE_STRING_DECRYPT_KEY: + command->set_operand_value(0, data_key); + command->CompileToNative(); + break; + case FACE_RC5_P: + command->set_operand_value(0, rc5_key_.P); + command->CompileToNative(); + break; + case FACE_RC5_Q: + command->set_operand_value(0, rc5_key_.Q); + command->CompileToNative(); + break; + case FACE_KEY_INFO: + if (key_entry) { + link = command->AddLink(0, ltOffset, key_entry); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_STRING_INFO: + if (strings_entry_) { + link = command->AddLink(0, ltOffset, strings_entry_); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_RESOURCE_INFO: + if (resources_entry_) { + link = command->AddLink(0, ltOffset, resources_entry_); + link->set_sub_value(image_base); + } + else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; +#ifdef ULTIMATE + case FACE_LICENSE_INFO: + if (license_data_entry_) { + link = command->AddLink(0, ltOffset, license_data_entry_); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_LICENSE_INFO_SIZE: + command->set_operand_value(0, license_data_size_); + command->CompileToNative(); + break; +#else + case FACE_LICENSE_INFO: + case FACE_LICENSE_INFO_SIZE: + command->set_operand_value(0, 0); + command->CompileToNative(); + break; +#endif + case FACE_TRIAL_HWID: + if (trial_hwid_entry_) { + link = command->AddLink(0, ltOffset, trial_hwid_entry_); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_TRIAL_HWID_SIZE: + command->set_operand_value(0, trial_hwid_size_); + command->CompileToNative(); + break; + case FACE_CRC_TABLE_ENTRY: + if (il_crc) { + link = command->AddLink(0, ltOffset, il_crc->table_entry()); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_CRC_TABLE_SIZE: + if (il_crc) { + link = command->AddLink(0, ltOffset, il_crc->size_entry()); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_CRC_TABLE_HASH: + if (il_crc) { + link = command->AddLink(0, ltOffset, il_crc->hash_entry()); + link->set_sub_value(image_base); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_CORE_OPTIONS: + { + uint32_t options = 0; + if (ctx.options.flags & cpInternalMemoryProtection) + options |= CORE_OPTION_MEMORY_PROTECTION; + if (ctx.options.flags & cpCheckDebugger) + options |= CORE_OPTION_CHECK_DEBUGGER; + command->set_operand_value(0, options); + } + command->CompileToNative(); + break; + } + } + } + } + + return true; +} + +size_t ILRuntimeData::WriteToFile(IArchitecture &file) +{ + size_t res = ILFunction::WriteToFile(file); + + CipherRC5 cipher(rc5_key_); + for (size_t i = 0; i < 3; i++) { + ILCommand *command; + size_t size; + + switch (i) { + case 0: + command = strings_entry_; + size = strings_size_; + break; + case 1: + command = trial_hwid_entry_; + size = trial_hwid_entry_ ? trial_hwid_entry_->dump_size() : 0; + break; + case 2: + command = resources_entry_; + size = resources_size_; + break; + +#ifdef ULTIMATE + /* + case 2: + command = license_data_entry_; + size = license_data_size_; + break; + */ +#endif + default: + command = NULL; + size = 0; + } + + if (size) { + std::vector<uint8_t> buff; + buff.resize(size); + file.AddressSeek(command->address()); + uint64_t pos = file.Tell(); + file.Read(buff.data(), buff.size()); + cipher.Encrypt(buff.data(), buff.size()); + file.Seek(pos); + file.Write(buff.data(), buff.size()); + } + } + + return res; +} + +/** +* ILRuntimeCRCTable +*/ + +ILRuntimeCRCTable::ILRuntimeCRCTable(IFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size), cryptor_(NULL) +{ + set_compilation_type(ctMutation); +} + +void ILRuntimeCRCTable::clear() +{ + region_info_list_.clear(); + ILFunction::clear(); +} + +bool ILRuntimeCRCTable::Compile(const CompileContext &ctx) +{ + ILFunctionList *function_list = reinterpret_cast<ILFunctionList *>(ctx.file->function_list()); + cryptor_ = function_list->crc_cryptor(); + + size_t block_size, i, j, k; + uint64_t block_address; + MemoryManager manager(ctx.file); + + for (i = 0; i < function_list->count(); i++) { + ILFunction *func = function_list->item(i); + if (!func->need_compile()) + continue; + + for (j = 0; j < func->block_list()->count(); j++) { + CommandBlock *block = func->block_list()->item(j); + if (block->type() & mtExecutable) { + // native block + block_size = 0; + block_address = 0; + for (k = block->start_index(); k <= block->end_index(); k++) { + ILCommand *command = func->item(k); + if (command->options() & roWritable) + continue; + + if (block_address && (block_address + block_size) != command->address()) { + if (block_size) + manager.Add(block_address, block_size, mtReadable); + block_address = 0; + block_size = 0; + } + if (!block_address) + block_address = command->address(); + block_size += command->dump_size(); + } + if (block_size) + manager.Add(block_address, block_size, mtReadable); + } + else { + // VM block + block_size = 0; + block_address = 0; + for (k = block->start_index(); k <= block->end_index(); k++) { + ILCommand *command = func->item(k); + + if (block_address && (block_address + block_size) != command->vm_address()) { + if (block_size) + manager.Add(block_address, block_size, mtReadable); + block_address = 0; + block_size = 0; + } + if (!block_address) + block_address = command->vm_address(); + block_size += command->vm_dump_size(); + } + if (block_size) + manager.Add(block_address, block_size, mtReadable); + } + } + } + if (manager.count() == 0) + return true; + + manager.Pack(); + + for (i = 0; i < manager.count(); i++) { + MemoryRegion *region = manager.item(i); + uint64_t block_address = region->address(); + + size_t region_size, block_size; + for (region_size = region->size(); region_size != 0; region_size -= block_size, block_address += block_size) { + block_size = 0x1000 - (rand() & 0xff); + if (block_size > region_size) + block_size = region_size; + + region_info_list_.push_back(RegionInfo(block_address, static_cast<uint32_t>(block_size), false)); + } + } + + for (i = 0; i < region_info_list_.size(); i++) { + std::swap(region_info_list_[i], region_info_list_[rand() % region_info_list_.size()]); + } + + size_t self_crc_offset = 0; + size_t self_crc_size = 0; + for (i = 0; i < region_info_list_.size(); i++) { + self_crc_size += sizeof(CRCInfo::POD); + if (self_crc_size > 0x1000 && (rand() & 1)) { + region_info_list_.insert(region_info_list_.begin() + i + 1, RegionInfo(self_crc_offset, (uint32_t)self_crc_size, true)); + self_crc_offset += self_crc_size; + self_crc_size = 0; + } + } + if (self_crc_size) + region_info_list_.push_back(RegionInfo(self_crc_offset, (uint32_t)self_crc_size, true)); + + for (i = 0; i < region_info_list_.size(); i++) { + AddCommand(icDword, 0); + AddCommand(icDword, 0); + AddCommand(icDword, 0); + } + set_entry(item(0)); + for (i = 0; i < count(); i++) { + item(i)->CompileToNative(); + } + + CreateBlocks(); + + for (i = 0; i < block_list()->count(); i++) { + block_list()->item(i)->Compile(*ctx.manager); + } + + return true; +} + +size_t ILRuntimeCRCTable::WriteToFile(IArchitecture &file) +{ + size_t res = ILFunction::WriteToFile(file); + + if (entry()) { + uint64_t address = entry()->address(); + std::vector<CRCInfo> crc_info_list; + std::vector<uint8_t> dump; + for (size_t i = 0; i < region_info_list_.size(); i++) { + RegionInfo region_info = region_info_list_[i]; + + dump.resize(region_info.size); + if (region_info.is_self_crc) { + memcpy(&dump[0], reinterpret_cast<uint8_t *>(&crc_info_list[0]) + region_info.address, dump.size()); + region_info.address += address; + } + else { + file.AddressSeek(region_info.address); + file.Read(&dump[0], dump.size()); + } + + CRCInfo crc_info(static_cast<uint32_t>(region_info.address - file.image_base()), dump); + if (cryptor_) { + crc_info.pod.address = static_cast<uint32_t>(cryptor_->Encrypt(crc_info.pod.address)); + crc_info.pod.size = static_cast<uint32_t>(cryptor_->Encrypt(crc_info.pod.size)); + } + crc_info.pod.hash = 0 - crc_info.pod.hash; + crc_info_list.push_back(crc_info); + } + + file.AddressSeek(address); + file.Write(&crc_info_list[0], crc_info_list.size() * sizeof(CRCInfo::POD)); + } + + return res; +} + +/** + * ILFileHelper + */ + +ILFileHelper::ILFileHelper() + : IObject(), marker_index_(0), marker_name_list_(NULL) +{ +} + +ILFileHelper::~ILFileHelper() +{ + +} + +void ILFileHelper::Parse(NETArchitecture &file) +{ + size_t i, j; + ILToken *token; + ILFunction func(NULL, file.cpu_address_size()); + std::set<uint64_t> address_list; + + size_t c = file.map_function_list()->count(); + file.StartProgress(string_format("%s %s...", language[lsLoading].c_str(), os::ExtractFileName(file.owner()->file_name().c_str()).c_str()), c); + for (i = 0; i < c; i++) { + MapFunction *map_function = file.map_function_list()->item(i); + file.StepProgress(); + + if (map_function->type() != otCode && map_function->type() != otMarker && map_function->type() != otExport) + continue; + + if (address_list.find(map_function->address()) != address_list.end()) + continue; + + address_list.insert(map_function->address()); + func.ReadFromFile(file, map_function->address()); + for (j = 0; j < func.count(); j++) { + ILCommand *command = func.item(j); + uint32_t value = static_cast<uint32_t>(command->operand_value()); + if (command->type() == icComment) { + if (command->comment().value.substr(0, 7) == ".locals") { + token = file.command_list()->token(value); + if (token) + token->reference_list()->Add(command->address()); + } + } else if (command->type() == icDword) { + if (command->comment().value == "ClassToken") { + token = file.command_list()->token(value); + if (token) + token->reference_list()->Add(command->address()); + } + } else switch (ILOpCodes[command->type()].operand_type) { + case InlineString: + token = file.command_list()->token(value); + if (!token) + token = file.command_list()->us_table()->Add(value); + command->set_token_reference(token->reference_list()->Add(command->address() + command->operand_pos())); + if (map_function->strings_protection()) + AddString(file, static_cast<uint32_t>(command->operand_value()), command->address()); + break; + case InlineField: + case InlineMethod: + case InlineSig: + case InlineTok: + case InlineType: + token = file.command_list()->token(value); + if (token) { + command->set_token_reference(token->reference_list()->Add(command->address() + command->operand_pos(), command->type())); + NETImportFunction *import_function = file.import_list()->GetFunctionByToken(value); + if (import_function) { + import_function->map_function()->reference_list()->Add(command->address(), 0); + if (ILOpCodes[command->type()].flow_type == Call) { + if (j > 0 && ILOpCodes[func.item(j - 1)->type()].opcode_type == Prefix) + import_function->include_option(ioHasCallPrefix); + } + + if (import_function->owner()->is_sdk()) { + switch (import_function->type()) { + case atDecryptStringA: + case atDecryptStringW: + if (command->type() == icCall && j > 0) { + ILCommand *prev = func.item(j - 1); + if (prev->type() == icLdstr) + AddString(file, static_cast<uint32_t>(prev->operand_value()), prev->address()); + } + break; + } + } + } + } + break; + } + } + + ILCommandBlock block; + if (block.Parse(func)) { + for (j = 0; j < block.count(); j++) { + ILCommandNode *node = block.item(j); + ILCommand *command = node->command(); + switch (command->type()) { + case icCall: case icNewobj: + { + std::string name = node->token_name(); + if (name == "instance void System.Runtime.InteropServices.ComAwareEventInfo::.ctor(class System.Type, string)") { + auto stack = node->stack(); + token = block.GetTypeOf(stack[0]); + if (token && token->type() == ttTypeDef) { + ILTypeDef *type_def = reinterpret_cast<ILTypeDef*>(token); + if (stack[1]->command()->type() == icLdstr) { + if (ILEvent *event = type_def->GetEvent(reinterpret_cast<ILUserString*>(stack[1]->command()->token_reference()->owner()->owner())->name())) + event->set_can_rename(false); + } + else { + ILTable *ref_table = file.command_list()->table(ttEvent); + for (size_t r = 0; r < ref_table->count(); r++) { + ILEvent *event = reinterpret_cast<ILEvent *>(ref_table->item(r)); + if (event->declaring_type() == type_def) + event->set_can_rename(false); + } + } + } + } + else if (name.size() > 58 && name.substr(0, 58) == "string Newtonsoft.Json.JsonConvert::SerializeObject(object") { + auto stack = node->stack(); + token = block.GetTypeFromStack(stack[0]); + if (token && token->type() == ttTypeDef) { + ILTypeDef *type_def = reinterpret_cast<ILTypeDef*>(token); + ILTable *ref_table = file.command_list()->table(ttProperty); + for (size_t r = 0; r < ref_table->count(); r++) { + ILProperty *property = reinterpret_cast<ILProperty*>(ref_table->item(r)); + if (property->declaring_type() == type_def) + property->set_can_rename(false); + } + } + } + } + break; + } + } + } + } + + file.EndProgress(); +} + +void ILFileHelper::AddString(NETArchitecture &file, uint32_t token, uint64_t reference) +{ + if (TOKEN_TYPE(token) != ttUserString) + return; + + uint64_t address; + ILData dump = file.command_list()->GetUserData(TOKEN_VALUE(token), &address); + if (dump.empty()) + return; + + std::string name = "string \"" + file.command_list()->GetUserString(TOKEN_VALUE(token)) + "\""; + MapFunction *map_function = file.map_function_list()->Add(address, address + dump.size(), otString, name); + map_function->reference_list()->Add(reference, address); +} + +/** +* ILCommandNode +*/ + +ILCommandNode::ILCommandNode(ILCommandBlock *owner, ILCommand *command) + : IObject(), owner_(owner), command_(command) +{ + +} + +ILCommandNode::~ILCommandNode() +{ + if (owner_) + owner_->RemoveObject(this); +} + +std::string ILCommandNode::token_name() const +{ + if (command_->token_reference()) { + ILToken *token = command_->token_reference()->owner()->owner(); + if (token->type() == ttMethodSpec) + token = reinterpret_cast<ILMethodSpec*>(token)->parent(); + + switch (token->type()) { + case ttMemberRef: + return reinterpret_cast<ILMemberRef*>(token)->full_name(); + } + } + + return std::string(); +} + +/** +* ILCommandBlock +*/ + +ILCommandBlock::ILCommandBlock() + : ObjectList<ILCommandNode>(), method_(NULL) +{ + +} + +ILCommandNode *ILCommandBlock::Add(ILCommand *command) +{ + ILCommandNode *node = new ILCommandNode(this, command); + AddObject(node); + return node; +} + +ILCommandNode *ILCommandBlock::GetNodeByCommand(ILCommand *command) const +{ + auto it = map_.find(command); + return (it != map_.end()) ? it->second : NULL; +} + +void ILCommandBlock::AddObject(ILCommandNode *node) +{ + ObjectList<ILCommandNode>::AddObject(node); + if (node->command()) + map_[node->command()] = node; +} + +ILToken *ILCommandBlock::GetTypeOf(ILCommandNode *node) const +{ + if (node->command()->type() == icCall) { + if (node->token_name() == "class System.Type System.Type::GetTypeFromHandle(valuetype System.RuntimeTypeHandle)") { + auto stack = node->stack(); + if (stack[0]->command()->type() == icLdtoken) + return stack[0]->command()->token_reference()->owner()->owner(); + } + } + + return NULL; +} + +ILToken *ILCommandBlock::GetTypeFromStack(ILCommandNode *node) const +{ + switch (node->command()->type()) { + case icLdarg_0: + if (method_ && method_->signature()->has_this()) + return method_->declaring_type(); + break; + case icDup: + return GetTypeFromStack(node->stack()[0]); + case icNewobj: + { + ILToken *token = node->command()->token_reference()->owner()->owner(); + switch (token->type()) { + case ttMethodDef: + return reinterpret_cast<ILMethodDef*>(token)->declaring_type(); + case ttMemberRef: + return reinterpret_cast<ILMemberRef*>(token)->declaring_type(); + } + } + break; + } + return NULL; +} + +bool ILCommandBlock::Parse(ILFunction &func) +{ + size_t i, j, c; + ILCommand *command; + std::set<ILCommand *> entry_list; + std::vector<ILCommandNode *> command_stack; + std::map<ILCommand *, std::vector<ILCommandNode *> > stack_map; + + for (i = 0; i < func.function_info_list()->count(); i++) { + FunctionInfo *info = func.function_info_list()->item(i); + if (!info->source()) + continue; + + command = reinterpret_cast<ILCommand *>(info->entry()); + entry_list.insert(command); + method_ = reinterpret_cast<NETRuntimeFunction*>(info->source())->method(); + } + + command_stack.push_back(NULL); + for (i = 0; i < func.link_list()->count(); i++) { + CommandLink *link = func.link_list()->item(i); + switch (link->type()) { + case ltSEHBlock: + command = func.GetCommandByAddress(link->to_address()); + if (command) { + entry_list.insert(command); + stack_map[command] = command_stack; + } + break; + case ltFinallyBlock: + command = func.GetCommandByAddress(link->to_address()); + if (command) + entry_list.insert(command); + break; + } + } + + while (!entry_list.empty()) { + command = *entry_list.begin(); + j = func.IndexOf(command); + + auto it = stack_map.find(command); + if (it != stack_map.end()) + command_stack = it->second; + else + command_stack.clear(); + + for (i = j; i < func.count(); i++) { + command = func.item(i); + std::set<ILCommand *>::const_iterator it = entry_list.find(command); + if (it != entry_list.end()) + entry_list.erase(it); + + ILCommandNode *node = Add(command); + + if (command->type() == icRet) { + if (command_stack.size() > 1) + return false; + + node->set_stack(command_stack); + break; + } + + size_t pop; + int stack = command->GetStackLevel(&pop); + + if (pop) { + if (pop > command_stack.size()) + return false; + + std::vector<ILCommandNode *> node_stack; + node_stack.insert(node_stack.begin(), command_stack.end() - pop, command_stack.end()); + command_stack.erase(command_stack.end() - pop, command_stack.end()); + node->set_stack(node_stack); + } + + for (c = 0; c < stack + pop; c++) { + command_stack.push_back(node); + } + + if (command->link() && (command->link()->type() == ltJmp || command->link()->type() == ltJmpWithFlag)) { + if (ILCommand *link_command = func.GetCommandByAddress(command->link()->to_address())) { + if (!GetNodeByCommand(link_command)) { + entry_list.insert(link_command); + stack_map[link_command] = command_stack; + } + } + } + + if (command->is_end()) + break; + } + } + + return true; +} + +/** +* ILImport +*/ + +ILImport::ILImport(IFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size) +{ + set_compilation_type(ctMutation); + +} + +bool ILImport::Init(const CompileContext &ctx) +{ + NETArchitecture *file = reinterpret_cast<NETArchitecture *>(ctx.file); + NETArchitecture *runtime = reinterpret_cast<NETArchitecture *>(ctx.runtime); + ILTypeDef *module = reinterpret_cast<ILTypeDef*>(file->command_list()->token(ttTypeDef | 1)); + ILTypeDef *runtime_loader = runtime->command_list()->GetTypeDef("VMProtect.Loader"); + if (!runtime_loader) + return false; + + ILField *iat_field = runtime_loader->GetField("IAT"); + if (!iat_field) + return false; + + size_t i, j, k, c; + std::map<ILToken *, bool> value_type_map; + ILTokenType table_types[] = {ttMemberRef, ttStandAloneSig, ttField, ttMethodDef}; + for (i = 0; i < _countof(table_types); i++) { + ILTable *table = module->meta()->table(table_types[i]); + for (k = 0; k < table->count(); k++) { + ILToken *token = table->item(k); + ILSignature *signature = NULL; + switch (token->type()) { + case ttMemberRef: + signature = reinterpret_cast<ILMemberRef *>(token)->signature(); + break; + case ttStandAloneSig: + signature = reinterpret_cast<ILStandAloneSig *>(token)->signature(); + break; + case ttField: + signature = reinterpret_cast<ILField *>(token)->signature(); + break; + case ttMethodDef: + signature = reinterpret_cast<ILMethodDef *>(token)->signature(); + break; + } + + if (!signature) + continue; + + std::vector<ILElement *> element_stack; + element_stack.push_back(signature->ret()); + for (c = 0; c < signature->count(); c++) { + element_stack.push_back(signature->item(c)); + } + for (c = 0; c < element_stack.size(); c++) { + ILElement *element = element_stack[c]; + if (element->type() == ELEMENT_TYPE_CLASS) + value_type_map[element->token()] = false; + else if (element->type() == ELEMENT_TYPE_VALUETYPE) + value_type_map[element->token()] = true; + if (element->next()) + element_stack.push_back(element->next()); + } + } + } + + std::vector<NETImportFunction *> import_list; + for (i = 0; i < file->import_list()->count(); i++) { + NETImport *import = file->import_list()->item(i); + + // APIs processed by ILSDK + if (import->is_sdk()) + continue; + + if (import->excluded_from_import_protection()) + continue; + + for (j = 0; j < import->count(); j++) { + NETImportFunction *import_function = import->item(j); + if (import_function->options() & ioHasCallPrefix) + continue; + + import_list.push_back(import_function); + } + } + for (i = 0; i < import_list.size(); i++) { + std::swap(import_list[i], import_list[rand() % import_list.size()]); + } + + size_t iat_index = 0; + ILTypeRef *delegate_base_type = NULL; + for (i = 0; i < import_list.size(); i++) { + NETImportFunction *import_function = import_list[i]; + ILToken *import_token = file->command_list()->token(import_function->token()); + ILSignature *signature; + ILToken *declaring_type; + switch (import_token->type()) { + case ttMemberRef: + signature = reinterpret_cast<ILMemberRef*>(import_token)->signature(); + declaring_type = reinterpret_cast<ILMemberRef*>(import_token)->declaring_type(); + break; + default: + continue; + } + + if (declaring_type->type() != ttTypeRef) + continue; + + MapFunction *map_function = import_function->map_function(); + ReferenceList *reference_list = map_function->reference_list(); + + std::map<ILCommandType, ILMethodDef *> proxy_map; + for (j = 0; j < reference_list->count(); j++) { + uint64_t address = reference_list->item(j)->address(); + + if (!file->AddressSeek(address)) + return false; + + ILCommand *src_command = reinterpret_cast<ILCommand *>(ctx.file->function_list()->GetCommandByAddress(address, true)); + + size_t index = count(); + ILCommand *ref_command = Add(address); + ref_command->ReadFromFile(*file); + ILCommandType ref_type = static_cast<ILCommandType>(ref_command->type()); + if (ref_type != icNewobj && ref_type != icCall && ref_type != icCallvirt && ref_type != icLdsfld && ref_type != icLdfld) { + delete ref_command; + continue; + } + + ILMethodDef *proxy_method; + std::map<ILCommandType, ILMethodDef *>::const_iterator it = proxy_map.find(ref_type); + if (it == proxy_map.end()) { + ILSignature *new_signature; + if (signature->is_field()) { + ILData data; + data.push_back(stDefault); + data.push_back(0); + signature->ret()->WriteToData(data); + new_signature = new ILSignature(module->meta()); + new_signature->Parse(data); + if (ref_type == icLdfld) + new_signature->set_has_this(true); + } + else { + new_signature = signature->Clone(module->meta()); + } + + if (new_signature->has_this()) { + std::map<ILToken *, bool>::const_iterator it = value_type_map.find(declaring_type); + if (it == value_type_map.end()) { + delete ref_command; + continue; + } + bool is_value_type = it->second; + + ILData data; + if (is_value_type) { + if (ref_type != icNewobj && ref_type != icLdfld) + data.push_back(ELEMENT_TYPE_BYREF); + data.push_back(ELEMENT_TYPE_VALUETYPE); + } + else { + data.push_back(ELEMENT_TYPE_CLASS); + } + uint32_t value = declaring_type->value() << 2; + switch (declaring_type->type()) { + case ttTypeDef: + value |= 0; + break; + case ttTypeRef: + value |= 1; + break; + case ttTypeSpec: + value |= 2; + break; + } + data.push_back(static_cast<uint8_t>(value >> 24) | 0xc0); + data.push_back(static_cast<uint8_t>(value >> 16)); + data.push_back(static_cast<uint8_t>(value >> 8)); + data.push_back(static_cast<uint8_t>(value)); + + if (ref_type == icNewobj) + new_signature->ret()->Parse(data); + else { + ILElement *element = new ILElement(module->meta(), new_signature); + element->Parse(data); + new_signature->InsertObject(0, element); + } + } + + ILData proxy_signature; + { + ILData data; + data.push_back(ELEMENT_TYPE_OBJECT); + ILElement *element = new_signature->ret(); + switch (element->type()) { + case ELEMENT_TYPE_CLASS: + case ELEMENT_TYPE_SZARRAY: + element->Parse(data); + break; + case ELEMENT_TYPE_GENERICINST: + if (element->next()->type() == ELEMENT_TYPE_CLASS) + element->Parse(data); + break; + } + + if (new_signature->has_this()) { + new_signature->set_has_this(false); + for (k = 0; k < new_signature->count(); k++) { + element = new_signature->item(k); + switch (element->type()) { + case ELEMENT_TYPE_CLASS: + case ELEMENT_TYPE_SZARRAY: + element->Parse(data); + break; + case ELEMENT_TYPE_GENERICINST: + if (element->next()->type() == ELEMENT_TYPE_CLASS) + element->Parse(data); + break; + } + } + } + } + new_signature->WriteToData(proxy_signature); + delete new_signature; + + if (!delegate_base_type) { + ILAssemblyRef *assembly_ref = module->meta()->GetCoreLib(); + delegate_base_type = module->meta()->ImportTypeRef(assembly_ref, "System", "MulticastDelegate"); + } + + ILTypeDef *delegate_type = module->meta()->AddTypeDef(delegate_base_type, "", "", (CorTypeAttr)(tdNotPublic | tdSealed)); + file->RenameToken(delegate_type); + + ILData ctor_signature; // instance void (object, native int) + ctor_signature.push_back(stDefault | stHasThis); + ctor_signature.push_back(2); + ctor_signature.push_back(ELEMENT_TYPE_VOID); + ctor_signature.push_back(ELEMENT_TYPE_OBJECT); + ctor_signature.push_back(ELEMENT_TYPE_I); + + ILMethodDef *delegate_ctor = module->meta()->AddMethod(delegate_type, ".ctor", ctor_signature, (CorMethodAttr)(mdAssem | mdHideBySig | mdRTSpecialName | mdSpecialName), miRuntime); + ILMethodDef *delegate_invoke = module->meta()->AddMethod(delegate_type, "Invoke", proxy_signature, (CorMethodAttr)(mdAssem | mdHideBySig | mdVirtual | mdNewSlot), miRuntime); + delegate_invoke->signature()->set_has_this(true); + + uint32_t call_type; + switch (ref_type) { + case icNewobj: + call_type = 1; + break; + case icCallvirt: + call_type = 2; + break; + case icLdsfld: + call_type = 8; + break; + case icLdfld: + call_type = 9; + break; + default: + call_type = 0; + break; + } + info_list_.push_back(ImportDelegateInfo(import_token, delegate_invoke, call_type)); + + proxy_method = module->meta()->AddMethod(module, "", proxy_signature, (CorMethodAttr)(mdAssem | mdStatic), miIL); + file->RenameToken(proxy_method); + + size_t entry_index = count(); + // header + ILCommand *command = AddCommand(icComment, 0); + command->include_section_option(rtLinkedToExt); + Data data; + data.PushByte(CorILMethod_TinyFormat); + command->set_dump(data.data(), data.size()); + command->set_alignment(sizeof(uint32_t)); + // code + command = AddCommand(icLdsfld, 0); + command->set_token_reference(iat_field->reference_list()->Add(0)); + AddCommand(icLdc_i4, static_cast<uint32_t>(iat_index++)); + AddCommand(icLdelem_ref, 0); + for (k = 0; k < proxy_method->signature()->count(); k++) { + AddCommand(icLdarg, static_cast<uint32_t>(k)); + } + command = AddCommand(icCall, 0); + command->set_token_reference(delegate_invoke->reference_list()->Add(0)); + AddCommand(icRet, 0); + + FunctionInfo *info = function_info_list()->Add(0, 0, btValue, item(entry_index)->dump_size(), 0, 0, runtime->runtime_function_list()->Add(0, 0, 0, proxy_method), item(entry_index)); + AddressRange *range = info->Add(0, 0, NULL, NULL, NULL); + for (k = entry_index; k < count(); k++) { + item(k)->set_address_range(range); + } + + proxy_map[ref_type] = proxy_method; + } + else { + proxy_method = it->second; + } + + if (src_command) { + delete ref_command; + + src_command->Init(icCall, 0, src_command->token_reference()); + src_command->CompileToNative(); + src_command->token_reference()->set_owner(proxy_method->reference_list()); + } + else { + ref_command->exclude_option(roClearOriginalCode); + ref_command->Init(icCall, 0, ref_command->token_reference()); + ref_command->CompileToNative(); + ref_command->token_reference()->set_owner(proxy_method->reference_list()); + + CommandBlock *block = AddBlock(index, true); + block->set_address(address); + ref_command->set_block(block); + } + } + } + + for (i = 0; i < count(); i++) { + item(i)->CompileToNative(); + } + + return ILFunction::Init(ctx); +} + +/** +* ILVirtualMachine +*/ + +ILVirtualMachine::ILVirtualMachine(ILVirtualMachineList *owner, uint8_t id, ILVirtualMachineProcessor *processor) + : BaseVirtualMachine(owner, id), processor_(processor), ctor_(NULL), invoke_(NULL) +{ + +} + +void ILVirtualMachine::Init(const CompileContext &ctx) +{ + processor_->InitCommands(ctx); + ctor_ = processor_->function_info_list()->count() > 0 ? reinterpret_cast<NETRuntimeFunction *>(processor_->function_info_list()->item(0)->source())->method() : NULL; + invoke_ = processor_->function_info_list()->count() > 1 ? reinterpret_cast<NETRuntimeFunction *>(processor_->function_info_list()->item(1)->source())->method() : NULL; + + size_t i, j, c; + ILCommand *command; + ILOpcodeInfo *opcode; + size_t template_index, template_count; + + template_index = 0; + template_count = 0; + for (i = 0; i < processor_->count(); i++) { + command = processor_->item(i); + if (command->type() != icLdftn) + continue; + + template_index = i - 4; + for (j = i; j < processor_->count(); j++) { + command = processor_->item(j); + if (command->type() != icLdftn) + continue; + + if (!template_count && j > i) + template_count = j - i; + opcode_list_.Add(static_cast<ILCommandType>(processor_->item(j - 2)->operand_value()), command->token_reference()->owner()->owner()); + } + break; + } + + for (i = template_index + template_count * opcode_list_.count(); i > template_index + template_count; i--) { + command = processor_->item(i - 1); + if (command->link()) + delete command->link(); + if (command->token_reference()) + delete command->token_reference(); + delete command; + } + + // randomize opcodes + c = opcode_list_.count(); + for (i = 0; i < opcode_list_.count(); i++) { + opcode_list_.SwapObjects(i, rand() % c); + } + for (i = opcode_list_.count(); i < 0x100; i++) { + opcode = opcode_list_.item(rand() % i); + opcode_list_.Add(opcode->command_type(), opcode->entry()); + } + + opcode_stack_.clear(); + for (i = 0; i < opcode_list_.count(); i++) { + opcode = opcode_list_.item(i); + opcode->set_opcode(static_cast<uint8_t>(i)); + opcode_stack_[opcode->Key()].push_back(opcode); + + for (j = 0; j < template_count; j++) { + command = processor_->item(template_index + j); + if (i > 0) { + command = command->Clone(processor_); + processor_->InsertObject(template_index + i * template_count + j, command); + } + switch (command->type()) { + case icLdc_i4: case icLdc_i4_s: + command->Init(icLdc_i4, opcode->opcode()); + command->CompileToNative(); + break; + case icLdftn: + command->set_operand_value(0, opcode->entry()->id()); + command->set_token_reference(opcode->entry()->reference_list()->Add(0)); + command->CompileToNative(); + break; + default: + if (command->token_reference()) + command->set_token_reference(command->token_reference()->owner()->Add(0)); + } + } + } +} + +ILOpcodeInfo *ILVirtualMachine::GetOpcode(ILCommandType command_type) +{ + ILOpcodeInfo *res = NULL; + auto it = opcode_stack_.find(command_type); + if (it != opcode_stack_.end()) + res = it->second.Next(); + return res; +} + +static void EncryptBuffer(uint32_t *buffer, uint64_t key) +{ + uint32_t key0 = static_cast<uint32_t>(key >> 32); + uint32_t key1 = static_cast<uint32_t>(key); + buffer[0] = _rotr32(buffer[0] - key0, 7) ^ key1; + buffer[1] = _rotr32(buffer[1] - key0, 11) ^ key1; + buffer[2] = _rotr32(buffer[2] - key0, 17) ^ key1; + buffer[3] = _rotr32(buffer[3] - key0, 23) ^ key1; +} + +void ILVirtualMachine::CompileCommand(ILVMCommand &vm_command) +{ + Data dump; + ILOpcodeInfo *opcode = NULL; + uint64_t value = vm_command.value(); + if (vm_command.crypt_command() == icAdd) { + uint32_t crypted_value[4]; + size_t i; + for (i = 0; i < _countof(crypted_value); i++) { + crypted_value[i] = rand32(); + } + switch (vm_command.crypt_size()) { + case osDWord: + crypted_value[3] = static_cast<uint32_t>(value); + break; + case osQWord: + *reinterpret_cast<uint64_t*>(&crypted_value[2]) = value; + break; + } + uint32_t dw = 0; + for (i = 1; i < 4; i++) { + dw += crypted_value[i]; + } + crypted_value[0] = 0 - dw; + EncryptBuffer(crypted_value, vm_command.crypt_key()); + ILVMCommand *link_command = vm_command.link_command(); + for (i = 3; i > 0; i--) { + link_command->set_value(crypted_value[i - 1]); + link_command->Compile(); + link_command = link_command->link_command(); + } + value = crypted_value[3]; + } + + switch (vm_command.command_type()) { + case icLdarg: case icLdarga: + case icStarg: + case icLdloc: case icLdloca: + case icStloc: + opcode = GetOpcode(vm_command.command_type()); + dump.PushWord(static_cast<uint16_t>(vm_command.value())); + break; + case icLdc_i4: + opcode = GetOpcode(vm_command.command_type()); + dump.PushDWord(static_cast<uint32_t>(value)); + break; + case icLdc_i8: + opcode = GetOpcode(vm_command.command_type()); + dump.PushQWord(value); + break; + case icLdc_r4: + opcode = GetOpcode(vm_command.command_type()); + dump.PushDWord(static_cast<uint32_t>(value)); + break; + case icLdc_r8: + opcode = GetOpcode(vm_command.command_type()); + dump.PushQWord(value); + break; + case icByte: + dump.PushByte(static_cast<uint8_t>(vm_command.value())); + break; + case icWord: + dump.PushWord(static_cast<uint16_t>(vm_command.value())); + break; + case icDword: + dump.PushDWord(static_cast<uint32_t>(vm_command.value())); + break; + case icQword: + dump.PushQWord(vm_command.value()); + break; + default: + opcode = GetOpcode(vm_command.command_type()); + break; + } + + if (opcode) { + dump.InsertByte(0, opcode->opcode()); + } + else if (!vm_command.is_data()) { + throw std::runtime_error("Runtime error at CompileToVM: " + std::string(ILOpCodes[vm_command.command_type()].name)); + } + + vm_command.set_dump(dump); +} + +/** +* ILOpcodeInfo +*/ + +ILOpcodeInfo::ILOpcodeInfo(ILOpcodeList *owner, ILCommandType command_type, ILToken *entry) + : IObject(), owner_(owner), command_type_(command_type), entry_(entry), opcode_(0) +{ + +} + +ILOpcodeInfo::~ILOpcodeInfo() +{ + if (owner_) + owner_->RemoveObject(this); +} + +ILOpcodeInfo *ILOpcodeInfo::circular_queue::Next() +{ + ILOpcodeInfo *res = NULL; + if (size()) + res = this->operator[](position_++ % size()); + return res; +} + +/** +* ILOpcodeList +*/ + +ILOpcodeList::ILOpcodeList() + : ObjectList<ILOpcodeInfo>() +{ + +} + +ILOpcodeInfo *ILOpcodeList::Add(ILCommandType command_type, ILToken *entry) +{ + ILOpcodeInfo *opcode = new ILOpcodeInfo(this, command_type, entry); + AddObject(opcode); + return opcode; +} + +ILOpcodeInfo *ILOpcodeList::GetOpcodeInfo(ILCommandType command_type) const +{ + for (size_t i = 0; i < count(); i++) { + ILOpcodeInfo *opcode = item(i); + if (opcode->command_type() == command_type) + return opcode; + } + return NULL; +} + +/** + * ILVirtualMachineList + */ + +IVirtualMachineList * ILVirtualMachineList::Clone() const +{ + ILVirtualMachineList *list = new ILVirtualMachineList(); + return list; +} + +void ILVirtualMachineList::Prepare(const CompileContext &ctx) +{ + ILFunctionList *function_list = reinterpret_cast<ILFunctionList *>(ctx.file->function_list()); + ILVirtualMachineProcessor *processor = function_list->AddProcessor(ctx.file->cpu_address_size()); + ILVirtualMachine *virtual_machine = new ILVirtualMachine(this, 1, processor); + AddObject(virtual_machine); + virtual_machine->Init(ctx); +} + +/** +* ILVirtualMachineProcessor +*/ + +ILVirtualMachineProcessor::ILVirtualMachineProcessor(ILFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size) +{ + set_compilation_type(ctMutation); + set_tag(ftProcessor); +} + +void ILVirtualMachineProcessor::InitCommands(const CompileContext &ctx) +{ + size_t i, j, k; + ILCommand *command, *src_command, *dst_command; + CommandLink *src_link, *dst_link; + + ILFunctionList *runtime_function_list = reinterpret_cast<ILFunctionList *>(ctx.vm_runtime->function_list()); + for (i = 0; i < runtime_function_list->count(); i++) { + ILFunction *func = runtime_function_list->item(i); + if (func->tag() != ftProcessor) + continue; + + //func->Init(ctx); + + size_t orig_function_info_count = function_info_list()->count(); + for (j = 0; j < func->function_info_list()->count(); j++) { + FunctionInfo *info = func->function_info_list()->item(j); + function_info_list()->AddObject(info->Clone(function_info_list())); + } + for (j = 0; j < func->range_list()->count(); j++) { + AddressRange *range = func->range_list()->item(j); + range_list()->AddObject(range->Clone(range_list())); + } + + for (j = 0; j < func->count(); j++) { + src_command = func->item(j); + dst_command = src_command->Clone(this); + AddressRange *address_range = src_command->address_range(); + if (address_range) { + FunctionInfo *info = function_info_list()->item(orig_function_info_count + func->function_info_list()->IndexOf(address_range->owner())); + dst_command->set_address_range(info->item(address_range->owner()->IndexOf(address_range))); + } + + AddObject(dst_command); + + src_link = src_command->link(); + if (src_link) { + dst_link = src_link->Clone(link_list()); + dst_link->set_from_command(dst_command); + link_list()->AddObject(dst_link); + + if (src_link->parent_command()) + dst_link->set_parent_command(GetCommandByAddress(src_link->parent_command()->address())); + if (src_link->base_function_info()) + dst_link->set_base_function_info(function_info_list()->GetItemByAddress(src_link->base_function_info()->begin())); + } + } + } + + for (i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + if (info->entry()) + info->set_entry(GetCommandByAddress(info->entry()->address())); + if (info->data_entry()) + info->set_data_entry(GetCommandByAddress(info->data_entry()->address())); + for (j = 0; j < info->count(); j++) { + AddressRange *dest = info->item(j); + for (k = 0; k < range_list()->count(); k++) { + AddressRange *range = range_list()->item(k); + if (range->begin() <= dest->begin() && range->end() > dest->begin()) + dest->AddLink(range); + } + } + } + for (i = 0; i < range_list()->count(); i++) { + AddressRange *range = range_list()->item(i); + if (range->begin_entry()) + range->set_begin_entry(GetCommandByAddress(range->begin_entry()->address())); + if (range->end_entry()) + range->set_end_entry(GetCommandByAddress(range->end_entry()->address())); + if (range->size_entry()) + range->set_size_entry(GetCommandByAddress(range->size_entry()->address())); + } + for (i = 0; i < count(); i++) { + command = item(i); + dst_link = command->link(); + if (dst_link) { + if (dst_link->to_address()) + dst_link->set_to_command(GetCommandByAddress(dst_link->to_address())); + } + if (command->token_reference()) + command->token_reference()->set_address(0); + command->exclude_option(roClearOriginalCode); + command->CompileToNative(); + } +} + +void ILVirtualMachineProcessor::AfterCompile(const CompileContext &ctx) +{ + ILFunction::AfterCompile(ctx); + + if (ctx.runtime) + set_need_compile(false); +} + +void ILVirtualMachineProcessor::CompileLinks(const CompileContext &ctx) +{ + if (!need_compile()) + return; + + ILFunction::CompileLinks(ctx); +} + +void ILVirtualMachineProcessor::CompileInfo(const CompileContext &ctx) +{ + if (!need_compile()) + return; + + ILFunction::CompileInfo(ctx); +} + +size_t ILVirtualMachineProcessor::WriteToFile(IArchitecture &file) +{ + if (!need_compile()) + return 0; + + return ILFunction::WriteToFile(file); +} + +/** + * NETLoader + */ + +NETLoader::NETLoader(IFunctionList *owner, OperandSize cpu_address_size) + : ILFunction(owner, cpu_address_size), file_crc_entry_(NULL), file_crc_size_(0), + import_entry_(NULL), import_size_(0), iat_entry_(NULL), iat_size_(0), loader_crc_entry_(NULL), loader_crc_size_(0), + file_crc_size_entry_(NULL), loader_crc_size_entry_(NULL), loader_crc_hash_entry_(NULL), + pe_entry_(NULL), strong_name_signature_entry_(NULL), tls_entry_(NULL), tls_size_(0) +{ + set_compilation_type(ctVirtualization); + set_tag(ftLoader); +} + +void NETLoader::AddAVBuffer(const CompileContext &ctx) +{ + ILCommand *command; + uint32_t sum = 0; + CommandBlock *block = AddBlock(count(), true); + for (size_t i = 0; i < 64; i++) { + uint32_t value = (i == 0) ? 0 : rand32(); + sum += value; + command = AddCommand(icDword, value); + command->CompileToNative(); + command->set_block(block); + } + block->set_end_index(count() - 1); + command = item(block->start_index()); + command->set_operand_value(0, 0xB7896EB5 - sum); + command->CompileToNative(); + uint64_t address = ctx.manager->Alloc((block->end_index() - block->start_index() + 1) * sizeof(uint32_t), mtReadable); + block->set_address(address); +} + +Data EncryptString(const char *str, uint32_t key); +Data EncryptString(const os::unicode_char *str, uint32_t key); + +bool NETLoader::Prepare(const CompileContext &ctx) +{ + size_t i, j, k, old_count, index, import_index, start_index; + NETArchitecture *file, *runtime; + ILFunctionList *runtime_function_list; + ILFunction *func; + CommandLink *link, *src_link, *dst_link; + ILCommand *src_command, *dst_command, *command; + ILCRCTable *il_crc; + PEImportList new_import_list(NULL); + std::vector<ImportInfo> import_info_list; + std::vector<ImportFunctionInfo> import_function_info_list; + PEImport *import; + PEImportFunction *import_function; + ImportInfo import_info; + PESegment *segment; + ILImport *il_import; + uint64_t tls_index_address; + + file = reinterpret_cast<NETArchitecture *>(ctx.file); + runtime = reinterpret_cast<NETArchitecture *>(ctx.runtime); + il_crc = reinterpret_cast<ILFunctionList *>(file->function_list())->crc_table(); + il_import = reinterpret_cast<ILFunctionList *>(file->function_list())->import(); + PEArchitecture *pe_file = file->pe(); + uint32_t string_key = rand32(); + ILCommandType value_command_type = (cpu_address_size() == osDWord) ? icDword : icQword; + + // create AV signature buffer + AddAVBuffer(ctx); + start_index = count(); + + import_size_ = 0; + import_entry_ = 0; + PEImportFunction *entry_point_import_function = NULL; + if ((ctx.options.flags & cpPack) && pe_file->import_list()->count()) { + for (i = 0; i < pe_file->import_list()->count(); i++) { + import = pe_file->import_list()->item(i); + + new_import_list.AddObject(import->Clone(&new_import_list)); + } + + const std::string import_name = "mscoree.dll"; + const std::string import_function_name = (pe_file->image_type() == itExe) ? "_CorExeMain" : "_CorDllMain"; + + import = reinterpret_cast<PEImport *>(new_import_list.GetImportByName(import_name)); + if (!import) { + import = new PEImport(&new_import_list, import_name); + new_import_list.AddObject(import); + } + entry_point_import_function = NULL; + for (i = 0; i < import->count(); i++) { + import_function = import->item(i); + if (import_function->name() == import_function_name) { + entry_point_import_function = import_function; + break; + } + } + if (!entry_point_import_function) { + entry_point_import_function = new PEImportFunction(import, import_function_name); + import->AddObject(entry_point_import_function); + } + + // create import directory + for (i = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + + // IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk + command = AddCommand(icDword, 0); + command->AddLink(0, ltOffset); + import_info.original_first_thunk = command; + + // IMAGE_IMPORT_DESCRIPTOR.TimeDateStamp + AddCommand(icDword, 0); + + // IMAGE_IMPORT_DESCRIPTOR.ForwarderChain + AddCommand(icDword, 0); + + // IMAGE_IMPORT_DESCRIPTOR.Name + command = AddCommand(icDword, 0); + command->AddLink(0, ltOffset); + import_info.name = command; + + // IMAGE_IMPORT_DESCRIPTOR.FirstThunk + command = AddCommand(icDword, 0); + command->AddLink(0, ltOffset); + import_info.first_thunk = command; + + import_info_list.push_back(import_info); + } + + // end of import directory + for (j = 0; j < 5; j++) { + AddCommand(icDword, 0); + } + + import_size_ = static_cast<uint32_t>((count() - start_index) * sizeof(uint32_t)); + import_entry_ = item(start_index); + import_entry_->set_alignment(OperandSizeToValue(pe_file->cpu_address_size())); + + // create IAT + uint64_t ordinal_mask = (cpu_address_size() == osDWord) ? IMAGE_ORDINAL_FLAG32 : IMAGE_ORDINAL_FLAG64; + size_t name_index = count(); + for (i = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + + index = count(); + for (j = 0; j < import->count(); j++) { + import_function = import->item(j); + + if (import_function->is_ordinal()) { + command = AddCommand(value_command_type, ordinal_mask | import_function->ordinal()); + } else { + command = AddCommand(value_command_type, 0); + command->AddLink(0, ltOffset); + } + + ImportFunctionInfo import_function_info(import_function); + import_function_info.name = command; + + import_function_info_list.push_back(import_function_info); + } + + AddCommand(value_command_type, 0); + + import_info_list[i].original_first_thunk->link()->set_to_command(item(index)); + } + command = item(name_index); + command->set_alignment(OperandSizeToValue(cpu_address_size())); + + size_t iat_index = count(); + for (i = 0, import_index = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + + bool is_delay_import = (import_info_list[i].name == NULL); + + index = count(); + for (j = 0; j < import->count(); j++, import_index++) { + import_function = import->item(j); + + if (import_function->is_ordinal()) { + command = AddCommand(value_command_type, ordinal_mask | import_function->ordinal()); + } else { + command = AddCommand(value_command_type, 0); + command->AddLink(0, ltOffset); + } + + import_function_info_list[import_index].thunk = command; + } + + if (is_delay_import) + continue; + + AddCommand(value_command_type, 0); + + import_info_list[i].first_thunk->link()->set_to_command(item(index)); + } + + iat_entry_ = item(iat_index); + iat_size_ = static_cast<uint32_t>((count() - iat_index) * OperandSizeToValue(cpu_address_size())); + iat_entry_->set_alignment(file->segment_alignment()); + iat_entry_->include_option(roCreateNewBlock); + + // IAT size must be aligned by page size + j = AlignValue(iat_size_, file->segment_alignment()); + if (j > iat_size_) { + std::string buffer; + buffer.resize(j - iat_size_, 0); + AddCommand(buffer); + } + + // create import DLL names + uint32_t string_key = rand32(); + for (i = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + + command = NULL; + for (j = 0; j < i; j++) { + if (new_import_list.item(j)->CompareName(import->name())) { + command = reinterpret_cast<ILCommand *>(import_info_list[j].name->link()->to_command()); + break; + } + } + if (command == NULL) { + command = AddCommand(import->name()); + command->include_option(roCreateNewBlock); + command->set_alignment(sizeof(uint16_t)); + } + + import_info_list[i].name->link()->set_to_command(command); + } + + // create import function names + for (i = 0, import_index = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + + for (j = 0; j < import->count(); j++, import_index++) { + import_function = import->item(j); + if (import_function->is_ordinal()) + continue; + + command = AddCommand(icWord, 0); + command->include_option(roCreateNewBlock); + command->set_alignment(sizeof(uint16_t)); + + AddCommand(import_function->name()); + + import_function_info_list[import_index].name->link()->set_to_command(command); + import_function_info_list[import_index].thunk->link()->set_to_command(command); + } + } + + // update links for PE structures + for (i = 0; i < count(); i++) { + link = item(i)->link(); + if (!link) + continue; + + link->set_sub_value(file->image_base()); + } + } + + pe_entry_ = NULL; + strong_name_signature_entry_ = NULL; + if ((ctx.options.flags & cpPack)) { + if (pe_file->entry_point()) { + // create native entry point + segment = file->segment_list()->GetSectionByAddress(pe_file->entry_point()); + if (segment && !segment->excluded_from_packing()) { + std::vector<ImportFunctionInfo>::const_iterator it = std::find(import_function_info_list.begin(), import_function_info_list.end(), entry_point_import_function); + if (it == import_function_info_list.end()) + return false; + + index = count(); + CommandBlock *block = AddBlock(count(), true); + AddCommand(icWord, 0x25ff); + command = AddCommand(icDword, 0); + command->AddLink(0, ltOffset, it->thunk); + pe_entry_ = item(index); + for (i = index; i < count(); i++) { + command = item(i); + command->set_block(block); + block->set_end_index(i); + } + } + } + + IMAGE_DATA_DIRECTORY strong_name_signature = file->header().StrongNameSignature; + if (strong_name_signature.VirtualAddress) { + // create blank StrongNameSignature + segment = file->segment_list()->GetSectionByAddress(strong_name_signature.VirtualAddress + file->image_base()); + if (segment && !segment->excluded_from_packing()) { + Data data; + data.resize(strong_name_signature.Size ? strong_name_signature.Size : 0x80); + strong_name_signature_entry_ = AddCommand(data); + strong_name_signature_entry_->include_option(roCreateNewBlock); + strong_name_signature_entry_->set_alignment(sizeof(uint32_t)); + } + } + } + + // create tls structure + tls_entry_ = NULL; + tls_size_ = 0; + tls_call_back_entry_ = NULL; + tls_index_address = 0; + if (pe_file->tls_directory()->address() && (pe_file->tls_directory()->count() || (ctx.options.flags & cpPack))) { + size_t tls_index = count(); + + PETLSDirectory *tls_directory = pe_file->tls_directory(); + if (ctx.options.flags & cpPack) { + if (file->AddressSeek(tls_directory->address_of_index()) && !file->selected_segment()->excluded_from_packing()) + tls_index_address = tls_directory->address_of_index(); + } + + ILCommand *start_address_entry = AddCommand(value_command_type, tls_directory->start_address_of_raw_data(), NEED_FIXUP); + ILCommand *end_address_entry = AddCommand(value_command_type, tls_directory->end_address_of_raw_data(), NEED_FIXUP); + AddCommand(value_command_type, tls_directory->address_of_index(), NEED_FIXUP); + ILCommand *call_back_entry = AddCommand(value_command_type, 0); + AddCommand(icDword, tls_directory->size_of_zero_fill()); + AddCommand(icDword, tls_directory->characteristics()); + + if (tls_directory->end_address_of_raw_data() > tls_directory->start_address_of_raw_data()) { + Data data; + data.resize(static_cast<size_t>(tls_directory->end_address_of_raw_data() - tls_directory->start_address_of_raw_data())); + if (file->AddressSeek(tls_directory->start_address_of_raw_data())) + file->Read(&data[0], data.size()); + ILCommand *data_entry = AddCommand(data); + start_address_entry->AddLink(0, ltOffset, data_entry); + link = end_address_entry->AddLink(0, ltOffset, data_entry); + link->set_sub_value(0 - (uint64_t)data.size()); + } + + index = count(); + if (pe_file->tls_directory()->count()) { + tls_call_back_entry_ = AddCommand(value_command_type, 0, NEED_FIXUP); + tls_call_back_entry_->AddLink(0, ltGateOffset); + } + for (i = 0; i < tls_directory->count(); i++) { + AddCommand(icDword, tls_directory->item(i)->address(), NEED_FIXUP); + } + if (count() > index) { + AddCommand(value_command_type, 0); + call_back_entry->AddLink(0, ltOffset, item(index)); + call_back_entry->set_operand_fixup(NEED_FIXUP); + } + + tls_entry_ = item(tls_index); + tls_entry_->include_option(roCreateNewBlock); + tls_entry_->set_alignment(OperandSizeToValue(cpu_address_size())); + for (i = tls_index; i < count(); i++) { + command = item(i); + tls_size_ += OperandSizeToValue(command->type() == icDword ? osDWord : osQWord); + } + } + + // create watermarks + AddWatermark(ctx.options.watermark, 2); + + // create section list for setting WRITABLE flag + std::vector<PESegment *> writable_section_list; + for (i = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + for (j = 0; j < import->count(); j++) { + import_function = import->item(j); + segment = file->segment_list()->GetSectionByAddress(import_function->address()); + if (!segment) + continue; + + if (std::find(writable_section_list.begin(), writable_section_list.end(), segment) == writable_section_list.end()) + writable_section_list.push_back(segment); + } + } + + std::vector<PackerInfo> packer_info_list; + PEFixupList loader_fixup_list; + bool pack_resources = false; + ILCommand *packer_props = NULL; + vtable_fixups_entry_ = NULL; + if (ctx.options.flags & cpPack) { + std::set<PESegment *> skip_segment_list; + if (file->header().VTableFixups.VirtualAddress) { + uint64_t address = file->image_base() + file->header().VTableFixups.VirtualAddress; + segment = file->segment_list()->GetSectionByAddress(address); + if (segment && !segment->excluded_from_packing() && file->AddressSeek(address)) { + index = count(); + + j = file->header().VTableFixups.Size; + for (i = 0; i < j; i += sizeof(IMAGE_COR_VTABLEFIXUP)) { + IMAGE_COR_VTABLEFIXUP fixup; + file->Read(&fixup, sizeof(fixup)); + + AddCommand(icDword, fixup.RVA); + AddCommand(icWord, fixup.Count); + AddCommand(icWord, fixup.Type); + + if (PESegment *tmp = file->segment_list()->GetSectionByAddress(file->image_base() + fixup.RVA)) + skip_segment_list.insert(tmp); + } + + if (index < count()) { + vtable_fixups_entry_ = item(index); + vtable_fixups_entry_->include_option(roCreateNewBlock); + vtable_fixups_entry_->set_alignment(sizeof(uint64_t)); + } + } + } + + PackerInfo packer_info; + for (i = 0; i < file->segment_list()->count(); i++) { + segment = file->segment_list()->item(i); + if (segment->excluded_from_packing()) + continue; + + bool can_be_packed = true; + if ((segment->memory_type() & (mtWritable | mtShared)) == (mtWritable | mtShared)) { + can_be_packed = false; + } else if (skip_segment_list.find(segment) != skip_segment_list.end()) { + can_be_packed = false; + } + + if (!can_be_packed) { + //file->Notify(mtWarning, NULL, string_format(language[lsSegmentCanNotBePacked].c_str(), segment->name().c_str())); + continue; + } + + if (segment->physical_size()) { + packer_info.section = segment; + packer_info.address = segment->address(); + packer_info.size = static_cast<size_t>(segment->physical_size()); + packer_info.data = NULL; + packer_info_list.push_back(packer_info); + + // need add packed section into WRITABLE section list + if (std::find(writable_section_list.begin(), writable_section_list.end(), segment) == writable_section_list.end()) + writable_section_list.push_back(segment); + } + } + + if ((ctx.options.flags & cpStripFixups) == 0) { + PEFixupList *fixup_list = file->pe()->fixup_list(); + + for (i = 0; i < fixup_list->count(); i++) { + PEFixup *fixup = fixup_list->item(i); + if (fixup->is_deleted()) + continue; + + segment = file->segment_list()->GetSectionByAddress(fixup->address()); + if (!segment || std::find(packer_info_list.begin(), packer_info_list.end(), segment) == packer_info_list.end()) + continue; + + loader_fixup_list.AddObject(fixup->Clone(&loader_fixup_list)); + fixup->set_deleted(true); + + // need add section into WRITABLE section list + if (std::find(writable_section_list.begin(), writable_section_list.end(), segment) == writable_section_list.end()) + writable_section_list.push_back(segment); + } + } + + // packing sections + j = 0; + for (i = 0; i < packer_info_list.size(); i++) { + j += packer_info_list[i].size; + } + /* + if (file->resource_list()->size() > file->resource_list()->store_size()) + j += file->resource_list()->size() - file->resource_list()->store_size(); + */ + file->StartProgress(string_format("%s...", language[lsPacking].c_str()), j); + + Data data; + Packer packer; + + if (!packer.WriteProps(&data)) + throw std::runtime_error("Packer error"); + packer_props = AddCommand(data); + packer_props->include_option(roCreateNewBlock); + + for (i = 0; i < packer_info_list.size(); i++) { + packer_info = packer_info_list[i]; + if (!file->AddressSeek(packer_info.address)) + return false; + + if (!packer.Code(file, packer_info.size, &data)) + throw std::runtime_error("Packer error"); + + command = AddCommand(data); + command->include_option(roCreateNewBlock); + packer_info_list[i].data = command; + } + + // remove packed sections from file + uint32_t physical_offset = 0; + for (i = 0; i < file->segment_list()->count(); i++) { + segment = file->segment_list()->item(i); + if (segment->physical_offset() > 0 && segment->physical_size() > 0) { + physical_offset = static_cast<uint32_t>(segment->physical_offset()); + break; + } + } + + for (i = 0; i < file->segment_list()->count(); i++) { + segment = file->segment_list()->item(i); + uint32_t physical_size = segment->physical_size(); + bool is_packed = false; + std::vector<PackerInfo>::iterator it = std::find(packer_info_list.begin(), packer_info_list.end(), segment); + if (it != packer_info_list.end()) { + physical_size = static_cast<uint32_t>(it->address - segment->address()); + is_packed = true; + } + + if (physical_size > 0 && segment->physical_offset() != physical_offset) { + uint8_t *buff = new uint8_t[physical_size]; + file->Seek(segment->physical_offset()); + file->Read(buff, physical_size); + file->Seek(physical_offset); + file->Write(buff, physical_size); + delete [] buff; + } + + segment->set_physical_offset(physical_offset); + segment->set_physical_size(physical_size); + + if (is_packed) { + j = physical_offset + physical_size; + file->Seek(j); + physical_offset = (uint32_t)AlignValue(j, file->file_alignment()); + for (k = j; k < physical_offset; k++) { + file->WriteByte(0); + } + } else { + physical_offset += physical_size; + } + } + file->Resize(physical_offset); + } + + // create packer info for loader + std::vector<LoaderInfo> loader_info_list; + index = count(); + if (packer_props) { + command = AddCommand(icDword, 0); + link = command->AddLink(0, ltOffset, packer_props); + link->set_sub_value(file->image_base()); + AddCommand(icDword, packer_props->dump_size()); + + for (i = 0; i < packer_info_list.size(); i++) { + command = AddCommand(icDword, 0); + link = command->AddLink(0, ltOffset, packer_info_list[i].data); + link->set_sub_value(file->image_base()); + + AddCommand(icDword, packer_info_list[i].address - file->image_base()); + } + } + command = (count() == index) ? NULL : item(index); + if (command) + command->include_option(roCreateNewBlock); + loader_info_list.push_back(LoaderInfo(command, (count() - index) * OperandSizeToValue(osDWord))); + + // create file CRC info for loader + index = count(); + if (((ctx.options.flags | ctx.options.sdk_flags) & cpMemoryProtection)) { + AddCommand(icDword, 0); + for (i = 0; i < 10; i++) { + AddCommand(icDword, 0); + AddCommand(icDword, 0); + AddCommand(icDword, 0); + } + } + file_crc_entry_ = (count() == index) ? NULL : item(index); + if (file_crc_entry_) + file_crc_entry_->include_option(roCreateNewBlock); + file_crc_size_ = static_cast<uint32_t>((count() - index) * OperandSizeToValue(osDWord)); + loader_info_list.push_back(LoaderInfo(file_crc_entry_, file_crc_size_)); + + file_crc_size_entry_ = file_crc_entry_ ? AddCommand(icDword, 0) : NULL; + if (file_crc_size_entry_) + file_crc_size_entry_->include_option(roCreateNewBlock); + + // create header and loader CRC info for loader + index = count(); + if (((ctx.options.flags | ctx.options.sdk_flags) & cpMemoryProtection) || (ctx.options.flags & cpLoaderCRC)) { + // calc CRC blocks count + k = 20 + new_import_list.count(); + if ((ctx.options.flags & cpStripFixups) == 0) { + PEFixupList *fixup_list = file->pe()->fixup_list(); + for (i = 0; i < fixup_list->count(); i++) { + PEFixup *fixup = fixup_list->item(i); + if (!fixup->is_deleted()) + k++; + } + } + for (i = 0; i < k; i++) { + AddCommand(icDword, 0); + AddCommand(icDword, 0); + AddCommand(icDword, 0); + } + } + loader_crc_entry_ = (count() == index) ? NULL : item(index); + if (loader_crc_entry_) + loader_crc_entry_->include_option(roCreateNewBlock); + loader_crc_size_ = static_cast<uint32_t>((count() - index) * OperandSizeToValue(osDWord)); + loader_info_list.push_back(LoaderInfo(loader_crc_entry_, loader_crc_size_)); + + loader_crc_size_entry_ = loader_crc_entry_ ? AddCommand(icDword, 0) : NULL; + if (loader_crc_size_entry_) + loader_crc_size_entry_->include_option(roCreateNewBlock); + loader_crc_hash_entry_ = loader_crc_entry_ ? AddCommand(icDword, 0) : NULL; + if (loader_crc_hash_entry_) + loader_crc_hash_entry_->include_option(roCreateNewBlock); + + // create section info for loader + index = count(); + for (i = 0; i < writable_section_list.size(); i++) { + segment = writable_section_list[i]; + + AddCommand(icDword, segment->address() - file->image_base()); + AddCommand(icDword, segment->size()); + AddCommand(icDword, segment->flags()); + } + command = (count() == index) ? NULL : item(index); + if (command) + command->include_option(roCreateNewBlock); + loader_info_list.push_back(LoaderInfo(command, (count() - index) * OperandSizeToValue(osDWord))); + + // create fixup info for loader + if (loader_fixup_list.count() > 0) { + Data data; + loader_fixup_list.WriteToData(data, file->image_base()); + command = AddCommand(data); + } else { + command = NULL; + } + if (command) + command->include_option(roCreateNewBlock); + loader_info_list.push_back(LoaderInfo(command, (command) ? command->dump_size() : 0)); + + // create relocation info for loader + loader_info_list.push_back(LoaderInfo(NULL, 0)); + + // create IAT info for loader + index = count(); + for (i = 0, import_index = 0; i < new_import_list.count(); i++) { + import = new_import_list.item(i); + if (import->count() == 0) + continue; + + import_function = import->item(0); + command = AddCommand(icDword, 0); + link = command->AddLink(0, ltOffset, import_function_info_list[import_index].thunk); + link->set_sub_value(file->image_base()); + + AddCommand(icDword, import_function->address() - file->image_base()); + AddCommand(icDword, import->count() * OperandSizeToValue(file->pe()->cpu_address_size())); + + import_index += import->count(); + } + command = (count() == index) ? NULL : item(index); + if (command) + command->include_option(roCreateNewBlock); + loader_info_list.push_back(LoaderInfo(command, (count() - index) * OperandSizeToValue(osDWord))); + + index = count(); + if (il_import) { + std::vector<ImportDelegateInfo> info_list = il_import->info_list(); + for (i = 0; i < info_list.size(); i++) { + ImportDelegateInfo info = info_list[i]; + AddCommand(icDword, info.method->id() ^ string_key); + AddCommand(icDword, info.invoke->id() ^ string_key); + AddCommand(icDword, info.call_type); + } + } + command = (count() == index) ? NULL : item(index); + if (command) + command->include_option(roCreateNewBlock); + loader_info_list.push_back(LoaderInfo(command, (count() - index) * OperandSizeToValue(osDWord))); + + loader_info_list.push_back(LoaderInfo(NULL, 0)); + + // create memory CRC info for loader + if (il_crc) { + command = il_crc->table_entry(); + i = static_cast<size_t>(il_crc->size_entry()->operand_value()); + } else { + command = NULL; + i = 0; + } + loader_info_list.push_back(LoaderInfo(command, i)); + + // create strings for loader + std::map<uint32_t, ILCommand *> loader_string_list; + loader_string_list[FACE_FILE_CORRUPTED] = AddCommand(EncryptString((ctx.options.flags & cpMemoryProtection) ? os::FromUTF8(ctx.options.messages[MESSAGE_FILE_CORRUPTED]).c_str() : os::unicode_string().c_str(), string_key)); + loader_string_list[FACE_DEBUGGER_FOUND] = AddCommand(EncryptString(os::FromUTF8(ctx.options.messages[MESSAGE_DEBUGGER_FOUND]).c_str(), string_key)); + loader_string_list[FACE_VIRTUAL_MACHINE_FOUND] = AddCommand(EncryptString(os::FromUTF8(ctx.options.messages[MESSAGE_VIRTUAL_MACHINE_FOUND]).c_str(), string_key)); + loader_string_list[FACE_INITIALIZATION_ERROR] = AddCommand(EncryptString(os::FromUTF8("Initialization error {0}").c_str(), string_key)); + VMProtectBeginVirtualization("Loader Strings"); + loader_string_list[FACE_UNREGISTERED_VERSION] = AddCommand(EncryptString( +#ifdef DEMO + true +#else + (ctx.options.flags & cpUnregisteredVersion) +#endif + ? os::FromUTF8(VMProtectDecryptStringA("This application is protected with unregistered version of VMProtect.")).c_str() : os::unicode_string().c_str(), string_key)); + VMProtectEnd(); + loader_string_list[FACE_NTDLL_NAME] = AddCommand(EncryptString("ntdll.dll", string_key)); + loader_string_list[FACE_NT_SET_INFORMATION_THREAD_NAME] = AddCommand(EncryptString("NtSetInformationThread", string_key)); + loader_string_list[FACE_NT_QUERY_INFORMATION_PROCESS_NAME] = AddCommand(EncryptString("NtQueryInformationProcess", string_key)); + loader_string_list[FACE_NT_CLOSE] = AddCommand(EncryptString("NtClose", string_key)); + loader_string_list[FACE_NT_VIRTUAL_PROTECT_NAME] = AddCommand(EncryptString("NtProtectVirtualMemory", string_key)); + loader_string_list[FACE_NT_ALLOCATE_VIRTUAL_MEMORY_NAME] = AddCommand(EncryptString("NtAllocateVirtualMemory", string_key)); + loader_string_list[FACE_NT_FREE_VIRTUAL_MEMORY_NAME] = AddCommand(EncryptString("NtFreeVirtualMemory", string_key)); + loader_string_list[FACE_NT_UNMAP_VIEW_OF_SECTION] = AddCommand(EncryptString("NtUnmapViewOfSection", string_key)); + loader_string_list[FACE_NT_OPEN_FILE_NAME] = AddCommand(EncryptString("NtOpenFile", string_key)); + loader_string_list[FACE_NT_RAISE_HARD_ERROR_NAME] = AddCommand(EncryptString("NtRaiseHardError", string_key)); + loader_string_list[FACE_NT_CREATE_SECTION_NAME] = AddCommand(EncryptString("NtCreateSection", string_key)); + loader_string_list[FACE_KERNEL32_NAME] = AddCommand(EncryptString("kernel32.dll", string_key)); + loader_string_list[FACE_ENUM_SYSTEM_FIRMWARE_NAME] = AddCommand(EncryptString("EnumSystemFirmwareTables", string_key)); + loader_string_list[FACE_GET_SYSTEM_FIRMWARE_NAME] = AddCommand(EncryptString("GetSystemFirmwareTable", string_key)); + loader_string_list[FACE_NT_MAP_VIEW_OF_SECTION] = AddCommand(EncryptString("MapViewOfFile", string_key)); + + for (std::map<uint32_t, ILCommand *>::const_iterator it = loader_string_list.begin(); it != loader_string_list.end(); it++) { + it->second->include_option(roCreateNewBlock); + } + + // append loader + old_count = count(); + runtime_function_list = reinterpret_cast<ILFunctionList *>(runtime->function_list()); + for (size_t n = 0; n < 2; n++) { + for (i = 0; i < runtime_function_list->count(); i++) { + func = runtime_function_list->item(i); + if (func->tag() != ftLoader) + continue; + + if (func->compilation_type() == ctMutation) { + if (n != 0) + continue; + } else { + if (n != 1) + continue; + } + + func->Init(ctx); + + size_t orig_function_info_count = function_info_list()->count(); + for (j = 0; j < func->function_info_list()->count(); j++) { + FunctionInfo *info = func->function_info_list()->item(j); + function_info_list()->AddObject(info->Clone(function_info_list())); + } + for (j = 0; j < func->range_list()->count(); j++) { + AddressRange *range = func->range_list()->item(j); + range_list()->AddObject(range->Clone(range_list())); + } + + for (j = 0; j < func->count(); j++) { + src_command = func->item(j); + dst_command = src_command->Clone(this); + + AddressRange *address_range = src_command->address_range(); + if (address_range) { + FunctionInfo *info = function_info_list()->item(orig_function_info_count + func->function_info_list()->IndexOf(address_range->owner())); + dst_command->set_address_range(info->item(address_range->owner()->IndexOf(address_range))); + } + + AddObject(dst_command); + + src_link = src_command->link(); + if (src_link) { + dst_link = src_link->Clone(link_list()); + dst_link->set_from_command(dst_command); + link_list()->AddObject(dst_link); + + if (src_link->parent_command()) + dst_link->set_parent_command(GetCommandByAddress(src_link->parent_command()->address())); + if (src_link->base_function_info()) + dst_link->set_base_function_info(function_info_list()->GetItemByAddress(src_link->base_function_info()->begin())); + } + + command = dst_command; + if (command->type() == icLdc_i4) { + uint32_t value = static_cast<uint32_t>(command->operand_value()); + if ((value & 0xFFFF0000) == 0xFACE0000) { + switch (value) { + case FACE_LOADER_OPTIONS: + value = 0; + if (ctx.options.flags & cpMemoryProtection) + value |= LOADER_OPTION_CHECK_PATCH; + if (ctx.options.flags & cpCheckDebugger) + value |= LOADER_OPTION_CHECK_DEBUGGER; + if (ctx.options.flags & cpCheckKernelDebugger) + value |= LOADER_OPTION_CHECK_KERNEL_DEBUGGER; + if (ctx.options.flags & cpCheckVirtualMachine) + value |= LOADER_OPTION_CHECK_VIRTUAL_MACHINE; + command->set_operand_value(0, value); + command->CompileToNative(); + break; + case FACE_STRING_DECRYPT_KEY: + command->set_operand_value(0, string_key); + command->CompileToNative(); + break; + case FACE_PACKER_INFO: + case FACE_FILE_CRC_INFO: + case FACE_LOADER_CRC_INFO: + case FACE_SECTION_INFO: + case FACE_FIXUP_INFO: + case FACE_RELOCATION_INFO: + case FACE_IAT_INFO: + case FACE_IMPORT_INFO: + case FACE_INTERNAL_IMPORT_INFO: + case FACE_MEMORY_CRC_INFO: + case FACE_DELAY_IMPORT_INFO: + dst_command = loader_info_list[(value & 0xff) >> 1].data; + if (dst_command) { + link = command->AddLink(0, ltOffset, dst_command); + link->set_sub_value(file->image_base()); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_PACKER_INFO_SIZE: + case FACE_SECTION_INFO_SIZE: + case FACE_FIXUP_INFO_SIZE: + case FACE_RELOCATION_INFO_SIZE: + case FACE_IAT_INFO_SIZE: + case FACE_IMPORT_INFO_SIZE: + case FACE_INTERNAL_IMPORT_INFO_SIZE: + case FACE_MEMORY_CRC_INFO_SIZE: + case FACE_DELAY_IMPORT_INFO_SIZE: + command->set_operand_value(0, loader_info_list[(value & 0xff) >> 1].size); + command->CompileToNative(); + break; + case FACE_LOADER_CRC_INFO_SIZE: + if (loader_crc_size_entry_) { + link = command->AddLink(0, ltOffset, loader_crc_size_entry_); + link->set_sub_value(file->image_base()); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_LOADER_CRC_INFO_HASH: + if (loader_crc_hash_entry_) { + link = command->AddLink(0, ltOffset, loader_crc_hash_entry_); + link->set_sub_value(file->image_base()); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_FILE_CRC_INFO_SIZE: + if (file_crc_size_entry_) { + link = command->AddLink(0, ltOffset, file_crc_size_entry_); + link->set_sub_value(file->image_base()); + } else { + command->set_operand_value(0, 0); + command->CompileToNative(); + } + break; + case FACE_MEMORY_CRC_INFO_HASH: + command->set_operand_value(0, il_crc ? il_crc->hash_entry()->operand_value() : 0); + command->CompileToNative(); + break; + case FACE_CRC_INFO_SALT: + command->set_operand_value(0, file->function_list()->crc_cryptor()->item(0)->value()); + command->CompileToNative(); + break; + case FACE_FILE_BASE: + command->Init(icLdc_i8, file->image_base()); + command->CompileToNative(); + break; + case FACE_TLS_INDEX_INFO: + command->set_operand_value(0, tls_index_address ? tls_index_address - file->image_base() : 0); + command->CompileToNative(); + break; + case FACE_VAR_IS_PATCH_DETECTED: + case FACE_VAR_IS_DEBUGGER_DETECTED: + case FACE_VAR_LOADER_CRC_INFO: + case FACE_VAR_LOADER_CRC_INFO_SIZE: + case FACE_VAR_LOADER_CRC_INFO_HASH: + case FACE_VAR_SESSION_KEY: + case FACE_VAR_LOADER_STATUS: + case FACE_VAR_SERVER_DATE: + command->set_operand_value(j, ctx.runtime_var_index[(value & 0xff) >> 4]); + command->CompileToNative(); + break; + case FACE_VAR_IS_PATCH_DETECTED_SALT: + case FACE_VAR_IS_DEBUGGER_DETECTED_SALT: + case FACE_VAR_LOADER_CRC_INFO_SALT: + case FACE_VAR_LOADER_CRC_INFO_SIZE_SALT: + case FACE_VAR_LOADER_CRC_INFO_HASH_SALT: + case FACE_VAR_SERVER_DATE_SALT: + command->set_operand_value(j, ctx.runtime_var_salt[value & 0xff]); + command->CompileToNative(); + break; + default: + std::map<uint32_t, ILCommand *>::const_iterator it = loader_string_list.find(value); + if (it != loader_string_list.end()) { + link = command->AddLink(0, ltOffset, it->second); + link->set_sub_value(file->image_base()); + } else { + throw std::runtime_error(string_format("Unknown loader string: %X", value)); + } + } + } + } + } + } + if (n == 0) { + // create native blocks + for (j = 0; j < count(); j++) { + item(j)->include_option(roNoProgress); + } + CompileToNative(ctx); + for (j = 0; j < count(); j++) { + item(j)->exclude_option(roNoProgress); + } + } + } + for (i = 0; i < function_info_list()->count(); i++) { + FunctionInfo *info = function_info_list()->item(i); + if (info->entry()) + info->set_entry(GetCommandByAddress(info->entry()->address())); + if (info->data_entry()) + info->set_data_entry(GetCommandByAddress(info->data_entry()->address())); + for (j = 0; j < info->count(); j++) { + AddressRange *dest = info->item(j); + for (k = 0; k < range_list()->count(); k++) { + AddressRange *range = range_list()->item(k); + if (range->begin() <= dest->begin() && range->end() > dest->begin()) + dest->AddLink(range); + } + } + } + for (i = 0; i < range_list()->count(); i++) { + AddressRange *range = range_list()->item(i); + if (range->begin_entry()) + range->set_begin_entry(GetCommandByAddress(range->begin_entry()->address())); + if (range->end_entry()) + range->set_end_entry(GetCommandByAddress(range->end_entry()->address())); + if (range->size_entry()) + range->set_size_entry(GetCommandByAddress(range->size_entry()->address())); + } + for (i = old_count; i < count(); i++) { + command = item(i); + dst_link = command->link(); + if (dst_link) { + if (dst_link->to_address()) + dst_link->set_to_command(GetCommandByAddress(dst_link->to_address())); + } + } + + // create code for <Module>::.cctor() + old_count = count(); + command = AddCommand(icComment, 0); + Data data; + data.PushByte(0); + command->set_dump(data.data(), data.size()); + command->set_alignment(4); + command = AddCommand(icCall, 0); + command->AddLink(0, ltCall, GetCommandByAddress(runtime->export_list()->GetAddressByType(atSetupImage))); + // search user <Module>::.cctor + ILMethodDef *module_cctor = runtime->entry_point_method(); + ILTypeDef *module = module_cctor->declaring_type(); + ILTable *table = file->command_list()->table(ttMethodDef); + for (i = table->IndexOf(module->method_list()); i < table->count(); i++) { + ILMethodDef *method = reinterpret_cast<ILMethodDef *>(table->item(i)); + if (method->declaring_type() != module || method == module_cctor) + break; + + if (method->name() == ".cctor") { + method->set_flags((CorMethodAttr)(method->flags() & ~(mdSpecialName | mdRTSpecialName))); + file->RenameToken(method); + command = AddCommand(icCall, method->id()); + break; + } + } + AddCommand(icRet, 0); + FunctionInfo *info = function_info_list()->Add(0, 0, btValue, 1, 0, 0, file->runtime_function_list()->Add(0, 0, 0, runtime->entry_point_method()), item(old_count)); + AddressRange *range = info->Add(0, 0, NULL, NULL, NULL); + for (i = old_count; i < count(); i++) { + item(i)->set_address_range(range); + } + + for (i = 0; i < count(); i++) { + command = item(i); + command->CompileToNative(); + } + + // prepare ranges + std::vector<IFunction *> function_list = ctx.file->function_list()->processor_list(); + function_list.push_back(this); + for (i = 0; i < function_list.size(); i++) { + ILFunction *func = reinterpret_cast<ILFunction *>(function_list[i]); + func->range_list()->Prepare(); + func->function_info_list()->Prepare(); + } + + PrepareExtCommands(ctx); + for (i = 0; i < link_list()->count(); i++) { + CommandLink *link = link_list()->item(i); + link->from_command()->PrepareLink(ctx); + } + return true; +} + +bool NETLoader::Compile(const CompileContext &ctx) +{ + size_t i, j; + std::vector<CommandBlock*> block_list; + ILCommand *command; + + std::vector<IFunction *> function_list = ctx.file->function_list()->processor_list(); + for (i = 0; i < function_list.size(); i++) { + function_list[i]->set_need_compile(true); + } + function_list.push_back(this); + + // update tokens + for (i = 0; i < function_list.size(); i++) { + ILFunction *func = reinterpret_cast<ILFunction *>(function_list[i]); + for (j = 0; j < func->count(); j++) { + command = func->item(j); + TokenReference *token_reference = command->token_reference(); + if (!token_reference) + continue; + + uint32_t id = token_reference->owner()->owner()->id(); + if (command->type() == icComment) { + Data data; + data.PushDWord(id); + command->set_dump(data.data(), data.size()); + } + else { + command->set_operand_value(0, id); + command->CompileToNative(); + } + } + } + + if (!ILFunction::Compile(ctx)) + return false; + ILFunction::AfterCompile(ctx); + + for (i = 0; i < count(); i++) { + command = item(i); + if (!command->block() || (command->block()->type() & mtExecutable) == 0 || !command->token_reference()) + continue; + + ILToken *token = command->token_reference()->owner()->owner(); + if (token->type() == ttStandAloneSig) { + ILTable *table = token->owner(); + uint32_t id = token->type() | 1; + for (j = 0; j < table->count(); j++) { + ILToken *tmp = table->item(j); + if (tmp == token) + break; + if (!tmp->is_deleted()) + id++; + } + if (token->id() != id) { + token->set_value(TOKEN_VALUE(id)); + command->set_operand_value(0, id); + command->CompileToNative(); + } + } + } + + for (i = 0; i < function_list.size(); i++) { + IFunction *func = function_list[i]; + for (j = 0; j < func->block_list()->count(); j++) { + block_list.push_back(func->block_list()->item(j)); + } + } + + for (i = 0; i < block_list.size(); i++) { + std::swap(block_list[i], block_list[rand() % block_list.size()]); + } + + if (ctx.file->runtime_function_list() && ctx.file->runtime_function_list()->count()) { + // sort blocks by address range + std::sort(block_list.begin(), block_list.end(), CommandBlockListCompareHelper()); + } + + for (i = 0; i < block_list.size(); i++) { + block_list[i]->Compile(*ctx.manager); + } + + for (i = 0; i < function_list.size(); i++) { + function_list[i]->CompileInfo(ctx); + } + + for (i = 0; i < function_list.size(); i++) { + function_list[i]->CompileLinks(ctx); + } + + return true; +} + +size_t NETLoader::WriteToFile(IArchitecture &file) +{ + size_t res = BaseFunction::WriteToFile(file); + + if (pe_entry_) { + PEArchitecture *pe = reinterpret_cast<NETArchitecture &>(file).pe(); + if (pe->cpu_address_size() == osDWord) { + IFixup *fixup = pe->fixup_list()->AddDefault(osDWord, true); + fixup->set_address(pe_entry_->address() + pe_entry_->dump_size()); + } + } + + return res; +}
\ No newline at end of file |