/// <summary>
        /// Replace all references to oldRegister with newRegister in the given instruction set.
        /// </summary>
        public void ReplaceRegisterWith(Register oldRegister, Register newRegister, MethodBody body)
        {
            var oldRegister2 = (oldRegister.Type == RType.Wide) ? body.GetNext(oldRegister) : null;
            var newRegister2 = (newRegister.Type == RType.Wide) ? body.GetNext(newRegister) : null;

            if (oldRegister.IsKeepWithNext != newRegister.IsKeepWithNext)
                throw new ArgumentException("New register has different keep-with-next value");

            HashSet<Instruction> list;
            if (map.TryGetValue(oldRegister, out list))
            {
                list.ForEach(x => x.ReplaceRegisterWith(oldRegister, newRegister));
                // Update newRegister
                AddRange(newRegister, list);
            }
            if (oldRegister2 != null)
            {
                if (map.TryGetValue(oldRegister2, out list))
                {
                    list.ForEach(x => x.ReplaceRegisterWith(oldRegister2, newRegister2));
                    // Update newRegister2
                    AddRange(newRegister2, list);
                }                
            }
        }

        /// <summary>
        /// Transform the given body.
        /// </summary>
        private static void TransformTempToVariable(MethodBody body, List<BasicBlock> basicBlocks)
        {
            body.Instructions.UpdateIndexCache();
            var allTempRegisterRanges = CollectTempRegisterUsageRanges(basicBlocks).Values.ToList();

            foreach (var iterator in basicBlocks)
            {
                var block = iterator;
                // Collect all register ranges that fit completly within this block and are used exactly 2 times
                var registerRanges = allTempRegisterRanges.Where(x => (x.InstructionCount == 2) && x.ContainsExactlyOne(block)).ToList();

                foreach (var range in registerRanges)
                {
                    var firstIns = range.Range.First;
                    var lastIns = range.Range.Last;
                    if (!lastIns.Code.IsMove())
                        continue;
                    var reg = range.Register;
                    if (lastIns.Registers[1] != reg)
                        continue;
                    var varReg = lastIns.Registers[0];
                    if (varReg.Category != RCategory.Variable)
                        continue;

                    // Replace
                    firstIns.ReplaceRegisterWith(reg, varReg);
                    lastIns.ConvertToNop();
                }
            }
        }

 /// <summary>
 /// Default ctor
 /// </summary>
 public BranchReRouter(MethodBody body)
 {
     List<Instruction> list = null;
     // Record instructions with branch targets
     foreach (var inst in body.Instructions)
     {
         switch (inst.Code)
         {
             case RCode.Goto:
             case RCode.Leave:
             case RCode.If_eq:
             case RCode.If_ne:
             case RCode.If_lt:
             case RCode.If_ge:
             case RCode.If_gt:
             case RCode.If_le:
             case RCode.If_eqz:
             case RCode.If_nez:
             case RCode.If_ltz:
             case RCode.If_gez:
             case RCode.If_gtz:
             case RCode.If_lez:
             case RCode.Packed_switch:
             case RCode.Sparse_switch:
                 list = list ?? new List<Instruction>();
                 list.Add(inst);
                 break;
         }
     }
     branches = list;
     exceptionHandlers = body.Exceptions.Any() ? body.Exceptions.ToArray() : null;
 }

 /// <summary>
 /// Transform the given body.
 /// </summary>
 public void Transform(Dex target, MethodBody body)
 {
     foreach (var ins in body.Instructions)
     {
         switch (ins.Code)
         {
             case RCode.Invoke_direct:
             case RCode.Invoke_virtual:
             case RCode.Invoke_interface:
                 MethodDefinition method;
                 if (((MethodReference)ins.Operand).TryResolve(target, out method))
                 {
                     if (method.Owner.IsInterface)
                     {
                         ins.Code = RCode.Invoke_interface;
                     }
                     else if (method.IsDirect)
                     {
                         ins.Code = RCode.Invoke_direct;
                     }
                     else
                     {
                         ins.Code = RCode.Invoke_virtual;
                     }
                 }
                 break;
         }
     }
 }

        private static IEnumerable<IRLTransformation> GetTransformations(Dex target, MethodBody body)
        {
            foreach (var transformation in optimizations1)
            {
                transformation.Transform(target, body);
                yield return transformation;
            }

            var noopRemove = new NopRemoveTransformation();
            noopRemove.Transform(target, body);
            yield return noopRemove;

            bool hasChanges = true;

            while (hasChanges)
            {
                hasChanges = false;
                foreach (var transformation in incrementalOptimizations)
                {
                    bool changed = transformation.Transform(target, body);
                    if (changed) noopRemove.Transform(target, body);

                    hasChanges = changed || hasChanges;

                    yield return transformation;
                }
            }

            foreach (var transformation in optimizations2)
            {
                transformation.Transform(target, body);
                yield return transformation;
            }    
        }

        public bool Transform(Dex target, MethodBody body)
        {
#if DEBUG
            //return;
#endif
            return DoOptimization(body);
        }

		static void AssertOpCodeSequence (OpCode [] expected, MethodBody body)
		{
			var opcodes = body.Instructions.Select (i => i.OpCode).ToArray ();
			Assert.AreEqual (expected.Length, opcodes.Length);

			for (int i = 0; i < opcodes.Length; i++)
				Assert.AreEqual (expected [i], opcodes [i]);
		}

        /// <summary>
        /// Transform the given body.
        /// </summary>
        public void Transform(Dex target, MethodBody body)
        {
            var basicBlocks = BasicBlock.Find(body);
            var registerCount = body.Registers.Count();
            if (registerCount > MaxRegisters)
                return;

            Dictionary<Instruction, ConstantKey> allConstInstructions;
            CollectReadOnlyConstInstructions(body, out allConstInstructions);
            RegisterUsageMap registerUsageMap = null;

            foreach (var block in basicBlocks)
            {
                // Select all const instructions that have a next instruction in the block.
                var list = block.Instructions.ToList();
                var isLargeBlock = list.Count > LargeBlockSize;
                if (isLargeBlock)
                    continue;
                var constInstructionKeys = list.Where(x => allConstInstructions.ContainsKey(x)).Select(x => allConstInstructions[x]).ToList();

                // Select all const instructions where the next instruction is a move.
                while (constInstructionKeys.Count > 0)
                {
                    // Take the first instruction
                    var insKey = constInstructionKeys[0];
                    constInstructionKeys.RemoveAt(0);

                    // Get the register
                    var reg = insKey.Instruction.Registers[0];

                    // Are there other const instructions of the same type and the same operand?
                    var sameConstInstructions = constInstructionKeys.Where(x => x.Equals(insKey)).ToList();
                    if (sameConstInstructions.Count == 0)
                        continue;
                    if (sameConstInstructions.Count < 4)
                        continue;

                    // It is now save to use the register for all const operations
                    foreach (var other in sameConstInstructions)
                    {
                        // Replace all register uses
                        var otherReg = other.Instruction.Registers[0];

                        // Find usages
                        registerUsageMap = registerUsageMap ?? new RegisterUsageMap(body.Instructions);
                        registerUsageMap.ReplaceRegisterWith(otherReg, reg, body);

                        // Remove const
                        constInstructionKeys.Remove(other);
                        allConstInstructions.Remove(other.Instruction);

                        // Change const to nop which will be removed later
                        other.Instruction.ConvertToNop();
                    }
                }
            }
        }

        public ControlFlowGraph2(MethodBody body)
        {
            _body = body;
            _basicBlocks = new ControlFlowGraph(body).ToList();
            _entries = _basicBlocks.ToDictionary(b => b.Entry, b => b);
            _exits = _basicBlocks.ToDictionary(b => b.Exit, b => b);
            _entryInstructions = _basicBlocks.Select(b => b.Entry).ToList();

            IncludeExceptionHandlers(body);
        }

        public bool Transform(Dex target, MethodBody body)
        {
            bool hasChanges = false;

            var registerUsage = new RegisterUsageMap2(body);

            hasChanges = InlineIntConstsIntoBinOp(registerUsage);

            return hasChanges;
        }

        /// <summary>
        /// Transform the given body.
        /// </summary>
        public bool Transform(Dex target, MethodBody body)
        {
            bool hasChanges = false;

            // Find all "const" instructions and record register usage
            var allConstInstructions = new List<Instruction>();
            var registerUsage = new Dictionary<Register, List<Instruction>>();
            CollectInstructionInformation(body, allConstInstructions, registerUsage);

            // Find all basic blocks
            var basicBlocks = BasicBlock.Find(body);

            // Go over each block
            foreach (var iterator in basicBlocks)
            {
                var block = iterator;
                // Select all const instructions where the next instruction is a move.
                foreach (var ins in allConstInstructions)
                {
                    var r = ins.Registers[0];
                    // Only optimize const instructions to temp registers
                    if (r.Category != RCategory.Temp)
                        continue;

                    // Get all instructions using this register
                    var all = registerUsage[r];
                    if ((all.Count != 2) || (all[0] != ins))
                        continue;
                    var next = all[1];
                    // Opcode must match
                    if (next.Code != ConstToMove(ins.Code))
                        continue;
                    // Register must match
                    if (next.Registers[1] != r)
                        continue;
                    
                    // The following are the most expensive, so only test them if we have to.
                    // Only optimize is instruction is in current block
                    if (!block.Contains(ins))
                        continue;

                    // Next must be in same basic block
                    if (!block.Contains(next))
                        continue;

                    // We found a replacement
                    r = next.Registers[0];
                    ins.Registers[0] = r;
                    next.ConvertToNop();

                    hasChanges = true;
                }
            }
            return hasChanges;
        }

        public bool Transform(Dex target, MethodBody body)
        {
            bool hasChanges = false;

            var graph = new ControlFlowGraph2(body);
            var registerUsage = new RegisterUsageMap2(graph);

            hasChanges = EliminateRegisterAssigments(registerUsage);
            
            return hasChanges;
        }

        public void Read(MethodBody body, InstructionMapper mapper)
        {
            var method_token = body.Method.MetadataToken;

            PdbFunction function;
            if (!functions.TryGetValue (method_token.ToUInt32 (), out function))
                return;

            ReadSequencePoints (function, mapper);
            ReadScopeAndLocals (function.scopes, null, body, mapper);
        }

        public void Read(MethodBody body, InstructionMapper mapper)
        {
            var method_token = body.Method.MetadataToken;
            var entry = symbol_file.GetMethodByToken (method_token.ToInt32	());
            if (entry == null)
                return;

            var scopes = ReadScopes (entry, body, mapper);
            ReadLineNumbers (entry, mapper);
            ReadLocalVariables (entry, body, scopes);
        }

		public MethodBody ReadMethodBody (MethodDefinition method)
		{
			this.method = method;
			this.body = new MethodBody (method);

			reader.context = method;

			ReadMethodBody ();

			return this.body;
		}

 public VariableDefinition InjectStopwatch(MethodBody body, int index)
 {
     // inject as variable
     var stopwatchVar = new VariableDefinition("methodTimerStopwatch", StopwatchType);
     body.Variables.Add(stopwatchVar);
     body.Insert(index, new List<Instruction>(new[] {
         Instruction.Create(OpCodes.Call, StartNewMethod),
         Instruction.Create(OpCodes.Stloc, stopwatchVar)
     }));
     return stopwatchVar;
 }

        /// <summary>
        /// Find all instructions that  are "const" and have a destination register that is never assigned to.
        /// </summary>
        private static void CollectReadOnlyConstInstructions(MethodBody body, out Dictionary<Instruction, ConstantKey> constInstructions)
        {
            // Find all const instructions
            constInstructions = body.Instructions
                                    .Where(ins => ins.Code.IsConst() && !ins.Registers[0].PreventOptimization)
                                    .ToDictionary(ins => ins, ins => new ConstantKey(ins));
            if (constInstructions.Count == 0)
                return;

            // Select all registers used by the const instructions
            var constRegs = new Dictionary<Register, Instruction>();
            var toRemove = new HashSet<Instruction>();
            foreach (var ins in constInstructions.Keys)
            {
                var reg = ins.Registers[0];
                if (constRegs.ContainsKey(reg))
                {
                    // Oops, duplicate register, remove this one
                    toRemove.Add(ins);
                    toRemove.Add(constRegs[reg]);
                }
                else
                {
                    // Add it
                    constRegs[reg] = ins;
                }
            }
            foreach (var ins in toRemove)
            {
                constInstructions.Remove(ins);
                constRegs.Remove(ins.Registers[0]);
            }
            foreach (var ins in body.Instructions)
            {
                if (constInstructions.ContainsKey(ins))
                    continue;

                var insRegs = ins.Registers;
                for (var k = 0; k < insRegs.Count; k++)
                {
                    var reg = insRegs[k];
                    Instruction constInst;
                    if (constRegs.TryGetValue(reg, out constInst))
                    {
                        if (ins.IsDestinationRegister(k))
                        {
                            // Register is a destination in another instruction, the constInst is not readonly.
                            constInstructions.Remove(constInst);
                            constRegs.Remove(reg);
                        }
                    }
                }
            }
        }

        public MSILDisassembler(MethodBody body)
        {
            MethodBody = body;

            Section section = Section.GetSectionByRva(body.Method._netheader._assembly, body.Method.RVA);

            _ilOffset = new OffsetConverter(section).RvaToFileOffset(body.Method.RVA) + (uint)body.HeaderSize;

            _reader = section.ParentAssembly._peImage.Reader;
            TokenResolver = new MetaDataTokenResolver(body.Method._netheader);
        }

    public void Execute()
    {
        moduleWeaver.LogInfo("\t\t" + propertyData.PropertyDefinition.Name);
        var property = propertyData.PropertyDefinition;
        setMethodBody = property.SetMethod.Body;
        instructions = property.SetMethod.Body.Instructions;

        foreach (var instruction in GetInstructions())
        {
            Inject(instruction);
        }
    }

        public bool Transform(Dex target, MethodBody body)
        {
            bool hasChanges = false;
#if DEBUG
            //return;
#endif
            var instructions = body.Instructions;
            var hasNops = instructions.Any(x => x.Code == RCode.Nop);
            if (!hasNops)
                return false;

            var rerouter = new BranchReRouter(body);
            var i = 0;
            while (i < instructions.Count)
            {
                var inst = instructions[i];
                if (inst.Code != RCode.Nop)
                {
                    i++;
                    continue;
                }
                if (body.Exceptions.Count > 0)
                {
                    foreach (var ex in body.Exceptions.Where(x => x.TryEnd == inst).ToList())
                    {
                        var exTryEnd = ex.TryEnd;
                        if (exTryEnd.Index > ex.TryStart.Index)
                            exTryEnd = exTryEnd.Previous;

                        if (exTryEnd == ex.TryStart)
                        {
                            // empty exception handler -- remove.
                            body.Exceptions.Remove(ex);
                        }
                        else
                        {
                            ex.TryEnd = exTryEnd;
                        }
                    }
                }

                if (i < instructions.Count - 1)
                {
                    var next = instructions[i + 1];
                    rerouter.Reroute(inst, next);
                }
                instructions.RemoveAt(i);
                hasChanges = true;
            }

            return hasChanges;
        }