From 05bf9ea3f362849f4659ba6d5d04e9a8c82c4527 Mon Sep 17 00:00:00 2001 From: Nick Fitzgerald Date: Thu, 6 Aug 2020 16:41:59 -0700 Subject: [PATCH] Rename "Stackmap" to "StackMap" And "stackmap" to "stack_map". This commit is purely mechanical. --- cranelift/codegen/meta/src/isa/x86/recipes.rs | 2 +- .../codegen/meta/src/shared/instructions.rs | 20 ++++---- cranelift/codegen/meta/src/shared/settings.rs | 2 +- cranelift/codegen/src/binemit/memorysink.rs | 28 +++++------ cranelift/codegen/src/binemit/mod.rs | 10 ++-- .../src/binemit/{stackmap.rs => stack_map.rs} | 19 ++++---- cranelift/codegen/src/context.rs | 16 +++++-- cranelift/codegen/src/inst_predicates.rs | 2 +- cranelift/codegen/src/isa/aarch64/abi.rs | 8 ++-- .../codegen/src/isa/aarch64/inst/emit.rs | 30 ++++++------ cranelift/codegen/src/isa/test_utils.rs | 2 +- cranelift/codegen/src/isa/x64/abi.rs | 8 ++-- cranelift/codegen/src/isa/x64/inst/emit.rs | 12 ++--- cranelift/codegen/src/isa/x64/inst/mod.rs | 18 ++++---- cranelift/codegen/src/machinst/abi.rs | 8 ++-- cranelift/codegen/src/machinst/buffer.rs | 46 +++++++++---------- cranelift/codegen/src/machinst/compile.rs | 10 ++-- cranelift/codegen/src/machinst/lower.rs | 4 +- cranelift/codegen/src/machinst/mod.rs | 4 +- cranelift/codegen/src/machinst/vcode.rs | 22 ++++----- cranelift/codegen/src/regalloc/context.rs | 4 +- cranelift/codegen/src/regalloc/mod.rs | 2 +- cranelift/codegen/src/regalloc/safepoint.rs | 4 +- cranelift/faerie/src/backend.rs | 16 +++---- .../{stackmaps => stack_maps}/call.clif | 2 +- .../incoming_args.clif | 3 +- cranelift/filetests/src/function_runner.rs | 6 +-- cranelift/filetests/src/lib.rs | 4 +- cranelift/filetests/src/test_binemit.rs | 2 +- cranelift/filetests/src/test_compile.rs | 2 +- cranelift/filetests/src/test_rodata.rs | 2 +- .../{test_stackmaps.rs => test_stack_maps.rs} | 21 +++++---- cranelift/object/src/backend.rs | 6 +-- cranelift/simplejit/src/backend.rs | 24 +++++----- cranelift/src/bugpoint.rs | 6 +-- cranelift/src/compile.rs | 8 ++-- cranelift/src/disasm.rs | 14 +++--- cranelift/src/wasm.rs | 8 ++-- crates/environ/src/compilation.rs | 2 +- crates/environ/src/cranelift.rs | 4 +- crates/environ/src/data_structures.rs | 2 +- crates/jit/src/trampoline.rs | 6 +-- crates/runtime/src/externref.rs | 6 +-- crates/wasmtime/src/trampoline/func.rs | 4 +- 44 files changed, 218 insertions(+), 211 deletions(-) mode change 100644 => 100755 cranelift/codegen/meta/src/shared/instructions.rs rename cranelift/codegen/src/binemit/{stackmap.rs => stack_map.rs} (93%) rename cranelift/filetests/filetests/{stackmaps => stack_maps}/call.clif (99%) rename cranelift/filetests/filetests/{stackmaps => stack_maps}/incoming_args.clif (97%) rename cranelift/filetests/src/{test_stackmaps.rs => test_stack_maps.rs} (84%) diff --git a/cranelift/codegen/meta/src/isa/x86/recipes.rs b/cranelift/codegen/meta/src/isa/x86/recipes.rs index 56c5e41c95..f45f8dc673 100644 --- a/cranelift/codegen/meta/src/isa/x86/recipes.rs +++ b/cranelift/codegen/meta/src/isa/x86/recipes.rs @@ -3334,7 +3334,7 @@ pub(crate) fn define<'shared>( recipes.add_recipe( EncodingRecipeBuilder::new("safepoint", &formats.multiary, 0).emit( r#" - sink.add_stackmap(args, func, isa); + sink.add_stack_map(args, func, isa); "#, ), ); diff --git a/cranelift/codegen/meta/src/shared/instructions.rs b/cranelift/codegen/meta/src/shared/instructions.rs old mode 100644 new mode 100755 index 93f80d498e..2c16734f27 --- a/cranelift/codegen/meta/src/shared/instructions.rs +++ b/cranelift/codegen/meta/src/shared/instructions.rs @@ -2071,7 +2071,7 @@ pub(crate) fn define( ); let N = - &Operand::new("args", &entities.varargs).with_doc("Variable number of args for Stackmap"); + &Operand::new("args", &entities.varargs).with_doc("Variable number of args for StackMap"); ig.push( Inst::new( @@ -3926,9 +3926,9 @@ pub(crate) fn define( Inst::new( "snarrow", r#" - Combine `x` and `y` into a vector with twice the lanes but half the integer width while + Combine `x` and `y` into a vector with twice the lanes but half the integer width while saturating overflowing values to the signed maximum and minimum. - + The lanes will be concatenated after narrowing. For example, when `x` and `y` are `i32x4` and `x = [x3, x2, x1, x0]` and `y = [y3, y2, y1, y0]`, then after narrowing the value returned is an `i16x8`: `a = [y3', y2', y1', y0', x3', x2', x1', x0']`. @@ -3943,12 +3943,12 @@ pub(crate) fn define( Inst::new( "unarrow", r#" - Combine `x` and `y` into a vector with twice the lanes but half the integer width while + Combine `x` and `y` into a vector with twice the lanes but half the integer width while saturating overflowing values to the unsigned maximum and minimum. - + Note that all input lanes are considered signed: any negative lanes will overflow and be replaced with the unsigned minimum, `0x00`. - + The lanes will be concatenated after narrowing. For example, when `x` and `y` are `i32x4` and `x = [x3, x2, x1, x0]` and `y = [y3, y2, y1, y0]`, then after narrowing the value returned is an `i16x8`: `a = [y3', y2', y1', y0', x3', x2', x1', x0']`. @@ -3977,7 +3977,7 @@ pub(crate) fn define( "swiden_low", r#" Widen the low lanes of `x` using signed extension. - + This will double the lane width and halve the number of lanes. "#, &formats.unary, @@ -3991,7 +3991,7 @@ pub(crate) fn define( "swiden_high", r#" Widen the high lanes of `x` using signed extension. - + This will double the lane width and halve the number of lanes. "#, &formats.unary, @@ -4005,7 +4005,7 @@ pub(crate) fn define( "uwiden_low", r#" Widen the low lanes of `x` using unsigned extension. - + This will double the lane width and halve the number of lanes. "#, &formats.unary, @@ -4019,7 +4019,7 @@ pub(crate) fn define( "uwiden_high", r#" Widen the high lanes of `x` using unsigned extension. - + This will double the lane width and halve the number of lanes. "#, &formats.unary, diff --git a/cranelift/codegen/meta/src/shared/settings.rs b/cranelift/codegen/meta/src/shared/settings.rs index 030fffc0a5..8a6e259101 100644 --- a/cranelift/codegen/meta/src/shared/settings.rs +++ b/cranelift/codegen/meta/src/shared/settings.rs @@ -157,7 +157,7 @@ pub(crate) fn define() -> SettingGroup { r#" Enable safepoint instruction insertions. - This will allow the emit_stackmaps() function to insert the safepoint + This will allow the emit_stack_maps() function to insert the safepoint instruction on top of calls and interrupt traps in order to display the live reference values at that point in the program. "#, diff --git a/cranelift/codegen/src/binemit/memorysink.rs b/cranelift/codegen/src/binemit/memorysink.rs index a8621924e2..151983933d 100644 --- a/cranelift/codegen/src/binemit/memorysink.rs +++ b/cranelift/codegen/src/binemit/memorysink.rs @@ -14,7 +14,7 @@ //! relocations to a `RelocSink` trait object. Relocations are less frequent than the //! `CodeSink::put*` methods, so the performance impact of the virtual callbacks is less severe. use super::{Addend, CodeInfo, CodeOffset, CodeSink, Reloc}; -use crate::binemit::stackmap::Stackmap; +use crate::binemit::stack_map::StackMap; use crate::ir::entities::Value; use crate::ir::{ConstantOffset, ExternalName, Function, JumpTable, Opcode, SourceLoc, TrapCode}; use crate::isa::TargetIsa; @@ -38,7 +38,7 @@ pub struct MemoryCodeSink<'a> { offset: isize, relocs: &'a mut dyn RelocSink, traps: &'a mut dyn TrapSink, - stackmaps: &'a mut dyn StackmapSink, + stack_maps: &'a mut dyn StackMapSink, /// Information about the generated code and read-only data. pub info: CodeInfo, } @@ -54,7 +54,7 @@ impl<'a> MemoryCodeSink<'a> { data: *mut u8, relocs: &'a mut dyn RelocSink, traps: &'a mut dyn TrapSink, - stackmaps: &'a mut dyn StackmapSink, + stack_maps: &'a mut dyn StackMapSink, ) -> Self { Self { data, @@ -67,7 +67,7 @@ impl<'a> MemoryCodeSink<'a> { }, relocs, traps, - stackmaps, + stack_maps, } } } @@ -182,10 +182,10 @@ impl<'a> CodeSink for MemoryCodeSink<'a> { self.info.total_size = self.offset(); } - fn add_stackmap(&mut self, val_list: &[Value], func: &Function, isa: &dyn TargetIsa) { + fn add_stack_map(&mut self, val_list: &[Value], func: &Function, isa: &dyn TargetIsa) { let ofs = self.offset(); - let stackmap = Stackmap::from_values(&val_list, func, isa); - self.stackmaps.add_stackmap(ofs, stackmap); + let stack_map = StackMap::from_values(&val_list, func, isa); + self.stack_maps.add_stack_map(ofs, stack_map); } fn add_call_site(&mut self, opcode: Opcode, loc: SourceLoc) { @@ -227,15 +227,15 @@ impl TrapSink for NullTrapSink { fn trap(&mut self, _offset: CodeOffset, _srcloc: SourceLoc, _code: TrapCode) {} } -/// A trait for emitting stackmaps. -pub trait StackmapSink { +/// A trait for emitting stack maps. +pub trait StackMapSink { /// Output a bitmap of the stack representing the live reference variables at this code offset. - fn add_stackmap(&mut self, _: CodeOffset, _: Stackmap); + fn add_stack_map(&mut self, _: CodeOffset, _: StackMap); } -/// Placeholder StackmapSink that does nothing. -pub struct NullStackmapSink {} +/// Placeholder StackMapSink that does nothing. +pub struct NullStackMapSink {} -impl StackmapSink for NullStackmapSink { - fn add_stackmap(&mut self, _: CodeOffset, _: Stackmap) {} +impl StackMapSink for NullStackMapSink { + fn add_stack_map(&mut self, _: CodeOffset, _: StackMap) {} } diff --git a/cranelift/codegen/src/binemit/mod.rs b/cranelift/codegen/src/binemit/mod.rs index 4cec5f801d..ae26f7f14e 100644 --- a/cranelift/codegen/src/binemit/mod.rs +++ b/cranelift/codegen/src/binemit/mod.rs @@ -6,15 +6,15 @@ mod memorysink; mod relaxation; mod shrink; -mod stackmap; +mod stack_map; pub use self::memorysink::{ - MemoryCodeSink, NullRelocSink, NullStackmapSink, NullTrapSink, RelocSink, StackmapSink, + MemoryCodeSink, NullRelocSink, NullStackMapSink, NullTrapSink, RelocSink, StackMapSink, TrapSink, }; pub use self::relaxation::relax_branches; pub use self::shrink::shrink_instructions; -pub use self::stackmap::Stackmap; +pub use self::stack_map::StackMap; use crate::ir::entities::Value; use crate::ir::{ ConstantOffset, ExternalName, Function, Inst, JumpTable, Opcode, SourceLoc, TrapCode, @@ -164,8 +164,8 @@ pub trait CodeSink { /// Read-only data output is complete, we're done. fn end_codegen(&mut self); - /// Add a stackmap at the current code offset. - fn add_stackmap(&mut self, _: &[Value], _: &Function, _: &dyn TargetIsa); + /// Add a stack map at the current code offset. + fn add_stack_map(&mut self, _: &[Value], _: &Function, _: &dyn TargetIsa); /// Add a call site for a call with the given opcode, returning at the current offset. fn add_call_site(&mut self, _: Opcode, _: SourceLoc) { diff --git a/cranelift/codegen/src/binemit/stackmap.rs b/cranelift/codegen/src/binemit/stack_map.rs similarity index 93% rename from cranelift/codegen/src/binemit/stackmap.rs rename to cranelift/codegen/src/binemit/stack_map.rs index 45716dcae0..c3055a0154 100644 --- a/cranelift/codegen/src/binemit/stackmap.rs +++ b/cranelift/codegen/src/binemit/stack_map.rs @@ -59,7 +59,7 @@ const NUM_BITS: usize = core::mem::size_of::() * 8; /// | ... | /// ``` /// -/// An individual `Stackmap` is associated with just one instruction pointer +/// An individual `StackMap` is associated with just one instruction pointer /// within the function, contains the size of the stack frame, and represents /// the stack frame as a bitmap. There is one bit per word in the stack frame, /// and if the bit is set, then the word contains a live GC reference. @@ -70,13 +70,14 @@ const NUM_BITS: usize = core::mem::size_of::() * 8; /// callee's stack map. #[derive(Clone, Debug, PartialEq, Eq)] #[cfg_attr(feature = "enable-serde", derive(serde::Deserialize, serde::Serialize))] -pub struct Stackmap { +pub struct StackMap { bitmap: Vec>, mapped_words: u32, } -impl Stackmap { - /// Create a stackmap based on where references are located on a function's stack. +impl StackMap { + /// Create a `StackMap` based on where references are located on a + /// function's stack. pub fn from_values( args: &[ir::entities::Value], func: &ir::Function, @@ -101,7 +102,7 @@ impl Stackmap { let stack = &func.stack_slots; let info = func.stack_slots.layout_info.unwrap(); - // Refer to the doc comment for `Stackmap` above to understand the + // Refer to the doc comment for `StackMap` above to understand the // bitmap representation used here. let map_size = (info.frame_size + info.inbound_args_size) as usize; let word_size = isa.pointer_bytes() as usize; @@ -171,9 +172,9 @@ mod tests { use super::*; #[test] - fn stackmaps() { + fn stack_maps() { let vec: Vec = Vec::new(); - assert!(Stackmap::from_slice(&vec).bitmap.is_empty()); + assert!(StackMap::from_slice(&vec).bitmap.is_empty()); let mut vec: [bool; NUM_BITS] = Default::default(); let set_true_idx = [5, 7, 24, 31]; @@ -185,12 +186,12 @@ mod tests { let mut vec = vec.to_vec(); assert_eq!( vec![BitSet::(2164261024)], - Stackmap::from_slice(&vec).bitmap + StackMap::from_slice(&vec).bitmap ); vec.push(false); vec.push(true); - let res = Stackmap::from_slice(&vec); + let res = StackMap::from_slice(&vec); assert_eq!( vec![BitSet::(2164261024), BitSet::(2)], res.bitmap diff --git a/cranelift/codegen/src/context.rs b/cranelift/codegen/src/context.rs index e5d11c6963..3d2595f270 100644 --- a/cranelift/codegen/src/context.rs +++ b/cranelift/codegen/src/context.rs @@ -10,7 +10,7 @@ //! single ISA instance. use crate::binemit::{ - relax_branches, shrink_instructions, CodeInfo, MemoryCodeSink, RelocSink, StackmapSink, + relax_branches, shrink_instructions, CodeInfo, MemoryCodeSink, RelocSink, StackMapSink, TrapSink, }; use crate::dce::do_dce; @@ -127,13 +127,19 @@ impl Context { mem: &mut Vec, relocs: &mut dyn RelocSink, traps: &mut dyn TrapSink, - stackmaps: &mut dyn StackmapSink, + stack_maps: &mut dyn StackMapSink, ) -> CodegenResult { let info = self.compile(isa)?; let old_len = mem.len(); mem.resize(old_len + info.total_size as usize, 0); let new_info = unsafe { - self.emit_to_memory(isa, mem.as_mut_ptr().add(old_len), relocs, traps, stackmaps) + self.emit_to_memory( + isa, + mem.as_mut_ptr().add(old_len), + relocs, + traps, + stack_maps, + ) }; debug_assert!(new_info == info); Ok(info) @@ -222,10 +228,10 @@ impl Context { mem: *mut u8, relocs: &mut dyn RelocSink, traps: &mut dyn TrapSink, - stackmaps: &mut dyn StackmapSink, + stack_maps: &mut dyn StackMapSink, ) -> CodeInfo { let _tt = timing::binemit(); - let mut sink = MemoryCodeSink::new(mem, relocs, traps, stackmaps); + let mut sink = MemoryCodeSink::new(mem, relocs, traps, stack_maps); if let Some(ref result) = &self.mach_compile_result { result.buffer.emit(&mut sink); } else { diff --git a/cranelift/codegen/src/inst_predicates.rs b/cranelift/codegen/src/inst_predicates.rs index 0ee2eb7c1f..9afe2ff6e1 100644 --- a/cranelift/codegen/src/inst_predicates.rs +++ b/cranelift/codegen/src/inst_predicates.rs @@ -63,7 +63,7 @@ pub fn is_constant_64bit(func: &Function, inst: Inst) -> Option { } /// Is the given instruction a safepoint (i.e., potentially causes a GC, depending on the -/// embedding, and so requires reftyped values to be enumerated with a stackmap)? +/// embedding, and so requires reftyped values to be enumerated with a stack map)? pub fn is_safepoint(func: &Function, inst: Inst) -> bool { let op = func.dfg[inst].opcode(); op.is_resumable_trap() || op.is_call() diff --git a/cranelift/codegen/src/isa/aarch64/abi.rs b/cranelift/codegen/src/isa/aarch64/abi.rs index 06f0514721..06fb9c5793 100644 --- a/cranelift/codegen/src/isa/aarch64/abi.rs +++ b/cranelift/codegen/src/isa/aarch64/abi.rs @@ -90,7 +90,7 @@ //! - Return v1 in memory at `[P+8]`. //! - Return v0 in memory at `[P+16]`. -use crate::binemit::Stackmap; +use crate::binemit::StackMap; use crate::ir; use crate::ir::types; use crate::ir::types::*; @@ -1074,10 +1074,10 @@ impl ABIBody for AArch64ABIBody { store_stack(MemArg::NominalSPOffset(sp_off, ty), from_reg, ty) } - fn spillslots_to_stackmap(&self, slots: &[SpillSlot], state: &EmitState) -> Stackmap { + fn spillslots_to_stack_map(&self, slots: &[SpillSlot], state: &EmitState) -> StackMap { assert!(state.virtual_sp_offset >= 0); trace!( - "spillslots_to_stackmap: slots = {:?}, state = {:?}", + "spillslots_to_stack_map: slots = {:?}, state = {:?}", slots, state ); @@ -1094,7 +1094,7 @@ impl ABIBody for AArch64ABIBody { bits[first_spillslot_word + slot] = true; } - Stackmap::from_slice(&bits[..]) + StackMap::from_slice(&bits[..]) } fn gen_prologue(&mut self) -> Vec { diff --git a/cranelift/codegen/src/isa/aarch64/inst/emit.rs b/cranelift/codegen/src/isa/aarch64/inst/emit.rs index 310db6ea68..9349f63bec 100644 --- a/cranelift/codegen/src/isa/aarch64/inst/emit.rs +++ b/cranelift/codegen/src/isa/aarch64/inst/emit.rs @@ -1,6 +1,6 @@ //! AArch64 ISA: binary code emission. -use crate::binemit::{CodeOffset, Reloc, Stackmap}; +use crate::binemit::{CodeOffset, Reloc, StackMap}; use crate::ir::constant::ConstantData; use crate::ir::types::*; use crate::ir::TrapCode; @@ -429,8 +429,8 @@ pub struct EmitState { pub(crate) virtual_sp_offset: i64, /// Offset of FP from nominal-SP. pub(crate) nominal_sp_to_fp: i64, - /// Safepoint stackmap for upcoming instruction, as provided to `pre_safepoint()`. - stackmap: Option, + /// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`. + stack_map: Option, } impl MachInstEmitState for EmitState { @@ -438,22 +438,22 @@ impl MachInstEmitState for EmitState { EmitState { virtual_sp_offset: 0, nominal_sp_to_fp: abi.frame_size() as i64, - stackmap: None, + stack_map: None, } } - fn pre_safepoint(&mut self, stackmap: Stackmap) { - self.stackmap = Some(stackmap); + fn pre_safepoint(&mut self, stack_map: StackMap) { + self.stack_map = Some(stack_map); } } impl EmitState { - fn take_stackmap(&mut self) -> Option { - self.stackmap.take() + fn take_stack_map(&mut self) -> Option { + self.stack_map.take() } fn clear_post_insn(&mut self) { - self.stackmap = None; + self.stack_map = None; } } @@ -1854,8 +1854,8 @@ impl MachInstEmit for Inst { // Noop; this is just a placeholder for epilogues. } &Inst::Call { ref info } => { - if let Some(s) = state.take_stackmap() { - sink.add_stackmap(StackmapExtent::UpcomingBytes(4), s); + if let Some(s) = state.take_stack_map() { + sink.add_stack_map(StackMapExtent::UpcomingBytes(4), s); } sink.add_reloc(info.loc, Reloc::Arm64Call, &info.dest, 0); sink.put4(enc_jump26(0b100101, 0)); @@ -1864,8 +1864,8 @@ impl MachInstEmit for Inst { } } &Inst::CallInd { ref info } => { - if let Some(s) = state.take_stackmap() { - sink.add_stackmap(StackmapExtent::UpcomingBytes(4), s); + if let Some(s) = state.take_stack_map() { + sink.add_stack_map(StackMapExtent::UpcomingBytes(4), s); } sink.put4(0b1101011_0001_11111_000000_00000_00000 | (machreg_to_gpr(info.rn) << 5)); if info.opcode.is_call() { @@ -1922,8 +1922,8 @@ impl MachInstEmit for Inst { &Inst::Udf { trap_info } => { let (srcloc, code) = trap_info; sink.add_trap(srcloc, code); - if let Some(s) = state.take_stackmap() { - sink.add_stackmap(StackmapExtent::UpcomingBytes(4), s); + if let Some(s) = state.take_stack_map() { + sink.add_stack_map(StackMapExtent::UpcomingBytes(4), s); } sink.put4(0xd4a00000); } diff --git a/cranelift/codegen/src/isa/test_utils.rs b/cranelift/codegen/src/isa/test_utils.rs index c7802b052a..77ce94fd4b 100644 --- a/cranelift/codegen/src/isa/test_utils.rs +++ b/cranelift/codegen/src/isa/test_utils.rs @@ -82,7 +82,7 @@ impl CodeSink for TestCodeSink { fn end_codegen(&mut self) {} - fn add_stackmap(&mut self, _val_list: &[Value], _func: &Function, _isa: &dyn TargetIsa) {} + fn add_stack_map(&mut self, _val_list: &[Value], _func: &Function, _isa: &dyn TargetIsa) {} fn add_call_site(&mut self, _opcode: Opcode, _srcloc: SourceLoc) {} } diff --git a/cranelift/codegen/src/isa/x64/abi.rs b/cranelift/codegen/src/isa/x64/abi.rs index 6013063ad0..4bc22357fd 100644 --- a/cranelift/codegen/src/isa/x64/abi.rs +++ b/cranelift/codegen/src/isa/x64/abi.rs @@ -1,6 +1,6 @@ //! Implementation of the standard x64 ABI. -use crate::binemit::Stackmap; +use crate::binemit::StackMap; use crate::ir::{self, types, ArgumentExtension, StackSlot, Type}; use crate::isa::{x64::inst::*, CallConv}; use crate::machinst::*; @@ -492,10 +492,10 @@ impl ABIBody for X64ABIBody { ) } - fn spillslots_to_stackmap(&self, slots: &[SpillSlot], state: &EmitState) -> Stackmap { + fn spillslots_to_stack_map(&self, slots: &[SpillSlot], state: &EmitState) -> StackMap { assert!(state.virtual_sp_offset >= 0); trace!( - "spillslots_to_stackmap: slots = {:?}, state = {:?}", + "spillslots_to_stack_map: slots = {:?}, state = {:?}", slots, state ); @@ -511,7 +511,7 @@ impl ABIBody for X64ABIBody { bits[first_spillslot_word + slot] = true; } - Stackmap::from_slice(&bits[..]) + StackMap::from_slice(&bits[..]) } fn gen_prologue(&mut self) -> Vec { diff --git a/cranelift/codegen/src/isa/x64/inst/emit.rs b/cranelift/codegen/src/isa/x64/inst/emit.rs index 1aa5b1b1a7..93fb996ef2 100644 --- a/cranelift/codegen/src/isa/x64/inst/emit.rs +++ b/cranelift/codegen/src/isa/x64/inst/emit.rs @@ -1349,8 +1349,8 @@ pub(crate) fn emit( Inst::CallKnown { dest, loc, opcode, .. } => { - if let Some(s) = state.take_stackmap() { - sink.add_stackmap(StackmapExtent::UpcomingBytes(5), s); + if let Some(s) = state.take_stack_map() { + sink.add_stack_map(StackMapExtent::UpcomingBytes(5), s); } sink.put1(0xE8); // The addend adjusts for the difference between the end of the instruction and the @@ -1393,8 +1393,8 @@ pub(crate) fn emit( ); } } - if let Some(s) = state.take_stackmap() { - sink.add_stackmap(StackmapExtent::StartedAtOffset(start_offset), s); + if let Some(s) = state.take_stack_map() { + sink.add_stack_map(StackMapExtent::StartedAtOffset(start_offset), s); } if opcode.is_call() { sink.add_call_site(*loc, *opcode); @@ -2428,8 +2428,8 @@ pub(crate) fn emit( Inst::Ud2 { trap_info } => { sink.add_trap(trap_info.0, trap_info.1); - if let Some(s) = state.take_stackmap() { - sink.add_stackmap(StackmapExtent::UpcomingBytes(2), s); + if let Some(s) = state.take_stack_map() { + sink.add_stack_map(StackMapExtent::UpcomingBytes(2), s); } sink.put1(0x0f); sink.put1(0x0b); diff --git a/cranelift/codegen/src/isa/x64/inst/mod.rs b/cranelift/codegen/src/isa/x64/inst/mod.rs index d0c9156671..145831c01e 100644 --- a/cranelift/codegen/src/isa/x64/inst/mod.rs +++ b/cranelift/codegen/src/isa/x64/inst/mod.rs @@ -4,7 +4,7 @@ #![allow(non_snake_case)] #![allow(non_camel_case_types)] -use crate::binemit::{CodeOffset, Stackmap}; +use crate::binemit::{CodeOffset, StackMap}; use crate::ir::{types, ExternalName, Opcode, SourceLoc, TrapCode, Type}; use crate::machinst::*; use crate::{settings, settings::Flags, CodegenError, CodegenResult}; @@ -2225,8 +2225,8 @@ pub struct EmitState { pub(crate) virtual_sp_offset: i64, /// Offset of FP from nominal-SP. pub(crate) nominal_sp_to_fp: i64, - /// Safepoint stackmap for upcoming instruction, as provided to `pre_safepoint()`. - stackmap: Option, + /// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`. + stack_map: Option, } impl MachInstEmit for Inst { @@ -2246,22 +2246,22 @@ impl MachInstEmitState for EmitState { EmitState { virtual_sp_offset: 0, nominal_sp_to_fp: abi.frame_size() as i64, - stackmap: None, + stack_map: None, } } - fn pre_safepoint(&mut self, stackmap: Stackmap) { - self.stackmap = Some(stackmap); + fn pre_safepoint(&mut self, stack_map: StackMap) { + self.stack_map = Some(stack_map); } } impl EmitState { - fn take_stackmap(&mut self) -> Option { - self.stackmap.take() + fn take_stack_map(&mut self) -> Option { + self.stack_map.take() } fn clear_post_insn(&mut self) { - self.stackmap = None; + self.stack_map = None; } } diff --git a/cranelift/codegen/src/machinst/abi.rs b/cranelift/codegen/src/machinst/abi.rs index 39b9084b5a..7f44941959 100644 --- a/cranelift/codegen/src/machinst/abi.rs +++ b/cranelift/codegen/src/machinst/abi.rs @@ -1,6 +1,6 @@ //! ABI definitions. -use crate::binemit::Stackmap; +use crate::binemit::StackMap; use crate::ir::StackSlot; use crate::machinst::*; use crate::settings; @@ -96,14 +96,14 @@ pub trait ABIBody { /// Store to a spillslot. fn store_spillslot(&self, slot: SpillSlot, ty: Type, from_reg: Reg) -> Self::I; - /// Generate a stackmap, given a list of spillslots and the emission state + /// Generate a stack map, given a list of spillslots and the emission state /// at a given program point (prior to emission fo the safepointing /// instruction). - fn spillslots_to_stackmap( + fn spillslots_to_stack_map( &self, slots: &[SpillSlot], state: &::State, - ) -> Stackmap; + ) -> StackMap; /// Generate a prologue, post-regalloc. This should include any stack /// frame or other setup necessary to use the other methods (`load_arg`, diff --git a/cranelift/codegen/src/machinst/buffer.rs b/cranelift/codegen/src/machinst/buffer.rs index af118508f7..ec9f296402 100644 --- a/cranelift/codegen/src/machinst/buffer.rs +++ b/cranelift/codegen/src/machinst/buffer.rs @@ -140,7 +140,7 @@ //! Given these invariants, we argue why each optimization preserves execution //! semantics below (grep for "Preserves execution semantics"). -use crate::binemit::{Addend, CodeOffset, CodeSink, Reloc, Stackmap}; +use crate::binemit::{Addend, CodeOffset, CodeSink, Reloc, StackMap}; use crate::ir::{ExternalName, Opcode, SourceLoc, TrapCode}; use crate::machinst::{BlockIndex, MachInstLabelUse, VCodeInst}; use crate::timing; @@ -169,8 +169,8 @@ pub struct MachBuffer { call_sites: SmallVec<[MachCallSite; 16]>, /// Any source location mappings referring to this code. srclocs: SmallVec<[MachSrcLoc; 64]>, - /// Any stackmaps referring to this code. - stackmaps: SmallVec<[MachStackMap; 8]>, + /// Any stack maps referring to this code. + stack_maps: SmallVec<[MachStackMap; 8]>, /// The current source location in progress (after `start_srcloc()` and /// before `end_srcloc()`). This is a (start_offset, src_loc) tuple. cur_srcloc: Option<(CodeOffset, SourceLoc)>, @@ -234,8 +234,8 @@ pub struct MachBufferFinalized { call_sites: SmallVec<[MachCallSite; 16]>, /// Any source location mappings referring to this code. srclocs: SmallVec<[MachSrcLoc; 64]>, - /// Any stackmaps referring to this code. - stackmaps: SmallVec<[MachStackMap; 8]>, + /// Any stack maps referring to this code. + stack_maps: SmallVec<[MachStackMap; 8]>, } static UNKNOWN_LABEL_OFFSET: CodeOffset = 0xffff_ffff; @@ -261,8 +261,8 @@ impl MachLabel { } } -/// A stackmap extent, when creating a stackmap. -pub enum StackmapExtent { +/// A stack map extent, when creating a stack map. +pub enum StackMapExtent { /// The stack map starts at this instruction, and ends after the number of upcoming bytes /// (note: this is a code offset diff). UpcomingBytes(CodeOffset), @@ -282,7 +282,7 @@ impl MachBuffer { traps: SmallVec::new(), call_sites: SmallVec::new(), srclocs: SmallVec::new(), - stackmaps: SmallVec::new(), + stack_maps: SmallVec::new(), cur_srcloc: None, label_offsets: SmallVec::new(), label_aliases: SmallVec::new(), @@ -1151,7 +1151,7 @@ impl MachBuffer { traps: self.traps, call_sites: self.call_sites, srclocs: self.srclocs, - stackmaps: self.stackmaps, + stack_maps: self.stack_maps, } } @@ -1212,28 +1212,28 @@ impl MachBuffer { } } - /// Add stackmap metadata for this program point: a set of stack offsets (from SP upward) that - /// contain live references. + /// Add stack map metadata for this program point: a set of stack offsets + /// (from SP upward) that contain live references. /// /// The `offset_to_fp` value is the offset from the nominal SP (at which the `stack_offsets` /// are based) and the FP value. By subtracting `offset_to_fp` from each `stack_offsets` /// element, one can obtain live-reference offsets from FP instead. - pub fn add_stackmap(&mut self, extent: StackmapExtent, stackmap: Stackmap) { + pub fn add_stack_map(&mut self, extent: StackMapExtent, stack_map: StackMap) { let (start, end) = match extent { - StackmapExtent::UpcomingBytes(insn_len) => { + StackMapExtent::UpcomingBytes(insn_len) => { let start_offset = self.cur_offset(); (start_offset, start_offset + insn_len) } - StackmapExtent::StartedAtOffset(start_offset) => { + StackMapExtent::StartedAtOffset(start_offset) => { let end_offset = self.cur_offset(); debug_assert!(end_offset >= start_offset); (start_offset, end_offset) } }; - self.stackmaps.push(MachStackMap { + self.stack_maps.push(MachStackMap { offset: start, offset_end: end, - stackmap, + stack_map, }); } } @@ -1295,9 +1295,9 @@ impl MachBufferFinalized { sink.end_codegen(); } - /// Get the stackmap metadata for this code. - pub fn stackmaps(&self) -> &[MachStackMap] { - &self.stackmaps[..] + /// Get the stack map metadata for this code. + pub fn stack_maps(&self) -> &[MachStackMap] { + &self.stack_maps[..] } } @@ -1378,17 +1378,17 @@ pub struct MachSrcLoc { pub loc: SourceLoc, } -/// Record of stackmap metadata: stack offsets containing references. +/// Record of stack map metadata: stack offsets containing references. #[derive(Clone, Debug)] pub struct MachStackMap { - /// The code offset at which this stackmap applies. + /// The code offset at which this stack map applies. pub offset: CodeOffset, /// The code offset just past the "end" of the instruction: that is, the /// offset of the first byte of the following instruction, or equivalently, /// the start offset plus the instruction length. pub offset_end: CodeOffset, - /// The Stackmap itself. - pub stackmap: Stackmap, + /// The stack map itself. + pub stack_map: StackMap, } /// Record of branch instruction in the buffer, to facilitate editing. diff --git a/cranelift/codegen/src/machinst/compile.rs b/cranelift/codegen/src/machinst/compile.rs index 4c24a98404..7d2d896b25 100644 --- a/cranelift/codegen/src/machinst/compile.rs +++ b/cranelift/codegen/src/machinst/compile.rs @@ -23,7 +23,7 @@ where // Build the lowering context. let lower = Lower::new(f, abi, block_order)?; // Lower the IR. - let (mut vcode, stackmap_request_info) = { + let (mut vcode, stack_map_request_info) = { let _tt = timing::vcode_lower(); lower.lower(b)? }; @@ -62,11 +62,11 @@ where // If either there are no reference-typed values, or else there are // but there are no safepoints at which we need to know about them, - // then we don't need stackmaps. - let sri = if stackmap_request_info.reftyped_vregs.len() > 0 - && stackmap_request_info.safepoint_insns.len() > 0 + // then we don't need stack maps. + let sri = if stack_map_request_info.reftyped_vregs.len() > 0 + && stack_map_request_info.safepoint_insns.len() > 0 { - Some(&stackmap_request_info) + Some(&stack_map_request_info) } else { None }; diff --git a/cranelift/codegen/src/machinst/lower.rs b/cranelift/codegen/src/machinst/lower.rs index 08dffacc00..c4cbbd820d 100644 --- a/cranelift/codegen/src/machinst/lower.rs +++ b/cranelift/codegen/src/machinst/lower.rs @@ -778,10 +778,10 @@ impl<'func, I: VCodeInst> Lower<'func, I> { self.copy_bbs_to_vcode(); // Now that we've emitted all instructions into the VCodeBuilder, let's build the VCode. - let (vcode, stackmap_info) = self.vcode.build(); + let (vcode, stack_map_info) = self.vcode.build(); debug!("built vcode: {:?}", vcode); - Ok((vcode, stackmap_info)) + Ok((vcode, stack_map_info)) } /// Get the actual inputs for a value. This is the implementation for diff --git a/cranelift/codegen/src/machinst/mod.rs b/cranelift/codegen/src/machinst/mod.rs index 0383ff12f6..7d14be82d2 100644 --- a/cranelift/codegen/src/machinst/mod.rs +++ b/cranelift/codegen/src/machinst/mod.rs @@ -96,7 +96,7 @@ //! //! ``` -use crate::binemit::{CodeInfo, CodeOffset, Stackmap}; +use crate::binemit::{CodeInfo, CodeOffset, StackMap}; use crate::ir::condcodes::IntCC; use crate::ir::{Function, Type}; use crate::result::CodegenResult; @@ -279,7 +279,7 @@ pub trait MachInstEmitState: Default + Clone + Debug { fn new(abi: &dyn ABIBody) -> Self; /// Update the emission state before emitting an instruction that is a /// safepoint. - fn pre_safepoint(&mut self, _stackmap: Stackmap) {} + fn pre_safepoint(&mut self, _stack_map: StackMap) {} } /// The result of a `MachBackend::compile_function()` call. Contains machine diff --git a/cranelift/codegen/src/machinst/vcode.rs b/cranelift/codegen/src/machinst/vcode.rs index ddf75cdba2..9e8b1b21e0 100644 --- a/cranelift/codegen/src/machinst/vcode.rs +++ b/cranelift/codegen/src/machinst/vcode.rs @@ -94,7 +94,7 @@ pub struct VCode { safepoint_insns: Vec, /// For each safepoint entry in `safepoint_insns`, a list of `SpillSlot`s. - /// These are used to generate actual stackmaps at emission. Filled in + /// These are used to generate actual stack maps at emission. Filled in /// post-regalloc. safepoint_slots: Vec>, } @@ -117,8 +117,8 @@ pub struct VCodeBuilder { /// In-progress VCode. vcode: VCode, - /// In-progress stackmap-request info. - stackmap_info: StackmapRequestInfo, + /// In-progress stack map-request info. + stack_map_info: StackmapRequestInfo, /// Index of the last block-start in the vcode. block_start: InsnIndex, @@ -135,7 +135,7 @@ impl VCodeBuilder { pub fn new(abi: Box>, block_order: BlockLoweringOrder) -> VCodeBuilder { let reftype_class = I::ref_type_regclass(abi.flags()); let vcode = VCode::new(abi, block_order); - let stackmap_info = StackmapRequestInfo { + let stack_map_info = StackmapRequestInfo { reftype_class, reftyped_vregs: vec![], safepoint_insns: vec![], @@ -143,7 +143,7 @@ impl VCodeBuilder { VCodeBuilder { vcode, - stackmap_info, + stack_map_info, block_start: 0, succ_start: 0, cur_srcloc: SourceLoc::default(), @@ -169,7 +169,7 @@ impl VCodeBuilder { } self.vcode.vreg_types[vreg.get_index()] = ty; if is_reftype(ty) { - self.stackmap_info.reftyped_vregs.push(vreg); + self.stack_map_info.reftyped_vregs.push(vreg); self.vcode.have_ref_values = true; } } @@ -222,7 +222,7 @@ impl VCodeBuilder { self.vcode.insts.push(insn); self.vcode.srclocs.push(self.cur_srcloc); if is_safepoint { - self.stackmap_info + self.stack_map_info .safepoint_insns .push(InstIx::new((self.vcode.insts.len() - 1) as u32)); } @@ -239,12 +239,12 @@ impl VCodeBuilder { } /// Build the final VCode, returning the vcode itself as well as auxiliary - /// information, such as the stackmap request information. + /// information, such as the stack map request information. pub fn build(self) -> (VCode, StackmapRequestInfo) { // TODO: come up with an abstraction for "vcode and auxiliary data". The // auxiliary data needs to be separate from the vcode so that it can be // referenced as the vcode is mutated (e.g. by the register allocator). - (self.vcode, self.stackmap_info) + (self.vcode, self.stack_map_info) } } @@ -460,11 +460,11 @@ impl VCode { && self.safepoint_insns[safepoint_idx] == iix { if self.safepoint_slots[safepoint_idx].len() > 0 { - let stackmap = self.abi.spillslots_to_stackmap( + let stack_map = self.abi.spillslots_to_stack_map( &self.safepoint_slots[safepoint_idx][..], &state, ); - state.pre_safepoint(stackmap); + state.pre_safepoint(stack_map); } safepoint_idx += 1; } diff --git a/cranelift/codegen/src/regalloc/context.rs b/cranelift/codegen/src/regalloc/context.rs index dfbec985eb..8aa1003d42 100644 --- a/cranelift/codegen/src/regalloc/context.rs +++ b/cranelift/codegen/src/regalloc/context.rs @@ -14,7 +14,7 @@ use crate::regalloc::coloring::Coloring; use crate::regalloc::live_value_tracker::LiveValueTracker; use crate::regalloc::liveness::Liveness; use crate::regalloc::reload::Reload; -use crate::regalloc::safepoint::emit_stackmaps; +use crate::regalloc::safepoint::emit_stack_maps; use crate::regalloc::spilling::Spilling; use crate::regalloc::virtregs::VirtRegs; use crate::result::CodegenResult; @@ -206,7 +206,7 @@ impl Context { // This function runs after register allocation has taken // place, meaning values have locations assigned already. if isa.flags().enable_safepoints() { - emit_stackmaps(func, domtree, &self.liveness, &mut self.tracker, isa); + emit_stack_maps(func, domtree, &self.liveness, &mut self.tracker, isa); } else { // Make sure no references are used. for val in func.dfg.values() { diff --git a/cranelift/codegen/src/regalloc/mod.rs b/cranelift/codegen/src/regalloc/mod.rs index 37fcccb3b0..581acc408e 100644 --- a/cranelift/codegen/src/regalloc/mod.rs +++ b/cranelift/codegen/src/regalloc/mod.rs @@ -23,4 +23,4 @@ mod spilling; pub use self::context::Context; pub use self::diversion::{EntryRegDiversions, RegDiversions}; pub use self::register_set::RegisterSet; -pub use self::safepoint::emit_stackmaps; +pub use self::safepoint::emit_stack_maps; diff --git a/cranelift/codegen/src/regalloc/safepoint.rs b/cranelift/codegen/src/regalloc/safepoint.rs index 18fe20ffac..2686c57277 100644 --- a/cranelift/codegen/src/regalloc/safepoint.rs +++ b/cranelift/codegen/src/regalloc/safepoint.rs @@ -32,9 +32,9 @@ fn insert_and_encode_safepoint<'f>( } } -// The emit_stackmaps() function analyzes each instruction to retrieve the liveness of +// The emit_stack_maps() function analyzes each instruction to retrieve the liveness of // the defs and operands by traversing a function's blocks in layout order. -pub fn emit_stackmaps( +pub fn emit_stack_maps( func: &mut Function, domtree: &DominatorTree, liveness: &Liveness, diff --git a/cranelift/faerie/src/backend.rs b/cranelift/faerie/src/backend.rs index 8fae42a0b4..8b7d3df5ae 100644 --- a/cranelift/faerie/src/backend.rs +++ b/cranelift/faerie/src/backend.rs @@ -3,7 +3,7 @@ use crate::container; use anyhow::anyhow; use cranelift_codegen::binemit::{ - Addend, CodeOffset, NullStackmapSink, Reloc, RelocSink, Stackmap, StackmapSink, TrapSink, + Addend, CodeOffset, NullStackMapSink, Reloc, RelocSink, StackMap, StackMapSink, TrapSink, }; use cranelift_codegen::isa::TargetIsa; use cranelift_codegen::{self, binemit, ir}; @@ -141,8 +141,8 @@ impl Backend for FaerieBackend { TS: TrapSink, { let mut code: Vec = vec![0; total_size as usize]; - // TODO: Replace this with FaerieStackmapSink once it is implemented. - let mut stackmap_sink = NullStackmapSink {}; + // TODO: Replace this with FaerieStackMapSink once it is implemented. + let mut stack_map_sink = NullStackMapSink {}; // Non-lexical lifetimes would obviate the braces here. { @@ -160,7 +160,7 @@ impl Backend for FaerieBackend { code.as_mut_ptr(), &mut reloc_sink, trap_sink, - &mut stackmap_sink, + &mut stack_map_sink, ) }; } @@ -469,14 +469,14 @@ impl<'a> RelocSink for FaerieRelocSink<'a> { } #[allow(dead_code)] -struct FaerieStackmapSink<'a> { +struct FaerieStackMapSink<'a> { artifact: &'a mut faerie::Artifact, namespace: &'a ModuleNamespace<'a, FaerieBackend>, } /// Faerie is currently not used in SpiderMonkey. Methods are unimplemented. -impl<'a> StackmapSink for FaerieStackmapSink<'a> { - fn add_stackmap(&mut self, _: CodeOffset, _: Stackmap) { - unimplemented!("faerie support for stackmaps"); +impl<'a> StackMapSink for FaerieStackMapSink<'a> { + fn add_stack_map(&mut self, _: CodeOffset, _: StackMap) { + unimplemented!("faerie support for stack maps"); } } diff --git a/cranelift/filetests/filetests/stackmaps/call.clif b/cranelift/filetests/filetests/stack_maps/call.clif similarity index 99% rename from cranelift/filetests/filetests/stackmaps/call.clif rename to cranelift/filetests/filetests/stack_maps/call.clif index cf46c61284..158082be0e 100644 --- a/cranelift/filetests/filetests/stackmaps/call.clif +++ b/cranelift/filetests/filetests/stack_maps/call.clif @@ -1,4 +1,4 @@ -test stackmaps +test stack_maps set enable_safepoints=true target x86_64 diff --git a/cranelift/filetests/filetests/stackmaps/incoming_args.clif b/cranelift/filetests/filetests/stack_maps/incoming_args.clif similarity index 97% rename from cranelift/filetests/filetests/stackmaps/incoming_args.clif rename to cranelift/filetests/filetests/stack_maps/incoming_args.clif index cb48f4455c..8ae5712b6d 100644 --- a/cranelift/filetests/filetests/stackmaps/incoming_args.clif +++ b/cranelift/filetests/filetests/stack_maps/incoming_args.clif @@ -1,4 +1,4 @@ -test stackmaps +test stack_maps set enable_safepoints=true target x86_64 @@ -28,4 +28,3 @@ block0(v0: r64, v1: r64, v2: r64, v3: r64, v4: r64): ; nextln: safepoint v4 ; nextln: - mapped words: 13 ; nextln: - live: [12] - diff --git a/cranelift/filetests/src/function_runner.rs b/cranelift/filetests/src/function_runner.rs index 518182d7f8..8eb801de1e 100644 --- a/cranelift/filetests/src/function_runner.rs +++ b/cranelift/filetests/src/function_runner.rs @@ -1,6 +1,6 @@ //! Provides functionality for compiling and running CLIF IR for `run` tests. use core::{mem, ptr}; -use cranelift_codegen::binemit::{NullRelocSink, NullStackmapSink, NullTrapSink}; +use cranelift_codegen::binemit::{NullRelocSink, NullStackMapSink, NullTrapSink}; use cranelift_codegen::ir::{condcodes::IntCC, Function, InstBuilder, Signature, Type}; use cranelift_codegen::isa::TargetIsa; use cranelift_codegen::{ir, settings, CodegenError, Context}; @@ -268,12 +268,12 @@ fn compile(function: Function, isa: &dyn TargetIsa) -> Result subtest::SubtestResult test_shrink::subtest(parsed), "simple-gvn" => test_simple_gvn::subtest(parsed), "simple_preopt" => test_simple_preopt::subtest(parsed), - "stackmaps" => test_stackmaps::subtest(parsed), + "stack_maps" => test_stack_maps::subtest(parsed), "unwind" => test_unwind::subtest(parsed), "verifier" => test_verifier::subtest(parsed), _ => Err(format!("unknown test command '{}'", parsed.command)), diff --git a/cranelift/filetests/src/test_binemit.rs b/cranelift/filetests/src/test_binemit.rs index 198a2c604b..d5d1860b44 100644 --- a/cranelift/filetests/src/test_binemit.rs +++ b/cranelift/filetests/src/test_binemit.rs @@ -108,7 +108,7 @@ impl binemit::CodeSink for TextSink { } fn begin_rodata(&mut self) {} fn end_codegen(&mut self) {} - fn add_stackmap( + fn add_stack_map( &mut self, _: &[ir::entities::Value], _: &ir::Function, diff --git a/cranelift/filetests/src/test_compile.rs b/cranelift/filetests/src/test_compile.rs index 64369183ba..a536bd44d8 100644 --- a/cranelift/filetests/src/test_compile.rs +++ b/cranelift/filetests/src/test_compile.rs @@ -129,7 +129,7 @@ impl binemit::CodeSink for SizeSink { fn begin_jumptables(&mut self) {} fn begin_rodata(&mut self) {} fn end_codegen(&mut self) {} - fn add_stackmap( + fn add_stack_map( &mut self, _: &[ir::entities::Value], _: &ir::Function, diff --git a/cranelift/filetests/src/test_rodata.rs b/cranelift/filetests/src/test_rodata.rs index 7761e504f1..0e6e3cc5f3 100644 --- a/cranelift/filetests/src/test_rodata.rs +++ b/cranelift/filetests/src/test_rodata.rs @@ -132,5 +132,5 @@ impl binemit::CodeSink for RodataSink { "Expected rodata to be emitted before the end of codegen" ); } - fn add_stackmap(&mut self, _: &[Value], _: &Function, _: &dyn TargetIsa) {} + fn add_stack_map(&mut self, _: &[Value], _: &Function, _: &dyn TargetIsa) {} } diff --git a/cranelift/filetests/src/test_stackmaps.rs b/cranelift/filetests/src/test_stack_maps.rs similarity index 84% rename from cranelift/filetests/src/test_stackmaps.rs rename to cranelift/filetests/src/test_stack_maps.rs index fe1688603c..25c49d7b01 100644 --- a/cranelift/filetests/src/test_stackmaps.rs +++ b/cranelift/filetests/src/test_stack_maps.rs @@ -1,5 +1,5 @@ use crate::subtest::{run_filecheck, Context, SubTest, SubtestResult}; -use cranelift_codegen::binemit::{self, Addend, CodeOffset, CodeSink, Reloc, Stackmap}; +use cranelift_codegen::binemit::{self, Addend, CodeOffset, CodeSink, Reloc, StackMap}; use cranelift_codegen::ir::*; use cranelift_codegen::isa::TargetIsa; use cranelift_codegen::print_errors::pretty_error; @@ -7,27 +7,27 @@ use cranelift_reader::TestCommand; use std::borrow::Cow; use std::fmt::Write; -struct TestStackmaps; +struct TestStackMaps; pub fn subtest(parsed: &TestCommand) -> SubtestResult> { - assert_eq!(parsed.command, "stackmaps"); + assert_eq!(parsed.command, "stack_maps"); if !parsed.options.is_empty() { Err(format!("No options allowed on {}", parsed)) } else { - Ok(Box::new(TestStackmaps)) + Ok(Box::new(TestStackMaps)) } } -impl SubTest for TestStackmaps { +impl SubTest for TestStackMaps { fn name(&self) -> &'static str { - "stackmaps" + "stack_maps" } fn run(&self, func: Cow, context: &Context) -> SubtestResult<()> { let mut comp_ctx = cranelift_codegen::Context::for_function(func.into_owned()); comp_ctx - .compile(context.isa.expect("`test stackmaps` requires an isa")) + .compile(context.isa.expect("`test stack_maps` requires an isa")) .map_err(|e| pretty_error(&comp_ctx.func, context.isa, e))?; let mut sink = TestStackMapsSink::default(); @@ -40,7 +40,7 @@ impl SubTest for TestStackmaps { isa.emit_inst(func, inst, div, sink) }, &mut sink, - context.isa.expect("`test stackmaps` requires an isa"), + context.isa.expect("`test stack_maps` requires an isa"), ); let mut text = comp_ctx.func.display(context.isa).to_string(); @@ -48,6 +48,7 @@ impl SubTest for TestStackmaps { text.push_str("Stack maps:\n"); text.push('\n'); text.push_str(&sink.text); + log::debug!("FITZGEN:\n{}", text); run_filecheck(&text, context) } @@ -89,8 +90,8 @@ impl CodeSink for TestStackMapsSink { fn begin_rodata(&mut self) {} fn end_codegen(&mut self) {} - fn add_stackmap(&mut self, val_list: &[Value], func: &Function, isa: &dyn TargetIsa) { - let map = Stackmap::from_values(&val_list, func, isa); + fn add_stack_map(&mut self, val_list: &[Value], func: &Function, isa: &dyn TargetIsa) { + let map = StackMap::from_values(&val_list, func, isa); writeln!(&mut self.text, " - mapped words: {}", map.mapped_words()).unwrap(); write!(&mut self.text, " - live: [").unwrap(); diff --git a/cranelift/object/src/backend.rs b/cranelift/object/src/backend.rs index 1dd93a054d..59014b77f4 100644 --- a/cranelift/object/src/backend.rs +++ b/cranelift/object/src/backend.rs @@ -2,7 +2,7 @@ use anyhow::anyhow; use cranelift_codegen::binemit::{ - Addend, CodeOffset, NullStackmapSink, Reloc, RelocSink, TrapSink, + Addend, CodeOffset, NullStackMapSink, Reloc, RelocSink, TrapSink, }; use cranelift_codegen::entity::SecondaryMap; use cranelift_codegen::isa::TargetIsa; @@ -213,7 +213,7 @@ impl Backend for ObjectBackend { { let mut code: Vec = vec![0; code_size as usize]; let mut reloc_sink = ObjectRelocSink::new(self.object.format()); - let mut stackmap_sink = NullStackmapSink {}; + let mut stack_map_sink = NullStackMapSink {}; unsafe { ctx.emit_to_memory( @@ -221,7 +221,7 @@ impl Backend for ObjectBackend { code.as_mut_ptr(), &mut reloc_sink, trap_sink, - &mut stackmap_sink, + &mut stack_map_sink, ) }; diff --git a/cranelift/simplejit/src/backend.rs b/cranelift/simplejit/src/backend.rs index d8928f1529..6e21e7f154 100644 --- a/cranelift/simplejit/src/backend.rs +++ b/cranelift/simplejit/src/backend.rs @@ -2,7 +2,7 @@ use crate::memory::Memory; use cranelift_codegen::binemit::{ - Addend, CodeOffset, Reloc, RelocSink, Stackmap, StackmapSink, TrapSink, + Addend, CodeOffset, Reloc, RelocSink, StackMap, StackMapSink, TrapSink, }; use cranelift_codegen::isa::TargetIsa; use cranelift_codegen::settings::Configurable; @@ -134,11 +134,11 @@ struct RelocRecord { addend: Addend, } -struct StackmapRecord { +struct StackMapRecord { #[allow(dead_code)] offset: CodeOffset, #[allow(dead_code)] - stackmap: Stackmap, + stack_map: StackMap, } pub struct SimpleJITCompiledFunction { @@ -298,14 +298,14 @@ impl<'simple_jit_backend> Backend for SimpleJITBackend { self.record_function_for_perf(ptr, size, name); let mut reloc_sink = SimpleJITRelocSink::new(); - let mut stackmap_sink = SimpleJITStackmapSink::new(); + let mut stack_map_sink = SimpleJITStackMapSink::new(); unsafe { ctx.emit_to_memory( &*self.isa, ptr, &mut reloc_sink, trap_sink, - &mut stackmap_sink, + &mut stack_map_sink, ) }; @@ -675,20 +675,20 @@ impl RelocSink for SimpleJITRelocSink { } } -struct SimpleJITStackmapSink { - pub stackmaps: Vec, +struct SimpleJITStackMapSink { + pub stack_maps: Vec, } -impl SimpleJITStackmapSink { +impl SimpleJITStackMapSink { pub fn new() -> Self { Self { - stackmaps: Vec::new(), + stack_maps: Vec::new(), } } } -impl StackmapSink for SimpleJITStackmapSink { - fn add_stackmap(&mut self, offset: CodeOffset, stackmap: Stackmap) { - self.stackmaps.push(StackmapRecord { offset, stackmap }); +impl StackMapSink for SimpleJITStackMapSink { + fn add_stack_map(&mut self, offset: CodeOffset, stack_map: StackMap) { + self.stack_maps.push(StackMapRecord { offset, stack_map }); } } diff --git a/cranelift/src/bugpoint.rs b/cranelift/src/bugpoint.rs index 4116ee37b9..b50fefaab1 100644 --- a/cranelift/src/bugpoint.rs +++ b/cranelift/src/bugpoint.rs @@ -1,6 +1,6 @@ //! CLI tool to reduce Cranelift IR files crashing during compilation. -use crate::disasm::{PrintRelocs, PrintStackmaps, PrintTraps}; +use crate::disasm::{PrintRelocs, PrintStackMaps, PrintTraps}; use crate::utils::{parse_sets_and_triple, read_to_string}; use cranelift_codegen::cursor::{Cursor, FuncCursor}; use cranelift_codegen::flowgraph::ControlFlowGraph; @@ -1045,14 +1045,14 @@ impl<'a> CrashCheckContext<'a> { let res = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { let mut relocs = PrintRelocs::new(false); let mut traps = PrintTraps::new(false); - let mut stackmaps = PrintStackmaps::new(false); + let mut stack_maps = PrintStackMaps::new(false); let _ = self.context.compile_and_emit( self.isa, &mut self.code_memory, &mut relocs, &mut traps, - &mut stackmaps, + &mut stack_maps, ); })) { Ok(()) => CheckResult::Succeed, diff --git a/cranelift/src/compile.rs b/cranelift/src/compile.rs index 4d71118876..ceceeaa244 100644 --- a/cranelift/src/compile.rs +++ b/cranelift/src/compile.rs @@ -1,6 +1,6 @@ //! CLI tool to read Cranelift IR files and compile them into native code. -use crate::disasm::{print_all, PrintRelocs, PrintStackmaps, PrintTraps}; +use crate::disasm::{print_all, PrintRelocs, PrintStackMaps, PrintTraps}; use crate::utils::{parse_sets_and_triple, read_to_string}; use cranelift_codegen::print_errors::pretty_error; use cranelift_codegen::settings::FlagsOrIsa; @@ -58,7 +58,7 @@ fn handle_module( for (func, _) in test_file.functions { let mut relocs = PrintRelocs::new(flag_print); let mut traps = PrintTraps::new(flag_print); - let mut stackmaps = PrintStackmaps::new(flag_print); + let mut stack_maps = PrintStackMaps::new(flag_print); if let Some(isa) = isa { let mut context = Context::new(); @@ -67,7 +67,7 @@ fn handle_module( // Compile and encode the result to machine code. let code_info = context - .compile_and_emit(isa, &mut mem, &mut relocs, &mut traps, &mut stackmaps) + .compile_and_emit(isa, &mut mem, &mut relocs, &mut traps, &mut stack_maps) .map_err(|err| pretty_error(&context.func, Some(isa), err))?; if flag_print { @@ -82,7 +82,7 @@ fn handle_module( code_info.jumptables_size + code_info.rodata_size, &relocs, &traps, - &stackmaps, + &stack_maps, )?; } } diff --git a/cranelift/src/disasm.rs b/cranelift/src/disasm.rs index fdea73ecb5..e68f3594a4 100644 --- a/cranelift/src/disasm.rs +++ b/cranelift/src/disasm.rs @@ -97,12 +97,12 @@ impl binemit::TrapSink for PrintTraps { } } -pub struct PrintStackmaps { +pub struct PrintStackMaps { pub flag_print: bool, pub text: String, } -impl PrintStackmaps { +impl PrintStackMaps { pub fn new(flag_print: bool) -> Self { Self { flag_print, @@ -111,10 +111,10 @@ impl PrintStackmaps { } } -impl binemit::StackmapSink for PrintStackmaps { - fn add_stackmap(&mut self, offset: binemit::CodeOffset, _: binemit::Stackmap) { +impl binemit::StackMapSink for PrintStackMaps { + fn add_stack_map(&mut self, offset: binemit::CodeOffset, _: binemit::StackMap) { if self.flag_print { - writeln!(&mut self.text, "add_stackmap at {}", offset).unwrap(); + writeln!(&mut self.text, "add_stack_map at {}", offset).unwrap(); } } } @@ -223,12 +223,12 @@ pub fn print_all( rodata_size: u32, relocs: &PrintRelocs, traps: &PrintTraps, - stackmaps: &PrintStackmaps, + stack_maps: &PrintStackMaps, ) -> Result<(), String> { print_bytes(&mem); print_disassembly(isa, &mem[0..code_size as usize])?; print_readonly_data(&mem[code_size as usize..(code_size + rodata_size) as usize]); - println!("\n{}\n{}\n{}", &relocs.text, &traps.text, &stackmaps.text); + println!("\n{}\n{}\n{}", &relocs.text, &traps.text, &stack_maps.text); Ok(()) } diff --git a/cranelift/src/wasm.rs b/cranelift/src/wasm.rs index 816c1c17dd..b98adcbf4a 100644 --- a/cranelift/src/wasm.rs +++ b/cranelift/src/wasm.rs @@ -7,7 +7,7 @@ allow(clippy::too_many_arguments, clippy::cognitive_complexity) )] -use crate::disasm::{print_all, PrintRelocs, PrintStackmaps, PrintTraps}; +use crate::disasm::{print_all, PrintRelocs, PrintStackMaps, PrintTraps}; use crate::utils::parse_sets_and_triple; use crate::UseTerminalColor; use cranelift_codegen::ir::DisplayFunctionAnnotations; @@ -219,14 +219,14 @@ fn handle_module( let mut mem = vec![]; let mut relocs = PrintRelocs::new(flag_print); let mut traps = PrintTraps::new(flag_print); - let mut stackmaps = PrintStackmaps::new(flag_print); + let mut stack_maps = PrintStackMaps::new(flag_print); if flag_check_translation { if let Err(errors) = context.verify(fisa) { return Err(pretty_verifier_error(&context.func, fisa.isa, None, errors)); } } else { let code_info = context - .compile_and_emit(isa, &mut mem, &mut relocs, &mut traps, &mut stackmaps) + .compile_and_emit(isa, &mut mem, &mut relocs, &mut traps, &mut stack_maps) .map_err(|err| pretty_error(&context.func, fisa.isa, err))?; if flag_print_size { @@ -289,7 +289,7 @@ fn handle_module( rodata_size, &relocs, &traps, - &stackmaps, + &stack_maps, )?; } diff --git a/crates/environ/src/compilation.rs b/crates/environ/src/compilation.rs index c0b814000f..57cb6a46ef 100644 --- a/crates/environ/src/compilation.rs +++ b/crates/environ/src/compilation.rs @@ -76,7 +76,7 @@ pub struct StackMapInformation { pub code_offset: binemit::CodeOffset, /// The stack map for identifying live GC refs at the GC safepoint. - pub stack_map: binemit::Stackmap, + pub stack_map: binemit::StackMap, } /// An error while compiling WebAssembly to machine code. diff --git a/crates/environ/src/cranelift.rs b/crates/environ/src/cranelift.rs index 4a936581b9..86b55a253f 100644 --- a/crates/environ/src/cranelift.rs +++ b/crates/environ/src/cranelift.rs @@ -208,8 +208,8 @@ struct StackMapSink { infos: Vec, } -impl binemit::StackmapSink for StackMapSink { - fn add_stackmap(&mut self, code_offset: binemit::CodeOffset, stack_map: binemit::Stackmap) { +impl binemit::StackMapSink for StackMapSink { + fn add_stack_map(&mut self, code_offset: binemit::CodeOffset, stack_map: binemit::StackMap) { self.infos.push(StackMapInformation { code_offset, stack_map, diff --git a/crates/environ/src/data_structures.rs b/crates/environ/src/data_structures.rs index 550549c780..063e254d79 100644 --- a/crates/environ/src/data_structures.rs +++ b/crates/environ/src/data_structures.rs @@ -1,7 +1,7 @@ #![doc(hidden)] pub mod ir { - pub use cranelift_codegen::binemit::{Reloc, Stackmap}; + pub use cranelift_codegen::binemit::{Reloc, StackMap}; pub use cranelift_codegen::ir::{ types, AbiParam, ArgumentPurpose, JumpTableOffsets, LibCall, Signature, SourceLoc, StackSlots, TrapCode, Type, ValueLabel, ValueLoc, diff --git a/crates/jit/src/trampoline.rs b/crates/jit/src/trampoline.rs index 903118f7b7..9116666ea2 100644 --- a/crates/jit/src/trampoline.rs +++ b/crates/jit/src/trampoline.rs @@ -22,7 +22,7 @@ pub use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext}; pub mod binemit { pub use cranelift_codegen::binemit::NullTrapSink; pub(super) use cranelift_codegen::binemit::{Addend, Reloc, RelocSink}; - pub use cranelift_codegen::binemit::{CodeOffset, NullStackmapSink, TrapSink}; + pub use cranelift_codegen::binemit::{CodeOffset, NullStackMapSink, TrapSink}; } /// Create a trampoline for invoking a function. @@ -130,14 +130,14 @@ pub(crate) fn build_trampoline( let mut code_buf = Vec::new(); let mut reloc_sink = TrampolineRelocSink::default(); let mut trap_sink = binemit::NullTrapSink {}; - let mut stackmap_sink = binemit::NullStackmapSink {}; + let mut stack_map_sink = binemit::NullStackMapSink {}; context .compile_and_emit( isa, &mut code_buf, &mut reloc_sink, &mut trap_sink, - &mut stackmap_sink, + &mut stack_map_sink, ) .map_err(|error| { SetupError::Compile(CompileError::Codegen(pretty_error( diff --git a/crates/runtime/src/externref.rs b/crates/runtime/src/externref.rs index a28808c563..0903f397e2 100644 --- a/crates/runtime/src/externref.rs +++ b/crates/runtime/src/externref.rs @@ -110,7 +110,7 @@ use std::mem; use std::ops::Deref; use std::ptr::{self, NonNull}; use std::rc::Rc; -use wasmtime_environ::{ir::Stackmap, StackMapInformation}; +use wasmtime_environ::{ir::StackMap, StackMapInformation}; /// An external reference to some opaque data. /// @@ -780,7 +780,7 @@ struct ModuleStackMaps { /// A map from a PC in this module (that is a GC safepoint) to its /// associated stack map. - pc_to_stack_map: Vec<(usize, Rc)>, + pc_to_stack_map: Vec<(usize, Rc)>, } impl StackMapRegistry { @@ -849,7 +849,7 @@ impl StackMapRegistry { } /// Lookup the stack map for the given PC, if any. - pub fn lookup_stack_map(&self, pc: usize) -> Option> { + pub fn lookup_stack_map(&self, pc: usize) -> Option> { let inner = self.inner.borrow(); let stack_maps = inner.module_stack_maps(pc)?; diff --git a/crates/wasmtime/src/trampoline/func.rs b/crates/wasmtime/src/trampoline/func.rs index 350236a3ff..81baa99b20 100644 --- a/crates/wasmtime/src/trampoline/func.rs +++ b/crates/wasmtime/src/trampoline/func.rs @@ -174,14 +174,14 @@ fn make_trampoline( let mut code_buf: Vec = Vec::new(); let mut reloc_sink = trampoline::TrampolineRelocSink::default(); let mut trap_sink = binemit::NullTrapSink {}; - let mut stackmap_sink = binemit::NullStackmapSink {}; + let mut stack_map_sink = binemit::NullStackMapSink {}; context .compile_and_emit( isa, &mut code_buf, &mut reloc_sink, &mut trap_sink, - &mut stackmap_sink, + &mut stack_map_sink, ) .map_err(|error| pretty_error(&context.func, Some(isa), error)) .expect("compile_and_emit");