def insert_ref_count_opcodes(ir: FuncIR) -> None:
"""Insert reference count inc/dec opcodes to a function.
This is the entry point to this module.
"""
cfg = get_cfg(ir.blocks)
values = all_values(ir.arg_regs, ir.blocks)
borrowed = {value for value in values if value.is_borrowed}
args = set(ir.arg_regs) # type: Set[Value]
live = analyze_live_regs(ir.blocks, cfg)
borrow = analyze_borrowed_arguments(ir.blocks, cfg, borrowed)
defined = analyze_must_defined_regs(ir.blocks, cfg, args, values)
ordering = make_value_ordering(ir)
cache = {} # type: BlockCache
for block in ir.blocks[:]:
if isinstance(block.ops[-1], (Branch, Goto)):
insert_branch_inc_and_decrefs(block,
cache,
ir.blocks,
live.before,
borrow.before,
borrow.after,
defined.after,
ordering)
transform_block(block, live.before, live.after, borrow.before, defined.after)
cleanup_cfg(ir.blocks)
def run_case(self, testcase: DataDrivenTestCase) -> None:
"""Perform a data-flow analysis test case."""
with use_custom_builtins(
os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
testcase.output = replace_native_int(testcase.output)
try:
ir = build_ir_for_single_file(testcase.input)
except CompileError as e:
actual = e.messages
else:
actual = []
for fn in ir:
if (fn.name == TOP_LEVEL_NAME
and not testcase.name.endswith('_toplevel')):
continue
exceptions.insert_exception_handling(fn)
actual.extend(format_func(fn))
cfg = dataflow.get_cfg(fn.blocks)
args = set(fn.arg_regs) # type: Set[Value]
name = testcase.name
if name.endswith('_MaybeDefined'):
# Forward, maybe
analysis_result = dataflow.analyze_maybe_defined_regs(
fn.blocks, cfg, args)
elif name.endswith('_Liveness'):
# Backward, maybe
analysis_result = dataflow.analyze_live_regs(
fn.blocks, cfg)
elif name.endswith('_MustDefined'):
# Forward, must
analysis_result = dataflow.analyze_must_defined_regs(
fn.blocks,
cfg,
args,
regs=all_values(fn.arg_regs, fn.blocks))
elif name.endswith('_BorrowedArgument'):
# Forward, must
analysis_result = dataflow.analyze_borrowed_arguments(
fn.blocks, cfg, args)
else:
assert False, 'No recognized _AnalysisName suffix in test case'
names = generate_names_for_ir(fn.arg_regs, fn.blocks)
for key in sorted(analysis_result.before.keys(),
key=lambda x: (x[0].label, x[1])):
pre = ', '.join(
sorted(names[reg]
for reg in analysis_result.before[key]))
post = ', '.join(
sorted(names[reg]
for reg in analysis_result.after[key]))
actual.append('%-8s %-23s %s' %
((key[0].label, key[1]), '{%s}' % pre,
'{%s}' % post))
assert_test_output(testcase, actual, 'Invalid source code output')
def insert_uninit_checks(ir: FuncIR) -> None:
# Remove dead blocks from the CFG, which helps avoid spurious
# checks due to unused error handling blocks.
cleanup_cfg(ir.blocks)
cfg = get_cfg(ir.blocks)
must_defined = analyze_must_defined_regs(
ir.blocks, cfg, set(ir.arg_regs), all_values(ir.arg_regs, ir.blocks))
ir.blocks = split_blocks_at_uninits(ir.blocks, must_defined.before)
def generate_native_function(fn: FuncIR, emitter: Emitter, source_path: str,
module_name: str) -> None:
declarations = Emitter(emitter.context)
names = generate_names_for_ir(fn.arg_regs, fn.blocks)
body = Emitter(emitter.context, names)
visitor = FunctionEmitterVisitor(body, declarations, source_path,
module_name)
declarations.emit_line(f'{native_function_header(fn.decl, emitter)} {{')
body.indent()
for r in all_values(fn.arg_regs, fn.blocks):
if isinstance(r.type, RTuple):
emitter.declare_tuple_struct(r.type)
if isinstance(r.type, RArray):
continue # Special: declared on first assignment
if r in fn.arg_regs:
continue # Skip the arguments
ctype = emitter.ctype_spaced(r.type)
init = ''
declarations.emit_line('{ctype}{prefix}{name}{init};'.format(
ctype=ctype, prefix=REG_PREFIX, name=names[r], init=init))
# Before we emit the blocks, give them all labels
blocks = fn.blocks
for i, block in enumerate(blocks):
block.label = i
common = frequently_executed_blocks(fn.blocks[0])
for i in range(len(blocks)):
block = blocks[i]
visitor.rare = block not in common
next_block = None
if i + 1 < len(blocks):
next_block = blocks[i + 1]
body.emit_label(block)
visitor.next_block = next_block
ops = block.ops
visitor.ops = ops
visitor.op_index = 0
while visitor.op_index < len(ops):
ops[visitor.op_index].accept(visitor)
visitor.op_index += 1
body.emit_line('}')
emitter.emit_from_emitter(declarations)
emitter.emit_from_emitter(body)
def analyze_undefined_regs(
blocks: List[BasicBlock], cfg: CFG,
initial_defined: Set[Value]) -> AnalysisResult[Value]:
"""Calculate potentially undefined registers at each CFG location.
A register is undefined if there is some path from initial block
where it has an undefined value.
Function arguments are assumed to be always defined.
"""
initial_undefined = set(all_values([], blocks)) - initial_defined
return run_analysis(blocks=blocks,
cfg=cfg,
gen_and_kill=UndefinedVisitor(),
initial=initial_undefined,
backward=False,
kind=MAYBE_ANALYSIS)
def generate_native_function(fn: FuncIR,
emitter: Emitter,
source_path: str,
module_name: str,
optimize_int: bool = True) -> None:
if optimize_int:
const_int_regs = find_constant_integer_registers(fn.blocks)
else:
const_int_regs = {}
declarations = Emitter(emitter.context)
names = generate_names_for_ir(fn.arg_regs, fn.blocks)
body = Emitter(emitter.context, names)
visitor = FunctionEmitterVisitor(body, declarations, source_path,
module_name, const_int_regs)
declarations.emit_line('{} {{'.format(
native_function_header(fn.decl, emitter)))
body.indent()
for r in all_values(fn.arg_regs, fn.blocks):
if isinstance(r.type, RTuple):
emitter.declare_tuple_struct(r.type)
if r in fn.arg_regs:
continue # Skip the arguments
ctype = emitter.ctype_spaced(r.type)
init = ''
if r not in const_int_regs:
declarations.emit_line('{ctype}{prefix}{name}{init};'.format(
ctype=ctype, prefix=REG_PREFIX, name=names[r], init=init))
# Before we emit the blocks, give them all labels
for i, block in enumerate(fn.blocks):
block.label = i
for block in fn.blocks:
body.emit_label(block)
for op in block.ops:
op.accept(visitor)
body.emit_line('}')
emitter.emit_from_emitter(declarations)
emitter.emit_from_emitter(body)
