LSL-PyOptimizer/lslopt/lsldeadcode.py

#    (C) Copyright 2015-2018 Sei Lisa. All rights reserved.
#
#    This file is part of LSL PyOptimizer.
#
#    LSL PyOptimizer is free software: you can redistribute it and/or
#    modify it under the terms of the GNU General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    LSL PyOptimizer is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with LSL PyOptimizer. If not, see <http://www.gnu.org/licenses/>.

# Dead Code Removal optimization

import lslfuncs
from lslcommon import nr

class deadcode(object):

    def MarkReferences(self, node):
        """Marks each node it passes through as executed (X), and each variable
        as read (R) (with count) and/or written (W) (with node where it is, or
        False if written more than once) as appropriate. Traces execution to
        determine if any part of the code is never executed.
        """
        # The 'X' key, when present, indicates whether a node is executed.
        # Its value means whether this instruction will proceed to the next
        # (True: it will; False: it won't).
        if hasattr(node, 'X'):
            return node.X # branch already analyzed

        nt = node.nt
        child = node.ch

        # Control flow statements

        if nt == 'STSW':
            node.X = False # Executed but path-breaking.
            sym = self.symtab[0][node.name]
            if not hasattr(self.tree[sym['Loc']], 'X'):
                self.MarkReferences(self.tree[sym['Loc']])

            return False

        if nt == 'JUMP':
            node.X = False # Executed but path-breaking.
            sym = self.symtab[node.scope][node.name]
            if 'R' in sym:
                sym['R'] += 1
            else:
                sym['R'] = 1
            return False

        if nt == 'RETURN':
            node.X = False # Executed but path-breaking.
            if child:
                self.MarkReferences(child[0])
            return False

        if nt == 'IF':
            # "When you get to a fork in the road, take it."
            node.X = None # provisional value, refined later
            self.MarkReferences(child[0])
            condnode = child[0]
            if condnode.nt == 'CONST':
                if lslfuncs.cond(condnode.value):
                    # TRUE - 'then' branch always executed.
                    node.X = self.MarkReferences(child[1])
                    return node.X
                elif len(child) == 3:
                    # FALSE - 'else' branch always executed.
                    node.X = self.MarkReferences(child[2])
                    return node.X
                # else fall through
            else:
                cont = self.MarkReferences(child[1])
                if len(child) == 3:
                    if not cont:
                        cont = self.MarkReferences(child[2])
                        node.X = cont
                        return cont
                    self.MarkReferences(child[2])
            node.X = True
            return True

        if nt == 'WHILE':
            node.X = None # provisional value, refined later
            self.MarkReferences(child[0])

            if child[0].nt == 'CONST':
                if lslfuncs.cond(child[0].value):
                    # Infinite loop - unless it returns, it stops
                    # execution. But it is executed itself.
                    self.MarkReferences(child[1])
                    node.X = False
                    return node.X
                # else the inside isn't executed at all, so don't mark it
            else:
                self.MarkReferences(child[1])
            node.X = True
            return True

        if nt == 'DO':
            node.X = None # provisional value, refined later
            if not self.MarkReferences(child[0]):
                node.X = False
                return False
            self.MarkReferences(child[1])
            # It proceeds to the next statement unless it's an infinite loop
            node.X = not (child[1].nt == 'CONST' and lslfuncs.cond(child[1].value))
            return node.X

        if nt == 'FOR':
            node.X = None # provisional value, refined later
            self.MarkReferences(child[0])
            self.MarkReferences(child[1])
            if child[1].nt == 'CONST':
                if lslfuncs.cond(child[1].value):
                    # Infinite loop - unless it returns, it stops
                    # execution. But it is executed itself.
                    node.X = False
                    self.MarkReferences(child[3])
                    self.MarkReferences(child[2]) # this can't stop execution
                    return node.X
                # else the body and the iterator aren't executed at all, so
                # don't mark them
                node.X = True
            else:
                node.X = True
                self.MarkReferences(child[3])
                self.MarkReferences(child[2])
            # Mark the EXPRLIST as always executed, but not the subexpressions.
            # That forces the EXPRLIST (which is a syntactic requirement) to be
            # kept, while still simplifying the contents properly.
            child[2].X = True
            return True

        if nt == '{}':
            # Go through each statement in turn. If one stops execution,
            # continue reading until either we find a used label (and resume
            # execution) or reach the end (and return False). Otherwise return
            # True.

            continues = True
            node.X = None # provisional
            for stmt in child:
                if continues or stmt.nt == '@':
                    continues = self.MarkReferences(stmt)
            node.X = continues
            return continues

        if nt == 'FNCALL':
            node.X = None # provisional
            sym = self.symtab[0][node.name]

            fdef = self.tree[sym['Loc']] if 'Loc' in sym else None
            for idx in xrange(len(child)-1, -1, -1):
                # Each element is a "write" on the callee's parameter.
                # E.g. f(integer a, integer b) { f(2,3); } means 2, 3 are
                # writes to a and b.
                self.MarkReferences(child[idx])
                if fdef is not None:
                    psym = self.symtab[fdef.pscope][fdef.pnames[idx]]
                    if 'W' in psym:
                        psym['W'] = False
                    else:
                        psym['W'] = child[idx]

            if 'Loc' in sym:
                if not hasattr(self.tree[sym['Loc']], 'X'):
                    self.MarkReferences(self.tree[sym['Loc']])
                node.X = self.tree[sym['Loc']].X
            else:
                node.X = 'stop' not in sym
            # Note that JUMP analysis is incomplete. To do it correctly, we
            # should follow the jump right to its destination, in order to know
            # if that branch leads to a RETURN or completely stops the event.
            # With our code structure, following the JUMP is unfeasible.
            # For that reason, we can't track whether a branch ends in RETURN
            # or in something more powerful like a script reset, in order to
            # propagate it through the function definition to the caller.
            #
            # In practice, this means that the caller can't distinguish this:
            #     fn() { return; }
            # from this:
            #     fn() { llResetScript(); }
            # and therefore, invocations of the function that are followed by
            # code can't know whether that code is dead or not.
            #
            # What does that have to do with jumps? Well, imagine this:
            #     fn(integer x) { if (x) jump x1; else jump x2;
            #                     @x1; return; @x2; llResetScript(); }
            # What of the branches of if() is taken, depends on where the jumps
            # lead to. Assuming the last one always is wrong, because it would
            # mark in the caller code that may execute, as dead, e.g. here:
            #     fn2() { fn(); x = 1; }


            return node.X

        if nt == 'DECL':
            sym = self.symtab[node.scope][node.name]
            if child is not None:
                sym['W'] = child[0]
            else:
                sym['W'] = nr(nt='CONST', t=node.t,
                    value=self.DefaultValues[node.t])

            node.X = True
            if child is not None:
                if hasattr(child[0], 'orig'):
                    orig = child[0].orig
                    self.MarkReferences(orig)
                    child[0].X = orig.X
                    if orig.nt == 'LIST':
                        # Add fake writes to variables used in list elements in
                        # 'orig', so they don't get deleted (Issue #3)
                        for subnode in orig.ch:
                            if subnode.nt == 'IDENT':
                                # can only happen in globals
                                assert subnode.scope == 0
                                sym = self.symtab[0][subnode.name]
                                sym['W'] = False
                                self.tree[sym['Loc']].X = True
                            elif subnode.nt in ('VECTOR', 'ROTATION'):
                                for sub2node in subnode.ch:
                                    if sub2node.nt == 'IDENT':
                                        # can only happen in globals
                                        assert sub2node.scope == 0
                                        sym = self.symtab[0][sub2node.name]
                                        sym['W'] = False
                                        self.tree[sym['Loc']].X = True
                else:
                    self.MarkReferences(child[0])
            return True

        # ---- Starting here, all node types return through the bottom
        #      (except '=').

        node.X = None # provisional
        if nt in self.assign_ops or nt in ('--V', '++V', 'V++', 'V--'):
            ident = node.ch[0]
            if ident.nt == 'FLD':
                ident = ident.ch[0]
            assert ident.nt == 'IDENT'
            sym = self.symtab[ident.scope][ident.name]
            if ident.scope == 0:
                # Mark the global first.
                self.MarkReferences(self.tree[sym['Loc']])
            # In any case, this is at least the second write, so mark it as such
            # (SSA would be a plus for this to be optimal)
            sym['W'] = False

            if nt == '=':
                # Prevent the first node from being mistaken as a read, by
                # recursing only on the RHS node.
                self.MarkReferences(child[1])
                node.X = True
                return True

        elif nt == 'FLD':
            # Mark this variable as referenced by a Field (recursing will mark
            # the ident as read later)
            self.symtab[child[0].scope][child[0].name]['Fld'] = True

        elif nt == 'IDENT':
            sym = self.symtab[node.scope][node.name]
            # Mark global if it's one.
            if 'W' not in sym and node.scope == 0:
                self.MarkReferences(self.tree[sym['Loc']])
            # Increase read counter
            if 'R' in sym:
                sym['R'] += 1
            else:
                sym['R'] = 1

        node.X = True
        if child is not None:
            for subnode in child:
                self.MarkReferences(subnode)

        return True

    def SymbolReplacedOrDeleted(self, curnode):
        """If the given node's name must be simplified, that is, replaced or
        deleted (deleted if declaration, replaced if identifier), it returns
        the symbol table entry. Otherwise it returns False.
        """
        # 'W':False means written more than once, i.e. not only in the
        # declaration. Variables written more than once can't be
        # simplified by this code.

        # If not written more than once:
        #   For expressions:
        #   - Remove expressions read only once, replacing the value, but only
        #     if the readers are not fields of vectors or rotations, and if
        #     they are side-effect free.
        #   For constants:
        #   - Remove lists, vectors and rotations read only once.
        #   - Floats are removed if their value has no decimals or if
        #     used no more than N times (for some N).
        #   - Strings, keys and integers are just removed.
        sym = self.symtab[curnode.scope][curnode.name]

        if 'R' not in sym:
            return True # if not used, it can be removed

        # Event parameters do not have 'W' in sym.
        if 'W' not in sym:
            return False

        if sym['W'] is not False:

            node = sym['W']
            nt = node.nt
            if nt == 'CONST':
                tcurnode = curnode.t
                if tcurnode in ('integer', 'string', 'key'):
                    return sym

                if tcurnode == 'float':
                    if sym['R'] <= 3 or type(node.value) == int:
                        return sym
                elif tcurnode == 'vector' \
                     or tcurnode == 'list' and len(node.value) <= 3:
                    if sym['R'] <= 1:
                        return sym
                elif tcurnode == 'rotation' \
                     or tcurnode == 'list' and len(node.value) <= 4:
                    if sym['R'] <= 1:
                        return sym
                return False

            # To replace expressions, they MUST be side-effect free, or they
            # will be executed at a different time.
            # Also, we can't safely replace expressions unless shrinknames is
            # active. shrinknames assigns a different identifier to each
            # variable, which avoids conflicts. Consider this scenario:
            #  integer i=2;
            #  default{state_entry(){integer j=i+1; integer i=4; llSleep(i+j);}}
            # Replacing j with i+1 in llOwnerSay will produce wrong code because
            # the name i is redefined after j is assigned. shrinknames prevents
            # that.
            # FIXME: EMERGENCY FIX: shrinknames is not enough guarantee. See nposerlv.lsl.
            #if not self.shrinknames or not node.SEF:
            if True or not node.SEF:
                return False

            if nt not in ('VECTOR', 'ROTATION'):
                # If it's an expression and the reference is to a field, we
                # can't simplify. Consider e.g.:
                #    vector v = llGetVel(); llOwnerSay((string)v.z);
                # However, if it's a field coming from a Vector or Rotation
                # expression, we can embed the corresponding component, e.g.
                #    vector v = <i+1, i+2, i+3>; llOwnerSay((string)v.y);
                # can be replaced with: llOwnerSay((string)((float)(i+2)));

                if 'Fld' in sym:
                    return False

            if sym['R'] == 1:
                return sym

        return False

    def CleanNode(self, curnode):
        """Recursively checks if the children are used, deleting those that are
        not.
        """
        if curnode.ch is None or (curnode.nt == 'DECL'
                                  and curnode.scope == 0):
            return
        # NOTE: Should not depend on 'Loc', since the nodes that are the
        # destination of 'Loc' are renumbered as we delete stuff from globals.

        index = int(curnode.nt in self.assign_ops) # don't recurse into a lvalue

        while index < len(curnode.ch):
            node = curnode.ch[index]

            if not hasattr(node, 'X'):
                del curnode.ch[index]
                continue

            nt = node.nt

            if nt == 'DECL':
                if self.SymbolReplacedOrDeleted(node):
                    if not node.ch or node.ch[0].SEF:
                        del curnode.ch[index]
                        continue
                    node = curnode.ch[index] = nr(nt='EXPR', t=node.t,
                        ch=[self.Cast(node.ch[0], node.t)])

            elif nt == 'FLD':
                sym = self.SymbolReplacedOrDeleted(node.ch[0])
                if sym:
                    value = sym['W']
                    # Mark as executed, so it isn't optimized out.
                    value.X = True
                    fieldidx = 'xyzs'.index(node.fld)
                    if value.nt == 'CONST':
                        value = value.value[fieldidx]
                        value = nr(nt='CONST', X=True, SEF=True,
                            t=self.PythonType2LSL[type(value)], value=value)
                        value = self.Cast(value, 'float')
                        SEF = True
                    else: # assumed VECTOR or ROTATION per SymbolReplacedOrDeleted
                        SEF = value.SEF
                        value = self.Cast(value.ch[fieldidx], 'float')
                    # Replace it
                    node = curnode.ch[index] = value
                    node.SEF = SEF

            elif nt == 'IDENT':
                sym = self.SymbolReplacedOrDeleted(node)
                if sym:
                    # Mark as executed, so it isn't optimized out.
                    # Make shallow copy.
                    # TODO: Needs more analysis to see if it's correct or not.
                    #       (See constant_anomaly.lsl)
                    new = sym['W'].copy()
                    if hasattr(new, 'orig'):
                        del new.orig

                    new.X = True

                    # this part makes no sense?
                    #new.SEF = sym['W'].SEF

                    if new.t != node.t:
                        new = self.Cast(new, node.t)
                    curnode.ch[index] = node = new
                    # Delete orig if present, as we've eliminated the original
                    #if hasattr(sym['W'], 'orig'):
                    #    del sym['W'].orig

            elif nt in self.assign_ops:
                ident = node.ch[0]
                if ident.nt == 'FLD':
                    ident = ident.ch[0]
                sym = self.SymbolReplacedOrDeleted(ident)
                if sym:
                    node = curnode.ch[index] = self.Cast(node.ch[1], node.t)

            elif nt in ('IF', 'WHILE', 'DO', 'FOR'):
                # If the mandatory statement is to be removed, replace it
                # with a ; to prevent leaving the statement empty.
                child = node.ch
                idx = 3 if nt == 'FOR' else 0 if nt == 'DO' else 1
                if not hasattr(child[idx], 'X'):
                    child[idx] = nr(nt=';', t=None, X=True, SEF=True)
                if nt == 'DO' and not hasattr(child[1],'X'):
                    # Mandatory condition but not executed - replace
                    child[1] = nr(nt='CONST', X=True, SEF=True, t='integer',
                        value=0)

            self.CleanNode(node)
            index += 1


    def RemoveDeadCode(self):
        """Simple reference-based dead code removal. It also performs a
        simplified form of constant propagation, taking advantage of the fact
        that it analyzes the code flow.
        """
        # TODO: Converting to SSA first would facilitate DCR.
        # The SSA should be followed by constant and expression propagation,
        # then constant folding and then dead code removal.

        # Start at state default and mark everything referenced from there.
        # At the end, unreferenced globals and states will be removed.
        # We assume all events in a state are executed.
        #
        # This may not be the case, e.g. a target()/no_target() without
        # llTarget, sensor()/no_sensor() without llSensor(), listen() without
        # llListen, timer without llSetTimerEvent, etc. but we're not that
        # sophisticated (yet).

        # TODO: Inlining of functions that are a single 'return' line.
        # TODO: Remove empty events if they are side effect-free.
        # Note that e.g. touch/* events are not SEF, because their presence
        # causes the hand to be shown, so we need a list of SEF events.

        if lslfuncs.lslcommon.IsCalc:
            # Do nothing if in calculator mode (there's no default event
            # and it crashes without this)
            return

        statedef = self.tree[self.symtab[0]['default']['Loc']]
        assert statedef.nt == 'STDEF' and statedef.name == 'default'
        self.MarkReferences(statedef)

        # Track removal of global lines, to reasign locations later.
        LocMap = range(len(self.tree))

        GlobalDeletions = []

        # Perform the removal
        idx = 0
        while idx < len(self.tree):
            # Globals are special.
            # We need to track the locations too.
            node = self.tree[idx]

            delete = False
            if not hasattr(node, 'X'):
                delete = True
            elif node.nt == 'DECL':
                delete = self.SymbolReplacedOrDeleted(node)

            if delete:
                # Mark the symbol for later deletion from symbol table.
                # We can't remove it here because there may be more references
                # that we will remove in CleanNode later, that hold the
                # original value.
                if node.nt == 'DECL' or node.nt == 'STDEF':
                    GlobalDeletions.append(node.name)
                del self.tree[idx]
                del LocMap[idx]
            else:
                idx += 1
                self.CleanNode(node)

        # Remove the globals now.
        for name in GlobalDeletions:
            del self.symtab[0][name]

        del GlobalDeletions

        # Reassign locations
        for name in self.symtab[0]:
            if name != -1:
                sym = self.symtab[0][name]
                if 'Loc' in sym:
                    try:
                        sym['Loc'] = LocMap.index(sym['Loc'])
                    except ValueError:
                        # Subtree deleted - delete the Loc
                        del sym['Loc']