use cretonne_codegen::binemit::{Addend, CodeOffset};
use cretonne_codegen::entity::PrimaryMap;
use cretonne_codegen::ir;
use std::boxed::Box;
use std::vec::Vec;
#[derive(PartialEq, Eq, Debug)]
pub enum Init {
Uninitialized,
Zeros {
size: usize,
},
Bytes {
contents: Box<[u8]>,
},
}
impl Init {
pub fn size(&self) -> usize {
match *self {
Init::Uninitialized => panic!("data size not initialized yet"),
Init::Zeros { size } => size,
Init::Bytes { ref contents } => contents.len(),
}
}
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum Writability {
Readonly,
Writable,
}
pub struct DataDescription {
pub writable: Writability,
pub init: Init,
pub function_decls: PrimaryMap<ir::FuncRef, ir::ExternalName>,
pub data_decls: PrimaryMap<ir::GlobalValue, ir::ExternalName>,
pub function_relocs: Vec<(CodeOffset, ir::FuncRef)>,
pub data_relocs: Vec<(CodeOffset, ir::GlobalValue, Addend)>,
}
pub struct DataContext {
description: DataDescription,
}
impl DataContext {
pub fn new() -> Self {
Self {
description: DataDescription {
writable: Writability::Readonly,
init: Init::Uninitialized,
function_decls: PrimaryMap::new(),
data_decls: PrimaryMap::new(),
function_relocs: Vec::new(),
data_relocs: Vec::new(),
},
}
}
pub fn clear(&mut self) {
self.description.writable = Writability::Readonly;
self.description.init = Init::Uninitialized;
self.description.function_decls.clear();
self.description.data_decls.clear();
self.description.function_relocs.clear();
self.description.data_relocs.clear();
}
pub fn define_zeroinit(&mut self, size: usize, writable: Writability) {
debug_assert_eq!(self.description.init, Init::Uninitialized);
self.description.writable = writable;
self.description.init = Init::Zeros { size };
}
pub fn define(&mut self, contents: Box<[u8]>, writable: Writability) {
debug_assert_eq!(self.description.init, Init::Uninitialized);
self.description.writable = writable;
self.description.init = Init::Bytes { contents };
}
pub fn import_function(&mut self, name: ir::ExternalName) -> ir::FuncRef {
self.description.function_decls.push(name)
}
pub fn import_global_value(&mut self, name: ir::ExternalName) -> ir::GlobalValue {
self.description.data_decls.push(name)
}
pub fn write_function_addr(&mut self, offset: CodeOffset, func: ir::FuncRef) {
self.description.function_relocs.push((offset, func))
}
pub fn write_data_addr(&mut self, offset: CodeOffset, data: ir::GlobalValue, addend: Addend) {
self.description.data_relocs.push((offset, data, addend))
}
pub fn description(&self) -> &DataDescription {
debug_assert!(
self.description.init != Init::Uninitialized,
"data must be initialized first"
);
&self.description
}
}
#[cfg(test)]
mod tests {
use cretonne_codegen::ir;
use {DataContext, Init, Writability};
#[test]
fn basic_data_context() {
let mut data_ctx = DataContext::new();
{
let description = &data_ctx.description;
assert_eq!(description.writable, Writability::Readonly);
assert_eq!(description.init, Init::Uninitialized);
assert!(description.function_decls.is_empty());
assert!(description.data_decls.is_empty());
assert!(description.function_relocs.is_empty());
assert!(description.data_relocs.is_empty());
}
data_ctx.define_zeroinit(256, Writability::Writable);
let _func_a = data_ctx.import_function(ir::ExternalName::user(0, 0));
let func_b = data_ctx.import_function(ir::ExternalName::user(0, 1));
let func_c = data_ctx.import_function(ir::ExternalName::user(1, 0));
let _data_a = data_ctx.import_global_value(ir::ExternalName::user(2, 2));
let data_b = data_ctx.import_global_value(ir::ExternalName::user(2, 3));
data_ctx.write_function_addr(8, func_b);
data_ctx.write_function_addr(16, func_c);
data_ctx.write_data_addr(32, data_b, 27);
{
let description = data_ctx.description();
assert_eq!(description.writable, Writability::Writable);
assert_eq!(description.init, Init::Zeros { size: 256 });
assert_eq!(description.function_decls.len(), 3);
assert_eq!(description.data_decls.len(), 2);
assert_eq!(description.function_relocs.len(), 2);
assert_eq!(description.data_relocs.len(), 1);
}
data_ctx.clear();
{
let description = &data_ctx.description;
assert_eq!(description.writable, Writability::Readonly);
assert_eq!(description.init, Init::Uninitialized);
assert!(description.function_decls.is_empty());
assert!(description.data_decls.is_empty());
assert!(description.function_relocs.is_empty());
assert!(description.data_relocs.is_empty());
}
let contents = vec![33, 34, 35, 36];
let contents_clone = contents.clone();
data_ctx.define(contents.into_boxed_slice(), Writability::Readonly);
{
let description = data_ctx.description();
assert_eq!(description.writable, Writability::Readonly);
assert_eq!(
description.init,
Init::Bytes {
contents: contents_clone.into_boxed_slice()
}
);
assert_eq!(description.function_decls.len(), 0);
assert_eq!(description.data_decls.len(), 0);
assert_eq!(description.function_relocs.len(), 0);
assert_eq!(description.data_relocs.len(), 0);
}
}
}