1243 lines
44 KiB
Rust
1243 lines
44 KiB
Rust
//! Data flow graph tracking Instructions, Values, and EBBs.
|
|
|
|
use entity::{self, PrimaryMap, SecondaryMap};
|
|
use ir;
|
|
use ir::builder::ReplaceBuilder;
|
|
use ir::extfunc::ExtFuncData;
|
|
use ir::instructions::{BranchInfo, CallInfo, InstructionData};
|
|
use ir::types;
|
|
use ir::{Ebb, FuncRef, Inst, SigRef, Signature, Type, Value, ValueList, ValueListPool};
|
|
use isa::TargetIsa;
|
|
use packed_option::ReservedValue;
|
|
use std::fmt;
|
|
use std::iter;
|
|
use std::mem;
|
|
use std::ops::{Index, IndexMut};
|
|
use std::u16;
|
|
use write::write_operands;
|
|
|
|
/// A data flow graph defines all instructions and extended basic blocks in a function as well as
|
|
/// the data flow dependencies between them. The DFG also tracks values which can be either
|
|
/// instruction results or EBB parameters.
|
|
///
|
|
/// The layout of EBBs in the function and of instructions in each EBB is recorded by the
|
|
/// `FunctionLayout` data structure which form the other half of the function representation.
|
|
///
|
|
#[derive(Clone)]
|
|
pub struct DataFlowGraph {
|
|
/// Data about all of the instructions in the function, including opcodes and operands.
|
|
/// The instructions in this map are not in program order. That is tracked by `Layout`, along
|
|
/// with the EBB containing each instruction.
|
|
insts: PrimaryMap<Inst, InstructionData>,
|
|
|
|
/// List of result values for each instruction.
|
|
///
|
|
/// This map gets resized automatically by `make_inst()` so it is always in sync with the
|
|
/// primary `insts` map.
|
|
results: SecondaryMap<Inst, ValueList>,
|
|
|
|
/// Extended basic blocks in the function and their parameters.
|
|
///
|
|
/// This map is not in program order. That is handled by `Layout`, and so is the sequence of
|
|
/// instructions contained in each EBB.
|
|
ebbs: PrimaryMap<Ebb, EbbData>,
|
|
|
|
/// Memory pool of value lists.
|
|
///
|
|
/// The `ValueList` references into this pool appear in many places:
|
|
///
|
|
/// - Instructions in `insts` that don't have room for their entire argument list inline.
|
|
/// - Instruction result values in `results`.
|
|
/// - EBB parameters in `ebbs`.
|
|
pub value_lists: ValueListPool,
|
|
|
|
/// Primary value table with entries for all values.
|
|
values: PrimaryMap<Value, ValueData>,
|
|
|
|
/// Function signature table. These signatures are referenced by indirect call instructions as
|
|
/// well as the external function references.
|
|
pub signatures: PrimaryMap<SigRef, Signature>,
|
|
|
|
/// External function references. These are functions that can be called directly.
|
|
pub ext_funcs: PrimaryMap<FuncRef, ExtFuncData>,
|
|
}
|
|
|
|
impl DataFlowGraph {
|
|
/// Create a new empty `DataFlowGraph`.
|
|
pub fn new() -> Self {
|
|
Self {
|
|
insts: PrimaryMap::new(),
|
|
results: SecondaryMap::new(),
|
|
ebbs: PrimaryMap::new(),
|
|
value_lists: ValueListPool::new(),
|
|
values: PrimaryMap::new(),
|
|
signatures: PrimaryMap::new(),
|
|
ext_funcs: PrimaryMap::new(),
|
|
}
|
|
}
|
|
|
|
/// Clear everything.
|
|
pub fn clear(&mut self) {
|
|
self.insts.clear();
|
|
self.results.clear();
|
|
self.ebbs.clear();
|
|
self.value_lists.clear();
|
|
self.values.clear();
|
|
self.signatures.clear();
|
|
self.ext_funcs.clear();
|
|
}
|
|
|
|
/// Get the total number of instructions created in this function, whether they are currently
|
|
/// inserted in the layout or not.
|
|
///
|
|
/// This is intended for use with `SecondaryMap::with_capacity`.
|
|
pub fn num_insts(&self) -> usize {
|
|
self.insts.len()
|
|
}
|
|
|
|
/// Returns `true` if the given instruction reference is valid.
|
|
pub fn inst_is_valid(&self, inst: Inst) -> bool {
|
|
self.insts.is_valid(inst)
|
|
}
|
|
|
|
/// Get the total number of extended basic blocks created in this function, whether they are
|
|
/// currently inserted in the layout or not.
|
|
///
|
|
/// This is intended for use with `SecondaryMap::with_capacity`.
|
|
pub fn num_ebbs(&self) -> usize {
|
|
self.ebbs.len()
|
|
}
|
|
|
|
/// Returns `true` if the given ebb reference is valid.
|
|
pub fn ebb_is_valid(&self, ebb: Ebb) -> bool {
|
|
self.ebbs.is_valid(ebb)
|
|
}
|
|
|
|
/// Get the total number of values.
|
|
pub fn num_values(&self) -> usize {
|
|
self.values.len()
|
|
}
|
|
}
|
|
|
|
/// Resolve value aliases.
|
|
///
|
|
/// Find the original SSA value that `value` aliases, or None if an
|
|
/// alias cycle is detected.
|
|
fn maybe_resolve_aliases(values: &PrimaryMap<Value, ValueData>, value: Value) -> Option<Value> {
|
|
let mut v = value;
|
|
|
|
// Note that values may be empty here.
|
|
for _ in 0..1 + values.len() {
|
|
if let ValueData::Alias { original, .. } = values[v] {
|
|
v = original;
|
|
} else {
|
|
return Some(v);
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
/// Resolve value aliases.
|
|
///
|
|
/// Find the original SSA value that `value` aliases.
|
|
fn resolve_aliases(values: &PrimaryMap<Value, ValueData>, value: Value) -> Value {
|
|
if let Some(v) = maybe_resolve_aliases(values, value) {
|
|
v
|
|
} else {
|
|
panic!("Value alias loop detected for {}", value);
|
|
}
|
|
}
|
|
|
|
/// Iterator over all Values in a DFG
|
|
pub struct Values<'a> {
|
|
inner: entity::Iter<'a, Value, ValueData>,
|
|
}
|
|
|
|
/// Check for non-values
|
|
fn valid_valuedata(data: &ValueData) -> bool {
|
|
if let ValueData::Alias {
|
|
ty: types::INVALID,
|
|
original,
|
|
} = *data
|
|
{
|
|
if original == Value::reserved_value() {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
|
|
impl<'a> Iterator for Values<'a> {
|
|
type Item = Value;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
self.inner
|
|
.by_ref()
|
|
.filter(|kv| valid_valuedata(kv.1))
|
|
.next()
|
|
.map(|kv| kv.0)
|
|
}
|
|
}
|
|
|
|
/// Handling values.
|
|
///
|
|
/// Values are either EBB parameters or instruction results.
|
|
impl DataFlowGraph {
|
|
/// Allocate an extended value entry.
|
|
fn make_value(&mut self, data: ValueData) -> Value {
|
|
self.values.push(data)
|
|
}
|
|
|
|
/// Get an iterator over all values.
|
|
pub fn values<'a>(&'a self) -> Values {
|
|
Values {
|
|
inner: self.values.iter(),
|
|
}
|
|
}
|
|
|
|
/// Check if a value reference is valid.
|
|
pub fn value_is_valid(&self, v: Value) -> bool {
|
|
self.values.is_valid(v)
|
|
}
|
|
|
|
/// Get the type of a value.
|
|
pub fn value_type(&self, v: Value) -> Type {
|
|
match self.values[v] {
|
|
ValueData::Inst { ty, .. }
|
|
| ValueData::Param { ty, .. }
|
|
| ValueData::Alias { ty, .. } => ty,
|
|
}
|
|
}
|
|
|
|
/// Get the definition of a value.
|
|
///
|
|
/// This is either the instruction that defined it or the Ebb that has the value as an
|
|
/// parameter.
|
|
pub fn value_def(&self, v: Value) -> ValueDef {
|
|
match self.values[v] {
|
|
ValueData::Inst { inst, num, .. } => ValueDef::Result(inst, num as usize),
|
|
ValueData::Param { ebb, num, .. } => ValueDef::Param(ebb, num as usize),
|
|
ValueData::Alias { original, .. } => {
|
|
// Make sure we only recurse one level. `resolve_aliases` has safeguards to
|
|
// detect alias loops without overrunning the stack.
|
|
self.value_def(self.resolve_aliases(original))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Determine if `v` is an attached instruction result / EBB parameter.
|
|
///
|
|
/// An attached value can't be attached to something else without first being detached.
|
|
///
|
|
/// Value aliases are not considered to be attached to anything. Use `resolve_aliases()` to
|
|
/// determine if the original aliased value is attached.
|
|
pub fn value_is_attached(&self, v: Value) -> bool {
|
|
use self::ValueData::*;
|
|
match self.values[v] {
|
|
Inst { inst, num, .. } => Some(&v) == self.inst_results(inst).get(num as usize),
|
|
Param { ebb, num, .. } => Some(&v) == self.ebb_params(ebb).get(num as usize),
|
|
Alias { .. } => false,
|
|
}
|
|
}
|
|
|
|
/// Resolve value aliases.
|
|
///
|
|
/// Find the original SSA value that `value` aliases.
|
|
pub fn resolve_aliases(&self, value: Value) -> Value {
|
|
resolve_aliases(&self.values, value)
|
|
}
|
|
|
|
/// Resolve all aliases among inst's arguments.
|
|
///
|
|
/// For each argument of inst which is defined by an alias, replace the
|
|
/// alias with the aliased value.
|
|
pub fn resolve_aliases_in_arguments(&mut self, inst: Inst) {
|
|
for arg in self.insts[inst].arguments_mut(&mut self.value_lists) {
|
|
let resolved = resolve_aliases(&self.values, *arg);
|
|
if resolved != *arg {
|
|
*arg = resolved;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Turn a value into an alias of another.
|
|
///
|
|
/// Change the `dest` value to behave as an alias of `src`. This means that all uses of `dest`
|
|
/// will behave as if they used that value `src`.
|
|
///
|
|
/// The `dest` value can't be attached to an instruction or EBB.
|
|
pub fn change_to_alias(&mut self, dest: Value, src: Value) {
|
|
debug_assert!(!self.value_is_attached(dest));
|
|
// Try to create short alias chains by finding the original source value.
|
|
// This also avoids the creation of loops.
|
|
let original = self.resolve_aliases(src);
|
|
debug_assert_ne!(
|
|
dest, original,
|
|
"Aliasing {} to {} would create a loop",
|
|
dest, src
|
|
);
|
|
let ty = self.value_type(original);
|
|
debug_assert_eq!(
|
|
self.value_type(dest),
|
|
ty,
|
|
"Aliasing {} to {} would change its type {} to {}",
|
|
dest,
|
|
src,
|
|
self.value_type(dest),
|
|
ty
|
|
);
|
|
debug_assert_ne!(ty, types::INVALID);
|
|
|
|
self.values[dest] = ValueData::Alias { ty, original };
|
|
}
|
|
|
|
/// Replace the results of one instruction with aliases to the results of another.
|
|
///
|
|
/// Change all the results of `dest_inst` to behave as aliases of
|
|
/// corresponding results of `src_inst`, as if calling change_to_alias for
|
|
/// each.
|
|
///
|
|
/// After calling this instruction, `dest_inst` will have had its results
|
|
/// cleared, so it likely needs to be removed from the graph.
|
|
///
|
|
pub fn replace_with_aliases(&mut self, dest_inst: Inst, src_inst: Inst) {
|
|
debug_assert_ne!(
|
|
dest_inst, src_inst,
|
|
"Replacing {} with itself would create a loop",
|
|
dest_inst
|
|
);
|
|
debug_assert_eq!(
|
|
self.results[dest_inst].len(&self.value_lists),
|
|
self.results[src_inst].len(&self.value_lists),
|
|
"Replacing {} with {} would produce a different number of results.",
|
|
dest_inst,
|
|
src_inst
|
|
);
|
|
|
|
for (&dest, &src) in self.results[dest_inst]
|
|
.as_slice(&self.value_lists)
|
|
.iter()
|
|
.zip(self.results[src_inst].as_slice(&self.value_lists))
|
|
{
|
|
let original = src;
|
|
let ty = self.value_type(original);
|
|
debug_assert_eq!(
|
|
self.value_type(dest),
|
|
ty,
|
|
"Aliasing {} to {} would change its type {} to {}",
|
|
dest,
|
|
src,
|
|
self.value_type(dest),
|
|
ty
|
|
);
|
|
debug_assert_ne!(ty, types::INVALID);
|
|
|
|
self.values[dest] = ValueData::Alias { ty, original };
|
|
}
|
|
|
|
self.clear_results(dest_inst);
|
|
}
|
|
}
|
|
|
|
/// Where did a value come from?
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum ValueDef {
|
|
/// Value is the n'th result of an instruction.
|
|
Result(Inst, usize),
|
|
/// Value is the n'th parameter to an EBB.
|
|
Param(Ebb, usize),
|
|
}
|
|
|
|
impl ValueDef {
|
|
/// Unwrap the instruction where the value was defined, or panic.
|
|
pub fn unwrap_inst(&self) -> Inst {
|
|
match *self {
|
|
ValueDef::Result(inst, _) => inst,
|
|
_ => panic!("Value is not an instruction result"),
|
|
}
|
|
}
|
|
|
|
/// Unwrap the EBB there the parameter is defined, or panic.
|
|
pub fn unwrap_ebb(&self) -> Ebb {
|
|
match *self {
|
|
ValueDef::Param(ebb, _) => ebb,
|
|
_ => panic!("Value is not an EBB parameter"),
|
|
}
|
|
}
|
|
|
|
/// Get the program point where the value was defined.
|
|
pub fn pp(self) -> ir::ExpandedProgramPoint {
|
|
self.into()
|
|
}
|
|
|
|
/// Get the number component of this definition.
|
|
///
|
|
/// When multiple values are defined at the same program point, this indicates the index of
|
|
/// this value.
|
|
pub fn num(self) -> usize {
|
|
match self {
|
|
ValueDef::Result(_, n) | ValueDef::Param(_, n) => n,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Internal table storage for extended values.
|
|
#[derive(Clone, Debug)]
|
|
enum ValueData {
|
|
/// Value is defined by an instruction.
|
|
Inst { ty: Type, num: u16, inst: Inst },
|
|
|
|
/// Value is an EBB parameter.
|
|
Param { ty: Type, num: u16, ebb: Ebb },
|
|
|
|
/// Value is an alias of another value.
|
|
/// An alias value can't be linked as an instruction result or EBB parameter. It is used as a
|
|
/// placeholder when the original instruction or EBB has been rewritten or modified.
|
|
Alias { ty: Type, original: Value },
|
|
}
|
|
|
|
/// Instructions.
|
|
///
|
|
impl DataFlowGraph {
|
|
/// Create a new instruction.
|
|
///
|
|
/// The type of the first result is indicated by `data.ty`. If the instruction produces
|
|
/// multiple results, also call `make_inst_results` to allocate value table entries.
|
|
pub fn make_inst(&mut self, data: InstructionData) -> Inst {
|
|
let n = self.num_insts() + 1;
|
|
self.results.resize(n);
|
|
self.insts.push(data)
|
|
}
|
|
|
|
/// Returns an object that displays `inst`.
|
|
pub fn display_inst<'a, I: Into<Option<&'a TargetIsa>>>(
|
|
&'a self,
|
|
inst: Inst,
|
|
isa: I,
|
|
) -> DisplayInst<'a> {
|
|
DisplayInst(self, isa.into(), inst)
|
|
}
|
|
|
|
/// Get all value arguments on `inst` as a slice.
|
|
pub fn inst_args(&self, inst: Inst) -> &[Value] {
|
|
self.insts[inst].arguments(&self.value_lists)
|
|
}
|
|
|
|
/// Get all value arguments on `inst` as a mutable slice.
|
|
pub fn inst_args_mut(&mut self, inst: Inst) -> &mut [Value] {
|
|
self.insts[inst].arguments_mut(&mut self.value_lists)
|
|
}
|
|
|
|
/// Get the fixed value arguments on `inst` as a slice.
|
|
pub fn inst_fixed_args(&self, inst: Inst) -> &[Value] {
|
|
let fixed_args = self[inst].opcode().constraints().fixed_value_arguments();
|
|
&self.inst_args(inst)[..fixed_args]
|
|
}
|
|
|
|
/// Get the fixed value arguments on `inst` as a mutable slice.
|
|
pub fn inst_fixed_args_mut(&mut self, inst: Inst) -> &mut [Value] {
|
|
let fixed_args = self[inst].opcode().constraints().fixed_value_arguments();
|
|
&mut self.inst_args_mut(inst)[..fixed_args]
|
|
}
|
|
|
|
/// Get the variable value arguments on `inst` as a slice.
|
|
pub fn inst_variable_args(&self, inst: Inst) -> &[Value] {
|
|
let fixed_args = self[inst].opcode().constraints().fixed_value_arguments();
|
|
&self.inst_args(inst)[fixed_args..]
|
|
}
|
|
|
|
/// Get the variable value arguments on `inst` as a mutable slice.
|
|
pub fn inst_variable_args_mut(&mut self, inst: Inst) -> &mut [Value] {
|
|
let fixed_args = self[inst].opcode().constraints().fixed_value_arguments();
|
|
&mut self.inst_args_mut(inst)[fixed_args..]
|
|
}
|
|
|
|
/// Create result values for an instruction that produces multiple results.
|
|
///
|
|
/// Instructions that produce no result values only need to be created with `make_inst`,
|
|
/// otherwise call `make_inst_results` to allocate value table entries for the results.
|
|
///
|
|
/// The result value types are determined from the instruction's value type constraints and the
|
|
/// provided `ctrl_typevar` type for polymorphic instructions. For non-polymorphic
|
|
/// instructions, `ctrl_typevar` is ignored, and `INVALID` can be used.
|
|
///
|
|
/// The type of the first result value is also set, even if it was already set in the
|
|
/// `InstructionData` passed to `make_inst`. If this function is called with a single-result
|
|
/// instruction, that is the only effect.
|
|
pub fn make_inst_results(&mut self, inst: Inst, ctrl_typevar: Type) -> usize {
|
|
self.make_inst_results_reusing(inst, ctrl_typevar, iter::empty())
|
|
}
|
|
|
|
/// Create result values for `inst`, reusing the provided detached values.
|
|
///
|
|
/// Create a new set of result values for `inst` using `ctrl_typevar` to determine the result
|
|
/// types. Any values provided by `reuse` will be reused. When `reuse` is exhausted or when it
|
|
/// produces `None`, a new value is created.
|
|
pub fn make_inst_results_reusing<I>(
|
|
&mut self,
|
|
inst: Inst,
|
|
ctrl_typevar: Type,
|
|
reuse: I,
|
|
) -> usize
|
|
where
|
|
I: Iterator<Item = Option<Value>>,
|
|
{
|
|
let mut reuse = reuse.fuse();
|
|
|
|
self.results[inst].clear(&mut self.value_lists);
|
|
|
|
// Get the call signature if this is a function call.
|
|
if let Some(sig) = self.call_signature(inst) {
|
|
// Create result values corresponding to the call return types.
|
|
debug_assert_eq!(self.insts[inst].opcode().constraints().fixed_results(), 0);
|
|
let num_results = self.signatures[sig].returns.len();
|
|
for res_idx in 0..num_results {
|
|
let ty = self.signatures[sig].returns[res_idx].value_type;
|
|
if let Some(Some(v)) = reuse.next() {
|
|
debug_assert_eq!(self.value_type(v), ty, "Reused {} is wrong type", ty);
|
|
self.attach_result(inst, v);
|
|
} else {
|
|
self.append_result(inst, ty);
|
|
}
|
|
}
|
|
num_results
|
|
} else {
|
|
// Create result values corresponding to the opcode's constraints.
|
|
let constraints = self.insts[inst].opcode().constraints();
|
|
let num_results = constraints.fixed_results();
|
|
for res_idx in 0..num_results {
|
|
let ty = constraints.result_type(res_idx, ctrl_typevar);
|
|
if let Some(Some(v)) = reuse.next() {
|
|
debug_assert_eq!(self.value_type(v), ty, "Reused {} is wrong type", ty);
|
|
self.attach_result(inst, v);
|
|
} else {
|
|
self.append_result(inst, ty);
|
|
}
|
|
}
|
|
num_results
|
|
}
|
|
}
|
|
|
|
/// Create a `ReplaceBuilder` that will replace `inst` with a new instruction in place.
|
|
pub fn replace(&mut self, inst: Inst) -> ReplaceBuilder {
|
|
ReplaceBuilder::new(self, inst)
|
|
}
|
|
|
|
/// Detach the list of result values from `inst` and return it.
|
|
///
|
|
/// This leaves `inst` without any result values. New result values can be created by calling
|
|
/// `make_inst_results` or by using a `replace(inst)` builder.
|
|
pub fn detach_results(&mut self, inst: Inst) -> ValueList {
|
|
self.results[inst].take()
|
|
}
|
|
|
|
/// Clear the list of result values from `inst`.
|
|
///
|
|
/// This leaves `inst` without any result values. New result values can be created by calling
|
|
/// `make_inst_results` or by using a `replace(inst)` builder.
|
|
pub fn clear_results(&mut self, inst: Inst) {
|
|
self.results[inst].clear(&mut self.value_lists)
|
|
}
|
|
|
|
/// Attach an existing value to the result value list for `inst`.
|
|
///
|
|
/// The `res` value is appended to the end of the result list.
|
|
///
|
|
/// This is a very low-level operation. Usually, instruction results with the correct types are
|
|
/// created automatically. The `res` value must not be attached to anything else.
|
|
pub fn attach_result(&mut self, inst: Inst, res: Value) {
|
|
debug_assert!(!self.value_is_attached(res));
|
|
let num = self.results[inst].push(res, &mut self.value_lists);
|
|
debug_assert!(num <= u16::MAX as usize, "Too many result values");
|
|
let ty = self.value_type(res);
|
|
self.values[res] = ValueData::Inst {
|
|
ty,
|
|
num: num as u16,
|
|
inst,
|
|
};
|
|
}
|
|
|
|
/// Replace an instruction result with a new value of type `new_type`.
|
|
///
|
|
/// The `old_value` must be an attached instruction result.
|
|
///
|
|
/// The old value is left detached, so it should probably be changed into something else.
|
|
///
|
|
/// Returns the new value.
|
|
pub fn replace_result(&mut self, old_value: Value, new_type: Type) -> Value {
|
|
let (num, inst) = match self.values[old_value] {
|
|
ValueData::Inst { num, inst, .. } => (num, inst),
|
|
_ => panic!("{} is not an instruction result value", old_value),
|
|
};
|
|
let new_value = self.make_value(ValueData::Inst {
|
|
ty: new_type,
|
|
num,
|
|
inst,
|
|
});
|
|
let num = num as usize;
|
|
let attached = mem::replace(
|
|
self.results[inst]
|
|
.get_mut(num, &mut self.value_lists)
|
|
.expect("Replacing detached result"),
|
|
new_value,
|
|
);
|
|
debug_assert_eq!(
|
|
attached,
|
|
old_value,
|
|
"{} wasn't detached from {}",
|
|
old_value,
|
|
self.display_inst(inst, None)
|
|
);
|
|
new_value
|
|
}
|
|
|
|
/// Append a new instruction result value to `inst`.
|
|
pub fn append_result(&mut self, inst: Inst, ty: Type) -> Value {
|
|
let res = self.values.next_key();
|
|
let num = self.results[inst].push(res, &mut self.value_lists);
|
|
debug_assert!(num <= u16::MAX as usize, "Too many result values");
|
|
self.make_value(ValueData::Inst {
|
|
ty,
|
|
inst,
|
|
num: num as u16,
|
|
})
|
|
}
|
|
|
|
/// Append a new value argument to an instruction.
|
|
///
|
|
/// Panics if the instruction doesn't support arguments.
|
|
pub fn append_inst_arg(&mut self, inst: Inst, new_arg: Value) {
|
|
let mut branch_values = self.insts[inst]
|
|
.take_value_list()
|
|
.expect("the instruction doesn't have value arguments");
|
|
branch_values.push(new_arg, &mut self.value_lists);
|
|
self.insts[inst].put_value_list(branch_values)
|
|
}
|
|
|
|
/// Get the first result of an instruction.
|
|
///
|
|
/// This function panics if the instruction doesn't have any result.
|
|
pub fn first_result(&self, inst: Inst) -> Value {
|
|
self.results[inst]
|
|
.first(&self.value_lists)
|
|
.expect("Instruction has no results")
|
|
}
|
|
|
|
/// Test if `inst` has any result values currently.
|
|
pub fn has_results(&self, inst: Inst) -> bool {
|
|
!self.results[inst].is_empty()
|
|
}
|
|
|
|
/// Return all the results of an instruction.
|
|
pub fn inst_results(&self, inst: Inst) -> &[Value] {
|
|
self.results[inst].as_slice(&self.value_lists)
|
|
}
|
|
|
|
/// Get the call signature of a direct or indirect call instruction.
|
|
/// Returns `None` if `inst` is not a call instruction.
|
|
pub fn call_signature(&self, inst: Inst) -> Option<SigRef> {
|
|
match self.insts[inst].analyze_call(&self.value_lists) {
|
|
CallInfo::NotACall => None,
|
|
CallInfo::Direct(f, _) => Some(self.ext_funcs[f].signature),
|
|
CallInfo::Indirect(s, _) => Some(s),
|
|
}
|
|
}
|
|
|
|
/// Check if `inst` is a branch.
|
|
pub fn analyze_branch(&self, inst: Inst) -> BranchInfo {
|
|
self.insts[inst].analyze_branch(&self.value_lists)
|
|
}
|
|
|
|
/// Compute the type of an instruction result from opcode constraints and call signatures.
|
|
///
|
|
/// This computes the same sequence of result types that `make_inst_results()` above would
|
|
/// assign to the created result values, but it does not depend on `make_inst_results()` being
|
|
/// called first.
|
|
///
|
|
/// Returns `None` if asked about a result index that is too large.
|
|
pub fn compute_result_type(
|
|
&self,
|
|
inst: Inst,
|
|
result_idx: usize,
|
|
ctrl_typevar: Type,
|
|
) -> Option<Type> {
|
|
let constraints = self.insts[inst].opcode().constraints();
|
|
let fixed_results = constraints.fixed_results();
|
|
|
|
if result_idx < fixed_results {
|
|
return Some(constraints.result_type(result_idx, ctrl_typevar));
|
|
}
|
|
|
|
// Not a fixed result, try to extract a return type from the call signature.
|
|
self.call_signature(inst).and_then(|sigref| {
|
|
self.signatures[sigref]
|
|
.returns
|
|
.get(result_idx - fixed_results)
|
|
.map(|&arg| arg.value_type)
|
|
})
|
|
}
|
|
|
|
/// Get the controlling type variable, or `INVALID` if `inst` isn't polymorphic.
|
|
pub fn ctrl_typevar(&self, inst: Inst) -> Type {
|
|
let constraints = self[inst].opcode().constraints();
|
|
|
|
if !constraints.is_polymorphic() {
|
|
types::INVALID
|
|
} else if constraints.requires_typevar_operand() {
|
|
// Not all instruction formats have a designated operand, but in that case
|
|
// `requires_typevar_operand()` should never be true.
|
|
self.value_type(
|
|
self[inst]
|
|
.typevar_operand(&self.value_lists)
|
|
.expect("Instruction format doesn't have a designated operand, bad opcode."),
|
|
)
|
|
} else {
|
|
self.value_type(self.first_result(inst))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Allow immutable access to instructions via indexing.
|
|
impl Index<Inst> for DataFlowGraph {
|
|
type Output = InstructionData;
|
|
|
|
fn index(&self, inst: Inst) -> &InstructionData {
|
|
&self.insts[inst]
|
|
}
|
|
}
|
|
|
|
/// Allow mutable access to instructions via indexing.
|
|
impl IndexMut<Inst> for DataFlowGraph {
|
|
fn index_mut(&mut self, inst: Inst) -> &mut InstructionData {
|
|
&mut self.insts[inst]
|
|
}
|
|
}
|
|
|
|
/// Extended basic blocks.
|
|
impl DataFlowGraph {
|
|
/// Create a new basic block.
|
|
pub fn make_ebb(&mut self) -> Ebb {
|
|
self.ebbs.push(EbbData::new())
|
|
}
|
|
|
|
/// Get the number of parameters on `ebb`.
|
|
pub fn num_ebb_params(&self, ebb: Ebb) -> usize {
|
|
self.ebbs[ebb].params.len(&self.value_lists)
|
|
}
|
|
|
|
/// Get the parameters on `ebb`.
|
|
pub fn ebb_params(&self, ebb: Ebb) -> &[Value] {
|
|
self.ebbs[ebb].params.as_slice(&self.value_lists)
|
|
}
|
|
|
|
/// Append a parameter with type `ty` to `ebb`.
|
|
pub fn append_ebb_param(&mut self, ebb: Ebb, ty: Type) -> Value {
|
|
let param = self.values.next_key();
|
|
let num = self.ebbs[ebb].params.push(param, &mut self.value_lists);
|
|
debug_assert!(num <= u16::MAX as usize, "Too many parameters on EBB");
|
|
self.make_value(ValueData::Param {
|
|
ty,
|
|
num: num as u16,
|
|
ebb,
|
|
})
|
|
}
|
|
|
|
/// Removes `val` from `ebb`'s parameters by swapping it with the last parameter on `ebb`.
|
|
/// Returns the position of `val` before removal.
|
|
///
|
|
/// *Important*: to ensure O(1) deletion, this method swaps the removed parameter with the
|
|
/// last `ebb` parameter. This can disrupt all the branch instructions jumping to this
|
|
/// `ebb` for which you have to change the branch argument order if necessary.
|
|
///
|
|
/// Panics if `val` is not an EBB parameter.
|
|
pub fn swap_remove_ebb_param(&mut self, val: Value) -> usize {
|
|
let (ebb, num) = if let ValueData::Param { num, ebb, .. } = self.values[val] {
|
|
(ebb, num)
|
|
} else {
|
|
panic!("{} must be an EBB parameter", val);
|
|
};
|
|
self.ebbs[ebb]
|
|
.params
|
|
.swap_remove(num as usize, &mut self.value_lists);
|
|
if let Some(last_arg_val) = self.ebbs[ebb].params.get(num as usize, &self.value_lists) {
|
|
// We update the position of the old last arg.
|
|
if let ValueData::Param {
|
|
num: ref mut old_num,
|
|
..
|
|
} = self.values[last_arg_val]
|
|
{
|
|
*old_num = num;
|
|
} else {
|
|
panic!("{} should be an Ebb parameter", last_arg_val);
|
|
}
|
|
}
|
|
num as usize
|
|
}
|
|
|
|
/// Removes `val` from `ebb`'s parameters by a standard linear time list removal which
|
|
/// preserves ordering. Also updates the values' data.
|
|
pub fn remove_ebb_param(&mut self, val: Value) {
|
|
let (ebb, num) = if let ValueData::Param { num, ebb, .. } = self.values[val] {
|
|
(ebb, num)
|
|
} else {
|
|
panic!("{} must be an EBB parameter", val);
|
|
};
|
|
self.ebbs[ebb]
|
|
.params
|
|
.remove(num as usize, &mut self.value_lists);
|
|
for index in num..(self.num_ebb_params(ebb) as u16) {
|
|
match self.values[self.ebbs[ebb]
|
|
.params
|
|
.get(index as usize, &self.value_lists)
|
|
.unwrap()]
|
|
{
|
|
ValueData::Param { ref mut num, .. } => {
|
|
*num -= 1;
|
|
}
|
|
_ => panic!(
|
|
"{} must be an EBB parameter",
|
|
self.ebbs[ebb]
|
|
.params
|
|
.get(index as usize, &self.value_lists)
|
|
.unwrap()
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Append an existing value to `ebb`'s parameters.
|
|
///
|
|
/// The appended value can't already be attached to something else.
|
|
///
|
|
/// In almost all cases, you should be using `append_ebb_param()` instead of this method.
|
|
pub fn attach_ebb_param(&mut self, ebb: Ebb, param: Value) {
|
|
debug_assert!(!self.value_is_attached(param));
|
|
let num = self.ebbs[ebb].params.push(param, &mut self.value_lists);
|
|
debug_assert!(num <= u16::MAX as usize, "Too many parameters on EBB");
|
|
let ty = self.value_type(param);
|
|
self.values[param] = ValueData::Param {
|
|
ty,
|
|
num: num as u16,
|
|
ebb,
|
|
};
|
|
}
|
|
|
|
/// Replace an EBB parameter with a new value of type `ty`.
|
|
///
|
|
/// The `old_value` must be an attached EBB parameter. It is removed from its place in the list
|
|
/// of parameters and replaced by a new value of type `new_type`. The new value gets the same
|
|
/// position in the list, and other parameters are not disturbed.
|
|
///
|
|
/// The old value is left detached, so it should probably be changed into something else.
|
|
///
|
|
/// Returns the new value.
|
|
pub fn replace_ebb_param(&mut self, old_value: Value, new_type: Type) -> Value {
|
|
// Create new value identical to the old one except for the type.
|
|
let (ebb, num) = if let ValueData::Param { num, ebb, .. } = self.values[old_value] {
|
|
(ebb, num)
|
|
} else {
|
|
panic!("{} must be an EBB parameter", old_value);
|
|
};
|
|
let new_arg = self.make_value(ValueData::Param {
|
|
ty: new_type,
|
|
num,
|
|
ebb,
|
|
});
|
|
|
|
self.ebbs[ebb].params.as_mut_slice(&mut self.value_lists)[num as usize] = new_arg;
|
|
new_arg
|
|
}
|
|
|
|
/// Detach all the parameters from `ebb` and return them as a `ValueList`.
|
|
///
|
|
/// This is a quite low-level operation. Sensible things to do with the detached EBB parameters
|
|
/// is to put them back on the same EBB with `attach_ebb_param()` or change them into aliases
|
|
/// with `change_to_alias()`.
|
|
pub fn detach_ebb_params(&mut self, ebb: Ebb) -> ValueList {
|
|
self.ebbs[ebb].params.take()
|
|
}
|
|
}
|
|
|
|
/// Contents of an extended basic block.
|
|
///
|
|
/// Parameters on an extended basic block are values that dominate everything in the EBB. All
|
|
/// branches to this EBB must provide matching arguments, and the arguments to the entry EBB must
|
|
/// match the function arguments.
|
|
#[derive(Clone)]
|
|
struct EbbData {
|
|
/// List of parameters to this EBB.
|
|
params: ValueList,
|
|
}
|
|
|
|
impl EbbData {
|
|
fn new() -> Self {
|
|
Self {
|
|
params: ValueList::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Object that can display an instruction.
|
|
pub struct DisplayInst<'a>(&'a DataFlowGraph, Option<&'a TargetIsa>, Inst);
|
|
|
|
impl<'a> fmt::Display for DisplayInst<'a> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
let dfg = self.0;
|
|
let isa = self.1;
|
|
let inst = self.2;
|
|
|
|
if let Some((first, rest)) = dfg.inst_results(inst).split_first() {
|
|
write!(f, "{}", first)?;
|
|
for v in rest {
|
|
write!(f, ", {}", v)?;
|
|
}
|
|
write!(f, " = ")?;
|
|
}
|
|
|
|
let typevar = dfg.ctrl_typevar(inst);
|
|
if typevar.is_invalid() {
|
|
write!(f, "{}", dfg[inst].opcode())?;
|
|
} else {
|
|
write!(f, "{}.{}", dfg[inst].opcode(), typevar)?;
|
|
}
|
|
write_operands(f, dfg, isa, inst)
|
|
}
|
|
}
|
|
|
|
/// Parser routines. These routines should not be used outside the parser.
|
|
impl DataFlowGraph {
|
|
/// Set the type of a value. This is only for use in the parser, which needs
|
|
/// to create invalid values for index padding which may be reassigned later.
|
|
#[cold]
|
|
fn set_value_type_for_parser(&mut self, v: Value, t: Type) {
|
|
assert_eq!(
|
|
self.value_type(v),
|
|
types::INVALID,
|
|
"this function is only for assigning types to previously invalid values"
|
|
);
|
|
match self.values[v] {
|
|
ValueData::Inst { ref mut ty, .. }
|
|
| ValueData::Param { ref mut ty, .. }
|
|
| ValueData::Alias { ref mut ty, .. } => *ty = t,
|
|
}
|
|
}
|
|
|
|
/// Create result values for `inst`, reusing the provided detached values.
|
|
/// This is similar to `make_inst_results_reusing` except it's only for use
|
|
/// in the parser, which needs to reuse previously invalid values.
|
|
#[cold]
|
|
pub fn make_inst_results_for_parser(
|
|
&mut self,
|
|
inst: Inst,
|
|
ctrl_typevar: Type,
|
|
reuse: &[Value],
|
|
) -> usize {
|
|
// Get the call signature if this is a function call.
|
|
if let Some(sig) = self.call_signature(inst) {
|
|
assert_eq!(self.insts[inst].opcode().constraints().fixed_results(), 0);
|
|
for res_idx in 0..self.signatures[sig].returns.len() {
|
|
let ty = self.signatures[sig].returns[res_idx].value_type;
|
|
if let Some(v) = reuse.get(res_idx) {
|
|
self.set_value_type_for_parser(*v, ty);
|
|
}
|
|
}
|
|
} else {
|
|
let constraints = self.insts[inst].opcode().constraints();
|
|
for res_idx in 0..constraints.fixed_results() {
|
|
let ty = constraints.result_type(res_idx, ctrl_typevar);
|
|
if let Some(v) = reuse.get(res_idx) {
|
|
self.set_value_type_for_parser(*v, ty);
|
|
}
|
|
}
|
|
}
|
|
|
|
self.make_inst_results_reusing(inst, ctrl_typevar, reuse.iter().map(|x| Some(*x)))
|
|
}
|
|
|
|
/// Similar to `append_ebb_param`, append a parameter with type `ty` to
|
|
/// `ebb`, but using value `val`. This is only for use by the parser to
|
|
/// create parameters with specific values.
|
|
#[cold]
|
|
pub fn append_ebb_param_for_parser(&mut self, ebb: Ebb, ty: Type, val: Value) {
|
|
let num = self.ebbs[ebb].params.push(val, &mut self.value_lists);
|
|
assert!(num <= u16::MAX as usize, "Too many parameters on EBB");
|
|
self.values[val] = ValueData::Param {
|
|
ty,
|
|
num: num as u16,
|
|
ebb,
|
|
};
|
|
}
|
|
|
|
/// Create a new value alias. This is only for use by the parser to create
|
|
/// aliases with specific values, and the printer for testing.
|
|
#[cold]
|
|
pub fn make_value_alias_for_serialization(&mut self, src: Value, dest: Value) {
|
|
assert_ne!(src, Value::reserved_value());
|
|
assert_ne!(dest, Value::reserved_value());
|
|
|
|
let ty = if self.values.is_valid(src) {
|
|
self.value_type(src)
|
|
} else {
|
|
// As a special case, if we can't resolve the aliasee yet, use INVALID
|
|
// temporarily. It will be resolved later in parsing.
|
|
types::INVALID
|
|
};
|
|
let data = ValueData::Alias { ty, original: src };
|
|
self.values[dest] = data;
|
|
}
|
|
|
|
/// If `v` is already defined as an alias, return its destination value.
|
|
/// Otherwise return None. This allows the parser to coalesce identical
|
|
/// alias definitions, and the printer to identify an alias's immediate target.
|
|
#[cold]
|
|
pub fn value_alias_dest_for_serialization(&self, v: Value) -> Option<Value> {
|
|
if let ValueData::Alias { original, .. } = self.values[v] {
|
|
Some(original)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Compute the type of an alias. This is only for use in the parser.
|
|
/// Returns false if an alias cycle was encountered.
|
|
#[cold]
|
|
pub fn set_alias_type_for_parser(&mut self, v: Value) -> bool {
|
|
if let Some(resolved) = maybe_resolve_aliases(&self.values, v) {
|
|
let old_ty = self.value_type(v);
|
|
let new_ty = self.value_type(resolved);
|
|
if old_ty == types::INVALID {
|
|
self.set_value_type_for_parser(v, new_ty);
|
|
} else {
|
|
assert_eq!(old_ty, new_ty);
|
|
}
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Create an invalid value, to pad the index space. This is only for use by
|
|
/// the parser to pad out the value index space.
|
|
#[cold]
|
|
pub fn make_invalid_value_for_parser(&mut self) {
|
|
let data = ValueData::Alias {
|
|
ty: types::INVALID,
|
|
original: Value::reserved_value(),
|
|
};
|
|
self.make_value(data);
|
|
}
|
|
|
|
/// Check if a value reference is valid, while being aware of aliases which
|
|
/// may be unresolved while parsing.
|
|
#[cold]
|
|
pub fn value_is_valid_for_parser(&self, v: Value) -> bool {
|
|
if !self.value_is_valid(v) {
|
|
return false;
|
|
}
|
|
if let ValueData::Alias { ty, .. } = self.values[v] {
|
|
ty != types::INVALID
|
|
} else {
|
|
true
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use cursor::{Cursor, FuncCursor};
|
|
use ir::types;
|
|
use ir::{Function, InstructionData, Opcode, TrapCode};
|
|
use std::string::ToString;
|
|
|
|
#[test]
|
|
fn make_inst() {
|
|
let mut dfg = DataFlowGraph::new();
|
|
|
|
let idata = InstructionData::UnaryImm {
|
|
opcode: Opcode::Iconst,
|
|
imm: 0.into(),
|
|
};
|
|
let inst = dfg.make_inst(idata);
|
|
|
|
dfg.make_inst_results(inst, types::I32);
|
|
assert_eq!(inst.to_string(), "inst0");
|
|
assert_eq!(
|
|
dfg.display_inst(inst, None).to_string(),
|
|
"v0 = iconst.i32 0"
|
|
);
|
|
|
|
// Immutable reference resolution.
|
|
{
|
|
let immdfg = &dfg;
|
|
let ins = &immdfg[inst];
|
|
assert_eq!(ins.opcode(), Opcode::Iconst);
|
|
}
|
|
|
|
// Results.
|
|
let val = dfg.first_result(inst);
|
|
assert_eq!(dfg.inst_results(inst), &[val]);
|
|
|
|
assert_eq!(dfg.value_def(val), ValueDef::Result(inst, 0));
|
|
assert_eq!(dfg.value_type(val), types::I32);
|
|
|
|
// Replacing results.
|
|
assert!(dfg.value_is_attached(val));
|
|
let v2 = dfg.replace_result(val, types::F64);
|
|
assert!(!dfg.value_is_attached(val));
|
|
assert!(dfg.value_is_attached(v2));
|
|
assert_eq!(dfg.inst_results(inst), &[v2]);
|
|
assert_eq!(dfg.value_def(v2), ValueDef::Result(inst, 0));
|
|
assert_eq!(dfg.value_type(v2), types::F64);
|
|
}
|
|
|
|
#[test]
|
|
fn no_results() {
|
|
let mut dfg = DataFlowGraph::new();
|
|
|
|
let idata = InstructionData::Trap {
|
|
opcode: Opcode::Trap,
|
|
code: TrapCode::User(0),
|
|
};
|
|
let inst = dfg.make_inst(idata);
|
|
assert_eq!(dfg.display_inst(inst, None).to_string(), "trap user0");
|
|
|
|
// Result slice should be empty.
|
|
assert_eq!(dfg.inst_results(inst), &[]);
|
|
}
|
|
|
|
#[test]
|
|
fn ebb() {
|
|
let mut dfg = DataFlowGraph::new();
|
|
|
|
let ebb = dfg.make_ebb();
|
|
assert_eq!(ebb.to_string(), "ebb0");
|
|
assert_eq!(dfg.num_ebb_params(ebb), 0);
|
|
assert_eq!(dfg.ebb_params(ebb), &[]);
|
|
assert!(dfg.detach_ebb_params(ebb).is_empty());
|
|
assert_eq!(dfg.num_ebb_params(ebb), 0);
|
|
assert_eq!(dfg.ebb_params(ebb), &[]);
|
|
|
|
let arg1 = dfg.append_ebb_param(ebb, types::F32);
|
|
assert_eq!(arg1.to_string(), "v0");
|
|
assert_eq!(dfg.num_ebb_params(ebb), 1);
|
|
assert_eq!(dfg.ebb_params(ebb), &[arg1]);
|
|
|
|
let arg2 = dfg.append_ebb_param(ebb, types::I16);
|
|
assert_eq!(arg2.to_string(), "v1");
|
|
assert_eq!(dfg.num_ebb_params(ebb), 2);
|
|
assert_eq!(dfg.ebb_params(ebb), &[arg1, arg2]);
|
|
|
|
assert_eq!(dfg.value_def(arg1), ValueDef::Param(ebb, 0));
|
|
assert_eq!(dfg.value_def(arg2), ValueDef::Param(ebb, 1));
|
|
assert_eq!(dfg.value_type(arg1), types::F32);
|
|
assert_eq!(dfg.value_type(arg2), types::I16);
|
|
|
|
// Swap the two EBB parameters.
|
|
let vlist = dfg.detach_ebb_params(ebb);
|
|
assert_eq!(dfg.num_ebb_params(ebb), 0);
|
|
assert_eq!(dfg.ebb_params(ebb), &[]);
|
|
assert_eq!(vlist.as_slice(&dfg.value_lists), &[arg1, arg2]);
|
|
dfg.attach_ebb_param(ebb, arg2);
|
|
let arg3 = dfg.append_ebb_param(ebb, types::I32);
|
|
dfg.attach_ebb_param(ebb, arg1);
|
|
assert_eq!(dfg.ebb_params(ebb), &[arg2, arg3, arg1]);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_ebb_params() {
|
|
let mut dfg = DataFlowGraph::new();
|
|
|
|
let ebb = dfg.make_ebb();
|
|
let arg1 = dfg.append_ebb_param(ebb, types::F32);
|
|
|
|
let new1 = dfg.replace_ebb_param(arg1, types::I64);
|
|
assert_eq!(dfg.value_type(arg1), types::F32);
|
|
assert_eq!(dfg.value_type(new1), types::I64);
|
|
assert_eq!(dfg.ebb_params(ebb), &[new1]);
|
|
|
|
dfg.attach_ebb_param(ebb, arg1);
|
|
assert_eq!(dfg.ebb_params(ebb), &[new1, arg1]);
|
|
|
|
let new2 = dfg.replace_ebb_param(arg1, types::I8);
|
|
assert_eq!(dfg.value_type(arg1), types::F32);
|
|
assert_eq!(dfg.value_type(new2), types::I8);
|
|
assert_eq!(dfg.ebb_params(ebb), &[new1, new2]);
|
|
|
|
dfg.attach_ebb_param(ebb, arg1);
|
|
assert_eq!(dfg.ebb_params(ebb), &[new1, new2, arg1]);
|
|
|
|
let new3 = dfg.replace_ebb_param(new2, types::I16);
|
|
assert_eq!(dfg.value_type(new1), types::I64);
|
|
assert_eq!(dfg.value_type(new2), types::I8);
|
|
assert_eq!(dfg.value_type(new3), types::I16);
|
|
assert_eq!(dfg.ebb_params(ebb), &[new1, new3, arg1]);
|
|
}
|
|
|
|
#[test]
|
|
fn swap_remove_ebb_params() {
|
|
let mut dfg = DataFlowGraph::new();
|
|
|
|
let ebb = dfg.make_ebb();
|
|
let arg1 = dfg.append_ebb_param(ebb, types::F32);
|
|
let arg2 = dfg.append_ebb_param(ebb, types::F32);
|
|
let arg3 = dfg.append_ebb_param(ebb, types::F32);
|
|
assert_eq!(dfg.ebb_params(ebb), &[arg1, arg2, arg3]);
|
|
|
|
dfg.swap_remove_ebb_param(arg1);
|
|
assert_eq!(dfg.value_is_attached(arg1), false);
|
|
assert_eq!(dfg.value_is_attached(arg2), true);
|
|
assert_eq!(dfg.value_is_attached(arg3), true);
|
|
assert_eq!(dfg.ebb_params(ebb), &[arg3, arg2]);
|
|
dfg.swap_remove_ebb_param(arg2);
|
|
assert_eq!(dfg.value_is_attached(arg2), false);
|
|
assert_eq!(dfg.value_is_attached(arg3), true);
|
|
assert_eq!(dfg.ebb_params(ebb), &[arg3]);
|
|
dfg.swap_remove_ebb_param(arg3);
|
|
assert_eq!(dfg.value_is_attached(arg3), false);
|
|
assert_eq!(dfg.ebb_params(ebb), &[]);
|
|
}
|
|
|
|
#[test]
|
|
fn aliases() {
|
|
use ir::condcodes::IntCC;
|
|
use ir::InstBuilder;
|
|
|
|
let mut func = Function::new();
|
|
let ebb0 = func.dfg.make_ebb();
|
|
let mut pos = FuncCursor::new(&mut func);
|
|
pos.insert_ebb(ebb0);
|
|
|
|
// Build a little test program.
|
|
let v1 = pos.ins().iconst(types::I32, 42);
|
|
|
|
// Make sure we can resolve value aliases even when values is empty.
|
|
assert_eq!(pos.func.dfg.resolve_aliases(v1), v1);
|
|
|
|
let arg0 = pos.func.dfg.append_ebb_param(ebb0, types::I32);
|
|
let (s, c) = pos.ins().iadd_cout(v1, arg0);
|
|
let iadd = match pos.func.dfg.value_def(s) {
|
|
ValueDef::Result(i, 0) => i,
|
|
_ => panic!(),
|
|
};
|
|
|
|
// Remove `c` from the result list.
|
|
pos.func.dfg.clear_results(iadd);
|
|
pos.func.dfg.attach_result(iadd, s);
|
|
|
|
// Replace `iadd_cout` with a normal `iadd` and an `icmp`.
|
|
pos.func.dfg.replace(iadd).iadd(v1, arg0);
|
|
let c2 = pos.ins().icmp(IntCC::UnsignedLessThan, s, v1);
|
|
pos.func.dfg.change_to_alias(c, c2);
|
|
|
|
assert_eq!(pos.func.dfg.resolve_aliases(c2), c2);
|
|
assert_eq!(pos.func.dfg.resolve_aliases(c), c2);
|
|
|
|
// Make a copy of the alias.
|
|
let c3 = pos.ins().copy(c);
|
|
// This does not see through copies.
|
|
assert_eq!(pos.func.dfg.resolve_aliases(c3), c3);
|
|
}
|
|
}
|