Beispiel #1
0
 private void addCodeSequence(IList <CodeSequence> codeSequences, CodeSequence codeSequence)
 {
     if (codeSequence != null)
     {
         if (codeSequence.Length > 1)
         {
             codeSequences.Add(codeSequence);
         }
     }
 }
Beispiel #2
0
        public SequenceCodeInstruction(CodeSequence codeSequence)
        {
            this.codeSequence = codeSequence;
            Address           = codeSequence.StartAddress;

            CodeInstruction firstInstruction = codeSequence.Instructions[0];

            BranchTarget = firstInstruction.BranchTarget;
            Branching    = firstInstruction.Branching;
            BranchingTo  = firstInstruction.BranchingTo;
        }
Beispiel #3
0
        private void splitCodeSequences(CompilerContext context, int methodMaxInstructions)
        {
            IList <CodeSequence> codeSequences = new List <CodeSequence>();

            generateCodeSequences(codeSequences, methodMaxInstructions);
            codeSequences.Sort();

            int currentMethodInstructions           = codeInstructions.Count;
            IList <CodeSequence> sequencesToBeSplit = new List <CodeSequence>();

            foreach (CodeSequence codeSequence in codeSequences)
            {
                sequencesToBeSplit.Add(codeSequence);
                //if (log.DebugEnabled)
                {
                    Console.WriteLine("Sequence to be split: " + codeSequence.ToString());
                }
                currentMethodInstructions -= codeSequence.Length;
                if (currentMethodInstructions <= methodMaxInstructions)
                {
                    break;
                }
            }

            CodeSequence currentCodeSequence = null;

//JAVA TO C# CONVERTER WARNING: Unlike Java's ListIterator, enumerators in .NET do not allow altering the collection:
            for (IEnumerator <CodeInstruction> lit = codeInstructions.GetEnumerator(); lit.MoveNext();)
            {
                CodeInstruction codeInstruction = lit.Current;
                CodeSequence    codeSequence    = findCodeSequence(codeInstruction, sequencesToBeSplit, currentCodeSequence);
                if (codeSequence != null)
                {
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
                    lit.remove();
                    if (codeSequence.Instructions.Count == 0)
                    {
                        codeSequence.addInstruction(codeInstruction);
                        SequenceCodeInstruction sequenceCodeInstruction = new SequenceCodeInstruction(codeSequence);
                        lit.add(sequenceCodeInstruction);
                        sequenceCodeInstructions.AddLast(sequenceCodeInstruction);
                    }
                    else
                    {
                        codeSequence.addInstruction(codeInstruction);
                    }
                    currentCodeSequence = codeSequence;
                }
            }
        }
Beispiel #4
0
        private CodeSequence findCodeSequence(CodeInstruction codeInstruction, IList <CodeSequence> codeSequences, CodeSequence currentCodeSequence)
        {
            int address = codeInstruction.Address;

            if (currentCodeSequence != null)
            {
                if (currentCodeSequence.isInside(address))
                {
                    return(currentCodeSequence);
                }
            }

            foreach (CodeSequence codeSequence in codeSequences)
            {
                if (codeSequence.isInside(address))
                {
                    return(codeSequence);
                }
            }

            return(null);
        }
Beispiel #5
0
        private void generateCodeSequences(IList <CodeSequence> codeSequences, int sequenceMaxInstructions)
        {
            CodeSequence currentCodeSequence = null;

            int nextAddress = 0;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'sealed override':
//ORIGINAL LINE: sealed override int sequenceMaxInstructionsWithDelay = sequenceMaxInstructions - 1;
            int sequenceMaxInstructionsWithDelay = sequenceMaxInstructions - 1;

            foreach (CodeInstruction codeInstruction in codeInstructions)
            {
                int address = codeInstruction.Address;
                if (address < nextAddress)
                {
                    // Skip it
                }
                else
                {
                    if (codeInstruction.hasFlags(Instruction.FLAG_CANNOT_BE_SPLIT))
                    {
                        addCodeSequence(codeSequences, currentCodeSequence);
                        currentCodeSequence = null;
                        if (codeInstruction.hasFlags(Instruction.FLAG_HAS_DELAY_SLOT))
                        {
                            nextAddress = address + 8;
                        }
                    }
                    else if (codeInstruction.BranchTarget)
                    {
                        addCodeSequence(codeSequences, currentCodeSequence);
                        currentCodeSequence = new CodeSequence(address);
                    }
                    else
                    {
                        if (currentCodeSequence == null)
                        {
                            currentCodeSequence = new CodeSequence(address);
                        }
                        else if (currentCodeSequence.Length + codeInstruction.Length > sequenceMaxInstructionsWithDelay)
                        {
                            bool doSplit = false;
                            if (currentCodeSequence.Length + codeInstruction.Length > sequenceMaxInstructions)
                            {
                                doSplit = true;
                            }
                            else if (codeInstruction.hasFlags(Instruction.FLAG_HAS_DELAY_SLOT))
                            {
                                doSplit = true;
                            }
                            if (doSplit)
                            {
                                addCodeSequence(codeSequences, currentCodeSequence);
                                currentCodeSequence = new CodeSequence(address);
                            }
                        }
                        currentCodeSequence.EndAddress = codeInstruction.EndAddress;
                    }
                }
            }

            addCodeSequence(codeSequences, currentCodeSequence);
        }