832666c45e
* Manually rename BasicBlock to BlockPredecessor BasicBlock is a pair of (Ebb, Inst) that is used to represent the basic block subcomponent of an Ebb that is a predecessor to an Ebb. Eventually we will be able to remove this struct, but for now it makes sense to give it a non-conflicting name so that we can start to transition Ebb to represent a basic block. I have not updated any comments that refer to BasicBlock, as eventually we will remove BlockPredecessor and replace with Block, which is a basic block, so the comments will become correct. * Manually rename SSABuilder block types to avoid conflict SSABuilder has its own Block and BlockData types. These along with associated identifier will cause conflicts in a later commit, so they are renamed to be more verbose here. * Automatically rename 'Ebb' to 'Block' in *.rs * Automatically rename 'EBB' to 'block' in *.rs * Automatically rename 'ebb' to 'block' in *.rs * Automatically rename 'extended basic block' to 'basic block' in *.rs * Automatically rename 'an basic block' to 'a basic block' in *.rs * Manually update comment for `Block` `Block`'s wikipedia article required an update. * Automatically rename 'an `Block`' to 'a `Block`' in *.rs * Automatically rename 'extended_basic_block' to 'basic_block' in *.rs * Automatically rename 'ebb' to 'block' in *.clif * Manually rename clif constant that contains 'ebb' as substring to avoid conflict * Automatically rename filecheck uses of 'EBB' to 'BB' 'regex: EBB' -> 'regex: BB' '$EBB' -> '$BB' * Automatically rename 'EBB' 'Ebb' to 'block' in *.clif * Automatically rename 'an block' to 'a block' in *.clif * Fix broken testcase when function name length increases Test function names are limited to 16 characters. This causes the new longer name to be truncated and fail a filecheck test. An outdated comment was also fixed.
86 lines
3.5 KiB
Rust
86 lines
3.5 KiB
Rust
//! A NaN-canonicalizing rewriting pass. Patch floating point arithmetic
|
|
//! instructions that may return a NaN result with a sequence of operations
|
|
//! that will replace nondeterministic NaN's with a single canonical NaN value.
|
|
|
|
use crate::cursor::{Cursor, FuncCursor};
|
|
use crate::ir::condcodes::FloatCC;
|
|
use crate::ir::immediates::{Ieee32, Ieee64};
|
|
use crate::ir::types;
|
|
use crate::ir::types::Type;
|
|
use crate::ir::{Function, Inst, InstBuilder, InstructionData, Opcode, Value};
|
|
use crate::timing;
|
|
|
|
// Canonical 32-bit and 64-bit NaN values.
|
|
static CANON_32BIT_NAN: u32 = 0b01111111110000000000000000000000;
|
|
static CANON_64BIT_NAN: u64 = 0b0111111111111000000000000000000000000000000000000000000000000000;
|
|
|
|
/// Perform the NaN canonicalization pass.
|
|
pub fn do_nan_canonicalization(func: &mut Function) {
|
|
let _tt = timing::canonicalize_nans();
|
|
let mut pos = FuncCursor::new(func);
|
|
while let Some(_block) = pos.next_block() {
|
|
while let Some(inst) = pos.next_inst() {
|
|
if is_fp_arith(&mut pos, inst) {
|
|
add_nan_canon_seq(&mut pos, inst);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns true/false based on whether the instruction is a floating-point
|
|
/// arithmetic operation. This ignores operations like `fneg`, `fabs`, or
|
|
/// `fcopysign` that only operate on the sign bit of a floating point value.
|
|
fn is_fp_arith(pos: &mut FuncCursor, inst: Inst) -> bool {
|
|
match pos.func.dfg[inst] {
|
|
InstructionData::Unary { opcode, .. } => {
|
|
opcode == Opcode::Ceil
|
|
|| opcode == Opcode::Floor
|
|
|| opcode == Opcode::Nearest
|
|
|| opcode == Opcode::Sqrt
|
|
|| opcode == Opcode::Trunc
|
|
}
|
|
InstructionData::Binary { opcode, .. } => {
|
|
opcode == Opcode::Fadd
|
|
|| opcode == Opcode::Fdiv
|
|
|| opcode == Opcode::Fmax
|
|
|| opcode == Opcode::Fmin
|
|
|| opcode == Opcode::Fmul
|
|
|| opcode == Opcode::Fsub
|
|
}
|
|
InstructionData::Ternary { opcode, .. } => opcode == Opcode::Fma,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
/// Append a sequence of canonicalizing instructions after the given instruction.
|
|
fn add_nan_canon_seq(pos: &mut FuncCursor, inst: Inst) {
|
|
// Select the instruction result, result type. Replace the instruction
|
|
// result and step forward before inserting the canonicalization sequence.
|
|
let val = pos.func.dfg.first_result(inst);
|
|
let val_type = pos.func.dfg.value_type(val);
|
|
let new_res = pos.func.dfg.replace_result(val, val_type);
|
|
let _next_inst = pos.next_inst().expect("block missing terminator!");
|
|
|
|
// Insert a comparison instruction, to check if `inst_res` is NaN. Select
|
|
// the canonical NaN value if `val` is NaN, assign the result to `inst`.
|
|
let is_nan = pos.ins().fcmp(FloatCC::NotEqual, new_res, new_res);
|
|
let canon_nan = insert_nan_const(pos, val_type);
|
|
pos.ins()
|
|
.with_result(val)
|
|
.select(is_nan, canon_nan, new_res);
|
|
|
|
pos.prev_inst(); // Step backwards so the pass does not skip instructions.
|
|
}
|
|
|
|
/// Insert a canonical 32-bit or 64-bit NaN constant at the current position.
|
|
fn insert_nan_const(pos: &mut FuncCursor, nan_type: Type) -> Value {
|
|
match nan_type {
|
|
types::F32 => pos.ins().f32const(Ieee32::with_bits(CANON_32BIT_NAN)),
|
|
types::F64 => pos.ins().f64const(Ieee64::with_bits(CANON_64BIT_NAN)),
|
|
_ => {
|
|
// Panic if the type given was not an IEEE floating point type.
|
|
panic!("Could not canonicalize NaN: Unexpected result type found.");
|
|
}
|
|
}
|
|
}
|