diff options
Diffstat (limited to 'dynasm')
-rw-r--r-- | dynasm/dasm_arm64.h | 518 | ||||
-rw-r--r-- | dynasm/dasm_arm64.lua | 1166 | ||||
-rw-r--r-- | dynasm/dasm_ppc.h | 2 | ||||
-rw-r--r-- | dynasm/dasm_ppc.lua | 596 |
4 files changed, 2276 insertions, 6 deletions
diff --git a/dynasm/dasm_arm64.h b/dynasm/dasm_arm64.h new file mode 100644 index 00000000..d912e61d --- /dev/null +++ b/dynasm/dasm_arm64.h | |||
@@ -0,0 +1,518 @@ | |||
1 | /* | ||
2 | ** DynASM ARM64 encoding engine. | ||
3 | ** Copyright (C) 2005-2015 Mike Pall. All rights reserved. | ||
4 | ** Released under the MIT license. See dynasm.lua for full copyright notice. | ||
5 | */ | ||
6 | |||
7 | #include <stddef.h> | ||
8 | #include <stdarg.h> | ||
9 | #include <string.h> | ||
10 | #include <stdlib.h> | ||
11 | |||
12 | #define DASM_ARCH "arm64" | ||
13 | |||
14 | #ifndef DASM_EXTERN | ||
15 | #define DASM_EXTERN(a,b,c,d) 0 | ||
16 | #endif | ||
17 | |||
18 | /* Action definitions. */ | ||
19 | enum { | ||
20 | DASM_STOP, DASM_SECTION, DASM_ESC, DASM_REL_EXT, | ||
21 | /* The following actions need a buffer position. */ | ||
22 | DASM_ALIGN, DASM_REL_LG, DASM_LABEL_LG, | ||
23 | /* The following actions also have an argument. */ | ||
24 | DASM_REL_PC, DASM_LABEL_PC, | ||
25 | DASM_IMM, DASM_IMM6, DASM_IMM12, DASM_IMM13W, DASM_IMM13X, DASM_IMML, | ||
26 | DASM__MAX | ||
27 | }; | ||
28 | |||
29 | /* Maximum number of section buffer positions for a single dasm_put() call. */ | ||
30 | #define DASM_MAXSECPOS 25 | ||
31 | |||
32 | /* DynASM encoder status codes. Action list offset or number are or'ed in. */ | ||
33 | #define DASM_S_OK 0x00000000 | ||
34 | #define DASM_S_NOMEM 0x01000000 | ||
35 | #define DASM_S_PHASE 0x02000000 | ||
36 | #define DASM_S_MATCH_SEC 0x03000000 | ||
37 | #define DASM_S_RANGE_I 0x11000000 | ||
38 | #define DASM_S_RANGE_SEC 0x12000000 | ||
39 | #define DASM_S_RANGE_LG 0x13000000 | ||
40 | #define DASM_S_RANGE_PC 0x14000000 | ||
41 | #define DASM_S_RANGE_REL 0x15000000 | ||
42 | #define DASM_S_UNDEF_LG 0x21000000 | ||
43 | #define DASM_S_UNDEF_PC 0x22000000 | ||
44 | |||
45 | /* Macros to convert positions (8 bit section + 24 bit index). */ | ||
46 | #define DASM_POS2IDX(pos) ((pos)&0x00ffffff) | ||
47 | #define DASM_POS2BIAS(pos) ((pos)&0xff000000) | ||
48 | #define DASM_SEC2POS(sec) ((sec)<<24) | ||
49 | #define DASM_POS2SEC(pos) ((pos)>>24) | ||
50 | #define DASM_POS2PTR(D, pos) (D->sections[DASM_POS2SEC(pos)].rbuf + (pos)) | ||
51 | |||
52 | /* Action list type. */ | ||
53 | typedef const unsigned int *dasm_ActList; | ||
54 | |||
55 | /* Per-section structure. */ | ||
56 | typedef struct dasm_Section { | ||
57 | int *rbuf; /* Biased buffer pointer (negative section bias). */ | ||
58 | int *buf; /* True buffer pointer. */ | ||
59 | size_t bsize; /* Buffer size in bytes. */ | ||
60 | int pos; /* Biased buffer position. */ | ||
61 | int epos; /* End of biased buffer position - max single put. */ | ||
62 | int ofs; /* Byte offset into section. */ | ||
63 | } dasm_Section; | ||
64 | |||
65 | /* Core structure holding the DynASM encoding state. */ | ||
66 | struct dasm_State { | ||
67 | size_t psize; /* Allocated size of this structure. */ | ||
68 | dasm_ActList actionlist; /* Current actionlist pointer. */ | ||
69 | int *lglabels; /* Local/global chain/pos ptrs. */ | ||
70 | size_t lgsize; | ||
71 | int *pclabels; /* PC label chains/pos ptrs. */ | ||
72 | size_t pcsize; | ||
73 | void **globals; /* Array of globals (bias -10). */ | ||
74 | dasm_Section *section; /* Pointer to active section. */ | ||
75 | size_t codesize; /* Total size of all code sections. */ | ||
76 | int maxsection; /* 0 <= sectionidx < maxsection. */ | ||
77 | int status; /* Status code. */ | ||
78 | dasm_Section sections[1]; /* All sections. Alloc-extended. */ | ||
79 | }; | ||
80 | |||
81 | /* The size of the core structure depends on the max. number of sections. */ | ||
82 | #define DASM_PSZ(ms) (sizeof(dasm_State)+(ms-1)*sizeof(dasm_Section)) | ||
83 | |||
84 | |||
85 | /* Initialize DynASM state. */ | ||
86 | void dasm_init(Dst_DECL, int maxsection) | ||
87 | { | ||
88 | dasm_State *D; | ||
89 | size_t psz = 0; | ||
90 | int i; | ||
91 | Dst_REF = NULL; | ||
92 | DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection)); | ||
93 | D = Dst_REF; | ||
94 | D->psize = psz; | ||
95 | D->lglabels = NULL; | ||
96 | D->lgsize = 0; | ||
97 | D->pclabels = NULL; | ||
98 | D->pcsize = 0; | ||
99 | D->globals = NULL; | ||
100 | D->maxsection = maxsection; | ||
101 | for (i = 0; i < maxsection; i++) { | ||
102 | D->sections[i].buf = NULL; /* Need this for pass3. */ | ||
103 | D->sections[i].rbuf = D->sections[i].buf - DASM_SEC2POS(i); | ||
104 | D->sections[i].bsize = 0; | ||
105 | D->sections[i].epos = 0; /* Wrong, but is recalculated after resize. */ | ||
106 | } | ||
107 | } | ||
108 | |||
109 | /* Free DynASM state. */ | ||
110 | void dasm_free(Dst_DECL) | ||
111 | { | ||
112 | dasm_State *D = Dst_REF; | ||
113 | int i; | ||
114 | for (i = 0; i < D->maxsection; i++) | ||
115 | if (D->sections[i].buf) | ||
116 | DASM_M_FREE(Dst, D->sections[i].buf, D->sections[i].bsize); | ||
117 | if (D->pclabels) DASM_M_FREE(Dst, D->pclabels, D->pcsize); | ||
118 | if (D->lglabels) DASM_M_FREE(Dst, D->lglabels, D->lgsize); | ||
119 | DASM_M_FREE(Dst, D, D->psize); | ||
120 | } | ||
121 | |||
122 | /* Setup global label array. Must be called before dasm_setup(). */ | ||
123 | void dasm_setupglobal(Dst_DECL, void **gl, unsigned int maxgl) | ||
124 | { | ||
125 | dasm_State *D = Dst_REF; | ||
126 | D->globals = gl - 10; /* Negative bias to compensate for locals. */ | ||
127 | DASM_M_GROW(Dst, int, D->lglabels, D->lgsize, (10+maxgl)*sizeof(int)); | ||
128 | } | ||
129 | |||
130 | /* Grow PC label array. Can be called after dasm_setup(), too. */ | ||
131 | void dasm_growpc(Dst_DECL, unsigned int maxpc) | ||
132 | { | ||
133 | dasm_State *D = Dst_REF; | ||
134 | size_t osz = D->pcsize; | ||
135 | DASM_M_GROW(Dst, int, D->pclabels, D->pcsize, maxpc*sizeof(int)); | ||
136 | memset((void *)(((unsigned char *)D->pclabels)+osz), 0, D->pcsize-osz); | ||
137 | } | ||
138 | |||
139 | /* Setup encoder. */ | ||
140 | void dasm_setup(Dst_DECL, const void *actionlist) | ||
141 | { | ||
142 | dasm_State *D = Dst_REF; | ||
143 | int i; | ||
144 | D->actionlist = (dasm_ActList)actionlist; | ||
145 | D->status = DASM_S_OK; | ||
146 | D->section = &D->sections[0]; | ||
147 | memset((void *)D->lglabels, 0, D->lgsize); | ||
148 | if (D->pclabels) memset((void *)D->pclabels, 0, D->pcsize); | ||
149 | for (i = 0; i < D->maxsection; i++) { | ||
150 | D->sections[i].pos = DASM_SEC2POS(i); | ||
151 | D->sections[i].ofs = 0; | ||
152 | } | ||
153 | } | ||
154 | |||
155 | |||
156 | #ifdef DASM_CHECKS | ||
157 | #define CK(x, st) \ | ||
158 | do { if (!(x)) { \ | ||
159 | D->status = DASM_S_##st|(p-D->actionlist-1); return; } } while (0) | ||
160 | #define CKPL(kind, st) \ | ||
161 | do { if ((size_t)((char *)pl-(char *)D->kind##labels) >= D->kind##size) { \ | ||
162 | D->status = DASM_S_RANGE_##st|(p-D->actionlist-1); return; } } while (0) | ||
163 | #else | ||
164 | #define CK(x, st) ((void)0) | ||
165 | #define CKPL(kind, st) ((void)0) | ||
166 | #endif | ||
167 | |||
168 | static int dasm_imm12(unsigned int n) | ||
169 | { | ||
170 | if ((n >> 12) == 0) | ||
171 | return n; | ||
172 | else if ((n & 0xff000fff) == 0) | ||
173 | return (n >> 12) | 0x1000; | ||
174 | else | ||
175 | return -1; | ||
176 | } | ||
177 | |||
178 | static int dasm_ffs(unsigned long long x) | ||
179 | { | ||
180 | int n = -1; | ||
181 | while (x) { x >>= 1; n++; } | ||
182 | return n; | ||
183 | } | ||
184 | |||
185 | static int dasm_imm13(int lo, int hi) | ||
186 | { | ||
187 | int inv = 0, w = 64, s = 0xfff, xa, xb; | ||
188 | unsigned long long n = (((unsigned long long)hi) << 32) | (unsigned int)lo; | ||
189 | unsigned long long m = 1ULL, a, b, c; | ||
190 | if (n & 1) { n = ~n; inv = 1; } | ||
191 | a = n & -n; b = (n+a)&-(n+a); c = (n+a-b)&-(n+a-b); | ||
192 | xa = dasm_ffs(a); xb = dasm_ffs(b); | ||
193 | if (c) { | ||
194 | w = dasm_ffs(c) - xa; | ||
195 | if (w == 32) m = 0x0000000100000001UL; | ||
196 | else if (w == 16) m = 0x0001000100010001UL; | ||
197 | else if (w == 8) m = 0x0101010101010101UL; | ||
198 | else if (w == 4) m = 0x1111111111111111UL; | ||
199 | else if (w == 2) m = 0x5555555555555555UL; | ||
200 | else return -1; | ||
201 | s = (-2*w & 0x3f) - 1; | ||
202 | } else if (!a) { | ||
203 | return -1; | ||
204 | } else if (xb == -1) { | ||
205 | xb = 64; | ||
206 | } | ||
207 | if ((b-a) * m != n) return -1; | ||
208 | if (inv) { | ||
209 | return ((w - xb) << 6) | (s+w+xa-xb); | ||
210 | } else { | ||
211 | return ((w - xa) << 6) | (s+xb-xa); | ||
212 | } | ||
213 | return -1; | ||
214 | } | ||
215 | |||
216 | /* Pass 1: Store actions and args, link branches/labels, estimate offsets. */ | ||
217 | void dasm_put(Dst_DECL, int start, ...) | ||
218 | { | ||
219 | va_list ap; | ||
220 | dasm_State *D = Dst_REF; | ||
221 | dasm_ActList p = D->actionlist + start; | ||
222 | dasm_Section *sec = D->section; | ||
223 | int pos = sec->pos, ofs = sec->ofs; | ||
224 | int *b; | ||
225 | |||
226 | if (pos >= sec->epos) { | ||
227 | DASM_M_GROW(Dst, int, sec->buf, sec->bsize, | ||
228 | sec->bsize + 2*DASM_MAXSECPOS*sizeof(int)); | ||
229 | sec->rbuf = sec->buf - DASM_POS2BIAS(pos); | ||
230 | sec->epos = (int)sec->bsize/sizeof(int) - DASM_MAXSECPOS+DASM_POS2BIAS(pos); | ||
231 | } | ||
232 | |||
233 | b = sec->rbuf; | ||
234 | b[pos++] = start; | ||
235 | |||
236 | va_start(ap, start); | ||
237 | while (1) { | ||
238 | unsigned int ins = *p++; | ||
239 | unsigned int action = (ins >> 16); | ||
240 | if (action >= DASM__MAX) { | ||
241 | ofs += 4; | ||
242 | } else { | ||
243 | int *pl, n = action >= DASM_REL_PC ? va_arg(ap, int) : 0; | ||
244 | switch (action) { | ||
245 | case DASM_STOP: goto stop; | ||
246 | case DASM_SECTION: | ||
247 | n = (ins & 255); CK(n < D->maxsection, RANGE_SEC); | ||
248 | D->section = &D->sections[n]; goto stop; | ||
249 | case DASM_ESC: p++; ofs += 4; break; | ||
250 | case DASM_REL_EXT: break; | ||
251 | case DASM_ALIGN: ofs += (ins & 255); b[pos++] = ofs; break; | ||
252 | case DASM_REL_LG: | ||
253 | n = (ins & 2047) - 10; pl = D->lglabels + n; | ||
254 | /* Bkwd rel or global. */ | ||
255 | if (n >= 0) { CK(n>=10||*pl<0, RANGE_LG); CKPL(lg, LG); goto putrel; } | ||
256 | pl += 10; n = *pl; | ||
257 | if (n < 0) n = 0; /* Start new chain for fwd rel if label exists. */ | ||
258 | goto linkrel; | ||
259 | case DASM_REL_PC: | ||
260 | pl = D->pclabels + n; CKPL(pc, PC); | ||
261 | putrel: | ||
262 | n = *pl; | ||
263 | if (n < 0) { /* Label exists. Get label pos and store it. */ | ||
264 | b[pos] = -n; | ||
265 | } else { | ||
266 | linkrel: | ||
267 | b[pos] = n; /* Else link to rel chain, anchored at label. */ | ||
268 | *pl = pos; | ||
269 | } | ||
270 | pos++; | ||
271 | break; | ||
272 | case DASM_LABEL_LG: | ||
273 | pl = D->lglabels + (ins & 2047) - 10; CKPL(lg, LG); goto putlabel; | ||
274 | case DASM_LABEL_PC: | ||
275 | pl = D->pclabels + n; CKPL(pc, PC); | ||
276 | putlabel: | ||
277 | n = *pl; /* n > 0: Collapse rel chain and replace with label pos. */ | ||
278 | while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = pos; | ||
279 | } | ||
280 | *pl = -pos; /* Label exists now. */ | ||
281 | b[pos++] = ofs; /* Store pass1 offset estimate. */ | ||
282 | break; | ||
283 | case DASM_IMM: | ||
284 | CK((n & ((1<<((ins>>10)&31))-1)) == 0, RANGE_I); | ||
285 | n >>= ((ins>>10)&31); | ||
286 | #ifdef DASM_CHECKS | ||
287 | if ((ins & 0x8000)) | ||
288 | CK(((n + (1<<(((ins>>5)&31)-1)))>>((ins>>5)&31)) == 0, RANGE_I); | ||
289 | else | ||
290 | CK((n>>((ins>>5)&31)) == 0, RANGE_I); | ||
291 | #endif | ||
292 | b[pos++] = n; | ||
293 | break; | ||
294 | case DASM_IMM6: | ||
295 | CK((n >> 6) == 0, RANGE_I); | ||
296 | b[pos++] = n; | ||
297 | break; | ||
298 | case DASM_IMM12: | ||
299 | CK(dasm_imm12((unsigned int)n) != -1, RANGE_I); | ||
300 | b[pos++] = n; | ||
301 | break; | ||
302 | case DASM_IMM13W: | ||
303 | CK(dasm_imm13(n, n) != -1, RANGE_I); | ||
304 | b[pos++] = n; | ||
305 | break; | ||
306 | case DASM_IMM13X: { | ||
307 | int m = va_arg(ap, int); | ||
308 | CK(dasm_imm13(n, m) != -1, RANGE_I); | ||
309 | b[pos++] = n; | ||
310 | b[pos++] = m; | ||
311 | break; | ||
312 | } | ||
313 | case DASM_IMML: { | ||
314 | #ifdef DASM_CHECKS | ||
315 | int scale = (p[-2] >> 30); | ||
316 | CK((!(n & ((1<<scale)-1)) && (unsigned int)(n>>scale) < 4096) || | ||
317 | (unsigned int)(n+256) < 512, RANGE_I); | ||
318 | #endif | ||
319 | b[pos++] = n; | ||
320 | break; | ||
321 | } | ||
322 | } | ||
323 | } | ||
324 | } | ||
325 | stop: | ||
326 | va_end(ap); | ||
327 | sec->pos = pos; | ||
328 | sec->ofs = ofs; | ||
329 | } | ||
330 | #undef CK | ||
331 | |||
332 | /* Pass 2: Link sections, shrink aligns, fix label offsets. */ | ||
333 | int dasm_link(Dst_DECL, size_t *szp) | ||
334 | { | ||
335 | dasm_State *D = Dst_REF; | ||
336 | int secnum; | ||
337 | int ofs = 0; | ||
338 | |||
339 | #ifdef DASM_CHECKS | ||
340 | *szp = 0; | ||
341 | if (D->status != DASM_S_OK) return D->status; | ||
342 | { | ||
343 | int pc; | ||
344 | for (pc = 0; pc*sizeof(int) < D->pcsize; pc++) | ||
345 | if (D->pclabels[pc] > 0) return DASM_S_UNDEF_PC|pc; | ||
346 | } | ||
347 | #endif | ||
348 | |||
349 | { /* Handle globals not defined in this translation unit. */ | ||
350 | int idx; | ||
351 | for (idx = 20; idx*sizeof(int) < D->lgsize; idx++) { | ||
352 | int n = D->lglabels[idx]; | ||
353 | /* Undefined label: Collapse rel chain and replace with marker (< 0). */ | ||
354 | while (n > 0) { int *pb = DASM_POS2PTR(D, n); n = *pb; *pb = -idx; } | ||
355 | } | ||
356 | } | ||
357 | |||
358 | /* Combine all code sections. No support for data sections (yet). */ | ||
359 | for (secnum = 0; secnum < D->maxsection; secnum++) { | ||
360 | dasm_Section *sec = D->sections + secnum; | ||
361 | int *b = sec->rbuf; | ||
362 | int pos = DASM_SEC2POS(secnum); | ||
363 | int lastpos = sec->pos; | ||
364 | |||
365 | while (pos != lastpos) { | ||
366 | dasm_ActList p = D->actionlist + b[pos++]; | ||
367 | while (1) { | ||
368 | unsigned int ins = *p++; | ||
369 | unsigned int action = (ins >> 16); | ||
370 | switch (action) { | ||
371 | case DASM_STOP: case DASM_SECTION: goto stop; | ||
372 | case DASM_ESC: p++; break; | ||
373 | case DASM_REL_EXT: break; | ||
374 | case DASM_ALIGN: ofs -= (b[pos++] + ofs) & (ins & 255); break; | ||
375 | case DASM_REL_LG: case DASM_REL_PC: pos++; break; | ||
376 | case DASM_LABEL_LG: case DASM_LABEL_PC: b[pos++] += ofs; break; | ||
377 | case DASM_IMM: case DASM_IMM6: case DASM_IMM12: case DASM_IMM13W: | ||
378 | case DASM_IMML: pos++; break; | ||
379 | case DASM_IMM13X: pos += 2; break; | ||
380 | } | ||
381 | } | ||
382 | stop: (void)0; | ||
383 | } | ||
384 | ofs += sec->ofs; /* Next section starts right after current section. */ | ||
385 | } | ||
386 | |||
387 | D->codesize = ofs; /* Total size of all code sections */ | ||
388 | *szp = ofs; | ||
389 | return DASM_S_OK; | ||
390 | } | ||
391 | |||
392 | #ifdef DASM_CHECKS | ||
393 | #define CK(x, st) \ | ||
394 | do { if (!(x)) return DASM_S_##st|(p-D->actionlist-1); } while (0) | ||
395 | #else | ||
396 | #define CK(x, st) ((void)0) | ||
397 | #endif | ||
398 | |||
399 | /* Pass 3: Encode sections. */ | ||
400 | int dasm_encode(Dst_DECL, void *buffer) | ||
401 | { | ||
402 | dasm_State *D = Dst_REF; | ||
403 | char *base = (char *)buffer; | ||
404 | unsigned int *cp = (unsigned int *)buffer; | ||
405 | int secnum; | ||
406 | |||
407 | /* Encode all code sections. No support for data sections (yet). */ | ||
408 | for (secnum = 0; secnum < D->maxsection; secnum++) { | ||
409 | dasm_Section *sec = D->sections + secnum; | ||
410 | int *b = sec->buf; | ||
411 | int *endb = sec->rbuf + sec->pos; | ||
412 | |||
413 | while (b != endb) { | ||
414 | dasm_ActList p = D->actionlist + *b++; | ||
415 | while (1) { | ||
416 | unsigned int ins = *p++; | ||
417 | unsigned int action = (ins >> 16); | ||
418 | int n = (action >= DASM_ALIGN && action < DASM__MAX) ? *b++ : 0; | ||
419 | switch (action) { | ||
420 | case DASM_STOP: case DASM_SECTION: goto stop; | ||
421 | case DASM_ESC: *cp++ = *p++; break; | ||
422 | case DASM_REL_EXT: | ||
423 | n = DASM_EXTERN(Dst, (unsigned char *)cp, (ins&2047), !(ins&2048)); | ||
424 | goto patchrel; | ||
425 | case DASM_ALIGN: | ||
426 | ins &= 255; while ((((char *)cp - base) & ins)) *cp++ = 0xe1a00000; | ||
427 | break; | ||
428 | case DASM_REL_LG: | ||
429 | CK(n >= 0, UNDEF_LG); | ||
430 | case DASM_REL_PC: | ||
431 | CK(n >= 0, UNDEF_PC); | ||
432 | n = *DASM_POS2PTR(D, n) - (int)((char *)cp - base) + 4; | ||
433 | patchrel: | ||
434 | if (!(ins & 0xf800)) { /* B, BL */ | ||
435 | CK((n & 3) == 0 && ((n+0x08000000) >> 28) == 0, RANGE_REL); | ||
436 | cp[-1] |= ((n >> 2) & 0x03ffffff); | ||
437 | } else if ((ins & 0x800)) { /* B.cond, CBZ, CBNZ, LDR* literal */ | ||
438 | CK((n & 3) == 0 && ((n+0x00100000) >> 21) == 0, RANGE_REL); | ||
439 | cp[-1] |= ((n << 3) & 0x00ffffe0); | ||
440 | } else if ((ins & 0x3000) == 0x2000) { /* ADR */ | ||
441 | CK(((n+0x00100000) >> 21) == 0, RANGE_REL); | ||
442 | cp[-1] |= ((n << 3) & 0x00ffffe0) | ((n & 3) << 29); | ||
443 | } else if ((ins & 0x3000) == 0x3000) { /* ADRP */ | ||
444 | cp[-1] |= ((n >> 9) & 0x00ffffe0) | (((n >> 12) & 3) << 29); | ||
445 | } else if ((ins & 0x1000)) { /* TBZ, TBNZ */ | ||
446 | CK((n & 3) == 0 && ((n+0x00008000) >> 16) == 0, RANGE_REL); | ||
447 | cp[-1] |= ((n << 3) & 0x0007ffe0); | ||
448 | } | ||
449 | break; | ||
450 | case DASM_LABEL_LG: | ||
451 | ins &= 2047; if (ins >= 20) D->globals[ins-10] = (void *)(base + n); | ||
452 | break; | ||
453 | case DASM_LABEL_PC: break; | ||
454 | case DASM_IMM: | ||
455 | cp[-1] |= (n & ((1<<((ins>>5)&31))-1)) << (ins&31); | ||
456 | break; | ||
457 | case DASM_IMM6: | ||
458 | cp[-1] |= ((n&31) << 19) | ((n&32) << 26); | ||
459 | break; | ||
460 | case DASM_IMM12: | ||
461 | cp[-1] |= (dasm_imm12((unsigned int)n) << 10); | ||
462 | break; | ||
463 | case DASM_IMM13W: | ||
464 | cp[-1] |= (dasm_imm13(n, n) << 10); | ||
465 | break; | ||
466 | case DASM_IMM13X: | ||
467 | cp[-1] |= (dasm_imm13(n, *b++) << 10); | ||
468 | break; | ||
469 | case DASM_IMML: { | ||
470 | int scale = (p[-2] >> 30); | ||
471 | cp[-1] |= (!(n & ((1<<scale)-1)) && (unsigned int)(n>>scale) < 4096) ? | ||
472 | ((n << (10-scale)) | 0x01000000) : ((n & 511) << 12); | ||
473 | break; | ||
474 | } | ||
475 | default: *cp++ = ins; break; | ||
476 | } | ||
477 | } | ||
478 | stop: (void)0; | ||
479 | } | ||
480 | } | ||
481 | |||
482 | if (base + D->codesize != (char *)cp) /* Check for phase errors. */ | ||
483 | return DASM_S_PHASE; | ||
484 | return DASM_S_OK; | ||
485 | } | ||
486 | #undef CK | ||
487 | |||
488 | /* Get PC label offset. */ | ||
489 | int dasm_getpclabel(Dst_DECL, unsigned int pc) | ||
490 | { | ||
491 | dasm_State *D = Dst_REF; | ||
492 | if (pc*sizeof(int) < D->pcsize) { | ||
493 | int pos = D->pclabels[pc]; | ||
494 | if (pos < 0) return *DASM_POS2PTR(D, -pos); | ||
495 | if (pos > 0) return -1; /* Undefined. */ | ||
496 | } | ||
497 | return -2; /* Unused or out of range. */ | ||
498 | } | ||
499 | |||
500 | #ifdef DASM_CHECKS | ||
501 | /* Optional sanity checker to call between isolated encoding steps. */ | ||
502 | int dasm_checkstep(Dst_DECL, int secmatch) | ||
503 | { | ||
504 | dasm_State *D = Dst_REF; | ||
505 | if (D->status == DASM_S_OK) { | ||
506 | int i; | ||
507 | for (i = 1; i <= 9; i++) { | ||
508 | if (D->lglabels[i] > 0) { D->status = DASM_S_UNDEF_LG|i; break; } | ||
509 | D->lglabels[i] = 0; | ||
510 | } | ||
511 | } | ||
512 | if (D->status == DASM_S_OK && secmatch >= 0 && | ||
513 | D->section != &D->sections[secmatch]) | ||
514 | D->status = DASM_S_MATCH_SEC|(D->section-D->sections); | ||
515 | return D->status; | ||
516 | } | ||
517 | #endif | ||
518 | |||
diff --git a/dynasm/dasm_arm64.lua b/dynasm/dasm_arm64.lua new file mode 100644 index 00000000..9766e475 --- /dev/null +++ b/dynasm/dasm_arm64.lua | |||
@@ -0,0 +1,1166 @@ | |||
1 | ------------------------------------------------------------------------------ | ||
2 | -- DynASM ARM64 module. | ||
3 | -- | ||
4 | -- Copyright (C) 2005-2015 Mike Pall. All rights reserved. | ||
5 | -- See dynasm.lua for full copyright notice. | ||
6 | ------------------------------------------------------------------------------ | ||
7 | |||
8 | -- Module information: | ||
9 | local _info = { | ||
10 | arch = "arm", | ||
11 | description = "DynASM ARM64 module", | ||
12 | version = "1.3.0", | ||
13 | vernum = 10300, | ||
14 | release = "2014-12-03", | ||
15 | author = "Mike Pall", | ||
16 | license = "MIT", | ||
17 | } | ||
18 | |||
19 | -- Exported glue functions for the arch-specific module. | ||
20 | local _M = { _info = _info } | ||
21 | |||
22 | -- Cache library functions. | ||
23 | local type, tonumber, pairs, ipairs = type, tonumber, pairs, ipairs | ||
24 | local assert, setmetatable, rawget = assert, setmetatable, rawget | ||
25 | local _s = string | ||
26 | local sub, format, byte, char = _s.sub, _s.format, _s.byte, _s.char | ||
27 | local match, gmatch, gsub = _s.match, _s.gmatch, _s.gsub | ||
28 | local concat, sort, insert = table.concat, table.sort, table.insert | ||
29 | local bit = bit or require("bit") | ||
30 | local band, shl, shr, sar = bit.band, bit.lshift, bit.rshift, bit.arshift | ||
31 | local ror, tohex = bit.ror, bit.tohex | ||
32 | |||
33 | -- Inherited tables and callbacks. | ||
34 | local g_opt, g_arch | ||
35 | local wline, werror, wfatal, wwarn | ||
36 | |||
37 | -- Action name list. | ||
38 | -- CHECK: Keep this in sync with the C code! | ||
39 | local action_names = { | ||
40 | "STOP", "SECTION", "ESC", "REL_EXT", | ||
41 | "ALIGN", "REL_LG", "LABEL_LG", | ||
42 | "REL_PC", "LABEL_PC", "IMM", "IMM6", "IMM12", "IMM13W", "IMM13X", "IMML", | ||
43 | } | ||
44 | |||
45 | -- Maximum number of section buffer positions for dasm_put(). | ||
46 | -- CHECK: Keep this in sync with the C code! | ||
47 | local maxsecpos = 25 -- Keep this low, to avoid excessively long C lines. | ||
48 | |||
49 | -- Action name -> action number. | ||
50 | local map_action = {} | ||
51 | for n,name in ipairs(action_names) do | ||
52 | map_action[name] = n-1 | ||
53 | end | ||
54 | |||
55 | -- Action list buffer. | ||
56 | local actlist = {} | ||
57 | |||
58 | -- Argument list for next dasm_put(). Start with offset 0 into action list. | ||
59 | local actargs = { 0 } | ||
60 | |||
61 | -- Current number of section buffer positions for dasm_put(). | ||
62 | local secpos = 1 | ||
63 | |||
64 | ------------------------------------------------------------------------------ | ||
65 | |||
66 | -- Dump action names and numbers. | ||
67 | local function dumpactions(out) | ||
68 | out:write("DynASM encoding engine action codes:\n") | ||
69 | for n,name in ipairs(action_names) do | ||
70 | local num = map_action[name] | ||
71 | out:write(format(" %-10s %02X %d\n", name, num, num)) | ||
72 | end | ||
73 | out:write("\n") | ||
74 | end | ||
75 | |||
76 | -- Write action list buffer as a huge static C array. | ||
77 | local function writeactions(out, name) | ||
78 | local nn = #actlist | ||
79 | if nn == 0 then nn = 1; actlist[0] = map_action.STOP end | ||
80 | out:write("static const unsigned int ", name, "[", nn, "] = {\n") | ||
81 | for i = 1,nn-1 do | ||
82 | assert(out:write("0x", tohex(actlist[i]), ",\n")) | ||
83 | end | ||
84 | assert(out:write("0x", tohex(actlist[nn]), "\n};\n\n")) | ||
85 | end | ||
86 | |||
87 | ------------------------------------------------------------------------------ | ||
88 | |||
89 | -- Add word to action list. | ||
90 | local function wputxw(n) | ||
91 | assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range") | ||
92 | actlist[#actlist+1] = n | ||
93 | end | ||
94 | |||
95 | -- Add action to list with optional arg. Advance buffer pos, too. | ||
96 | local function waction(action, val, a, num) | ||
97 | local w = assert(map_action[action], "bad action name `"..action.."'") | ||
98 | wputxw(w * 0x10000 + (val or 0)) | ||
99 | if a then actargs[#actargs+1] = a end | ||
100 | if a or num then secpos = secpos + (num or 1) end | ||
101 | end | ||
102 | |||
103 | -- Flush action list (intervening C code or buffer pos overflow). | ||
104 | local function wflush(term) | ||
105 | if #actlist == actargs[1] then return end -- Nothing to flush. | ||
106 | if not term then waction("STOP") end -- Terminate action list. | ||
107 | wline(format("dasm_put(Dst, %s);", concat(actargs, ", ")), true) | ||
108 | actargs = { #actlist } -- Actionlist offset is 1st arg to next dasm_put(). | ||
109 | secpos = 1 -- The actionlist offset occupies a buffer position, too. | ||
110 | end | ||
111 | |||
112 | -- Put escaped word. | ||
113 | local function wputw(n) | ||
114 | if n <= 0x000fffff then waction("ESC") end | ||
115 | wputxw(n) | ||
116 | end | ||
117 | |||
118 | -- Reserve position for word. | ||
119 | local function wpos() | ||
120 | local pos = #actlist+1 | ||
121 | actlist[pos] = "" | ||
122 | return pos | ||
123 | end | ||
124 | |||
125 | -- Store word to reserved position. | ||
126 | local function wputpos(pos, n) | ||
127 | assert(n >= 0 and n <= 0xffffffff and n % 1 == 0, "word out of range") | ||
128 | if n <= 0x000fffff then | ||
129 | insert(actlist, pos+1, n) | ||
130 | n = map_action.ESC * 0x10000 | ||
131 | end | ||
132 | actlist[pos] = n | ||
133 | end | ||
134 | |||
135 | ------------------------------------------------------------------------------ | ||
136 | |||
137 | -- Global label name -> global label number. With auto assignment on 1st use. | ||
138 | local next_global = 20 | ||
139 | local map_global = setmetatable({}, { __index = function(t, name) | ||
140 | if not match(name, "^[%a_][%w_]*$") then werror("bad global label") end | ||
141 | local n = next_global | ||
142 | if n > 2047 then werror("too many global labels") end | ||
143 | next_global = n + 1 | ||
144 | t[name] = n | ||
145 | return n | ||
146 | end}) | ||
147 | |||
148 | -- Dump global labels. | ||
149 | local function dumpglobals(out, lvl) | ||
150 | local t = {} | ||
151 | for name, n in pairs(map_global) do t[n] = name end | ||
152 | out:write("Global labels:\n") | ||
153 | for i=20,next_global-1 do | ||
154 | out:write(format(" %s\n", t[i])) | ||
155 | end | ||
156 | out:write("\n") | ||
157 | end | ||
158 | |||
159 | -- Write global label enum. | ||
160 | local function writeglobals(out, prefix) | ||
161 | local t = {} | ||
162 | for name, n in pairs(map_global) do t[n] = name end | ||
163 | out:write("enum {\n") | ||
164 | for i=20,next_global-1 do | ||
165 | out:write(" ", prefix, t[i], ",\n") | ||
166 | end | ||
167 | out:write(" ", prefix, "_MAX\n};\n") | ||
168 | end | ||
169 | |||
170 | -- Write global label names. | ||
171 | local function writeglobalnames(out, name) | ||
172 | local t = {} | ||
173 | for name, n in pairs(map_global) do t[n] = name end | ||
174 | out:write("static const char *const ", name, "[] = {\n") | ||
175 | for i=20,next_global-1 do | ||
176 | out:write(" \"", t[i], "\",\n") | ||
177 | end | ||
178 | out:write(" (const char *)0\n};\n") | ||
179 | end | ||
180 | |||
181 | ------------------------------------------------------------------------------ | ||
182 | |||
183 | -- Extern label name -> extern label number. With auto assignment on 1st use. | ||
184 | local next_extern = 0 | ||
185 | local map_extern_ = {} | ||
186 | local map_extern = setmetatable({}, { __index = function(t, name) | ||
187 | -- No restrictions on the name for now. | ||
188 | local n = next_extern | ||
189 | if n > 2047 then werror("too many extern labels") end | ||
190 | next_extern = n + 1 | ||
191 | t[name] = n | ||
192 | map_extern_[n] = name | ||
193 | return n | ||
194 | end}) | ||
195 | |||
196 | -- Dump extern labels. | ||
197 | local function dumpexterns(out, lvl) | ||
198 | out:write("Extern labels:\n") | ||
199 | for i=0,next_extern-1 do | ||
200 | out:write(format(" %s\n", map_extern_[i])) | ||
201 | end | ||
202 | out:write("\n") | ||
203 | end | ||
204 | |||
205 | -- Write extern label names. | ||
206 | local function writeexternnames(out, name) | ||
207 | out:write("static const char *const ", name, "[] = {\n") | ||
208 | for i=0,next_extern-1 do | ||
209 | out:write(" \"", map_extern_[i], "\",\n") | ||
210 | end | ||
211 | out:write(" (const char *)0\n};\n") | ||
212 | end | ||
213 | |||
214 | ------------------------------------------------------------------------------ | ||
215 | |||
216 | -- Arch-specific maps. | ||
217 | |||
218 | -- Ext. register name -> int. name. | ||
219 | local map_archdef = { xzr = "@x31", wzr = "@w31", lr = "x30", } | ||
220 | |||
221 | -- Int. register name -> ext. name. | ||
222 | local map_reg_rev = { ["@x31"] = "xzr", ["@w31"] = "wzr", x30 = "lr", } | ||
223 | |||
224 | local map_type = {} -- Type name -> { ctype, reg } | ||
225 | local ctypenum = 0 -- Type number (for Dt... macros). | ||
226 | |||
227 | -- Reverse defines for registers. | ||
228 | function _M.revdef(s) | ||
229 | return map_reg_rev[s] or s | ||
230 | end | ||
231 | |||
232 | local map_shift = { lsl = 0, lsr = 1, asr = 2, } | ||
233 | |||
234 | local map_extend = { | ||
235 | uxtb = 0, uxth = 1, uxtw = 2, uxtx = 3, | ||
236 | sxtb = 4, sxth = 5, sxtw = 6, sxtx = 7, | ||
237 | } | ||
238 | |||
239 | local map_cond = { | ||
240 | eq = 0, ne = 1, cs = 2, cc = 3, mi = 4, pl = 5, vs = 6, vc = 7, | ||
241 | hi = 8, ls = 9, ge = 10, lt = 11, gt = 12, le = 13, al = 14, | ||
242 | hs = 2, lo = 3, | ||
243 | } | ||
244 | |||
245 | ------------------------------------------------------------------------------ | ||
246 | |||
247 | local parse_reg_type | ||
248 | |||
249 | local function parse_reg(expr) | ||
250 | if not expr then werror("expected register name") end | ||
251 | local tname, ovreg = match(expr, "^([%w_]+):(@?%l%d+)$") | ||
252 | local tp = map_type[tname or expr] | ||
253 | if tp then | ||
254 | local reg = ovreg or tp.reg | ||
255 | if not reg then | ||
256 | werror("type `"..(tname or expr).."' needs a register override") | ||
257 | end | ||
258 | expr = reg | ||
259 | end | ||
260 | local ok31, rt, r = match(expr, "^(@?)([xwqdshb])([123]?[0-9])$") | ||
261 | if r then | ||
262 | r = tonumber(r) | ||
263 | if r <= 30 or (r == 31 and ok31 ~= "" or (rt ~= "w" and rt ~= "x")) then | ||
264 | if not parse_reg_type then | ||
265 | parse_reg_type = rt | ||
266 | elseif parse_reg_type ~= rt then | ||
267 | werror("register size mismatch") | ||
268 | end | ||
269 | return r, tp | ||
270 | end | ||
271 | end | ||
272 | werror("bad register name `"..expr.."'") | ||
273 | end | ||
274 | |||
275 | local function parse_reg_base(expr) | ||
276 | if expr == "sp" then return 0x3e0 end | ||
277 | local base, tp = parse_reg(expr) | ||
278 | if parse_reg_type ~= "x" then werror("bad register type") end | ||
279 | parse_reg_type = false | ||
280 | return shl(base, 5), tp | ||
281 | end | ||
282 | |||
283 | local parse_ctx = {} | ||
284 | |||
285 | local loadenv = setfenv and function(s) | ||
286 | local code = loadstring(s, "") | ||
287 | if code then setfenv(code, parse_ctx) end | ||
288 | return code | ||
289 | end or function(s) | ||
290 | return load(s, "", nil, parse_ctx) | ||
291 | end | ||
292 | |||
293 | -- Try to parse simple arithmetic, too, since some basic ops are aliases. | ||
294 | local function parse_number(n) | ||
295 | local x = tonumber(n) | ||
296 | if x then return x end | ||
297 | local code = loadenv("return "..n) | ||
298 | if code then | ||
299 | local ok, y = pcall(code) | ||
300 | if ok then return y end | ||
301 | end | ||
302 | return nil | ||
303 | end | ||
304 | |||
305 | local function parse_imm(imm, bits, shift, scale, signed) | ||
306 | imm = match(imm, "^#(.*)$") | ||
307 | if not imm then werror("expected immediate operand") end | ||
308 | local n = parse_number(imm) | ||
309 | if n then | ||
310 | local m = sar(n, scale) | ||
311 | if shl(m, scale) == n then | ||
312 | if signed then | ||
313 | local s = sar(m, bits-1) | ||
314 | if s == 0 then return shl(m, shift) | ||
315 | elseif s == -1 then return shl(m + shl(1, bits), shift) end | ||
316 | else | ||
317 | if sar(m, bits) == 0 then return shl(m, shift) end | ||
318 | end | ||
319 | end | ||
320 | werror("out of range immediate `"..imm.."'") | ||
321 | else | ||
322 | waction("IMM", (signed and 32768 or 0)+scale*1024+bits*32+shift, imm) | ||
323 | return 0 | ||
324 | end | ||
325 | end | ||
326 | |||
327 | local function parse_imm12(imm) | ||
328 | imm = match(imm, "^#(.*)$") | ||
329 | if not imm then werror("expected immediate operand") end | ||
330 | local n = parse_number(imm) | ||
331 | if n then | ||
332 | if shr(n, 12) == 0 then | ||
333 | return shl(n, 10) | ||
334 | elseif band(n, 0xff000fff) == 0 then | ||
335 | return shr(n, 2) + 0x00400000 | ||
336 | end | ||
337 | werror("out of range immediate `"..imm.."'") | ||
338 | else | ||
339 | waction("IMM12", 0, imm) | ||
340 | return 0 | ||
341 | end | ||
342 | end | ||
343 | |||
344 | local function parse_imm13(imm) | ||
345 | imm = match(imm, "^#(.*)$") | ||
346 | if not imm then werror("expected immediate operand") end | ||
347 | local n = parse_number(imm) | ||
348 | local r64 = parse_reg_type == "x" | ||
349 | if n and n % 1 == 0 and n >= 0 and n <= 0xffffffff then | ||
350 | local inv = false | ||
351 | if band(n, 1) == 1 then n = bit.bnot(n); inv = true end | ||
352 | local t = {} | ||
353 | for i=1,32 do t[i] = band(n, 1); n = shr(n, 1) end | ||
354 | local b = table.concat(t) | ||
355 | b = b..(r64 and (inv and "1" or "0"):rep(32) or b) | ||
356 | local p0, p1, p0a, p1a = b:match("^(0+)(1+)(0*)(1*)") | ||
357 | if p0 then | ||
358 | local w = p1a == "" and (r64 and 64 or 32) or #p1+#p0a | ||
359 | if band(w, w-1) == 0 and b == b:sub(1, w):rep(64/w) then | ||
360 | local s = band(-2*w, 0x3f) - 1 | ||
361 | if w == 64 then s = s + 0x1000 end | ||
362 | if inv then | ||
363 | return shl(w-#p1-#p0, 16) + shl(s+w-#p1, 10) | ||
364 | else | ||
365 | return shl(w-#p0, 16) + shl(s+#p1, 10) | ||
366 | end | ||
367 | end | ||
368 | end | ||
369 | werror("out of range immediate `"..imm.."'") | ||
370 | elseif r64 then | ||
371 | waction("IMM13X", 0, format("(unsigned int)(%s)", imm)) | ||
372 | actargs[#actargs+1] = format("(unsigned int)((unsigned long long)(%s)>>32)", imm) | ||
373 | return 0 | ||
374 | else | ||
375 | waction("IMM13W", 0, imm) | ||
376 | return 0 | ||
377 | end | ||
378 | end | ||
379 | |||
380 | local function parse_imm6(imm) | ||
381 | imm = match(imm, "^#(.*)$") | ||
382 | if not imm then werror("expected immediate operand") end | ||
383 | local n = parse_number(imm) | ||
384 | if n then | ||
385 | if n >= 0 and n <= 63 then | ||
386 | return shl(band(n, 0x1f), 19) + (n >= 32 and 0x80000000 or 0) | ||
387 | end | ||
388 | werror("out of range immediate `"..imm.."'") | ||
389 | else | ||
390 | waction("IMM6", 0, imm) | ||
391 | return 0 | ||
392 | end | ||
393 | end | ||
394 | |||
395 | local function parse_imm_load(imm, scale) | ||
396 | local n = parse_number(imm) | ||
397 | if n then | ||
398 | local m = sar(n, scale) | ||
399 | if shl(m, scale) == n and m >= 0 and m < 0x1000 then | ||
400 | return shl(m, 10) + 0x01000000 -- Scaled, unsigned 12 bit offset. | ||
401 | elseif n >= -256 and n < 256 then | ||
402 | return shl(band(n, 511), 12) -- Unscaled, signed 9 bit offset. | ||
403 | end | ||
404 | werror("out of range immediate `"..imm.."'") | ||
405 | else | ||
406 | waction("IMML", 0, imm) | ||
407 | return 0 | ||
408 | end | ||
409 | end | ||
410 | |||
411 | local function parse_fpimm(imm) | ||
412 | imm = match(imm, "^#(.*)$") | ||
413 | if not imm then werror("expected immediate operand") end | ||
414 | local n = parse_number(imm) | ||
415 | if n then | ||
416 | local m, e = math.frexp(n) | ||
417 | local s, e2 = 0, band(e-2, 7) | ||
418 | if m < 0 then m = -m; s = 0x00100000 end | ||
419 | m = m*32-16 | ||
420 | if m % 1 == 0 and m >= 0 and m <= 15 and sar(shl(e2, 29), 29)+2 == e then | ||
421 | return s + shl(e2, 17) + shl(m, 13) | ||
422 | end | ||
423 | werror("out of range immediate `"..imm.."'") | ||
424 | else | ||
425 | werror("NYI fpimm action") | ||
426 | end | ||
427 | end | ||
428 | |||
429 | local function parse_shift(expr) | ||
430 | local s, s2 = match(expr, "^(%S+)%s*(.*)$") | ||
431 | s = map_shift[s] | ||
432 | if not s then werror("expected shift operand") end | ||
433 | return parse_imm(s2, 6, 10, 0, false) + shl(s, 22) | ||
434 | end | ||
435 | |||
436 | local function parse_lslx16(expr) | ||
437 | local n = match(expr, "^lsl%s*#(%d+)$") | ||
438 | n = tonumber(n) | ||
439 | if not n then werror("expected shift operand") end | ||
440 | if band(n, parse_reg_type == "x" and 0xffffffcf or 0xffffffef) ~= 0 then | ||
441 | werror("bad shift amount") | ||
442 | end | ||
443 | return shl(n, 17) | ||
444 | end | ||
445 | |||
446 | local function parse_extend(expr) | ||
447 | local s, s2 = match(expr, "^(%S+)%s*(.*)$") | ||
448 | if s == "lsl" then | ||
449 | s = parse_reg_type == "x" and 3 or 2 | ||
450 | else | ||
451 | s = map_extend[s] | ||
452 | end | ||
453 | if not s then werror("expected extend operand") end | ||
454 | return (s2 == "" and 0 or parse_imm(s2, 3, 10, 0, false)) + shl(s, 13) | ||
455 | end | ||
456 | |||
457 | local function parse_cond(expr, inv) | ||
458 | local c = map_cond[expr] | ||
459 | if not c then werror("expected condition operand") end | ||
460 | return shl(bit.bxor(c, inv), 12) | ||
461 | end | ||
462 | |||
463 | local function parse_load(params, nparams, n, op) | ||
464 | if params[n+2] then werror("too many operands") end | ||
465 | local pn, p2 = params[n], params[n+1] | ||
466 | local p1, wb = match(pn, "^%[%s*(.-)%s*%](!?)$") | ||
467 | if not p1 then | ||
468 | if not p2 then | ||
469 | local reg, tailr = match(pn, "^([%w_:]+)%s*(.*)$") | ||
470 | if reg and tailr ~= "" then | ||
471 | local base, tp = parse_reg_base(reg) | ||
472 | if tp then | ||
473 | waction("IMML", 0, format(tp.ctypefmt, tailr)) | ||
474 | return op + base | ||
475 | end | ||
476 | end | ||
477 | end | ||
478 | werror("expected address operand") | ||
479 | end | ||
480 | local scale = shr(op, 30) | ||
481 | if p2 then | ||
482 | if wb == "!" then werror("bad use of '!'") end | ||
483 | op = op + parse_reg_base(p1) + parse_imm(p2, 9, 12, 0, true) + 0x400 | ||
484 | elseif wb == "!" then | ||
485 | local p1a, p2a = match(p1, "^([^,%s]*)%s*,%s*(.*)$") | ||
486 | if not p1a then werror("bad use of '!'") end | ||
487 | op = op + parse_reg_base(p1a) + parse_imm(p2a, 9, 12, 0, true) + 0xc00 | ||
488 | else | ||
489 | local p1a, p2a = match(p1, "^([^,%s]*)%s*(.*)$") | ||
490 | op = op + parse_reg_base(p1a) | ||
491 | if p2a ~= "" then | ||
492 | local imm = match(p2a, "^,%s*#(.*)$") | ||
493 | if imm then | ||
494 | op = op + parse_imm_load(imm, scale) | ||
495 | else | ||
496 | local p2b, p3b, p3s = match(p2a, "^,%s*([^,%s]*)%s*,?%s*(%S*)%s*(.*)$") | ||
497 | op = op + shl(parse_reg(p2b), 16) + 0x00200800 | ||
498 | if parse_reg_type ~= "x" and parse_reg_type ~= "w" then | ||
499 | werror("bad index register type") | ||
500 | end | ||
501 | if p3b == "" then | ||
502 | if parse_reg_type ~= "x" then werror("bad index register type") end | ||
503 | op = op + 0x6000 | ||
504 | else | ||
505 | if p3s == "" or p3s == "#0" then | ||
506 | elseif p3s == "#"..scale then | ||
507 | op = op + 0x1000 | ||
508 | else | ||
509 | werror("bad scale") | ||
510 | end | ||
511 | if parse_reg_type == "x" then | ||
512 | if p3b == "lsl" and p3s ~= "" then op = op + 0x6000 | ||
513 | elseif p3b == "sxtx" then op = op + 0xe000 | ||
514 | else | ||
515 | werror("bad extend/shift specifier") | ||
516 | end | ||
517 | else | ||
518 | if p3b == "uxtw" then op = op + 0x4000 | ||
519 | elseif p3b == "sxtw" then op = op + 0xc000 | ||
520 | else | ||
521 | werror("bad extend/shift specifier") | ||
522 | end | ||
523 | end | ||
524 | end | ||
525 | end | ||
526 | else | ||
527 | if wb == "!" then werror("bad use of '!'") end | ||
528 | op = op + 0x01000000 | ||
529 | end | ||
530 | end | ||
531 | return op | ||
532 | end | ||
533 | |||
534 | local function parse_load_pair(params, nparams, n, op) | ||
535 | if params[n+2] then werror("too many operands") end | ||
536 | local pn, p2 = params[n], params[n+1] | ||
537 | local scale = shr(op, 30) == 0 and 2 or 3 | ||
538 | local p1, wb = match(pn, "^%[%s*(.-)%s*%](!?)$") | ||
539 | if not p1 then | ||
540 | if not p2 then | ||
541 | local reg, tailr = match(pn, "^([%w_:]+)%s*(.*)$") | ||
542 | if reg and tailr ~= "" then | ||
543 | local base, tp = parse_reg_base(reg) | ||
544 | if tp then | ||
545 | waction("IMM", 32768+7*32+15+scale*1024, format(tp.ctypefmt, tailr)) | ||
546 | return op + base + 0x01000000 | ||
547 | end | ||
548 | end | ||
549 | end | ||
550 | werror("expected address operand") | ||
551 | end | ||
552 | if p2 then | ||
553 | if wb == "!" then werror("bad use of '!'") end | ||
554 | op = op + 0x00800000 | ||
555 | else | ||
556 | local p1a, p2a = match(p1, "^([^,%s]*)%s*,%s*(.*)$") | ||
557 | if p1a then p1, p2 = p1a, p2a else p2 = "#0" end | ||
558 | op = op + (wb == "!" and 0x01800000 or 0x01000000) | ||
559 | end | ||
560 | return op + parse_reg_base(p1) + parse_imm(p2, 7, 15, scale, true) | ||
561 | end | ||
562 | |||
563 | local function parse_label(label, def) | ||
564 | local prefix = sub(label, 1, 2) | ||
565 | -- =>label (pc label reference) | ||
566 | if prefix == "=>" then | ||
567 | return "PC", 0, sub(label, 3) | ||
568 | end | ||
569 | -- ->name (global label reference) | ||
570 | if prefix == "->" then | ||
571 | return "LG", map_global[sub(label, 3)] | ||
572 | end | ||
573 | if def then | ||
574 | -- [1-9] (local label definition) | ||
575 | if match(label, "^[1-9]$") then | ||
576 | return "LG", 10+tonumber(label) | ||
577 | end | ||
578 | else | ||
579 | -- [<>][1-9] (local label reference) | ||
580 | local dir, lnum = match(label, "^([<>])([1-9])$") | ||
581 | if dir then -- Fwd: 1-9, Bkwd: 11-19. | ||
582 | return "LG", lnum + (dir == ">" and 0 or 10) | ||
583 | end | ||
584 | -- extern label (extern label reference) | ||
585 | local extname = match(label, "^extern%s+(%S+)$") | ||
586 | if extname then | ||
587 | return "EXT", map_extern[extname] | ||
588 | end | ||
589 | end | ||
590 | werror("bad label `"..label.."'") | ||
591 | end | ||
592 | |||
593 | local function branch_type(op) | ||
594 | if band(op, 0x7c000000) == 0x14000000 then return 0 -- B, BL | ||
595 | elseif shr(op, 24) == 0x54 or band(op, 0x7e000000) == 0x34000000 or | ||
596 | band(op, 0x3b000000) == 0x18000000 then | ||
597 | return 0x800 -- B.cond, CBZ, CBNZ, LDR* literal | ||
598 | elseif band(op, 0x7e000000) == 0x36000000 then return 0x1000 -- TBZ, TBNZ | ||
599 | elseif band(op, 0x9f000000) == 0x10000000 then return 0x2000 -- ADR | ||
600 | elseif band(op, 0x9f000000) == band(0x90000000) then return 0x3000 -- ADRP | ||
601 | else | ||
602 | assert(false, "unknown branch type") | ||
603 | end | ||
604 | end | ||
605 | |||
606 | ------------------------------------------------------------------------------ | ||
607 | |||
608 | local map_op, op_template | ||
609 | |||
610 | local function op_alias(opname, f) | ||
611 | return function(params, nparams) | ||
612 | if not params then return "-> "..opname:sub(1, -3) end | ||
613 | f(params, nparams) | ||
614 | op_template(params, map_op[opname], nparams) | ||
615 | end | ||
616 | end | ||
617 | |||
618 | local function alias_bfx(p) | ||
619 | p[4] = "#("..p[3]:sub(2)..")+("..p[4]:sub(2)..")-1" | ||
620 | end | ||
621 | |||
622 | local function alias_bfiz(p) | ||
623 | parse_reg(p[1]) | ||
624 | if parse_reg_type == "w" then | ||
625 | p[3] = "#-("..p[3]:sub(2)..")%32" | ||
626 | p[4] = "#("..p[4]:sub(2)..")-1" | ||
627 | else | ||
628 | p[3] = "#-("..p[3]:sub(2)..")%64" | ||
629 | p[4] = "#("..p[4]:sub(2)..")-1" | ||
630 | end | ||
631 | end | ||
632 | |||
633 | local alias_lslimm = op_alias("ubfm_4", function(p) | ||
634 | parse_reg(p[1]) | ||
635 | local sh = p[3]:sub(2) | ||
636 | if parse_reg_type == "w" then | ||
637 | p[3] = "#-("..sh..")%32" | ||
638 | p[4] = "#31-("..sh..")" | ||
639 | else | ||
640 | p[3] = "#-("..sh..")%64" | ||
641 | p[4] = "#63-("..sh..")" | ||
642 | end | ||
643 | end) | ||
644 | |||
645 | -- Template strings for ARM instructions. | ||
646 | map_op = { | ||
647 | -- Basic data processing instructions. | ||
648 | add_3 = "0b000000DNMg|11000000pDpNIg|8b206000pDpNMx", | ||
649 | add_4 = "0b000000DNMSg|0b200000DNMXg|8b200000pDpNMXx|8b200000pDpNxMwX", | ||
650 | adds_3 = "2b000000DNMg|31000000DpNIg|ab206000DpNMx", | ||
651 | adds_4 = "2b000000DNMSg|2b200000DNMXg|ab200000DpNMXx|ab200000DpNxMwX", | ||
652 | cmn_2 = "2b00001fNMg|3100001fpNIg|ab20601fpNMx", | ||
653 | cmn_3 = "2b00001fNMSg|2b20001fNMXg|ab20001fpNMXx|ab20001fpNxMwX", | ||
654 | |||
655 | sub_3 = "4b000000DNMg|51000000pDpNIg|cb206000pDpNMx", | ||
656 | sub_4 = "4b000000DNMSg|4b200000DNMXg|cb200000pDpNMXx|cb200000pDpNxMwX", | ||
657 | subs_3 = "6b000000DNMg|71000000DpNIg|eb206000DpNMx", | ||
658 | subs_4 = "6b000000DNMSg|6b200000DNMXg|eb200000DpNMXx|eb200000DpNxMwX", | ||
659 | cmp_2 = "6b00001fNMg|7100001fpNIg|eb20601fpNMx", | ||
660 | cmp_3 = "6b00001fNMSg|6b20001fNMXg|eb20001fpNMXx|eb20001fpNxMwX", | ||
661 | |||
662 | neg_2 = "4b0003e0DMg", | ||
663 | neg_3 = "4b0003e0DMSg", | ||
664 | negs_2 = "6b0003e0DMg", | ||
665 | negs_3 = "6b0003e0DMSg", | ||
666 | |||
667 | adc_3 = "1a000000DNMg", | ||
668 | adcs_3 = "3a000000DNMg", | ||
669 | sbc_3 = "5a000000DNMg", | ||
670 | sbcs_3 = "7a000000DNMg", | ||
671 | ngc_2 = "5a0003e0DMg", | ||
672 | ngcs_2 = "7a0003e0DMg", | ||
673 | |||
674 | and_3 = "0a000000DNMg|12000000pDNig", | ||
675 | and_4 = "0a000000DNMSg", | ||
676 | orr_3 = "2a000000DNMg|32000000pDNig", | ||
677 | orr_4 = "2a000000DNMSg", | ||
678 | eor_3 = "4a000000DNMg|52000000pDNig", | ||
679 | eor_4 = "4a000000DNMSg", | ||
680 | ands_3 = "6a000000DNMg|72000000DNig", | ||
681 | ands_4 = "6a000000DNMSg", | ||
682 | tst_2 = "6a00001fNMg|7200001fNig", | ||
683 | tst_3 = "6a00001fNMSg", | ||
684 | |||
685 | bic_3 = "0a200000DNMg", | ||
686 | bic_4 = "0a200000DNMSg", | ||
687 | orn_3 = "2a200000DNMg", | ||
688 | orn_4 = "2a200000DNMSg", | ||
689 | eon_3 = "4a200000DNMg", | ||
690 | eon_4 = "4a200000DNMSg", | ||
691 | bics_3 = "6a200000DNMg", | ||
692 | bics_4 = "6a200000DNMSg", | ||
693 | |||
694 | movn_2 = "12800000DWg", | ||
695 | movn_3 = "12800000DWRg", | ||
696 | movz_2 = "52800000DWg", | ||
697 | movz_3 = "52800000DWRg", | ||
698 | movk_2 = "72800000DWg", | ||
699 | movk_3 = "72800000DWRg", | ||
700 | |||
701 | -- TODO: this doesn't cover all valid immediates for mov reg, #imm. | ||
702 | mov_2 = "2a0003e0DMg|52800000DW|320003e0pDig|11000000pDpNg", | ||
703 | mov_3 = "2a0003e0DMSg", | ||
704 | mvn_2 = "2a2003e0DMg", | ||
705 | mvn_3 = "2a2003e0DMSg", | ||
706 | |||
707 | adr_2 = "10000000DBx", | ||
708 | adrp_2 = "90000000DBx", | ||
709 | |||
710 | csel_4 = "1a800000DNMCg", | ||
711 | csinc_4 = "1a800400DNMCg", | ||
712 | csinv_4 = "5a800000DNMCg", | ||
713 | csneg_4 = "5a800400DNMCg", | ||
714 | cset_2 = "1a9f07e0Dcg", | ||
715 | csetm_2 = "5a9f03e0Dcg", | ||
716 | cinc_3 = "1a800400DNmcg", | ||
717 | cinv_3 = "5a800000DNmcg", | ||
718 | cneg_3 = "5a800400DNmcg", | ||
719 | |||
720 | ccmn_4 = "3a400000NMVCg|3a400800N5VCg", | ||
721 | ccmp_4 = "7a400000NMVCg|7a400800N5VCg", | ||
722 | |||
723 | madd_4 = "1b000000DNMAg", | ||
724 | msub_4 = "1b008000DNMAg", | ||
725 | mul_3 = "1b007c00DNMg", | ||
726 | mneg_3 = "1b00fc00DNMg", | ||
727 | |||
728 | smaddl_4 = "9b200000DxNMwAx", | ||
729 | smsubl_4 = "9b208000DxNMwAx", | ||
730 | smull_3 = "9b207c00DxNMw", | ||
731 | smnegl_3 = "9b20fc00DxNMw", | ||
732 | smulh_3 = "9b407c00DNMx", | ||
733 | umaddl_4 = "9ba00000DxNMwAx", | ||
734 | umsubl_4 = "9ba08000DxNMwAx", | ||
735 | umull_3 = "9ba07c00DxNMw", | ||
736 | umnegl_3 = "9ba0fc00DxNMw", | ||
737 | umulh_3 = "9bc07c00DNMx", | ||
738 | |||
739 | udiv_3 = "1ac00800DNMg", | ||
740 | sdiv_3 = "1ac00c00DNMg", | ||
741 | |||
742 | -- Bit operations. | ||
743 | sbfm_4 = "13000000DN12w|93400000DN12x", | ||
744 | bfm_4 = "33000000DN12w|b3400000DN12x", | ||
745 | ubfm_4 = "53000000DN12w|d3400000DN12x", | ||
746 | extr_4 = "13800000DNM2w|93c00000DNM2x", | ||
747 | |||
748 | sxtb_2 = "13001c00DNw|93401c00DNx", | ||
749 | sxth_2 = "13003c00DNw|93403c00DNx", | ||
750 | sxtw_2 = "93407c00DxNw", | ||
751 | uxtb_2 = "53001c00DNw", | ||
752 | uxth_2 = "53003c00DNw", | ||
753 | |||
754 | sbfx_4 = op_alias("sbfm_4", alias_bfx), | ||
755 | bfxil_4 = op_alias("bfm_4", alias_bfx), | ||
756 | ubfx_4 = op_alias("ubfm_4", alias_bfx), | ||
757 | sbfiz_4 = op_alias("sbfm_4", alias_bfiz), | ||
758 | bfi_4 = op_alias("bfm_4", alias_bfiz), | ||
759 | ubfiz_4 = op_alias("ubfm_4", alias_bfiz), | ||
760 | |||
761 | lsl_3 = function(params, nparams) | ||
762 | if params and params[3]:byte() == 35 then | ||
763 | return alias_lslimm(params, nparams) | ||
764 | else | ||
765 | return op_template(params, "1ac02000DNMg", nparams) | ||
766 | end | ||
767 | end, | ||
768 | lsr_3 = "1ac02400DNMg|53007c00DN1w|d340fc00DN1x", | ||
769 | asr_3 = "1ac02800DNMg|13007c00DN1w|9340fc00DN1x", | ||
770 | ror_3 = "1ac02c00DNMg|13800000DNm2w|93c00000DNm2x", | ||
771 | |||
772 | clz_2 = "5ac01000DNg", | ||
773 | cls_2 = "5ac01400DNg", | ||
774 | rbit_2 = "5ac00000DNg", | ||
775 | rev_2 = "5ac00800DNw|dac00c00DNx", | ||
776 | rev16_2 = "5ac00400DNg", | ||
777 | rev32_2 = "dac00800DNx", | ||
778 | |||
779 | -- Loads and stores. | ||
780 | ["strb_*"] = "38000000DwL", | ||
781 | ["ldrb_*"] = "38400000DwL", | ||
782 | ["ldrsb_*"] = "38c00000DwL|38800000DxL", | ||
783 | ["strh_*"] = "78000000DwL", | ||
784 | ["ldrh_*"] = "78400000DwL", | ||
785 | ["ldrsh_*"] = "78c00000DwL|78800000DxL", | ||
786 | ["str_*"] = "b8000000DwL|f8000000DxL|bc000000DsL|fc000000DdL", | ||
787 | ["ldr_*"] = "18000000DwB|58000000DxB|1c000000DsB|5c000000DdB|b8400000DwL|f8400000DxL|bc400000DsL|fc400000DdL", | ||
788 | ["ldrsw_*"] = "98000000DxB|b8800000DxL", | ||
789 | -- NOTE: ldur etc. are handled by ldr et al. | ||
790 | |||
791 | ["stp_*"] = "28000000DAwP|a8000000DAxP|2c000000DAsP|6c000000DAdP", | ||
792 | ["ldp_*"] = "28400000DAwP|a8400000DAxP|2c400000DAsP|6c400000DAdP", | ||
793 | ["ldpsw_*"] = "68400000DAxP", | ||
794 | |||
795 | -- Branches. | ||
796 | b_1 = "14000000B", | ||
797 | bl_1 = "94000000B", | ||
798 | blr_1 = "d63f0000Nx", | ||
799 | br_1 = "d61f0000Nx", | ||
800 | ret_0 = "d65f03c0", | ||
801 | ret_1 = "d65f0000Nx", | ||
802 | -- b.cond is added below. | ||
803 | cbz_2 = "34000000DBg", | ||
804 | cbnz_2 = "35000000DBg", | ||
805 | tbz_3 = "36000000DTBw|36000000DTBx", | ||
806 | tbnz_3 = "37000000DTBw|37000000DTBx", | ||
807 | |||
808 | -- Miscellaneous instructions. | ||
809 | -- TODO: hlt, hvc, smc, svc, eret, dcps[123], drps, mrs, msr | ||
810 | -- TODO: sys, sysl, ic, dc, at, tlbi | ||
811 | -- TODO: hint, yield, wfe, wfi, sev, sevl | ||
812 | -- TODO: clrex, dsb, dmb, isb | ||
813 | nop_0 = "d503201f", | ||
814 | brk_0 = "d4200000", | ||
815 | brk_1 = "d4200000W", | ||
816 | |||
817 | -- Floating point instructions. | ||
818 | fmov_2 = "1e204000DNf|1e260000DwNs|1e270000DsNw|9e660000DxNd|9e670000DdNx|1e201000DFf", | ||
819 | fabs_2 = "1e20c000DNf", | ||
820 | fneg_2 = "1e214000DNf", | ||
821 | fsqrt_2 = "1e21c000DNf", | ||
822 | |||
823 | fcvt_2 = "1e22c000DdNs|1e624000DsNd", | ||
824 | |||
825 | -- TODO: half-precision and fixed-point conversions. | ||
826 | fcvtas_2 = "1e240000DwNs|9e240000DxNs|1e640000DwNd|9e640000DxNd", | ||
827 | fcvtau_2 = "1e250000DwNs|9e250000DxNs|1e650000DwNd|9e650000DxNd", | ||
828 | fcvtms_2 = "1e300000DwNs|9e300000DxNs|1e700000DwNd|9e700000DxNd", | ||
829 | fcvtmu_2 = "1e310000DwNs|9e310000DxNs|1e710000DwNd|9e710000DxNd", | ||
830 | fcvtns_2 = "1e200000DwNs|9e200000DxNs|1e600000DwNd|9e600000DxNd", | ||
831 | fcvtnu_2 = "1e210000DwNs|9e210000DxNs|1e610000DwNd|9e610000DxNd", | ||
832 | fcvtps_2 = "1e280000DwNs|9e280000DxNs|1e680000DwNd|9e680000DxNd", | ||
833 | fcvtpu_2 = "1e290000DwNs|9e290000DxNs|1e690000DwNd|9e690000DxNd", | ||
834 | fcvtzs_2 = "1e380000DwNs|9e380000DxNs|1e780000DwNd|9e780000DxNd", | ||
835 | fcvtzu_2 = "1e390000DwNs|9e390000DxNs|1e790000DwNd|9e790000DxNd", | ||
836 | |||
837 | scvtf_2 = "1e220000DsNw|9e220000DsNx|1e620000DdNw|9e620000DdNx", | ||
838 | ucvtf_2 = "1e230000DsNw|9e230000DsNx|1e630000DdNw|9e630000DdNx", | ||
839 | |||
840 | frintn_2 = "1e244000DNf", | ||
841 | frintp_2 = "1e24c000DNf", | ||
842 | frintm_2 = "1e254000DNf", | ||
843 | frintz_2 = "1e25c000DNf", | ||
844 | frinta_2 = "1e264000DNf", | ||
845 | frintx_2 = "1e274000DNf", | ||
846 | frinti_2 = "1e27c000DNf", | ||
847 | |||
848 | fadd_3 = "1e202800DNMf", | ||
849 | fsub_3 = "1e203800DNMf", | ||
850 | fmul_3 = "1e200800DNMf", | ||
851 | fnmul_3 = "1e208800DNMf", | ||
852 | fdiv_3 = "1e201800DNMf", | ||
853 | |||
854 | fmadd_4 = "1f000000DNMAf", | ||
855 | fmsub_4 = "1f008000DNMAf", | ||
856 | fnmadd_4 = "1f200000DNMAf", | ||
857 | fnmsub_4 = "1f208000DNMAf", | ||
858 | |||
859 | fmax_3 = "1e204800DNMf", | ||
860 | fmaxnm_3 = "1e206800DNMf", | ||
861 | fmin_3 = "1e205800DNMf", | ||
862 | fminnm_3 = "1e207800DNMf", | ||
863 | |||
864 | fcmp_2 = "1e202000NMf|1e202008NZf", | ||
865 | fcmpe_2 = "1e202010NMf|1e202018NZf", | ||
866 | |||
867 | fccmp_4 = "1e200400NMVCf", | ||
868 | fccmpe_4 = "1e200410NMVCf", | ||
869 | |||
870 | fcsel_4 = "1e200c00DNMCf", | ||
871 | |||
872 | -- TODO: crc32*, aes*, sha*, pmull | ||
873 | -- TODO: SIMD instructions. | ||
874 | } | ||
875 | |||
876 | for cond,c in pairs(map_cond) do | ||
877 | map_op["b"..cond.."_1"] = tohex(0x54000000+c).."B" | ||
878 | end | ||
879 | |||
880 | ------------------------------------------------------------------------------ | ||
881 | |||
882 | -- Handle opcodes defined with template strings. | ||
883 | local function parse_template(params, template, nparams, pos) | ||
884 | local op = tonumber(sub(template, 1, 8), 16) | ||
885 | local n = 1 | ||
886 | local rtt = {} | ||
887 | |||
888 | parse_reg_type = false | ||
889 | |||
890 | -- Process each character. | ||
891 | for p in gmatch(sub(template, 9), ".") do | ||
892 | local q = params[n] | ||
893 | if p == "D" then | ||
894 | op = op + parse_reg(q); n = n + 1 | ||
895 | elseif p == "N" then | ||
896 | op = op + shl(parse_reg(q), 5); n = n + 1 | ||
897 | elseif p == "M" then | ||
898 | op = op + shl(parse_reg(q), 16); n = n + 1 | ||
899 | elseif p == "A" then | ||
900 | op = op + shl(parse_reg(q), 10); n = n + 1 | ||
901 | elseif p == "m" then | ||
902 | op = op + shl(parse_reg(params[n-1]), 16) | ||
903 | |||
904 | elseif p == "p" then | ||
905 | if q == "sp" then params[n] = "@x31" end | ||
906 | elseif p == "g" then | ||
907 | if parse_reg_type == "x" then | ||
908 | op = op + 0x80000000 | ||
909 | elseif parse_reg_type ~= "w" then | ||
910 | werror("bad register type") | ||
911 | end | ||
912 | parse_reg_type = false | ||
913 | elseif p == "f" then | ||
914 | if parse_reg_type == "d" then | ||
915 | op = op + 0x00400000 | ||
916 | elseif parse_reg_type ~= "s" then | ||
917 | werror("bad register type") | ||
918 | end | ||
919 | parse_reg_type = false | ||
920 | elseif p == "x" or p == "w" or p == "d" or p == "s" then | ||
921 | if parse_reg_type ~= p then | ||
922 | werror("register size mismatch") | ||
923 | end | ||
924 | parse_reg_type = false | ||
925 | |||
926 | elseif p == "L" then | ||
927 | op = parse_load(params, nparams, n, op) | ||
928 | elseif p == "P" then | ||
929 | op = parse_load_pair(params, nparams, n, op) | ||
930 | |||
931 | elseif p == "B" then | ||
932 | local mode, v, s = parse_label(q, false); n = n + 1 | ||
933 | local m = branch_type(op) | ||
934 | waction("REL_"..mode, v+m, s, 1) | ||
935 | |||
936 | elseif p == "I" then | ||
937 | op = op + parse_imm12(q); n = n + 1 | ||
938 | elseif p == "i" then | ||
939 | op = op + parse_imm13(q); n = n + 1 | ||
940 | elseif p == "W" then | ||
941 | op = op + parse_imm(q, 16, 5, 0, false); n = n + 1 | ||
942 | elseif p == "T" then | ||
943 | op = op + parse_imm6(q); n = n + 1 | ||
944 | elseif p == "1" then | ||
945 | op = op + parse_imm(q, 6, 16, 0, false); n = n + 1 | ||
946 | elseif p == "2" then | ||
947 | op = op + parse_imm(q, 6, 10, 0, false); n = n + 1 | ||
948 | elseif p == "5" then | ||
949 | op = op + parse_imm(q, 5, 16, 0, false); n = n + 1 | ||
950 | elseif p == "V" then | ||
951 | op = op + parse_imm(q, 4, 0, 0, false); n = n + 1 | ||
952 | elseif p == "F" then | ||
953 | op = op + parse_fpimm(q); n = n + 1 | ||
954 | elseif p == "Z" then | ||
955 | if q ~= "#0" and q ~= "#0.0" then werror("expected zero immediate") end | ||
956 | n = n + 1 | ||
957 | |||
958 | elseif p == "S" then | ||
959 | op = op + parse_shift(q); n = n + 1 | ||
960 | elseif p == "X" then | ||
961 | op = op + parse_extend(q); n = n + 1 | ||
962 | elseif p == "R" then | ||
963 | op = op + parse_lslx16(q); n = n + 1 | ||
964 | elseif p == "C" then | ||
965 | op = op + parse_cond(q, 0); n = n + 1 | ||
966 | elseif p == "c" then | ||
967 | op = op + parse_cond(q, 1); n = n + 1 | ||
968 | |||
969 | else | ||
970 | assert(false) | ||
971 | end | ||
972 | end | ||
973 | wputpos(pos, op) | ||
974 | end | ||
975 | |||
976 | function op_template(params, template, nparams) | ||
977 | if not params then return template:gsub("%x%x%x%x%x%x%x%x", "") end | ||
978 | |||
979 | -- Limit number of section buffer positions used by a single dasm_put(). | ||
980 | -- A single opcode needs a maximum of 3 positions. | ||
981 | if secpos+3 > maxsecpos then wflush() end | ||
982 | local pos = wpos() | ||
983 | local lpos, apos, spos = #actlist, #actargs, secpos | ||
984 | |||
985 | local ok, err | ||
986 | for t in gmatch(template, "[^|]+") do | ||
987 | ok, err = pcall(parse_template, params, t, nparams, pos) | ||
988 | if ok then return end | ||
989 | secpos = spos | ||
990 | actlist[lpos+1] = nil | ||
991 | actlist[lpos+2] = nil | ||
992 | actlist[lpos+3] = nil | ||
993 | actargs[apos+1] = nil | ||
994 | actargs[apos+2] = nil | ||
995 | actargs[apos+3] = nil | ||
996 | end | ||
997 | error(err, 0) | ||
998 | end | ||
999 | |||
1000 | map_op[".template__"] = op_template | ||
1001 | |||
1002 | ------------------------------------------------------------------------------ | ||
1003 | |||
1004 | -- Pseudo-opcode to mark the position where the action list is to be emitted. | ||
1005 | map_op[".actionlist_1"] = function(params) | ||
1006 | if not params then return "cvar" end | ||
1007 | local name = params[1] -- No syntax check. You get to keep the pieces. | ||
1008 | wline(function(out) writeactions(out, name) end) | ||
1009 | end | ||
1010 | |||
1011 | -- Pseudo-opcode to mark the position where the global enum is to be emitted. | ||
1012 | map_op[".globals_1"] = function(params) | ||
1013 | if not params then return "prefix" end | ||
1014 | local prefix = params[1] -- No syntax check. You get to keep the pieces. | ||
1015 | wline(function(out) writeglobals(out, prefix) end) | ||
1016 | end | ||
1017 | |||
1018 | -- Pseudo-opcode to mark the position where the global names are to be emitted. | ||
1019 | map_op[".globalnames_1"] = function(params) | ||
1020 | if not params then return "cvar" end | ||
1021 | local name = params[1] -- No syntax check. You get to keep the pieces. | ||
1022 | wline(function(out) writeglobalnames(out, name) end) | ||
1023 | end | ||
1024 | |||
1025 | -- Pseudo-opcode to mark the position where the extern names are to be emitted. | ||
1026 | map_op[".externnames_1"] = function(params) | ||
1027 | if not params then return "cvar" end | ||
1028 | local name = params[1] -- No syntax check. You get to keep the pieces. | ||
1029 | wline(function(out) writeexternnames(out, name) end) | ||
1030 | end | ||
1031 | |||
1032 | ------------------------------------------------------------------------------ | ||
1033 | |||
1034 | -- Label pseudo-opcode (converted from trailing colon form). | ||
1035 | map_op[".label_1"] = function(params) | ||
1036 | if not params then return "[1-9] | ->global | =>pcexpr" end | ||
1037 | if secpos+1 > maxsecpos then wflush() end | ||
1038 | local mode, n, s = parse_label(params[1], true) | ||
1039 | if mode == "EXT" then werror("bad label definition") end | ||
1040 | waction("LABEL_"..mode, n, s, 1) | ||
1041 | end | ||
1042 | |||
1043 | ------------------------------------------------------------------------------ | ||
1044 | |||
1045 | -- Pseudo-opcodes for data storage. | ||
1046 | map_op[".long_*"] = function(params) | ||
1047 | if not params then return "imm..." end | ||
1048 | for _,p in ipairs(params) do | ||
1049 | local n = tonumber(p) | ||
1050 | if not n then werror("bad immediate `"..p.."'") end | ||
1051 | if n < 0 then n = n + 2^32 end | ||
1052 | wputw(n) | ||
1053 | if secpos+2 > maxsecpos then wflush() end | ||
1054 | end | ||
1055 | end | ||
1056 | |||
1057 | -- Alignment pseudo-opcode. | ||
1058 | map_op[".align_1"] = function(params) | ||
1059 | if not params then return "numpow2" end | ||
1060 | if secpos+1 > maxsecpos then wflush() end | ||
1061 | local align = tonumber(params[1]) | ||
1062 | if align then | ||
1063 | local x = align | ||
1064 | -- Must be a power of 2 in the range (2 ... 256). | ||
1065 | for i=1,8 do | ||
1066 | x = x / 2 | ||
1067 | if x == 1 then | ||
1068 | waction("ALIGN", align-1, nil, 1) -- Action byte is 2**n-1. | ||
1069 | return | ||
1070 | end | ||
1071 | end | ||
1072 | end | ||
1073 | werror("bad alignment") | ||
1074 | end | ||
1075 | |||
1076 | ------------------------------------------------------------------------------ | ||
1077 | |||
1078 | -- Pseudo-opcode for (primitive) type definitions (map to C types). | ||
1079 | map_op[".type_3"] = function(params, nparams) | ||
1080 | if not params then | ||
1081 | return nparams == 2 and "name, ctype" or "name, ctype, reg" | ||
1082 | end | ||
1083 | local name, ctype, reg = params[1], params[2], params[3] | ||
1084 | if not match(name, "^[%a_][%w_]*$") then | ||
1085 | werror("bad type name `"..name.."'") | ||
1086 | end | ||
1087 | local tp = map_type[name] | ||
1088 | if tp then | ||
1089 | werror("duplicate type `"..name.."'") | ||
1090 | end | ||
1091 | -- Add #type to defines. A bit unclean to put it in map_archdef. | ||
1092 | map_archdef["#"..name] = "sizeof("..ctype..")" | ||
1093 | -- Add new type and emit shortcut define. | ||
1094 | local num = ctypenum + 1 | ||
1095 | map_type[name] = { | ||
1096 | ctype = ctype, | ||
1097 | ctypefmt = format("Dt%X(%%s)", num), | ||
1098 | reg = reg, | ||
1099 | } | ||
1100 | wline(format("#define Dt%X(_V) (int)(ptrdiff_t)&(((%s *)0)_V)", num, ctype)) | ||
1101 | ctypenum = num | ||
1102 | end | ||
1103 | map_op[".type_2"] = map_op[".type_3"] | ||
1104 | |||
1105 | -- Dump type definitions. | ||
1106 | local function dumptypes(out, lvl) | ||
1107 | local t = {} | ||
1108 | for name in pairs(map_type) do t[#t+1] = name end | ||
1109 | sort(t) | ||
1110 | out:write("Type definitions:\n") | ||
1111 | for _,name in ipairs(t) do | ||
1112 | local tp = map_type[name] | ||
1113 | local reg = tp.reg or "" | ||
1114 | out:write(format(" %-20s %-20s %s\n", name, tp.ctype, reg)) | ||
1115 | end | ||
1116 | out:write("\n") | ||
1117 | end | ||
1118 | |||
1119 | ------------------------------------------------------------------------------ | ||
1120 | |||
1121 | -- Set the current section. | ||
1122 | function _M.section(num) | ||
1123 | waction("SECTION", num) | ||
1124 | wflush(true) -- SECTION is a terminal action. | ||
1125 | end | ||
1126 | |||
1127 | ------------------------------------------------------------------------------ | ||
1128 | |||
1129 | -- Dump architecture description. | ||
1130 | function _M.dumparch(out) | ||
1131 | out:write(format("DynASM %s version %s, released %s\n\n", | ||
1132 | _info.arch, _info.version, _info.release)) | ||
1133 | dumpactions(out) | ||
1134 | end | ||
1135 | |||
1136 | -- Dump all user defined elements. | ||
1137 | function _M.dumpdef(out, lvl) | ||
1138 | dumptypes(out, lvl) | ||
1139 | dumpglobals(out, lvl) | ||
1140 | dumpexterns(out, lvl) | ||
1141 | end | ||
1142 | |||
1143 | ------------------------------------------------------------------------------ | ||
1144 | |||
1145 | -- Pass callbacks from/to the DynASM core. | ||
1146 | function _M.passcb(wl, we, wf, ww) | ||
1147 | wline, werror, wfatal, wwarn = wl, we, wf, ww | ||
1148 | return wflush | ||
1149 | end | ||
1150 | |||
1151 | -- Setup the arch-specific module. | ||
1152 | function _M.setup(arch, opt) | ||
1153 | g_arch, g_opt = arch, opt | ||
1154 | end | ||
1155 | |||
1156 | -- Merge the core maps and the arch-specific maps. | ||
1157 | function _M.mergemaps(map_coreop, map_def) | ||
1158 | setmetatable(map_op, { __index = map_coreop }) | ||
1159 | setmetatable(map_def, { __index = map_archdef }) | ||
1160 | return map_op, map_def | ||
1161 | end | ||
1162 | |||
1163 | return _M | ||
1164 | |||
1165 | ------------------------------------------------------------------------------ | ||
1166 | |||
diff --git a/dynasm/dasm_ppc.h b/dynasm/dasm_ppc.h index 7df49365..2ded2580 100644 --- a/dynasm/dasm_ppc.h +++ b/dynasm/dasm_ppc.h | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | ** DynASM PPC encoding engine. | 2 | ** DynASM PPC/PPC64 encoding engine. |
3 | ** Copyright (C) 2005-2015 Mike Pall. All rights reserved. | 3 | ** Copyright (C) 2005-2015 Mike Pall. All rights reserved. |
4 | ** Released under the MIT license. See dynasm.lua for full copyright notice. | 4 | ** Released under the MIT license. See dynasm.lua for full copyright notice. |
5 | */ | 5 | */ |
diff --git a/dynasm/dasm_ppc.lua b/dynasm/dasm_ppc.lua index 91f4ff9a..37447072 100644 --- a/dynasm/dasm_ppc.lua +++ b/dynasm/dasm_ppc.lua | |||
@@ -1,8 +1,10 @@ | |||
1 | ------------------------------------------------------------------------------ | 1 | ------------------------------------------------------------------------------ |
2 | -- DynASM PPC module. | 2 | -- DynASM PPC/PPC64 module. |
3 | -- | 3 | -- |
4 | -- Copyright (C) 2005-2015 Mike Pall. All rights reserved. | 4 | -- Copyright (C) 2005-2015 Mike Pall. All rights reserved. |
5 | -- See dynasm.lua for full copyright notice. | 5 | -- See dynasm.lua for full copyright notice. |
6 | -- | ||
7 | -- Support for various extensions contributed by Caio Souza Oliveira. | ||
6 | ------------------------------------------------------------------------------ | 8 | ------------------------------------------------------------------------------ |
7 | 9 | ||
8 | -- Module information: | 10 | -- Module information: |
@@ -11,7 +13,7 @@ local _info = { | |||
11 | description = "DynASM PPC module", | 13 | description = "DynASM PPC module", |
12 | version = "1.3.0", | 14 | version = "1.3.0", |
13 | vernum = 10300, | 15 | vernum = 10300, |
14 | release = "2011-05-05", | 16 | release = "2015-01-14", |
15 | author = "Mike Pall", | 17 | author = "Mike Pall", |
16 | license = "MIT", | 18 | license = "MIT", |
17 | } | 19 | } |
@@ -297,6 +299,223 @@ local map_op = { | |||
297 | std_2 = "f8000000RD", | 299 | std_2 = "f8000000RD", |
298 | stdu_2 = "f8000001RD", | 300 | stdu_2 = "f8000001RD", |
299 | 301 | ||
302 | -- Primary opcode 4: | ||
303 | mulhhwu_3 = "10000010RRR.", | ||
304 | machhwu_3 = "10000018RRR.", | ||
305 | mulhhw_3 = "10000050RRR.", | ||
306 | nmachhw_3 = "1000005cRRR.", | ||
307 | machhwsu_3 = "10000098RRR.", | ||
308 | machhws_3 = "100000d8RRR.", | ||
309 | nmachhws_3 = "100000dcRRR.", | ||
310 | mulchwu_3 = "10000110RRR.", | ||
311 | macchwu_3 = "10000118RRR.", | ||
312 | mulchw_3 = "10000150RRR.", | ||
313 | macchw_3 = "10000158RRR.", | ||
314 | nmacchw_3 = "1000015cRRR.", | ||
315 | macchwsu_3 = "10000198RRR.", | ||
316 | macchws_3 = "100001d8RRR.", | ||
317 | nmacchws_3 = "100001dcRRR.", | ||
318 | mullhw_3 = "10000350RRR.", | ||
319 | maclhw_3 = "10000358RRR.", | ||
320 | nmaclhw_3 = "1000035cRRR.", | ||
321 | maclhwsu_3 = "10000398RRR.", | ||
322 | maclhws_3 = "100003d8RRR.", | ||
323 | nmaclhws_3 = "100003dcRRR.", | ||
324 | machhwuo_3 = "10000418RRR.", | ||
325 | nmachhwo_3 = "1000045cRRR.", | ||
326 | machhwsuo_3 = "10000498RRR.", | ||
327 | machhwso_3 = "100004d8RRR.", | ||
328 | nmachhwso_3 = "100004dcRRR.", | ||
329 | macchwuo_3 = "10000518RRR.", | ||
330 | macchwo_3 = "10000558RRR.", | ||
331 | nmacchwo_3 = "1000055cRRR.", | ||
332 | macchwsuo_3 = "10000598RRR.", | ||
333 | macchwso_3 = "100005d8RRR.", | ||
334 | nmacchwso_3 = "100005dcRRR.", | ||
335 | maclhwo_3 = "10000758RRR.", | ||
336 | nmaclhwo_3 = "1000075cRRR.", | ||
337 | maclhwsuo_3 = "10000798RRR.", | ||
338 | maclhwso_3 = "100007d8RRR.", | ||
339 | nmaclhwso_3 = "100007dcRRR.", | ||
340 | |||
341 | vaddubm_3 = "10000000VVV", | ||
342 | vmaxub_3 = "10000002VVV", | ||
343 | vrlb_3 = "10000004VVV", | ||
344 | vcmpequb_3 = "10000006VVV", | ||
345 | vmuloub_3 = "10000008VVV", | ||
346 | vaddfp_3 = "1000000aVVV", | ||
347 | vmrghb_3 = "1000000cVVV", | ||
348 | vpkuhum_3 = "1000000eVVV", | ||
349 | vmhaddshs_4 = "10000020VVVV", | ||
350 | vmhraddshs_4 = "10000021VVVV", | ||
351 | vmladduhm_4 = "10000022VVVV", | ||
352 | vmsumubm_4 = "10000024VVVV", | ||
353 | vmsummbm_4 = "10000025VVVV", | ||
354 | vmsumuhm_4 = "10000026VVVV", | ||
355 | vmsumuhs_4 = "10000027VVVV", | ||
356 | vmsumshm_4 = "10000028VVVV", | ||
357 | vmsumshs_4 = "10000029VVVV", | ||
358 | vsel_4 = "1000002aVVVV", | ||
359 | vperm_4 = "1000002bVVVV", | ||
360 | vsldoi_4 = "1000002cVVVP", | ||
361 | vpermxor_4 = "1000002dVVVV", | ||
362 | vmaddfp_4 = "1000002eVVVV~", | ||
363 | vnmsubfp_4 = "1000002fVVVV~", | ||
364 | vaddeuqm_4 = "1000003cVVVV", | ||
365 | vaddecuq_4 = "1000003dVVVV", | ||
366 | vsubeuqm_4 = "1000003eVVVV", | ||
367 | vsubecuq_4 = "1000003fVVVV", | ||
368 | vadduhm_3 = "10000040VVV", | ||
369 | vmaxuh_3 = "10000042VVV", | ||
370 | vrlh_3 = "10000044VVV", | ||
371 | vcmpequh_3 = "10000046VVV", | ||
372 | vmulouh_3 = "10000048VVV", | ||
373 | vsubfp_3 = "1000004aVVV", | ||
374 | vmrghh_3 = "1000004cVVV", | ||
375 | vpkuwum_3 = "1000004eVVV", | ||
376 | vadduwm_3 = "10000080VVV", | ||
377 | vmaxuw_3 = "10000082VVV", | ||
378 | vrlw_3 = "10000084VVV", | ||
379 | vcmpequw_3 = "10000086VVV", | ||
380 | vmulouw_3 = "10000088VVV", | ||
381 | vmuluwm_3 = "10000089VVV", | ||
382 | vmrghw_3 = "1000008cVVV", | ||
383 | vpkuhus_3 = "1000008eVVV", | ||
384 | vaddudm_3 = "100000c0VVV", | ||
385 | vmaxud_3 = "100000c2VVV", | ||
386 | vrld_3 = "100000c4VVV", | ||
387 | vcmpeqfp_3 = "100000c6VVV", | ||
388 | vcmpequd_3 = "100000c7VVV", | ||
389 | vpkuwus_3 = "100000ceVVV", | ||
390 | vadduqm_3 = "10000100VVV", | ||
391 | vmaxsb_3 = "10000102VVV", | ||
392 | vslb_3 = "10000104VVV", | ||
393 | vmulosb_3 = "10000108VVV", | ||
394 | vrefp_2 = "1000010aV-V", | ||
395 | vmrglb_3 = "1000010cVVV", | ||
396 | vpkshus_3 = "1000010eVVV", | ||
397 | vaddcuq_3 = "10000140VVV", | ||
398 | vmaxsh_3 = "10000142VVV", | ||
399 | vslh_3 = "10000144VVV", | ||
400 | vmulosh_3 = "10000148VVV", | ||
401 | vrsqrtefp_2 = "1000014aV-V", | ||
402 | vmrglh_3 = "1000014cVVV", | ||
403 | vpkswus_3 = "1000014eVVV", | ||
404 | vaddcuw_3 = "10000180VVV", | ||
405 | vmaxsw_3 = "10000182VVV", | ||
406 | vslw_3 = "10000184VVV", | ||
407 | vmulosw_3 = "10000188VVV", | ||
408 | vexptefp_2 = "1000018aV-V", | ||
409 | vmrglw_3 = "1000018cVVV", | ||
410 | vpkshss_3 = "1000018eVVV", | ||
411 | vmaxsd_3 = "100001c2VVV", | ||
412 | vsl_3 = "100001c4VVV", | ||
413 | vcmpgefp_3 = "100001c6VVV", | ||
414 | vlogefp_2 = "100001caV-V", | ||
415 | vpkswss_3 = "100001ceVVV", | ||
416 | vadduhs_3 = "10000240VVV", | ||
417 | vminuh_3 = "10000242VVV", | ||
418 | vsrh_3 = "10000244VVV", | ||
419 | vcmpgtuh_3 = "10000246VVV", | ||
420 | vmuleuh_3 = "10000248VVV", | ||
421 | vrfiz_2 = "1000024aV-V", | ||
422 | vsplth_3 = "1000024cVV3", | ||
423 | vupkhsh_2 = "1000024eV-V", | ||
424 | vminuw_3 = "10000282VVV", | ||
425 | vminud_3 = "100002c2VVV", | ||
426 | vcmpgtud_3 = "100002c7VVV", | ||
427 | vrfim_2 = "100002caV-V", | ||
428 | vcmpgtsb_3 = "10000306VVV", | ||
429 | vcfux_3 = "1000030aVVA~", | ||
430 | vaddshs_3 = "10000340VVV", | ||
431 | vminsh_3 = "10000342VVV", | ||
432 | vsrah_3 = "10000344VVV", | ||
433 | vcmpgtsh_3 = "10000346VVV", | ||
434 | vmulesh_3 = "10000348VVV", | ||
435 | vcfsx_3 = "1000034aVVA~", | ||
436 | vspltish_2 = "1000034cVS", | ||
437 | vupkhpx_2 = "1000034eV-V", | ||
438 | vaddsws_3 = "10000380VVV", | ||
439 | vminsw_3 = "10000382VVV", | ||
440 | vsraw_3 = "10000384VVV", | ||
441 | vcmpgtsw_3 = "10000386VVV", | ||
442 | vmulesw_3 = "10000388VVV", | ||
443 | vctuxs_3 = "1000038aVVA~", | ||
444 | vspltisw_2 = "1000038cVS", | ||
445 | vminsd_3 = "100003c2VVV", | ||
446 | vsrad_3 = "100003c4VVV", | ||
447 | vcmpbfp_3 = "100003c6VVV", | ||
448 | vcmpgtsd_3 = "100003c7VVV", | ||
449 | vctsxs_3 = "100003caVVA~", | ||
450 | vupklpx_2 = "100003ceV-V", | ||
451 | vsububm_3 = "10000400VVV", | ||
452 | ["bcdadd._4"] = "10000401VVVy.", | ||
453 | vavgub_3 = "10000402VVV", | ||
454 | vand_3 = "10000404VVV", | ||
455 | ["vcmpequb._3"] = "10000406VVV", | ||
456 | vmaxfp_3 = "1000040aVVV", | ||
457 | vsubuhm_3 = "10000440VVV", | ||
458 | ["bcdsub._4"] = "10000441VVVy.", | ||
459 | vavguh_3 = "10000442VVV", | ||
460 | vandc_3 = "10000444VVV", | ||
461 | ["vcmpequh._3"] = "10000446VVV", | ||
462 | vminfp_3 = "1000044aVVV", | ||
463 | vpkudum_3 = "1000044eVVV", | ||
464 | vsubuwm_3 = "10000480VVV", | ||
465 | vavguw_3 = "10000482VVV", | ||
466 | vor_3 = "10000484VVV", | ||
467 | ["vcmpequw._3"] = "10000486VVV", | ||
468 | vpmsumw_3 = "10000488VVV", | ||
469 | ["vcmpeqfp._3"] = "100004c6VVV", | ||
470 | ["vcmpequd._3"] = "100004c7VVV", | ||
471 | vpkudus_3 = "100004ceVVV", | ||
472 | vavgsb_3 = "10000502VVV", | ||
473 | vavgsh_3 = "10000542VVV", | ||
474 | vorc_3 = "10000544VVV", | ||
475 | vbpermq_3 = "1000054cVVV", | ||
476 | vpksdus_3 = "1000054eVVV", | ||
477 | vavgsw_3 = "10000582VVV", | ||
478 | vsld_3 = "100005c4VVV", | ||
479 | ["vcmpgefp._3"] = "100005c6VVV", | ||
480 | vpksdss_3 = "100005ceVVV", | ||
481 | vsububs_3 = "10000600VVV", | ||
482 | mfvscr_1 = "10000604V--", | ||
483 | vsum4ubs_3 = "10000608VVV", | ||
484 | vsubuhs_3 = "10000640VVV", | ||
485 | mtvscr_1 = "10000644--V", | ||
486 | ["vcmpgtuh._3"] = "10000646VVV", | ||
487 | vsum4shs_3 = "10000648VVV", | ||
488 | vupkhsw_2 = "1000064eV-V", | ||
489 | vsubuws_3 = "10000680VVV", | ||
490 | vshasigmaw_4 = "10000682VVYp", | ||
491 | veqv_3 = "10000684VVV", | ||
492 | vsum2sws_3 = "10000688VVV", | ||
493 | vmrgow_3 = "1000068cVVV", | ||
494 | vshasigmad_4 = "100006c2VVYp", | ||
495 | vsrd_3 = "100006c4VVV", | ||
496 | ["vcmpgtud._3"] = "100006c7VVV", | ||
497 | vupklsw_2 = "100006ceV-V", | ||
498 | vupkslw_2 = "100006ceV-V", | ||
499 | vsubsbs_3 = "10000700VVV", | ||
500 | vclzb_2 = "10000702V-V", | ||
501 | vpopcntb_2 = "10000703V-V", | ||
502 | ["vcmpgtsb._3"] = "10000706VVV", | ||
503 | vsum4sbs_3 = "10000708VVV", | ||
504 | vsubshs_3 = "10000740VVV", | ||
505 | vclzh_2 = "10000742V-V", | ||
506 | vpopcnth_2 = "10000743V-V", | ||
507 | ["vcmpgtsh._3"] = "10000746VVV", | ||
508 | vsubsws_3 = "10000780VVV", | ||
509 | vclzw_2 = "10000782V-V", | ||
510 | vpopcntw_2 = "10000783V-V", | ||
511 | ["vcmpgtsw._3"] = "10000786VVV", | ||
512 | vsumsws_3 = "10000788VVV", | ||
513 | vmrgew_3 = "1000078cVVV", | ||
514 | vclzd_2 = "100007c2V-V", | ||
515 | vpopcntd_2 = "100007c3V-V", | ||
516 | ["vcmpbfp._3"] = "100007c6VVV", | ||
517 | ["vcmpgtsd._3"] = "100007c7VVV", | ||
518 | |||
300 | -- Primary opcode 19: | 519 | -- Primary opcode 19: |
301 | mcrf_2 = "4c000000XX", | 520 | mcrf_2 = "4c000000XX", |
302 | isync_0 = "4c00012c", | 521 | isync_0 = "4c00012c", |
@@ -316,6 +535,8 @@ local map_op = { | |||
316 | bclrl_2 = "4c000021AA", | 535 | bclrl_2 = "4c000021AA", |
317 | bcctr_2 = "4c000420AA", | 536 | bcctr_2 = "4c000420AA", |
318 | bcctrl_2 = "4c000421AA", | 537 | bcctrl_2 = "4c000421AA", |
538 | bctar_2 = "4c000460AA", | ||
539 | bctarl_2 = "4c000461AA", | ||
319 | blr_0 = "4e800020", | 540 | blr_0 = "4e800020", |
320 | blrl_0 = "4e800021", | 541 | blrl_0 = "4e800021", |
321 | bctr_0 = "4e800420", | 542 | bctr_0 = "4e800420", |
@@ -327,6 +548,7 @@ local map_op = { | |||
327 | cmpd_3 = "7c200000XRR", | 548 | cmpd_3 = "7c200000XRR", |
328 | cmpd_2 = "7c200000-RR", | 549 | cmpd_2 = "7c200000-RR", |
329 | tw_3 = "7c000008ARR", | 550 | tw_3 = "7c000008ARR", |
551 | lvsl_3 = "7c00000cVRR", | ||
330 | subfc_3 = "7c000010RRR.", | 552 | subfc_3 = "7c000010RRR.", |
331 | subc_3 = "7c000010RRR~.", | 553 | subc_3 = "7c000010RRR~.", |
332 | mulhdu_3 = "7c000012RRR.", | 554 | mulhdu_3 = "7c000012RRR.", |
@@ -351,50 +573,68 @@ local map_op = { | |||
351 | cmplw_2 = "7c000040-RR", | 573 | cmplw_2 = "7c000040-RR", |
352 | cmpld_3 = "7c200040XRR", | 574 | cmpld_3 = "7c200040XRR", |
353 | cmpld_2 = "7c200040-RR", | 575 | cmpld_2 = "7c200040-RR", |
576 | lvsr_3 = "7c00004cVRR", | ||
354 | subf_3 = "7c000050RRR.", | 577 | subf_3 = "7c000050RRR.", |
355 | sub_3 = "7c000050RRR~.", | 578 | sub_3 = "7c000050RRR~.", |
579 | lbarx_3 = "7c000068RR0R", | ||
356 | ldux_3 = "7c00006aRR0R", | 580 | ldux_3 = "7c00006aRR0R", |
357 | dcbst_2 = "7c00006c-RR", | 581 | dcbst_2 = "7c00006c-RR", |
358 | lwzux_3 = "7c00006eRR0R", | 582 | lwzux_3 = "7c00006eRR0R", |
359 | cntlzd_2 = "7c000074RR~", | 583 | cntlzd_2 = "7c000074RR~", |
360 | andc_3 = "7c000078RR~R.", | 584 | andc_3 = "7c000078RR~R.", |
361 | td_3 = "7c000088ARR", | 585 | td_3 = "7c000088ARR", |
586 | lvewx_3 = "7c00008eVRR", | ||
362 | mulhd_3 = "7c000092RRR.", | 587 | mulhd_3 = "7c000092RRR.", |
588 | addg6s_3 = "7c000094RRR", | ||
363 | mulhw_3 = "7c000096RRR.", | 589 | mulhw_3 = "7c000096RRR.", |
590 | dlmzb_3 = "7c00009cRR~R.", | ||
364 | ldarx_3 = "7c0000a8RR0R", | 591 | ldarx_3 = "7c0000a8RR0R", |
365 | dcbf_2 = "7c0000ac-RR", | 592 | dcbf_2 = "7c0000ac-RR", |
366 | lbzx_3 = "7c0000aeRR0R", | 593 | lbzx_3 = "7c0000aeRR0R", |
594 | lvx_3 = "7c0000ceVRR", | ||
367 | neg_2 = "7c0000d0RR.", | 595 | neg_2 = "7c0000d0RR.", |
596 | lharx_3 = "7c0000e8RR0R", | ||
368 | lbzux_3 = "7c0000eeRR0R", | 597 | lbzux_3 = "7c0000eeRR0R", |
369 | popcntb_2 = "7c0000f4RR~", | 598 | popcntb_2 = "7c0000f4RR~", |
370 | not_2 = "7c0000f8RR~%.", | 599 | not_2 = "7c0000f8RR~%.", |
371 | nor_3 = "7c0000f8RR~R.", | 600 | nor_3 = "7c0000f8RR~R.", |
601 | stvebx_3 = "7c00010eVRR", | ||
372 | subfe_3 = "7c000110RRR.", | 602 | subfe_3 = "7c000110RRR.", |
373 | sube_3 = "7c000110RRR~.", | 603 | sube_3 = "7c000110RRR~.", |
374 | adde_3 = "7c000114RRR.", | 604 | adde_3 = "7c000114RRR.", |
375 | stdx_3 = "7c00012aRR0R", | 605 | stdx_3 = "7c00012aRR0R", |
376 | stwcx_3 = "7c00012cRR0R.", | 606 | ["stwcx._3"] = "7c00012dRR0R.", |
377 | stwx_3 = "7c00012eRR0R", | 607 | stwx_3 = "7c00012eRR0R", |
378 | prtyw_2 = "7c000134RR~", | 608 | prtyw_2 = "7c000134RR~", |
609 | stvehx_3 = "7c00014eVRR", | ||
379 | stdux_3 = "7c00016aRR0R", | 610 | stdux_3 = "7c00016aRR0R", |
611 | ["stqcx._3"] = "7c00016dR:R0R.", | ||
380 | stwux_3 = "7c00016eRR0R", | 612 | stwux_3 = "7c00016eRR0R", |
381 | prtyd_2 = "7c000174RR~", | 613 | prtyd_2 = "7c000174RR~", |
614 | stvewx_3 = "7c00018eVRR", | ||
382 | subfze_2 = "7c000190RR.", | 615 | subfze_2 = "7c000190RR.", |
383 | addze_2 = "7c000194RR.", | 616 | addze_2 = "7c000194RR.", |
384 | stdcx_3 = "7c0001acRR0R.", | 617 | ["stdcx._3"] = "7c0001adRR0R.", |
385 | stbx_3 = "7c0001aeRR0R", | 618 | stbx_3 = "7c0001aeRR0R", |
619 | stvx_3 = "7c0001ceVRR", | ||
386 | subfme_2 = "7c0001d0RR.", | 620 | subfme_2 = "7c0001d0RR.", |
387 | mulld_3 = "7c0001d2RRR.", | 621 | mulld_3 = "7c0001d2RRR.", |
388 | addme_2 = "7c0001d4RR.", | 622 | addme_2 = "7c0001d4RR.", |
389 | mullw_3 = "7c0001d6RRR.", | 623 | mullw_3 = "7c0001d6RRR.", |
390 | dcbtst_2 = "7c0001ec-RR", | 624 | dcbtst_2 = "7c0001ec-RR", |
391 | stbux_3 = "7c0001eeRR0R", | 625 | stbux_3 = "7c0001eeRR0R", |
626 | bpermd_3 = "7c0001f8RR~R", | ||
627 | lvepxl_3 = "7c00020eVRR", | ||
392 | add_3 = "7c000214RRR.", | 628 | add_3 = "7c000214RRR.", |
629 | lqarx_3 = "7c000228R:R0R", | ||
393 | dcbt_2 = "7c00022c-RR", | 630 | dcbt_2 = "7c00022c-RR", |
394 | lhzx_3 = "7c00022eRR0R", | 631 | lhzx_3 = "7c00022eRR0R", |
632 | cdtbcd_2 = "7c000234RR~", | ||
395 | eqv_3 = "7c000238RR~R.", | 633 | eqv_3 = "7c000238RR~R.", |
634 | lvepx_3 = "7c00024eVRR", | ||
396 | eciwx_3 = "7c00026cRR0R", | 635 | eciwx_3 = "7c00026cRR0R", |
397 | lhzux_3 = "7c00026eRR0R", | 636 | lhzux_3 = "7c00026eRR0R", |
637 | cbcdtd_2 = "7c000274RR~", | ||
398 | xor_3 = "7c000278RR~R.", | 638 | xor_3 = "7c000278RR~R.", |
399 | mfspefscr_1 = "7c0082a6R", | 639 | mfspefscr_1 = "7c0082a6R", |
400 | mfxer_1 = "7c0102a6R", | 640 | mfxer_1 = "7c0102a6R", |
@@ -404,8 +644,12 @@ local map_op = { | |||
404 | lhax_3 = "7c0002aeRR0R", | 644 | lhax_3 = "7c0002aeRR0R", |
405 | mftb_1 = "7c0c42e6R", | 645 | mftb_1 = "7c0c42e6R", |
406 | mftbu_1 = "7c0d42e6R", | 646 | mftbu_1 = "7c0d42e6R", |
647 | lvxl_3 = "7c0002ceVRR", | ||
407 | lwaux_3 = "7c0002eaRR0R", | 648 | lwaux_3 = "7c0002eaRR0R", |
408 | lhaux_3 = "7c0002eeRR0R", | 649 | lhaux_3 = "7c0002eeRR0R", |
650 | popcntw_2 = "7c0002f4RR~", | ||
651 | divdeu_3 = "7c000312RRR.", | ||
652 | divweu_3 = "7c000316RRR.", | ||
409 | sthx_3 = "7c00032eRR0R", | 653 | sthx_3 = "7c00032eRR0R", |
410 | orc_3 = "7c000338RR~R.", | 654 | orc_3 = "7c000338RR~R.", |
411 | ecowx_3 = "7c00036cRR0R", | 655 | ecowx_3 = "7c00036cRR0R", |
@@ -420,10 +664,14 @@ local map_op = { | |||
420 | mtctr_1 = "7c0903a6R", | 664 | mtctr_1 = "7c0903a6R", |
421 | dcbi_2 = "7c0003ac-RR", | 665 | dcbi_2 = "7c0003ac-RR", |
422 | nand_3 = "7c0003b8RR~R.", | 666 | nand_3 = "7c0003b8RR~R.", |
667 | dsn_2 = "7c0003c6-RR", | ||
668 | stvxl_3 = "7c0003ceVRR", | ||
423 | divd_3 = "7c0003d2RRR.", | 669 | divd_3 = "7c0003d2RRR.", |
424 | divw_3 = "7c0003d6RRR.", | 670 | divw_3 = "7c0003d6RRR.", |
671 | popcntd_2 = "7c0003f4RR~", | ||
425 | cmpb_3 = "7c0003f8RR~R.", | 672 | cmpb_3 = "7c0003f8RR~R.", |
426 | mcrxr_1 = "7c000400X", | 673 | mcrxr_1 = "7c000400X", |
674 | lbdx_3 = "7c000406RRR", | ||
427 | subfco_3 = "7c000410RRR.", | 675 | subfco_3 = "7c000410RRR.", |
428 | subco_3 = "7c000410RRR~.", | 676 | subco_3 = "7c000410RRR~.", |
429 | addco_3 = "7c000414RRR.", | 677 | addco_3 = "7c000414RRR.", |
@@ -433,16 +681,20 @@ local map_op = { | |||
433 | lfsx_3 = "7c00042eFR0R", | 681 | lfsx_3 = "7c00042eFR0R", |
434 | srw_3 = "7c000430RR~R.", | 682 | srw_3 = "7c000430RR~R.", |
435 | srd_3 = "7c000436RR~R.", | 683 | srd_3 = "7c000436RR~R.", |
684 | lhdx_3 = "7c000446RRR", | ||
436 | subfo_3 = "7c000450RRR.", | 685 | subfo_3 = "7c000450RRR.", |
437 | subo_3 = "7c000450RRR~.", | 686 | subo_3 = "7c000450RRR~.", |
438 | lfsux_3 = "7c00046eFR0R", | 687 | lfsux_3 = "7c00046eFR0R", |
688 | lwdx_3 = "7c000486RRR", | ||
439 | lswi_3 = "7c0004aaRR0A", | 689 | lswi_3 = "7c0004aaRR0A", |
440 | sync_0 = "7c0004ac", | 690 | sync_0 = "7c0004ac", |
441 | lwsync_0 = "7c2004ac", | 691 | lwsync_0 = "7c2004ac", |
442 | ptesync_0 = "7c4004ac", | 692 | ptesync_0 = "7c4004ac", |
443 | lfdx_3 = "7c0004aeFR0R", | 693 | lfdx_3 = "7c0004aeFR0R", |
694 | lddx_3 = "7c0004c6RRR", | ||
444 | nego_2 = "7c0004d0RR.", | 695 | nego_2 = "7c0004d0RR.", |
445 | lfdux_3 = "7c0004eeFR0R", | 696 | lfdux_3 = "7c0004eeFR0R", |
697 | stbdx_3 = "7c000506RRR", | ||
446 | subfeo_3 = "7c000510RRR.", | 698 | subfeo_3 = "7c000510RRR.", |
447 | subeo_3 = "7c000510RRR~.", | 699 | subeo_3 = "7c000510RRR~.", |
448 | addeo_3 = "7c000514RRR.", | 700 | addeo_3 = "7c000514RRR.", |
@@ -450,27 +702,42 @@ local map_op = { | |||
450 | stswx_3 = "7c00052aRR0R", | 702 | stswx_3 = "7c00052aRR0R", |
451 | stwbrx_3 = "7c00052cRR0R", | 703 | stwbrx_3 = "7c00052cRR0R", |
452 | stfsx_3 = "7c00052eFR0R", | 704 | stfsx_3 = "7c00052eFR0R", |
705 | sthdx_3 = "7c000546RRR", | ||
706 | ["stbcx._3"] = "7c00056dRRR", | ||
453 | stfsux_3 = "7c00056eFR0R", | 707 | stfsux_3 = "7c00056eFR0R", |
708 | stwdx_3 = "7c000586RRR", | ||
454 | subfzeo_2 = "7c000590RR.", | 709 | subfzeo_2 = "7c000590RR.", |
455 | addzeo_2 = "7c000594RR.", | 710 | addzeo_2 = "7c000594RR.", |
456 | stswi_3 = "7c0005aaRR0A", | 711 | stswi_3 = "7c0005aaRR0A", |
712 | ["sthcx._3"] = "7c0005adRRR", | ||
457 | stfdx_3 = "7c0005aeFR0R", | 713 | stfdx_3 = "7c0005aeFR0R", |
714 | stddx_3 = "7c0005c6RRR", | ||
458 | subfmeo_2 = "7c0005d0RR.", | 715 | subfmeo_2 = "7c0005d0RR.", |
459 | mulldo_3 = "7c0005d2RRR.", | 716 | mulldo_3 = "7c0005d2RRR.", |
460 | addmeo_2 = "7c0005d4RR.", | 717 | addmeo_2 = "7c0005d4RR.", |
461 | mullwo_3 = "7c0005d6RRR.", | 718 | mullwo_3 = "7c0005d6RRR.", |
462 | dcba_2 = "7c0005ec-RR", | 719 | dcba_2 = "7c0005ec-RR", |
463 | stfdux_3 = "7c0005eeFR0R", | 720 | stfdux_3 = "7c0005eeFR0R", |
721 | stvepxl_3 = "7c00060eVRR", | ||
464 | addo_3 = "7c000614RRR.", | 722 | addo_3 = "7c000614RRR.", |
465 | lhbrx_3 = "7c00062cRR0R", | 723 | lhbrx_3 = "7c00062cRR0R", |
724 | lfdpx_3 = "7c00062eF:RR", | ||
466 | sraw_3 = "7c000630RR~R.", | 725 | sraw_3 = "7c000630RR~R.", |
467 | srad_3 = "7c000634RR~R.", | 726 | srad_3 = "7c000634RR~R.", |
727 | lfddx_3 = "7c000646FRR", | ||
728 | stvepx_3 = "7c00064eVRR", | ||
468 | srawi_3 = "7c000670RR~A.", | 729 | srawi_3 = "7c000670RR~A.", |
469 | sradi_3 = "7c000674RR~H.", | 730 | sradi_3 = "7c000674RR~H.", |
470 | eieio_0 = "7c0006ac", | 731 | eieio_0 = "7c0006ac", |
471 | lfiwax_3 = "7c0006aeFR0R", | 732 | lfiwax_3 = "7c0006aeFR0R", |
733 | divdeuo_3 = "7c000712RRR.", | ||
734 | divweuo_3 = "7c000716RRR.", | ||
472 | sthbrx_3 = "7c00072cRR0R", | 735 | sthbrx_3 = "7c00072cRR0R", |
736 | stfdpx_3 = "7c00072eF:RR", | ||
473 | extsh_2 = "7c000734RR~.", | 737 | extsh_2 = "7c000734RR~.", |
738 | stfddx_3 = "7c000746FRR", | ||
739 | divdeo_3 = "7c000752RRR.", | ||
740 | divweo_3 = "7c000756RRR.", | ||
474 | extsb_2 = "7c000774RR~.", | 741 | extsb_2 = "7c000774RR~.", |
475 | divduo_3 = "7c000792RRR.", | 742 | divduo_3 = "7c000792RRR.", |
476 | divwou_3 = "7c000796RRR.", | 743 | divwou_3 = "7c000796RRR.", |
@@ -481,6 +748,40 @@ local map_op = { | |||
481 | divwo_3 = "7c0007d6RRR.", | 748 | divwo_3 = "7c0007d6RRR.", |
482 | dcbz_2 = "7c0007ec-RR", | 749 | dcbz_2 = "7c0007ec-RR", |
483 | 750 | ||
751 | ["tbegin._1"] = "7c00051d1", | ||
752 | ["tbegin._0"] = "7c00051d", | ||
753 | ["tend._1"] = "7c00055dY", | ||
754 | ["tend._0"] = "7c00055d", | ||
755 | ["tendall._0"] = "7e00055d", | ||
756 | tcheck_1 = "7c00059cX", | ||
757 | ["tsr._1"] = "7c0005dd1", | ||
758 | ["tsuspend._0"] = "7c0005dd", | ||
759 | ["tresume._0"] = "7c2005dd", | ||
760 | ["tabortwc._3"] = "7c00061dARR", | ||
761 | ["tabortdc._3"] = "7c00065dARR", | ||
762 | ["tabortwci._3"] = "7c00069dARS", | ||
763 | ["tabortdci._3"] = "7c0006ddARS", | ||
764 | ["tabort._1"] = "7c00071d-R-", | ||
765 | ["treclaim._1"] = "7c00075d-R", | ||
766 | ["trechkpt._0"] = "7c0007dd", | ||
767 | |||
768 | lxsiwzx_3 = "7c000018QRR", | ||
769 | lxsiwax_3 = "7c000098QRR", | ||
770 | mfvsrd_2 = "7c000066-Rq", | ||
771 | mfvsrwz_2 = "7c0000e6-Rq", | ||
772 | stxsiwx_3 = "7c000118QRR", | ||
773 | mtvsrd_2 = "7c000166QR", | ||
774 | mtvsrwa_2 = "7c0001a6QR", | ||
775 | lxvdsx_3 = "7c000298QRR", | ||
776 | lxsspx_3 = "7c000418QRR", | ||
777 | lxsdx_3 = "7c000498QRR", | ||
778 | stxsspx_3 = "7c000518QRR", | ||
779 | stxsdx_3 = "7c000598QRR", | ||
780 | lxvw4x_3 = "7c000618QRR", | ||
781 | lxvd2x_3 = "7c000698QRR", | ||
782 | stxvw4x_3 = "7c000718QRR", | ||
783 | stxvd2x_3 = "7c000798QRR", | ||
784 | |||
484 | -- Primary opcode 30: | 785 | -- Primary opcode 30: |
485 | rldicl_4 = "78000000RR~HM.", | 786 | rldicl_4 = "78000000RR~HM.", |
486 | rldicr_4 = "78000004RR~HM.", | 787 | rldicr_4 = "78000004RR~HM.", |
@@ -489,6 +790,12 @@ local map_op = { | |||
489 | rldcl_4 = "78000010RR~RM.", | 790 | rldcl_4 = "78000010RR~RM.", |
490 | rldcr_4 = "78000012RR~RM.", | 791 | rldcr_4 = "78000012RR~RM.", |
491 | 792 | ||
793 | -- Primary opcode 56: | ||
794 | lq_2 = "e0000000R:D", -- NYI: displacement must be divisible by 8. | ||
795 | |||
796 | -- Primary opcode 57: | ||
797 | lfdp_2 = "e4000000F:D", -- NYI: displacement must be divisible by 4. | ||
798 | |||
492 | -- Primary opcode 59: | 799 | -- Primary opcode 59: |
493 | fdivs_3 = "ec000024FFF.", | 800 | fdivs_3 = "ec000024FFF.", |
494 | fsubs_3 = "ec000028FFF.", | 801 | fsubs_3 = "ec000028FFF.", |
@@ -501,6 +808,200 @@ local map_op = { | |||
501 | fmadds_4 = "ec00003aFFFF~.", | 808 | fmadds_4 = "ec00003aFFFF~.", |
502 | fnmsubs_4 = "ec00003cFFFF~.", | 809 | fnmsubs_4 = "ec00003cFFFF~.", |
503 | fnmadds_4 = "ec00003eFFFF~.", | 810 | fnmadds_4 = "ec00003eFFFF~.", |
811 | fcfids_2 = "ec00069cF-F.", | ||
812 | fcfidus_2 = "ec00079cF-F.", | ||
813 | |||
814 | dadd_3 = "ec000004FFF.", | ||
815 | dqua_4 = "ec000006FFFZ.", | ||
816 | dmul_3 = "ec000044FFF.", | ||
817 | drrnd_4 = "ec000046FFFZ.", | ||
818 | dscli_3 = "ec000084FF6.", | ||
819 | dquai_4 = "ec000086SF~FZ.", | ||
820 | dscri_3 = "ec0000c4FF6.", | ||
821 | drintx_4 = "ec0000c61F~FZ.", | ||
822 | dcmpo_3 = "ec000104XFF", | ||
823 | dtstex_3 = "ec000144XFF", | ||
824 | dtstdc_3 = "ec000184XF6", | ||
825 | dtstdg_3 = "ec0001c4XF6", | ||
826 | drintn_4 = "ec0001c61F~FZ.", | ||
827 | dctdp_2 = "ec000204F-F.", | ||
828 | dctfix_2 = "ec000244F-F.", | ||
829 | ddedpd_3 = "ec000284ZF~F.", | ||
830 | dxex_2 = "ec0002c4F-F.", | ||
831 | dsub_3 = "ec000404FFF.", | ||
832 | ddiv_3 = "ec000444FFF.", | ||
833 | dcmpu_3 = "ec000504XFF", | ||
834 | dtstsf_3 = "ec000544XFF", | ||
835 | drsp_2 = "ec000604F-F.", | ||
836 | dcffix_2 = "ec000644F-F.", | ||
837 | denbcd_3 = "ec000684YF~F.", | ||
838 | diex_3 = "ec0006c4FFF.", | ||
839 | |||
840 | -- Primary opcode 60: | ||
841 | xsaddsp_3 = "f0000000QQQ", | ||
842 | xsmaddasp_3 = "f0000008QQQ", | ||
843 | xxsldwi_4 = "f0000010QQQz", | ||
844 | xsrsqrtesp_2 = "f0000028Q-Q", | ||
845 | xssqrtsp_2 = "f000002cQ-Q", | ||
846 | xxsel_4 = "f0000030QQQQ", | ||
847 | xssubsp_3 = "f0000040QQQ", | ||
848 | xsmaddmsp_3 = "f0000048QQQ", | ||
849 | xxpermdi_4 = "f0000050QQQz", | ||
850 | xsresp_2 = "f0000068Q-Q", | ||
851 | xsmulsp_3 = "f0000080QQQ", | ||
852 | xsmsubasp_3 = "f0000088QQQ", | ||
853 | xxmrghw_3 = "f0000090QQQ", | ||
854 | xsdivsp_3 = "f00000c0QQQ", | ||
855 | xsmsubmsp_3 = "f00000c8QQQ", | ||
856 | xsadddp_3 = "f0000100QQQ", | ||
857 | xsmaddadp_3 = "f0000108QQQ", | ||
858 | xscmpudp_3 = "f0000118XQQ", | ||
859 | xscvdpuxws_2 = "f0000120Q-Q", | ||
860 | xsrdpi_2 = "f0000124Q-Q", | ||
861 | xsrsqrtedp_2 = "f0000128Q-Q", | ||
862 | xssqrtdp_2 = "f000012cQ-Q", | ||
863 | xssubdp_3 = "f0000140QQQ", | ||
864 | xsmaddmdp_3 = "f0000148QQQ", | ||
865 | xscmpodp_3 = "f0000158XQQ", | ||
866 | xscvdpsxws_2 = "f0000160Q-Q", | ||
867 | xsrdpiz_2 = "f0000164Q-Q", | ||
868 | xsredp_2 = "f0000168Q-Q", | ||
869 | xsmuldp_3 = "f0000180QQQ", | ||
870 | xsmsubadp_3 = "f0000188QQQ", | ||
871 | xxmrglw_3 = "f0000190QQQ", | ||
872 | xsrdpip_2 = "f00001a4Q-Q", | ||
873 | xstsqrtdp_2 = "f00001a8X-Q", | ||
874 | xsrdpic_2 = "f00001acQ-Q", | ||
875 | xsdivdp_3 = "f00001c0QQQ", | ||
876 | xsmsubmdp_3 = "f00001c8QQQ", | ||
877 | xsrdpim_2 = "f00001e4Q-Q", | ||
878 | xstdivdp_3 = "f00001e8XQQ", | ||
879 | xvaddsp_3 = "f0000200QQQ", | ||
880 | xvmaddasp_3 = "f0000208QQQ", | ||
881 | xvcmpeqsp_3 = "f0000218QQQ", | ||
882 | xvcvspuxws_2 = "f0000220Q-Q", | ||
883 | xvrspi_2 = "f0000224Q-Q", | ||
884 | xvrsqrtesp_2 = "f0000228Q-Q", | ||
885 | xvsqrtsp_2 = "f000022cQ-Q", | ||
886 | xvsubsp_3 = "f0000240QQQ", | ||
887 | xvmaddmsp_3 = "f0000248QQQ", | ||
888 | xvcmpgtsp_3 = "f0000258QQQ", | ||
889 | xvcvspsxws_2 = "f0000260Q-Q", | ||
890 | xvrspiz_2 = "f0000264Q-Q", | ||
891 | xvresp_2 = "f0000268Q-Q", | ||
892 | xvmulsp_3 = "f0000280QQQ", | ||
893 | xvmsubasp_3 = "f0000288QQQ", | ||
894 | xxspltw_3 = "f0000290QQg~", | ||
895 | xvcmpgesp_3 = "f0000298QQQ", | ||
896 | xvcvuxwsp_2 = "f00002a0Q-Q", | ||
897 | xvrspip_2 = "f00002a4Q-Q", | ||
898 | xvtsqrtsp_2 = "f00002a8X-Q", | ||
899 | xvrspic_2 = "f00002acQ-Q", | ||
900 | xvdivsp_3 = "f00002c0QQQ", | ||
901 | xvmsubmsp_3 = "f00002c8QQQ", | ||
902 | xvcvsxwsp_2 = "f00002e0Q-Q", | ||
903 | xvrspim_2 = "f00002e4Q-Q", | ||
904 | xvtdivsp_3 = "f00002e8XQQ", | ||
905 | xvadddp_3 = "f0000300QQQ", | ||
906 | xvmaddadp_3 = "f0000308QQQ", | ||
907 | xvcmpeqdp_3 = "f0000318QQQ", | ||
908 | xvcvdpuxws_2 = "f0000320Q-Q", | ||
909 | xvrdpi_2 = "f0000324Q-Q", | ||
910 | xvrsqrtedp_2 = "f0000328Q-Q", | ||
911 | xvsqrtdp_2 = "f000032cQ-Q", | ||
912 | xvsubdp_3 = "f0000340QQQ", | ||
913 | xvmaddmdp_3 = "f0000348QQQ", | ||
914 | xvcmpgtdp_3 = "f0000358QQQ", | ||
915 | xvcvdpsxws_2 = "f0000360Q-Q", | ||
916 | xvrdpiz_2 = "f0000364Q-Q", | ||
917 | xvredp_2 = "f0000368Q-Q", | ||
918 | xvmuldp_3 = "f0000380QQQ", | ||
919 | xvmsubadp_3 = "f0000388QQQ", | ||
920 | xvcmpgedp_3 = "f0000398QQQ", | ||
921 | xvcvuxwdp_2 = "f00003a0Q-Q", | ||
922 | xvrdpip_2 = "f00003a4Q-Q", | ||
923 | xvtsqrtdp_2 = "f00003a8X-Q", | ||
924 | xvrdpic_2 = "f00003acQ-Q", | ||
925 | xvdivdp_3 = "f00003c0QQQ", | ||
926 | xvmsubmdp_3 = "f00003c8QQQ", | ||
927 | xvcvsxwdp_2 = "f00003e0Q-Q", | ||
928 | xvrdpim_2 = "f00003e4Q-Q", | ||
929 | xvtdivdp_3 = "f00003e8XQQ", | ||
930 | xsnmaddasp_3 = "f0000408QQQ", | ||
931 | xxland_3 = "f0000410QQQ", | ||
932 | xscvdpsp_2 = "f0000424Q-Q", | ||
933 | xscvdpspn_2 = "f000042cQ-Q", | ||
934 | xsnmaddmsp_3 = "f0000448QQQ", | ||
935 | xxlandc_3 = "f0000450QQQ", | ||
936 | xsrsp_2 = "f0000464Q-Q", | ||
937 | xsnmsubasp_3 = "f0000488QQQ", | ||
938 | xxlor_3 = "f0000490QQQ", | ||
939 | xscvuxdsp_2 = "f00004a0Q-Q", | ||
940 | xsnmsubmsp_3 = "f00004c8QQQ", | ||
941 | xxlxor_3 = "f00004d0QQQ", | ||
942 | xscvsxdsp_2 = "f00004e0Q-Q", | ||
943 | xsmaxdp_3 = "f0000500QQQ", | ||
944 | xsnmaddadp_3 = "f0000508QQQ", | ||
945 | xxlnor_3 = "f0000510QQQ", | ||
946 | xscvdpuxds_2 = "f0000520Q-Q", | ||
947 | xscvspdp_2 = "f0000524Q-Q", | ||
948 | xscvspdpn_2 = "f000052cQ-Q", | ||
949 | xsmindp_3 = "f0000540QQQ", | ||
950 | xsnmaddmdp_3 = "f0000548QQQ", | ||
951 | xxlorc_3 = "f0000550QQQ", | ||
952 | xscvdpsxds_2 = "f0000560Q-Q", | ||
953 | xsabsdp_2 = "f0000564Q-Q", | ||
954 | xscpsgndp_3 = "f0000580QQQ", | ||
955 | xsnmsubadp_3 = "f0000588QQQ", | ||
956 | xxlnand_3 = "f0000590QQQ", | ||
957 | xscvuxddp_2 = "f00005a0Q-Q", | ||
958 | xsnabsdp_2 = "f00005a4Q-Q", | ||
959 | xsnmsubmdp_3 = "f00005c8QQQ", | ||
960 | xxleqv_3 = "f00005d0QQQ", | ||
961 | xscvsxddp_2 = "f00005e0Q-Q", | ||
962 | xsnegdp_2 = "f00005e4Q-Q", | ||
963 | xvmaxsp_3 = "f0000600QQQ", | ||
964 | xvnmaddasp_3 = "f0000608QQQ", | ||
965 | ["xvcmpeqsp._3"] = "f0000618QQQ", | ||
966 | xvcvspuxds_2 = "f0000620Q-Q", | ||
967 | xvcvdpsp_2 = "f0000624Q-Q", | ||
968 | xvminsp_3 = "f0000640QQQ", | ||
969 | xvnmaddmsp_3 = "f0000648QQQ", | ||
970 | ["xvcmpgtsp._3"] = "f0000658QQQ", | ||
971 | xvcvspsxds_2 = "f0000660Q-Q", | ||
972 | xvabssp_2 = "f0000664Q-Q", | ||
973 | xvcpsgnsp_3 = "f0000680QQQ", | ||
974 | xvnmsubasp_3 = "f0000688QQQ", | ||
975 | ["xvcmpgesp._3"] = "f0000698QQQ", | ||
976 | xvcvuxdsp_2 = "f00006a0Q-Q", | ||
977 | xvnabssp_2 = "f00006a4Q-Q", | ||
978 | xvnmsubmsp_3 = "f00006c8QQQ", | ||
979 | xvcvsxdsp_2 = "f00006e0Q-Q", | ||
980 | xvnegsp_2 = "f00006e4Q-Q", | ||
981 | xvmaxdp_3 = "f0000700QQQ", | ||
982 | xvnmaddadp_3 = "f0000708QQQ", | ||
983 | ["xvcmpeqdp._3"] = "f0000718QQQ", | ||
984 | xvcvdpuxds_2 = "f0000720Q-Q", | ||
985 | xvcvspdp_2 = "f0000724Q-Q", | ||
986 | xvmindp_3 = "f0000740QQQ", | ||
987 | xvnmaddmdp_3 = "f0000748QQQ", | ||
988 | ["xvcmpgtdp._3"] = "f0000758QQQ", | ||
989 | xvcvdpsxds_2 = "f0000760Q-Q", | ||
990 | xvabsdp_2 = "f0000764Q-Q", | ||
991 | xvcpsgndp_3 = "f0000780QQQ", | ||
992 | xvnmsubadp_3 = "f0000788QQQ", | ||
993 | ["xvcmpgedp._3"] = "f0000798QQQ", | ||
994 | xvcvuxddp_2 = "f00007a0Q-Q", | ||
995 | xvnabsdp_2 = "f00007a4Q-Q", | ||
996 | xvnmsubmdp_3 = "f00007c8QQQ", | ||
997 | xvcvsxddp_2 = "f00007e0Q-Q", | ||
998 | xvnegdp_2 = "f00007e4Q-Q", | ||
999 | |||
1000 | -- Primary opcode 61: | ||
1001 | stfdp_2 = "f4000000F:D", -- NYI: displacement must be divisible by 4. | ||
1002 | |||
1003 | -- Primary opcode 62: | ||
1004 | stq_2 = "f8000002R:D", -- NYI: displacement must be divisible by 8. | ||
504 | 1005 | ||
505 | -- Primary opcode 63: | 1006 | -- Primary opcode 63: |
506 | fdiv_3 = "fc000024FFF.", | 1007 | fdiv_3 = "fc000024FFF.", |
@@ -526,8 +1027,12 @@ local map_op = { | |||
526 | frsp_2 = "fc000018F-F.", | 1027 | frsp_2 = "fc000018F-F.", |
527 | fctiw_2 = "fc00001cF-F.", | 1028 | fctiw_2 = "fc00001cF-F.", |
528 | fctiwz_2 = "fc00001eF-F.", | 1029 | fctiwz_2 = "fc00001eF-F.", |
1030 | ftdiv_2 = "fc000100X-F.", | ||
1031 | fctiwu_2 = "fc00011cF-F.", | ||
1032 | fctiwuz_2 = "fc00011eF-F.", | ||
529 | mtfsfi_2 = "fc00010cAA", -- NYI: upshift. | 1033 | mtfsfi_2 = "fc00010cAA", -- NYI: upshift. |
530 | fnabs_2 = "fc000110F-F.", | 1034 | fnabs_2 = "fc000110F-F.", |
1035 | ftsqrt_2 = "fc000140X-F.", | ||
531 | fabs_2 = "fc000210F-F.", | 1036 | fabs_2 = "fc000210F-F.", |
532 | frin_2 = "fc000310F-F.", | 1037 | frin_2 = "fc000310F-F.", |
533 | friz_2 = "fc000350F-F.", | 1038 | friz_2 = "fc000350F-F.", |
@@ -537,7 +1042,38 @@ local map_op = { | |||
537 | -- NYI: mtfsf, mtfsb0, mtfsb1. | 1042 | -- NYI: mtfsf, mtfsb0, mtfsb1. |
538 | fctid_2 = "fc00065cF-F.", | 1043 | fctid_2 = "fc00065cF-F.", |
539 | fctidz_2 = "fc00065eF-F.", | 1044 | fctidz_2 = "fc00065eF-F.", |
1045 | fmrgow_3 = "fc00068cFFF", | ||
540 | fcfid_2 = "fc00069cF-F.", | 1046 | fcfid_2 = "fc00069cF-F.", |
1047 | fctidu_2 = "fc00075cF-F.", | ||
1048 | fctiduz_2 = "fc00075eF-F.", | ||
1049 | fmrgew_3 = "fc00078cFFF", | ||
1050 | fcfidu_2 = "fc00079cF-F.", | ||
1051 | |||
1052 | daddq_3 = "fc000004F:F:F:.", | ||
1053 | dquaq_4 = "fc000006F:F:F:Z.", | ||
1054 | dmulq_3 = "fc000044F:F:F:.", | ||
1055 | drrndq_4 = "fc000046F:F:F:Z.", | ||
1056 | dscliq_3 = "fc000084F:F:6.", | ||
1057 | dquaiq_4 = "fc000086SF:~F:Z.", | ||
1058 | dscriq_3 = "fc0000c4F:F:6.", | ||
1059 | drintxq_4 = "fc0000c61F:~F:Z.", | ||
1060 | dcmpoq_3 = "fc000104XF:F:", | ||
1061 | dtstexq_3 = "fc000144XF:F:", | ||
1062 | dtstdcq_3 = "fc000184XF:6", | ||
1063 | dtstdgq_3 = "fc0001c4XF:6", | ||
1064 | drintnq_4 = "fc0001c61F:~F:Z.", | ||
1065 | dctqpq_2 = "fc000204F:-F:.", | ||
1066 | dctfixq_2 = "fc000244F:-F:.", | ||
1067 | ddedpdq_3 = "fc000284ZF:~F:.", | ||
1068 | dxexq_2 = "fc0002c4F:-F:.", | ||
1069 | dsubq_3 = "fc000404F:F:F:.", | ||
1070 | ddivq_3 = "fc000444F:F:F:.", | ||
1071 | dcmpuq_3 = "fc000504XF:F:", | ||
1072 | dtstsfq_3 = "fc000544XF:F:", | ||
1073 | drdpq_2 = "fc000604F:-F:.", | ||
1074 | dcffixq_2 = "fc000644F:-F:.", | ||
1075 | denbcdq_3 = "fc000684YF:~F:.", | ||
1076 | diexq_3 = "fc0006c4F:FF:.", | ||
541 | 1077 | ||
542 | -- Primary opcode 4, SPE APU extension: | 1078 | -- Primary opcode 4, SPE APU extension: |
543 | evaddw_3 = "10000200RRR", | 1079 | evaddw_3 = "10000200RRR", |
@@ -884,6 +1420,24 @@ local function parse_fpr(expr) | |||
884 | werror("bad register name `"..expr.."'") | 1420 | werror("bad register name `"..expr.."'") |
885 | end | 1421 | end |
886 | 1422 | ||
1423 | local function parse_vr(expr) | ||
1424 | local r = match(expr, "^v([1-3]?[0-9])$") | ||
1425 | if r then | ||
1426 | r = tonumber(r) | ||
1427 | if r <= 31 then return r end | ||
1428 | end | ||
1429 | werror("bad register name `"..expr.."'") | ||
1430 | end | ||
1431 | |||
1432 | local function parse_vs(expr) | ||
1433 | local r = match(expr, "^vs([1-6]?[0-9])$") | ||
1434 | if r then | ||
1435 | r = tonumber(r) | ||
1436 | if r <= 63 then return r end | ||
1437 | end | ||
1438 | werror("bad register name `"..expr.."'") | ||
1439 | end | ||
1440 | |||
887 | local function parse_cr(expr) | 1441 | local function parse_cr(expr) |
888 | local r = match(expr, "^cr([0-7])$") | 1442 | local r = match(expr, "^cr([0-7])$") |
889 | if r then return tonumber(r) end | 1443 | if r then return tonumber(r) end |
@@ -914,7 +1468,8 @@ local function parse_imm(imm, bits, shift, scale, signed) | |||
914 | end | 1468 | end |
915 | end | 1469 | end |
916 | werror("out of range immediate `"..imm.."'") | 1470 | werror("out of range immediate `"..imm.."'") |
917 | elseif match(imm, "^r([1-3]?[0-9])$") or | 1471 | elseif match(imm, "^[rfv]([1-3]?[0-9])$") or |
1472 | match(imm, "^vs([1-6]?[0-9])$") or | ||
918 | match(imm, "^([%w_]+):(r[1-3]?[0-9])$") then | 1473 | match(imm, "^([%w_]+):(r[1-3]?[0-9])$") then |
919 | werror("expected immediate operand, got register") | 1474 | werror("expected immediate operand, got register") |
920 | else | 1475 | else |
@@ -1027,6 +1582,15 @@ map_op[".template__"] = function(params, template, nparams) | |||
1027 | rs = rs - 5; op = op + shl(parse_gpr(params[n]), rs); n = n + 1 | 1582 | rs = rs - 5; op = op + shl(parse_gpr(params[n]), rs); n = n + 1 |
1028 | elseif p == "F" then | 1583 | elseif p == "F" then |
1029 | rs = rs - 5; op = op + shl(parse_fpr(params[n]), rs); n = n + 1 | 1584 | rs = rs - 5; op = op + shl(parse_fpr(params[n]), rs); n = n + 1 |
1585 | elseif p == "V" then | ||
1586 | rs = rs - 5; op = op + shl(parse_vr(params[n]), rs); n = n + 1 | ||
1587 | elseif p == "Q" then | ||
1588 | local vs = parse_vs(params[n]); n = n + 1; rs = rs - 5 | ||
1589 | local sh = rs == 6 and 2 or 3 + band(shr(rs, 1), 3) | ||
1590 | op = op + shl(band(vs, 31), rs) + shr(band(vs, 32), sh) | ||
1591 | elseif p == "q" then | ||
1592 | local vs = parse_vs(params[n]); n = n + 1 | ||
1593 | op = op + shl(band(vs, 31), 21) + shr(band(vs, 32), 5) | ||
1030 | elseif p == "A" then | 1594 | elseif p == "A" then |
1031 | rs = rs - 5; op = op + parse_imm(params[n], 5, rs, 0, false); n = n + 1 | 1595 | rs = rs - 5; op = op + parse_imm(params[n], 5, rs, 0, false); n = n + 1 |
1032 | elseif p == "S" then | 1596 | elseif p == "S" then |
@@ -1047,6 +1611,26 @@ map_op[".template__"] = function(params, template, nparams) | |||
1047 | rs = rs - 5; op = op + shl(parse_cond(params[n]), rs); n = n + 1 | 1611 | rs = rs - 5; op = op + shl(parse_cond(params[n]), rs); n = n + 1 |
1048 | elseif p == "X" then | 1612 | elseif p == "X" then |
1049 | rs = rs - 5; op = op + shl(parse_cr(params[n]), rs+2); n = n + 1 | 1613 | rs = rs - 5; op = op + shl(parse_cr(params[n]), rs+2); n = n + 1 |
1614 | elseif p == "1" then | ||
1615 | rs = rs - 5; op = op + parse_imm(params[n], 1, rs, 0, false); n = n + 1 | ||
1616 | elseif p == "g" then | ||
1617 | rs = rs - 5; op = op + parse_imm(params[n], 2, rs, 0, false); n = n + 1 | ||
1618 | elseif p == "3" then | ||
1619 | rs = rs - 5; op = op + parse_imm(params[n], 3, rs, 0, false); n = n + 1 | ||
1620 | elseif p == "P" then | ||
1621 | rs = rs - 5; op = op + parse_imm(params[n], 4, rs, 0, false); n = n + 1 | ||
1622 | elseif p == "p" then | ||
1623 | op = op + parse_imm(params[n], 4, rs, 0, false); n = n + 1 | ||
1624 | elseif p == "6" then | ||
1625 | rs = rs - 6; op = op + parse_imm(params[n], 6, rs, 0, false); n = n + 1 | ||
1626 | elseif p == "Y" then | ||
1627 | rs = rs - 5; op = op + parse_imm(params[n], 1, rs+4, 0, false); n = n + 1 | ||
1628 | elseif p == "y" then | ||
1629 | rs = rs - 5; op = op + parse_imm(params[n], 1, rs+3, 0, false); n = n + 1 | ||
1630 | elseif p == "Z" then | ||
1631 | rs = rs - 5; op = op + parse_imm(params[n], 2, rs+3, 0, false); n = n + 1 | ||
1632 | elseif p == "z" then | ||
1633 | rs = rs - 5; op = op + parse_imm(params[n], 2, rs+2, 0, false); n = n + 1 | ||
1050 | elseif p == "W" then | 1634 | elseif p == "W" then |
1051 | op = op + parse_cr(params[n]); n = n + 1 | 1635 | op = op + parse_cr(params[n]); n = n + 1 |
1052 | elseif p == "G" then | 1636 | elseif p == "G" then |
@@ -1071,6 +1655,8 @@ map_op[".template__"] = function(params, template, nparams) | |||
1071 | local lo = band(op, mm) | 1655 | local lo = band(op, mm) |
1072 | local hi = band(op, shl(mm, 5)) | 1656 | local hi = band(op, shl(mm, 5)) |
1073 | op = op - lo - hi + shl(lo, 5) + shr(hi, 5) | 1657 | op = op - lo - hi + shl(lo, 5) + shr(hi, 5) |
1658 | elseif p == ":" then | ||
1659 | if band(shr(op, rs), 1) ~= 0 then werror("register pair expected") end | ||
1074 | elseif p == "-" then | 1660 | elseif p == "-" then |
1075 | rs = rs - 5 | 1661 | rs = rs - 5 |
1076 | elseif p == "." then | 1662 | elseif p == "." then |