M-Labs/nac3
M-Labs
/
nac3
8
0
Fork 10
Code Issues 99 Pull Requests 21 Releases Wiki Activity

nac3standalone: compile multiple functions

This commit is contained in:
pca006132 2021-08-27 16:25:59 +08:00
parent 72aebed559
commit 2223c86d9b
3 changed files with 204 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
nac3core/src/codegen/mod.rs
View File

@ -304,7 +304,11 @@ pub fn gen_func<'ctx>(
.fn_type(&params, false)
};
let fn_val = module.add_function(&task.symbol_name, fn_type, None);
let symbol = &task.symbol_name;
let fn_val = module
.get_function(symbol)
.unwrap_or_else(|| module.add_function(symbol, fn_type, None));
let init_bb = context.append_basic_block(fn_val, "init");
builder.position_at_end(init_bb);
let body_bb = context.append_basic_block(fn_val, "body");

1
nac3core/src/toplevel/mod.rs
View File

@ -22,6 +22,7 @@ mod type_annotation;
use type_annotation::*;
mod helper;
#[derive(Clone)]
pub struct FunInstance {
pub body: Vec<Stmt<Option<Type>>>,
pub calls: HashMap<CodeLocation, CallId>,

276
nac3standalone/src/main.rs
View File

@ -1,7 +1,11 @@
use std::fs;
use std::time::SystemTime;
use std::{collections::HashSet, fs};
use inkwell::{OptimizationLevel, passes::{PassManager, PassManagerBuilder}, targets::*};
use inkwell::{
passes::{PassManager, PassManagerBuilder},
targets::*,
OptimizationLevel,
};
use parking_lot::RwLock;
use rustpython_parser::{
ast::{fold::Fold, StmtKind},
@ -12,7 +16,7 @@ use std::{cell::RefCell, collections::HashMap, path::Path, sync::Arc};
use nac3core::{
codegen::{CodeGenTask, WithCall, WorkerRegistry},
symbol_resolver::SymbolResolver,
toplevel::{DefinitionId, TopLevelComposer, TopLevelContext, TopLevelDef},
toplevel::{DefinitionId, FunInstance, TopLevelComposer, TopLevelContext, TopLevelDef},
typecheck::{
type_inferencer::{FunctionData, Inferencer},
typedef::{FunSignature, FuncArg, TypeEnum},
@ -33,25 +37,6 @@ fn main() {
};
let start = SystemTime::now();
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();
let mut unifier = composer.unifier.clone();
@ -67,7 +52,7 @@ fn main() {
ret: primitives.none,
vars: HashMap::new(),
})));
let def_id = top_level.definitions.read().len();
let output_id = top_level.definitions.read().len();
top_level
.definitions
.write()
@ -83,59 +68,179 @@ fn main() {
resolver: None,
})));
// dummy resolver...
let resolver = Arc::new(Box::new(basic_symbol_resolver::Resolver {
id_to_type: [("output".into(), output_fun)].iter().cloned().collect(),
id_to_def: [("output".into(), DefinitionId(def_id))]
.iter()
.cloned()
.collect(),
id_to_type: HashMap::new(),
id_to_def: HashMap::new(),
class_names: Default::default(),
}) as Box<dyn SymbolResolver + Send + Sync>);
let mut functions = HashMap::new();
let threads = ["test"];
let signature = FunSignature {
args: vec![],
ret: primitives.int32,
vars: HashMap::new(),
};
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(),
};
for stmt in parser::parse_program(&program).unwrap().into_iter() {
if let StmtKind::FunctionDef {
name,
body,
args,
returns,
..
} = stmt.node
{
let args = args
.args
.into_iter()
.map(|arg| FuncArg {
name: arg.node.arg.to_string(),
ty: resolver
.parse_type_annotation(
&top_level.definitions.read(),
&mut unifier,
&primitives,
&arg.node
.annotation
.expect("expected type annotation in parameters"),
)
.unwrap(),
default_value: None,
})
.collect();
let ret = returns
.map(|r| {
resolver
.parse_type_annotation(
&top_level.definitions.read(),
&mut unifier,
&primitives,
&r,
)
.unwrap()
})
.unwrap_or(primitives.none);
let signature = FunSignature {
args,
ret,
vars: Default::default(),
};
let fun_ty = unifier.add_ty(TypeEnum::TFunc(RefCell::new(signature.clone())));
let id = top_level.definitions.read().len();
top_level
.definitions
.write()
.push(Arc::new(RwLock::new(TopLevelDef::Function {
name: name.clone(),
signature: fun_ty,
var_id: vec![],
instance_to_stmt: HashMap::new(),
instance_to_symbol: HashMap::new(),
resolver: None,
})));
functions.insert(name, (id, body, signature));
} else {
panic!("unsupported statement type");
}
}
let setup_time = SystemTime::now();
println!(
"Setup time: {}ms",
setup_time.duration_since(start).unwrap().as_millis()
setup_time
.duration_since(start)
.unwrap()
.as_millis()
);
let statements = statements
.into_iter()
.map(|v| inferencer.fold_stmt(v))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let mut identifiers = ["output".to_string()].iter().cloned().collect();
if !inferencer
.check_block(&statements, &mut identifiers)
.unwrap()
{
panic!("expected return");
let mut id_to_def: HashMap<_, _> = functions
.iter()
.map(|(k, v)| (k.clone(), DefinitionId(v.0)))
.collect();
id_to_def.insert("output".into(), DefinitionId(output_id));
let mut id_to_type: HashMap<_, _> = functions
.iter()
.map(|(k, v)| {
(
k.clone(),
unifier.add_ty(TypeEnum::TFunc(RefCell::new(v.2.clone()))),
)
})
.collect();
id_to_type.insert("output".into(), output_fun);
let resolver = Arc::new(Box::new(basic_symbol_resolver::Resolver {
class_names: Default::default(),
id_to_type,
id_to_def,
}) as Box<dyn SymbolResolver + Send + Sync>);
for (_, (id, ast, signature)) in functions.into_iter() {
if let TopLevelDef::Function {
resolver: r,
instance_to_stmt,
..
} = &mut *top_level.definitions.read()[id].write()
{
*r = Some(resolver.clone());
let return_type = if unifier.unioned(primitives.none, signature.ret) {
None
} else {
Some(signature.ret)
};
let mut function_data = FunctionData {
resolver: resolver.clone(),
bound_variables: Vec::new(),
return_type,
};
let mut virtual_checks = Vec::new();
let mut calls = HashMap::new();
let mut identifiers = HashSet::new();
let mut variable_mapping = HashMap::new();
for arg in signature.args.iter() {
identifiers.insert(arg.name.clone());
variable_mapping.insert(arg.name.clone(), arg.ty);
}
let mut inferencer = Inferencer {
top_level: &top_level,
function_data: &mut function_data,
unifier: &mut unifier,
variable_mapping,
primitives: &primitives,
virtual_checks: &mut virtual_checks,
calls: &mut calls,
defined_identifiers: identifiers.clone(),
};
let statements = ast
.into_iter()
.map(|v| inferencer.fold_stmt(v))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let returned = inferencer
.check_block(&statements, &mut identifiers)
.unwrap();
if return_type.is_some() && !returned {
panic!("expected return");
}
instance_to_stmt.insert(
"".to_string(),
FunInstance {
body: statements,
unifier_id: 0,
calls,
subst: Default::default(),
},
);
}
}
let inference_time = SystemTime::now();
println!(
"Type inference time: {}ms",
inference_time
.duration_since(setup_time)
.unwrap()
.as_millis()
);
let top_level = Arc::new(TopLevelContext {
definitions: Arc::new(RwLock::new(std::mem::take(
&mut *top_level.definitions.write(),
@ -146,22 +251,34 @@ fn main() {
)])),
});
let inference_time = SystemTime::now();
println!(
"Type inference time: {}ms",
inference_time.duration_since(setup_time).unwrap().as_millis()
);
let unifier = (unifier.get_shared_unifier(), primitives);
let instance = {
let defs = top_level.definitions.read();
let mut instance = defs[resolver.get_identifier_def("run").unwrap().0].write();
if let TopLevelDef::Function {
instance_to_stmt,
instance_to_symbol,
..
} = &mut *instance
{
instance_to_symbol.insert("".to_string(), "run".to_string());
instance_to_stmt[""].clone()
} else {
unreachable!()
}
};
let signature = FunSignature {
args: vec![],
ret: primitives.int32,
vars: HashMap::new(),
};
let task = CodeGenTask {
subst: Default::default(),
symbol_name: "run".to_string(),
body: statements,
resolver,
unifier,
calls,
body: instance.body,
signature,
resolver,
unifier: top_level.unifiers.read()[instance.unifier_id].clone(),
calls: instance.calls,
};
let f = Arc::new(WithCall::new(Box::new(move |module| {
let codegen_time = SystemTime::now();
@ -172,7 +289,6 @@ fn main() {
.unwrap()
.as_millis()
);
let builder = PassManagerBuilder::create();
builder.set_optimization_level(OptimizationLevel::Aggressive);
let passes = PassManager::create(());
@ -195,6 +311,7 @@ fn main() {
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()
@ -202,9 +319,12 @@ fn main() {
.unwrap()
.as_millis()
);
println!("IR:\n{}", module.print_to_string().to_str().unwrap());
})));
let threads = ["test"];
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")
println!("object file is in mandelbrot.o");
}