linux / linux / kernel / git / bpf / bpf / b317538c47943f9903860d83cc0060409e12d2ff / . / arch / nios2 / kernel / insnemu.S

/* SPDX-License-Identifier: GPL-2.0-or-later */ | |

/* | |

* Copyright (C) 2003-2013 Altera Corporation | |

* All rights reserved. | |

*/ | |

#include <linux/linkage.h> | |

#include <asm/entry.h> | |

.set noat | |

.set nobreak | |

/* | |

* Explicitly allow the use of r1 (the assembler temporary register) | |

* within this code. This register is normally reserved for the use of | |

* the compiler. | |

*/ | |

ENTRY(instruction_trap) | |

ldw r1, PT_R1(sp) // Restore registers | |

ldw r2, PT_R2(sp) | |

ldw r3, PT_R3(sp) | |

ldw r4, PT_R4(sp) | |

ldw r5, PT_R5(sp) | |

ldw r6, PT_R6(sp) | |

ldw r7, PT_R7(sp) | |

ldw r8, PT_R8(sp) | |

ldw r9, PT_R9(sp) | |

ldw r10, PT_R10(sp) | |

ldw r11, PT_R11(sp) | |

ldw r12, PT_R12(sp) | |

ldw r13, PT_R13(sp) | |

ldw r14, PT_R14(sp) | |

ldw r15, PT_R15(sp) | |

ldw ra, PT_RA(sp) | |

ldw fp, PT_FP(sp) | |

ldw gp, PT_GP(sp) | |

ldw et, PT_ESTATUS(sp) | |

wrctl estatus, et | |

ldw ea, PT_EA(sp) | |

ldw et, PT_SP(sp) /* backup sp in et */ | |

addi sp, sp, PT_REGS_SIZE | |

/* INSTRUCTION EMULATION | |

* --------------------- | |

* | |

* Nios II processors generate exceptions for unimplemented instructions. | |

* The routines below emulate these instructions. Depending on the | |

* processor core, the only instructions that might need to be emulated | |

* are div, divu, mul, muli, mulxss, mulxsu, and mulxuu. | |

* | |

* The emulations match the instructions, except for the following | |

* limitations: | |

* | |

* 1) The emulation routines do not emulate the use of the exception | |

* temporary register (et) as a source operand because the exception | |

* handler already has modified it. | |

* | |

* 2) The routines do not emulate the use of the stack pointer (sp) or | |

* the exception return address register (ea) as a destination because | |

* modifying these registers crashes the exception handler or the | |

* interrupted routine. | |

* | |

* Detailed Design | |

* --------------- | |

* | |

* The emulation routines expect the contents of integer registers r0-r31 | |

* to be on the stack at addresses sp, 4(sp), 8(sp), ... 124(sp). The | |

* routines retrieve source operands from the stack and modify the | |

* destination register's value on the stack prior to the end of the | |

* exception handler. Then all registers except the destination register | |

* are restored to their previous values. | |

* | |

* The instruction that causes the exception is found at address -4(ea). | |

* The instruction's OP and OPX fields identify the operation to be | |

* performed. | |

* | |

* One instruction, muli, is an I-type instruction that is identified by | |

* an OP field of 0x24. | |

* | |

* muli AAAAA,BBBBB,IIIIIIIIIIIIIIII,-0x24- | |

* 27 22 6 0 <-- LSB of field | |

* | |

* The remaining emulated instructions are R-type and have an OP field | |

* of 0x3a. Their OPX fields identify them. | |

* | |

* R-type AAAAA,BBBBB,CCCCC,XXXXXX,NNNNN,-0x3a- | |

* 27 22 17 11 6 0 <-- LSB of field | |

* | |

* | |

* Opcode Encoding. muli is identified by its OP value. Then OPX & 0x02 | |

* is used to differentiate between the division opcodes and the | |

* remaining multiplication opcodes. | |

* | |

* Instruction OP OPX OPX & 0x02 | |

* ----------- ---- ---- ---------- | |

* muli 0x24 | |

* divu 0x3a 0x24 0 | |

* div 0x3a 0x25 0 | |

* mul 0x3a 0x27 != 0 | |

* mulxuu 0x3a 0x07 != 0 | |

* mulxsu 0x3a 0x17 != 0 | |

* mulxss 0x3a 0x1f != 0 | |

*/ | |

/* | |

* Save everything on the stack to make it easy for the emulation | |

* routines to retrieve the source register operands. | |

*/ | |

addi sp, sp, -128 | |

stw zero, 0(sp) /* Save zero on stack to avoid special case for r0. */ | |

stw r1, 4(sp) | |

stw r2, 8(sp) | |

stw r3, 12(sp) | |

stw r4, 16(sp) | |

stw r5, 20(sp) | |

stw r6, 24(sp) | |

stw r7, 28(sp) | |

stw r8, 32(sp) | |

stw r9, 36(sp) | |

stw r10, 40(sp) | |

stw r11, 44(sp) | |

stw r12, 48(sp) | |

stw r13, 52(sp) | |

stw r14, 56(sp) | |

stw r15, 60(sp) | |

stw r16, 64(sp) | |

stw r17, 68(sp) | |

stw r18, 72(sp) | |

stw r19, 76(sp) | |

stw r20, 80(sp) | |

stw r21, 84(sp) | |

stw r22, 88(sp) | |

stw r23, 92(sp) | |

/* Don't bother to save et. It's already been changed. */ | |

rdctl r5, estatus | |

stw r5, 100(sp) | |

stw gp, 104(sp) | |

stw et, 108(sp) /* et contains previous sp value. */ | |

stw fp, 112(sp) | |

stw ea, 116(sp) | |

stw ra, 120(sp) | |

/* | |

* Split the instruction into its fields. We need 4*A, 4*B, and 4*C as | |

* offsets to the stack pointer for access to the stored register values. | |

*/ | |

ldw r2,-4(ea) /* r2 = AAAAA,BBBBB,IIIIIIIIIIIIIIII,PPPPPP */ | |

roli r3, r2, 7 /* r3 = BBB,IIIIIIIIIIIIIIII,PPPPPP,AAAAA,BB */ | |

roli r4, r3, 3 /* r4 = IIIIIIIIIIIIIIII,PPPPPP,AAAAA,BBBBB */ | |

roli r5, r4, 2 /* r5 = IIIIIIIIIIIIII,PPPPPP,AAAAA,BBBBB,II */ | |

srai r4, r4, 16 /* r4 = (sign-extended) IMM16 */ | |

roli r6, r5, 5 /* r6 = XXXX,NNNNN,PPPPPP,AAAAA,BBBBB,CCCCC,XX */ | |

andi r2, r2, 0x3f /* r2 = 00000000000000000000000000,PPPPPP */ | |

andi r3, r3, 0x7c /* r3 = 0000000000000000000000000,AAAAA,00 */ | |

andi r5, r5, 0x7c /* r5 = 0000000000000000000000000,BBBBB,00 */ | |

andi r6, r6, 0x7c /* r6 = 0000000000000000000000000,CCCCC,00 */ | |

/* Now | |

* r2 = OP | |

* r3 = 4*A | |

* r4 = IMM16 (sign extended) | |

* r5 = 4*B | |

* r6 = 4*C | |

*/ | |

/* | |

* Get the operands. | |

* | |

* It is necessary to check for muli because it uses an I-type | |

* instruction format, while the other instructions are have an R-type | |

* format. | |

* | |

* Prepare for either multiplication or division loop. | |

* They both loop 32 times. | |

*/ | |

movi r14, 32 | |

add r3, r3, sp /* r3 = address of A-operand. */ | |

ldw r3, 0(r3) /* r3 = A-operand. */ | |

movi r7, 0x24 /* muli opcode (I-type instruction format) */ | |

beq r2, r7, mul_immed /* muli doesn't use the B register as a source */ | |

add r5, r5, sp /* r5 = address of B-operand. */ | |

ldw r5, 0(r5) /* r5 = B-operand. */ | |

/* r4 = SSSSSSSSSSSSSSSS,-----IMM16------ */ | |

/* IMM16 not needed, align OPX portion */ | |

/* r4 = SSSSSSSSSSSSSSSS,CCCCC,-OPX--,00000 */ | |

srli r4, r4, 5 /* r4 = 00000,SSSSSSSSSSSSSSSS,CCCCC,-OPX-- */ | |

andi r4, r4, 0x3f /* r4 = 00000000000000000000000000,-OPX-- */ | |

/* Now | |

* r2 = OP | |

* r3 = src1 | |

* r5 = src2 | |

* r4 = OPX (no longer can be muli) | |

* r6 = 4*C | |

*/ | |

/* | |

* Multiply or Divide? | |

*/ | |

andi r7, r4, 0x02 /* For R-type multiply instructions, | |

OPX & 0x02 != 0 */ | |

bne r7, zero, multiply | |

/* DIVISION | |

* | |

* Divide an unsigned dividend by an unsigned divisor using | |

* a shift-and-subtract algorithm. The example below shows | |

* 43 div 7 = 6 for 8-bit integers. This classic algorithm uses a | |

* single register to store both the dividend and the quotient, | |

* allowing both values to be shifted with a single instruction. | |

* | |

* remainder dividend:quotient | |

* --------- ----------------- | |

* initialize 00000000 00101011: | |

* shift 00000000 0101011:_ | |

* remainder >= divisor? no 00000000 0101011:0 | |

* shift 00000000 101011:0_ | |

* remainder >= divisor? no 00000000 101011:00 | |

* shift 00000001 01011:00_ | |

* remainder >= divisor? no 00000001 01011:000 | |

* shift 00000010 1011:000_ | |

* remainder >= divisor? no 00000010 1011:0000 | |

* shift 00000101 011:0000_ | |

* remainder >= divisor? no 00000101 011:00000 | |

* shift 00001010 11:00000_ | |

* remainder >= divisor? yes 00001010 11:000001 | |

* remainder -= divisor - 00000111 | |

* ---------- | |

* 00000011 11:000001 | |

* shift 00000111 1:000001_ | |

* remainder >= divisor? yes 00000111 1:0000011 | |

* remainder -= divisor - 00000111 | |

* ---------- | |

* 00000000 1:0000011 | |

* shift 00000001 :0000011_ | |

* remainder >= divisor? no 00000001 :00000110 | |

* | |

* The quotient is 00000110. | |

*/ | |

divide: | |

/* | |

* Prepare for division by assuming the result | |

* is unsigned, and storing its "sign" as 0. | |

*/ | |

movi r17, 0 | |

/* Which division opcode? */ | |

xori r7, r4, 0x25 /* OPX of div */ | |

bne r7, zero, unsigned_division | |

/* | |

* OPX is div. Determine and store the sign of the quotient. | |

* Then take the absolute value of both operands. | |

*/ | |

xor r17, r3, r5 /* MSB contains sign of quotient */ | |

bge r3,zero,dividend_is_nonnegative | |

sub r3, zero, r3 /* -r3 */ | |

dividend_is_nonnegative: | |

bge r5, zero, divisor_is_nonnegative | |

sub r5, zero, r5 /* -r5 */ | |

divisor_is_nonnegative: | |

unsigned_division: | |

/* Initialize the unsigned-division loop. */ | |

movi r13, 0 /* remainder = 0 */ | |

/* Now | |

* r3 = dividend : quotient | |

* r4 = 0x25 for div, 0x24 for divu | |

* r5 = divisor | |

* r13 = remainder | |

* r14 = loop counter (already initialized to 32) | |

* r17 = MSB contains sign of quotient | |

*/ | |

/* | |

* for (count = 32; count > 0; --count) | |

* { | |

*/ | |

divide_loop: | |

/* | |

* Division: | |

* | |

* (remainder:dividend:quotient) <<= 1; | |

*/ | |

slli r13, r13, 1 | |

cmplt r7, r3, zero /* r7 = MSB of r3 */ | |

or r13, r13, r7 | |

slli r3, r3, 1 | |

/* | |

* if (remainder >= divisor) | |

* { | |

* set LSB of quotient | |

* remainder -= divisor; | |

* } | |

*/ | |

bltu r13, r5, div_skip | |

ori r3, r3, 1 | |

sub r13, r13, r5 | |

div_skip: | |

/* | |

* } | |

*/ | |

subi r14, r14, 1 | |

bne r14, zero, divide_loop | |

/* Now | |

* r3 = quotient | |

* r4 = 0x25 for div, 0x24 for divu | |

* r6 = 4*C | |

* r17 = MSB contains sign of quotient | |

*/ | |

/* | |

* Conditionally negate signed quotient. If quotient is unsigned, | |

* the sign already is initialized to 0. | |

*/ | |

bge r17, zero, quotient_is_nonnegative | |

sub r3, zero, r3 /* -r3 */ | |

quotient_is_nonnegative: | |

/* | |

* Final quotient is in r3. | |

*/ | |

add r6, r6, sp | |

stw r3, 0(r6) /* write quotient to stack */ | |

br restore_registers | |

/* MULTIPLICATION | |

* | |

* A "product" is the number that one gets by summing a "multiplicand" | |

* several times. The "multiplier" specifies the number of copies of the | |

* multiplicand that are summed. | |

* | |

* Actual multiplication algorithms don't use repeated addition, however. | |

* Shift-and-add algorithms get the same answer as repeated addition, and | |

* they are faster. To compute the lower half of a product (pppp below) | |

* one shifts the product left before adding in each of the partial | |

* products (a * mmmm) through (d * mmmm). | |

* | |

* To compute the upper half of a product (PPPP below), one adds in the | |

* partial products (d * mmmm) through (a * mmmm), each time following | |

* the add by a right shift of the product. | |

* | |

* mmmm | |

* * abcd | |

* ------ | |

* #### = d * mmmm | |

* #### = c * mmmm | |

* #### = b * mmmm | |

* #### = a * mmmm | |

* -------- | |

* PPPPpppp | |

* | |

* The example above shows 4 partial products. Computing actual Nios II | |

* products requires 32 partials. | |

* | |

* It is possible to compute the result of mulxsu from the result of | |

* mulxuu because the only difference between the results of these two | |

* opcodes is the value of the partial product associated with the sign | |

* bit of rA. | |

* | |

* mulxsu = mulxuu - (rA < 0) ? rB : 0; | |

* | |

* It is possible to compute the result of mulxss from the result of | |

* mulxsu because the only difference between the results of these two | |

* opcodes is the value of the partial product associated with the sign | |

* bit of rB. | |

* | |

* mulxss = mulxsu - (rB < 0) ? rA : 0; | |

* | |

*/ | |

mul_immed: | |

/* Opcode is muli. Change it into mul for remainder of algorithm. */ | |

mov r6, r5 /* Field B is dest register, not field C. */ | |

mov r5, r4 /* Field IMM16 is src2, not field B. */ | |

movi r4, 0x27 /* OPX of mul is 0x27 */ | |

multiply: | |

/* Initialize the multiplication loop. */ | |

movi r9, 0 /* mul_product = 0 */ | |

movi r10, 0 /* mulxuu_product = 0 */ | |

mov r11, r5 /* save original multiplier for mulxsu and mulxss */ | |

mov r12, r5 /* mulxuu_multiplier (will be shifted) */ | |

movi r16, 1 /* used to create "rori B,A,1" from "ror B,A,r16" */ | |

/* Now | |

* r3 = multiplicand | |

* r5 = mul_multiplier | |

* r6 = 4 * dest_register (used later as offset to sp) | |

* r7 = temp | |

* r9 = mul_product | |

* r10 = mulxuu_product | |

* r11 = original multiplier | |

* r12 = mulxuu_multiplier | |

* r14 = loop counter (already initialized) | |

* r16 = 1 | |

*/ | |

/* | |

* for (count = 32; count > 0; --count) | |

* { | |

*/ | |

multiply_loop: | |

/* | |

* mul_product <<= 1; | |

* lsb = multiplier & 1; | |

*/ | |

slli r9, r9, 1 | |

andi r7, r12, 1 | |

/* | |

* if (lsb == 1) | |

* { | |

* mulxuu_product += multiplicand; | |

* } | |

*/ | |

beq r7, zero, mulx_skip | |

add r10, r10, r3 | |

cmpltu r7, r10, r3 /* Save the carry from the MSB of mulxuu_product. */ | |

ror r7, r7, r16 /* r7 = 0x80000000 on carry, or else 0x00000000 */ | |

mulx_skip: | |

/* | |

* if (MSB of mul_multiplier == 1) | |

* { | |

* mul_product += multiplicand; | |

* } | |

*/ | |

bge r5, zero, mul_skip | |

add r9, r9, r3 | |

mul_skip: | |

/* | |

* mulxuu_product >>= 1; logical shift | |

* mul_multiplier <<= 1; done with MSB | |

* mulx_multiplier >>= 1; done with LSB | |

*/ | |

srli r10, r10, 1 | |

or r10, r10, r7 /* OR in the saved carry bit. */ | |

slli r5, r5, 1 | |

srli r12, r12, 1 | |

/* | |

* } | |

*/ | |

subi r14, r14, 1 | |

bne r14, zero, multiply_loop | |

/* | |

* Multiply emulation loop done. | |

*/ | |

/* Now | |

* r3 = multiplicand | |

* r4 = OPX | |

* r6 = 4 * dest_register (used later as offset to sp) | |

* r7 = temp | |

* r9 = mul_product | |

* r10 = mulxuu_product | |

* r11 = original multiplier | |

*/ | |

/* Calculate address for result from 4 * dest_register */ | |

add r6, r6, sp | |

/* | |

* Select/compute the result based on OPX. | |

*/ | |

/* OPX == mul? Then store. */ | |

xori r7, r4, 0x27 | |

beq r7, zero, store_product | |

/* It's one of the mulx.. opcodes. Move over the result. */ | |

mov r9, r10 | |

/* OPX == mulxuu? Then store. */ | |

xori r7, r4, 0x07 | |

beq r7, zero, store_product | |

/* Compute mulxsu | |

* | |

* mulxsu = mulxuu - (rA < 0) ? rB : 0; | |

*/ | |

bge r3, zero, mulxsu_skip | |

sub r9, r9, r11 | |

mulxsu_skip: | |

/* OPX == mulxsu? Then store. */ | |

xori r7, r4, 0x17 | |

beq r7, zero, store_product | |

/* Compute mulxss | |

* | |

* mulxss = mulxsu - (rB < 0) ? rA : 0; | |

*/ | |

bge r11,zero,mulxss_skip | |

sub r9, r9, r3 | |

mulxss_skip: | |

/* At this point, assume that OPX is mulxss, so store*/ | |

store_product: | |

stw r9, 0(r6) | |

restore_registers: | |

/* No need to restore r0. */ | |

ldw r5, 100(sp) | |

wrctl estatus, r5 | |

ldw r1, 4(sp) | |

ldw r2, 8(sp) | |

ldw r3, 12(sp) | |

ldw r4, 16(sp) | |

ldw r5, 20(sp) | |

ldw r6, 24(sp) | |

ldw r7, 28(sp) | |

ldw r8, 32(sp) | |

ldw r9, 36(sp) | |

ldw r10, 40(sp) | |

ldw r11, 44(sp) | |

ldw r12, 48(sp) | |

ldw r13, 52(sp) | |

ldw r14, 56(sp) | |

ldw r15, 60(sp) | |

ldw r16, 64(sp) | |

ldw r17, 68(sp) | |

ldw r18, 72(sp) | |

ldw r19, 76(sp) | |

ldw r20, 80(sp) | |

ldw r21, 84(sp) | |

ldw r22, 88(sp) | |

ldw r23, 92(sp) | |

/* Does not need to restore et */ | |

ldw gp, 104(sp) | |

ldw fp, 112(sp) | |

ldw ea, 116(sp) | |

ldw ra, 120(sp) | |

ldw sp, 108(sp) /* last restore sp */ | |

eret | |

.set at | |

.set break |