Merge branch 'master' of nyus.joshuawise.com:/git/firearm
[firearm.git] / Issue.v
1 `include "ARM_Constants.v"
2
3 module Issue(
4         input clk,
5         input Nrst,     /* XXX not used yet */
6         
7         input stall,    /* pipeline control */
8         input flush,    /* XXX not used yet */
9         
10         input inbubble, /* stage inputs */
11         input [31:0] insn,
12         input [31:0] inpc,
13         input [31:0] cpsr,
14         
15         output reg outstall = 0,        /* stage outputs */
16         output reg outbubble = 1,
17         output reg [31:0] outpc = 0,
18         output reg [31:0] outinsn = 0
19         /* XXX other? */
20         );
21         
22 `ifdef COPY_PASTA_FODDER
23         /* from page 2 of ARM7TDMIvE2.pdf */
24         casex (insn)
25         `DECODE_ALU_MULT:       /* Multiply -- must come before ALU, because it pattern matches a specific case of ALU */
26 //      `DECODE_ALU_MUL_LONG:   /* Multiply long */
27         `DECODE_ALU_MRS:        /* MRS (Transfer PSR to register) */
28         `DECODE_ALU_MSR:        /* MSR (Transfer register to PSR) */
29         `DECODE_ALU_MSR_FLAGS:  /* MSR (Transfer register or immediate to PSR, flag bits only) */
30         `DECODE_ALU_SWP:        /* Atomic swap */
31         `DECODE_ALU_BX:         /* Branch */
32         `DECODE_ALU_HDATA_REG:  /* Halfword transfer - register offset */
33         `DECODE_ALU_HDATA_IMM:  /* Halfword transfer - immediate offset */
34         `DECODE_ALU:            /* ALU */
35         `DECODE_LDRSTR_UNDEFINED:       /* Undefined. I hate ARM */
36         `DECODE_LDRSTR:         /* Single data transfer */
37         `DECODE_LDMSTM:         /* Block data transfer */
38         `DECODE_BRANCH:         /* Branch */
39         `DECODE_LDCSTC:         /* Coprocessor data transfer */
40         `DECODE_CDP:            /* Coprocessor data op */
41         `DECODE_MRCMCR:         /* Coprocessor register transfer */
42         `DECODE_SWI:            /* SWI */
43         default:                /* X everything else out */
44         endcase
45 `endif
46
47         /* Flag setting */
48         reg use_cpsr;
49         reg [15:0] use_regs;
50         reg def_cpsr;
51         reg [15:0] def_regs;
52         
53         function [15:0] idxbit;
54                 input [3:0] r;
55                 if (r == 15)
56                         idxbit = 0;
57                 else
58                         idxbit = (16'b1) << r;
59         endfunction
60         
61         wire [3:0] rn = insn[19:16];
62         wire [3:0] rd = insn[15:12];
63         wire [3:0] rs = insn[11:8];
64         wire [3:0] rm = insn[3:0];
65         wire [3:0] cond = insn[31:28];
66         
67         wire [3:0] rd_mul = insn[19:16];
68         wire [3:0] rn_mul = insn[15:12];
69         wire [3:0] rs_mul = insn[11:8];
70         
71         wire [3:0] alu_opc = insn[24:21];
72         
73         function alu_is_logical;
74                 input [3:0] op;
75                 
76                 case (op)
77                 `ALU_AND,`ALU_EOR,`ALU_TST,`ALU_TEQ,`ALU_ORR,`ALU_MOV,`ALU_BIC,`ALU_MVN: alu_is_logical = 1;
78                 default: alu_is_logical = 0;
79                 endcase
80         endfunction
81         
82         function alu_flags_only;
83                 input [3:0] op;
84                 
85                 case (op)
86                 `ALU_TST,`ALU_TEQ,`ALU_CMP,`ALU_CMN: alu_flags_only = 1;
87                 default: alu_flags_only = 0;
88                 endcase
89         endfunction
90         
91         function shift_requires_carry;
92                 input [7:0] shift;
93                 
94                 case(shift[1:0])
95                 `SHIFT_LSL: shift_requires_carry = (shift[7:2] == 0);
96                 `SHIFT_LSR: shift_requires_carry = 0;
97                 `SHIFT_ASR: shift_requires_carry = 0;
98                 `SHIFT_ROR: shift_requires_carry = (shift[7:2] == 0);
99                 endcase
100         endfunction
101         
102         always @(*)
103                 casez (insn)
104                 `DECODE_ALU_MULT:       /* Multiply -- must come before ALU, because it pattern matches a specific case of ALU */
105                 begin
106                         use_cpsr = `COND_MATTERS(cond);
107                         use_regs = (insn[21] /* accum */ ? idxbit(rn_mul) : 0) | idxbit(rs_mul) | idxbit(rm);
108                         def_cpsr = insn[20] /* setcc */;
109                         def_regs = idxbit(rd_mul);
110                 end
111 //              `DECODE_ALU_MUL_LONG:   /* Multiply long */
112                 `DECODE_ALU_MRS:        /* MRS (Transfer PSR to register) */
113                 begin
114                         use_cpsr = `COND_MATTERS(cond) || (insn[22] == 0) /* Source = CPSR */;
115                         use_regs = 0;
116                         def_cpsr = 0;
117                         def_regs = idxbit(rd);
118                 end
119                 `DECODE_ALU_MSR:        /* MSR (Transfer register to PSR) */
120                 begin
121                         use_cpsr = `COND_MATTERS(cond);
122                         use_regs = idxbit(rm);
123                         def_cpsr = 1;
124                         def_regs = 0;
125                 end
126                 `DECODE_ALU_MSR_FLAGS:  /* MSR (Transfer register or immediate to PSR, flag bits only) */
127                 begin
128                         use_cpsr = `COND_MATTERS(cond);
129                         use_regs = insn[25] ? 0 : idxbit(rm);
130                         def_cpsr = 1;
131                         def_regs = 0;
132                 end
133                 `DECODE_ALU_SWP:        /* Atomic swap */
134                 begin
135                         use_cpsr = `COND_MATTERS(cond);
136                         use_regs = idxbit(rn) | idxbit(rm);
137                         def_cpsr = 0;
138                         def_regs = idxbit(rd);
139                 end
140                 `DECODE_ALU_BX: /* Branch */
141                 begin
142                         use_cpsr = `COND_MATTERS(cond);
143                         use_regs = idxbit(rm);
144                         def_cpsr = 0;   // don't care, we'll never get there
145                         def_regs = 0;
146                 end
147                 `DECODE_ALU_HDATA_REG:  /* Halfword transfer - register offset */
148                 begin
149                         use_cpsr = `COND_MATTERS(cond);
150                         use_regs = idxbit(rn) | idxbit(rm) | (insn[20] /* L */ ? 0 : idxbit(rd));
151                         def_cpsr = 0;
152                         def_regs = insn[20] /* L */ ? idxbit(rd) : 0;
153                 end
154                 `DECODE_ALU_HDATA_IMM:  /* Halfword transfer - immediate offset */
155                 begin
156                         use_cpsr = `COND_MATTERS(cond);
157                         use_regs = idxbit(rn) | (insn[20] /* L */ ? 0 : idxbit(rd));
158                         def_cpsr = 0;
159                         def_regs = insn[20] /* L */ ? idxbit(rd) : 0;
160                 end
161                 `DECODE_ALU:    /* ALU */
162                 begin
163                         use_cpsr = `COND_MATTERS(cond) | (!insn[25] /* I */ && shift_requires_carry(insn[11:4]));
164                         use_regs =
165                                 (insn[25] /* I */ ? 0 :
166                                         (insn[4] /* shift by reg */ ?
167                                                 (idxbit(rs) | idxbit(rm)) :
168                                                 (idxbit(rm)))) |
169                                 (((alu_opc != `ALU_MOV) && (alu_opc != `ALU_MVN)) ? idxbit(rn) : 0);
170                         def_cpsr = insn[20] /* S */;
171                         def_regs = alu_flags_only(alu_opc) ? 0 : idxbit(rd);
172                 end
173                 `DECODE_LDRSTR_UNDEFINED:       /* Undefined. I hate ARM */
174                 begin   
175                         use_cpsr = 0;
176                         use_regs = 0;
177                         def_cpsr = 0;
178                         def_regs = 0;
179                 end
180                 `DECODE_LDRSTR:
181                 begin
182                         use_cpsr = `COND_MATTERS(cond);
183                         use_regs = idxbit(rn) | (insn[20] /* L */ ? 0 : idxbit(rd));
184                         def_cpsr = 0;
185                         def_regs = insn[20] /* L */ ? idxbit(rd) : 0;
186                 end
187                 `DECODE_LDMSTM:         /* Block data transfer */
188                 begin
189                         use_cpsr = `COND_MATTERS(cond);
190                         use_regs = idxbit(rn) | (insn[20] /* L */ ? 0 : insn[15:0]);
191                         def_cpsr = insn[22];    /* This is a superset of all cases, anyway. */
192                         def_regs = (insn[21] /* W */ ? idxbit(rn) : 0) | (insn[20] /* L */ ? insn[15:0] : 0);
193                 end
194                 `DECODE_BRANCH: /* Branch */
195                 begin
196                         use_cpsr = `COND_MATTERS(cond);
197                         use_regs = 0;
198                         def_cpsr = 0;
199                         def_regs = 0;
200                 end
201                 `DECODE_LDCSTC: /* Coprocessor data transfer */
202                 begin
203                         use_cpsr = `COND_MATTERS(cond);
204                         use_regs = idxbit(rn);
205                         def_cpsr = 0;
206                         def_regs = insn[21] /* W */ ? idxbit(rn) : 0;
207                 end
208                 `DECODE_CDP:    /* Coprocessor data op */
209                 begin
210                         use_cpsr = `COND_MATTERS(cond);
211                         use_regs = 0;
212                         def_cpsr = 0;
213                         def_regs = 0;
214                 end
215                 `DECODE_MRCMCR:         /* Coprocessor register transfer */
216                 begin
217                         use_cpsr = `COND_MATTERS(cond);
218                         use_regs = insn[20] /* L */ ? 0 : idxbit(rd);
219                         def_cpsr = 0;
220                         def_regs = insn[20] /* L */ ? idxbit(rd) : 0;
221                 end
222                 `DECODE_SWI:    /* SWI */
223                 begin
224                         use_cpsr = `COND_MATTERS(cond);
225                         use_regs = 0;
226                         def_cpsr = 0;
227                         def_regs = 0;
228                 end
229                 default:                                /* X everything else out */
230                 begin
231                         use_cpsr = 1'bx;
232                         use_regs = 16'bxxxxxxxxxxxxxxxx;
233                         def_cpsr = 1'bx;
234                         def_regs = 16'bxxxxxxxxxxxxxxxx;
235                 end
236                 endcase
237         
238         /* Condition checking logic */
239         reg condition_met;
240         always @(*)
241                 casez(insn[31:28])
242                 `COND_EQ:       condition_met = cpsr[`CPSR_Z];
243                 `COND_NE:       condition_met = !cpsr[`CPSR_Z];
244                 `COND_CS:       condition_met = cpsr[`CPSR_C];
245                 `COND_CC:       condition_met = !cpsr[`CPSR_C];
246                 `COND_MI:       condition_met = cpsr[`CPSR_N];
247                 `COND_PL:       condition_met = !cpsr[`CPSR_N];
248                 `COND_VS:       condition_met = cpsr[`CPSR_V];
249                 `COND_VC:       condition_met = !cpsr[`CPSR_V];
250                 `COND_HI:       condition_met = cpsr[`CPSR_C] && !cpsr[`CPSR_Z];
251                 `COND_LS:       condition_met = !cpsr[`CPSR_C] || cpsr[`CPSR_Z];
252                 `COND_GE:       condition_met = cpsr[`CPSR_N] == cpsr[`CPSR_V];
253                 `COND_LT:       condition_met = cpsr[`CPSR_N] != cpsr[`CPSR_V];
254                 `COND_GT:       condition_met = !cpsr[`CPSR_Z] && (cpsr[`CPSR_N] == cpsr[`CPSR_V]);
255                 `COND_LE:       condition_met = cpsr[`CPSR_Z] || (cpsr[`CPSR_N] != cpsr[`CPSR_V]);
256                 `COND_AL:       condition_met = 1;
257                 `COND_NV:       condition_met = 0;
258                 default:        condition_met = 1'bx;
259                 endcase
260         
261         /* Issue logic */
262 `define STAGE_EXECUTE   0
263 `define STAGE_MEMORY    1
264 /* Once it's hit writeback, it's essentially hit the regfile so you're done. */
265         reg cpsr_inflight [1:0];
266         reg [15:0] regs_inflight [1:0];
267         
268         reg waiting_cpsr;
269         reg waiting_regs;
270         wire waiting = waiting_cpsr | waiting_regs;
271         
272         initial
273         begin
274                 cpsr_inflight[0] = 0;
275                 cpsr_inflight[1] = 0;
276                 regs_inflight[0] = 0;
277                 regs_inflight[1] = 0;
278         end
279                 
280         always @(*)
281         begin
282                 waiting_cpsr = use_cpsr & (cpsr_inflight[0] | cpsr_inflight[1]);
283                 waiting_regs = |(use_regs & (regs_inflight[0] | regs_inflight[1]));
284                 
285                 outstall = (waiting && !inbubble) || stall;     /* Happens in an always @*, because it is an exception. */
286         end
287         
288         /* Actually do the issue. */
289         always @(posedge clk)
290         begin
291                 if (waiting)
292                         $display("ISSUE: Stalling instruction %08x because %d/%d", insn, waiting_cpsr, waiting_regs);
293         
294                 if (!stall)
295                 begin
296                         cpsr_inflight[0] <= cpsr_inflight[1];   /* I'm not sure how well selects work with arrays, and that seems like a dumb thing to get anusulated by. */
297                         cpsr_inflight[1] <= (waiting || inbubble || !condition_met) ? 0 : def_cpsr;
298                         regs_inflight[0] <= regs_inflight[1];
299                         regs_inflight[1] <= (waiting || inbubble || !condition_met) ? 0 : def_regs;
300                         
301                         outbubble <= inbubble | waiting | !condition_met;
302                         outpc <= inpc;
303                         outinsn <= insn;
304                 end
305         end
306 endmodule
This page took 0.03282 seconds and 4 git commands to generate.