private static CustomAttributeTypedArgument LoadInt64(IBinaryAccessor accessor, Module module, bool isArray, int arrayLength)
        {
            var type = TypeReference.GetPrimitiveType(PrimitiveTypeCode.Int64, module.Assembly);

            if (isArray)
            {
                var value = new long[arrayLength];
                for (int i = 0; i < arrayLength; i++)
                {
                    value[i] = accessor.ReadInt64();
                }

                return(new CustomAttributeTypedArgument(value, type));
            }
            else
            {
                long value = accessor.ReadInt64();
                return(new CustomAttributeTypedArgument(value, type));
            }
        }
        private void StateLoadInstructions(IBinaryAccessor accessor, Module module)
        {
            int instructionCount = accessor.Read7BitEncodedInt();

            _instructions = new List <Instruction>(instructionCount);

            for (int i = 0; i < instructionCount; i++)
            {
                OpCode opCode;
                byte   opByte = accessor.ReadByte();
                if (opByte == 0xFE)
                {
                    opByte = accessor.ReadByte();
                    opCode = OpCodes.OpCodeArray[256 + opByte];
                }
                else
                {
                    opCode = OpCodes.OpCodeArray[opByte];
                }

                object value;
                switch (opCode.OperandType)
                {
                case OperandType.InlineBrTarget:
                {
                    value = accessor.ReadInt32();
                }
                break;

                case OperandType.InlineField:
                {
                    int token = accessor.ReadInt32();
                    value = module.GetSignature <Signature>(token);
                }
                break;

                case OperandType.InlineI:
                {
                    value = accessor.ReadInt32();
                }
                break;

                case OperandType.InlineI8:
                {
                    value = accessor.ReadInt64();
                }
                break;

                case OperandType.InlineMethod:
                {
                    int token = accessor.ReadInt32();
                    value = module.GetSignature <Signature>(token);
                }
                break;

                case OperandType.InlineR:
                {
                    value = accessor.ReadDouble();
                }
                break;

                case OperandType.InlineSig:
                {
                    int token = accessor.ReadInt32();
                    value = module.GetSignature <Signature>(token);
                }
                break;

                case OperandType.InlineString:
                {
                    // Token of a userdefined string, whose RID portion is actually an offset in the #US blob stream.
                    value = accessor.ReadLengthPrefixedString(Encoding.Unicode);
                }
                break;

                case OperandType.InlineSwitch:
                {
                    int   count   = accessor.ReadInt32();
                    int[] targets = new int[count];
                    for (int j = 0; j < count; j++)
                    {
                        targets[j] = accessor.ReadInt32();
                    }

                    value = targets;
                }
                break;

                case OperandType.InlineTok:
                {
                    int token = accessor.ReadInt32();
                    value = module.GetSignature <Signature>(token);
                }
                break;

                case OperandType.InlineType:
                {
                    int token = accessor.ReadInt32();
                    value = module.GetSignature <Signature>(token);
                }
                break;

                case OperandType.InlineVar:
                {
                    value = accessor.ReadInt16();
                }
                break;

                case OperandType.ShortInlineBrTarget:
                {
                    value = accessor.ReadSByte();
                }
                break;

                case OperandType.ShortInlineI:
                {
                    value = accessor.ReadByte();
                }
                break;

                case OperandType.ShortInlineR:
                {
                    value = accessor.ReadSingle();
                }
                break;

                case OperandType.ShortInlineVar:
                {
                    value = accessor.ReadByte();
                }
                break;

                default:
                {
                    value = null;
                }
                break;
                }

                _instructions.Add(new Instruction(opCode, value));
            }
        }
        private void LoadInstructions(IBinaryAccessor accessor, Module module, int codeSize)
        {
            long startOffset = accessor.Position;

            var image = module.Image;

            _instructions = new List <Instruction>();

            while (accessor.Position < startOffset + codeSize)
            {
                OpCode opCode;
                byte   opByte = accessor.ReadByte();
                if (opByte == 0xFE)
                {
                    opByte = accessor.ReadByte();
                    opCode = OpCodes.OpCodeArray[256 + opByte];
                }
                else
                {
                    opCode = OpCodes.OpCodeArray[opByte];
                }

                if (opCode == null)
                {
                    throw new CodeModelException(string.Format(SR.AssemblyLoadError, module.Location));
                }

                object value;
                switch (opCode.OperandType)
                {
                case OperandType.InlineBrTarget:
                {
                    value = accessor.ReadInt32();
                }
                break;

                case OperandType.InlineField:
                {
                    int token = accessor.ReadInt32();
                    value = FieldReference.Load(module, token);
                }
                break;

                case OperandType.InlineI:
                {
                    value = accessor.ReadInt32();
                }
                break;

                case OperandType.InlineI8:
                {
                    value = accessor.ReadInt64();
                }
                break;

                case OperandType.InlineMethod:
                {
                    int token = accessor.ReadInt32();
                    value = MethodReference.Load(module, token);
                }
                break;

                case OperandType.InlineR:
                {
                    value = accessor.ReadDouble();
                }
                break;

                case OperandType.InlineSig:
                {
                    int token = accessor.ReadInt32();
                    if (MetadataToken.GetType(token) == MetadataTokenType.Signature)
                    {
                        int rid = MetadataToken.GetRID(token);
                        value = CallSite.LoadStandAloneSig(module, rid);
                    }
                    else
                    {
                        throw new CodeModelException(SR.MethodBodyBlobNotValid);
                    }
                }
                break;

                case OperandType.InlineString:
                {
                    // Token of a userdefined string, whose RID portion is actually an offset in the #US blob stream.
                    uint token = accessor.ReadUInt32();
                    int  rid   = (int)(token & 0x00ffffff);
                    value = image.GetUserString(rid);
                }
                break;

                case OperandType.InlineSwitch:
                {
                    int   count   = accessor.ReadInt32();
                    int[] targets = new int[count];
                    for (int i = 0; i < count; i++)
                    {
                        targets[i] = accessor.ReadInt32();
                    }

                    value = targets;
                }
                break;

                case OperandType.InlineTok:
                {
                    int token = accessor.ReadInt32();
                    int rid   = MetadataToken.GetRID(token);
                    switch (MetadataToken.GetType(token))
                    {
                    case MetadataTokenType.Method:
                        value = MethodReference.LoadMethodDef(module, rid);
                        break;

                    case MetadataTokenType.MethodSpec:
                        value = GenericMethodReference.LoadMethodSpec(module, rid);
                        break;

                    case MetadataTokenType.MemberRef:
                        value = MethodReference.LoadMemberRef(module, rid);
                        break;

                    case MetadataTokenType.Field:
                        value = FieldReference.LoadFieldDef(module, rid);
                        break;

                    case MetadataTokenType.TypeDef:
                        value = TypeReference.LoadTypeDef(module, rid);
                        break;

                    case MetadataTokenType.TypeRef:
                        value = TypeReference.LoadTypeRef(module, rid);
                        break;

                    case MetadataTokenType.TypeSpec:
                        value = TypeSignature.LoadTypeSpec(module, rid);
                        break;

                    default:
                        throw new CodeModelException(SR.MethodBodyBlobNotValid);
                    }
                }
                break;

                case OperandType.InlineType:
                {
                    int token = accessor.ReadInt32();
                    value = TypeSignature.Load(module, token);
                }
                break;

                case OperandType.InlineVar:
                {
                    value = accessor.ReadInt16();
                }
                break;

                case OperandType.ShortInlineBrTarget:
                {
                    value = accessor.ReadSByte();
                }
                break;

                case OperandType.ShortInlineI:
                {
                    value = accessor.ReadByte();
                }
                break;

                case OperandType.ShortInlineR:
                {
                    value = accessor.ReadSingle();
                }
                break;

                case OperandType.ShortInlineVar:
                {
                    value = accessor.ReadByte();
                }
                break;

                default:
                {
                    value = null;
                }
                break;
                }

                _instructions.Add(new Instruction(opCode, value));
            }
        }