80c147d9c0
Rework br_table to use BlockCall, allowing us to avoid adding new nodes during ssa construction to hold block arguments. Additionally, many places where we previously matched on InstructionData to extract branch destinations can be replaced with a use of branch_destination or branch_destination_mut.
618 lines
20 KiB
Rust
618 lines
20 KiB
Rust
//! Converting Cranelift IR to text.
|
|
//!
|
|
//! The `write` module provides the `write_function` function which converts an IR `Function` to an
|
|
//! equivalent textual form. This textual form can be read back by the `cranelift-reader` crate.
|
|
|
|
use crate::entity::SecondaryMap;
|
|
use crate::ir::entities::AnyEntity;
|
|
use crate::ir::{Block, DataFlowGraph, Function, Inst, SigRef, Type, Value, ValueDef};
|
|
use crate::packed_option::ReservedValue;
|
|
use alloc::string::{String, ToString};
|
|
use alloc::vec::Vec;
|
|
use core::fmt::{self, Write};
|
|
|
|
/// A `FuncWriter` used to decorate functions during printing.
|
|
pub trait FuncWriter {
|
|
/// Write the basic block header for the current function.
|
|
fn write_block_header(
|
|
&mut self,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
block: Block,
|
|
indent: usize,
|
|
) -> fmt::Result;
|
|
|
|
/// Write the given `inst` to `w`.
|
|
fn write_instruction(
|
|
&mut self,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
aliases: &SecondaryMap<Value, Vec<Value>>,
|
|
inst: Inst,
|
|
indent: usize,
|
|
) -> fmt::Result;
|
|
|
|
/// Write the preamble to `w`. By default, this uses `write_entity_definition`.
|
|
fn write_preamble(&mut self, w: &mut dyn Write, func: &Function) -> Result<bool, fmt::Error> {
|
|
self.super_preamble(w, func)
|
|
}
|
|
|
|
/// Default impl of `write_preamble`
|
|
fn super_preamble(&mut self, w: &mut dyn Write, func: &Function) -> Result<bool, fmt::Error> {
|
|
let mut any = false;
|
|
|
|
for (ss, slot) in func.dynamic_stack_slots.iter() {
|
|
any = true;
|
|
self.write_entity_definition(w, func, ss.into(), slot)?;
|
|
}
|
|
|
|
for (ss, slot) in func.sized_stack_slots.iter() {
|
|
any = true;
|
|
self.write_entity_definition(w, func, ss.into(), slot)?;
|
|
}
|
|
|
|
for (gv, gv_data) in &func.global_values {
|
|
any = true;
|
|
self.write_entity_definition(w, func, gv.into(), gv_data)?;
|
|
}
|
|
|
|
for (table, table_data) in &func.tables {
|
|
if !table_data.index_type.is_invalid() {
|
|
any = true;
|
|
self.write_entity_definition(w, func, table.into(), table_data)?;
|
|
}
|
|
}
|
|
|
|
// Write out all signatures before functions since function declarations can refer to
|
|
// signatures.
|
|
for (sig, sig_data) in &func.dfg.signatures {
|
|
any = true;
|
|
self.write_entity_definition(w, func, sig.into(), &sig_data)?;
|
|
}
|
|
|
|
for (fnref, ext_func) in &func.dfg.ext_funcs {
|
|
if ext_func.signature != SigRef::reserved_value() {
|
|
any = true;
|
|
self.write_entity_definition(
|
|
w,
|
|
func,
|
|
fnref.into(),
|
|
&ext_func.display(Some(&func.params)),
|
|
)?;
|
|
}
|
|
}
|
|
|
|
for (&cref, cval) in func.dfg.constants.iter() {
|
|
any = true;
|
|
self.write_entity_definition(w, func, cref.into(), cval)?;
|
|
}
|
|
|
|
if let Some(limit) = func.stack_limit {
|
|
any = true;
|
|
self.write_entity_definition(w, func, AnyEntity::StackLimit, &limit)?;
|
|
}
|
|
|
|
Ok(any)
|
|
}
|
|
|
|
/// Write an entity definition defined in the preamble to `w`.
|
|
fn write_entity_definition(
|
|
&mut self,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
entity: AnyEntity,
|
|
value: &dyn fmt::Display,
|
|
) -> fmt::Result {
|
|
self.super_entity_definition(w, func, entity, value)
|
|
}
|
|
|
|
/// Default impl of `write_entity_definition`
|
|
#[allow(unused_variables)]
|
|
fn super_entity_definition(
|
|
&mut self,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
entity: AnyEntity,
|
|
value: &dyn fmt::Display,
|
|
) -> fmt::Result {
|
|
writeln!(w, " {} = {}", entity, value)
|
|
}
|
|
}
|
|
|
|
/// A `PlainWriter` that doesn't decorate the function.
|
|
pub struct PlainWriter;
|
|
|
|
impl FuncWriter for PlainWriter {
|
|
fn write_instruction(
|
|
&mut self,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
aliases: &SecondaryMap<Value, Vec<Value>>,
|
|
inst: Inst,
|
|
indent: usize,
|
|
) -> fmt::Result {
|
|
write_instruction(w, func, aliases, inst, indent)
|
|
}
|
|
|
|
fn write_block_header(
|
|
&mut self,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
block: Block,
|
|
indent: usize,
|
|
) -> fmt::Result {
|
|
write_block_header(w, func, block, indent)
|
|
}
|
|
}
|
|
|
|
/// Write `func` to `w` as equivalent text.
|
|
/// Use `isa` to emit ISA-dependent annotations.
|
|
pub fn write_function(w: &mut dyn Write, func: &Function) -> fmt::Result {
|
|
decorate_function(&mut PlainWriter, w, func)
|
|
}
|
|
|
|
/// Create a reverse-alias map from a value to all aliases having that value as a direct target
|
|
fn alias_map(func: &Function) -> SecondaryMap<Value, Vec<Value>> {
|
|
let mut aliases = SecondaryMap::<_, Vec<_>>::new();
|
|
for v in func.dfg.values() {
|
|
// VADFS returns the immediate target of an alias
|
|
if let Some(k) = func.dfg.value_alias_dest_for_serialization(v) {
|
|
aliases[k].push(v);
|
|
}
|
|
}
|
|
aliases
|
|
}
|
|
|
|
/// Writes `func` to `w` as text.
|
|
/// write_function_plain is passed as 'closure' to print instructions as text.
|
|
/// pretty_function_error is passed as 'closure' to add error decoration.
|
|
pub fn decorate_function<FW: FuncWriter>(
|
|
func_w: &mut FW,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
) -> fmt::Result {
|
|
write!(w, "function ")?;
|
|
write_spec(w, func)?;
|
|
writeln!(w, " {{")?;
|
|
let aliases = alias_map(func);
|
|
let mut any = func_w.write_preamble(w, func)?;
|
|
for block in &func.layout {
|
|
if any {
|
|
writeln!(w)?;
|
|
}
|
|
decorate_block(func_w, w, func, &aliases, block)?;
|
|
any = true;
|
|
}
|
|
writeln!(w, "}}")
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// Function spec.
|
|
|
|
fn write_spec(w: &mut dyn Write, func: &Function) -> fmt::Result {
|
|
write!(w, "{}{}", func.name, func.signature)
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// Basic blocks
|
|
|
|
fn write_arg(w: &mut dyn Write, func: &Function, arg: Value) -> fmt::Result {
|
|
write!(w, "{}: {}", arg, func.dfg.value_type(arg))
|
|
}
|
|
|
|
/// Write out the basic block header, outdented:
|
|
///
|
|
/// block1:
|
|
/// block1(v1: i32):
|
|
/// block10(v4: f64, v5: b1):
|
|
///
|
|
pub fn write_block_header(
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
block: Block,
|
|
indent: usize,
|
|
) -> fmt::Result {
|
|
let cold = if func.layout.is_cold(block) {
|
|
" cold"
|
|
} else {
|
|
""
|
|
};
|
|
|
|
// The `indent` is the instruction indentation. block headers are 4 spaces out from that.
|
|
write!(w, "{1:0$}{2}", indent - 4, "", block)?;
|
|
|
|
let mut args = func.dfg.block_params(block).iter().cloned();
|
|
match args.next() {
|
|
None => return writeln!(w, "{}:", cold),
|
|
Some(arg) => {
|
|
write!(w, "(")?;
|
|
write_arg(w, func, arg)?;
|
|
}
|
|
}
|
|
// Remaining arguments.
|
|
for arg in args {
|
|
write!(w, ", ")?;
|
|
write_arg(w, func, arg)?;
|
|
}
|
|
writeln!(w, "){}:", cold)
|
|
}
|
|
|
|
fn decorate_block<FW: FuncWriter>(
|
|
func_w: &mut FW,
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
aliases: &SecondaryMap<Value, Vec<Value>>,
|
|
block: Block,
|
|
) -> fmt::Result {
|
|
// Indent all instructions if any srclocs are present.
|
|
let indent = if func.rel_srclocs().is_empty() { 4 } else { 36 };
|
|
|
|
func_w.write_block_header(w, func, block, indent)?;
|
|
for a in func.dfg.block_params(block).iter().cloned() {
|
|
write_value_aliases(w, aliases, a, indent)?;
|
|
}
|
|
|
|
for inst in func.layout.block_insts(block) {
|
|
func_w.write_instruction(w, func, aliases, inst, indent)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// Instructions
|
|
|
|
// Should `inst` be printed with a type suffix?
|
|
//
|
|
// Polymorphic instructions may need a suffix indicating the value of the controlling type variable
|
|
// if it can't be trivially inferred.
|
|
//
|
|
fn type_suffix(func: &Function, inst: Inst) -> Option<Type> {
|
|
let inst_data = &func.dfg.insts[inst];
|
|
let constraints = inst_data.opcode().constraints();
|
|
|
|
if !constraints.is_polymorphic() {
|
|
return None;
|
|
}
|
|
|
|
// If the controlling type variable can be inferred from the type of the designated value input
|
|
// operand, we don't need the type suffix.
|
|
if constraints.use_typevar_operand() {
|
|
let ctrl_var = inst_data.typevar_operand(&func.dfg.value_lists).unwrap();
|
|
let def_block = match func.dfg.value_def(ctrl_var) {
|
|
ValueDef::Result(instr, _) => func.layout.inst_block(instr),
|
|
ValueDef::Param(block, _) => Some(block),
|
|
ValueDef::Union(..) => None,
|
|
};
|
|
if def_block.is_some() && def_block == func.layout.inst_block(inst) {
|
|
return None;
|
|
}
|
|
}
|
|
|
|
let rtype = func.dfg.ctrl_typevar(inst);
|
|
assert!(
|
|
!rtype.is_invalid(),
|
|
"Polymorphic instruction must produce a result"
|
|
);
|
|
Some(rtype)
|
|
}
|
|
|
|
/// Write out any aliases to the given target, including indirect aliases
|
|
fn write_value_aliases(
|
|
w: &mut dyn Write,
|
|
aliases: &SecondaryMap<Value, Vec<Value>>,
|
|
target: Value,
|
|
indent: usize,
|
|
) -> fmt::Result {
|
|
let mut todo_stack = vec![target];
|
|
while let Some(target) = todo_stack.pop() {
|
|
for &a in &aliases[target] {
|
|
writeln!(w, "{1:0$}{2} -> {3}", indent, "", a, target)?;
|
|
todo_stack.push(a);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn write_instruction(
|
|
w: &mut dyn Write,
|
|
func: &Function,
|
|
aliases: &SecondaryMap<Value, Vec<Value>>,
|
|
inst: Inst,
|
|
indent: usize,
|
|
) -> fmt::Result {
|
|
// Prefix containing source location, encoding, and value locations.
|
|
let mut s = String::with_capacity(16);
|
|
|
|
// Source location goes first.
|
|
let srcloc = func.srcloc(inst);
|
|
if !srcloc.is_default() {
|
|
write!(s, "{} ", srcloc)?;
|
|
}
|
|
|
|
// Write out prefix and indent the instruction.
|
|
write!(w, "{1:0$}", indent, s)?;
|
|
|
|
// Write out the result values, if any.
|
|
let mut has_results = false;
|
|
for r in func.dfg.inst_results(inst) {
|
|
if !has_results {
|
|
has_results = true;
|
|
write!(w, "{}", r)?;
|
|
} else {
|
|
write!(w, ", {}", r)?;
|
|
}
|
|
}
|
|
if has_results {
|
|
write!(w, " = ")?;
|
|
}
|
|
|
|
// Then the opcode, possibly with a '.type' suffix.
|
|
let opcode = func.dfg.insts[inst].opcode();
|
|
|
|
match type_suffix(func, inst) {
|
|
Some(suf) => write!(w, "{}.{}", opcode, suf)?,
|
|
None => write!(w, "{}", opcode)?,
|
|
}
|
|
|
|
write_operands(w, &func.dfg, inst)?;
|
|
writeln!(w)?;
|
|
|
|
// Value aliases come out on lines after the instruction defining the referent.
|
|
for r in func.dfg.inst_results(inst) {
|
|
write_value_aliases(w, aliases, *r, indent)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Write the operands of `inst` to `w` with a prepended space.
|
|
pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt::Result {
|
|
let pool = &dfg.value_lists;
|
|
let jump_tables = &dfg.jump_tables;
|
|
use crate::ir::instructions::InstructionData::*;
|
|
match dfg.insts[inst] {
|
|
AtomicRmw { op, args, .. } => write!(w, " {} {}, {}", op, args[0], args[1]),
|
|
AtomicCas { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
|
|
LoadNoOffset { flags, arg, .. } => write!(w, "{} {}", flags, arg),
|
|
StoreNoOffset { flags, args, .. } => write!(w, "{} {}, {}", flags, args[0], args[1]),
|
|
Unary { arg, .. } => write!(w, " {}", arg),
|
|
UnaryImm { imm, .. } => write!(w, " {}", imm),
|
|
UnaryIeee32 { imm, .. } => write!(w, " {}", imm),
|
|
UnaryIeee64 { imm, .. } => write!(w, " {}", imm),
|
|
UnaryGlobalValue { global_value, .. } => write!(w, " {}", global_value),
|
|
UnaryConst {
|
|
constant_handle, ..
|
|
} => write!(w, " {}", constant_handle),
|
|
Binary { args, .. } => write!(w, " {}, {}", args[0], args[1]),
|
|
BinaryImm8 { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
|
|
BinaryImm64 { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
|
|
Ternary { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
|
|
MultiAry { ref args, .. } => {
|
|
if args.is_empty() {
|
|
write!(w, "")
|
|
} else {
|
|
write!(w, " {}", DisplayValues(args.as_slice(pool)))
|
|
}
|
|
}
|
|
NullAry { .. } => write!(w, " "),
|
|
TernaryImm8 { imm, args, .. } => write!(w, " {}, {}, {}", args[0], args[1], imm),
|
|
Shuffle { imm, args, .. } => {
|
|
let data = dfg.immediates.get(imm).expect(
|
|
"Expected the shuffle mask to already be inserted into the immediates table",
|
|
);
|
|
write!(w, " {}, {}, {}", args[0], args[1], data)
|
|
}
|
|
IntCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
|
|
IntCompareImm { cond, arg, imm, .. } => write!(w, " {} {}, {}", cond, arg, imm),
|
|
IntAddTrap { args, code, .. } => write!(w, " {}, {}, {}", args[0], args[1], code),
|
|
FloatCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
|
|
Jump { destination, .. } => {
|
|
write!(w, " {}", destination.display(pool))
|
|
}
|
|
Brif {
|
|
arg,
|
|
blocks: [block_then, block_else],
|
|
..
|
|
} => {
|
|
write!(w, " {}, {}", arg, block_then.display(pool))?;
|
|
write!(w, ", {}", block_else.display(pool))
|
|
}
|
|
BranchTable { arg, table, .. } => {
|
|
write!(w, " {}, {}", arg, jump_tables[table].display(pool))
|
|
}
|
|
Call {
|
|
func_ref, ref args, ..
|
|
} => write!(w, " {}({})", func_ref, DisplayValues(args.as_slice(pool))),
|
|
CallIndirect {
|
|
sig_ref, ref args, ..
|
|
} => {
|
|
let args = args.as_slice(pool);
|
|
write!(
|
|
w,
|
|
" {}, {}({})",
|
|
sig_ref,
|
|
args[0],
|
|
DisplayValues(&args[1..])
|
|
)
|
|
}
|
|
FuncAddr { func_ref, .. } => write!(w, " {}", func_ref),
|
|
StackLoad {
|
|
stack_slot, offset, ..
|
|
} => write!(w, " {}{}", stack_slot, offset),
|
|
StackStore {
|
|
arg,
|
|
stack_slot,
|
|
offset,
|
|
..
|
|
} => write!(w, " {}, {}{}", arg, stack_slot, offset),
|
|
DynamicStackLoad {
|
|
dynamic_stack_slot, ..
|
|
} => write!(w, " {}", dynamic_stack_slot),
|
|
DynamicStackStore {
|
|
arg,
|
|
dynamic_stack_slot,
|
|
..
|
|
} => write!(w, " {}, {}", arg, dynamic_stack_slot),
|
|
TableAddr { table, arg, .. } => write!(w, " {}, {}", table, arg),
|
|
Load {
|
|
flags, arg, offset, ..
|
|
} => write!(w, "{} {}{}", flags, arg, offset),
|
|
Store {
|
|
flags,
|
|
args,
|
|
offset,
|
|
..
|
|
} => write!(w, "{} {}, {}{}", flags, args[0], args[1], offset),
|
|
Trap { code, .. } => write!(w, " {}", code),
|
|
CondTrap { arg, code, .. } => write!(w, " {}, {}", arg, code),
|
|
}?;
|
|
|
|
let mut sep = " ; ";
|
|
for arg in dfg.inst_values(inst) {
|
|
if let ValueDef::Result(src, _) = dfg.value_def(arg) {
|
|
let imm = match dfg.insts[src] {
|
|
UnaryImm { imm, .. } => imm.to_string(),
|
|
UnaryIeee32 { imm, .. } => imm.to_string(),
|
|
UnaryIeee64 { imm, .. } => imm.to_string(),
|
|
UnaryConst {
|
|
constant_handle, ..
|
|
} => constant_handle.to_string(),
|
|
_ => continue,
|
|
};
|
|
write!(w, "{}{} = {}", sep, arg, imm)?;
|
|
sep = ", ";
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Displayable slice of values.
|
|
struct DisplayValues<'a>(&'a [Value]);
|
|
|
|
impl<'a> fmt::Display for DisplayValues<'a> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
for (i, val) in self.0.iter().enumerate() {
|
|
if i == 0 {
|
|
write!(f, "{}", val)?;
|
|
} else {
|
|
write!(f, ", {}", val)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::cursor::{Cursor, CursorPosition, FuncCursor};
|
|
use crate::ir::types;
|
|
use crate::ir::{Function, InstBuilder, StackSlotData, StackSlotKind, UserFuncName};
|
|
use alloc::string::ToString;
|
|
|
|
#[test]
|
|
fn basic() {
|
|
let mut f = Function::new();
|
|
assert_eq!(f.to_string(), "function u0:0() fast {\n}\n");
|
|
|
|
f.name = UserFuncName::testcase("foo");
|
|
assert_eq!(f.to_string(), "function %foo() fast {\n}\n");
|
|
|
|
f.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4));
|
|
assert_eq!(
|
|
f.to_string(),
|
|
"function %foo() fast {\n ss0 = explicit_slot 4\n}\n"
|
|
);
|
|
|
|
let block = f.dfg.make_block();
|
|
f.layout.append_block(block);
|
|
assert_eq!(
|
|
f.to_string(),
|
|
"function %foo() fast {\n ss0 = explicit_slot 4\n\nblock0:\n}\n"
|
|
);
|
|
|
|
f.dfg.append_block_param(block, types::I8);
|
|
assert_eq!(
|
|
f.to_string(),
|
|
"function %foo() fast {\n ss0 = explicit_slot 4\n\nblock0(v0: i8):\n}\n"
|
|
);
|
|
|
|
f.dfg.append_block_param(block, types::F32.by(4).unwrap());
|
|
assert_eq!(
|
|
f.to_string(),
|
|
"function %foo() fast {\n ss0 = explicit_slot 4\n\nblock0(v0: i8, v1: f32x4):\n}\n"
|
|
);
|
|
|
|
{
|
|
let mut cursor = FuncCursor::new(&mut f);
|
|
cursor.set_position(CursorPosition::After(block));
|
|
cursor.ins().return_(&[])
|
|
};
|
|
assert_eq!(
|
|
f.to_string(),
|
|
"function %foo() fast {\n ss0 = explicit_slot 4\n\nblock0(v0: i8, v1: f32x4):\n return\n}\n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn aliases() {
|
|
use crate::ir::InstBuilder;
|
|
|
|
let mut func = Function::new();
|
|
{
|
|
let block0 = func.dfg.make_block();
|
|
let mut pos = FuncCursor::new(&mut func);
|
|
pos.insert_block(block0);
|
|
|
|
// make some detached values for change_to_alias
|
|
let v0 = pos.func.dfg.append_block_param(block0, types::I32);
|
|
let v1 = pos.func.dfg.append_block_param(block0, types::I32);
|
|
let v2 = pos.func.dfg.append_block_param(block0, types::I32);
|
|
pos.func.dfg.detach_block_params(block0);
|
|
|
|
// alias to a param--will be printed at beginning of block defining param
|
|
let v3 = pos.func.dfg.append_block_param(block0, types::I32);
|
|
pos.func.dfg.change_to_alias(v0, v3);
|
|
|
|
// alias to an alias--should print attached to alias, not ultimate target
|
|
pos.func.dfg.make_value_alias_for_serialization(v0, v2); // v0 <- v2
|
|
|
|
// alias to a result--will be printed after instruction producing result
|
|
let _dummy0 = pos.ins().iconst(types::I32, 42);
|
|
let v4 = pos.ins().iadd(v0, v0);
|
|
pos.func.dfg.change_to_alias(v1, v4);
|
|
let _dummy1 = pos.ins().iconst(types::I32, 23);
|
|
let _v7 = pos.ins().iadd(v1, v1);
|
|
}
|
|
assert_eq!(
|
|
func.to_string(),
|
|
"function u0:0() fast {\nblock0(v3: i32):\n v0 -> v3\n v2 -> v0\n v4 = iconst.i32 42\n v5 = iadd v0, v0\n v1 -> v5\n v6 = iconst.i32 23\n v7 = iadd v1, v1\n}\n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cold_blocks() {
|
|
let mut func = Function::new();
|
|
{
|
|
let mut pos = FuncCursor::new(&mut func);
|
|
|
|
let block0 = pos.func.dfg.make_block();
|
|
pos.insert_block(block0);
|
|
pos.func.layout.set_cold(block0);
|
|
|
|
let block1 = pos.func.dfg.make_block();
|
|
pos.insert_block(block1);
|
|
pos.func.dfg.append_block_param(block1, types::I32);
|
|
pos.func.layout.set_cold(block1);
|
|
}
|
|
|
|
assert_eq!(
|
|
func.to_string(),
|
|
"function u0:0() fast {\nblock0 cold:\n\nblock1(v0: i32) cold:\n}\n"
|
|
);
|
|
}
|
|
}
|