/*******************************************************************/
declare    alu {
    input       a<32> ;
    input       b<32> ;
    output      out<32> ;
    output      ov ;     /* add, sub */
    output      z ;      /* sub */
    instrin     add ;
    instrin     sub ;
    instrin     and ;
    instrin     or ;
    instrin     xor ;

    instr_arg    add(a,b) ;
    instr_arg    sub(a,b) ;
    instr_arg    and(a,b) ;
    instr_arg    or(a,b) ;
    instr_arg    xor(a,b) ;
}

circuit    alu {
    input       a<32> ;
    input       b<32> ;
    output      out<32> ;
    output      ov ;     /* add, sub */
    output      z ;      /* sub */
    instrin     add ;
    instrin     sub ;
    instrin     and ;
    instrin     or ;
    instrin     xor ;

    instruct        add     par {
        out  = a + b ;
        ov   = ((^a<31>) & (^b<31>) & out<31>)
                | (a<31> & b<31> & (^out<31>)) ;
    }
    instruct        sub     par {
        out  = a + (^b) + 0b1 ;
        ov   = ((^a<31>) & b<31> & out<31>)
                | (a<31> & (^b<31>) & (^out<31>)) ;
        z    = ^(/| out<31:0>) ;
    }
    instruct        and     out = a & b ;
    instruct        or      out = a | b ;
    instruct        xor     out = a @ b ;
}

/*******************************************************************/
declare    shift {
    input       a<32> ;
    input       b<5> ;
    output      out<32> ;
    instrin     sll ;
    instrin     srl;
    instrin     sra ;

    instr_arg    sll(a,b) ;
    instr_arg    srl(a,b) ;
    instr_arg    sra(a,b) ;
}

circuit    shift {
    input       a<32> ;
    input       b<5> ;
    output      out<32> ;
    instrin     sll ;
    instrin     srl;
    instrin     sra ;

    sel        work<64> ;

    instruct        sll   out = a << b ;
    instruct        srl   out = a >> b ;
    instruct        sra   par {
                        work = 64#a >> b ;
                        out = work<31:0> ;
    }
}

/*******************************************************************/
declare    adder {
    input       a<32> ;
    input       b<32> ;
    output      out<32> ;
    instrin     add ;

    instr_arg    add(a,b) ;
}

circuit    adder {
    input       a<32> ;
    input       b<32> ;
    output      out<32> ;
    instrin     add ;

    instruct        add     out = a + b ;
}

/*******************************************************************/
declare    reg_file {
    input       w_adrs<5> ;
    input       a_adrs<5> ;
    input       b_adrs<5> ;
    input       w_data<32> ;
    output      a<32> ;
    output      b<32> ;
    instrin     do ;
    instr_arg do(a_adrs, b_adrs, w_adrs, w_data) ;
}

circuit    reg_file {
    input       w_adrs<5> ;
    input       a_adrs<5> ;
    input       b_adrs<5> ;
    input       w_data<32> ;
    output      a<32> ;
    output      b<32> ;
    instrin     do ;
    mem         cell[32]<32> ;

    instruct do par {
        any {
            /|a_adrs : a = cell[a_adrs] ;
            else     : a = 0x00000000 ;
        }
        any {
            /|b_adrs : b = cell[b_adrs] ;
            else     : b = 0x00000000 ;
        }
        any {
            /|w_adrs : cell[w_adrs] := w_data ;
        }
    }
}

/*******************************************************************/
declare    zero_check {
    input       data<32> ;
    output      zero ;
    instrin     do ;
    instr_arg do(data) ;
}

circuit    zero_check {
    input       data<32> ;
    output      zero ;
    instrin     do ;

    instruct do zero = ^(/|data) ;
}

/*******************************************************************/
declare    cmp5 {
    input       in1<5> ;
    input       in2<5> ;
    output      same ;
    instrin     do ;
    instr_arg do(in1,in2) ;
}

circuit    cmp5 {
    input       in1<5> ;
    input       in2<5> ;
    output      same ;
    instrin     do ;

    instruct do same = ^(/|(in1 @ in2)) ;
}

/*******************************************************************/