Merge branch 'master' into new-parallel-parsing
[dyninst.git] / common / src / arch-power.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 // $Id: arch-power.h,v 1.45 2008/03/25 19:24:23 bernat Exp $
32
33 #ifndef _ARCH_POWER_H
34 #define _ARCH_POWER_H
35
36 // Code generation
37
38 #include "common/src/Types.h"
39 #include "common/src/Vector.h"
40 class AddressSpace;
41
42 namespace NS_power {
43
44 /*
45  * Define power instruction information.
46  *
47  */
48
49 //struct genericform {
50 //  unsigned op : 6;
51 //  unsigned XX : 26;
52 //};
53 #define GENERIC_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
54 #define GENERIC_XX(x) ((unsigned int) (((x).asInt() & 0x03ffffff)       ))
55
56 #define GENERIC_OP_SET(x, y) ((x).setBits(26,  6, (y)))
57 #define GENERIC_XX_SET(x, y) ((x).setBits( 0, 26, (y)))
58
59 //struct iform {            // unconditional branch + 
60 //  unsigned op : 6;
61 //  signed   li : 24;
62 //  unsigned aa : 1;
63 //  unsigned lk : 1;
64 //};
65 #define IFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
66 #define IFORM_LI(x) (instruction::signExtend( \
67                                     (((x).asInt() & 0x03fffffc) >>  2 ), 24))
68 #define IFORM_AA(x) ((unsigned int) (((x).asInt() & 0x00000002) >>  1 ))
69 #define IFORM_LK(x) ((unsigned int) (((x).asInt() & 0x00000001)       ))
70
71 #define IFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
72 #define IFORM_LI_SET(x, y) ((x).setBits( 2, 24, (y)))
73 #define IFORM_AA_SET(x, y) ((x).setBits( 1,  1, (y)))
74 #define IFORM_LK_SET(x, y) ((x).setBits( 0,  1, (y)))
75
76 //struct bform {            // conditional branch +
77 //  unsigned op : 6;
78 //  unsigned bo : 5;
79 //  unsigned bi : 5;
80 //  signed   bd : 14;
81 //  unsigned aa : 1;
82 //  unsigned lk : 1;
83 //};
84 #define BFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
85 #define BFORM_BO(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
86 #define BFORM_BI(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
87 #define BFORM_BD(x) (instruction::signExtend( \
88                                     (((x).asInt() & 0x0000fffc) >>  2 ), 14))
89 #define BFORM_AA(x) ((unsigned int) (((x).asInt() & 0x00000002) >>  1 ))
90 #define BFORM_LK(x) ((unsigned int) (((x).asInt() & 0x00000001)       ))
91
92 #define BFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
93 #define BFORM_BO_SET(x, y) ((x).setBits(21,  5, (y)))
94 #define BFORM_BI_SET(x, y) ((x).setBits(16,  5, (y)))
95 #define BFORM_BD_SET(x, y) ((x).setBits( 2, 14, (y)))
96 #define BFORM_AA_SET(x, y) ((x).setBits( 1,  1, (y)))
97 #define BFORM_LK_SET(x, y) ((x).setBits( 0,  1, (y)))
98
99 //struct dform {
100 //    unsigned op : 6;
101 //    unsigned rt : 5;        // rt, rs, frt, frs, to, bf_l
102 //    unsigned ra : 5;
103 //    signed   d_or_si : 16;  // d, si, ui
104 //};
105 #define DFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
106 #define DFORM_RT(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
107 #define DFORM_RA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
108 #define DFORM_D(x)  (instruction::signExtend( \
109                                     (((x).asInt() & 0x0000ffff)       ), 16))
110 #define DFORM_SI(x) (instruction::signExtend( \
111                                     (((x).asInt() & 0x0000ffff)       ), 16))
112
113 #define DFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
114 #define DFORM_RT_SET(x, y) ((x).setBits(21,  5, (y)))
115 #define DFORM_RA_SET(x, y) ((x).setBits(16,  5, (y)))
116 #define DFORM_D_SET(x, y)  ((x).setBits( 0, 16, (y)))
117 #define DFORM_SI_SET(x, y) ((x).setBits( 0, 16, (y)))
118
119 //struct dsform {
120 //    unsigned op : 6;
121 //    unsigned rt : 5;        // rt, rs
122 //    unsigned ra : 5;
123 //    signed   ds : 14;
124 //    unsigned xo : 2;
125 //};
126 #define DSFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
127 #define DSFORM_RT(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
128 #define DSFORM_RA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
129 #define DSFORM_DS(x) (instruction::signExtend( \
130                                      (((x).asInt() & 0x0000fffc) >>  2 ), 14))
131 #define DSFORM_XO(x) ((unsigned int) (((x).asInt() & 0x00000003)       ))
132
133 #define DSFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
134 #define DSFORM_RT_SET(x, y) ((x).setBits(21,  5, (y)))
135 #define DSFORM_RA_SET(x, y) ((x).setBits(16,  5, (y)))
136 #define DSFORM_DS_SET(x, y) ((x).setBits( 2, 14, (y)))
137 #define DSFORM_XO_SET(x, y) ((x).setBits( 0,  2, (y)))
138
139 //struct xform {
140 //    unsigned op : 6;
141 //    unsigned rt : 5;   // rt, frt, bf_l, rs, frs, to, bt
142 //    unsigned ra : 5;   // ra, fra, bfa_, sr, spr
143 //    unsigned rb : 5;   // rb, frb, sh, nb, u_
144 //    unsigned xo : 10;  // xo, eo
145 //    unsigned rc : 1;
146 //};
147 #define XFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
148 #define XFORM_RT(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
149 #define XFORM_RA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
150 #define XFORM_RB(x) ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
151 #define XFORM_XO(x) ((unsigned int) (((x).asInt() & 0x000007fe) >>  1 ))
152 #define XFORM_RC(x) ((unsigned int) (((x).asInt() & 0x00000001)       ))
153
154 #define XFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
155 #define XFORM_RT_SET(x, y) ((x).setBits(21,  5, (y)))
156 #define XFORM_RA_SET(x, y) ((x).setBits(16,  5, (y)))
157 #define XFORM_RB_SET(x, y) ((x).setBits(11,  5, (y)))
158 #define XFORM_XO_SET(x, y) ((x).setBits( 1, 10, (y)))
159 #define XFORM_RC_SET(x, y) ((x).setBits( 0,  1, (y)))
160
161 //struct xlform {
162 //  unsigned op : 6;
163 //  unsigned bt : 5;   // rt, bo, bf_
164 //  unsigned ba : 5;   // ba, bi, bfa_
165 //  unsigned bb : 5; 
166 //  unsigned xo : 10;  // xo, eo
167 //  unsigned lk : 1;
168 //};
169 #define XLFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
170 #define XLFORM_BT(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
171 #define XLFORM_BA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
172 #define XLFORM_BB(x) ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
173 #define XLFORM_XO(x) ((unsigned int) (((x).asInt() & 0x000007fe) >>  1 ))
174 #define XLFORM_LK(x) ((unsigned int) (((x).asInt() & 0x00000001)       ))
175
176 #define XLFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
177 #define XLFORM_BT_SET(x, y) ((x).setBits(21,  5, (y)))
178 #define XLFORM_BA_SET(x, y) ((x).setBits(16,  5, (y)))
179 #define XLFORM_BB_SET(x, y) ((x).setBits(11,  5, (y)))
180 #define XLFORM_XO_SET(x, y) ((x).setBits( 1, 10, (y)))
181 #define XLFORM_LK_SET(x, y) ((x).setBits( 0,  1, (y)))
182
183 /* struct xx1form {
184         unsigned op : 6;
185         unsigned t  : 5;
186         unsigned RA : 5;
187         unsigned RB : 5; 
188         unsigned xo : 10;
189         unsigned TX/SX : 1;
190 };
191 */
192
193
194
195
196 //struct xfxform {
197 //  unsigned op : 6;
198 //  unsigned rt : 5;   // rs
199 //  unsigned spr: 10;  // spr, tbr, fxm
200 //  unsigned xo : 10;
201 //  unsigned rc : 1;
202 //};
203 #define XFXFORM_OP(x)  ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
204 #define XFXFORM_RT(x)  ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
205 #define XFXFORM_SPR(x) ((unsigned int) (((x).asInt() & 0x001ff800) >> 11 ))
206 #define XFXFORM_XO(x)  ((unsigned int) (((x).asInt() & 0x000007fe) >>  1 ))
207 #define XFXFORM_RC(x)  ((unsigned int) (((x).asInt() & 0x00000001)       ))
208
209 #define XFXFORM_OP_SET(x, y)  ((x).setBits(26,  6, (y)))
210 #define XFXFORM_RT_SET(x, y)  ((x).setBits(21,  5, (y)))
211 #define XFXFORM_SPR_SET(x, y) ((x).setBits(11, 10, (y)))
212 #define XFXFORM_XO_SET(x, y)  ((x).setBits( 1, 10, (y)))
213 #define XFXFORM_RC_SET(x, y)  ((x).setBits( 0,  1, (y)))
214
215 //struct xflform {
216 //  unsigned op : 6;
217 //  unsigned u1 : 1;
218 //  unsigned flm: 8;
219 //  unsigned u2 : 1;
220 //  unsigned frb: 5;
221 //  unsigned xo : 10;
222 //  unsigned rc : 1;
223 //};
224 #define XFLFORM_OP(x)  ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
225 #define XFLFORM_U1(x)  ((unsigned int) (((x).asInt() & 0x02000000) >> 25 ))
226 #define XFLFORM_FLM(x) ((unsigned int) (((x).asInt() & 0x01fe0000) >> 17 ))
227 #define XFLFORM_U2(x)  ((unsigned int) (((x).asInt() & 0x00010000) >> 16 ))
228 #define XFLFORM_FRB(x) ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
229 #define XFLFORM_XO(x)  ((unsigned int) (((x).asInt() & 0x000007fe) >>  1 ))
230 #define XFLFORM_RC(x)  ((unsigned int) (((x).asInt() & 0x00000001)       ))
231
232 #define XFLFORM_OP_SET(x, y)  ((x).setBits(26,  6, (y)))
233 #define XFLFORM_U1_SET(x, y)  ((x).setBits(25,  1, (y)))
234 #define XFLFORM_FLM_SET(x, y) ((x).setBits(17,  8, (y)))
235 #define XFLFORM_U2_SET(x, y)  ((x).setBits(16,  1, (y)))
236 #define XFLFORM_FRB_SET(x, y) ((x).setBits(11,  5, (y)))
237 #define XFLFORM_XO_SET(x, y)  ((x).setBits( 1, 10, (y)))
238 #define XFLFORM_RC_SET(x, y)  ((x).setBits( 0,  1, (y)))
239
240 //struct xoform {
241 //    unsigned op : 6;
242 //    unsigned rt : 5;
243 //    unsigned ra : 5;
244 //    unsigned rb : 5;
245 //    unsigned oe : 1;
246 //    unsigned xo : 9; // xo, eo'
247 //    unsigned rc : 1;
248 //};
249 #define XOFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
250 #define XOFORM_RT(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
251 #define XOFORM_RA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
252 #define XOFORM_RB(x) ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
253 #define XOFORM_OE(x) ((unsigned int) (((x).asInt() & 0x00000400) >> 10 ))
254 #define XOFORM_XO(x) ((unsigned int) (((x).asInt() & 0x000003fe) >>  1 ))
255 #define XOFORM_RC(x) ((unsigned int) (((x).asInt() & 0x00000001)       ))
256
257 #define XOFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
258 #define XOFORM_RT_SET(x, y) ((x).setBits(21,  5, (y)))
259 #define XOFORM_RA_SET(x, y) ((x).setBits(16,  5, (y)))
260 #define XOFORM_RB_SET(x, y) ((x).setBits(11,  5, (y)))
261 #define XOFORM_OE_SET(x, y) ((x).setBits(10,  1, (y)))
262 #define XOFORM_XO_SET(x, y) ((x).setBits( 1,  9, (y)))
263 #define XOFORM_RC_SET(x, y) ((x).setBits( 0,  1, (y)))
264
265 //struct mform {
266 //    unsigned op : 6;
267 //    unsigned rs : 5;
268 //    unsigned ra : 5;
269 //    unsigned sh : 5;
270 //    unsigned mb : 5; // mb, sh
271 //    unsigned me : 5;
272 //    unsigned rc : 1;
273 //};
274 #define MFORM_OP(x) ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
275 #define MFORM_RS(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
276 #define MFORM_RA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
277 #define MFORM_SH(x) ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
278 #define MFORM_MB(x) ((unsigned int) (((x).asInt() & 0x000007c0) >>  6 ))
279 #define MFORM_ME(x) ((unsigned int) (((x).asInt() & 0x0000003e) >>  1 ))
280 #define MFORM_RC(x) ((unsigned int) (((x).asInt() & 0x00000001)       ))
281
282 #define MFORM_OP_SET(x, y) ((x).setBits(26,  6, (y)))
283 #define MFORM_RS_SET(x, y) ((x).setBits(21,  5, (y)))
284 #define MFORM_RA_SET(x, y) ((x).setBits(16,  5, (y)))
285 #define MFORM_SH_SET(x, y) ((x).setBits(11,  5, (y)))
286 #define MFORM_MB_SET(x, y) ((x).setBits( 6,  5, (y)))
287 #define MFORM_ME_SET(x, y) ((x).setBits( 1,  5, (y)))
288 #define MFORM_RC_SET(x, y) ((x).setBits( 0,  1, (y)))
289
290 //struct mdform {
291 //    unsigned op : 6;
292 //    unsigned rs : 5;
293 //    unsigned ra : 5;
294 //    unsigned sh : 5;
295 //    unsigned mb : 5; // me
296 //    unsigned mb2 : 1;
297 //    unsigned xo : 3;
298 //    unsigned sh2 : 1;
299 //    unsigned rc : 1;
300 //};
301 #define MDFORM_OP(x)  ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
302 #define MDFORM_RS(x)  ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
303 #define MDFORM_RA(x)  ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
304 #define MDFORM_SH(x)  ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
305 #define MDFORM_MB(x)  ((unsigned int) (((x).asInt() & 0x000007c0) >>  6 ))
306 #define MDFORM_MB2(x) ((unsigned int) (((x).asInt() & 0x00000020) >>  5 ))
307 #define MDFORM_XO(x)  ((unsigned int) (((x).asInt() & 0x0000001c) >>  2 ))
308 #define MDFORM_SH2(x) ((unsigned int) (((x).asInt() & 0x00000002) >>  1 ))
309 #define MDFORM_RC(x)  ((unsigned int) (((x).asInt() & 0x00000001)       ))
310
311 #define MDFORM_OP_SET(x, y)  ((x).setBits(26,  6, (y)))
312 #define MDFORM_RS_SET(x, y)  ((x).setBits(21,  5, (y)))
313 #define MDFORM_RA_SET(x, y)  ((x).setBits(16,  5, (y)))
314 #define MDFORM_SH_SET(x, y)  ((x).setBits(11,  5, (y)))
315 #define MDFORM_MB_SET(x, y)  ((x).setBits( 6,  5, (y)))
316 #define MDFORM_MB2_SET(x, y) ((x).setBits( 5,  1, (y)))
317 #define MDFORM_XO_SET(x, y)  ((x).setBits( 2,  3, (y)))
318 #define MDFORM_SH2_SET(x, y) ((x).setBits( 1,  1, (y)))
319 #define MDFORM_RC_SET(x, y)  ((x).setBits( 0,  1, (y)))
320
321 //struct aform {
322 //  unsigned op: 6;
323 //  unsigned frt: 5;
324 //  unsigned fra: 5;
325 //  unsigned frb: 5;
326 //  unsigned frc: 5;
327 //  unsigned xo:  5;
328 //  unsigned rc:  1;
329 //};
330 #define AFORM_OP(x)  ((unsigned int) (((x).asInt() & 0xfc000000) >> 26 ))
331 #define AFORM_FRT(x) ((unsigned int) (((x).asInt() & 0x03e00000) >> 21 ))
332 #define AFORM_FRA(x) ((unsigned int) (((x).asInt() & 0x001f0000) >> 16 ))
333 #define AFORM_FRB(x) ((unsigned int) (((x).asInt() & 0x0000f800) >> 11 ))
334 #define AFORM_FRC(x) ((unsigned int) (((x).asInt() & 0x000007c0) >>  6 ))
335 #define AFORM_XO(x)  ((unsigned int) (((x).asInt() & 0x0000003e) >>  1 ))
336 #define AFORM_RC(x)  ((unsigned int) (((x).asInt() & 0x00000001)       ))
337
338 #define AFORM_OP_SET(x, y)  ((x).setBits(26,  6, (y)))
339 #define AFORM_FRT_SET(x, y) ((x).setBits(21,  5, (y)))
340 #define AFORM_FRA_SET(x, y) ((x).setBits(16,  5, (y)))
341 #define AFORM_FRB_SET(x, y) ((x).setBits(11,  5, (y)))
342 #define AFORM_FRC_SET(x, y) ((x).setBits( 6,  5, (y)))
343 #define AFORM_XO_SET(x, y)  ((x).setBits( 1,  5, (y)))
344 #define AFORM_RC_SET(x, y)  ((x).setBits( 0,  1, (y)))
345
346 typedef union {
347 //  struct iform  iform;  // branch;
348 //  struct bform  bform;  // cbranch;
349 //  struct dform  dform;
350 //  struct dsform dsform;
351 //  struct xform  xform;
352 //  struct xoform xoform;
353 //  struct xlform xlform;
354 //  struct xfxform xfxform;
355 //  struct xflform xflform;
356 //  struct mform  mform;
357 //  struct mdform  mdform;
358 //  struct aform  aform;
359     unsigned char byte[4];
360     unsigned int  raw;
361 } instructUnion;
362
363 // instruction is now a class for platform-indep.
364
365 // Mmmm alignment
366 typedef instructUnion codeBuf_t;
367 typedef unsigned codeBufIndex_t;
368
369 #define SPR_XER 1
370 #define SPR_LR  8
371 #define SPR_CTR 9
372 #define SPR_TAR 815
373 #define SPR_MQ 0
374
375 /*
376  * Register saving constants
377  */
378 #define maxFPR 32           /* Save FPRs 0-13 */
379 #define maxGPR 32           /* More space than is needed */
380 #define FPRspaceUsed (8*16) /* Aligned space for FPRs */
381 #define GPRoffset(reg) (-1* (FPRspaceUsed + 4*(maxGPR-reg)))
382 #define GPRspaceUsed (20*4) /* Aligned space for GPRs */
383
384 #define stackFrameSize (FPRspaceUsed+GPRspaceUsed+128)
385
386 /*
387  * Define the operation codes
388  */
389
390 #define X_EXTENDEDop     31
391 #define XO_EXTENDEDop    31
392 #define X_FP_EXTENDEDop  63
393 #define A_FP_EXTENDEDop1  59   
394 #define A_FP_EXTENDEDop2  63
395
396 // ------------- Op Codes, instruction form I  ------------------
397 #define Bop             18      /* (unconditional) branch */
398
399 // ------------- Op Codes, instruction form D  ------------------
400 #define TIop             3      /* trap immediate */
401 #define MULIop           7      /* multiply immediate */
402 #define SFIop            8      /* subtract from immediate */
403 #define DOZIop           9
404 #define CMPLIop         10
405 #define CMPIop          11      /* compare immediate */
406 #define SIop            12      /* subtract immediate */
407 #define AIDOTop         13
408 #define CALop           14      /* compute address lower -- ADDIop */
409 #define CAUop           15      /* compute address upper -- ADDISop*/
410 #define ORILop          24      /* (logical) or immediate lower -- ORIop*/
411 #define ORIUop          25
412 #define XORILop         26
413 #define XORIUop         27 
414 #define ANDILop         28      /* and immediate lower -- ANDIop*/
415 #define ANDIUop         29
416 #define RLDop           30      /* RLD* family -- rotate left doubleword */
417 #define Lop             32      /* load (word) (aka lwz op in PowerPC) */
418 #define LUop            33
419 #define LBZop           34
420 #define LBZUop          35
421 #define STop            36      /* store (word) -- STWop */
422 #define STUop           37      /* store (word) with update -- STWUop */
423 #define STBop           38
424 #define STBUop          39
425 #define LHZop           40
426 #define LHZUop          41
427 #define LHAop           42
428 #define LHAUop          43
429 #define STHop           44
430 #define STHUop          45
431 #define LMop            46
432 #define STMop           47
433 #define LFSop           48
434 #define LFSUop          49
435 #define LFDop           50      /* load floating-point double */
436 #define LFDUop          51
437 #define STFSop          52
438 #define STFSUop         53
439 #define STFDop          54      /* store floating-point double */
440 #define STFDUop         55
441
442 // ------------- Op Codes, instruction form DS  ------------------
443 #define LDop            58      // LWA and LDU have the same op, xop differs
444 #define LDxop           0
445 #define LDUxop          1
446 #define LWAxop          2
447 #define STDop           62      // ditto
448 #define STDxop          0
449 #define STDUxop         1
450
451 // ------------- Op Codes, instruction form B  ------------------
452 #define BCop            16      /* branch conditional */
453
454 // ------------- Op Codes, instruction form MD ------------------
455 #define RLDop          30      /* RLD* family -- rotate left doubleword */
456 #define ICLxop          0      // Immediate and Clear Left
457 #define ICRxop          1      // Immediate and Clear Right
458
459 // ------------- Op Codes, instruction form X  ------------------
460 /* #define XFPop        31      -- extendened fixed point ops */
461 // -- X-from Loads
462 #define LXop            31      // VG: all X-from loads have op 31, only xop differs
463 #define LWARXxop        20
464 #define LDXxop          21
465 #define LXxop           23
466 #define LDUXxop         53
467 #define LUXxop          55
468 #define LDARXxop        84
469 #define LBZXxop         87
470 #define LBZUXxop        119
471 #define LHZXxop         279
472 #define LHZUXxop        311
473 #define MFSPRop         31
474 #define MFSPRxop        339
475 #define LHAXxop         343
476 #define LWAXxop         341
477 #define LWAUXxop        373
478 #define LHAUXxop        375
479 #define LSXxop          533
480 #define LWBRXxop        534
481 #define LFSXxop         535
482 #define LFSUXxop        567     // I guess it must be so ;)
483 #define LSIxop          597
484 #define LFDXxop         599
485 #define LFDUXxop        631
486 #define LHBRXxop        790
487 // -- X-from stores
488 #define STXop           31      // VG: X-form stores, same story
489 #define STDXxop         149
490 #define STWCXxop        150
491 #define STXxop          151
492 #define STDUXxop        181
493 #define STUXxop         183
494 #define STDCXxop        214
495 #define STBXxop         215
496 #define STBUXxop        247
497 #define STHXxop         407
498 #define STHUXxop        439
499 #define STSXxop         661
500 #define STBRXxop        662
501 #define STFSXxop        663
502 #define STFSUXxop       695
503 #define STSIxop         725
504 #define STFDXxop        727
505 #define STFDUXxop       759
506 #define STHBRXxop       918
507 #define STFIWXxop       983
508 // -- other X-forms
509 #define CMPop           31      /* compare -- XFPop*/
510 #define CMPxop          0       /* compare */
511 #define ANDop           31      /* and */
512 #define ANDxop          28      /* and */
513 #define ORop            31      /* or */
514 #define ORxop           444     /* or */
515 #define XORop           31
516 #define XORxop          316
517
518 // -- Other extended op codes for X, XFX, & XO when op is 31
519 #define EXTop           31
520 #define Txop             4
521 #define Axop            10
522 #define MULHWUxop       11
523 #define MFCRxop         19
524 #define SLxop           24
525 #define CNTLZxop        26
526 #define SLDxop          27
527 #define MASKGxop        29
528 #define CMPLxop         32
529 #define SUBFxop         40
530 #define DCBSxop         54
531 #define ANDCxop         60
532 #define MULHWxop        75
533 #define MFMSRxop        83
534 #define DCBFxop         86
535 #define LBZXxop         87
536 #define NEGxop         104
537 #define MULxop         107
538 #define CLFxop         118
539 #define NORxop         124
540 #define SFExop         136
541 #define AExop          138
542 #define MTCRFxop       144
543 #define MTMSRxop       146
544 #define SLQxop         152
545 #define SLExop         153
546 #define SLIQxop        184
547 #define SFZExop        200
548 #define AZExop         202
549 #define MTSRxop        210
550 #define SLLQxop        216
551 #define SLEQxop        217
552 #define SFMExop        232
553 #define AMExop         234
554 #define MTSRIxop       242
555 #define DCBTSTxop      246
556 #define SLLIQxop       248
557 #define DOZxop         264
558 #define LSCBXxop       277
559 #define DCBTxop        278
560 #define EQVxop         284
561 #define TLBIxop        306
562 #define DIVxop         331
563 #define ABSxop         360
564 #define ORCxop         412
565 #define DIVWUxop       459
566 #define MTSPRop         31
567 #define MTSPRxop       467
568 #define DCBIxop        470
569 #define NANDxop        476
570 #define NABSxop        488
571 #define DIVWxop        491
572 #define CLIxop         502
573 #define CLCSxop        531
574 #define SRxop          536
575 #define RRIBxop        537
576 #define SRDxop         539
577 #define MASKIRxop      541
578 #define LFSUXxop       567
579 #define MFSRxop        595
580 #define MFSRIxop       627
581 #define DCLSTxop       630
582 #define MFSRINxop      659
583 #define SRQxop         664
584 #define SRExop         665
585 #define SRIQxop        696
586 #define SRLQxop        728
587 #define SREQxop        729
588 #define SRLIQxop       760
589 #define SRAxop         792
590 #define RACxop         818
591 #define SRAIxop        824
592 #define EIEIOxop       854
593 #define SRAQxop        920
594 #define SREAxop        921
595 #define EXTSxop        922
596 #define SRAIQxop       952
597 #define EXTSBxop       954
598 #define ICBIxop        982
599 #define DCLZxop       1014
600
601 // Vector Op Codes (XX1 Form, identical to XFORM)
602 #define LXVD2Xop            31
603 #define LXVD2Xxo           844
604 #define STXVD2Xop               31
605 #define STXVD2Xxo      972
606
607 // ------------- Op Codes, instruction form XL  -----------------
608 #define BCLRop          19      /* branch conditional link register */
609 #define BCLRxop         16      /* branch conditional link register */
610 #define BCCTRop         19      /* branch conditional count register */
611 #define BCCTRxop        528     /* branch conditional count register */
612 #define BCTARop                 19 /* Branch conditional to TAR register */
613 #define BCTARxop        560 /* Branch conditional to TAR register */ 
614
615 // ------------- Op Codes, instruction form XO  -----------------
616 /* #define XFPop        31      -- extendened fixed point ops */
617 #define SFop            31      /* subtract from -- XFPop */
618 #define SFxop           8       /* subtract from -- SUBFxop */
619 #define MULSop          31      /* multiply short -- XFPop */
620 #define MULSxop         235     /* multiply short -- MULLWxop */
621 #define CAXop           31      /* compute address -- XFPop */
622 #define CAXxop          266     /* compute address -- ADDxop */
623 #define DIVSop          31      /* divide short -- XFPop */
624 #define DIVSxop         363     /* divide short -- replacing DIVWxop */
625
626 // ------------- Extended Floating PointOp Codes, instruction form A ---
627 // Op code - 59
628 #define FDIVSxop        18
629 #define FSUBSxop        20
630 #define FADDSxop        21
631 #define FMULSxop        25
632 #define FMSUBSxop       28
633 #define FMADDSxop       29
634 #define FNMSUBSxop      30
635 #define FNMADDSxop      31
636
637 // Op code - 63
638 #define FDxop           18
639 #define FSxop           20
640 #define FAxop           21
641 #define FSQRTxop        22
642 #define FMxop           25
643 #define FMSxop          28
644 #define FMAxop          29
645 #define FNMSxop         30
646 #define FNMAxop         31
647
648 // ------------- Extended Floating Point Op Codes, instruction form X---
649 // Op Code - 63
650 #define FCMPUxop         0
651 #define FRSPxop         12
652 #define FCIRxop         14
653 #define FCIRZxop        15
654 #define FCMPOxop        32
655 #define FNEGxop         40
656 #define FMRxop          72
657 #define FNABSxop       136
658 #define FABSxop        264
659 #define MFFSxop        583
660 #define MTFSFxop       711
661
662 // ------------- Op Codes, instruction form SC  -----------------
663 #define SVCop           17      /* supervisor call -- used to be SCop */
664
665 // ------------- Op Codes, instruction form M  -----------------
666
667 #define RLIMIop         20      /* rotate left immediate then mask insert */
668 #define RLINMxop        21      /* rotate left immediate then AND with mask
669                                  * -- RLWINMxop */
670 #define RLMIop          22
671 #define RLNMop          23
672
673 #define RLDICLop        30      /* Rotate Left Doubleword Imm and Clear Left */
674
675 // -------------------------- Raw instructions ------------------
676 /* a few full instructions that are in forms we don't break down by field */
677 // xlform
678 #define MTLR0raw       0x7c0803a6      /* move from link reg -- mtlw r0 */
679 #define MFLR0raw       0x7c0802a6      /* move from link reg -- mflr r0 */
680 #define MTLR2raw       0x7c4803a6      /* move from link reg -- mtlr r2 */
681 #define MFLR2raw       0x7c4802a6      /* move from link reg -- mflr r2 */
682 #define MR12CTR        0x7d8903a6      /* move from r12 to CTR */
683 #define BCTRraw        0x4e800420      /* bctr instrunction */
684 #define BCTRLraw       0x4e800421      /* bctrl instrunction */
685 #define BRraw          0x4e800020      /* br instruction bclr */
686 #define BRLraw         0x4e800021      /* branch and link to link reg bclrl */
687 #define NOOPraw        0x60000000      /* noop, d form ORIL 0, 0, 0 */
688
689 // -------------------------- Branch fields ------------------------------
690 // BO field of branch conditional
691 #define Bcondmask               0x1e
692 #define BALWAYSmask             0x14
693
694 #define BPREDICTbit             1       // Set means reverse branch prediction
695 #define BifCTRzerobit           2       // Set means branch if CTR = 0
696 #define BnoDecCTRbit            4       // Set means decrement CTR and branch
697 #define BifTRUEbit              8       // Set means branch if condition true
698 #define BnoCondbit              16      // Set means ignore condition (use CTR)
699
700 #define BFALSEcond              4
701 #define BTRUEcond               12
702 #define BALWAYScond             20
703
704 /* BI field for branch conditional (really bits of the CR Field to use) */
705 #define LTcond                  0               /* negative */
706 #define GTcond                  1               /* positive */
707 #define EQcond                  2               /* zero */
708 #define SOcond                  3               /* summary overflow */
709
710 // -------------------------- Load/Store fields ---------------------------
711 #define RTmask          0x03e00000              // bits  6-10
712 #define RAmask          0x001f0000              // bits 11-15
713 #define RBmask          0x0000f800              // bits 16-20
714 #define DinDmask        0x0000ffff              // bits 16-31
715 #define DinDSmask       0x0000fffc              // bits 16-29
716
717 #define getRT(x) (((x) & RTmask) >> 21)
718 #define getRAByMask(x) (((x) & RAmask) >> 16)
719 #define getRB(x) (((x) & RBmask) >> 11)
720 #define getDinD(x) ((x) & DinDmask)
721 #define getDinDS(x) ((x) & DinDSmask)
722
723 // -------------------------------------------------------------------
724
725 /* mask bits for various parts of the more common instruction format */
726 #define OPmask          0xfc000000              /* most sig. 6 bits */
727 #define AAmask          0x00000002              /* absolutate address */
728 #define LLmask          0x00000001              /* set linkage register */
729 #define AALKmask        AAmask|LLmask           /* AA | LK bits */
730 #define FULLmask        0xffffffff
731
732 #define Bmask           OPmask | AAmask
733 #define Bmatch          0x48000000 /* pc relative unconditional branch */
734 #define BCmatch         0x40000000 /* pc relative conditional branch */
735 #define BAAmatch                0x48000002 /* pc relative unconditional branch */
736 #define BCAAmatch               0x40000002 /* pc relative conditional branch */
737
738
739
740 #define BREAK_POINT_INSN 0x7d821008  /* trap */
741 // #define BREAK_POINT_INSN 0x7fe00008  -- this form should also work and
742 // follows the recommended form outlined in the AIX manual
743
744 #define SPIN_WAIT_INSN 0x48000000 /* VxWorks Trap - Can't perform a trap there. */
745
746 /* high and low half words.  Useful to load addresses as two parts */
747 #define LOW(x)  ((x) & 0xffff)
748 #define HIGH(x) (((x) >> 16) & 0xffff)
749 // HA: adjusted hi value compensating for LOW(x) being sign extended
750 #define HA(x)   ((((x) >> 16) + (((x) & 0x8000) ? 1 : 0)) & 0xffff)
751
752 /* high and low half words for top and bottom words.  Useful to load
753  * addresses in four parts.
754  */
755 #define TOP_HI(x) (((x) >> 48))          // Can't think of a way to do this on
756 #define TOP_LO(x) (((x) >> 32) & 0xFFFF) // 32-bit compilers without warnings.
757 #define BOT_HI(x) (((x) >> 16) & 0xFFFF)
758 #define BOT_LO(x) (((x)      ) & 0xFFFF)
759
760 #define ABS(x)          ((x) > 0 ? x : -x)
761 //#define MAX_BRANCH    0x1<<23
762 #define MAX_BRANCH      0x01fffffc
763 #define MAX_CBRANCH     0x1<<13
764
765 #define MAX_IMM         0x1<<15         /* 15 plus sign == 16 bits */
766
767 // Delcared some other functions in inst-power.C
768 // bool isCallInsn(const instruction);
769 // bool isReturnInsn(const image *, Address, bool&);
770
771 // Define bounds for immediate offsets.
772 // Use strange definitions to avoid compiler warnings.
773 #define MAX_IMM16      32767
774 #define MIN_IMM16      -32768
775
776 #define MAX_IMM32      2147483647
777 #define MIN_IMM32      (-2147483647 - 1)    // In C90, there are no negative
778                                             // constants. Only negated positive
779                                             // constants. Hopefully, compiler
780                                             // will optimize this away.
781
782 #define MAX_IMM48      ((long)(-1 >> 17))   // To avoid warnings on 32-bit
783 #define MIN_IMM48      ((long)(~MAX_IMM48)) // compilers.
784
785 // Helps to mitigate host/target endian mismatches
786 COMMON_EXPORT unsigned int swapBytesIfNeeded(unsigned int i);
787
788 ///////////////////////////////////////////////////////
789 // Bum bum bum.....
790 ///////////////////////////////////////////////////////
791
792 class COMMON_EXPORT instruction {
793  private:
794     instructUnion insn_;
795
796  public:
797     instruction() { insn_.raw = 0; }
798     instruction(unsigned int raw) {
799         // Don't flip bits here.  Input is already in host byte order.
800         insn_.raw = raw;
801     }
802     // Pointer creation method
803     instruction(const void *ptr) {
804       insn_ = *((const instructUnion *)ptr);
805     }
806     instruction(const void *ptr, bool mode_64) {
807       insn_ = *((const instructUnion *)ptr);
808     }
809     instruction(const instruction &insn) :        insn_(insn.insn_) {};
810     instruction(instructUnion &insn) :
811         insn_(insn) {};
812
813     instruction *copy() const;
814
815     void clear() { insn_.raw = 0; }
816     void setInstruction(codeBuf_t *ptr, Address = 0);
817     void setBits(unsigned int pos, unsigned int len, unsigned int value) {
818         unsigned int mask;
819
820         mask = ~(~0 << len);
821         value = value & mask;
822
823         mask = ~(mask << pos);
824         value = value << pos;
825
826         insn_.raw = insn_.raw & mask;
827         insn_.raw = insn_.raw | value;
828     }
829     unsigned int asInt() const { return insn_.raw; }
830     void setInstruction(unsigned char *ptr, Address = 0);
831     
832
833     // To solve host/target endian mismatches
834     static int signExtend(unsigned int i, unsigned int pos);
835     static instructUnion &swapBytes(instructUnion &i);
836
837     // We need instruction::size() all _over_ the place.
838     static unsigned size() { return sizeof(instructUnion); } 
839
840     Address getBranchOffset() const;
841     void setBranchOffset(Address newOffset);
842
843     // And tell us how much space we'll need...
844     // Returns -1 if we can't do a branch due to architecture limitations
845     static unsigned jumpSize(Address from, Address to, unsigned addr_width);
846     static unsigned jumpSize(Address disp, unsigned addr_width);
847     static unsigned maxJumpSize(unsigned addr_width);
848
849     static unsigned maxInterFunctionJumpSize(unsigned addr_width);
850
851     // return the type of the instruction
852     unsigned type() const;
853     
854     // return a pointer to the instruction
855     const unsigned char *ptr() const { return (const unsigned char *)&insn_; }
856
857     // For external modification
858     // Don't allow external modification anymore.  Host byte order may differ
859     // from target byte order.
860     //instructUnion &operator* () { return insn_; }
861     //const instructUnion &operator* () const { return insn_; }
862     //const unsigned int &raw() const { return insn_.raw; }
863
864     unsigned opcode() const;
865     
866     // Local version
867     bool isInsnType(const unsigned mask, const unsigned match) const { 
868         return ((insn_.raw & mask) == match);
869     }
870     
871     Address getTarget(Address insnAddr) const;
872     
873     unsigned spaceToRelocate() const;
874     bool getUsedRegs(pdvector<int> &regs);
875     
876     
877     /* -- CHECK !!!!!
878      * catch small ints that are invalid instructions
879      * opcode 0 is really reserved, not illegal (with the exception of all 0's).
880      *
881      * opcodes 1, 4-6, 56-57, 60-61 are illegal.
882      *
883      * opcodes 2, 30, 58, 62 are illegal in 32 bit implementations, but are
884      *    defined in 64 bit implementations.
885      *
886      * opcodes 19, 30, 31, 59, 62, 63 contain extended op codes that are unused.
887      */
888     
889     bool valid() const { return IFORM_OP(*this) > 0; }
890     
891     bool isCall() const;
892     
893     static bool isAligned(Address addr) {
894         return !(addr & 0x3);
895     }
896     
897     bool isCondBranch() const;
898     bool isUncondBranch() const;
899     bool isThunk() const;
900
901
902   bool isCleaningRet() const {return false; }
903
904 };
905
906 } // arch_power namespace
907 #endif