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

Subversion Repositories forwardcom

[/] [forwardcom/] [bintools/] [emulator2.cpp] - Blame information for rev 164

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 53 Agner
/****************************  emulator2.cpp  ********************************
2
* Author:        Agner Fog
3
* date created:  2018-02-18
4
* Last modified: 2021-02-19
5
* Version:       1.11
6
* Project:       Binary tools for ForwardCom instruction set
7
* Description:
8
* Emulator: Execution functions for jump instructions
9
*
10
* Copyright 2018-2021 GNU General Public License http://www.gnu.org/licenses
11
*****************************************************************************/
12
 
13
#include "stdafx.h"
14
 
15
static uint64_t f_jump(CThread * t) {
16
    // simple self-relative jump
17
    t->ip += t->addrOperand * 4;                           // add relative offset to IP
18
    t->running = 2;  t->returnType = 0;                    // no return value to save
19
    return 0;
20
}
21
 
22
static uint64_t f_call(CThread * t) {
23
    // simple self-relative call
24
    t->callStack.push(t->ip);                              // push return address on call stack
25
    if (t->callStack.numEntries() > t->callDept) t->callDept = t->callStack.numEntries();
26
    t->ip += t->addrOperand * 4;                           // add relative offset to IP
27
    t->running = 2;  t->returnType = 0;                    // no return value to save
28
    return 0;
29
}
30
 
31
static uint64_t compare_jump_generic(CThread * t) {
32
    // compare operands, jump on contition
33
    SNum a = t->parm[1];                                   // first parameter
34
    SNum b = t->parm[2];                                   // second parameter
35
    uint8_t branch = 0;                                    // jump if 1
36
    if (t->operandType < 4) {
37
        // all integer types
38
        uint64_t sizeMask = dataSizeMask[t->operandType];  // mask for data size
39
        uint64_t signBit = (sizeMask >> 1) + 1;            // sign bit
40
        a.q &= sizeMask;  b.q &= sizeMask;                 // limit to right number of bits
41
        // select condition
42
        switch (t->op & 0xE) {                             // mask out constant bits and invert bit
43
        case 0:  // jump if equal
44
            branch = a.q == b.q;  break;
45
        case 2:  // jump if signed below
46
            branch = (a.q ^ signBit) < (b.q ^ signBit);  break;
47
        case 4:  // jump if signed above
48
            branch = (a.q ^ signBit) > (b.q ^ signBit);  break;
49
        case 6:  // jump if unsigned below
50
            branch = a.q < b.q;  break;
51
        case 8:  // jump if unsigned above
52
            branch = a.q > b.q;  break;
53
        default:
54
            t->interrupt(INT_WRONG_PARAMETERS);
55
        }
56
        branch ^= t->op;                                   // invert branch condition if op odd
57
    }
58
    else {
59
        // vector registers
60
        if (t->operandType != 5 && t->operandType != 6) {
61
            t->interrupt(INT_WRONG_PARAMETERS);                // unsupported operand type
62
            return 0;
63
        }
64
        if ((t->op & 0xFE) == 24) {
65
            // fp_category test
66
            if (t->fInstr->immSize) b = t->parm[4];        // avoid conversion of b to float
67
            bool mant0;                                    // mantissa is zero
68
            bool exp0;                                     // exponent is all zeroes
69
            bool exp1;                                     // exponent is all ones
70
            bool sign;                                     // sign bit
71
            if (t->operandType == 5) {                     // float
72
                mant0 = (a.i & 0x007FFFFF) == 0;           // mantissa is zero
73
                exp0 = (a.i & 0x7F800000) == 0;            // exponent is all zeroes
74
                exp1 = (a.i & 0x7F800000) == 0x7F800000;   // exponent is all ones
75
                sign = a.i >> 31 != 0;                     // sign bit
76
            }
77
            else {                                         // double
78
                mant0 = a.q << 12 == 0;                    // mantissa is zero
79
                exp0 = a.q << 1 >> 53 == 0;                // exponent is all zeroes
80
                exp1 = a.q << 1 >> 53 == 0xFFFFFFFFFFFFF;  // exponent is all ones
81
                sign = a.q >> 63 != 0;                     // sign bit
82
            }
83
            if (exp1) {
84
                if (b.b & 1)    branch |= !mant0;          // NAN
85
                if (b.b & 0x40) branch |= mant0 && sign;   // -INF
86
                if (b.b & 0x80) branch |= mant0 && !sign;  // +INF
87
            }
88
            else if (exp0) {
89
                if (b.b & 2)    branch |= uint8_t(mant0);  // +/- 0.0
90
                if (b.b & 4)    branch |= !mant0 && sign;  // - subnormal
91
                if (b.b & 8)    branch |= !mant0 && !sign; // + subnormal
92
            }
93
            else {
94
                if (b.b & 0x10) branch |= uint8_t(sign);   // - normal
95
                if (b.b & 0x20) branch |= !sign;           // + normal
96
            }
97
            branch ^= t->op;                               // invert branch condition if op odd
98
        }
99
        else {
100
            bool unordered;
101
            uint8_t opj = t->op;
102
            if (t->operandType == 5) {
103
                // float
104
                unordered = isnan_f(a.i) || isnan_f(b.i);  // check if unordered
105
                if (unordered) {
106
                    // a or b is NAN. Don't check the condition. Branch only if unordered version of instruction.
107
                    branch = t->op < 32;
108
                }
109
                else {
110
                    if ((opj & 0xE) > 5) {
111
                        // compare absolute values
112
                        a.i &= 0x7FFFFFFF;  b.i &= 0x7FFFFFFF;
113
                        opj -= 4;
114
                    }
115
                    // select condition, float
116
                    switch (opj & 0xE) {   // mask out bits for ordered/unordered and invert
117
                    case 0:    // jump if equal
118
                        branch = a.f == b.f;  break;
119
                    case 2:    // jump if below
120
                        branch = a.f < b.f;  break;
121
                    case 4:    // jump if above
122
                        branch = a.f > b.f;  break;
123
                    default:
124
                        t->interrupt(INT_WRONG_PARAMETERS);
125
                    }
126
                    branch ^= t->op;                               // invert branch condition if op odd
127
                }
128
            }
129
            else {
130
                // double
131
                unordered = isnan_d(a.q) || isnan_d(b.q);  // check if unordered
132
                if (unordered) {
133
                    // a or b is NAN. Don't check the condition. Branch only if unordered version of instruction.
134
                    branch = t->op < 32;
135
                }
136
                else {
137
                    if ((opj & 0xE) > 5) {
138
                        // compare absolute values
139
                        a.q &= 0x7FFFFFFFFFFFFFFF;  b.q &= 0x7FFFFFFFFFFFFFFF;
140
                        opj -= 4;
141
                    }
142
                    // select condition, float
143
                    switch (opj & 0xE) {                 // mask out bits for ordered/unordered and invert
144
                    case 0:    // jump if equal
145
                        branch = a.d == b.d;  break;
146
                    case 2:    // jump if below
147
                        branch = a.d < b.d;  break;
148
                    case 4:    // jump if above
149
                        branch = a.d > b.d;  break;
150
                    default:
151
                        t->interrupt(INT_WRONG_PARAMETERS);
152
                    }
153
                    branch ^= t->op;                       // invert branch condition if op odd
154
                }
155
            }
156
        }
157
    }
158
    if (branch & 1) {
159
        t->ip += t->addrOperand * 4;                       // add relative offset to IP
160
        t->returnType = 0x2000;                            // debug output jump taken
161
    }
162
    else t->returnType = 0x1000;                           // debug output jump taken
163
    if (t->vect) t->vect = 4;                              // stop vector loop
164
    t->running = 2;                                        // don't save result
165
    return 0;
166
}
167
 
168
 
169
static uint64_t sub_jump_generic(CThread * t) {
170
    // subtract and jump on some condition
171
    if (t->operandType > 4) {  // floating point types have no add/jump
172
        // the opcode is used for floating point compare unordered
173
        return compare_jump_generic(t);
174
    }
175
    SNum a = t->parm[1];                         // first parameter
176
    SNum b = t->parm[2];                         // second parameter
177
    SNum result;                                 // result
178
    int8_t branch = 0;                           // jump if 1
179
    int8_t unsignedOverflow = 0;                 // unsigned overflow detected
180
    int8_t signedOverflow = 0;                   // signed overflow detected
181
    int8_t op1 = t->op >> 1;                     // operation without toggle bit
182
    uint64_t sizeMask = dataSizeMask[t->operandType]; // mask for data size
183
    uint64_t signBit = (sizeMask >> 1) + 1;      // sign bit
184
    result.q = a.q - b.q;                        // subtract integers
185
 
186
    // detection of signed overflow 
187
    SNum overfl;  // overflow if a and b have opposite sign and result has opposite sign of a
188
    overfl.q = (a.q ^ b.q) & (a.q ^ result.q);
189
    signedOverflow = (overfl.q & signBit) != 0;
190
    // detection of borrow / unsigned overflow required
191
    unsignedOverflow = (result.q & sizeMask) > (a.q & sizeMask);
192
 
193
    // detect branch condition
194
    switch (op1) {
195
    case 0:  // jump if zero
196
        branch = (result.q & sizeMask) == 0;
197
        break;
198
    case 1:  // jump if negative
199
        branch = (result.q & signBit) != 0;
200
        break;
201
    case 2:  // jump if positive
202
        branch = (result.q & signBit) == 0 && (result.q & sizeMask) != 0;
203
        break;
204
    case 3:  // jump if signed overflow
205
        branch = signedOverflow;
206
        signedOverflow = unsignedOverflow = 0;   // no interrupt for this condition
207
        break;
208
    case 4:  // jump if borrow (unsigned overflow)
209
        branch = unsignedOverflow;
210
        signedOverflow = unsignedOverflow = 0;   // no interrupt for this condition
211
        break;
212
    default:
213
        err.submit(ERR_INTERNAL);
214
    }
215
    // only integer types in g.p. registers allowed
216
    if (t->operandType > 3) t->interrupt(INT_WRONG_PARAMETERS);
217
    // overflow interrupts
218
    //if (signedOverflow)   t->interrupt(INT_OVERFL_SIGN);
219
    //if (unsignedOverflow) t->interrupt(INT_OVERFL_UNSIGN);
220
 
221
    // invert condition if op odd
222
    branch ^= t->op;
223
    // conditional branch
224
    if (branch & 1) {
225
        t->ip += t->addrOperand * 4;             // add relative offset to IP
226
        t->returnType |= 0x2000;                 // debug output jump taken
227
    }
228
    return result.q;                             // return result
229
}
230
 
231
static uint64_t add_jump_generic(CThread * t) {
232
    // add and jump on some condition
233
    if (t->operandType > 4) {  // floating point types have no add/jump
234
        // the opcode is used for floating point compare unordered
235
        return compare_jump_generic(t);
236
    }
237
    SNum a = t->parm[1];                         // first parameter
238
    SNum b = t->parm[2];                         // second parameter
239
    SNum result;                                 // result
240
    int8_t branch = 0;                           // jump if 1
241
    int8_t unsignedOverflow = 0;                 // unsigned overflow detected
242
    int8_t signedOverflow = 0;                   // signed overflow detected
243
    int8_t op1 = t->op >> 1;                     // operation without toggle bit
244
    uint64_t sizeMask = dataSizeMask[t->operandType]; // mask for data size
245
    uint64_t signBit = (sizeMask >> 1) + 1;      // sign bit
246
 
247
    // add integers
248
    result.q = a.q + b.q;
249
    // detection of signed overflow required
250
    SNum overfl;  // overflow if a and b have same sign and result has opposite sign of a
251
    overfl.q = ~(a.q ^ b.q) & (a.q ^ result.q);
252
    signedOverflow = (overfl.q & signBit) != 0;
253
    // detection of carry / unsigned overflow required
254
    unsignedOverflow = (result.q & sizeMask) < (a.q & sizeMask);
255
 
256
    // detect branch condition
257
    switch (op1) {
258
    case 8:  // jump if zero
259
        branch = (result.q & sizeMask) == 0;
260
        break;
261
    case 9:  // jump if negative
262
        branch = (result.q & signBit) != 0;
263
        break;
264
    case 10:  // jump if positive
265
        branch = (result.q & signBit) == 0 && (result.q & sizeMask) != 0;
266
        break;
267
    case 11:  // jump if signed overflow
268
        branch = signedOverflow;
269
        signedOverflow = unsignedOverflow = 0;   // no interrupt for this condition
270
        break;
271
    case 12:  // jump if borrow (unsigned overflow)
272
        branch = unsignedOverflow;
273
        signedOverflow = unsignedOverflow = 0;   // no interrupts for these conditions
274
        break;
275
    default:
276
        err.submit(ERR_INTERNAL);
277
    }
278
    // only integer types in g.p. registers allowed for add/jump instructions
279
    if (t->operandType > 3 && op1 < 12) t->interrupt(INT_WRONG_PARAMETERS);
280
    // overflow interrupts
281
    //if (signedOverflow)   t->interrupt(INT_OVERFL_SIGN);
282
    //if (unsignedOverflow) t->interrupt(INT_OVERFL_UNSIGN);
283
 
284
    // invert condition if op odd
285
    branch ^= t->op;
286
 
287
    // conditional branch
288
    if (branch & 1) {
289
        t->ip += t->addrOperand * 4;             // add relative offset to IP
290
        t->returnType |= 0x2000;                 // debug output jump taken
291
    }
292
    return result.q;                             // return result
293
}
294
/*
295
static uint64_t shift_left_jump_zero(CThread * t) {
296
    // shift left and jump if zero
297
    SNum a = t->parm[1];                         // first parameter
298
    SNum b = t->parm[2];                         // second parameter
299
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
300
    SNum result;                                 // result
301
    int8_t branch = 0;                           // jump if 1
302
    result.q = 0;
303
 
304
    switch (t->operandType) {
305
    case 0:   // int8
306
        if (b.b < 8) result.b = a.b << b.b;
307
        branch = result.b == 0;
308
        break;
309
    case 1:   // int16
310
        if (b.s < 16) result.s = a.s << b.b;
311
        branch = result.s == 0;
312
        break;
313
    case 2: case 5:   // int32, float
314
        if (b.i < 32) result.i = a.i << b.b;
315
        branch = result.i == 0;
316
        break;
317
    case 3:   // int64, double
318
        if (b.q < 64) result.q = a.q << b.b;
319
        branch = result.q == 0;
320
        break;
321
    default:
322
        t->interrupt(INT_WRONG_PARAMETERS);
323
    }
324
    if (t->vect) { // vector registers. make result scalar and stop vector loop
325
        t->vectorLength[t->operands[0]] = t->vectorLengthR = dataSizeTable[t->operandType];
326
    }
327
    // invert condition if op odd
328
    branch ^= t->op;
329
 
330
    // conditional branch
331
    if (branch & 1) {
332
        t->ip += t->addrOperand * 4;             // add relative offset to IP
333
        t->returnType |= 0x2000;                 // debug output jump taken
334
    }
335
    return result.q;
336
}
337
 
338
static uint64_t shift_right_u_jump_zero(CThread * t) {
339
    // shift right unsigned and jump if zero
340
    SNum a = t->parm[1];                         // first parameter
341
    SNum b = t->parm[2];                         // second parameter
342
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
343
    SNum result;                                 // result
344
    int8_t branch = 0;                           // jump if 1
345
    result.q = 0;
346
 
347
    switch (t->operandType) {
348
    case 0:   // int8
349
        if (b.b < 8) result.b = a.b >> b.b;
350
        branch = result.b == 0;
351
        break;
352
    case 1:   // int16
353
        if (b.s < 16) result.s = a.s >> b.b;
354
        branch = result.s == 0;
355
        break;
356
    case 2: case 5:   // int32, float
357
        if (b.i < 32) result.i = a.i >> b.b;
358
        branch = result.i == 0;
359
        break;
360
    case 3:   // int64, double
361
        if (b.q < 64) result.q = a.q >> b.b;
362
        branch = result.q == 0;
363
        break;
364
    default:
365
        t->interrupt(INT_WRONG_PARAMETERS);
366
    }
367
    if (t->vect) { // vector registers. make result scalar and stop vector loop
368
        t->vectorLength[t->operands[0]] = t->vectorLengthR = dataSizeTable[t->operandType];
369
    }
370
    // invert condition if op odd
371
    branch ^= t->op;
372
 
373
    // conditional branch
374
    if (branch & 1) {
375
        t->ip += t->addrOperand * 4;             // add relative offset to IP
376
        t->returnType |= 0x2000;                 // debug output jump taken
377
    }
378
    return result.q;
379
}
380
 
381
static uint64_t rotate_jump_carry(CThread * t) {
382
    // rotate left and jump if the last rotated bit is 1
383
    SNum a = t->parm[1];                         // first parameter
384
    SNum b = t->parm[2];                         // second parameter
385
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
386
    SNum result;                                 // result
387
    int8_t branch = 0;                           // jump if 1
388
    result.q = 0;
389
 
390
    switch (t->operandType) {
391
    case 0:   // int8
392
        b.b &= 7;
393
        result.b = (a.b << b.b) | (a.b >> (8 - b.b));
394
        branch = b.bs < 0 ? result.b >> 7 : result.b; // most or least significant bit
395
        break;
396
    case 1:   // int16
397
        b.b &= 15;
398
        result.b = (a.s << b.b) | (a.s >> (16 - b.b));
399
        branch = uint8_t(b.ss < 0 ? result.s >> 15 : result.s); // most or least significant bit
400
        break;
401
    case 2: case 5:   // int32, float
402
        b.b &= 31;
403
        result.i = (a.i << b.b) | (a.i >> (32 - b.b));
404
        branch = uint8_t(b.is < 0 ? result.i >> 31 : result.i); // most or least significant bit
405
        break;
406
    case 3:   // int64, double
407
        b.b &= 63;
408
        result.q = (a.q << b.b) | (a.q >> (64 - b.b));
409
        branch = uint8_t(b.qs < 0 ? result.q >> 63 : result.q); // most or least significant bit
410
        break;
411
    default:
412
        t->interrupt(INT_WRONG_PARAMETERS);
413
    }
414
    if (t->vect) { // vector registers. make result scalar and stop vector loop
415
        t->vectorLength[t->operands[0]] = t->vectorLengthR = dataSizeTable[t->operandType];
416
    }
417
    // invert condition if op odd
418
    branch ^= t->op;
419
 
420
    // conditional branch
421
    if (branch & 1) {
422
        t->ip += t->addrOperand * 4;             // add relative offset to IP
423
        t->returnType |= 0x2000;                 // debug output jump taken
424
    }
425
    return result.q;
426
} */
427
 
428
static uint64_t and_jump_zero(CThread * t) {
429
    // bitwise AND, jump if zero
430
    SNum a = t->parm[1];                         // first parameter
431
    SNum b = t->parm[2];                         // second parameter
432
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
433
    SNum result;                                 // result
434
    int8_t branch = 0;                           // jump if 1
435
    result.q = a.q & b.q;                        // bitwise AND
436
 
437
    // branch condition
438
    switch (t->operandType) {
439
    case 0:   // int8
440
        branch = result.b == 0;  break;
441
    case 1:   // int16
442
        branch = result.s == 0;  break;
443
    case 2: case 5:   // int32, float
444
        branch = result.i == 0;  break;
445
    case 3: case 6:  // int64, double
446
        branch = result.q == 0;  break;
447
    default:
448
        t->interrupt(INT_WRONG_PARAMETERS);
449
    }
450
    if (t->vect) { // vector registers. make result scalar and stop vector loop
451
        t->vectorLength[t->operands[0]] = t->vectorLengthR = dataSizeTable[t->operandType];
452
    }
453
    // invert condition if op odd
454
    branch ^= t->op;
455
 
456
    // conditional branch
457
    if (branch & 1) {
458
        t->ip += t->addrOperand * 4;             // add relative offset to IP
459
        t->returnType |= 0x2000;                 // debug output jump taken
460
    }
461
    return result.q;
462
}
463
 
464
static uint64_t or_jump_zero(CThread * t) {
465
    // bitwise OR, jump if zero
466
    SNum a = t->parm[1];                         // first parameter
467
    SNum b = t->parm[2];                         // second parameter
468
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
469
    SNum result;                                 // result
470
    int8_t branch = 0;                           // jump if 1
471
    result.q = a.q | b.q;                        // bitwise AND
472
 
473
    // branch condition
474
    switch (t->operandType) {
475
    case 0:   // int8
476
        branch = result.b == 0;  break;
477
    case 1:   // int16
478
        branch = result.s == 0;  break;
479
    case 2: case 5:   // int32, float
480
        branch = result.i == 0;  break;
481
    case 3: case 6:   // int64, double
482
        branch = result.q == 0;  break;
483
    default:
484
        t->interrupt(INT_WRONG_PARAMETERS);
485
    }
486
    if (t->vect) { // vector registers. make result scalar and stop vector loop
487
        t->vectorLength[t->operands[0]] = t->vectorLengthR = dataSizeTable[t->operandType];
488
    }
489
    // invert condition if op odd
490
    branch ^= t->op;
491
 
492
    // conditional branch
493
    if (branch & 1) {
494
        t->ip += t->addrOperand * 4;             // add relative offset to IP
495
        t->returnType |= 0x2000;                 // debug output jump taken
496
    }
497
    return result.q;
498
}
499
 
500
static uint64_t xor_jump_zero(CThread * t) {
501
    // bitwise XOR, jump if zero
502
    SNum a = t->parm[1];                         // first parameter
503
    SNum b = t->parm[2];                         // second parameter
504
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
505
    SNum result;                                 // result
506
    int8_t branch = 0;                           // jump if 1
507
    result.q = a.q ^ b.q;                        // bitwise AND
508
 
509
    // branch condition
510
    switch (t->operandType) {
511
    case 0:   // int8
512
        branch = result.b == 0;  break;
513
    case 1:   // int16
514
        branch = result.s == 0;  break;
515
    case 2: case 5:   // int32, float
516
        branch = result.i == 0;  break;
517
    case 3: case 6:  // int64, double
518
        branch = result.q == 0;  break;
519
    default:
520
        t->interrupt(INT_WRONG_PARAMETERS);
521
    }
522
    if (t->vect) { // vector registers. make result scalar and stop vector loop
523
        t->vectorLength[t->operands[0]] = t->vectorLengthR = dataSizeTable[t->operandType];
524
    }
525
    // invert condition if op odd
526
    branch ^= t->op;
527
 
528
    // conditional branch
529
    if (branch & 1) {
530
        t->ip += t->addrOperand * 4;             // add relative offset to IP
531
        t->returnType |= 0x2000;                 // debug output jump taken
532
    }
533
    return result.q;
534
}
535
 
536
static uint64_t test_bit_jump_true(CThread * t) {
537
    // test bit number b in a, jump if zero
538
    // floating point operands are treated as integers with the same size
539
    SNum a = t->parm[1];                         // first parameter
540
    SNum b = t->parm[2];                         // second parameter
541
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
542
    uint8_t branch = 0;                          // treat bits out of range as zero
543
 
544
    // branch condition
545
    switch (t->operandType) {
546
    case 0:   // int8
547
        if (b.b < 8) branch = a.b >> b.b;
548
        break;
549
    case 1:   // int16
550
        if (b.s < 16) branch = uint8_t(a.s >> b.b);
551
        break;
552
    case 2:   // int32
553
    case 5:   // float
554
        if (b.i < 32) branch = uint8_t(a.i >> b.b);
555
        break;
556
    case 3:   // int64
557
    case 6:   // double
558
        if (b.q < 64) branch = uint8_t(a.q >> b.b);
559
        break;
560
    default:
561
        t->interrupt(INT_WRONG_PARAMETERS);
562
    }
563
    if (t->vect)  t->vect = 4;                             // stop vector loop
564
 
565
    // invert condition if op odd
566
    branch ^= t->op;
567
    // conditional branch
568
    if (branch & 1) {
569
        t->ip += t->addrOperand * 4;                       // add relative offset to IP
570
        t->returnType = 0x2000;                            // debug output jump taken
571
    }
572
    else t->returnType = 0x1000;                           // debug output jump taken
573
    t->running = 2;                                        // don't save result
574
    return 0;
575
}
576
 
577
static uint64_t test_bits_and(CThread * t) {
578
    // jump if (a & b) == b
579
    SNum a = t->parm[1];                         // first parameter
580
    SNum b = t->parm[2];                         // second parameter
581
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
582
    int8_t branch = 0;                           // branch condition is inverted if op is odd
583
 
584
    // branch condition
585
    switch (t->operandType) {
586
    case 0:   // int8
587
        branch = (a.b & b.b) == b.b;  break;
588
    case 1:   // int16
589
        branch = (a.s & b.s) == b.s;  break;
590
    case 2:   // int32
591
    case 5:   // float
592
        branch = (a.i & b.i) == b.i;  break;
593
    case 3:   // int64
594
    case 6:   // double
595
        branch = (a.q & b.q) == b.q;  break;
596
    default:
597
        t->interrupt(INT_WRONG_PARAMETERS);
598
    }
599
    if (t->vect)  t->vect = 4;                             // stop vector loop
600
 
601
    // invert condition if op odd
602
    branch ^= t->op;
603
    // conditional branch 
604
    if (branch & 1) {
605
        t->ip += t->addrOperand * 4;                       // add relative offset to IP
606
        t->returnType = 0x2000;                            // debug output jump taken
607
    }
608
    else t->returnType = 0x1000;                           // debug output jump taken
609
    t->running = 2;                                        // don't save result
610
    return 0;
611
}
612
 
613
static uint64_t test_bits_or(CThread * t) {
614
    // jump if (a & b) != 0
615
    SNum a = t->parm[1];                         // first parameter
616
    SNum b = t->parm[2];                         // second parameter
617
    if (t->fInstr->immSize) b = t->parm[4];      // avoid conversion of b to float
618
    int8_t branch = 0;                           // branch condition is inverted if op is odd
619
    // branch condition
620
    switch (t->operandType) {
621
    case 0:   // int8
622
        branch = (a.b & b.b) != 0;  break;
623
    case 1:   // int16
624
        branch = (a.s & b.s) != 0;  break;
625
    case 2:   // int32
626
    case 5:   // float
627
        branch = (a.i & b.i) != 0;  break;
628
    case 3:   // int64
629
    case 6:   // double
630
        branch = (a.q & b.q) != 0;  break;
631
    default:
632
        t->interrupt(INT_WRONG_PARAMETERS);
633
    }
634
    if (t->vect)  t->vect = 4;                             // stop vector loop
635
    // invert condition if op odd
636
    branch ^= t->op;
637
    // conditional branch 
638
    if (branch & 1) {
639
        t->ip += t->addrOperand * 4;                       // add relative offset to IP
640
        t->returnType = 0x2000;                            // debug output jump taken
641
    }
642
    else t->returnType = 0x1000;                           // debug output jump taken
643
    t->running = 2;                                        // don't save result
644
    return 0;
645
}
646
 
647
 
648
static uint64_t increment_compare_jump(CThread * t) {
649
    // result = a + 1. Jump if condition
650
    SNum a = t->parm[1];                         // first parameter
651
    SNum b = t->parm[2];                         // second parameter
652
    SNum result;                                 // result
653
    int8_t branch1 = 0;                          // jump if 1
654
    int8_t branch2 = 0;                          // jump if 1
655
    result.q = a.q + 1;                          // increment
656
 
657
    // branch condition
658
    switch (t->operandType) {
659
    case 0:   // int8
660
        branch1 = result.bs < b.bs;
661
        branch2 = result.bs > b.bs;
662
        break;
663
    case 1:   // int16
664
        branch1 = result.ss < b.ss;
665
        branch2 = result.ss > b.ss;
666
        break;
667
    case 2:   // int32
668
        branch1 = result.is < b.is;
669
        branch2 = result.is > b.is;
670
        break;
671
    case 3:   // int64
672
        branch1 = result.qs < b.qs;
673
        branch2 = result.qs > b.qs;
674
        break;
675
    default:
676
        t->interrupt(INT_WRONG_PARAMETERS);
677
    }
678
    // select instruction
679
    if ((t->op & 0x3E) != II_INCREMENT_COMPARE_JBELOW) {
680
        branch1 = branch2;       // increment_compare/jump_above
681
    }
682
    // invert condition if opj odd
683
    branch1 ^= t->op;
684
    // conditional branch
685
    if (branch1 & 1) {
686
        t->ip += t->addrOperand * 4;                       // add relative offset to IP
687
        t->returnType |= 0x2000;                           // debug output jump taken
688
    }
689
    return result.q;
690
}
691
 
692
static uint64_t sub_maxlen_jump_pos(CThread * t) {
693
    // Subtract the maximum vector length (in bytes) from a general purpose register 
694
    // and jump if the result is positive. The 8-bit immediate operand indicates the 
695
    // operand type for which the maximum vector length is obtained.
696
    // The register operand must be a 64-bit general purpose register.
697
    SNum a = t->parm[1];                         // first parameter
698
    SNum b = t->parm[2];                         // second parameter
699
    SNum result;                                 // result
700
    int8_t branch = 0;                           // jump if 1
701
    // b indicates the operand type for which the maximum vector length is used.
702
    // to do: allow different maximum vector lengths for different operand types
703
    if (b.q > 7) t->interrupt(INT_WRONG_PARAMETERS);
704
    uint64_t maxlen = t->MaxVectorLength;
705
 
706
    result.q = a.q - maxlen;                     // subtract maximum length
707
 
708
    // branch condition
709
    switch (t->operandType) {
710
    case 0:   // int8
711
        branch = result.bs > 0;  break;
712
    case 1:   // int16
713
        branch = result.ss > 0;  break;
714
    case 2:   // int32
715
        branch = result.is > 0;  break;
716
    case 3:   // int64. This is the preferred operant types.
717
        branch = result.qs > 0;  break;
718
    default:
719
        t->interrupt(INT_WRONG_PARAMETERS);
720
    }
721
    // invert condition if op odd
722
    branch ^= t->op;
723
    // conditional branch
724
    if (branch & 1) {
725
        t->ip += t->addrOperand * 4;                       // add relative offset to IP
726
        t->returnType |= 0x2000;                           // debug output jump taken
727
    }
728
    return result.q;
729
}
730
/*
731
static uint64_t sub_jump(CThread * t) {
732
    // subtract integers and jump unconditionally. optional
733
    SNum a = t->parm[1];                         // first parameter
734
    SNum b = t->parm[2];                         // second parameter
735
    SNum result;                                 // result
736
    int8_t unsignedOverflow = 0;                 // unsigned overflow detected
737
    int8_t signedOverflow = 0;                   // signed overflow detected
738
    result.q = a.q - b.q;                        // subtract integers
739
    // only integer types in g.p. registers allowed
740
    if (t->operandType > 3) t->interrupt(INT_WRONG_PARAMETERS);
741
    // overflow interrupts
742
    if (signedOverflow)   t->interrupt(INT_OVERFL_SIGN);
743
    if (unsignedOverflow) t->interrupt(INT_OVERFL_UNSIGN);
744
 
745
    // unconditional branch
746
    t->ip += t->addrOperand * 4;                 // add relative offset to IP
747
    t->returnType |= 0x2000;                     // debug output jump taken
748
    return result.q;                             // return result
749
}
750
 
751
static uint64_t add_jump(CThread * t) {
752
    // add integers and jump unconditionally. optional
753
    SNum a = t->parm[1];                         // first parameter
754
    SNum b = t->parm[2];                         // second parameter
755
    SNum result;                                 // result
756
    int8_t unsignedOverflow = 0;                 // unsigned overflow detected
757
    int8_t signedOverflow = 0;                   // signed overflow detected
758
    result.q = a.q + b.q;                        // add integers
759
    // only integer types in g.p. registers allowed
760
    if (t->operandType > 3) t->interrupt(INT_WRONG_PARAMETERS);
761
    // overflow interrupts
762
    if (signedOverflow)   t->interrupt(INT_OVERFL_SIGN);
763
    if (unsignedOverflow) t->interrupt(INT_OVERFL_UNSIGN);
764
 
765
    // unconditional branch
766
    t->ip += t->addrOperand * 4;                 // add relative offset to IP
767
    t->returnType |= 0x2000;                     // debug output jump taken
768
    return result.q;                             // return result
769
}*/
770
 
771
static uint64_t jump_call_58(CThread * t) {
772
    // op = 58: jump, 59: call
773
    // Format 1.6 and 2.5.0: Indirect jump or call with memory operand
774
    // Format 1.7 C, 2.5.4, and 3.1.0: Unconditional direct jump or call
775
    uint64_t target = 0;                         // target address
776
 
777
    // different instructions for different formats
778
    switch (t->fInstr->format2) {
779
    case 0x161: case 0x252: // Indirect jump or call with memory operand
780
        target = t->readMemoryOperand(t->memAddress);
781
        break;
782
    case 0x172: case 0x254: // Unconditional direct jump or call with relative address
783
        target = t->ip + t->addrOperand * 4;     // add relative offset to IP
784
        break;
785
    case 0x310: // Unconditional direct jump or call with absolute address
786
        target = t->addrOperand;                 // absolute address
787
        break;
788
    default:
789
        t->interrupt(INT_WRONG_PARAMETERS);
790
        return 0;
791
    }
792
    if (target & 3) { // misaligned jump target
793
        t->interrupt(INT_MISALIGNED_JUMP);
794
        return 0;
795
    }
796
 
797
    if (t->op & 1) {
798
        // this is a call instruction. push return address
799
        t->callStack.push(t->ip);                // push return address on call stack
800
        if (t->callStack.numEntries() > t->callDept) t->callDept = t->callStack.numEntries();
801
    }
802
    t->ip = target;                              // jump to new address
803
    t->running = 2;                              // don't save result
804
    return 0;
805
}
806
 
807
static uint64_t multiway_and_indirect(CThread * t) {
808
    // op = 60: jump, 61: call
809
    // Format 1.6 and 2.5.2: Multiway jump or call with table of relative addresses
810
    // Format 1.7 C: Indirect jump or call to value of register 
811
    uint64_t target = 0;                         // target address
812
    uint64_t offset;                             // offset relative to reference point
813
 
814
    // different instructions for different formats
815
    switch (t->fInstr->format2) {
816
    case 0x162: case 0x252: // Indirect jump or call with memory operand
817
        offset = t->readMemoryOperand(t->memAddress);
818
        // sign extend table entry
819
        switch (t->operandType) {
820
        case 0:  // int8
821
            offset = (uint64_t)(int64_t)(int8_t)offset;  break;
822
        case 1:  // int16
823
            offset = (uint64_t)(int64_t)(int16_t)offset;  break;
824
        case 2:  // int32
825
            offset = (uint64_t)(int64_t)(int32_t)offset;  break;
826
        case 3:  // int64
827
            break;
828
        default:
829
            t->interrupt(INT_WRONG_PARAMETERS);
830
        }
831
        offset <<= 2;                            // scale by 4
832
        target = t->parm[1].q + offset;          // add reference point
833
        break;
834
    case 0x173: // Unconditional indirect jump or call to value of register
835
        target = t->registers[t->operands[0]];
836
        break;
837
    default:
838
        t->interrupt(INT_WRONG_PARAMETERS);
839
        return 0;
840
    }
841
    if (target & 3) { // misaligned jump target
842
        t->interrupt(INT_MISALIGNED_JUMP);
843
        return 0;
844
    }
845
 
846
    if (t->op & 1) {
847
        // this is a call instruction. push return address
848
        t->callStack.push(t->ip);                // push return address on call stack
849
        if (t->callStack.numEntries() > t->callDept) t->callDept = t->callStack.numEntries();
850
    }
851
    t->ip = target;                              // jump to new address
852
    t->returnType = 0x2000;                      // debug output jump taken
853
    t->running = 2;                              // don't save result
854
    return 0;
855
}
856
 
857
static uint64_t return_62(CThread * t) {
858
    // Format 1.6: Normal function return
859
    // Format 1.7 C: system return
860
    uint64_t target = 0;                         // target address
861
    switch (t->fInstr->format2) {
862
    case 0x163: // return
863
        if (t->callStack.numEntries() == 0) {
864
            t->interrupt(INT_CALL_STACK);        // call stack empty
865
            target = t->entry_point;             // return to program start            
866
        }
867
        else {
868
            target = t->callStack.pop();         // pop return address
869
        }
870
        break;
871
    case 0x173: // system return
872
        // to do!
873
        target = t->ip;
874
        break;
875
    default:
876
        t->interrupt(INT_WRONG_PARAMETERS);
877
    }
878
    t->ip = target;                              // go to return address
879
    t->running = 2;                              // don't save result
880
    return 0;
881
}
882
 
883
static uint64_t syscall_63(CThread * t) {
884
    // Format 1.6: sys call. ID in register
885
    // Format 2.5.1, 2.5.7 and 3.1.0: sys call. ID in constants
886
    // Format 1.7 C: trap or filler
887
    // Format 2.5.5: conditional traps
888
    uint8_t rd = t->pInstr->a.rd;
889
    uint8_t rs = t->pInstr->a.rs;
890
    uint8_t rt = t->pInstr->a.rt;
891
    uint32_t mod;                                // module id
892
    uint32_t funcid;                             // function id
893
    switch (t->fInstr->format2) {
894
    case 0x163: // system call. ID in register
895
        if (t->operandType == 2) { // 16+16 bit
896
            mod = uint16_t(t->registers[rt] >> 16);
897
            funcid = uint16_t(t->registers[rt]);
898
        }
899
        else if (t->operandType == 3) {  // 32+32 bit
900
            mod = uint32_t(t->registers[rt] >> 32);
901
            funcid = uint32_t(t->registers[rt]);
902
        }
903
        else {t->interrupt(INT_WRONG_PARAMETERS); return 0;}
904
        t->systemCall(mod, funcid, rd, rs);
905
        break;
906
    case 0x251:  // system call. ID in constants
907
        mod = t->pInstr->s[3];
908
        funcid = t->pInstr->s[2];
909
        t->systemCall(mod, funcid, rd, rs);
910
        break;
911
    case 0x257:  // system call. ID in constants. no registers
912
        mod = t->pInstr->i[1];
913
        funcid = t->pInstr->s[0];
914
        t->systemCall(mod, funcid, 0, 0);
915
        break;
916
    case 0x310: // system call. ID in constants
917
        mod = t->pInstr->i[2];
918
        funcid = t->pInstr->i[1];
919
        t->systemCall(mod, funcid, rd, rs);
920
        break;
921
    case 0x174: case 0x175: // trap or filler
922
        t->interrupt(t->pInstr->s[0]);
923
        break;
924
    case 0x255: // conditional traps
925
        if (t->pInstr->b[1] != 40) t->interrupt(INT_WRONG_PARAMETERS); // the only condition supported is unsigned above
926
        if (t->parm[1].i > t->parm[2].i) {       // check condition, unsigned compare
927
            t->interrupt(t->pInstr->b[0]);       // generate interrupt
928
        }
929
        break;
930
    default:
931
        t->interrupt(INT_WRONG_PARAMETERS);
932
    }
933
    t->running = 2;                              // don't save result
934
    t->returnType = 0;                           // debug output written by system function
935
    return 0;
936
}
937
 
938
// Jump instructions, conditional and indirect
939
PFunc funcTab2[64] = {
940
    sub_jump_generic, sub_jump_generic, sub_jump_generic, sub_jump_generic,                        // 0 - 3
941
    sub_jump_generic, sub_jump_generic, sub_jump_generic, sub_jump_generic,                        // 4 - 7
942
    sub_jump_generic, sub_jump_generic, and_jump_zero, and_jump_zero,                              // 8 - 11
943
    or_jump_zero, or_jump_zero, xor_jump_zero, xor_jump_zero,                                      // 12 - 15                                                                   
944
    add_jump_generic, add_jump_generic, add_jump_generic, add_jump_generic,                        // 16 - 19
945
    add_jump_generic, add_jump_generic, add_jump_generic, add_jump_generic,                        // 20 - 23
946
    add_jump_generic, add_jump_generic, test_bit_jump_true, test_bit_jump_true,                    // 24 - 27
947
    test_bits_and, test_bits_and, test_bits_or, test_bits_or,                                      // 28 - 31
948
    compare_jump_generic, compare_jump_generic, compare_jump_generic, compare_jump_generic,        // 32 - 35
949
    compare_jump_generic, compare_jump_generic, compare_jump_generic, compare_jump_generic,        // 36 - 39
950
    compare_jump_generic, compare_jump_generic, 0, 0,                                              // 40 - 43
951
    0, 0, 0, 0,                                                                                    // 44 - 47
952
    increment_compare_jump, increment_compare_jump, increment_compare_jump, increment_compare_jump,// 48 - 51
953
    sub_maxlen_jump_pos, sub_maxlen_jump_pos, 0, 0,                                                // 52 - 55
954
    0, 0, jump_call_58, jump_call_58,                                                              // 56 - 59
955
    multiway_and_indirect, multiway_and_indirect, return_62, syscall_63                            // 60 - 63
956
};
957
 
958
// jump and call instructions with 24 bit offset
959
PFunc funcTab3[16] = {
960
    f_jump, f_jump, f_jump, f_jump, f_jump, f_jump, f_jump, f_jump,
961
    f_call, f_call, f_call, f_call, f_call, f_call, f_call, f_call
962
};

powered by: WebSVN 2.1.0

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