From 2bd02047ac741f9783e024a6ee7ca2a37056b409 Mon Sep 17 00:00:00 2001 From: Pedro Torruella Date: Wed, 1 Sep 2021 07:34:29 +0000 Subject: [PATCH 1/5] Adding first version of support for edif --- src/langs/edif/Cargo.toml | 22 + src/langs/edif/README.md | 15 + src/langs/edif/examples/Makefile | 23 + src/langs/edif/examples/do_all.sh | 13 + src/langs/edif/examples/load_edif.tcl | 36 + src/langs/edif/examples/xilinx_inverter.rs | 32 + src/langs/edif/examples/xilinx_multiplier.rs | 31 + src/langs/edif/src/edifier/Cargo.toml | 12 + src/langs/edif/src/edifier/src/ast.rs | 183 ++++ src/langs/edif/src/edifier/src/helpers.rs | 413 ++++++++ src/langs/edif/src/edifier/src/lib.rs | 19 + src/langs/edif/src/edifier/src/main.rs | 52 + src/langs/edif/src/edifier/src/serialize.rs | 449 ++++++++ .../edif/src/edifier/src/string_helpers.rs | 52 + .../src/edifier/tests/string_helpers_ut.rs | 28 + .../edif/src/edifier/tests/unit_tests.rs | 348 +++++++ src/langs/edif/src/platforms/Cargo.toml | 13 + src/langs/edif/src/platforms/src/lib.rs | 16 + src/langs/edif/src/platforms/src/xilinx.rs | 971 ++++++++++++++++++ .../edif/src/platforms/tests/xilinx_ut.rs | 113 ++ src/langs/edif/src/xilinx_multiplier.edf | 1 + src/langs/edif/xilinx_multiplier.edf | 666 ++++++++++++ 22 files changed, 3508 insertions(+) create mode 100644 src/langs/edif/Cargo.toml create mode 100644 src/langs/edif/README.md create mode 100644 src/langs/edif/examples/Makefile create mode 100755 src/langs/edif/examples/do_all.sh create mode 100644 src/langs/edif/examples/load_edif.tcl create mode 100644 src/langs/edif/examples/xilinx_inverter.rs create mode 100644 src/langs/edif/examples/xilinx_multiplier.rs create mode 100644 src/langs/edif/src/edifier/Cargo.toml create mode 100644 src/langs/edif/src/edifier/src/ast.rs create mode 100644 src/langs/edif/src/edifier/src/helpers.rs create mode 100644 src/langs/edif/src/edifier/src/lib.rs create mode 100644 src/langs/edif/src/edifier/src/main.rs create mode 100644 src/langs/edif/src/edifier/src/serialize.rs create mode 100644 src/langs/edif/src/edifier/src/string_helpers.rs create mode 100644 src/langs/edif/src/edifier/tests/string_helpers_ut.rs create mode 100644 src/langs/edif/src/edifier/tests/unit_tests.rs create mode 100644 src/langs/edif/src/platforms/Cargo.toml create mode 100644 src/langs/edif/src/platforms/src/lib.rs create mode 100644 src/langs/edif/src/platforms/src/xilinx.rs create mode 100644 src/langs/edif/src/platforms/tests/xilinx_ut.rs create mode 100644 src/langs/edif/src/xilinx_multiplier.edf create mode 100644 src/langs/edif/xilinx_multiplier.edf diff --git a/src/langs/edif/Cargo.toml b/src/langs/edif/Cargo.toml new file mode 100644 index 00000000..10ceffe3 --- /dev/null +++ b/src/langs/edif/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "edifier_top" +version = "0.1.0" +authors = ["Pedro Torruella "] +license = "Apache-2.0" +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +edifier = { path = "src/edifier" } +platforms = { path = "src/platforms" } +serde = { version = "1.0", features = ["derive", "rc"] } +serde_sexpr = "0.1.0" + +[workspace] +members = [ + "src/edifier", + "src/platforms", +] + +exclude = ["others"] \ No newline at end of file diff --git a/src/langs/edif/README.md b/src/langs/edif/README.md new file mode 100644 index 00000000..8906ac19 --- /dev/null +++ b/src/langs/edif/README.md @@ -0,0 +1,15 @@ +# edifier +Like an emulsifier, edifier aims to allow you to mix rust and edif. + +The goal of this is to turn it into a crate to allow the generation of edif files programatically from a Rust program. + +# Project Structure +The project has the following areas: +* examples: this is a good point of entry as it will quicky show you a template for your application. +* src: this is the place where we have stored the code, separated in crates. + * edifier: This crate is the core of the project, provides generic edif utilities. + * platforms: This crate hosts a non-comprehensive list of platform specific support functions, mainly for unit-testing/example. +* others: random files to support development. + +# Still under construction +Please do not integrate just yet as it is still early days... diff --git a/src/langs/edif/examples/Makefile b/src/langs/edif/examples/Makefile new file mode 100644 index 00000000..c0412400 --- /dev/null +++ b/src/langs/edif/examples/Makefile @@ -0,0 +1,23 @@ +OUT_DIR = $(abspath .)/out + +NAME ?= "xilinx_inverter" +IMPL_FILE = $(NAME).v +EDIF_FILE = $(NAME).edf +NETLIST_FILE = $(NAME)_netlist.v +TIME_FILE = $(OUT_DIR)/$(NAME)_time.txt +UTIL_FILE = $(OUT_DIR)/$(NAME)_util.txt +DCP_FILE = $(OUT_DIR)/$(NAME).dcp + +.PHONY: all +all: | $(OUT_DIR) + vivado -mode batch -source load_edif.tcl -tclargs $(NAME) $(IMPL_FILE) $(UTIL_FILE) $(TIME_FILE) $(DCP_FILE) $(NETLIST_FILE) $(EDIF_FILE) + + +$(OUT_DIR): + mkdir -p $@ + +clean-logs: + rm -rf ./*jou ./*.log + +clean: + rm -rf $(OUT_DIR) \ No newline at end of file diff --git a/src/langs/edif/examples/do_all.sh b/src/langs/edif/examples/do_all.sh new file mode 100755 index 00000000..70c90f25 --- /dev/null +++ b/src/langs/edif/examples/do_all.sh @@ -0,0 +1,13 @@ +#!/bin/bash +OUTLOG=output.txt + +cargo run --example xilinx_inverter + +source /tools/Xilinx/Vivado/2020.1/settings64.sh +time make all > $OUTLOG + +#source /tools/Xilinx/Vivado/2020.2/settings64.sh +#time make all >> $OUTLOG + +#source /tools/Xilinx/Vivado/2021.1/settings64.sh +#time make all >> $OUTLOG \ No newline at end of file diff --git a/src/langs/edif/examples/load_edif.tcl b/src/langs/edif/examples/load_edif.tcl new file mode 100644 index 00000000..f697072c --- /dev/null +++ b/src/langs/edif/examples/load_edif.tcl @@ -0,0 +1,36 @@ +set top_name [lindex $argv 0] +set verilog_file [lindex $argv 1] +set utilization_file [lindex $argv 2] +set timing_file [lindex $argv 3] +set dcp_file [lindex $argv 4] +set netlist_file [lindex $argv 5] +set edif_file [lindex $argv 6] +set edif_file_placed [lindex $argv 6].placed +set edif_file_routed [lindex $argv 6].routed +#set part_name "xczu3eg-sbva484-1-e" + +# Set target part +#set_part $part_name + +# Read the netlist from third-party synthesis tool +read_edif $edif_file + +# Read in the IP XCIs +#read_ip ip1.xci +#read_ip ip2.xci + +# read in top level constraints +#read_xdc top.xdc + +# Implement the design +link_design -top $top_name + +# at this point we would have done opt_design and placement +#phys_opt_design +place_design -directive Default +write_edif -force $edif_file_placed +route_design -directive Default +write_edif -force $edif_file_routed +report_timing -file $timing_file +report_utilization -file $utilization_file +#write_bitstream -file $top_name.bit \ No newline at end of file diff --git a/src/langs/edif/examples/xilinx_inverter.rs b/src/langs/edif/examples/xilinx_inverter.rs new file mode 100644 index 00000000..91a85ef5 --- /dev/null +++ b/src/langs/edif/examples/xilinx_inverter.rs @@ -0,0 +1,32 @@ +use edifier::string_helpers::add_new_lines; +use platforms::xilinx::inverter; +use std::fs::File; +use std::io::Write; +use std::path::Path; + +static DOFILE: bool = true; + +fn main() { + let edif = inverter(); + + let serialized = serde_sexpr::to_string(&edif).unwrap(); + let edif_string = add_new_lines(serialized, 5, true); + + if DOFILE { + let path = Path::new("xilinx_inverter.edf"); + let display = path.display(); + + // Open a file in write-only mode, returns `io::Result` + let mut file = match File::create(&path) { + Err(why) => panic!("couldn't create {}: {}", display, why), + Ok(file) => file, + }; + + match file.write_all(edif_string.as_bytes()) { + Err(why) => panic!("couldn't write to {}: {}", display, why), + Ok(_) => println!("successfully wrote to {}", display), + } + } else { + println!("{}", edif_string); + }; +} diff --git a/src/langs/edif/examples/xilinx_multiplier.rs b/src/langs/edif/examples/xilinx_multiplier.rs new file mode 100644 index 00000000..d32be41e --- /dev/null +++ b/src/langs/edif/examples/xilinx_multiplier.rs @@ -0,0 +1,31 @@ +use edifier::string_helpers::add_new_lines; +use platforms::xilinx::dsp; +use std::fs::File; +use std::io::Write; +use std::path::Path; + +static DOFILE: bool = true; + +fn main() { + let edif = dsp(); + let serialized = serde_sexpr::to_string(&edif).unwrap(); + let edif_string = add_new_lines(serialized, 7, true); + + if DOFILE { + let path = Path::new("xilinx_multiplier.edf"); + let display = path.display(); + + // Open a file in write-only mode, returns `io::Result` + let mut file = match File::create(&path) { + Err(why) => panic!("couldn't create {}: {}", display, why), + Ok(file) => file, + }; + + match file.write_all(edif_string.as_bytes()) { + Err(why) => panic!("couldn't write to {}: {}", display, why), + Ok(_) => println!("successfully wrote to {}", display), + } + } else { + println!("{}", edif_string); + }; +} diff --git a/src/langs/edif/src/edifier/Cargo.toml b/src/langs/edif/src/edifier/Cargo.toml new file mode 100644 index 00000000..bada3581 --- /dev/null +++ b/src/langs/edif/src/edifier/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "edifier" +version = "0.1.0" +authors = ["Pedro Torruella "] +license = "Apache-2.0" +edition = "2018" + +[dependencies] +serde = { version = "1.0", features = ["derive", "rc"] } +serde_sexpr = "0.1.0" +expect-test = "1.0.2" +derive_more = { version = "0.99.14" , features = ["from"] } \ No newline at end of file diff --git a/src/langs/edif/src/edifier/src/ast.rs b/src/langs/edif/src/edifier/src/ast.rs new file mode 100644 index 00000000..e36d6c11 --- /dev/null +++ b/src/langs/edif/src/edifier/src/ast.rs @@ -0,0 +1,183 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +use derive_more::{Deref, DerefMut, From}; +use serde::Serialize; + +#[derive(Debug)] +pub struct Rename { + pub from: String, + pub to: String, +} + +// TODO: probably create a module to allow these fields to +// be private +#[derive(Debug, Clone)] +pub struct GenericRef { + pub name: String, + pub reference: String, +} + +#[derive(Debug, From, Serialize)] +pub struct LibraryRef(pub GenericRef); + +#[derive(Debug, From, Serialize, Clone)] +pub struct InstanceRef(pub GenericRef); + +#[derive(Debug, From)] +pub enum PropertyValue { + Integer(i32), + String(String), +} + +#[derive(Debug)] +pub struct Property { + pub name: String, + pub property: PropertyValue, +} + +#[derive(Debug, Deref, DerefMut, From, Serialize)] +pub struct PropertyList(pub Vec); + +#[derive(Debug)] +pub struct PortMember { + pub name: String, + pub index: u32, +} + +#[derive(Debug, From)] +pub enum PortRefToken { + Name(String), + Member(PortMember), +} + +#[derive(Debug)] +pub struct PortRef { + pub token: PortRefToken, + pub instanceref: InstanceRef, +} + +#[derive(Debug, Deref, DerefMut)] +pub struct PortList(pub Vec); + +#[derive(Debug, From)] +pub enum StringToken { + Name(String), + Rename(Rename), +} + +#[derive(Debug)] +pub struct ContentNet { + pub token: StringToken, + pub portlist: PortList, +} + +#[derive(Debug)] +pub struct CellRef { + pub name: String, + pub libraryref: LibraryRef, +} + +#[derive(Debug)] +pub struct ContentInstance { + pub token: StringToken, + pub viewref: String, + pub cellref: CellRef, + pub properties: PropertyList, +} + +#[derive(Debug, From)] +pub enum ContentElement { + Instance(ContentInstance), + Net(ContentNet), +} + +#[derive(Debug, Deref, DerefMut)] +pub struct CellContents(pub Vec); + +#[derive(Debug, From)] +pub enum PortDirection { + Input, + Output, +} + +#[derive(Debug, From)] +pub struct PortArray { + pub rename: Rename, + pub length: i32, +} + +#[derive(Debug, From)] +pub enum PortToken { + Name(String), + Array(PortArray), +} + +#[derive(Debug)] +pub struct InterfacePort { + pub token: PortToken, + pub direction: PortDirection, +} + +#[derive(Debug, Deref, DerefMut)] +pub struct CellInterface(pub Vec); + +#[derive(Debug)] +pub struct CellView { + pub name: String, + pub interface: CellInterface, + pub contents: CellContents, + pub properties: PropertyList, +} + +#[derive(Debug, Deref, DerefMut, From)] +pub struct CellViews(pub Vec); + +#[derive(Debug)] +pub struct Cell { + pub name: String, + pub views: CellViews, +} + +#[derive(Debug, Deref, DerefMut, From, Serialize)] +pub struct Cells(pub Vec); + +#[derive(Debug)] +pub struct Library { + pub name: String, + pub elements: Cells, +} + +#[derive(Debug)] +pub struct Design { + pub name: String, + pub cellref: CellRef, + pub properties: PropertyList, +} + +#[derive(Debug, From)] +pub enum EdifElement { + Library(Library), + Design(Design), +} + +#[derive(Debug, Deref, DerefMut, From, Serialize)] +pub struct EdifElements(pub Vec); + +#[derive(Debug)] +pub struct Edif { + pub name: String, + pub elements: EdifElements, +} diff --git a/src/langs/edif/src/edifier/src/helpers.rs b/src/langs/edif/src/edifier/src/helpers.rs new file mode 100644 index 00000000..129b98ec --- /dev/null +++ b/src/langs/edif/src/edifier/src/helpers.rs @@ -0,0 +1,413 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +use crate::ast::*; + +impl Rename { + pub fn new(from: S, to: S) -> Self + where + S: AsRef, + { + Rename { + from: from.as_ref().to_string(), + to: to.as_ref().to_string(), + } + } +} + +impl GenericRef { + pub fn new(name: S, reference: S) -> Self + where + S: AsRef, + { + GenericRef { + name: name.as_ref().to_string(), + reference: reference.as_ref().to_string(), + } + } + + pub fn is_empty(&self) -> bool { + self.reference.is_empty() + } +} + +impl LibraryRef { + pub fn new(reference: S) -> Self + where + S: AsRef, + { + LibraryRef::from(GenericRef::new("libraryref", reference.as_ref())) + } + + pub fn is_empty(&self) -> bool { + self.0.reference.is_empty() + } +} + +impl InstanceRef { + pub fn new(reference: S) -> Self + where + S: AsRef, + { + InstanceRef::from(GenericRef::new("instanceref", reference.as_ref())) + } + + pub fn is_empty(&self) -> bool { + self.0.reference.is_empty() + } +} + +impl CellRef { + pub fn new(name: S, libref: S) -> Self + where + S: AsRef, + { + CellRef { + name: name.as_ref().to_string(), + libraryref: LibraryRef::new(libref), + } + } +} + +impl Property { + // TODO: is there a way to have a single def of new for multiple types? + pub fn new_integer(name: S, val: i32) -> Self + where + S: AsRef, + { + Property { + name: name.as_ref().to_string(), + property: PropertyValue::from(val), + } + } + + pub fn new_string(name: S, val: S) -> Self + where + S: AsRef, + { + Property { + name: name.as_ref().to_string(), + property: PropertyValue::from(val.as_ref().to_string()), + } + } +} + +impl PortRefToken { + pub fn new(name: S) -> Self + where + S: AsRef, + { + PortRefToken::Name(name.as_ref().to_string()) + } +} + +impl PortRef { + pub fn new(name: S) -> Self + where + S: AsRef, + { + PortRef { + token: PortRefToken::new(name), + instanceref: InstanceRef::new(""), + } + } + + pub fn new_with_ref(name: S, instref: InstanceRef) -> Self + where + S: AsRef, + { + PortRef { + token: PortRefToken::new(name), + instanceref: instref, + } + } + + pub fn new_member(name: S, index: u32) -> Self + where + S: AsRef, + { + PortRef { + token: PortRefToken::Member(PortMember { + name: name.as_ref().to_string(), + index, + }), + instanceref: InstanceRef::new(""), + } + } + + pub fn new_member_with_ref(name: S, index: u32, instref: InstanceRef) -> Self + where + S: AsRef, + { + PortRef { + token: PortRefToken::Member(PortMember { + name: name.as_ref().to_string(), + index, + }), + instanceref: instref, + } + } +} + +impl ContentNet { + pub fn new(name: S) -> Self + where + S: AsRef, + { + ContentNet { + token: StringToken::from(name.as_ref().to_string()), + portlist: PortList(Vec::new()), + } + } + + pub fn new_with_ports(name: S, ports: PortList) -> Self + where + S: AsRef, + { + ContentNet { + token: StringToken::from(name.as_ref().to_string()), + portlist: ports, + } + } + + pub fn new_renamed(from: S, to: S) -> Self + where + S: AsRef, + { + ContentNet { + token: StringToken::from(Rename { + from: from.as_ref().to_string(), + to: to.as_ref().to_string(), + }), + portlist: PortList(Vec::new()), + } + } + + pub fn new_renamed_with_ports(from: S, to: S, ports: PortList) -> Self + where + S: AsRef, + { + ContentNet { + token: StringToken::from(Rename { + from: from.as_ref().to_string(), + to: to.as_ref().to_string(), + }), + portlist: ports, + } + } +} + +impl StringToken { + pub fn new(name: S) -> Self + where + S: AsRef, + { + StringToken::from(name.as_ref().to_string()) + } + + pub fn new_renamed(from: S, to: S) -> Self + where + S: AsRef, + { + StringToken::from(Rename { + from: from.as_ref().to_string(), + to: to.as_ref().to_string(), + }) + } +} + +impl PortArray { + pub fn new(from: S, to: S, len: i32) -> Self + where + S: AsRef, + { + PortArray { + rename: Rename::new(from, to), + length: len, + } + } +} + +impl PortToken { + pub fn new(name: S) -> Self + where + S: AsRef, + { + PortToken::from(name.as_ref().to_string()) + } + + // TODO: How to automatically define the type of len + // to be the same time as PortArray.length? + // TODO: turn len to u32? + pub fn new_array(from: S, to: S, len: i32) -> Self + where + S: AsRef, + { + PortToken::from(PortArray::new(from, to, len)) + } +} + +impl InterfacePort { + pub fn new(porttoken: PortToken, dir: PortDirection) -> Self { + InterfacePort { + token: porttoken, + direction: dir, + } + } + + pub fn new_input(name: S) -> Self + where + S: AsRef, + { + InterfacePort { + token: PortToken::new(name), + direction: PortDirection::Input, + } + } + + pub fn new_output(name: S) -> Self + where + S: AsRef, + { + InterfacePort { + token: PortToken::new(name), + direction: PortDirection::Output, + } + } + + pub fn new_input_array(from: S, to: S, len: i32) -> Self + where + S: AsRef, + { + InterfacePort { + token: PortToken::new_array(from, to, len), + direction: PortDirection::Input, + } + } + + pub fn new_output_array(from: S, to: S, len: i32) -> Self + where + S: AsRef, + { + InterfacePort { + token: PortToken::new_array(from, to, len), + direction: PortDirection::Output, + } + } +} + +impl CellView { + pub fn new(name: S) -> Self + where + S: AsRef, + { + CellView { + name: name.as_ref().to_string(), + interface: CellInterface(Vec::new()), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + } + } +} + +impl Cell { + pub fn new(name: S) -> Self + where + S: AsRef, + { + Cell { + name: name.as_ref().to_string(), + views: CellViews(Vec::new()), + } + } + + pub fn new_with_views(name: S, cells: CellViews) -> Self + where + S: AsRef, + { + Cell { + name: name.as_ref().to_string(), + views: cells, + } + } +} + +impl Design { + pub fn new(name: S, cell: CellRef) -> Self + where + S: AsRef, + { + Design { + name: name.as_ref().to_string(), + cellref: cell, + properties: PropertyList::from(Vec::new()), + } + } + + pub fn new_with_prop(name: S, cell: CellRef, props: PropertyList) -> Self + where + S: AsRef, + { + Design { + name: name.as_ref().to_string(), + cellref: cell, + properties: props, + } + } +} + +impl Library { + pub fn new(name: S) -> Self + where + S: AsRef, + { + Library { + name: name.as_ref().to_string(), + elements: Cells::from(Vec::new()), + } + } + + pub fn new_with_cells(name: S, cells: Cells) -> Self + where + S: AsRef, + { + Library { + name: name.as_ref().to_string(), + elements: cells, + } + } +} + +impl Edif { + pub fn new(name: S) -> Self + where + S: AsRef, + { + Edif { + name: name.as_ref().to_string(), + elements: EdifElements::from(Vec::new()), + } + } + + pub fn new_with_elems(name: S, elems: EdifElements) -> Self + where + S: AsRef, + { + Edif { + name: name.as_ref().to_string(), + elements: elems, + } + } +} diff --git a/src/langs/edif/src/edifier/src/lib.rs b/src/langs/edif/src/edifier/src/lib.rs new file mode 100644 index 00000000..a2e4dddb --- /dev/null +++ b/src/langs/edif/src/edifier/src/lib.rs @@ -0,0 +1,19 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +pub mod ast; +pub mod helpers; +pub mod serialize; +pub mod string_helpers; diff --git a/src/langs/edif/src/edifier/src/main.rs b/src/langs/edif/src/edifier/src/main.rs new file mode 100644 index 00000000..1e3281f5 --- /dev/null +++ b/src/langs/edif/src/edifier/src/main.rs @@ -0,0 +1,52 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +use std::path::Path; + +use std::fs::File; +use std::io::Write; + +use edifier::ast::*; + +static DOFILE: bool = false; + +fn main() { + let point = Edif { + name: r#"dsp2"#.to_string(), + elements: EdifElements::from(Vec::new()), + }; + + //point.libraries.push(mylib); + + let serialized = serde_sexpr::to_string(&point).unwrap(); + + println!("serialized = {}", serialized); + + let path = Path::new("test.edf"); + let display = path.display(); + + if DOFILE { + // Open a file in write-only mode, returns `io::Result` + let mut file = match File::create(&path) { + Err(why) => panic!("couldn't create {}: {}", display, why), + Ok(file) => file, + }; + + match file.write_all(serialized.as_bytes()) { + Err(why) => panic!("couldn't write to {}: {}", display, why), + Ok(_) => println!("successfully wrote to {}", display), + } + } +} diff --git a/src/langs/edif/src/edifier/src/serialize.rs b/src/langs/edif/src/edifier/src/serialize.rs new file mode 100644 index 00000000..875a22f7 --- /dev/null +++ b/src/langs/edif/src/edifier/src/serialize.rs @@ -0,0 +1,449 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +use crate::ast::*; +use serde::ser::{SerializeSeq, Serializer}; +use serde::Serialize; + +impl Serialize for Rename { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"rename".to_string())?; + seq.serialize_element(&self.from)?; + let mut with_quotes = r#"""#.to_string(); + with_quotes.push_str(&self.to); + with_quotes.push_str(&r#"""#.to_string()); + seq.serialize_element(&with_quotes)?; + seq.end() + } +} + +impl Serialize for GenericRef { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(2))?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&self.reference)?; + seq.end() + } +} + +impl Serialize for PropertyValue { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(2))?; + + match self { + PropertyValue::Integer(val) => { + seq.serialize_element(&"integer".to_string())?; + seq.serialize_element(&val)?; + seq.end() + } + PropertyValue::String(val) => { + seq.serialize_element(&"string".to_string())?; + let mut with_quotes = r#"""#.to_string(); + with_quotes.push_str(val); + with_quotes.push_str(&r#"""#.to_string()); + seq.serialize_element(&with_quotes)?; + seq.end() + } + } + } +} + +impl Serialize for Property { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"property".to_string())?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&self.property)?; + seq.end() + } +} + +impl Serialize for PortMember { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"member".to_string())?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&self.index)?; + seq.end() + } +} + +impl Serialize for PortRefToken { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + PortRefToken::Name(elem) => elem.serialize(serializer), + PortRefToken::Member(elem) => elem.serialize(serializer), + } + } +} + +impl Serialize for PortRef { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"portref".to_string())?; + seq.serialize_element(&self.token)?; + if !self.instanceref.is_empty() { + seq.serialize_element(&self.instanceref)? + } + seq.end() + } +} + +impl Serialize for PortList { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + if !self.is_empty() { + let mut seq = serializer.serialize_seq(Some(self.len() + 1))?; + seq.serialize_element(&"joined".to_string())?; + for portref in self.iter() { + seq.serialize_element(&portref)?; + } + seq.end() + } else { + serializer.serialize_none() + } + } +} + +impl Serialize for StringToken { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + StringToken::Name(elem) => elem.serialize(serializer), + StringToken::Rename(elem) => elem.serialize(serializer), + } + } +} + +impl Serialize for ContentNet { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"net".to_string())?; + seq.serialize_element(&self.token)?; + + if !self.portlist.is_empty() { + seq.serialize_element(&self.portlist)?; + } + seq.end() + } +} + +impl Serialize for CellRef { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"cellref".to_string())?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&self.libraryref)?; + seq.end() + } +} + +impl Serialize for ContentInstance { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3 + self.properties.len()))?; + let all = ("viewref", &self.viewref, &self.cellref); + + seq.serialize_element(&"instance".to_string())?; + seq.serialize_element(&self.token)?; + seq.serialize_element(&all)?; + if !self.properties.is_empty() { + for prop in self.properties.iter() { + seq.serialize_element(&prop)?; + } + } + seq.end() + } +} + +impl Serialize for ContentElement { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + ContentElement::Instance(elem) => elem.serialize(serializer), + ContentElement::Net(elem) => elem.serialize(serializer), + } + } +} + +impl Serialize for CellContents { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + if !self.is_empty() { + let mut seq = serializer.serialize_seq(Some(2))?; + seq.serialize_element(&"contents".to_string())?; + + for element in self.iter() { + seq.serialize_element(&element)?; + } + seq.end() + } else { + serializer.serialize_none() + } + } +} + +impl Serialize for PortDirection { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(2))?; + seq.serialize_element(&"direction".to_string())?; + match self { + PortDirection::Input => { + seq.serialize_element(&"INPUT".to_string())?; + } + PortDirection::Output => { + seq.serialize_element(&"OUTPUT".to_string())?; + } + } + seq.end() + } +} + +impl Serialize for PortArray { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + + seq.serialize_element(&"array".to_string())?; + seq.serialize_element(&self.rename)?; + seq.serialize_element(&self.length)?; + seq.end() + } +} + +impl Serialize for PortToken { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + PortToken::Name(name) => name.serialize(serializer), + PortToken::Array(array) => array.serialize(serializer), + } + } +} + +impl Serialize for InterfacePort { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + seq.serialize_element(&"port".to_string())?; + seq.serialize_element(&self.token)?; + seq.serialize_element(&self.direction)?; + seq.end() + } +} + +impl Serialize for CellInterface { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + if !self.is_empty() { + let mut seq = serializer.serialize_seq(Some(1 + self.len()))?; + seq.serialize_element(&"interface".to_string())?; + + for port in self.iter() { + seq.serialize_element(&port)?; + } + seq.end() + } else { + serializer.serialize_none() + } + } +} + +impl Serialize for CellView { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let len_interface = self.interface.len(); + let len_contents = self.contents.len(); + let len_properties = self.properties.len(); + let local_size = 2 + len_interface + len_contents + len_properties; + let mut seq = serializer.serialize_seq(Some(local_size))?; + let viewtype = ("viewtype", "NETLIST"); + + seq.serialize_element("view")?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&viewtype)?; + + if !self.interface.is_empty() { + seq.serialize_element(&self.interface)?; + } + + if !self.contents.is_empty() { + seq.serialize_element(&self.contents)?; + } + + if !self.properties.is_empty() { + for prop in self.properties.iter() { + seq.serialize_element(&prop)?; + } + } + + seq.end() + } +} + +impl Serialize for Cell { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(4))?; + let celltype = ("celltype", "GENERIC"); + + seq.serialize_element("cell")?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&celltype)?; + if !self.views.is_empty() { + for view in self.views.iter() { + seq.serialize_element(&view)?; + } + } + seq.end() + } +} + +impl Serialize for Library { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + let fixed1 = ("edifLevel", "0"); + //Little hack to make serialize to insert braces around numberDefinition. + let fixed2 = ("technology", ("numberDefinition",)); + + seq.serialize_element("Library")?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&fixed1)?; + seq.serialize_element(&fixed2)?; + if !self.elements.is_empty() { + for elem in self.elements.iter() { + seq.serialize_element(&elem)?; + } + } + seq.end() + } +} + +impl Serialize for Design { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut seq = serializer.serialize_seq(Some(3))?; + + seq.serialize_element("design")?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&self.cellref)?; + if !self.properties.is_empty() { + for prop in self.properties.iter() { + seq.serialize_element(&prop)?; + } + } + seq.end() + } +} + +impl Serialize for EdifElement { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + EdifElement::Library(lib) => lib.serialize(serializer), + EdifElement::Design(des) => des.serialize(serializer), + } + } +} + +impl Serialize for Edif { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + // 1) Need to count the number of fields we will have on the + // main branch. + // + // 3 is the number of fields in the struct. + let mut seq = serializer.serialize_seq(Some(6))?; + let version = ("edifversion", "2", "0", "0"); + let level = ("edifLevel", 0); + let kword = ("keywordmap", ("keywordlevel", 0)); + + seq.serialize_element("edif")?; + seq.serialize_element(&self.name)?; + seq.serialize_element(&version)?; + seq.serialize_element(&level)?; + seq.serialize_element(&kword)?; + + if !self.elements.is_empty() { + for elem in self.elements.iter() { + seq.serialize_element(&elem)?; + } + } + + seq.end() + } +} diff --git a/src/langs/edif/src/edifier/src/string_helpers.rs b/src/langs/edif/src/edifier/src/string_helpers.rs new file mode 100644 index 00000000..d76dac16 --- /dev/null +++ b/src/langs/edif/src/edifier/src/string_helpers.rs @@ -0,0 +1,52 @@ +use std::cmp::Ordering; + +pub fn match_check(incoming: String) -> i32 { + let mut counter: i32 = 0; + for c in incoming.chars() { + if c == '(' { + counter += 1; + } else if c == ')' { + counter -= 1; + } + } + match counter.cmp(&0) { + Ordering::Greater => println!("ERROR: Too many left parentheses."), + Ordering::Less => println!("ERROR: Too many right parentheses."), + Ordering::Equal => (), + } + counter +} + +pub fn add_new_lines(input: String, level: u32, dospaces: bool) -> String { + let mut output = String::new(); + let mut count = 0; + let mut first_pass = false; + for c in input.chars() { + match c { + '(' => { + if (count <= level) & (first_pass) { + if output.ends_with(' ') { + output.pop(); + } + output.push('\n'); + if dospaces { + for _i in 0..count { + output.push(' '); + output.push(' '); + } + } + } + output.push(c); + first_pass = true; + count += 1; + } + ')' => { + output.push(c); + count -= 1; + } + _ => output.push(c), + } + } + assert_eq!(0, match_check(output.clone())); + output +} diff --git a/src/langs/edif/src/edifier/tests/string_helpers_ut.rs b/src/langs/edif/src/edifier/tests/string_helpers_ut.rs new file mode 100644 index 00000000..a7057375 --- /dev/null +++ b/src/langs/edif/src/edifier/tests/string_helpers_ut.rs @@ -0,0 +1,28 @@ +use edifier::string_helpers::*; + +#[test] +fn simple_new_lines() { + let test = "Aqui ((hay espacios) estes) o no estes".to_string(); + let actual = add_new_lines(test, 2, false); + + assert_eq!(actual, "Aqui (\n(hay espacios) estes) o no estes") +} + +#[test] +fn onelevel_new_lines() { + let test = "(Aqui ((())) ((())) estes o no estes)".to_string(); + let actual = add_new_lines(test, 1, false); + + assert_eq!(actual, "(Aqui\n((()))\n((())) estes o no estes)") +} + +#[test] +fn complex_new_lines() { + let test = "(Aqui((() ))((())) estes o no estes)".to_string(); + let actual = add_new_lines(test, 2, true); + + assert_eq!( + actual, + "(Aqui\n (\n (() ))\n (\n (())) estes o no estes)" + ) +} diff --git a/src/langs/edif/src/edifier/tests/unit_tests.rs b/src/langs/edif/src/edifier/tests/unit_tests.rs new file mode 100644 index 00000000..81ecc1df --- /dev/null +++ b/src/langs/edif/src/edifier/tests/unit_tests.rs @@ -0,0 +1,348 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +//use std::process::Command; +//use Edif; +use edifier::ast::*; +use edifier::string_helpers::*; + +/* +#[test] +fn runs_without_arguments() { + let mut cmd = Command::cargo_bin("ls").unwrap(); + cmd.assert().success(); +}*/ + +// Test 1: we should get a minimal edif with no elements +#[test] +fn empty_edif() { + let ed = Edif { + name: "ed".to_string(), + elements: EdifElements::from(Vec::new()), + }; + let actual = serde_sexpr::to_string(&ed).unwrap(); + + assert_eq!( + actual, + "(edif ed (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)))" + ); + assert_eq!(match_check(actual), 0); +} + +// Test 2: with library elements +#[test] +fn edif_lib() { + let libelem = EdifElement::from(Library::new("mylib")); + let ed = Edif { + name: "ed2".to_string(), + elements: EdifElements::from(vec![libelem]), + }; + let actual = serde_sexpr::to_string(&ed).unwrap(); + + assert_eq!(actual, + "(edif ed2 (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library mylib (edifLevel 0) (technology (numberDefinition))))" ); + assert_eq!(match_check(actual), 0); +} + +// Test 2.1: with library that has cells +#[test] +fn edif_lib_cells() { + let libelem = EdifElement::from(Library::new_with_cells( + "mylib", + Cells::from(vec![Cell::new_with_views( + "mycell", + CellViews::from(vec![CellView::new("myview")]), + )]), + )); + + let ed = Edif { + name: "ed2".to_string(), + elements: EdifElements::from(vec![libelem]), + }; + + let actual = serde_sexpr::to_string(&ed).unwrap(); + + assert_eq!(actual, + "(edif ed2 (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library mylib (edifLevel 0) (technology (numberDefinition)) (cell mycell (celltype GENERIC) (view myview (viewtype NETLIST)))))" ); + assert_eq!(match_check(actual), 0); +} + +// Test 3: cell with no elements +#[test] +fn cell_empty() { + let mycell = Cell::new("mycell"); + let actual = serde_sexpr::to_string(&mycell).unwrap(); + assert_eq!(actual, "(cell mycell (celltype GENERIC))"); + assert_eq!(match_check(actual), 0); +} + +// Test 4: cell view with no elements +#[test] +fn cellview_empty() { + let myview = CellView::new("myview"); + let actual = serde_sexpr::to_string(&myview).unwrap(); + assert_eq!(actual, "(view myview (viewtype NETLIST))"); + assert_eq!(match_check(actual), 0); +} + +// Test 4.1: cell view with properties +#[test] +fn cellview_w_props() { + let mut myview = CellView::new("myview"); + myview + .properties + .push(Property::new_string("usability", "very_high_please")); + let actual = serde_sexpr::to_string(&myview).unwrap(); + assert_eq!( + actual, + r#"(view myview (viewtype NETLIST) (property usability (string "very_high_please")))"# + ); + assert_eq!(match_check(actual), 0); +} + +// Test 5: interface with no elements +#[test] +fn interface_empty() { + let myinterface = CellInterface(Vec::new()); + let actual = serde_sexpr::to_string(&myinterface).unwrap(); + assert_eq!(actual, "()"); + assert_eq!(match_check(actual), 0); +} + +// Test 6: interface with 2 elements +#[test] +fn interface_some() { + let porta = InterfacePort::new_input("a"); + let portb = InterfacePort::new_input("b"); + let myinterface = CellInterface(vec![porta, portb]); + let actual = serde_sexpr::to_string(&myinterface).unwrap(); + assert_eq!( + actual, + "(interface (port a (direction INPUT)) (port b (direction INPUT)))" + ); + assert_eq!(match_check(actual), 0); +} + +// Test 7: contents empty +#[test] +fn contents_empty() { + let mycontent = CellContents(Vec::new()); + let actual = serde_sexpr::to_string(&mycontent).unwrap(); + assert_eq!(actual, "()"); + assert_eq!(match_check(actual), 0); +} + +//test 8: content instance with no properties +#[test] +fn contents_instance_simple() { + let myinstance = ContentInstance { + token: StringToken::new("lut4"), + viewref: "myview".to_string(), + cellref: CellRef::new("mycellref", "mylibref"), + properties: PropertyList(Vec::new()), + }; + let actual = serde_sexpr::to_string(&myinstance).unwrap(); + assert_eq!( + actual, + "(instance lut4 (viewref myview (cellref mycellref (libraryref mylibref))))" + ); + assert_eq!(match_check(actual), 0); +} + +//test 8.1: content instance with properties +#[test] +fn contents_instance_props() { + let props = PropertyList(vec![ + Property { + name: "adjustability".to_string(), + property: PropertyValue::Integer(11), + }, + Property { + name: "usability".to_string(), + property: PropertyValue::String("very_high_please".to_string()), + }, + ]); + let myinstance = ContentInstance { + token: StringToken::new("dsp1"), + viewref: "myview".to_string(), + cellref: CellRef::new("mycellref", "mylibref"), + properties: props, + }; + let actual = serde_sexpr::to_string(&myinstance).unwrap(); + assert_eq!( + actual, + r#"(instance dsp1 (viewref myview (cellref mycellref (libraryref mylibref))) (property adjustability (integer 11)) (property usability (string "very_high_please")))"# + ); + assert_eq!(match_check(actual), 0); +} + +//test 9: content net +#[test] +fn net_empty() { + let myinstance = ContentNet::new("y"); + let actual = serde_sexpr::to_string(&myinstance).unwrap(); + assert_eq!(actual, "(net y)"); + assert_eq!(match_check(actual), 0); +} + +//test 9.1: content net renamed +#[test] +fn net_renamed() { + let myinstance = ContentNet::new_renamed("u_u_sad_4", "u_u_sad[4]"); + let actual = serde_sexpr::to_string(&myinstance).unwrap(); + assert_eq!(actual, r#"(net (rename u_u_sad_4 "u_u_sad[4]"))"#); + assert_eq!(match_check(actual), 0); +} + +//test 10: port reference +#[test] +fn portref() { + let myport = PortRef { + token: PortRefToken::new("y"), + instanceref: InstanceRef::new("myinst"), + }; + let actual = serde_sexpr::to_string(&myport).unwrap(); + assert_eq!(actual, "(portref y (instanceref myinst))"); + assert_eq!(match_check(actual), 0); +} + +//test 11: multiple port reference +#[test] +fn multi_portref() { + let myport1 = PortRef { + token: PortRefToken::new("y"), + instanceref: InstanceRef::new("myinst"), + }; + let myport2 = PortRef { + token: PortRefToken::new("x"), + instanceref: InstanceRef::new(""), + }; + let myport3 = PortRef { + token: PortRefToken::Member(PortMember { + name: "some_other_port_".to_string(), + index: 9, + }), + instanceref: InstanceRef::new("the_inst"), + }; + let mut myinstance = ContentNet::new("y"); + myinstance.portlist = PortList(vec![myport1, myport2, myport3]); + + let actual = serde_sexpr::to_string(&myinstance).unwrap(); + assert_eq!( + actual, + "(net y (joined (portref y (instanceref myinst)) (portref x) (portref (member some_other_port_ 9) (instanceref the_inst))))" + ); + assert_eq!(match_check(actual), 0); +} + +// Test 12: contents with something inside. +#[test] +fn contents_elements() { + let mut mycontent = CellContents(Vec::new()); + mycontent.push(ContentElement::Net(ContentNet::new("a"))); + mycontent.push(ContentElement::Net(ContentNet::new("b"))); + + let actual = serde_sexpr::to_string(&mycontent).unwrap(); + assert_eq!(actual, "(contents (net a) (net b))"); + assert_eq!(match_check(actual), 0); +} + +// Test 13: property values +#[test] +fn property_values() { + let mypropint = PropertyValue::Integer(42); + let actual = serde_sexpr::to_string(&mypropint).unwrap(); + assert_eq!(actual, "(integer 42)"); + assert_eq!(match_check(actual), 0); + + let mypropstr = PropertyValue::from("64'h00AA00FF33CC0F00".to_string()); + let actual = serde_sexpr::to_string(&mypropstr).unwrap(); + assert_eq!(actual, r#"(string "64'h00AA00FF33CC0F00")"#); + assert_eq!(match_check(actual), 0); +} + +// Test 14: property +#[test] +fn property_complete() { + let mypropval = PropertyValue::from( + "256'h0000000000000000000000000000000000000000000000000000000000000000".to_string(), + ); + let myprop = Property { + name: "INITP_01".to_string(), + property: mypropval, + }; + let actual = serde_sexpr::to_string(&myprop).unwrap(); + assert_eq!( + actual, + r#"(property INITP_01 (string "256'h0000000000000000000000000000000000000000000000000000000000000000"))"# + ); + assert_eq!(match_check(actual), 0); +} + +// Test 15: rename +#[test] +fn rename() { + let myren = Rename::new("my_exp_0", r#"my_exp[0]"#); + let actual = serde_sexpr::to_string(&myren).unwrap(); + assert_eq!(actual, r#"(rename my_exp_0 "my_exp[0]")"#); + assert_eq!(match_check(actual), 0); +} + +// Test 16: References +#[test] +fn references() { + let libref = LibraryRef::new("anew_libref"); + let actual = serde_sexpr::to_string(&libref).unwrap(); + assert_eq!(actual, r#"(libraryref anew_libref)"#); + assert_eq!(match_check(actual), 0); + + let instref = InstanceRef::new("anew_instance"); + let actual = serde_sexpr::to_string(&instref).unwrap(); + assert_eq!(actual, r#"(instanceref anew_instance)"#); + assert_eq!(match_check(actual), 0); +} + +// Test 17: Designs +#[test] +fn design_empty() { + let design = Design::new("mydesign", CellRef::new("LUT4", "hdi_primitives")); + let actual = serde_sexpr::to_string(&design).unwrap(); + assert_eq!( + actual, + r#"(design mydesign (cellref LUT4 (libraryref hdi_primitives)))"# + ); + assert_eq!(match_check(actual), 0); +} + +// Test 18: Designs with properties +#[test] +fn design_props() { + let mut proplist = PropertyList(Vec::new()); + proplist.push(Property::new_string( + "XLNX_PROJ_DIR", + "/home/clavin/testRW/picoblaze", + )); + proplist.push(Property::new_string("part", "xcvu3p-ffvc1517-2-i")); + + let design = + Design::new_with_prop("mydesign", CellRef::new("LUT4", "hdi_primitives"), proplist); + let actual = serde_sexpr::to_string(&design).unwrap(); + assert_eq!( + actual, + r#"(design mydesign (cellref LUT4 (libraryref hdi_primitives)) (property XLNX_PROJ_DIR (string "/home/clavin/testRW/picoblaze")) (property part (string "xcvu3p-ffvc1517-2-i")))"# + ); + assert_eq!(match_check(actual), 0); +} diff --git a/src/langs/edif/src/platforms/Cargo.toml b/src/langs/edif/src/platforms/Cargo.toml new file mode 100644 index 00000000..72e56987 --- /dev/null +++ b/src/langs/edif/src/platforms/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "platforms" +version = "0.1.0" +authors = ["Pedro Torruella "] +license = "Apache-2.0" +edition = "2018" + +[dependencies] +edifier = { path = "../edifier" } +serde = { version = "1.0", features = ["derive", "rc"] } +serde_json = "1.0" +serde_sexpr = "0.1.0" +expect-test = "1.0.2" \ No newline at end of file diff --git a/src/langs/edif/src/platforms/src/lib.rs b/src/langs/edif/src/platforms/src/lib.rs new file mode 100644 index 00000000..b9a5df58 --- /dev/null +++ b/src/langs/edif/src/platforms/src/lib.rs @@ -0,0 +1,16 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +pub mod xilinx; diff --git a/src/langs/edif/src/platforms/src/xilinx.rs b/src/langs/edif/src/platforms/src/xilinx.rs new file mode 100644 index 00000000..9ba91bd4 --- /dev/null +++ b/src/langs/edif/src/platforms/src/xilinx.rs @@ -0,0 +1,971 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +use edifier::ast::*; + +pub fn new_lut2() -> Cell { + let porto = InterfacePort::new_output("O"); + + let porti0 = InterfacePort::new_input("I0"); + + let porti1 = InterfacePort::new_input("I1"); + + let interface = CellInterface(vec![porto, porti0, porti1]); + + let cellview = CellView { + name: "netlist".to_string(), + interface, + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }; + Cell { + name: "LUT2".to_string(), + views: CellViews(vec![cellview]), + } +} + +pub fn lut2_prop_ini(val: S) -> Property +where + S: AsRef, +{ + Property { + name: "INIT".to_string(), + property: PropertyValue::from(val.as_ref().to_string()), + } +} + +pub fn lut2_prop_box(val: S) -> Property +where + S: AsRef, +{ + Property { + name: "BOX_TYPE".to_string(), + property: PropertyValue::from(val.as_ref().to_string()), + } +} + +pub fn lut2_prop_loc(val: S) -> Property +where + S: AsRef, +{ + Property { + name: "LOC".to_string(), + property: PropertyValue::from(val.as_ref().to_string()), + } +} + +pub fn lut2_prop_bel(val: S) -> Property +where + S: AsRef, +{ + Property { + name: "BEL".to_string(), + property: PropertyValue::from(val.as_ref().to_string()), + } +} + +pub fn carry8() -> Cell { + let mut interface = CellInterface(Vec::new()); + + interface.push(InterfacePort::new_input("CI")); + interface.push(InterfacePort::new_input("CI_TOP")); + interface.push(InterfacePort::new( + PortToken::new_array("CO", "CO[7:0]", 8), + PortDirection::Output, + )); + interface.push(InterfacePort::new( + PortToken::new_array("O", "O[7:0]", 8), + PortDirection::Output, + )); + interface.push(InterfacePort::new( + PortToken::new_array("DI", "DI[7:0]", 8), + PortDirection::Input, + )); + interface.push(InterfacePort::new( + PortToken::new_array("S", "S[7:0]", 8), + PortDirection::Input, + )); + + let cellview = CellView { + name: "netlist".to_string(), + interface, + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }; + Cell { + name: "CARRY8".to_string(), + views: CellViews(vec![cellview]), + } +} + +pub fn inverter() -> Edif { + let top_name = "inverter".to_string(); + let work_name = "work".to_string(); + let netlist = "netlist".to_string(); + + let elems = Cells::from(vec![ + Cell { + name: "LUT2".to_string(), + views: CellViews(vec![CellView { + name: netlist.clone(), + interface: CellInterface(vec![ + InterfacePort::new_output("O"), + InterfacePort::new_input("I0"), + InterfacePort::new_input("I1"), + ]), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }]), + }, + Cell { + name: "INV".to_string(), + views: CellViews(vec![CellView { + name: netlist.clone(), + interface: CellInterface(vec![ + InterfacePort::new_input("I"), + InterfacePort::new_output("O"), + ]), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }]), + }, + ]); + + let lib_prims = Library { + name: "hdi_primitives".to_string(), + elements: elems, + }; + + let yinst0_name = "y_INST_0".to_string(); + + let yinst0 = ContentElement::from(ContentInstance { + token: StringToken::new(yinst0_name.clone()), + viewref: netlist, + cellref: CellRef::new("LUT2", "hdi_primitives"), + properties: PropertyList(vec![Property::new_string("INIT", "4'h8")]), + }); + + let neta_name = "a".to_string(); + let neta = ContentElement::from(ContentNet::new_with_ports( + neta_name.clone(), + PortList(vec![ + PortRef::new_with_ref("I0", InstanceRef::new(yinst0_name.clone())), + PortRef::new(neta_name.clone()), + ]), + )); + + let netb_name = "b".to_string(); + let netb = ContentElement::from(ContentNet::new_with_ports( + netb_name.clone(), + PortList(vec![ + PortRef::new_with_ref("I1", InstanceRef::new(yinst0_name.clone())), + PortRef::new(netb_name.clone()), + ]), + )); + + let nety_name = "y".to_string(); + let nety = ContentElement::from(ContentNet::new_with_ports( + nety_name.clone(), + PortList(vec![ + PortRef::new_with_ref("O", InstanceRef::new(yinst0_name)), + PortRef::new(nety_name.clone()), + ]), + )); + + let inv = Cell { + name: top_name.clone(), + views: CellViews(vec![CellView { + name: top_name.clone(), + interface: CellInterface(vec![ + InterfacePort::new_input(neta_name), + InterfacePort::new_input(netb_name), + InterfacePort::new_output(nety_name), + ]), + contents: CellContents(vec![yinst0, neta, netb, nety]), + properties: PropertyList::from(Vec::new()), + }]), + }; + + let lib_work = Library { + name: work_name.clone(), + elements: Cells::from(vec![inv]), + }; + + let design_inv = Design::new_with_prop( + top_name.clone(), + CellRef::new(top_name.clone(), work_name), + PropertyList(vec![Property::new_string("part", "xczu3eg-sbva484-1-e")]), + ); + + let libp = EdifElement::from(lib_prims); + let libw = EdifElement::from(lib_work); + let desi = EdifElement::from(design_inv); + + Edif { + name: top_name, + elements: EdifElements::from(vec![libp, libw, desi]), + } +} + +pub fn dsp() -> Edif { + let top_name = "dsp2".to_string(); + let work_name = "work".to_string(); + let netlist = "netlist".to_string(); + + // Building the Primitive's library + let elems = Cells::from(vec![ + Cell { + name: "GND".to_string(), + views: CellViews(vec![CellView { + name: netlist.clone(), + interface: CellInterface(vec![InterfacePort::new_output("G")]), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }]), + }, + Cell { + name: "VCC".to_string(), + views: CellViews(vec![CellView { + name: netlist.clone(), + interface: CellInterface(vec![InterfacePort::new_output("P")]), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }]), + }, + Cell { + name: "DSP48E2".to_string(), + views: CellViews(vec![CellView { + name: netlist.clone(), + interface: CellInterface(vec![ + InterfacePort::new_output("CARRYCASCOUT"), + InterfacePort::new_output("MULTSIGNOUT"), + InterfacePort::new_output("OVERFLOW"), + InterfacePort::new_output("PATTERNBDETECT"), + InterfacePort::new_output("PATTERNDETECT"), + InterfacePort::new_output("UNDERFLOW"), + InterfacePort::new_input("CARRYCASCIN"), + InterfacePort::new_input("CARRYIN"), + InterfacePort::new_input("CEA1"), + InterfacePort::new_input("CEA2"), + InterfacePort::new_input("CEAD"), + InterfacePort::new_input("CEALUMODE"), + InterfacePort::new_input("CEB1"), + InterfacePort::new_input("CEB2"), + InterfacePort::new_input("CEC"), + InterfacePort::new_input("CECARRYIN"), + InterfacePort::new_input("CECTRL"), + InterfacePort::new_input("CED"), + InterfacePort::new_input("CEINMODE"), + InterfacePort::new_input("CEM"), + InterfacePort::new_input("CEP"), + InterfacePort::new_input("CLK"), + InterfacePort::new_input("MULTSIGNIN"), + InterfacePort::new_input("RSTA"), + InterfacePort::new_input("RSTALLCARRYIN"), + InterfacePort::new_input("RSTALUMODE"), + InterfacePort::new_input("RSTB"), + InterfacePort::new_input("RSTC"), + InterfacePort::new_input("RSTCTRL"), + InterfacePort::new_input("RSTD"), + InterfacePort::new_input("RSTINMODE"), + InterfacePort::new_input("RSTM"), + InterfacePort::new_input("RSTP"), + InterfacePort::new( + PortToken::new_array("ACOUT", "ACOUT[29:0]", 30), + PortDirection::Output, + ), + InterfacePort::new( + PortToken::new_array("BCOUT", "BCOUT[17:0]", 18), + PortDirection::Output, + ), + InterfacePort::new( + PortToken::new_array("CARRYOUT", "CARRYOUT[3:0]", 4), + PortDirection::Output, + ), + InterfacePort::new( + PortToken::new_array("PCOUT", "PCOUT[47:0]", 48), + PortDirection::Output, + ), + InterfacePort::new( + PortToken::new_array("P", "P[47:0]", 48), + PortDirection::Output, + ), + InterfacePort::new( + PortToken::new_array("XOROUT", "XOROUT[7:0]", 8), + PortDirection::Output, + ), + InterfacePort::new( + PortToken::new_array("ACIN", "ACIN[29:0]", 30), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("ALUMODE", "ALUMODE[3:0]", 4), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("A", "A[29:0]", 30), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("BCIN", "BCIN[17:0]", 18), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("B", "B[17:0]", 18), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("CARRYINSEL", "CARRYINSEL[2:0]", 3), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("C", "C[47:0]", 48), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("D", "D[26:0]", 27), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("INMODE", "INMODE[4:0]", 5), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("OPMODE", "OPMODE[8:0]", 9), + PortDirection::Input, + ), + InterfacePort::new( + PortToken::new_array("PCIN", "PCIN[47:0]", 48), + PortDirection::Input, + ), + ]), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }]), + }, + Cell { + name: "INV".to_string(), + views: CellViews(vec![CellView { + name: netlist.clone(), + interface: CellInterface(vec![ + InterfacePort::new_input("I"), + InterfacePort::new_output("O"), + ]), + contents: CellContents(Vec::new()), + properties: PropertyList::from(Vec::new()), + }]), + }, + ]); + + let lib_prims = Library { + name: "hdi_primitives".to_string(), + elements: elems, + }; + + // Building the elemtns for the work library + let gnd_name = "GND".to_string(); + let gnd_ref = InstanceRef::new(gnd_name.clone()); + let gnd = ContentElement::from(ContentInstance { + token: StringToken::new(gnd_name), + viewref: netlist.clone(), + cellref: CellRef::new("GND", "hdi_primitives"), + properties: PropertyList(vec![]), + }); + + let gnd1_name = "GND_1".to_string(); + let gnd1_ref = InstanceRef::new(gnd1_name.clone()); + let gnd1 = ContentElement::from(ContentInstance { + token: StringToken::new(gnd1_name), + viewref: netlist.clone(), + cellref: CellRef::new("GND", "hdi_primitives"), + properties: PropertyList(vec![]), + }); + + let vcc_name = "VCC".to_string(); + let vccref = InstanceRef::new(vcc_name.clone()); + let vcc = ContentElement::from(ContentInstance { + token: StringToken::new(vcc_name), + viewref: netlist.clone(), + cellref: CellRef::new("VCC", "hdi_primitives"), + properties: PropertyList(vec![]), + }); + + let vcc1_name = "VCC_1".to_string(); + let vcc1_ref = InstanceRef::new(vcc1_name.clone()); + let vcc1 = ContentElement::from(ContentInstance { + token: StringToken::new(vcc1_name), + viewref: netlist.clone(), + cellref: CellRef::new("VCC", "hdi_primitives"), + properties: PropertyList(vec![]), + }); + + let dsp_name = "res".to_string(); + let dspref = InstanceRef::new(dsp_name.clone()); + let dspinst = ContentElement::from(ContentInstance { + token: StringToken::new(dsp_name), + viewref: netlist, + cellref: CellRef::new("DSP48E2", "hdi_primitives"), + properties: PropertyList(vec![ + Property::new_string("XORSIMD", "XOR24_48_96"), + Property::new_string("USE_WIDEXOR", "FALSE"), + Property::new_integer("ACASCREG", 0), + Property::new_integer("ADREG", 1), + Property::new_integer("ALUMODEREG", 0), + Property::new_string("AMULTSEL", "A"), + Property::new_integer("AREG", 0), + Property::new_string("AUTORESET_PATDET", "NO_RESET"), + Property::new_string("AUTORESET_PRIORITY", "RESET"), + Property::new_string("A_INPUT", "DIRECT"), + Property::new_integer("BCASCREG", 0), + Property::new_string("BMULTSEL", "B"), + Property::new_integer("BREG", 0), + Property::new_string("B_INPUT", "DIRECT"), + Property::new_integer("CARRYINREG", 0), + Property::new_integer("CARRYINSELREG", 0), + Property::new_integer("CREG", 1), + Property::new_integer("DREG", 1), + Property::new_integer("INMODEREG", 0), + Property::new_string("MASK", "48'h3FFFFFFFFFFF"), + Property::new_string("METHODOLOGY_DRC_VIOS", r#"{SYNTH-13 {cell *THIS*}}"#), + Property::new_integer("MREG", 0), + Property::new_integer("OPMODEREG", 0), + Property::new_string("PATTERN", "48'h000000000000"), + Property::new_string("PREADDINSEL", "A"), + Property::new_integer("PREG", 0), + Property::new_string("RND", "48'h000000000000"), + Property::new_string("SEL_MASK", "MASK"), + Property::new_string("SEL_PATTERN", "PATTERN"), + Property::new_string("USE_MULT", "MULTIPLY"), + Property::new_string("USE_PATTERN_DETECT", "NO_PATDET"), + Property::new_string("USE_SIMD", "ONE48"), + Property::new_string("OPT_MODIFIED", "SWEEP"), + ]), + }); + + let const_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "&_const0_", + "", + PortList(vec![ + PortRef::new_member_with_ref("ACIN", 29, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 19, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 18, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 17, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 16, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 15, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 14, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 13, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 12, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 11, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 10, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 28, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 9, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 8, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 7, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 6, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 5, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 4, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 3, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 2, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 1, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 0, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 27, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 26, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 25, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 24, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 23, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 22, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 21, dspref.clone()), + PortRef::new_member_with_ref("ACIN", 20, dspref.clone()), + PortRef::new_member_with_ref("ALUMODE", 3, dspref.clone()), + PortRef::new_member_with_ref("ALUMODE", 2, dspref.clone()), + PortRef::new_member_with_ref("ALUMODE", 1, dspref.clone()), + PortRef::new_member_with_ref("ALUMODE", 0, dspref.clone()), + PortRef::new_member_with_ref("A", 19, dspref.clone()), + PortRef::new_member_with_ref("A", 18, dspref.clone()), + PortRef::new_member_with_ref("A", 17, dspref.clone()), + PortRef::new_member_with_ref("A", 16, dspref.clone()), + PortRef::new_member_with_ref("A", 15, dspref.clone()), + PortRef::new_member_with_ref("A", 14, dspref.clone()), + PortRef::new_member_with_ref("A", 13, dspref.clone()), + PortRef::new_member_with_ref("A", 12, dspref.clone()), + PortRef::new_member_with_ref("A", 11, dspref.clone()), + PortRef::new_member_with_ref("A", 10, dspref.clone()), + PortRef::new_member_with_ref("A", 9, dspref.clone()), + PortRef::new_member_with_ref("A", 8, dspref.clone()), + PortRef::new_member_with_ref("A", 7, dspref.clone()), + PortRef::new_member_with_ref("A", 6, dspref.clone()), + PortRef::new_member_with_ref("A", 5, dspref.clone()), + PortRef::new_member_with_ref("A", 4, dspref.clone()), + PortRef::new_member_with_ref("A", 3, dspref.clone()), + PortRef::new_member_with_ref("A", 2, dspref.clone()), + PortRef::new_member_with_ref("A", 1, dspref.clone()), + PortRef::new_member_with_ref("A", 0, dspref.clone()), + PortRef::new_member_with_ref("A", 21, dspref.clone()), + PortRef::new_member_with_ref("A", 20, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 17, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 7, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 6, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 5, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 4, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 3, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 2, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 1, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 0, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 16, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 15, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 14, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 13, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 12, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 11, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 10, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 9, dspref.clone()), + PortRef::new_member_with_ref("BCIN", 8, dspref.clone()), + PortRef::new_member_with_ref("B", 7, dspref.clone()), + PortRef::new_member_with_ref("B", 6, dspref.clone()), + PortRef::new_member_with_ref("B", 5, dspref.clone()), + PortRef::new_member_with_ref("B", 4, dspref.clone()), + PortRef::new_member_with_ref("B", 3, dspref.clone()), + PortRef::new_member_with_ref("B", 2, dspref.clone()), + PortRef::new_member_with_ref("B", 1, dspref.clone()), + PortRef::new_member_with_ref("B", 0, dspref.clone()), + PortRef::new_member_with_ref("B", 9, dspref.clone()), + PortRef::new_member_with_ref("B", 8, dspref.clone()), + PortRef::new_with_ref("CARRYCASCIN", dspref.clone()), + PortRef::new_with_ref("CARRYIN", dspref.clone()), + PortRef::new_member_with_ref("CARRYINSEL", 2, dspref.clone()), + PortRef::new_member_with_ref("CARRYINSEL", 1, dspref.clone()), + PortRef::new_member_with_ref("CARRYINSEL", 0, dspref.clone()), + PortRef::new_with_ref("CEA1", dspref.clone()), + PortRef::new_with_ref("CEA2", dspref.clone()), + PortRef::new_with_ref("CEAD", dspref.clone()), + PortRef::new_with_ref("CEALUMODE", dspref.clone()), + PortRef::new_with_ref("CEB1", dspref.clone()), + PortRef::new_with_ref("CEB2", dspref.clone()), + PortRef::new_with_ref("CEC", dspref.clone()), + PortRef::new_with_ref("CECARRYIN", dspref.clone()), + PortRef::new_with_ref("CECTRL", dspref.clone()), + PortRef::new_with_ref("CED", dspref.clone()), + PortRef::new_with_ref("CEINMODE", dspref.clone()), + PortRef::new_with_ref("CEM", dspref.clone()), + PortRef::new_with_ref("CEP", dspref.clone()), + PortRef::new_with_ref("CLK", dspref.clone()), + PortRef::new_with_ref("G", gnd_ref), + PortRef::new_member_with_ref("INMODE", 4, dspref.clone()), + PortRef::new_member_with_ref("INMODE", 3, dspref.clone()), + PortRef::new_member_with_ref("INMODE", 2, dspref.clone()), + PortRef::new_member_with_ref("INMODE", 1, dspref.clone()), + PortRef::new_member_with_ref("INMODE", 0, dspref.clone()), + PortRef::new_with_ref("MULTSIGNIN", dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 7, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 5, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 4, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 3, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 2, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 1, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 0, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 47, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 37, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 36, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 35, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 34, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 33, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 32, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 31, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 30, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 29, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 28, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 46, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 27, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 26, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 25, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 24, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 23, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 22, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 21, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 20, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 19, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 18, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 45, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 17, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 16, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 15, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 14, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 13, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 12, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 11, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 10, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 9, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 8, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 44, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 7, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 6, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 5, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 4, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 3, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 2, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 1, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 0, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 43, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 42, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 41, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 40, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 39, dspref.clone()), + PortRef::new_member_with_ref("PCIN", 38, dspref.clone()), + PortRef::new_with_ref("RSTA", dspref.clone()), + PortRef::new_with_ref("RSTALLCARRYIN", dspref.clone()), + PortRef::new_with_ref("RSTALUMODE", dspref.clone()), + PortRef::new_with_ref("RSTB", dspref.clone()), + PortRef::new_with_ref("RSTC", dspref.clone()), + PortRef::new_with_ref("RSTCTRL", dspref.clone()), + PortRef::new_with_ref("RSTD", dspref.clone()), + PortRef::new_with_ref("RSTINMODE", dspref.clone()), + PortRef::new_with_ref("RSTM", dspref.clone()), + PortRef::new_with_ref("RSTP", dspref.clone()), + ]), + )); + + let const1_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "&_const1_", + "", + PortList(vec![ + PortRef::new_member_with_ref("OPMODE", 8, dspref.clone()), + PortRef::new_member_with_ref("OPMODE", 6, dspref.clone()), + PortRef::new_with_ref("P", vccref), + ]), + )); + + let nety_name = "GND_2".to_string(); + let gnd2 = ContentElement::from(ContentNet::new_with_ports( + nety_name, + PortList(vec![ + PortRef::new_member_with_ref("D", 26, dspref.clone()), + PortRef::new_member_with_ref("D", 16, dspref.clone()), + PortRef::new_member_with_ref("D", 15, dspref.clone()), + PortRef::new_member_with_ref("D", 14, dspref.clone()), + PortRef::new_member_with_ref("D", 13, dspref.clone()), + PortRef::new_member_with_ref("D", 12, dspref.clone()), + PortRef::new_member_with_ref("D", 11, dspref.clone()), + PortRef::new_member_with_ref("D", 10, dspref.clone()), + PortRef::new_member_with_ref("D", 9, dspref.clone()), + PortRef::new_member_with_ref("D", 8, dspref.clone()), + PortRef::new_member_with_ref("D", 7, dspref.clone()), + PortRef::new_member_with_ref("D", 25, dspref.clone()), + PortRef::new_member_with_ref("D", 6, dspref.clone()), + PortRef::new_member_with_ref("D", 5, dspref.clone()), + PortRef::new_member_with_ref("D", 4, dspref.clone()), + PortRef::new_member_with_ref("D", 3, dspref.clone()), + PortRef::new_member_with_ref("D", 2, dspref.clone()), + PortRef::new_member_with_ref("D", 1, dspref.clone()), + PortRef::new_member_with_ref("D", 0, dspref.clone()), + PortRef::new_member_with_ref("D", 24, dspref.clone()), + PortRef::new_member_with_ref("D", 23, dspref.clone()), + PortRef::new_member_with_ref("D", 22, dspref.clone()), + PortRef::new_member_with_ref("D", 21, dspref.clone()), + PortRef::new_member_with_ref("D", 20, dspref.clone()), + PortRef::new_member_with_ref("D", 19, dspref.clone()), + PortRef::new_member_with_ref("D", 18, dspref.clone()), + PortRef::new_member_with_ref("D", 17, dspref.clone()), + PortRef::new_with_ref("G", gnd1_ref), + ]), + )); + + let vcc2_name = "VCC_2".to_string(); + let vcc2 = ContentElement::from(ContentNet::new_with_ports( + vcc2_name, + PortList(vec![ + PortRef::new_member_with_ref("C", 47, dspref.clone()), + PortRef::new_member_with_ref("C", 37, dspref.clone()), + PortRef::new_member_with_ref("C", 36, dspref.clone()), + PortRef::new_member_with_ref("C", 35, dspref.clone()), + PortRef::new_member_with_ref("C", 34, dspref.clone()), + PortRef::new_member_with_ref("C", 33, dspref.clone()), + PortRef::new_member_with_ref("C", 32, dspref.clone()), + PortRef::new_member_with_ref("C", 31, dspref.clone()), + PortRef::new_member_with_ref("C", 30, dspref.clone()), + PortRef::new_member_with_ref("C", 29, dspref.clone()), + PortRef::new_member_with_ref("C", 28, dspref.clone()), + PortRef::new_member_with_ref("C", 46, dspref.clone()), + PortRef::new_member_with_ref("C", 27, dspref.clone()), + PortRef::new_member_with_ref("C", 26, dspref.clone()), + PortRef::new_member_with_ref("C", 25, dspref.clone()), + PortRef::new_member_with_ref("C", 24, dspref.clone()), + PortRef::new_member_with_ref("C", 23, dspref.clone()), + PortRef::new_member_with_ref("C", 22, dspref.clone()), + PortRef::new_member_with_ref("C", 21, dspref.clone()), + PortRef::new_member_with_ref("C", 20, dspref.clone()), + PortRef::new_member_with_ref("C", 19, dspref.clone()), + PortRef::new_member_with_ref("C", 18, dspref.clone()), + PortRef::new_member_with_ref("C", 45, dspref.clone()), + PortRef::new_member_with_ref("C", 17, dspref.clone()), + PortRef::new_member_with_ref("C", 16, dspref.clone()), + PortRef::new_member_with_ref("C", 15, dspref.clone()), + PortRef::new_member_with_ref("C", 14, dspref.clone()), + PortRef::new_member_with_ref("C", 13, dspref.clone()), + PortRef::new_member_with_ref("C", 12, dspref.clone()), + PortRef::new_member_with_ref("C", 11, dspref.clone()), + PortRef::new_member_with_ref("C", 10, dspref.clone()), + PortRef::new_member_with_ref("C", 9, dspref.clone()), + PortRef::new_member_with_ref("C", 8, dspref.clone()), + PortRef::new_member_with_ref("C", 44, dspref.clone()), + PortRef::new_member_with_ref("C", 7, dspref.clone()), + PortRef::new_member_with_ref("C", 6, dspref.clone()), + PortRef::new_member_with_ref("C", 5, dspref.clone()), + PortRef::new_member_with_ref("C", 4, dspref.clone()), + PortRef::new_member_with_ref("C", 3, dspref.clone()), + PortRef::new_member_with_ref("C", 2, dspref.clone()), + PortRef::new_member_with_ref("C", 1, dspref.clone()), + PortRef::new_member_with_ref("C", 0, dspref.clone()), + PortRef::new_member_with_ref("C", 43, dspref.clone()), + PortRef::new_member_with_ref("C", 42, dspref.clone()), + PortRef::new_member_with_ref("C", 41, dspref.clone()), + PortRef::new_member_with_ref("C", 40, dspref.clone()), + PortRef::new_member_with_ref("C", 39, dspref.clone()), + PortRef::new_member_with_ref("C", 38, dspref.clone()), + PortRef::new_with_ref("P", vcc1_ref), + ]), + )); + + let a0_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_0_", + "a[0]", + PortList(vec![ + PortRef::new_member_with_ref("A", 29, dspref.clone()), + PortRef::new_member("a", 7), + ]), + )); + let a1_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_1_", + "a[1]", + PortList(vec![ + PortRef::new_member_with_ref("A", 28, dspref.clone()), + PortRef::new_member("a", 6), + ]), + )); + let a2_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_2_", + "a[2]", + PortList(vec![ + PortRef::new_member_with_ref("A", 27, dspref.clone()), + PortRef::new_member("a", 5), + ]), + )); + let a3_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_3_", + "a[3]", + PortList(vec![ + PortRef::new_member_with_ref("A", 26, dspref.clone()), + PortRef::new_member("a", 4), + ]), + )); + let a4_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_4_", + "a[4]", + PortList(vec![ + PortRef::new_member_with_ref("A", 25, dspref.clone()), + PortRef::new_member("a", 3), + ]), + )); + let a5_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_5_", + "a[5]", + PortList(vec![ + PortRef::new_member_with_ref("A", 24, dspref.clone()), + PortRef::new_member("a", 2), + ]), + )); + let a6_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_6_", + "a[6]", + PortList(vec![ + PortRef::new_member_with_ref("A", 23, dspref.clone()), + PortRef::new_member("a", 1), + ]), + )); + let a7_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "a_7_", + "a[7]", + PortList(vec![ + PortRef::new_member_with_ref("A", 22, dspref.clone()), + PortRef::new_member("a", 0), + ]), + )); + let b0_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_0_", + "b[0]", + PortList(vec![ + PortRef::new_member_with_ref("B", 17, dspref.clone()), + PortRef::new_member("b", 7), + ]), + )); + let b1_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_1_", + "b[1]", + PortList(vec![ + PortRef::new_member_with_ref("B", 16, dspref.clone()), + PortRef::new_member("b", 6), + ]), + )); + let b2_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_2_", + "b[2]", + PortList(vec![ + PortRef::new_member_with_ref("B", 15, dspref.clone()), + PortRef::new_member("b", 5), + ]), + )); + let b3_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_3_", + "b[3]", + PortList(vec![ + PortRef::new_member_with_ref("B", 14, dspref.clone()), + PortRef::new_member("b", 4), + ]), + )); + let b4_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_4_", + "b[4]", + PortList(vec![ + PortRef::new_member_with_ref("B", 13, dspref.clone()), + PortRef::new_member("b", 3), + ]), + )); + let b5_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_5_", + "b[5]", + PortList(vec![ + PortRef::new_member_with_ref("B", 12, dspref.clone()), + PortRef::new_member("b", 2), + ]), + )); + let b6_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_6_", + "b[6]", + PortList(vec![ + PortRef::new_member_with_ref("B", 11, dspref.clone()), + PortRef::new_member("b", 1), + ]), + )); + let b7_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "b_7_", + "b[7]", + PortList(vec![ + PortRef::new_member_with_ref("B", 10, dspref.clone()), + PortRef::new_member("b", 0), + ]), + )); + let y0_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_0_", + "y[0]", + PortList(vec![ + PortRef::new_member_with_ref("P", 47, dspref.clone()), + PortRef::new_member("y", 7), + ]), + )); + let y1_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_1_", + "y[1]", + PortList(vec![ + PortRef::new_member_with_ref("P", 46, dspref.clone()), + PortRef::new_member("y", 6), + ]), + )); + let y2_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_2_", + "y[2]", + PortList(vec![ + PortRef::new_member_with_ref("P", 45, dspref.clone()), + PortRef::new_member("y", 5), + ]), + )); + let y3_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_3_", + "y[3]", + PortList(vec![ + PortRef::new_member_with_ref("P", 44, dspref.clone()), + PortRef::new_member("y", 4), + ]), + )); + let y4_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_4_", + "y[4]", + PortList(vec![ + PortRef::new_member_with_ref("P", 43, dspref.clone()), + PortRef::new_member("y", 3), + ]), + )); + let y5_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_5_", + "y[5]", + PortList(vec![ + PortRef::new_member_with_ref("P", 42, dspref.clone()), + PortRef::new_member("y", 2), + ]), + )); + let y6_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_6_", + "y[6]", + PortList(vec![ + PortRef::new_member_with_ref("P", 41, dspref.clone()), + PortRef::new_member("y", 1), + ]), + )); + let y7_net = ContentElement::from(ContentNet::new_renamed_with_ports( + "y_7_", + "y[7]", + PortList(vec![ + PortRef::new_member_with_ref("P", 40, dspref), + PortRef::new_member("y", 0), + ]), + )); + + let dsp_cell = Cell { + name: top_name.clone(), + views: CellViews(vec![CellView { + name: top_name.clone(), + interface: CellInterface(vec![ + InterfacePort::new_input_array("a", "a[7:0]", 8), + InterfacePort::new_input_array("b", "b[7:0]", 8), + InterfacePort::new_output_array("y", "y[7:0]", 8), + ]), + contents: CellContents(vec![ + gnd, gnd1, vcc, vcc1, dspinst, const_net, const1_net, gnd2, vcc2, a0_net, a1_net, + a2_net, a3_net, a4_net, a5_net, a6_net, a7_net, b0_net, b1_net, b2_net, b3_net, + b4_net, b5_net, b6_net, b7_net, y0_net, y1_net, y2_net, y3_net, y4_net, y5_net, + y6_net, y7_net, + ]), + properties: PropertyList(vec![Property::new_string("ECO_CHECKSUM", "2ac8fb58")]), + }]), + }; + + let lib_work = Library { + name: work_name.clone(), + elements: Cells::from(vec![dsp_cell]), + }; + + let design_dsp = Design::new_with_prop( + top_name.clone(), + CellRef::new(top_name.clone(), work_name), + PropertyList(vec![Property::new_string("part", "xczu3eg-sbva484-1-e")]), + ); + + let libp = EdifElement::from(lib_prims); + let libw = EdifElement::from(lib_work); + let desi = EdifElement::from(design_dsp); + + Edif { + name: top_name, + elements: EdifElements::from(vec![libp, libw, desi]), + } +} diff --git a/src/langs/edif/src/platforms/tests/xilinx_ut.rs b/src/langs/edif/src/platforms/tests/xilinx_ut.rs new file mode 100644 index 00000000..66fb07dd --- /dev/null +++ b/src/langs/edif/src/platforms/tests/xilinx_ut.rs @@ -0,0 +1,113 @@ +/* +Copyright 2021 Pedro M. Torruella N. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +use edifier::ast::*; +use edifier::string_helpers::match_check; +use platforms::xilinx::*; + +// Test 1: we should get a lut2 element +#[test] +fn lut2() { + let ed = new_lut2(); + + let actual = serde_sexpr::to_string(&ed).unwrap(); + + assert_eq!( + actual, + "(cell LUT2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port O (direction OUTPUT)) (port I0 (direction INPUT)) (port I1 (direction INPUT)))))" + ); + //assert_eq!(match_check(actual), 0); +} + +// Test 2: we should get an instance with properties +// for a placed lut2 element +#[test] +fn lut2_instance() { + let mut proplist = PropertyList(Vec::new()); + proplist.push(lut2_prop_ini("4'h6")); + proplist.push(lut2_prop_box("PRIMITIVE")); + proplist.push(lut2_prop_loc("SLICE_X0Y0")); + proplist.push(lut2_prop_bel("A6LUT")); + + let contents = ContentInstance { + token: StringToken::new("i0"), + viewref: "netlist".to_string(), + cellref: CellRef::new("LUT2", "hdi_primitives"), + properties: proplist, + }; + + let actual = serde_sexpr::to_string(&contents).unwrap(); + + assert_eq!( + actual, + r#"(instance i0 (viewref netlist (cellref LUT2 (libraryref hdi_primitives))) (property INIT (string "4'h6")) (property BOX_TYPE (string "PRIMITIVE")) (property LOC (string "SLICE_X0Y0")) (property BEL (string "A6LUT")))"# + ); +} + +// Test 3: we should get an instance with properties +// for a placed lut2 element, being renamed +#[test] +fn lut2_instance_renamed() { + let mut proplist = PropertyList(Vec::new()); + proplist.push(lut2_prop_ini("4'h6")); + proplist.push(lut2_prop_box("PRIMITIVE")); + proplist.push(lut2_prop_loc("SLICE_X0Y0")); + proplist.push(lut2_prop_bel("A6LUT")); + + let contents = ContentInstance { + token: StringToken::new_renamed( + "address_loop_2__output_data_pc_vector_mux_lut", + r#"address_loop[2].output_data.pc_vector_mux_lut"#, + ), + viewref: "netlist".to_string(), + cellref: CellRef::new("LUT2", "hdi_primitives"), + properties: proplist, + }; + + let actual = serde_sexpr::to_string(&contents).unwrap(); + + assert_eq!( + actual, + r#"(instance (rename address_loop_2__output_data_pc_vector_mux_lut "address_loop[2].output_data.pc_vector_mux_lut") (viewref netlist (cellref LUT2 (libraryref hdi_primitives))) (property INIT (string "4'h6")) (property BOX_TYPE (string "PRIMITIVE")) (property LOC (string "SLICE_X0Y0")) (property BEL (string "A6LUT")))"# + ); +} + +// Test 4: Testing arrays +#[test] +fn simple_array() { + let ed = carry8(); + + let actual = serde_sexpr::to_string(&ed).unwrap(); + + assert_eq!( + actual, + r#"(cell CARRY8 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port CI (direction INPUT)) (port CI_TOP (direction INPUT)) (port (array (rename CO "CO[7:0]") 8) (direction OUTPUT)) (port (array (rename O "O[7:0]") 8) (direction OUTPUT)) (port (array (rename DI "DI[7:0]") 8) (direction INPUT)) (port (array (rename S "S[7:0]") 8) (direction INPUT)))))"# + ); + assert_eq!(match_check(actual), 0); +} + +// Test 5: Testing the inverter example +#[test] +fn test_inverter_top() { + let edif = inverter(); + + let actual = serde_sexpr::to_string(&edif).unwrap(); + + assert_eq!( + actual, + r#"(edif inverter (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library hdi_primitives (edifLevel 0) (technology (numberDefinition)) (cell LUT2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port O (direction OUTPUT)) (port I0 (direction INPUT)) (port I1 (direction INPUT))))) (cell INV (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port I (direction INPUT)) (port O (direction OUTPUT)))))) (Library work (edifLevel 0) (technology (numberDefinition)) (cell inverter (celltype GENERIC) (view inverter (viewtype NETLIST) (interface (port a (direction INPUT)) (port b (direction INPUT)) (port y (direction OUTPUT))) (contents (instance y_INST_0 (viewref netlist (cellref LUT2 (libraryref hdi_primitives))) (property INIT (string "4'h8"))) (net a (joined (portref I0 (instanceref y_INST_0)) (portref a))) (net b (joined (portref I1 (instanceref y_INST_0)) (portref b))) (net y (joined (portref O (instanceref y_INST_0)) (portref y))))))) (design inverter (cellref inverter (libraryref work)) (property part (string "xczu3eg-sbva484-1-e"))))"# + ); + assert_eq!(match_check(actual), 0); +} diff --git a/src/langs/edif/src/xilinx_multiplier.edf b/src/langs/edif/src/xilinx_multiplier.edf new file mode 100644 index 00000000..dac95841 --- /dev/null +++ b/src/langs/edif/src/xilinx_multiplier.edf @@ -0,0 +1 @@ +(edif dsp2 (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library hdi_primitives (edifLevel 0) (technology (numberDefinition)) (cell GND (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port G (direction OUTPUT))))) (cell VCC (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port P (direction OUTPUT))))) (cell DSP48E2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port CARRYCASCOUT (direction OUTPUT)) (port MULTSIGNOUT (direction OUTPUT)) (port OVERFLOW (direction OUTPUT)) (port PATTERNBDETECT (direction OUTPUT)) (port PATTERNDETECT (direction OUTPUT)) (port UNDERFLOW (direction OUTPUT)) (port CARRYCASCIN (direction INPUT)) (port CARRYIN (direction INPUT)) (port CEA1 (direction INPUT)) (port CEA2 (direction INPUT)) (port CEAD (direction INPUT)) (port CEALUMODE (direction INPUT)) (port CEB1 (direction INPUT)) (port CEB2 (direction INPUT)) (port CEC (direction INPUT)) (port CECARRYIN (direction INPUT)) (port CECTRL (direction INPUT)) (port CED (direction INPUT)) (port CEINMODE (direction INPUT)) (port CEM (direction INPUT)) (port CEP (direction INPUT)) (port CLK (direction INPUT)) (port MULTSIGNIN (direction INPUT)) (port RSTA (direction INPUT)) (port RSTALLCARRYIN (direction INPUT)) (port RSTALUMODE (direction INPUT)) (port RSTB (direction INPUT)) (port RSTC (direction INPUT)) (port RSTCTRL (direction INPUT)) (port RSTD (direction INPUT)) (port RSTINMODE (direction INPUT)) (port RSTM (direction INPUT)) (port RSTP (direction INPUT)) (port (array (rename ACOUT "ACOUT[29:0]") 30) (direction OUTPUT)) (port (array (rename BCOUT "BCOUT[17:0]") 18) (direction OUTPUT)) (port (array (rename CARRYOUT "CARRYOUT[3:0]") 4) (direction OUTPUT)) (port (array (rename PCOUT "PCOUT[47:0]") 48) (direction OUTPUT)) (port (array (rename P "P[47:0]") 48) (direction OUTPUT)) (port (array (rename XOROUT "XOROUT[7:0]") 8) (direction OUTPUT)) (port (array (rename ACIN "ACIN[29:0]") 30) (direction INPUT)) (port (array (rename ALUMODE "ALUMODE[3:0]") 4) (direction INPUT)) (port (array (rename A "A[29:0]") 30) (direction INPUT)) (port (array (rename BCIN "BCIN[17:0]") 18) (direction INPUT)) (port (array (rename B "B[17:0]") 18) (direction INPUT)) (port (array (rename CARRYINSEL "CARRYINSEL[2:0]") 3) (direction INPUT)) (port (array (rename C "C[47:0]") 48) (direction INPUT)) (port (array (rename D "D[26:0]") 27) (direction INPUT)) (port (array (rename INMODE "INMODE[4:0]") 5) (direction INPUT)) (port (array (rename OPMODE "OPMODE[8:0]") 9) (direction INPUT)) (port (array (rename PCIN "PCIN[47:0]") 48) (direction INPUT))))) (cell INV (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port I (direction INPUT)) (port O (direction OUTPUT)))))) (Library work (edifLevel 0) (technology (numberDefinition)) (cell dsp2 (celltype GENERIC) (view dsp2 (viewtype NETLIST) (interface (port (array (rename a "a[7:0]") 8) (direction INPUT)) (port (array (rename b "b[7:0]") 8) (direction INPUT)) (port (array (rename y "y[7:0]") 8) (direction OUTPUT))) (contents (instance GND (viewref netlist (cellref GND (libraryref hdi_primitives)))) (instance GND_1 (viewref netlist (cellref GND (libraryref hdi_primitives)))) (instance VCC (viewref netlist (cellref VCC (libraryref hdi_primitives)))) (instance VCC_1 (viewref netlist (cellref VCC (libraryref hdi_primitives)))) (instance res (viewref netlist (cellref DSP48E2 (libraryref hdi_primitives))) (property XORSIMD (string "XOR24_48_96")) (property USE_WIDEXOR (string "FALSE")) (property ACASCREG (integer 0)) (property ADREG (integer 1)) (property ALUMODEREG (integer 0)) (property AMULTSEL (string "A")) (property AREG (integer 0)) (property AUTORESET_PATDET (string "NO_RESET")) (property AUTORESET_PRIORITY (string "RESET")) (property A_INPUT (string "DIRECT")) (property BCASCREG (integer 0)) (property BMULTSEL (string "B")) (property BREG (integer 0)) (property B_INPUT (string "DIRECT")) (property CARRYINREG (integer 0)) (property CARRYINSELREG (integer 0)) (property CREG (integer 1)) (property DREG (integer 1)) (property INMODEREG (integer 0)) (property MASK (string "48'h3FFFFFFFFFFF")) (property METHODOLOGY_DRC_VIOS (string |"{SYNTH-13\ {cell\ *THIS*}}"|)) (property MREG (integer 0)) (property OPMODEREG (integer 0)) (property PATTERN (string "48'h000000000000")) (property PREADDINSEL (string "A")) (property PREG (integer 0)) (property RND (string "48'h000000000000")) (property SEL_MASK (string "MASK")) (property SEL_PATTERN (string "PATTERN")) (property USE_MULT (string "MULTIPLY")) (property USE_PATTERN_DETECT (string "NO_PATDET")) (property USE_SIMD (string "ONE48")) (property OPT_MODIFIED (string "SWEEP"))) (net (rename &_const0_ "") (joined (portref (member ACIN 29) (instanceref res)) (portref (member ACIN 19) (instanceref res)) (portref (member ACIN 18) (instanceref res)) (portref (member ACIN 17) (instanceref res)) (portref (member ACIN 16) (instanceref res)) (portref (member ACIN 15) (instanceref res)) (portref (member ACIN 14) (instanceref res)) (portref (member ACIN 13) (instanceref res)) (portref (member ACIN 12) (instanceref res)) (portref (member ACIN 11) (instanceref res)) (portref (member ACIN 10) (instanceref res)) (portref (member ACIN 28) (instanceref res)) (portref (member ACIN 9) (instanceref res)) (portref (member ACIN 8) (instanceref res)) (portref (member ACIN 7) (instanceref res)) (portref (member ACIN 6) (instanceref res)) (portref (member ACIN 5) (instanceref res)) (portref (member ACIN 4) (instanceref res)) (portref (member ACIN 3) (instanceref res)) (portref (member ACIN 2) (instanceref res)) (portref (member ACIN 1) (instanceref res)) (portref (member ACIN 0) (instanceref res)) (portref (member ACIN 27) (instanceref res)) (portref (member ACIN 26) (instanceref res)) (portref (member ACIN 25) (instanceref res)) (portref (member ACIN 24) (instanceref res)) (portref (member ACIN 23) (instanceref res)) (portref (member ACIN 22) (instanceref res)) (portref (member ACIN 21) (instanceref res)) (portref (member ACIN 20) (instanceref res)) (portref (member ALUMODE 3) (instanceref res)) (portref (member ALUMODE 2) (instanceref res)) (portref (member ALUMODE 1) (instanceref res)) (portref (member ALUMODE 0) (instanceref res)) (portref (member A 19) (instanceref res)) (portref (member A 18) (instanceref res)) (portref (member A 17) (instanceref res)) (portref (member A 16) (instanceref res)) (portref (member A 15) (instanceref res)) (portref (member A 14) (instanceref res)) (portref (member A 13) (instanceref res)) (portref (member A 12) (instanceref res)) (portref (member A 11) (instanceref res)) (portref (member A 10) (instanceref res)) (portref (member A 9) (instanceref res)) (portref (member A 8) (instanceref res)) (portref (member A 7) (instanceref res)) (portref (member A 6) (instanceref res)) (portref (member A 5) (instanceref res)) (portref (member A 4) (instanceref res)) (portref (member A 3) (instanceref res)) (portref (member A 2) (instanceref res)) (portref (member A 1) (instanceref res)) (portref (member A 0) (instanceref res)) (portref (member A 21) (instanceref res)) (portref (member A 20) (instanceref res)) (portref (member BCIN 17) (instanceref res)) (portref (member BCIN 7) (instanceref res)) (portref (member BCIN 6) (instanceref res)) (portref (member BCIN 5) (instanceref res)) (portref (member BCIN 4) (instanceref res)) (portref (member BCIN 3) (instanceref res)) (portref (member BCIN 2) (instanceref res)) (portref (member BCIN 1) (instanceref res)) (portref (member BCIN 0) (instanceref res)) (portref (member BCIN 16) (instanceref res)) (portref (member BCIN 15) (instanceref res)) (portref (member BCIN 14) (instanceref res)) (portref (member BCIN 13) (instanceref res)) (portref (member BCIN 12) (instanceref res)) (portref (member BCIN 11) (instanceref res)) (portref (member BCIN 10) (instanceref res)) (portref (member BCIN 9) (instanceref res)) (portref (member BCIN 8) (instanceref res)) (portref (member B 7) (instanceref res)) (portref (member B 6) (instanceref res)) (portref (member B 5) (instanceref res)) (portref (member B 4) (instanceref res)) (portref (member B 3) (instanceref res)) (portref (member B 2) (instanceref res)) (portref (member B 1) (instanceref res)) (portref (member B 0) (instanceref res)) (portref (member B 9) (instanceref res)) (portref (member B 8) (instanceref res)) (portref CARRYCASCIN (instanceref res)) (portref CARRYIN (instanceref res)) (portref (member CARRYINSEL 2) (instanceref res)) (portref (member CARRYINSEL 1) (instanceref res)) (portref (member CARRYINSEL 0) (instanceref res)) (portref CEA1 (instanceref res)) (portref CEA2 (instanceref res)) (portref CEAD (instanceref res)) (portref CEALUMODE (instanceref res)) (portref CEB1 (instanceref res)) (portref CEB2 (instanceref res)) (portref CEC (instanceref res)) (portref CECARRYIN (instanceref res)) (portref CECTRL (instanceref res)) (portref CED (instanceref res)) (portref CEINMODE (instanceref res)) (portref CEM (instanceref res)) (portref CEP (instanceref res)) (portref CLK (instanceref res)) (portref G (instanceref GND)) (portref (member INMODE 4) (instanceref res)) (portref (member INMODE 3) (instanceref res)) (portref (member INMODE 2) (instanceref res)) (portref (member INMODE 1) (instanceref res)) (portref (member INMODE 0) (instanceref res)) (portref MULTSIGNIN (instanceref res)) (portref (member OPMODE 7) (instanceref res)) (portref (member OPMODE 5) (instanceref res)) (portref (member OPMODE 4) (instanceref res)) (portref (member OPMODE 3) (instanceref res)) (portref (member OPMODE 2) (instanceref res)) (portref (member OPMODE 1) (instanceref res)) (portref (member OPMODE 0) (instanceref res)) (portref (member PCIN 47) (instanceref res)) (portref (member PCIN 37) (instanceref res)) (portref (member PCIN 36) (instanceref res)) (portref (member PCIN 35) (instanceref res)) (portref (member PCIN 34) (instanceref res)) (portref (member PCIN 33) (instanceref res)) (portref (member PCIN 32) (instanceref res)) (portref (member PCIN 31) (instanceref res)) (portref (member PCIN 30) (instanceref res)) (portref (member PCIN 29) (instanceref res)) (portref (member PCIN 28) (instanceref res)) (portref (member PCIN 46) (instanceref res)) (portref (member PCIN 27) (instanceref res)) (portref (member PCIN 26) (instanceref res)) (portref (member PCIN 25) (instanceref res)) (portref (member PCIN 24) (instanceref res)) (portref (member PCIN 23) (instanceref res)) (portref (member PCIN 22) (instanceref res)) (portref (member PCIN 21) (instanceref res)) (portref (member PCIN 20) (instanceref res)) (portref (member PCIN 19) (instanceref res)) (portref (member PCIN 18) (instanceref res)) (portref (member PCIN 45) (instanceref res)) (portref (member PCIN 17) (instanceref res)) (portref (member PCIN 16) (instanceref res)) (portref (member PCIN 15) (instanceref res)) (portref (member PCIN 14) (instanceref res)) (portref (member PCIN 13) (instanceref res)) (portref (member PCIN 12) (instanceref res)) (portref (member PCIN 11) (instanceref res)) (portref (member PCIN 10) (instanceref res)) (portref (member PCIN 9) (instanceref res)) (portref (member PCIN 8) (instanceref res)) (portref (member PCIN 44) (instanceref res)) (portref (member PCIN 7) (instanceref res)) (portref (member PCIN 6) (instanceref res)) (portref (member PCIN 5) (instanceref res)) (portref (member PCIN 4) (instanceref res)) (portref (member PCIN 3) (instanceref res)) (portref (member PCIN 2) (instanceref res)) (portref (member PCIN 1) (instanceref res)) (portref (member PCIN 0) (instanceref res)) (portref (member PCIN 43) (instanceref res)) (portref (member PCIN 42) (instanceref res)) (portref (member PCIN 41) (instanceref res)) (portref (member PCIN 40) (instanceref res)) (portref (member PCIN 39) (instanceref res)) (portref (member PCIN 38) (instanceref res)) (portref RSTA (instanceref res)) (portref RSTALLCARRYIN (instanceref res)) (portref RSTALUMODE (instanceref res)) (portref RSTB (instanceref res)) (portref RSTC (instanceref res)) (portref RSTCTRL (instanceref res)) (portref RSTD (instanceref res)) (portref RSTINMODE (instanceref res)) (portref RSTM (instanceref res)) (portref RSTP (instanceref res)))) (net (rename &_const1_ "") (joined (portref (member OPMODE 8) (instanceref res)) (portref (member OPMODE 6) (instanceref res)) (portref P (instanceref VCC)))) (net GND_2 (joined (portref (member D 26) (instanceref res)) (portref (member D 16) (instanceref res)) (portref (member D 15) (instanceref res)) (portref (member D 14) (instanceref res)) (portref (member D 13) (instanceref res)) (portref (member D 12) (instanceref res)) (portref (member D 11) (instanceref res)) (portref (member D 10) (instanceref res)) (portref (member D 9) (instanceref res)) (portref (member D 8) (instanceref res)) (portref (member D 7) (instanceref res)) (portref (member D 25) (instanceref res)) (portref (member D 6) (instanceref res)) (portref (member D 5) (instanceref res)) (portref (member D 4) (instanceref res)) (portref (member D 3) (instanceref res)) (portref (member D 2) (instanceref res)) (portref (member D 1) (instanceref res)) (portref (member D 0) (instanceref res)) (portref (member D 24) (instanceref res)) (portref (member D 23) (instanceref res)) (portref (member D 22) (instanceref res)) (portref (member D 21) (instanceref res)) (portref (member D 20) (instanceref res)) (portref (member D 19) (instanceref res)) (portref (member D 18) (instanceref res)) (portref (member D 17) (instanceref res)) (portref G (instanceref GND_1)))) (net VCC_2 (joined (portref (member C 47) (instanceref res)) (portref (member C 37) (instanceref res)) (portref (member C 36) (instanceref res)) (portref (member C 35) (instanceref res)) (portref (member C 34) (instanceref res)) (portref (member C 33) (instanceref res)) (portref (member C 32) (instanceref res)) (portref (member C 31) (instanceref res)) (portref (member C 30) (instanceref res)) (portref (member C 29) (instanceref res)) (portref (member C 28) (instanceref res)) (portref (member C 46) (instanceref res)) (portref (member C 27) (instanceref res)) (portref (member C 26) (instanceref res)) (portref (member C 25) (instanceref res)) (portref (member C 24) (instanceref res)) (portref (member C 23) (instanceref res)) (portref (member C 22) (instanceref res)) (portref (member C 21) (instanceref res)) (portref (member C 20) (instanceref res)) (portref (member C 19) (instanceref res)) (portref (member C 18) (instanceref res)) (portref (member C 45) (instanceref res)) (portref (member C 17) (instanceref res)) (portref (member C 16) (instanceref res)) (portref (member C 15) (instanceref res)) (portref (member C 14) (instanceref res)) (portref (member C 13) (instanceref res)) (portref (member C 12) (instanceref res)) (portref (member C 11) (instanceref res)) (portref (member C 10) (instanceref res)) (portref (member C 9) (instanceref res)) (portref (member C 8) (instanceref res)) (portref (member C 44) (instanceref res)) (portref (member C 7) (instanceref res)) (portref (member C 6) (instanceref res)) (portref (member C 5) (instanceref res)) (portref (member C 4) (instanceref res)) (portref (member C 3) (instanceref res)) (portref (member C 2) (instanceref res)) (portref (member C 1) (instanceref res)) (portref (member C 0) (instanceref res)) (portref (member C 43) (instanceref res)) (portref (member C 42) (instanceref res)) (portref (member C 41) (instanceref res)) (portref (member C 40) (instanceref res)) (portref (member C 39) (instanceref res)) (portref (member C 38) (instanceref res)) (portref P (instanceref VCC_1)))) (net (rename a_0_ "a[0]") (joined (portref (member A 29) (instanceref res)) (portref (member a 7)))) (net (rename a_1_ "a[1]") (joined (portref (member A 28) (instanceref res)) (portref (member a 6)))) (net (rename a_2_ "a[2]") (joined (portref (member A 27) (instanceref res)) (portref (member a 5)))) (net (rename a_3_ "a[3]") (joined (portref (member A 26) (instanceref res)) (portref (member a 4)))) (net (rename a_4_ "a[4]") (joined (portref (member A 25) (instanceref res)) (portref (member a 3)))) (net (rename a_5_ "a[5]") (joined (portref (member A 24) (instanceref res)) (portref (member a 2)))) (net (rename a_6_ "a[6]") (joined (portref (member A 23) (instanceref res)) (portref (member a 1)))) (net (rename a_7_ "a[7]") (joined (portref (member A 22) (instanceref res)) (portref (member a 0)))) (net (rename b_0_ "b[0]") (joined (portref (member B 17) (instanceref res)) (portref (member b 7)))) (net (rename b_1_ "b[1]") (joined (portref (member B 16) (instanceref res)) (portref (member b 6)))) (net (rename b_2_ "b[2]") (joined (portref (member B 15) (instanceref res)) (portref (member b 5)))) (net (rename b_3_ "b[3]") (joined (portref (member B 14) (instanceref res)) (portref (member b 4)))) (net (rename b_4_ "b[4]") (joined (portref (member B 13) (instanceref res)) (portref (member b 3)))) (net (rename b_5_ "b[5]") (joined (portref (member B 12) (instanceref res)) (portref (member b 2)))) (net (rename b_6_ "b[6]") (joined (portref (member B 11) (instanceref res)) (portref (member b 1)))) (net (rename b_7_ "b[7]") (joined (portref (member B 10) (instanceref res)) (portref (member b 0)))) (net (rename y_0_ "y[0]") (joined (portref (member P 47) (instanceref res)) (portref (member y 7)))) (net (rename y_1_ "y[1]") (joined (portref (member P 46) (instanceref res)) (portref (member y 6)))) (net (rename y_2_ "y[2]") (joined (portref (member P 45) (instanceref res)) (portref (member y 5)))) (net (rename y_3_ "y[3]") (joined (portref (member P 44) (instanceref res)) (portref (member y 4)))) (net (rename y_4_ "y[4]") (joined (portref (member P 43) (instanceref res)) (portref (member y 3)))) (net (rename y_5_ "y[5]") (joined (portref (member P 42) (instanceref res)) (portref (member y 2)))) (net (rename y_6_ "y[6]") (joined (portref (member P 41) (instanceref res)) (portref (member y 1)))) (net (rename y_7_ "y[7]") (joined (portref (member P 40) (instanceref res)) (portref (member y 0))))) ((property ECO_CHECKSUM (string "2ac8fb58")))))) (design dsp2 (cellref dsp2 (libraryref work)) (property part (string "xczu3eg-sbva484-1-e")))) \ No newline at end of file diff --git a/src/langs/edif/xilinx_multiplier.edf b/src/langs/edif/xilinx_multiplier.edf new file mode 100644 index 00000000..57616d83 --- /dev/null +++ b/src/langs/edif/xilinx_multiplier.edf @@ -0,0 +1,666 @@ +(edif dsp2 + (edifversion 2 0 0) + (edifLevel 0) + (keywordmap + (keywordlevel 0)) + (Library hdi_primitives + (edifLevel 0) + (technology + (numberDefinition)) + (cell GND + (celltype GENERIC) + (view netlist + (viewtype NETLIST) + (interface + (port G + (direction OUTPUT))))) + (cell VCC + (celltype GENERIC) + (view netlist + (viewtype NETLIST) + (interface + (port P + (direction OUTPUT))))) + (cell DSP48E2 + (celltype GENERIC) + (view netlist + (viewtype NETLIST) + (interface + (port CARRYCASCOUT + (direction OUTPUT)) + (port MULTSIGNOUT + (direction OUTPUT)) + (port OVERFLOW + (direction OUTPUT)) + (port PATTERNBDETECT + (direction OUTPUT)) + (port PATTERNDETECT + (direction OUTPUT)) + (port UNDERFLOW + (direction OUTPUT)) + (port CARRYCASCIN + (direction INPUT)) + (port CARRYIN + (direction INPUT)) + (port CEA1 + (direction INPUT)) + (port CEA2 + (direction INPUT)) + (port CEAD + (direction INPUT)) + (port CEALUMODE + (direction INPUT)) + (port CEB1 + (direction INPUT)) + (port CEB2 + (direction INPUT)) + (port CEC + (direction INPUT)) + (port CECARRYIN + (direction INPUT)) + (port CECTRL + (direction INPUT)) + (port CED + (direction INPUT)) + (port CEINMODE + (direction INPUT)) + (port CEM + (direction INPUT)) + (port CEP + (direction INPUT)) + (port CLK + (direction INPUT)) + (port MULTSIGNIN + (direction INPUT)) + (port RSTA + (direction INPUT)) + (port RSTALLCARRYIN + (direction INPUT)) + (port RSTALUMODE + (direction INPUT)) + (port RSTB + (direction INPUT)) + (port RSTC + (direction INPUT)) + (port RSTCTRL + (direction INPUT)) + (port RSTD + (direction INPUT)) + (port RSTINMODE + (direction INPUT)) + (port RSTM + (direction INPUT)) + (port RSTP + (direction INPUT)) + (port + (array + (rename ACOUT "ACOUT[29:0]") 30) + (direction OUTPUT)) + (port + (array + (rename BCOUT "BCOUT[17:0]") 18) + (direction OUTPUT)) + (port + (array + (rename CARRYOUT "CARRYOUT[3:0]") 4) + (direction OUTPUT)) + (port + (array + (rename PCOUT "PCOUT[47:0]") 48) + (direction OUTPUT)) + (port + (array + (rename P "P[47:0]") 48) + (direction OUTPUT)) + (port + (array + (rename XOROUT "XOROUT[7:0]") 8) + (direction OUTPUT)) + (port + (array + (rename ACIN "ACIN[29:0]") 30) + (direction INPUT)) + (port + (array + (rename ALUMODE "ALUMODE[3:0]") 4) + (direction INPUT)) + (port + (array + (rename A "A[29:0]") 30) + (direction INPUT)) + (port + (array + (rename BCIN "BCIN[17:0]") 18) + (direction INPUT)) + (port + (array + (rename B "B[17:0]") 18) + (direction INPUT)) + (port + (array + (rename CARRYINSEL "CARRYINSEL[2:0]") 3) + (direction INPUT)) + (port + (array + (rename C "C[47:0]") 48) + (direction INPUT)) + (port + (array + (rename D "D[26:0]") 27) + (direction INPUT)) + (port + (array + (rename INMODE "INMODE[4:0]") 5) + (direction INPUT)) + (port + (array + (rename OPMODE "OPMODE[8:0]") 9) + (direction INPUT)) + (port + (array + (rename PCIN "PCIN[47:0]") 48) + (direction INPUT))))) + (cell INV + (celltype GENERIC) + (view netlist + (viewtype NETLIST) + (interface + (port I + (direction INPUT)) + (port O + (direction OUTPUT)))))) + (Library work + (edifLevel 0) + (technology + (numberDefinition)) + (cell dsp2 + (celltype GENERIC) + (view dsp2 + (viewtype NETLIST) + (interface + (port + (array + (rename a "a[7:0]") 8) + (direction INPUT)) + (port + (array + (rename b "b[7:0]") 8) + (direction INPUT)) + (port + (array + (rename y "y[7:0]") 8) + (direction OUTPUT))) + (contents + (instance GND + (viewref netlist + (cellref GND (libraryref hdi_primitives)))) + (instance GND_1 + (viewref netlist + (cellref GND (libraryref hdi_primitives)))) + (instance VCC + (viewref netlist + (cellref VCC (libraryref hdi_primitives)))) + (instance VCC_1 + (viewref netlist + (cellref VCC (libraryref hdi_primitives)))) + (instance res + (viewref netlist + (cellref DSP48E2 (libraryref hdi_primitives))) + (property XORSIMD + (string "XOR24_48_96")) + (property USE_WIDEXOR + (string "FALSE")) + (property ACASCREG + (integer 0)) + (property ADREG + (integer 1)) + (property ALUMODEREG + (integer 0)) + (property AMULTSEL + (string "A")) + (property AREG + (integer 0)) + (property AUTORESET_PATDET + (string "NO_RESET")) + (property AUTORESET_PRIORITY + (string "RESET")) + (property A_INPUT + (string "DIRECT")) + (property BCASCREG + (integer 0)) + (property BMULTSEL + (string "B")) + (property BREG + (integer 0)) + (property B_INPUT + (string "DIRECT")) + (property CARRYINREG + (integer 0)) + (property CARRYINSELREG + (integer 0)) + (property CREG + (integer 1)) + (property DREG + (integer 1)) + (property INMODEREG + (integer 0)) + (property MASK + (string "48'h3FFFFFFFFFFF")) + (property METHODOLOGY_DRC_VIOS + (string |"{SYNTH-13\ {cell\ *THIS*}}"|)) + (property MREG + (integer 0)) + (property OPMODEREG + (integer 0)) + (property PATTERN + (string "48'h000000000000")) + (property PREADDINSEL + (string "A")) + (property PREG + (integer 0)) + (property RND + (string "48'h000000000000")) + (property SEL_MASK + (string "MASK")) + (property SEL_PATTERN + (string "PATTERN")) + (property USE_MULT + (string "MULTIPLY")) + (property USE_PATTERN_DETECT + (string "NO_PATDET")) + (property USE_SIMD + (string "ONE48")) + (property OPT_MODIFIED + (string "SWEEP"))) + (net + (rename &_const0_ "") + (joined + (portref (member ACIN 29) (instanceref res)) + (portref (member ACIN 19) (instanceref res)) + (portref (member ACIN 18) (instanceref res)) + (portref (member ACIN 17) (instanceref res)) + (portref (member ACIN 16) (instanceref res)) + (portref (member ACIN 15) (instanceref res)) + (portref (member ACIN 14) (instanceref res)) + (portref (member ACIN 13) (instanceref res)) + (portref (member ACIN 12) (instanceref res)) + (portref (member ACIN 11) (instanceref res)) + (portref (member ACIN 10) (instanceref res)) + (portref (member ACIN 28) (instanceref res)) + (portref (member ACIN 9) (instanceref res)) + (portref (member ACIN 8) (instanceref res)) + (portref (member ACIN 7) (instanceref res)) + (portref (member ACIN 6) (instanceref res)) + (portref (member ACIN 5) (instanceref res)) + (portref (member ACIN 4) (instanceref res)) + (portref (member ACIN 3) (instanceref res)) + (portref (member ACIN 2) (instanceref res)) + (portref (member ACIN 1) (instanceref res)) + (portref (member ACIN 0) (instanceref res)) + (portref (member ACIN 27) (instanceref res)) + (portref (member ACIN 26) (instanceref res)) + (portref (member ACIN 25) (instanceref res)) + (portref (member ACIN 24) (instanceref res)) + (portref (member ACIN 23) (instanceref res)) + (portref (member ACIN 22) (instanceref res)) + (portref (member ACIN 21) (instanceref res)) + (portref (member ACIN 20) (instanceref res)) + (portref (member ALUMODE 3) (instanceref res)) + (portref (member ALUMODE 2) (instanceref res)) + (portref (member ALUMODE 1) (instanceref res)) + (portref (member ALUMODE 0) (instanceref res)) + (portref (member A 19) (instanceref res)) + (portref (member A 18) (instanceref res)) + (portref (member A 17) (instanceref res)) + (portref (member A 16) (instanceref res)) + (portref (member A 15) (instanceref res)) + (portref (member A 14) (instanceref res)) + (portref (member A 13) (instanceref res)) + (portref (member A 12) (instanceref res)) + (portref (member A 11) (instanceref res)) + (portref (member A 10) (instanceref res)) + (portref (member A 9) (instanceref res)) + (portref (member A 8) (instanceref res)) + (portref (member A 7) (instanceref res)) + (portref (member A 6) (instanceref res)) + (portref (member A 5) (instanceref res)) + (portref (member A 4) (instanceref res)) + (portref (member A 3) (instanceref res)) + (portref (member A 2) (instanceref res)) + (portref (member A 1) (instanceref res)) + (portref (member A 0) (instanceref res)) + (portref (member A 21) (instanceref res)) + (portref (member A 20) (instanceref res)) + (portref (member BCIN 17) (instanceref res)) + (portref (member BCIN 7) (instanceref res)) + (portref (member BCIN 6) (instanceref res)) + (portref (member BCIN 5) (instanceref res)) + (portref (member BCIN 4) (instanceref res)) + (portref (member BCIN 3) (instanceref res)) + (portref (member BCIN 2) (instanceref res)) + (portref (member BCIN 1) (instanceref res)) + (portref (member BCIN 0) (instanceref res)) + (portref (member BCIN 16) (instanceref res)) + (portref (member BCIN 15) (instanceref res)) + (portref (member BCIN 14) (instanceref res)) + (portref (member BCIN 13) (instanceref res)) + (portref (member BCIN 12) (instanceref res)) + (portref (member BCIN 11) (instanceref res)) + (portref (member BCIN 10) (instanceref res)) + (portref (member BCIN 9) (instanceref res)) + (portref (member BCIN 8) (instanceref res)) + (portref (member B 7) (instanceref res)) + (portref (member B 6) (instanceref res)) + (portref (member B 5) (instanceref res)) + (portref (member B 4) (instanceref res)) + (portref (member B 3) (instanceref res)) + (portref (member B 2) (instanceref res)) + (portref (member B 1) (instanceref res)) + (portref (member B 0) (instanceref res)) + (portref (member B 9) (instanceref res)) + (portref (member B 8) (instanceref res)) + (portref CARRYCASCIN (instanceref res)) + (portref CARRYIN (instanceref res)) + (portref (member CARRYINSEL 2) (instanceref res)) + (portref (member CARRYINSEL 1) (instanceref res)) + (portref (member CARRYINSEL 0) (instanceref res)) + (portref CEA1 (instanceref res)) + (portref CEA2 (instanceref res)) + (portref CEAD (instanceref res)) + (portref CEALUMODE (instanceref res)) + (portref CEB1 (instanceref res)) + (portref CEB2 (instanceref res)) + (portref CEC (instanceref res)) + (portref CECARRYIN (instanceref res)) + (portref CECTRL (instanceref res)) + (portref CED (instanceref res)) + (portref CEINMODE (instanceref res)) + (portref CEM (instanceref res)) + (portref CEP (instanceref res)) + (portref CLK (instanceref res)) + (portref G (instanceref GND)) + (portref (member INMODE 4) (instanceref res)) + (portref (member INMODE 3) (instanceref res)) + (portref (member INMODE 2) (instanceref res)) + (portref (member INMODE 1) (instanceref res)) + (portref (member INMODE 0) (instanceref res)) + (portref MULTSIGNIN (instanceref res)) + (portref (member OPMODE 7) (instanceref res)) + (portref (member OPMODE 5) (instanceref res)) + (portref (member OPMODE 4) (instanceref res)) + (portref (member OPMODE 3) (instanceref res)) + (portref (member OPMODE 2) (instanceref res)) + (portref (member OPMODE 1) (instanceref res)) + (portref (member OPMODE 0) (instanceref res)) + (portref (member PCIN 47) (instanceref res)) + (portref (member PCIN 37) (instanceref res)) + (portref (member PCIN 36) (instanceref res)) + (portref (member PCIN 35) (instanceref res)) + (portref (member PCIN 34) (instanceref res)) + (portref (member PCIN 33) (instanceref res)) + (portref (member PCIN 32) (instanceref res)) + (portref (member PCIN 31) (instanceref res)) + (portref (member PCIN 30) (instanceref res)) + (portref (member PCIN 29) (instanceref res)) + (portref (member PCIN 28) (instanceref res)) + (portref (member PCIN 46) (instanceref res)) + (portref (member PCIN 27) (instanceref res)) + (portref (member PCIN 26) (instanceref res)) + (portref (member PCIN 25) (instanceref res)) + (portref (member PCIN 24) (instanceref res)) + (portref (member PCIN 23) (instanceref res)) + (portref (member PCIN 22) (instanceref res)) + (portref (member PCIN 21) (instanceref res)) + (portref (member PCIN 20) (instanceref res)) + (portref (member PCIN 19) (instanceref res)) + (portref (member PCIN 18) (instanceref res)) + (portref (member PCIN 45) (instanceref res)) + (portref (member PCIN 17) (instanceref res)) + (portref (member PCIN 16) (instanceref res)) + (portref (member PCIN 15) (instanceref res)) + (portref (member PCIN 14) (instanceref res)) + (portref (member PCIN 13) (instanceref res)) + (portref (member PCIN 12) (instanceref res)) + (portref (member PCIN 11) (instanceref res)) + (portref (member PCIN 10) (instanceref res)) + (portref (member PCIN 9) (instanceref res)) + (portref (member PCIN 8) (instanceref res)) + (portref (member PCIN 44) (instanceref res)) + (portref (member PCIN 7) (instanceref res)) + (portref (member PCIN 6) (instanceref res)) + (portref (member PCIN 5) (instanceref res)) + (portref (member PCIN 4) (instanceref res)) + (portref (member PCIN 3) (instanceref res)) + (portref (member PCIN 2) (instanceref res)) + (portref (member PCIN 1) (instanceref res)) + (portref (member PCIN 0) (instanceref res)) + (portref (member PCIN 43) (instanceref res)) + (portref (member PCIN 42) (instanceref res)) + (portref (member PCIN 41) (instanceref res)) + (portref (member PCIN 40) (instanceref res)) + (portref (member PCIN 39) (instanceref res)) + (portref (member PCIN 38) (instanceref res)) + (portref RSTA (instanceref res)) + (portref RSTALLCARRYIN (instanceref res)) + (portref RSTALUMODE (instanceref res)) + (portref RSTB (instanceref res)) + (portref RSTC (instanceref res)) + (portref RSTCTRL (instanceref res)) + (portref RSTD (instanceref res)) + (portref RSTINMODE (instanceref res)) + (portref RSTM (instanceref res)) + (portref RSTP (instanceref res)))) + (net + (rename &_const1_ "") + (joined + (portref (member OPMODE 8) (instanceref res)) + (portref (member OPMODE 6) (instanceref res)) + (portref P (instanceref VCC)))) + (net GND_2 + (joined + (portref (member D 26) (instanceref res)) + (portref (member D 16) (instanceref res)) + (portref (member D 15) (instanceref res)) + (portref (member D 14) (instanceref res)) + (portref (member D 13) (instanceref res)) + (portref (member D 12) (instanceref res)) + (portref (member D 11) (instanceref res)) + (portref (member D 10) (instanceref res)) + (portref (member D 9) (instanceref res)) + (portref (member D 8) (instanceref res)) + (portref (member D 7) (instanceref res)) + (portref (member D 25) (instanceref res)) + (portref (member D 6) (instanceref res)) + (portref (member D 5) (instanceref res)) + (portref (member D 4) (instanceref res)) + (portref (member D 3) (instanceref res)) + (portref (member D 2) (instanceref res)) + (portref (member D 1) (instanceref res)) + (portref (member D 0) (instanceref res)) + (portref (member D 24) (instanceref res)) + (portref (member D 23) (instanceref res)) + (portref (member D 22) (instanceref res)) + (portref (member D 21) (instanceref res)) + (portref (member D 20) (instanceref res)) + (portref (member D 19) (instanceref res)) + (portref (member D 18) (instanceref res)) + (portref (member D 17) (instanceref res)) + (portref G (instanceref GND_1)))) + (net VCC_2 + (joined + (portref (member C 47) (instanceref res)) + (portref (member C 37) (instanceref res)) + (portref (member C 36) (instanceref res)) + (portref (member C 35) (instanceref res)) + (portref (member C 34) (instanceref res)) + (portref (member C 33) (instanceref res)) + (portref (member C 32) (instanceref res)) + (portref (member C 31) (instanceref res)) + (portref (member C 30) (instanceref res)) + (portref (member C 29) (instanceref res)) + (portref (member C 28) (instanceref res)) + (portref (member C 46) (instanceref res)) + (portref (member C 27) (instanceref res)) + (portref (member C 26) (instanceref res)) + (portref (member C 25) (instanceref res)) + (portref (member C 24) (instanceref res)) + (portref (member C 23) (instanceref res)) + (portref (member C 22) (instanceref res)) + (portref (member C 21) (instanceref res)) + (portref (member C 20) (instanceref res)) + (portref (member C 19) (instanceref res)) + (portref (member C 18) (instanceref res)) + (portref (member C 45) (instanceref res)) + (portref (member C 17) (instanceref res)) + (portref (member C 16) (instanceref res)) + (portref (member C 15) (instanceref res)) + (portref (member C 14) (instanceref res)) + (portref (member C 13) (instanceref res)) + (portref (member C 12) (instanceref res)) + (portref (member C 11) (instanceref res)) + (portref (member C 10) (instanceref res)) + (portref (member C 9) (instanceref res)) + (portref (member C 8) (instanceref res)) + (portref (member C 44) (instanceref res)) + (portref (member C 7) (instanceref res)) + (portref (member C 6) (instanceref res)) + (portref (member C 5) (instanceref res)) + (portref (member C 4) (instanceref res)) + (portref (member C 3) (instanceref res)) + (portref (member C 2) (instanceref res)) + (portref (member C 1) (instanceref res)) + (portref (member C 0) (instanceref res)) + (portref (member C 43) (instanceref res)) + (portref (member C 42) (instanceref res)) + (portref (member C 41) (instanceref res)) + (portref (member C 40) (instanceref res)) + (portref (member C 39) (instanceref res)) + (portref (member C 38) (instanceref res)) + (portref P (instanceref VCC_1)))) + (net + (rename a_0_ "a[0]") + (joined + (portref (member A 29) (instanceref res)) + (portref (member a 7)))) + (net + (rename a_1_ "a[1]") + (joined + (portref (member A 28) (instanceref res)) + (portref (member a 6)))) + (net + (rename a_2_ "a[2]") + (joined + (portref (member A 27) (instanceref res)) + (portref (member a 5)))) + (net + (rename a_3_ "a[3]") + (joined + (portref (member A 26) (instanceref res)) + (portref (member a 4)))) + (net + (rename a_4_ "a[4]") + (joined + (portref (member A 25) (instanceref res)) + (portref (member a 3)))) + (net + (rename a_5_ "a[5]") + (joined + (portref (member A 24) (instanceref res)) + (portref (member a 2)))) + (net + (rename a_6_ "a[6]") + (joined + (portref (member A 23) (instanceref res)) + (portref (member a 1)))) + (net + (rename a_7_ "a[7]") + (joined + (portref (member A 22) (instanceref res)) + (portref (member a 0)))) + (net + (rename b_0_ "b[0]") + (joined + (portref (member B 17) (instanceref res)) + (portref (member b 7)))) + (net + (rename b_1_ "b[1]") + (joined + (portref (member B 16) (instanceref res)) + (portref (member b 6)))) + (net + (rename b_2_ "b[2]") + (joined + (portref (member B 15) (instanceref res)) + (portref (member b 5)))) + (net + (rename b_3_ "b[3]") + (joined + (portref (member B 14) (instanceref res)) + (portref (member b 4)))) + (net + (rename b_4_ "b[4]") + (joined + (portref (member B 13) (instanceref res)) + (portref (member b 3)))) + (net + (rename b_5_ "b[5]") + (joined + (portref (member B 12) (instanceref res)) + (portref (member b 2)))) + (net + (rename b_6_ "b[6]") + (joined + (portref (member B 11) (instanceref res)) + (portref (member b 1)))) + (net + (rename b_7_ "b[7]") + (joined + (portref (member B 10) (instanceref res)) + (portref (member b 0)))) + (net + (rename y_0_ "y[0]") + (joined + (portref (member P 47) (instanceref res)) + (portref (member y 7)))) + (net + (rename y_1_ "y[1]") + (joined + (portref (member P 46) (instanceref res)) + (portref (member y 6)))) + (net + (rename y_2_ "y[2]") + (joined + (portref (member P 45) (instanceref res)) + (portref (member y 5)))) + (net + (rename y_3_ "y[3]") + (joined + (portref (member P 44) (instanceref res)) + (portref (member y 4)))) + (net + (rename y_4_ "y[4]") + (joined + (portref (member P 43) (instanceref res)) + (portref (member y 3)))) + (net + (rename y_5_ "y[5]") + (joined + (portref (member P 42) (instanceref res)) + (portref (member y 2)))) + (net + (rename y_6_ "y[6]") + (joined + (portref (member P 41) (instanceref res)) + (portref (member y 1)))) + (net + (rename y_7_ "y[7]") + (joined + (portref (member P 40) (instanceref res)) + (portref (member y 0))))) + (property ECO_CHECKSUM + (string "2ac8fb58"))))) + (design dsp2 + (cellref dsp2 + (libraryref work)) + (property part + (string "xczu3eg-sbva484-1-e")))) \ No newline at end of file From 97cae464464d53bb0ff6a2501a21fc123541658e Mon Sep 17 00:00:00 2001 From: Pedro Torruella Date: Wed, 1 Sep 2021 07:35:36 +0000 Subject: [PATCH 2/5] adding local gitignore --- src/langs/edif/.gitignore | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 src/langs/edif/.gitignore diff --git a/src/langs/edif/.gitignore b/src/langs/edif/.gitignore new file mode 100644 index 00000000..ecf8487f --- /dev/null +++ b/src/langs/edif/.gitignore @@ -0,0 +1,7 @@ +/target +**.jou +**.txt +**.log +**xilinx_inverter.edf +**xilinx_multiplier.edf +Cargo.lock \ No newline at end of file From b9b3dfb7390f1234f5b79b72bb7d976a994da2d5 Mon Sep 17 00:00:00 2001 From: Pedro Torruella Date: Wed, 1 Sep 2021 08:37:32 +0100 Subject: [PATCH 3/5] Updating readme --- src/langs/edif/README.md | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/langs/edif/README.md b/src/langs/edif/README.md index 8906ac19..a72cd559 100644 --- a/src/langs/edif/README.md +++ b/src/langs/edif/README.md @@ -1,15 +1,9 @@ -# edifier -Like an emulsifier, edifier aims to allow you to mix rust and edif. - +# edif The goal of this is to turn it into a crate to allow the generation of edif files programatically from a Rust program. -# Project Structure -The project has the following areas: +# Crate Structure +This crate has the following areas: * examples: this is a good point of entry as it will quicky show you a template for your application. * src: this is the place where we have stored the code, separated in crates. * edifier: This crate is the core of the project, provides generic edif utilities. * platforms: This crate hosts a non-comprehensive list of platform specific support functions, mainly for unit-testing/example. -* others: random files to support development. - -# Still under construction -Please do not integrate just yet as it is still early days... From e8b51eee8efe955dc7378012c42f8b4307a14b02 Mon Sep 17 00:00:00 2001 From: Pedro Torruella Date: Wed, 1 Sep 2021 08:38:11 +0100 Subject: [PATCH 4/5] Delete xilinx_multiplier.edf --- src/langs/edif/src/xilinx_multiplier.edf | 1 - 1 file changed, 1 deletion(-) delete mode 100644 src/langs/edif/src/xilinx_multiplier.edf diff --git a/src/langs/edif/src/xilinx_multiplier.edf b/src/langs/edif/src/xilinx_multiplier.edf deleted file mode 100644 index dac95841..00000000 --- a/src/langs/edif/src/xilinx_multiplier.edf +++ /dev/null @@ -1 +0,0 @@ -(edif dsp2 (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library hdi_primitives (edifLevel 0) (technology (numberDefinition)) (cell GND (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port G (direction OUTPUT))))) (cell VCC (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port P (direction OUTPUT))))) (cell DSP48E2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port CARRYCASCOUT (direction OUTPUT)) (port MULTSIGNOUT (direction OUTPUT)) (port OVERFLOW (direction OUTPUT)) (port PATTERNBDETECT (direction OUTPUT)) (port PATTERNDETECT (direction OUTPUT)) (port UNDERFLOW (direction OUTPUT)) (port CARRYCASCIN (direction INPUT)) (port CARRYIN (direction INPUT)) (port CEA1 (direction INPUT)) (port CEA2 (direction INPUT)) (port CEAD (direction INPUT)) (port CEALUMODE (direction INPUT)) (port CEB1 (direction INPUT)) (port CEB2 (direction INPUT)) (port CEC (direction INPUT)) (port CECARRYIN (direction INPUT)) (port CECTRL (direction INPUT)) (port CED (direction INPUT)) (port CEINMODE (direction INPUT)) (port CEM (direction INPUT)) (port CEP (direction INPUT)) (port CLK (direction INPUT)) (port MULTSIGNIN (direction INPUT)) (port RSTA (direction INPUT)) (port RSTALLCARRYIN (direction INPUT)) (port RSTALUMODE (direction INPUT)) (port RSTB (direction INPUT)) (port RSTC (direction INPUT)) (port RSTCTRL (direction INPUT)) (port RSTD (direction INPUT)) (port RSTINMODE (direction INPUT)) (port RSTM (direction INPUT)) (port RSTP (direction INPUT)) (port (array (rename ACOUT "ACOUT[29:0]") 30) (direction OUTPUT)) (port (array (rename BCOUT "BCOUT[17:0]") 18) (direction OUTPUT)) (port (array (rename CARRYOUT "CARRYOUT[3:0]") 4) (direction OUTPUT)) (port (array (rename PCOUT "PCOUT[47:0]") 48) (direction OUTPUT)) (port (array (rename P "P[47:0]") 48) (direction OUTPUT)) (port (array (rename XOROUT "XOROUT[7:0]") 8) (direction OUTPUT)) (port (array (rename ACIN "ACIN[29:0]") 30) (direction INPUT)) (port (array (rename ALUMODE "ALUMODE[3:0]") 4) (direction INPUT)) (port (array (rename A "A[29:0]") 30) (direction INPUT)) (port (array (rename BCIN "BCIN[17:0]") 18) (direction INPUT)) (port (array (rename B "B[17:0]") 18) (direction INPUT)) (port (array (rename CARRYINSEL "CARRYINSEL[2:0]") 3) (direction INPUT)) (port (array (rename C "C[47:0]") 48) (direction INPUT)) (port (array (rename D "D[26:0]") 27) (direction INPUT)) (port (array (rename INMODE "INMODE[4:0]") 5) (direction INPUT)) (port (array (rename OPMODE "OPMODE[8:0]") 9) (direction INPUT)) (port (array (rename PCIN "PCIN[47:0]") 48) (direction INPUT))))) (cell INV (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port I (direction INPUT)) (port O (direction OUTPUT)))))) (Library work (edifLevel 0) (technology (numberDefinition)) (cell dsp2 (celltype GENERIC) (view dsp2 (viewtype NETLIST) (interface (port (array (rename a "a[7:0]") 8) (direction INPUT)) (port (array (rename b "b[7:0]") 8) (direction INPUT)) (port (array (rename y "y[7:0]") 8) (direction OUTPUT))) (contents (instance GND (viewref netlist (cellref GND (libraryref hdi_primitives)))) (instance GND_1 (viewref netlist (cellref GND (libraryref hdi_primitives)))) (instance VCC (viewref netlist (cellref VCC (libraryref hdi_primitives)))) (instance VCC_1 (viewref netlist (cellref VCC (libraryref hdi_primitives)))) (instance res (viewref netlist (cellref DSP48E2 (libraryref hdi_primitives))) (property XORSIMD (string "XOR24_48_96")) (property USE_WIDEXOR (string "FALSE")) (property ACASCREG (integer 0)) (property ADREG (integer 1)) (property ALUMODEREG (integer 0)) (property AMULTSEL (string "A")) (property AREG (integer 0)) (property AUTORESET_PATDET (string "NO_RESET")) (property AUTORESET_PRIORITY (string "RESET")) (property A_INPUT (string "DIRECT")) (property BCASCREG (integer 0)) (property BMULTSEL (string "B")) (property BREG (integer 0)) (property B_INPUT (string "DIRECT")) (property CARRYINREG (integer 0)) (property CARRYINSELREG (integer 0)) (property CREG (integer 1)) (property DREG (integer 1)) (property INMODEREG (integer 0)) (property MASK (string "48'h3FFFFFFFFFFF")) (property METHODOLOGY_DRC_VIOS (string |"{SYNTH-13\ {cell\ *THIS*}}"|)) (property MREG (integer 0)) (property OPMODEREG (integer 0)) (property PATTERN (string "48'h000000000000")) (property PREADDINSEL (string "A")) (property PREG (integer 0)) (property RND (string "48'h000000000000")) (property SEL_MASK (string "MASK")) (property SEL_PATTERN (string "PATTERN")) (property USE_MULT (string "MULTIPLY")) (property USE_PATTERN_DETECT (string "NO_PATDET")) (property USE_SIMD (string "ONE48")) (property OPT_MODIFIED (string "SWEEP"))) (net (rename &_const0_ "") (joined (portref (member ACIN 29) (instanceref res)) (portref (member ACIN 19) (instanceref res)) (portref (member ACIN 18) (instanceref res)) (portref (member ACIN 17) (instanceref res)) (portref (member ACIN 16) (instanceref res)) (portref (member ACIN 15) (instanceref res)) (portref (member ACIN 14) (instanceref res)) (portref (member ACIN 13) (instanceref res)) (portref (member ACIN 12) (instanceref res)) (portref (member ACIN 11) (instanceref res)) (portref (member ACIN 10) (instanceref res)) (portref (member ACIN 28) (instanceref res)) (portref (member ACIN 9) (instanceref res)) (portref (member ACIN 8) (instanceref res)) (portref (member ACIN 7) (instanceref res)) (portref (member ACIN 6) (instanceref res)) (portref (member ACIN 5) (instanceref res)) (portref (member ACIN 4) (instanceref res)) (portref (member ACIN 3) (instanceref res)) (portref (member ACIN 2) (instanceref res)) (portref (member ACIN 1) (instanceref res)) (portref (member ACIN 0) (instanceref res)) (portref (member ACIN 27) (instanceref res)) (portref (member ACIN 26) (instanceref res)) (portref (member ACIN 25) (instanceref res)) (portref (member ACIN 24) (instanceref res)) (portref (member ACIN 23) (instanceref res)) (portref (member ACIN 22) (instanceref res)) (portref (member ACIN 21) (instanceref res)) (portref (member ACIN 20) (instanceref res)) (portref (member ALUMODE 3) (instanceref res)) (portref (member ALUMODE 2) (instanceref res)) (portref (member ALUMODE 1) (instanceref res)) (portref (member ALUMODE 0) (instanceref res)) (portref (member A 19) (instanceref res)) (portref (member A 18) (instanceref res)) (portref (member A 17) (instanceref res)) (portref (member A 16) (instanceref res)) (portref (member A 15) (instanceref res)) (portref (member A 14) (instanceref res)) (portref (member A 13) (instanceref res)) (portref (member A 12) (instanceref res)) (portref (member A 11) (instanceref res)) (portref (member A 10) (instanceref res)) (portref (member A 9) (instanceref res)) (portref (member A 8) (instanceref res)) (portref (member A 7) (instanceref res)) (portref (member A 6) (instanceref res)) (portref (member A 5) (instanceref res)) (portref (member A 4) (instanceref res)) (portref (member A 3) (instanceref res)) (portref (member A 2) (instanceref res)) (portref (member A 1) (instanceref res)) (portref (member A 0) (instanceref res)) (portref (member A 21) (instanceref res)) (portref (member A 20) (instanceref res)) (portref (member BCIN 17) (instanceref res)) (portref (member BCIN 7) (instanceref res)) (portref (member BCIN 6) (instanceref res)) (portref (member BCIN 5) (instanceref res)) (portref (member BCIN 4) (instanceref res)) (portref (member BCIN 3) (instanceref res)) (portref (member BCIN 2) (instanceref res)) (portref (member BCIN 1) (instanceref res)) (portref (member BCIN 0) (instanceref res)) (portref (member BCIN 16) (instanceref res)) (portref (member BCIN 15) (instanceref res)) (portref (member BCIN 14) (instanceref res)) (portref (member BCIN 13) (instanceref res)) (portref (member BCIN 12) (instanceref res)) (portref (member BCIN 11) (instanceref res)) (portref (member BCIN 10) (instanceref res)) (portref (member BCIN 9) (instanceref res)) (portref (member BCIN 8) (instanceref res)) (portref (member B 7) (instanceref res)) (portref (member B 6) (instanceref res)) (portref (member B 5) (instanceref res)) (portref (member B 4) (instanceref res)) (portref (member B 3) (instanceref res)) (portref (member B 2) (instanceref res)) (portref (member B 1) (instanceref res)) (portref (member B 0) (instanceref res)) (portref (member B 9) (instanceref res)) (portref (member B 8) (instanceref res)) (portref CARRYCASCIN (instanceref res)) (portref CARRYIN (instanceref res)) (portref (member CARRYINSEL 2) (instanceref res)) (portref (member CARRYINSEL 1) (instanceref res)) (portref (member CARRYINSEL 0) (instanceref res)) (portref CEA1 (instanceref res)) (portref CEA2 (instanceref res)) (portref CEAD (instanceref res)) (portref CEALUMODE (instanceref res)) (portref CEB1 (instanceref res)) (portref CEB2 (instanceref res)) (portref CEC (instanceref res)) (portref CECARRYIN (instanceref res)) (portref CECTRL (instanceref res)) (portref CED (instanceref res)) (portref CEINMODE (instanceref res)) (portref CEM (instanceref res)) (portref CEP (instanceref res)) (portref CLK (instanceref res)) (portref G (instanceref GND)) (portref (member INMODE 4) (instanceref res)) (portref (member INMODE 3) (instanceref res)) (portref (member INMODE 2) (instanceref res)) (portref (member INMODE 1) (instanceref res)) (portref (member INMODE 0) (instanceref res)) (portref MULTSIGNIN (instanceref res)) (portref (member OPMODE 7) (instanceref res)) (portref (member OPMODE 5) (instanceref res)) (portref (member OPMODE 4) (instanceref res)) (portref (member OPMODE 3) (instanceref res)) (portref (member OPMODE 2) (instanceref res)) (portref (member OPMODE 1) (instanceref res)) (portref (member OPMODE 0) (instanceref res)) (portref (member PCIN 47) (instanceref res)) (portref (member PCIN 37) (instanceref res)) (portref (member PCIN 36) (instanceref res)) (portref (member PCIN 35) (instanceref res)) (portref (member PCIN 34) (instanceref res)) (portref (member PCIN 33) (instanceref res)) (portref (member PCIN 32) (instanceref res)) (portref (member PCIN 31) (instanceref res)) (portref (member PCIN 30) (instanceref res)) (portref (member PCIN 29) (instanceref res)) (portref (member PCIN 28) (instanceref res)) (portref (member PCIN 46) (instanceref res)) (portref (member PCIN 27) (instanceref res)) (portref (member PCIN 26) (instanceref res)) (portref (member PCIN 25) (instanceref res)) (portref (member PCIN 24) (instanceref res)) (portref (member PCIN 23) (instanceref res)) (portref (member PCIN 22) (instanceref res)) (portref (member PCIN 21) (instanceref res)) (portref (member PCIN 20) (instanceref res)) (portref (member PCIN 19) (instanceref res)) (portref (member PCIN 18) (instanceref res)) (portref (member PCIN 45) (instanceref res)) (portref (member PCIN 17) (instanceref res)) (portref (member PCIN 16) (instanceref res)) (portref (member PCIN 15) (instanceref res)) (portref (member PCIN 14) (instanceref res)) (portref (member PCIN 13) (instanceref res)) (portref (member PCIN 12) (instanceref res)) (portref (member PCIN 11) (instanceref res)) (portref (member PCIN 10) (instanceref res)) (portref (member PCIN 9) (instanceref res)) (portref (member PCIN 8) (instanceref res)) (portref (member PCIN 44) (instanceref res)) (portref (member PCIN 7) (instanceref res)) (portref (member PCIN 6) (instanceref res)) (portref (member PCIN 5) (instanceref res)) (portref (member PCIN 4) (instanceref res)) (portref (member PCIN 3) (instanceref res)) (portref (member PCIN 2) (instanceref res)) (portref (member PCIN 1) (instanceref res)) (portref (member PCIN 0) (instanceref res)) (portref (member PCIN 43) (instanceref res)) (portref (member PCIN 42) (instanceref res)) (portref (member PCIN 41) (instanceref res)) (portref (member PCIN 40) (instanceref res)) (portref (member PCIN 39) (instanceref res)) (portref (member PCIN 38) (instanceref res)) (portref RSTA (instanceref res)) (portref RSTALLCARRYIN (instanceref res)) (portref RSTALUMODE (instanceref res)) (portref RSTB (instanceref res)) (portref RSTC (instanceref res)) (portref RSTCTRL (instanceref res)) (portref RSTD (instanceref res)) (portref RSTINMODE (instanceref res)) (portref RSTM (instanceref res)) (portref RSTP (instanceref res)))) (net (rename &_const1_ "") (joined (portref (member OPMODE 8) (instanceref res)) (portref (member OPMODE 6) (instanceref res)) (portref P (instanceref VCC)))) (net GND_2 (joined (portref (member D 26) (instanceref res)) (portref (member D 16) (instanceref res)) (portref (member D 15) (instanceref res)) (portref (member D 14) (instanceref res)) (portref (member D 13) (instanceref res)) (portref (member D 12) (instanceref res)) (portref (member D 11) (instanceref res)) (portref (member D 10) (instanceref res)) (portref (member D 9) (instanceref res)) (portref (member D 8) (instanceref res)) (portref (member D 7) (instanceref res)) (portref (member D 25) (instanceref res)) (portref (member D 6) (instanceref res)) (portref (member D 5) (instanceref res)) (portref (member D 4) (instanceref res)) (portref (member D 3) (instanceref res)) (portref (member D 2) (instanceref res)) (portref (member D 1) (instanceref res)) (portref (member D 0) (instanceref res)) (portref (member D 24) (instanceref res)) (portref (member D 23) (instanceref res)) (portref (member D 22) (instanceref res)) (portref (member D 21) (instanceref res)) (portref (member D 20) (instanceref res)) (portref (member D 19) (instanceref res)) (portref (member D 18) (instanceref res)) (portref (member D 17) (instanceref res)) (portref G (instanceref GND_1)))) (net VCC_2 (joined (portref (member C 47) (instanceref res)) (portref (member C 37) (instanceref res)) (portref (member C 36) (instanceref res)) (portref (member C 35) (instanceref res)) (portref (member C 34) (instanceref res)) (portref (member C 33) (instanceref res)) (portref (member C 32) (instanceref res)) (portref (member C 31) (instanceref res)) (portref (member C 30) (instanceref res)) (portref (member C 29) (instanceref res)) (portref (member C 28) (instanceref res)) (portref (member C 46) (instanceref res)) (portref (member C 27) (instanceref res)) (portref (member C 26) (instanceref res)) (portref (member C 25) (instanceref res)) (portref (member C 24) (instanceref res)) (portref (member C 23) (instanceref res)) (portref (member C 22) (instanceref res)) (portref (member C 21) (instanceref res)) (portref (member C 20) (instanceref res)) (portref (member C 19) (instanceref res)) (portref (member C 18) (instanceref res)) (portref (member C 45) (instanceref res)) (portref (member C 17) (instanceref res)) (portref (member C 16) (instanceref res)) (portref (member C 15) (instanceref res)) (portref (member C 14) (instanceref res)) (portref (member C 13) (instanceref res)) (portref (member C 12) (instanceref res)) (portref (member C 11) (instanceref res)) (portref (member C 10) (instanceref res)) (portref (member C 9) (instanceref res)) (portref (member C 8) (instanceref res)) (portref (member C 44) (instanceref res)) (portref (member C 7) (instanceref res)) (portref (member C 6) (instanceref res)) (portref (member C 5) (instanceref res)) (portref (member C 4) (instanceref res)) (portref (member C 3) (instanceref res)) (portref (member C 2) (instanceref res)) (portref (member C 1) (instanceref res)) (portref (member C 0) (instanceref res)) (portref (member C 43) (instanceref res)) (portref (member C 42) (instanceref res)) (portref (member C 41) (instanceref res)) (portref (member C 40) (instanceref res)) (portref (member C 39) (instanceref res)) (portref (member C 38) (instanceref res)) (portref P (instanceref VCC_1)))) (net (rename a_0_ "a[0]") (joined (portref (member A 29) (instanceref res)) (portref (member a 7)))) (net (rename a_1_ "a[1]") (joined (portref (member A 28) (instanceref res)) (portref (member a 6)))) (net (rename a_2_ "a[2]") (joined (portref (member A 27) (instanceref res)) (portref (member a 5)))) (net (rename a_3_ "a[3]") (joined (portref (member A 26) (instanceref res)) (portref (member a 4)))) (net (rename a_4_ "a[4]") (joined (portref (member A 25) (instanceref res)) (portref (member a 3)))) (net (rename a_5_ "a[5]") (joined (portref (member A 24) (instanceref res)) (portref (member a 2)))) (net (rename a_6_ "a[6]") (joined (portref (member A 23) (instanceref res)) (portref (member a 1)))) (net (rename a_7_ "a[7]") (joined (portref (member A 22) (instanceref res)) (portref (member a 0)))) (net (rename b_0_ "b[0]") (joined (portref (member B 17) (instanceref res)) (portref (member b 7)))) (net (rename b_1_ "b[1]") (joined (portref (member B 16) (instanceref res)) (portref (member b 6)))) (net (rename b_2_ "b[2]") (joined (portref (member B 15) (instanceref res)) (portref (member b 5)))) (net (rename b_3_ "b[3]") (joined (portref (member B 14) (instanceref res)) (portref (member b 4)))) (net (rename b_4_ "b[4]") (joined (portref (member B 13) (instanceref res)) (portref (member b 3)))) (net (rename b_5_ "b[5]") (joined (portref (member B 12) (instanceref res)) (portref (member b 2)))) (net (rename b_6_ "b[6]") (joined (portref (member B 11) (instanceref res)) (portref (member b 1)))) (net (rename b_7_ "b[7]") (joined (portref (member B 10) (instanceref res)) (portref (member b 0)))) (net (rename y_0_ "y[0]") (joined (portref (member P 47) (instanceref res)) (portref (member y 7)))) (net (rename y_1_ "y[1]") (joined (portref (member P 46) (instanceref res)) (portref (member y 6)))) (net (rename y_2_ "y[2]") (joined (portref (member P 45) (instanceref res)) (portref (member y 5)))) (net (rename y_3_ "y[3]") (joined (portref (member P 44) (instanceref res)) (portref (member y 4)))) (net (rename y_4_ "y[4]") (joined (portref (member P 43) (instanceref res)) (portref (member y 3)))) (net (rename y_5_ "y[5]") (joined (portref (member P 42) (instanceref res)) (portref (member y 2)))) (net (rename y_6_ "y[6]") (joined (portref (member P 41) (instanceref res)) (portref (member y 1)))) (net (rename y_7_ "y[7]") (joined (portref (member P 40) (instanceref res)) (portref (member y 0))))) ((property ECO_CHECKSUM (string "2ac8fb58")))))) (design dsp2 (cellref dsp2 (libraryref work)) (property part (string "xczu3eg-sbva484-1-e")))) \ No newline at end of file From 627a2e0748a43aada752d547fa94220b76f65273 Mon Sep 17 00:00:00 2001 From: Pedro Torruella Date: Thu, 2 Sep 2021 16:32:14 +0000 Subject: [PATCH 5/5] Adding simplified fileset for edif --- Cargo.toml | 5 +- src/langs/edif/.gitignore | 7 - src/langs/edif/Cargo.toml | 16 +- src/langs/edif/README.md | 8 +- src/langs/edif/examples/Makefile | 23 - src/langs/edif/examples/do_all.sh | 13 - src/langs/edif/examples/load_edif.tcl | 36 - src/langs/edif/examples/xilinx_inverter.rs | 32 - src/langs/edif/examples/xilinx_multiplier.rs | 31 - src/langs/edif/src/{edifier/src => }/ast.rs | 0 src/langs/edif/src/edifier/Cargo.toml | 12 - .../edif/src/{edifier/src => }/helpers.rs | 0 src/langs/edif/src/{edifier/src => }/lib.rs | 0 src/langs/edif/src/{edifier/src => }/main.rs | 2 +- src/langs/edif/src/platforms/Cargo.toml | 13 - src/langs/edif/src/platforms/src/lib.rs | 16 - src/langs/edif/src/platforms/src/xilinx.rs | 971 ------------------ .../edif/src/platforms/tests/xilinx_ut.rs | 113 -- .../edif/src/{edifier/src => }/serialize.rs | 0 .../src/{edifier/src => }/string_helpers.rs | 0 src/langs/edif/src/xilinx_multiplier.edf | 1 - .../edifier => }/tests/string_helpers_ut.rs | 2 +- .../{src/edifier => }/tests/unit_tests.rs | 4 +- src/langs/edif/xilinx_multiplier.edf | 666 ------------ 24 files changed, 11 insertions(+), 1960 deletions(-) delete mode 100644 src/langs/edif/.gitignore delete mode 100644 src/langs/edif/examples/Makefile delete mode 100755 src/langs/edif/examples/do_all.sh delete mode 100644 src/langs/edif/examples/load_edif.tcl delete mode 100644 src/langs/edif/examples/xilinx_inverter.rs delete mode 100644 src/langs/edif/examples/xilinx_multiplier.rs rename src/langs/edif/src/{edifier/src => }/ast.rs (100%) delete mode 100644 src/langs/edif/src/edifier/Cargo.toml rename src/langs/edif/src/{edifier/src => }/helpers.rs (100%) rename src/langs/edif/src/{edifier/src => }/lib.rs (100%) rename src/langs/edif/src/{edifier/src => }/main.rs (98%) delete mode 100644 src/langs/edif/src/platforms/Cargo.toml delete mode 100644 src/langs/edif/src/platforms/src/lib.rs delete mode 100644 src/langs/edif/src/platforms/src/xilinx.rs delete mode 100644 src/langs/edif/src/platforms/tests/xilinx_ut.rs rename src/langs/edif/src/{edifier/src => }/serialize.rs (100%) rename src/langs/edif/src/{edifier/src => }/string_helpers.rs (100%) delete mode 100644 src/langs/edif/src/xilinx_multiplier.edf rename src/langs/edif/{src/edifier => }/tests/string_helpers_ut.rs (95%) rename src/langs/edif/{src/edifier => }/tests/unit_tests.rs (99%) delete mode 100644 src/langs/edif/xilinx_multiplier.edf diff --git a/Cargo.toml b/Cargo.toml index 9bd4f287..36d644df 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,11 +25,12 @@ path = "src/bin/ro.rs" [workspace] members = [ + "src/langs/asm", + "src/langs/edif", "src/langs/ir", "src/langs/pat", - "src/langs/asm", - "src/langs/xir", "src/langs/xim", + "src/langs/xir", "src/langs/verilog", "src/tools/io", "src/tools/prettyprint", diff --git a/src/langs/edif/.gitignore b/src/langs/edif/.gitignore deleted file mode 100644 index ecf8487f..00000000 --- a/src/langs/edif/.gitignore +++ /dev/null @@ -1,7 +0,0 @@ -/target -**.jou -**.txt -**.log -**xilinx_inverter.edf -**xilinx_multiplier.edf -Cargo.lock \ No newline at end of file diff --git a/src/langs/edif/Cargo.toml b/src/langs/edif/Cargo.toml index 10ceffe3..6907e492 100644 --- a/src/langs/edif/Cargo.toml +++ b/src/langs/edif/Cargo.toml @@ -1,22 +1,12 @@ [package] -name = "edifier_top" +name = "edif" version = "0.1.0" authors = ["Pedro Torruella "] license = "Apache-2.0" edition = "2018" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [dependencies] -edifier = { path = "src/edifier" } -platforms = { path = "src/platforms" } serde = { version = "1.0", features = ["derive", "rc"] } serde_sexpr = "0.1.0" - -[workspace] -members = [ - "src/edifier", - "src/platforms", -] - -exclude = ["others"] \ No newline at end of file +expect-test = "1.0.2" +derive_more = { version = "0.99.14" , features = ["from"] } diff --git a/src/langs/edif/README.md b/src/langs/edif/README.md index 8906ac19..30150b94 100644 --- a/src/langs/edif/README.md +++ b/src/langs/edif/README.md @@ -1,15 +1,9 @@ -# edifier -Like an emulsifier, edifier aims to allow you to mix rust and edif. - -The goal of this is to turn it into a crate to allow the generation of edif files programatically from a Rust program. - # Project Structure The project has the following areas: * examples: this is a good point of entry as it will quicky show you a template for your application. * src: this is the place where we have stored the code, separated in crates. - * edifier: This crate is the core of the project, provides generic edif utilities. + * edif: This crate is the core of the project, provides generic edif utilities. * platforms: This crate hosts a non-comprehensive list of platform specific support functions, mainly for unit-testing/example. * others: random files to support development. # Still under construction -Please do not integrate just yet as it is still early days... diff --git a/src/langs/edif/examples/Makefile b/src/langs/edif/examples/Makefile deleted file mode 100644 index c0412400..00000000 --- a/src/langs/edif/examples/Makefile +++ /dev/null @@ -1,23 +0,0 @@ -OUT_DIR = $(abspath .)/out - -NAME ?= "xilinx_inverter" -IMPL_FILE = $(NAME).v -EDIF_FILE = $(NAME).edf -NETLIST_FILE = $(NAME)_netlist.v -TIME_FILE = $(OUT_DIR)/$(NAME)_time.txt -UTIL_FILE = $(OUT_DIR)/$(NAME)_util.txt -DCP_FILE = $(OUT_DIR)/$(NAME).dcp - -.PHONY: all -all: | $(OUT_DIR) - vivado -mode batch -source load_edif.tcl -tclargs $(NAME) $(IMPL_FILE) $(UTIL_FILE) $(TIME_FILE) $(DCP_FILE) $(NETLIST_FILE) $(EDIF_FILE) - - -$(OUT_DIR): - mkdir -p $@ - -clean-logs: - rm -rf ./*jou ./*.log - -clean: - rm -rf $(OUT_DIR) \ No newline at end of file diff --git a/src/langs/edif/examples/do_all.sh b/src/langs/edif/examples/do_all.sh deleted file mode 100755 index 70c90f25..00000000 --- a/src/langs/edif/examples/do_all.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/bash -OUTLOG=output.txt - -cargo run --example xilinx_inverter - -source /tools/Xilinx/Vivado/2020.1/settings64.sh -time make all > $OUTLOG - -#source /tools/Xilinx/Vivado/2020.2/settings64.sh -#time make all >> $OUTLOG - -#source /tools/Xilinx/Vivado/2021.1/settings64.sh -#time make all >> $OUTLOG \ No newline at end of file diff --git a/src/langs/edif/examples/load_edif.tcl b/src/langs/edif/examples/load_edif.tcl deleted file mode 100644 index f697072c..00000000 --- a/src/langs/edif/examples/load_edif.tcl +++ /dev/null @@ -1,36 +0,0 @@ -set top_name [lindex $argv 0] -set verilog_file [lindex $argv 1] -set utilization_file [lindex $argv 2] -set timing_file [lindex $argv 3] -set dcp_file [lindex $argv 4] -set netlist_file [lindex $argv 5] -set edif_file [lindex $argv 6] -set edif_file_placed [lindex $argv 6].placed -set edif_file_routed [lindex $argv 6].routed -#set part_name "xczu3eg-sbva484-1-e" - -# Set target part -#set_part $part_name - -# Read the netlist from third-party synthesis tool -read_edif $edif_file - -# Read in the IP XCIs -#read_ip ip1.xci -#read_ip ip2.xci - -# read in top level constraints -#read_xdc top.xdc - -# Implement the design -link_design -top $top_name - -# at this point we would have done opt_design and placement -#phys_opt_design -place_design -directive Default -write_edif -force $edif_file_placed -route_design -directive Default -write_edif -force $edif_file_routed -report_timing -file $timing_file -report_utilization -file $utilization_file -#write_bitstream -file $top_name.bit \ No newline at end of file diff --git a/src/langs/edif/examples/xilinx_inverter.rs b/src/langs/edif/examples/xilinx_inverter.rs deleted file mode 100644 index 91a85ef5..00000000 --- a/src/langs/edif/examples/xilinx_inverter.rs +++ /dev/null @@ -1,32 +0,0 @@ -use edifier::string_helpers::add_new_lines; -use platforms::xilinx::inverter; -use std::fs::File; -use std::io::Write; -use std::path::Path; - -static DOFILE: bool = true; - -fn main() { - let edif = inverter(); - - let serialized = serde_sexpr::to_string(&edif).unwrap(); - let edif_string = add_new_lines(serialized, 5, true); - - if DOFILE { - let path = Path::new("xilinx_inverter.edf"); - let display = path.display(); - - // Open a file in write-only mode, returns `io::Result` - let mut file = match File::create(&path) { - Err(why) => panic!("couldn't create {}: {}", display, why), - Ok(file) => file, - }; - - match file.write_all(edif_string.as_bytes()) { - Err(why) => panic!("couldn't write to {}: {}", display, why), - Ok(_) => println!("successfully wrote to {}", display), - } - } else { - println!("{}", edif_string); - }; -} diff --git a/src/langs/edif/examples/xilinx_multiplier.rs b/src/langs/edif/examples/xilinx_multiplier.rs deleted file mode 100644 index d32be41e..00000000 --- a/src/langs/edif/examples/xilinx_multiplier.rs +++ /dev/null @@ -1,31 +0,0 @@ -use edifier::string_helpers::add_new_lines; -use platforms::xilinx::dsp; -use std::fs::File; -use std::io::Write; -use std::path::Path; - -static DOFILE: bool = true; - -fn main() { - let edif = dsp(); - let serialized = serde_sexpr::to_string(&edif).unwrap(); - let edif_string = add_new_lines(serialized, 7, true); - - if DOFILE { - let path = Path::new("xilinx_multiplier.edf"); - let display = path.display(); - - // Open a file in write-only mode, returns `io::Result` - let mut file = match File::create(&path) { - Err(why) => panic!("couldn't create {}: {}", display, why), - Ok(file) => file, - }; - - match file.write_all(edif_string.as_bytes()) { - Err(why) => panic!("couldn't write to {}: {}", display, why), - Ok(_) => println!("successfully wrote to {}", display), - } - } else { - println!("{}", edif_string); - }; -} diff --git a/src/langs/edif/src/edifier/src/ast.rs b/src/langs/edif/src/ast.rs similarity index 100% rename from src/langs/edif/src/edifier/src/ast.rs rename to src/langs/edif/src/ast.rs diff --git a/src/langs/edif/src/edifier/Cargo.toml b/src/langs/edif/src/edifier/Cargo.toml deleted file mode 100644 index bada3581..00000000 --- a/src/langs/edif/src/edifier/Cargo.toml +++ /dev/null @@ -1,12 +0,0 @@ -[package] -name = "edifier" -version = "0.1.0" -authors = ["Pedro Torruella "] -license = "Apache-2.0" -edition = "2018" - -[dependencies] -serde = { version = "1.0", features = ["derive", "rc"] } -serde_sexpr = "0.1.0" -expect-test = "1.0.2" -derive_more = { version = "0.99.14" , features = ["from"] } \ No newline at end of file diff --git a/src/langs/edif/src/edifier/src/helpers.rs b/src/langs/edif/src/helpers.rs similarity index 100% rename from src/langs/edif/src/edifier/src/helpers.rs rename to src/langs/edif/src/helpers.rs diff --git a/src/langs/edif/src/edifier/src/lib.rs b/src/langs/edif/src/lib.rs similarity index 100% rename from src/langs/edif/src/edifier/src/lib.rs rename to src/langs/edif/src/lib.rs diff --git a/src/langs/edif/src/edifier/src/main.rs b/src/langs/edif/src/main.rs similarity index 98% rename from src/langs/edif/src/edifier/src/main.rs rename to src/langs/edif/src/main.rs index 1e3281f5..f97a13fa 100644 --- a/src/langs/edif/src/edifier/src/main.rs +++ b/src/langs/edif/src/main.rs @@ -18,7 +18,7 @@ use std::path::Path; use std::fs::File; use std::io::Write; -use edifier::ast::*; +use edif::ast::*; static DOFILE: bool = false; diff --git a/src/langs/edif/src/platforms/Cargo.toml b/src/langs/edif/src/platforms/Cargo.toml deleted file mode 100644 index 72e56987..00000000 --- a/src/langs/edif/src/platforms/Cargo.toml +++ /dev/null @@ -1,13 +0,0 @@ -[package] -name = "platforms" -version = "0.1.0" -authors = ["Pedro Torruella "] -license = "Apache-2.0" -edition = "2018" - -[dependencies] -edifier = { path = "../edifier" } -serde = { version = "1.0", features = ["derive", "rc"] } -serde_json = "1.0" -serde_sexpr = "0.1.0" -expect-test = "1.0.2" \ No newline at end of file diff --git a/src/langs/edif/src/platforms/src/lib.rs b/src/langs/edif/src/platforms/src/lib.rs deleted file mode 100644 index b9a5df58..00000000 --- a/src/langs/edif/src/platforms/src/lib.rs +++ /dev/null @@ -1,16 +0,0 @@ -/* -Copyright 2021 Pedro M. Torruella N. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ -pub mod xilinx; diff --git a/src/langs/edif/src/platforms/src/xilinx.rs b/src/langs/edif/src/platforms/src/xilinx.rs deleted file mode 100644 index 9ba91bd4..00000000 --- a/src/langs/edif/src/platforms/src/xilinx.rs +++ /dev/null @@ -1,971 +0,0 @@ -/* -Copyright 2021 Pedro M. Torruella N. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ -use edifier::ast::*; - -pub fn new_lut2() -> Cell { - let porto = InterfacePort::new_output("O"); - - let porti0 = InterfacePort::new_input("I0"); - - let porti1 = InterfacePort::new_input("I1"); - - let interface = CellInterface(vec![porto, porti0, porti1]); - - let cellview = CellView { - name: "netlist".to_string(), - interface, - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }; - Cell { - name: "LUT2".to_string(), - views: CellViews(vec![cellview]), - } -} - -pub fn lut2_prop_ini(val: S) -> Property -where - S: AsRef, -{ - Property { - name: "INIT".to_string(), - property: PropertyValue::from(val.as_ref().to_string()), - } -} - -pub fn lut2_prop_box(val: S) -> Property -where - S: AsRef, -{ - Property { - name: "BOX_TYPE".to_string(), - property: PropertyValue::from(val.as_ref().to_string()), - } -} - -pub fn lut2_prop_loc(val: S) -> Property -where - S: AsRef, -{ - Property { - name: "LOC".to_string(), - property: PropertyValue::from(val.as_ref().to_string()), - } -} - -pub fn lut2_prop_bel(val: S) -> Property -where - S: AsRef, -{ - Property { - name: "BEL".to_string(), - property: PropertyValue::from(val.as_ref().to_string()), - } -} - -pub fn carry8() -> Cell { - let mut interface = CellInterface(Vec::new()); - - interface.push(InterfacePort::new_input("CI")); - interface.push(InterfacePort::new_input("CI_TOP")); - interface.push(InterfacePort::new( - PortToken::new_array("CO", "CO[7:0]", 8), - PortDirection::Output, - )); - interface.push(InterfacePort::new( - PortToken::new_array("O", "O[7:0]", 8), - PortDirection::Output, - )); - interface.push(InterfacePort::new( - PortToken::new_array("DI", "DI[7:0]", 8), - PortDirection::Input, - )); - interface.push(InterfacePort::new( - PortToken::new_array("S", "S[7:0]", 8), - PortDirection::Input, - )); - - let cellview = CellView { - name: "netlist".to_string(), - interface, - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }; - Cell { - name: "CARRY8".to_string(), - views: CellViews(vec![cellview]), - } -} - -pub fn inverter() -> Edif { - let top_name = "inverter".to_string(); - let work_name = "work".to_string(); - let netlist = "netlist".to_string(); - - let elems = Cells::from(vec![ - Cell { - name: "LUT2".to_string(), - views: CellViews(vec![CellView { - name: netlist.clone(), - interface: CellInterface(vec![ - InterfacePort::new_output("O"), - InterfacePort::new_input("I0"), - InterfacePort::new_input("I1"), - ]), - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }]), - }, - Cell { - name: "INV".to_string(), - views: CellViews(vec![CellView { - name: netlist.clone(), - interface: CellInterface(vec![ - InterfacePort::new_input("I"), - InterfacePort::new_output("O"), - ]), - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }]), - }, - ]); - - let lib_prims = Library { - name: "hdi_primitives".to_string(), - elements: elems, - }; - - let yinst0_name = "y_INST_0".to_string(); - - let yinst0 = ContentElement::from(ContentInstance { - token: StringToken::new(yinst0_name.clone()), - viewref: netlist, - cellref: CellRef::new("LUT2", "hdi_primitives"), - properties: PropertyList(vec![Property::new_string("INIT", "4'h8")]), - }); - - let neta_name = "a".to_string(); - let neta = ContentElement::from(ContentNet::new_with_ports( - neta_name.clone(), - PortList(vec![ - PortRef::new_with_ref("I0", InstanceRef::new(yinst0_name.clone())), - PortRef::new(neta_name.clone()), - ]), - )); - - let netb_name = "b".to_string(); - let netb = ContentElement::from(ContentNet::new_with_ports( - netb_name.clone(), - PortList(vec![ - PortRef::new_with_ref("I1", InstanceRef::new(yinst0_name.clone())), - PortRef::new(netb_name.clone()), - ]), - )); - - let nety_name = "y".to_string(); - let nety = ContentElement::from(ContentNet::new_with_ports( - nety_name.clone(), - PortList(vec![ - PortRef::new_with_ref("O", InstanceRef::new(yinst0_name)), - PortRef::new(nety_name.clone()), - ]), - )); - - let inv = Cell { - name: top_name.clone(), - views: CellViews(vec![CellView { - name: top_name.clone(), - interface: CellInterface(vec![ - InterfacePort::new_input(neta_name), - InterfacePort::new_input(netb_name), - InterfacePort::new_output(nety_name), - ]), - contents: CellContents(vec![yinst0, neta, netb, nety]), - properties: PropertyList::from(Vec::new()), - }]), - }; - - let lib_work = Library { - name: work_name.clone(), - elements: Cells::from(vec![inv]), - }; - - let design_inv = Design::new_with_prop( - top_name.clone(), - CellRef::new(top_name.clone(), work_name), - PropertyList(vec![Property::new_string("part", "xczu3eg-sbva484-1-e")]), - ); - - let libp = EdifElement::from(lib_prims); - let libw = EdifElement::from(lib_work); - let desi = EdifElement::from(design_inv); - - Edif { - name: top_name, - elements: EdifElements::from(vec![libp, libw, desi]), - } -} - -pub fn dsp() -> Edif { - let top_name = "dsp2".to_string(); - let work_name = "work".to_string(); - let netlist = "netlist".to_string(); - - // Building the Primitive's library - let elems = Cells::from(vec![ - Cell { - name: "GND".to_string(), - views: CellViews(vec![CellView { - name: netlist.clone(), - interface: CellInterface(vec![InterfacePort::new_output("G")]), - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }]), - }, - Cell { - name: "VCC".to_string(), - views: CellViews(vec![CellView { - name: netlist.clone(), - interface: CellInterface(vec![InterfacePort::new_output("P")]), - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }]), - }, - Cell { - name: "DSP48E2".to_string(), - views: CellViews(vec![CellView { - name: netlist.clone(), - interface: CellInterface(vec![ - InterfacePort::new_output("CARRYCASCOUT"), - InterfacePort::new_output("MULTSIGNOUT"), - InterfacePort::new_output("OVERFLOW"), - InterfacePort::new_output("PATTERNBDETECT"), - InterfacePort::new_output("PATTERNDETECT"), - InterfacePort::new_output("UNDERFLOW"), - InterfacePort::new_input("CARRYCASCIN"), - InterfacePort::new_input("CARRYIN"), - InterfacePort::new_input("CEA1"), - InterfacePort::new_input("CEA2"), - InterfacePort::new_input("CEAD"), - InterfacePort::new_input("CEALUMODE"), - InterfacePort::new_input("CEB1"), - InterfacePort::new_input("CEB2"), - InterfacePort::new_input("CEC"), - InterfacePort::new_input("CECARRYIN"), - InterfacePort::new_input("CECTRL"), - InterfacePort::new_input("CED"), - InterfacePort::new_input("CEINMODE"), - InterfacePort::new_input("CEM"), - InterfacePort::new_input("CEP"), - InterfacePort::new_input("CLK"), - InterfacePort::new_input("MULTSIGNIN"), - InterfacePort::new_input("RSTA"), - InterfacePort::new_input("RSTALLCARRYIN"), - InterfacePort::new_input("RSTALUMODE"), - InterfacePort::new_input("RSTB"), - InterfacePort::new_input("RSTC"), - InterfacePort::new_input("RSTCTRL"), - InterfacePort::new_input("RSTD"), - InterfacePort::new_input("RSTINMODE"), - InterfacePort::new_input("RSTM"), - InterfacePort::new_input("RSTP"), - InterfacePort::new( - PortToken::new_array("ACOUT", "ACOUT[29:0]", 30), - PortDirection::Output, - ), - InterfacePort::new( - PortToken::new_array("BCOUT", "BCOUT[17:0]", 18), - PortDirection::Output, - ), - InterfacePort::new( - PortToken::new_array("CARRYOUT", "CARRYOUT[3:0]", 4), - PortDirection::Output, - ), - InterfacePort::new( - PortToken::new_array("PCOUT", "PCOUT[47:0]", 48), - PortDirection::Output, - ), - InterfacePort::new( - PortToken::new_array("P", "P[47:0]", 48), - PortDirection::Output, - ), - InterfacePort::new( - PortToken::new_array("XOROUT", "XOROUT[7:0]", 8), - PortDirection::Output, - ), - InterfacePort::new( - PortToken::new_array("ACIN", "ACIN[29:0]", 30), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("ALUMODE", "ALUMODE[3:0]", 4), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("A", "A[29:0]", 30), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("BCIN", "BCIN[17:0]", 18), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("B", "B[17:0]", 18), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("CARRYINSEL", "CARRYINSEL[2:0]", 3), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("C", "C[47:0]", 48), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("D", "D[26:0]", 27), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("INMODE", "INMODE[4:0]", 5), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("OPMODE", "OPMODE[8:0]", 9), - PortDirection::Input, - ), - InterfacePort::new( - PortToken::new_array("PCIN", "PCIN[47:0]", 48), - PortDirection::Input, - ), - ]), - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }]), - }, - Cell { - name: "INV".to_string(), - views: CellViews(vec![CellView { - name: netlist.clone(), - interface: CellInterface(vec![ - InterfacePort::new_input("I"), - InterfacePort::new_output("O"), - ]), - contents: CellContents(Vec::new()), - properties: PropertyList::from(Vec::new()), - }]), - }, - ]); - - let lib_prims = Library { - name: "hdi_primitives".to_string(), - elements: elems, - }; - - // Building the elemtns for the work library - let gnd_name = "GND".to_string(); - let gnd_ref = InstanceRef::new(gnd_name.clone()); - let gnd = ContentElement::from(ContentInstance { - token: StringToken::new(gnd_name), - viewref: netlist.clone(), - cellref: CellRef::new("GND", "hdi_primitives"), - properties: PropertyList(vec![]), - }); - - let gnd1_name = "GND_1".to_string(); - let gnd1_ref = InstanceRef::new(gnd1_name.clone()); - let gnd1 = ContentElement::from(ContentInstance { - token: StringToken::new(gnd1_name), - viewref: netlist.clone(), - cellref: CellRef::new("GND", "hdi_primitives"), - properties: PropertyList(vec![]), - }); - - let vcc_name = "VCC".to_string(); - let vccref = InstanceRef::new(vcc_name.clone()); - let vcc = ContentElement::from(ContentInstance { - token: StringToken::new(vcc_name), - viewref: netlist.clone(), - cellref: CellRef::new("VCC", "hdi_primitives"), - properties: PropertyList(vec![]), - }); - - let vcc1_name = "VCC_1".to_string(); - let vcc1_ref = InstanceRef::new(vcc1_name.clone()); - let vcc1 = ContentElement::from(ContentInstance { - token: StringToken::new(vcc1_name), - viewref: netlist.clone(), - cellref: CellRef::new("VCC", "hdi_primitives"), - properties: PropertyList(vec![]), - }); - - let dsp_name = "res".to_string(); - let dspref = InstanceRef::new(dsp_name.clone()); - let dspinst = ContentElement::from(ContentInstance { - token: StringToken::new(dsp_name), - viewref: netlist, - cellref: CellRef::new("DSP48E2", "hdi_primitives"), - properties: PropertyList(vec![ - Property::new_string("XORSIMD", "XOR24_48_96"), - Property::new_string("USE_WIDEXOR", "FALSE"), - Property::new_integer("ACASCREG", 0), - Property::new_integer("ADREG", 1), - Property::new_integer("ALUMODEREG", 0), - Property::new_string("AMULTSEL", "A"), - Property::new_integer("AREG", 0), - Property::new_string("AUTORESET_PATDET", "NO_RESET"), - Property::new_string("AUTORESET_PRIORITY", "RESET"), - Property::new_string("A_INPUT", "DIRECT"), - Property::new_integer("BCASCREG", 0), - Property::new_string("BMULTSEL", "B"), - Property::new_integer("BREG", 0), - Property::new_string("B_INPUT", "DIRECT"), - Property::new_integer("CARRYINREG", 0), - Property::new_integer("CARRYINSELREG", 0), - Property::new_integer("CREG", 1), - Property::new_integer("DREG", 1), - Property::new_integer("INMODEREG", 0), - Property::new_string("MASK", "48'h3FFFFFFFFFFF"), - Property::new_string("METHODOLOGY_DRC_VIOS", r#"{SYNTH-13 {cell *THIS*}}"#), - Property::new_integer("MREG", 0), - Property::new_integer("OPMODEREG", 0), - Property::new_string("PATTERN", "48'h000000000000"), - Property::new_string("PREADDINSEL", "A"), - Property::new_integer("PREG", 0), - Property::new_string("RND", "48'h000000000000"), - Property::new_string("SEL_MASK", "MASK"), - Property::new_string("SEL_PATTERN", "PATTERN"), - Property::new_string("USE_MULT", "MULTIPLY"), - Property::new_string("USE_PATTERN_DETECT", "NO_PATDET"), - Property::new_string("USE_SIMD", "ONE48"), - Property::new_string("OPT_MODIFIED", "SWEEP"), - ]), - }); - - let const_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "&_const0_", - "", - PortList(vec![ - PortRef::new_member_with_ref("ACIN", 29, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 19, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 18, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 17, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 16, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 15, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 14, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 13, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 12, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 11, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 10, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 28, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 9, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 8, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 7, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 6, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 5, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 4, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 3, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 2, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 1, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 0, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 27, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 26, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 25, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 24, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 23, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 22, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 21, dspref.clone()), - PortRef::new_member_with_ref("ACIN", 20, dspref.clone()), - PortRef::new_member_with_ref("ALUMODE", 3, dspref.clone()), - PortRef::new_member_with_ref("ALUMODE", 2, dspref.clone()), - PortRef::new_member_with_ref("ALUMODE", 1, dspref.clone()), - PortRef::new_member_with_ref("ALUMODE", 0, dspref.clone()), - PortRef::new_member_with_ref("A", 19, dspref.clone()), - PortRef::new_member_with_ref("A", 18, dspref.clone()), - PortRef::new_member_with_ref("A", 17, dspref.clone()), - PortRef::new_member_with_ref("A", 16, dspref.clone()), - PortRef::new_member_with_ref("A", 15, dspref.clone()), - PortRef::new_member_with_ref("A", 14, dspref.clone()), - PortRef::new_member_with_ref("A", 13, dspref.clone()), - PortRef::new_member_with_ref("A", 12, dspref.clone()), - PortRef::new_member_with_ref("A", 11, dspref.clone()), - PortRef::new_member_with_ref("A", 10, dspref.clone()), - PortRef::new_member_with_ref("A", 9, dspref.clone()), - PortRef::new_member_with_ref("A", 8, dspref.clone()), - PortRef::new_member_with_ref("A", 7, dspref.clone()), - PortRef::new_member_with_ref("A", 6, dspref.clone()), - PortRef::new_member_with_ref("A", 5, dspref.clone()), - PortRef::new_member_with_ref("A", 4, dspref.clone()), - PortRef::new_member_with_ref("A", 3, dspref.clone()), - PortRef::new_member_with_ref("A", 2, dspref.clone()), - PortRef::new_member_with_ref("A", 1, dspref.clone()), - PortRef::new_member_with_ref("A", 0, dspref.clone()), - PortRef::new_member_with_ref("A", 21, dspref.clone()), - PortRef::new_member_with_ref("A", 20, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 17, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 7, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 6, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 5, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 4, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 3, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 2, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 1, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 0, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 16, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 15, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 14, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 13, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 12, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 11, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 10, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 9, dspref.clone()), - PortRef::new_member_with_ref("BCIN", 8, dspref.clone()), - PortRef::new_member_with_ref("B", 7, dspref.clone()), - PortRef::new_member_with_ref("B", 6, dspref.clone()), - PortRef::new_member_with_ref("B", 5, dspref.clone()), - PortRef::new_member_with_ref("B", 4, dspref.clone()), - PortRef::new_member_with_ref("B", 3, dspref.clone()), - PortRef::new_member_with_ref("B", 2, dspref.clone()), - PortRef::new_member_with_ref("B", 1, dspref.clone()), - PortRef::new_member_with_ref("B", 0, dspref.clone()), - PortRef::new_member_with_ref("B", 9, dspref.clone()), - PortRef::new_member_with_ref("B", 8, dspref.clone()), - PortRef::new_with_ref("CARRYCASCIN", dspref.clone()), - PortRef::new_with_ref("CARRYIN", dspref.clone()), - PortRef::new_member_with_ref("CARRYINSEL", 2, dspref.clone()), - PortRef::new_member_with_ref("CARRYINSEL", 1, dspref.clone()), - PortRef::new_member_with_ref("CARRYINSEL", 0, dspref.clone()), - PortRef::new_with_ref("CEA1", dspref.clone()), - PortRef::new_with_ref("CEA2", dspref.clone()), - PortRef::new_with_ref("CEAD", dspref.clone()), - PortRef::new_with_ref("CEALUMODE", dspref.clone()), - PortRef::new_with_ref("CEB1", dspref.clone()), - PortRef::new_with_ref("CEB2", dspref.clone()), - PortRef::new_with_ref("CEC", dspref.clone()), - PortRef::new_with_ref("CECARRYIN", dspref.clone()), - PortRef::new_with_ref("CECTRL", dspref.clone()), - PortRef::new_with_ref("CED", dspref.clone()), - PortRef::new_with_ref("CEINMODE", dspref.clone()), - PortRef::new_with_ref("CEM", dspref.clone()), - PortRef::new_with_ref("CEP", dspref.clone()), - PortRef::new_with_ref("CLK", dspref.clone()), - PortRef::new_with_ref("G", gnd_ref), - PortRef::new_member_with_ref("INMODE", 4, dspref.clone()), - PortRef::new_member_with_ref("INMODE", 3, dspref.clone()), - PortRef::new_member_with_ref("INMODE", 2, dspref.clone()), - PortRef::new_member_with_ref("INMODE", 1, dspref.clone()), - PortRef::new_member_with_ref("INMODE", 0, dspref.clone()), - PortRef::new_with_ref("MULTSIGNIN", dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 7, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 5, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 4, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 3, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 2, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 1, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 0, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 47, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 37, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 36, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 35, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 34, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 33, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 32, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 31, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 30, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 29, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 28, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 46, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 27, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 26, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 25, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 24, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 23, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 22, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 21, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 20, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 19, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 18, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 45, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 17, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 16, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 15, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 14, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 13, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 12, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 11, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 10, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 9, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 8, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 44, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 7, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 6, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 5, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 4, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 3, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 2, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 1, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 0, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 43, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 42, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 41, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 40, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 39, dspref.clone()), - PortRef::new_member_with_ref("PCIN", 38, dspref.clone()), - PortRef::new_with_ref("RSTA", dspref.clone()), - PortRef::new_with_ref("RSTALLCARRYIN", dspref.clone()), - PortRef::new_with_ref("RSTALUMODE", dspref.clone()), - PortRef::new_with_ref("RSTB", dspref.clone()), - PortRef::new_with_ref("RSTC", dspref.clone()), - PortRef::new_with_ref("RSTCTRL", dspref.clone()), - PortRef::new_with_ref("RSTD", dspref.clone()), - PortRef::new_with_ref("RSTINMODE", dspref.clone()), - PortRef::new_with_ref("RSTM", dspref.clone()), - PortRef::new_with_ref("RSTP", dspref.clone()), - ]), - )); - - let const1_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "&_const1_", - "", - PortList(vec![ - PortRef::new_member_with_ref("OPMODE", 8, dspref.clone()), - PortRef::new_member_with_ref("OPMODE", 6, dspref.clone()), - PortRef::new_with_ref("P", vccref), - ]), - )); - - let nety_name = "GND_2".to_string(); - let gnd2 = ContentElement::from(ContentNet::new_with_ports( - nety_name, - PortList(vec![ - PortRef::new_member_with_ref("D", 26, dspref.clone()), - PortRef::new_member_with_ref("D", 16, dspref.clone()), - PortRef::new_member_with_ref("D", 15, dspref.clone()), - PortRef::new_member_with_ref("D", 14, dspref.clone()), - PortRef::new_member_with_ref("D", 13, dspref.clone()), - PortRef::new_member_with_ref("D", 12, dspref.clone()), - PortRef::new_member_with_ref("D", 11, dspref.clone()), - PortRef::new_member_with_ref("D", 10, dspref.clone()), - PortRef::new_member_with_ref("D", 9, dspref.clone()), - PortRef::new_member_with_ref("D", 8, dspref.clone()), - PortRef::new_member_with_ref("D", 7, dspref.clone()), - PortRef::new_member_with_ref("D", 25, dspref.clone()), - PortRef::new_member_with_ref("D", 6, dspref.clone()), - PortRef::new_member_with_ref("D", 5, dspref.clone()), - PortRef::new_member_with_ref("D", 4, dspref.clone()), - PortRef::new_member_with_ref("D", 3, dspref.clone()), - PortRef::new_member_with_ref("D", 2, dspref.clone()), - PortRef::new_member_with_ref("D", 1, dspref.clone()), - PortRef::new_member_with_ref("D", 0, dspref.clone()), - PortRef::new_member_with_ref("D", 24, dspref.clone()), - PortRef::new_member_with_ref("D", 23, dspref.clone()), - PortRef::new_member_with_ref("D", 22, dspref.clone()), - PortRef::new_member_with_ref("D", 21, dspref.clone()), - PortRef::new_member_with_ref("D", 20, dspref.clone()), - PortRef::new_member_with_ref("D", 19, dspref.clone()), - PortRef::new_member_with_ref("D", 18, dspref.clone()), - PortRef::new_member_with_ref("D", 17, dspref.clone()), - PortRef::new_with_ref("G", gnd1_ref), - ]), - )); - - let vcc2_name = "VCC_2".to_string(); - let vcc2 = ContentElement::from(ContentNet::new_with_ports( - vcc2_name, - PortList(vec![ - PortRef::new_member_with_ref("C", 47, dspref.clone()), - PortRef::new_member_with_ref("C", 37, dspref.clone()), - PortRef::new_member_with_ref("C", 36, dspref.clone()), - PortRef::new_member_with_ref("C", 35, dspref.clone()), - PortRef::new_member_with_ref("C", 34, dspref.clone()), - PortRef::new_member_with_ref("C", 33, dspref.clone()), - PortRef::new_member_with_ref("C", 32, dspref.clone()), - PortRef::new_member_with_ref("C", 31, dspref.clone()), - PortRef::new_member_with_ref("C", 30, dspref.clone()), - PortRef::new_member_with_ref("C", 29, dspref.clone()), - PortRef::new_member_with_ref("C", 28, dspref.clone()), - PortRef::new_member_with_ref("C", 46, dspref.clone()), - PortRef::new_member_with_ref("C", 27, dspref.clone()), - PortRef::new_member_with_ref("C", 26, dspref.clone()), - PortRef::new_member_with_ref("C", 25, dspref.clone()), - PortRef::new_member_with_ref("C", 24, dspref.clone()), - PortRef::new_member_with_ref("C", 23, dspref.clone()), - PortRef::new_member_with_ref("C", 22, dspref.clone()), - PortRef::new_member_with_ref("C", 21, dspref.clone()), - PortRef::new_member_with_ref("C", 20, dspref.clone()), - PortRef::new_member_with_ref("C", 19, dspref.clone()), - PortRef::new_member_with_ref("C", 18, dspref.clone()), - PortRef::new_member_with_ref("C", 45, dspref.clone()), - PortRef::new_member_with_ref("C", 17, dspref.clone()), - PortRef::new_member_with_ref("C", 16, dspref.clone()), - PortRef::new_member_with_ref("C", 15, dspref.clone()), - PortRef::new_member_with_ref("C", 14, dspref.clone()), - PortRef::new_member_with_ref("C", 13, dspref.clone()), - PortRef::new_member_with_ref("C", 12, dspref.clone()), - PortRef::new_member_with_ref("C", 11, dspref.clone()), - PortRef::new_member_with_ref("C", 10, dspref.clone()), - PortRef::new_member_with_ref("C", 9, dspref.clone()), - PortRef::new_member_with_ref("C", 8, dspref.clone()), - PortRef::new_member_with_ref("C", 44, dspref.clone()), - PortRef::new_member_with_ref("C", 7, dspref.clone()), - PortRef::new_member_with_ref("C", 6, dspref.clone()), - PortRef::new_member_with_ref("C", 5, dspref.clone()), - PortRef::new_member_with_ref("C", 4, dspref.clone()), - PortRef::new_member_with_ref("C", 3, dspref.clone()), - PortRef::new_member_with_ref("C", 2, dspref.clone()), - PortRef::new_member_with_ref("C", 1, dspref.clone()), - PortRef::new_member_with_ref("C", 0, dspref.clone()), - PortRef::new_member_with_ref("C", 43, dspref.clone()), - PortRef::new_member_with_ref("C", 42, dspref.clone()), - PortRef::new_member_with_ref("C", 41, dspref.clone()), - PortRef::new_member_with_ref("C", 40, dspref.clone()), - PortRef::new_member_with_ref("C", 39, dspref.clone()), - PortRef::new_member_with_ref("C", 38, dspref.clone()), - PortRef::new_with_ref("P", vcc1_ref), - ]), - )); - - let a0_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_0_", - "a[0]", - PortList(vec![ - PortRef::new_member_with_ref("A", 29, dspref.clone()), - PortRef::new_member("a", 7), - ]), - )); - let a1_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_1_", - "a[1]", - PortList(vec![ - PortRef::new_member_with_ref("A", 28, dspref.clone()), - PortRef::new_member("a", 6), - ]), - )); - let a2_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_2_", - "a[2]", - PortList(vec![ - PortRef::new_member_with_ref("A", 27, dspref.clone()), - PortRef::new_member("a", 5), - ]), - )); - let a3_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_3_", - "a[3]", - PortList(vec![ - PortRef::new_member_with_ref("A", 26, dspref.clone()), - PortRef::new_member("a", 4), - ]), - )); - let a4_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_4_", - "a[4]", - PortList(vec![ - PortRef::new_member_with_ref("A", 25, dspref.clone()), - PortRef::new_member("a", 3), - ]), - )); - let a5_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_5_", - "a[5]", - PortList(vec![ - PortRef::new_member_with_ref("A", 24, dspref.clone()), - PortRef::new_member("a", 2), - ]), - )); - let a6_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_6_", - "a[6]", - PortList(vec![ - PortRef::new_member_with_ref("A", 23, dspref.clone()), - PortRef::new_member("a", 1), - ]), - )); - let a7_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "a_7_", - "a[7]", - PortList(vec![ - PortRef::new_member_with_ref("A", 22, dspref.clone()), - PortRef::new_member("a", 0), - ]), - )); - let b0_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_0_", - "b[0]", - PortList(vec![ - PortRef::new_member_with_ref("B", 17, dspref.clone()), - PortRef::new_member("b", 7), - ]), - )); - let b1_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_1_", - "b[1]", - PortList(vec![ - PortRef::new_member_with_ref("B", 16, dspref.clone()), - PortRef::new_member("b", 6), - ]), - )); - let b2_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_2_", - "b[2]", - PortList(vec![ - PortRef::new_member_with_ref("B", 15, dspref.clone()), - PortRef::new_member("b", 5), - ]), - )); - let b3_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_3_", - "b[3]", - PortList(vec![ - PortRef::new_member_with_ref("B", 14, dspref.clone()), - PortRef::new_member("b", 4), - ]), - )); - let b4_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_4_", - "b[4]", - PortList(vec![ - PortRef::new_member_with_ref("B", 13, dspref.clone()), - PortRef::new_member("b", 3), - ]), - )); - let b5_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_5_", - "b[5]", - PortList(vec![ - PortRef::new_member_with_ref("B", 12, dspref.clone()), - PortRef::new_member("b", 2), - ]), - )); - let b6_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_6_", - "b[6]", - PortList(vec![ - PortRef::new_member_with_ref("B", 11, dspref.clone()), - PortRef::new_member("b", 1), - ]), - )); - let b7_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "b_7_", - "b[7]", - PortList(vec![ - PortRef::new_member_with_ref("B", 10, dspref.clone()), - PortRef::new_member("b", 0), - ]), - )); - let y0_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_0_", - "y[0]", - PortList(vec![ - PortRef::new_member_with_ref("P", 47, dspref.clone()), - PortRef::new_member("y", 7), - ]), - )); - let y1_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_1_", - "y[1]", - PortList(vec![ - PortRef::new_member_with_ref("P", 46, dspref.clone()), - PortRef::new_member("y", 6), - ]), - )); - let y2_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_2_", - "y[2]", - PortList(vec![ - PortRef::new_member_with_ref("P", 45, dspref.clone()), - PortRef::new_member("y", 5), - ]), - )); - let y3_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_3_", - "y[3]", - PortList(vec![ - PortRef::new_member_with_ref("P", 44, dspref.clone()), - PortRef::new_member("y", 4), - ]), - )); - let y4_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_4_", - "y[4]", - PortList(vec![ - PortRef::new_member_with_ref("P", 43, dspref.clone()), - PortRef::new_member("y", 3), - ]), - )); - let y5_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_5_", - "y[5]", - PortList(vec![ - PortRef::new_member_with_ref("P", 42, dspref.clone()), - PortRef::new_member("y", 2), - ]), - )); - let y6_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_6_", - "y[6]", - PortList(vec![ - PortRef::new_member_with_ref("P", 41, dspref.clone()), - PortRef::new_member("y", 1), - ]), - )); - let y7_net = ContentElement::from(ContentNet::new_renamed_with_ports( - "y_7_", - "y[7]", - PortList(vec![ - PortRef::new_member_with_ref("P", 40, dspref), - PortRef::new_member("y", 0), - ]), - )); - - let dsp_cell = Cell { - name: top_name.clone(), - views: CellViews(vec![CellView { - name: top_name.clone(), - interface: CellInterface(vec![ - InterfacePort::new_input_array("a", "a[7:0]", 8), - InterfacePort::new_input_array("b", "b[7:0]", 8), - InterfacePort::new_output_array("y", "y[7:0]", 8), - ]), - contents: CellContents(vec![ - gnd, gnd1, vcc, vcc1, dspinst, const_net, const1_net, gnd2, vcc2, a0_net, a1_net, - a2_net, a3_net, a4_net, a5_net, a6_net, a7_net, b0_net, b1_net, b2_net, b3_net, - b4_net, b5_net, b6_net, b7_net, y0_net, y1_net, y2_net, y3_net, y4_net, y5_net, - y6_net, y7_net, - ]), - properties: PropertyList(vec![Property::new_string("ECO_CHECKSUM", "2ac8fb58")]), - }]), - }; - - let lib_work = Library { - name: work_name.clone(), - elements: Cells::from(vec![dsp_cell]), - }; - - let design_dsp = Design::new_with_prop( - top_name.clone(), - CellRef::new(top_name.clone(), work_name), - PropertyList(vec![Property::new_string("part", "xczu3eg-sbva484-1-e")]), - ); - - let libp = EdifElement::from(lib_prims); - let libw = EdifElement::from(lib_work); - let desi = EdifElement::from(design_dsp); - - Edif { - name: top_name, - elements: EdifElements::from(vec![libp, libw, desi]), - } -} diff --git a/src/langs/edif/src/platforms/tests/xilinx_ut.rs b/src/langs/edif/src/platforms/tests/xilinx_ut.rs deleted file mode 100644 index 66fb07dd..00000000 --- a/src/langs/edif/src/platforms/tests/xilinx_ut.rs +++ /dev/null @@ -1,113 +0,0 @@ -/* -Copyright 2021 Pedro M. Torruella N. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ -use edifier::ast::*; -use edifier::string_helpers::match_check; -use platforms::xilinx::*; - -// Test 1: we should get a lut2 element -#[test] -fn lut2() { - let ed = new_lut2(); - - let actual = serde_sexpr::to_string(&ed).unwrap(); - - assert_eq!( - actual, - "(cell LUT2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port O (direction OUTPUT)) (port I0 (direction INPUT)) (port I1 (direction INPUT)))))" - ); - //assert_eq!(match_check(actual), 0); -} - -// Test 2: we should get an instance with properties -// for a placed lut2 element -#[test] -fn lut2_instance() { - let mut proplist = PropertyList(Vec::new()); - proplist.push(lut2_prop_ini("4'h6")); - proplist.push(lut2_prop_box("PRIMITIVE")); - proplist.push(lut2_prop_loc("SLICE_X0Y0")); - proplist.push(lut2_prop_bel("A6LUT")); - - let contents = ContentInstance { - token: StringToken::new("i0"), - viewref: "netlist".to_string(), - cellref: CellRef::new("LUT2", "hdi_primitives"), - properties: proplist, - }; - - let actual = serde_sexpr::to_string(&contents).unwrap(); - - assert_eq!( - actual, - r#"(instance i0 (viewref netlist (cellref LUT2 (libraryref hdi_primitives))) (property INIT (string "4'h6")) (property BOX_TYPE (string "PRIMITIVE")) (property LOC (string "SLICE_X0Y0")) (property BEL (string "A6LUT")))"# - ); -} - -// Test 3: we should get an instance with properties -// for a placed lut2 element, being renamed -#[test] -fn lut2_instance_renamed() { - let mut proplist = PropertyList(Vec::new()); - proplist.push(lut2_prop_ini("4'h6")); - proplist.push(lut2_prop_box("PRIMITIVE")); - proplist.push(lut2_prop_loc("SLICE_X0Y0")); - proplist.push(lut2_prop_bel("A6LUT")); - - let contents = ContentInstance { - token: StringToken::new_renamed( - "address_loop_2__output_data_pc_vector_mux_lut", - r#"address_loop[2].output_data.pc_vector_mux_lut"#, - ), - viewref: "netlist".to_string(), - cellref: CellRef::new("LUT2", "hdi_primitives"), - properties: proplist, - }; - - let actual = serde_sexpr::to_string(&contents).unwrap(); - - assert_eq!( - actual, - r#"(instance (rename address_loop_2__output_data_pc_vector_mux_lut "address_loop[2].output_data.pc_vector_mux_lut") (viewref netlist (cellref LUT2 (libraryref hdi_primitives))) (property INIT (string "4'h6")) (property BOX_TYPE (string "PRIMITIVE")) (property LOC (string "SLICE_X0Y0")) (property BEL (string "A6LUT")))"# - ); -} - -// Test 4: Testing arrays -#[test] -fn simple_array() { - let ed = carry8(); - - let actual = serde_sexpr::to_string(&ed).unwrap(); - - assert_eq!( - actual, - r#"(cell CARRY8 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port CI (direction INPUT)) (port CI_TOP (direction INPUT)) (port (array (rename CO "CO[7:0]") 8) (direction OUTPUT)) (port (array (rename O "O[7:0]") 8) (direction OUTPUT)) (port (array (rename DI "DI[7:0]") 8) (direction INPUT)) (port (array (rename S "S[7:0]") 8) (direction INPUT)))))"# - ); - assert_eq!(match_check(actual), 0); -} - -// Test 5: Testing the inverter example -#[test] -fn test_inverter_top() { - let edif = inverter(); - - let actual = serde_sexpr::to_string(&edif).unwrap(); - - assert_eq!( - actual, - r#"(edif inverter (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library hdi_primitives (edifLevel 0) (technology (numberDefinition)) (cell LUT2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port O (direction OUTPUT)) (port I0 (direction INPUT)) (port I1 (direction INPUT))))) (cell INV (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port I (direction INPUT)) (port O (direction OUTPUT)))))) (Library work (edifLevel 0) (technology (numberDefinition)) (cell inverter (celltype GENERIC) (view inverter (viewtype NETLIST) (interface (port a (direction INPUT)) (port b (direction INPUT)) (port y (direction OUTPUT))) (contents (instance y_INST_0 (viewref netlist (cellref LUT2 (libraryref hdi_primitives))) (property INIT (string "4'h8"))) (net a (joined (portref I0 (instanceref y_INST_0)) (portref a))) (net b (joined (portref I1 (instanceref y_INST_0)) (portref b))) (net y (joined (portref O (instanceref y_INST_0)) (portref y))))))) (design inverter (cellref inverter (libraryref work)) (property part (string "xczu3eg-sbva484-1-e"))))"# - ); - assert_eq!(match_check(actual), 0); -} diff --git a/src/langs/edif/src/edifier/src/serialize.rs b/src/langs/edif/src/serialize.rs similarity index 100% rename from src/langs/edif/src/edifier/src/serialize.rs rename to src/langs/edif/src/serialize.rs diff --git a/src/langs/edif/src/edifier/src/string_helpers.rs b/src/langs/edif/src/string_helpers.rs similarity index 100% rename from src/langs/edif/src/edifier/src/string_helpers.rs rename to src/langs/edif/src/string_helpers.rs diff --git a/src/langs/edif/src/xilinx_multiplier.edf b/src/langs/edif/src/xilinx_multiplier.edf deleted file mode 100644 index dac95841..00000000 --- a/src/langs/edif/src/xilinx_multiplier.edf +++ /dev/null @@ -1 +0,0 @@ -(edif dsp2 (edifversion 2 0 0) (edifLevel 0) (keywordmap (keywordlevel 0)) (Library hdi_primitives (edifLevel 0) (technology (numberDefinition)) (cell GND (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port G (direction OUTPUT))))) (cell VCC (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port P (direction OUTPUT))))) (cell DSP48E2 (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port CARRYCASCOUT (direction OUTPUT)) (port MULTSIGNOUT (direction OUTPUT)) (port OVERFLOW (direction OUTPUT)) (port PATTERNBDETECT (direction OUTPUT)) (port PATTERNDETECT (direction OUTPUT)) (port UNDERFLOW (direction OUTPUT)) (port CARRYCASCIN (direction INPUT)) (port CARRYIN (direction INPUT)) (port CEA1 (direction INPUT)) (port CEA2 (direction INPUT)) (port CEAD (direction INPUT)) (port CEALUMODE (direction INPUT)) (port CEB1 (direction INPUT)) (port CEB2 (direction INPUT)) (port CEC (direction INPUT)) (port CECARRYIN (direction INPUT)) (port CECTRL (direction INPUT)) (port CED (direction INPUT)) (port CEINMODE (direction INPUT)) (port CEM (direction INPUT)) (port CEP (direction INPUT)) (port CLK (direction INPUT)) (port MULTSIGNIN (direction INPUT)) (port RSTA (direction INPUT)) (port RSTALLCARRYIN (direction INPUT)) (port RSTALUMODE (direction INPUT)) (port RSTB (direction INPUT)) (port RSTC (direction INPUT)) (port RSTCTRL (direction INPUT)) (port RSTD (direction INPUT)) (port RSTINMODE (direction INPUT)) (port RSTM (direction INPUT)) (port RSTP (direction INPUT)) (port (array (rename ACOUT "ACOUT[29:0]") 30) (direction OUTPUT)) (port (array (rename BCOUT "BCOUT[17:0]") 18) (direction OUTPUT)) (port (array (rename CARRYOUT "CARRYOUT[3:0]") 4) (direction OUTPUT)) (port (array (rename PCOUT "PCOUT[47:0]") 48) (direction OUTPUT)) (port (array (rename P "P[47:0]") 48) (direction OUTPUT)) (port (array (rename XOROUT "XOROUT[7:0]") 8) (direction OUTPUT)) (port (array (rename ACIN "ACIN[29:0]") 30) (direction INPUT)) (port (array (rename ALUMODE "ALUMODE[3:0]") 4) (direction INPUT)) (port (array (rename A "A[29:0]") 30) (direction INPUT)) (port (array (rename BCIN "BCIN[17:0]") 18) (direction INPUT)) (port (array (rename B "B[17:0]") 18) (direction INPUT)) (port (array (rename CARRYINSEL "CARRYINSEL[2:0]") 3) (direction INPUT)) (port (array (rename C "C[47:0]") 48) (direction INPUT)) (port (array (rename D "D[26:0]") 27) (direction INPUT)) (port (array (rename INMODE "INMODE[4:0]") 5) (direction INPUT)) (port (array (rename OPMODE "OPMODE[8:0]") 9) (direction INPUT)) (port (array (rename PCIN "PCIN[47:0]") 48) (direction INPUT))))) (cell INV (celltype GENERIC) (view netlist (viewtype NETLIST) (interface (port I (direction INPUT)) (port O (direction OUTPUT)))))) (Library work (edifLevel 0) (technology (numberDefinition)) (cell dsp2 (celltype GENERIC) (view dsp2 (viewtype NETLIST) (interface (port (array (rename a "a[7:0]") 8) (direction INPUT)) (port (array (rename b "b[7:0]") 8) (direction INPUT)) (port (array (rename y "y[7:0]") 8) (direction OUTPUT))) (contents (instance GND (viewref netlist (cellref GND (libraryref hdi_primitives)))) (instance GND_1 (viewref netlist (cellref GND (libraryref hdi_primitives)))) (instance VCC (viewref netlist (cellref VCC (libraryref hdi_primitives)))) (instance VCC_1 (viewref netlist (cellref VCC (libraryref hdi_primitives)))) (instance res (viewref netlist (cellref DSP48E2 (libraryref hdi_primitives))) (property XORSIMD (string "XOR24_48_96")) (property USE_WIDEXOR (string "FALSE")) (property ACASCREG (integer 0)) (property ADREG (integer 1)) (property ALUMODEREG (integer 0)) (property AMULTSEL (string "A")) (property AREG (integer 0)) (property AUTORESET_PATDET (string "NO_RESET")) (property AUTORESET_PRIORITY (string "RESET")) (property A_INPUT (string "DIRECT")) (property BCASCREG (integer 0)) (property BMULTSEL (string "B")) (property BREG (integer 0)) (property B_INPUT (string "DIRECT")) (property CARRYINREG (integer 0)) (property CARRYINSELREG (integer 0)) (property CREG (integer 1)) (property DREG (integer 1)) (property INMODEREG (integer 0)) (property MASK (string "48'h3FFFFFFFFFFF")) (property METHODOLOGY_DRC_VIOS (string |"{SYNTH-13\ {cell\ *THIS*}}"|)) (property MREG (integer 0)) (property OPMODEREG (integer 0)) (property PATTERN (string "48'h000000000000")) (property PREADDINSEL (string "A")) (property PREG (integer 0)) (property RND (string "48'h000000000000")) (property SEL_MASK (string "MASK")) (property SEL_PATTERN (string "PATTERN")) (property USE_MULT (string "MULTIPLY")) (property USE_PATTERN_DETECT (string "NO_PATDET")) (property USE_SIMD (string "ONE48")) (property OPT_MODIFIED (string "SWEEP"))) (net (rename &_const0_ "") (joined (portref (member ACIN 29) (instanceref res)) (portref (member ACIN 19) (instanceref res)) (portref (member ACIN 18) (instanceref res)) (portref (member ACIN 17) (instanceref res)) (portref (member ACIN 16) (instanceref res)) (portref (member ACIN 15) (instanceref res)) (portref (member ACIN 14) (instanceref res)) (portref (member ACIN 13) (instanceref res)) (portref (member ACIN 12) (instanceref res)) (portref (member ACIN 11) (instanceref res)) (portref (member ACIN 10) (instanceref res)) (portref (member ACIN 28) (instanceref res)) (portref (member ACIN 9) (instanceref res)) (portref (member ACIN 8) (instanceref res)) (portref (member ACIN 7) (instanceref res)) (portref (member ACIN 6) (instanceref res)) (portref (member ACIN 5) (instanceref res)) (portref (member ACIN 4) (instanceref res)) (portref (member ACIN 3) (instanceref res)) (portref (member ACIN 2) (instanceref res)) (portref (member ACIN 1) (instanceref res)) (portref (member ACIN 0) (instanceref res)) (portref (member ACIN 27) (instanceref res)) (portref (member ACIN 26) (instanceref res)) (portref (member ACIN 25) (instanceref res)) (portref (member ACIN 24) (instanceref res)) (portref (member ACIN 23) (instanceref res)) (portref (member ACIN 22) (instanceref res)) (portref (member ACIN 21) (instanceref res)) (portref (member ACIN 20) (instanceref res)) (portref (member ALUMODE 3) (instanceref res)) (portref (member ALUMODE 2) (instanceref res)) (portref (member ALUMODE 1) (instanceref res)) (portref (member ALUMODE 0) (instanceref res)) (portref (member A 19) (instanceref res)) (portref (member A 18) (instanceref res)) (portref (member A 17) (instanceref res)) (portref (member A 16) (instanceref res)) (portref (member A 15) (instanceref res)) (portref (member A 14) (instanceref res)) (portref (member A 13) (instanceref res)) (portref (member A 12) (instanceref res)) (portref (member A 11) (instanceref res)) (portref (member A 10) (instanceref res)) (portref (member A 9) (instanceref res)) (portref (member A 8) (instanceref res)) (portref (member A 7) (instanceref res)) (portref (member A 6) (instanceref res)) (portref (member A 5) (instanceref res)) (portref (member A 4) (instanceref res)) (portref (member A 3) (instanceref res)) (portref (member A 2) (instanceref res)) (portref (member A 1) (instanceref res)) (portref (member A 0) (instanceref res)) (portref (member A 21) (instanceref res)) (portref (member A 20) (instanceref res)) (portref (member BCIN 17) (instanceref res)) (portref (member BCIN 7) (instanceref res)) (portref (member BCIN 6) (instanceref res)) (portref (member BCIN 5) (instanceref res)) (portref (member BCIN 4) (instanceref res)) (portref (member BCIN 3) (instanceref res)) (portref (member BCIN 2) (instanceref res)) (portref (member BCIN 1) (instanceref res)) (portref (member BCIN 0) (instanceref res)) (portref (member BCIN 16) (instanceref res)) (portref (member BCIN 15) (instanceref res)) (portref (member BCIN 14) (instanceref res)) (portref (member BCIN 13) (instanceref res)) (portref (member BCIN 12) (instanceref res)) (portref (member BCIN 11) (instanceref res)) (portref (member BCIN 10) (instanceref res)) (portref (member BCIN 9) (instanceref res)) (portref (member BCIN 8) (instanceref res)) (portref (member B 7) (instanceref res)) (portref (member B 6) (instanceref res)) (portref (member B 5) (instanceref res)) (portref (member B 4) (instanceref res)) (portref (member B 3) (instanceref res)) (portref (member B 2) (instanceref res)) (portref (member B 1) (instanceref res)) (portref (member B 0) (instanceref res)) (portref (member B 9) (instanceref res)) (portref (member B 8) (instanceref res)) (portref CARRYCASCIN (instanceref res)) (portref CARRYIN (instanceref res)) (portref (member CARRYINSEL 2) (instanceref res)) (portref (member CARRYINSEL 1) (instanceref res)) (portref (member CARRYINSEL 0) (instanceref res)) (portref CEA1 (instanceref res)) (portref CEA2 (instanceref res)) (portref CEAD (instanceref res)) (portref CEALUMODE (instanceref res)) (portref CEB1 (instanceref res)) (portref CEB2 (instanceref res)) (portref CEC (instanceref res)) (portref CECARRYIN (instanceref res)) (portref CECTRL (instanceref res)) (portref CED (instanceref res)) (portref CEINMODE (instanceref res)) (portref CEM (instanceref res)) (portref CEP (instanceref res)) (portref CLK (instanceref res)) (portref G (instanceref GND)) (portref (member INMODE 4) (instanceref res)) (portref (member INMODE 3) (instanceref res)) (portref (member INMODE 2) (instanceref res)) (portref (member INMODE 1) (instanceref res)) (portref (member INMODE 0) (instanceref res)) (portref MULTSIGNIN (instanceref res)) (portref (member OPMODE 7) (instanceref res)) (portref (member OPMODE 5) (instanceref res)) (portref (member OPMODE 4) (instanceref res)) (portref (member OPMODE 3) (instanceref res)) (portref (member OPMODE 2) (instanceref res)) (portref (member OPMODE 1) (instanceref res)) (portref (member OPMODE 0) (instanceref res)) (portref (member PCIN 47) (instanceref res)) (portref (member PCIN 37) (instanceref res)) (portref (member PCIN 36) (instanceref res)) (portref (member PCIN 35) (instanceref res)) (portref (member PCIN 34) (instanceref res)) (portref (member PCIN 33) (instanceref res)) (portref (member PCIN 32) (instanceref res)) (portref (member PCIN 31) (instanceref res)) (portref (member PCIN 30) (instanceref res)) (portref (member PCIN 29) (instanceref res)) (portref (member PCIN 28) (instanceref res)) (portref (member PCIN 46) (instanceref res)) (portref (member PCIN 27) (instanceref res)) (portref (member PCIN 26) (instanceref res)) (portref (member PCIN 25) (instanceref res)) (portref (member PCIN 24) (instanceref res)) (portref (member PCIN 23) (instanceref res)) (portref (member PCIN 22) (instanceref res)) (portref (member PCIN 21) (instanceref res)) (portref (member PCIN 20) (instanceref res)) (portref (member PCIN 19) (instanceref res)) (portref (member PCIN 18) (instanceref res)) (portref (member PCIN 45) (instanceref res)) (portref (member PCIN 17) (instanceref res)) (portref (member PCIN 16) (instanceref res)) (portref (member PCIN 15) (instanceref res)) (portref (member PCIN 14) (instanceref res)) (portref (member PCIN 13) (instanceref res)) (portref (member PCIN 12) (instanceref res)) (portref (member PCIN 11) (instanceref res)) (portref (member PCIN 10) (instanceref res)) (portref (member PCIN 9) (instanceref res)) (portref (member PCIN 8) (instanceref res)) (portref (member PCIN 44) (instanceref res)) (portref (member PCIN 7) (instanceref res)) (portref (member PCIN 6) (instanceref res)) (portref (member PCIN 5) (instanceref res)) (portref (member PCIN 4) (instanceref res)) (portref (member PCIN 3) (instanceref res)) (portref (member PCIN 2) (instanceref res)) (portref (member PCIN 1) (instanceref res)) (portref (member PCIN 0) (instanceref res)) (portref (member PCIN 43) (instanceref res)) (portref (member PCIN 42) (instanceref res)) (portref (member PCIN 41) (instanceref res)) (portref (member PCIN 40) (instanceref res)) (portref (member PCIN 39) (instanceref res)) (portref (member PCIN 38) (instanceref res)) (portref RSTA (instanceref res)) (portref RSTALLCARRYIN (instanceref res)) (portref RSTALUMODE (instanceref res)) (portref RSTB (instanceref res)) (portref RSTC (instanceref res)) (portref RSTCTRL (instanceref res)) (portref RSTD (instanceref res)) (portref RSTINMODE (instanceref res)) (portref RSTM (instanceref res)) (portref RSTP (instanceref res)))) (net (rename &_const1_ "") (joined (portref (member OPMODE 8) (instanceref res)) (portref (member OPMODE 6) (instanceref res)) (portref P (instanceref VCC)))) (net GND_2 (joined (portref (member D 26) (instanceref res)) (portref (member D 16) (instanceref res)) (portref (member D 15) (instanceref res)) (portref (member D 14) (instanceref res)) (portref (member D 13) (instanceref res)) (portref (member D 12) (instanceref res)) (portref (member D 11) (instanceref res)) (portref (member D 10) (instanceref res)) (portref (member D 9) (instanceref res)) (portref (member D 8) (instanceref res)) (portref (member D 7) (instanceref res)) (portref (member D 25) (instanceref res)) (portref (member D 6) (instanceref res)) (portref (member D 5) (instanceref res)) (portref (member D 4) (instanceref res)) (portref (member D 3) (instanceref res)) (portref (member D 2) (instanceref res)) (portref (member D 1) (instanceref res)) (portref (member D 0) (instanceref res)) (portref (member D 24) (instanceref res)) (portref (member D 23) (instanceref res)) (portref (member D 22) (instanceref res)) (portref (member D 21) (instanceref res)) (portref (member D 20) (instanceref res)) (portref (member D 19) (instanceref res)) (portref (member D 18) (instanceref res)) (portref (member D 17) (instanceref res)) (portref G (instanceref GND_1)))) (net VCC_2 (joined (portref (member C 47) (instanceref res)) (portref (member C 37) (instanceref res)) (portref (member C 36) (instanceref res)) (portref (member C 35) (instanceref res)) (portref (member C 34) (instanceref res)) (portref (member C 33) (instanceref res)) (portref (member C 32) (instanceref res)) (portref (member C 31) (instanceref res)) (portref (member C 30) (instanceref res)) (portref (member C 29) (instanceref res)) (portref (member C 28) (instanceref res)) (portref (member C 46) (instanceref res)) (portref (member C 27) (instanceref res)) (portref (member C 26) (instanceref res)) (portref (member C 25) (instanceref res)) (portref (member C 24) (instanceref res)) (portref (member C 23) (instanceref res)) (portref (member C 22) (instanceref res)) (portref (member C 21) (instanceref res)) (portref (member C 20) (instanceref res)) (portref (member C 19) (instanceref res)) (portref (member C 18) (instanceref res)) (portref (member C 45) (instanceref res)) (portref (member C 17) (instanceref res)) (portref (member C 16) (instanceref res)) (portref (member C 15) (instanceref res)) (portref (member C 14) (instanceref res)) (portref (member C 13) (instanceref res)) (portref (member C 12) (instanceref res)) (portref (member C 11) (instanceref res)) (portref (member C 10) (instanceref res)) (portref (member C 9) (instanceref res)) (portref (member C 8) (instanceref res)) (portref (member C 44) (instanceref res)) (portref (member C 7) (instanceref res)) (portref (member C 6) (instanceref res)) (portref (member C 5) (instanceref res)) (portref (member C 4) (instanceref res)) (portref (member C 3) (instanceref res)) (portref (member C 2) (instanceref res)) (portref (member C 1) (instanceref res)) (portref (member C 0) (instanceref res)) (portref (member C 43) (instanceref res)) (portref (member C 42) (instanceref res)) (portref (member C 41) (instanceref res)) (portref (member C 40) (instanceref res)) (portref (member C 39) (instanceref res)) (portref (member C 38) (instanceref res)) (portref P (instanceref VCC_1)))) (net (rename a_0_ "a[0]") (joined (portref (member A 29) (instanceref res)) (portref (member a 7)))) (net (rename a_1_ "a[1]") (joined (portref (member A 28) (instanceref res)) (portref (member a 6)))) (net (rename a_2_ "a[2]") (joined (portref (member A 27) (instanceref res)) (portref (member a 5)))) (net (rename a_3_ "a[3]") (joined (portref (member A 26) (instanceref res)) (portref (member a 4)))) (net (rename a_4_ "a[4]") (joined (portref (member A 25) (instanceref res)) (portref (member a 3)))) (net (rename a_5_ "a[5]") (joined (portref (member A 24) (instanceref res)) (portref (member a 2)))) (net (rename a_6_ "a[6]") (joined (portref (member A 23) (instanceref res)) (portref (member a 1)))) (net (rename a_7_ "a[7]") (joined (portref (member A 22) (instanceref res)) (portref (member a 0)))) (net (rename b_0_ "b[0]") (joined (portref (member B 17) (instanceref res)) (portref (member b 7)))) (net (rename b_1_ "b[1]") (joined (portref (member B 16) (instanceref res)) (portref (member b 6)))) (net (rename b_2_ "b[2]") (joined (portref (member B 15) (instanceref res)) (portref (member b 5)))) (net (rename b_3_ "b[3]") (joined (portref (member B 14) (instanceref res)) (portref (member b 4)))) (net (rename b_4_ "b[4]") (joined (portref (member B 13) (instanceref res)) (portref (member b 3)))) (net (rename b_5_ "b[5]") (joined (portref (member B 12) (instanceref res)) (portref (member b 2)))) (net (rename b_6_ "b[6]") (joined (portref (member B 11) (instanceref res)) (portref (member b 1)))) (net (rename b_7_ "b[7]") (joined (portref (member B 10) (instanceref res)) (portref (member b 0)))) (net (rename y_0_ "y[0]") (joined (portref (member P 47) (instanceref res)) (portref (member y 7)))) (net (rename y_1_ "y[1]") (joined (portref (member P 46) (instanceref res)) (portref (member y 6)))) (net (rename y_2_ "y[2]") (joined (portref (member P 45) (instanceref res)) (portref (member y 5)))) (net (rename y_3_ "y[3]") (joined (portref (member P 44) (instanceref res)) (portref (member y 4)))) (net (rename y_4_ "y[4]") (joined (portref (member P 43) (instanceref res)) (portref (member y 3)))) (net (rename y_5_ "y[5]") (joined (portref (member P 42) (instanceref res)) (portref (member y 2)))) (net (rename y_6_ "y[6]") (joined (portref (member P 41) (instanceref res)) (portref (member y 1)))) (net (rename y_7_ "y[7]") (joined (portref (member P 40) (instanceref res)) (portref (member y 0))))) ((property ECO_CHECKSUM (string "2ac8fb58")))))) (design dsp2 (cellref dsp2 (libraryref work)) (property part (string "xczu3eg-sbva484-1-e")))) \ No newline at end of file diff --git a/src/langs/edif/src/edifier/tests/string_helpers_ut.rs b/src/langs/edif/tests/string_helpers_ut.rs similarity index 95% rename from src/langs/edif/src/edifier/tests/string_helpers_ut.rs rename to src/langs/edif/tests/string_helpers_ut.rs index a7057375..10429649 100644 --- a/src/langs/edif/src/edifier/tests/string_helpers_ut.rs +++ b/src/langs/edif/tests/string_helpers_ut.rs @@ -1,4 +1,4 @@ -use edifier::string_helpers::*; +use edif::string_helpers::*; #[test] fn simple_new_lines() { diff --git a/src/langs/edif/src/edifier/tests/unit_tests.rs b/src/langs/edif/tests/unit_tests.rs similarity index 99% rename from src/langs/edif/src/edifier/tests/unit_tests.rs rename to src/langs/edif/tests/unit_tests.rs index 81ecc1df..b90bc867 100644 --- a/src/langs/edif/src/edifier/tests/unit_tests.rs +++ b/src/langs/edif/tests/unit_tests.rs @@ -16,8 +16,8 @@ limitations under the License. //use std::process::Command; //use Edif; -use edifier::ast::*; -use edifier::string_helpers::*; +use edif::ast::*; +use edif::string_helpers::*; /* #[test] diff --git a/src/langs/edif/xilinx_multiplier.edf b/src/langs/edif/xilinx_multiplier.edf deleted file mode 100644 index 57616d83..00000000 --- a/src/langs/edif/xilinx_multiplier.edf +++ /dev/null @@ -1,666 +0,0 @@ -(edif dsp2 - (edifversion 2 0 0) - (edifLevel 0) - (keywordmap - (keywordlevel 0)) - (Library hdi_primitives - (edifLevel 0) - (technology - (numberDefinition)) - (cell GND - (celltype GENERIC) - (view netlist - (viewtype NETLIST) - (interface - (port G - (direction OUTPUT))))) - (cell VCC - (celltype GENERIC) - (view netlist - (viewtype NETLIST) - (interface - (port P - (direction OUTPUT))))) - (cell DSP48E2 - (celltype GENERIC) - (view netlist - (viewtype NETLIST) - (interface - (port CARRYCASCOUT - (direction OUTPUT)) - (port MULTSIGNOUT - (direction OUTPUT)) - (port OVERFLOW - (direction OUTPUT)) - (port PATTERNBDETECT - (direction OUTPUT)) - (port PATTERNDETECT - (direction OUTPUT)) - (port UNDERFLOW - (direction OUTPUT)) - (port CARRYCASCIN - (direction INPUT)) - (port CARRYIN - (direction INPUT)) - (port CEA1 - (direction INPUT)) - (port CEA2 - (direction INPUT)) - (port CEAD - (direction INPUT)) - (port CEALUMODE - (direction INPUT)) - (port CEB1 - (direction INPUT)) - (port CEB2 - (direction INPUT)) - (port CEC - (direction INPUT)) - (port CECARRYIN - (direction INPUT)) - (port CECTRL - (direction INPUT)) - (port CED - (direction INPUT)) - (port CEINMODE - (direction INPUT)) - (port CEM - (direction INPUT)) - (port CEP - (direction INPUT)) - (port CLK - (direction INPUT)) - (port MULTSIGNIN - (direction INPUT)) - (port RSTA - (direction INPUT)) - (port RSTALLCARRYIN - (direction INPUT)) - (port RSTALUMODE - (direction INPUT)) - (port RSTB - (direction INPUT)) - (port RSTC - (direction INPUT)) - (port RSTCTRL - (direction INPUT)) - (port RSTD - (direction INPUT)) - (port RSTINMODE - (direction INPUT)) - (port RSTM - (direction INPUT)) - (port RSTP - (direction INPUT)) - (port - (array - (rename ACOUT "ACOUT[29:0]") 30) - (direction OUTPUT)) - (port - (array - (rename BCOUT "BCOUT[17:0]") 18) - (direction OUTPUT)) - (port - (array - (rename CARRYOUT "CARRYOUT[3:0]") 4) - (direction OUTPUT)) - (port - (array - (rename PCOUT "PCOUT[47:0]") 48) - (direction OUTPUT)) - (port - (array - (rename P "P[47:0]") 48) - (direction OUTPUT)) - (port - (array - (rename XOROUT "XOROUT[7:0]") 8) - (direction OUTPUT)) - (port - (array - (rename ACIN "ACIN[29:0]") 30) - (direction INPUT)) - (port - (array - (rename ALUMODE "ALUMODE[3:0]") 4) - (direction INPUT)) - (port - (array - (rename A "A[29:0]") 30) - (direction INPUT)) - (port - (array - (rename BCIN "BCIN[17:0]") 18) - (direction INPUT)) - (port - (array - (rename B "B[17:0]") 18) - (direction INPUT)) - (port - (array - (rename CARRYINSEL "CARRYINSEL[2:0]") 3) - (direction INPUT)) - (port - (array - (rename C "C[47:0]") 48) - (direction INPUT)) - (port - (array - (rename D "D[26:0]") 27) - (direction INPUT)) - (port - (array - (rename INMODE "INMODE[4:0]") 5) - (direction INPUT)) - (port - (array - (rename OPMODE "OPMODE[8:0]") 9) - (direction INPUT)) - (port - (array - (rename PCIN "PCIN[47:0]") 48) - (direction INPUT))))) - (cell INV - (celltype GENERIC) - (view netlist - (viewtype NETLIST) - (interface - (port I - (direction INPUT)) - (port O - (direction OUTPUT)))))) - (Library work - (edifLevel 0) - (technology - (numberDefinition)) - (cell dsp2 - (celltype GENERIC) - (view dsp2 - (viewtype NETLIST) - (interface - (port - (array - (rename a "a[7:0]") 8) - (direction INPUT)) - (port - (array - (rename b "b[7:0]") 8) - (direction INPUT)) - (port - (array - (rename y "y[7:0]") 8) - (direction OUTPUT))) - (contents - (instance GND - (viewref netlist - (cellref GND (libraryref hdi_primitives)))) - (instance GND_1 - (viewref netlist - (cellref GND (libraryref hdi_primitives)))) - (instance VCC - (viewref netlist - (cellref VCC (libraryref hdi_primitives)))) - (instance VCC_1 - (viewref netlist - (cellref VCC (libraryref hdi_primitives)))) - (instance res - (viewref netlist - (cellref DSP48E2 (libraryref hdi_primitives))) - (property XORSIMD - (string "XOR24_48_96")) - (property USE_WIDEXOR - (string "FALSE")) - (property ACASCREG - (integer 0)) - (property ADREG - (integer 1)) - (property ALUMODEREG - (integer 0)) - (property AMULTSEL - (string "A")) - (property AREG - (integer 0)) - (property AUTORESET_PATDET - (string "NO_RESET")) - (property AUTORESET_PRIORITY - (string "RESET")) - (property A_INPUT - (string "DIRECT")) - (property BCASCREG - (integer 0)) - (property BMULTSEL - (string "B")) - (property BREG - (integer 0)) - (property B_INPUT - (string "DIRECT")) - (property CARRYINREG - (integer 0)) - (property CARRYINSELREG - (integer 0)) - (property CREG - (integer 1)) - (property DREG - (integer 1)) - (property INMODEREG - (integer 0)) - (property MASK - (string "48'h3FFFFFFFFFFF")) - (property METHODOLOGY_DRC_VIOS - (string |"{SYNTH-13\ {cell\ *THIS*}}"|)) - (property MREG - (integer 0)) - (property OPMODEREG - (integer 0)) - (property PATTERN - (string "48'h000000000000")) - (property PREADDINSEL - (string "A")) - (property PREG - (integer 0)) - (property RND - (string "48'h000000000000")) - (property SEL_MASK - (string "MASK")) - (property SEL_PATTERN - (string "PATTERN")) - (property USE_MULT - (string "MULTIPLY")) - (property USE_PATTERN_DETECT - (string "NO_PATDET")) - (property USE_SIMD - (string "ONE48")) - (property OPT_MODIFIED - (string "SWEEP"))) - (net - (rename &_const0_ "") - (joined - (portref (member ACIN 29) (instanceref res)) - (portref (member ACIN 19) (instanceref res)) - (portref (member ACIN 18) (instanceref res)) - (portref (member ACIN 17) (instanceref res)) - (portref (member ACIN 16) (instanceref res)) - (portref (member ACIN 15) (instanceref res)) - (portref (member ACIN 14) (instanceref res)) - (portref (member ACIN 13) (instanceref res)) - (portref (member ACIN 12) (instanceref res)) - (portref (member ACIN 11) (instanceref res)) - (portref (member ACIN 10) (instanceref res)) - (portref (member ACIN 28) (instanceref res)) - (portref (member ACIN 9) (instanceref res)) - (portref (member ACIN 8) (instanceref res)) - (portref (member ACIN 7) (instanceref res)) - (portref (member ACIN 6) (instanceref res)) - (portref (member ACIN 5) (instanceref res)) - (portref (member ACIN 4) (instanceref res)) - (portref (member ACIN 3) (instanceref res)) - (portref (member ACIN 2) (instanceref res)) - (portref (member ACIN 1) (instanceref res)) - (portref (member ACIN 0) (instanceref res)) - (portref (member ACIN 27) (instanceref res)) - (portref (member ACIN 26) (instanceref res)) - (portref (member ACIN 25) (instanceref res)) - (portref (member ACIN 24) (instanceref res)) - (portref (member ACIN 23) (instanceref res)) - (portref (member ACIN 22) (instanceref res)) - (portref (member ACIN 21) (instanceref res)) - (portref (member ACIN 20) (instanceref res)) - (portref (member ALUMODE 3) (instanceref res)) - (portref (member ALUMODE 2) (instanceref res)) - (portref (member ALUMODE 1) (instanceref res)) - (portref (member ALUMODE 0) (instanceref res)) - (portref (member A 19) (instanceref res)) - (portref (member A 18) (instanceref res)) - (portref (member A 17) (instanceref res)) - (portref (member A 16) (instanceref res)) - (portref (member A 15) (instanceref res)) - (portref (member A 14) (instanceref res)) - (portref (member A 13) (instanceref res)) - (portref (member A 12) (instanceref res)) - (portref (member A 11) (instanceref res)) - (portref (member A 10) (instanceref res)) - (portref (member A 9) (instanceref res)) - (portref (member A 8) (instanceref res)) - (portref (member A 7) (instanceref res)) - (portref (member A 6) (instanceref res)) - (portref (member A 5) (instanceref res)) - (portref (member A 4) (instanceref res)) - (portref (member A 3) (instanceref res)) - (portref (member A 2) (instanceref res)) - (portref (member A 1) (instanceref res)) - (portref (member A 0) (instanceref res)) - (portref (member A 21) (instanceref res)) - (portref (member A 20) (instanceref res)) - (portref (member BCIN 17) (instanceref res)) - (portref (member BCIN 7) (instanceref res)) - (portref (member BCIN 6) (instanceref res)) - (portref (member BCIN 5) (instanceref res)) - (portref (member BCIN 4) (instanceref res)) - (portref (member BCIN 3) (instanceref res)) - (portref (member BCIN 2) (instanceref res)) - (portref (member BCIN 1) (instanceref res)) - (portref (member BCIN 0) (instanceref res)) - (portref (member BCIN 16) (instanceref res)) - (portref (member BCIN 15) (instanceref res)) - (portref (member BCIN 14) (instanceref res)) - (portref (member BCIN 13) (instanceref res)) - (portref (member BCIN 12) (instanceref res)) - (portref (member BCIN 11) (instanceref res)) - (portref (member BCIN 10) (instanceref res)) - (portref (member BCIN 9) (instanceref res)) - (portref (member BCIN 8) (instanceref res)) - (portref (member B 7) (instanceref res)) - (portref (member B 6) (instanceref res)) - (portref (member B 5) (instanceref res)) - (portref (member B 4) (instanceref res)) - (portref (member B 3) (instanceref res)) - (portref (member B 2) (instanceref res)) - (portref (member B 1) (instanceref res)) - (portref (member B 0) (instanceref res)) - (portref (member B 9) (instanceref res)) - (portref (member B 8) (instanceref res)) - (portref CARRYCASCIN (instanceref res)) - (portref CARRYIN (instanceref res)) - (portref (member CARRYINSEL 2) (instanceref res)) - (portref (member CARRYINSEL 1) (instanceref res)) - (portref (member CARRYINSEL 0) (instanceref res)) - (portref CEA1 (instanceref res)) - (portref CEA2 (instanceref res)) - (portref CEAD (instanceref res)) - (portref CEALUMODE (instanceref res)) - (portref CEB1 (instanceref res)) - (portref CEB2 (instanceref res)) - (portref CEC (instanceref res)) - (portref CECARRYIN (instanceref res)) - (portref CECTRL (instanceref res)) - (portref CED (instanceref res)) - (portref CEINMODE (instanceref res)) - (portref CEM (instanceref res)) - (portref CEP (instanceref res)) - (portref CLK (instanceref res)) - (portref G (instanceref GND)) - (portref (member INMODE 4) (instanceref res)) - (portref (member INMODE 3) (instanceref res)) - (portref (member INMODE 2) (instanceref res)) - (portref (member INMODE 1) (instanceref res)) - (portref (member INMODE 0) (instanceref res)) - (portref MULTSIGNIN (instanceref res)) - (portref (member OPMODE 7) (instanceref res)) - (portref (member OPMODE 5) (instanceref res)) - (portref (member OPMODE 4) (instanceref res)) - (portref (member OPMODE 3) (instanceref res)) - (portref (member OPMODE 2) (instanceref res)) - (portref (member OPMODE 1) (instanceref res)) - (portref (member OPMODE 0) (instanceref res)) - (portref (member PCIN 47) (instanceref res)) - (portref (member PCIN 37) (instanceref res)) - (portref (member PCIN 36) (instanceref res)) - (portref (member PCIN 35) (instanceref res)) - (portref (member PCIN 34) (instanceref res)) - (portref (member PCIN 33) (instanceref res)) - (portref (member PCIN 32) (instanceref res)) - (portref (member PCIN 31) (instanceref res)) - (portref (member PCIN 30) (instanceref res)) - (portref (member PCIN 29) (instanceref res)) - (portref (member PCIN 28) (instanceref res)) - (portref (member PCIN 46) (instanceref res)) - (portref (member PCIN 27) (instanceref res)) - (portref (member PCIN 26) (instanceref res)) - (portref (member PCIN 25) (instanceref res)) - (portref (member PCIN 24) (instanceref res)) - (portref (member PCIN 23) (instanceref res)) - (portref (member PCIN 22) (instanceref res)) - (portref (member PCIN 21) (instanceref res)) - (portref (member PCIN 20) (instanceref res)) - (portref (member PCIN 19) (instanceref res)) - (portref (member PCIN 18) (instanceref res)) - (portref (member PCIN 45) (instanceref res)) - (portref (member PCIN 17) (instanceref res)) - (portref (member PCIN 16) (instanceref res)) - (portref (member PCIN 15) (instanceref res)) - (portref (member PCIN 14) (instanceref res)) - (portref (member PCIN 13) (instanceref res)) - (portref (member PCIN 12) (instanceref res)) - (portref (member PCIN 11) (instanceref res)) - (portref (member PCIN 10) (instanceref res)) - (portref (member PCIN 9) (instanceref res)) - (portref (member PCIN 8) (instanceref res)) - (portref (member PCIN 44) (instanceref res)) - (portref (member PCIN 7) (instanceref res)) - (portref (member PCIN 6) (instanceref res)) - (portref (member PCIN 5) (instanceref res)) - (portref (member PCIN 4) (instanceref res)) - (portref (member PCIN 3) (instanceref res)) - (portref (member PCIN 2) (instanceref res)) - (portref (member PCIN 1) (instanceref res)) - (portref (member PCIN 0) (instanceref res)) - (portref (member PCIN 43) (instanceref res)) - (portref (member PCIN 42) (instanceref res)) - (portref (member PCIN 41) (instanceref res)) - (portref (member PCIN 40) (instanceref res)) - (portref (member PCIN 39) (instanceref res)) - (portref (member PCIN 38) (instanceref res)) - (portref RSTA (instanceref res)) - (portref RSTALLCARRYIN (instanceref res)) - (portref RSTALUMODE (instanceref res)) - (portref RSTB (instanceref res)) - (portref RSTC (instanceref res)) - (portref RSTCTRL (instanceref res)) - (portref RSTD (instanceref res)) - (portref RSTINMODE (instanceref res)) - (portref RSTM (instanceref res)) - (portref RSTP (instanceref res)))) - (net - (rename &_const1_ "") - (joined - (portref (member OPMODE 8) (instanceref res)) - (portref (member OPMODE 6) (instanceref res)) - (portref P (instanceref VCC)))) - (net GND_2 - (joined - (portref (member D 26) (instanceref res)) - (portref (member D 16) (instanceref res)) - (portref (member D 15) (instanceref res)) - (portref (member D 14) (instanceref res)) - (portref (member D 13) (instanceref res)) - (portref (member D 12) (instanceref res)) - (portref (member D 11) (instanceref res)) - (portref (member D 10) (instanceref res)) - (portref (member D 9) (instanceref res)) - (portref (member D 8) (instanceref res)) - (portref (member D 7) (instanceref res)) - (portref (member D 25) (instanceref res)) - (portref (member D 6) (instanceref res)) - (portref (member D 5) (instanceref res)) - (portref (member D 4) (instanceref res)) - (portref (member D 3) (instanceref res)) - (portref (member D 2) (instanceref res)) - (portref (member D 1) (instanceref res)) - (portref (member D 0) (instanceref res)) - (portref (member D 24) (instanceref res)) - (portref (member D 23) (instanceref res)) - (portref (member D 22) (instanceref res)) - (portref (member D 21) (instanceref res)) - (portref (member D 20) (instanceref res)) - (portref (member D 19) (instanceref res)) - (portref (member D 18) (instanceref res)) - (portref (member D 17) (instanceref res)) - (portref G (instanceref GND_1)))) - (net VCC_2 - (joined - (portref (member C 47) (instanceref res)) - (portref (member C 37) (instanceref res)) - (portref (member C 36) (instanceref res)) - (portref (member C 35) (instanceref res)) - (portref (member C 34) (instanceref res)) - (portref (member C 33) (instanceref res)) - (portref (member C 32) (instanceref res)) - (portref (member C 31) (instanceref res)) - (portref (member C 30) (instanceref res)) - (portref (member C 29) (instanceref res)) - (portref (member C 28) (instanceref res)) - (portref (member C 46) (instanceref res)) - (portref (member C 27) (instanceref res)) - (portref (member C 26) (instanceref res)) - (portref (member C 25) (instanceref res)) - (portref (member C 24) (instanceref res)) - (portref (member C 23) (instanceref res)) - (portref (member C 22) (instanceref res)) - (portref (member C 21) (instanceref res)) - (portref (member C 20) (instanceref res)) - (portref (member C 19) (instanceref res)) - (portref (member C 18) (instanceref res)) - (portref (member C 45) (instanceref res)) - (portref (member C 17) (instanceref res)) - (portref (member C 16) (instanceref res)) - (portref (member C 15) (instanceref res)) - (portref (member C 14) (instanceref res)) - (portref (member C 13) (instanceref res)) - (portref (member C 12) (instanceref res)) - (portref (member C 11) (instanceref res)) - (portref (member C 10) (instanceref res)) - (portref (member C 9) (instanceref res)) - (portref (member C 8) (instanceref res)) - (portref (member C 44) (instanceref res)) - (portref (member C 7) (instanceref res)) - (portref (member C 6) (instanceref res)) - (portref (member C 5) (instanceref res)) - (portref (member C 4) (instanceref res)) - (portref (member C 3) (instanceref res)) - (portref (member C 2) (instanceref res)) - (portref (member C 1) (instanceref res)) - (portref (member C 0) (instanceref res)) - (portref (member C 43) (instanceref res)) - (portref (member C 42) (instanceref res)) - (portref (member C 41) (instanceref res)) - (portref (member C 40) (instanceref res)) - (portref (member C 39) (instanceref res)) - (portref (member C 38) (instanceref res)) - (portref P (instanceref VCC_1)))) - (net - (rename a_0_ "a[0]") - (joined - (portref (member A 29) (instanceref res)) - (portref (member a 7)))) - (net - (rename a_1_ "a[1]") - (joined - (portref (member A 28) (instanceref res)) - (portref (member a 6)))) - (net - (rename a_2_ "a[2]") - (joined - (portref (member A 27) (instanceref res)) - (portref (member a 5)))) - (net - (rename a_3_ "a[3]") - (joined - (portref (member A 26) (instanceref res)) - (portref (member a 4)))) - (net - (rename a_4_ "a[4]") - (joined - (portref (member A 25) (instanceref res)) - (portref (member a 3)))) - (net - (rename a_5_ "a[5]") - (joined - (portref (member A 24) (instanceref res)) - (portref (member a 2)))) - (net - (rename a_6_ "a[6]") - (joined - (portref (member A 23) (instanceref res)) - (portref (member a 1)))) - (net - (rename a_7_ "a[7]") - (joined - (portref (member A 22) (instanceref res)) - (portref (member a 0)))) - (net - (rename b_0_ "b[0]") - (joined - (portref (member B 17) (instanceref res)) - (portref (member b 7)))) - (net - (rename b_1_ "b[1]") - (joined - (portref (member B 16) (instanceref res)) - (portref (member b 6)))) - (net - (rename b_2_ "b[2]") - (joined - (portref (member B 15) (instanceref res)) - (portref (member b 5)))) - (net - (rename b_3_ "b[3]") - (joined - (portref (member B 14) (instanceref res)) - (portref (member b 4)))) - (net - (rename b_4_ "b[4]") - (joined - (portref (member B 13) (instanceref res)) - (portref (member b 3)))) - (net - (rename b_5_ "b[5]") - (joined - (portref (member B 12) (instanceref res)) - (portref (member b 2)))) - (net - (rename b_6_ "b[6]") - (joined - (portref (member B 11) (instanceref res)) - (portref (member b 1)))) - (net - (rename b_7_ "b[7]") - (joined - (portref (member B 10) (instanceref res)) - (portref (member b 0)))) - (net - (rename y_0_ "y[0]") - (joined - (portref (member P 47) (instanceref res)) - (portref (member y 7)))) - (net - (rename y_1_ "y[1]") - (joined - (portref (member P 46) (instanceref res)) - (portref (member y 6)))) - (net - (rename y_2_ "y[2]") - (joined - (portref (member P 45) (instanceref res)) - (portref (member y 5)))) - (net - (rename y_3_ "y[3]") - (joined - (portref (member P 44) (instanceref res)) - (portref (member y 4)))) - (net - (rename y_4_ "y[4]") - (joined - (portref (member P 43) (instanceref res)) - (portref (member y 3)))) - (net - (rename y_5_ "y[5]") - (joined - (portref (member P 42) (instanceref res)) - (portref (member y 2)))) - (net - (rename y_6_ "y[6]") - (joined - (portref (member P 41) (instanceref res)) - (portref (member y 1)))) - (net - (rename y_7_ "y[7]") - (joined - (portref (member P 40) (instanceref res)) - (portref (member y 0))))) - (property ECO_CHECKSUM - (string "2ac8fb58"))))) - (design dsp2 - (cellref dsp2 - (libraryref work)) - (property part - (string "xczu3eg-sbva484-1-e")))) \ No newline at end of file