cmtc 0.1.2

The cmtc compiler providing cmtir-based passes to generate backends including FIRRTL, SystemVerilog and simulators.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! The passes for the cmtc compiler

#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_mut)]

use indexmap::IndexMap;
use location_macros::workspace_dir;
use petgraph::graph::{DiGraph, NodeIndex};
use petgraph::prelude::StableDiGraph;
use petgraph::visit::EdgeRef;
use slotmap::SecondaryMap;

use std::{
  collections::HashMap,
  path::{Path, PathBuf},
};
use cmtir::utils::{setup_logger, string_match, AutoVec};
use cmtir::{IRDump, OpIO, Print, SlotMap};
use num::Integer;

use std::ops::Sub;

use crate::{IfOp, InstRule, InvokeOp, TimingIntv};

use cmtir as ir;
use cmtir::utils;

use crate::builtin;

mod common;
pub use common::*;

mod test_utils;
pub use test_utils::*;

mod visitor;
pub use visitor::*;

mod set_synth;
pub use set_synth::*;

mod function_inline;
pub use function_inline::*;

mod value_context;
pub use value_context::*;

mod type_infer;
pub use type_infer::*;

mod legal_check;
pub use legal_check::*;

mod methodrel_infer;
pub use methodrel_infer::*;

mod dep_models;
pub use dep_models::*;

mod conflict;
pub use conflict::*;

mod msched;
pub use msched::*;

mod mpart;
pub use mpart::*;

mod delay_resolve;
pub use delay_resolve::*;

mod inline;
pub use inline::*;

mod sched;
pub use sched::*;

mod port_resolve;
pub use port_resolve::*;

mod set_private;
pub use set_private::*;

mod side_effect;
pub use side_effect::*;

mod fsmgen;
pub use fsmgen::*;

mod canonicalize;
pub use canonicalize::*;

mod passthrough;
pub use passthrough::*;

pub fn canonicalize(mut circuit: ir::Circuit) -> Result<ir::Circuit, anyhow::Error> {
  let mut canonicalize_pass = CanonicalizePass::new();
  canonicalize_pass.apply_pass(&mut circuit)?;
  Ok(circuit)
}

pub fn side_effect(mut circuit: ir::Circuit) -> Result<ir::Circuit, anyhow::Error> {
  let mut side_effect_pass = SideEffectPass::new();
  side_effect_pass.apply_pass(&mut circuit)?;
  Ok(circuit)
}

pub fn legal_check(
  mut circuit: ir::Circuit,
) -> Result<ir::Circuit, anyhow::Error> {
  let mut legal_check_pass = LegalCheckPass::new();
  legal_check_pass.apply_pass(&mut circuit)?;
  Ok(circuit)
}

pub fn function_inline(
  mut circuit: ir::Circuit,
) -> Result<ir::Circuit, anyhow::Error> {
  let mut function_inline_pass = FunctionInlinePass::new();
  function_inline_pass.apply_pass(&mut circuit)?;
  Ok(circuit)
}

pub fn type_infer(mut circuit: ir::Circuit) -> Result<ir::Circuit, anyhow::Error> {
  let mut type_infer_pass = TypeInferPass::new();
  type_infer_pass.apply_pass(&mut circuit)?;
  Ok(circuit)
}

pub fn msched(
  mut circuit: ir::Circuit,
) -> Result<(ir::Circuit, MSchedPass), anyhow::Error> {
  let mut msched_pass = MSchedPass::new();
  msched_pass.apply_pass(&mut circuit)?;
  Ok((circuit, msched_pass))
}

pub fn mpart(
  mut circuit: ir::Circuit,
  msched: MSchedPass,
) -> Result<(ir::Circuit, IndexMap<RuleId, Vec<RuleId>>), anyhow::Error> {
  let mut mpart_pass = MPartPass::with(msched);
  mpart_pass.apply_pass(&mut circuit)?;
  Ok((circuit, mpart_pass.rule_derive_table))
}

pub fn all_passes(
  mut circuit: ir::Circuit,
) -> Result<(ir::Circuit, IndexMap<RuleId, Vec<RuleId>>), anyhow::Error> {
  let circuit = type_infer(circuit)?;
  let (circuit, msched) = msched(circuit)?;
  let (circuit, rule_derive_table) = mpart(circuit, msched)?;
  Ok((circuit, rule_derive_table))
}