| 2 |
7u83 |
1 |
/*
|
|
|
2 |
Copyright (c) 1993 Open Software Foundation, Inc.
|
|
|
3 |
|
|
|
4 |
|
|
|
5 |
All Rights Reserved
|
|
|
6 |
|
|
|
7 |
|
|
|
8 |
Permission to use, copy, modify, and distribute this software
|
|
|
9 |
and its documentation for any purpose and without fee is hereby
|
|
|
10 |
granted, provided that the above copyright notice appears in all
|
|
|
11 |
copies and that both the copyright notice and this permission
|
|
|
12 |
notice appear in supporting documentation.
|
|
|
13 |
|
|
|
14 |
|
|
|
15 |
OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING
|
|
|
16 |
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
|
|
|
17 |
PARTICULAR PURPOSE.
|
|
|
18 |
|
|
|
19 |
|
|
|
20 |
IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
|
|
|
21 |
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
|
22 |
LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
|
|
|
23 |
NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
|
|
24 |
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
25 |
*/
|
|
|
26 |
|
|
|
27 |
/*
|
|
|
28 |
Crown Copyright (c) 1997
|
|
|
29 |
|
|
|
30 |
This TenDRA(r) Computer Program is subject to Copyright
|
|
|
31 |
owned by the United Kingdom Secretary of State for Defence
|
|
|
32 |
acting through the Defence Evaluation and Research Agency
|
|
|
33 |
(DERA). It is made available to Recipients with a
|
|
|
34 |
royalty-free licence for its use, reproduction, transfer
|
|
|
35 |
to other parties and amendment for any purpose not excluding
|
|
|
36 |
product development provided that any such use et cetera
|
|
|
37 |
shall be deemed to be acceptance of the following conditions:-
|
|
|
38 |
|
|
|
39 |
(1) Its Recipients shall ensure that this Notice is
|
|
|
40 |
reproduced upon any copies or amended versions of it;
|
|
|
41 |
|
|
|
42 |
(2) Any amended version of it shall be clearly marked to
|
|
|
43 |
show both the nature of and the organisation responsible
|
|
|
44 |
for the relevant amendment or amendments;
|
|
|
45 |
|
|
|
46 |
(3) Its onward transfer from a recipient to another
|
|
|
47 |
party shall be deemed to be that party's acceptance of
|
|
|
48 |
these conditions;
|
|
|
49 |
|
|
|
50 |
(4) DERA gives no warranty or assurance as to its
|
|
|
51 |
quality or suitability for any purpose and DERA accepts
|
|
|
52 |
no liability whatsoever in relation to any use to which
|
|
|
53 |
it may be put.
|
|
|
54 |
*/
|
|
|
55 |
|
|
|
56 |
|
|
|
57 |
|
|
|
58 |
/**********************************************************************
|
|
|
59 |
$Author: release $
|
|
|
60 |
$Date: 1998/02/04 15:48:51 $
|
|
|
61 |
$Revision: 1.2 $
|
|
|
62 |
$Log: instruct.h,v $
|
|
|
63 |
* Revision 1.2 1998/02/04 15:48:51 release
|
|
|
64 |
* Added OSF copyright message.
|
|
|
65 |
*
|
|
|
66 |
* Revision 1.1.1.1 1998/01/17 15:55:56 release
|
|
|
67 |
* First version to be checked into rolling release.
|
|
|
68 |
*
|
|
|
69 |
* Revision 1.2 1996/10/04 16:01:35 pwe
|
|
|
70 |
* add banners and mod for PWE ownership
|
|
|
71 |
*
|
|
|
72 |
**********************************************************************/
|
|
|
73 |
|
|
|
74 |
|
|
|
75 |
#ifndef INSTRUCTDECS_H
|
|
|
76 |
#define INSTRUCTDECS_H
|
|
|
77 |
|
|
|
78 |
#define CRF0 0
|
|
|
79 |
#define CRF1 1
|
|
|
80 |
#define CRF2 2
|
|
|
81 |
#define CRF3 3
|
|
|
82 |
#define CRF4 4
|
|
|
83 |
#define CRF5 5
|
|
|
84 |
#define CRF6 6
|
|
|
85 |
#define CRF7 7
|
|
|
86 |
|
|
|
87 |
/* is constant small enough for signed immediate operand */
|
|
|
88 |
#define IMM_SIZE(i) ((long)(i) >= - 0x8000 && ((long)(i) <= 0x7fff))
|
|
|
89 |
|
|
|
90 |
/* is constant small enough for logical immediate lower operand */
|
|
|
91 |
#define IMMLOGL_SIZE(i) (((unsigned long)(i) >> 16) == 0)
|
|
|
92 |
|
|
|
93 |
/* is constant small enough for logical immediate upper operand */
|
|
|
94 |
#define IMMLOGU_SIZE(i) (((unsigned long)(i) << 16) == 0)
|
|
|
95 |
|
|
|
96 |
/* STRUCTURE FOR INSTRUCTIONS */
|
|
|
97 |
typedef struct Instruction
|
|
|
98 |
{
|
|
|
99 |
char *com;
|
|
|
100 |
char *ppc;
|
|
|
101 |
char *pwr;
|
|
|
102 |
} Instruction_T;
|
|
|
103 |
|
|
|
104 |
typedef Instruction_T * Instruction_P;
|
|
|
105 |
|
|
|
106 |
#define SPR_MQ 0
|
|
|
107 |
#define SPR_XER 1
|
|
|
108 |
#define SPR_RTCU 4
|
|
|
109 |
#define SPR_RTCL 5
|
|
|
110 |
#define SPR_DEC 6
|
|
|
111 |
#define SPR_LR 8
|
|
|
112 |
#define SPR_CTR 9
|
|
|
113 |
|
|
|
114 |
#define OV_BIT_MASK 0x40000000
|
|
|
115 |
#define CA_BIT_MASK 0x20000000
|
|
|
116 |
#define SO_BIT_MASK 0x80000000
|
|
|
117 |
|
|
|
118 |
/*
|
|
|
119 |
* INS_DEFINE only set in instruct.c before including this header.
|
|
|
120 |
* This causes definition and initialisation rather than external declaration.
|
|
|
121 |
*/
|
|
|
122 |
#if FS_STDC_HASH
|
|
|
123 |
#ifdef INS_DEFINE
|
|
|
124 |
/* define */
|
|
|
125 |
#define INS(inst,com,ppc,pwr) Instruction_T INSTRUCTION_##inst = {com,ppc,pwr};\
|
|
|
126 |
Instruction_P inst = &INSTRUCTION_##inst
|
|
|
127 |
#else
|
|
|
128 |
/* external declaration */
|
|
|
129 |
#define INS(inst,com,ppc,pwr) extern Instruction_P inst;\
|
|
|
130 |
extern Instruction_T INSTRUCTION_##inst
|
|
|
131 |
#endif
|
|
|
132 |
#else
|
|
|
133 |
#ifdef INS_DEFINE
|
|
|
134 |
/* define */
|
|
|
135 |
#define INS(inst,com,ppc,pwr) Instruction_T INSTRUCTION_/* paste */inst = {com,ppc,pwr};\
|
|
|
136 |
Instruction_P inst = &INSTRUCTION_/* paste */inst
|
|
|
137 |
#else
|
|
|
138 |
/* external declaration */
|
|
|
139 |
#define INS(inst,com,ppc,pwr) extern Instruction_P inst;\
|
|
|
140 |
extern Instruction_T INSTRUCTION_/* paste */inst
|
|
|
141 |
#endif
|
|
|
142 |
#endif
|
|
|
143 |
|
|
|
144 |
#if 1
|
|
|
145 |
/* some pseudo instruction, mapped onto POWER instructions in inst_format.c */
|
|
|
146 |
INS(i_s ,"s" ,"s" ,"s");
|
|
|
147 |
/* pseudo instruction: subtract, mapped
|
|
|
148 |
onto sf with regs reversed */
|
|
|
149 |
INS(i_not ,"not" ,"not" ,"not");
|
|
|
150 |
/* pseudo instruction: monadic not reg to reg
|
|
|
151 |
expanded to sfi dest,-1,src */
|
|
|
152 |
#endif
|
|
|
153 |
|
|
|
154 |
|
|
|
155 |
/*
|
|
|
156 |
* Instructions PowerPC 601 User's manual Appendix B says
|
|
|
157 |
* is in POWER but not PowerPC. We avoid them for future advantage.
|
|
|
158 |
* Obviously we do not yet use any of the new PowerPC instructions.
|
|
|
159 |
*/
|
|
|
160 |
/* All definitions are of common,ppc,pwr */
|
|
|
161 |
/*
|
|
|
162 |
* Name Common Powerpc POWER
|
|
|
163 |
*/
|
|
|
164 |
|
|
|
165 |
INS(I_NIL ,"VOID" ,"VOID" ,"VOID");
|
|
|
166 |
|
|
|
167 |
|
|
|
168 |
/*
|
|
|
169 |
* Non PowerPC instruction we must use as we cannot use the replacement
|
|
|
170 |
* instructions yet.
|
|
|
171 |
*/
|
|
|
172 |
INS(i_mfmq ,"mfmq" ,"mfmq" ,"mfmq");
|
|
|
173 |
INS(i_mtmq ,"mtmq" ,"mtmq" ,"mtmq");
|
|
|
174 |
|
|
|
175 |
|
|
|
176 |
|
|
|
177 |
#if PowerPC_PRIVILEGED
|
|
|
178 |
/* we dont use privileged instructions */
|
|
|
179 |
INS(i_mfmsr ,"mfmsr" ,"mfmsr" ,"mfmsr");
|
|
|
180 |
INS(i_mfsr ,"mfsr" ,"mfsr" ,"mfsr");
|
|
|
181 |
#endif
|
|
|
182 |
/* Table B-3 */
|
|
|
183 |
/* POWER instructions dropped for PowerPC architecture*/
|
|
|
184 |
INS(i_abs ,"VOID" ,"VOID" ,"abs");
|
|
|
185 |
INS(i_abs_cr ,"VOID" ,"VOID" ,"abs.");
|
|
|
186 |
INS(i_abso ,"VOID" ,"VOID" ,"abso");
|
|
|
187 |
INS(i_abso_cr ,"VOID" ,"VOID" ,"abso.");
|
|
|
188 |
INS(i_clcs ,"VOID" ,"VOID" ,"clcs");
|
|
|
189 |
INS(i_clf ,"VOID" ,"VOID" ,"clf");
|
|
|
190 |
INS(i_cli ,"VOID" ,"VOID" ,"cli");
|
|
|
191 |
INS(i_dclst ,"VOID" ,"VOID" ,"dclst");
|
|
|
192 |
INS(i_div ,"div" ,"VOID" ,"div");/* Seem to work for common */
|
|
|
193 |
INS(i_div_cr ,"VOID" ,"VOID" ,"div.");
|
|
|
194 |
INS(i_divo ,"VOID" ,"VOID" ,"divo");
|
|
|
195 |
INS(i_divo_cr ,"VOID" ,"VOID" ,"divo.");
|
|
|
196 |
INS(i_divs ,"divs" ,"VOID" ,"divs"); /* Seem to work for common*/
|
|
|
197 |
INS(i_divs_cr ,"VOID" ,"VOID" ,"divs.");
|
|
|
198 |
INS(i_divso ,"VOID" ,"VOID" ,"divso");
|
|
|
199 |
INS(i_divso_cr ,"VOID" ,"VOID" ,"divso.");
|
|
|
200 |
INS(i_doz ,"VOID" ,"VOID" ,"doz");
|
|
|
201 |
INS(i_doz_cr ,"VOID" ,"VOID" ,"doz.");
|
|
|
202 |
INS(i_dozi ,"VOID" ,"VOID" ,"dozi");
|
|
|
203 |
INS(i_dozo ,"VOID" ,"VOID" ,"dozo");
|
|
|
204 |
INS(i_dozo_cr ,"VOID" ,"VOID" ,"dozo.");
|
|
|
205 |
INS(i_lscbx ,"VOID" ,"VOID" ,"lscbx");
|
|
|
206 |
INS(i_lscbx_cr ,"VOID" ,"VOID" ,"lscbx.");
|
|
|
207 |
INS(i_maskg ,"VOID" ,"VOID" ,"maskg");
|
|
|
208 |
INS(i_maskg_cr ,"VOID" ,"VOID" ,"maskg.");
|
|
|
209 |
INS(i_maskir ,"VOID" ,"VOID" ,"maskir");
|
|
|
210 |
INS(i_maskir_cr ,"VOID" ,"VOID" ,"maskir.");
|
|
|
211 |
INS(i_mfsri ,"VOID" ,"VOID" ,"mfsri");
|
|
|
212 |
INS(i_mul ,"mul" ,"mulhw" ,"mul");/* mul appears to work */
|
|
|
213 |
INS(i_mul_cr ,"VOID" ,"VOID" ,"mul.");
|
|
|
214 |
INS(i_mulo ,"VOID" ,"VOID" ,"mulo");
|
|
|
215 |
INS(i_mulo_cr ,"VOID" ,"VOID" ,"mulo.");
|
|
|
216 |
INS(i_nabs ,"VOID" ,"VOID" ,"nabs");
|
|
|
217 |
INS(i_nabs_cr ,"VOID" ,"VOID" ,"nabs.");
|
|
|
218 |
INS(i_nabso ,"VOID" ,"VOID" ,"nabso");
|
|
|
219 |
INS(i_nabso_cr ,"VOID" ,"VOID" ,"nabso.");
|
|
|
220 |
INS(i_rac ,"VOID" ,"VOID" ,"rac");
|
|
|
221 |
INS(i_rac_cr ,"VOID" ,"VOID" ,"rac.");
|
|
|
222 |
INS(i_rlmi ,"VOID" ,"VOID" ,"rlmi");
|
|
|
223 |
INS(i_rlmi_cr ,"VOID" ,"VOID" ,"rlmi.");
|
|
|
224 |
INS(i_rrib ,"VOID" ,"VOID" ,"rrib");
|
|
|
225 |
INS(i_rrib_cr ,"VOID" ,"VOID" ,"rrib.");
|
|
|
226 |
INS(i_sle ,"VOID" ,"VOID" ,"sle");
|
|
|
227 |
INS(i_sle_cr ,"VOID" ,"VOID" ,"sle.");
|
|
|
228 |
INS(i_sleq ,"VOID" ,"VOID" ,"sleq");
|
|
|
229 |
INS(i_sleq_cr ,"VOID" ,"VOID" ,"sleq.");
|
|
|
230 |
INS(i_sliq ,"VOID" ,"VOID" ,"sliq");
|
|
|
231 |
INS(i_sliq_cr ,"VOID" ,"VOID" ,"sliq.");
|
|
|
232 |
INS(i_slliq ,"VOID" ,"VOID" ,"slliq");
|
|
|
233 |
INS(i_slliq_c ,"VOID" ,"VOID" ,"slliq.");
|
|
|
234 |
INS(i_sllq ,"VOID" ,"VOID" ,"sllq");
|
|
|
235 |
INS(i_sllq_cr ,"VOID" ,"VOID" ,"sllq.");
|
|
|
236 |
INS(i_slq ,"VOID" ,"VOID" ,"slq");
|
|
|
237 |
INS(i_slq_cr ,"VOID" ,"VOID" ,"slq.");
|
|
|
238 |
INS(i_sraiq ,"VOID" ,"VOID" ,"sraiq");
|
|
|
239 |
INS(i_sraiq_cr ,"VOID" ,"VOID" ,"sraiq.");
|
|
|
240 |
INS(i_sraq ,"VOID" ,"VOID" ,"sraq");
|
|
|
241 |
INS(i_sraq_cr ,"VOID" ,"VOID" ,"sraq.");
|
|
|
242 |
INS(i_sre ,"VOID" ,"VOID" ,"sre");
|
|
|
243 |
INS(i_sre_cr ,"VOID" ,"VOID" ,"sre.");
|
|
|
244 |
INS(i_srea ,"VOID" ,"VOID" ,"srea");
|
|
|
245 |
INS(i_srea_cr ,"VOID" ,"VOID" ,"srea.");
|
|
|
246 |
INS(i_sreq ,"VOID" ,"VOID" ,"sreq");
|
|
|
247 |
INS(i_sreq_cr ,"VOID" ,"VOID" ,"sreq.");
|
|
|
248 |
INS(i_sriq ,"VOID" ,"VOID" ,"sriq");
|
|
|
249 |
INS(i_sriq_cr ,"VOID" ,"VOID" ,"sriq.");
|
|
|
250 |
INS(i_srliq ,"VOID" ,"VOID" ,"srliq");
|
|
|
251 |
INS(i_srliq_cr ,"VOID" ,"VOID" ,"srliq.");
|
|
|
252 |
INS(i_srlq ,"VOID" ,"VOID" ,"srlq");
|
|
|
253 |
INS(i_srlq_cr ,"VOID" ,"VOID" ,"srlq.");
|
|
|
254 |
INS(i_srq ,"VOID" ,"VOID" ,"srq");
|
|
|
255 |
INS(i_srq_cr ,"VOID" ,"VOID" ,"srq.");
|
|
|
256 |
INS(i_svc ,"VOID" ,"VOID" ,"svc");
|
|
|
257 |
INS(i_svcl ,"VOID" ,"VOID" ,"svcl");
|
|
|
258 |
INS(i_svcla ,"VOID" ,"VOID" ,"svcla");
|
|
|
259 |
|
|
|
260 |
|
|
|
261 |
/* Table B-4
|
|
|
262 |
* POWER instructions implemented in the PowerPC architecture
|
|
|
263 |
* Different mnemonics
|
|
|
264 |
*/
|
|
|
265 |
INS(i_a ,"a" ,"addc" ,"a");
|
|
|
266 |
INS(i_a_cr ,"a." ,"addc." ,"a.");
|
|
|
267 |
INS(i_ao ,"ao" ,"addco" ,"ao");
|
|
|
268 |
INS(i_ao_cr ,"ao." ,"addco." ,"ao.");
|
|
|
269 |
INS(i_ae ,"ae" ,"adde" ,"ae");
|
|
|
270 |
INS(i_ae_cr ,"ae." ,"adde." ,"ae.");
|
|
|
271 |
INS(i_aeo ,"aeo" ,"addeo" ,"aeo");
|
|
|
272 |
INS(i_aeo_cr ,"aeo." ,"addeo." ,"aeo.");
|
|
|
273 |
INS(i_ai ,"ai" ,"addic" ,"ai");
|
|
|
274 |
INS(i_ai_cr ,"ai." ,"addic." ,"ai.");
|
|
|
275 |
INS(i_ame ,"ame" ,"addme" ,"ame");
|
|
|
276 |
INS(i_ame_cr ,"ame." ,"addme." ,"ame.");
|
|
|
277 |
INS(i_ameo ,"ameo" ,"addmeo" ,"ameo");
|
|
|
278 |
INS(i_ameo_cr ,"ameo." ,"addmeo." ,"ameo.");
|
|
|
279 |
INS(i_andil_cr ,"andil." ,"andi." ,"andil.");
|
|
|
280 |
INS(i_andiu_cr ,"andiu." ,"andis." ,"andiu.");
|
|
|
281 |
INS(i_aze ,"aze" ,"addze" ,"aze");
|
|
|
282 |
INS(i_aze_cr ,"aze." ,"addze." ,"aze.");
|
|
|
283 |
INS(i_azeo ,"azeo" ,"addzeo" ,"azeo");
|
|
|
284 |
INS(i_azeo_cr ,"azeo." ,"addzeo." ,"azeo.");
|
|
|
285 |
INS(i_bcc ,"bcc" ,"bcctr" ,"bcc");
|
|
|
286 |
INS(i_bccl ,"bccl" ,"bcctrl" ,"bccl");
|
|
|
287 |
INS(i_bcr ,"bcr" ,"bclr" ,"bcr");
|
|
|
288 |
INS(i_bcrl ,"bcrl" ,"bclrl" ,"bcrl");
|
|
|
289 |
INS(i_cal ,"cal" ,"addi" ,"cal");
|
|
|
290 |
INS(i_cau ,"cau" ,"addis" ,"cau");
|
|
|
291 |
INS(i_cax ,"cax" ,"add" ,"cax");
|
|
|
292 |
INS(i_cax_cr ,"cax." ,"add." ,"cax.");
|
|
|
293 |
INS(i_caxo ,"caxo" ,"addo" ,"caxo");
|
|
|
294 |
INS(i_caxo_cr ,"caxo." ,"addo." ,"caxo.");
|
|
|
295 |
INS(i_cntlz ,"cntlz" ,"cntlzw" ,"cntlz");
|
|
|
296 |
INS(i_cntlz_cr ,"cntlz." ,"cntlzw." ,"cntlz.");
|
|
|
297 |
INS(i_dclz ,"dclz" ,"dcbz" ,"dclz");
|
|
|
298 |
INS(i_dcs ,"dcs" ,"sync" ,"dcs");
|
|
|
299 |
INS(i_exts ,"exts" ,"extsh" ,"exts");
|
|
|
300 |
INS(i_exts_cr ,"exts." ,"extsh." ,"exts.");
|
|
|
301 |
INS(i_fa ,"fa" ,"fadd" ,"fa");
|
|
|
302 |
INS(i_fa_cr ,"fa." ,"fadd." ,"fa");
|
|
|
303 |
INS(i_fd ,"fd" ,"fdiv" ,"fd");
|
|
|
304 |
INS(i_fd_cr ,"fd." ,"fdiv." ,"fd.");
|
|
|
305 |
INS(i_fm ,"fm" ,"fmul" ,"fm");
|
|
|
306 |
INS(i_fm_cr ,"fm." ,"fmul." ,"fm.");
|
|
|
307 |
INS(i_fma ,"fma" ,"fmadd" ,"fma");
|
|
|
308 |
INS(i_fma_cr ,"fma." ,"fmadd." ,"fma.");
|
|
|
309 |
INS(i_fms ,"fms" ,"fmsub" ,"fms");
|
|
|
310 |
INS(i_fms_cr ,"fms." ,"fmsub." ,"fms");
|
|
|
311 |
INS(i_fnma ,"fnma" ,"fnmadd" ,"fnma");
|
|
|
312 |
INS(i_fnma_cr ,"fnma." ,"fnmadd." ,"fnma.");
|
|
|
313 |
INS(i_fnms ,"fnms" ,"fnmsub" ,"fnms");
|
|
|
314 |
INS(i_fnms_cr ,"fnms." ,"fnmsub." ,"fnms.");
|
|
|
315 |
INS(i_fs ,"fs" ,"fsub" ,"fs");
|
|
|
316 |
INS(i_fs_cr ,"fs." ,"fsub." ,"fs.");
|
|
|
317 |
INS(i_l ,"l" ,"lwz" ,"l");
|
|
|
318 |
INS(i_lbrx ,"lbrx" ,"lwbrx" ,"lbrx");
|
|
|
319 |
INS(i_lm ,"lm" ,"lmw" ,"lm");
|
|
|
320 |
INS(i_lsi ,"lsi" ,"lswi" ,"lswi");
|
|
|
321 |
INS(i_lsx ,"lsx" ,"lswx" ,"lsx");
|
|
|
322 |
INS(i_lu ,"lu" ,"lwzu" ,"lu");
|
|
|
323 |
INS(i_lux ,"lux" ,"lwzux" ,"lux");
|
|
|
324 |
INS(i_lx ,"lx" ,"lwzx" ,"lx");
|
|
|
325 |
INS(i_mtsri ,"mtsri" ,"mtsrin" ,"mtsri");
|
|
|
326 |
INS(i_muli ,"muli" ,"mulli" ,"muli");
|
|
|
327 |
INS(i_muls ,"muls" ,"mullw" ,"muls");
|
|
|
328 |
INS(i_muls_cr ,"muls." ,"mullw." ,"muls.");
|
|
|
329 |
INS(i_mulso ,"mulso" ,"mullwo" ,"mulso");
|
|
|
330 |
INS(i_mulso_cr ,"mulso." ,"mullwo." ,"mulso.");
|
|
|
331 |
INS(i_oril ,"oril" ,"ori" ,"oril");
|
|
|
332 |
INS(i_oriu ,"oriu" ,"oris" ,"oriu");
|
|
|
333 |
INS(i_rlimi ,"rlimi" ,"rlwimi" ,"rlimi");
|
|
|
334 |
INS(i_rlimi_cr ,"rlimi." ,"rlwimi." ,"rlimi.");
|
|
|
335 |
INS(i_rlinm ,"rlinm" ,"rlwinm" ,"rlinm");
|
|
|
336 |
INS(i_rlinm_cr ,"rlinm." ,"rlwinm." ,"rlinm.");
|
|
|
337 |
INS(i_rlnm ,"rlnm" ,"rlwnm" ,"rlnm");
|
|
|
338 |
INS(i_rlnm_cr ,"rlnm." ,"rlwnm." ,"rlnm.");
|
|
|
339 |
INS(i_sf ,"sf" ,"subfc" ,"sf");
|
|
|
340 |
INS(i_sf_cr ,"sf." ,"subfc." ,"sf.");
|
|
|
341 |
INS(i_sfo ,"sfo" ,"subfco" ,"sfo");
|
|
|
342 |
INS(i_sfo_cr ,"sfo." ,"subfco." ,"sfo.");
|
|
|
343 |
INS(i_sfe ,"sfe" ,"subfe" ,"sfe");
|
|
|
344 |
INS(i_sfe_cr ,"sfe." ,"subfe." ,"sfe.");
|
|
|
345 |
INS(i_sfeo ,"sfeo" ,"subfeo" ,"sfeo");
|
|
|
346 |
INS(i_sfeo_cr ,"sfeo." ,"subfeo." ,"sfeo.");
|
|
|
347 |
INS(i_sfi ,"sfi" ,"subfic" ,"sfi");
|
|
|
348 |
INS(i_sfme ,"sfme" ,"subfme" ,"sfme");
|
|
|
349 |
INS(i_sfme_cr ,"sfme." ,"subfme." ,"sfme.");
|
|
|
350 |
INS(i_sfmeo ,"sfmeo" ,"subfmeo" ,"sfmeo");
|
|
|
351 |
INS(i_sfmeo_cr ,"sfmeo." ,"subfmeo.","sfmeo.");
|
|
|
352 |
INS(i_sfze ,"sfze" ,"subfze" ,"sfze");
|
|
|
353 |
INS(i_sfze_cr ,"sfze." ,"subfze." ,"sfze.");
|
|
|
354 |
INS(i_sfzeo ,"sfzeo" ,"subfzeo" ,"sfzeo");
|
|
|
355 |
INS(i_sfzeo_cr ,"sfzeo." ,"subfzeo.","sfzeo.");
|
|
|
356 |
INS(i_sl ,"sl" ,"slw" ,"sl");
|
|
|
357 |
INS(i_sl_cr ,"sl." ,"slw." ,"sl.");
|
|
|
358 |
INS(i_sr ,"sr" ,"srw" ,"sr");
|
|
|
359 |
INS(i_sr_cr ,"sr." ,"srw." ,"sr.");
|
|
|
360 |
INS(i_sra ,"sra" ,"sraw" ,"sra");
|
|
|
361 |
INS(i_sra_cr ,"sra." ,"sraw." ,"sra.");
|
|
|
362 |
INS(i_srai ,"srai" ,"srawi" ,"srai");
|
|
|
363 |
INS(i_srai_cr ,"srai." ,"srawi." ,"srai.");
|
|
|
364 |
INS(i_st ,"st" ,"stw" ,"st");
|
|
|
365 |
INS(i_stbrx ,"stbrx" ,"stwbrx" ,"stbrx");
|
|
|
366 |
INS(i_stm ,"stm" ,"stmw" ,"stm");
|
|
|
367 |
INS(i_stsi ,"stsi" ,"stswi" ,"stsi");
|
|
|
368 |
INS(i_stsx ,"stsx" ,"stswx" ,"stsx");
|
|
|
369 |
INS(i_stu ,"stu" ,"stwu" ,"stu");
|
|
|
370 |
INS(i_stux ,"stux" ,"stwux" ,"stux");
|
|
|
371 |
INS(i_stx ,"stx" ,"stwx" ,"stx");
|
|
|
372 |
INS(i_svca ,"svca" ,"sc" ,"svca");
|
|
|
373 |
INS(i_t ,"t" ,"tw" ,"t");
|
|
|
374 |
INS(i_ti ,"ti" ,"twi" ,"ti");
|
|
|
375 |
INS(i_tlbi ,"tlbi" ,"tlbie" ,"tlbi");
|
|
|
376 |
INS(i_xoril ,"xoril" ,"xori" ,"xoril");
|
|
|
377 |
INS(i_xoriu ,"xoriu" ,"xoris" ,"xoriu");
|
|
|
378 |
/* end*/
|
|
|
379 |
|
|
|
380 |
/* POWER instructions retained on PowerPc with same mnenonic */
|
|
|
381 |
INS(i_and ,"and" ,"and" ,"and");
|
|
|
382 |
INS(i_and_cr ,"and." ,"and." ,"and.");
|
|
|
383 |
INS(i_andc ,"andc" ,"andc" ,"andc");
|
|
|
384 |
INS(i_andc_cr ,"andc." ,"andc." ,"andc.");
|
|
|
385 |
INS(i_b ,"b" ,"b" ,"b");
|
|
|
386 |
INS(i_ba ,"ba" ,"ba" ,"ba");
|
|
|
387 |
INS(i_bbf ,"bbf" ,"bbf" ,"bbf");
|
|
|
388 |
INS(i_bbfa ,"bbfa" ,"bbfa" ,"bbfa");
|
|
|
389 |
INS(i_bbfc ,"bbfc" ,"bbfc" ,"bbfc");
|
|
|
390 |
INS(i_bbfcl ,"bbfcl" ,"bbfcl" ,"bbfcl");
|
|
|
391 |
INS(i_bbfl ,"bbfl" ,"bbfl" ,"bbfl");
|
|
|
392 |
INS(i_bbfla ,"bbfla" ,"bbfla" ,"bbfla");
|
|
|
393 |
INS(i_bbfr ,"bbfr" ,"bbfr" ,"bbfr");
|
|
|
394 |
INS(i_bbfrl ,"bbfrl" ,"bbfrl" ,"bbfrl");
|
|
|
395 |
INS(i_bbt ,"bbt" ,"bbt" ,"bbt");
|
|
|
396 |
INS(i_bbta ,"bbta" ,"bbta" ,"bbta");
|
|
|
397 |
INS(i_bbtc ,"bbtc" ,"bbtc" ,"bbtc");
|
|
|
398 |
INS(i_bbtcl ,"bbtcl" ,"bbtcl" ,"bbtcl");
|
|
|
399 |
INS(i_bbtl ,"bbtl" ,"bbtl" ,"bbtl");
|
|
|
400 |
INS(i_bbtla ,"bbtla" ,"bbtla" ,"bbtla");
|
|
|
401 |
INS(i_bbtr ,"bbtr" ,"bbtr" ,"bbtr");
|
|
|
402 |
INS(i_bbtrl ,"bbtrl" ,"bbtrl" ,"bbtrl");
|
|
|
403 |
INS(i_bc ,"bc" ,"bc" ,"bc");
|
|
|
404 |
INS(i_bca ,"bca" ,"bca" ,"bca");
|
|
|
405 |
INS(i_bcl ,"bcl" ,"bcl" ,"bcl");
|
|
|
406 |
INS(i_bcla ,"bcla" ,"bcla" ,"bcla");
|
|
|
407 |
INS(i_bctr ,"bctr" ,"bctr" ,"bctr");
|
|
|
408 |
INS(i_bctrl ,"bctrl" ,"bctrl" ,"bctrl");
|
|
|
409 |
INS(i_bdn ,"bdn" ,"bdn" ,"bdn");
|
|
|
410 |
INS(i_bdna ,"bdna" ,"bdna" ,"bdna");
|
|
|
411 |
INS(i_bdneq ,"bdneq" ,"bdneq" ,"bdneq");
|
|
|
412 |
INS(i_bdnge ,"bdnge" ,"bdnge" ,"bdnge");
|
|
|
413 |
INS(i_bdngt ,"bdngt" ,"bdngt" ,"bdngt");
|
|
|
414 |
INS(i_bdnl ,"bdnl" ,"bdnl" ,"bdnl");
|
|
|
415 |
INS(i_bdnla ,"bdnla" ,"bdnla" ,"bdnla");
|
|
|
416 |
INS(i_bdnle ,"bdnle" ,"bdnle" ,"bdnle");
|
|
|
417 |
INS(i_bdnlt ,"bdnlt" ,"bdnlt" ,"bdnlt");
|
|
|
418 |
INS(i_bdnne ,"bdnne" ,"bdnne" ,"bdnne");
|
|
|
419 |
INS(i_bdnns ,"bdnns" ,"bdnns" ,"bdnns");
|
|
|
420 |
INS(i_bdnr ,"bdnr" ,"bdnr" ,"bdnr");
|
|
|
421 |
INS(i_bdnrl ,"bdnrl" ,"bdnrl" ,"bdnrl");
|
|
|
422 |
INS(i_bdnso ,"bdnso" ,"bdnso" ,"bdnso");
|
|
|
423 |
INS(i_bdz ,"bdz" ,"bdz" ,"bdz");
|
|
|
424 |
INS(i_bdza ,"bdza" ,"bdza" ,"bdza");
|
|
|
425 |
INS(i_bdzeq ,"bdzeq" ,"bdzeq" ,"bdzeq");
|
|
|
426 |
INS(i_bdzge ,"bdzge" ,"bdzge" ,"bdzge");
|
|
|
427 |
INS(i_bdzgt ,"bdzgt" ,"bdzgt" ,"bdzgt");
|
|
|
428 |
INS(i_bdzl ,"bdzl" ,"bdzl" ,"bdzl");
|
|
|
429 |
INS(i_bdzla ,"bdzla" ,"bdzla" ,"bdzla");
|
|
|
430 |
INS(i_bdzle ,"bdzle" ,"bdzle" ,"bdzle");
|
|
|
431 |
INS(i_bdzlt ,"bdzlt" ,"bdzlt" ,"bdzlt");
|
|
|
432 |
INS(i_bdzne ,"bdzne" ,"bdzne" ,"bdzne");
|
|
|
433 |
INS(i_bdzns ,"bdzns" ,"bdzns" ,"bdzns");
|
|
|
434 |
INS(i_bdzr ,"bdzr" ,"bdzr" ,"bdzr");
|
|
|
435 |
INS(i_bdzrl ,"bdzrl" ,"bdzrl" ,"bdzrl");
|
|
|
436 |
INS(i_bdzso ,"bdzso" ,"bdzso" ,"bdzso");
|
|
|
437 |
INS(i_beq ,"beq" ,"beq" ,"beq");
|
|
|
438 |
INS(i_beqa ,"beqa" ,"beqa" ,"beqa");
|
|
|
439 |
INS(i_beqc ,"beqc" ,"beqc" ,"beqc");
|
|
|
440 |
INS(i_beqcl ,"beqcl" ,"beqcl" ,"beqcl");
|
|
|
441 |
INS(i_beql ,"beql" ,"beql" ,"beql");
|
|
|
442 |
INS(i_beqla ,"beqla" ,"beqla" ,"beqla");
|
|
|
443 |
INS(i_beqr ,"beqr" ,"beqr" ,"beqr");
|
|
|
444 |
INS(i_beqrl ,"beqrl" ,"beqrl" ,"beqrl");
|
|
|
445 |
INS(i_bge ,"bge" ,"bge" ,"bge");
|
|
|
446 |
INS(i_bgea ,"bgea" ,"bgea" ,"bgea");
|
|
|
447 |
INS(i_bgec ,"bgec" ,"bgec" ,"bgec");
|
|
|
448 |
INS(i_bgecl ,"bgecl" ,"bgecl" ,"bgecl");
|
|
|
449 |
INS(i_bgel ,"bgel" ,"bgel" ,"bgel");
|
|
|
450 |
INS(i_bgela ,"bgela" ,"bgela" ,"bgela");
|
|
|
451 |
INS(i_bger ,"bger" ,"bger" ,"bger");
|
|
|
452 |
INS(i_bgerl ,"bgerl" ,"bgerl" ,"bgerl");
|
|
|
453 |
INS(i_bgt ,"bgt" ,"bgt" ,"bgt");
|
|
|
454 |
INS(i_bgta ,"bgta" ,"bgta" ,"bgta");
|
|
|
455 |
INS(i_bgtc ,"bgtc" ,"bgtc" ,"bgtc");
|
|
|
456 |
INS(i_bgtcl ,"bgtcl" ,"bgtcl" ,"bgtcl");
|
|
|
457 |
INS(i_bgtl ,"bgtl" ,"bgtl" ,"bgtl");
|
|
|
458 |
INS(i_bgtla ,"bgtla" ,"bgtla" ,"bgtla");
|
|
|
459 |
INS(i_bgtr ,"bgtr" ,"bgtr" ,"bgtr");
|
|
|
460 |
INS(i_bgtrl ,"bgtrl" ,"bgtrl" ,"bgtrl");
|
|
|
461 |
INS(i_bl ,"bl" ,"bl" ,"bl");
|
|
|
462 |
INS(i_bla ,"bla" ,"bla" ,"bla");
|
|
|
463 |
INS(i_ble ,"ble" ,"ble" ,"ble");
|
|
|
464 |
INS(i_blea ,"blea" ,"blea" ,"blea");
|
|
|
465 |
INS(i_blec ,"blec" ,"blec" ,"blec");
|
|
|
466 |
INS(i_blecl ,"blecl" ,"blecl" ,"blecl");
|
|
|
467 |
INS(i_blel ,"blel" ,"blel" ,"blel");
|
|
|
468 |
INS(i_blela ,"blela" ,"blela" ,"blela");
|
|
|
469 |
INS(i_bler ,"bler" ,"bler" ,"bler");
|
|
|
470 |
INS(i_blerl ,"blerl" ,"blerl" ,"blerl");
|
|
|
471 |
INS(i_blt ,"blt" ,"blt" ,"blt");
|
|
|
472 |
INS(i_blta ,"blta" ,"blta" ,"blta");
|
|
|
473 |
INS(i_bltc ,"bltc" ,"bltc" ,"bltc");
|
|
|
474 |
INS(i_bltcl ,"bltcl" ,"bltcl" ,"bltcl");
|
|
|
475 |
INS(i_bltl ,"bltl" ,"bltl" ,"bltl");
|
|
|
476 |
INS(i_bltla ,"bltla" ,"bltla" ,"bltla");
|
|
|
477 |
INS(i_bltr ,"bltr" ,"bltr" ,"bltr");
|
|
|
478 |
INS(i_bltrl ,"bltrl" ,"bltrl" ,"bltrl");
|
|
|
479 |
INS(i_bne ,"bne" ,"bne" ,"bne");
|
|
|
480 |
INS(i_bnea ,"bnea" ,"bnea" ,"bnea");
|
|
|
481 |
INS(i_bnec ,"bnec" ,"bnec" ,"bnec");
|
|
|
482 |
INS(i_bnecl ,"bnecl" ,"bnecl" ,"bnecl");
|
|
|
483 |
INS(i_bnel ,"bnel" ,"bnel" ,"bnel");
|
|
|
484 |
INS(i_bnela ,"bnela" ,"bnela" ,"bnela");
|
|
|
485 |
INS(i_bner ,"bner" ,"bner" ,"bner");
|
|
|
486 |
INS(i_bnerl ,"bnerl" ,"bnerl" ,"bnerl");
|
|
|
487 |
INS(i_bng ,"bng" ,"bng" ,"bng");
|
|
|
488 |
INS(i_bnga ,"bnga" ,"bnga" ,"bnga");
|
|
|
489 |
INS(i_bngc ,"bngc" ,"bngc" ,"bngc");
|
|
|
490 |
INS(i_bngcl ,"bngcl" ,"bngcl" ,"bngcl");
|
|
|
491 |
INS(i_bngl ,"bngl" ,"bngl" ,"bngl");
|
|
|
492 |
INS(i_bngla ,"bngla" ,"bngla" ,"bngla");
|
|
|
493 |
INS(i_bngr ,"bngr" ,"bngr" ,"bngr");
|
|
|
494 |
INS(i_bngrl ,"bngrl" ,"bngrl" ,"bngrl");
|
|
|
495 |
INS(i_bnl ,"bnl" ,"bnl" ,"bnl");
|
|
|
496 |
INS(i_bnla ,"bnla" ,"bnla" ,"bnla");
|
|
|
497 |
INS(i_bnlc ,"bnlc" ,"bnlc" ,"bnlc");
|
|
|
498 |
INS(i_bnlcl ,"bnlcl" ,"bnlcl" ,"bnlcl");
|
|
|
499 |
INS(i_bnll ,"bnll" ,"bnll" ,"bnll");
|
|
|
500 |
INS(i_bnlla ,"bnlla" ,"bnlla" ,"bnlla");
|
|
|
501 |
INS(i_bnlr ,"bnlr" ,"bnlr" ,"bnlr");
|
|
|
502 |
INS(i_bnlrl ,"bnlrl" ,"bnlrl" ,"bnlrl");
|
|
|
503 |
INS(i_bns ,"bns" ,"bns" ,"bns");
|
|
|
504 |
INS(i_bnsa ,"bnsa" ,"bnsa" ,"bnsa");
|
|
|
505 |
INS(i_bnsc ,"bnsc" ,"bnsc" ,"bnsc");
|
|
|
506 |
INS(i_bnscl ,"bnscl" ,"bnscl" ,"bnscl");
|
|
|
507 |
INS(i_bnsl ,"bnsl" ,"bnsl" ,"bnsl");
|
|
|
508 |
INS(i_bnsla ,"bnsla" ,"bnsla" ,"bnsla");
|
|
|
509 |
INS(i_bnsr ,"bnsr" ,"bnsr" ,"bnsr");
|
|
|
510 |
INS(i_bnsrl ,"bnsrl" ,"bnsrl" ,"bnsrl");
|
|
|
511 |
INS(i_bnz ,"bnz" ,"bnz" ,"bnz");
|
|
|
512 |
INS(i_bnza ,"bnza" ,"bnza" ,"bnza");
|
|
|
513 |
INS(i_bnzc ,"bnzc" ,"bnzc" ,"bnzc");
|
|
|
514 |
INS(i_bnzcl ,"bnzcl" ,"bnzcl" ,"bnzcl");
|
|
|
515 |
INS(i_bnzl ,"bnzl" ,"bnzl" ,"bnzl");
|
|
|
516 |
INS(i_bnzla ,"bnzla" ,"bnzla" ,"bnzla");
|
|
|
517 |
INS(i_bnzr ,"bnzr" ,"bnzr" ,"bnzr");
|
|
|
518 |
INS(i_bnzrl ,"bnzrl" ,"bnzrl" ,"bnzrl");
|
|
|
519 |
INS(i_br ,"br" ,"br" ,"br");
|
|
|
520 |
INS(i_brl ,"brl" ,"brl" ,"brl");
|
|
|
521 |
INS(i_bso ,"bso" ,"bso" ,"bso");
|
|
|
522 |
INS(i_bsoa ,"bsoa" ,"bsoa" ,"bsoa");
|
|
|
523 |
INS(i_bsoc ,"bsoc" ,"bsoc" ,"bsoc");
|
|
|
524 |
INS(i_bsocl ,"bsocl" ,"bsocl" ,"bsocl");
|
|
|
525 |
INS(i_bsol ,"bsol" ,"bsol" ,"bsol");
|
|
|
526 |
INS(i_bsola ,"bsola" ,"bsola" ,"bsola");
|
|
|
527 |
INS(i_bsor ,"bsor" ,"bsor" ,"bsor");
|
|
|
528 |
INS(i_bsorl ,"bsorl" ,"bsorl" ,"bsorl");
|
|
|
529 |
INS(i_bz ,"bz" ,"bz" ,"bz");
|
|
|
530 |
INS(i_bza ,"bza" ,"bza" ,"bza");
|
|
|
531 |
INS(i_bzc ,"bzc" ,"bzc" ,"bzc");
|
|
|
532 |
INS(i_bzcl ,"bzcl" ,"bzcl" ,"bzcl");
|
|
|
533 |
INS(i_bzl ,"bzl" ,"bzl" ,"bzl");
|
|
|
534 |
INS(i_bzla ,"bzla" ,"bzla" ,"bzla");
|
|
|
535 |
INS(i_bzr ,"bzr" ,"bzr" ,"bzr");
|
|
|
536 |
INS(i_bzrl ,"bzrl" ,"bzrl" ,"bzrl");
|
|
|
537 |
INS(i_ca ,"ca" ,"ca" ,"ca");
|
|
|
538 |
INS(i_cmp ,"cmp" ,"cmp" ,"cmp");
|
|
|
539 |
INS(i_cmpi ,"cmpi" ,"cmpi" ,"cmpi");
|
|
|
540 |
INS(i_cmpl ,"cmpl" ,"cmpl" ,"cmpl");
|
|
|
541 |
INS(i_cmpli ,"cmpli" ,"cmpli" ,"cmpli");
|
|
|
542 |
INS(i_crand ,"crand" ,"crand" ,"crand");
|
|
|
543 |
INS(i_crandc ,"crandc" ,"crandc" ,"crandc");
|
|
|
544 |
INS(i_creqv ,"creqv" ,"creqv" ,"creqv");
|
|
|
545 |
INS(i_crnand ,"crnand" ,"crnand" ,"crnand");
|
|
|
546 |
INS(i_crnor ,"crnor" ,"crnor" ,"crnor");
|
|
|
547 |
INS(i_cror ,"cror" ,"cror" ,"cror");
|
|
|
548 |
INS(i_crorc ,"crorc" ,"crorc" ,"crorc");
|
|
|
549 |
INS(i_crxor ,"crxor" ,"crxor" ,"crxor");
|
|
|
550 |
INS(i_eqv ,"eqv" ,"eqv" ,"eqv");
|
|
|
551 |
INS(i_eqv_cr ,"eqv." ,"eqv." ,"eqv.");
|
|
|
552 |
INS(i_er ,"er" ,"er" ,"er");
|
|
|
553 |
|
|
|
554 |
|
|
|
555 |
INS(i_fabs ,"fabs" ,"fabs" ,"fabs");
|
|
|
556 |
INS(i_fabs_cr ,"fabs." ,"fabs." ,"fabs.");
|
|
|
557 |
INS(i_fcmpo ,"fcmpo" ,"fcmpo" ,"fcmpo");
|
|
|
558 |
INS(i_fcmpu ,"fcmpu" ,"fcmpu" ,"fcmpu");
|
|
|
559 |
|
|
|
560 |
|
|
|
561 |
INS(i_fmr ,"fmr" ,"fmr" ,"fmr");
|
|
|
562 |
INS(i_fmr_cr ,"fmr." ,"fmr." ,"fmr.");
|
|
|
563 |
|
|
|
564 |
INS(i_fnabs ,"fnabs" ,"fnabs" ,"fnabs");
|
|
|
565 |
INS(i_fnabs_cr ,"fnabs." ,"fnabs." ,"fnabs.");
|
|
|
566 |
INS(i_fneg ,"fneg" ,"fneg" ,"fneg");
|
|
|
567 |
INS(i_fneg_cr ,"fneg." ,"fneg." ,"fneg.");
|
|
|
568 |
|
|
|
569 |
INS(i_frsp ,"frsp" ,"frsp" ,"frsp");
|
|
|
570 |
INS(i_frsp_cr ,"frsp." ,"frsp." ,"frsp.");
|
|
|
571 |
|
|
|
572 |
INS(i_ics ,"ics" ,"isync" ,"ics");
|
|
|
573 |
INS(i_ilop ,"ilop" ,"ilop" ,"ilop");
|
|
|
574 |
INS(i_ilopi ,"ilopi" ,"ilopi" ,"ilopi");
|
|
|
575 |
INS(i_ilopr ,"ilopr" ,"ilopr" ,"ilopr");
|
|
|
576 |
|
|
|
577 |
INS(i_lbz ,"lbz" ,"lbz" ,"lbz");
|
|
|
578 |
INS(i_lbzu ,"lbzu" ,"lbzu" ,"lbzu");
|
|
|
579 |
INS(i_lbzux ,"lbzux" ,"lbzux" ,"lbzux");
|
|
|
580 |
INS(i_lbzx ,"lbzx" ,"lbzx" ,"lbzx");
|
|
|
581 |
INS(i_lfd ,"lfd" ,"lfd" ,"lfd");
|
|
|
582 |
INS(i_lfdu ,"lfdu" ,"lfdu" ,"lfdu");
|
|
|
583 |
INS(i_lfdux ,"lfdux" ,"lfdux" ,"lfdux");
|
|
|
584 |
INS(i_lfdx ,"lfdx" ,"lfdx" ,"lfdx");
|
|
|
585 |
INS(i_lfs ,"lfs" ,"lfs" ,"lfs");
|
|
|
586 |
INS(i_lfsu ,"lfsu" ,"lfsu" ,"lfsu");
|
|
|
587 |
INS(i_lfsux ,"lfsux" ,"lfsux" ,"lfsux");
|
|
|
588 |
INS(i_lfsx ,"lfsx" ,"lfsx" ,"lfsx");
|
|
|
589 |
INS(i_lha ,"lha" ,"lha" ,"lha");
|
|
|
590 |
INS(i_lhau ,"lhau" ,"lhau" ,"lhau");
|
|
|
591 |
INS(i_lhaux ,"lhaux" ,"lhaux" ,"lhaux");
|
|
|
592 |
INS(i_lhax ,"lhax" ,"lhax" ,"lhax");
|
|
|
593 |
INS(i_lhbrx ,"lhbrx" ,"lhbrx" ,"lhbrx");
|
|
|
594 |
INS(i_lhz ,"lhz" ,"lhz" ,"lhz");
|
|
|
595 |
INS(i_lhzu ,"lhzu" ,"lhzu" ,"lhzu");
|
|
|
596 |
INS(i_lhzux ,"lhzux" ,"lhzux" ,"lhzux");
|
|
|
597 |
INS(i_lhzx ,"lhzx" ,"lhzx" ,"lhzx");
|
|
|
598 |
INS(i_li ,"li" ,"li" ,"li");
|
|
|
599 |
INS(i_lil ,"lil" ,"lil" ,"lil");
|
|
|
600 |
INS(i_liu ,"liu" ,"liu" ,"liu");
|
|
|
601 |
|
|
|
602 |
|
|
|
603 |
|
|
|
604 |
|
|
|
605 |
INS(i_mcrf ,"mcrf" ,"mcrf" ,"mcrf");
|
|
|
606 |
INS(i_mcrfs ,"mcrfs" ,"mcrfs" ,"mcrfs");
|
|
|
607 |
INS(i_mcrxr ,"mcrxr" ,"mcrxr" ,"mcrxr");
|
|
|
608 |
INS(i_mfcr ,"mfcr" ,"mfcr" ,"mfcr");
|
|
|
609 |
INS(i_mfctr ,"mfctr" ,"mfctr" ,"mfctr");
|
|
|
610 |
INS(i_mfdar ,"mfdar" ,"mfdar" ,"mfdar");
|
|
|
611 |
INS(i_mfdec ,"mfdec" ,"mfdec" ,"mfdec");
|
|
|
612 |
INS(i_mfdsisr ,"mfdsisr" ,"mfdsisr" ,"mfdsisr");
|
|
|
613 |
INS(i_mffs ,"mffs" ,"mffs" ,"mffs");
|
|
|
614 |
INS(i_mffs_cr ,"mffs." ,"mffs." ,"mffs.");
|
|
|
615 |
INS(i_mflr ,"mflr" ,"mflr" ,"mflr");
|
|
|
616 |
INS(i_mfrtcl ,"mfrtcl" ,"mfrtcl" ,"mfrtcl");
|
|
|
617 |
INS(i_mfrtcu ,"mfrtcu" ,"mfrtcu" ,"mfrtcu");
|
|
|
618 |
INS(i_mfsdr0 ,"mfsdr0" ,"mfsdr0" ,"mfsdr0");
|
|
|
619 |
INS(i_mfsdr1 ,"mfsdr1" ,"mfsdr1" ,"mfsdr1");
|
|
|
620 |
INS(i_mfspr ,"mfspr" ,"mfspr" ,"mfspr");
|
|
|
621 |
|
|
|
622 |
INS(i_mfsrr0 ,"mfsrr0" ,"mfsrr0" ,"mfsrr0");
|
|
|
623 |
INS(i_mfsrr1 ,"mfsrr1" ,"mfsrr1" ,"mfsrr1");
|
|
|
624 |
INS(i_mftid ,"mftid" ,"mftid" ,"mftid");
|
|
|
625 |
INS(i_mfxer ,"mfxer" ,"mfxer" ,"mfxer");
|
|
|
626 |
INS(i_mr ,"mr" ,"mr" ,"mr");
|
|
|
627 |
INS(i_mr_cr ,"mr." ,"mr." ,"mr.");
|
|
|
628 |
INS(i_mtcr ,"mtcr" ,"mtcr" ,"mtcr");
|
|
|
629 |
INS(i_mtcrf ,"mtcrf" ,"mtcrf" ,"mtcrf");
|
|
|
630 |
INS(i_mtctr ,"mtctr" ,"mtctr" ,"mtctr");
|
|
|
631 |
INS(i_mtdar ,"mtdar" ,"mtdar" ,"mtdar");
|
|
|
632 |
INS(i_mtdec ,"mtdec" ,"mtdec" ,"mtdec");
|
|
|
633 |
INS(i_mtdsisr ,"mtdsisr" ,"mtdsisr" ,"mtdsisr");
|
|
|
634 |
INS(i_mtfs ,"mtfs" ,"mtfs" ,"mtfs");
|
|
|
635 |
INS(i_mtfs_cr ,"mtfs." ,"mtfs." ,"mtfs.");
|
|
|
636 |
INS(i_mtfsb0 ,"mtfsb0" ,"mtfsb0" ,"mtfsb0");
|
|
|
637 |
INS(i_mtfsb0_cr ,"mtfsb0." ,"mtfsb0." ,"mtfsb0.");
|
|
|
638 |
INS(i_mtfsb1 ,"mtfsb1" ,"mtfsb1" ,"mtfsb1");
|
|
|
639 |
INS(i_mtfsb1_cr ,"mtfsb1." ,"mtfsb1." ,"mtfsb1.");
|
|
|
640 |
INS(i_mtfsf ,"mtfsf" ,"mtfsf" ,"mtfsf");
|
|
|
641 |
INS(i_mtfsf_cr ,"mtfsf." ,"mtfsf." ,"mtfsf.");
|
|
|
642 |
INS(i_mtfsfi ,"mtfsfi" ,"mtfsfi" ,"mtfsfi");
|
|
|
643 |
INS(i_mtfsfi_cr ,"mtfsfi." ,"mtfsfi." ,"mtfsfi.");
|
|
|
644 |
INS(i_mtlr ,"mtlr" ,"mtlr" ,"mtlr");
|
|
|
645 |
INS(i_mtmsr ,"mtmsr" ,"mtmsr" ,"mtmsr");
|
|
|
646 |
INS(i_mtrtcl ,"mtrtcl" ,"mtrtcl" ,"mtrtcl");
|
|
|
647 |
INS(i_mtrtcu ,"mtrtcu" ,"mtrtcu" ,"mtrtcu");
|
|
|
648 |
INS(i_mtsdr0 ,"mtsdr0" ,"mtsdr0" ,"mtsdr0");
|
|
|
649 |
INS(i_mtsdr1 ,"mtsdr1" ,"mtsdr1" ,"mtsdr1");
|
|
|
650 |
INS(i_mtspr ,"mtspr" ,"mtspr" ,"mtspr");
|
|
|
651 |
INS(i_mtsr ,"mtsr" ,"mtsr" ,"mtsr");
|
|
|
652 |
INS(i_mtsrr0 ,"mtsrr0" ,"mtsrr0" ,"mtsrr0");
|
|
|
653 |
INS(i_mtsrr1 ,"mtsrr1" ,"mtsrr1" ,"mtsrr1");
|
|
|
654 |
INS(i_mttid ,"mttid" ,"mttid" ,"mttid");
|
|
|
655 |
INS(i_mtxer ,"mtxer" ,"mtxer" ,"mtxer");
|
|
|
656 |
|
|
|
657 |
|
|
|
658 |
INS(i_nand ,"nand" ,"nand" ,"nand");
|
|
|
659 |
INS(i_nand_cr ,"nand." ,"nand." ,"nand.");
|
|
|
660 |
INS(i_neg ,"neg" ,"neg" ,"neg");
|
|
|
661 |
INS(i_neg_cr ,"neg." ,"neg." ,"neg.");
|
|
|
662 |
INS(i_nego ,"nego" ,"nego" ,"nego");
|
|
|
663 |
INS(i_nego_cr ,"nego." ,"nego." ,"nego.");
|
|
|
664 |
INS(i_nor ,"nor" ,"nor" ,"nor");
|
|
|
665 |
INS(i_nor_cr ,"nor." ,"nor." ,"nor.");
|
|
|
666 |
INS(i_or ,"or" ,"or" ,"or");
|
|
|
667 |
INS(i_or_cr ,"or." ,"or." ,"or.");
|
|
|
668 |
INS(i_orc ,"orc" ,"orc" ,"orc");
|
|
|
669 |
INS(i_orc_cr ,"orc." ,"orc." ,"orc.");
|
|
|
670 |
|
|
|
671 |
INS(i_re ,"re" ,"re" ,"re");
|
|
|
672 |
INS(i_rfi ,"rfi" ,"rfi" ,"rfi");
|
|
|
673 |
INS(i_rfsvc ,"rfsvc" ,"rfsvc" ,"rfsvc");
|
|
|
674 |
|
|
|
675 |
INS(i_rtc ,"rtc" ,"rtc" ,"rtc");
|
|
|
676 |
INS(i_ru ,"ru" ,"ru" ,"ru");
|
|
|
677 |
INS(i_ryo ,"ryo" ,"ryo" ,"ryo");
|
|
|
678 |
INS(i_ryod ,"ryod" ,"ryod" ,"ryod");
|
|
|
679 |
|
|
|
680 |
|
|
|
681 |
INS(i_si ,"si" ,"si" ,"si");
|
|
|
682 |
INS(i_si_cr ,"si." ,"si." ,"si.");
|
|
|
683 |
INS(i_sli ,"sli" ,"sli" ,"sli");
|
|
|
684 |
INS(i_sli_cr ,"sli." ,"sli." ,"sli.");
|
|
|
685 |
INS(i_sri ,"sri" ,"sri" ,"sri");
|
|
|
686 |
INS(i_sri_cr ,"sri." ,"sri." ,"sri.");
|
|
|
687 |
INS(i_stb ,"stb" ,"stb" ,"stb");
|
|
|
688 |
INS(i_stbu ,"stbu" ,"stbu" ,"stbu");
|
|
|
689 |
INS(i_stbux ,"stbux" ,"stbux" ,"stbux");
|
|
|
690 |
INS(i_stbx ,"stbx" ,"stbx" ,"stbx");
|
|
|
691 |
INS(i_stfd ,"stfd" ,"stfd" ,"stfd");
|
|
|
692 |
INS(i_stfdu ,"stfdu" ,"stfdu" ,"stfdu");
|
|
|
693 |
INS(i_stfdux ,"stfdux" ,"stfdux" ,"stfdux");
|
|
|
694 |
INS(i_stfdx ,"stfdx" ,"stfdx" ,"stfdx");
|
|
|
695 |
INS(i_stfs ,"stfs" ,"stfs" ,"stfs");
|
|
|
696 |
INS(i_stfsu ,"stfsu" ,"stfsu" ,"stfsu");
|
|
|
697 |
INS(i_stfsux ,"stfsux" ,"stfsux" ,"stfsux");
|
|
|
698 |
INS(i_stfsx ,"stfsx" ,"stfsx" ,"stfsx");
|
|
|
699 |
INS(i_sth ,"sth" ,"sth" ,"sth");
|
|
|
700 |
INS(i_sthbrx ,"sthbrx" ,"sthbrx" ,"sthbrx");
|
|
|
701 |
INS(i_sthu ,"sthu" ,"sthu" ,"sthu");
|
|
|
702 |
INS(i_sthux ,"sthux" ,"sthux" ,"sthux");
|
|
|
703 |
INS(i_sthx ,"sthx" ,"sthx" ,"sthx");
|
|
|
704 |
INS(i_teq ,"teq" ,"teq" ,"teq");
|
|
|
705 |
INS(i_teqi ,"teqi" ,"teqi" ,"teqi");
|
|
|
706 |
INS(i_tge ,"tge" ,"tge" ,"tge");
|
|
|
707 |
INS(i_tgei ,"tgei" ,"tgei" ,"tgei");
|
|
|
708 |
INS(i_tgt ,"tgt" ,"tgt" ,"tgt");
|
|
|
709 |
INS(i_tgti ,"tgti" ,"tgti" ,"tgti");
|
|
|
710 |
INS(i_tlbp ,"tlbp" ,"tlbp" ,"tlbp");
|
|
|
711 |
INS(i_tle ,"tle" ,"tle" ,"tle");
|
|
|
712 |
INS(i_tlei ,"tlei" ,"tlei" ,"tlei");
|
|
|
713 |
INS(i_tlge ,"tlge" ,"tlge" ,"tlge");
|
|
|
714 |
INS(i_tlgei ,"tlgei" ,"tlgei" ,"tlgei");
|
|
|
715 |
INS(i_tlgt ,"tlgt" ,"tlgt" ,"tlgt");
|
|
|
716 |
INS(i_tlgti ,"tlgti" ,"tlgti" ,"tlgti");
|
|
|
717 |
INS(i_tlle ,"tlle" ,"tlle" ,"tlle");
|
|
|
718 |
INS(i_tllei ,"tllei" ,"tllei" ,"tllei");
|
|
|
719 |
INS(i_tllt ,"tllt" ,"tllt" ,"tllt");
|
|
|
720 |
INS(i_tllti ,"tllti" ,"tllti" ,"tllti");
|
|
|
721 |
INS(i_tlne ,"tlne" ,"tlne" ,"tlne");
|
|
|
722 |
INS(i_tlnei ,"tlnei" ,"tlnei" ,"tlnei");
|
|
|
723 |
INS(i_tlt ,"tlt" ,"tlt" ,"tlt");
|
|
|
724 |
INS(i_tlti ,"tlti" ,"tlti" ,"tlti");
|
|
|
725 |
INS(i_tne ,"tne" ,"tne" ,"tne");
|
|
|
726 |
INS(i_tnei ,"tnei" ,"tnei" ,"tnei");
|
|
|
727 |
INS(i_tri ,"tri" ,"tri" ,"tri");
|
|
|
728 |
INS(i_trr ,"trr" ,"trr" ,"trr");
|
|
|
729 |
INS(i_xor ,"xor" ,"xor" ,"xor");
|
|
|
730 |
INS(i_xor_cr ,"xor." ,"xor." ,"xor.");
|
|
|
731 |
|
|
|
732 |
|
|
|
733 |
|
|
|
734 |
|
|
|
735 |
|
|
|
736 |
/* PowerPC only instructions */
|
|
|
737 |
|
|
|
738 |
INS(i_divw ,"VOID" ,"divw" ,"VOID");
|
|
|
739 |
INS(i_divw_cr ,"VOID" ,"divw." ,"VOID");
|
|
|
740 |
INS(i_divwo ,"VOID" ,"divwo" ,"VOID");
|
|
|
741 |
INS(i_divwo_cr ,"VOID" ,"divwo." ,"VOID");
|
|
|
742 |
INS(i_divwu ,"VOID" ,"divwu" ,"VOID");
|
|
|
743 |
INS(i_divwu_cr ,"VOID" ,"divwu." ,"VOID");
|
|
|
744 |
INS(i_divwuo ,"VOID" ,"divwuo" ,"VOID");
|
|
|
745 |
INS(i_divwuo_cr ,"VOID" ,"divwuo." ,"VOID");
|
|
|
746 |
INS(i_extsb ,"VOID" ,"extsb" ,"VOID");
|
|
|
747 |
INS(i_extsb_cr ,"VOID" ,"extsb." ,"VOID");
|
|
|
748 |
INS(i_fctiw ,"VOID" ,"fctiw" ,"VOID");
|
|
|
749 |
INS(i_fctiwz ,"VOID" ,"fctiwz" ,"VOID");
|
|
|
750 |
INS(i_mulhw ,"VOID" ,"mulhw" ,"VOID");
|
|
|
751 |
INS(i_mulhw_cr ,"VOID" ,"mulhw." ,"VOID");
|
|
|
752 |
INS(i_mulhwu ,"VOID" ,"mulhwu" ,"VOID");
|
|
|
753 |
INS(i_mulhwu_cr ,"VOID" ,"mulhwu." ,"VOID");
|
|
|
754 |
|
|
|
755 |
|
|
|
756 |
|
|
|
757 |
#endif /* INSTRUCTDECS_H */
|
|
|
758 |
|
|
|
759 |
|