256 lines
8.6 KiB
Python
256 lines
8.6 KiB
Python
"""
|
|
Generate sources with settings.
|
|
"""
|
|
|
|
import srcgen
|
|
from unique_table import UniqueSeqTable
|
|
import constant_hash
|
|
from cretonne import camel_case, BoolSetting, NumSetting, EnumSetting, settings
|
|
|
|
|
|
def layout_group(sgrp):
|
|
"""
|
|
Layout the settings in sgrp, assigning byte and bit offsets.
|
|
|
|
Return the next unused byte offset.
|
|
"""
|
|
# Byte offset where booleans are allocated.
|
|
bool_byte = -1
|
|
# Next available bit number in bool_byte.
|
|
bool_bit = 10
|
|
# Next available whole byte.
|
|
next_byte = 0
|
|
|
|
for setting in sgrp.settings:
|
|
if isinstance(setting, BoolSetting):
|
|
# Allocate a bit from bool_byte.
|
|
if bool_bit > 7:
|
|
bool_byte = next_byte
|
|
next_byte += 1
|
|
bool_bit = 0
|
|
setting.byte_offset = bool_byte
|
|
setting.bit_offset = bool_bit
|
|
bool_bit += 1
|
|
else:
|
|
# This is a numerical or enumerated setting. Allocate a single
|
|
# byte.
|
|
setting.byte_offset = next_byte
|
|
next_byte += 1
|
|
|
|
return next_byte
|
|
|
|
|
|
def gen_enum_types(sgrp, fmt):
|
|
"""
|
|
Emit enum types for any enum settings.
|
|
"""
|
|
for setting in sgrp.settings:
|
|
if not isinstance(setting, EnumSetting):
|
|
continue
|
|
ty = camel_case(setting.name)
|
|
fmt.line('#[derive(Debug, PartialEq, Eq)]')
|
|
fmt.line(
|
|
'pub enum {} {{ {} }}'
|
|
.format(ty, ", ".join(camel_case(v) for v in setting.values)))
|
|
|
|
|
|
def gen_getter(setting, fmt):
|
|
"""
|
|
Emit a getter function for `setting`.
|
|
"""
|
|
fmt.doc_comment(setting.__doc__)
|
|
|
|
if isinstance(setting, BoolSetting):
|
|
proto = 'pub fn {}(&self) -> bool'.format(setting.name)
|
|
with fmt.indented(proto + ' {', '}'):
|
|
fmt.line('(self.bytes[{}] & (1 << {})) != 0'.format(
|
|
setting.byte_offset,
|
|
setting.bit_offset))
|
|
elif isinstance(setting, NumSetting):
|
|
proto = 'pub fn {}(&self) -> u8'.format(setting.name)
|
|
with fmt.indented(proto + ' {', '}'):
|
|
fmt.line('self.bytes[{}]'.format(setting.byte_offset))
|
|
elif isinstance(setting, EnumSetting):
|
|
ty = camel_case(setting.name)
|
|
proto = 'pub fn {}(&self) -> {}'.format(setting.name, ty)
|
|
with fmt.indented(proto + ' {', '}'):
|
|
with fmt.indented(
|
|
'match self.bytes[{}] {{'.format(setting.byte_offset), '}'):
|
|
for i, v in enumerate(setting.values):
|
|
fmt.line( '{} => {}::{},'.format(i, ty, camel_case(v)))
|
|
fmt.line( '_ => panic!("Invalid enum value")')
|
|
else:
|
|
raise AssertionError("Unknown setting kind")
|
|
|
|
|
|
def gen_getters(sgrp, fmt):
|
|
"""
|
|
Emit getter functions for all the settings in fmt.
|
|
"""
|
|
fmt.doc_comment("User-defined settings.")
|
|
with fmt.indented('impl Settings {', '}'):
|
|
for setting in sgrp.settings:
|
|
gen_getter(setting, fmt)
|
|
|
|
|
|
def gen_default(sgrp, byte_size, fmt):
|
|
"""
|
|
Emit a Default impl for Settings.
|
|
"""
|
|
v = [0] * byte_size
|
|
for setting in sgrp.settings:
|
|
v[setting.byte_offset] |= setting.default_byte()
|
|
|
|
with fmt.indented('impl Default for Settings {', '}'):
|
|
fmt.doc_comment('Return a `Settings` object with default values.')
|
|
with fmt.indented('fn default() -> Settings {', '}'):
|
|
with fmt.indented('Settings {', '}'):
|
|
vs = ', '.join('{:#04x}'.format(x) for x in v)
|
|
fmt.line('bytes: [ {} ],'.format(vs))
|
|
|
|
|
|
def gen_descriptors(sgrp, fmt):
|
|
"""
|
|
Generate the DESCRIPTORS and ENUMERATORS tables.
|
|
"""
|
|
|
|
enums = UniqueSeqTable()
|
|
|
|
with fmt.indented(
|
|
'const DESCRIPTORS: [Descriptor; {}] = ['
|
|
.format(len(sgrp.settings)),
|
|
'];'):
|
|
for idx, setting in enumerate(sgrp.settings):
|
|
setting.descriptor_index = idx
|
|
with fmt.indented('Descriptor {', '},'):
|
|
fmt.line('name: "{}",'.format(setting.name))
|
|
fmt.line('offset: {},'.format(setting.byte_offset))
|
|
if isinstance(setting, BoolSetting):
|
|
fmt.line(
|
|
'detail: Detail::Bool {{ bit: {} }},'
|
|
.format(setting.bit_offset))
|
|
elif isinstance(setting, NumSetting):
|
|
fmt.line('detail: Detail::Num,')
|
|
elif isinstance(setting, EnumSetting):
|
|
offs = enums.add(setting.values)
|
|
fmt.line(
|
|
'detail: Detail::Enum {{ last: {}, enumerators: {} }},'
|
|
.format(len(setting.values)-1, offs))
|
|
else:
|
|
raise AssertionError("Unknown setting kind")
|
|
|
|
with fmt.indented(
|
|
'const ENUMERATORS: [&\'static str; {}] = ['
|
|
.format(len(enums.table)),
|
|
'];'):
|
|
for txt in enums.table:
|
|
fmt.line('"{}",'.format(txt))
|
|
|
|
def hash_setting(s):
|
|
return constant_hash.simple_hash(s.name)
|
|
|
|
hash_table = constant_hash.compute_quadratic(sgrp.settings, hash_setting)
|
|
if len(sgrp.settings) > 0xffff:
|
|
ty = 'u32'
|
|
elif len(sgrp.settings) > 0xff:
|
|
ty = 'u16'
|
|
else:
|
|
ty = 'u8'
|
|
|
|
with fmt.indented(
|
|
'const HASH_TABLE: [{}; {}] = ['
|
|
.format(ty, len(hash_table)),
|
|
'];'):
|
|
for h in hash_table:
|
|
if h is None:
|
|
fmt.line('{},'.format(len(sgrp.settings)))
|
|
else:
|
|
fmt.line('{},'.format(h.descriptor_index))
|
|
|
|
|
|
def gen_stringwise(sgrp, fmt):
|
|
"""
|
|
Generate the Stringwise implementation and supporting tables.
|
|
"""
|
|
|
|
with fmt.indented('impl Stringwise for Settings {', '}'):
|
|
with fmt.indented(
|
|
'fn lookup(&self, name: &str)' +
|
|
'-> Result<(usize, Detail)> {',
|
|
'}'):
|
|
fmt.line('use simple_hash::simple_hash;')
|
|
fmt.line('let tlen = HASH_TABLE.len();')
|
|
fmt.line('assert!(tlen.is_power_of_two());')
|
|
fmt.line('let mut idx = simple_hash(name) as usize;')
|
|
fmt.line('let mut step: usize = 0;')
|
|
with fmt.indented('loop {', '}'):
|
|
fmt.line('idx = idx % tlen;')
|
|
fmt.line('let entry = HASH_TABLE[idx] as usize;')
|
|
with fmt.indented('if entry >= DESCRIPTORS.len() {', '}'):
|
|
fmt.line('return Err(Error::BadName)')
|
|
with fmt.indented('if DESCRIPTORS[entry].name == name {', '}'):
|
|
fmt.line(
|
|
'return Ok((DESCRIPTORS[entry].offset as usize, ' +
|
|
'DESCRIPTORS[entry].detail))')
|
|
fmt.line('step += 1;')
|
|
fmt.line('assert!(step < tlen);')
|
|
fmt.line('idx += step;')
|
|
|
|
with fmt.indented(
|
|
'fn enumerator(&self, enums: u16, value: u8)' +
|
|
'-> &\'static str {',
|
|
'}'):
|
|
fmt.line('ENUMERATORS[enums as usize + value as usize]')
|
|
|
|
with fmt.indented('fn raw_bytes_mut(&mut self) -> &mut [u8] {', '}'):
|
|
fmt.line('&mut self.bytes')
|
|
|
|
def gen_display(sgrp, fmt):
|
|
"""
|
|
Generate the Display impl for Settings.
|
|
"""
|
|
with fmt.indented('impl fmt::Display for Settings {', '}'):
|
|
with fmt.indented(
|
|
'fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {',
|
|
'}'):
|
|
fmt.line('try!(writeln!(f, "[{}]"));'.format(sgrp.name))
|
|
with fmt.indented('for d in &DESCRIPTORS {', '}'):
|
|
fmt.line('try!(write!(f, "{} = ", d.name));')
|
|
fmt.line(
|
|
'try!(self.format_toml_value(d.detail,' +
|
|
'self.bytes[d.offset as usize], f));')
|
|
fmt.line('try!(writeln!(f, ""));')
|
|
fmt.line('Ok(())')
|
|
|
|
|
|
def gen_group(sgrp, fmt):
|
|
"""
|
|
Generate a Settings struct representing `sgrp`.
|
|
"""
|
|
byte_size = layout_group(sgrp)
|
|
|
|
fmt.doc_comment('Settings group `{}`.'.format(sgrp.name))
|
|
with fmt.indented('pub struct Settings {', '}'):
|
|
fmt.line('bytes: [u8; {}],'.format(byte_size))
|
|
|
|
gen_enum_types(sgrp, fmt)
|
|
gen_getters(sgrp, fmt)
|
|
gen_default(sgrp, byte_size, fmt)
|
|
gen_descriptors(sgrp, fmt)
|
|
gen_stringwise(sgrp, fmt)
|
|
gen_display(sgrp, fmt)
|
|
|
|
|
|
def generate(isas, out_dir):
|
|
# Generate shared settings.
|
|
fmt = srcgen.Formatter()
|
|
gen_group(settings.group, fmt)
|
|
fmt.update_file('settings.rs', out_dir)
|
|
|
|
# Generate ISA-specific settings.
|
|
for isa in isas:
|
|
if isa.settings:
|
|
fmt = srcgen.Formatter()
|
|
gen_group(isa.settings, fmt)
|
|
fmt.update_file('settings-{}.rs'.format(isa.name), out_dir)
|