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

Add a settings::Builder data type.

Browse Source 
- Move detail data structures into a settings::detail module to avoid polluting
  the settings namespace.

- Rename generated data types to 'Flags' in anticipation of computed predicate
  flags that can't be set. The Flags struct is immutable.

- Use a settings::Builder struct to manipulate settings, then pass it to
  Flags::new().
This commit is contained in:
Jakob Stoklund Olesen
2016-08-10 15:28:17 -07:00
parent 56cb249e13
commit 6e6ad1ef52
3 changed files with 292 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
cranelift/src/libcretonne/isa/riscv/settings.rs
View File

@@ -1,20 +1,21 @@
//! RISC-V Settings.
use settings::{Descriptor, Detail, Stringwise, Result, Error};
use settings::{detail, Builder};
use std::fmt;
// Include code generated by `meta/gen_settings.py`. This file contains a public `Settings` struct
// Include code generated by `meta/gen_settings.py`. This file contains a public `Flags` struct
// with an impl for all of the settings defined in `meta/cretonne/settings.py`.
include!(concat!(env!("OUT_DIR"), "/settings-riscv.rs"));
#[cfg(test)]
mod tests {
use super::Settings;
use super::{builder, Flags};
#[test]
fn display_default() {
let s = Settings::default();
assert_eq!(s.to_string(),
let b = builder();
let f = Flags::new(b);
assert_eq!(f.to_string(),
"[riscv]\n\
supports_m = false\n\
supports_a = false\n\

366
cranelift/src/libcretonne/settings.rs
View File

@@ -2,49 +2,151 @@
//!
//! This module defines data structures to access the settings defined in the meta language.
//!
//! Each settings group is translated to a `Settings` struct either in this module or in its
//! Each settings group is translated to a `Flags` struct either in this module or in its
//! ISA-specific `settings` module. The struct provides individual getter methods for all of the
//! settings. It also implements the `Stringwise` trait which allows settings to be manipulated by
//! name.
//! settings as well as computed predicate flags.
//!
//! The `Flags` struct is immutable once it has been created. A `Builder` instance is used to
//! create it.
//!
//! # Example
//! ```
//! use cretonne::settings::{self, Configurable};
//!
//! let mut b = settings::builder();
//! b.set("opt_level", "fastest");
//!
//! let f = settings::Flags::new(b);
//! assert_eq!(f.opt_level(), settings::OptLevel::Fastest);
//! ```
use std::fmt;
use std::result;
/// A setting descriptor holds the information needed to generically set and print a setting.
use simple_hash::simple_hash;
/// A string-based configurator for settings groups.
///
/// Each settings group will be represented as a constant DESCRIPTORS array.
pub struct Descriptor {
/// Lower snake-case name of setting as defined in meta.
pub name: &'static str,
/// The `Configurable` protocol allows settings to be modified by name before a finished `Flags`
/// struct is created.
pub trait Configurable {
/// Set the string value of any setting by name.
///
/// This can set any type of setting whether it is numeric, boolean, or enumerated.
fn set(&mut self, name: &str, value: &str) -> Result<()>;
/// Offset of byte containing this setting.
pub offset: u32,
/// Additional details, depending on the kind of setting.
pub detail: Detail,
/// Set the value of a boolean setting by name.
///
/// If the identified setting isn't a boolean, a `BadType` error is returned.
fn set_bool(&mut self, name: &str, value: bool) -> Result<()>;
}
/// The different kind of settings along with descriptor bits that depend on the kind.
#[derive(Clone, Copy)]
pub enum Detail {
/// A boolean setting only uses one bit, numbered from LSB.
Bool {
bit: u8,
},
/// A numerical setting uses the whole byte.
Num,
/// An Enum setting uses a range of enumerators.
Enum {
/// Numerical value of last enumerator, allowing for 1-256 enumerators.
last: u8,
/// First enumerator in the ENUMERATORS table.
enumerators: u16,
},
/// Collect settings values based on a template.
pub struct Builder {
template: &'static detail::Template,
bytes: Vec<u8>,
}
impl Builder {
/// Create a new builder with defaults and names from the given template.
pub fn new(tmpl: &'static detail::Template) -> Builder {
Builder {
template: tmpl,
bytes: tmpl.defaults.into(),
}
}
/// Extract contents of builder once everything is configured.
pub fn finish(self, name: &str) -> Vec<u8> {
assert_eq!(name, self.template.name);
self.bytes
}
/// Set the value of a single bit.
fn set_bit(&mut self, offset: usize, bit: u8, value: bool) {
let byte = &mut self.bytes[offset];
let mask = 1 << bit;
if value {
*byte |= mask;
} else {
*byte &= !mask;
}
}
/// Look up a descriptor by name.
fn lookup(&self, name: &str) -> Result<(usize, detail::Detail)> {
let table = self.template.hash_table;
let descs = self.template.descriptors;
let mask = table.len() - 1;
assert!((mask + 1).is_power_of_two());
let mut idx = simple_hash(name) as usize;
let mut step: usize = 0;
loop {
idx = idx & mask;
let entry = table[idx] as usize;
if entry >= descs.len() {
return Err(Error::BadName);
}
let desc = &descs[entry];
if desc.name == name {
return Ok((desc.offset as usize, desc.detail));
}
step += 1;
assert!(step <= mask);
idx += step;
}
}
}
fn parse_bool_value(value: &str) -> Result<bool> {
match value {
"true" | "on" | "yes" | "1" => Ok(true),
"false" | "off" | "no" | "0" => Ok(false),
_ => Err(Error::BadValue),
}
}
fn parse_enum_value(value: &str, choices: &[&str]) -> Result<u8> {
match choices.iter().position(|&tag| tag == value) {
Some(idx) => Ok(idx as u8),
None => Err(Error::BadValue),
}
}
impl Configurable for Builder {
fn set_bool(&mut self, name: &str, value: bool) -> Result<()> {
use self::detail::Detail;
let (offset, detail) = try!(self.lookup(name));
if let Detail::Bool { bit } = detail {
self.set_bit(offset, bit, value);
Ok(())
} else {
Err(Error::BadType)
}
}
fn set(&mut self, name: &str, value: &str) -> Result<()> {
use self::detail::Detail;
let (offset, detail) = try!(self.lookup(name));
match detail {
Detail::Bool { bit } => {
self.set_bit(offset, bit, try!(parse_bool_value(value)));
}
Detail::Num => {
self.bytes[offset] = try!(value.parse().map_err(|_| Error::BadValue));
}
Detail::Enum { last, enumerators } => {
self.bytes[offset] = try!(parse_enum_value(value,
self.template.enums(last, enumerators)));
}
}
Ok(())
}
}
/// An error produced when changing a setting.
#[derive(Debug, PartialEq, Eq)]
pub enum Error {
/// No setting by this name exists.
@@ -59,143 +161,133 @@ pub enum Error {
pub type Result<T> = result::Result<T, Error>;
fn parse_bool_value(value: &str) -> Result<bool> {
match value {
"true" | "on" | "yes" | "1" => Ok(true),
"false" | "off" | "no" | "0" => Ok(false),
_ => Err(Error::BadValue),
/// Implementation details for generated code.
///
/// This module holds definitions that need to be public so the can be instantiated by generated
/// code in other modules.
pub mod detail {
use std::fmt;
/// An instruction group template.
pub struct Template {
pub name: &'static str,
pub descriptors: &'static [Descriptor],
pub enumerators: &'static [&'static str],
pub hash_table: &'static [u16],
pub defaults: &'static [u8],
}
}
/// Interface for working with a group of settings as strings.
pub trait Stringwise {
/// Look up a setting by name, return the byte offset and details of the setting.
fn lookup(&self, name: &str) -> Result<(usize, Detail)>;
/// Get an enumerator string from the `Detail::enumerators` value and an offset.
fn enumerator(&self, enums: u16, value: u8) -> &'static str;
/// Get the underlying byte array used to store settings.
fn raw_bytes_mut(&mut self) -> &mut [u8];
/// Format a setting value as a TOML string. This is mostly for use by the generated `Display`
/// implementation.
fn format_toml_value(&self, detail: Detail, byte: u8, f: &mut fmt::Formatter) -> fmt::Result {
match detail {
Detail::Bool { bit } => write!(f, "{}", (byte & (1 << bit)) != 0),
Detail::Num => write!(f, "{}", byte),
Detail::Enum { last, enumerators } => {
if byte <= last {
write!(f, "\"{}\"", self.enumerator(enumerators, byte))
} else {
write!(f, "{}", byte)
}
}
impl Template {
/// Get enumerators corresponding to a `Details::Enum`.
pub fn enums(&self, last: u8, enumerators: u16) -> &[&'static str] {
let from = enumerators as usize;
let len = last as usize + 1;
&self.enumerators[from..from + len]
}
}
/// Set a boolean setting by name.
fn set_bool(&mut self, name: &str, value: bool) -> Result<()> {
let (offset, detail) = try!(self.lookup(name));
if let Detail::Bool { bit } = detail {
let mask = 1 << bit;
let byte = &mut self.raw_bytes_mut()[offset];
if value {
*byte |= mask;
} else {
*byte &= !mask;
}
Ok(())
} else {
Err(Error::BadType)
}
}
/// Set the string value of a named setting.
///
/// For boolean settings, any of the values accepted by `parse_bool_value` above are accepted
/// (true/false, on/off, yes/no, 1/0).
///
/// For enumerated settings, the value must match one of the allowed values exactly.
fn set(&mut self, name: &str, value: &str) -> Result<()> {
let (offset, detail) = try!(self.lookup(name));
match detail {
Detail::Bool { bit } => {
let mask = 1 << bit;
let byte = &mut self.raw_bytes_mut()[offset];
if try!(parse_bool_value(value)) {
*byte |= mask;
} else {
*byte &= !mask;
}
}
Detail::Num => {
self.raw_bytes_mut()[offset] = try!(value.parse().map_err(|_| Error::BadValue));
}
Detail::Enum { last, enumerators } => {
// Linear search..
for i in 0.. {
if value == self.enumerator(enumerators, i) {
self.raw_bytes_mut()[offset] = i;
break;
}
if i == last {
return Err(Error::BadValue);
/// Format a setting value as a TOML string. This is mostly for use by the generated
/// `Display` implementation.
pub fn format_toml_value(&self,
detail: Detail,
byte: u8,
f: &mut fmt::Formatter)
-> fmt::Result {
match detail {
Detail::Bool { bit } => write!(f, "{}", (byte & (1 << bit)) != 0),
Detail::Num => write!(f, "{}", byte),
Detail::Enum { last, enumerators } => {
if byte <= last {
let tags = self.enums(last, enumerators);
write!(f, "\"{}\"", tags[byte as usize])
} else {
write!(f, "{}", byte)
}
}
}
}
Ok(())
}
/// A setting descriptor holds the information needed to generically set and print a setting.
///
/// Each settings group will be represented as a constant DESCRIPTORS array.
pub struct Descriptor {
/// Lower snake-case name of setting as defined in meta.
pub name: &'static str,
/// Offset of byte containing this setting.
pub offset: u32,
/// Additional details, depending on the kind of setting.
pub detail: Detail,
}
/// The different kind of settings along with descriptor bits that depend on the kind.
#[derive(Clone, Copy)]
pub enum Detail {
/// A boolean setting only uses one bit, numbered from LSB.
Bool {
bit: u8,
},
/// A numerical setting uses the whole byte.
Num,
/// An Enum setting uses a range of enumerators.
Enum {
/// Numerical value of last enumerator, allowing for 1-256 enumerators.
last: u8,
/// First enumerator in the ENUMERATORS table.
enumerators: u16,
},
}
}
// Include code generated by `meta/gen_settings.py`. This file contains a public `Settings` struct
// Include code generated by `meta/gen_settings.py`. This file contains a public `Flags` struct
// with an impl for all of the settings defined in `meta/cretonne/settings.py`.
include!(concat!(env!("OUT_DIR"), "/settings.rs"));
#[cfg(test)]
mod tests {
use super::Settings;
use super::{builder, Flags};
use super::Error::*;
use super::Stringwise;
use super::Configurable;
#[test]
fn display_default() {
let s = Settings::default();
assert_eq!(s.to_string(),
let b = builder();
let f = Flags::new(b);
assert_eq!(f.to_string(),
"[shared]\n\
opt_level = \"default\"\n\
enable_simd = true\n");
assert_eq!(f.opt_level(), super::OptLevel::Default);
assert_eq!(f.enable_simd(), true);
}
#[test]
fn modify_bool() {
let mut s = Settings::default();
assert_eq!(s.enable_simd(), true);
assert_eq!(s.set_bool("not_there", true), Err(BadName));
let mut b = builder();
assert_eq!(b.set_bool("not_there", true), Err(BadName));
assert_eq!(b.set_bool("enable_simd", true), Ok(()));
assert_eq!(b.set_bool("enable_simd", false), Ok(()));
assert_eq!(s.set_bool("enable_simd", true), Ok(()));
assert_eq!(s.enable_simd(), true);
assert_eq!(s.set_bool("enable_simd", false), Ok(()));
assert_eq!(s.enable_simd(), false);
let f = Flags::new(b);
assert_eq!(f.enable_simd(), false);
}
#[test]
fn modify_string() {
let mut s = Settings::default();
assert_eq!(s.enable_simd(), true);
assert_eq!(s.opt_level(), super::OptLevel::Default);
let mut b = builder();
assert_eq!(b.set("not_there", "true"), Err(BadName));
assert_eq!(b.set("enable_simd", ""), Err(BadValue));
assert_eq!(b.set("enable_simd", "best"), Err(BadValue));
assert_eq!(b.set("opt_level", "true"), Err(BadValue));
assert_eq!(b.set("opt_level", "best"), Ok(()));
assert_eq!(b.set("enable_simd", "0"), Ok(()));
assert_eq!(s.set("not_there", "true"), Err(BadName));
assert_eq!(s.set("enable_simd", ""), Err(BadValue));
assert_eq!(s.set("enable_simd", "best"), Err(BadValue));
assert_eq!(s.set("opt_level", "true"), Err(BadValue));
assert_eq!(s.set("enable_simd", "no"), Ok(()));
assert_eq!(s.enable_simd(), false);
assert_eq!(s.set("opt_level", "best"), Ok(()));
assert_eq!(s.opt_level(), super::OptLevel::Best);
let f = Flags::new(b);
assert_eq!(f.enable_simd(), false);
assert_eq!(f.opt_level(), super::OptLevel::Best);
}
}