def reorder(
expression_list: List[Expression]
) -> Tuple[Statement, List[Expression]]:
if not expression_list:
return noop_statement(), []
if isinstance(expression_list[0], Call):
temporary = TempManager.new_temp()
expression_list[0] = EvaluateSequence(
Move(Temporary(temporary), expression_list[0]),
Temporary(temporary))
return reorder(expression_list)
head_statement, head_expression = do_expression(expression_list[0])
tail_statement, tail_expressions = reorder(expression_list[1:])
if commute(tail_statement, head_expression):
return (
simplified_sequence(head_statement, tail_statement),
[head_expression] + tail_expressions,
)
temporary = TempManager.new_temp()
return (
simplified_sequence(
simplified_sequence(head_statement,
Move(Temporary(temporary), head_expression)),
tail_statement,
),
[Temporary(temporary)] + tail_expressions,
)
def for_expression(
variable: TranslatedExpression,
lo: TranslatedExpression,
hi: TranslatedExpression,
body: TranslatedExpression,
break_label: TempLabel,
) -> TranslatedExpression:
test_label = TempManager.new_label()
body_label = TempManager.new_label()
limit = TempManager.new_temp()
variable_expression = convert_to_expression(variable)
sequence = Sequence([
Move(variable_expression, convert_to_expression(lo)),
Move(Temporary(limit), convert_to_expression(hi)),
Label(test_label),
ConditionalJump(
RelationalOperator.le,
variable_expression,
Temporary(limit),
body_label,
break_label,
),
Label(body_label),
convert_to_statement(body),
Move(
variable_expression,
BinaryOperation(BinaryOperator.plus, variable_expression,
Constant(1)),
),
Jump(Name(test_label), [test_label]),
Label(break_label),
])
return NoResult(sequence)
def if_expression(
test: TranslatedExpression,
then: TranslatedExpression,
else_do: Optional[TranslatedExpression],
) -> TranslatedExpression:
test_condition = convert_to_condition(test)
then_expression = convert_to_expression(then)
else_expression = (convert_to_expression(else_do)
if else_do is not None else Constant(0))
true_label = TempManager.new_label()
false_label = TempManager.new_label()
join_label = TempManager.new_label()
result = TempManager.new_temp()
patch_true_labels(test_condition.trues, true_label)
patch_false_labels(test_condition.trues, false_label)
sequence = Sequence([
test_condition.statement,
Label(true_label),
Move(Temporary(result), then_expression),
Jump(Name(join_label), [join_label]),
Label(false_label),
Move(Temporary(result), else_expression),
Label(join_label),
])
return Expression(EvaluateSequence(sequence, Temporary(result)))
def record_expression(
field_list: List[TranslatedExpression]) -> TranslatedExpression:
result = TempManager.new_temp()
creation_sequence = [
Move(
Temporary(result),
frame.external_call("init_record",
[Constant(len(field_list) * frame.word_size)]),
)
]
for index, field_expression in enumerate(field_list):
field_allocation = Move(
Memory(
BinaryOperation(
BinaryOperator.plus,
Temporary(result),
Constant(index * frame.word_size),
)),
convert_to_expression(field_expression),
)
creation_sequence.append(field_allocation)
return Expression(
EvaluateSequence(Sequence(creation_sequence), Temporary(result)))
def convert_to_expression(exp: TranslatedExpression) -> tree.Expression:
if isinstance(exp, Expression):
return exp.expression
if isinstance(exp, NoResult):
return EvaluateSequence(exp.statement, Constant(0))
if isinstance(exp, Conditional):
temporary_value = TempManager.new_temp()
true = TempManager.new_label()
false = TempManager.new_label()
patch_true_labels(exp.condition.trues, true)
patch_false_labels(exp.condition.falses, false)
return EvaluateSequence(
Move(Temporary(temporary_value), Constant(1)),
EvaluateSequence(
exp.condition.statement,
EvaluateSequence(
Label(false),
EvaluateSequence(
Move(Temporary(temporary_value), Constant(0)),
EvaluateSequence(Label(true),
Temporary(temporary_value)),
),
),
),
)
def _alloc_single_var(self, escape: bool,
access_list: List[Access]) -> Access:
if escape:
self.offset -= word_size
access_list.append(InFrame(self.offset))
else:
access_list.append(InRegister(TempManager.new_temp()))
return access_list[-1]
def _rewrite_program(self, instructions: List[Instruction]) -> List[Instruction]:
for node in self.spilled_nodes:
memory_access = self.frame.alloc_local(True)
for use_instruction in self.temp_uses[node]:
new_temporary = TempManager.new_temp()
use_instruction.source = [
source_temp if source_temp != node else new_temporary
for source_temp in use_instruction.source
]
fetch_instruction = Operation(
f"movq {memory_access.offset}(%'s0), %'d0\n",
[frame_pointer()],
[new_temporary],
None,
)
instructions.insert(
instructions.index(use_instruction), fetch_instruction
)
for definition_instruction in self.temp_definitions[node]:
new_temporary = TempManager.new_temp()
definition_instruction.destination = [
destination_temp if destination_temp != node else new_temporary
for destination_temp in definition_instruction.destination
]
store_instruction = Operation(
f"movq %'s0, {memory_access.offset}(%'s1)\n",
[new_temporary, frame_pointer()],
[],
None,
)
instructions.insert(
instructions.index(definition_instruction) + 1, store_instruction
)
return instructions
def preserve_callee_registers(frame: Frame,
function_body: IRT.Statement) -> IRT.Statement:
save_registers = []
restore_registers = []
for callee_register in callee_saved_registers:
temp = TempManager.new_temp()
save_registers.append(
IRT.Move(
IRT.Temporary(temp),
IRT.Temporary(TempMap.register_to_temp[callee_register]),
))
restore_registers.append(
IRT.Move(
IRT.Temporary(TempMap.register_to_temp[callee_register]),
IRT.Temporary(temp),
))
return IRT.Sequence(save_registers + [function_body] + restore_registers)
def initialize(cls):
for register in all_registers:
temp = TempManager.new_temp()
cls.register_to_temp[register] = temp
cls.temp_to_register[temp] = register
