forked from M-Labs/nac3
1
0
Fork 0
nac3/nac3standalone/src/main.rs

211 lines
6.5 KiB
Rust
Raw Normal View History

2020-12-17 22:20:30 +08:00
use std::fs;
use std::time::SystemTime;
2020-12-17 22:20:30 +08:00
use inkwell::{OptimizationLevel, passes::{PassManager, PassManagerBuilder}, targets::*};
2021-08-19 15:30:52 +08:00
use parking_lot::RwLock;
use rustpython_parser::{
ast::{fold::Fold, StmtKind},
parser,
};
use std::{cell::RefCell, collections::HashMap, path::Path, sync::Arc};
2020-12-17 22:20:30 +08:00
2021-08-19 15:30:52 +08:00
use nac3core::{
codegen::{CodeGenTask, WithCall, WorkerRegistry},
2021-08-25 15:30:36 +08:00
symbol_resolver::SymbolResolver,
toplevel::{DefinitionId, TopLevelComposer, TopLevelContext, TopLevelDef},
2021-08-19 15:30:52 +08:00
typecheck::{
type_inferencer::{FunctionData, Inferencer},
typedef::{FunSignature, FuncArg, TypeEnum},
},
};
2020-12-17 22:20:30 +08:00
2021-08-19 15:30:52 +08:00
mod basic_symbol_resolver;
2020-12-17 22:20:30 +08:00
fn main() {
Target::initialize_all(&InitializationConfig::default());
2020-12-18 22:35:59 +08:00
let program = match fs::read_to_string("mandelbrot.py") {
2020-12-17 22:20:30 +08:00
Ok(program) => program,
2021-08-19 15:30:52 +08:00
Err(err) => {
println!("Cannot open input file: {}", err);
return;
}
2020-12-17 22:20:30 +08:00
};
2021-08-19 15:30:52 +08:00
let start = SystemTime::now();
2021-08-19 15:30:52 +08:00
let statements = match parser::parse_program(&program) {
Ok(mut ast) => {
let first = ast.remove(0);
if let StmtKind::FunctionDef { name, body, .. } = first.node {
if name != "run" {
panic!("Parse error: expected function \"run\" but got {}", name);
}
body
} else {
panic!(
"Parse error: expected function \"run\" but got {:?}",
first.node
);
}
}
Err(err) => {
panic!("Parse error: {}", err);
}
};
let composer = TopLevelComposer::new();
2021-08-19 15:30:52 +08:00
let mut unifier = composer.unifier.clone();
2021-08-25 15:30:36 +08:00
let primitives = composer.primitives_ty;
let top_level = Arc::new(composer.make_top_level_context());
unifier.top_level = Some(top_level.clone());
2021-08-25 15:30:36 +08:00
let output_fun = unifier.add_ty(TypeEnum::TFunc(RefCell::new(FunSignature {
2021-08-19 15:30:52 +08:00
args: vec![FuncArg {
name: "c".into(),
ty: primitives.int32,
default_value: None,
}],
ret: primitives.none,
vars: HashMap::new(),
})));
let def_id = top_level.definitions.read().len();
top_level
.definitions
.write()
.push(Arc::new(RwLock::new(TopLevelDef::Function {
name: "output".into(),
2021-08-25 15:30:36 +08:00
signature: output_fun,
2021-08-19 15:30:52 +08:00
instance_to_stmt: HashMap::new(),
instance_to_symbol: [("".to_string(), "output".to_string())]
.iter()
.cloned()
.collect(),
2021-08-25 15:30:36 +08:00
var_id: Default::default(),
2021-08-19 15:30:52 +08:00
resolver: None,
})));
2021-08-25 15:30:36 +08:00
let resolver = Arc::new(Box::new(basic_symbol_resolver::Resolver {
id_to_type: [("output".into(), output_fun)].iter().cloned().collect(),
2021-08-19 15:30:52 +08:00
id_to_def: [("output".into(), DefinitionId(def_id))]
.iter()
.cloned()
.collect(),
class_names: Default::default(),
2021-08-25 15:30:36 +08:00
}) as Box<dyn SymbolResolver + Send + Sync>);
2021-08-19 15:30:52 +08:00
let threads = ["test"];
let signature = FunSignature {
args: vec![],
ret: primitives.int32,
vars: HashMap::new(),
2020-12-17 22:20:30 +08:00
};
2021-08-19 15:30:52 +08:00
let mut function_data = FunctionData {
resolver: resolver.clone(),
bound_variables: Vec::new(),
return_type: Some(primitives.int32),
};
let mut virtual_checks = Vec::new();
let mut calls = HashMap::new();
let mut inferencer = Inferencer {
top_level: &top_level,
function_data: &mut function_data,
unifier: &mut unifier,
variable_mapping: Default::default(),
primitives: &primitives,
virtual_checks: &mut virtual_checks,
calls: &mut calls,
defined_identifiers: Default::default(),
2021-08-19 15:30:52 +08:00
};
let setup_time = SystemTime::now();
println!(
"Setup time: {}ms",
setup_time.duration_since(start).unwrap().as_millis()
);
2021-08-19 15:30:52 +08:00
let statements = statements
.into_iter()
.map(|v| inferencer.fold_stmt(v))
.collect::<Result<Vec<_>, _>>()
.unwrap();
2021-08-25 15:30:36 +08:00
let mut identifiers = ["output".to_string()].iter().cloned().collect();
2021-08-27 11:39:36 +08:00
if !inferencer
2021-08-19 15:30:52 +08:00
.check_block(&statements, &mut identifiers)
.unwrap()
{
2021-08-27 11:39:36 +08:00
panic!("expected return");
}
2021-08-19 15:30:52 +08:00
let top_level = Arc::new(TopLevelContext {
definitions: Arc::new(RwLock::new(std::mem::take(
&mut *top_level.definitions.write(),
))),
unifiers: Arc::new(RwLock::new(vec![(
unifier.get_shared_unifier(),
2021-08-25 15:30:36 +08:00
primitives,
2021-08-19 15:30:52 +08:00
)])),
});
2021-08-25 15:30:36 +08:00
let inference_time = SystemTime::now();
println!(
"Type inference time: {}ms",
inference_time.duration_since(setup_time).unwrap().as_millis()
);
2021-08-25 15:30:36 +08:00
let unifier = (unifier.get_shared_unifier(), primitives);
2021-08-19 15:30:52 +08:00
let task = CodeGenTask {
subst: Default::default(),
symbol_name: "run".to_string(),
body: statements,
resolver,
2021-08-25 15:30:36 +08:00
unifier,
2021-08-19 15:30:52 +08:00
calls,
signature,
};
let f = Arc::new(WithCall::new(Box::new(move |module| {
let codegen_time = SystemTime::now();
println!(
"Code generation time: {}ms",
codegen_time
.duration_since(inference_time)
.unwrap()
.as_millis()
);
let builder = PassManagerBuilder::create();
builder.set_optimization_level(OptimizationLevel::Aggressive);
let passes = PassManager::create(());
builder.populate_module_pass_manager(&passes);
passes.run_on(module);
2021-08-19 15:30:52 +08:00
let triple = TargetMachine::get_default_triple();
let target =
Target::from_triple(&triple).expect("couldn't create target from target triple");
let target_machine = target
.create_target_machine(
&triple,
"",
"",
OptimizationLevel::Default,
RelocMode::Default,
CodeModel::Default,
)
.expect("couldn't create target machine");
target_machine
.write_to_file(module, FileType::Object, Path::new("mandelbrot.o"))
.expect("couldn't write module to file");
println!(
"LLVM time: {}ms",
SystemTime::now()
.duration_since(codegen_time)
.unwrap()
.as_millis()
);
2021-08-19 15:30:52 +08:00
})));
let (registry, handles) = WorkerRegistry::create_workers(&threads, top_level, f);
registry.add_task(task);
registry.wait_tasks_complete(handles);
println!("object file is in mandelbrot.o")
2020-12-17 22:20:30 +08:00
}