itycodes
/
shaderc
1
0
Fork 2
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Compare commits

base: itycodes:master
Branches Tags
itycodes:master
MinekPo1:fork-avery/master
MinekPo1:master
..
compare: MinekPo1:fork-avery/master
Branches Tags
MinekPo1:fork-avery/master
MinekPo1:master
itycodes:master

No commits in common. 'master' and 'fork-avery/master' have entirely different histories.
master ... fork-avery

8 changed files with 202 additions and 677 deletions
Show Stats

528
src/compiler/backend/mod.rs
Unescape View File

@ -2,12 +2,10 @@
mod tests;
use crate::compiler::{
AddressingModel, BuiltinDecoration, Decoration, ExecutionMode, ExecutionModel, Instruction,
MemoryModel, Module, StorageClass,
AddressingModel, ExecutionMode, ExecutionModel, MemoryModel, Module, StorageClass,
};
use std::fmt;
use crate::parser::Ast;
use std::fmt::Write;
#[derive(Debug, PartialEq, Clone)]
pub enum Type {
@ -44,43 +42,48 @@ pub fn parse_type(typ: &String) -> Type {
// So, *v4f32i is a pointer to a vector of 4 floats, with the storage class Input.
// *v4f32o is a pointer to a vector of 4 floats, with the storage class Output.
let mut chars = typ.chars();
match chars.next() {
Some('<') => {
let c = typ.chars().next().unwrap();
match c {
'<' => {
assert_eq!(typ.as_str(), "<>");
Type::Void
}
Some('*') => {
let mut typ = chars.collect::<String>();
let storage_class = match typ.pop() {
Some('i') => StorageClass::Input,
Some('o') => StorageClass::Output,
'*' => {
let mut chars = typ.chars();
chars.next();
let typ = chars.collect::<String>();
let storage_class = match typ.chars().last().unwrap() {
'i' => StorageClass::Input,
'o' => StorageClass::Output,
_ => panic!("Invalid storage class"),
};
let typ = typ.chars().take(typ.len() - 1).collect::<String>();
Type::Pointer(Box::new(parse_type(&typ)), storage_class)
}
Some('v') => {
let size = chars.next().map(|s| s.to_digit(10)).flatten().unwrap();
'v' => {
let mut chars = typ.chars();
chars.next();
let size = chars.next().unwrap().to_digit(10).unwrap();
let typ = chars.collect::<String>();
Type::Vector(Box::new(parse_type(&typ)), size)
}
Some('f') => {
let size = chars.collect::<String>().parse().unwrap();
'f' => {
let size = typ.chars().skip(1).collect::<String>().parse().unwrap();
Type::Float(size)
}
Some('s') => {
let size = chars.collect::<String>().parse().unwrap();
's' => {
let size = typ.chars().skip(1).collect::<String>().parse().unwrap();
Type::Int(size)
}
Some('u') => {
let size = chars.collect::<String>().parse().unwrap();
'u' => {
let size = typ.chars().skip(1).collect::<String>().parse().unwrap();
Type::Unsigned(size)
}
_ => panic!("Invalid type"),
}
}
fn emit_type(typ: &Type, ops: &mut Vec<(String, String)>) {
fn emit_type(typ: Type, ops: &mut Vec<(String, String)>) {
match &typ {
Type::Void => {
ops.push(("%void".to_string(), "OpTypeVoid".to_string()));
@ -104,14 +107,18 @@ fn emit_type(typ: &Type, ops: &mut Vec<(String, String)>) {
));
}
Type::Vector(in_typ, size) => {
emit_type(in_typ, ops);
emit_type(*in_typ.clone(), ops);
ops.push((
fix_name(&typ.to_string()),
format!("OpTypeVector {} {}", fix_name(&in_typ.to_string()), size),
format!(
"OpTypeVector {} {}",
fix_name(&in_typ.clone().to_string()),
size
),
))
}
Type::Pointer(in_typ, storage_class) => {
emit_type(in_typ, ops);
emit_type(*in_typ.clone(), ops);
let typ_id = fix_name(&typ.to_string());
let storage_class = match storage_class {
StorageClass::Input => "Input",
@ -130,23 +137,27 @@ fn emit_type(typ: &Type, ops: &mut Vec<(String, String)>) {
}
}
fn fix_name(name: &str) -> String {
fn fix_name(name: &String) -> String {
format!(
"%{}",
name.replace("-", "_")
name.clone()
.replace("-", "_")
.replace("*", "p")
.replace("<>", "void")
.replace(".", "_")
)
}
fn has_id<T>(name: &str, ops: &Vec<(Option<String>, T)>) -> bool {
ops.iter()
.find(|op| op.0.as_ref().map(|s| *s == name).unwrap_or(false))
.is_some()
fn has_id(name: String, ops: &Vec<(Option<String>, Vec<String>)>) -> bool {
for op in ops {
if op.0.is_some() && op.0.clone().unwrap() == name {
return true;
}
}
false
}
pub fn spirv_meta(module: &mut Module) -> Vec<(Option<String>, Vec<String>)> {
pub fn spirv_meta(module: Module) -> String {
let mut spirv_asm = String::new();
let mut ops: Vec<(Option<String>, Vec<String>)> = Vec::new();
let capabilities: Vec<String> = module
@ -179,7 +190,7 @@ pub fn spirv_meta(module: &mut Module) -> Vec<(Option<String>, Vec<String>)> {
],
));
for entry in module.entry_points.clone() {
for entry in module.entry_points {
let exec_model = match entry.execution_model {
ExecutionModel::Fragment => "Fragment",
ExecutionModel::Vertex => "Vertex",
@ -212,25 +223,8 @@ pub fn spirv_meta(module: &mut Module) -> Vec<(Option<String>, Vec<String>)> {
],
));
}
for global in module.globals.clone() {
let name: String = fix_name(&global.name);
for dec in global.decorations {
// Decorations have the format Location 0, or Builtin FragCoord
let dec = match dec {
crate::compiler::Decoration::Location(loc) => format!("Location {}", loc),
crate::compiler::Decoration::BuiltIn(builtin) => {
let builtin = match builtin {
crate::compiler::BuiltinDecoration::FragCoord => "FragCoord",
};
format!("BuiltIn {}", builtin)
}
};
ops.push((None, vec!["OpDecorate".to_string(), name.clone(), dec]));
}
}
for global in module.globals.clone() {
for global in module.globals {
let name = fix_name(&global.name);
let typ = global.typ;
let storage_class = match global.storage_class {
@ -239,9 +233,9 @@ pub fn spirv_meta(module: &mut Module) -> Vec<(Option<String>, Vec<String>)> {
StorageClass::Undefined => panic!("Bound a non-declared variable"),
};
let mut type_ops = Vec::new();
emit_type(&parse_type(&typ), &mut type_ops);
emit_type(parse_type(&typ), &mut type_ops);
for op in type_ops {
if has_id(&op.0, &ops) {
if has_id(op.0.clone(), &ops) {
continue;
}
ops.push((Some(op.0), vec![op.1]));
@ -254,419 +248,47 @@ pub fn spirv_meta(module: &mut Module) -> Vec<(Option<String>, Vec<String>)> {
storage_class.to_string(),
],
));
for dec in global.decorations {
// Decorations have the format Location 0, or Builtin FragCoord
let dec = match dec {
crate::compiler::Decoration::Location(loc) => format!("Location {}", loc),
crate::compiler::Decoration::BuiltIn(builtin) => {
let builtin = match builtin {
crate::compiler::BuiltinDecoration::FragCoord => "FragCoord",
};
format!("BuiltIn {}", builtin)
}
};
ops.push((None, vec!["OpDecorate".to_string(), name.clone(), dec]));
}
}
for fun in module.functions.clone() {
let name = fix_name(&format!("l_{}", fun.name));
for fun in module.functions {
let name = fix_name(&fun.name);
let return_type = fix_name(&fun.return_type);
let mut type_ops = Vec::new();
emit_type(&parse_type(&fun.return_type), &mut type_ops);
emit_type(parse_type(&fun.return_type), &mut type_ops);
for op in type_ops {
if has_id(&op.0, &ops) {
if has_id(op.0.clone(), &ops) {
continue;
}
ops.push((Some(op.0), vec![op.1]));
}
// Push OpFunctionType
ops.push((Some(name), vec!["OpTypeFunction".to_string(), return_type]));
}
// for op in ops {
// if op.0.is_some() {
// write!(spirv_asm, "{} = ", op.0.unwrap()).unwrap();
// }
// for arg in op.1 {
// write!(spirv_asm, "{} ", arg).unwrap();
// }
// writeln!(spirv_asm).unwrap();
// }
// spirv_asm
ops
}
enum Number {
Int(i32),
Float(f32),
NotANumber,
}
fn match_number(s: &str) -> Number {
// floats have to be in the format of [0-9]+\.[0-9]*
// integers have to be in the format of [0-9]+
let mut chars = s.chars();
let mut has_dot = false;
while let Some(c) = chars.next() {
if c == '.' {
if has_dot {
// only one dot allowed.
return Number::NotANumber;
}
has_dot = true;
} else if !c.is_digit(10) {
// not a number;
// has a character that is not a digit or a dot.
return Number::NotANumber;
}
}
if has_dot {
// we have checked that the whole thing is numbers and dots
// and that there is precisely one dot
// that matches the regex.
Number::Float(s.parse().unwrap())
} else {
// this is an integer, since no dots.
Number::Int(s.parse().unwrap())
}
}
fn compile_biop(
op: &str,
lst: &mut Vec<Ast>,
vars: &mut Vec<(String, String)>,
constants: &mut Vec<(String, String)>,
types: &mut Vec<String>,
counter: &mut i32,
stack: &mut Vec<String>,
out: &mut Vec<(Option<String>, String)>,
typ: &str,
) {
assert!(lst.len() == 2);
let rhs = lst.pop().unwrap();
let lhs = lst.pop().unwrap();
compile_ast_ssa(lhs, vars, constants, types, counter, stack, out);
compile_ast_ssa(rhs, vars, constants, types, counter, stack, out);
let rhs_id = stack.pop().unwrap();
let lhs_id = stack.pop().unwrap();
let id = String::from(counter.to_string());
*counter += 1;
out.push((
Some(id.clone()),
format!(
"{} {} {} {}",
op,
fix_name(&String::from(typ)),
fix_name(&lhs_id),
fix_name(&rhs_id),
),
));
stack.push(id);
}
fn compile_comp_constr(
lst: &mut Vec<Ast>,
vars: &mut Vec<(String, String)>,
constants: &mut Vec<(String, String)>,
types: &mut Vec<String>,
counter: &mut i32,
stack: &mut Vec<String>,
out: &mut Vec<(Option<String>, String)>,
typ: &str,
) {
types.push(String::from(typ));
let typ_parsed = parse_type(&String::from(typ));
match typ_parsed {
Type::Vector(_, size) => {
assert!(lst.len() == size as usize);
let mut inners: Vec<String> = vec![];
for _ in 0..size {
let ast = lst.pop().unwrap();
compile_ast_ssa(ast, vars, constants, types, counter, stack, out);
let res_id = stack.pop().unwrap();
inners.push(res_id);
}
let id = String::from(counter.to_string());
*counter += 1;
let mut out_str = String::new();
out_str.push_str(
format!("OpCompositeConstruct {}", fix_name(&String::from(typ))).as_str(),
);
inners.reverse();
for inn in inners {
out_str.push_str(format!(" {}", fix_name(&inn)).as_str());
}
out.push((Some(id.clone()), out_str));
stack.push(id);
}
_ => {
panic!("Invalid vector!")
}
}
}
fn compile_comp_extract(
lst: &mut Vec<Ast>,
vars: &mut Vec<(String, String)>,
constants: &mut Vec<(String, String)>,
types: &mut Vec<String>,
counter: &mut i32,
stack: &mut Vec<String>,
out: &mut Vec<(Option<String>, String)>,
typ: &str,
inx: u32,
) {
assert!(lst.len() == 1);
let vec = lst.pop().unwrap();
compile_ast_ssa(vec, vars, constants, types, counter, stack, out);
let vec_id = stack.pop().unwrap();
let id = counter.to_string();
*counter += 1;
out.push((
Some(id.clone()),
format!(
"OpCompositeExtract {} {} {}",
fix_name(&String::from(typ)),
fix_name(&vec_id),
inx
),
));
stack.push(id);
}
pub fn compile_ast_ssa(
ast: Ast,
vars: &mut Vec<(String, String)>,
constants: &mut Vec<(String, String)>,
types: &mut Vec<String>,
counter: &mut i32,
stack: &mut Vec<String>,
out: &mut Vec<(Option<String>, String)>,
) {
match ast.clone().list() {
Some(mut lst) => {
assert!(!lst.is_empty());
let fun = lst.remove(0);
assert!(true); // no safe remove, thanks Rust
let fun_name = fun.symbol();
assert!(fun_name.is_some());
let fun_name = fun_name.unwrap();
if fun_name.starts_with(".") {
let to_split = &fun_name[1..fun_name.len()];
let split = to_split.split("-").collect::<Vec<&str>>();
assert!(split.len() == 2);
let inx = split[0];
let typ = split[1];
let inx = str::parse::<u32>(inx).expect("Invalid index!");
compile_comp_extract(
&mut lst, vars, constants, types, counter, stack, out, typ, inx,
);
return;
}
if fun_name.starts_with("/") {
let typ = &fun_name[1..fun_name.len()];
compile_biop(
"OpFDiv", &mut lst, vars, constants, types, counter, stack, out, typ,
);
return;
}
if fun_name.starts_with("*") {
let typ = &fun_name[1..fun_name.len()];
compile_biop(
"OpFMul", &mut lst, vars, constants, types, counter, stack, out, typ,
);
return;
}
if fun_name.starts_with("+") {
let typ = &fun_name[1..fun_name.len()];
compile_biop(
"OpFAdd", &mut lst, vars, constants, types, counter, stack, out, typ,
);
return;
}
if fun_name.starts_with("-") {
let typ = &fun_name[1..fun_name.len()];
compile_biop(
"OpFSub", &mut lst, vars, constants, types, counter, stack, out, typ,
);
return;
}
if fun_name.starts_with("v") {
compile_comp_constr(
&mut lst,
vars,
constants,
types,
counter,
stack,
out,
fun_name.as_str(),
);
return;
}
if fun_name.starts_with("load-ptr-") {
let typ = &fun_name[9..fun_name.len()];
assert!(lst.len() == 1);
let ptr = lst.pop().unwrap();
compile_ast_ssa(ptr, vars, constants, types, counter, stack, out);
let ptr_id = stack.pop().unwrap();
let id: String = counter.to_string();
*counter += 1;
out.push((
Some(id.clone()),
format!(
"OpLoad {} {}",
fix_name(&String::from(typ)),
fix_name(&ptr_id)
),
));
stack.push(id);
return;
}
match fun_name.as_str() {
"store-ptr" => {
assert!(lst.len() == 2);
let val = lst.pop().unwrap();
let ptr = lst.pop().unwrap();
compile_ast_ssa(val, vars, constants, types, counter, stack, out);
compile_ast_ssa(ptr, vars, constants, types, counter, stack, out);
let val_id = stack.pop().unwrap();
let ptr_id = stack.pop().unwrap();
out.push((
None,
format!("OpStore {} {}", fix_name(&val_id), fix_name(&ptr_id)),
));
}
s => {
panic!(
"Unknown function: {} with params {:#?} in context:\n{:#?}",
s, lst, ast
);
}
}
}
None => {
let sym = ast.symbol().expect("This must be a symbol");
match match_number(&sym) {
Number::Int(i) => {
let key = format!("i32_{}", i);
let mut contains = false;
for c in constants.iter() {
if c.0 == key {
contains = true;
}
}
if !contains {
constants.push((key.clone(), format!("OpConstant %i32 {}", i.to_string())));
}
stack.push(key);
}
Number::Float(f) => {
let key = format!("f32_{}", f);
let mut contains = false;
for c in constants.iter() {
if c.0 == key {
contains = true;
}
}
if !contains {
constants.push((key.clone(), format!("OpConstant %f32 {}", f.to_string())));
}
for t in types.iter() {
if t == "f32" {
contains = true;
}
}
if !contains {
types.push("f32".to_string());
}
stack.push(key);
}
Number::NotANumber => {
for v in vars.iter() {
if v.0 == sym {
stack.push(v.0.clone());
return;
}
}
panic!("Unknown variable or constant: {}", sym);
}
}
}
ops.push((
Some(name.clone()),
vec!["OpTypeFunction".to_string(), return_type.clone()],
));
}
}
pub fn compile_fun_ssa(module: &mut Module, ops: &Vec<(Option<String>, String)>) {
let mut label_counter = Box::new(0);
for fun in module.functions.iter_mut() {
assert!(fun.ast.is_some());
let ast = fun.ast.as_mut().unwrap();
let block = ast.clone().list().unwrap().get(0).unwrap().clone();
let mut vars = vec![];
let mut constants = vec![];
let mut types = vec![];
let mut counter = Box::new(0);
let mut stack = vec![];
let mut out_op = vec![];
for v in &module.globals {
vars.push((v.name.clone(), v.typ.clone()));
for op in ops {
if op.0.is_some() {
write!(spirv_asm, "{} = ", op.0.unwrap()).unwrap();
}
compile_ast_ssa(
block,
&mut vars,
&mut constants,
&mut types,
&mut counter,
&mut stack,
&mut out_op,
);
let mut out_pre = vec![];
for t in &types {
let typ = parse_type(t);
if has_id(&fix_name(&typ.to_string()), ops) {
continue;
}
if has_id(&fix_name(&typ.to_string()), &out_pre) {
continue;
}
let mut type_ops = vec![];
emit_type(&typ, &mut type_ops);
for type_op in type_ops {
out_pre.push((Some(type_op.0), type_op.1));
}
}
for c in &constants {
out_pre.push((Some(fix_name(&c.0.clone())), c.1.clone()));
}
// TODO non-void type
out_pre.push((
Some(fix_name(&fun.name)),
format!("OpFunction %void None %l_{}", fun.name),
));
out_pre.push((
Some(format!("%n_{}", label_counter.to_string())),
"OpLabel".to_string(),
));
*label_counter += 1;
let mut out_ops = out_pre.clone();
for op in out_op {
if op.0.is_some() {
out_ops.push((Some(fix_name(&op.0.unwrap())), op.1));
} else {
out_ops.push((None, op.1));
}
}
out_ops.push((None, String::from("OpReturn")));
out_ops.push((None, String::from("OpFunctionEnd")));
for op in out_ops {
let split: Vec<String> = op.1.split(" ").map(|s| s.to_string()).collect();
let op_name: String = (&split[0]).clone();
let op_args: Vec<String> = split[1..].iter().map(|s| s.clone()).collect();
let op_id = op.0.clone();
let ins: Instruction = Instruction {
result_id: op_id,
op: op_name,
operands: op_args,
};
fun.body.as_mut().unwrap().push(ins);
for arg in op.1 {
write!(spirv_asm, "{} ", arg).unwrap();
}
writeln!(spirv_asm).unwrap();
}
spirv_asm
}

167
src/compiler/backend/tests.rs
Unescape View File

@ -12,17 +12,16 @@ fn test_emit() {
(dec out-color:*v4f32o Output)
(entry main Fragment OriginUpperLeft (:frag-coord :out-color))
(fun (main) :<>
(store-ptr out-color
(store-ptr (out-color)
(v4f32i (/ (.xy (load-ptr frag-coord))
(v2f32 1920.0 1080.0))
1.0
1.0)))
";
let ast = parse(tokenize(src));
let mut module = meta_compile(ast.unwrap()).unwrap();
let res = spirv_meta(&mut module);
println!("{:#?}", res);
// TODO add an assert
let module = meta_compile(ast.unwrap()).unwrap();
let res = spirv_meta(module);
println!("{}", res);
}
#[test]
@ -50,161 +49,3 @@ fn test_type_parse() {
assert_eq!(parse_type(&"f32".to_string()), Float(32));
assert_eq!(parse_type(&"s32".to_string()), Int(32));
}
#[test]
fn test_block_ssa() {
use crate::compiler::backend::*;
use crate::compiler::*;
use crate::parser::*;
let src = "
(module Shader Logical GLSL450)
(import :std GLSL.std.450)
(bind (out-color:*f32o) (Location 0))
(dec out-color:*f32o Output)
(entry main Fragment OriginUpperLeft (:out-color))
(fun (main) :<>
(store-ptr out-color (/f32 1.0 (+f32 1.0 1.0))))
";
let ast = parse(tokenize(src));
let mut module = meta_compile(ast.unwrap()).unwrap();
let fun = module.functions.pop().unwrap();
let block = fun.ast.unwrap();
let block = block.list().unwrap().get(0).unwrap().clone();
println!("{:#?}", block);
let mut vars = vec![];
let mut constants = vec![];
let mut types = vec![];
let mut counter = Box::new(0);
let mut stack = vec![];
let mut out = vec![];
for v in &module.globals {
vars.push((v.name.clone(), v.typ.clone()));
}
compile_ast_ssa(
block,
&mut vars,
&mut constants,
&mut types,
&mut counter,
&mut stack,
&mut out,
);
println!("\n---vars:---\n{:#?}\n-----------", vars);
println!("\n---constants:---\n{:#?}\n----------------", constants);
println!("\n---types:---\n{:#?}\n------------", types);
println!("\n---stack:---\n{:#?}\n------------", stack);
println!("\n---counter:---\n{}\n--------------", counter);
println!("\n---out:---");
for (a, b) in &out {
match a {
Some(a) => println!("%{} = {}", a, b),
None => println!("{}", b),
}
}
println!("----------");
assert!(stack.is_empty());
}
#[test]
fn test_fun_ssa() {
use crate::compiler::backend::*;
use crate::compiler::*;
use crate::parser::*;
let src = "
(module Shader Logical GLSL450)
(import :std GLSL.std.450)
(bind (out-color:*f32o) (Location 0))
(dec out-color:*f32o Output)
(entry main Fragment OriginUpperLeft (:out-color))
(fun (main) :<>
(store-ptr out-color (/f32 1.0 (+f32 1.0 1.0))))
";
let ast = parse(tokenize(src));
let mut module = meta_compile(ast.unwrap()).unwrap();
let ops = vec![];
compile_fun_ssa(&mut module, &ops);
let res = module.functions.pop().unwrap();
let res = res.body.unwrap();
println!("{:#?}", res);
// TODO we need to unify the place where we call fix_name
let res_spv: Vec<Instruction> = vec![
Instruction {
result_id: Some("%f32".to_string()),
op: "OpTypeFloat".to_string(),
operands: vec!["32".to_string()],
},
Instruction {
result_id: Some("%f32_1".to_string()),
op: "OpConstant".to_string(),
operands: vec!["%f32".to_string(), "1".to_string()],
},
Instruction {
result_id: Some("%main".to_string()),
op: "OpFunction".to_string(),
operands: vec![
"%void".to_string(),
"None".to_string(),
"%l_main".to_string(),
],
},
Instruction {
result_id: Some("%n_0".to_string()),
op: "OpLabel".to_string(),
operands: vec![],
},
Instruction {
result_id: Some("%0".to_string()),
op: "OpFAdd".to_string(),
operands: vec![
"%f32".to_string(),
"%f32_1".to_string(),
"%f32_1".to_string(),
],
},
Instruction {
result_id: Some("%1".to_string()),
op: "OpFDiv".to_string(),
operands: vec!["%f32".to_string(), "%f32_1".to_string(), "%0".to_string()],
},
Instruction {
result_id: None,
op: "OpStore".to_string(),
operands: vec!["%out_color".to_string(), "%1".to_string()],
},
Instruction {
result_id: None,
op: "OpReturn".to_string(),
operands: vec![],
},
Instruction {
result_id: None,
op: "OpFunctionEnd".to_string(),
operands: vec![],
},
];
assert_eq!(res, res_spv);
}
#[test]
fn test_fun_ssa_vec() {
use crate::compiler::backend::*;
use crate::compiler::*;
use crate::parser::*;
let src = "
(module Shader Logical GLSL450)
(import :std GLSL.std.450)
(bind (out-color:*v4f32o) (Location 0))
(dec out-color:*v4f32o Output)
(entry main Fragment OriginUpperLeft (:out-color))
(fun (main) :<>
(store-ptr out-color (v4f32 1.0 1.0 0.0 1.0)))
";
let ast = parse(tokenize(src));
let mut module = meta_compile(ast.unwrap()).unwrap();
let ops = vec![];
compile_fun_ssa(&mut module, &ops);
let res = module.functions.pop().unwrap();
let res = res.body.unwrap();
println!("{:#?}", res);
println!("{:#?}", module)
}

2
src/compiler/meta_compile.rs
Unescape View File

@ -194,7 +194,7 @@ pub fn compile_fun<I: Iterator<Item = Ast>>(
};
let fun = Function {
name: name.to_string(),
return_type,
return_type: return_type,
arguments: vec![],
body: Some(vec![]),
ast: Some(Ast::List(Localised {

118
src/main.rs
Unescape View File

@ -1,26 +1,31 @@
use compiler::{
backend::{compile_fun_ssa, spirv_meta},
meta_compile,
};
use compiler::{backend::spirv_meta, meta_compile};
use error::print_error;
use std::{env, fs, path::PathBuf, process::ExitCode};
use std::{env, fs, path::PathBuf};
use parser::parse_string;
use parser::{parse_string, tokenize, Token};
pub mod compiler;
mod error;
pub mod parser;
#[derive(Debug, Default, PartialEq)]
enum Trace {
Tokens,
AST,
#[default] Normal
}
#[derive(Debug, Default)]
struct CompilerArgs {
input: Option<PathBuf>,
output: Option<PathBuf>,
trace: Trace,
print_help: bool,
print_version: bool,
}
const SPIRV_VERSION: &'static str = "1.0";
fn main() -> ExitCode {
fn main() {
let args = parse_args();
if args.print_version || args.print_help {
if args.print_help {
@ -29,78 +34,59 @@ fn main() -> ExitCode {
if args.print_version {
print_version();
}
return ExitCode::FAILURE;
return;
}
let Some(input) = args.input else {
eprintln!("No input specified");
return ExitCode::FAILURE;
return;
};
let output = args.output.unwrap_or(PathBuf::from("./out.spvas"));
let output = args.output.unwrap_or(PathBuf::from("./out.spv"));
let src = match fs::read_to_string(input) {
Ok(i) => i,
Err(e) => {
eprintln!("{e}");
return ExitCode::FAILURE;
return;
}
};
if args.trace == Trace::Tokens {
let tokens = tokenize(&src);
for tok in tokens {
match tok.item {
Token::LeftParen => println!("{:>3}:{:<3} LeftParen",tok.location.line_start(), tok.location.col_start()),
Token::RightParen => println!("{:>3}:{:<3} RightParen",tok.location.line_start(), tok.location.col_start()),
Token::Symbol( val ) => println!("{:>3}:{:<3} Symbol `{}`",tok.location.line_start(), tok.location.col_start(), val)
}
}
return;
}
let ast = match parse_string(&src) {
Ok(i) => i,
Err(e) => {
print_error(e, Some(&src));
return ExitCode::FAILURE;
return;
}
};
if args.trace == Trace::AST {
ast.pretty_print(None,None);
return;
}
let mut module = match meta_compile(ast) {
let module = match meta_compile(ast) {
Ok(m) => m,
Err(e) => {
print_error(e, Some(&src));
return ExitCode::FAILURE;
return;
}
};
use std::fmt::Write;
let ops_split_params = spirv_meta(&mut module);
let mut ops_merged_param = vec![];
for op in ops_split_params.clone() {
ops_merged_param.push((op.0, op.1.join(" ")));
}
compile_fun_ssa(&mut module, &ops_merged_param);
let mut res = String::new();
for op in ops_split_params {
if op.0.is_some() {
write!(res, "{} = ", op.0.unwrap()).unwrap();
}
for arg in op.1 {
write!(res, "{} ", arg).unwrap();
}
writeln!(res).unwrap();
}
for fun in module.functions.iter() {
// TODO non-void type
for inst in fun.body.clone().unwrap().iter() {
if let Some(id) = inst.result_id.as_ref() {
write!(res, "{} = ", id).unwrap();
}
write!(res, "{}", inst.op).unwrap();
for op in inst.operands.iter() {
write!(res, " {}", op).unwrap();
}
writeln!(res).unwrap();
}
}
let res = spirv_meta(module);
fs::write(output, res).unwrap();
ExitCode::SUCCESS
}
fn parse_args() -> CompilerArgs {
@ -149,6 +135,36 @@ fn parse_args() -> CompilerArgs {
return parsed_args;
}
}
"trace" => {
if parsed_args.trace == Trace::Normal {
let Some(output) = args.next() else {
parsed_args.print_help = true;
eprintln!("trace needs a file");
eprintln!();
return parsed_args;
};
match output.as_str() {
"ast" | "AST" | "Ast" => {
parsed_args.trace = Trace::AST;
}
"token" | "tokens" => {
parsed_args.trace = Trace::Tokens;
}
a => {
eprintln!("unknown trace value {a}");
eprintln!();
parsed_args.print_help = true;
return parsed_args;
}
}
} else {
eprintln!("trace can be passed only once");
eprintln!();
parsed_args.print_help = true;
return parsed_args;
}
}
a => {
eprintln!("unknown arg --{a}");
eprintln!();
@ -239,7 +255,7 @@ fn print_help() {
println!("\t\tThe shader to be parsed and compiled, manadory argument");
println!();
println!("\t-o --output:");
println!("\t\tWhere to output the compiled spirv assembly to, default: out.spvas");
println!("\t\tWhere to output the compiled spirv assembly to, default: out.spv");
println!();
println!("\t-h --help:");
println!("\t\tPrint this and exit");

32
src/parser/mod.rs
Unescape View File

@ -148,13 +148,6 @@ impl Ast {
}
}
pub fn list(self) -> Option<Vec<Ast>> {
match self {
Ast::List(Localised { item, .. }) => Some(item),
_ => None,
}
}
pub fn location(&self) -> &Location {
match self {
Ast::Symbol(Localised { location, .. }) => location,
@ -162,6 +155,31 @@ impl Ast {
Ast::Root(_) => &Location::All,
}
}
pub fn pretty_print(&self, prefix: Option<&String>, body_prefix: Option<&String>) {
let empty_string_to_make_rust_happy = &String::from("");
let prefix_ = prefix.unwrap_or(&empty_string_to_make_rust_happy);
let body_prefix_ = body_prefix.unwrap_or(&empty_string_to_make_rust_happy);
match self {
Ast::Symbol(Localised { item, location }) => {
println!("{} Symbol `{}` ({}:{})", prefix_, item, location.line_start(), location.col_start());
},
Ast::List(Localised { item, location }) => {
println!("{} List ({}:{})", prefix_, location.line_start(), location.col_start());
for i in 0..item.len()-1 {
item[i].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ├─ "))), Some(&(body_prefix_.to_owned() + &String::from(" │ "))));
}
item[item.len()-1].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ╰─ "))), Some(&(body_prefix_.to_owned() + &String::from(" "))));
},
Ast::Root( items ) => {
println!("{} Root", prefix_);
for i in 0..items.len()-2 {
items[i].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ├─ "))), Some(&(body_prefix_.to_owned() + &String::from(" │ "))));
}
items[items.len()-1].pretty_print(Some(&(body_prefix_.to_owned() + &String::from(" ╰─ "))), Some(&(body_prefix_.to_owned() + &String::from(" "))));
},
}
}
}
pub fn tokenize(input: &str) -> Vec<Localised<Token>> {

6
src/parser/tests.rs
Unescape View File

@ -44,7 +44,7 @@ fn test_parse() {
(dec out-color:*v4f32o Output)
(entry main Fragment OriginUpperLeft (:frag-coord :out-color))
(fun (main) :<>
(store-ptr out-color
(store-ptr (out-color)
(v4f32i (/ (.xy (load-ptr frag-coord))
(v2f32 1920.0 1080.0))
1.0
@ -111,7 +111,9 @@ fn test_parse() {
Ast::Symbol(Localised::dummy_location(":<>".to_string())),
Ast::List(Localised::dummy_location(vec![
Ast::Symbol(Localised::dummy_location("store-ptr".to_string())),
Ast::Symbol(Localised::dummy_location("out-color".to_string())),
Ast::List(Localised::dummy_location(vec![Ast::Symbol(
Localised::dummy_location("out-color".to_string()),
)])),
Ast::List(Localised::dummy_location(vec![
Ast::Symbol(Localised::dummy_location("v4f32i".to_string())),
Ast::List(Localised::dummy_location(vec![

14
test.sdr
Unescape View File

@ -0,0 +1,14 @@
(module Shader Logical GLSL450)
(import :std GLSL.std.450)
(bind (frag-coord:*v4f32i) (BuiltIn FragCoord))
(bind (out-color:*v4f32o) (Location 0))
(dec frag-coord:*v4f32i Input)
(decr out-color:*v4f32o Output)
(entry main Fragment OriginUpperLeft (:frag-coord :out-color))
(fun (main)
(store-ptr (out-color)
(v4f32i (/ (.xy (load-ptr frag-coord))
(v2f32 1920.0 1080.0))
1.0
1.0)))

12
test.spv
Unescape View File

@ -0,0 +1,12 @@
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main" %frag_coord %out_color
OpExecutionMode %main OriginUpperLeft
%f32 = OpTypeFloat 32
%v4f32 = OpTypeVector %f32 4
%pv4f32i = OpTypePointer Input %v4f32
%frag_coord = OpVariable %pv4f32i Input
OpDecorate %frag_coord BuiltIn FragCoord
%pv4f32o = OpTypePointer Output %v4f32
%out_color = OpVariable %pv4f32o Output
OpDecorate %out_color Location 0
Write Preview
Loading…
Cancel
Save