From e4d42a1be4cd240937978f553c6689bff81661a7 Mon Sep 17 00:00:00 2001 From: bjorn3 Date: Sun, 31 Oct 2021 18:11:49 +0100 Subject: [PATCH] Move arg unpacking for all remaining expand functions to simple_legalize --- .../codegen/src/legalizer/globalvalue.rs | 19 ++------ cranelift/codegen/src/legalizer/heap.rs | 32 ++++++-------- cranelift/codegen/src/legalizer/mod.rs | 43 +++++++++---------- cranelift/codegen/src/legalizer/table.rs | 26 ----------- 4 files changed, 38 insertions(+), 82 deletions(-) diff --git a/cranelift/codegen/src/legalizer/globalvalue.rs b/cranelift/codegen/src/legalizer/globalvalue.rs index 28cf966172..50974a1d85 100644 --- a/cranelift/codegen/src/legalizer/globalvalue.rs +++ b/cranelift/codegen/src/legalizer/globalvalue.rs @@ -4,7 +4,6 @@ //! instruction into code that depends on the kind of global value referenced. use crate::cursor::{Cursor, FuncCursor}; -use crate::flowgraph::ControlFlowGraph; use crate::ir::{self, InstBuilder}; use crate::isa::TargetIsa; @@ -12,22 +11,10 @@ use crate::isa::TargetIsa; pub fn expand_global_value( inst: ir::Inst, func: &mut ir::Function, - _cfg: &mut ControlFlowGraph, isa: &dyn TargetIsa, + global_value: ir::GlobalValue, ) { - // Unpack the instruction. - let gv = match func.dfg[inst] { - ir::InstructionData::UnaryGlobalValue { - opcode, - global_value, - } => { - debug_assert_eq!(opcode, ir::Opcode::GlobalValue); - global_value - } - _ => panic!("Wanted global_value: {}", func.dfg.display_inst(inst)), - }; - - match func.global_values[gv] { + match func.global_values[global_value] { ir::GlobalValueData::VMContext => vmctx_addr(inst, func), ir::GlobalValueData::IAddImm { base, @@ -40,7 +27,7 @@ pub fn expand_global_value( global_type, readonly, } => load_addr(inst, func, base, offset, global_type, readonly, isa), - ir::GlobalValueData::Symbol { tls, .. } => symbol(inst, func, gv, isa, tls), + ir::GlobalValueData::Symbol { tls, .. } => symbol(inst, func, global_value, isa, tls), } } diff --git a/cranelift/codegen/src/legalizer/heap.rs b/cranelift/codegen/src/legalizer/heap.rs index f423632a6a..91ae3da3c7 100644 --- a/cranelift/codegen/src/legalizer/heap.rs +++ b/cranelift/codegen/src/legalizer/heap.rs @@ -6,6 +6,7 @@ use crate::cursor::{Cursor, FuncCursor}; use crate::flowgraph::ControlFlowGraph; use crate::ir::condcodes::IntCC; +use crate::ir::immediates::Uimm32; use crate::ir::{self, InstBuilder}; use crate::isa::TargetIsa; @@ -15,31 +16,26 @@ pub fn expand_heap_addr( func: &mut ir::Function, cfg: &mut ControlFlowGraph, isa: &dyn TargetIsa, + heap: ir::Heap, + offset: ir::Value, + access_size: Uimm32, ) { - // Unpack the instruction. - let (heap, offset, access_size) = match func.dfg[inst] { - ir::InstructionData::HeapAddr { - opcode, - heap, - arg, - imm, - } => { - debug_assert_eq!(opcode, ir::Opcode::HeapAddr); - (heap, arg, u64::from(imm)) - } - _ => panic!("Wanted heap_addr: {}", func.dfg.display_inst(inst)), - }; - match func.heaps[heap].style { - ir::HeapStyle::Dynamic { bound_gv } => { - dynamic_addr(isa, inst, heap, offset, access_size, bound_gv, func) - } + ir::HeapStyle::Dynamic { bound_gv } => dynamic_addr( + isa, + inst, + heap, + offset, + u64::from(access_size), + bound_gv, + func, + ), ir::HeapStyle::Static { bound } => static_addr( isa, inst, heap, offset, - access_size, + u64::from(access_size), bound.into(), func, cfg, diff --git a/cranelift/codegen/src/legalizer/mod.rs b/cranelift/codegen/src/legalizer/mod.rs index a186337c68..d0f39d3605 100644 --- a/cranelift/codegen/src/legalizer/mod.rs +++ b/cranelift/codegen/src/legalizer/mod.rs @@ -60,21 +60,25 @@ pub fn simple_legalize(func: &mut ir::Function, cfg: &mut ControlFlowGraph, isa: cfg.recompute_block(pos.func, old_block); } InstructionData::CondTrap { - opcode: ir::Opcode::Trapnz | ir::Opcode::Trapz | ir::Opcode::ResumableTrapnz, - .. + opcode: + opcode @ (ir::Opcode::Trapnz | ir::Opcode::Trapz | ir::Opcode::ResumableTrapnz), + arg, + code, } => { - expand_cond_trap(inst, &mut pos.func, cfg, isa); + expand_cond_trap(inst, &mut pos.func, cfg, opcode, arg, code); } // memory and constants InstructionData::UnaryGlobalValue { opcode: ir::Opcode::GlobalValue, - .. - } => expand_global_value(inst, &mut pos.func, cfg, isa), + global_value, + } => expand_global_value(inst, &mut pos.func, isa, global_value), InstructionData::HeapAddr { opcode: ir::Opcode::HeapAddr, - .. - } => expand_heap_addr(inst, &mut pos.func, cfg, isa), + heap, + arg, + imm, + } => expand_heap_addr(inst, &mut pos.func, cfg, isa, heap, arg, imm), InstructionData::StackLoad { opcode: ir::Opcode::StackLoad, stack_slot, @@ -113,8 +117,10 @@ pub fn simple_legalize(func: &mut ir::Function, cfg: &mut ControlFlowGraph, isa: } InstructionData::TableAddr { opcode: ir::Opcode::TableAddr, - .. - } => expand_table_addr(inst, &mut pos.func, cfg, isa), + table, + arg, + offset, + } => expand_table_addr(inst, &mut pos.func, table, arg, offset), // bitops InstructionData::BinaryImm64 { @@ -287,25 +293,18 @@ pub fn simple_legalize(func: &mut ir::Function, cfg: &mut ControlFlowGraph, isa: } /// Custom expansion for conditional trap instructions. -/// TODO: Add CFG support to the Rust DSL patterns so we won't have to do this. fn expand_cond_trap( inst: ir::Inst, func: &mut ir::Function, cfg: &mut ControlFlowGraph, - _isa: &dyn TargetIsa, + opcode: ir::Opcode, + arg: ir::Value, + code: ir::TrapCode, ) { // Parse the instruction. - let trapz; - let (arg, code, opcode) = match func.dfg[inst] { - ir::InstructionData::CondTrap { opcode, arg, code } => { - // We want to branch *over* an unconditional trap. - trapz = match opcode { - ir::Opcode::Trapz => true, - ir::Opcode::Trapnz | ir::Opcode::ResumableTrapnz => false, - _ => panic!("Expected cond trap: {}", func.dfg.display_inst(inst)), - }; - (arg, code, opcode) - } + let trapz = match opcode { + ir::Opcode::Trapz => true, + ir::Opcode::Trapnz | ir::Opcode::ResumableTrapnz => false, _ => panic!("Expected cond trap: {}", func.dfg.display_inst(inst)), }; diff --git a/cranelift/codegen/src/legalizer/table.rs b/cranelift/codegen/src/legalizer/table.rs index 14e653e944..2cefb91f25 100644 --- a/cranelift/codegen/src/legalizer/table.rs +++ b/cranelift/codegen/src/legalizer/table.rs @@ -4,43 +4,17 @@ //! instruction into code that depends on the kind of table referenced. use crate::cursor::{Cursor, FuncCursor}; -use crate::flowgraph::ControlFlowGraph; use crate::ir::condcodes::IntCC; use crate::ir::immediates::Offset32; use crate::ir::{self, InstBuilder}; -use crate::isa::TargetIsa; /// Expand a `table_addr` instruction according to the definition of the table. pub fn expand_table_addr( inst: ir::Inst, func: &mut ir::Function, - _cfg: &mut ControlFlowGraph, - _isa: &dyn TargetIsa, -) { - // Unpack the instruction. - let (table, index, element_offset) = match func.dfg[inst] { - ir::InstructionData::TableAddr { - opcode, - table, - arg, - offset, - } => { - debug_assert_eq!(opcode, ir::Opcode::TableAddr); - (table, arg, offset) - } - _ => panic!("Wanted table_addr: {}", func.dfg.display_inst(inst)), - }; - - dynamic_addr(inst, table, index, element_offset, func); -} - -/// Expand a `table_addr` for a dynamic table. -fn dynamic_addr( - inst: ir::Inst, table: ir::Table, index: ir::Value, element_offset: Offset32, - func: &mut ir::Function, ) { let bound_gv = func.tables[table].bound_gv; let index_ty = func.dfg.value_type(index);