OpenCores
URL https://opencores.org/ocsvn/amber/amber/trunk

Subversion Repositories amber

[/] [amber/] [trunk/] [hw/] [vlog/] [amber23/] [a23_decode.v] - Diff between revs 2 and 15

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 2 Rev 15
 
//////////////////////////////////////////////////////////////////
 
//                                                              //
 
//  Decode stage of Amber 2 Core                                //
 
//                                                              //
 
//  This file is part of the Amber project                      //
 
//  http://www.opencores.org/project,amber                      //
 
//                                                              //
 
//  Description                                                 //
 
//  This module is the most complex part of the Amber core      //
 
//  It decodes and sequences all instructions and handles all   //
 
//  interrupts                                                  //
 
//                                                              //
 
//  Author(s):                                                  //
 
//      - Conor Santifort, csantifort.amber@gmail.com           //
 
//                                                              //
 
//////////////////////////////////////////////////////////////////
 
//                                                              //
 
// Copyright (C) 2010 Authors and OPENCORES.ORG                 //
 
//                                                              //
 
// This source file may be used and distributed without         //
 
// restriction provided that this copyright statement is not    //
 
// removed from the file and that any derivative work contains  //
 
// the original copyright notice and the associated disclaimer. //
 
//                                                              //
 
// This source file is free software; you can redistribute it   //
 
// and/or modify it under the terms of the GNU Lesser General   //
 
// Public License as published by the Free Software Foundation; //
 
// either version 2.1 of the License, or (at your option) any   //
 
// later version.                                               //
 
//                                                              //
 
// This source is distributed in the hope that it will be       //
 
// useful, but WITHOUT ANY WARRANTY; without even the implied   //
 
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //
 
// PURPOSE.  See the GNU Lesser General Public License for more //
 
// details.                                                     //
 
//                                                              //
 
// You should have received a copy of the GNU Lesser General    //
 
// Public License along with this source; if not, download it   //
 
// from http://www.opencores.org/lgpl.shtml                     //
 
//                                                              //
 
//////////////////////////////////////////////////////////////////
 
 
 
 
 
module a23_decode
 
(
 
input                       i_clk,
 
input       [31:0]          i_read_data,
 
input                       i_fetch_stall,                  // stall all stages of the cpu at the same time
 
input                       i_irq,                          // interrupt request
 
input                       i_firq,                         // Fast interrupt request
 
input                       i_dabt,                         // data abort interrupt request
 
input                       i_iabt,                         // instruction pre-fetch abort flag
 
input                       i_adex,                         // Address Exception
 
input       [31:0]          i_execute_address,              // Registered address output by execute stage
 
                                                            // 2 LSBs of read address used for calculating 
 
                                                            // shift in LDRB ops
 
input       [7:0]           i_abt_status,                   // Abort status
 
input       [31:0]          i_execute_status_bits,          // current status bits values in execute stage
 
input                       i_multiply_done,                // multiply unit is nearly done
 
 
 
 
 
// --------------------------------------------------
 
// Control signals to execute stage
 
// --------------------------------------------------
 
output reg  [31:0]          o_read_data = 1'd0,
 
output reg  [4:0]           o_read_data_alignment = 1'd0,  // 2 LSBs of read address used for calculating shift in LDRB ops
 
 
 
output reg  [31:0]          o_imm32 = 'd0,
 
output reg  [4:0]           o_imm_shift_amount = 'd0,
 
output reg                  o_shift_imm_zero = 'd0,
 
output reg  [3:0]           o_condition = 4'he,             // 4'he = al
 
output reg                  o_exclusive_exec = 'd0,         // exclusive access request ( swap instruction )
 
output reg                  o_data_access_exec = 'd0,       // high means the memory access is a read 
 
                                                            // read or write, low for instruction
 
output reg  [1:0]           o_status_bits_mode = 2'b11,     // SVC
 
output reg                  o_status_bits_irq_mask = 1'd1,
 
output reg                  o_status_bits_firq_mask = 1'd1,
 
 
 
output reg  [3:0]           o_rm_sel = 'd0,
 
output reg  [3:0]           o_rds_sel = 'd0,
 
output reg  [3:0]           o_rn_sel = 'd0,
 
output reg  [1:0]           o_barrel_shift_amount_sel = 'd0,
 
output reg  [1:0]           o_barrel_shift_data_sel = 'd0,
 
output reg  [1:0]           o_barrel_shift_function = 'd0,
 
output reg  [8:0]           o_alu_function = 'd0,
 
output reg  [1:0]           o_multiply_function = 'd0,
 
output reg  [2:0]           o_interrupt_vector_sel = 'd0,
 
output reg  [3:0]           o_address_sel = 4'd2,
 
output reg  [1:0]           o_pc_sel = 2'd2,
 
output reg  [1:0]           o_byte_enable_sel = 'd0,        // byte, halfword or word write
 
output reg  [2:0]           o_status_bits_sel = 'd0,
 
output reg  [2:0]           o_reg_write_sel,
 
output reg                  o_user_mode_regs_load,
 
output reg                  o_user_mode_regs_store_nxt,
 
output reg                  o_firq_not_user_mode,
 
 
 
output reg                  o_write_data_wen = 'd0,
 
output reg                  o_base_address_wen = 'd0,       // save LDM base address register
 
                                                            // in case of data abort
 
output reg                  o_pc_wen = 1'd1,
 
output reg  [14:0]          o_reg_bank_wen = 'd0,
 
output reg                  o_status_bits_flags_wen = 'd0,
 
output reg                  o_status_bits_mode_wen = 'd0,
 
output reg                  o_status_bits_irq_mask_wen = 'd0,
 
output reg                  o_status_bits_firq_mask_wen = 'd0,
 
 
 
// --------------------------------------------------
 
// Co-Processor interface
 
// --------------------------------------------------
 
output reg  [2:0]           o_copro_opcode1 = 'd0,
 
output reg  [2:0]           o_copro_opcode2 = 'd0,
 
output reg  [3:0]           o_copro_crn = 'd0,
 
output reg  [3:0]           o_copro_crm = 'd0,
 
output reg  [3:0]           o_copro_num = 'd0,
 
output reg  [1:0]           o_copro_operation = 'd0, // 0 = no operation, 
 
                                                     // 1 = Move to Amber Core Register from Coprocessor
 
                                                     // 2 = Move to Coprocessor from Amber Core Register
 
output reg                  o_copro_write_data_wen = 'd0,
 
output                      o_iabt_trigger,
 
output      [31:0]          o_iabt_address,
 
output      [7:0]           o_iabt_status,
 
output                      o_dabt_trigger,
 
output      [31:0]          o_dabt_address,
 
output      [7:0]           o_dabt_status
 
 
 
 
 
);
 
 
 
`include "a23_localparams.v"
 
`include "a23_functions.v"
 
 
 
localparam [4:0] RST_WAIT1      = 5'd0,
 
                 RST_WAIT2      = 5'd1,
 
                 INT_WAIT1      = 5'd2,
 
                 INT_WAIT2      = 5'd3,
 
                 EXECUTE        = 5'd4,
 
                 PRE_FETCH_EXEC = 5'd5,  // Execute the Pre-Fetched Instruction
 
                 MEM_WAIT1      = 5'd6,  // conditionally decode current instruction, in case
 
                                         // previous instruction does not execute in S2
 
                 MEM_WAIT2      = 5'd7,
 
                 PC_STALL1      = 5'd8,  // Program Counter altered
 
                                         // conditionally decude current instruction, in case
 
                                         // previous instruction does not execute in S2
 
                 PC_STALL2      = 5'd9,
 
                 MTRANS_EXEC1   = 5'd10,
 
                 MTRANS_EXEC2   = 5'd11,
 
                 MTRANS_EXEC3   = 5'd12,
 
                 MTRANS_EXEC3B  = 5'd13,
 
                 MTRANS_EXEC4   = 5'd14,
 
                 MTRANS5_ABORT  = 5'd15,
 
                 MULT_PROC1     = 5'd16,  // first cycle, save pre fetch instruction
 
                 MULT_PROC2     = 5'd17,  // do multiplication
 
                 MULT_STORE     = 5'd19,  // save RdLo
 
                 MULT_ACCUMU    = 5'd20,  // Accumulate add lower 32 bits
 
                 SWAP_WRITE     = 5'd22,
 
                 SWAP_WAIT1     = 5'd23,
 
                 SWAP_WAIT2     = 5'd24,
 
                 COPRO_WAIT     = 5'd25;
 
 
 
 
 
// ========================================================
 
// Internal signals
 
// ========================================================
 
wire    [31:0]         instruction;
 
wire                   instruction_iabt;        // abort flag, follows the instruction
 
wire                   instruction_adex;        // address exception flag, follows the instruction
 
wire    [31:0]         instruction_address;     // instruction virtual address, follows 
 
                                                // the instruction
 
wire    [7:0]          instruction_iabt_status; // abort status, follows the instruction
 
wire    [1:0]          instruction_sel;
 
reg     [3:0]          type;
 
wire    [3:0]          opcode;
 
wire    [7:0]          imm8;
 
wire    [31:0]         offset12;
 
wire    [31:0]         offset24;
 
wire    [4:0]          shift_imm;
 
 
 
wire                   opcode_compare;
 
wire                   mem_op;
 
wire                   load_op;
 
wire                   store_op;
 
wire                   write_pc;
 
wire                   immediate_shifter_operand;
 
wire                   rds_use_rs;
 
wire                   branch;
 
wire                   mem_op_pre_indexed;
 
wire                   mem_op_post_indexed;
 
 
 
// Flop inputs
 
wire    [31:0]         imm32_nxt;
 
wire    [4:0]          imm_shift_amount_nxt;
 
wire                   shift_imm_zero_nxt;
 
wire    [3:0]          condition_nxt;
 
reg                    exclusive_exec_nxt;
 
reg                    data_access_exec_nxt;
 
 
 
reg     [1:0]          barrel_shift_function_nxt;
 
wire    [8:0]          alu_function_nxt;
 
reg     [1:0]          multiply_function_nxt;
 
reg     [1:0]          status_bits_mode_nxt;
 
reg                    status_bits_irq_mask_nxt;
 
reg                    status_bits_firq_mask_nxt;
 
 
 
wire    [3:0]          rm_sel_nxt;
 
wire    [3:0]          rds_sel_nxt;
 
wire    [3:0]          rn_sel_nxt;
 
reg     [1:0]          barrel_shift_amount_sel_nxt;
 
reg     [1:0]          barrel_shift_data_sel_nxt;
 
reg     [3:0]          address_sel_nxt;
 
reg     [1:0]          pc_sel_nxt;
 
reg     [1:0]          byte_enable_sel_nxt;
 
reg     [2:0]          status_bits_sel_nxt;
 
reg     [2:0]          reg_write_sel_nxt;
 
reg                    user_mode_regs_load_nxt;
 
wire                   firq_not_user_mode_nxt;
 
 
 
// ALU Function signals
 
reg                    alu_swap_sel_nxt;
 
reg                    alu_not_sel_nxt;
 
reg     [1:0]          alu_cin_sel_nxt;
 
reg                    alu_cout_sel_nxt;
 
reg     [3:0]          alu_out_sel_nxt;
 
 
 
reg                    write_data_wen_nxt;
 
reg                    copro_write_data_wen_nxt;
 
reg                    base_address_wen_nxt;
 
reg                    pc_wen_nxt;
 
reg     [14:0]         reg_bank_wen_nxt;
 
reg                    status_bits_flags_wen_nxt;
 
reg                    status_bits_mode_wen_nxt;
 
reg                    status_bits_irq_mask_wen_nxt;
 
reg                    status_bits_firq_mask_wen_nxt;
 
 
 
reg                    saved_current_instruction_wen;   // saved load instruction
 
reg                    pre_fetch_instruction_wen;       // pre-fetch instruction
 
 
 
reg     [4:0]          control_state = RST_WAIT1;
 
reg     [4:0]          control_state_nxt;
 
 
 
 
 
wire                   dabt;
 
reg                    dabt_reg = 'd0;
 
reg                    dabt_reg_d1;
 
reg                    iabt_reg = 'd0;
 
reg                    adex_reg = 'd0;
 
reg     [31:0]         abt_address_reg = 'd0;
 
reg     [7:0]          abt_status_reg = 'd0;
 
reg     [31:0]         saved_current_instruction = 'd0;
 
reg                    saved_current_instruction_iabt = 'd0;          // access abort flag
 
reg                    saved_current_instruction_adex = 'd0;          // address exception
 
reg     [31:0]         saved_current_instruction_address = 'd0;       // virtual address of abort instruction
 
reg     [7:0]          saved_current_instruction_iabt_status = 'd0;   // status of abort instruction
 
reg     [31:0]         pre_fetch_instruction = 'd0;
 
reg                    pre_fetch_instruction_iabt = 'd0;              // access abort flag
 
reg                    pre_fetch_instruction_adex = 'd0;              // address exception
 
reg     [31:0]         pre_fetch_instruction_address = 'd0;           // virtual address of abort instruction
 
reg     [7:0]          pre_fetch_instruction_iabt_status = 'd0;       // status of abort instruction
 
 
 
wire                   instruction_valid;
 
wire                   instruction_execute;
 
 
 
reg     [3:0]          mtrans_reg;              // the current register being accessed as part of STM/LDM
 
reg     [3:0]          mtrans_reg_d1 = 'd0;     // delayed by 1 period
 
reg     [3:0]          mtrans_reg_d2 = 'd0;     // delayed by 2 periods
 
reg     [31:0]         mtrans_instruction_nxt;
 
 
 
wire   [31:0]          mtrans_base_reg_change;
 
wire   [4:0]           mtrans_num_registers;
 
wire                   use_saved_current_instruction;
 
wire                   use_pre_fetch_instruction;
 
wire                   interrupt;
 
wire   [1:0]           interrupt_mode;
 
wire   [2:0]           next_interrupt;
 
reg                    irq = 'd0;
 
reg                    firq = 'd0;
 
wire                   firq_request;
 
wire                   irq_request;
 
wire                   swi_request;
 
wire                   und_request;
 
wire                   dabt_request;
 
reg    [1:0]           copro_operation_nxt;
 
reg                    mtrans_r15 = 'd0;
 
reg                    mtrans_r15_nxt;
 
reg                    restore_base_address = 'd0;
 
reg                    restore_base_address_nxt;
 
 
 
wire                   regop_set_flags;
 
 
 
 
 
// ========================================================
 
// Instruction Abort and Data Abort outputs
 
// ========================================================
 
 
 
assign o_iabt_trigger     = instruction_iabt && o_status_bits_mode == SVC && control_state == INT_WAIT1;
 
assign o_iabt_address     = instruction_address;
 
assign o_iabt_status      = instruction_iabt_status;
 
 
 
assign o_dabt_trigger     = dabt_reg && !dabt_reg_d1;
 
assign o_dabt_address     = abt_address_reg;
 
assign o_dabt_status      = abt_status_reg;
 
 
 
 
 
// ========================================================
 
// Instruction Decode
 
// ========================================================
 
 
 
// for instructions that take more than one cycle
 
// the instruction is saved in the 'saved_mem_instruction'
 
// register and then that register is used for the rest of
 
// the execution of the instruction.
 
// But if the instruction does not execute because of the
 
// condition, then need to select the next instruction to
 
// decode
 
assign use_saved_current_instruction =  instruction_execute &&
 
                          ( control_state == MEM_WAIT1     ||
 
                            control_state == MEM_WAIT2     ||
 
                            control_state == MTRANS_EXEC1  ||
 
                            control_state == MTRANS_EXEC2  ||
 
                            control_state == MTRANS_EXEC3  ||
 
                            control_state == MTRANS_EXEC3B ||
 
                            control_state == MTRANS_EXEC4  ||
 
                            control_state == MTRANS5_ABORT ||
 
                            control_state == MULT_PROC1    ||
 
                            control_state == MULT_PROC2    ||
 
                            control_state == MULT_ACCUMU   ||
 
                            control_state == MULT_STORE    ||
 
                            control_state == INT_WAIT1     ||
 
                            control_state == INT_WAIT2     ||
 
                            control_state == SWAP_WRITE    ||
 
                            control_state == SWAP_WAIT1    ||
 
                            control_state == SWAP_WAIT2    ||
 
                            control_state == COPRO_WAIT     );
 
 
 
assign use_pre_fetch_instruction = control_state == PRE_FETCH_EXEC;
 
 
 
 
 
assign instruction_sel  =         use_saved_current_instruction  ? 2'd1 :  // saved_current_instruction 
 
                                  use_pre_fetch_instruction      ? 2'd2 :  // pre_fetch_instruction     
 
                                                                   2'd0 ;  // o_read_data               
 
 
 
assign instruction      =         instruction_sel == 2'd0 ? o_read_data               :
 
                                  instruction_sel == 2'd1 ? saved_current_instruction :
 
                                                            pre_fetch_instruction     ;
 
 
 
// abort flag
 
assign instruction_iabt =         instruction_sel == 2'd0 ? iabt_reg                       :
 
                                  instruction_sel == 2'd1 ? saved_current_instruction_iabt :
 
                                                            pre_fetch_instruction_iabt     ;
 
 
 
assign instruction_address =      instruction_sel == 2'd0 ? abt_address_reg                   :
 
                                  instruction_sel == 2'd1 ? saved_current_instruction_address :
 
                                                            pre_fetch_instruction_address     ;
 
 
 
assign instruction_iabt_status =  instruction_sel == 2'd0 ? abt_status_reg                        :
 
                                  instruction_sel == 2'd1 ? saved_current_instruction_iabt_status :
 
                                                            pre_fetch_instruction_iabt_status     ;
 
 
 
// instruction address exception
 
assign instruction_adex =         instruction_sel == 2'd0 ? adex_reg                       :
 
                                  instruction_sel == 2'd1 ? saved_current_instruction_adex :
 
                                                            pre_fetch_instruction_adex     ;
 
 
 
// Instruction Decode - Order is important!
 
always @*
 
    casez ({instruction[27:20], instruction[7:4]})
 
        12'b00010?001001 : type = SWAP;
 
        12'b000000??1001 : type = MULT;
 
        12'b00?????????? : type = REGOP;
 
        12'b01?????????? : type = TRANS;
 
        12'b100????????? : type = MTRANS;
 
        12'b101????????? : type = BRANCH;
 
        12'b110????????? : type = CODTRANS;
 
        12'b1110???????0 : type = COREGOP;
 
        12'b1110???????1 : type = CORTRANS;
 
        default:           type = SWI;
 
    endcase
 
 
 
 
 
// ========================================================
 
// Fixed fields within the instruction
 
// ========================================================
 
 
 
assign opcode        = instruction[24:21];
 
assign condition_nxt = instruction[31:28];
 
 
 
assign rm_sel_nxt    = instruction[3:0];
 
 
 
assign rn_sel_nxt    = branch  ? 4'd15             : // Use PC to calculate branch destination
 
                                 instruction[19:16] ;
 
 
 
assign rds_sel_nxt   = control_state == SWAP_WRITE  ? instruction[3:0]   : // Rm gets written out to memory
 
                       type == MTRANS               ? mtrans_reg      :
 
                       branch                       ? 4'd15              : // Update the PC
 
                       rds_use_rs                   ? instruction[11:8]  :
 
                                                      instruction[15:12] ;
 
 
 
 
 
assign shift_imm     = instruction[11:7];
 
assign offset12      = { 20'h0, instruction[11:0]};
 
assign offset24      = {{6{instruction[23]}}, instruction[23:0], 2'd0 }; // sign extend
 
assign imm8          = instruction[7:0];
 
 
 
assign immediate_shifter_operand = instruction[25];
 
assign rds_use_rs                = (type == REGOP && !instruction[25] && instruction[4]) ||
 
                                   (type == MULT &&
 
                                    (control_state == MULT_PROC1  ||
 
                                     control_state == MULT_PROC2  ||
 
                                     instruction_valid && !interrupt )) ;
 
assign branch                    = type == BRANCH;
 
assign opcode_compare =
 
            opcode == CMP ||
 
            opcode == CMN ||
 
            opcode == TEQ ||
 
            opcode == TST ;
 
 
 
 
 
assign mem_op               = type == TRANS;
 
assign load_op              = mem_op && instruction[20];
 
assign store_op             = mem_op && !instruction[20];
 
assign write_pc             = pc_wen_nxt && pc_sel_nxt != 2'd0;
 
assign regop_set_flags      = type == REGOP && instruction[20];
 
 
 
assign mem_op_pre_indexed   =  instruction[24] && instruction[21];
 
assign mem_op_post_indexed  = !instruction[24];
 
 
 
assign imm32_nxt            =  // add 0 to Rm
 
                               type == MULT               ? {  32'd0                      } :
 
 
 
                               // 4 x number of registers
 
                               type == MTRANS             ? {  mtrans_base_reg_change     } :
 
                               type == BRANCH             ? {  offset24                   } :
 
                               type == TRANS              ? {  offset12                   } :
 
                               instruction[11:8] == 4'h0  ? {            24'h0, imm8[7:0] } :
 
                               instruction[11:8] == 4'h1  ? { imm8[1:0], 24'h0, imm8[7:2] } :
 
                               instruction[11:8] == 4'h2  ? { imm8[3:0], 24'h0, imm8[7:4] } :
 
                               instruction[11:8] == 4'h3  ? { imm8[5:0], 24'h0, imm8[7:6] } :
 
                               instruction[11:8] == 4'h4  ? { imm8[7:0], 24'h0            } :
 
                               instruction[11:8] == 4'h5  ? { 2'h0,  imm8[7:0], 22'h0     } :
 
                               instruction[11:8] == 4'h6  ? { 4'h0,  imm8[7:0], 20'h0     } :
 
                               instruction[11:8] == 4'h7  ? { 6'h0,  imm8[7:0], 18'h0     } :
 
                               instruction[11:8] == 4'h8  ? { 8'h0,  imm8[7:0], 16'h0     } :
 
                               instruction[11:8] == 4'h9  ? { 10'h0, imm8[7:0], 14'h0     } :
 
                               instruction[11:8] == 4'ha  ? { 12'h0, imm8[7:0], 12'h0     } :
 
                               instruction[11:8] == 4'hb  ? { 14'h0, imm8[7:0], 10'h0     } :
 
                               instruction[11:8] == 4'hc  ? { 16'h0, imm8[7:0], 8'h0      } :
 
                               instruction[11:8] == 4'hd  ? { 18'h0, imm8[7:0], 6'h0      } :
 
                               instruction[11:8] == 4'he  ? { 20'h0, imm8[7:0], 4'h0      } :
 
                                                            { 22'h0, imm8[7:0], 2'h0      } ;
 
 
 
 
 
assign imm_shift_amount_nxt = shift_imm ;
 
 
 
       // This signal is encoded in the decode stage because 
 
       // it is on the critical path in the execute stage
 
assign shift_imm_zero_nxt   = imm_shift_amount_nxt == 5'd0 &&       // immediate amount = 0
 
                              barrel_shift_amount_sel_nxt == 2'd2;  // shift immediate amount
 
 
 
assign alu_function_nxt     = { alu_swap_sel_nxt,
 
                                alu_not_sel_nxt,
 
                                alu_cin_sel_nxt,
 
                                alu_cout_sel_nxt,
 
                                alu_out_sel_nxt  };
 
 
 
 
 
// ========================================================
 
// MTRANS Operations
 
// ========================================================
 
 
 
   // Bit 15 = r15
 
   // Bit 0  = R0
 
   // In LDM and STM instructions R0 is loaded or stored first 
 
always @*
 
    casez (instruction[15:0])
 
    16'b???????????????1 : mtrans_reg = 4'h0 ;
 
    16'b??????????????10 : mtrans_reg = 4'h1 ;
 
    16'b?????????????100 : mtrans_reg = 4'h2 ;
 
    16'b????????????1000 : mtrans_reg = 4'h3 ;
 
    16'b???????????10000 : mtrans_reg = 4'h4 ;
 
    16'b??????????100000 : mtrans_reg = 4'h5 ;
 
    16'b?????????1000000 : mtrans_reg = 4'h6 ;
 
    16'b????????10000000 : mtrans_reg = 4'h7 ;
 
    16'b???????100000000 : mtrans_reg = 4'h8 ;
 
    16'b??????1000000000 : mtrans_reg = 4'h9 ;
 
    16'b?????10000000000 : mtrans_reg = 4'ha ;
 
    16'b????100000000000 : mtrans_reg = 4'hb ;
 
    16'b???1000000000000 : mtrans_reg = 4'hc ;
 
    16'b??10000000000000 : mtrans_reg = 4'hd ;
 
    16'b?100000000000000 : mtrans_reg = 4'he ;
 
    default              : mtrans_reg = 4'hf ;
 
    endcase
 
 
 
always @*
 
    casez (instruction[15:0])
 
    16'b???????????????1 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 1],  1'd0};
 
    16'b??????????????10 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 2],  2'd0};
 
    16'b?????????????100 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 3],  3'd0};
 
    16'b????????????1000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 4],  4'd0};
 
    16'b???????????10000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 5],  5'd0};
 
    16'b??????????100000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 6],  6'd0};
 
    16'b?????????1000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 7],  7'd0};
 
    16'b????????10000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 8],  8'd0};
 
    16'b???????100000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 9],  9'd0};
 
    16'b??????1000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:10], 10'd0};
 
    16'b?????10000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:11], 11'd0};
 
    16'b????100000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:12], 12'd0};
 
    16'b???1000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:13], 13'd0};
 
    16'b??10000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:14], 14'd0};
 
    16'b?100000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15   ], 15'd0};
 
    default              : mtrans_instruction_nxt = {instruction[31:16],                     16'd0};
 
    endcase
 
 
 
 
 
// number of registers to be stored
 
assign mtrans_num_registers =   {4'd0, instruction[15]} +
 
                                {4'd0, instruction[14]} +
 
                                {4'd0, instruction[13]} +
 
                                {4'd0, instruction[12]} +
 
                                {4'd0, instruction[11]} +
 
                                {4'd0, instruction[10]} +
 
                                {4'd0, instruction[ 9]} +
 
                                {4'd0, instruction[ 8]} +
 
                                {4'd0, instruction[ 7]} +
 
                                {4'd0, instruction[ 6]} +
 
                                {4'd0, instruction[ 5]} +
 
                                {4'd0, instruction[ 4]} +
 
                                {4'd0, instruction[ 3]} +
 
                                {4'd0, instruction[ 2]} +
 
                                {4'd0, instruction[ 1]} +
 
                                {4'd0, instruction[ 0]} ;
 
 
 
// 4 x number of registers to be stored
 
assign mtrans_base_reg_change = {25'd0, mtrans_num_registers, 2'd0};
 
 
 
// ========================================================
 
// Interrupts
 
// ========================================================
 
 
 
assign firq_request = firq && !i_execute_status_bits[26];
 
assign irq_request  = irq  && !i_execute_status_bits[27];
 
assign swi_request  = type == SWI;
 
assign dabt_request = dabt_reg;
 
 
 
// copro15 and copro13 only supports reg trans opcodes
 
// all other opcodes involving co-processors cause an 
 
// undefined instrution interrupt
 
assign und_request  =   type == CODTRANS ||
 
                        type == COREGOP  ||
 
                      ( type == CORTRANS && instruction[11:8] != 4'd15 );
 
 
 
 
 
  // in order of priority !!                 
 
  // Highest 
 
  // 1 Reset
 
  // 2 Data Abort (including data TLB miss)
 
  // 3 FIRQ
 
  // 4 IRQ
 
  // 5 Prefetch Abort (including prefetch TLB miss)
 
  // 6 Undefined instruction, SWI
 
  // Lowest                        
 
assign next_interrupt = dabt_request     ? 3'd1 :  // Data Abort
 
                        firq_request     ? 3'd2 :  // FIRQ
 
                        irq_request      ? 3'd3 :  // IRQ
 
                        instruction_adex ? 3'd4 :  // Address Exception 
 
                        instruction_iabt ? 3'd5 :  // PreFetch Abort, only triggered 
 
                                                   // if the instruction is used
 
                        und_request      ? 3'd6 :  // Undefined Instruction
 
                        swi_request      ? 3'd7 :  // SWI
 
                                           3'd0 ;  // none             
 
 
 
        // SWI and undefined instructions do not cause an interrupt in the decode
 
        // stage. They only trigger interrupts if they arfe executed, so the
 
        // interrupt is triggered if the execute condition is met in the execute stage
 
assign interrupt      = next_interrupt != 3'd0 &&
 
                        next_interrupt != 3'd7 &&  // SWI
 
                        next_interrupt != 3'd6 ;   // undefined interrupt
 
 
 
 
 
assign interrupt_mode = next_interrupt == 3'd2 ? FIRQ :
 
                        next_interrupt == 3'd3 ? IRQ  :
 
                        next_interrupt == 3'd4 ? SVC  :
 
                        next_interrupt == 3'd5 ? SVC  :
 
                        next_interrupt == 3'd6 ? SVC  :
 
                        next_interrupt == 3'd7 ? SVC  :
 
                        next_interrupt == 3'd1 ? SVC  :
 
                                                 USR  ;
 
 
 
 
 
 
 
 
 
// ========================================================
 
// Generate control signals
 
// ========================================================
 
always @*
 
    begin
 
    // default mode
 
    status_bits_mode_nxt            = i_execute_status_bits[1:0];   // change to mode in execute stage get reflected
 
                                                                    // back to this stage automatically
 
    status_bits_irq_mask_nxt        = o_status_bits_irq_mask;
 
    status_bits_firq_mask_nxt       = o_status_bits_firq_mask;
 
    exclusive_exec_nxt              = 1'd0;
 
    data_access_exec_nxt            = 1'd0;
 
    copro_operation_nxt             = 'd0;
 
 
 
    // Save an instruction to use later
 
    saved_current_instruction_wen   = 1'd0;
 
    pre_fetch_instruction_wen       = 1'd0;
 
    mtrans_r15_nxt                  = mtrans_r15;
 
    restore_base_address_nxt        = restore_base_address;
 
 
 
    // default Mux Select values
 
    barrel_shift_amount_sel_nxt     = 'd0;  // don't shift the input
 
    barrel_shift_data_sel_nxt       = 'd0;  // immediate value
 
    barrel_shift_function_nxt       = 'd0;
 
    multiply_function_nxt           = 'd0;
 
    address_sel_nxt                 = 'd0;
 
    pc_sel_nxt                      = 'd0;
 
    byte_enable_sel_nxt             = 'd0;
 
    status_bits_sel_nxt             = 'd0;
 
    reg_write_sel_nxt               = 'd0;
 
    user_mode_regs_load_nxt         = 'd0;
 
    o_user_mode_regs_store_nxt      = 'd0;
 
 
 
    // ALU Muxes
 
    alu_swap_sel_nxt                = 'd0;
 
    alu_not_sel_nxt                 = 'd0;
 
    alu_cin_sel_nxt                 = 'd0;
 
    alu_cout_sel_nxt                = 'd0;
 
    alu_out_sel_nxt                 = 'd0;
 
 
 
    // default Flop Write Enable values
 
    write_data_wen_nxt              = 'd0;
 
    copro_write_data_wen_nxt        = 'd0;
 
    base_address_wen_nxt            = 'd0;
 
    pc_wen_nxt                      = 'd1;
 
    reg_bank_wen_nxt                = 'd0;  // Don't select any
 
    status_bits_flags_wen_nxt       = 'd0;
 
    status_bits_mode_wen_nxt        = 'd0;
 
    status_bits_irq_mask_wen_nxt    = 'd0;
 
    status_bits_firq_mask_wen_nxt   = 'd0;
 
 
 
    if ( instruction_valid && !interrupt )
 
        begin
 
        if ( type == REGOP )
 
            begin
 
            if ( !opcode_compare )
 
                begin
 
                // Check is the load destination is the PC
 
                if (instruction[15:12]  == 4'd15)
 
                    begin
 
                    pc_sel_nxt      = 2'd1; // alu_out
 
                    address_sel_nxt = 4'd1; // alu_out
 
                    end
 
                else
 
                    reg_bank_wen_nxt = decode (instruction[15:12]);
 
                end
 
 
 
            if ( !immediate_shifter_operand )
 
                barrel_shift_function_nxt  = instruction[6:5];
 
 
 
            if ( !immediate_shifter_operand )
 
                barrel_shift_data_sel_nxt = 2'd2; // Shift value from Rm register
 
 
 
            if ( !immediate_shifter_operand && instruction[4] )
 
                barrel_shift_amount_sel_nxt = 2'd1; // Shift amount from Rs registter
 
 
 
            if ( !immediate_shifter_operand && !instruction[4] )
 
                barrel_shift_amount_sel_nxt = 2'd2; // Shift immediate amount 
 
 
 
            if ( opcode == ADD || opcode == CMN )   // CMN is just like an ADD
 
                begin
 
                alu_out_sel_nxt  = 4'd1; // Add
 
                end
 
 
 
            if ( opcode == ADC ) // Add with Carry
 
                begin
 
                alu_out_sel_nxt  = 4'd1; // Add
 
                alu_cin_sel_nxt  = 2'd2; // carry in from status_bits
 
                end
 
 
 
            if ( opcode == SUB || opcode == CMP ) // Subtract
 
                begin
 
                alu_out_sel_nxt  = 4'd1; // Add
 
                alu_cin_sel_nxt  = 2'd1; // cin = 1
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                end
 
 
 
            // SBC (Subtract with Carry) subtracts the value of its 
 
            // second operand and the value of NOT(Carry flag) from
 
            // the value of its first operand.
 
            //  Rd = Rn - shifter_operand - NOT(C Flag)
 
            if ( opcode == SBC ) // Subtract with Carry
 
                begin
 
                alu_out_sel_nxt  = 4'd1; // Add
 
                alu_cin_sel_nxt  = 2'd2; // carry in from status_bits
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                end
 
 
 
            if ( opcode == RSB ) // Reverse Subtract
 
                begin
 
                alu_out_sel_nxt  = 4'd1; // Add
 
                alu_cin_sel_nxt  = 2'd1; // cin = 1
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                alu_swap_sel_nxt = 1'd1; // swap A and B
 
                end
 
 
 
            if ( opcode == RSC ) // Reverse Subtract with carry
 
                begin
 
                alu_out_sel_nxt  = 4'd1; // Add
 
                alu_cin_sel_nxt  = 2'd2; // carry in from status_bits
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                alu_swap_sel_nxt = 1'd1; // swap A and B
 
                end
 
 
 
            if ( opcode == AND || opcode == TST ) // Logical AND, Test  (using AND operator)
 
                begin
 
                alu_out_sel_nxt  = 4'd8;  // AND
 
                alu_cout_sel_nxt = 1'd1;  // i_barrel_shift_carry
 
                end
 
 
 
            if ( opcode == EOR || opcode == TEQ ) // Logical Exclusive OR, Test Equivalence (using EOR operator)
 
                begin
 
                alu_out_sel_nxt = 4'd6;  // XOR
 
                alu_cout_sel_nxt = 1'd1; // i_barrel_shift_carry
 
                end
 
 
 
            if ( opcode == ORR )
 
                begin
 
                alu_out_sel_nxt  = 4'd7; // OR
 
                alu_cout_sel_nxt = 1'd1;  // i_barrel_shift_carry
 
                end
 
 
 
            if ( opcode == BIC ) // Bit Clear (using AND & NOT operators)
 
                begin
 
                alu_out_sel_nxt  = 4'd8;  // AND
 
                alu_not_sel_nxt  = 1'd1;  // invert B
 
                alu_cout_sel_nxt = 1'd1;  // i_barrel_shift_carry
 
                end
 
 
 
            if ( opcode == MOV ) // Move
 
                begin
 
                alu_cout_sel_nxt = 1'd1;  // i_barrel_shift_carry
 
                end
 
 
 
            if ( opcode == MVN ) // Move NOT
 
                begin
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                alu_cout_sel_nxt = 1'd1;  // i_barrel_shift_carry
 
                end
 
            end
 
 
 
        // Load & Store instructions
 
        if ( mem_op )
 
            begin
 
            saved_current_instruction_wen   = 1'd1; // Save the memory access instruction to refer back to later
 
            pc_wen_nxt                      = 1'd0; // hold current PC value
 
            data_access_exec_nxt            = 1'd1; // indicate that its a data read or write, 
 
                                                    // rather than an instruction fetch
 
            alu_out_sel_nxt                 = 4'd1; // Add
 
 
 
            if ( !instruction[23] )  // U: Subtract offset
 
                begin
 
                alu_cin_sel_nxt  = 2'd1; // cin = 1
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                end
 
 
 
            if ( store_op )
 
                begin
 
                write_data_wen_nxt = 1'd1;
 
                if ( type == TRANS && instruction[22] )
 
                    byte_enable_sel_nxt = 2'd1;         // Save byte
 
                end
 
 
 
                // need to update the register holding the address ?
 
                // This is Rn bits [19:16]
 
            if ( mem_op_pre_indexed || mem_op_post_indexed )
 
                begin
 
                // Check is the load destination is the PC
 
                if ( rn_sel_nxt  == 4'd15 )
 
                    pc_sel_nxt = 2'd1;
 
                else
 
                    reg_bank_wen_nxt = decode ( rn_sel_nxt );
 
                end
 
 
 
                // if post-indexed, then use Rn rather than ALU output, as address
 
            if ( mem_op_post_indexed )
 
               address_sel_nxt = 4'd4; // Rn
 
            else
 
               address_sel_nxt = 4'd1; // alu out
 
 
 
            if ( instruction[25] && type ==  TRANS )
 
                barrel_shift_data_sel_nxt = 2'd2; // Shift value from Rm register
 
 
 
            if ( type == TRANS && instruction[25] && shift_imm != 5'd0 )
 
                begin
 
                barrel_shift_function_nxt   = instruction[6:5];
 
                barrel_shift_amount_sel_nxt = 2'd2; // imm_shift_amount
 
                end
 
            end
 
 
 
        if ( type == BRANCH )
 
            begin
 
            pc_sel_nxt      = 2'd1; // alu_out
 
            address_sel_nxt = 4'd1; // alu_out
 
            alu_out_sel_nxt = 4'd1; // Add
 
 
 
            if ( instruction[24] ) // Link
 
                begin
 
                reg_bank_wen_nxt  = decode (4'd14);  // Save PC to LR
 
                reg_write_sel_nxt = 3'd1;            // pc - 32'd4
 
                end
 
            end
 
 
 
        if ( type == MTRANS )
 
            begin
 
            saved_current_instruction_wen   = 1'd1; // Save the memory access instruction to refer back to later
 
            pc_wen_nxt                      = 1'd0; // hold current PC value
 
            data_access_exec_nxt            = 1'd1; // indicate that its a data read or write, 
 
                                                    // rather than an instruction fetch
 
            alu_out_sel_nxt                 = 4'd1; // Add
 
            mtrans_r15_nxt                  = instruction[15];  // load or save r15 ?
 
            base_address_wen_nxt            = 1'd1; // Save the value of the register used for the base address,
 
                                                    // in case of a data abort, and need to restore the value        
 
 
 
            // The spec says -
 
            // If the instruction would have overwritten the base with data 
 
            // (that is, it has the base in the transfer list), the overwriting is prevented.
 
            // This is true even when the abort occurs after the base word gets loaded
 
            restore_base_address_nxt        = instruction[20] &&
 
                                                (instruction[15:0] & (1'd1 << instruction[19:16]));
 
 
 
            // Increment or Decrement
 
            if ( instruction[23] ) // increment
 
                begin
 
                if ( instruction[24] )    // increment before
 
                    address_sel_nxt = 4'd7; // Rn + 4
 
                else
 
                    address_sel_nxt = 4'd4; // Rn
 
                end
 
            else // decrement
 
                begin
 
                alu_cin_sel_nxt  = 2'd1; // cin = 1
 
                alu_not_sel_nxt  = 1'd1; // invert B
 
                if ( !instruction[24] )    // decrement after
 
                    address_sel_nxt  = 4'd6; // alu out + 4
 
                else
 
                    address_sel_nxt  = 4'd1; // alu out
 
                end
 
 
 
            // Load or store ?
 
            if ( !instruction[20] )  // Store
 
                write_data_wen_nxt = 1'd1;
 
 
 
            // LDM: load into user mode registers, when in priviledged mode  
 
            // DOnt use mtrans_r15 here because its not loaded yet   
 
            if ( {instruction[22:20],instruction[15]} == 4'b1010 )
 
                user_mode_regs_load_nxt = 1'd1;
 
 
 
            // SDM: store the user mode registers, when in priviledged mode     
 
            if ( {instruction[22:20]} == 3'b100 )
 
                o_user_mode_regs_store_nxt = 1'd1;
 
 
 
            // update the base register ?
 
            if ( instruction[21] )  // the W bit
 
                reg_bank_wen_nxt  = decode (rn_sel_nxt);
 
            end
 
 
 
 
 
        if ( type == MULT )
 
            begin
 
            multiply_function_nxt[0]        = 1'd1; // set enable
 
                                                    // some bits can be changed just below
 
            saved_current_instruction_wen   = 1'd1; // Save the Multiply instruction to 
 
                                                    // refer back to later
 
            pc_wen_nxt                      = 1'd0; // hold current PC value
 
 
 
            if ( instruction[21] )
 
                multiply_function_nxt[1]    = 1'd1; // accumulate
 
            end
 
 
 
 
 
        // swp - do read part first
 
        if ( type == SWAP )
 
            begin
 
            saved_current_instruction_wen   = 1'd1; // Save the memory access instruction to refer back to later
 
            pc_wen_nxt                      = 1'd0; // hold current PC value
 
            data_access_exec_nxt            = 1'd1; // indicate that its a data read or write, 
 
                                                    // rather than an instruction fetch
 
            barrel_shift_data_sel_nxt       = 2'd2; // Shift value from Rm register
 
            address_sel_nxt                 = 4'd4; // Rn
 
            exclusive_exec_nxt              = 1'd1; // signal an exclusive access
 
            end
 
 
 
 
 
        // mcr & mrc - takes two cycles
 
        if ( type == CORTRANS && !und_request )
 
            begin
 
            saved_current_instruction_wen   = 1'd1; // Save the memory access instruction to refer back to later
 
            pc_wen_nxt                      = 1'd0; // hold current PC value
 
            address_sel_nxt                 = 4'd3; // pc  (not pc + 4)
 
 
 
            if ( instruction[20] ) // MRC
 
                copro_operation_nxt         = 2'd1;  // Register transfer from Co-Processor
 
            else // MCR
 
                begin
 
                 // Don't enable operation to Co-Processor until next period
 
                 // So it gets the Rd value from the execution stage at the same time
 
                copro_operation_nxt      = 2'd0;
 
                copro_write_data_wen_nxt = 1'd1;  // Rd register value to co-processor
 
                end
 
            end
 
 
 
 
 
        if ( type == SWI || und_request )
 
            begin
 
            // save address of next instruction to Supervisor Mode LR
 
            reg_write_sel_nxt               = 3'd1;            // pc -4
 
            reg_bank_wen_nxt                = decode (4'd14);  // LR
 
 
 
            address_sel_nxt                 = 4'd2;            // interrupt_vector
 
            pc_sel_nxt                      = 2'd2;            // interrupt_vector
 
 
 
            status_bits_mode_nxt            = interrupt_mode;  // e.g. Supervisor mode
 
            status_bits_mode_wen_nxt        = 1'd1;
 
 
 
            // disable normal interrupts
 
            status_bits_irq_mask_nxt        = 1'd1;
 
            status_bits_irq_mask_wen_nxt    = 1'd1;
 
            end
 
 
 
 
 
        if ( regop_set_flags )
 
            begin
 
            status_bits_flags_wen_nxt = 1'd1;
 
 
 
            // If <Rd> is r15, the ALU output is copied to the Status Bits. 
 
            // Not allowed to use r15 for mul or lma instructions           
 
            if ( instruction[15:12] == 4'd15 )
 
                begin
 
                status_bits_sel_nxt       = 3'd1; // alu out
 
 
 
                // Priviledged mode? Then also update the other status bits
 
                if ( i_execute_status_bits[1:0] != USR )
 
                    begin
 
                    status_bits_mode_wen_nxt      = 1'd1;
 
                    status_bits_irq_mask_wen_nxt  = 1'd1;
 
                    status_bits_firq_mask_wen_nxt = 1'd1;
 
                    end
 
                end
 
            end
 
 
 
        end
 
 
 
    // Handle asynchronous interrupts.
 
    // interrupts are processed only during execution states
 
    // multicycle instructions must complete before the interrupt starts
 
    // SWI, Address Exception and Undefined Instruction interrupts are only executed if the
 
    // instruction that causes the interrupt is conditionally executed so
 
    // its not handled here
 
    if ( instruction_valid && interrupt &&  next_interrupt != 3'd6 )
 
        begin
 
        // Save the interrupt causing instruction to refer back to later
 
        // This also saves the instruction abort vma and status, in the case of an
 
        // instruction abort interrupt
 
        saved_current_instruction_wen   = 1'd1;
 
 
 
        // save address of next instruction to Supervisor Mode LR
 
        // Address Exception ?
 
        if ( next_interrupt == 3'd4 )
 
            reg_write_sel_nxt               = 3'd7;            // pc
 
        else
 
            reg_write_sel_nxt               = 3'd1;            // pc -4
 
 
 
        reg_bank_wen_nxt                = decode (4'd14);  // LR
 
 
 
        address_sel_nxt                 = 4'd2;            // interrupt_vector
 
        pc_sel_nxt                      = 2'd2;            // interrupt_vector
 
 
 
        status_bits_mode_nxt            = interrupt_mode;  // e.g. Supervisor mode
 
        status_bits_mode_wen_nxt        = 1'd1;
 
 
 
        // disable normal interrupts
 
        status_bits_irq_mask_nxt        = 1'd1;
 
        status_bits_irq_mask_wen_nxt    = 1'd1;
 
 
 
        // disable fast interrupts
 
        if ( next_interrupt == 3'd2 ) // FIRQ
 
            begin
 
            status_bits_firq_mask_nxt        = 1'd1;
 
            status_bits_firq_mask_wen_nxt    = 1'd1;
 
            end
 
        end
 
 
 
 
 
    // previous instruction was either ldr or sdr
 
    // if it is currently executing in the execute stage do the following    
 
    if ( control_state == MEM_WAIT1 )
 
        begin
 
        // Save the next instruction to execute later
 
        // Do this even if this instruction does not execute because of Condition
 
        pre_fetch_instruction_wen   = 1'd1;
 
 
 
        if ( instruction_execute ) // conditional execution state
 
            begin
 
            address_sel_nxt             = 4'd3; // pc  (not pc + 4)
 
            pc_wen_nxt                  = 1'd0; // hold current PC value
 
            end
 
        end
 
 
 
 
 
    // completion of load operation        
 
    if ( control_state == MEM_WAIT2 && load_op )
 
        begin
 
        barrel_shift_data_sel_nxt   = 2'd1;  // load word from memory
 
        barrel_shift_amount_sel_nxt = 2'd3;  // shift by address[1:0] x 8
 
 
 
        // shift needed
 
        if ( i_execute_address[1:0] != 2'd0 )
 
            barrel_shift_function_nxt = ROR;
 
 
 
        // load a byte            
 
        if ( type == TRANS && instruction[22] )
 
            alu_out_sel_nxt             = 4'd3;  // zero_extend8
 
 
 
        if ( !dabt )  // dont load data there is an abort on the data read
 
            begin
 
            // Check if the load destination is the PC
 
            if (instruction[15:12]  == 4'd15)
 
                begin
 
                pc_sel_nxt      = 2'd1; // alu_out
 
                address_sel_nxt = 4'd1; // alu_out
 
                end
 
            else
 
                reg_bank_wen_nxt = decode (instruction[15:12]);
 
            end
 
        end
 
 
 
 
 
    // second cycle of multiple load or store
 
    if ( control_state == MTRANS_EXEC1 )
 
        begin
 
        // Save the next instruction to execute later
 
        // Do this even if this instruction does not execute because of Condition
 
        pre_fetch_instruction_wen   = 1'd1;
 
 
 
        if ( instruction_execute ) // conditional execution state
 
            begin
 
            address_sel_nxt             = 4'd5;  // o_address
 
            pc_wen_nxt                  = 1'd0;  // hold current PC value
 
            data_access_exec_nxt        = 1'd1;  // indicate that its a data read or write, 
 
                                                 // rather than an instruction fetch
 
 
 
            if ( !instruction[20] ) // Store
 
                write_data_wen_nxt = 1'd1;
 
 
 
            // LDM: load into user mode registers, when in priviledged mode     
 
            if ( {instruction[22:20],mtrans_r15} == 4'b1010 )
 
                user_mode_regs_load_nxt = 1'd1;
 
 
 
            // SDM: store the user mode registers, when in priviledged mode     
 
            if ( {instruction[22:20]} == 3'b100 )
 
                o_user_mode_regs_store_nxt = 1'd1;
 
            end
 
        end
 
 
 
 
 
        // third cycle of multiple load or store
 
    if ( control_state == MTRANS_EXEC2 )
 
        begin
 
        address_sel_nxt             = 4'd5;  // o_address
 
        pc_wen_nxt                  = 1'd0;  // hold current PC value
 
        data_access_exec_nxt        = 1'd1;  // indicate that its a data read or write, 
 
                                             // rather than an instruction fetch
 
        barrel_shift_data_sel_nxt   = 2'd1;  // load word from memory
 
 
 
        // Load or Store
 
        if ( instruction[20] ) // Load
 
            begin
 
            // Can never be loading the PC in this state, as the PC is always
 
            // the last register in the set to be loaded
 
            if ( !dabt )
 
                reg_bank_wen_nxt = decode (mtrans_reg_d2);
 
            end
 
        else // Store
 
            write_data_wen_nxt = 1'd1;
 
 
 
        // LDM: load into user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20],mtrans_r15} == 4'b1010 )
 
            user_mode_regs_load_nxt = 1'd1;
 
 
 
        // SDM: store the user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20]} == 3'b100 )
 
            o_user_mode_regs_store_nxt = 1'd1;
 
        end
 
 
 
 
 
        // second or fourth cycle of multiple load or store
 
    if ( control_state == MTRANS_EXEC3 && instruction_execute )
 
        begin
 
        address_sel_nxt             = 4'd3; // pc  (not pc + 4)
 
        pc_wen_nxt                  = 1'd0;  // hold current PC value
 
        barrel_shift_data_sel_nxt   = 2'd1;  // load word from memory
 
 
 
        // Can never be loading the PC in this state, as the PC is always
 
        // the last register in the set to be loaded
 
        if ( instruction[20] && !dabt ) // Load
 
            reg_bank_wen_nxt = decode (mtrans_reg_d2);
 
 
 
        // LDM: load into user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20],mtrans_r15} == 4'b1010 )
 
            user_mode_regs_load_nxt = 1'd1;
 
 
 
        // SDM: store the user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20]} == 3'b100 )
 
            o_user_mode_regs_store_nxt = 1'd1;
 
       end
 
 
 
    // state is used for LMD/STM of a single register
 
    if ( control_state == MTRANS_EXEC3B && instruction_execute )
 
        begin
 
        // Save the next instruction to execute later
 
        // Do this even if this instruction does not execute because of Condition
 
        pre_fetch_instruction_wen   = 1'd1;
 
 
 
        address_sel_nxt             = 4'd3;  // pc  (not pc + 4)
 
        pc_wen_nxt                  = 1'd0;  // hold current PC value
 
 
 
        // LDM: load into user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20],mtrans_r15} == 4'b1010 )
 
            user_mode_regs_load_nxt = 1'd1;
 
 
 
        // SDM: store the user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20]} == 3'b100 )
 
            o_user_mode_regs_store_nxt = 1'd1;
 
        end
 
 
 
    if ( control_state == MTRANS_EXEC4 )
 
        begin
 
        barrel_shift_data_sel_nxt   = 2'd1;  // load word from memory
 
 
 
        if ( instruction[20] ) // Load
 
            begin
 
            if (!dabt) // dont overwrite registers or status if theres a data abort
 
                begin
 
                if ( mtrans_reg_d2 == 4'd15 ) // load new value into PC
 
                    begin
 
                    address_sel_nxt = 4'd1; // alu_out - read instructions using new PC value
 
                    pc_sel_nxt      = 2'd1; // alu_out
 
                    pc_wen_nxt      = 1'd1; // write PC
 
 
 
                    // ldm with S bit and pc: the Status bits are updated
 
                    // Node this must be done only at the end
 
                    // so the register set is the set in the mode before it
 
                    // gets changed. 
 
                    if ( instruction[22] )
 
                         begin
 
                         status_bits_sel_nxt           = 3'd1; // alu out
 
                         status_bits_flags_wen_nxt     = 1'd1;
 
 
 
                         // Can't change the mode or mask bits in User mode
 
                         if ( i_execute_status_bits[1:0] != USR )
 
                            begin
 
                            status_bits_mode_wen_nxt      = 1'd1;
 
                            status_bits_irq_mask_wen_nxt  = 1'd1;
 
                            status_bits_firq_mask_wen_nxt = 1'd1;
 
                            end
 
                         end
 
                    end
 
                else
 
                    begin
 
                    reg_bank_wen_nxt = decode (mtrans_reg_d2);
 
                    end
 
                end
 
            end
 
 
 
           // we have a data abort interrupt
 
        if ( dabt )
 
            begin
 
            pc_wen_nxt = 1'd0;  // hold current PC value
 
            end
 
 
 
        // LDM: load into user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20],mtrans_r15} == 4'b1010 )
 
            user_mode_regs_load_nxt = 1'd1;
 
 
 
        // SDM: store the user mode registers, when in priviledged mode     
 
        if ( {instruction[22:20]} == 3'b100 )
 
            o_user_mode_regs_store_nxt = 1'd1;
 
        end
 
 
 
 
 
    // state is for when a data abort interrupt is triggered during an LDM
 
    if ( control_state == MTRANS5_ABORT )
 
        begin
 
        // Restore the Base Address, if the base register is included in the
 
        // list of registers being loaded
 
        if (restore_base_address) // LDM with base address in register list
 
            begin
 
            reg_write_sel_nxt = 3'd6;                        // write base_register
 
            reg_bank_wen_nxt  = decode ( instruction[19:16] ); // to Rn
 
            end
 
        end
 
 
 
 
 
        // Multiply or Multiply-Accumulate
 
    if ( control_state == MULT_PROC1 && instruction_execute )
 
        begin
 
        // Save the next instruction to execute later
 
        // Do this even if this instruction does not execute because of Condition
 
        pre_fetch_instruction_wen   = 1'd1;
 
        pc_wen_nxt                  = 1'd0;  // hold current PC value
 
        multiply_function_nxt       = o_multiply_function;
 
        end
 
 
 
 
 
        // Multiply or Multiply-Accumulate
 
        // Do multiplication
 
        // Wait for done or accumulate signal
 
    if ( control_state == MULT_PROC2 )
 
        begin
 
        // Save the next instruction to execute later
 
        // Do this even if this instruction does not execute because of Condition
 
        pc_wen_nxt              = 1'd0;  // hold current PC value
 
        address_sel_nxt         = 4'd3;  // pc  (not pc + 4)
 
        multiply_function_nxt   = o_multiply_function;
 
        end
 
 
 
 
 
    // Save RdLo
 
    // always last cycle of all multiply or multiply accumulate operations
 
    if ( control_state == MULT_STORE )
 
        begin
 
        reg_write_sel_nxt     = 3'd2; // multiply_out
 
        multiply_function_nxt = o_multiply_function;
 
 
 
        if ( type == MULT ) // 32-bit
 
            reg_bank_wen_nxt      = decode (instruction[19:16]); // Rd
 
        else  // 64-bit / Long
 
            reg_bank_wen_nxt      = decode (instruction[15:12]); // RdLo
 
 
 
        if ( instruction[20] )  // the 'S' bit
 
            begin
 
            status_bits_sel_nxt       = 3'd4; // { multiply_flags, status_bits_flags[1:0] } 
 
            status_bits_flags_wen_nxt = 1'd1;
 
            end
 
        end
 
 
 
        // Add lower 32 bits to multiplication product
 
    if ( control_state == MULT_ACCUMU )
 
        begin
 
        multiply_function_nxt = o_multiply_function;
 
        pc_wen_nxt            = 1'd0;  // hold current PC value
 
        address_sel_nxt       = 4'd3;  // pc  (not pc + 4)
 
        end
 
 
 
    // swp - do write request in 2nd cycle
 
    if ( control_state == SWAP_WRITE && instruction_execute )
 
        begin
 
        barrel_shift_data_sel_nxt       = 2'd2; // Shift value from Rm register
 
        address_sel_nxt                 = 4'd4; // Rn
 
        write_data_wen_nxt              = 1'd1;
 
        data_access_exec_nxt            = 1'd1; // indicate that its a data read or write, 
 
                                                // rather than an instruction fetch
 
 
 
        if ( instruction[22] )
 
            byte_enable_sel_nxt = 2'd1;         // Save byte
 
 
 
        if ( instruction_execute )                         // conditional execution state
 
            pc_wen_nxt                  = 1'd0; // hold current PC value
 
 
 
        // Save the next instruction to execute later
 
        // Do this even if this instruction does not execute because of Condition
 
        pre_fetch_instruction_wen   = 1'd1;
 
 
 
        end
 
 
 
 
 
    // swp - receive read response in 3rd cycle
 
    if ( control_state == SWAP_WAIT1 )
 
        begin
 
        barrel_shift_data_sel_nxt   = 2'd1;  // load word from memory
 
        barrel_shift_amount_sel_nxt = 2'd3;  // shift by address[1:0] x 8
 
 
 
        // shift needed
 
        if ( i_execute_address[1:0] != 2'd0 )
 
            barrel_shift_function_nxt = ROR;
 
 
 
        if ( instruction_execute ) // conditional execution state
 
            begin
 
            address_sel_nxt             = 4'd3; // pc  (not pc + 4)
 
            pc_wen_nxt                  = 1'd0; // hold current PC value
 
            end
 
 
 
        // load a byte            
 
        if ( instruction[22] )
 
            alu_out_sel_nxt = 4'd3;  // zero_extend8
 
 
 
        if ( !dabt )
 
            begin
 
            // Check is the load destination is the PC
 
            if ( instruction[15:12]  == 4'd15 )
 
                begin
 
                pc_sel_nxt      = 2'd1; // alu_out
 
                address_sel_nxt = 4'd1; // alu_out
 
                end
 
            else
 
                reg_bank_wen_nxt = decode (instruction[15:12]);
 
            end
 
        end
 
 
 
    // 1 cycle delay for Co-Processor Register access
 
    if ( control_state == COPRO_WAIT && instruction_execute )
 
        begin
 
        pre_fetch_instruction_wen = 1'd1;
 
 
 
        if ( instruction[20] ) // mrc instruction
 
            begin
 
            // Check is the load destination is the PC
 
            if ( instruction[15:12]  == 4'd15 )
 
                begin
 
                // If r15 is specified for <Rd>, the condition code flags are 
 
                // updated instead of a general-purpose register.
 
                status_bits_sel_nxt           = 3'd3;  // i_copro_data
 
                status_bits_flags_wen_nxt     = 1'd1;
 
 
 
                // Can't change these in USR mode
 
                if ( i_execute_status_bits[1:0] != USR )
 
                   begin
 
                   status_bits_mode_wen_nxt      = 1'd1;
 
                   status_bits_irq_mask_wen_nxt  = 1'd1;
 
                   status_bits_firq_mask_wen_nxt = 1'd1;
 
                   end
 
                end
 
            else
 
                reg_bank_wen_nxt = decode (instruction[15:12]);
 
 
 
            reg_write_sel_nxt = 3'd5;     // i_copro_data
 
            end
 
        else // mcr instruction
 
            begin
 
            copro_operation_nxt      = 2'd2;  // Register transfer to Co-Processor 
 
            end
 
        end
 
 
 
 
 
    // Have just changed the status_bits mode but this
 
    // creates a 1 cycle gap with the old mode
 
    // coming back from execute into instruction_decode
 
    // So squash that old mode value during this
 
    // cycle of the interrupt transition    
 
    if ( control_state == INT_WAIT1 )
 
        status_bits_mode_nxt            = o_status_bits_mode;   // Supervisor mode
 
 
 
    end
 
 
 
 
 
// Speed up the long path from u_decode/o_read_data to u_register_bank/r8_firq
 
// This pre-encodes the firq_s3 signal thats used in u_register_bank
 
assign firq_not_user_mode_nxt = !user_mode_regs_load_nxt && status_bits_mode_nxt == FIRQ;
 
 
 
 
 
// ========================================================
 
// Next State Logic
 
// ========================================================
 
 
 
// this replicates the current value of the execute signal in the execute stage
 
assign instruction_execute = conditional_execute ( o_condition, i_execute_status_bits[31:28] );
 
 
 
assign instruction_valid = (control_state == EXECUTE || control_state == PRE_FETCH_EXEC) ||
 
                     // when last instruction was multi-cycle instruction but did not execute
 
                     // because condition was false then act like you're in the execute state
 
                    (!instruction_execute && (control_state == PC_STALL1    ||
 
                                              control_state == MEM_WAIT1    ||
 
                                              control_state == COPRO_WAIT   ||
 
                                              control_state == SWAP_WRITE   ||
 
                                              control_state == MULT_PROC1   ||
 
                                              control_state == MTRANS_EXEC1 ||
 
                                              control_state == MTRANS_EXEC3 ||
 
                                              control_state == MTRANS_EXEC3B  ) );
 
 
 
 
 
 always @*
 
    begin
 
    // default is to hold the current state
 
    control_state_nxt = control_state;
 
 
 
    // Note: The order is important here
 
    if ( control_state == RST_WAIT1 )     control_state_nxt = RST_WAIT2;
 
    if ( control_state == RST_WAIT2 )     control_state_nxt = EXECUTE;
 
    if ( control_state == INT_WAIT1 )     control_state_nxt = INT_WAIT2;
 
    if ( control_state == INT_WAIT2 )     control_state_nxt = EXECUTE;
 
    if ( control_state == COPRO_WAIT )    control_state_nxt = PRE_FETCH_EXEC;
 
    if ( control_state == PC_STALL1 )     control_state_nxt = PC_STALL2;
 
    if ( control_state == PC_STALL2 )     control_state_nxt = EXECUTE;
 
    if ( control_state == SWAP_WRITE )    control_state_nxt = SWAP_WAIT1;
 
    if ( control_state == SWAP_WAIT1 )    control_state_nxt = SWAP_WAIT2;
 
    if ( control_state == MULT_STORE )    control_state_nxt = PRE_FETCH_EXEC;
 
    if ( control_state == MTRANS5_ABORT ) control_state_nxt = PRE_FETCH_EXEC;
 
 
 
    if ( control_state == MEM_WAIT1 )
 
        control_state_nxt = MEM_WAIT2;
 
 
 
    if ( control_state == MEM_WAIT2   ||
 
        control_state == SWAP_WAIT2    )
 
        begin
 
        if ( write_pc ) // writing to the PC!! 
 
            control_state_nxt = PC_STALL1;
 
        else
 
            control_state_nxt = PRE_FETCH_EXEC;
 
        end
 
 
 
    if ( control_state == MTRANS_EXEC1 )
 
        begin
 
        if (mtrans_instruction_nxt[15:0] != 16'd0)
 
            control_state_nxt = MTRANS_EXEC2;
 
        else   // if the register list holds a single register 
 
            control_state_nxt = MTRANS_EXEC3;
 
        end
 
 
 
        // Stay in State MTRANS_EXEC2 until the full list of registers to
 
        // load or store has been processed
 
    if ( control_state == MTRANS_EXEC2 && mtrans_num_registers == 5'd1 )
 
        control_state_nxt = MTRANS_EXEC3;
 
 
 
    if ( control_state == MTRANS_EXEC3 )     control_state_nxt = MTRANS_EXEC4;
 
 
 
    if ( control_state == MTRANS_EXEC3B )    control_state_nxt = MTRANS_EXEC4;
 
 
 
    if ( control_state == MTRANS_EXEC4  )
 
        begin
 
        if ( dabt ) // data abort
 
            control_state_nxt = MTRANS5_ABORT;
 
        else if (write_pc) // writing to the PC!! 
 
            control_state_nxt = PC_STALL1;
 
        else
 
            control_state_nxt = PRE_FETCH_EXEC;
 
        end
 
 
 
    if ( control_state == MULT_PROC1 )
 
        begin
 
        if (!instruction_execute)
 
            control_state_nxt = PRE_FETCH_EXEC;
 
        else
 
            control_state_nxt = MULT_PROC2;
 
        end
 
 
 
    if ( control_state == MULT_PROC2 )
 
        begin
 
        if ( i_multiply_done )
 
            if      ( o_multiply_function[1] )  // Accumulate ?
 
                control_state_nxt = MULT_ACCUMU;
 
            else
 
                control_state_nxt = MULT_STORE;
 
        end
 
 
 
 
 
    if ( control_state == MULT_ACCUMU )
 
        begin
 
        control_state_nxt = MULT_STORE;
 
        end
 
 
 
 
 
    // This should come at the end, so that conditional execution works
 
    // correctly
 
    if ( instruction_valid )
 
        begin
 
        // default is to stay in execute state, or to move into this
 
        // state from a conditional execute state
 
        control_state_nxt = EXECUTE;
 
 
 
        if ( mem_op )  // load or store word or byte
 
             control_state_nxt = MEM_WAIT1;
 
        if ( write_pc )
 
             control_state_nxt = PC_STALL1;
 
        if ( type == MTRANS )
 
            begin
 
            if ( mtrans_num_registers != 5'd0 )
 
                begin
 
                // check for LDM/STM of a single register
 
                if ( mtrans_num_registers == 5'd1 )
 
                    control_state_nxt = MTRANS_EXEC3B;
 
                else
 
                    control_state_nxt = MTRANS_EXEC1;
 
                end
 
            else
 
                control_state_nxt = MTRANS_EXEC3;
 
            end
 
 
 
        if ( type == MULT )
 
                control_state_nxt = MULT_PROC1;
 
 
 
        if ( type == SWAP )
 
                control_state_nxt = SWAP_WRITE;
 
 
 
        if ( type == CORTRANS && !und_request )
 
                control_state_nxt = COPRO_WAIT;
 
 
 
         // interrupt overrides everything else so its last       
 
        if ( interrupt )
 
                control_state_nxt = INT_WAIT1;
 
        end
 
    end
 
 
 
 
 
// ========================================================
 
// Register Update
 
// ========================================================
 
always @ ( posedge i_clk )
 
    if (!i_fetch_stall)
 
        begin
 
        o_read_data                 <= i_read_data;
 
        o_read_data_alignment       <= {i_execute_address[1:0], 3'd0};
 
        abt_address_reg             <= i_execute_address;
 
        iabt_reg                    <= i_iabt;
 
        adex_reg                    <= i_adex;
 
        abt_status_reg              <= i_abt_status;
 
        o_status_bits_mode          <= status_bits_mode_nxt;
 
        o_status_bits_irq_mask      <= status_bits_irq_mask_nxt;
 
        o_status_bits_firq_mask     <= status_bits_firq_mask_nxt;
 
        o_imm32                     <= imm32_nxt;
 
        o_imm_shift_amount          <= imm_shift_amount_nxt;
 
        o_shift_imm_zero            <= shift_imm_zero_nxt;
 
 
 
                                        // when have an interrupt, execute the interrupt operation
 
                                        // unconditionally in the execute stage
 
                                        // ensures that status_bits register gets updated correctly
 
                                        // Likewise when in middle of multi-cycle instructions
 
                                        // execute them unconditionally
 
        o_condition                 <= instruction_valid && !interrupt ? condition_nxt : AL;
 
        o_exclusive_exec            <= exclusive_exec_nxt;
 
        o_data_access_exec          <= data_access_exec_nxt;
 
 
 
        o_rm_sel                    <= rm_sel_nxt;
 
        o_rds_sel                   <= rds_sel_nxt;
 
        o_rn_sel                    <= rn_sel_nxt;
 
        o_barrel_shift_amount_sel   <= barrel_shift_amount_sel_nxt;
 
        o_barrel_shift_data_sel     <= barrel_shift_data_sel_nxt;
 
        o_barrel_shift_function     <= barrel_shift_function_nxt;
 
        o_alu_function              <= alu_function_nxt;
 
        o_multiply_function         <= multiply_function_nxt;
 
        o_interrupt_vector_sel      <= next_interrupt;
 
        o_address_sel               <= address_sel_nxt;
 
        o_pc_sel                    <= pc_sel_nxt;
 
        o_byte_enable_sel           <= byte_enable_sel_nxt;
 
        o_status_bits_sel           <= status_bits_sel_nxt;
 
        o_reg_write_sel             <= reg_write_sel_nxt;
 
        o_user_mode_regs_load       <= user_mode_regs_load_nxt;
 
        o_firq_not_user_mode        <= firq_not_user_mode_nxt;
 
        o_write_data_wen            <= write_data_wen_nxt;
 
        o_base_address_wen          <= base_address_wen_nxt;
 
        o_pc_wen                    <= pc_wen_nxt;
 
        o_reg_bank_wen              <= reg_bank_wen_nxt;
 
        o_status_bits_flags_wen     <= status_bits_flags_wen_nxt;
 
        o_status_bits_mode_wen      <= status_bits_mode_wen_nxt;
 
        o_status_bits_irq_mask_wen  <= status_bits_irq_mask_wen_nxt;
 
        o_status_bits_firq_mask_wen <= status_bits_firq_mask_wen_nxt;
 
 
 
        o_copro_opcode1             <= instruction[23:21];
 
        o_copro_opcode2             <= instruction[7:5];
 
        o_copro_crn                 <= instruction[19:16];
 
        o_copro_crm                 <= instruction[3:0];
 
        o_copro_num                 <= instruction[11:8];
 
        o_copro_operation           <= copro_operation_nxt;
 
        o_copro_write_data_wen      <= copro_write_data_wen_nxt;
 
        mtrans_r15                  <= mtrans_r15_nxt;
 
        restore_base_address        <= restore_base_address_nxt;
 
        control_state               <= control_state_nxt;
 
        mtrans_reg_d1               <= mtrans_reg;
 
        mtrans_reg_d2               <= mtrans_reg_d1;
 
        end
 
 
 
 
 
 
 
always @ ( posedge i_clk )
 
    if ( !i_fetch_stall )
 
        begin
 
        // sometimes this is a pre-fetch instruction
 
        // e.g. two ldr instructions in a row. The second ldr will be saved
 
        // to the pre-fetch instruction register
 
        // then when its decoded, a copy is saved to the saved_current_instruction
 
        // register
 
        if      (type == MTRANS)
 
            begin
 
            saved_current_instruction              <= mtrans_instruction_nxt;
 
            saved_current_instruction_iabt         <= instruction_iabt;
 
            saved_current_instruction_adex         <= instruction_adex;
 
            saved_current_instruction_address      <= instruction_address;
 
            saved_current_instruction_iabt_status  <= instruction_iabt_status;
 
            end
 
        else if (saved_current_instruction_wen)
 
            begin
 
            saved_current_instruction              <= instruction;
 
            saved_current_instruction_iabt         <= instruction_iabt;
 
            saved_current_instruction_adex         <= instruction_adex;
 
            saved_current_instruction_address      <= instruction_address;
 
            saved_current_instruction_iabt_status  <= instruction_iabt_status;
 
            end
 
 
 
        if      (pre_fetch_instruction_wen)
 
            begin
 
            pre_fetch_instruction                  <= o_read_data;
 
            pre_fetch_instruction_iabt             <= iabt_reg;
 
            pre_fetch_instruction_adex             <= adex_reg;
 
            pre_fetch_instruction_address          <= abt_address_reg;
 
            pre_fetch_instruction_iabt_status      <= abt_status_reg;
 
            end
 
        end
 
 
 
 
 
 
 
always @ ( posedge i_clk )
 
    if ( !i_fetch_stall )
 
        begin
 
        irq   <= i_irq;
 
        firq  <= i_firq;
 
 
 
        if ( control_state == INT_WAIT1 && o_status_bits_mode == SVC )
 
            begin
 
            dabt_reg  <= 1'd0;
 
            end
 
        else
 
            begin
 
            dabt_reg  <= dabt_reg || i_dabt;
 
            end
 
 
 
        dabt_reg_d1  <= dabt_reg;
 
        end
 
 
 
assign dabt = dabt_reg || i_dabt;
 
 
 
 
 
// ========================================================
 
// Decompiler for debugging core - not synthesizable
 
// ========================================================
 
//synopsys translate_off
 
 
 
`include "debug_functions.v"
 
 
 
a23_decompile  u_decompile (
 
    .i_clk                      ( i_clk                            ),
 
    .i_fetch_stall              ( i_fetch_stall                    ),
 
    .i_instruction              ( instruction                      ),
 
    .i_instruction_valid        ( instruction_valid                ),
 
    .i_instruction_execute      ( instruction_execute              ),
 
    .i_instruction_address      ( instruction_address              ),
 
    .i_interrupt                ( {3{interrupt}} & next_interrupt  ),
 
    .i_interrupt_state          ( control_state == INT_WAIT2       ),
 
    .i_instruction_undefined    ( und_request                      ),
 
    .i_pc_sel                   ( o_pc_sel                         ),
 
    .i_pc_wen                   ( o_pc_wen                         )
 
);
 
 
 
 
 
wire    [(15*8)-1:0]    xCONTROL_STATE;
 
wire    [(15*8)-1:0]    xMODE;
 
 
 
assign xCONTROL_STATE        =
 
                               control_state == RST_WAIT1      ? "RST_WAIT1"      :
 
                               control_state == RST_WAIT2      ? "RST_WAIT2"      :
 
 
 
 
 
                               control_state == INT_WAIT1      ? "INT_WAIT1"      :
 
                               control_state == INT_WAIT2      ? "INT_WAIT2"      :
 
                               control_state == EXECUTE        ? "EXECUTE"        :
 
                               control_state == PRE_FETCH_EXEC ? "PRE_FETCH_EXEC" :
 
                               control_state == MEM_WAIT1      ? "MEM_WAIT1"      :
 
                               control_state == MEM_WAIT2      ? "MEM_WAIT2"      :
 
                               control_state == PC_STALL1      ? "PC_STALL1"      :
 
                               control_state == PC_STALL2      ? "PC_STALL2"      :
 
                               control_state == MTRANS_EXEC1   ? "MTRANS_EXEC1"   :
 
                               control_state == MTRANS_EXEC2   ? "MTRANS_EXEC2"   :
 
                               control_state == MTRANS_EXEC3   ? "MTRANS_EXEC3"   :
 
                               control_state == MTRANS_EXEC3B  ? "MTRANS_EXEC3B"  :
 
                               control_state == MTRANS_EXEC4   ? "MTRANS_EXEC4"   :
 
                               control_state == MTRANS5_ABORT  ? "MTRANS5_ABORT"  :
 
                               control_state == MULT_PROC1     ? "MULT_PROC1"     :
 
                               control_state == MULT_PROC2     ? "MULT_PROC2"     :
 
                               control_state == MULT_STORE     ? "MULT_STORE"     :
 
                               control_state == MULT_ACCUMU    ? "MULT_ACCUMU"    :
 
                               control_state == SWAP_WRITE     ? "SWAP_WRITE"     :
 
                               control_state == SWAP_WAIT1     ? "SWAP_WAIT1"     :
 
                               control_state == SWAP_WAIT2     ? "SWAP_WAIT2"     :
 
                               control_state == COPRO_WAIT     ? "COPRO_WAIT"     :
 
                                                                 "UNKNOWN "       ;
 
 
 
assign xMODE  = mode_name ( o_status_bits_mode );
 
 
 
always @( posedge i_clk )
 
    if (control_state == EXECUTE && ((instruction[0] === 1'bx) || (instruction[31] === 1'bx)))
 
        begin
 
        `TB_ERROR_MESSAGE
 
        $display("Instruction with x's =%08h", instruction);
 
        end
 
//synopsys translate_on
 
 
 
endmodule
 
 
 
 
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.