Loading files
a480b9028This file is pinned to the selected release. Download the original to open it in your design tool.
// Copyright 2020 ETH Zurich and University of Bologna.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//! Runtime structures shared with the translated binary
//!
//! This module contains various structures that are used by banshee and the
//! translated binary as it executes. Some code is needed only in banshee, some
//! only in the JITed binary, and some in both. The separation is as follows:
//!
//! - `mod.rs` (this file) contains the banshee-only code.
//!
//! - `jit.rs` contains the JIT-only code. It is compiled by `build.rs` into an
//! LLVM IR file that is linked with the IR assembled during binary
//! translation.
//!
//! - `common.rs` contains code shared between banshee and the JITed binary. Its
//! goals is to mainly contain the runtime data structures that the JITed
//! binary needs visibility into as well.
//!
//! - `jit.ll` is the initial content of the JITed binary module, before binary
//! translation populates it with code.
//!
//! The LLVM IR module for the JITed binary is assembled as follows:
//!
//! - The `jit.ll` module is loaded to obtain the initial LLVM module.
//! - Binary translation emits code into the module.
//! - The module is linked with the LLVM IR obtained from `jit.rs`.
use crate::engine::Engine;
use itertools::Itertools;
include!("common.rs");
/// The initial contents of the LLVM module for the JITed binary.
///
/// These are the contents of the `jit.ll` file, and should contain any opaque
/// type declarations and function declarations needed by the binary
/// translation.
pub static JIT_INITIAL: &'static str = include_str!("jit.ll");
/// The compiled version of `jit.rs`.
///
/// These are the compiled Rust code snippets that are needed to execute the
/// translated binary. This is also where most definitions corresponding to the
/// declaratiosn in `jit.ll` should go.
pub static JIT_GENERATED: &'static [u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/jit_generated.ll"));
impl std::fmt::Debug for CpuState {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let regs = self
.regs
.iter()
.copied()
.enumerate()
.map(|(i, value)| format!("x{:02}: 0x{:08x}", i, value))
.chunks(4)
.into_iter()
.map(|mut chunk| chunk.join(" "))
.join("\n");
let fregs = self
.fregs
.iter()
.copied()
.enumerate()
.map(|(i, value)| format!("f{:02}: 0x{:016x}", i, value))
.chunks(4)
.into_iter()
.map(|mut chunk| chunk.join(" "))
.join("\n");
f.debug_struct("CpuState")
.field("regs", &format_args!("\n{}", regs))
.field("fregs", &format_args!("\n{}", fregs))
.field("cas_value", &self.cas_value)
.field("pc", &format_args!("0x{:x}", self.pc))
.field("cycle", &self.cycle)
.field("instret", &self.instret)
.field("ssrs", &self.ssrs)
.field("dma", &self.dma)
.field("irq", &self.irq)
.field("wfi", &self.wfi)
.finish()
}
}
impl std::fmt::Debug for SsrState {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.debug_struct("SsrState")
.field("index", &format_args!("{:?}", self.index))
.field("bound", &format_args!("{:?}", self.bound))
.field("stride", &format_args!("{:08x?}", self.stride))
.field("ptr", &format_args!("{:08x}", self.ptr))
.field("ptr_next", &format_args!("{:08x}", self.ptr_next))
.field(
"repeat",
&format_args!("{} of {}", self.repeat_count, self.repeat_bound),
)
.field(
"status",
&format_args!(
"{{ done: {}, write: {}, dims: {} }}",
self.done, self.write, self.dims
),
)
.field("accessed", &format_args!("{}", self.accessed))
.finish()
}
}
impl std::fmt::Debug for DmaState {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.debug_struct("DmaState")
.field("src", &format_args!("{:08x}", self.src))
.field("dst", &format_args!("{:08x}", self.dst))
.field("src stride", &format_args!("{:08x}", self.src_stride))
.field("dst stride", &format_args!("{:08x}", self.dst_stride))
.field("reps", &self.reps)
.field("size", &self.size)
.field("done_id", &self.done_id)
.finish()
}
}
impl std::fmt::Debug for IrqState {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.debug_struct("IrqState")
.field("mstatus", &format_args!("{:08x}", self.mstatus))
.field("mie", &format_args!("{:08x}", self.mie))
.field("mip", &format_args!("{:08x}", self.mip))
.field("mtvec", &format_args!("{:08x}", self.mtvec))
.field("mepc", &format_args!("{:08x}", self.mepc))
.field("mcause", &format_args!("{:08x}", self.mcause))
.finish()
}
}