Parallax Propeller 2 Instructions v27
 Share
The version of the browser you are using is no longer supported. Please upgrade to a supported browser.Dismiss

View only
 
ABCDEFGHIJKLMNOPQRSTUVWXYZAAABACADAE
1
0- Alias -- Group -- Encoding -
#S = immediate (I=1). S = register.
#D = immediate (L=1). D = register.

- Assembly Syntax -
* Z = (result == 0).
** If #S and cogex, PC += signed(S). If #S and hubex, PC += signed(S << 2). If S, PC = register S.

- Description -
* +1 if crosses hub long

- Cogex Cycles -
* +1 if crosses hub long

- Hubex Cycles -
* Data not forwarded.

- Register Write -
- Hub R/W -- Stack R/W -
CF/ZF are local bits
Dv = variable to write

- Spin Methods -
2
1.Miscellaneous0000 0000000 000 000000000 000000000NOPNo operation.2same
3
2.Math and LogicEEEE 0000000 CZI DDDDDDDDD SSSSSSSSSROR D,{#}S {WC/WZ/WCZ}Rotate right. D = [31:0] of ({D[31:0], D[31:0]} >> S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[0]. *2sameDROR_(Dv,S)
4
3.Math and LogicEEEE 0000001 CZI DDDDDDDDD SSSSSSSSSROL D,{#}S {WC/WZ/WCZ}Rotate left. D = [63:32] of ({D[31:0], D[31:0]} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[31]. *2sameDROL_(Dv,S)
5
4.Math and LogicEEEE 0000010 CZI DDDDDDDDD SSSSSSSSSSHR D,{#}S {WC/WZ/WCZ}Shift right. D = [31:0] of ({32'b0, D[31:0]} >> S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[0]. *2sameDSHR_(Dv,S)
6
5.Math and LogicEEEE 0000011 CZI DDDDDDDDD SSSSSSSSSSHL D,{#}S {WC/WZ/WCZ}Shift left. D = [63:32] of ({D[31:0], 32'b0} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[31]. *2sameDSHL_(Dv,S)
7
6.Math and LogicEEEE 0000100 CZI DDDDDDDDD SSSSSSSSSRCR D,{#}S {WC/WZ/WCZ}Rotate carry right. D = [31:0] of ({{32{C}}, D[31:0]} >> S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[0]. *2sameDRCR_(Dv,S)
8
7.Math and LogicEEEE 0000101 CZI DDDDDDDDD SSSSSSSSSRCL D,{#}S {WC/WZ/WCZ}Rotate carry left. D = [63:32] of ({D[31:0], {32{C}}} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[31]. *2sameDRCL_(Dv,S)
9
8.Math and LogicEEEE 0000110 CZI DDDDDDDDD SSSSSSSSSSAR D,{#}S {WC/WZ/WCZ}Shift arithmetic right. D = [31:0] of ({{32{D[31]}}, D[31:0]} >> S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[0]. *2sameDSAR_(Dv,S)
10
9.Math and LogicEEEE 0000111 CZI DDDDDDDDD SSSSSSSSSSAL D,{#}S {WC/WZ/WCZ}Shift arithmetic left. D = [63:32] of ({D[31:0], {32{D[0]}}} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[31]. *2sameDSAL_(Dv,S)
11
10.Math and LogicEEEE 0001000 CZI DDDDDDDDD SSSSSSSSSADD D,{#}S {WC/WZ/WCZ}Add S into D. D = D + S. C = carry of (D + S). *2sameDADD_(Dv,S)
12
11.Math and LogicEEEE 0001001 CZI DDDDDDDDD SSSSSSSSS
ADDX D,{#}S {WC/WZ/WCZ}
Add (S + C) into D, extended. D = D + S + C. C = carry of (D + S + C). Z = Z AND (result == 0).2sameDADDX_(Dv,S)
13
12.Math and LogicEEEE 0001010 CZI DDDDDDDDD SSSSSSSSS
ADDS D,{#}S {WC/WZ/WCZ}
Add S into D, signed. D = D + S. C = correct sign of (D + S). *2sameDADDS_(Dv,S)
14
13.Math and LogicEEEE 0001011 CZI DDDDDDDDD SSSSSSSSS
ADDSX D,{#}S {WC/WZ/WCZ}
Add (S + C) into D, signed and extended. D = D + S + C. C = correct sign of (D + S + C). Z = Z AND (result == 0).2sameDADDSX_(Dv,S)
15
14.Math and LogicEEEE 0001100 CZI DDDDDDDDD SSSSSSSSSSUB D,{#}S {WC/WZ/WCZ}Subtract S from D. D = D - S. C = borrow of (D - S). *2sameDSUB_(Dv,S)
16
15.Math and LogicEEEE 0001101 CZI DDDDDDDDD SSSSSSSSS
SUBX D,{#}S {WC/WZ/WCZ}
Subtract (S + C) from D, extended. D = D - (S + C). C = borrow of (D - (S + C)). Z = Z AND (result == 0).2sameDSUBX_(Dv,S)
17
16.Math and LogicEEEE 0001110 CZI DDDDDDDDD SSSSSSSSS
SUBS D,{#}S {WC/WZ/WCZ}
Subtract S from D, signed. D = D - S. C = correct sign of (D - S). *2sameDSUBS_(Dv,S)
18
17.Math and LogicEEEE 0001111 CZI DDDDDDDDD SSSSSSSSS
SUBSX D,{#}S {WC/WZ/WCZ}
Subtract (S + C) from D, signed and extended. D = D - (S + C). C = correct sign of (D - (S + C)). Z = Z AND (result == 0).2sameDSUBSX_(Dv,S)
19
18.Math and LogicEEEE 0010000 CZI DDDDDDDDD SSSSSSSSS
CMP D,{#}S {WC/WZ/WCZ}
Compare D to S. C = borrow of (D - S). Z = (D == S).2sameDCMP_(D,S)
20
19.Math and LogicEEEE 0010001 CZI DDDDDDDDD SSSSSSSSS
CMPX D,{#}S {WC/WZ/WCZ}
Compare D to (S + C), extended. C = borrow of (D - (S + C)). Z = Z AND (D == S + C).2sameCMPX_(D,S)
21
20.Math and LogicEEEE 0010010 CZI DDDDDDDDD SSSSSSSSS
CMPS D,{#}S {WC/WZ/WCZ}
Compare D to S, signed. C = correct sign of (D - S). Z = (D == S).2sameCMPS_(D,S)
22
21.Math and LogicEEEE 0010011 CZI DDDDDDDDD SSSSSSSSS
CMPSX D,{#}S {WC/WZ/WCZ}
Compare D to (S + C), signed and extended. C = correct sign of (D - (S + C)). Z = Z AND (D == S + C).2sameCMPSX_(D,S)
23
22.Math and LogicEEEE 0010100 CZI DDDDDDDDD SSSSSSSSS
CMPR D,{#}S {WC/WZ/WCZ}
Compare S to D (reverse). C = borrow of (S - D). Z = (D == S).2sameCMPR_(D,S)
24
23.Math and LogicEEEE 0010101 CZI DDDDDDDDD SSSSSSSSS
CMPM D,{#}S {WC/WZ/WCZ}
Compare D to S, get MSB of difference. C = MSB of (D - S). Z = (D == S).2sameCMPM_(D,S)
25
24.Math and LogicEEEE 0010110 CZI DDDDDDDDD SSSSSSSSS
SUBR D,{#}S {WC/WZ/WCZ}
Subtract D from S (reverse). D = S - D. C = borrow of (S - D). *2sameDSUBR_(Dv,S)
26
25.Math and LogicEEEE 0010111 CZI DDDDDDDDD SSSSSSSSS
CMPSUB D,{#}S {WC/WZ/WCZ}
Compare and subtract S from D if D >= S. If D => S then D = D - S and C = 1, else D same and C = 0. *2sameDCMPSUB_(Dv,S)
27
26.Math and LogicEEEE 0011000 CZI DDDDDDDDD SSSSSSSSSFGE D,{#}S {WC/WZ/WCZ}Force D >= S. If D < S then D = S and C = 1, else D same and C = 0. *2sameDFGE_(Dv,S)
28
27.Math and LogicEEEE 0011001 CZI DDDDDDDDD SSSSSSSSSFLE D,{#}S {WC/WZ/WCZ}Force D <= S. If D > S then D = S and C = 1, else D same and C = 0. *2sameDFLE_(Dv,S)
29
28.Math and LogicEEEE 0011010 CZI DDDDDDDDD SSSSSSSSS
FGES D,{#}S {WC/WZ/WCZ}
Force D >= S, signed. If D < S then D = S and C = 1, else D same and C = 0. *2sameDFGES_(Dv,S)
30
29.Math and LogicEEEE 0011011 CZI DDDDDDDDD SSSSSSSSSFLES D,{#}S {WC/WZ/WCZ}Force D <= S, signed. If D > S then D = S and C = 1, else D same and C = 0. *2sameDFLES_(Dv,S)
31
30.Math and LogicEEEE 0011100 CZI DDDDDDDDD SSSSSSSSS
SUMC D,{#}S {WC/WZ/WCZ}
Sum +/-S into D by C. If C = 1 then D = D - S, else D = D + S. C = 1 if signed overflow. *2sameDSUMC_(Dv,S)
32
31.Math and LogicEEEE 0011101 CZI DDDDDDDDD SSSSSSSSS
SUMNC D,{#}S {WC/WZ/WCZ}
Sum +/-S into D by !C. If C = 0 then D = D - S, else D = D + S. C = 1 if signed overflow. *2sameDSUMNC_(Dv,S)
33
32.Math and LogicEEEE 0011110 CZI DDDDDDDDD SSSSSSSSS
SUMZ D,{#}S {WC/WZ/WCZ}
Sum +/-S into D by Z. If Z = 1 then D = D - S, else D = D + S. C = 1 if signed overflow. *2sameDSUMZ_(Dv,S)
34
33.Math and LogicEEEE 0011111 CZI DDDDDDDDD SSSSSSSSS
SUMNZ D,{#}S {WC/WZ/WCZ}
Sum +/-S into D by !Z. If Z = 0 then D = D - S, else D = D + S. C = 1 if signed overflow. *2sameDSUMNZ_(Dv,S)
35
34.Math and LogicEEEE 0100000 CZI DDDDDDDDD SSSSSSSSSTESTB D,{#}S WC/WZTest bit S[4:0] of D, write to C/Z. C/Z = D[S[4:0]].2sameTESTB_(D,S,WC/WZ)
36
35.Math and LogicEEEE 0100001 CZI DDDDDDDDD SSSSSSSSSTESTBN D,{#}S WC/WZTest bit S[4:0] of !D, write to C/Z. C/Z = !D[S[4:0]].2sameTESTBN_(D,S,WC/WZ)
37
36.Math and LogicEEEE 0100010 CZI DDDDDDDDD SSSSSSSSSTESTB D,{#}S ANDC/ANDZTest bit S[4:0] of D, AND into C/Z. C/Z = C/Z AND D[S[4:0]].2sameTESTB_(D,S,ANDC/ANDZ)
38
37.Math and LogicEEEE 0100011 CZI DDDDDDDDD SSSSSSSSSTESTBN D,{#}S ANDC/ANDZTest bit S[4:0] of !D, AND into C/Z. C/Z = C/Z AND !D[S[4:0]].2sameTESTBN_(D,S,ANDC/ANDZ)
39
38.Math and LogicEEEE 0100100 CZI DDDDDDDDD SSSSSSSSSTESTB D,{#}S ORC/ORZTest bit S[4:0] of D, OR into C/Z. C/Z = C/Z OR D[S[4:0]].2sameTESTB_(D,S,ORC/ORZ)
40
39.Math and LogicEEEE 0100101 CZI DDDDDDDDD SSSSSSSSSTESTBN D,{#}S ORC/ORZTest bit S[4:0] of !D, OR into C/Z. C/Z = C/Z OR !D[S[4:0]].2sameTESTBN_(D,S,ORC/ORZ)
41
40.Math and LogicEEEE 0100110 CZI DDDDDDDDD SSSSSSSSSTESTB D,{#}S XORC/XORZTest bit S[4:0] of D, XOR into C/Z. C/Z = C/Z XOR D[S[4:0]].2sameTESTB_(D,S,XORC/XORZ)
42
41.Math and LogicEEEE 0100111 CZI DDDDDDDDD SSSSSSSSSTESTBN D,{#}S XORC/XORZTest bit S[4:0] of !D, XOR into C/Z. C/Z = C/Z XOR !D[S[4:0]].2sameTESTBN_(D,S,XORC/XORZ)
43
42.Math and LogicEEEE 0100000 CZI DDDDDDDDD SSSSSSSSSBITL D,{#}S {WCZ}Bit S[4:0] of D = 0, C,Z = D[S[4:0]].2sameDBITL_(Dv,S)
44
43.Math and LogicEEEE 0100001 CZI DDDDDDDDD SSSSSSSSSBITH D,{#}S {WCZ}Bit S[4:0] of D = 1, C,Z = D[S[4:0]].2sameDBITH_(Dv,S)
45
44.Math and LogicEEEE 0100010 CZI DDDDDDDDD SSSSSSSSSBITC D,{#}S {WCZ}Bit S[4:0] of D = C, C,Z = D[S[4:0]].2sameDBITC_(Dv,S)
46
45.Math and LogicEEEE 0100011 CZI DDDDDDDDD SSSSSSSSSBITNC D,{#}S {WCZ}Bit S[4:0] of D = !C, C,Z = D[S[4:0]].2sameDBITNC_(Dv,S)
47
46.Math and LogicEEEE 0100100 CZI DDDDDDDDD SSSSSSSSSBITZ D,{#}S {WCZ}Bit S[4:0] of D = Z, C,Z = D[S[4:0]].2sameDBITZ_(Dv,S)
48
47.Math and LogicEEEE 0100101 CZI DDDDDDDDD SSSSSSSSSBITNZ D,{#}S {WCZ}Bit S[4:0] of D = !Z, C,Z = D[S[4:0]].2sameDBITNZ_(Dv,S)
49
48.Math and LogicEEEE 0100110 CZI DDDDDDDDD SSSSSSSSSBITRND D,{#}S {WCZ}Bit S[4:0] of D = RND, C,Z = D[S[4:0]].2sameDBITRND_(Dv,S)
50
49.Math and LogicEEEE 0100111 CZI DDDDDDDDD SSSSSSSSSBITNOT D,{#}S {WCZ}Bit S[4:0] of D = !bit, C,Z = D[S[4:0]].2sameDBITNOT_(Dv,S)
51
50.Math and LogicEEEE 0101000 CZI DDDDDDDDD SSSSSSSSS
ANDN D,{#}S {WC/WZ/WCZ}
AND !S into D. D = D & !S. C = parity of result. *2sameDANDN_(Dv,S)
52
51.Math and LogicEEEE 0101001 CZI DDDDDDDDD SSSSSSSSSAND D,{#}S {WC/WZ/WCZ}AND S into D. D = D & S. C = parity of result. *2sameDAND_(Dv,S)
53
52.Math and LogicEEEE 0101010 CZI DDDDDDDDD SSSSSSSSSOR D,{#}S {WC/WZ/WCZ}OR S into D. D = D | S. C = parity of result. *2sameDOR_(Dv,S)
54
53.Math and LogicEEEE 0101011 CZI DDDDDDDDD SSSSSSSSSXOR D,{#}S {WC/WZ/WCZ}XOR S into D. D = D ^ S. C = parity of result. *2sameDXOR_(Dv,S)
55
54.Math and LogicEEEE 0101100 CZI DDDDDDDDD SSSSSSSSS
MUXC D,{#}S {WC/WZ/WCZ}
Mux C into each D bit that is '1' in S. D = (!S & D ) | (S & {32{ C}}). C = parity of result. *2sameDMUXC_(Dv,S)
56
55.Math and LogicEEEE 0101101 CZI DDDDDDDDD SSSSSSSSS
MUXNC D,{#}S {WC/WZ/WCZ}
Mux !C into each D bit that is '1' in S. D = (!S & D ) | (S & {32{!C}}). C = parity of result. *2sameDMUXNC_(Dv,S)
57
56.Math and LogicEEEE 0101110 CZI DDDDDDDDD SSSSSSSSS
MUXZ D,{#}S {WC/WZ/WCZ}
Mux Z into each D bit that is '1' in S. D = (!S & D ) | (S & {32{ Z}}). C = parity of result. *2sameDMUXZ_(Dv,S)
58
57.Math and LogicEEEE 0101111 CZI DDDDDDDDD SSSSSSSSS
MUXNZ D,{#}S {WC/WZ/WCZ}
Mux !Z into each D bit that is '1' in S. D = (!S & D ) | (S & {32{!Z}}). C = parity of result. *2sameDMUXNZ_(Dv,S)
59
58.Math and LogicEEEE 0110000 CZI DDDDDDDDD SSSSSSSSS
MOV D,{#}S {WC/WZ/WCZ}
Move S into D. D = S. C = S[31]. *2sameDMOV_(Dv,S)
60
59.Math and LogicEEEE 0110001 CZI DDDDDDDDD SSSSSSSSSNOT D,{#}S {WC/WZ/WCZ}Get !S into D. D = !S. C = !S[31]. *2sameDNOT_(Dv,S)
61
60aliasMath and Logic
EEEE 0110001 CZ0 DDDDDDDDD DDDDDDDDD
NOT D {WC/WZ/WCZ}Get !D into D. D = !D. C = !D[31]. *2sameDNOT_(Dv)
62
61.Math and LogicEEEE 0110010 CZI DDDDDDDDD SSSSSSSSSABS D,{#}S {WC/WZ/WCZ}Get absolute value of S into D. D = ||S. C = S[31]. *2sameDABS_(Dv,S)
63
62aliasMath and Logic
EEEE 0110010 CZ0 DDDDDDDDD DDDDDDDDD
ABS D {WC/WZ/WCZ}Get absolute value of D into D. D = ||D. C = D[31]. *2sameDABS_(Dv)
64
63.Math and LogicEEEE 0110011 CZI DDDDDDDDD SSSSSSSSSNEG D,{#}S {WC/WZ/WCZ}Negate S into D. D = -S. C = MSB of result. *2sameDNEG_(Dv,S)
65
64aliasMath and Logic
EEEE 0110011 CZ0 DDDDDDDDD DDDDDDDDD
NEG D {WC/WZ/WCZ}Negate D. D = -D. C = MSB of result. *2sameDNEG_(Dv)
66
65.Math and LogicEEEE 0110100 CZI DDDDDDDDD SSSSSSSSS
NEGC D,{#}S {WC/WZ/WCZ}
Negate S by C into D. If C = 1 then D = -S, else D = S. C = MSB of result. *2sameDNEGC_(Dv,S)
67
66aliasMath and Logic
EEEE 0110100 CZ0 DDDDDDDDD DDDDDDDDD
NEGC D {WC/WZ/WCZ}Negate D by C. If C = 1 then D = -D, else D = D. C = MSB of result. *2sameDNEGC_(Dv)
68
67.Math and LogicEEEE 0110101 CZI DDDDDDDDD SSSSSSSSS
NEGNC D,{#}S {WC/WZ/WCZ}
Negate S by !C into D. If C = 0 then D = -S, else D = S. C = MSB of result. *2sameDNEGNC_(Dv,S)
69
68aliasMath and Logic
EEEE 0110101 CZ0 DDDDDDDDD DDDDDDDDD
NEGNC D {WC/WZ/WCZ}Negate D by !C. If C = 0 then D = -D, else D = D. C = MSB of result. *2sameDNEGNC_(Dv)
70
69.Math and LogicEEEE 0110110 CZI DDDDDDDDD SSSSSSSSS
NEGZ D,{#}S {WC/WZ/WCZ}
Negate S by Z into D. If Z = 1 then D = -S, else D = S. C = MSB of result. *2sameDNEGZ_(Dv,S)
71
70aliasMath and Logic
EEEE 0110110 CZ0 DDDDDDDDD DDDDDDDDD
NEGZ D {WC/WZ/WCZ}Negate D by Z. If Z = 1 then D = -D, else D = D. C = MSB of result. *2sameDNEGZ_(Dv)
72
71.Math and LogicEEEE 0110111 CZI DDDDDDDDD SSSSSSSSS
NEGNZ D,{#}S {WC/WZ/WCZ}
Negate S by !Z into D. If Z = 0 then D = -S, else D = S. C = MSB of result. *2sameDNEGNZ_(Dv,S)
73
72aliasMath and Logic
EEEE 0110111 CZ0 DDDDDDDDD DDDDDDDDD
NEGNZ D {WC/WZ/WCZ}Negate D by !Z. If Z = 0 then D = -D, else D = D. C = MSB of result. *2sameDNEGNZ_(Dv)
74
73.Math and LogicEEEE 0111000 CZI DDDDDDDDD SSSSSSSSS
INCMOD D,{#}S {WC/WZ/WCZ}
Increment with modulus. If D = S then D = 0 and C = 1, else D = D + 1 and C = 0. *2sameDINCMOD_(Dv,S)
75
74.Math and LogicEEEE 0111001 CZI DDDDDDDDD SSSSSSSSS
DECMOD D,{#}S {WC/WZ/WCZ}
Decrement with modulus. If D = 0 then D = S and C = 1, else D = D - 1 and C = 0. *2sameDDECMOD_(Dv,S)
76
75.Math and LogicEEEE 0111010 CZI DDDDDDDDD SSSSSSSSS
ENCOD D,{#}S {WC/WZ/WCZ}
Get bit position of top-most '1' in S into D. D = {27'b0, 5'position}. C = (S == 0). *2sameDENCOD_(Dv,S)
77
76aliasMath and Logic
EEEE 0111010 CZ0 DDDDDDDDD DDDDDDDDD
ENCOD D {WC/WZ/WCZ}Get bit position of top-most '1' in D into D. D = {27'b0, 5'position}. C = (S == 0). *2sameDENCOD_(Dv)
78
77.MiscellaneousEEEE 0111011 CZI DDDDDDDDD SSSSSSSSS
<empty> D,{#}S {WC/WZ/WCZ}
<empty>
79
78.Math and LogicEEEE 0111100 CZI DDDDDDDDD SSSSSSSSS
TESTN D,{#}S {WC/WZ/WCZ}
Test D with !S. C = parity of (D & !S). Z = ((D & !S) == 0).2sameTESTN_(D,S)
80
79.Math and LogicEEEE 0111101 CZI DDDDDDDDD SSSSSSSSSTEST D,{#}S {WC/WZ/WCZ}Test D with S. C = parity of (D & S). Z = ((D & S) == 0).2sameTEST_(D,S)
81
80aliasMath and Logic
EEEE 0111101 CZ0 DDDDDDDDD DDDDDDDDD
TEST D {WC/WZ/WCZ}Test D. C = parity of D. Z = (D == 0).2sameTEST_(D)
82
81.Math and LogicEEEE 0111110 CZI DDDDDDDDD SSSSSSSSS
ANYB D,{#}S {WC/WZ/WCZ}
Check if any bits set in either D or S. C = parity of (D | S). Z = ((D | S) == 0).2sameANYB_(D,S)
83
82.MiscellaneousEEEE 0111111 CZI DDDDDDDDD SSSSSSSSS
<empty> D,{#}S {WC/WZ/WCZ}
<empty>
84
83.Math and Logic
EEEE 100000N NNI DDDDDDDDD SSSSSSSSS
SETNIB D,{#}S,#NSet S[3:0] into nibble N in D, keeping rest of D same.2sameDSETNIB_(Dv,S,N)
85
84aliasMath and LogicEEEE 1000000 00I 000000000 SSSSSSSSSSETNIB {#}SSet S[3:0] into nibble established by prior ALTSN instruction.2sameD
86
85.Math and Logic
EEEE 100001N NNI DDDDDDDDD SSSSSSSSS
GETNIB D,{#}S,#NGet nibble N of S into D. D = {28'b0, S.NIBBLE[N]).2sameDGETNIB_(Dv,S,N)
87
86aliasMath and Logic
EEEE 1000010 000 DDDDDDDDD 000000000
GETNIB DGet nibble established by prior ALTGN instruction into D.2sameD
88
87.Math and Logic
EEEE 100010N NNI DDDDDDDDD SSSSSSSSS
ROLNIB D,{#}S,#NRotate-left nibble N of S into D. D = {D[27:0], S.NIBBLE[N]).2sameDROLNIB_(Dv,S,N)
89
88aliasMath and Logic
EEEE 1000100 000 DDDDDDDDD 000000000
ROLNIB DRotate-left nibble established by prior ALTGN instruction into D.2sameD
90
89.Math and Logic
EEEE 1000110 NNI DDDDDDDDD SSSSSSSSS
SETBYTE D,{#}S,#NSet S[7:0] into byte N in D, keeping rest of D same.2sameDSETBYTE_(Dv,S,N)
91
90aliasMath and LogicEEEE 1000110 00I 000000000 SSSSSSSSSSETBYTE {#}SSet S[7:0] into byte established by prior ALTSB instruction.2sameD
92
91.Math and Logic
EEEE 1000111 NNI DDDDDDDDD SSSSSSSSS
GETBYTE D,{#}S,#NGet byte N of S into D. D = {24'b0, S.BYTE[N]).2sameDGETBYTE_(Dv,S,N)
93
92aliasMath and Logic
EEEE 1000111 000 DDDDDDDDD 000000000
GETBYTE DGet byte established by prior ALTGB instruction into D.2sameD
94
93.Math and Logic
EEEE 1001000 NNI DDDDDDDDD SSSSSSSSS
ROLBYTE D,{#}S,#NRotate-left byte N of S into D. D = {D[23:0], S.BYTE[N]).2sameDROLBYTE_(Dv,S,N)
95
94aliasMath and Logic
EEEE 1001000 000 DDDDDDDDD 000000000
ROLBYTE DRotate-left byte established by prior ALTGB instruction into D.2sameD
96
95.Math and LogicEEEE 1001001 0NI DDDDDDDDD SSSSSSSSSSETWORD D,{#}S,#NSet S[15:0] into word N in D, keeping rest of D same.2sameDSETWORD_(Dv,S,N)
97
96aliasMath and LogicEEEE 1001001 00I 000000000 SSSSSSSSSSETWORD {#}SSet S[15:0] into word established by prior ALTSW instruction.2sameD
98
97.Math and LogicEEEE 1001001 1NI DDDDDDDDD SSSSSSSSSGETWORD D,{#}S,#NGet word N of S into D. D = {16'b0, S.WORD[N]).2sameDGETWORD_(Dv,S,N)
99
98aliasMath and Logic
EEEE 1001001 100 DDDDDDDDD 000000000
GETWORD DGet word established by prior ALTGW instruction into D.2sameD
100
99.Math and LogicEEEE 1001010 0NI DDDDDDDDD SSSSSSSSSROLWORD D,{#}S,#NRotate-left word N of S into D. D = {D[15:0], S.WORD[N]).2sameDROLWORD_(Dv,S,N)
Loading...