mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2026-05-22 02:18:10 +02:00
66dd248593
Although it's kind-of similar to "(rptN)" in the shader ISA, I called it "xmov" to make it clear that it's completely orthogonal to "(rep)", although you certainly can use both modifiers on the same instruction. Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6368>
266 lines
7.3 KiB
Text
266 lines
7.3 KiB
Text
/*
|
|
* Copyright (c) 2013 Rob Clark <robclark@freedesktop.org>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
%{
|
|
#define YYDEBUG 0
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include "asm.h"
|
|
|
|
|
|
int yyget_lineno(void);
|
|
|
|
#ifdef YYDEBUG
|
|
int yydebug;
|
|
#endif
|
|
|
|
extern int yylex(void);
|
|
typedef void *YY_BUFFER_STATE;
|
|
extern YY_BUFFER_STATE yy_scan_string(const char *);
|
|
extern void yy_delete_buffer(YY_BUFFER_STATE);
|
|
|
|
int yyparse(void);
|
|
|
|
void yyerror(const char *error);
|
|
void yyerror(const char *error)
|
|
{
|
|
fprintf(stderr, "error at line %d: %s\n", yyget_lineno(), error);
|
|
}
|
|
|
|
static struct asm_instruction *instr; /* current instruction */
|
|
|
|
static void
|
|
new_instr(int tok)
|
|
{
|
|
instr = next_instr(tok);
|
|
}
|
|
|
|
static void
|
|
dst(int num)
|
|
{
|
|
instr->dst = num;
|
|
}
|
|
|
|
static void
|
|
src1(int num)
|
|
{
|
|
instr->src1 = num;
|
|
}
|
|
|
|
static void
|
|
src2(int num)
|
|
{
|
|
instr->src2 = num;
|
|
}
|
|
|
|
static void
|
|
immed(int num)
|
|
{
|
|
instr->immed = num;
|
|
instr->has_immed = true;
|
|
}
|
|
|
|
static void
|
|
shift(int num)
|
|
{
|
|
instr->shift = num;
|
|
instr->has_shift = true;
|
|
}
|
|
|
|
static void
|
|
bit(int num)
|
|
{
|
|
instr->bit = num;
|
|
instr->has_bit = true;
|
|
}
|
|
|
|
static void
|
|
literal(uint32_t num)
|
|
{
|
|
instr->literal = num;
|
|
instr->is_literal = true;
|
|
}
|
|
|
|
static void
|
|
label(const char *str)
|
|
{
|
|
instr->label = str;
|
|
}
|
|
|
|
%}
|
|
|
|
%union {
|
|
int tok;
|
|
uint32_t num;
|
|
const char *str;
|
|
}
|
|
|
|
%token <num> T_INT
|
|
%token <num> T_HEX
|
|
%token <num> T_CONTROL_REG
|
|
%token <str> T_LABEL_DECL
|
|
%token <str> T_LABEL_REF
|
|
%token <num> T_LITERAL
|
|
%token <num> T_BIT
|
|
%token <num> T_REGISTER
|
|
|
|
%token <tok> T_OP_NOP
|
|
%token <tok> T_OP_ADD
|
|
%token <tok> T_OP_ADDHI
|
|
%token <tok> T_OP_SUB
|
|
%token <tok> T_OP_SUBHI
|
|
%token <tok> T_OP_AND
|
|
%token <tok> T_OP_OR
|
|
%token <tok> T_OP_XOR
|
|
%token <tok> T_OP_NOT
|
|
%token <tok> T_OP_SHL
|
|
%token <tok> T_OP_USHR
|
|
%token <tok> T_OP_ISHR
|
|
%token <tok> T_OP_ROT
|
|
%token <tok> T_OP_MUL8
|
|
%token <tok> T_OP_MIN
|
|
%token <tok> T_OP_MAX
|
|
%token <tok> T_OP_CMP
|
|
%token <tok> T_OP_MSB
|
|
%token <tok> T_OP_MOV
|
|
%token <tok> T_OP_CWRITE
|
|
%token <tok> T_OP_CREAD
|
|
%token <tok> T_OP_STORE
|
|
%token <tok> T_OP_LOAD
|
|
%token <tok> T_OP_BRNE
|
|
%token <tok> T_OP_BREQ
|
|
%token <tok> T_OP_RET
|
|
%token <tok> T_OP_IRET
|
|
%token <tok> T_OP_CALL
|
|
%token <tok> T_OP_JUMP
|
|
%token <tok> T_OP_WAITIN
|
|
%token <tok> T_OP_PREEMPTLEAVE
|
|
%token <tok> T_OP_SETSECURE
|
|
%token <tok> T_LSHIFT
|
|
%token <tok> T_REP
|
|
%token <num> T_XMOV
|
|
|
|
%type <num> reg
|
|
%type <num> immediate
|
|
|
|
%error-verbose
|
|
|
|
%start instrs
|
|
|
|
%%
|
|
|
|
instrs: instr_or_label instrs
|
|
| instr_or_label
|
|
|
|
instr_or_label: instr_r
|
|
| T_REP instr_r { instr->rep = true; }
|
|
| branch_instr
|
|
| other_instr
|
|
| T_LABEL_DECL { decl_label($1); }
|
|
|
|
/* instructions that can optionally have (rep) flag: */
|
|
instr_r: alu_instr
|
|
| T_XMOV alu_instr { instr->xmov = $1; }
|
|
| config_instr
|
|
|
|
/* need to special case:
|
|
* - not (single src, possibly an immediate)
|
|
* - msb (single src, must be reg)
|
|
* - mov (single src, plus possibly a shift)
|
|
* from the other ALU instructions:
|
|
*/
|
|
|
|
alu_msb_instr: T_OP_MSB reg ',' reg { new_instr($1); dst($2); src2($4); }
|
|
|
|
alu_not_instr: T_OP_NOT reg ',' reg { new_instr($1); dst($2); src2($4); }
|
|
| T_OP_NOT reg ',' immediate { new_instr($1); dst($2); immed($4); }
|
|
|
|
alu_mov_instr: T_OP_MOV reg ',' reg { new_instr($1); dst($2); src1($4); }
|
|
| T_OP_MOV reg ',' immediate T_LSHIFT immediate {
|
|
new_instr($1); dst($2); immed($4); shift($6);
|
|
}
|
|
| T_OP_MOV reg ',' immediate { new_instr($1); dst($2); immed($4); }
|
|
| T_OP_MOV reg ',' T_LABEL_REF T_LSHIFT immediate {
|
|
new_instr($1); dst($2); label($4); shift($6);
|
|
}
|
|
| T_OP_MOV reg ',' T_LABEL_REF { new_instr($1); dst($2); label($4); }
|
|
|
|
alu_2src_op: T_OP_ADD { new_instr($1); }
|
|
| T_OP_ADDHI { new_instr($1); }
|
|
| T_OP_SUB { new_instr($1); }
|
|
| T_OP_SUBHI { new_instr($1); }
|
|
| T_OP_AND { new_instr($1); }
|
|
| T_OP_OR { new_instr($1); }
|
|
| T_OP_XOR { new_instr($1); }
|
|
| T_OP_SHL { new_instr($1); }
|
|
| T_OP_USHR { new_instr($1); }
|
|
| T_OP_ISHR { new_instr($1); }
|
|
| T_OP_ROT { new_instr($1); }
|
|
| T_OP_MUL8 { new_instr($1); }
|
|
| T_OP_MIN { new_instr($1); }
|
|
| T_OP_MAX { new_instr($1); }
|
|
| T_OP_CMP { new_instr($1); }
|
|
|
|
alu_2src_instr: alu_2src_op reg ',' reg ',' reg { dst($2); src1($4); src2($6); }
|
|
| alu_2src_op reg ',' reg ',' immediate { dst($2); src1($4); immed($6); }
|
|
|
|
alu_instr: alu_2src_instr
|
|
| alu_msb_instr
|
|
| alu_not_instr
|
|
| alu_mov_instr
|
|
|
|
config_op: T_OP_CWRITE { new_instr($1); }
|
|
| T_OP_CREAD { new_instr($1); }
|
|
| T_OP_LOAD { new_instr($1); }
|
|
| T_OP_STORE { new_instr($1); }
|
|
|
|
config_instr: config_op reg ',' '[' reg '+' immediate ']' ',' immediate {
|
|
src1($2); src2($5); immed($7); bit($10);
|
|
}
|
|
|
|
branch_op: T_OP_BRNE { new_instr($1); }
|
|
| T_OP_BREQ { new_instr($1); }
|
|
|
|
branch_instr: branch_op reg ',' T_BIT ',' T_LABEL_REF { src1($2); bit($4); label($6); }
|
|
| branch_op reg ',' immediate ',' T_LABEL_REF { src1($2); immed($4); label($6); }
|
|
|
|
other_instr: T_OP_CALL T_LABEL_REF { new_instr($1); label($2); }
|
|
| T_OP_PREEMPTLEAVE T_LABEL_REF { new_instr($1); label($2); }
|
|
| T_OP_SETSECURE reg ',' T_LABEL_REF { new_instr($1); src1($2); label($4); }
|
|
| T_OP_RET { new_instr($1); }
|
|
| T_OP_IRET { new_instr($1); }
|
|
| T_OP_JUMP T_LABEL_REF { new_instr($1); label($2); }
|
|
| T_OP_WAITIN { new_instr($1); }
|
|
| T_OP_NOP { new_instr($1); }
|
|
| T_LITERAL { new_instr($1); literal($1); }
|
|
|
|
reg: T_REGISTER
|
|
|
|
immediate: T_HEX
|
|
| T_INT
|
|
| T_CONTROL_REG
|
|
| T_CONTROL_REG '+' immediate { $$ = $1 + $3; }
|
|
|