Subversion Repositories forwardcom

//////////////////////////////////////////////////////////////////////////////////

// Engineer: Agner Fog

//

// Create Date:       2020-05-05

// Last modified:     2021-07-27

// Module Name:       call_stack

// Project Name:      ForwardCom soft core

// Target Devices:    Artix 7

// Tool Versions:     Vivado v. 2020.1

// License:           CERN-OHL-W v. 2 or later

// Description:       on-chip call stack. controls call and return instructions

//

//////////////////////////////////////////////////////////////////////////////////

`include "defines.vh"

// call stack, 1024*32 bits, used for function return addresses but not for parameters or local data

// On call instruction: put return address on push_data and set call_e high for one clock cycle.

// On return instruction: the return address is pre-loaded into pop_data for early read.

// Set return_e high for one clock cycle to make next return address ready.

// It is not allowed to have call_e and return_e in the same clock cycle.

// It is not allowed to have return_e in the first clock cycle after call_e

// or return_e. This is not a problem in the current design because consecutive

// jump, call, and return instructions are delayed by the access time to the code cache.

// If the design is improved with more efficient branch prediction then it may be

// necessary to add precautions to prevent a return_e signal in the first clock cycle

// after another return_e or call_e.

module call_stack (

    input clock,                                 // clock

    input clock_enable,                          // clock enable. Used when single-stepping

    input reset,                                 // clock enable. Used when single-stepping

    input call_e,                                // Executing call instruction. push_data contains return address

    input return_e,                              // Executing return instruction. return address is available in advance on pop_data

    input  [`CODE_ADDR_WIDTH-1:0] push_data,     // Return address pushed here at call instruction

    output reg [`CODE_ADDR_WIDTH-1:0] pop_data,  // Return address popped here at return instruction

    output reg overflow                          // stack overflow or underflow or error

   );

// site of stack = 2**stack_pointer_bits

parameter integer stack_pointer_bits = `CALL_STACK_POINTER_BITS;

// stack ram, on-chip

reg [`CODE_ADDR_WIDTH-1:0] ram[0:(2**stack_pointer_bits)-1];

// call stack pointer

reg [stack_pointer_bits-1:0] call_stack_pointer = 0;

// call and return operations = push and pop of function return addresses:

always_ff @(posedge clock) if (clock_enable) begin

    overflow <= 0;

    if (reset) begin

        call_stack_pointer <= 0;

        pop_data <= 0;

        overflow <= 0;

    end else if (call_e) begin

        if (call_stack_pointer == (2**stack_pointer_bits)-1 || return_e) begin

            overflow <= 1;                          // overflow or other error

        end else begin

            ram[call_stack_pointer] <= push_data;   // push return address on stack

            pop_data <= push_data;                  // make next return address ready

            call_stack_pointer <= call_stack_pointer + 1;

        end

    end else if (return_e) begin

        if (call_stack_pointer == 0) begin

            overflow <= 1;                          // stack underflow

        end else if (call_stack_pointer == 1) begin

            pop_data <= 0;                          // stack empty

            call_stack_pointer <= call_stack_pointer - 1;

        end else begin

            pop_data <= ram[call_stack_pointer-2];  // make next return address ready

            call_stack_pointer <= call_stack_pointer - 1;

        end

    end

end

endmodule