Lines Matching refs:Instruction
558 set fmovm_flg, 0x40 # flag bit: fmovm instruction
595 # _imem_read_long() - read instruction longword #
601 # fout() - emulate an opclass 3 instruction #
622 # instruction, the 060 will take an overflow exception whether the #
624 # This handler emulates the instruction to determine what the correct #
631 # the default result (only if the instruction is opclass 3). For #
639 # Also, in the case of an opclass three instruction where #
658 # the FPIAR holds the "current PC" of the faulting instruction
660 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
661 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
662 bsr.l _imem_read_long # fetch the instruction words
835 # _imem_read_long() - read instruction longword #
841 # fout() - emulate an opclass 3 instruction #
862 # instruction, the 060 will take an underflow exception whether the #
864 # This handler emulates the instruction to determine what the correct #
871 # the default result (only if the instruction is opclass 3). For #
879 # Also, in the case of an opclass three instruction where #
898 # the FPIAR holds the "current PC" of the faulting instruction
900 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
901 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
902 bsr.l _imem_read_long # fetch the instruction words
1110 # _imem_read_{word,long}() - read instruction word/longword #
1117 # fout() - emulate an opclass 3 instruction #
1150 # Two main instruction types can enter here: (1) DENORM or UNNORM #
1156 # from the FP register file. The instruction is then emulated by #
1158 # instruction type. Once the instruction has been emulated and result #
1160 # instruction emulation. If none, then we exit through the "callout" #
1164 # PACKED opclass 0 and 2 is similar in how the instruction is #
1186 # post-instruction
1189 # pre-instruction * *
1238 # the FPIAR holds the "current PC" of the faulting instruction
1242 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
1243 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
1244 bsr.l _imem_read_long # fetch the instruction words
1262 # I'm not sure at this point what FPSR bits are valid for this instruction.
1516 # I'm not sure at this point what FPSR bits are valid for this instruction.
1732 # three instruction exceptions don't update the stack pointer. so, if the
1818 # I'm not sure at this point what FPSR bits are valid for this instruction.
2048 # The opclass two PACKED instruction that took an "Unimplemented Data Type"
2075 # I'm not sure at this point what FPSR bits are valid for this instruction.
2195 # the instruction was "fmove.p fpn,-(a7)" from supervisor mode.
2235 # the instruction was "fmove.p fpn,-(a7)" from supervisor mode.
2275 # the instruction was "fmove.p fpn,-(a7)" from supervisor mode.
2381 # _imem_read_long() - read instruction longword #
2394 # fmovm_dynamic() - emulate dynamic fmovm instruction #
2395 # fmovm_ctrl() - emulate fmovm control instruction #
2414 # (2) The "fmovm.x" instruction w/ dynamic register specification. #
2415 # (3) The "fmovm.l" instruction w/ 2 or 3 control registers. #
2419 # as the source operand to the instruction specified by the instruction #
2431 # decode and emulate the instruction. No FP exceptions can be pending #
2435 # For the case of "fmovm.x Dn,-(a7)", where the offending instruction #
2440 # For "fmovm.l", fmovm_ctrl() is used to emulate the instruction. #
2450 # reproducing the effective address of the instruction to put on the #
2479 # PC of instruction that took the exception is the PC in the frame
2482 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
2483 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
2484 bsr.l _imem_read_long # fetch the instruction words
2720 # The opclass two instruction that took an "Unimplemented Effective Address"
2921 # The control reg instruction that took an "Unimplemented Effective Address"
2956 # of the faulting instruction to get the "next PC". This is trivial for
2966 # PC of instruction that took the exception is the PC in the frame
2968 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
2969 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
2970 bsr.l _imem_read_long # fetch the instruction words
2975 # instruction is using an extended precision immediate operand. therefore,
2976 # the total instruction length is 16 bytes.
2978 mov.l &0x10,%d0 # 16 bytes of instruction
2983 # the instruction is a fmovm.l with 2 or 3 registers.
2990 # the instruction is an fmovm.x dynamic which can use many addressing
2991 # modes and thus can have several different total instruction lengths.
2993 # as a by-product, will tell us how long the instruction is.
3081 # _imem_read_long() - read instruction longword #
3100 # for opclass zero and two instruction taking this exception, the #
3126 # the FPIAR holds the "current PC" of the faulting instruction
3129 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
3130 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
3131 bsr.l _imem_read_long # fetch the instruction words
3270 # _imem_read_long() - read instruction longword #
3302 # For the case of an extended precision opclass 3 instruction, #
3322 # the FPIAR holds the "current PC" of the faulting instruction
3325 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
3326 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
3327 bsr.l _imem_read_long # fetch the instruction words
3569 # _imem_read_long() - read instruction longword #
3575 # smovcr() - emulate an "fmovcr" instruction #
3576 # fout() - emulate an opclass 3 instruction #
3591 # for opclass zero and two instruction taking this exception, the #
3594 # instruction in order to get this value and then store it to the #
3614 # the FPIAR holds the "current PC" of the faulting instruction
3617 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
3618 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
3619 bsr.l _imem_read_long # fetch the instruction words
3645 # emulate the whole instruction. Notice, though, that we don't kill the
3755 # _imem_read_long() - read instruction longword from memory #
3788 # the FPIAR holds the "current PC" of the faulting instruction
3791 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
3792 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
3793 bsr.l _imem_read_long # fetch the instruction words
3826 # _imem_read_long() - read instruction longword #
3838 # (1) FPU unimplemented instruction (6 word stack frame) #
3855 # check to see if this exception is a "FP Unimplemented Instruction"
3866 # if the F-Line instruction is an "fmovecr" w/ a non-zero <ea>. if
3868 # Instruction exception stack frame else branch to the OS entry
3875 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
3876 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
3877 bsr.l _imem_read_long # fetch instruction words
3890 # FP Unimplemented Instruction stack frame and jump to that entry
3936 # Instruction" exception. #
3939 # FP Unimplemented Instruction exception in an operating system. #
3942 # _imem_read_{word,long}() - read instruction word/longword #
3949 # smovcr() - emulate "fmovecr" instruction #
3951 # _ftrapcc() - emulate an "ftrapcc" instruction #
3952 # _fdbcc() - emulate an "fdbcc" instruction #
3953 # _fscc() - emulate an "fscc" instruction #
3974 # for instruction emulation. The correct emulation routine is then #
3975 # chosen by decoding the instruction type and indexing into an #
3978 # FP instruction emulation. If so, then an FP exception of the correct #
3980 # instruction before exiting through _fpsp_done(). In either the #
3990 # instruction was "ftrapcc" and a Trap exception should result, a Trap #
4005 # FP UNIMPLEMENTED INSTRUCTION STACK FRAME:
4052 # the FPIAR holds the "current PC" of the faulting instruction.
4055 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
4056 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
4057 bsr.l _imem_read_long # fetch the instruction words
4152 # if the instruction was executed from supervisor mode and the addressing
4250 # restored into the machine for the instruction just emulated.
4305 # the ftrapcc instruction should take a trap. so, here we must create a
4306 # trap stack frame from an unimplemented fp instruction stack frame and
4324 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
4325 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
4347 # I am assuming here that an "fs<cc>.b -(An)" or "fs<cc>.b (An)+" instruction
4366 # remember, also, this instruction may be traced.
4396 # the fp unimplemented instruction exception stack frame into a bsun stack frame,
4463 # the fscc instruction should take a trace trap. so, here we must create a
4464 # trace stack frame from an unimplemented fp instruction stack frame and
4983 # the instruction fetch access for the displacement word for the
5579 #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
6010 #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
6952 # Note also that we use the FMOVEM instruction to move X #
10422 # a0 : points to result (in instruction memory) #
10999 # routines where an instruction is selected by an index into
11000 # a large jump table corresponding to a given instruction which
11347 # fmul() - emulate a multiply instruction #
11348 # fadd() - emulate an add instruction #
11349 # fin() - emulate an fmove instruction #
11353 # d0 = type of instruction that took exception #
11361 # An exception occurred on the last instruction of the #
11532 # fmul(): emulates the fmul instruction #
11533 # fsmul(): emulates the fsmul instruction #
11534 # fdmul(): emulates the fdmul instruction #
11557 # instruction won't cause an exception. Use the regular fmul to #
12028 # fin(): emulates the fmove instruction #
12029 # fsin(): emulates the fsmove instruction #
12030 # fdin(): emulates the fdmove instruction #
12051 # Norms can be emulated w/ a regular fmove instruction. For #
12349 # fdiv(): emulates the fdiv instruction #
12350 # fsdiv(): emulates the fsdiv instruction #
12351 # fddiv(): emulates the fddiv instruction #
12374 # instruction won't cause an exception. Use the regular fdiv to #
12803 # fneg(): emulates the fneg instruction #
12804 # fsneg(): emulates the fsneg instruction #
12805 # fdneg(): emulates the fdneg instruction #
13129 # ftst(): emulates the ftest instruction #
13132 # res{s,q}nan_1op() - set NAN result for monadic instruction #
13214 # fint(): emulates the fint instruction #
13320 # fintrz(): emulates the fintrz instruction #
13422 # fabs(): emulates the fabs instruction #
13423 # fsabs(): emulates the fsabs instruction #
13424 # fdabs(): emulates the fdabs instruction #
13760 # just use the actual fcmp instruction to produce the correct condition #
13936 # fsglmul(): emulates the fsglmul instruction #
13959 # instruction won't cause an exception. Use the regular fsglmul to #
14277 # fsgldiv(): emulates the fsgldiv instruction #
14300 # instruction won't cause an exception. Use the regular fsgldiv to #
14612 # fadd(): emulates the fadd instruction #
14613 # fsadd(): emulates the fadd instruction #
14614 # fdadd(): emulates the fdadd instruction #
15065 # fsub(): emulates the fsub instruction #
15066 # fssub(): emulates the fssub instruction #
15067 # fdsub(): emulates the fdsub instruction #
15511 # fsqrt(): emulates the fsqrt instruction #
15512 # fssqrt(): emulates the fssqrt instruction #
15513 # fdsqrt(): emulates the fdsqrt instruction #
15534 # instruction won't cause an exception. Use the regular fsqrt to #
16257 # fdbcc(): routine to emulate the fdbcc instruction #
16274 # the stacked fdbcc instruction opcode and then branches to a routine #
16275 # for that predicate. The corresponding fbcc instruction is then used #
16852 # pc = pc of next instruction
16873 add.l USER_FPIAR(%a6),%d0 # add instruction PC
16874 addq.l &0x4,%d0 # add instruction length
16887 # ftrapcc(): routine to emulate the ftrapcc instruction #
16903 # the stacked ftrapcc instruction opcode and then branches to a routine #
16904 # for that predicate. The corresponding fbcc instruction is then used #
17439 # is the same size as that of the fp unimp instruction. the
17441 # of the ftrapcc instruction and the vector offset field
17456 # fscc(): routine to emulate the fscc instruction #
17475 # the stacked fscc instruction opcode and then branches to a routine #
17476 # for that predicate. The corresponding fbcc instruction is then used #
18159 # fmovm_dynamic(): emulate "fmovm" dynamic instruction #
18165 # iea_iacc() - instruction memory access error occurred #
18176 # Else if instruction access error, #
18194 # If the instruction is "fmovm.x <ea>,Dn", a _mem_read() is used #
18197 # If the instruction is "fmovm.x DN,<ea>", a _mem_write() is used #
18199 # If the instruction is "fmovm.x DN,-(a7)" from supervisor mode, #
18220 # instruction is a nop. #
18790 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18791 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18803 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18804 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18816 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18817 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18829 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18830 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18842 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18843 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18855 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18856 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18868 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18869 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18881 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18882 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18904 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18905 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18949 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18950 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18963 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18964 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
18977 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
18978 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
18999 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19000 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
19092 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19093 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19102 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19103 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
19123 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19124 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19133 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19134 addq.l &0x2,EXC_EXTWPTR(%a6) # incr instruction ptr
19225 # Decode the instruction
19230 # Instruction word decoding: #
19256 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19257 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19264 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19265 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19276 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19277 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19284 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19285 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19296 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19297 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19304 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19305 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19316 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19317 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19324 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19325 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19332 mov.l EXC_EXTWPTR(%a6),%a0 # fetch instruction addr
19333 addq.l &0x4,EXC_EXTWPTR(%a6) # incr instruction ptr
19578 # _imem_read_{word,long}() - read from instruction memory #
19595 # FP_SRC(a6) and FP_DST(a6). If the instruction was opclass zero, load #
19599 # If the instruction is opclass two (memory->reg), then fetch #
19611 # instruction bit set. #
19621 # | opclass | RX | RY | EXTENSION | (2nd word of general FP instruction)
20187 # Decode an fmove out (opclass 3) instruction to determine if #
20198 # For packed, the k-factor must be fetched from the instruction #
21352 # Typically used for an instruction w/ a post-increment <ea>, #
21416 # Typically used for an instruction w/ a pre-decrement <ea>, #
24724 # instruction value. but since we're exiting to the access error
24725 # handler, then AN must be returned to its pre-instruction value.
24774 # if it's a fmove out instruction, we don't have to fix a7
24776 # instruction (data moved in) and the exception was in supervisor
Indexes created Fri Oct 17 17:09:57 GMT 2025