Skip to content

C
cython
Commit 44b2077c authored by Dag Sverre Seljebotn's avatar Dag Sverre Seljebotn
Browse files
Options

Remove allocate_temps/release_temps phase

parent b9c2853f
Hide whitespace changes
Inline Side-by-side
Showing with 2 additions and 248 deletions
Cython/Compiler/DebugFlags.py
View file @ 44b2077c
......@@ -10,4 +10,4 @@ debug_temp_code_comments = 0
debug_trace_code_generation = 0
# Do not replace exceptions with user-friendly error messages
debug_no_exception_intercept = 0
debug_no_exception_intercept = 1
Cython/Compiler/ExprNodes.py
View file @ 44b2077c
......@@ -102,20 +102,6 @@ class ExprNode(Node):
# the LHS of an assignment or argument of a del
# statement. Similar responsibilities to analyse_types.
#
# allocate_temps
# - Call allocate_temps for all sub-nodes.
# - Call allocate_temp for this node.
# - If a temporary was allocated, call release_temp on
# all sub-expressions.
#
# allocate_target_temps
# - Call allocate_temps on sub-nodes and allocate any other
# temps used during assignment.
# - Fill in result_code with a C lvalue if needed.
# - If a rhs node is supplied, call release_temp on it.
# - Call release_temp on sub-nodes and release any other
# temps used during assignment.
#
# target_code
# Called by the default implementation of allocate_target_temps.
# Should return a C lvalue for assigning to the node. The default
......@@ -278,7 +264,6 @@ class ExprNode(Node):
# checks whether it is a legal const expression,
# and determines its value.
self.analyse_types(env)
self.allocate_temps(env)
self.check_const()
def analyse_expressions(self, env):
......@@ -286,20 +271,17 @@ class ExprNode(Node):
# Analysis and Temp Allocation phases for a whole
# expression.
self.analyse_types(env)
self.allocate_temps(env)
def analyse_target_expression(self, env, rhs):
# Convenience routine performing both the Type
# Analysis and Temp Allocation phases for the LHS of
# an assignment.
self.analyse_target_types(env)
self.allocate_target_temps(env, rhs)
def analyse_boolean_expression(self, env):
# Analyse expression and coerce to a boolean.
self.analyse_types(env)
bool = self.coerce_to_boolean(env)
bool.allocate_temps(env)
return bool
def analyse_temp_boolean_expression(self, env):
......@@ -313,7 +295,6 @@ class ExprNode(Node):
self.analyse_types(env)
bool = self.coerce_to_boolean(env)
temp_bool = bool.coerce_to_temp(env)
temp_bool.allocate_temps(env)
return temp_bool
# --------------- Type Analysis ------------------
......@@ -371,47 +352,6 @@ class ExprNode(Node):
# a subnode.
return self.is_temp
def allocate_target_temps(self, env, rhs):
self.allocate_subexpr_temps(env)
self.is_target = True
if rhs:
rhs.release_temp(env)
self.release_subexpr_temps(env)
def allocate_temps(self, env, result = None):
assert result is None, "deprecated, contact dagss if this triggers"
self.allocate_subexpr_temps(env)
if self.is_temp:
self.release_subexpr_temps(env)
def allocate_temps(self, env, result = None):
# Allocate temporary variables for this node and
# all its sub-expressions. If a result is specified,
# this must be a temp node and the specified variable
# is used as the result instead of allocating a new
# one.
assert result is None, "deprecated, contact dagss if this triggers"
if debug_temp_alloc:
print("%s Allocating temps" % self)
self.allocate_subexpr_temps(env)
self.allocate_temp(env, result)
if self.is_temp:
self.release_subexpr_temps(env)
def allocate_subexpr_temps(self, env):
# Allocate temporary variables for all sub-expressions
# of this node.
if debug_temp_alloc:
print("%s Allocating temps for: %s" % (self, self.subexprs))
for node in self.subexpr_nodes():
if node:
if debug_temp_alloc:
print("%s Allocating temps for %s" % (self, node))
node.allocate_temps(env)
def allocate_temp(self, env, result = None):
assert result is None
def target_code(self):
# Return code fragment for use as LHS of a C assignment.
return self.calculate_result_code()
......@@ -423,20 +363,6 @@ class ExprNode(Node):
# # Release temporaries used by LHS of an assignment.
# self.release_subexpr_temps(env)
def release_temp(self, env):
if self.is_temp:
pass
else:
self.release_subexpr_temps(env)
def release_subexpr_temps(self, env):
# Release the results of all sub-expressions of
# this node.
for node in self.subexpr_nodes():
if node:
node.release_temp(env)
def allocate_temp_result(self, code):
if self.temp_code:
raise RuntimeError("Temp allocated multiple times")
......@@ -2975,26 +2901,6 @@ class SequenceNode(ExprNode):
self.type = py_object_type
env.use_utility_code(unpacking_utility_code)
def allocate_target_temps(self, env, rhs):
self.iterator.allocate_temps(env)
for arg, node in zip(self.args, self.coerced_unpacked_items):
node.allocate_temps(env)
arg.allocate_target_temps(env, None)
#arg.release_target_temp(env)
#node.release_temp(env)
if rhs:
rhs.release_temp(env)
self.iterator.release_temp(env)
for node in self.coerced_unpacked_items:
node.release_temp(env)
# def release_target_temp(self, env):
# #for arg in self.args:
# # arg.release_target_temp(env)
# #for node in self.coerced_unpacked_items:
# # node.release_temp(env)
# self.iterator.release_temp(env)
def generate_result_code(self, code):
self.generate_operation_code(code)
......@@ -3267,13 +3173,6 @@ class ComprehensionNode(ExprNode):
self.type = self.target.type
self.append.target = self # this is a CloneNode used in the PyList_Append in the inner loop
self.loop.analyse_declarations(env)
def allocate_temps(self, env, result = None):
if debug_temp_alloc:
print("%s Allocating temps" % self)
self.allocate_temp(env, result)
# call loop.analyse_expressions() now to make sure temps get
# allocated at the right time
self.loop.analyse_expressions(env)
def calculate_result_code(self):
......@@ -4392,25 +4291,6 @@ class BoolBinopNode(ExprNode):
gil_message = "Truth-testing Python object"
## def allocate_temps(self, env, result_code = None):
## # We don't need both operands at the same time, and
## # one of the operands will also be our result. So we
## # use an allocation strategy here which results in
## # this node and both its operands sharing the same
## # result variable. This allows us to avoid some
## # assignments and increfs/decrefs that would otherwise
## # be necessary.
## self.allocate_temp(env, result_code)
## self.operand1.allocate_temps(env, self.result())
## self.operand2.allocate_temps(env, self.result())
## # We haven't called release_temp on either operand,
## # because although they are temp nodes, they don't own
## # their result variable. And because they are temp
## # nodes, any temps in their subnodes will have been
## # released before their allocate_temps returned.
## # Therefore, they contain no temp vars that need to
## # be released.
def check_const(self):
self.operand1.check_const()
self.operand2.check_const()
......@@ -4753,18 +4633,6 @@ class PrimaryCmpNode(ExprNode, CmpNode):
if self.cascade:
self.cascade.coerce_chars_to_ints(env)
def allocate_subexpr_temps(self, env):
self.operand1.allocate_temps(env)
self.operand2.allocate_temps(env)
if self.cascade:
self.cascade.allocate_subexpr_temps(env)
def release_subexpr_temps(self, env):
self.operand1.release_temp(env)
self.operand2.release_temp(env)
if self.cascade:
self.cascade.release_subexpr_temps(env)
def check_const(self):
self.operand1.check_const()
self.operand2.check_const()
......@@ -4858,16 +4726,6 @@ class CascadedCmpNode(Node, CmpNode):
self.operand2 = self.operand2.coerce_to_simple(env)
self.cascade.coerce_cascaded_operands_to_temp(env)
def allocate_subexpr_temps(self, env):
self.operand2.allocate_temps(env)
if self.cascade:
self.cascade.allocate_subexpr_temps(env)
def release_subexpr_temps(self, env):
self.operand2.release_temp(env)
if self.cascade:
self.cascade.release_subexpr_temps(env)
def generate_evaluation_code(self, code, result, operand1):
if self.type.is_pyobject:
code.putln("if (__Pyx_PyObject_IsTrue(%s)) {" % result)
......@@ -5228,12 +5086,6 @@ class CloneNode(CoercionNode):
def generate_disposal_code(self, code):
pass
def allocate_temps(self, env):
pass
def release_temp(self, env):
pass
def free_temps(self, code):
pass
......
Cython/Compiler/Nodes.py
View file @ 44b2077c
......@@ -963,7 +963,6 @@ class FuncDefNode(StatNode, BlockNode):
if arg.is_generic:
arg.default.analyse_types(env)
arg.default = arg.default.coerce_to(arg.type, genv)
arg.default.allocate_temps(genv)
else:
error(arg.pos,
"This argument cannot have a default value")
......@@ -2539,9 +2538,6 @@ class PyClassDefNode(ClassDefNode):
cenv = self.scope
self.body.analyse_expressions(cenv)
self.target.analyse_target_expression(env, self.classobj)
self.dict.release_temp(env)
#self.classobj.release_temp(env)
#self.target.release_target_temp(env)
def generate_function_definitions(self, env, code):
self.body.generate_function_definitions(self.scope, code)
......@@ -2771,7 +2767,6 @@ class ExprStatNode(StatNode):
def analyse_expressions(self, env):
self.expr.analyse_expressions(env)
self.expr.release_temp(env)
def generate_execution_code(self, code):
self.expr.generate_evaluation_code(code)
......@@ -2795,8 +2790,6 @@ class AssignmentNode(StatNode):
def analyse_expressions(self, env):
self.analyse_types(env)
self.allocate_rhs_temps(env)
self.allocate_lhs_temps(env)
# def analyse_expressions(self, env):
# self.analyse_expressions_1(env)
......@@ -2894,14 +2887,6 @@ class SingleAssignmentNode(AssignmentNode):
if use_temp:
self.rhs = self.rhs.coerce_to_temp(env)
def allocate_rhs_temps(self, env):
self.rhs.allocate_temps(env)
def allocate_lhs_temps(self, env):
self.lhs.allocate_target_temps(env, self.rhs)
#self.lhs.release_target_temp(env)
#self.rhs.release_temp(env)
def generate_rhs_evaluation_code(self, code):
self.rhs.generate_evaluation_code(code)
......@@ -2947,17 +2932,6 @@ class CascadedAssignmentNode(AssignmentNode):
rhs = rhs.coerce_to(lhs.type, env)
self.coerced_rhs_list.append(rhs)
def allocate_rhs_temps(self, env):
self.rhs.allocate_temps(env)
def allocate_lhs_temps(self, env):
for lhs, rhs in zip(self.lhs_list, self.coerced_rhs_list):
rhs.allocate_temps(env)
lhs.allocate_target_temps(env, rhs)
#lhs.release_target_temp(env)
#rhs.release_temp(env)
self.rhs.release_temp(env)
def generate_rhs_evaluation_code(self, code):
self.rhs.generate_evaluation_code(code)
......@@ -3001,9 +2975,6 @@ class ParallelAssignmentNode(AssignmentNode):
def analyse_expressions(self, env):
for stat in self.stats:
stat.analyse_types(env, use_temp = 1)
stat.allocate_rhs_temps(env)
for stat in self.stats:
stat.allocate_lhs_temps(env)
# def analyse_expressions(self, env):
# for stat in self.stats:
......@@ -3053,8 +3024,6 @@ class InPlaceAssignmentNode(AssignmentNode):
self.lhs.analyse_target_types(env)
if Options.incref_local_binop and self.dup.type.is_pyobject:
self.dup = self.dup.coerce_to_temp(env)
def allocate_rhs_temps(self, env):
import ExprNodes
if self.lhs.type.is_pyobject:
self.rhs = self.rhs.coerce_to_pyobject(env)
......@@ -3063,23 +3032,7 @@ class InPlaceAssignmentNode(AssignmentNode):
if self.lhs.type.is_pyobject:
self.result_value_temp = ExprNodes.PyTempNode(self.pos, env)
self.result_value = self.result_value_temp.coerce_to(self.lhs.type, env)
self.result_value.allocate_temps(env)
# if use_temp:
# self.rhs = self.rhs.coerce_to_temp(env)
self.rhs.allocate_temps(env)
self.dup.allocate_subexpr_temps(env)
self.dup.allocate_temp(env)
def allocate_lhs_temps(self, env):
self.lhs.allocate_target_temps(env, self.rhs)
# self.lhs.release_target_temp(env)
self.dup.release_temp(env)
if self.dup.is_temp:
self.dup.release_subexpr_temps(env)
# self.rhs.release_temp(env)
if self.lhs.type.is_pyobject:
self.result_value.release_temp(env)
def generate_execution_code(self, code):
import ExprNodes
self.rhs.generate_evaluation_code(code)
......@@ -3201,7 +3154,6 @@ class PrintStatNode(StatNode):
def analyse_expressions(self, env):
self.arg_tuple.analyse_expressions(env)
self.arg_tuple = self.arg_tuple.coerce_to_pyobject(env)
self.arg_tuple.release_temp(env)
env.use_utility_code(printing_utility_code)
if len(self.arg_tuple.args) == 1 and self.append_newline:
env.use_utility_code(printing_one_utility_code)
......@@ -3245,7 +3197,6 @@ class ExecStatNode(StatNode):
for i, arg in enumerate(self.args):
arg.analyse_expressions(env)
arg = arg.coerce_to_pyobject(env)
arg.release_temp(env)
self.args[i] = arg
self.temp_result = env.allocate_temp_pyobject()
env.release_temp(self.temp_result)
......@@ -3376,8 +3327,6 @@ class ReturnStatNode(StatNode):
"Return with value in void function")
else:
self.value = self.value.coerce_to(env.return_type, env)
self.value.allocate_temps(env)
self.value.release_temp(env)
else:
if (not return_type.is_void
and not return_type.is_pyobject
......@@ -3444,21 +3393,12 @@ class RaiseStatNode(StatNode):
if self.exc_type:
self.exc_type.analyse_types(env)
self.exc_type = self.exc_type.coerce_to_pyobject(env)
self.exc_type.allocate_temps(env)
if self.exc_value:
self.exc_value.analyse_types(env)
self.exc_value = self.exc_value.coerce_to_pyobject(env)
self.exc_value.allocate_temps(env)
if self.exc_tb:
self.exc_tb.analyse_types(env)
self.exc_tb = self.exc_tb.coerce_to_pyobject(env)
self.exc_tb.allocate_temps(env)
if self.exc_type:
self.exc_type.release_temp(env)
if self.exc_value:
self.exc_value.release_temp(env)
if self.exc_tb:
self.exc_tb.release_temp(env)
env.use_utility_code(raise_utility_code)
env.use_utility_code(restore_exception_utility_code)
......@@ -3539,11 +3479,6 @@ class AssertStatNode(StatNode):
if self.value:
self.value.analyse_types(env)
self.value = self.value.coerce_to_pyobject(env)
self.value.allocate_temps(env)
self.cond.release_temp(env)
if self.value:
self.value.release_temp(env)
#env.recycle_pending_temps() # TEMPORARY
gil_check = StatNode._gil_check
gil_message = "Raising exception"
......@@ -3643,7 +3578,6 @@ class IfClauseNode(Node):
def analyse_expressions(self, env):
self.condition = \
self.condition.analyse_temp_boolean_expression(env)
self.condition.release_temp(env)
self.body.analyse_expressions(env)
def generate_execution_code(self, code, end_label):
......@@ -3740,8 +3674,6 @@ class WhileStatNode(LoopNode, StatNode):
def analyse_expressions(self, env):
self.condition = \
self.condition.analyse_temp_boolean_expression(env)
self.condition.release_temp(env)
#env.recycle_pending_temps() # TEMPORARY
self.body.analyse_expressions(env)
if self.else_clause:
self.else_clause.analyse_expressions(env)
......@@ -3804,14 +3736,9 @@ class ForInStatNode(LoopNode, StatNode):
self.iterator.analyse_expressions(env)
self.item = ExprNodes.NextNode(self.iterator, env)
self.item = self.item.coerce_to(self.target.type, env)
self.item.allocate_temps(env)
self.target.allocate_target_temps(env, self.item)
#self.item.release_temp(env)
#self.target.release_target_temp(env)
self.body.analyse_expressions(env)
if self.else_clause:
self.else_clause.analyse_expressions(env)
self.iterator.release_temp(env)
def generate_execution_code(self, code):
old_loop_labels = code.new_loop_labels()
......@@ -3919,28 +3846,12 @@ class ForFromStatNode(LoopNode, StatNode):
else:
self.is_py_target = True
c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)
c_loopvar_node.allocate_temps(env)
self.loopvar_node = c_loopvar_node
self.py_loopvar_node = \
ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)
self.bound1.allocate_temps(env)
self.bound2.allocate_temps(env)
if self.step is not None:
self.step.allocate_temps(env)
if self.is_py_target:
self.py_loopvar_node.allocate_temps(env)
self.target.allocate_target_temps(env, self.py_loopvar_node)
#self.target.release_target_temp(env)
#self.py_loopvar_node.release_temp(env)
self.body.analyse_expressions(env)
if self.is_py_target:
c_loopvar_node.release_temp(env)
if self.else_clause:
self.else_clause.analyse_expressions(env)
self.bound1.release_temp(env)
self.bound2.release_temp(env)
if self.step is not None:
self.step.release_temp(env)
def generate_execution_code(self, code):
old_loop_labels = code.new_loop_labels()
......@@ -4006,8 +3917,6 @@ class ForFromStatNode(LoopNode, StatNode):
if self.step is not None:
self.step.generate_disposal_code(code)
self.step.free_temps(code)
if from_range:
code.funcstate.release_temp(loopvar_name)
relation_table = {
# {relop : (initial offset, increment op)}
......@@ -4232,7 +4141,6 @@ class ExceptClauseNode(Node):
self.pattern.analyse_expressions(env)
self.pattern = self.pattern.coerce_to_pyobject(env)
self.match_flag = env.allocate_temp(PyrexTypes.c_int_type)
self.pattern.release_temp(env)
env.release_temp(self.match_flag)
if self.target or self.excinfo_target:
......@@ -4242,7 +4150,6 @@ class ExceptClauseNode(Node):
if self.target:
self.exc_value = ExprNodes.ExcValueNode(self.pos, env, self.exc_vars[1])
self.exc_value.allocate_temps(env)
self.target.analyse_target_expression(env, self.exc_value)
if self.excinfo_target is not None:
import ExprNodes
......@@ -4252,7 +4159,6 @@ class ExceptClauseNode(Node):
ExprNodes.ExcValueNode(pos=self.pos, env=env, var=self.exc_vars[2])
])
self.excinfo_tuple.analyse_expressions(env)
self.excinfo_tuple.allocate_temps(env)
self.excinfo_target.analyse_target_expression(env, self.excinfo_tuple)
self.body.analyse_expressions(env)
......@@ -4720,7 +4626,6 @@ class FromImportStatNode(StatNode):
import ExprNodes
self.module.analyse_expressions(env)
self.item = ExprNodes.PyTempNode(self.pos, env)
self.item.allocate_temp(env)
self.interned_items = []
for name, target in self.items:
if name == '*':
......@@ -4739,9 +4644,6 @@ class FromImportStatNode(StatNode):
coerced_item = self.item.coerce_to(target.type, env)
self.interned_items.append(
(name, target, coerced_item))
#target.release_target_temp(env) # was release_temp ?!?
self.module.release_temp(env)
self.item.release_temp(env)
def generate_execution_code(self, code):
self.module.generate_evaluation_code(code)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7