Generating Code for Methods

Generating Code for Methods

1. It seems like it would be a good idea to review/summarize the suggestions for generating code for methods and method invocations.
   • First, at this point, the idea is that the actual code generated for a method's body would look like:

     methLabel    LINK    A6,#-sizeOfLocalsAndTemps
                  MOVE    A5,objPtrSaveDisp(A6)
                         ...
                    code for the statements in the body
                         ...
                  UNLK    A6
                  RTD     #-numberOfParams
     

     Note: The correct value for "sizeOfLocalsAndTemps" won't be known until after the code for the body is generated. You can use a symbolic label in the LINK instruction and then generate an assembler EQU directive after the RTD.
   • Second, while processing of each class, you should generate a method jump table of the form:

     jmpTabLabel    DC      superClassTableLabel
                    JMP    method 1
                    JMP    method 2
                        ....
     

     Note: We haven't actually talked about the initial DC yet, but I will shortly.
   • Next, during semantic processing, you will restructure the tree so that any invocation of the form:

               methname( ... )
                          

     in which "methname" refers to a method from a surrounding class will be rewritten as a tree for an invocation of the form

               expr.methname( ... )
                          

     where the tree for "expr" is basically a chain of ref-var nodes designed to generate code that will take the correct number of steps up the chain of static links to get to the object with which "methname" is associated.
   • Next (to last), when you encounter an invocation of the form:

               methname( param1, param2, ... )
                          

     you will generate code for the form:

            SUB    #1,A7      // space to save A5?
              code for param1
            MOVE   p1-op,-(A7)
              code for param2
            MOVE   p2-op,-A7)
               ...
            MOVE   (A5),Ai      // get addr of method tab
            JSR    1+methNum*2(Ai)
            ADD    #1,A7      // pop space for saved A5                       
                        or         
            MOVE   (SP)+,some-temp // access return value
                            

   • Finally, when you encounter an invocation of the form:

               expr.methname( param1, param2, ... )
                          

     you will generate code for the form:

            SUB    #1,A7      // space to save A5?
              code for param1
            MOVE   p1-op,-(A7)
              code for param2
            MOVE   p2-op,-A7)
               ...
               code for expr
            MOVE   expr-op,A5
            MOVE   (A5),Ai      // get addr of method tab
            JSR    1+methNum*2(Ai)
            MOVE   objPtrSaveDisp(A6),A5  // restore A5
            ADD    #1,A7      // pop space for saved A5                       
                        or         
            MOVE   (SP)+,some-temp // access return value
                            

2. As mentioned above, to make all this work, you should restructure the trees for invocations of non-local methods so that they look like trees for qualified invocations. To do this you will add a subtree that describes an expression that evaluates to the object on which the method should be invoked.
   • The root of the expression subtree will be a refvar node.
   • The displacement in the root ref-var node will be the displacement to the static link within an object (probably 1).
   • The base address pointer for the refvar node will either be another tree rooted at a similar refvar node or Nthis.
   • The number of refvar nodes chained together before you get to an Nthis should equal the difference between the level of the class in which the invocation occurs and the level of the class with which the method being invoked is associated (which is not necessarily the same as the class in which the method was declared thanks to inheritance).

3. Finally, since all of this depends upon the idea that objects will contain pointers to method tables and also contain static links, we should talk about implementing the "new" operation for a moment.
   • Eventually, your code for "new" will have to interact with some sort of library routine that talks to the garbage collector. For now, however, let's just assume that you never run out of memory.
   • At the end of your code, generate instructions like:

           freePtr        DC   freeAreaStart
           freeAreaStart  DS   1
                

     This will ensure that the word labeled "freePtr" will contain the address of the first unused wordin memory.
   • When you have to generate code for a new operation output something like:

        MOVE   freePtr,Ai        // Get addr of new obj
        ADD    #objSize,freePtr  // Increment free ptr
        LEA    classMethTab,(Ai) // Set ptr to method tab
        MOVE   1(A5),Aj          // Get 
        MOVE   1(Aj),Aj          //     static 
             ...                 //        link
        MOVE   Aj,1(Ai)          // Set static link
                   

   • Later, we will replace the first two instruction with a JSR to a library routine that will allocate a given amount of space (calling the garbage collector if necessary).

Generating Code for Methods