diff --git a/cranelift/codegen/src/ir/mod.rs b/cranelift/codegen/src/ir/mod.rs index d97d23c447..d0836fc746 100644 --- a/cranelift/codegen/src/ir/mod.rs +++ b/cranelift/codegen/src/ir/mod.rs @@ -52,7 +52,7 @@ pub use crate::ir::libcall::{get_probestack_funcref, LibCall}; pub use crate::ir::memflags::{Endianness, MemFlags}; pub use crate::ir::progpoint::{ExpandedProgramPoint, ProgramOrder, ProgramPoint}; pub use crate::ir::sourceloc::SourceLoc; -pub use crate::ir::stackslot::{StackLayoutInfo, StackSlotData, StackSlotKind, StackSlots}; +pub use crate::ir::stackslot::{StackSlotData, StackSlotKind, StackSlots}; pub use crate::ir::table::TableData; pub use crate::ir::trapcode::TrapCode; pub use crate::ir::types::Type; diff --git a/cranelift/codegen/src/ir/stackslot.rs b/cranelift/codegen/src/ir/stackslot.rs index 13d35d37b9..993fcc8ee1 100644 --- a/cranelift/codegen/src/ir/stackslot.rs +++ b/cranelift/codegen/src/ir/stackslot.rs @@ -162,23 +162,6 @@ impl fmt::Display for StackSlotData { } } -/// Stack frame layout information. -/// -/// This is computed by the `layout_stack()` method. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] -pub struct StackLayoutInfo { - /// The total size of the stack frame. - /// - /// This is the distance from the stack pointer in the current function to the stack pointer in - /// the calling function, so it includes a pushed return address as well as space for outgoing - /// call arguments. - pub frame_size: StackSize, - - /// The total size of the stack frame for inbound arguments pushed by the caller. - pub inbound_args_size: StackSize, -} - /// Stack frame manager. /// /// Keep track of all the stack slots used by a function. @@ -193,9 +176,6 @@ pub struct StackSlots { /// All the emergency slots. emergency: Vec, - - /// Layout information computed from `layout_stack`. - pub layout_info: Option, } /// Stack slot manager functions that behave mostly like an entity map. @@ -210,7 +190,6 @@ impl StackSlots { self.slots.clear(); self.outgoing.clear(); self.emergency.clear(); - self.layout_info = None; } /// Allocate a new stack slot. diff --git a/cranelift/codegen/src/isa/mod.rs b/cranelift/codegen/src/isa/mod.rs index 29b84d5959..9c2bdcf31c 100644 --- a/cranelift/codegen/src/isa/mod.rs +++ b/cranelift/codegen/src/isa/mod.rs @@ -45,7 +45,6 @@ pub use crate::isa::call_conv::CallConv; pub use crate::isa::constraints::BranchRange; -pub use crate::isa::stack::{StackBase, StackBaseMask, StackRef}; use crate::flowgraph; use crate::ir; @@ -78,7 +77,6 @@ pub mod unwind; mod call_conv; mod constraints; -mod stack; #[cfg(test)] mod test_utils; diff --git a/cranelift/codegen/src/isa/stack.rs b/cranelift/codegen/src/isa/stack.rs deleted file mode 100644 index ae093bed28..0000000000 --- a/cranelift/codegen/src/isa/stack.rs +++ /dev/null @@ -1,95 +0,0 @@ -//! Low-level details of stack accesses. -//! -//! The `ir::StackSlots` type deals with stack slots and stack frame layout. The `StackRef` type -//! defined in this module expresses the low-level details of accessing a stack slot from an -//! encoded instruction. - -use crate::ir::stackslot::{StackOffset, StackSlotKind, StackSlots}; -use crate::ir::StackSlot; - -/// A method for referencing a stack slot in the current stack frame. -/// -/// Stack slots are addressed with a constant offset from a base register. The base can be the -/// stack pointer, the frame pointer, or (in the future) a zone register pointing to an inner zone -/// of a large stack frame. -#[derive(Clone, Copy, Debug)] -pub struct StackRef { - /// The base register to use for addressing. - pub base: StackBase, - - /// Immediate offset from the base register to the first byte of the stack slot. - pub offset: StackOffset, -} - -impl StackRef { - /// Get a reference to the stack slot `ss` using one of the base pointers in `mask`. - pub fn masked(ss: StackSlot, mask: StackBaseMask, frame: &StackSlots) -> Option { - // Try an SP-relative reference. - if mask.contains(StackBase::SP) { - return Some(Self::sp(ss, frame)); - } - - // No reference possible with this mask. - None - } - - /// Get a reference to `ss` using the stack pointer as a base. - pub fn sp(ss: StackSlot, frame: &StackSlots) -> Self { - let size = frame - .layout_info - .expect("Stack layout must be computed before referencing stack slots") - .frame_size; - let slot = &frame[ss]; - let offset = if slot.kind == StackSlotKind::OutgoingArg { - // Outgoing argument slots have offsets relative to our stack pointer. - slot.offset.unwrap() - } else { - // All other slots have offsets relative to our caller's stack frame. - // Offset where SP is pointing. (All ISAs have stacks growing downwards.) - let sp_offset = -(size as StackOffset); - slot.offset.unwrap() - sp_offset - }; - Self { - base: StackBase::SP, - offset, - } - } -} - -/// Generic base register for referencing stack slots. -/// -/// Most ISAs have a stack pointer and an optional frame pointer, so provide generic names for -/// those two base pointers. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum StackBase { - /// Use the stack pointer. - SP = 0, - - /// Use the frame pointer (if one is present). - FP = 1, - - /// Use an explicit zone pointer in a general-purpose register. - /// - /// This feature is not yet implemented. - Zone = 2, -} - -/// Bit mask of supported stack bases. -/// -/// Many instruction encodings can use different base registers while others only work with the -/// stack pointer, say. A `StackBaseMask` is a bit mask of supported stack bases for a given -/// instruction encoding. -/// -/// This behaves like a set of `StackBase` variants. -/// -/// The internal representation as a `u8` is public because stack base masks are used in constant -/// tables generated from the meta-language encoding definitions. -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StackBaseMask(pub u8); - -impl StackBaseMask { - /// Check if this mask contains the `base` variant. - pub fn contains(self, base: StackBase) -> bool { - self.0 & (1 << base as usize) != 0 - } -}