Class MethodModel


  • public class MethodModel
    extends java.lang.Object
    • Field Detail

      • logger

        private static java.util.logging.Logger logger
      • usesDoubles

        private boolean usesDoubles
        True is an indication to use the fp64 pragma
      • usesByteWrites

        private boolean usesByteWrites
        True is an indication to use the byte addressable store pragma
      • methodIsGetter

        private boolean methodIsGetter
      • methodIsSetter

        private boolean methodIsSetter
      • methodIsPrivateMemoryGetter

        private boolean methodIsPrivateMemoryGetter
      • usesPutfield

        private boolean usesPutfield
      • noCL

        private boolean noCL
      • calledMethods

        private final java.util.Set<MethodModel> calledMethods
      • pcTail

        private Instruction pcTail
        After we have folded the top level instructions this root list will contain a list of all of the 'root' instructions (stores/loops/conditionals) We are going to build a linked list. Here we track the head and tail
    • Method Detail

      • isGetter

        public boolean isGetter()
      • isSetter

        public boolean isSetter()
      • methodUsesPutfield

        public boolean methodUsesPutfield()
      • isNoCL

        public boolean isNoCL()
      • isPrivateMemoryGetter

        public boolean isPrivateMemoryGetter()
      • getCalledMethods

        public java.util.Set<MethodModel> getCalledMethods()
      • setRequiredPragmas

        public void setRequiredPragmas​(Instruction instruction)
        Look at each instruction for use of long/double or byte writes which require pragmas to be used in the OpenCL source
      • requiresDoublePragma

        public boolean requiresDoublePragma()
      • requiresByteAddressableStorePragma

        public boolean requiresByteAddressableStorePragma()
      • createListOfInstructions

        public java.util.Map<java.lang.Integer,​Instruction> createListOfInstructions()
                                                                                    throws ClassParseException
        Create a linked list of instructions (from pcHead to pcTail). Returns a map of int (pc) to Instruction which to allow us to quickly get from a bytecode offset to the appropriate instruction. Note that not all int values from 0 to code.length values will map to a valid instruction, if pcMap.get(n) == null then this implies that 'n' is not the start of an instruction So either pcMap.get(i)== null or pcMap.get(i).getThisPC()==i
        Returns:
        Map the returned pc to Instruction map
        Throws:
        ClassParseException
      • buildBranchGraphs

        public void buildBranchGraphs​(java.util.Map<java.lang.Integer,​Instruction> pcMap)
        Here we connect the branch nodes to the instruction that they branch to.

        Each branch node contains a 'target' field indended to reference the node that the branch targets. Each instruction also contain four seperate lists of branch nodes that reference it. These lists hold forwardConditional, forwardUnconditional, reverseConditional and revereseUnconditional branches that reference it.

        So assuming that we had a branch node at pc offset 100 which represented 'goto 200'.

        Following this call the branch node at pc offset 100 will have a 'target' field which actually references the instruction at pc offset 200, and the instruction at pc offset 200 will have the branch node (at 100) added to it's forwardUnconditional list.

        See Also:
        InstructionSet.Branch.getTarget()
      • deoptimizeReverseBranches

        public void deoptimizeReverseBranches()
        Javac optimizes some branches to avoid goto->goto, branch->goto etc. This method specifically deals with reverse branches which are the result of such optimisations.
         
         
      • txFormDups

        public void txFormDups​(ExpressionList _expressionList,
                               Instruction _instruction)
                        throws ClassParseException
        DUP family of instructions break our stack unwind model (whereby we treat instructions like the oeprands they create/consume).

        Here we replace DUP style instructions with a 'mock' instruction which 'clones' the effect of the instruction. This would be invalid to execute but is useful to replace the DUP with a 'pattern' which it simulates. This allows us to later apply transforms to represent the original code.

        An example might be the bytecode for the following sequence.

            results[10]++; 
                 return
         
        Which results in the following bytecode
              0:   aload_0       // reference through 'this' to get 
              1:   getfield      // field 'results' which is an array of int
              4:   bipush  10    // push the array index
              6:   dup2          // dreaded dup2 we'll come back here
              7:   iaload        // ignore for the moment.
              8:   iconst_1
              9:   iadd
              10:  iastore
              11:  return
         
        First we need to know what the stack will look like before the dup2 is encountered. Using our folding technique we represent the first two instructions inside ()
        
                   getfield (aload_0     // result in the array field reference on stack
                   bipush  10            // the array index
                   dup2                  // dreaded dup2 we'll come back here
         
        The dup2 essentially copies the top two elements on the stack. So we emulate this by replacing the dup2 with clones of the instructions which would reinstate the same stack state.

        So after the dup2 transform we end up with:-

        
                  getfield (aload_0)     // result in the array field reference on stack
                  bipush  10             // the array index
                  {getfield (aload_0)}   // result in the array field reference on stack
                  {bipush 10}            // the array index
         
        So carrying on lets look at the iaload which consumes two operands (the index and the array field reference) and creates one (the result of an array access)
        
                  getfield (aload_0)     // result in the array field reference on stack
                  bipush  10             // the array index
                  {getfield (aload_0)}   // result in the array field reference on stack
                  {bipush  10}           // the array index
                  iaload 
         
        So we now have
        
                  getfield (aload_0)                        // result in the array field reference on stack
                  bipush  10                                // the array index
                  iaload ({getfield(aload_0), {bipush 10})  // results in the array element on the stack
                  iconst
                  iadd
         
        And if you are following along the iadd will fold the previous two stack entries essentially pushing the result of results[10]+1 on the stack.
        
                  getfield (aload_0)                                        // result in the array field reference on stack
                  bipush  10                                                // the array index
                  iadd (iaload ({getfield(aload_0), {bipush 10}, iconst_1)  // push of results[10]+1 
         
        Then the final istore instruction which consumes 3 stack operands (the field array reference, the index and the value to assign).

        Which results in

         
                  istore (getfield (aload_0), bipush 10,  iadd (iaload ({getfield(aload_0), {bipush 10}, iconst_1)) // results[10] = results[10+1]
         
        Where results[10] = results[10+1] is the long-hand form of the results[10]++ and will be transformed by one of the 'inc' transforms to the more familiar form a little later.
        Parameters:
        _expressionList -
        _instruction -
        Throws:
        ClassParseException
      • foldExpressions

        void foldExpressions()
                      throws ClassParseException
        Try to fold the instructions into higher level structures. At the end we have a folded instruction tree with 'roots' containing the top level branches (stores mostly)
        Throws:
        ClassParseException
      • getSimpleName

        public java.lang.String getSimpleName()
      • getName

        public java.lang.String getName()
      • getReturnType

        public java.lang.String getReturnType()
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object