mirrors/ZLUDA
1
0
Fork 0
mirror of https://github.com/vosen/ZLUDA.git synced 2025-04-19 16:04:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Pass parser state to instruction callbacks

Browse source
This commit is contained in:
Andrzej Janik 2024-08-15 19:30:09 +02:00
parent dbd37f97ad
commit ba17906de8
2 changed files with 21 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
gen/src/lib.rs
View file

@ -383,7 +383,7 @@ fn emit_parse_function(
let code_block = &def.code_block.0;
let args = def.function_arguments_declarations();
quote! {
fn #fn_name<'input>( #(#args),* ) -> Instruction<ParsedOperand<'input>> #code_block
fn #fn_name<'input>(state: &mut PtxParserState, #(#args),* ) -> Instruction<ParsedOperand<'input>> #code_block
}
})
})
@ -473,7 +473,7 @@ fn emit_parse_function(
#(#fns_)*
fn parse_instruction<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> winnow::error::PResult<Instruction<ParsedOperand<'input>>>
fn parse_instruction<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> winnow::error::PResult<Instruction<ParsedOperand<'input>>>
{
use winnow::Parser;
use winnow::token::*;
@ -695,7 +695,7 @@ fn emit_definition_parser(
let fn_args = definition.function_arguments();
let fn_name = format_ident!("{}_{}", opcode, fn_idx);
let fn_call = quote! {
#fn_name( #(#fn_args),* )
#fn_name(&mut stream.state, #(#fn_args),* )
};
quote! {
#(#unordered_parse_declarations)*

35
ptx_parser/src/main.rs
View file

@ -199,9 +199,10 @@ pub struct RetData {
pub uniform: bool,
}
type ParserState<'a, 'input> = Stateful<&'a [Token<'input>], Vec<PtxError>>;
type PtxParserState = Vec<PtxError>;
type PtxParser<'a, 'input> = Stateful<&'a [Token<'input>], PtxParserState>;
fn ident<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<&'input str> {
fn ident<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<&'input str> {
any.verify_map(|t| {
if let Token::Ident(text) = t {
Some(text)
@ -214,7 +215,7 @@ fn ident<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<&'input st
.parse_next(stream)
}
fn num<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<(&'input str, u32, bool)> {
fn num<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<(&'input str, u32, bool)> {
any.verify_map(|t| {
Some(match t {
Token::Hex(s) => {
@ -239,9 +240,9 @@ fn num<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<(&'input str
}
fn take_error<'a, 'input: 'a, O, E>(
mut parser: impl Parser<ParserState<'a, 'input>, Result<O, (O, PtxError)>, E>,
) -> impl Parser<ParserState<'a, 'input>, O, E> {
move |input: &mut ParserState<'a, 'input>| {
mut parser: impl Parser<PtxParser<'a, 'input>, Result<O, (O, PtxError)>, E>,
) -> impl Parser<PtxParser<'a, 'input>, O, E> {
move |input: &mut PtxParser<'a, 'input>| {
Ok(match parser.parse_next(input)? {
Ok(x) => x,
Err((x, err)) => {
@ -252,7 +253,7 @@ fn take_error<'a, 'input: 'a, O, E>(
}
}
fn int_immediate<'a, 'input>(input: &mut ParserState<'a, 'input>) -> PResult<ast::ImmediateValue> {
fn int_immediate<'a, 'input>(input: &mut PtxParser<'a, 'input>) -> PResult<ast::ImmediateValue> {
take_error((opt(Token::Minus), num).map(|(neg, x)| {
let (num, radix, is_unsigned) = x;
if neg.is_some() {
@ -278,7 +279,7 @@ fn int_immediate<'a, 'input>(input: &mut ParserState<'a, 'input>) -> PResult<ast
.parse_next(input)
}
fn f32<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<f32> {
fn f32<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<f32> {
take_error(any.verify_map(|t| match t {
Token::F32(f) => Some(match u32::from_str_radix(&f[2..], 16) {
Ok(x) => Ok(f32::from_bits(x)),
@ -289,7 +290,7 @@ fn f32<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<f32> {
.parse_next(stream)
}
fn f64<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<f64> {
fn f64<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<f64> {
take_error(any.verify_map(|t| match t {
Token::F64(f) => Some(match u64::from_str_radix(&f[2..], 16) {
Ok(x) => Ok(f64::from_bits(x)),
@ -300,7 +301,7 @@ fn f64<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<f64> {
.parse_next(stream)
}
fn s32<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<i32> {
fn s32<'a, 'input>(stream: &mut PtxParser<'a, 'input>) -> PResult<i32> {
take_error((opt(Token::Minus), num).map(|(sign, x)| {
let (text, radix, _) = x;
match i32::from_str_radix(text, radix) {
@ -312,7 +313,7 @@ fn s32<'a, 'input>(stream: &mut ParserState<'a, 'input>) -> PResult<i32> {
}
fn immediate_value<'a, 'input>(
stream: &mut ParserState<'a, 'input>,
stream: &mut PtxParser<'a, 'input>,
) -> PResult<ast::ImmediateValue> {
alt((
int_immediate,
@ -324,7 +325,7 @@ fn immediate_value<'a, 'input>(
impl<Ident> ast::ParsedOperand<Ident> {
fn parse<'a, 'input>(
stream: &mut ParserState<'a, 'input>,
stream: &mut PtxParser<'a, 'input>,
) -> PResult<ast::ParsedOperand<&'input str>> {
use winnow::combinator::*;
use winnow::token::any;
@ -338,7 +339,7 @@ impl<Ident> ast::ParsedOperand<Ident> {
}
}
fn ident_operands<'a, 'input>(
stream: &mut ParserState<'a, 'input>,
stream: &mut PtxParser<'a, 'input>,
) -> PResult<ast::ParsedOperand<&'input str>> {
let main_ident = ident.parse_next(stream)?;
alt((
@ -354,7 +355,7 @@ impl<Ident> ast::ParsedOperand<Ident> {
.parse_next(stream)
}
fn vector_operand<'a, 'input>(
stream: &mut ParserState<'a, 'input>,
stream: &mut PtxParser<'a, 'input>,
) -> PResult<Vec<&'input str>> {
let (_, r1, _, r2) =
(Token::LBracket, ident, Token::Comma, ident).parse_next(stream)?;
@ -565,9 +566,9 @@ derive_parser!(
// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-mov
mov.type d, a => {
Instruction::Mov{
Instruction::Mov {
data: MovDetails::new(type_.into()),
arguments: MovArgs { dst: d, src: a }
arguments: MovArgs { dst: d, src: a },
}
}
.type: ScalarType = { .pred,
@ -704,7 +705,7 @@ fn main() {
);
let tokens = lexer.map(|t| t.unwrap()).collect::<Vec<_>>();
println!("{:?}", &tokens);
let mut stream = ParserState {
let mut stream = PtxParser {
input: &tokens[..],
state: Vec::new(),
};