# no simplification result = node self.memoization_map[node] = result return result class Pass_LogicalSimplification(FunctionPass): """ Pass to simplify logical operation """ pass_tag = "logical_simplification" def __init__(self, target): FunctionPass.__init__(self, "logical operation simplification pass", target) ## memoization map for promoted optree self.memoization_map = {} self.simplifier = LogicalSimplification(target) def execute_on_optree(self, node, fct=None, fct_group=None, memoization_map=None): """ If node can be transformed returns the transformed node else returns None """ return self.simplifier.simplify(node) Log.report(LOG_PASS_INFO, "Registering logical_simplification pass") # register pass Pass.register(Pass_LogicalSimplification)
target) ## memoization map for promoted optree self.memoization_map = {} self.expander = VectorMaskTestExpander(target) def can_be_transformed(self, node, *args): """ Returns True if @p can be expanded from a multi-precision node to a list of scalar-precision fields, returns False otherwise """ return self.expander.is_expandable(node) def transform_node(self, node, transformed_inputs, *args): """ If node can be transformed returns the transformed node else returns None """ return self.expander.expand_node(node) def reconstruct_from_transformed(self, node, transformed_node): """return a node at the root of a transformation chain, compatible with untransformed nodes """ return transformed_node ## standard Opt pass API def execute(self, optree): """ Implémentation of the standard optimization pass API """ return self.transform_graph(optree) Log.report(LOG_PASS_INFO, "Registering vector_mask_test_legalization pass") # register pass Pass.register(Pass_VectorMaskTestLegalization)
OptreeOptimization.__init__(self, "basic legalization pass", target) ## memoization map for promoted optree self.memoization_map = {} self.expander = BasicExpander(target) def can_be_transformed(self, node, *args): """ Returns True if @p can be expanded from a multi-precision node to a list of scalar-precision fields, returns False otherwise """ return self.expander.is_expandable(node) def transform_node(self, node, transformed_inputs, *args): """ If node can be transformed returns the transformed node else returns None """ return self.expander.expand_node(node) def reconstruct_from_transformed(self, node, transformed_node): """return a node at the root of a transformation chain, compatible with untransformed nodes """ return transformed_node ## standard Opt pass API def execute(self, optree): """ Implémentation of the standard optimization pass API """ return self.transform_graph(optree) Log.report(LOG_PASS_INFO, "Registering basic_legalization pass") # register pass Pass.register(Pass_BasicLegalization)
function-group @p fct_group """ Log.report( LOG_LEVEL_GEN_BB_INFO, "executing pass {} on fct {}".format(self.pass_tag, fct.get_name())) optree = fct.get_scheme() assert isinstance(optree, BasicBlockList) bb_root = optree.get_input(0) bbg = BasicBlockGraph(bb_root, optree) phi_node_insertion(bbg) variable_renaming(bbg) # registering basic-block generation pass Log.report(LOG_PASS_INFO, "Registering generate Basic-Blocks pass") Pass.register(Pass_GenerateBasicBlock) # registering ssa translation pass Log.report(LOG_PASS_INFO, "Registering ssa translation pass") Pass.register(Pass_SSATranslate) if __name__ == "__main__": bb_root = BasicBlock(tag="bb_root") bb_1 = BasicBlock(tag="bb_1") bb_2 = BasicBlock(tag="bb_2") bb_3 = BasicBlock(tag="bb_3") var_x = Variable("x", precision=None) var_y = Variable("y", precision=None) bb_root.add(ReferenceAssign(var_x, 1)) bb_root.add(ReferenceAssign(var_y, 2))