|
|
@ -8,15 +8,19 @@ use work.decode_types.all;
|
|
|
|
|
|
|
|
|
|
|
|
entity decode1 is
|
|
|
|
entity decode1 is
|
|
|
|
port (
|
|
|
|
port (
|
|
|
|
clk : in std_ulogic;
|
|
|
|
clk : in std_ulogic;
|
|
|
|
|
|
|
|
rst : in std_ulogic;
|
|
|
|
|
|
|
|
|
|
|
|
f_in : in Fetch2ToDecode1Type;
|
|
|
|
stall_in : in std_ulogic;
|
|
|
|
d_out : out Decode1ToDecode2Type
|
|
|
|
flush_in : in std_ulogic;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
f_in : in Fetch2ToDecode1Type;
|
|
|
|
|
|
|
|
d_out : out Decode1ToDecode2Type
|
|
|
|
);
|
|
|
|
);
|
|
|
|
end entity decode1;
|
|
|
|
end entity decode1;
|
|
|
|
|
|
|
|
|
|
|
|
architecture behaviour of decode1 is
|
|
|
|
architecture behaviour of decode1 is
|
|
|
|
signal f : Fetch2ToDecode1Type := Fetch2ToDecode1Init;
|
|
|
|
signal r, rin : Decode1ToDecode2Type;
|
|
|
|
|
|
|
|
|
|
|
|
type decode_rom_array_t is array(ppc_insn_t) of decode_rom_t;
|
|
|
|
type decode_rom_array_t is array(ppc_insn_t) of decode_rom_t;
|
|
|
|
|
|
|
|
|
|
|
@ -218,9 +222,6 @@ architecture behaviour of decode1 is
|
|
|
|
PPC_XOR => (ALU, OP_XOR, RS, RB, NONE, RA, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', RC, '0', '1'),
|
|
|
|
PPC_XOR => (ALU, OP_XOR, RS, RB, NONE, RA, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', RC, '0', '1'),
|
|
|
|
PPC_XORI => (ALU, OP_XOR, RS, CONST_UI, NONE, RA, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
PPC_XORI => (ALU, OP_XOR, RS, CONST_UI, NONE, RA, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
PPC_XORIS => (ALU, OP_XOR, RS, CONST_UI_HI, NONE, RA, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
PPC_XORIS => (ALU, OP_XOR, RS, CONST_UI_HI, NONE, RA, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
PPC_SIM_READ => (ALU, OP_SIM_READ, NONE, NONE, NONE, RT, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
|
|
|
|
PPC_SIM_POLL => (ALU, OP_SIM_POLL, NONE, NONE, NONE, RT, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
|
|
|
|
PPC_SIM_WRITE => (ALU, OP_SIM_WRITE, RS, NONE, NONE, NONE, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
|
|
|
|
PPC_SIM_CONFIG => (ALU, OP_SIM_CONFIG,NONE, NONE, NONE, RT, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
PPC_SIM_CONFIG => (ALU, OP_SIM_CONFIG,NONE, NONE, NONE, RT, NONE, NONE, NONE, '0', '0', '0', '0', NONE, '0', '0', '0', '0', '0', '0', NONE, '0', '1'),
|
|
|
|
|
|
|
|
|
|
|
|
others => decode_rom_init
|
|
|
|
others => decode_rom_init
|
|
|
@ -230,610 +231,607 @@ begin
|
|
|
|
decode1_0: process(clk)
|
|
|
|
decode1_0: process(clk)
|
|
|
|
begin
|
|
|
|
begin
|
|
|
|
if rising_edge(clk) then
|
|
|
|
if rising_edge(clk) then
|
|
|
|
f <= f_in;
|
|
|
|
-- Output state remains unchanged on stall, unless we are flushing
|
|
|
|
|
|
|
|
if rst = '1' or flush_in = '1' or stall_in = '0' then
|
|
|
|
|
|
|
|
r <= rin;
|
|
|
|
|
|
|
|
end if;
|
|
|
|
end if;
|
|
|
|
end if;
|
|
|
|
end process;
|
|
|
|
end process;
|
|
|
|
|
|
|
|
|
|
|
|
decode1_1: process(all)
|
|
|
|
decode1_1: process(all)
|
|
|
|
|
|
|
|
variable v : Decode1ToDecode2Type;
|
|
|
|
variable ppc_insn: ppc_insn_t;
|
|
|
|
variable ppc_insn: ppc_insn_t;
|
|
|
|
begin
|
|
|
|
begin
|
|
|
|
d_out <= Decode1ToDecode2Init;
|
|
|
|
v := r;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
v.valid := f_in.valid;
|
|
|
|
|
|
|
|
|
|
|
|
ppc_insn := PPC_ILLEGAL;
|
|
|
|
ppc_insn := PPC_ILLEGAL;
|
|
|
|
|
|
|
|
|
|
|
|
d_out.valid <= f.valid;
|
|
|
|
if f_in.valid then
|
|
|
|
|
|
|
|
v.nia := f_in.nia;
|
|
|
|
|
|
|
|
v.insn := f_in.insn;
|
|
|
|
|
|
|
|
|
|
|
|
if f.valid then
|
|
|
|
report "Decode insn " & to_hstring(f_in.insn) & " at " & to_hstring(f_in.nia);
|
|
|
|
d_out.nia <= f.nia;
|
|
|
|
|
|
|
|
d_out.insn <= f.insn;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
report "Decode insn " & to_hstring(f.insn);
|
|
|
|
if std_match(f_in.insn, "011111---------------0100001010-") then
|
|
|
|
if std_match(f.insn, "011111---------------0100001010-") then
|
|
|
|
|
|
|
|
report "PPC_add";
|
|
|
|
report "PPC_add";
|
|
|
|
ppc_insn := PPC_ADD;
|
|
|
|
ppc_insn := PPC_ADD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000001010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000001010-") then
|
|
|
|
report "PPC_addc";
|
|
|
|
report "PPC_addc";
|
|
|
|
ppc_insn := PPC_ADDC;
|
|
|
|
ppc_insn := PPC_ADDC;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010001010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010001010-") then
|
|
|
|
report "PPC_adde";
|
|
|
|
report "PPC_adde";
|
|
|
|
ppc_insn := PPC_ADDE;
|
|
|
|
ppc_insn := PPC_ADDE;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010101010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010101010-") then
|
|
|
|
report "PPC_addex";
|
|
|
|
report "PPC_addex";
|
|
|
|
ppc_insn := PPC_ADDEX;
|
|
|
|
ppc_insn := PPC_ADDEX;
|
|
|
|
elsif std_match(f.insn, "001110--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001110--------------------------") then
|
|
|
|
report "PPC_addi";
|
|
|
|
report "PPC_addi";
|
|
|
|
ppc_insn := PPC_ADDI;
|
|
|
|
ppc_insn := PPC_ADDI;
|
|
|
|
elsif std_match(f.insn, "001100--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001100--------------------------") then
|
|
|
|
report "PPC_addic";
|
|
|
|
report "PPC_addic";
|
|
|
|
ppc_insn := PPC_ADDIC;
|
|
|
|
ppc_insn := PPC_ADDIC;
|
|
|
|
elsif std_match(f.insn, "001101--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001101--------------------------") then
|
|
|
|
report "PPC_addic.";
|
|
|
|
report "PPC_addic.";
|
|
|
|
ppc_insn := PPC_ADDIC_RC;
|
|
|
|
ppc_insn := PPC_ADDIC_RC;
|
|
|
|
elsif std_match(f.insn, "001111--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001111--------------------------") then
|
|
|
|
report "PPC_addis";
|
|
|
|
report "PPC_addis";
|
|
|
|
ppc_insn := PPC_ADDIS;
|
|
|
|
ppc_insn := PPC_ADDIS;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011101010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011101010-") then
|
|
|
|
report "PPC_addme";
|
|
|
|
report "PPC_addme";
|
|
|
|
ppc_insn := PPC_ADDME;
|
|
|
|
ppc_insn := PPC_ADDME;
|
|
|
|
elsif std_match(f.insn, "010011--------------------00010-") then
|
|
|
|
elsif std_match(f_in.insn, "010011--------------------00010-") then
|
|
|
|
report "PPC_addpcis";
|
|
|
|
report "PPC_addpcis";
|
|
|
|
ppc_insn := PPC_ADDPCIS;
|
|
|
|
ppc_insn := PPC_ADDPCIS;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011001010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011001010-") then
|
|
|
|
report "PPC_addze";
|
|
|
|
report "PPC_addze";
|
|
|
|
ppc_insn := PPC_ADDZE;
|
|
|
|
ppc_insn := PPC_ADDZE;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000011100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000011100-") then
|
|
|
|
report "PPC_and";
|
|
|
|
report "PPC_and";
|
|
|
|
ppc_insn := PPC_AND;
|
|
|
|
ppc_insn := PPC_AND;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000111100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000111100-") then
|
|
|
|
report "PPC_andc";
|
|
|
|
report "PPC_andc";
|
|
|
|
ppc_insn := PPC_ANDC;
|
|
|
|
ppc_insn := PPC_ANDC;
|
|
|
|
elsif std_match(f.insn, "011100--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "011100--------------------------") then
|
|
|
|
report "PPC_andi.";
|
|
|
|
report "PPC_andi.";
|
|
|
|
ppc_insn := PPC_ANDI_RC;
|
|
|
|
ppc_insn := PPC_ANDI_RC;
|
|
|
|
elsif std_match(f.insn, "011101--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "011101--------------------------") then
|
|
|
|
report "PPC_andis.";
|
|
|
|
report "PPC_andis.";
|
|
|
|
ppc_insn := PPC_ANDIS_RC;
|
|
|
|
ppc_insn := PPC_ANDIS_RC;
|
|
|
|
elsif std_match(f.insn, "000000---------------0100000000-") then
|
|
|
|
elsif std_match(f_in.insn, "000000---------------0100000000-") then
|
|
|
|
report "PPC_attn";
|
|
|
|
report "PPC_attn";
|
|
|
|
ppc_insn := PPC_ATTN;
|
|
|
|
ppc_insn := PPC_ATTN;
|
|
|
|
elsif std_match(f.insn, "010010------------------------0-") then
|
|
|
|
elsif std_match(f_in.insn, "010010------------------------0-") then
|
|
|
|
report "PPC_b";
|
|
|
|
report "PPC_b";
|
|
|
|
ppc_insn := PPC_B;
|
|
|
|
ppc_insn := PPC_B;
|
|
|
|
elsif std_match(f.insn, "010010------------------------1-") then
|
|
|
|
elsif std_match(f_in.insn, "010010------------------------1-") then
|
|
|
|
report "PPC_ba";
|
|
|
|
report "PPC_ba";
|
|
|
|
ppc_insn := PPC_BA;
|
|
|
|
ppc_insn := PPC_BA;
|
|
|
|
elsif std_match(f.insn, "010000------------------------0-") then
|
|
|
|
elsif std_match(f_in.insn, "010000------------------------0-") then
|
|
|
|
report "PPC_bc";
|
|
|
|
report "PPC_bc";
|
|
|
|
ppc_insn := PPC_BC;
|
|
|
|
ppc_insn := PPC_BC;
|
|
|
|
elsif std_match(f.insn, "010000------------------------10") then
|
|
|
|
elsif std_match(f_in.insn, "010000------------------------10") then
|
|
|
|
report "PPC_bca";
|
|
|
|
report "PPC_bca";
|
|
|
|
ppc_insn := PPC_BCA;
|
|
|
|
ppc_insn := PPC_BCA;
|
|
|
|
elsif std_match(f.insn, "010011---------------1000010000-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------1000010000-") then
|
|
|
|
report "PPC_bcctr";
|
|
|
|
report "PPC_bcctr";
|
|
|
|
ppc_insn := PPC_BCCTR;
|
|
|
|
ppc_insn := PPC_BCCTR;
|
|
|
|
elsif std_match(f.insn, "010000------------------------11") then
|
|
|
|
elsif std_match(f_in.insn, "010000------------------------11") then
|
|
|
|
report "PPC_bcla";
|
|
|
|
report "PPC_bcla";
|
|
|
|
ppc_insn := PPC_BCLA;
|
|
|
|
ppc_insn := PPC_BCLA;
|
|
|
|
elsif std_match(f.insn, "010011---------------0000010000-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0000010000-") then
|
|
|
|
report "PPC_bclr";
|
|
|
|
report "PPC_bclr";
|
|
|
|
ppc_insn := PPC_BCLR;
|
|
|
|
ppc_insn := PPC_BCLR;
|
|
|
|
elsif std_match(f.insn, "010011---------------1000110000-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------1000110000-") then
|
|
|
|
report "PPC_bctar";
|
|
|
|
report "PPC_bctar";
|
|
|
|
ppc_insn := PPC_BCTAR;
|
|
|
|
ppc_insn := PPC_BCTAR;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011111100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011111100-") then
|
|
|
|
report "PPC_bperm";
|
|
|
|
report "PPC_bperm";
|
|
|
|
ppc_insn := PPC_BPERM;
|
|
|
|
ppc_insn := PPC_BPERM;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000000000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000000000-") then
|
|
|
|
report "PPC_cmp";
|
|
|
|
report "PPC_cmp";
|
|
|
|
ppc_insn := PPC_CMP;
|
|
|
|
ppc_insn := PPC_CMP;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111111100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111111100-") then
|
|
|
|
report "PPC_cmpb";
|
|
|
|
report "PPC_cmpb";
|
|
|
|
ppc_insn := PPC_CMPB;
|
|
|
|
ppc_insn := PPC_CMPB;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011100000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011100000-") then
|
|
|
|
report "PPC_cmpeqb";
|
|
|
|
report "PPC_cmpeqb";
|
|
|
|
ppc_insn := PPC_CMPEQB;
|
|
|
|
ppc_insn := PPC_CMPEQB;
|
|
|
|
elsif std_match(f.insn, "001011--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001011--------------------------") then
|
|
|
|
report "PPC_cmpi";
|
|
|
|
report "PPC_cmpi";
|
|
|
|
ppc_insn := PPC_CMPI;
|
|
|
|
ppc_insn := PPC_CMPI;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000100000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000100000-") then
|
|
|
|
report "PPC_cmpl";
|
|
|
|
report "PPC_cmpl";
|
|
|
|
ppc_insn := PPC_CMPL;
|
|
|
|
ppc_insn := PPC_CMPL;
|
|
|
|
elsif std_match(f.insn, "001010--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001010--------------------------") then
|
|
|
|
report "PPC_cmpli";
|
|
|
|
report "PPC_cmpli";
|
|
|
|
ppc_insn := PPC_CMPLI;
|
|
|
|
ppc_insn := PPC_CMPLI;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011000000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011000000-") then
|
|
|
|
report "PPC_cmprb";
|
|
|
|
report "PPC_cmprb";
|
|
|
|
ppc_insn := PPC_CMPRB;
|
|
|
|
ppc_insn := PPC_CMPRB;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000111010-") then
|
|
|
|
report "PPC_cntlzd";
|
|
|
|
report "PPC_cntlzd";
|
|
|
|
ppc_insn := PPC_CNTLZD;
|
|
|
|
ppc_insn := PPC_CNTLZD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000011010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000011010-") then
|
|
|
|
report "PPC_cntlzw";
|
|
|
|
report "PPC_cntlzw";
|
|
|
|
ppc_insn := PPC_CNTLZW;
|
|
|
|
ppc_insn := PPC_CNTLZW;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000111010-") then
|
|
|
|
report "PPC_cnttzd";
|
|
|
|
report "PPC_cnttzd";
|
|
|
|
ppc_insn := PPC_CNTTZD;
|
|
|
|
ppc_insn := PPC_CNTTZD;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000011010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000011010-") then
|
|
|
|
report "PPC_cnttzw";
|
|
|
|
report "PPC_cnttzw";
|
|
|
|
ppc_insn := PPC_CNTTZW;
|
|
|
|
ppc_insn := PPC_CNTTZW;
|
|
|
|
elsif std_match(f.insn, "010011---------------0100000001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0100000001-") then
|
|
|
|
report "PPC_crand";
|
|
|
|
report "PPC_crand";
|
|
|
|
ppc_insn := PPC_CRAND;
|
|
|
|
ppc_insn := PPC_CRAND;
|
|
|
|
elsif std_match(f.insn, "010011---------------0010000001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0010000001-") then
|
|
|
|
report "PPC_crandc";
|
|
|
|
report "PPC_crandc";
|
|
|
|
ppc_insn := PPC_CRANDC;
|
|
|
|
ppc_insn := PPC_CRANDC;
|
|
|
|
elsif std_match(f.insn, "010011---------------0100100001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0100100001-") then
|
|
|
|
report "PPC_creqv";
|
|
|
|
report "PPC_creqv";
|
|
|
|
ppc_insn := PPC_CREQV;
|
|
|
|
ppc_insn := PPC_CREQV;
|
|
|
|
elsif std_match(f.insn, "010011---------------0011100001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0011100001-") then
|
|
|
|
report "PPC_crnand";
|
|
|
|
report "PPC_crnand";
|
|
|
|
ppc_insn := PPC_CRNAND;
|
|
|
|
ppc_insn := PPC_CRNAND;
|
|
|
|
elsif std_match(f.insn, "010011---------------0000100001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0000100001-") then
|
|
|
|
report "PPC_crnor";
|
|
|
|
report "PPC_crnor";
|
|
|
|
ppc_insn := PPC_CRNOR;
|
|
|
|
ppc_insn := PPC_CRNOR;
|
|
|
|
elsif std_match(f.insn, "010011---------------0111000001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0111000001-") then
|
|
|
|
report "PPC_cror";
|
|
|
|
report "PPC_cror";
|
|
|
|
ppc_insn := PPC_CROR;
|
|
|
|
ppc_insn := PPC_CROR;
|
|
|
|
elsif std_match(f.insn, "010011---------------0110100001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0110100001-") then
|
|
|
|
report "PPC_crorc";
|
|
|
|
report "PPC_crorc";
|
|
|
|
ppc_insn := PPC_CRORC;
|
|
|
|
ppc_insn := PPC_CRORC;
|
|
|
|
elsif std_match(f.insn, "010011---------------0011000001-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0011000001-") then
|
|
|
|
report "PPC_crxor";
|
|
|
|
report "PPC_crxor";
|
|
|
|
ppc_insn := PPC_CRXOR;
|
|
|
|
ppc_insn := PPC_CRXOR;
|
|
|
|
elsif std_match(f.insn, "011111---------------1011110011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1011110011-") then
|
|
|
|
report "PPC_darn";
|
|
|
|
report "PPC_darn";
|
|
|
|
ppc_insn := PPC_DARN;
|
|
|
|
ppc_insn := PPC_DARN;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001010110-") then
|
|
|
|
report "PPC_dcbf";
|
|
|
|
report "PPC_dcbf";
|
|
|
|
ppc_insn := PPC_DCBF;
|
|
|
|
ppc_insn := PPC_DCBF;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000110110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000110110-") then
|
|
|
|
report "PPC_dcbst";
|
|
|
|
report "PPC_dcbst";
|
|
|
|
ppc_insn := PPC_DCBST;
|
|
|
|
ppc_insn := PPC_DCBST;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100010110-") then
|
|
|
|
report "PPC_dcbt";
|
|
|
|
report "PPC_dcbt";
|
|
|
|
ppc_insn := PPC_DCBT;
|
|
|
|
ppc_insn := PPC_DCBT;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011110110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011110110-") then
|
|
|
|
report "PPC_dcbtst";
|
|
|
|
report "PPC_dcbtst";
|
|
|
|
ppc_insn := PPC_DCBTST;
|
|
|
|
ppc_insn := PPC_DCBTST;
|
|
|
|
elsif std_match(f.insn, "011111---------------1111110110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1111110110-") then
|
|
|
|
report "PPC_dcbz";
|
|
|
|
report "PPC_dcbz";
|
|
|
|
ppc_insn := PPC_DCBZ;
|
|
|
|
ppc_insn := PPC_DCBZ;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111101001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111101001-") then
|
|
|
|
report "PPC_divd";
|
|
|
|
report "PPC_divd";
|
|
|
|
ppc_insn := PPC_DIVD;
|
|
|
|
ppc_insn := PPC_DIVD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110101001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110101001-") then
|
|
|
|
report "PPC_divde";
|
|
|
|
report "PPC_divde";
|
|
|
|
ppc_insn := PPC_DIVDE;
|
|
|
|
ppc_insn := PPC_DIVDE;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110001001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110001001-") then
|
|
|
|
report "PPC_divdeu";
|
|
|
|
report "PPC_divdeu";
|
|
|
|
ppc_insn := PPC_DIVDEU;
|
|
|
|
ppc_insn := PPC_DIVDEU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111001001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111001001-") then
|
|
|
|
report "PPC_divdu";
|
|
|
|
report "PPC_divdu";
|
|
|
|
ppc_insn := PPC_DIVDU;
|
|
|
|
ppc_insn := PPC_DIVDU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111101011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111101011-") then
|
|
|
|
report "PPC_divw";
|
|
|
|
report "PPC_divw";
|
|
|
|
ppc_insn := PPC_DIVW;
|
|
|
|
ppc_insn := PPC_DIVW;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110101011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110101011-") then
|
|
|
|
report "PPC_divwe";
|
|
|
|
report "PPC_divwe";
|
|
|
|
ppc_insn := PPC_DIVWE;
|
|
|
|
ppc_insn := PPC_DIVWE;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110001011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110001011-") then
|
|
|
|
report "PPC_divweu";
|
|
|
|
report "PPC_divweu";
|
|
|
|
ppc_insn := PPC_DIVWEU;
|
|
|
|
ppc_insn := PPC_DIVWEU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111001011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111001011-") then
|
|
|
|
report "PPC_divwu";
|
|
|
|
report "PPC_divwu";
|
|
|
|
ppc_insn := PPC_DIVWU;
|
|
|
|
ppc_insn := PPC_DIVWU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100011100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100011100-") then
|
|
|
|
report "PPC_eqv";
|
|
|
|
report "PPC_eqv";
|
|
|
|
ppc_insn := PPC_EQV;
|
|
|
|
ppc_insn := PPC_EQV;
|
|
|
|
elsif std_match(f.insn, "011111---------------1110111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1110111010-") then
|
|
|
|
report "PPC_extsb";
|
|
|
|
report "PPC_extsb";
|
|
|
|
ppc_insn := PPC_EXTSB;
|
|
|
|
ppc_insn := PPC_EXTSB;
|
|
|
|
elsif std_match(f.insn, "011111---------------1110011010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1110011010-") then
|
|
|
|
report "PPC_extsh";
|
|
|
|
report "PPC_extsh";
|
|
|
|
ppc_insn := PPC_EXTSH;
|
|
|
|
ppc_insn := PPC_EXTSH;
|
|
|
|
elsif std_match(f.insn, "011111---------------1111011010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1111011010-") then
|
|
|
|
report "PPC_extsw";
|
|
|
|
report "PPC_extsw";
|
|
|
|
ppc_insn := PPC_EXTSW;
|
|
|
|
ppc_insn := PPC_EXTSW;
|
|
|
|
elsif std_match(f.insn, "011111---------------110111101--") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------110111101--") then
|
|
|
|
report "PPC_extswsli";
|
|
|
|
report "PPC_extswsli";
|
|
|
|
ppc_insn := PPC_EXTSWSLI;
|
|
|
|
ppc_insn := PPC_EXTSWSLI;
|
|
|
|
elsif std_match(f.insn, "011111---------------1111010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1111010110-") then
|
|
|
|
report "PPC_icbi";
|
|
|
|
report "PPC_icbi";
|
|
|
|
ppc_insn := PPC_ICBI;
|
|
|
|
ppc_insn := PPC_ICBI;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000010110-") then
|
|
|
|
report "PPC_icbt";
|
|
|
|
report "PPC_icbt";
|
|
|
|
ppc_insn := PPC_ICBT;
|
|
|
|
ppc_insn := PPC_ICBT;
|
|
|
|
elsif std_match(f.insn, "011111--------------------01111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111--------------------01111-") then
|
|
|
|
report "PPC_isel";
|
|
|
|
report "PPC_isel";
|
|
|
|
ppc_insn := PPC_ISEL;
|
|
|
|
ppc_insn := PPC_ISEL;
|
|
|
|
elsif std_match(f.insn, "010011---------------0010010110-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0010010110-") then
|
|
|
|
report "PPC_isync";
|
|
|
|
report "PPC_isync";
|
|
|
|
ppc_insn := PPC_ISYNC;
|
|
|
|
ppc_insn := PPC_ISYNC;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000110100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000110100-") then
|
|
|
|
report "PPC_lbarx";
|
|
|
|
report "PPC_lbarx";
|
|
|
|
ppc_insn := PPC_LBARX;
|
|
|
|
ppc_insn := PPC_LBARX;
|
|
|
|
elsif std_match(f.insn, "100010--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100010--------------------------") then
|
|
|
|
report "PPC_lbz";
|
|
|
|
report "PPC_lbz";
|
|
|
|
ppc_insn := PPC_LBZ;
|
|
|
|
ppc_insn := PPC_LBZ;
|
|
|
|
elsif std_match(f.insn, "100011--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100011--------------------------") then
|
|
|
|
report "PPC_lbzu";
|
|
|
|
report "PPC_lbzu";
|
|
|
|
ppc_insn := PPC_LBZU;
|
|
|
|
ppc_insn := PPC_LBZU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001110111-") then
|
|
|
|
report "PPC_lbzux";
|
|
|
|
report "PPC_lbzux";
|
|
|
|
ppc_insn := PPC_LBZUX;
|
|
|
|
ppc_insn := PPC_LBZUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001010111-") then
|
|
|
|
report "PPC_lbzx";
|
|
|
|
report "PPC_lbzx";
|
|
|
|
ppc_insn := PPC_LBZX;
|
|
|
|
ppc_insn := PPC_LBZX;
|
|
|
|
elsif std_match(f.insn, "111010------------------------00") then
|
|
|
|
elsif std_match(f_in.insn, "111010------------------------00") then
|
|
|
|
report "PPC_ld";
|
|
|
|
report "PPC_ld";
|
|
|
|
ppc_insn := PPC_LD;
|
|
|
|
ppc_insn := PPC_LD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001010100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001010100-") then
|
|
|
|
report "PPC_ldarx";
|
|
|
|
report "PPC_ldarx";
|
|
|
|
ppc_insn := PPC_LDARX;
|
|
|
|
ppc_insn := PPC_LDARX;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000010100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000010100-") then
|
|
|
|
report "PPC_ldbrx";
|
|
|
|
report "PPC_ldbrx";
|
|
|
|
ppc_insn := PPC_LDBRX;
|
|
|
|
ppc_insn := PPC_LDBRX;
|
|
|
|
elsif std_match(f.insn, "111010------------------------01") then
|
|
|
|
elsif std_match(f_in.insn, "111010------------------------01") then
|
|
|
|
report "PPC_ldu";
|
|
|
|
report "PPC_ldu";
|
|
|
|
ppc_insn := PPC_LDU;
|
|
|
|
ppc_insn := PPC_LDU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000110101-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000110101-") then
|
|
|
|
report "PPC_ldux";
|
|
|
|
report "PPC_ldux";
|
|
|
|
ppc_insn := PPC_LDUX;
|
|
|
|
ppc_insn := PPC_LDUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000010101-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000010101-") then
|
|
|
|
report "PPC_ldx";
|
|
|
|
report "PPC_ldx";
|
|
|
|
ppc_insn := PPC_LDX;
|
|
|
|
ppc_insn := PPC_LDX;
|
|
|
|
elsif std_match(f.insn, "101010--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "101010--------------------------") then
|
|
|
|
report "PPC_lha";
|
|
|
|
report "PPC_lha";
|
|
|
|
ppc_insn := PPC_LHA;
|
|
|
|
ppc_insn := PPC_LHA;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001110100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001110100-") then
|
|
|
|
report "PPC_lharx";
|
|
|
|
report "PPC_lharx";
|
|
|
|
ppc_insn := PPC_LHARX;
|
|
|
|
ppc_insn := PPC_LHARX;
|
|
|
|
elsif std_match(f.insn, "101011--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "101011--------------------------") then
|
|
|
|
report "PPC_lhau";
|
|
|
|
report "PPC_lhau";
|
|
|
|
ppc_insn := PPC_LHAU;
|
|
|
|
ppc_insn := PPC_LHAU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0101110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0101110111-") then
|
|
|
|
report "PPC_lhaux";
|
|
|
|
report "PPC_lhaux";
|
|
|
|
ppc_insn := PPC_LHAUX;
|
|
|
|
ppc_insn := PPC_LHAUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0101010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0101010111-") then
|
|
|
|
report "PPC_lhax";
|
|
|
|
report "PPC_lhax";
|
|
|
|
ppc_insn := PPC_LHAX;
|
|
|
|
ppc_insn := PPC_LHAX;
|
|
|
|
elsif std_match(f.insn, "011111---------------1100010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1100010110-") then
|
|
|
|
report "PPC_lhbrx";
|
|
|
|
report "PPC_lhbrx";
|
|
|
|
ppc_insn := PPC_LHBRX;
|
|
|
|
ppc_insn := PPC_LHBRX;
|
|
|
|
elsif std_match(f.insn, "101000--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "101000--------------------------") then
|
|
|
|
report "PPC_lhz";
|
|
|
|
report "PPC_lhz";
|
|
|
|
ppc_insn := PPC_LHZ;
|
|
|
|
ppc_insn := PPC_LHZ;
|
|
|
|
elsif std_match(f.insn, "101001--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "101001--------------------------") then
|
|
|
|
report "PPC_lhzu";
|
|
|
|
report "PPC_lhzu";
|
|
|
|
ppc_insn := PPC_LHZU;
|
|
|
|
ppc_insn := PPC_LHZU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100110111-") then
|
|
|
|
report "PPC_lhzux";
|
|
|
|
report "PPC_lhzux";
|
|
|
|
ppc_insn := PPC_LHZUX;
|
|
|
|
ppc_insn := PPC_LHZUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100010111-") then
|
|
|
|
report "PPC_lhzx";
|
|
|
|
report "PPC_lhzx";
|
|
|
|
ppc_insn := PPC_LHZX;
|
|
|
|
ppc_insn := PPC_LHZX;
|
|
|
|
elsif std_match(f.insn, "111010------------------------10") then
|
|
|
|
elsif std_match(f_in.insn, "111010------------------------10") then
|
|
|
|
report "PPC_lwa";
|
|
|
|
report "PPC_lwa";
|
|
|
|
ppc_insn := PPC_LWA;
|
|
|
|
ppc_insn := PPC_LWA;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000010100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000010100-") then
|
|
|
|
report "PPC_lwarx";
|
|
|
|
report "PPC_lwarx";
|
|
|
|
ppc_insn := PPC_LWARX;
|
|
|
|
ppc_insn := PPC_LWARX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0101110101-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0101110101-") then
|
|
|
|
report "PPC_lwaux";
|
|
|
|
report "PPC_lwaux";
|
|
|
|
ppc_insn := PPC_LWAUX;
|
|
|
|
ppc_insn := PPC_LWAUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0101010101-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0101010101-") then
|
|
|
|
report "PPC_lwax";
|
|
|
|
report "PPC_lwax";
|
|
|
|
ppc_insn := PPC_LWAX;
|
|
|
|
ppc_insn := PPC_LWAX;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000010110-") then
|
|
|
|
report "PPC_lwbrx";
|
|
|
|
report "PPC_lwbrx";
|
|
|
|
ppc_insn := PPC_LWBRX;
|
|
|
|
ppc_insn := PPC_LWBRX;
|
|
|
|
elsif std_match(f.insn, "100000--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100000--------------------------") then
|
|
|
|
report "PPC_lwz";
|
|
|
|
report "PPC_lwz";
|
|
|
|
ppc_insn := PPC_LWZ;
|
|
|
|
ppc_insn := PPC_LWZ;
|
|
|
|
elsif std_match(f.insn, "100001--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100001--------------------------") then
|
|
|
|
report "PPC_lwzu";
|
|
|
|
report "PPC_lwzu";
|
|
|
|
ppc_insn := PPC_LWZU;
|
|
|
|
ppc_insn := PPC_LWZU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000110111-") then
|
|
|
|
report "PPC_lwzux";
|
|
|
|
report "PPC_lwzux";
|
|
|
|
ppc_insn := PPC_LWZUX;
|
|
|
|
ppc_insn := PPC_LWZUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000010111-") then
|
|
|
|
report "PPC_lwzx";
|
|
|
|
report "PPC_lwzx";
|
|
|
|
ppc_insn := PPC_LWZX;
|
|
|
|
ppc_insn := PPC_LWZX;
|
|
|
|
elsif std_match(f.insn, "000100--------------------110000") then
|
|
|
|
elsif std_match(f_in.insn, "000100--------------------110000") then
|
|
|
|
report "PPC_maddhd";
|
|
|
|
report "PPC_maddhd";
|
|
|
|
ppc_insn := PPC_MADDHD;
|
|
|
|
ppc_insn := PPC_MADDHD;
|
|
|
|
elsif std_match(f.insn, "000100--------------------110001") then
|
|
|
|
elsif std_match(f_in.insn, "000100--------------------110001") then
|
|
|
|
report "PPC_maddhdu";
|
|
|
|
report "PPC_maddhdu";
|
|
|
|
ppc_insn := PPC_MADDHDU;
|
|
|
|
ppc_insn := PPC_MADDHDU;
|
|
|
|
elsif std_match(f.insn, "000100--------------------110011") then
|
|
|
|
elsif std_match(f_in.insn, "000100--------------------110011") then
|
|
|
|
report "PPC_maddld";
|
|
|
|
report "PPC_maddld";
|
|
|
|
ppc_insn := PPC_MADDLD;
|
|
|
|
ppc_insn := PPC_MADDLD;
|
|
|
|
elsif std_match(f.insn, "010011---------------0000000000-") then
|
|
|
|
elsif std_match(f_in.insn, "010011---------------0000000000-") then
|
|
|
|
report "PPC_mcrf";
|
|
|
|
report "PPC_mcrf";
|
|
|
|
ppc_insn := PPC_MCRF;
|
|
|
|
ppc_insn := PPC_MCRF;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000000000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000000000-") then
|
|
|
|
report "PPC_mcrxr";
|
|
|
|
report "PPC_mcrxr";
|
|
|
|
ppc_insn := PPC_MCRXR;
|
|
|
|
ppc_insn := PPC_MCRXR;
|
|
|
|
elsif std_match(f.insn, "011111---------------1001000000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1001000000-") then
|
|
|
|
report "PPC_mcrxrx";
|
|
|
|
report "PPC_mcrxrx";
|
|
|
|
ppc_insn := PPC_MCRXRX;
|
|
|
|
ppc_insn := PPC_MCRXRX;
|
|
|
|
elsif std_match(f.insn, "011111-----0---------0000010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----0---------0000010011-") then
|
|
|
|
report "PPC_mfcr";
|
|
|
|
report "PPC_mfcr";
|
|
|
|
ppc_insn := PPC_MFCR;
|
|
|
|
ppc_insn := PPC_MFCR;
|
|
|
|
elsif std_match(f.insn, "011111-----1---------0000010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----1---------0000010011-") then
|
|
|
|
report "PPC_mfocrf";
|
|
|
|
report "PPC_mfocrf";
|
|
|
|
ppc_insn := PPC_MFOCRF;
|
|
|
|
ppc_insn := PPC_MFOCRF;
|
|
|
|
-- Specific MF/MT SPR encodings first
|
|
|
|
-- Specific MF/MT SPR encodings first
|
|
|
|
elsif std_match(f.insn, "011111-----01001000000101010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----01001000000101010011-") then
|
|
|
|
report "PPC_mfctr";
|
|
|
|
report "PPC_mfctr";
|
|
|
|
ppc_insn := PPC_MFCTR;
|
|
|
|
ppc_insn := PPC_MFCTR;
|
|
|
|
elsif std_match(f.insn, "011111-----01000000000101010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----01000000000101010011-") then
|
|
|
|
report "PPC_mflr";
|
|
|
|
report "PPC_mflr";
|
|
|
|
ppc_insn := PPC_MFLR;
|
|
|
|
ppc_insn := PPC_MFLR;
|
|
|
|
elsif std_match(f.insn, "011111-----01100010000101010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----01100010000101010011-") then
|
|
|
|
report "PPC_mftb";
|
|
|
|
report "PPC_mftb";
|
|
|
|
ppc_insn := PPC_MFTB;
|
|
|
|
ppc_insn := PPC_MFTB;
|
|
|
|
elsif std_match(f.insn, "011111-----01001000000111010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----01001000000111010011-") then
|
|
|
|
report "PPC_mtctr";
|
|
|
|
report "PPC_mtctr";
|
|
|
|
ppc_insn := PPC_MTCTR;
|
|
|
|
ppc_insn := PPC_MTCTR;
|
|
|
|
elsif std_match(f.insn, "011111-----01000000000111010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----01000000000111010011-") then
|
|
|
|
report "PPC_mtlr";
|
|
|
|
report "PPC_mtlr";
|
|
|
|
ppc_insn := PPC_MTLR;
|
|
|
|
ppc_insn := PPC_MTLR;
|
|
|
|
elsif std_match(f.insn, "011111---------------0101010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0101010011-") then
|
|
|
|
report "PPC_mfspr";
|
|
|
|
report "PPC_mfspr";
|
|
|
|
ppc_insn := PPC_MFSPR;
|
|
|
|
ppc_insn := PPC_MFSPR;
|
|
|
|
elsif std_match(f.insn, "011111---------------1100001001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1100001001-") then
|
|
|
|
report "PPC_modsd";
|
|
|
|
report "PPC_modsd";
|
|
|
|
ppc_insn := PPC_MODSD;
|
|
|
|
ppc_insn := PPC_MODSD;
|
|
|
|
elsif std_match(f.insn, "011111---------------1100001011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1100001011-") then
|
|
|
|
report "PPC_modsw";
|
|
|
|
report "PPC_modsw";
|
|
|
|
ppc_insn := PPC_MODSW;
|
|
|
|
ppc_insn := PPC_MODSW;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100001001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100001001-") then
|
|
|
|
report "PPC_modud";
|
|
|
|
report "PPC_modud";
|
|
|
|
ppc_insn := PPC_MODUD;
|
|
|
|
ppc_insn := PPC_MODUD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100001011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100001011-") then
|
|
|
|
report "PPC_moduw";
|
|
|
|
report "PPC_moduw";
|
|
|
|
ppc_insn := PPC_MODUW;
|
|
|
|
ppc_insn := PPC_MODUW;
|
|
|
|
elsif std_match(f.insn, "011111-----0---------0010010000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----0---------0010010000-") then
|
|
|
|
report "PPC_mtcrf";
|
|
|
|
report "PPC_mtcrf";
|
|
|
|
ppc_insn := PPC_MTCRF;
|
|
|
|
ppc_insn := PPC_MTCRF;
|
|
|
|
elsif std_match(f.insn, "011111-----1---------0010010000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111-----1---------0010010000-") then
|
|
|
|
report "PPC_mtocrf";
|
|
|
|
report "PPC_mtocrf";
|
|
|
|
ppc_insn := PPC_MTOCRF;
|
|
|
|
ppc_insn := PPC_MTOCRF;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111010011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111010011-") then
|
|
|
|
report "PPC_mtspr";
|
|
|
|
report "PPC_mtspr";
|
|
|
|
ppc_insn := PPC_MTSPR;
|
|
|
|
ppc_insn := PPC_MTSPR;
|
|
|
|
elsif std_match(f.insn, "011111----------------001001001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111----------------001001001-") then
|
|
|
|
report "PPC_mulhd";
|
|
|
|
report "PPC_mulhd";
|
|
|
|
ppc_insn := PPC_MULHD;
|
|
|
|
ppc_insn := PPC_MULHD;
|
|
|
|
elsif std_match(f.insn, "011111----------------000001001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111----------------000001001-") then
|
|
|
|
report "PPC_mulhdu";
|
|
|
|
report "PPC_mulhdu";
|
|
|
|
ppc_insn := PPC_MULHDU;
|
|
|
|
ppc_insn := PPC_MULHDU;
|
|
|
|
elsif std_match(f.insn, "011111----------------001001011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111----------------001001011-") then
|
|
|
|
report "PPC_mulhw";
|
|
|
|
report "PPC_mulhw";
|
|
|
|
ppc_insn := PPC_MULHW;
|
|
|
|
ppc_insn := PPC_MULHW;
|
|
|
|
elsif std_match(f.insn, "011111----------------000001011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111----------------000001011-") then
|
|
|
|
report "PPC_mulhwu";
|
|
|
|
report "PPC_mulhwu";
|
|
|
|
ppc_insn := PPC_MULHWU;
|
|
|
|
ppc_insn := PPC_MULHWU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011101001-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011101001-") then
|
|
|
|
report "PPC_mulld";
|
|
|
|
report "PPC_mulld";
|
|
|
|
ppc_insn := PPC_MULLD;
|
|
|
|
ppc_insn := PPC_MULLD;
|
|
|
|
elsif std_match(f.insn, "000111--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "000111--------------------------") then
|
|
|
|
report "PPC_mulli";
|
|
|
|
report "PPC_mulli";
|
|
|
|
ppc_insn := PPC_MULLI;
|
|
|
|
ppc_insn := PPC_MULLI;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011101011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011101011-") then
|
|
|
|
report "PPC_mullw";
|
|
|
|
report "PPC_mullw";
|
|
|
|
ppc_insn := PPC_MULLW;
|
|
|
|
ppc_insn := PPC_MULLW;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111011100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111011100-") then
|
|
|
|
report "PPC_nand";
|
|
|
|
report "PPC_nand";
|
|
|
|
ppc_insn := PPC_NAND;
|
|
|
|
ppc_insn := PPC_NAND;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001101000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001101000-") then
|
|
|
|
report "PPC_neg";
|
|
|
|
report "PPC_neg";
|
|
|
|
ppc_insn := PPC_NEG;
|
|
|
|
ppc_insn := PPC_NEG;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001111100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001111100-") then
|
|
|
|
report "PPC_nor";
|
|
|
|
report "PPC_nor";
|
|
|
|
ppc_insn := PPC_NOR;
|
|
|
|
ppc_insn := PPC_NOR;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110111100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110111100-") then
|
|
|
|
report "PPC_or";
|
|
|
|
report "PPC_or";
|
|
|
|
ppc_insn := PPC_OR;
|
|
|
|
ppc_insn := PPC_OR;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110011100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110011100-") then
|
|
|
|
report "PPC_orc";
|
|
|
|
report "PPC_orc";
|
|
|
|
ppc_insn := PPC_ORC;
|
|
|
|
ppc_insn := PPC_ORC;
|
|
|
|
elsif std_match(f.insn, "011000--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "011000--------------------------") then
|
|
|
|
report "PPC_ori";
|
|
|
|
report "PPC_ori";
|
|
|
|
ppc_insn := PPC_ORI;
|
|
|
|
ppc_insn := PPC_ORI;
|
|
|
|
elsif std_match(f.insn, "011001--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "011001--------------------------") then
|
|
|
|
report "PPC_oris";
|
|
|
|
report "PPC_oris";
|
|
|
|
ppc_insn := PPC_ORIS;
|
|
|
|
ppc_insn := PPC_ORIS;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001111010-") then
|
|
|
|
report "PPC_popcntb";
|
|
|
|
report "PPC_popcntb";
|
|
|
|
ppc_insn := PPC_POPCNTB;
|
|
|
|
ppc_insn := PPC_POPCNTB;
|
|
|
|
elsif std_match(f.insn, "011111---------------0111111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0111111010-") then
|
|
|
|
report "PPC_popcntd";
|
|
|
|
report "PPC_popcntd";
|
|
|
|
ppc_insn := PPC_POPCNTD;
|
|
|
|
ppc_insn := PPC_POPCNTD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0101111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0101111010-") then
|
|
|
|
report "PPC_popcntw";
|
|
|
|
report "PPC_popcntw";
|
|
|
|
ppc_insn := PPC_POPCNTW;
|
|
|
|
ppc_insn := PPC_POPCNTW;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010111010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010111010-") then
|
|
|
|
report "PPC_prtyd";
|
|
|
|
report "PPC_prtyd";
|
|
|
|
ppc_insn := PPC_PRTYD;
|
|
|
|
ppc_insn := PPC_PRTYD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010011010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010011010-") then
|
|
|
|
report "PPC_prtyw";
|
|
|
|
report "PPC_prtyw";
|
|
|
|
ppc_insn := PPC_PRTYW;
|
|
|
|
ppc_insn := PPC_PRTYW;
|
|
|
|
elsif std_match(f.insn, "011110---------------------1000-") then
|
|
|
|
elsif std_match(f_in.insn, "011110---------------------1000-") then
|
|
|
|
report "PPC_rldcl";
|
|
|
|
report "PPC_rldcl";
|
|
|
|
ppc_insn := PPC_RLDCL;
|
|
|
|
ppc_insn := PPC_RLDCL;
|
|
|
|
elsif std_match(f.insn, "011110---------------------1001-") then
|
|
|
|
elsif std_match(f_in.insn, "011110---------------------1001-") then
|
|
|
|
report "PPC_rldcr";
|
|
|
|
report "PPC_rldcr";
|
|
|
|
ppc_insn := PPC_RLDCR;
|
|
|
|
ppc_insn := PPC_RLDCR;
|
|
|
|
elsif std_match(f.insn, "011110---------------------010--") then
|
|
|
|
elsif std_match(f_in.insn, "011110---------------------010--") then
|
|
|
|
report "PPC_rldic";
|
|
|
|
report "PPC_rldic";
|
|
|
|
ppc_insn := PPC_RLDIC;
|
|
|
|
ppc_insn := PPC_RLDIC;
|
|
|
|
elsif std_match(f.insn, "011110---------------------000--") then
|
|
|
|
elsif std_match(f_in.insn, "011110---------------------000--") then
|
|
|
|
report "PPC_rldicl";
|
|
|
|
report "PPC_rldicl";
|
|
|
|
ppc_insn := PPC_RLDICL;
|
|
|
|
ppc_insn := PPC_RLDICL;
|
|
|
|
elsif std_match(f.insn, "011110---------------------001--") then
|
|
|
|
elsif std_match(f_in.insn, "011110---------------------001--") then
|
|
|
|
report "PPC_rldicr";
|
|
|
|
report "PPC_rldicr";
|
|
|
|
ppc_insn := PPC_RLDICR;
|
|
|
|
ppc_insn := PPC_RLDICR;
|
|
|
|
elsif std_match(f.insn, "011110---------------------011--") then
|
|
|
|
elsif std_match(f_in.insn, "011110---------------------011--") then
|
|
|
|
report "PPC_rldimi";
|
|
|
|
report "PPC_rldimi";
|
|
|
|
ppc_insn := PPC_RLDIMI;
|
|
|
|
ppc_insn := PPC_RLDIMI;
|
|
|
|
elsif std_match(f.insn, "010100--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "010100--------------------------") then
|
|
|
|
report "PPC_rlwimi";
|
|
|
|
report "PPC_rlwimi";
|
|
|
|
ppc_insn := PPC_RLWIMI;
|
|
|
|
ppc_insn := PPC_RLWIMI;
|
|
|
|
elsif std_match(f.insn, "010101--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "010101--------------------------") then
|
|
|
|
report "PPC_rlwinm";
|
|
|
|
report "PPC_rlwinm";
|
|
|
|
ppc_insn := PPC_RLWINM;
|
|
|
|
ppc_insn := PPC_RLWINM;
|
|
|
|
elsif std_match(f.insn, "010111--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "010111--------------------------") then
|
|
|
|
report "PPC_rlwnm";
|
|
|
|
report "PPC_rlwnm";
|
|
|
|
ppc_insn := PPC_RLWNM;
|
|
|
|
ppc_insn := PPC_RLWNM;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010000000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010000000-") then
|
|
|
|
report "PPC_setb";
|
|
|
|
report "PPC_setb";
|
|
|
|
ppc_insn := PPC_SETB;
|
|
|
|
ppc_insn := PPC_SETB;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000011011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000011011-") then
|
|
|
|
report "PPC_sld";
|
|
|
|
report "PPC_sld";
|
|
|
|
ppc_insn := PPC_SLD;
|
|
|
|
ppc_insn := PPC_SLD;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000011000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000011000-") then
|
|
|
|
report "PPC_slw";
|
|
|
|
report "PPC_slw";
|
|
|
|
ppc_insn := PPC_SLW;
|
|
|
|
ppc_insn := PPC_SLW;
|
|
|
|
elsif std_match(f.insn, "011111---------------1100011010-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1100011010-") then
|
|
|
|
report "PPC_srad";
|
|
|
|
report "PPC_srad";
|
|
|
|
ppc_insn := PPC_SRAD;
|
|
|
|
ppc_insn := PPC_SRAD;
|
|
|
|
elsif std_match(f.insn, "011111---------------110011101--") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------110011101--") then
|
|
|
|
report "PPC_sradi";
|
|
|
|
report "PPC_sradi";
|
|
|
|
ppc_insn := PPC_SRADI;
|
|
|
|
ppc_insn := PPC_SRADI;
|
|
|
|
elsif std_match(f.insn, "011111---------------1100011000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1100011000-") then
|
|
|
|
report "PPC_sraw";
|
|
|
|
report "PPC_sraw";
|
|
|
|
ppc_insn := PPC_SRAW;
|
|
|
|
ppc_insn := PPC_SRAW;
|
|
|
|
elsif std_match(f.insn, "011111---------------1100111000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1100111000-") then
|
|
|
|
report "PPC_srawi";
|
|
|
|
report "PPC_srawi";
|
|
|
|
ppc_insn := PPC_SRAWI;
|
|
|
|
ppc_insn := PPC_SRAWI;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000011011-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000011011-") then
|
|
|
|
report "PPC_srd";
|
|
|
|
report "PPC_srd";
|
|
|
|
ppc_insn := PPC_SRD;
|
|
|
|
ppc_insn := PPC_SRD;
|
|
|
|
elsif std_match(f.insn, "011111---------------1000011000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1000011000-") then
|
|
|
|
report "PPC_srw";
|
|
|
|
report "PPC_srw";
|
|
|
|
ppc_insn := PPC_SRW;
|
|
|
|
ppc_insn := PPC_SRW;
|
|
|
|
elsif std_match(f.insn, "100110--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100110--------------------------") then
|
|
|
|
report "PPC_stb";
|
|
|
|
report "PPC_stb";
|
|
|
|
ppc_insn := PPC_STB;
|
|
|
|
ppc_insn := PPC_STB;
|
|
|
|
elsif std_match(f.insn, "011111---------------1010110110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1010110110-") then
|
|
|
|
report "PPC_stbcx";
|
|
|
|
report "PPC_stbcx";
|
|
|
|
ppc_insn := PPC_STBCX;
|
|
|
|
ppc_insn := PPC_STBCX;
|
|
|
|
elsif std_match(f.insn, "100111--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100111--------------------------") then
|
|
|
|
report "PPC_stbu";
|
|
|
|
report "PPC_stbu";
|
|
|
|
ppc_insn := PPC_STBU;
|
|
|
|
ppc_insn := PPC_STBU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011110111-") then
|
|
|
|
report "PPC_stbux";
|
|
|
|
report "PPC_stbux";
|
|
|
|
ppc_insn := PPC_STBUX;
|
|
|
|
ppc_insn := PPC_STBUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011010111-") then
|
|
|
|
report "PPC_stbx";
|
|
|
|
report "PPC_stbx";
|
|
|
|
ppc_insn := PPC_STBX;
|
|
|
|
ppc_insn := PPC_STBX;
|
|
|
|
elsif std_match(f.insn, "111110------------------------00") then
|
|
|
|
elsif std_match(f_in.insn, "111110------------------------00") then
|
|
|
|
report "PPC_std";
|
|
|
|
report "PPC_std";
|
|
|
|
ppc_insn := PPC_STD;
|
|
|
|
ppc_insn := PPC_STD;
|
|
|
|
elsif std_match(f.insn, "011111---------------1010010100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1010010100-") then
|
|
|
|
report "PPC_stdbrx";
|
|
|
|
report "PPC_stdbrx";
|
|
|
|
ppc_insn := PPC_STDBRX;
|
|
|
|
ppc_insn := PPC_STDBRX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011010110-") then
|
|
|
|
report "PPC_stdcx";
|
|
|
|
report "PPC_stdcx";
|
|
|
|
ppc_insn := PPC_STDCX;
|
|
|
|
ppc_insn := PPC_STDCX;
|
|
|
|
elsif std_match(f.insn, "111110------------------------01") then
|
|
|
|
elsif std_match(f_in.insn, "111110------------------------01") then
|
|
|
|
report "PPC_stdu";
|
|
|
|
report "PPC_stdu";
|
|
|
|
ppc_insn := PPC_STDU;
|
|
|
|
ppc_insn := PPC_STDU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010110101-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010110101-") then
|
|
|
|
report "PPC_stdux";
|
|
|
|
report "PPC_stdux";
|
|
|
|
ppc_insn := PPC_STDUX;
|
|
|
|
ppc_insn := PPC_STDUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010010101-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010010101-") then
|
|
|
|
report "PPC_stdx";
|
|
|
|
report "PPC_stdx";
|
|
|
|
ppc_insn := PPC_STDX;
|
|
|
|
ppc_insn := PPC_STDX;
|
|
|
|
elsif std_match(f.insn, "101100--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "101100--------------------------") then
|
|
|
|
report "PPC_sth";
|
|
|
|
report "PPC_sth";
|
|
|
|
ppc_insn := PPC_STH;
|
|
|
|
ppc_insn := PPC_STH;
|
|
|
|
elsif std_match(f.insn, "011111---------------1110010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1110010110-") then
|
|
|
|
report "PPC_sthbrx";
|
|
|
|
report "PPC_sthbrx";
|
|
|
|
ppc_insn := PPC_STHBRX;
|
|
|
|
ppc_insn := PPC_STHBRX;
|
|
|
|
elsif std_match(f.insn, "011111---------------1011010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1011010110-") then
|
|
|
|
report "PPC_sthcx";
|
|
|
|
report "PPC_sthcx";
|
|
|
|
ppc_insn := PPC_STHCX;
|
|
|
|
ppc_insn := PPC_STHCX;
|
|
|
|
elsif std_match(f.insn, "101101--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "101101--------------------------") then
|
|
|
|
report "PPC_sthu";
|
|
|
|
report "PPC_sthu";
|
|
|
|
ppc_insn := PPC_STHU;
|
|
|
|
ppc_insn := PPC_STHU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110110111-") then
|
|
|
|
report "PPC_sthux";
|
|
|
|
report "PPC_sthux";
|
|
|
|
ppc_insn := PPC_STHUX;
|
|
|
|
ppc_insn := PPC_STHUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0110010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0110010111-") then
|
|
|
|
report "PPC_sthx";
|
|
|
|
report "PPC_sthx";
|
|
|
|
ppc_insn := PPC_STHX;
|
|
|
|
ppc_insn := PPC_STHX;
|
|
|
|
elsif std_match(f.insn, "100100--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100100--------------------------") then
|
|
|
|
report "PPC_stw";
|
|
|
|
report "PPC_stw";
|
|
|
|
ppc_insn := PPC_STW;
|
|
|
|
ppc_insn := PPC_STW;
|
|
|
|
elsif std_match(f.insn, "011111---------------1010010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1010010110-") then
|
|
|
|
report "PPC_stwbrx";
|
|
|
|
report "PPC_stwbrx";
|
|
|
|
ppc_insn := PPC_STWBRX;
|
|
|
|
ppc_insn := PPC_STWBRX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010010110-") then
|
|
|
|
report "PPC_stwcx";
|
|
|
|
report "PPC_stwcx";
|
|
|
|
ppc_insn := PPC_STWCX;
|
|
|
|
ppc_insn := PPC_STWCX;
|
|
|
|
elsif std_match(f.insn, "100101--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "100101--------------------------") then
|
|
|
|
report "PPC_stwu";
|
|
|
|
report "PPC_stwu";
|
|
|
|
ppc_insn := PPC_STWU;
|
|
|
|
ppc_insn := PPC_STWU;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010110111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010110111-") then
|
|
|
|
report "PPC_stwux";
|
|
|
|
report "PPC_stwux";
|
|
|
|
ppc_insn := PPC_STWUX;
|
|
|
|
ppc_insn := PPC_STWUX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010010111-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010010111-") then
|
|
|
|
report "PPC_stwx";
|
|
|
|
report "PPC_stwx";
|
|
|
|
ppc_insn := PPC_STWX;
|
|
|
|
ppc_insn := PPC_STWX;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000101000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000101000-") then
|
|
|
|
report "PPC_subf";
|
|
|
|
report "PPC_subf";
|
|
|
|
ppc_insn := PPC_SUBF;
|
|
|
|
ppc_insn := PPC_SUBF;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000001000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000001000-") then
|
|
|
|
report "PPC_subfc";
|
|
|
|
report "PPC_subfc";
|
|
|
|
ppc_insn := PPC_SUBFC;
|
|
|
|
ppc_insn := PPC_SUBFC;
|
|
|
|
elsif std_match(f.insn, "011111---------------0010001000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0010001000-") then
|
|
|
|
report "PPC_subfe";
|
|
|
|
report "PPC_subfe";
|
|
|
|
ppc_insn := PPC_SUBFE;
|
|
|
|
ppc_insn := PPC_SUBFE;
|
|
|
|
elsif std_match(f.insn, "001000--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "001000--------------------------") then
|
|
|
|
report "PPC_subfic";
|
|
|
|
report "PPC_subfic";
|
|
|
|
ppc_insn := PPC_SUBFIC;
|
|
|
|
ppc_insn := PPC_SUBFIC;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011101000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011101000-") then
|
|
|
|
report "PPC_subfme";
|
|
|
|
report "PPC_subfme";
|
|
|
|
ppc_insn := PPC_SUBFME;
|
|
|
|
ppc_insn := PPC_SUBFME;
|
|
|
|
elsif std_match(f.insn, "011111---------------0011001000-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0011001000-") then
|
|
|
|
report "PPC_subfze";
|
|
|
|
report "PPC_subfze";
|
|
|
|
ppc_insn := PPC_SUBFZE;
|
|
|
|
ppc_insn := PPC_SUBFZE;
|
|
|
|
elsif std_match(f.insn, "011111---------------1001010110-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------1001010110-") then
|
|
|
|
report "PPC_sync";
|
|
|
|
report "PPC_sync";
|
|
|
|
ppc_insn := PPC_SYNC;
|
|
|
|
ppc_insn := PPC_SYNC;
|
|
|
|
elsif std_match(f.insn, "011111---------------0001000100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0001000100-") then
|
|
|
|
report "PPC_td";
|
|
|
|
report "PPC_td";
|
|
|
|
ppc_insn := PPC_TD;
|
|
|
|
ppc_insn := PPC_TD;
|
|
|
|
elsif std_match(f.insn, "000010--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "000010--------------------------") then
|
|
|
|
report "PPC_tdi";
|
|
|
|
report "PPC_tdi";
|
|
|
|
ppc_insn := PPC_TDI;
|
|
|
|
ppc_insn := PPC_TDI;
|
|
|
|
elsif std_match(f.insn, "011111---------------0000000100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0000000100-") then
|
|
|
|
report "PPC_tw";
|
|
|
|
report "PPC_tw";
|
|
|
|
ppc_insn := PPC_TW;
|
|
|
|
ppc_insn := PPC_TW;
|
|
|
|
elsif std_match(f.insn, "000011--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "000011--------------------------") then
|
|
|
|
report "PPC_twi";
|
|
|
|
report "PPC_twi";
|
|
|
|
ppc_insn := PPC_TWI;
|
|
|
|
ppc_insn := PPC_TWI;
|
|
|
|
elsif std_match(f.insn, "011111---------------0100111100-") then
|
|
|
|
elsif std_match(f_in.insn, "011111---------------0100111100-") then
|
|
|
|
report "PPC_xor";
|
|
|
|
report "PPC_xor";
|
|
|
|
ppc_insn := PPC_XOR;
|
|
|
|
ppc_insn := PPC_XOR;
|
|
|
|
elsif std_match(f.insn, "011010--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "011010--------------------------") then
|
|
|
|
report "PPC_xori";
|
|
|
|
report "PPC_xori";
|
|
|
|
ppc_insn := PPC_XORI;
|
|
|
|
ppc_insn := PPC_XORI;
|
|
|
|
elsif std_match(f.insn, "011011--------------------------") then
|
|
|
|
elsif std_match(f_in.insn, "011011--------------------------") then
|
|
|
|
report "PPC_xoris";
|
|
|
|
report "PPC_xoris";
|
|
|
|
ppc_insn := PPC_XORIS;
|
|
|
|
ppc_insn := PPC_XORIS;
|
|
|
|
elsif std_match(f.insn, "000001---------------0000000000-") then
|
|
|
|
elsif std_match(f_in.insn, "000001---------------0000000011-") then
|
|
|
|
report "PPC_SIM_READ";
|
|
|
|
|
|
|
|
ppc_insn := PPC_SIM_READ;
|
|
|
|
|
|
|
|
elsif std_match(f.insn, "000001---------------0000000001-") then
|
|
|
|
|
|
|
|
report "PPC_SIM_POLL";
|
|
|
|
|
|
|
|
ppc_insn := PPC_SIM_POLL;
|
|
|
|
|
|
|
|
elsif std_match(f.insn, "000001---------------0000000010-") then
|
|
|
|
|
|
|
|
report "PPC_SIM_WRITE";
|
|
|
|
|
|
|
|
ppc_insn := PPC_SIM_WRITE;
|
|
|
|
|
|
|
|
elsif std_match(f.insn, "000001---------------0000000011-") then
|
|
|
|
|
|
|
|
report "PPC_SIM_CONFIG";
|
|
|
|
report "PPC_SIM_CONFIG";
|
|
|
|
ppc_insn := PPC_SIM_CONFIG;
|
|
|
|
ppc_insn := PPC_SIM_CONFIG;
|
|
|
|
else
|
|
|
|
else
|
|
|
@ -841,7 +839,21 @@ begin
|
|
|
|
ppc_insn := PPC_ILLEGAL;
|
|
|
|
ppc_insn := PPC_ILLEGAL;
|
|
|
|
end if;
|
|
|
|
end if;
|
|
|
|
|
|
|
|
|
|
|
|
d_out.decode <= decode_rom_array(ppc_insn);
|
|
|
|
v.decode := decode_rom_array(ppc_insn);
|
|
|
|
|
|
|
|
end if;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if flush_in = '1' then
|
|
|
|
|
|
|
|
v.valid := '0';
|
|
|
|
|
|
|
|
end if;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if rst = '1' then
|
|
|
|
|
|
|
|
v := Decode1ToDecode2Init;
|
|
|
|
end if;
|
|
|
|
end if;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
-- Update registers
|
|
|
|
|
|
|
|
rin <= v;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
-- Update outputs
|
|
|
|
|
|
|
|
d_out <= r;
|
|
|
|
end process;
|
|
|
|
end process;
|
|
|
|
end architecture behaviour;
|
|
|
|
end architecture behaviour;
|
|
|
|