Esempio n. 1
0
        void PatchRawFatMethod(ByteBuffer buffer, MethodSymbols symbols, CodeWriter writer, out MetadataToken local_var_token)
        {
            var flags = ReadUInt16();
            buffer.WriteUInt16(flags);
            buffer.WriteUInt16(ReadUInt16());
            symbols.code_size = ReadInt32();
            buffer.WriteInt32(symbols.code_size);
            local_var_token = ReadToken();

            if (local_var_token.RID > 0)
            {
                var variables = symbols.variables = ReadVariables(local_var_token);
                buffer.WriteUInt32(variables != null
                    ? writer.GetStandAloneSignature(symbols.variables).ToUInt32()
                    : 0);
            }
            else
                buffer.WriteUInt32(0);

            PatchRawCode(buffer, symbols.code_size, writer);

            if ((flags & 0x8) != 0)
                PatchRawSection(buffer, writer.metadata);
        }
Esempio n. 2
0
        void PatchRawSmallSection(ByteBuffer buffer, MetadataBuilder metadata)
        {
            var length = ReadByte();
            buffer.WriteByte(length);
            Advance(2);

            buffer.WriteUInt16(0);

            var count = length / 12;

            PatchRawExceptionHandlers(buffer, metadata, count, false);
        }
Esempio n. 3
0
        void PatchRawExceptionHandlers(ByteBuffer buffer, MetadataBuilder metadata, int count, bool fat_entry)
        {
            const int fat_entry_size = 16;
            const int small_entry_size = 6;

            for (int i = 0; i < count; i++)
            {
                ExceptionHandlerType handler_type;
                if (fat_entry)
                {
                    var type = ReadUInt32();
                    handler_type = (ExceptionHandlerType)(type & 0x7);
                    buffer.WriteUInt32(type);
                }
                else
                {
                    var type = ReadUInt16();
                    handler_type = (ExceptionHandlerType)(type & 0x7);
                    buffer.WriteUInt16(type);
                }

                buffer.WriteBytes(ReadBytes(fat_entry ? fat_entry_size : small_entry_size));

                switch (handler_type)
                {
                    case ExceptionHandlerType.Catch:
                        var exception = reader.LookupToken(ReadToken());
                        buffer.WriteUInt32(metadata.LookupToken(exception).ToUInt32());
                        break;
                    default:
                        buffer.WriteUInt32(ReadUInt32());
                        break;
                }
            }
        }