#!/usr/bin/env python  """ Optimise code produced by the AST translator.  Copyright (C) 2007, 2008, 2009 Paul Boddie <paul@boddie.org.uk>  This program 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.  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>. """  from micropython.common import * from micropython.data import * from micropython.rsvp import *  class Optimiser:      "A code optimiser."      supported_optimisations = [         # Code generation optimisations:         "constant_storage", "constant_accessor", "known_target", "self_access",         "temp_storage", "load_operations", "no_operations", "unused_results",         "unused_handlers", "accesses_by_usage",         # Inspection optimisations:         "unused_objects"         ]      def __init__(self, translation, optimisations=None):          """         Provide for the given 'translation' an optimiser for the desired         'optimisations'. See the 'supported_optimisations' attribute of this         class for permitted values.         """          self.translation = translation         self.optimisations = set(optimisations or [])          # The current "active" instruction.         # As a rule, this will become the last instruction, but some         # control-flow operations will flush the "active" instruction.          self.active = None          # The instruction providing the active value.          self.active_value = None      def reset(self):          "Reset the optimiser, clearing the active instructions."          self.clear_active_value()         self.clear_active()      def set_new(self, op):          "Set the latest 'op' as the active instruction."          self.set_active(op)         self.set_active_value(op)      def set_active_value(self, op):          "Set the value-providing active instruction."          if isinstance(op, current_value_instructions):             self.active_value = op      def clear_active_value(self):          "Clear the value-providing active instruction."          self.active_value = None      def remove_active_value(self):          """         Remove the value-providing active instruction from the generated code,         if appropriate, but keep a record of the active instruction itself.         """          if self.active_value is self.active:             removed = self.active             self.translation.remove_op()             return removed         else:             return None      def set_source(self, expr):          "Set the source of the active instruction to 'expr'."          if self.active is not None:             self.active.source = expr      def set_active(self, op):          "Set the active instruction."          self.active = op      def clear_active(self):          "Clear the active instruction."          self.active = None      # Optimisation tests.      def should_optimise_constant_storage(self):         return "constant_storage" in self.optimisations      def should_optimise_constant_accessor(self):         return "constant_accessor" in self.optimisations      def should_optimise_known_target(self):         return "known_target" in self.optimisations      def should_optimise_self_access(self):         return "self_access" in self.optimisations      def should_optimise_temp_storage(self):         return "temp_storage" in self.optimisations      def should_optimise_load_operations(self):         return "load_operations" in self.optimisations      def should_optimise_away_no_operations(self):         return "no_operations" in self.optimisations      def should_optimise_unused_results(self):         return "unused_results" in self.optimisations      def should_optimise_unused_handlers(self):         return "unused_handlers" in self.optimisations      def should_optimise_accesses_by_attribute_usage(self):         return "accesses_by_usage" in self.optimisations      # Simple tests.      def is_constant_input(self, instruction):          "Return whether 'instruction' provides a constant input."          return isinstance(instruction, LoadAddress) and instruction.attr.assignments == 1 and \             isinstance(instruction.attr.get_value(), Constant) or \             isinstance(instruction, (LoadConst, LoadClass, LoadFunction))      def is_constant_target(self, instruction):          "Return whether 'instruction' provides a constant target."          # NOTE: Removed StoreName, since this would then demand population of         # NOTE: locals/frames.          return isinstance(instruction, (StoreAddress, StoreAddressContext)) and \             instruction.attr.assignments == 1      def is_simple_input(self, instruction):          """         Return whether 'instruction' provides a simple input (typically a load         instruction). A simple input is something which would be represented by         a load operation from a CPU register or special memory location.         """          return isinstance(instruction, (LoadConst, LoadClass, LoadFunction, LoadName, LoadTemp, LoadResult, LoadException, LoadAddress))      def is_simple_input_user(self, instruction):          """         Return whether 'instruction' can use simple input from the current         value. Such instructions would, in a low-level implementation, be able         to have the simple input registers as operands.         """          return isinstance(instruction, simple_input_user_instructions)      def is_resultant_no_operation(self, instruction):          """         Return whether 'instruction' merely stores its input where the input         originally came from.         """          return (             isinstance(instruction.input, LoadTemp) and isinstance(instruction, StoreTemp) and                 instruction.input.attr == instruction.attr) or (             isinstance(instruction.input, LoadResult) and isinstance(instruction, StoreResult)             )      def is_input(self, instruction):          "Return whether 'instruction' provides an input."          return isinstance(instruction, current_value_instructions)      # Convenience tests on outputs.      def have_constant_target(self):          "Return whether the active instruction provides a constant target."          return self.is_constant_target(self.active)      def have_constant_source(self):          "Return whether the active instruction has a constant source."          return self.is_constant_input(self.active.source)      # Convenience tests on inputs.      def have_constant_input(self):          "Return whether the active instruction provides a constant input."          return self.is_constant_input(self.active_value)      have_known_target = have_constant_input      def have_simple_input(self):          "Return whether the active instruction provides a simple input."          return self.is_simple_input(self.active_value)      def have_input(self):          "Return whether the active instruction provides an input."          return self.is_input(self.active_value)      def have_self_input(self, unit):          """         Return whether the active instruction is a reference to self in the         given 'unit'.         """          return isinstance(unit, Function) and \             unit.is_method() and isinstance(self.active_value, LoadName) and \             self.active_value.attr.name == "self"      def have_temp_compatible_access(self):          """         Indicate whether the active instruction can be used in place of access         to a temporary variable retaining the result of the last instruction.         """          # LoadResult cannot be relied upon in general since the result register         # could be updated since first being referenced.          return isinstance(self.active_value, (LoadName, LoadTemp, LoadAddress, LoadConst, LoadClass, LoadFunction)) or \             isinstance(self.active_value, LoadResult) and self.active_value is self.active or \             isinstance(self.active_value, LoadException) and self.active_value is self.active      def have_correct_self_for_target(self, context, unit):          "Return whether the 'context' is compatible with the given 'unit'."          if context is not None and self.have_self_input(unit):              parent = unit.parent             if parent is context or parent.has_subclass(context) or context.has_subclass(parent):                 return 1          return 0      def have_empty_handler(self, instruction):          """         Return whether the active instruction defined a handler for exceptions         which is then discarded by the given 'instruction'.         """          return isinstance(self.translation.last_op(), PushHandler) and isinstance(instruction, PopHandler)      # Optimisation methods. See the supported_optimisations class attribute.      def optimise_constant_storage(self):          """         Where the last operation stores a constant into a target which is also         constant, indicate that both operations should be optimised away.         """          return self.should_optimise_constant_storage() and \             self.have_constant_target() and \             self.have_constant_source()      def optimise_constant_accessor(self):          """         Where the object whose attribute is being accessed is constant, provide         information about its full name.         """          if self.should_optimise_constant_accessor() and self.have_constant_input():             value = self.active_value              # Get the details of the access.              if isinstance(value.attr, Const):                 target_name = value.attr.value_type_name()             else:                 target = value.attr.get_value()                  if target is None:                     return None # no clearly defined target                 elif isinstance(target, Const):                     return target.value_type_name()                 elif isinstance(target, Instance):                     return None # skip production of optimised code                 else:                     return target.full_name()          else:             return None      def optimise_known_target(self):          """         Where the target of an invocation is known, provide information about it         and its context. If a class is being invoked and the conditions are         appropriate, get information about the specific initialiser.         """          if self.should_optimise_known_target() and self.have_known_target():             value = self.active_value             target = value.attr.get_value()             context = value.attr.get_context()              # Return target details only if this is clearly defined.              if target is not None:                 return target, context          return None      def optimise_self_access(self, unit, attrname):          """         Return whether code in the given 'unit' is able to access the given         'attrname' through the same position in all possible objects which might         be accessed.         """          return self.should_optimise_self_access() and \             self.have_self_input(unit) and not unit.is_relocated(attrname)      def optimise_temp_storage(self):          """         Where the next operation would involve storing a value into temporary         storage at 'temp_position', record and remove any simple instruction         which produced the value to be stored such that instead of subsequently         accessing the temporary storage, that instruction is substituted.          If no optimisation can be achieved, a StoreTemp instruction is produced         and the appropriate LoadTemp instruction is returned.          Restriction: for use only in situations where the source of the         temporary data will not be disturbed between its first access and its         subsequent use.         """          if self.should_optimise_temp_storage() and \             self.have_temp_compatible_access():              # Remove the active value contributor.              removed = self.remove_active_value()              # Extend the lifetime of any temporary storage location.              self.translation.ensure_temp(removed)             return removed         else:             return self.translation.get_temp()      def optimise_load_operations(self, instruction):          """         Incorporate previous load operations into other operations.         """          if self.should_optimise_load_operations() and \             self.have_simple_input() and \             self.is_simple_input_user(instruction):              self.remove_active_value()             instruction.input = self.active_value      def optimise_away_no_operations(self, instruction):          """         Optimise away operations which just store their inputs in the place         the inputs originally came from.         """          return self.should_optimise_away_no_operations() and \             self.is_resultant_no_operation(instruction)      def optimise_unused_results(self):          "Discard results which will not be used."          if self.should_optimise_unused_results() and self.have_simple_input():             self.remove_active_value()      def optimise_unused_handlers(self, instruction):          "Discard handlers which will not be used."          if self.should_optimise_unused_handlers() and self.have_empty_handler(instruction):             self.translation.remove_op()             return 1         else:             return 0  # vim: tabstop=4 expandtab shiftwidth=4