T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename "Stackmap" to "StackMap"

Browse Source 
And "stackmap" to "stack_map".

This commit is purely mechanical.
This commit is contained in:
Nick Fitzgerald
2020-08-06 16:41:59 -07:00
parent b5a6daedc4
commit 05bf9ea3f3
44 changed files with 218 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cranelift/codegen/meta/src/isa/x86/recipes.rs
View File

@@ -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);
"#,
),
);

2
cranelift/codegen/meta/src/shared/instructions.rs Normal file → Executable file
View File

@@ -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(

2
cranelift/codegen/meta/src/shared/settings.rs
View File

@@ -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.
"#,

28
cranelift/codegen/src/binemit/memorysink.rs
View File

@@ -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) {}
}

10
cranelift/codegen/src/binemit/mod.rs
View File

@@ -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) {

19
cranelift/codegen/src/binemit/stackmap.rs → cranelift/codegen/src/binemit/stack_map.rs
View File

@@ -59,7 +59,7 @@ const NUM_BITS: usize = core::mem::size_of::<Num>() * 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::<Num>() * 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<BitSet<Num>>,
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<bool> = 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::<Num>(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::<Num>(2164261024), BitSet::<Num>(2)],
res.bitmap

16
cranelift/codegen/src/context.rs
View File

@@ -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<u8>,
relocs: &mut dyn RelocSink,
traps: &mut dyn TrapSink,
stackmaps: &mut dyn StackmapSink,
stack_maps: &mut dyn StackMapSink,
) -> CodegenResult<CodeInfo> {
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 {

2
cranelift/codegen/src/inst_predicates.rs
View File

@@ -63,7 +63,7 @@ pub fn is_constant_64bit(func: &Function, inst: Inst) -> Option<u64> {
}
/// 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()

8
cranelift/codegen/src/isa/aarch64/abi.rs
View File

@@ -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<Inst> {

30
cranelift/codegen/src/isa/aarch64/inst/emit.rs
View File

@@ -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<Stackmap>,
/// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`.
stack_map: Option<StackMap>,
}
impl MachInstEmitState<Inst> for EmitState {
@@ -438,22 +438,22 @@ impl MachInstEmitState<Inst> 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<Stackmap> {
self.stackmap.take()
fn take_stack_map(&mut self) -> Option<StackMap> {
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);
}

2
cranelift/codegen/src/isa/test_utils.rs
View File

@@ -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) {}
}

8
cranelift/codegen/src/isa/x64/abi.rs
View File

@@ -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<Inst> {

12
cranelift/codegen/src/isa/x64/inst/emit.rs
View File

@@ -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);

18
cranelift/codegen/src/isa/x64/inst/mod.rs
View File

@@ -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<Stackmap>,
/// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`.
stack_map: Option<StackMap>,
}
impl MachInstEmit for Inst {
@@ -2246,22 +2246,22 @@ impl MachInstEmitState<Inst> 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<Stackmap> {
self.stackmap.take()
fn take_stack_map(&mut self) -> Option<StackMap> {
self.stack_map.take()
}
fn clear_post_insn(&mut self) {
self.stackmap = None;
self.stack_map = None;
}
}

8
cranelift/codegen/src/machinst/abi.rs
View File

@@ -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: &<Self::I as MachInstEmit>::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`,

46
cranelift/codegen/src/machinst/buffer.rs
View File

@@ -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<I: VCodeInst> {
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<I: VCodeInst> MachBuffer<I> {
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<I: VCodeInst> MachBuffer<I> {
traps: self.traps,
call_sites: self.call_sites,
srclocs: self.srclocs,
stackmaps: self.stackmaps,
stack_maps: self.stack_maps,
}
}
@@ -1212,28 +1212,28 @@ impl<I: VCodeInst> MachBuffer<I> {
}
}
/// 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.

10
cranelift/codegen/src/machinst/compile.rs
View File

@@ -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
};

4
cranelift/codegen/src/machinst/lower.rs
View File

@@ -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

4
cranelift/codegen/src/machinst/mod.rs
View File

@@ -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<I: MachInst>: Default + Clone + Debug {
fn new(abi: &dyn ABIBody<I = I>) -> 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

22
cranelift/codegen/src/machinst/vcode.rs
View File

@@ -94,7 +94,7 @@ pub struct VCode<I: VCodeInst> {
safepoint_insns: Vec<InsnIndex>,
/// 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<Vec<SpillSlot>>,
}
@@ -117,8 +117,8 @@ pub struct VCodeBuilder<I: VCodeInst> {
/// In-progress VCode.
vcode: VCode<I>,
/// 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<I: VCodeInst> VCodeBuilder<I> {
pub fn new(abi: Box<dyn ABIBody<I = I>>, block_order: BlockLoweringOrder) -> VCodeBuilder<I> {
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<I: VCodeInst> VCodeBuilder<I> {
VCodeBuilder {
vcode,
stackmap_info,
stack_map_info,
block_start: 0,
succ_start: 0,
cur_srcloc: SourceLoc::default(),
@@ -169,7 +169,7 @@ impl<I: VCodeInst> VCodeBuilder<I> {
}
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<I: VCodeInst> VCodeBuilder<I> {
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<I: VCodeInst> VCodeBuilder<I> {
}
/// 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<I>, 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<I: VCodeInst> VCode<I> {
&& 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;
}

4
cranelift/codegen/src/regalloc/context.rs
View File

@@ -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() {

2
cranelift/codegen/src/regalloc/mod.rs
View File

@@ -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;

4
cranelift/codegen/src/regalloc/safepoint.rs
View File

@@ -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,

16
cranelift/faerie/src/backend.rs
View File

@@ -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<u8> = 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");
}
}

2
cranelift/filetests/filetests/stackmaps/call.clif → cranelift/filetests/filetests/stack_maps/call.clif
View File

@@ -1,4 +1,4 @@
test stackmaps
test stack_maps
set enable_safepoints=true
target x86_64

3
cranelift/filetests/filetests/stackmaps/incoming_args.clif → cranelift/filetests/filetests/stack_maps/incoming_args.clif
View File

@@ -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]

6
cranelift/filetests/src/function_runner.rs
View File

@@ -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<Mmap, CompilationE
// Compile and encode the result to machine code.
let relocs = &mut NullRelocSink {};
let traps = &mut NullTrapSink {};
let stackmaps = &mut NullStackmapSink {};
let stack_maps = &mut NullStackMapSink {};
let code_info = context.compile(isa)?;
let mut code_page = MmapMut::map_anon(code_info.total_size as usize)?;
unsafe {
context.emit_to_memory(isa, code_page.as_mut_ptr(), relocs, traps, stackmaps);
context.emit_to_memory(isa, code_page.as_mut_ptr(), relocs, traps, stack_maps);
};
let code_page = code_page.make_exec()?;

4
cranelift/filetests/src/lib.rs
View File

@@ -56,7 +56,7 @@ mod test_safepoint;
mod test_shrink;
mod test_simple_gvn;
mod test_simple_preopt;
mod test_stackmaps;
mod test_stack_maps;
mod test_unwind;
mod test_verifier;
@@ -140,7 +140,7 @@ fn new_subtest(parsed: &TestCommand) -> subtest::SubtestResult<Box<dyn subtest::
"shrink" => 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)),

2
cranelift/filetests/src/test_binemit.rs
View File

@@ -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,

2
cranelift/filetests/src/test_compile.rs
View File

@@ -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,

2
cranelift/filetests/src/test_rodata.rs
View File

@@ -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) {}
}

21
cranelift/filetests/src/test_stackmaps.rs → cranelift/filetests/src/test_stack_maps.rs
View File

@@ -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<Box<dyn SubTest>> {
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<Function>, 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();

6
cranelift/object/src/backend.rs
View File

@@ -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<u8> = 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,
)
};

24
cranelift/simplejit/src/backend.rs
View File

@@ -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<StackmapRecord>,
struct SimpleJITStackMapSink {
pub stack_maps: Vec<StackMapRecord>,
}
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 });
}
}

6
cranelift/src/bugpoint.rs
View File

@@ -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,

8
cranelift/src/compile.rs
View File

@@ -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,
)?;
}
}

14
cranelift/src/disasm.rs
View File

@@ -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(())
}

8
cranelift/src/wasm.rs
View File

@@ -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,
)?;
}

2
crates/environ/src/compilation.rs
View File

@@ -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.

4
crates/environ/src/cranelift.rs
View File

@@ -208,8 +208,8 @@ struct StackMapSink {
infos: Vec<StackMapInformation>,
}
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,

2
crates/environ/src/data_structures.rs
View File

@@ -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,

6
crates/jit/src/trampoline.rs
View File

@@ -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(

6
crates/runtime/src/externref.rs
View File

@@ -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<Stackmap>)>,
pc_to_stack_map: Vec<(usize, Rc<StackMap>)>,
}
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<Rc<Stackmap>> {
pub fn lookup_stack_map(&self, pc: usize) -> Option<Rc<StackMap>> {
let inner = self.inner.borrow();
let stack_maps = inner.module_stack_maps(pc)?;

4
crates/wasmtime/src/trampoline/func.rs
View File

@@ -174,14 +174,14 @@ fn make_trampoline(
let mut code_buf: Vec<u8> = 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");