Extended Berkeley Packet Filter (eBPF) assembler and virtual machine
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

304 lines
3.9 KiB

grammar Assembler;
program
: (labelDefinition | labelDefinition? instruction)+ EOF
;
labelDefinition
: IDENTIFIER ':'
;
label : IDENTIFIER ;
comment
: COMMENT
;
instruction
: aluOperation
| alu64Operation
| byteSwapOperation
| jumpOperation
| jumpConditionalOperation
| callOperation
| exitOperation
| loadOperation
| storeOperation
;
aluOperation
: aluOperator register ',' (register | immediate)
| aluOperator register
;
aluOperator
: ADD32
| SUB32
| MUL32
| DIV32
| MOD32
| AND32
| OR32
| NEG32
| XOR32
| MOV32
| LSH32
| RSH32
| ARSH32
;
ADD32 : A D D '32' ;
SUB32 : S U B '32' ;
MUL32 : M U L '32' ;
DIV32 : D I V '32' ;
MOD32 : M O D '32' ;
AND32 : A N D '32' ;
OR32 : O R '32' ;
NEG32 : N E G '32' ;
XOR32 : X O R '32' ;
MOV32 : M O V '32' ;
LSH32 : L S H '32' ;
RSH32 : R S H '32' ;
ARSH32 : A R S H '32' ;
alu64Operation
: alu64Operator register ',' (register | immediate)
| alu64Operator register
;
alu64Operator
: ADD
| SUB
| MUL
| DIV
| MOD
| AND
| OR
| NEG
| XOR
| MOV
| LSH
| RSH
| ARSH
| LE
| BE
;
ADD : A D D ;
SUB : S U B ;
MUL : M U L ;
DIV : D I V ;
MOD : M O D ;
AND : A N D ;
OR : O R ;
NEG : N E G ;
XOR : X O R ;
MOV : M O V ;
LSH : L S H ;
RSH : R S H ;
ARSH : A R S H ;
byteSwapOperation
: byteSwapOperator register
;
byteSwapOperator
: LE
| BE
;
LE : L E '16'
| L E '32'
| L E '64'
;
BE : B E '16'
| B E '32'
| B E '64'
;
jumpOperation
: jumpOperator '+' number
;
jumpOperator
: JA
;
jumpConditionalOperation
: jumpConditionalOperator register ',' ( register | immediate ) ',' '+' offset
;
jumpConditionalOperator
: JEQ
| JGT
| JGE
| JLT
| JLE
| JSET
| JNE
| JSGT
| JSGE
| JSLT
| JSLE
;
callOperation
: CALL literalNumber
;
exitOperation
: EXIT
;
JA : J A ;
JEQ : J E Q ;
JGT : J G T ;
JGE : J G E ;
JLT : J L T ;
JLE : J L E ;
JSET : J S E T ;
JNE : J N E ;
JSGT : J S G T ;
JSGE : J S G E ;
JSLT : J S L T ;
JSLE : J S L E ;
CALL : C A L L ;
EXIT : E X I T ;
loadOperation
: LDDW register ',' literalNumber
| loadAbsoluteOperator register ',' register ',' immediate
| loadOperator register ',' '[' register '+' offset ']'
;
loadAbsoluteOperator
: LDABSW
| LDABSH
| LDABSB
| LDABSDW
;
loadOperator
: LDXW
| LDXH
| LDXB
| LDXDW
;
LDDW : L D D W ;
LDABSW : L D A B S W ;
LDABSH : L D A B S H ;
LDABSB : L D A B S B ;
LDABSDW : L D A B S D W ;
LDXW : L D X W ;
LDXH : L D X H ;
LDXB : L D X B ;
LDXDW : L D X D W ;
storeOperation
: storeOperator '[' register '+' offset ']' ',' immediate
| storeXOperator '[' register '+' offset ']' ',' register
;
storeOperator
: STW
| STH
| STB
| STDW
;
storeXOperator
: STXW
| STXH
| STXB
| STXDW
;
STW : S T W;
STH : S T H;
STB : S T B;
STDW : S T D W;
STXW : S T X W;
STXH : S T X H;
STXB : S T X B;
STXDW : S T X D W;
number
: NUMBER
;
literalNumber
: ('#' number)
;
offset
: NUMBER
;
immediate
: NUMBER
;
register
: REGISTER
| RAX
| RFP
;
extension
: IDENTIFIER
;
NUMBER
: '0b' [01]+
| '0x' [0-9a-fA-F]+
| '-'? [0-9]+
;
COMMENT
: ';' ~ [\r\n]* -> skip
;
IDENTIFIER
: [._a-zA-Z]+
;
WHITESPACE
: [ \t\r\n]+ -> skip
;
REGISTER
: R [0-9]
| R '10'
;
RAX : R A X ;
RFP : R F P ;
fragment A : ( 'a' | 'A' );
fragment B : ( 'b' | 'B' );
fragment C : ( 'c' | 'C' );
fragment D : ( 'd' | 'D' );
fragment E : ( 'e' | 'E' );
fragment F : ( 'f' | 'F' );
fragment G : ( 'g' | 'G' );
fragment H : ( 'h' | 'H' );
fragment I : ( 'i' | 'I' );
fragment J : ( 'j' | 'J' );
fragment K : ( 'k' | 'K' );
fragment L : ( 'l' | 'L' );
fragment M : ( 'm' | 'M' );
fragment N : ( 'n' | 'N' );
fragment O : ( 'o' | 'O' );
fragment P : ( 'p' | 'P' );
fragment Q : ( 'q' | 'Q' );
fragment R : ( 'r' | 'R' );
fragment S : ( 's' | 'S' );
fragment T : ( 't' | 'T' );
fragment U : ( 'u' | 'U' );
fragment V : ( 'v' | 'V' );
fragment W : ( 'w' | 'W' );
fragment X : ( 'x' | 'X' );
fragment Y : ( 'y' | 'Y' );
fragment Z : ( 'z' | 'Z' );