CW Cyrix's Git Repository Mirror
Browse code

Slight update from DeSmuME SVN and a bit more code style cleanup of the AsmJit stuff, since I think it's code style is ugly.

Naram Qashat authored on 2013/04/19 12:45:47
Showing 9 changed files
src/in_2sf/desmume/arm_jit.h
History View file @ d07af85
... ... 
@@ -28,7 +28,7 @@ void arm_jit_close();
28 28 
 void arm_jit_sync();
29 29 
 template<int PROCNUM> uint32_t arm_jit_compile();
30 30
31 
-#ifdef _WINDOWS
31 
+#if defined(_WINDOWS) || defined(DESMUME_COCOA)
32 32 
 # define MAPPED_JIT_FUNCS
33 33 
 #endif
34 34
src/in_2sf/desmume/utils/AsmJit/x86/x86compileritem.cpp
History View file @ d07af85
... ... 
@@ -19,14 +19,14 @@
19 19 
 // [Api-Begin]
20 20 
 #include "../core/apibegin.h"
21 21
22 
-namespace AsmJit {
22 
+namespace AsmJit
23 
+{
23 24
24 25 
 // ============================================================================
25 26 
 // [AsmJit::X86CompilerAlign - Construction / Destruction]
26 27 
 // ============================================================================
27 28
28 
-X86CompilerAlign::X86CompilerAlign(X86Compiler* x86Compiler, uint32_t size) :
29 
-  CompilerAlign(x86Compiler, size)
29 
+X86CompilerAlign::X86CompilerAlign(X86Compiler *x86Compiler, uint32_t size) : CompilerAlign(x86Compiler, size)
30 30 
 {
31 31 
 }
32 32
... ... 
@@ -38,19 +38,18 @@ X86CompilerAlign::~X86CompilerAlign()
38 38 
 // [AsmJit::X86CompilerAlign - Interface]
39 39 
 // ============================================================================
40 40
41 
-void X86CompilerAlign::emit(Assembler& a)
41 
+void X86CompilerAlign::emit(Assembler &a)
42 42 
 {
43 
-  X86Assembler& x86Asm = static_cast<X86Assembler&>(a);
43 
+	X86Assembler &x86Asm = static_cast<X86Assembler &>(a);
44 44
45 
-  x86Asm.align(_size);
45 
+	x86Asm.align(_size);
46 46 
 }
47 47
48 48 
 // ============================================================================
49 49 
 // [AsmJit::X86CompilerTarget - Construction / Destruction]
50 50 
 // ============================================================================
51 51
52 
-X86CompilerTarget::X86CompilerTarget(X86Compiler* c, const Label& label) :
53 
-  CompilerTarget(c, label)
52 
+X86CompilerTarget::X86CompilerTarget(X86Compiler *c, const Label &label) : CompilerTarget(c, label)
54 53 
 {
55 54 
 }
56 55
... ... 
@@ -62,92 +61,89 @@ X86CompilerTarget::~X86CompilerTarget()
62 61 
 // [AsmJit::X86CompilerTarget - Interface]
63 62 
 // ============================================================================
64 63
65 
-static X86CompilerTarget* X86CompilerTarget_removeUnreachableItems(X86CompilerTarget* target)
64 
+static X86CompilerTarget *X86CompilerTarget_removeUnreachableItems(X86CompilerTarget *target)
66 65 
 {
67 
-  CompilerItem* prev = target->getPrev();
68 
-  CompilerItem* item = target->getNext();
66 
+	CompilerItem *prev = target->getPrev();
67 
+	CompilerItem *item = target->getNext();
69 68
70 
-  ASMJIT_ASSERT(!!prev);
71 
-  ASMJIT_ASSERT(!!item);
69 
+	ASMJIT_ASSERT(prev);
70 
+	ASMJIT_ASSERT(item);
72 71
73 
-  for (;;)
74 
-  {
75 
-    CompilerItem* next = item->getNext();
76 
-    ASMJIT_ASSERT(!!next);
72 
+	for (;;)
73 
+	{
74 
+		CompilerItem *next = item->getNext();
75 
+		ASMJIT_ASSERT(next);
77 76
78 
-    if (item->getType() == kCompilerItemTarget)
79 
-      break;
77 
+		if (item->getType() == kCompilerItemTarget)
78 
+			break;
80 79
81 
-    item->_prev = nullptr;
82 
-    item->_next = nullptr;
83 
-    item->_isUnreachable = true;
80 
+		item->_prev = nullptr;
81 
+		item->_next = nullptr;
82 
+		item->_isUnreachable = true;
84 83
85 
-    item = next;
86 
-  }
84 
+		item = next;
85 
+	}
87 86
88 
-  target->_prev = nullptr;
89 
-  target->_next = nullptr;
90 
-  target->_isTranslated = true;
87 
+	target->_prev = nullptr;
88 
+	target->_next = nullptr;
89 
+	target->_isTranslated = true;
91 90
92 
-  prev->_next = item;
93 
-  item->_prev = prev;
91 
+	prev->_next = item;
92 
+	item->_prev = prev;
94 93
95 
-  return static_cast<X86CompilerTarget*>(item);
94 
+	return static_cast<X86CompilerTarget *>(item);
96 95 
 }
97 96
98 
-void X86CompilerTarget::prepare(CompilerContext& cc)
97 
+void X86CompilerTarget::prepare(CompilerContext &cc)
99 98 
 {
100 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
101 
-  _offset = x86Context._currentOffset++;
99 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
100 
+	this->_offset = x86Context._currentOffset++;
102 101 
 }
103 102
104 
-CompilerItem* X86CompilerTarget::translate(CompilerContext& cc)
103 
+CompilerItem *X86CompilerTarget::translate(CompilerContext &cc)
105 104 
 {
106 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
107 
-
108 
-  // If this X86CompilerTarget was already translated, it's needed to change
109 
-  // the current state and return NULL to tell CompilerContext to process next
110 
-  // untranslated item.
111 
-  if (_isTranslated)
112 
-  {
113 
-    x86Context._restoreState(getState());
114 
-    return nullptr;
115 
-  }
116 
-
117 
-  if (x86Context._isUnreachable)
118 
-  {
119 
-    // If the context has "isUnreachable" flag set and there is no state then
120 
-    // it means that this code will be never called. This is a problem, because
121 
-    // we are unable to assign a state to current location so we can't allocate
122 
-    // registers for variables used inside. So instead of doing anything wrong
123 
-    // we remove the unreachable code.
124 
-    if (!_state)
125 
-      return X86CompilerTarget_removeUnreachableItems(this);
126 
-
127 
-    // Assign state to the compiler context.
128 
-    x86Context._isUnreachable = 0;
129 
-    x86Context._assignState(getState());
130 
-  }
131 
-  else
132 
-  {
133 
-    _state = x86Context._saveState();
134 
-  }
135 
-
136 
-  return translated();
105 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
106 
+
107 
+	// If this X86CompilerTarget was already translated, it's needed to change
108 
+	// the current state and return NULL to tell CompilerContext to process next
109 
+	// untranslated item.
110 
+	if (this->_isTranslated)
111 
+	{
112 
+		x86Context._restoreState(this->getState());
113 
+		return nullptr;
114 
+	}
115 
+
116 
+	if (x86Context._isUnreachable)
117 
+	{
118 
+		// If the context has "isUnreachable" flag set and there is no state then
119 
+		// it means that this code will be never called. This is a problem, because
120 
+		// we are unable to assign a state to current location so we can't allocate
121 
+		// registers for variables used inside. So instead of doing anything wrong
122 
+		// we remove the unreachable code.
123 
+		if (!this->_state)
124 
+			return X86CompilerTarget_removeUnreachableItems(this);
125 
+
126 
+		// Assign state to the compiler context.
127 
+		x86Context._isUnreachable = 0;
128 
+		x86Context._assignState(this->getState());
129 
+	}
130 
+	else
131 
+		this->_state = x86Context._saveState();
132 
+
133 
+	return this->translated();
137 134 
 }
138 135
139 
-void X86CompilerTarget::emit(Assembler& a)
136 
+void X86CompilerTarget::emit(Assembler &a)
140 137 
 {
141 
-  X86Assembler& x86Asm = static_cast<X86Assembler&>(a);
142 
-  x86Asm.bind(_label);
138 
+	X86Assembler &x86Asm = static_cast<X86Assembler &>(a);
139 
+	x86Asm.bind(this->_label);
143 140 
 }
144 141
145 142 
 // ============================================================================
146 143 
 // [AsmJit::X86CompilerHint - Construction / Destruction]
147 144 
 // ============================================================================
148 145
149 
-X86CompilerHint::X86CompilerHint(X86Compiler* compiler, X86CompilerVar* var, uint32_t hintId, uint32_t hintValue) :
150 
-  CompilerHint(compiler, var, hintId, hintValue)
146 
+X86CompilerHint::X86CompilerHint(X86Compiler *compiler, X86CompilerVar *var, uint32_t hintId, uint32_t hintValue) : CompilerHint(compiler, var, hintId, hintValue)
151 147 
 {
152 148 
 }
153 149
... ... 
@@ -159,79 +155,78 @@ X86CompilerHint::~X86CompilerHint()
159 155 
 // [AsmJit::X86CompilerHint - Interface]
160 156 
 // ============================================================================
161 157
162 
-void X86CompilerHint::prepare(CompilerContext& cc)
158 
+void X86CompilerHint::prepare(CompilerContext &cc)
163 159 
 {
164 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
165 
-  X86CompilerVar* var = getVar();
166 
-
167 
-  _offset = x86Context._currentOffset;
168 
-
169 
-  // First item (begin of variable scope).
170 
-  if (!var->firstItem)
171 
-    var->firstItem = this;
172 
-
173 
-  // Last item (end of variable scope).
174 
-  CompilerItem* oldLast = var->lastItem;
175 
-  var->lastItem = this;
176 
-
177 
-  switch (_hintId)
178 
-  {
179 
-    case kVarHintAlloc:
180 
-    case kVarHintSpill:
181 
-    case kVarHintSave:
182 
-      if (!x86Context._isActive(var))
183 
-        x86Context._addActive(var);
184 
-      break;
185 
-
186 
-    case kVarHintSaveAndUnuse:
187 
-      if (!x86Context._isActive(var))
188 
-        x86Context._addActive(var);
189 
-      break;
190 
-
191 
-    case kVarHintUnuse:
192 
-      if (oldLast)
193 
-        oldLast->_tryUnuseVar(var);
194 
-      break;
195 
-  }
160 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
161 
+	X86CompilerVar *var = this->getVar();
162 
+
163 
+	this->_offset = x86Context._currentOffset;
164 
+
165 
+	// First item (begin of variable scope).
166 
+	if (!var->firstItem)
167 
+		var->firstItem = this;
168 
+
169 
+	// Last item (end of variable scope).
170 
+	CompilerItem *oldLast = var->lastItem;
171 
+	var->lastItem = this;
172 
+
173 
+	switch (this->_hintId)
174 
+	{
175 
+		case kVarHintAlloc:
176 
+		case kVarHintSpill:
177 
+		case kVarHintSave:
178 
+			if (!x86Context._isActive(var))
179 
+				x86Context._addActive(var);
180 
+			break;
181 
+
182 
+		case kVarHintSaveAndUnuse:
183 
+			if (!x86Context._isActive(var))
184 
+				x86Context._addActive(var);
185 
+		break;
186 
+
187 
+		case kVarHintUnuse:
188 
+			if (oldLast)
189 
+				oldLast->_tryUnuseVar(var);
190 
+	}
196 191 
 }
197 192
198 
-CompilerItem* X86CompilerHint::translate(CompilerContext& cc)
193 
+CompilerItem *X86CompilerHint::translate(CompilerContext &cc)
199 194 
 {
200 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
201 
-  X86CompilerVar* var = getVar();
202 
-
203 
-  switch (_hintId)
204 
-  {
205 
-    case kVarHintAlloc:
206 
-      x86Context.allocVar(var, _hintValue, kVarAllocRead);
207 
-      break;
208 
-
209 
-    case kVarHintSpill:
210 
-      if (var->state == kVarStateReg)
211 
-        x86Context.spillVar(var);
212 
-      break;
213 
-
214 
-    case kVarHintSave:
215 
-    case kVarHintSaveAndUnuse:
216 
-      if (var->state == kVarStateReg && var->changed)
217 
-      {
218 
-        x86Context.emitSaveVar(var, var->regIndex);
219 
-        var->changed = false;
220 
-      }
221 
-      if (_hintId == kVarHintSaveAndUnuse)
222 
-        goto _Unuse;
223 
-      break;
224 
-
225 
-    case kVarHintUnuse:
226 
-_Unuse:
227 
-      x86Context.unuseVar(var, kVarStateUnused);
228 
-      goto _End;
229 
-  }
230 
-
231 
-  x86Context._unuseVarOnEndOfScope(this, var);
195 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
196 
+	X86CompilerVar *var = this->getVar();
197 
+
198 
+	switch (this->_hintId)
199 
+	{
200 
+		case kVarHintAlloc:
201 
+			x86Context.allocVar(var, this->_hintValue, kVarAllocRead);
202 
+			break;
203 
+
204 
+		case kVarHintSpill:
205 
+			if (var->state == kVarStateReg)
206 
+				x86Context.spillVar(var);
207 
+			break;
208 
+
209 
+		case kVarHintSave:
210 
+		case kVarHintSaveAndUnuse:
211 
+			if (var->state == kVarStateReg && var->changed)
212 
+			{
213 
+				x86Context.emitSaveVar(var, var->regIndex);
214 
+				var->changed = false;
215 
+			}
216 
+			if (this->_hintId == kVarHintSaveAndUnuse)
217 
+				goto _Unuse;
218 
+			break;
219 
+
220 
+		case kVarHintUnuse:
221 
+		_Unuse:
222 
+			x86Context.unuseVar(var, kVarStateUnused);
223 
+				goto _End;
224 
+	}
225 
+
226 
+	x86Context._unuseVarOnEndOfScope(this, var);
232 227
233 228 
 _End:
234 
-  return translated();
229 
+	return this->translated();
235 230 
 }
236 231
237 232 
 // ============================================================================
... ... 
@@ -240,197 +235,193 @@ _End:
240 235
241 236 
 int X86CompilerHint::getMaxSize() const
242 237 
 {
243 
-  // Compiler hint is NOP, but it can generate other items which can do
244 
-  // something - in such more items are added into the stream so we don't need
245 
-  // to worry about this.
246 
-  return 0;
238 
+	// Compiler hint is NOP, but it can generate other items which can do
239 
+	// something - in such more items are added into the stream so we don't need
240 
+	// to worry about this.
241 
+	return 0;
247 242 
 }
248 243
249 244 
 // ============================================================================
250 245 
 // [AsmJit::X86CompilerInst - Construction / Destruction]
251 246 
 // ============================================================================
252 247
253 
-X86CompilerInst::X86CompilerInst(X86Compiler* x86Compiler, uint32_t code, Operand* opData, uint32_t opCount) :
254 
-  CompilerInst(x86Compiler, code, opData, opCount)
248 
+X86CompilerInst::X86CompilerInst(X86Compiler *x86Compiler, uint32_t code, Operand *opData, uint32_t opCount) : CompilerInst(x86Compiler, code, opData, opCount)
255 249 
 {
256 
-  uint32_t i;
257 
-
258 
-  _memOp = nullptr;
259 
-  _vars = nullptr;
260 
-  _variablesCount = 0;
261 
-
262 
-  for (i = 0; i < opCount; i++)
263 
-  {
264 
-    if (_operands[i].isMem())
265 
-    {
266 
-      _memOp = reinterpret_cast<Mem*>(&_operands[i]);
267 
-      break;
268 
-    }
269 
-  }
270 
-
271 
-  const X86InstInfo* info = &x86InstInfo[_code];
272 
-
273 
-  if (info->isSpecial())
274 
-    setInstFlag(kX86CompilerInstFlagIsSpecial);
275 
-  if (info->isFpu())
276 
-    setInstFlag(kX86CompilerInstFlagIsFpu);
277 
-
278 
-  if (isSpecial())
279 
-  {
280 
-    // ${SPECIAL_INSTRUCTION_HANDLING_BEGIN}
281 
-    switch (_code)
282 
-    {
283 
-      case kX86InstCpuId:
284 
-        // Special...
285 
-        break;
286 
-
287 
-      case kX86InstCbw:
288 
-      case kX86InstCdq:
289 
-      case kX86InstCdqe:
290 
-      case kX86InstCwd:
291 
-      case kX86InstCwde:
292 
-      case kX86InstCqo:
293 
-        // Special...
294 
-        break;
295 
-
296 
-      case kX86InstCmpXCHG:
297 
-      case kX86InstCmpXCHG8B:
298 
-#if defined(ASMJIT_X64)
299 
-      case kX86InstCmpXCHG16B:
250 
+	this->_memOp = nullptr;
251 
+	this->_vars = nullptr;
252 
+	this->_variablesCount = 0;
253 
+
254 
+	for (uint32_t i = 0; i < opCount; ++i)
255 
+	{
256 
+		if (this->_operands[i].isMem())
257 
+		{
258 
+			this->_memOp = reinterpret_cast<Mem *>(&this->_operands[i]);
259 
+			break;
260 
+		}
261 
+	}
262 
+
263 
+	const X86InstInfo *info = &x86InstInfo[this->_code];
264 
+
265 
+	if (info->isSpecial())
266 
+		this->setInstFlag(kX86CompilerInstFlagIsSpecial);
267 
+	if (info->isFpu())
268 
+		this->setInstFlag(kX86CompilerInstFlagIsFpu);
269 
+
270 
+	if (this->isSpecial())
271 
+	{
272 
+		// ${SPECIAL_INSTRUCTION_HANDLING_BEGIN}
273 
+		switch (this->_code)
274 
+		{
275 
+			case kX86InstCpuId:
276 
+				// Special...
277 
+				break;
278 
+
279 
+			case kX86InstCbw:
280 
+			case kX86InstCdq:
281 
+			case kX86InstCdqe:
282 
+			case kX86InstCwd:
283 
+			case kX86InstCwde:
284 
+			case kX86InstCqo:
285 
+				// Special...
286 
+				break;
287 
+
288 
+			case kX86InstCmpXCHG:
289 
+			case kX86InstCmpXCHG8B:
290 
+#ifdef ASMJIT_X64
291 
+			case kX86InstCmpXCHG16B:
300 292 
 #endif // ASMJIT_X64
301 
-        // Special...
302 
-        break;
303 
-
304 
-#if defined(ASMJIT_X86)
305 
-      case kX86InstDaa:
306 
-      case kX86InstDas:
307 
-        // Special...
308 
-        break;
293 
+				// Special...
294 
+				break;
295 
+
296 
+#ifdef ASMJIT_X86
297 
+			case kX86InstDaa:
298 
+			case kX86InstDas:
299 
+				// Special...
300 
+				break;
309 301 
 #endif // ASMJIT_X86
310 302
311 
-      case kX86InstIMul:
312 
-        switch (_operandsCount)
313 
-        {
314 
-          case 2:
315 
-            // IMUL dst, src is not special instruction.
316 
-            clearInstFlag(kX86CompilerInstFlagIsSpecial);
317 
-            break;
318 
-          case 3:
319 
-            // Only IMUL dst_hi, dst_lo, reg/mem is special, all others don't.
320 
-            if (!(_operands[0].isVar() && _operands[1].isVar() && _operands[2].isVarMem()))
321 
-              clearInstFlag(kX86CompilerInstFlagIsSpecial);
322 
-            break;
323 
-        }
324 
-        break;
325 
-      case kX86InstMul:
326 
-      case kX86InstIDiv:
327 
-      case kX86InstDiv:
328 
-        // Special...
329 
-        break;
330 
-
331 
-      case kX86InstMovPtr:
332 
-        // Special...
333 
-        break;
334 
-
335 
-      case kX86InstLahf:
336 
-      case kX86InstSahf:
337 
-        // Special...
338 
-        break;
339 
-
340 
-      case kX86InstMaskMovQ:
341 
-      case kX86InstMaskMovDQU:
342 
-        // Special...
343 
-        break;
344 
-
345 
-      case kX86InstEnter:
346 
-      case kX86InstLeave:
347 
-        // Special...
348 
-        break;
349 
-
350 
-      case kX86InstRet:
351 
-        // Special...
352 
-        break;
353 
-
354 
-      case kX86InstMonitor:
355 
-      case kX86InstMWait:
356 
-        // Special...
357 
-        break;
358 
-
359 
-      case kX86InstPop:
360 
-      case kX86InstPopAD:
361 
-      case kX86InstPopFD:
362 
-      case kX86InstPopFQ:
363 
-        // Special...
364 
-        break;
365 
-
366 
-      case kX86InstPush:
367 
-      case kX86InstPushAD:
368 
-      case kX86InstPushFD:
369 
-      case kX86InstPushFQ:
370 
-        // Special...
371 
-        break;
372 
-
373 
-      case kX86InstRcl:
374 
-      case kX86InstRcr:
375 
-      case kX86InstRol:
376 
-      case kX86InstRor:
377 
-      case kX86InstSal:
378 
-      case kX86InstSar:
379 
-      case kX86InstShl:
380 
-      case kX86InstShr:
381 
-        // Rot instruction is special only if last operand is variable (register).
382 
-        if (!_operands[1].isVar())
383 
-          clearInstFlag(kX86CompilerInstFlagIsSpecial);
384 
-        break;
385 
-
386 
-      case kX86InstShld:
387 
-      case kX86InstShrd:
388 
-        // Shld/Shrd instruction is special only if last operand is variable (register).
389 
-        if (!_operands[2].isVar())
390 
-          clearInstFlag(kX86CompilerInstFlagIsSpecial);
391 
-        break;
392 
-
393 
-      case kX86InstRdtsc:
394 
-      case kX86InstRdtscP:
395 
-        // Special...
396 
-        break;
397 
-
398 
-      case kX86InstRepLodSB:
399 
-      case kX86InstRepLodSD:
400 
-      case kX86InstRepLodSQ:
401 
-      case kX86InstRepLodSW:
402 
-      case kX86InstRepMovSB:
403 
-      case kX86InstRepMovSD:
404 
-      case kX86InstRepMovSQ:
405 
-      case kX86InstRepMovSW:
406 
-      case kX86InstRepStoSB:
407 
-      case kX86InstRepStoSD:
408 
-      case kX86InstRepStoSQ:
409 
-      case kX86InstRepStoSW:
410 
-      case kX86InstRepECmpSB:
411 
-      case kX86InstRepECmpSD:
412 
-      case kX86InstRepECmpSQ:
413 
-      case kX86InstRepECmpSW:
414 
-      case kX86InstRepEScaSB:
415 
-      case kX86InstRepEScaSD:
416 
-      case kX86InstRepEScaSQ:
417 
-      case kX86InstRepEScaSW:
418 
-      case kX86InstRepNECmpSB:
419 
-      case kX86InstRepNECmpSD:
420 
-      case kX86InstRepNECmpSQ:
421 
-      case kX86InstRepNECmpSW:
422 
-      case kX86InstRepNEScaSB:
423 
-      case kX86InstRepNEScaSD:
424 
-      case kX86InstRepNEScaSQ:
425 
-      case kX86InstRepNEScaSW:
426 
-        // Special...
427 
-        break;
428 
-
429 
-      default:
430 
-        ASMJIT_ASSERT(0);
431 
-    }
432 
-    // ${SPECIAL_INSTRUCTION_HANDLING_END}
433 
-  }
303 
+			case kX86InstIMul:
304 
+				switch (this->_operandsCount)
305 
+				{
306 
+					case 2:
307 
+						// IMUL dst, src is not special instruction.
308 
+						this->clearInstFlag(kX86CompilerInstFlagIsSpecial);
309 
+						break;
310 
+					case 3:
311 
+						// Only IMUL dst_hi, dst_lo, reg/mem is special, all others don't.
312 
+						if (!(this->_operands[0].isVar() && this->_operands[1].isVar() && this->_operands[2].isVarMem()))
313 
+							this->clearInstFlag(kX86CompilerInstFlagIsSpecial);
314 
+				}
315 
+				break;
316 
+			case kX86InstMul:
317 
+			case kX86InstIDiv:
318 
+			case kX86InstDiv:
319 
+				// Special...
320 
+				break;
321 
+
322 
+			case kX86InstMovPtr:
323 
+				// Special...
324 
+				break;
325 
+
326 
+			case kX86InstLahf:
327 
+			case kX86InstSahf:
328 
+				// Special...
329 
+				break;
330 
+
331 
+			case kX86InstMaskMovQ:
332 
+			case kX86InstMaskMovDQU:
333 
+				// Special...
334 
+				break;
335 
+
336 
+			case kX86InstEnter:
337 
+			case kX86InstLeave:
338 
+				// Special...
339 
+				break;
340 
+
341 
+			case kX86InstRet:
342 
+				// Special...
343 
+				break;
344 
+
345 
+			case kX86InstMonitor:
346 
+			case kX86InstMWait:
347 
+				// Special...
348 
+				break;
349 
+
350 
+			case kX86InstPop:
351 
+			case kX86InstPopAD:
352 
+			case kX86InstPopFD:
353 
+			case kX86InstPopFQ:
354 
+				// Special...
355 
+				break;
356 
+
357 
+			case kX86InstPush:
358 
+			case kX86InstPushAD:
359 
+			case kX86InstPushFD:
360 
+			case kX86InstPushFQ:
361 
+				// Special...
362 
+				break;
363 
+
364 
+			case kX86InstRcl:
365 
+			case kX86InstRcr:
366 
+			case kX86InstRol:
367 
+			case kX86InstRor:
368 
+			case kX86InstSal:
369 
+			case kX86InstSar:
370 
+			case kX86InstShl:
371 
+			case kX86InstShr:
372 
+				// Rot instruction is special only if last operand is variable (register).
373 
+				if (!this->_operands[1].isVar())
374 
+					this->clearInstFlag(kX86CompilerInstFlagIsSpecial);
375 
+				break;
376 
+
377 
+			case kX86InstShld:
378 
+			case kX86InstShrd:
379 
+				// Shld/Shrd instruction is special only if last operand is variable (register).
380 
+				if (!this->_operands[2].isVar())
381 
+					this->clearInstFlag(kX86CompilerInstFlagIsSpecial);
382 
+				break;
383 
+
384 
+			case kX86InstRdtsc:
385 
+			case kX86InstRdtscP:
386 
+				// Special...
387 
+				break;
388 
+
389 
+			case kX86InstRepLodSB:
390 
+			case kX86InstRepLodSD:
391 
+			case kX86InstRepLodSQ:
392 
+			case kX86InstRepLodSW:
393 
+			case kX86InstRepMovSB:
394 
+			case kX86InstRepMovSD:
395 
+			case kX86InstRepMovSQ:
396 
+			case kX86InstRepMovSW:
397 
+			case kX86InstRepStoSB:
398 
+			case kX86InstRepStoSD:
399 
+			case kX86InstRepStoSQ:
400 
+			case kX86InstRepStoSW:
401 
+			case kX86InstRepECmpSB:
402 
+			case kX86InstRepECmpSD:
403 
+			case kX86InstRepECmpSQ:
404 
+			case kX86InstRepECmpSW:
405 
+			case kX86InstRepEScaSB:
406 
+			case kX86InstRepEScaSD:
407 
+			case kX86InstRepEScaSQ:
408 
+			case kX86InstRepEScaSW:
409 
+			case kX86InstRepNECmpSB:
410 
+			case kX86InstRepNECmpSD:
411 
+			case kX86InstRepNECmpSQ:
412 
+			case kX86InstRepNECmpSW:
413 
+			case kX86InstRepNEScaSB:
414 
+			case kX86InstRepNEScaSD:
415 
+			case kX86InstRepNEScaSQ:
416 
+			case kX86InstRepNEScaSW:
417 
+				// Special...
418 
+				break;
419 
+
420 
+			default:
421 
+				ASMJIT_ASSERT(0);
422 
+		}
423 
+		// ${SPECIAL_INSTRUCTION_HANDLING_END}
424 
+	}
434 425 
 }
435 426
436 427 
 X86CompilerInst::~X86CompilerInst()
... ... 
@@ -441,1139 +432,1112 @@ X86CompilerInst::~X86CompilerInst()
441 432 
 // [AsmJit::X86CompilerInst - Interface]
442 433 
 // ============================================================================
443 434
444 
-void X86CompilerInst::prepare(CompilerContext& cc)
435 
+void X86CompilerInst::prepare(CompilerContext &cc)
445 436 
 {
446 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
447 
-  X86Compiler* x86Compiler = getCompiler();
437 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
438 
+	X86Compiler *x86Compiler = this->getCompiler();
448 439
449 440 
 #define __GET_VARIABLE(__vardata__) \
450 
-  { \
451 
-    X86CompilerVar* _candidate = __vardata__; \
452 
-    \
453 
-    for (var = cur; ;) \
454 
-    { \
455 
-      if (var == _vars) \
456 
-      { \
457 
-        var = cur++; \
458 
-        var->vdata = _candidate; \
459 
-        var->vflags = 0; \
460 
-        var->regMask = 0xFFFFFFFF; \
461 
-        break; \
462 
-      } \
463 
-      \
464 
-      var--; \
465 
-      \
466 
-      if (var->vdata == _candidate) \
467 
-      { \
468 
-        break; \
469 
-      } \
470 
-    } \
471 
-    \
472 
-    ASMJIT_ASSERT(!!var); \
473 
-  }
474 
-
475 
-  _offset = x86Context._currentOffset;
476 
-
477 
-  const X86InstInfo* id = &x86InstInfo[_code];
478 
-
479 
-  uint32_t i, len = _operandsCount;
480 
-  uint32_t variablesCount = 0;
481 
-
482 
-  for (i = 0; i < len; i++)
483 
-  {
484 
-    Operand& o = _operands[i];
485 
-
486 
-    if (o.isVar())
487 
-    {
488 
-      ASMJIT_ASSERT(o.getId() != kInvalidValue);
489 
-      X86CompilerVar* vdata = x86Compiler->_getVar(o.getId());
490 
-      ASMJIT_ASSERT(!!vdata);
491 
-
492 
-      if (reinterpret_cast<Var*>(&o)->isGpVar())
493 
-      {
494 
-        if (reinterpret_cast<GpVar*>(&o)->isGpbLo()) { setInstFlag(kX86CompilerInstFlagIsGpbLoUsed); vdata->regGpbLoCount++; };
495 
-        if (reinterpret_cast<GpVar*>(&o)->isGpbHi()) { setInstFlag(kX86CompilerInstFlagIsGpbHiUsed); vdata->regGpbHiCount++; };
496 
-      }
497 
-
498 
-      if (vdata->workOffset != _offset)
499 
-      {
500 
-        if (!x86Context._isActive(vdata)) x86Context._addActive(vdata);
501 
-
502 
-        vdata->workOffset = _offset;
503 
-        variablesCount++;
504 
-      }
505 
-    }
506 
-    else if (o.isMem())
507 
-    {
508 
-      if ((o.getId() & kOperandIdTypeMask) == kOperandIdTypeVar)
509 
-      {
510 
-        X86CompilerVar* vdata = x86Compiler->_getVar(o.getId());
511 
-        ASMJIT_ASSERT(!!vdata);
512 
-
513 
-        x86Context._markMemoryUsed(vdata);
514 
-
515 
-        if (vdata->workOffset != _offset)
516 
-        {
517 
-          if (!x86Context._isActive(vdata)) x86Context._addActive(vdata);
518 
-
519 
-          vdata->workOffset = _offset;
520 
-          variablesCount++;
521 
-        }
522 
-      }
523 
-      else if ((o._mem.base & kOperandIdTypeMask) == kOperandIdTypeVar)
524 
-      {
525 
-        X86CompilerVar* vdata = x86Compiler->_getVar(o._mem.base);
526 
-        ASMJIT_ASSERT(!!vdata);
527 
-
528 
-        if (vdata->workOffset != _offset)
529 
-        {
530 
-          if (!x86Context._isActive(vdata)) x86Context._addActive(vdata);
531 
-
532 
-          vdata->workOffset = _offset;
533 
-          variablesCount++;
534 
-        }
535 
-      }
536 
-
537 
-      if ((o._mem.index & kOperandIdTypeMask) == kOperandIdTypeVar)
538 
-      {
539 
-        X86CompilerVar* vdata = x86Compiler->_getVar(o._mem.index);
540 
-        ASMJIT_ASSERT(!!vdata);
541 
-
542 
-        if (vdata->workOffset != _offset)
543 
-        {
544 
-          if (!x86Context._isActive(vdata)) x86Context._addActive(vdata);
545 
-
546 
-          vdata->workOffset = _offset;
547 
-          variablesCount++;
548 
-        }
549 
-      }
550 
-    }
551 
-  }
552 
-
553 
-  if (!variablesCount)
554 
-  {
555 
-    x86Context._currentOffset++;
556 
-    return;
557 
-  }
558 
-
559 
-  _vars = reinterpret_cast<VarAllocRecord*>(x86Compiler->getZoneMemory().alloc(sizeof(VarAllocRecord) * variablesCount));
560 
-  if (!_vars)
561 
-  {
562 
-    x86Compiler->setError(kErrorNoHeapMemory);
563 
-    x86Context._currentOffset++;
564 
-    return;
565 
-  }
566 
-
567 
-  _variablesCount = variablesCount;
568 
-
569 
-  VarAllocRecord* cur = _vars;
570 
-  VarAllocRecord* var = nullptr;
571 
-
572 
-  bool _isGpbUsed = hasInstFlag(kX86CompilerInstFlagIsGpbLoUsed) |
573 
-                    hasInstFlag(kX86CompilerInstFlagIsGpbHiUsed) ;
574 
-  uint32_t gpRestrictMask = IntUtil::maskUpToIndex(kX86RegNumGp);
575 
-
576 
-#if defined(ASMJIT_X64)
577 
-  if (hasInstFlag(kX86CompilerInstFlagIsGpbHiUsed))
578 
-  {
579 
-    gpRestrictMask &= IntUtil::maskFromIndex(kX86RegIndexEax) |
580 
-                      IntUtil::maskFromIndex(kX86RegIndexEbx) |
581 
-                      IntUtil::maskFromIndex(kX86RegIndexEcx) |
582 
-                      IntUtil::maskFromIndex(kX86RegIndexEdx) |
583 
-                      IntUtil::maskFromIndex(kX86RegIndexEbp) |
584 
-                      IntUtil::maskFromIndex(kX86RegIndexEsi) |
585 
-                      IntUtil::maskFromIndex(kX86RegIndexEdi) ;
586 
-  }
441 
+{ \
442 
+	X86CompilerVar *_candidate = __vardata__; \
443 
+\
444 
+	for (var = cur; ; ) \
445 
+	{ \
446 
+		if (var == this->_vars) \
447 
+		{ \
448 
+			var = cur++; \
449 
+			var->vdata = _candidate; \
450 
+			var->vflags = 0; \
451 
+			var->regMask = 0xFFFFFFFF; \
452 
+			break; \
453 
+		} \
454 
+\
455 
+		--var; \
456 
+\
457 
+		if (var->vdata == _candidate) \
458 
+			break; \
459 
+	} \
460 
+\
461 
+	ASMJIT_ASSERT(var); \
462 
+}
463 
+
464 
+	this->_offset = x86Context._currentOffset;
465 
+
466 
+	const X86InstInfo *id = &x86InstInfo[this->_code];
467 
+
468 
+	uint32_t i, len = _operandsCount;
469 
+	uint32_t variablesCount = 0;
470 
+
471 
+	for (i = 0; i < len; ++i)
472 
+	{
473 
+		Operand &o = this->_operands[i];
474 
+
475 
+		if (o.isVar())
476 
+		{
477 
+			ASMJIT_ASSERT(o.getId() != kInvalidValue);
478 
+			X86CompilerVar *vdata = x86Compiler->_getVar(o.getId());
479 
+			ASMJIT_ASSERT(vdata);
480 
+
481 
+			if (reinterpret_cast<Var *>(&o)->isGpVar())
482 
+			{
483 
+				if (reinterpret_cast<GpVar *>(&o)->isGpbLo())
484 
+				{
485 
+					this->setInstFlag(kX86CompilerInstFlagIsGpbLoUsed);
486 
+					++vdata->regGpbLoCount;
487 
+				}
488 
+				if (reinterpret_cast<GpVar *>(&o)->isGpbHi())
489 
+				{
490 
+					this->setInstFlag(kX86CompilerInstFlagIsGpbHiUsed);
491 
+					++vdata->regGpbHiCount;
492 
+				}
493 
+			}
494 
+
495 
+			if (vdata->workOffset != this->_offset)
496 
+			{
497 
+				if (!x86Context._isActive(vdata))
498 
+					x86Context._addActive(vdata);
499 
+
500 
+				vdata->workOffset = this->_offset;
501 
+				++variablesCount;
502 
+			}
503 
+		}
504 
+		else if (o.isMem())
505 
+		{
506 
+			if ((o.getId() & kOperandIdTypeMask) == kOperandIdTypeVar)
507 
+			{
508 
+				X86CompilerVar *vdata = x86Compiler->_getVar(o.getId());
509 
+				ASMJIT_ASSERT(vdata);
510 
+
511 
+				x86Context._markMemoryUsed(vdata);
512 
+
513 
+				if (vdata->workOffset != this->_offset)
514 
+				{
515 
+					if (!x86Context._isActive(vdata))
516 
+						x86Context._addActive(vdata);
517 
+
518 
+					vdata->workOffset = this->_offset;
519 
+					++variablesCount;
520 
+				}
521 
+			}
522 
+			else if ((o._mem.base & kOperandIdTypeMask) == kOperandIdTypeVar)
523 
+			{
524 
+				X86CompilerVar *vdata = x86Compiler->_getVar(o._mem.base);
525 
+				ASMJIT_ASSERT(vdata);
526 
+
527 
+				if (vdata->workOffset != this->_offset)
528 
+				{
529 
+					if (!x86Context._isActive(vdata))
530 
+						x86Context._addActive(vdata);
531 
+
532 
+					vdata->workOffset = this->_offset;
533 
+					++variablesCount;
534 
+				}
535 
+			}
536 
+
537 
+			if ((o._mem.index & kOperandIdTypeMask) == kOperandIdTypeVar)
538 
+			{
539 
+				X86CompilerVar *vdata = x86Compiler->_getVar(o._mem.index);
540 
+				ASMJIT_ASSERT(vdata);
541 
+
542 
+				if (vdata->workOffset != this->_offset)
543 
+				{
544 
+					if (!x86Context._isActive(vdata))
545 
+						x86Context._addActive(vdata);
546 
+
547 
+					vdata->workOffset = this->_offset;
548 
+					++variablesCount;
549 
+				}
550 
+			}
551 
+		}
552 
+	}
553 
+
554 
+	if (!variablesCount)
555 
+	{
556 
+		++x86Context._currentOffset;
557 
+		return;
558 
+	}
559 
+
560 
+	this->_vars = reinterpret_cast<VarAllocRecord *>(x86Compiler->getZoneMemory().alloc(sizeof(VarAllocRecord) * variablesCount));
561 
+	if (!this->_vars)
562 
+	{
563 
+		x86Compiler->setError(kErrorNoHeapMemory);
564 
+		++x86Context._currentOffset;
565 
+		return;
566 
+	}
567 
+
568 
+	this->_variablesCount = variablesCount;
569 
+
570 
+	VarAllocRecord *cur = this->_vars;
571 
+	VarAllocRecord *var = nullptr;
572 
+
573 
+	bool _isGpbUsed = hasInstFlag(kX86CompilerInstFlagIsGpbLoUsed) | hasInstFlag(kX86CompilerInstFlagIsGpbHiUsed);
574 
+	uint32_t gpRestrictMask = IntUtil::maskUpToIndex(kX86RegNumGp);
575 
+
576 
+#ifdef ASMJIT_X64
577 
+	if (hasInstFlag(kX86CompilerInstFlagIsGpbHiUsed))
578 
+		gpRestrictMask &= IntUtil::maskFromIndex(kX86RegIndexEax) | IntUtil::maskFromIndex(kX86RegIndexEbx) | IntUtil::maskFromIndex(kX86RegIndexEcx) | IntUtil::maskFromIndex(kX86RegIndexEdx) |
579 
+			IntUtil::maskFromIndex(kX86RegIndexEbp) | IntUtil::maskFromIndex(kX86RegIndexEsi) | IntUtil::maskFromIndex(kX86RegIndexEdi);
587 580 
 #endif // ASMJIT_X64
588 581
589 
-  for (i = 0; i < len; i++)
590 
-  {
591 
-    Operand& o = _operands[i];
592 
-
593 
-    if (o.isVar())
594 
-    {
595 
-      X86CompilerVar* vdata = x86Compiler->_getVar(o.getId());
596 
-      ASMJIT_ASSERT(!!vdata);
597 
-
598 
-      __GET_VARIABLE(vdata)
599 
-      var->vflags |= kVarAllocRegister;
600 
-
601 
-      if (_isGpbUsed)
602 
-      {
603 
-#if defined(ASMJIT_X86)
604 
-        if (reinterpret_cast<GpVar*>(&o)->isGpb())
605 
-        {
606 
-          var->regMask &= IntUtil::maskFromIndex(kX86RegIndexEax) |
607 
-                          IntUtil::maskFromIndex(kX86RegIndexEbx) |
608 
-                          IntUtil::maskFromIndex(kX86RegIndexEcx) |
609 
-                          IntUtil::maskFromIndex(kX86RegIndexEdx) ;
610 
-        }
582 
+	for (i = 0; i < len; ++i)
583 
+	{
584 
+		Operand &o = this->_operands[i];
585 
+
586 
+		if (o.isVar())
587 
+		{
588 
+			X86CompilerVar *vdata = x86Compiler->_getVar(o.getId());
589 
+			ASMJIT_ASSERT(vdata);
590 
+
591 
+			__GET_VARIABLE(vdata)
592 
+			var->vflags |= kVarAllocRegister;
593 
+
594 
+			if (_isGpbUsed)
595 
+			{
596 
+#ifdef ASMJIT_X86
597 
+				if (reinterpret_cast<GpVar *>(&o)->isGpb())
598 
+					var->regMask &= IntUtil::maskFromIndex(kX86RegIndexEax) | IntUtil::maskFromIndex(kX86RegIndexEbx) | IntUtil::maskFromIndex(kX86RegIndexEcx) | IntUtil::maskFromIndex(kX86RegIndexEdx);
611 599 
 #else
612 
-        // Restrict all BYTE registers to RAX/RBX/RCX/RDX if HI BYTE register
613 
-        // is used (REX prefix makes HI BYTE addressing unencodable).
614 
-        if (hasInstFlag(kX86CompilerInstFlagIsGpbHiUsed))
615 
-        {
616 
-          if (reinterpret_cast<GpVar*>(&o)->isGpb())
617 
-          {
618 
-            var->regMask &= IntUtil::maskFromIndex(kX86RegIndexEax) |
619 
-                            IntUtil::maskFromIndex(kX86RegIndexEbx) |
620 
-                            IntUtil::maskFromIndex(kX86RegIndexEcx) |
621 
-                            IntUtil::maskFromIndex(kX86RegIndexEdx) ;
622 
-          }
623 
-        }
600 
+				// Restrict all BYTE registers to RAX/RBX/RCX/RDX if HI BYTE register
601 
+				// is used (REX prefix makes HI BYTE addressing unencodable).
602 
+				if (hasInstFlag(kX86CompilerInstFlagIsGpbHiUsed))
603 
+				{
604 
+					if (reinterpret_cast<GpVar *>(&o)->isGpb())
605 
+						var->regMask &= IntUtil::maskFromIndex(kX86RegIndexEax) | IntUtil::maskFromIndex(kX86RegIndexEbx) | IntUtil::maskFromIndex(kX86RegIndexEcx) | IntUtil::maskFromIndex(kX86RegIndexEdx);
606 
+				}
624 607 
 #endif // ASMJIT_X86/X64
625 
-      }
626 
-
627 
-      if (isSpecial())
628 
-      {
629 
-        // ${SPECIAL_INSTRUCTION_HANDLING_BEGIN}
630 
-        switch (_code)
631 
-        {
632 
-          case kX86InstCpuId:
633 
-            switch (i)
634 
-            {
635 
-              case 0:
636 
-                vdata->regRwCount++;
637 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
638 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
639 
-                gpRestrictMask &= ~var->regMask;
640 
-                break;
641 
-              case 1:
642 
-                vdata->regWriteCount++;
643 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
644 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEbx);
645 
-                gpRestrictMask &= ~var->regMask;
646 
-                break;
647 
-              case 2:
648 
-                vdata->regWriteCount++;
649 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
650 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
651 
-                gpRestrictMask &= ~var->regMask;
652 
-                break;
653 
-              case 3:
654 
-                vdata->regWriteCount++;
655 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
656 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
657 
-                gpRestrictMask &= ~var->regMask;
658 
-                break;
659 
-
660 
-              default:
661 
-                ASMJIT_ASSERT(0);
662 
-            }
663 
-            break;
664 
-
665 
-          case kX86InstCbw:
666 
-          case kX86InstCdqe:
667 
-          case kX86InstCwde:
668 
-            switch (i)
669 
-            {
670 
-              case 0:
671 
-                vdata->regRwCount++;
672 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
673 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
674 
-                gpRestrictMask &= ~var->regMask;
675 
-                break;
676 
-
677 
-              default:
678 
-                ASMJIT_ASSERT(0);
679 
-            }
680 
-            break;
681 
-
682 
-          case kX86InstCdq:
683 
-          case kX86InstCwd:
684 
-          case kX86InstCqo:
685 
-            switch (i)
686 
-            {
687 
-              case 0:
688 
-                vdata->regWriteCount++;
689 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
690 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
691 
-                gpRestrictMask &= ~var->regMask;
692 
-                break;
693 
-              case 1:
694 
-                vdata->regReadCount++;
695 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
696 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
697 
-                gpRestrictMask &= ~var->regMask;
698 
-                break;
699 
-
700 
-              default:
701 
-                ASMJIT_ASSERT(0);
702 
-            }
703 
-            break;
704 
-
705 
-          case kX86InstCmpXCHG:
706 
-            switch (i)
707 
-            {
708 
-              case 0:
709 
-                vdata->regRwCount++;
710 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
711 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
712 
-                gpRestrictMask &= ~var->regMask;
713 
-                break;
714 
-              case 1:
715 
-                vdata->regRwCount++;
716 
-                var->vflags |= kVarAllocReadWrite;
717 
-                break;
718 
-              case 2:
719 
-                vdata->regReadCount++;
720 
-                var->vflags |= kVarAllocRead;
721 
-                break;
722 
-
723 
-              default:
724 
-                ASMJIT_ASSERT(0);
725 
-            }
726 
-            break;
727 
-
728 
-          case kX86InstCmpXCHG8B:
729 
-#if defined(ASMJIT_X64)
730 
-          case kX86InstCmpXCHG16B:
608 
+			}
609 
+
610 
+			if (this->isSpecial())
611 
+			{
612 
+				// ${SPECIAL_INSTRUCTION_HANDLING_BEGIN}
613 
+				switch (this->_code)
614 
+				{
615 
+					case kX86InstCpuId:
616 
+						switch (i)
617 
+						{
618 
+							case 0:
619 
+								++vdata->regRwCount;
620 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
621 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
622 
+								gpRestrictMask &= ~var->regMask;
623 
+								break;
624 
+							case 1:
625 
+								++vdata->regWriteCount;
626 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
627 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEbx);
628 
+								gpRestrictMask &= ~var->regMask;
629 
+								break;
630 
+							case 2:
631 
+								++vdata->regWriteCount;
632 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
633 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
634 
+								gpRestrictMask &= ~var->regMask;
635 
+								break;
636 
+							case 3:
637 
+								++vdata->regWriteCount;
638 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
639 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
640 
+								gpRestrictMask &= ~var->regMask;
641 
+								break;
642 
+
643 
+							default:
644 
+								ASMJIT_ASSERT(0);
645 
+						}
646 
+						break;
647 
+
648 
+					case kX86InstCbw:
649 
+					case kX86InstCdqe:
650 
+					case kX86InstCwde:
651 
+						switch (i)
652 
+						{
653 
+							case 0:
654 
+								++vdata->regRwCount;
655 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
656 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
657 
+								gpRestrictMask &= ~var->regMask;
658 
+								break;
659 
+
660 
+							default:
661 
+								ASMJIT_ASSERT(0);
662 
+						}
663 
+						break;
664 
+
665 
+					case kX86InstCdq:
666 
+					case kX86InstCwd:
667 
+					case kX86InstCqo:
668 
+						switch (i)
669 
+						{
670 
+							case 0:
671 
+								++vdata->regWriteCount;
672 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
673 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
674 
+								gpRestrictMask &= ~var->regMask;
675 
+								break;
676 
+							case 1:
677 
+								++vdata->regReadCount;
678 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
679 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
680 
+								gpRestrictMask &= ~var->regMask;
681 
+								break;
682 
+
683 
+							default:
684 
+								ASMJIT_ASSERT(0);
685 
+						}
686 
+						break;
687 
+
688 
+					case kX86InstCmpXCHG:
689 
+						switch (i)
690 
+						{
691 
+							case 0:
692 
+								++vdata->regRwCount;
693 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
694 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
695 
+								gpRestrictMask &= ~var->regMask;
696 
+								break;
697 
+							case 1:
698 
+								++vdata->regRwCount;
699 
+								var->vflags |= kVarAllocReadWrite;
700 
+								break;
701 
+							case 2:
702 
+								++vdata->regReadCount;
703 
+								var->vflags |= kVarAllocRead;
704 
+								break;
705 
+
706 
+							default:
707 
+								ASMJIT_ASSERT(0);
708 
+						}
709 
+						break;
710 
+
711 
+					case kX86InstCmpXCHG8B:
712 
+#ifdef ASMJIT_X64
713 
+					case kX86InstCmpXCHG16B:
731 714 
 #endif // ASMJIT_X64
732 
-            switch (i)
733 
-            {
734 
-              case 0:
735 
-                vdata->regRwCount++;
736 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
737 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
738 
-                gpRestrictMask &= ~var->regMask;
739 
-                break;
740 
-              case 1:
741 
-                vdata->regRwCount++;
742 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
743 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
744 
-                gpRestrictMask &= ~var->regMask;
745 
-                break;
746 
-              case 2:
747 
-                vdata->regReadCount++;
748 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
749 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
750 
-                gpRestrictMask &= ~var->regMask;
751 
-                break;
752 
-              case 3:
753 
-                vdata->regReadCount++;
754 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
755 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEbx);
756 
-                gpRestrictMask &= ~var->regMask;
757 
-                break;
758 
-
759 
-              default:
760 
-                ASMJIT_ASSERT(0);
761 
-            }
762 
-            break;
763 
-
764 
-#if defined(ASMJIT_X86)
765 
-          case kX86InstDaa:
766 
-          case kX86InstDas:
767 
-            ASMJIT_ASSERT(!i);
768 
-            vdata->regRwCount++;
769 
-            var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
770 
-            var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
771 
-            gpRestrictMask &= ~var->regMask;
772 
-            break;
715 
+						switch (i)
716 
+						{
717 
+							case 0:
718 
+								++vdata->regRwCount;
719 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
720 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
721 
+								gpRestrictMask &= ~var->regMask;
722 
+								break;
723 
+							case 1:
724 
+								++vdata->regRwCount;
725 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
726 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
727 
+								gpRestrictMask &= ~var->regMask;
728 
+								break;
729 
+							case 2:
730 
+								++vdata->regReadCount;
731 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
732 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
733 
+								gpRestrictMask &= ~var->regMask;
734 
+								break;
735 
+							case 3:
736 
+								++vdata->regReadCount;
737 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
738 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEbx);
739 
+								gpRestrictMask &= ~var->regMask;
740 
+								break;
741 
+
742 
+							default:
743 
+								ASMJIT_ASSERT(0);
744 
+						}
745 
+						break;
746 
+
747 
+#ifdef ASMJIT_X86
748 
+					case kX86InstDaa:
749 
+					case kX86InstDas:
750 
+						ASMJIT_ASSERT(!i);
751 
+						++vdata->regRwCount;
752 
+						var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
753 
+						var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
754 
+						gpRestrictMask &= ~var->regMask;
755 
+						break;
773 756 
 #endif // ASMJIT_X86
774 757
775 
-          case kX86InstIMul:
776 
-          case kX86InstMul:
777 
-          case kX86InstIDiv:
778 
-          case kX86InstDiv:
779 
-            switch (i)
780 
-            {
781 
-              case 0:
782 
-                vdata->regWriteCount++;
783 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
784 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
785 
-                gpRestrictMask &= ~var->regMask;
786 
-                break;
787 
-              case 1:
788 
-                vdata->regRwCount++;
789 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
790 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
791 
-                gpRestrictMask &= ~var->regMask;
792 
-                break;
793 
-              case 2:
794 
-                vdata->regReadCount++;
795 
-                var->vflags |= kVarAllocRead;
796 
-                break;
797 
-
798 
-              default:
799 
-                ASMJIT_ASSERT(0);
800 
-            }
801 
-            break;
802 
-
803 
-          case kX86InstMovPtr:
804 
-            switch (i)
805 
-            {
806 
-              case 0:
807 
-                vdata->regWriteCount++;
808 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
809 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
810 
-                gpRestrictMask &= ~var->regMask;
811 
-                break;
812 
-              case 1:
813 
-                vdata->regReadCount++;
814 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
815 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
816 
-                gpRestrictMask &= ~var->regMask;
817 
-                break;
818 
-              default:
819 
-                ASMJIT_ASSERT(0);
820 
-            }
821 
-            break;
822 
-
823 
-          case kX86InstLahf:
824 
-            ASMJIT_ASSERT(!i);
825 
-            vdata->regWriteCount++;
826 
-            var->vflags |= kVarAllocWrite | kVarAllocSpecial;
827 
-            var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
828 
-            gpRestrictMask &= ~var->regMask;
829 
-            break;
830 
-
831 
-          case kX86InstSahf:
832 
-            ASMJIT_ASSERT(!i);
833 
-            vdata->regReadCount++;
834 
-            var->vflags |= kVarAllocRead | kVarAllocSpecial;
835 
-            var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
836 
-            gpRestrictMask &= ~var->regMask;
837 
-            break;
838 
-
839 
-          case kX86InstMaskMovQ:
840 
-          case kX86InstMaskMovDQU:
841 
-            switch (i)
842 
-            {
843 
-              case 0:
844 
-                vdata->regReadCount++;
845 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
846 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
847 
-                gpRestrictMask &= ~var->regMask;
848 
-                break;
849 
-              case 1:
850 
-              case 2:
851 
-                vdata->regReadCount++;
852 
-                var->vflags |= kVarAllocRead;
853 
-                break;
854 
-            }
855 
-            break;
856 
-
857 
-          case kX86InstEnter:
858 
-          case kX86InstLeave:
859 
-            // TODO: SPECIAL INSTRUCTION.
860 
-            break;
861 
-
862 
-          case kX86InstRet:
863 
-            // TODO: SPECIAL INSTRUCTION.
864 
-            break;
865 
-
866 
-          case kX86InstMonitor:
867 
-          case kX86InstMWait:
868 
-            // TODO: MONITOR/MWAIT (COMPILER).
869 
-            break;
870 
-
871 
-          case kX86InstPop:
872 
-            // TODO: SPECIAL INSTRUCTION.
873 
-            break;
874 
-
875 
-          case kX86InstPopAD:
876 
-          case kX86InstPopFD:
877 
-          case kX86InstPopFQ:
878 
-            // TODO: SPECIAL INSTRUCTION.
879 
-            break;
880 
-
881 
-          case kX86InstPush:
882 
-            // TODO: SPECIAL INSTRUCTION.
883 
-            break;
884 
-
885 
-          case kX86InstPushAD:
886 
-          case kX86InstPushFD:
887 
-          case kX86InstPushFQ:
888 
-            // TODO: SPECIAL INSTRUCTION.
889 
-            break;
890 
-
891 
-          case kX86InstRcl:
892 
-          case kX86InstRcr:
893 
-          case kX86InstRol:
894 
-          case kX86InstRor:
895 
-          case kX86InstSal:
896 
-          case kX86InstSar:
897 
-          case kX86InstShl:
898 
-          case kX86InstShr:
899 
-            switch (i)
900 
-            {
901 
-              case 0:
902 
-                vdata->regRwCount++;
903 
-                var->vflags |= kVarAllocReadWrite;
904 
-                break;
905 
-              case 1:
906 
-                vdata->regReadCount++;
907 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
908 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
909 
-                gpRestrictMask &= ~var->regMask;
910 
-                break;
911 
-
912 
-              default:
913 
-                ASMJIT_ASSERT(0);
914 
-            }
915 
-            break;
916 
-
917 
-          case kX86InstShld:
918 
-          case kX86InstShrd:
919 
-            switch (i)
920 
-            {
921 
-              case 0:
922 
-                vdata->regRwCount++;
923 
-                var->vflags |= kVarAllocReadWrite;
924 
-                break;
925 
-              case 1:
926 
-                vdata->regReadCount++;
927 
-                var->vflags |= kVarAllocRead;
928 
-                break;
929 
-              case 2:
930 
-                vdata->regReadCount++;
931 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
932 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
933 
-                gpRestrictMask &= ~var->regMask;
934 
-                break;
935 
-
936 
-              default:
937 
-                ASMJIT_ASSERT(0);
938 
-            }
939 
-            break;
940 
-
941 
-          case kX86InstRdtsc:
942 
-          case kX86InstRdtscP:
943 
-            switch (i)
944 
-            {
945 
-              case 0:
946 
-                vdata->regWriteCount++;
947 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
948 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
949 
-                gpRestrictMask &= ~var->regMask;
950 
-                break;
951 
-              case 1:
952 
-                vdata->regWriteCount++;
953 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
954 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
955 
-                gpRestrictMask &= ~var->regMask;
956 
-                break;
957 
-              case 2:
958 
-                ASMJIT_ASSERT(_code == kX86InstRdtscP);
959 
-                vdata->regWriteCount++;
960 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
961 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
962 
-                gpRestrictMask &= ~var->regMask;
963 
-                break;
964 
-
965 
-              default:
966 
-                ASMJIT_ASSERT(0);
967 
-            }
968 
-            break;
969 
-
970 
-          case kX86InstRepLodSB:
971 
-          case kX86InstRepLodSD:
972 
-          case kX86InstRepLodSQ:
973 
-          case kX86InstRepLodSW:
974 
-            switch (i)
975 
-            {
976 
-              case 0:
977 
-                vdata->regWriteCount++;
978 
-                var->vflags |= kVarAllocWrite | kVarAllocSpecial;
979 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
980 
-                gpRestrictMask &= ~var->regMask;
981 
-                break;
982 
-              case 1:
983 
-                vdata->regReadCount++;
984 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
985 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEsi);
986 
-                gpRestrictMask &= ~var->regMask;
987 
-                break;
988 
-              case 2:
989 
-                vdata->regRwCount++;
990 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
991 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
992 
-                gpRestrictMask &= ~var->regMask;
993 
-                break;
994 
-              default:
995 
-                ASMJIT_ASSERT(0);
996 
-            }
997 
-            break;
998 
-
999 
-          case kX86InstRepMovSB:
1000 
-          case kX86InstRepMovSD:
1001 
-          case kX86InstRepMovSQ:
1002 
-          case kX86InstRepMovSW:
1003 
-          case kX86InstRepECmpSB:
1004 
-          case kX86InstRepECmpSD:
1005 
-          case kX86InstRepECmpSQ:
1006 
-          case kX86InstRepECmpSW:
1007 
-          case kX86InstRepNECmpSB:
1008 
-          case kX86InstRepNECmpSD:
1009 
-          case kX86InstRepNECmpSQ:
1010 
-          case kX86InstRepNECmpSW:
1011 
-            switch (i)
1012 
-            {
1013 
-              case 0:
1014 
-                vdata->regReadCount++;
1015 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
1016 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
1017 
-                gpRestrictMask &= ~var->regMask;
1018 
-                break;
1019 
-              case 1:
1020 
-                vdata->regReadCount++;
1021 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
1022 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEsi);
1023 
-                gpRestrictMask &= ~var->regMask;
1024 
-                break;
1025 
-              case 2:
1026 
-                vdata->regRwCount++;
1027 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
1028 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
1029 
-                gpRestrictMask &= ~var->regMask;
1030 
-                break;
1031 
-              default:
1032 
-                ASMJIT_ASSERT(0);
1033 
-            }
1034 
-            break;
1035 
-
1036 
-          case kX86InstRepStoSB:
1037 
-          case kX86InstRepStoSD:
1038 
-          case kX86InstRepStoSQ:
1039 
-          case kX86InstRepStoSW:
1040 
-            switch (i)
1041 
-            {
1042 
-              case 0:
1043 
-                vdata->regReadCount++;
1044 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
1045 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
1046 
-                gpRestrictMask &= ~var->regMask;
1047 
-                break;
1048 
-              case 1:
1049 
-                vdata->regReadCount++;
1050 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
1051 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
1052 
-                gpRestrictMask &= ~var->regMask;
1053 
-                break;
1054 
-              case 2:
1055 
-                vdata->regRwCount++;
1056 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
1057 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
1058 
-                gpRestrictMask &= ~var->regMask;
1059 
-                break;
1060 
-              default:
1061 
-                ASMJIT_ASSERT(0);
1062 
-            }
1063 
-            break;
1064 
-
1065 
-          case kX86InstRepEScaSB:
1066 
-          case kX86InstRepEScaSD:
1067 
-          case kX86InstRepEScaSQ:
1068 
-          case kX86InstRepEScaSW:
1069 
-          case kX86InstRepNEScaSB:
1070 
-          case kX86InstRepNEScaSD:
1071 
-          case kX86InstRepNEScaSQ:
1072 
-          case kX86InstRepNEScaSW:
1073 
-            switch (i)
1074 
-            {
1075 
-              case 0:
1076 
-                vdata->regReadCount++;
1077 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
1078 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
1079 
-                gpRestrictMask &= ~var->regMask;
1080 
-                break;
1081 
-              case 1:
1082 
-                vdata->regReadCount++;
1083 
-                var->vflags |= kVarAllocRead | kVarAllocSpecial;
1084 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
1085 
-                gpRestrictMask &= ~var->regMask;
1086 
-                break;
1087 
-              case 2:
1088 
-                vdata->regRwCount++;
1089 
-                var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
1090 
-                var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
1091 
-                gpRestrictMask &= ~var->regMask;
1092 
-                break;
1093 
-              default:
1094 
-                ASMJIT_ASSERT(0);
1095 
-            }
1096 
-            break;
1097 
-
1098 
-          default:
1099 
-            ASMJIT_ASSERT(0);
1100 
-        }
1101 
-        // ${SPECIAL_INSTRUCTION_HANDLING_END}
1102 
-      }
1103 
-      else
1104 
-      {
1105 
-        if (!i)
1106 
-        {
1107 
-          // CMP/TEST instruction.
1108 
-          if (id->getCode() == kX86InstCmp || id->getCode() == kX86InstTest)
1109 
-          {
1110 
-            // Read-only case.
1111 
-            vdata->regReadCount++;
1112 
-            var->vflags |= kVarAllocRead;
1113 
-          }
1114 
-          // CVTTSD2SI/CVTTSS2SI instructions.
1115 
-          else if (id->getCode() == kX86InstCvttSD2SI || id->getCode() == kX86InstCvttSS2SI)
1116 
-          {
1117 
-            // In 32-bit mode the whole destination is replaced. In 64-bit mode
1118 
-            // we need to check whether the destination operand size is 64-bits.
1119 
-#if defined(ASMJIT_X64)
1120 
-            if (_operands[0].isRegType(kX86RegTypeGpq))
1121 
-            {
758 
+					case kX86InstIMul:
759 
+					case kX86InstMul:
760 
+					case kX86InstIDiv:
761 
+					case kX86InstDiv:
762 
+						switch (i)
763 
+						{
764 
+							case 0:
765 
+								++vdata->regWriteCount;
766 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
767 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
768 
+								gpRestrictMask &= ~var->regMask;
769 
+								break;
770 
+							case 1:
771 
+								++vdata->regRwCount;
772 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
773 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
774 
+								gpRestrictMask &= ~var->regMask;
775 
+								break;
776 
+							case 2:
777 
+								++vdata->regReadCount;
778 
+								var->vflags |= kVarAllocRead;
779 
+								break;
780 
+
781 
+							default:
782 
+								ASMJIT_ASSERT(0);
783 
+						}
784 
+						break;
785 
+
786 
+					case kX86InstMovPtr:
787 
+						switch (i)
788 
+						{
789 
+							case 0:
790 
+								++vdata->regWriteCount;
791 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
792 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
793 
+								gpRestrictMask &= ~var->regMask;
794 
+								break;
795 
+							case 1:
796 
+								++vdata->regReadCount;
797 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
798 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
799 
+								gpRestrictMask &= ~var->regMask;
800 
+								break;
801 
+
802 
+							default:
803 
+								ASMJIT_ASSERT(0);
804 
+						}
805 
+						break;
806 
+
807 
+					case kX86InstLahf:
808 
+						ASMJIT_ASSERT(!i);
809 
+						++vdata->regWriteCount;
810 
+						var->vflags |= kVarAllocWrite | kVarAllocSpecial;
811 
+						var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
812 
+						gpRestrictMask &= ~var->regMask;
813 
+						break;
814 
+
815 
+					case kX86InstSahf:
816 
+						ASMJIT_ASSERT(!i);
817 
+						++vdata->regReadCount;
818 
+						var->vflags |= kVarAllocRead | kVarAllocSpecial;
819 
+						var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
820 
+						gpRestrictMask &= ~var->regMask;
821 
+						break;
822 
+
823 
+					case kX86InstMaskMovQ:
824 
+					case kX86InstMaskMovDQU:
825 
+						switch (i)
826 
+						{
827 
+							case 0:
828 
+								++vdata->regReadCount;
829 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
830 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
831 
+								gpRestrictMask &= ~var->regMask;
832 
+								break;
833 
+							case 1:
834 
+							case 2:
835 
+								++vdata->regReadCount;
836 
+								var->vflags |= kVarAllocRead;
837 
+						}
838 
+						break;
839 
+
840 
+					case kX86InstEnter:
841 
+					case kX86InstLeave:
842 
+						// TODO: SPECIAL INSTRUCTION.
843 
+						break;
844 
+
845 
+					case kX86InstRet:
846 
+						// TODO: SPECIAL INSTRUCTION.
847 
+						break;
848 
+
849 
+					case kX86InstMonitor:
850 
+					case kX86InstMWait:
851 
+						// TODO: MONITOR/MWAIT (COMPILER).
852 
+						break;
853 
+
854 
+					case kX86InstPop:
855 
+						// TODO: SPECIAL INSTRUCTION.
856 
+						break;
857 
+
858 
+					case kX86InstPopAD:
859 
+					case kX86InstPopFD:
860 
+					case kX86InstPopFQ:
861 
+						// TODO: SPECIAL INSTRUCTION.
862 
+						break;
863 
+
864 
+					case kX86InstPush:
865 
+						// TODO: SPECIAL INSTRUCTION.
866 
+						break;
867 
+
868 
+					case kX86InstPushAD:
869 
+					case kX86InstPushFD:
870 
+					case kX86InstPushFQ:
871 
+						// TODO: SPECIAL INSTRUCTION.
872 
+						break;
873 
+
874 
+					case kX86InstRcl:
875 
+					case kX86InstRcr:
876 
+					case kX86InstRol:
877 
+					case kX86InstRor:
878 
+					case kX86InstSal:
879 
+					case kX86InstSar:
880 
+					case kX86InstShl:
881 
+					case kX86InstShr:
882 
+						switch (i)
883 
+						{
884 
+							case 0:
885 
+								++vdata->regRwCount;
886 
+								var->vflags |= kVarAllocReadWrite;
887 
+								break;
888 
+							case 1:
889 
+								++vdata->regReadCount;
890 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
891 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
892 
+								gpRestrictMask &= ~var->regMask;
893 
+								break;
894 
+
895 
+							default:
896 
+								ASMJIT_ASSERT(0);
897 
+						}
898 
+						break;
899 
+
900 
+					case kX86InstShld:
901 
+					case kX86InstShrd:
902 
+						switch (i)
903 
+						{
904 
+							case 0:
905 
+								++vdata->regRwCount;
906 
+								var->vflags |= kVarAllocReadWrite;
907 
+								break;
908 
+							case 1:
909 
+								++vdata->regReadCount;
910 
+								var->vflags |= kVarAllocRead;
911 
+								break;
912 
+							case 2:
913 
+								++vdata->regReadCount;
914 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
915 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
916 
+								gpRestrictMask &= ~var->regMask;
917 
+								break;
918 
+
919 
+							default:
920 
+								ASMJIT_ASSERT(0);
921 
+						}
922 
+						break;
923 
+
924 
+					case kX86InstRdtsc:
925 
+					case kX86InstRdtscP:
926 
+						switch (i)
927 
+						{
928 
+							case 0:
929 
+								++vdata->regWriteCount;
930 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
931 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdx);
932 
+								gpRestrictMask &= ~var->regMask;
933 
+								break;
934 
+							case 1:
935 
+								++vdata->regWriteCount;
936 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
937 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
938 
+								gpRestrictMask &= ~var->regMask;
939 
+								break;
940 
+							case 2:
941 
+								ASMJIT_ASSERT(this->_code == kX86InstRdtscP);
942 
+								++vdata->regWriteCount;
943 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
944 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
945 
+								gpRestrictMask &= ~var->regMask;
946 
+								break;
947 
+
948 
+							default:
949 
+								ASMJIT_ASSERT(0);
950 
+						}
951 
+						break;
952 
+
953 
+					case kX86InstRepLodSB:
954 
+					case kX86InstRepLodSD:
955 
+					case kX86InstRepLodSQ:
956 
+					case kX86InstRepLodSW:
957 
+						switch (i)
958 
+						{
959 
+							case 0:
960 
+								++vdata->regWriteCount;
961 
+								var->vflags |= kVarAllocWrite | kVarAllocSpecial;
962 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
963 
+								gpRestrictMask &= ~var->regMask;
964 
+								break;
965 
+							case 1:
966 
+								++vdata->regReadCount;
967 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
968 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEsi);
969 
+								gpRestrictMask &= ~var->regMask;
970 
+								break;
971 
+							case 2:
972 
+								++vdata->regRwCount;
973 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
974 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
975 
+								gpRestrictMask &= ~var->regMask;
976 
+								break;
977 
+
978 
+							default:
979 
+								ASMJIT_ASSERT(0);
980 
+						}
981 
+						break;
982 
+
983 
+					case kX86InstRepMovSB:
984 
+					case kX86InstRepMovSD:
985 
+					case kX86InstRepMovSQ:
986 
+					case kX86InstRepMovSW:
987 
+					case kX86InstRepECmpSB:
988 
+					case kX86InstRepECmpSD:
989 
+					case kX86InstRepECmpSQ:
990 
+					case kX86InstRepECmpSW:
991 
+					case kX86InstRepNECmpSB:
992 
+					case kX86InstRepNECmpSD:
993 
+					case kX86InstRepNECmpSQ:
994 
+					case kX86InstRepNECmpSW:
995 
+						switch (i)
996 
+						{
997 
+							case 0:
998 
+								++vdata->regReadCount;
999 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
1000 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
1001 
+								gpRestrictMask &= ~var->regMask;
1002 
+								break;
1003 
+							case 1:
1004 
+								++vdata->regReadCount;
1005 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
1006 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEsi);
1007 
+								gpRestrictMask &= ~var->regMask;
1008 
+								break;
1009 
+							case 2:
1010 
+								++vdata->regRwCount;
1011 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
1012 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
1013 
+								gpRestrictMask &= ~var->regMask;
1014 
+								break;
1015 
+
1016 
+							default:
1017 
+								ASMJIT_ASSERT(0);
1018 
+						}
1019 
+						break;
1020 
+
1021 
+					case kX86InstRepStoSB:
1022 
+					case kX86InstRepStoSD:
1023 
+					case kX86InstRepStoSQ:
1024 
+					case kX86InstRepStoSW:
1025 
+						switch (i)
1026 
+						{
1027 
+							case 0:
1028 
+								++vdata->regReadCount;
1029 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
1030 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
1031 
+								gpRestrictMask &= ~var->regMask;
1032 
+								break;
1033 
+							case 1:
1034 
+								++vdata->regReadCount;
1035 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
1036 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
1037 
+								gpRestrictMask &= ~var->regMask;
1038 
+								break;
1039 
+							case 2:
1040 
+								++vdata->regRwCount;
1041 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
1042 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
1043 
+								gpRestrictMask &= ~var->regMask;
1044 
+								break;
1045 
+
1046 
+							default:
1047 
+								ASMJIT_ASSERT(0);
1048 
+						}
1049 
+						break;
1050 
+
1051 
+					case kX86InstRepEScaSB:
1052 
+					case kX86InstRepEScaSD:
1053 
+					case kX86InstRepEScaSQ:
1054 
+					case kX86InstRepEScaSW:
1055 
+					case kX86InstRepNEScaSB:
1056 
+					case kX86InstRepNEScaSD:
1057 
+					case kX86InstRepNEScaSQ:
1058 
+					case kX86InstRepNEScaSW:
1059 
+						switch (i)
1060 
+						{
1061 
+							case 0:
1062 
+								++vdata->regReadCount;
1063 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
1064 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEdi);
1065 
+								gpRestrictMask &= ~var->regMask;
1066 
+								break;
1067 
+							case 1:
1068 
+								++vdata->regReadCount;
1069 
+								var->vflags |= kVarAllocRead | kVarAllocSpecial;
1070 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEax);
1071 
+								gpRestrictMask &= ~var->regMask;
1072 
+								break;
1073 
+							case 2:
1074 
+								++vdata->regRwCount;
1075 
+								var->vflags |= kVarAllocReadWrite | kVarAllocSpecial;
1076 
+								var->regMask = IntUtil::maskFromIndex(kX86RegIndexEcx);
1077 
+								gpRestrictMask &= ~var->regMask;
1078 
+								break;
1079 
+
1080 
+							default:
1081 
+								ASMJIT_ASSERT(0);
1082 
+						}
1083 
+						break;
1084 
+
1085 
+					default:
1086 
+						ASMJIT_ASSERT(0);
1087 
+				}
1088 
+				// ${SPECIAL_INSTRUCTION_HANDLING_END}
1089 
+			}
1090 
+			else
1091 
+			{
1092 
+				if (!i)
1093 
+				{
1094 
+					// CMP/TEST instruction.
1095 
+					if (id->getCode() == kX86InstCmp || id->getCode() == kX86InstTest)
1096 
+					{
1097 
+						// Read-only case.
1098 
+						++vdata->regReadCount;
1099 
+						var->vflags |= kVarAllocRead;
1100 
+					}
1101 
+					// CVTTSD2SI/CVTTSS2SI instructions.
1102 
+					else if (id->getCode() == kX86InstCvttSD2SI || id->getCode() == kX86InstCvttSS2SI)
1103 
+					{
1104 
+						// In 32-bit mode the whole destination is replaced. In 64-bit mode
1105 
+						// we need to check whether the destination operand size is 64-bits.
1106 
+#ifdef ASMJIT_X64
1107 
+						if (this->_operands[0].isRegType(kX86RegTypeGpq))
1108 
+						{
1122 1109 
 #endif // ASMJIT_X64
1123 
-              // Write-only case.
1124 
-              vdata->regWriteCount++;
1125 
-              var->vflags |= kVarAllocWrite;
1126 
-#if defined(ASMJIT_X64)
1127 
-            }
1128 
-            else
1129 
-            {
1130 
-              // Read/Write.
1131 
-              vdata->regRwCount++;
1132 
-              var->vflags |= kVarAllocReadWrite;
1133 
-            }
1110 
+							// Write-only case.
1111 
+							++vdata->regWriteCount;
1112 
+							var->vflags |= kVarAllocWrite;
1113 
+#ifdef ASMJIT_X64
1114 
+						}
1115 
+						else
1116 
+						{
1117 
+							// Read/Write.
1118 
+							++vdata->regRwCount;
1119 
+							var->vflags |= kVarAllocReadWrite;
1120 
+						}
1134 1121 
 #endif // ASMJIT_X64
1135 
-          }
1136 
-          // MOV/MOVSS/MOVSD instructions.
1137 
-          //
1138 
-          // If instruction is MOV (source replaces the destination) or
1139 
-          // MOVSS/MOVSD and source operand is memory location then register
1140 
-          // allocator should know that previous destination value is lost
1141 
-          // (write only operation).
1142 
-          else if ((id->isMov()) ||
1143 
-                  ((id->getCode() == kX86InstMovSS || id->getCode() == kX86InstMovSD) /* && _operands[1].isMem() */) ||
1144 
-                  (id->getCode() == kX86InstIMul && _operandsCount == 3 && !isSpecial()))
1145 
-          {
1146 
-            // Write-only case.
1147 
-            vdata->regWriteCount++;
1148 
-            var->vflags |= kVarAllocWrite;
1149 
-          }
1150 
-          else if (id->getCode() == kX86InstLea)
1151 
-          {
1152 
-            // Write.
1153 
-            vdata->regWriteCount++;
1154 
-            var->vflags |= kVarAllocWrite;
1155 
-          }
1156 
-          else
1157 
-          {
1158 
-            // Read/Write.
1159 
-            vdata->regRwCount++;
1160 
-            var->vflags |= kVarAllocReadWrite;
1161 
-          }
1162 
-        }
1163 
-        else
1164 
-        {
1165 
-          // Second, third, ... operands are read-only.
1166 
-          vdata->regReadCount++;
1167 
-          var->vflags |= kVarAllocRead;
1168 
-        }
1169 
-
1170 
-        if (!_memOp && i < 2 && (id->_opFlags[i] & kX86InstOpMem))
1171 
-        {
1172 
-          var->vflags |= kVarAllocMem;
1173 
-        }
1174 
-      }
1175 
-
1176 
-      // If variable must be in specific register we could add some hint to allocator.
1177 
-      if (var->vflags & kVarAllocSpecial)
1178 
-      {
1179 
-        vdata->prefRegisterMask |= var->regMask;
1180 
-        x86Context._newRegisterHomeIndex(vdata, IntUtil::findFirstBit(var->regMask));
1181 
-      }
1182 
-    }
1183 
-    else if (o.isMem())
1184 
-    {
1185 
-      if ((o.getId() & kOperandIdTypeMask) == kOperandIdTypeVar)
1186 
-      {
1187 
-        X86CompilerVar* vdata = x86Compiler->_getVar(o.getId());
1188 
-        ASMJIT_ASSERT(!!vdata);
1189 
-
1190 
-        __GET_VARIABLE(vdata)
1191 
-
1192 
-        if (!i)
1193 
-        {
1194 
-          // If variable is MOV instruction type (source replaces the destination)
1195 
-          // or variable is MOVSS/MOVSD instruction then register allocator should
1196 
-          // know that previous destination value is lost (write only operation).
1197 
-          if (id->isMov() || ((id->getCode() == kX86InstMovSS || id->getCode() == kX86InstMovSD)))
1198 
-          {
1199 
-            // Write only case.
1200 
-            vdata->memWriteCount++;
1201 
-          }
1202 
-          else
1203 
-          {
1204 
-            vdata->memRwCount++;
1205 
-          }
1206 
-        }
1207 
-        else
1208 
-        {
1209 
-          vdata->memReadCount++;
1210 
-        }
1211 
-      }
1212 
-      else if ((o._mem.base & kOperandIdTypeMask) == kOperandIdTypeVar)
1213 
-      {
1214 
-        X86CompilerVar* vdata = x86Compiler->_getVar(reinterpret_cast<Mem&>(o).getBase());
1215 
-        ASMJIT_ASSERT(!!vdata);
1216 
-
1217 
-        __GET_VARIABLE(vdata)
1218 
-        vdata->regReadCount++;
1219 
-        var->vflags |= kVarAllocRegister | kVarAllocRead;
1220 
-        var->regMask &= gpRestrictMask;
1221 
-      }
1222 
-
1223 
-      if ((o._mem.index & kOperandIdTypeMask) == kOperandIdTypeVar)
1224 
-      {
1225 
-        X86CompilerVar* vdata = x86Compiler->_getVar(reinterpret_cast<Mem&>(o).getIndex());
1226 
-        ASMJIT_ASSERT(!!vdata);
1227 
-
1228 
-        __GET_VARIABLE(vdata)
1229 
-        vdata->regReadCount++;
1230 
-        var->vflags |= kVarAllocRegister | kVarAllocRead;
1231 
-        var->regMask &= gpRestrictMask;
1232 
-      }
1233 
-    }
1234 
-  }
1235 
-
1236 
-  // Traverse all variables and update firstItem / lastItem. This
1237 
-  // function is called from iterator that scans items using forward
1238 
-  // direction so we can use this knowledge to optimize the process.
1239 
-  //
1240 
-  // Similar to X86CompilerFuncCall::prepare().
1241 
-  for (i = 0; i < _variablesCount; i++)
1242 
-  {
1243 
-    X86CompilerVar* v = _vars[i].vdata;
1244 
-
1245 
-    // Update GP register allocator restrictions.
1246 
-    if (X86Util::isVarTypeInt(v->getType()))
1247 
-    {
1248 
-      if (_vars[i].regMask == 0xFFFFFFFF) _vars[i].regMask &= gpRestrictMask;
1249 
-    }
1250 
-
1251 
-    // Update first/last item (begin of variable scope).
1252 
-    if (!v->firstItem) v->firstItem = this;
1253 
-    v->lastItem = this;
1254 
-  }
1255 
-
1256 
-  // There are some instructions that can be used to clear or to set all bits
1257 
-  // in a register:
1258 
-  //
1259 
-  // - andn reg, reg        ; Set all bits in reg to 0.
1260 
-  // - xor/pxor reg, reg    ; Set all bits in reg to 0.
1261 
-  // - sub/psub reg, reg    ; Set all bits in reg to 0.
1262 
-  // - pcmpgt reg, reg      ; Set all bits in reg to 0.
1263 
-  // - pcmpeq reg, reg      ; Set all bits in reg to 1.
1264 
-  //
1265 
-  // There are also combinations which do nothing:
1266 
-  //
1267 
-  // - and reg, reg         ; Nop.
1268 
-  // - or reg, reg          ; Nop.
1269 
-  // - xchg reg, reg        ; Nop.
1270 
-
1271 
-  if (_variablesCount == 1 && _operandsCount > 1 && _operands[0].isVar() && _operands[1].isVar() && !_memOp)
1272 
-  {
1273 
-    switch (_code)
1274 
-    {
1275 
-      // ----------------------------------------------------------------------
1276 
-      // [Zeros/Ones]
1277 
-      // ----------------------------------------------------------------------
1278 
-
1279 
-      // ANDN Instructions.
1280 
-      case kX86InstPAndN:
1281 
-
1282 
-      // XOR Instructions.
1283 
-      case kX86InstXor:
1284 
-      case kX86InstXorPD:
1285 
-      case kX86InstXorPS:
1286 
-      case kX86InstPXor:
1287 
-
1288 
-      // SUB Instructions.
1289 
-      case kX86InstSub:
1290 
-      case kX86InstPSubB:
1291 
-      case kX86InstPSubW:
1292 
-      case kX86InstPSubD:
1293 
-      case kX86InstPSubQ:
1294 
-      case kX86InstPSubSB:
1295 
-      case kX86InstPSubSW:
1296 
-      case kX86InstPSubUSB:
1297 
-      case kX86InstPSubUSW:
1298 
-
1299 
-      // PCMPEQ Instructions.
1300 
-      case kX86InstPCmpEqB:
1301 
-      case kX86InstPCmpEqW:
1302 
-      case kX86InstPCmpEqD:
1303 
-      case kX86InstPCmpEqQ:
1304 
-
1305 
-      // PCMPGT Instructions.
1306 
-      case kX86InstPCmpGtB:
1307 
-      case kX86InstPCmpGtW:
1308 
-      case kX86InstPCmpGtD:
1309 
-      case kX86InstPCmpGtQ:
1310 
-        // Clear the read flag. This prevents variable alloc/spill.
1311 
-        _vars[0].vflags = kVarAllocWrite;
1312 
-        _vars[0].vdata->regReadCount--;
1313 
-        break;
1314 
-
1315 
-      // ----------------------------------------------------------------------
1316 
-      // [Nop]
1317 
-      // ----------------------------------------------------------------------
1318 
-
1319 
-      // AND Instructions.
1320 
-      case kX86InstAnd:
1321 
-      case kX86InstAndPD:
1322 
-      case kX86InstAndPS:
1323 
-      case kX86InstPAnd:
1324 
-
1325 
-      // OR Instructions.
1326 
-      case kX86InstOr:
1327 
-      case kX86InstOrPD:
1328 
-      case kX86InstOrPS:
1329 
-      case kX86InstPOr:
1330 
-
1331 
-      // XCHG Instruction.
1332 
-      case kX86InstXchg:
1333 
-
1334 
-        // Clear the write flag.
1335 
-        _vars[0].vflags = kVarAllocRead;
1336 
-        _vars[0].vdata->regWriteCount--;
1337 
-        break;
1338 
-    }
1339 
-  }
1340 
-  x86Context._currentOffset++;
1122 
+					}
1123 
+					// MOV/MOVSS/MOVSD instructions.
1124 
+					//
1125 
+					// If instruction is MOV (source replaces the destination) or
1126 
+					// MOVSS/MOVSD and source operand is memory location then register
1127 
+					// allocator should know that previous destination value is lost
1128 
+					// (write only operation).
1129 
+					else if ((id->isMov()) || ((id->getCode() == kX86InstMovSS || id->getCode() == kX86InstMovSD) /* && _operands[1].isMem() */) ||
1130 
+						(id->getCode() == kX86InstIMul && this->_operandsCount == 3 && !isSpecial()))
1131 
+					{
1132 
+						// Write-only case.
1133 
+						++vdata->regWriteCount;
1134 
+						var->vflags |= kVarAllocWrite;
1135 
+					}
1136 
+					else if (id->getCode() == kX86InstLea)
1137 
+					{
1138 
+						// Write.
1139 
+						++vdata->regWriteCount;
1140 
+						var->vflags |= kVarAllocWrite;
1141 
+					}
1142 
+					else
1143 
+					{
1144 
+						// Read/Write.
1145 
+						++vdata->regRwCount;
1146 
+						var->vflags |= kVarAllocReadWrite;
1147 
+					}
1148 
+				}
1149 
+				else
1150 
+				{
1151 
+					// Second, third, ... operands are read-only.
1152 
+					++vdata->regReadCount;
1153 
+					var->vflags |= kVarAllocRead;
1154 
+				}
1155 
+
1156 
+				if (!this->_memOp && i < 2 && (id->_opFlags[i] & kX86InstOpMem))
1157 
+					var->vflags |= kVarAllocMem;
1158 
+			}
1159 
+
1160 
+			// If variable must be in specific register we could add some hint to allocator.
1161 
+			if (var->vflags & kVarAllocSpecial)
1162 
+			{
1163 
+				vdata->prefRegisterMask |= var->regMask;
1164 
+				x86Context._newRegisterHomeIndex(vdata, IntUtil::findFirstBit(var->regMask));
1165 
+			}
1166 
+		}
1167 
+		else if (o.isMem())
1168 
+		{
1169 
+			if ((o.getId() & kOperandIdTypeMask) == kOperandIdTypeVar)
1170 
+			{
1171 
+				X86CompilerVar *vdata = x86Compiler->_getVar(o.getId());
1172 
+				ASMJIT_ASSERT(vdata);
1173 
+
1174 
+				__GET_VARIABLE(vdata)
1175 
+
1176 
+				if (!i)
1177 
+				{
1178 
+					// If variable is MOV instruction type (source replaces the destination)
1179 
+					// or variable is MOVSS/MOVSD instruction then register allocator should
1180 
+					// know that previous destination value is lost (write only operation).
1181 
+					if (id->isMov() || (id->getCode() == kX86InstMovSS || id->getCode() == kX86InstMovSD))
1182 
+						// Write only case.
1183 
+						++vdata->memWriteCount;
1184 
+					else
1185 
+						++vdata->memRwCount;
1186 
+				}
1187 
+				else
1188 
+					++vdata->memReadCount;
1189 
+			}
1190 
+			else if ((o._mem.base & kOperandIdTypeMask) == kOperandIdTypeVar)
1191 
+			{
1192 
+				X86CompilerVar *vdata = x86Compiler->_getVar(reinterpret_cast<Mem &>(o).getBase());
1193 
+				ASMJIT_ASSERT(vdata);
1194 
+
1195 
+				__GET_VARIABLE(vdata)
1196 
+				++vdata->regReadCount;
1197 
+				var->vflags |= kVarAllocRegister | kVarAllocRead;
1198 
+				var->regMask &= gpRestrictMask;
1199 
+			}
1200 
+
1201 
+			if ((o._mem.index & kOperandIdTypeMask) == kOperandIdTypeVar)
1202 
+			{
1203 
+				X86CompilerVar *vdata = x86Compiler->_getVar(reinterpret_cast<Mem &>(o).getIndex());
1204 
+				ASMJIT_ASSERT(vdata);
1205 
+
1206 
+				__GET_VARIABLE(vdata)
1207 
+				++vdata->regReadCount;
1208 
+				var->vflags |= kVarAllocRegister | kVarAllocRead;
1209 
+				var->regMask &= gpRestrictMask;
1210 
+			}
1211 
+		}
1212 
+	}
1213 
+
1214 
+	// Traverse all variables and update firstItem / lastItem. This
1215 
+	// function is called from iterator that scans items using forward
1216 
+	// direction so we can use this knowledge to optimize the process.
1217 
+	//
1218 
+	// Similar to X86CompilerFuncCall::prepare().
1219 
+	for (i = 0; i < this->_variablesCount; ++i)
1220 
+	{
1221 
+		X86CompilerVar *v = this->_vars[i].vdata;
1222 
+
1223 
+		// Update GP register allocator restrictions.
1224 
+		if (X86Util::isVarTypeInt(v->getType()) && this->_vars[i].regMask == 0xFFFFFFFF)
1225 
+			this->_vars[i].regMask &= gpRestrictMask;
1226 
+
1227 
+		// Update first/last item (begin of variable scope).
1228 
+		if (!v->firstItem)
1229 
+			v->firstItem = this;
1230 
+		v->lastItem = this;
1231 
+	}
1232 
+
1233 
+	// There are some instructions that can be used to clear or to set all bits
1234 
+	// in a register:
1235 
+	//
1236 
+	// - andn reg, reg        ; Set all bits in reg to 0.
1237 
+	// - xor/pxor reg, reg    ; Set all bits in reg to 0.
1238 
+	// - sub/psub reg, reg    ; Set all bits in reg to 0.
1239 
+	// - pcmpgt reg, reg      ; Set all bits in reg to 0.
1240 
+	// - pcmpeq reg, reg      ; Set all bits in reg to 1.
1241 
+	//
1242 
+	// There are also combinations which do nothing:
1243 
+	//
1244 
+	// - and reg, reg         ; Nop.
1245 
+	// - or reg, reg          ; Nop.
1246 
+	// - xchg reg, reg        ; Nop.
1247 
+
1248 
+	if (this->_variablesCount == 1 && this->_operandsCount > 1 && this->_operands[0].isVar() && this->_operands[1].isVar() && !this->_memOp)
1249 
+	{
1250 
+		switch (this->_code)
1251 
+		{
1252 
+			// ----------------------------------------------------------------------
1253 
+			// [Zeros/Ones]
1254 
+			// ----------------------------------------------------------------------
1255 
+
1256 
+			// ANDN Instructions.
1257 
+			case kX86InstPAndN:
1258 
+			// XOR Instructions.
1259 
+			case kX86InstXor:
1260 
+			case kX86InstXorPD:
1261 
+			case kX86InstXorPS:
1262 
+			case kX86InstPXor:
1263 
+			// SUB Instructions.
1264 
+			case kX86InstSub:
1265 
+			case kX86InstPSubB:
1266 
+			case kX86InstPSubW:
1267 
+			case kX86InstPSubD:
1268 
+			case kX86InstPSubQ:
1269 
+			case kX86InstPSubSB:
1270 
+			case kX86InstPSubSW:
1271 
+			case kX86InstPSubUSB:
1272 
+			case kX86InstPSubUSW:
1273 
+			// PCMPEQ Instructions.
1274 
+			case kX86InstPCmpEqB:
1275 
+			case kX86InstPCmpEqW:
1276 
+			case kX86InstPCmpEqD:
1277 
+			case kX86InstPCmpEqQ:
1278 
+			// PCMPGT Instructions.
1279 
+			case kX86InstPCmpGtB:
1280 
+			case kX86InstPCmpGtW:
1281 
+			case kX86InstPCmpGtD:
1282 
+			case kX86InstPCmpGtQ:
1283 
+				// Clear the read flag. This prevents variable alloc/spill.
1284 
+				this->_vars[0].vflags = kVarAllocWrite;
1285 
+				--this->_vars[0].vdata->regReadCount;
1286 
+				break;
1287 
+
1288 
+			// ----------------------------------------------------------------------
1289 
+			// [Nop]
1290 
+			// ----------------------------------------------------------------------
1291 
+
1292 
+			// AND Instructions.
1293 
+			case kX86InstAnd:
1294 
+			case kX86InstAndPD:
1295 
+			case kX86InstAndPS:
1296 
+			case kX86InstPAnd:
1297 
+			// OR Instructions.
1298 
+			case kX86InstOr:
1299 
+			case kX86InstOrPD:
1300 
+			case kX86InstOrPS:
1301 
+			case kX86InstPOr:
1302 
+			// XCHG Instruction.
1303 
+			case kX86InstXchg:
1304 
+				// Clear the write flag.
1305 
+				this->_vars[0].vflags = kVarAllocRead;
1306 
+				--this->_vars[0].vdata->regWriteCount;
1307 
+				break;
1308 
+		}
1309 
+	}
1310 
+	++x86Context._currentOffset;
1341 1311
1342 1312 
 #undef __GET_VARIABLE
1343 1313 
 }
1344 1314
1345 
-CompilerItem* X86CompilerInst::translate(CompilerContext& cc)
1315 
+CompilerItem *X86CompilerInst::translate(CompilerContext &cc)
1346 1316 
 {
1347 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
1348 
-  X86Compiler* x86Compiler = getCompiler();
1349 
-
1350 
-  uint32_t i;
1351 
-  uint32_t variablesCount = _variablesCount;
1352 
-
1353 
-  if (variablesCount > 0)
1354 
-  {
1355 
-    // These variables are used by the instruction and we set current offset
1356 
-    // to their work offsets -> getSpillCandidate never return the variable
1357 
-    // used this instruction.
1358 
-    for (i = 0; i < variablesCount; i++)
1359 
-    {
1360 
-      _vars[i].vdata->workOffset = x86Context._currentOffset;
1361 
-    }
1362 
-
1363 
-    // Alloc variables used by the instruction (special first).
1364 
-    for (i = 0; i < variablesCount; i++)
1365 
-    {
1366 
-      VarAllocRecord& r = _vars[i];
1367 
-      // Alloc variables with specific register first.
1368 
-      if (r.vflags & kVarAllocSpecial)
1369 
-        x86Context.allocVar(r.vdata, r.regMask, r.vflags);
1370 
-    }
1371 
-
1372 
-    for (i = 0; i < variablesCount; i++)
1373 
-    {
1374 
-      VarAllocRecord& r = _vars[i];
1375 
-      // Alloc variables without specific register last.
1376 
-      if (!(r.vflags & kVarAllocSpecial))
1377 
-        x86Context.allocVar(r.vdata, r.regMask, r.vflags);
1378 
-    }
1379 
-
1380 
-    x86Context.translateOperands(_operands, _operandsCount);
1381 
-  }
1382 
-
1383 
-  if (_memOp && (_memOp->getId() & kOperandIdTypeMask) == kOperandIdTypeVar)
1384 
-  {
1385 
-    X86CompilerVar* cv = x86Compiler->_getVar(_memOp->getId());
1386 
-    ASMJIT_ASSERT(!!cv);
1387 
-
1388 
-    switch (cv->state)
1389 
-    {
1390 
-      case kVarStateUnused:
1391 
-        cv->state = kVarStateMem;
1392 
-        break;
1393 
-      case kVarStateReg:
1394 
-        cv->changed = false;
1395 
-        x86Context.unuseVar(cv, kVarStateMem);
1396 
-        break;
1397 
-    }
1398 
-  }
1399 
-
1400 
-  for (i = 0; i < variablesCount; i++)
1401 
-  {
1402 
-    x86Context._unuseVarOnEndOfScope(this, &_vars[i]);
1403 
-  }
1404 
-
1405 
-  return translated();
1317 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
1318 
+	X86Compiler *x86Compiler = this->getCompiler();
1319 
+
1320 
+	uint32_t i;
1321 
+	uint32_t variablesCount = this->_variablesCount;
1322 
+
1323 
+	if (variablesCount > 0)
1324 
+	{
1325 
+		// These variables are used by the instruction and we set current offset
1326 
+		// to their work offsets -> getSpillCandidate never return the variable
1327 
+		// used this instruction.
1328 
+		for (i = 0; i < variablesCount; ++i)
1329 
+			this->_vars[i].vdata->workOffset = x86Context._currentOffset;
1330 
+
1331 
+		// Alloc variables used by the instruction (special first).
1332 
+		for (i = 0; i < variablesCount; ++i)
1333 
+		{
1334 
+			VarAllocRecord &r = this->_vars[i];
1335 
+			// Alloc variables with specific register first.
1336 
+			if (r.vflags & kVarAllocSpecial)
1337 
+				x86Context.allocVar(r.vdata, r.regMask, r.vflags);
1338 
+		}
1339 
+
1340 
+		for (i = 0; i < variablesCount; ++i)
1341 
+		{
1342 
+			VarAllocRecord &r = this->_vars[i];
1343 
+			// Alloc variables without specific register last.
1344 
+			if (!(r.vflags & kVarAllocSpecial))
1345 
+				x86Context.allocVar(r.vdata, r.regMask, r.vflags);
1346 
+		}
1347 
+
1348 
+		x86Context.translateOperands(this->_operands, this->_operandsCount);
1349 
+	}
1350 
+
1351 
+	if (this->_memOp && (this->_memOp->getId() & kOperandIdTypeMask) == kOperandIdTypeVar)
1352 
+	{
1353 
+		X86CompilerVar *cv = x86Compiler->_getVar(this->_memOp->getId());
1354 
+		ASMJIT_ASSERT(cv);
1355 
+
1356 
+		switch (cv->state)
1357 
+		{
1358 
+			case kVarStateUnused:
1359 
+				cv->state = kVarStateMem;
1360 
+				break;
1361 
+			case kVarStateReg:
1362 
+				cv->changed = false;
1363 
+				x86Context.unuseVar(cv, kVarStateMem);
1364 
+		}
1365 
+	}
1366 
+
1367 
+	for (i = 0; i < variablesCount; ++i)
1368 
+		x86Context._unuseVarOnEndOfScope(this, &this->_vars[i]);
1369 
+
1370 
+	return this->translated();
1406 1371 
 }
1407 1372
1408 
-void X86CompilerInst::emit(Assembler& a)
1373 
+void X86CompilerInst::emit(Assembler &a)
1409 1374 
 {
1410 
-  X86Assembler& x86Asm = static_cast<X86Assembler&>(a);
1411 
-
1412 
-  x86Asm._inlineComment = _comment;
1413 
-  x86Asm._emitOptions = _emitOptions;
1414 
-
1415 
-  if (isSpecial())
1416 
-  {
1417 
-    // ${SPECIAL_INSTRUCTION_HANDLING_BEGIN}
1418 
-    switch (_code)
1419 
-    {
1420 
-      case kX86InstCpuId:
1421 
-        x86Asm._emitInstruction(_code);
1422 
-        return;
1423 
-
1424 
-      case kX86InstCbw:
1425 
-      case kX86InstCdq:
1426 
-      case kX86InstCdqe:
1427 
-      case kX86InstCwd:
1428 
-      case kX86InstCwde:
1429 
-      case kX86InstCqo:
1430 
-        x86Asm._emitInstruction(_code);
1431 
-        return;
1432 
-
1433 
-      case kX86InstCmpXCHG:
1434 
-        x86Asm._emitInstruction(_code, &_operands[1], &_operands[2]);
1435 
-        return;
1436 
-
1437 
-      case kX86InstCmpXCHG8B:
1438 
-#if defined(ASMJIT_X64)
1439 
-      case kX86InstCmpXCHG16B:
1375 
+	X86Assembler &x86Asm = static_cast<X86Assembler &>(a);
1376 
+
1377 
+	x86Asm._inlineComment = this->_comment;
1378 
+	x86Asm._emitOptions = this->_emitOptions;
1379 
+
1380 
+	if (this->isSpecial())
1381 
+	{
1382 
+		// ${SPECIAL_INSTRUCTION_HANDLING_BEGIN}
1383 
+		switch (this->_code)
1384 
+		{
1385 
+			case kX86InstCpuId:
1386 
+				x86Asm._emitInstruction(this->_code);
1387 
+				return;
1388 
+
1389 
+			case kX86InstCbw:
1390 
+			case kX86InstCdq:
1391 
+			case kX86InstCdqe:
1392 
+			case kX86InstCwd:
1393 
+			case kX86InstCwde:
1394 
+			case kX86InstCqo:
1395 
+				x86Asm._emitInstruction(this->_code);
1396 
+				return;
1397 
+
1398 
+			case kX86InstCmpXCHG:
1399 
+				x86Asm._emitInstruction(this->_code, &this->_operands[1], &this->_operands[2]);
1400 
+				return;
1401 
+
1402 
+			case kX86InstCmpXCHG8B:
1403 
+#ifdef ASMJIT_X64
1404 
+			case kX86InstCmpXCHG16B:
1440 1405 
 #endif // ASMJIT_X64
1441 
-        x86Asm._emitInstruction(_code, &_operands[4]);
1442 
-        return;
1443 
-
1444 
-#if defined(ASMJIT_X86)
1445 
-      case kX86InstDaa:
1446 
-      case kX86InstDas:
1447 
-        x86Asm._emitInstruction(_code);
1448 
-        return;
1406 
+				x86Asm._emitInstruction(this->_code, &this->_operands[4]);
1407 
+				return;
1408 
+
1409 
+#ifdef ASMJIT_X86
1410 
+			case kX86InstDaa:
1411 
+			case kX86InstDas:
1412 
+				x86Asm._emitInstruction(this->_code);
1413 
+				return;
1449 1414 
 #endif // ASMJIT_X86
1450 1415
1451 
-      case kX86InstIMul:
1452 
-      case kX86InstMul:
1453 
-      case kX86InstIDiv:
1454 
-      case kX86InstDiv:
1455 
-        // INST dst_lo (implicit), dst_hi (implicit), src (explicit)
1456 
-        ASMJIT_ASSERT(_operandsCount == 3);
1457 
-        x86Asm._emitInstruction(_code, &_operands[2]);
1458 
-        return;
1459 
-
1460 
-      case kX86InstMovPtr:
1461 
-        break;
1462 
-
1463 
-      case kX86InstLahf:
1464 
-      case kX86InstSahf:
1465 
-        x86Asm._emitInstruction(_code);
1466 
-        return;
1467 
-
1468 
-      case kX86InstMaskMovQ:
1469 
-      case kX86InstMaskMovDQU:
1470 
-        x86Asm._emitInstruction(_code, &_operands[1], &_operands[2]);
1471 
-        return;
1472 
-
1473 
-      case kX86InstEnter:
1474 
-      case kX86InstLeave:
1475 
-        // TODO: SPECIAL INSTRUCTION.
1476 
-        break;
1477 
-
1478 
-      case kX86InstRet:
1479 
-        // TODO: SPECIAL INSTRUCTION.
1480 
-        break;
1481 
-
1482 
-      case kX86InstMonitor:
1483 
-      case kX86InstMWait:
1484 
-        // TODO: MONITOR/MWAIT (COMPILER).
1485 
-        break;
1486 
-
1487 
-      case kX86InstPop:
1488 
-      case kX86InstPopAD:
1489 
-      case kX86InstPopFD:
1490 
-      case kX86InstPopFQ:
1491 
-        // TODO: SPECIAL INSTRUCTION.
1492 
-        break;
1493 
-
1494 
-      case kX86InstPush:
1495 
-      case kX86InstPushAD:
1496 
-      case kX86InstPushFD:
1497 
-      case kX86InstPushFQ:
1498 
-        // TODO: SPECIAL INSTRUCTION.
1499 
-        break;
1500 
-
1501 
-      case kX86InstRcl:
1502 
-      case kX86InstRcr:
1503 
-      case kX86InstRol:
1504 
-      case kX86InstRor:
1505 
-      case kX86InstSal:
1506 
-      case kX86InstSar:
1507 
-      case kX86InstShl:
1508 
-      case kX86InstShr:
1509 
-        x86Asm._emitInstruction(_code, &_operands[0], &cl);
1510 
-        return;
1511 
-
1512 
-      case kX86InstShld:
1513 
-      case kX86InstShrd:
1514 
-        x86Asm._emitInstruction(_code, &_operands[0], &_operands[1], &cl);
1515 
-        return;
1516 
-
1517 
-      case kX86InstRdtsc:
1518 
-      case kX86InstRdtscP:
1519 
-        x86Asm._emitInstruction(_code);
1520 
-        return;
1521 
-
1522 
-      case kX86InstRepLodSB:
1523 
-      case kX86InstRepLodSD:
1524 
-      case kX86InstRepLodSQ:
1525 
-      case kX86InstRepLodSW:
1526 
-      case kX86InstRepMovSB:
1527 
-      case kX86InstRepMovSD:
1528 
-      case kX86InstRepMovSQ:
1529 
-      case kX86InstRepMovSW:
1530 
-      case kX86InstRepStoSB:
1531 
-      case kX86InstRepStoSD:
1532 
-      case kX86InstRepStoSQ:
1533 
-      case kX86InstRepStoSW:
1534 
-      case kX86InstRepECmpSB:
1535 
-      case kX86InstRepECmpSD:
1536 
-      case kX86InstRepECmpSQ:
1537 
-      case kX86InstRepECmpSW:
1538 
-      case kX86InstRepEScaSB:
1539 
-      case kX86InstRepEScaSD:
1540 
-      case kX86InstRepEScaSQ:
1541 
-      case kX86InstRepEScaSW:
1542 
-      case kX86InstRepNECmpSB:
1543 
-      case kX86InstRepNECmpSD:
1544 
-      case kX86InstRepNECmpSQ:
1545 
-      case kX86InstRepNECmpSW:
1546 
-      case kX86InstRepNEScaSB:
1547 
-      case kX86InstRepNEScaSD:
1548 
-      case kX86InstRepNEScaSQ:
1549 
-      case kX86InstRepNEScaSW:
1550 
-        x86Asm._emitInstruction(_code);
1551 
-        return;
1552 
-
1553 
-      default:
1554 
-        ASMJIT_ASSERT(0);
1555 
-    }
1556 
-    // ${SPECIAL_INSTRUCTION_HANDLING_END}
1557 
-  }
1558 
-
1559 
-  switch (_operandsCount)
1560 
-  {
1561 
-    case 0:
1562 
-      x86Asm._emitInstruction(_code);
1563 
-      break;
1564 
-    case 1:
1565 
-      x86Asm._emitInstruction(_code, &_operands[0]);
1566 
-      break;
1567 
-    case 2:
1568 
-      x86Asm._emitInstruction(_code, &_operands[0], &_operands[1]);
1569 
-      break;
1570 
-    case 3:
1571 
-      x86Asm._emitInstruction(_code, &_operands[0], &_operands[1], &_operands[2]);
1572 
-      break;
1573 
-    default:
1574 
-      ASMJIT_ASSERT(0);
1575 
-      break;
1576 
-  }
1416 
+			case kX86InstIMul:
1417 
+			case kX86InstMul:
1418 
+			case kX86InstIDiv:
1419 
+			case kX86InstDiv:
1420 
+				// INST dst_lo (implicit), dst_hi (implicit), src (explicit)
1421 
+				ASMJIT_ASSERT(this->_operandsCount == 3);
1422 
+				x86Asm._emitInstruction(this->_code, &this->_operands[2]);
1423 
+				return;
1424 
+
1425 
+			case kX86InstMovPtr:
1426 
+				break;
1427 
+
1428 
+			case kX86InstLahf:
1429 
+			case kX86InstSahf:
1430 
+				x86Asm._emitInstruction(this->_code);
1431 
+				return;
1432 
+
1433 
+			case kX86InstMaskMovQ:
1434 
+			case kX86InstMaskMovDQU:
1435 
+				x86Asm._emitInstruction(this->_code, &this->_operands[1], &this->_operands[2]);
1436 
+				return;
1437 
+
1438 
+			case kX86InstEnter:
1439 
+			case kX86InstLeave:
1440 
+				// TODO: SPECIAL INSTRUCTION.
1441 
+				break;
1442 
+
1443 
+			case kX86InstRet:
1444 
+				// TODO: SPECIAL INSTRUCTION.
1445 
+				break;
1446 
+
1447 
+			case kX86InstMonitor:
1448 
+			case kX86InstMWait:
1449 
+				// TODO: MONITOR/MWAIT (COMPILER).
1450 
+				break;
1451 
+
1452 
+			case kX86InstPop:
1453 
+			case kX86InstPopAD:
1454 
+			case kX86InstPopFD:
1455 
+			case kX86InstPopFQ:
1456 
+				// TODO: SPECIAL INSTRUCTION.
1457 
+				break;
1458 
+
1459 
+			case kX86InstPush:
1460 
+			case kX86InstPushAD:
1461 
+			case kX86InstPushFD:
1462 
+			case kX86InstPushFQ:
1463 
+				// TODO: SPECIAL INSTRUCTION.
1464 
+				break;
1465 
+
1466 
+			case kX86InstRcl:
1467 
+			case kX86InstRcr:
1468 
+			case kX86InstRol:
1469 
+			case kX86InstRor:
1470 
+			case kX86InstSal:
1471 
+			case kX86InstSar:
1472 
+			case kX86InstShl:
1473 
+			case kX86InstShr:
1474 
+				x86Asm._emitInstruction(this->_code, &this->_operands[0], &cl);
1475 
+				return;
1476 
+
1477 
+			case kX86InstShld:
1478 
+			case kX86InstShrd:
1479 
+				x86Asm._emitInstruction(this->_code, &this->_operands[0], &this->_operands[1], &cl);
1480 
+				return;
1481 
+
1482 
+			case kX86InstRdtsc:
1483 
+			case kX86InstRdtscP:
1484 
+				x86Asm._emitInstruction(this->_code);
1485 
+				return;
1486 
+
1487 
+			case kX86InstRepLodSB:
1488 
+			case kX86InstRepLodSD:
1489 
+			case kX86InstRepLodSQ:
1490 
+			case kX86InstRepLodSW:
1491 
+			case kX86InstRepMovSB:
1492 
+			case kX86InstRepMovSD:
1493 
+			case kX86InstRepMovSQ:
1494 
+			case kX86InstRepMovSW:
1495 
+			case kX86InstRepStoSB:
1496 
+			case kX86InstRepStoSD:
1497 
+			case kX86InstRepStoSQ:
1498 
+			case kX86InstRepStoSW:
1499 
+			case kX86InstRepECmpSB:
1500 
+			case kX86InstRepECmpSD:
1501 
+			case kX86InstRepECmpSQ:
1502 
+			case kX86InstRepECmpSW:
1503 
+			case kX86InstRepEScaSB:
1504 
+			case kX86InstRepEScaSD:
1505 
+			case kX86InstRepEScaSQ:
1506 
+			case kX86InstRepEScaSW:
1507 
+			case kX86InstRepNECmpSB:
1508 
+			case kX86InstRepNECmpSD:
1509 
+			case kX86InstRepNECmpSQ:
1510 
+			case kX86InstRepNECmpSW:
1511 
+			case kX86InstRepNEScaSB:
1512 
+			case kX86InstRepNEScaSD:
1513 
+			case kX86InstRepNEScaSQ:
1514 
+			case kX86InstRepNEScaSW:
1515 
+				x86Asm._emitInstruction(this->_code);
1516 
+				return;
1517 
+
1518 
+			default:
1519 
+				ASMJIT_ASSERT(0);
1520 
+		}
1521 
+		// ${SPECIAL_INSTRUCTION_HANDLING_END}
1522 
+	}
1523 
+
1524 
+	switch (this->_operandsCount)
1525 
+	{
1526 
+		case 0:
1527 
+			x86Asm._emitInstruction(this->_code);
1528 
+			break;
1529 
+		case 1:
1530 
+			x86Asm._emitInstruction(this->_code, &this->_operands[0]);
1531 
+			break;
1532 
+		case 2:
1533 
+			x86Asm._emitInstruction(this->_code, &this->_operands[0], &this->_operands[1]);
1534 
+			break;
1535 
+		case 3:
1536 
+			x86Asm._emitInstruction(this->_code, &this->_operands[0], &this->_operands[1], &this->_operands[2]);
1537 
+			break;
1538 
+		default:
1539 
+			ASMJIT_ASSERT(0);
1540 
+	}
1577 1541 
 }
1578 1542
1579 1543 
 // ============================================================================
... ... 
@@ -1582,44 +1546,41 @@ void X86CompilerInst::emit(Assembler& a)
1582 1546
1583 1547 
 int X86CompilerInst::getMaxSize() const
1584 1548 
 {
1585 
-  // TODO: Instruction max size.
1586 
-  return 15;
1549 
+	// TODO: Instruction max size.
1550 
+	return 15;
1587 1551 
 }
1588 1552
1589 
-bool X86CompilerInst::_tryUnuseVar(CompilerVar* _v)
1553 
+bool X86CompilerInst::_tryUnuseVar(CompilerVar *_v)
1590 1554 
 {
1591 
-  X86CompilerVar* cv = static_cast<X86CompilerVar*>(_v);
1592 
-
1593 
-  for (uint32_t i = 0; i < _variablesCount; i++)
1594 
-  {
1595 
-    if (_vars[i].vdata == cv)
1596 
-    {
1597 
-      _vars[i].vflags |= kVarAllocUnuseAfterUse;
1598 
-      return true;
1599 
-    }
1600 
-  }
1601 
-
1602 
-  return false;
1555 
+	X86CompilerVar *cv = static_cast<X86CompilerVar *>(_v);
1556 
+
1557 
+	for (uint32_t i = 0; i < this->_variablesCount; ++i)
1558 
+		if (this->_vars[i].vdata == cv)
1559 
+		{
1560 
+			this->_vars[i].vflags |= kVarAllocUnuseAfterUse;
1561 
+			return true;
1562 
+		}
1563 
+
1564 
+	return false;
1603 1565 
 }
1604 1566
1605 1567 
 // ============================================================================
1606 1568 
 // [AsmJit::X86CompilerJmpInst - Construction / Destruction]
1607 1569 
 // ============================================================================
1608 1570
1609 
-X86CompilerJmpInst::X86CompilerJmpInst(X86Compiler* x86Compiler, uint32_t code, Operand* opData, uint32_t opCount) :
1610 
-  X86CompilerInst(x86Compiler, code, opData, opCount)
1571 
+X86CompilerJmpInst::X86CompilerJmpInst(X86Compiler *x86Compiler, uint32_t code, Operand *opData, uint32_t opCount) : X86CompilerInst(x86Compiler, code, opData, opCount)
1611 1572 
 {
1612 
-  _jumpTarget = x86Compiler->_getTarget(_operands[0].getId());
1613 
-  _jumpTarget->_jumpsCount++;
1573 
+	this->_jumpTarget = x86Compiler->_getTarget(this->_operands[0].getId());
1574 
+	++this->_jumpTarget->_jumpsCount;
1614 1575
1615 
-  _jumpNext = static_cast<X86CompilerJmpInst*>(_jumpTarget->_from);
1616 
-  _jumpTarget->_from = this;
1576 
+	this->_jumpNext = static_cast<X86CompilerJmpInst *>(this->_jumpTarget->_from);
1577 
+	this->_jumpTarget->_from = this;
1617 1578
1618 
-  // The 'jmp' is always taken, conditional jump can contain hint, we detect it.
1619 
-  if (getCode() == kX86InstJmp)
1620 
-    setInstFlag(kX86CompilerInstFlagIsTaken);
1621 
-  else if (opCount > 1 && opData[1].isImm() && reinterpret_cast<Imm*>(&opData[1])->getValue() == kCondHintLikely)
1622 
-    setInstFlag(kX86CompilerInstFlagIsTaken);
1579 
+	// The 'jmp' is always taken, conditional jump can contain hint, we detect it.
1580 
+	if (this->getCode() == kX86InstJmp)
1581 
+		this->setInstFlag(kX86CompilerInstFlagIsTaken);
1582 
+	else if (opCount > 1 && opData[1].isImm() && reinterpret_cast<Imm *>(&opData[1])->getValue() == kCondHintLikely)
1583 
+		this->setInstFlag(kX86CompilerInstFlagIsTaken);
1623 1584 
 }
1624 1585
1625 1586 
 X86CompilerJmpInst::~X86CompilerJmpInst()
... ... 
@@ -1630,196 +1591,194 @@ X86CompilerJmpInst::~X86CompilerJmpInst()
1630 1591 
 // [AsmJit::X86CompilerJmpInst - Interface]
1631 1592 
 // ============================================================================
1632 1593
1633 
-void X86CompilerJmpInst::prepare(CompilerContext& cc)
1594 
+void X86CompilerJmpInst::prepare(CompilerContext &cc)
1634 1595 
 {
1635 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
1636 
-  _offset = x86Context._currentOffset;
1637 
-
1638 
-  // Update _isTaken to true if this is conditional backward jump. This behavior
1639 
-  // can be overridden by using kCondHintUnlikely when using the instruction.
1640 
-  if (getCode() != kX86InstJmp && _operandsCount == 1 && _jumpTarget->getOffset() < getOffset())
1641 
-  {
1642 
-    setInstFlag(kX86CompilerInstFlagIsTaken);
1643 
-  }
1644 
-
1645 
-  // Now patch all variables where jump location is in the active range.
1646 
-  if (_jumpTarget->getOffset() != kInvalidValue && x86Context._active)
1647 
-  {
1648 
-    X86CompilerVar* first = static_cast<X86CompilerVar*>(x86Context._active);
1649 
-    X86CompilerVar* var = first;
1650 
-    uint32_t jumpOffset = _jumpTarget->getOffset();
1651 
-
1652 
-    do {
1653 
-      if (var->firstItem)
1654 
-      {
1655 
-        ASMJIT_ASSERT(!!var->lastItem);
1656 
-        uint32_t start = var->firstItem->getOffset();
1657 
-        uint32_t end = var->lastItem->getOffset();
1658 
-
1659 
-        if (jumpOffset >= start && jumpOffset <= end)
1660 
-          var->lastItem = this;
1661 
-      }
1662 
-      var = var->nextActive;
1663 
-    } while (var != first);
1664 
-  }
1665 
-
1666 
-  x86Context._currentOffset++;
1596 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
1597 
+	this->_offset = x86Context._currentOffset;
1598 
+
1599 
+	// Update _isTaken to true if this is conditional backward jump. This behavior
1600 
+	// can be overridden by using kCondHintUnlikely when using the instruction.
1601 
+	if (this->getCode() != kX86InstJmp && this->_operandsCount == 1 && this->_jumpTarget->getOffset() < getOffset())
1602 
+		this->setInstFlag(kX86CompilerInstFlagIsTaken);
1603 
+
1604 
+	// Now patch all variables where jump location is in the active range.
1605 
+	if (this->_jumpTarget->getOffset() != kInvalidValue && x86Context._active)
1606 
+	{
1607 
+		X86CompilerVar *first = static_cast<X86CompilerVar *>(x86Context._active);
1608 
+		X86CompilerVar *var = first;
1609 
+		uint32_t jumpOffset = this->_jumpTarget->getOffset();
1610 
+
1611 
+		do
1612 
+		{
1613 
+			if (var->firstItem)
1614 
+			{
1615 
+				ASMJIT_ASSERT(var->lastItem);
1616 
+				uint32_t start = var->firstItem->getOffset();
1617 
+				uint32_t end = var->lastItem->getOffset();
1618 
+
1619 
+				if (jumpOffset >= start && jumpOffset <= end)
1620 
+					var->lastItem = this;
1621 
+			}
1622 
+			var = var->nextActive;
1623 
+		} while (var != first);
1624 
+	}
1625 
+
1626 
+	++x86Context._currentOffset;
1667 1627 
 }
1668 1628
1669 
-CompilerItem* X86CompilerJmpInst::translate(CompilerContext& cc)
1629 
+CompilerItem* X86CompilerJmpInst::translate(CompilerContext &cc)
1670 1630 
 {
1671 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
1672 
-
1673 
-  // Translate using X86CompilerInst.
1674 
-  CompilerItem* ret = X86CompilerInst::translate(cc);
1675 
-
1676 
-  // We jump with item if its kX86InstJUMP (not based on condiiton) and it
1677 
-  // points into yet unknown location.
1678 
-  if (_code == kX86InstJmp && !_jumpTarget->isTranslated())
1679 
-  {
1680 
-    x86Context.addBackwardCode(this);
1681 
-    ret = _jumpTarget;
1682 
-  }
1683 
-  else
1684 
-  {
1685 
-    _state = x86Context._saveState();
1686 
-    if (_jumpTarget->isTranslated())
1687 
-    {
1688 
-      doJump(cc);
1689 
-    }
1690 
-    else
1691 
-    {
1692 
-      // State is not known, so we need to call doJump() later. Compiler will
1693 
-      // do it for us.
1694 
-      x86Context.addForwardJump(this);
1695 
-      _jumpTarget->_state = _state;
1696 
-    }
1697 
-
1698 
-    // Mark next code as unreachable, cleared by a next label (CompilerTarget).
1699 
-    if (_code == kX86InstJmp)
1700 
-      x86Context._isUnreachable = 1;
1701 
-  }
1702 
-
1703 
-  // Need to traverse over all active variables and unuse them if their scope ends
1704 
-  // here.
1705 
-  if (x86Context._active)
1706 
-  {
1707 
-    X86CompilerVar* first = static_cast<X86CompilerVar*>(x86Context._active);
1708 
-    X86CompilerVar* var = first;
1709 
-
1710 
-    do {
1711 
-      x86Context._unuseVarOnEndOfScope(this, var);
1712 
-      var = var->nextActive;
1713 
-    } while (var != first);
1714 
-  }
1715 
-
1716 
-  return ret;
1631 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
1632 
+
1633 
+	// Translate using X86CompilerInst.
1634 
+	CompilerItem *ret = X86CompilerInst::translate(cc);
1635 
+
1636 
+	// We jump with item if its kX86InstJUMP (not based on condiiton) and it
1637 
+	// points into yet unknown location.
1638 
+	if (this->_code == kX86InstJmp && !this->_jumpTarget->isTranslated())
1639 
+	{
1640 
+		x86Context.addBackwardCode(this);
1641 
+		ret = this->_jumpTarget;
1642 
+	}
1643 
+	else
1644 
+	{
1645 
+		this->_state = x86Context._saveState();
1646 
+		if (this->_jumpTarget->isTranslated())
1647 
+			this->doJump(cc);
1648 
+		else
1649 
+		{
1650 
+			// State is not known, so we need to call doJump() later. Compiler will
1651 
+			// do it for us.
1652 
+			x86Context.addForwardJump(this);
1653 
+			this->_jumpTarget->_state = this->_state;
1654 
+		}
1655 
+
1656 
+		// Mark next code as unreachable, cleared by a next label (CompilerTarget).
1657 
+		if (this->_code == kX86InstJmp)
1658 
+			x86Context._isUnreachable = 1;
1659 
+	}
1660 
+
1661 
+	// Need to traverse over all active variables and unuse them if their scope ends
1662 
+	// here.
1663 
+	if (x86Context._active)
1664 
+	{
1665 
+		X86CompilerVar *first = static_cast<X86CompilerVar *>(x86Context._active);
1666 
+		X86CompilerVar *var = first;
1667 
+
1668 
+		do
1669 
+		{
1670 
+			x86Context._unuseVarOnEndOfScope(this, var);
1671 
+			var = var->nextActive;
1672 
+		} while (var != first);
1673 
+	}
1674 
+
1675 
+	return ret;
1717 1676 
 }
1718 1677
1719 
-void X86CompilerJmpInst::emit(Assembler& a)
1678 
+void X86CompilerJmpInst::emit(Assembler &a)
1720 1679 
 {
1721 
-  static const unsigned MAXIMUM_SHORT_JMP_SIZE = 127;
1722 
-
1723 
-  // Try to minimize size of jump using SHORT jump (8-bit displacement) by
1724 
-  // traversing into the target and calculating the maximum code size. We
1725 
-  // end when code size reaches MAXIMUM_SHORT_JMP_SIZE.
1726 
-  if (!(_emitOptions & kX86EmitOptionShortJump) && getJumpTarget()->getOffset() > getOffset())
1727 
-  {
1728 
-    // Calculate the code size.
1729 
-    unsigned codeSize = 0;
1730 
-    CompilerItem* cur = this->getNext();
1731 
-    CompilerItem* target = getJumpTarget();
1732 
-
1733 
-    while (cur)
1734 
-    {
1735 
-      if (cur == target)
1736 
-      {
1737 
-        // Target found, we can tell assembler to generate short form of jump.
1738 
-        _emitOptions |= kX86EmitOptionShortJump;
1739 
-        goto _End;
1740 
-      }
1741 
-
1742 
-      int s = cur->getMaxSize();
1743 
-      if (s == -1) break;
1744 
-
1745 
-      codeSize += (unsigned)s;
1746 
-      if (codeSize > MAXIMUM_SHORT_JMP_SIZE) break;
1747 
-
1748 
-      cur = cur->getNext();
1749 
-    }
1750 
-  }
1680 
+	static const unsigned MAXIMUM_SHORT_JMP_SIZE = 127;
1681 
+
1682 
+	// Try to minimize size of jump using SHORT jump (8-bit displacement) by
1683 
+	// traversing into the target and calculating the maximum code size. We
1684 
+	// end when code size reaches MAXIMUM_SHORT_JMP_SIZE.
1685 
+	if (!(this->_emitOptions & kX86EmitOptionShortJump) && this->getJumpTarget()->getOffset() > this->getOffset())
1686 
+	{
1687 
+		// Calculate the code size.
1688 
+		unsigned codeSize = 0;
1689 
+		CompilerItem *cur = this->getNext();
1690 
+		CompilerItem *target = this->getJumpTarget();
1691 
+
1692 
+		while (cur)
1693 
+		{
1694 
+			if (cur == target)
1695 
+			{
1696 
+				// Target found, we can tell assembler to generate short form of jump.
1697 
+				this->_emitOptions |= kX86EmitOptionShortJump;
1698 
+				goto _End;
1699 
+			}
1700 
+
1701 
+			int s = cur->getMaxSize();
1702 
+			if (s == -1)
1703 
+				break;
1704 
+
1705 
+			codeSize += s;
1706 
+			if (codeSize > MAXIMUM_SHORT_JMP_SIZE)
1707 
+				break;
1708 
+
1709 
+			cur = cur->getNext();
1710 
+		}
1711 
+	}
1751 1712
1752 1713 
 _End:
1753 
-  X86CompilerInst::emit(a);
1714 
+	X86CompilerInst::emit(a);
1754 1715 
 }
1755 1716
1756 1717 
 // ============================================================================
1757 1718 
 // [AsmJit::X86CompilerJmpInst - DoJump]
1758 1719 
 // ============================================================================
1759 1720
1760 
-void X86CompilerJmpInst::doJump(CompilerContext& cc)
1721 
+void X86CompilerJmpInst::doJump(CompilerContext &cc)
1761 1722 
 {
1762 
-  X86CompilerContext& x86Context = static_cast<X86CompilerContext&>(cc);
1763 
-  X86Compiler* x86Compiler = getCompiler();
1764 
-
1765 
-  // The state have to be already known. The doJump() method is called by
1766 
-  // translate() or by Compiler in case that it's forward jump.
1767 
-  ASMJIT_ASSERT(_jumpTarget->getState());
1768 
-
1769 
-  if (getCode() == kX86InstJmp || (isTaken() && _jumpTarget->getOffset() < getOffset()))
1770 
-  {
1771 
-    // Instruction type is JMP or conditional jump that should be taken (likely).
1772 
-    // We can set state here instead of jumping out, setting state and jumping
1773 
-    // to _jumpTarget.
1774 
-    //
1775 
-    // NOTE: We can't use this technique if instruction is forward conditional
1776 
-    // jump. The reason is that when generating code we can't change state here,
1777 
-    // because the next instruction depends on it.
1778 
-    x86Context._restoreState(_jumpTarget->getState(), _jumpTarget->getOffset());
1779 
-  }
1780 
-  else
1781 
-  {
1782 
-    // Instruction type is JMP or conditional jump that should be not normally
1783 
-    // taken. If we need add code that will switch between different states we
1784 
-    // add it after the end of function body (after epilog, using 'ExtraBlock').
1785 
-    CompilerItem* ext = x86Context.getExtraBlock();
1786 
-    CompilerItem* old = x86Compiler->setCurrentItem(ext);
1787 
-
1788 
-    x86Context._restoreState(_jumpTarget->getState(), _jumpTarget->getOffset());
1789 
-
1790 
-    if (x86Compiler->getCurrentItem() != ext)
1791 
-    {
1792 
-      // Add the jump to the target.
1793 
-      x86Compiler->jmp(_jumpTarget->_label);
1794 
-      ext = x86Compiler->getCurrentItem();
1795 
-
1796 
-      // The x86Context._restoreState() method emitted some instructions so we need to
1797 
-      // patch the jump.
1798 
-      Label L = x86Compiler->newLabel();
1799 
-      x86Compiler->setCurrentItem(x86Context.getExtraBlock());
1800 
-      x86Compiler->bind(L);
1801 
-
1802 
-      // Finally, patch the jump target.
1803 
-      ASMJIT_ASSERT(_operandsCount > 0);
1804 
-      _operands[0] = L;                                 // Operand part (Label).
1805 
-      _jumpTarget = x86Compiler->_getTarget(L.getId()); // Compiler part (CompilerTarget).
1806 
-    }
1807 
-
1808 
-    x86Context.setExtraBlock(ext);
1809 
-    x86Compiler->setCurrentItem(old);
1810 
-
1811 
-    // Assign state back.
1812 
-    x86Context._assignState(static_cast<X86CompilerState*>(_state));
1813 
-  }
1723 
+	X86CompilerContext &x86Context = static_cast<X86CompilerContext &>(cc);
1724 
+	X86Compiler *x86Compiler = this->getCompiler();
1725 
+
1726 
+	// The state have to be already known. The doJump() method is called by
1727 
+	// translate() or by Compiler in case that it's forward jump.
1728 
+	ASMJIT_ASSERT(this->_jumpTarget->getState());
1729 
+
1730 
+	if (this->getCode() == kX86InstJmp || (this->isTaken() && this->_jumpTarget->getOffset() < this->getOffset()))
1731 
+		// Instruction type is JMP or conditional jump that should be taken (likely).
1732 
+		// We can set state here instead of jumping out, setting state and jumping
1733 
+		// to _jumpTarget.
1734 
+		//
1735 
+		// NOTE: We can't use this technique if instruction is forward conditional
1736 
+		// jump. The reason is that when generating code we can't change state here,
1737 
+		// because the next instruction depends on it.
1738 
+		x86Context._restoreState(this->_jumpTarget->getState(), this->_jumpTarget->getOffset());
1739 
+	else
1740 
+	{
1741 
+		// Instruction type is JMP or conditional jump that should be not normally
1742 
+		// taken. If we need add code that will switch between different states we
1743 
+		// add it after the end of function body (after epilog, using 'ExtraBlock').
1744 
+		CompilerItem *ext = x86Context.getExtraBlock();
1745 
+		CompilerItem *old = x86Compiler->setCurrentItem(ext);
1746 
+
1747 
+		x86Context._restoreState(this->_jumpTarget->getState(), this->_jumpTarget->getOffset());
1748 
+
1749 
+		if (x86Compiler->getCurrentItem() != ext)
1750 
+		{
1751 
+			// Add the jump to the target.
1752 
+			x86Compiler->jmp(this->_jumpTarget->_label);
1753 
+			ext = x86Compiler->getCurrentItem();
1754 
+
1755 
+			// The x86Context._restoreState() method emitted some instructions so we need to
1756 
+			// patch the jump.
1757 
+			Label L = x86Compiler->newLabel();
1758 
+			x86Compiler->setCurrentItem(x86Context.getExtraBlock());
1759 
+			x86Compiler->bind(L);
1760 
+
1761 
+			// Finally, patch the jump target.
1762 
+			ASMJIT_ASSERT(this->_operandsCount > 0);
1763 
+			this->_operands[0] = L; // Operand part (Label).
1764 
+			this->_jumpTarget = x86Compiler->_getTarget(L.getId()); // Compiler part (CompilerTarget).
1765 
+		}
1766 
+
1767 
+		x86Context.setExtraBlock(ext);
1768 
+		x86Compiler->setCurrentItem(old);
1769 
+
1770 
+		// Assign state back.
1771 
+		x86Context._assignState(static_cast<X86CompilerState *>(this->_state));
1772 
+	}
1814 1773 
 }
1815 1774
1816 1775 
 // ============================================================================
1817 1776 
 // [AsmJit::X86CompilerJmpInst - GetJumpTarget]
1818 1777 
 // ============================================================================
1819 1778
1820 
-CompilerTarget* X86CompilerJmpInst::getJumpTarget() const
1779 
+CompilerTarget *X86CompilerJmpInst::getJumpTarget() const
1821 1780 
 {
1822 
-  return _jumpTarget;
1781 
+	return this->_jumpTarget;
1823 1782 
 }
1824 1783
1825 1784 
 } // AsmJit namespace
src/in_2sf/desmume/utils/AsmJit/x86/x86cpuinfo.cpp
History View file @ d07af85
... ... 
@@ -12,16 +12,15 @@
12 12
13 13 
 // 2009-02-05: Thanks to Mike Tajmajer for VC7.1 compiler support. It shouldn't
14 14 
 // affect x64 compilation, because x64 compiler starts with VS2005 (VC8.0).
15 
-#if defined(_MSC_VER)
16 
-# if _MSC_VER >= 1400
17 
-#  include <intrin.h>
18 
-# endif // _MSC_VER >= 1400 (>= VS2005)
19 
-#endif // _MSC_VER
15 
+#if defined(_MSC_VER) && _MSC_VER >= 1400
16 
+# include <intrin.h>
17 
+#endif // _MSC_VER && _MSC_VER >= 1400 (>= VS2005)
20 18
21 19 
 // [Api-Begin]
22 20 
 #include "../core/apibegin.h"
23 21
24 
-namespace AsmJit {
22 
+namespace AsmJit
23 
+{
25 24
26 25 
 // ============================================================================
27 26 
 // [AsmJit::X86CpuVendor]
... ... 
@@ -29,71 +28,72 @@ namespace AsmJit {
29 28
30 29 
 struct X86CpuVendor
31 30 
 {
32 
-  uint32_t id;
33 
-  char text[12];
31 
+	uint32_t id;
32 
+	char text[12];
34 33 
 };
35 34
36 35 
 static const X86CpuVendor x86CpuVendor[] =
37 36 
 {
38 
-  { kCpuIntel    , { 'G', 'e', 'n', 'u', 'i', 'n', 'e', 'I', 'n', 't', 'e', 'l' } },
37 
+	{ kCpuIntel    , { 'G', 'e', 'n', 'u', 'i', 'n', 'e', 'I', 'n', 't', 'e', 'l' } },
39 38
40 
-  { kCpuAmd      , { 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'A', 'M', 'D' } },
41 
-  { kCpuAmd      , { 'A', 'M', 'D', 'i', 's', 'b', 'e', 't', 't', 'e', 'r', '!' } },
39 
+	{ kCpuAmd      , { 'A', 'u', 't', 'h', 'e', 'n', 't', 'i', 'c', 'A', 'M', 'D' } },
40 
+	{ kCpuAmd      , { 'A', 'M', 'D', 'i', 's', 'b', 'e', 't', 't', 'e', 'r', '!' } },
42 41
43 
-  { kCpuNSM      , { 'G', 'e', 'o', 'd', 'e', ' ', 'b', 'y', ' ', 'N', 'S', 'C' } },
44 
-  { kCpuNSM      , { 'C', 'y', 'r', 'i', 'x', 'I', 'n', 's', 't', 'e', 'a', 'd' } },
42 
+	{ kCpuNSM      , { 'G', 'e', 'o', 'd', 'e', ' ', 'b', 'y', ' ', 'N', 'S', 'C' } },
43 
+	{ kCpuNSM      , { 'C', 'y', 'r', 'i', 'x', 'I', 'n', 's', 't', 'e', 'a', 'd' } },
45 44
46 
-  { kCpuTransmeta, { 'G', 'e', 'n', 'u', 'i', 'n', 'e', 'T', 'M', 'x', '8', '6' } },
47 
-  { kCpuTransmeta, { 'T', 'r', 'a', 'n', 's', 'm', 'e', 't', 'a', 'C', 'P', 'U' } },
45 
+	{ kCpuTransmeta, { 'G', 'e', 'n', 'u', 'i', 'n', 'e', 'T', 'M', 'x', '8', '6' } },
46 
+	{ kCpuTransmeta, { 'T', 'r', 'a', 'n', 's', 'm', 'e', 't', 'a', 'C', 'P', 'U' } },
48 47
49 
-  { kCpuVia      , { 'V', 'I', 'A',  0 , 'V', 'I', 'A',  0 , 'V', 'I', 'A',  0  } },
50 
-  { kCpuVia      , { 'C', 'e', 'n', 't', 'a', 'u', 'r', 'H', 'a', 'u', 'l', 's' } }
48 
+	{ kCpuVia      , { 'V', 'I', 'A',  0 , 'V', 'I', 'A',  0 , 'V', 'I', 'A',  0  } },
49 
+	{ kCpuVia      , { 'C', 'e', 'n', 't', 'a', 'u', 'r', 'H', 'a', 'u', 'l', 's' } }
51 50 
 };
52 51
53 
-static inline bool x86CpuVendorEq(const X86CpuVendor& info, const char* vendorString)
52 
+static inline bool x86CpuVendorEq(const X86CpuVendor &info, const char *vendorString)
54 53 
 {
55 
-  const uint32_t* a = reinterpret_cast<const uint32_t*>(info.text);
56 
-  const uint32_t* b = reinterpret_cast<const uint32_t*>(vendorString);
54 
+	const uint32_t *a = reinterpret_cast<const uint32_t *>(info.text);
55 
+	const uint32_t *b = reinterpret_cast<const uint32_t *>(vendorString);
57 56
58 
-  return (a[0] == b[0]) &
59 
-         (a[1] == b[1]) &
60 
-         (a[2] == b[2]) ;
57 
+	return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
61 58 
 }
62 59
63 60 
 // ============================================================================
64 61 
 // [AsmJit::x86CpuSimplifyBrandString]
65 62 
 // ============================================================================
66 63
67 
-static inline void x86CpuSimplifyBrandString(char* s)
64 
+static inline void x86CpuSimplifyBrandString(char *s)
68 65 
 {
69 
-  // Always clear the current character in the buffer. This ensures that there
70 
-  // is no garbage after the string NULL terminator.
71 
-  char* d = s;
72 
-
73 
-  char prev = 0;
74 
-  char curr = s[0];
75 
-  s[0] = '\0';
76 
-
77 
-  for (;;)
78 
-  {
79 
-    if (!curr) break;
80 
-
81 
-    if (curr == ' ')
82 
-    {
83 
-      if (prev == '@') goto _Skip;
84 
-      if (s[1] == ' ' || s[1] == '@') goto _Skip;
85 
-    }
86 
-
87 
-    d[0] = curr;
88 
-    d++;
89 
-    prev = curr;
90 
-
91 
-_Skip:
92 
-    curr = *++s;
93 
-    s[0] = '\0';
94 
-  }
95 
-
96 
-  d[0] = '\0';
66 
+	// Always clear the current character in the buffer. This ensures that there
67 
+	// is no garbage after the string NULL terminator.
68 
+	char *d = s;
69 
+
70 
+	char prev = 0;
71 
+	char curr = s[0];
72 
+	s[0] = 0;
73 
+
74 
+	for (;;)
75 
+	{
76 
+		if (!curr)
77 
+			break;
78 
+
79 
+		if (curr == ' ')
80 
+		{
81 
+			if (prev == '@')
82 
+				goto _Skip;
83 
+			if (s[1] == ' ' || s[1] == '@')
84 
+				goto _Skip;
85 
+		}
86 
+
87 
+		d[0] = curr;
88 
+		++d;
89 
+		prev = curr;
90 
+
91 
+	_Skip:
92 
+		curr = *++s;
93 
+		s[0] = 0;
94 
+	}
95 
+
96 
+	d[0] = 0;
97 97 
 }
98 98
99 99 
 // ============================================================================
... ... 
@@ -107,49 +107,45 @@ _Skip:
107 107
108 108 
 // x86CpuId() and detectCpuInfo() for x86 and x64 platforms begins here.
109 109 
 #if defined(ASMJIT_X86) || defined(ASMJIT_X64)
110 
-void x86CpuId(uint32_t in, X86CpuId* out)
110 
+void x86CpuId(uint32_t in, X86CpuId *out)
111 111 
 {
112 
-#if defined(_MSC_VER)
113 
-
114 
-// 2009-02-05: Thanks to Mike Tajmajer for supporting VC7.1 compiler.
115 
-// ASMJIT_X64 is here only for readibility, only VS2005 can compile 64-bit code.
112 
+#ifdef _MSC_VER
113 
+	// 2009-02-05: Thanks to Mike Tajmajer for supporting VC7.1 compiler.
114 
+	// ASMJIT_X64 is here only for readibility, only VS2005 can compile 64-bit code.
116 115 
 # if _MSC_VER >= 1400 || defined(ASMJIT_X64)
117 
-  // Done by intrinsics.
118 
-  __cpuid(reinterpret_cast<int*>(out->i), in);
116 
+	// Done by intrinsics.
117 
+	__cpuid(reinterpret_cast<int *>(out->i), in);
119 118 
 # else // _MSC_VER < 1400
120 
-  uint32_t cpuid_in = in;
121 
-  uint32_t* cpuid_out = out->i;
122 
-
123 
-  __asm
124 
-  {
125 
-    mov     eax, cpuid_in
126 
-    mov     edi, cpuid_out
127 
-    cpuid
128 
-    mov     dword ptr[edi +  0], eax
129 
-    mov     dword ptr[edi +  4], ebx
130 
-    mov     dword ptr[edi +  8], ecx
131 
-    mov     dword ptr[edi + 12], edx
132 
-  }
119 
+	uint32_t cpuid_in = in;
120 
+	uint32_t *cpuid_out = out->i;
121 
+
122 
+	__asm
123 
+	{
124 
+		mov     eax, cpuid_in
125 
+		mov     edi, cpuid_out
126 
+		cpuid
127 
+		mov     dword ptr[edi +  0], eax
128 
+		mov     dword ptr[edi +  4], ebx
129 
+		mov     dword ptr[edi +  8], ecx
130 
+		mov     dword ptr[edi + 12], edx
131 
+	}
133 132 
 # endif // _MSC_VER < 1400
134 
-
135 133 
 #elif defined(__GNUC__)
136 
-
137 134 
 // Note, need to preserve ebx/rbx register!
138 
-# if defined(ASMJIT_X86)
135 
+# ifdef ASMJIT_X86
139 136 
 #  define __myCpuId(a, b, c, d, inp) \
140 
-  asm ("mov %%ebx, %%edi\n"    \
141 
-       "cpuid\n"               \
142 
-       "xchg %%edi, %%ebx\n"   \
143 
-       : "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp))
137 
+	asm ("mov %%ebx, %%edi\n"    \
138 
+		"cpuid\n"               \
139 
+		"xchg %%edi, %%ebx\n"   \
140 
+		: "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp))
144 141 
 # else
145 142 
 #  define __myCpuId(a, b, c, d, inp) \
146 
-  asm ("mov %%rbx, %%rdi\n"    \
147 
-       "cpuid\n"               \
148 
-       "xchg %%rdi, %%rbx\n"   \
149 
-       : "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp))
143 
+	asm ("mov %%rbx, %%rdi\n"    \
144 
+		"cpuid\n"               \
145 
+		"xchg %%rdi, %%rbx\n"   \
146 
+		: "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp))
150 147 
 # endif
151 
-  __myCpuId(out->eax, out->ebx, out->ecx, out->edx, in);
152 
-
148 
+	__myCpuId(out->eax, out->ebx, out->ecx, out->edx, in);
153 149 
 #endif // Compiler #ifdef.
154 150 
 }
155 151
... ... 
@@ -157,144 +153,171 @@ void x86CpuId(uint32_t in, X86CpuId* out)
157 153 
 // [AsmJit::x86CpuDetect]
158 154 
 // ============================================================================
159 155
160 
-void x86CpuDetect(X86CpuInfo* out)
156 
+void x86CpuDetect(X86CpuInfo *out)
161 157 
 {
162 
-  uint32_t i;
163 
-  X86CpuId regs;
164 
-
165 
-  // Clear everything except the '_size' member.
166 
-  memset(reinterpret_cast<uint8_t*>(out) + sizeof(uint32_t),
167 
-    0, sizeof(CpuInfo) - sizeof(uint32_t));
168 
-
169 
-  // Fill safe defaults.
170 
-  memcpy(out->_vendorString, "Unknown", 8);
171 
-  out->_numberOfProcessors = CpuInfo::detectNumberOfProcessors();
172 
-
173 
-  // Get vendor string/id.
174 
-  x86CpuId(0, &regs);
175 
-
176 
-  memcpy(out->_vendorString, &regs.ebx, 4);
177 
-  memcpy(out->_vendorString + 4, &regs.edx, 4);
178 
-  memcpy(out->_vendorString + 8, &regs.ecx, 4);
179 
-
180 
-  for (i = 0; i < 3; i++)
181 
-  {
182 
-    if (x86CpuVendorEq(x86CpuVendor[i], out->_vendorString))
183 
-    {
184 
-      out->_vendorId = x86CpuVendor[i].id;
185 
-      break;
186 
-    }
187 
-  }
188 
-
189 
-  // Get feature flags in ecx/edx, and family/model in eax.
190 
-  x86CpuId(1, &regs);
191 
-
192 
-  // Fill family and model fields.
193 
-  out->_family   = (regs.eax >> 8) & 0x0F;
194 
-  out->_model    = (regs.eax >> 4) & 0x0F;
195 
-  out->_stepping = (regs.eax     ) & 0x0F;
196 
-
197 
-  // Use extended family and model fields.
198 
-  if (out->_family == 0x0F)
199 
-  {
200 
-    out->_family += ((regs.eax >> 20) & 0xFF);
201 
-    out->_model  += ((regs.eax >> 16) & 0x0F) << 4;
202 
-  }
203 
-
204 
-  out->_processorType        = ((regs.eax >> 12) & 0x03);
205 
-  out->_brandIndex           = ((regs.ebx      ) & 0xFF);
206 
-  out->_flushCacheLineSize   = ((regs.ebx >>  8) & 0xFF) * 8;
207 
-  out->_maxLogicalProcessors = ((regs.ebx >> 16) & 0xFF);
208 
-  out->_apicPhysicalId       = ((regs.ebx >> 24) & 0xFF);
209 
-
210 
-  if (regs.ecx & 0x00000001U) out->_features |= kX86FeatureSse3;
211 
-  if (regs.ecx & 0x00000002U) out->_features |= kX86FeaturePclMulDQ;
212 
-  if (regs.ecx & 0x00000008U) out->_features |= kX86FeatureMonitorMWait;
213 
-  if (regs.ecx & 0x00000200U) out->_features |= kX86FeatureSsse3;
214 
-  if (regs.ecx & 0x00002000U) out->_features |= kX86FeatureCmpXchg16B;
215 
-  if (regs.ecx & 0x00080000U) out->_features |= kX86FeatureSse41;
216 
-  if (regs.ecx & 0x00100000U) out->_features |= kX86FeatureSse42;
217 
-  if (regs.ecx & 0x00400000U) out->_features |= kX86FeatureMovBE;
218 
-  if (regs.ecx & 0x00800000U) out->_features |= kX86FeaturePopCnt;
219 
-  if (regs.ecx & 0x10000000U) out->_features |= kX86FeatureAvx;
220 
-
221 
-  if (regs.edx & 0x00000010U) out->_features |= kX86FeatureRdtsc;
222 
-  if (regs.edx & 0x00000100U) out->_features |= kX86FeatureCmpXchg8B;
223 
-  if (regs.edx & 0x00008000U) out->_features |= kX86FeatureCMov;
224 
-  if (regs.edx & 0x00800000U) out->_features |= kX86FeatureMmx;
225 
-  if (regs.edx & 0x01000000U) out->_features |= kX86FeatureFXSR;
226 
-  if (regs.edx & 0x02000000U) out->_features |= kX86FeatureSse | kX86FeatureMmxExt;
227 
-  if (regs.edx & 0x04000000U) out->_features |= kX86FeatureSse | kX86FeatureSse2;
228 
-  if (regs.edx & 0x10000000U) out->_features |= kX86FeatureMultiThreading;
229 
-
230 
-  if (out->_vendorId == kCpuAmd && (regs.edx & 0x10000000U))
231 
-  {
232 
-    // AMD sets Multithreading to ON if it has more cores.
233 
-    if (out->_numberOfProcessors == 1) out->_numberOfProcessors = 2;
234 
-  }
235 
-
236 
-  // This comment comes from V8 and I think that its important:
237 
-  //
238 
-  // Opteron Rev E has i bug in which on very rare occasions i locked
239 
-  // instruction doesn't act as i read-acquire barrier if followed by i
240 
-  // non-locked read-modify-write instruction.  Rev F has this bug in
241 
-  // pre-release versions, but not in versions released to customers,
242 
-  // so we test only for Rev E, which is family 15, model 32..63 inclusive.
243 
-
244 
-  if (out->_vendorId == kCpuAmd && out->_family == 15 && out->_model >= 32 && out->_model <= 63)
245 
-  {
246 
-    out->_bugs |= kX86BugAmdLockMB;
247 
-  }
248 
-
249 
-  // Calling cpuid with 0x80000000 as the in argument
250 
-  // gets the number of valid extended IDs.
251 
-
252 
-  x86CpuId(0x80000000, &regs);
253 
-
254 
-  uint32_t exIds = regs.eax;
255 
-  if (exIds > 0x80000004) exIds = 0x80000004;
256 
-
257 
-  uint32_t* brand = reinterpret_cast<uint32_t*>(out->_brandString);
258 
-
259 
-  for (i = 0x80000001; i <= exIds; i++)
260 
-  {
261 
-    x86CpuId(i, &regs);
262 
-
263 
-    switch (i)
264 
-    {
265 
-      case 0x80000001:
266 
-        if (regs.ecx & 0x00000001U) out->_features |= kX86FeatureLahfSahf;
267 
-        if (regs.ecx & 0x00000020U) out->_features |= kX86FeatureLzCnt;
268 
-        if (regs.ecx & 0x00000040U) out->_features |= kX86FeatureSse4A;
269 
-        if (regs.ecx & 0x00000080U) out->_features |= kX86FeatureMSse;
270 
-        if (regs.ecx & 0x00000100U) out->_features |= kX86FeaturePrefetch;
271 
-
272 
-        if (regs.edx & 0x00100000U) out->_features |= kX86FeatureExecuteDisableBit;
273 
-        if (regs.edx & 0x00200000U) out->_features |= kX86FeatureFFXSR;
274 
-        if (regs.edx & 0x00400000U) out->_features |= kX86FeatureMmxExt;
275 
-        if (regs.edx & 0x08000000U) out->_features |= kX86FeatureRdtscP;
276 
-        if (regs.edx & 0x20000000U) out->_features |= kX86Feature64Bit;
277 
-        if (regs.edx & 0x40000000U) out->_features |= kX86Feature3dNowExt | kX86FeatureMmxExt;
278 
-        if (regs.edx & 0x80000000U) out->_features |= kX86Feature3dNow;
279 
-        break;
280 
-
281 
-      case 0x80000002:
282 
-      case 0x80000003:
283 
-      case 0x80000004:
284 
-        *brand++ = regs.eax;
285 
-        *brand++ = regs.ebx;
286 
-        *brand++ = regs.ecx;
287 
-        *brand++ = regs.edx;
288 
-        break;
289 
-
290 
-      default:
291 
-        // Additional features can be detected in the future.
292 
-        break;
293 
-    }
294 
-  }
295 
-
296 
-  // Simplify the brand string (remove unnecessary spaces to make it printable).
297 
-  x86CpuSimplifyBrandString(out->_brandString);
158 
+	uint32_t i;
159 
+	X86CpuId regs;
160 
+
161 
+	// Clear everything except the '_size' member.
162 
+	memset(reinterpret_cast<uint8_t *>(out) + sizeof(uint32_t), 0, sizeof(CpuInfo) - sizeof(uint32_t));
163 
+
164 
+	// Fill safe defaults.
165 
+	memcpy(out->_vendorString, "Unknown", 8);
166 
+	out->_numberOfProcessors = CpuInfo::detectNumberOfProcessors();
167 
+
168 
+	// Get vendor string/id.
169 
+	x86CpuId(0, &regs);
170 
+
171 
+	memcpy(out->_vendorString, &regs.ebx, 4);
172 
+	memcpy(out->_vendorString + 4, &regs.edx, 4);
173 
+	memcpy(out->_vendorString + 8, &regs.ecx, 4);
174 
+
175 
+	for (i = 0; i < 3; ++i)
176 
+		if (x86CpuVendorEq(x86CpuVendor[i], out->_vendorString))
177 
+		{
178 
+			out->_vendorId = x86CpuVendor[i].id;
179 
+			break;
180 
+		}
181 
+
182 
+	// Get feature flags in ecx/edx, and family/model in eax.
183 
+	x86CpuId(1, &regs);
184 
+
185 
+	// Fill family and model fields.
186 
+	out->_family = (regs.eax >> 8) & 0x0F;
187 
+	out->_model = (regs.eax >> 4) & 0x0F;
188 
+	out->_stepping = regs.eax & 0x0F;
189 
+
190 
+	// Use extended family and model fields.
191 
+	if (out->_family == 0x0F)
192 
+	{
193 
+		out->_family += (regs.eax >> 20) & 0xFF;
194 
+		out->_model  += ((regs.eax >> 16) & 0x0F) << 4;
195 
+	}
196 
+
197 
+	out->_processorType = (regs.eax >> 12) & 0x03;
198 
+	out->_brandIndex = regs.ebx & 0xFF;
199 
+	out->_flushCacheLineSize = ((regs.ebx >> 8) & 0xFF) * 8;
200 
+	out->_maxLogicalProcessors = (regs.ebx >> 16) & 0xFF;
201 
+	out->_apicPhysicalId = (regs.ebx >> 24) & 0xFF;
202 
+
203 
+	if (regs.ecx & 0x00000001U)
204 
+		out->_features |= kX86FeatureSse3;
205 
+	if (regs.ecx & 0x00000002U)
206 
+		out->_features |= kX86FeaturePclMulDQ;
207 
+	if (regs.ecx & 0x00000008U)
208 
+		out->_features |= kX86FeatureMonitorMWait;
209 
+	if (regs.ecx & 0x00000200U)
210 
+		out->_features |= kX86FeatureSsse3;
211 
+	if (regs.ecx & 0x00002000U)
212 
+		out->_features |= kX86FeatureCmpXchg16B;
213 
+	if (regs.ecx & 0x00080000U)
214 
+		out->_features |= kX86FeatureSse41;
215 
+	if (regs.ecx & 0x00100000U)
216 
+		out->_features |= kX86FeatureSse42;
217 
+	if (regs.ecx & 0x00400000U)
218 
+		out->_features |= kX86FeatureMovBE;
219 
+	if (regs.ecx & 0x00800000U)
220 
+		out->_features |= kX86FeaturePopCnt;
221 
+	if (regs.ecx & 0x10000000U)
222 
+		out->_features |= kX86FeatureAvx;
223 
+
224 
+	if (regs.edx & 0x00000010U)
225 
+		out->_features |= kX86FeatureRdtsc;
226 
+	if (regs.edx & 0x00000100U)
227 
+		out->_features |= kX86FeatureCmpXchg8B;
228 
+	if (regs.edx & 0x00008000U)
229 
+		out->_features |= kX86FeatureCMov;
230 
+	if (regs.edx & 0x00800000U)
231 
+		out->_features |= kX86FeatureMmx;
232 
+	if (regs.edx & 0x01000000U)
233 
+		out->_features |= kX86FeatureFXSR;
234 
+	if (regs.edx & 0x02000000U)
235 
+		out->_features |= kX86FeatureSse | kX86FeatureMmxExt;
236 
+	if (regs.edx & 0x04000000U)
237 
+		out->_features |= kX86FeatureSse | kX86FeatureSse2;
238 
+	if (regs.edx & 0x10000000U)
239 
+		out->_features |= kX86FeatureMultiThreading;
240 
+
241 
+	if (out->_vendorId == kCpuAmd && (regs.edx & 0x10000000U))
242 
+	{
243 
+		// AMD sets Multithreading to ON if it has more cores.
244 
+		if (out->_numberOfProcessors == 1)
245 
+			out->_numberOfProcessors = 2;
246 
+	}
247 
+
248 
+	// This comment comes from V8 and I think that its important:
249 
+	//
250 
+	// Opteron Rev E has i bug in which on very rare occasions i locked
251 
+	// instruction doesn't act as i read-acquire barrier if followed by i
252 
+	// non-locked read-modify-write instruction.  Rev F has this bug in
253 
+	// pre-release versions, but not in versions released to customers,
254 
+	// so we test only for Rev E, which is family 15, model 32..63 inclusive.
255 
+
256 
+	if (out->_vendorId == kCpuAmd && out->_family == 15 && out->_model >= 32 && out->_model <= 63)
257 
+		out->_bugs |= kX86BugAmdLockMB;
258 
+
259 
+	// Calling cpuid with 0x80000000 as the in argument
260 
+	// gets the number of valid extended IDs.
261 
+
262 
+	x86CpuId(0x80000000, &regs);
263 
+
264 
+	uint32_t exIds = regs.eax;
265 
+	if (exIds > 0x80000004)
266 
+		exIds = 0x80000004;
267 
+
268 
+	uint32_t *brand = reinterpret_cast<uint32_t *>(out->_brandString);
269 
+
270 
+	for (i = 0x80000001; i <= exIds; ++i)
271 
+	{
272 
+		x86CpuId(i, &regs);
273 
+
274 
+		switch (i)
275 
+		{
276 
+			case 0x80000001:
277 
+				if (regs.ecx & 0x00000001U)
278 
+					out->_features |= kX86FeatureLahfSahf;
279 
+				if (regs.ecx & 0x00000020U)
280 
+					out->_features |= kX86FeatureLzCnt;
281 
+				if (regs.ecx & 0x00000040U)
282 
+					out->_features |= kX86FeatureSse4A;
283 
+				if (regs.ecx & 0x00000080U)
284 
+					out->_features |= kX86FeatureMSse;
285 
+				if (regs.ecx & 0x00000100U)
286 
+					out->_features |= kX86FeaturePrefetch;
287 
+
288 
+				if (regs.edx & 0x00100000U)
289 
+					out->_features |= kX86FeatureExecuteDisableBit;
290 
+				if (regs.edx & 0x00200000U)
291 
+					out->_features |= kX86FeatureFFXSR;
292 
+				if (regs.edx & 0x00400000U)
293 
+					out->_features |= kX86FeatureMmxExt;
294 
+				if (regs.edx & 0x08000000U)
295 
+					out->_features |= kX86FeatureRdtscP;
296 
+				if (regs.edx & 0x20000000U)
297 
+					out->_features |= kX86Feature64Bit;
298 
+				if (regs.edx & 0x40000000U)
299 
+					out->_features |= kX86Feature3dNowExt | kX86FeatureMmxExt;
300 
+				if (regs.edx & 0x80000000U)
301 
+					out->_features |= kX86Feature3dNow;
302 
+				break;
303 
+
304 
+			case 0x80000002:
305 
+			case 0x80000003:
306 
+			case 0x80000004:
307 
+				*brand++ = regs.eax;
308 
+				*brand++ = regs.ebx;
309 
+				*brand++ = regs.ecx;
310 
+				*brand++ = regs.edx;
311 
+				break;
312 
+
313 
+			default:
314 
+				// Additional features can be detected in the future.
315 
+				break;
316 
+		}
317 
+	}
318 
+
319 
+	// Simplify the brand string (remove unnecessary spaces to make it printable).
320 
+	x86CpuSimplifyBrandString(out->_brandString);
298 321 
 }
299 322 
 #endif
300 323
src/in_2sf/desmume/utils/AsmJit/x86/x86defs.cpp
History View file @ d07af85
... ... 
@@ -12,7 +12,8 @@
12 12 
 // [Api-Begin]
13 13 
 #include "../core/apibegin.h"
14 14
15 
-namespace AsmJit {
15 
+namespace AsmJit
16 
+{
16 17
17 18 
 // ============================================================================
18 19 
 // [AsmJit::x86InstName]
... ... 
@@ -23,586 +24,585 @@ namespace AsmJit {
23 24 
 //
24 25 
 // ${X86_INST_DATA:BEGIN}
25 26 
 const char x86InstName[] =
26 
-  "\0"
27 
-  "adc\0"
28 
-  "add\0"
29 
-  "addpd\0"
30 
-  "addps\0"
31 
-  "addsd\0"
32 
-  "addss\0"
33 
-  "addsubpd\0"
34 
-  "addsubps\0"
35 
-  "amd_prefetch\0"
36 
-  "amd_prefetchw\0"
37 
-  "and\0"
38 
-  "andnpd\0"
39 
-  "andnps\0"
40 
-  "andpd\0"
41 
-  "andps\0"
42 
-  "blendpd\0"
43 
-  "blendps\0"
44 
-  "blendvpd\0"
45 
-  "blendvps\0"
46 
-  "bsf\0"
47 
-  "bsr\0"
48 
-  "bswap\0"
49 
-  "bt\0"
50 
-  "btc\0"
51 
-  "btr\0"
52 
-  "bts\0"
53 
-  "call\0"
54 
-  "cbw\0"
55 
-  "cdq\0"
56 
-  "cdqe\0"
57 
-  "clc\0"
58 
-  "cld\0"
59 
-  "clflush\0"
60 
-  "cmc\0"
61 
-  "cmova\0"
62 
-  "cmovae\0"
63 
-  "cmovb\0"
64 
-  "cmovbe\0"
65 
-  "cmovc\0"
66 
-  "cmove\0"
67 
-  "cmovg\0"
68 
-  "cmovge\0"
69 
-  "cmovl\0"
70 
-  "cmovle\0"
71 
-  "cmovna\0"
72 
-  "cmovnae\0"
73 
-  "cmovnb\0"
74 
-  "cmovnbe\0"
75 
-  "cmovnc\0"
76 
-  "cmovne\0"
77 
-  "cmovng\0"
78 
-  "cmovnge\0"
79 
-  "cmovnl\0"
80 
-  "cmovnle\0"
81 
-  "cmovno\0"
82 
-  "cmovnp\0"
83 
-  "cmovns\0"
84 
-  "cmovnz\0"
85 
-  "cmovo\0"
86 
-  "cmovp\0"
87 
-  "cmovpe\0"
88 
-  "cmovpo\0"
89 
-  "cmovs\0"
90 
-  "cmovz\0"
91 
-  "cmp\0"
92 
-  "cmppd\0"
93 
-  "cmpps\0"
94 
-  "cmpsd\0"
95 
-  "cmpss\0"
96 
-  "cmpxchg\0"
97 
-  "cmpxchg16b\0"
98 
-  "cmpxchg8b\0"
99 
-  "comisd\0"
100 
-  "comiss\0"
101 
-  "cpuid\0"
102 
-  "cqo\0"
103 
-  "crc32\0"
104 
-  "cvtdq2pd\0"
105 
-  "cvtdq2ps\0"
106 
-  "cvtpd2dq\0"
107 
-  "cvtpd2pi\0"
108 
-  "cvtpd2ps\0"
109 
-  "cvtpi2pd\0"
110 
-  "cvtpi2ps\0"
111 
-  "cvtps2dq\0"
112 
-  "cvtps2pd\0"
113 
-  "cvtps2pi\0"
114 
-  "cvtsd2si\0"
115 
-  "cvtsd2ss\0"
116 
-  "cvtsi2sd\0"
117 
-  "cvtsi2ss\0"
118 
-  "cvtss2sd\0"
119 
-  "cvtss2si\0"
120 
-  "cvttpd2dq\0"
121 
-  "cvttpd2pi\0"
122 
-  "cvttps2dq\0"
123 
-  "cvttps2pi\0"
124 
-  "cvttsd2si\0"
125 
-  "cvttss2si\0"
126 
-  "cwd\0"
127 
-  "cwde\0"
128 
-  "daa\0"
129 
-  "das\0"
130 
-  "dec\0"
131 
-  "div\0"
132 
-  "divpd\0"
133 
-  "divps\0"
134 
-  "divsd\0"
135 
-  "divss\0"
136 
-  "dppd\0"
137 
-  "dpps\0"
138 
-  "emms\0"
139 
-  "enter\0"
140 
-  "extractps\0"
141 
-  "f2xm1\0"
142 
-  "fabs\0"
143 
-  "fadd\0"
144 
-  "faddp\0"
145 
-  "fbld\0"
146 
-  "fbstp\0"
147 
-  "fchs\0"
148 
-  "fclex\0"
149 
-  "fcmovb\0"
150 
-  "fcmovbe\0"
151 
-  "fcmove\0"
152 
-  "fcmovnb\0"
153 
-  "fcmovnbe\0"
154 
-  "fcmovne\0"
155 
-  "fcmovnu\0"
156 
-  "fcmovu\0"
157 
-  "fcom\0"
158 
-  "fcomi\0"
159 
-  "fcomip\0"
160 
-  "fcomp\0"
161 
-  "fcompp\0"
162 
-  "fcos\0"
163 
-  "fdecstp\0"
164 
-  "fdiv\0"
165 
-  "fdivp\0"
166 
-  "fdivr\0"
167 
-  "fdivrp\0"
168 
-  "femms\0"
169 
-  "ffree\0"
170 
-  "fiadd\0"
171 
-  "ficom\0"
172 
-  "ficomp\0"
173 
-  "fidiv\0"
174 
-  "fidivr\0"
175 
-  "fild\0"
176 
-  "fimul\0"
177 
-  "fincstp\0"
178 
-  "finit\0"
179 
-  "fist\0"
180 
-  "fistp\0"
181 
-  "fisttp\0"
182 
-  "fisub\0"
183 
-  "fisubr\0"
184 
-  "fld\0"
185 
-  "fld1\0"
186 
-  "fldcw\0"
187 
-  "fldenv\0"
188 
-  "fldl2e\0"
189 
-  "fldl2t\0"
190 
-  "fldlg2\0"
191 
-  "fldln2\0"
192 
-  "fldpi\0"
193 
-  "fldz\0"
194 
-  "fmul\0"
195 
-  "fmulp\0"
196 
-  "fnclex\0"
197 
-  "fninit\0"
198 
-  "fnop\0"
199 
-  "fnsave\0"
200 
-  "fnstcw\0"
201 
-  "fnstenv\0"
202 
-  "fnstsw\0"
203 
-  "fpatan\0"
204 
-  "fprem\0"
205 
-  "fprem1\0"
206 
-  "fptan\0"
207 
-  "frndint\0"
208 
-  "frstor\0"
209 
-  "fsave\0"
210 
-  "fscale\0"
211 
-  "fsin\0"
212 
-  "fsincos\0"
213 
-  "fsqrt\0"
214 
-  "fst\0"
215 
-  "fstcw\0"
216 
-  "fstenv\0"
217 
-  "fstp\0"
218 
-  "fstsw\0"
219 
-  "fsub\0"
220 
-  "fsubp\0"
221 
-  "fsubr\0"
222 
-  "fsubrp\0"
223 
-  "ftst\0"
224 
-  "fucom\0"
225 
-  "fucomi\0"
226 
-  "fucomip\0"
227 
-  "fucomp\0"
228 
-  "fucompp\0"
229 
-  "fwait\0"
230 
-  "fxam\0"
231 
-  "fxch\0"
232 
-  "fxrstor\0"
233 
-  "fxsave\0"
234 
-  "fxtract\0"
235 
-  "fyl2x\0"
236 
-  "fyl2xp1\0"
237 
-  "haddpd\0"
238 
-  "haddps\0"
239 
-  "hsubpd\0"
240 
-  "hsubps\0"
241 
-  "idiv\0"
242 
-  "imul\0"
243 
-  "inc\0"
244 
-  "int3\0"
245 
-  "ja\0"
246 
-  "jae\0"
247 
-  "jb\0"
248 
-  "jbe\0"
249 
-  "jc\0"
250 
-  "je\0"
251 
-  "jg\0"
252 
-  "jge\0"
253 
-  "jl\0"
254 
-  "jle\0"
255 
-  "jna\0"
256 
-  "jnae\0"
257 
-  "jnb\0"
258 
-  "jnbe\0"
259 
-  "jnc\0"
260 
-  "jne\0"
261 
-  "jng\0"
262 
-  "jnge\0"
263 
-  "jnl\0"
264 
-  "jnle\0"
265 
-  "jno\0"
266 
-  "jnp\0"
267 
-  "jns\0"
268 
-  "jnz\0"
269 
-  "jo\0"
270 
-  "jp\0"
271 
-  "jpe\0"
272 
-  "jpo\0"
273 
-  "js\0"
274 
-  "jz\0"
275 
-  "jmp\0"
276 
-  "lddqu\0"
277 
-  "ldmxcsr\0"
278 
-  "lahf\0"
279 
-  "lea\0"
280 
-  "leave\0"
281 
-  "lfence\0"
282 
-  "maskmovdqu\0"
283 
-  "maskmovq\0"
284 
-  "maxpd\0"
285 
-  "maxps\0"
286 
-  "maxsd\0"
287 
-  "maxss\0"
288 
-  "mfence\0"
289 
-  "minpd\0"
290 
-  "minps\0"
291 
-  "minsd\0"
292 
-  "minss\0"
293 
-  "monitor\0"
294 
-  "mov\0"
295 
-  "movapd\0"
296 
-  "movaps\0"
297 
-  "movbe\0"
298 
-  "movd\0"
299 
-  "movddup\0"
300 
-  "movdq2q\0"
301 
-  "movdqa\0"
302 
-  "movdqu\0"
303 
-  "movhlps\0"
304 
-  "movhpd\0"
305 
-  "movhps\0"
306 
-  "movlhps\0"
307 
-  "movlpd\0"
308 
-  "movlps\0"
309 
-  "movmskpd\0"
310 
-  "movmskps\0"
311 
-  "movntdq\0"
312 
-  "movntdqa\0"
313 
-  "movnti\0"
314 
-  "movntpd\0"
315 
-  "movntps\0"
316 
-  "movntq\0"
317 
-  "movq\0"
318 
-  "movq2dq\0"
319 
-  "movsd\0"
320 
-  "movshdup\0"
321 
-  "movsldup\0"
322 
-  "movss\0"
323 
-  "movsx\0"
324 
-  "movsxd\0"
325 
-  "movupd\0"
326 
-  "movups\0"
327 
-  "movzx\0"
328 
-  "mov_ptr\0"
329 
-  "mpsadbw\0"
330 
-  "mul\0"
331 
-  "mulpd\0"
332 
-  "mulps\0"
333 
-  "mulsd\0"
334 
-  "mulss\0"
335 
-  "mwait\0"
336 
-  "neg\0"
337 
-  "nop\0"
338 
-  "not\0"
339 
-  "or\0"
340 
-  "orpd\0"
341 
-  "orps\0"
342 
-  "pabsb\0"
343 
-  "pabsd\0"
344 
-  "pabsw\0"
345 
-  "packssdw\0"
346 
-  "packsswb\0"
347 
-  "packusdw\0"
348 
-  "packuswb\0"
349 
-  "paddb\0"
350 
-  "paddd\0"
351 
-  "paddq\0"
352 
-  "paddsb\0"
353 
-  "paddsw\0"
354 
-  "paddusb\0"
355 
-  "paddusw\0"
356 
-  "paddw\0"
357 
-  "palignr\0"
358 
-  "pand\0"
359 
-  "pandn\0"
360 
-  "pause\0"
361 
-  "pavgb\0"
362 
-  "pavgw\0"
363 
-  "pblendvb\0"
364 
-  "pblendw\0"
365 
-  "pcmpeqb\0"
366 
-  "pcmpeqd\0"
367 
-  "pcmpeqq\0"
368 
-  "pcmpeqw\0"
369 
-  "pcmpestri\0"
370 
-  "pcmpestrm\0"
371 
-  "pcmpgtb\0"
372 
-  "pcmpgtd\0"
373 
-  "pcmpgtq\0"
374 
-  "pcmpgtw\0"
375 
-  "pcmpistri\0"
376 
-  "pcmpistrm\0"
377 
-  "pextrb\0"
378 
-  "pextrd\0"
379 
-  "pextrq\0"
380 
-  "pextrw\0"
381 
-  "pf2id\0"
382 
-  "pf2iw\0"
383 
-  "pfacc\0"
384 
-  "pfadd\0"
385 
-  "pfcmpeq\0"
386 
-  "pfcmpge\0"
387 
-  "pfcmpgt\0"
388 
-  "pfmax\0"
389 
-  "pfmin\0"
390 
-  "pfmul\0"
391 
-  "pfnacc\0"
392 
-  "pfpnacc\0"
393 
-  "pfrcp\0"
394 
-  "pfrcpit1\0"
395 
-  "pfrcpit2\0"
396 
-  "pfrsqit1\0"
397 
-  "pfrsqrt\0"
398 
-  "pfsub\0"
399 
-  "pfsubr\0"
400 
-  "phaddd\0"
401 
-  "phaddsw\0"
402 
-  "phaddw\0"
403 
-  "phminposuw\0"
404 
-  "phsubd\0"
405 
-  "phsubsw\0"
406 
-  "phsubw\0"
407 
-  "pi2fd\0"
408 
-  "pi2fw\0"
409 
-  "pinsrb\0"
410 
-  "pinsrd\0"
411 
-  "pinsrq\0"
412 
-  "pinsrw\0"
413 
-  "pmaddubsw\0"
414 
-  "pmaddwd\0"
415 
-  "pmaxsb\0"
416 
-  "pmaxsd\0"
417 
-  "pmaxsw\0"
418 
-  "pmaxub\0"
419 
-  "pmaxud\0"
420 
-  "pmaxuw\0"
421 
-  "pminsb\0"
422 
-  "pminsd\0"
423 
-  "pminsw\0"
424 
-  "pminub\0"
425 
-  "pminud\0"
426 
-  "pminuw\0"
427 
-  "pmovmskb\0"
428 
-  "pmovsxbd\0"
429 
-  "pmovsxbq\0"
430 
-  "pmovsxbw\0"
431 
-  "pmovsxdq\0"
432 
-  "pmovsxwd\0"
433 
-  "pmovsxwq\0"
434 
-  "pmovzxbd\0"
435 
-  "pmovzxbq\0"
436 
-  "pmovzxbw\0"
437 
-  "pmovzxdq\0"
438 
-  "pmovzxwd\0"
439 
-  "pmovzxwq\0"
440 
-  "pmuldq\0"
441 
-  "pmulhrsw\0"
442 
-  "pmulhuw\0"
443 
-  "pmulhw\0"
444 
-  "pmulld\0"
445 
-  "pmullw\0"
446 
-  "pmuludq\0"
447 
-  "pop\0"
448 
-  "popad\0"
449 
-  "popcnt\0"
450 
-  "popfd\0"
451 
-  "popfq\0"
452 
-  "por\0"
453 
-  "prefetch\0"
454 
-  "psadbw\0"
455 
-  "pshufb\0"
456 
-  "pshufd\0"
457 
-  "pshufw\0"
458 
-  "pshufhw\0"
459 
-  "pshuflw\0"
460 
-  "psignb\0"
461 
-  "psignd\0"
462 
-  "psignw\0"
463 
-  "pslld\0"
464 
-  "pslldq\0"
465 
-  "psllq\0"
466 
-  "psllw\0"
467 
-  "psrad\0"
468 
-  "psraw\0"
469 
-  "psrld\0"
470 
-  "psrldq\0"
471 
-  "psrlq\0"
472 
-  "psrlw\0"
473 
-  "psubb\0"
474 
-  "psubd\0"
475 
-  "psubq\0"
476 
-  "psubsb\0"
477 
-  "psubsw\0"
478 
-  "psubusb\0"
479 
-  "psubusw\0"
480 
-  "psubw\0"
481 
-  "pswapd\0"
482 
-  "ptest\0"
483 
-  "punpckhbw\0"
484 
-  "punpckhdq\0"
485 
-  "punpckhqdq\0"
486 
-  "punpckhwd\0"
487 
-  "punpcklbw\0"
488 
-  "punpckldq\0"
489 
-  "punpcklqdq\0"
490 
-  "punpcklwd\0"
491 
-  "push\0"
492 
-  "pushad\0"
493 
-  "pushfd\0"
494 
-  "pushfq\0"
495 
-  "pxor\0"
496 
-  "rcl\0"
497 
-  "rcpps\0"
498 
-  "rcpss\0"
499 
-  "rcr\0"
500 
-  "rdtsc\0"
501 
-  "rdtscp\0"
502 
-  "rep lodsb\0"
503 
-  "rep lodsd\0"
504 
-  "rep lodsq\0"
505 
-  "rep lodsw\0"
506 
-  "rep movsb\0"
507 
-  "rep movsd\0"
508 
-  "rep movsq\0"
509 
-  "rep movsw\0"
510 
-  "rep stosb\0"
511 
-  "rep stosd\0"
512 
-  "rep stosq\0"
513 
-  "rep stosw\0"
514 
-  "repe cmpsb\0"
515 
-  "repe cmpsd\0"
516 
-  "repe cmpsq\0"
517 
-  "repe cmpsw\0"
518 
-  "repe scasb\0"
519 
-  "repe scasd\0"
520 
-  "repe scasq\0"
521 
-  "repe scasw\0"
522 
-  "repne cmpsb\0"
523 
-  "repne cmpsd\0"
524 
-  "repne cmpsq\0"
525 
-  "repne cmpsw\0"
526 
-  "repne scasb\0"
527 
-  "repne scasd\0"
528 
-  "repne scasq\0"
529 
-  "repne scasw\0"
530 
-  "ret\0"
531 
-  "rol\0"
532 
-  "ror\0"
533 
-  "roundpd\0"
534 
-  "roundps\0"
535 
-  "roundsd\0"
536 
-  "roundss\0"
537 
-  "rsqrtps\0"
538 
-  "rsqrtss\0"
539 
-  "sahf\0"
540 
-  "sal\0"
541 
-  "sar\0"
542 
-  "sbb\0"
543 
-  "seta\0"
544 
-  "setae\0"
545 
-  "setb\0"
546 
-  "setbe\0"
547 
-  "setc\0"
548 
-  "sete\0"
549 
-  "setg\0"
550 
-  "setge\0"
551 
-  "setl\0"
552 
-  "setle\0"
553 
-  "setna\0"
554 
-  "setnae\0"
555 
-  "setnb\0"
556 
-  "setnbe\0"
557 
-  "setnc\0"
558 
-  "setne\0"
559 
-  "setng\0"
560 
-  "setnge\0"
561 
-  "setnl\0"
562 
-  "setnle\0"
563 
-  "setno\0"
564 
-  "setnp\0"
565 
-  "setns\0"
566 
-  "setnz\0"
567 
-  "seto\0"
568 
-  "setp\0"
569 
-  "setpe\0"
570 
-  "setpo\0"
571 
-  "sets\0"
572 
-  "setz\0"
573 
-  "sfence\0"
574 
-  "shl\0"
575 
-  "shld\0"
576 
-  "shr\0"
577 
-  "shrd\0"
578 
-  "shufpd\0"
579 
-  "shufps\0"
580 
-  "sqrtpd\0"
581 
-  "sqrtps\0"
582 
-  "sqrtsd\0"
583 
-  "sqrtss\0"
584 
-  "stc\0"
585 
-  "std\0"
586 
-  "stmxcsr\0"
587 
-  "sub\0"
588 
-  "subpd\0"
589 
-  "subps\0"
590 
-  "subsd\0"
591 
-  "subss\0"
592 
-  "test\0"
593 
-  "ucomisd\0"
594 
-  "ucomiss\0"
595 
-  "ud2\0"
596 
-  "unpckhpd\0"
597 
-  "unpckhps\0"
598 
-  "unpcklpd\0"
599 
-  "unpcklps\0"
600 
-  "xadd\0"
601 
-  "xchg\0"
602 
-  "xor\0"
603 
-  "xorpd\0"
604 
-  "xorps\0"
605 
-  ;
27 
+	"\0"
28 
+	"adc\0"
29 
+	"add\0"
30 
+	"addpd\0"
31 
+	"addps\0"
32 
+	"addsd\0"
33 
+	"addss\0"
34 
+	"addsubpd\0"
35 
+	"addsubps\0"
36 
+	"amd_prefetch\0"
37 
+	"amd_prefetchw\0"
38 
+	"and\0"
39 
+	"andnpd\0"
40 
+	"andnps\0"
41 
+	"andpd\0"
42 
+	"andps\0"
43 
+	"blendpd\0"
44 
+	"blendps\0"
45 
+	"blendvpd\0"
46 
+	"blendvps\0"
47 
+	"bsf\0"
48 
+	"bsr\0"
49 
+	"bswap\0"
50 
+	"bt\0"
51 
+	"btc\0"
52 
+	"btr\0"
53 
+	"bts\0"
54 
+	"call\0"
55 
+	"cbw\0"
56 
+	"cdq\0"
57 
+	"cdqe\0"
58 
+	"clc\0"
59 
+	"cld\0"
60 
+	"clflush\0"
61 
+	"cmc\0"
62 
+	"cmova\0"
63 
+	"cmovae\0"
64 
+	"cmovb\0"
65 
+	"cmovbe\0"
66 
+	"cmovc\0"
67 
+	"cmove\0"
68 
+	"cmovg\0"
69 
+	"cmovge\0"
70 
+	"cmovl\0"
71 
+	"cmovle\0"
72 
+	"cmovna\0"
73 
+	"cmovnae\0"
74 
+	"cmovnb\0"
75 
+	"cmovnbe\0"
76 
+	"cmovnc\0"
77 
+	"cmovne\0"
78 
+	"cmovng\0"
79 
+	"cmovnge\0"
80 
+	"cmovnl\0"
81 
+	"cmovnle\0"
82 
+	"cmovno\0"
83 
+	"cmovnp\0"
84 
+	"cmovns\0"
85 
+	"cmovnz\0"
86 
+	"cmovo\0"
87 
+	"cmovp\0"
88 
+	"cmovpe\0"
89 
+	"cmovpo\0"
90 
+	"cmovs\0"
91 
+	"cmovz\0"
92 
+	"cmp\0"
93 
+	"cmppd\0"
94 
+	"cmpps\0"
95 
+	"cmpsd\0"
96 
+	"cmpss\0"
97 
+	"cmpxchg\0"
98 
+	"cmpxchg16b\0"
99 
+	"cmpxchg8b\0"
100 
+	"comisd\0"
101 
+	"comiss\0"
102 
+	"cpuid\0"
103 
+	"cqo\0"
104 
+	"crc32\0"
105 
+	"cvtdq2pd\0"
106 
+	"cvtdq2ps\0"
107 
+	"cvtpd2dq\0"
108 
+	"cvtpd2pi\0"
109 
+	"cvtpd2ps\0"
110 
+	"cvtpi2pd\0"
111 
+	"cvtpi2ps\0"
112 
+	"cvtps2dq\0"
113 
+	"cvtps2pd\0"
114 
+	"cvtps2pi\0"
115 
+	"cvtsd2si\0"
116 
+	"cvtsd2ss\0"
117 
+	"cvtsi2sd\0"
118 
+	"cvtsi2ss\0"
119 
+	"cvtss2sd\0"
120 
+	"cvtss2si\0"
121 
+	"cvttpd2dq\0"
122 
+	"cvttpd2pi\0"
123 
+	"cvttps2dq\0"
124 
+	"cvttps2pi\0"
125 
+	"cvttsd2si\0"
126 
+	"cvttss2si\0"
127 
+	"cwd\0"
128 
+	"cwde\0"
129 
+	"daa\0"
130 
+	"das\0"
131 
+	"dec\0"
132 
+	"div\0"
133 
+	"divpd\0"
134 
+	"divps\0"
135 
+	"divsd\0"
136 
+	"divss\0"
137 
+	"dppd\0"
138 
+	"dpps\0"
139 
+	"emms\0"
140 
+	"enter\0"
141 
+	"extractps\0"
142 
+	"f2xm1\0"
143 
+	"fabs\0"
144 
+	"fadd\0"
145 
+	"faddp\0"
146 
+	"fbld\0"
147 
+	"fbstp\0"
148 
+	"fchs\0"
149 
+	"fclex\0"
150 
+	"fcmovb\0"
151 
+	"fcmovbe\0"
152 
+	"fcmove\0"
153 
+	"fcmovnb\0"
154 
+	"fcmovnbe\0"
155 
+	"fcmovne\0"
156 
+	"fcmovnu\0"
157 
+	"fcmovu\0"
158 
+	"fcom\0"
159 
+	"fcomi\0"
160 
+	"fcomip\0"
161 
+	"fcomp\0"
162 
+	"fcompp\0"
163 
+	"fcos\0"
164 
+	"fdecstp\0"
165 
+	"fdiv\0"
166 
+	"fdivp\0"
167 
+	"fdivr\0"
168 
+	"fdivrp\0"
169 
+	"femms\0"
170 
+	"ffree\0"
171 
+	"fiadd\0"
172 
+	"ficom\0"
173 
+	"ficomp\0"
174 
+	"fidiv\0"
175 
+	"fidivr\0"
176 
+	"fild\0"
177 
+	"fimul\0"
178 
+	"fincstp\0"
179 
+	"finit\0"
180 
+	"fist\0"
181 
+	"fistp\0"
182 
+	"fisttp\0"
183 
+	"fisub\0"
184 
+	"fisubr\0"
185 
+	"fld\0"
186 
+	"fld1\0"
187 
+	"fldcw\0"
188 
+	"fldenv\0"
189 
+	"fldl2e\0"
190 
+	"fldl2t\0"
191 
+	"fldlg2\0"
192 
+	"fldln2\0"
193 
+	"fldpi\0"
194 
+	"fldz\0"
195 
+	"fmul\0"
196 
+	"fmulp\0"
197 
+	"fnclex\0"
198 
+	"fninit\0"
199 
+	"fnop\0"
200 
+	"fnsave\0"
201 
+	"fnstcw\0"
202 
+	"fnstenv\0"
203 
+	"fnstsw\0"
204 
+	"fpatan\0"
205 
+	"fprem\0"
206 
+	"fprem1\0"
207 
+	"fptan\0"
208 
+	"frndint\0"
209 
+	"frstor\0"
210 
+	"fsave\0"
211 
+	"fscale\0"
212 
+	"fsin\0"
213 
+	"fsincos\0"
214 
+	"fsqrt\0"
215 
+	"fst\0"
216 
+	"fstcw\0"
217 
+	"fstenv\0"
218 
+	"fstp\0"
219 
+	"fstsw\0"
220 
+	"fsub\0"
221 
+	"fsubp\0"
222 
+	"fsubr\0"
223 
+	"fsubrp\0"
224 
+	"ftst\0"
225 
+	"fucom\0"
226 
+	"fucomi\0"
227 
+	"fucomip\0"
228 
+	"fucomp\0"
229 
+	"fucompp\0"
230 
+	"fwait\0"
231 
+	"fxam\0"
232 
+	"fxch\0"
233 
+	"fxrstor\0"
234 
+	"fxsave\0"
235 
+	"fxtract\0"
236 
+	"fyl2x\0"
237 
+	"fyl2xp1\0"
238 
+	"haddpd\0"
239 
+	"haddps\0"
240 
+	"hsubpd\0"
241 
+	"hsubps\0"
242 
+	"idiv\0"
243 
+	"imul\0"
244 
+	"inc\0"
245 
+	"int3\0"
246 
+	"ja\0"
247 
+	"jae\0"
248 
+	"jb\0"
249 
+	"jbe\0"
250 
+	"jc\0"
251 
+	"je\0"
252 
+	"jg\0"
253 
+	"jge\0"
254 
+	"jl\0"
255 
+	"jle\0"
256 
+	"jna\0"
257 
+	"jnae\0"
258 
+	"jnb\0"
259 
+	"jnbe\0"
260 
+	"jnc\0"
261 
+	"jne\0"
262 
+	"jng\0"
263 
+	"jnge\0"
264 
+	"jnl\0"
265 
+	"jnle\0"
266 
+	"jno\0"
267 
+	"jnp\0"
268 
+	"jns\0"
269 
+	"jnz\0"
270 
+	"jo\0"
271 
+	"jp\0"
272 
+	"jpe\0"
273 
+	"jpo\0"
274 
+	"js\0"
275 
+	"jz\0"
276 
+	"jmp\0"
277 
+	"lddqu\0"
278 
+	"ldmxcsr\0"
279 
+	"lahf\0"
280 
+	"lea\0"
281 
+	"leave\0"
282 
+	"lfence\0"
283 
+	"maskmovdqu\0"
284 
+	"maskmovq\0"
285 
+	"maxpd\0"
286 
+	"maxps\0"
287 
+	"maxsd\0"
288 
+	"maxss\0"
289 
+	"mfence\0"
290 
+	"minpd\0"
291 
+	"minps\0"
292 
+	"minsd\0"
293 
+	"minss\0"
294 
+	"monitor\0"
295 
+	"mov\0"
296 
+	"movapd\0"
297 
+	"movaps\0"
298 
+	"movbe\0"
299 
+	"movd\0"
300 
+	"movddup\0"
301 
+	"movdq2q\0"
302 
+	"movdqa\0"
303 
+	"movdqu\0"
304 
+	"movhlps\0"
305 
+	"movhpd\0"
306 
+	"movhps\0"
307 
+	"movlhps\0"
308 
+	"movlpd\0"
309 
+	"movlps\0"
310 
+	"movmskpd\0"
311 
+	"movmskps\0"
312 
+	"movntdq\0"
313 
+	"movntdqa\0"
314 
+	"movnti\0"
315 
+	"movntpd\0"
316 
+	"movntps\0"
317 
+	"movntq\0"
318 
+	"movq\0"
319 
+	"movq2dq\0"
320 
+	"movsd\0"
321 
+	"movshdup\0"
322 
+	"movsldup\0"
323 
+	"movss\0"
324 
+	"movsx\0"
325 
+	"movsxd\0"
326 
+	"movupd\0"
327 
+	"movups\0"
328 
+	"movzx\0"
329 
+	"mov_ptr\0"
330 
+	"mpsadbw\0"
331 
+	"mul\0"
332 
+	"mulpd\0"
333 
+	"mulps\0"
334 
+	"mulsd\0"
335 
+	"mulss\0"
336 
+	"mwait\0"
337 
+	"neg\0"
338 
+	"nop\0"
339 
+	"not\0"
340 
+	"or\0"
341 
+	"orpd\0"
342 
+	"orps\0"
343 
+	"pabsb\0"
344 
+	"pabsd\0"
345 
+	"pabsw\0"
346 
+	"packssdw\0"
347 
+	"packsswb\0"
348 
+	"packusdw\0"
349 
+	"packuswb\0"
350 
+	"paddb\0"
351 
+	"paddd\0"
352 
+	"paddq\0"
353 
+	"paddsb\0"
354 
+	"paddsw\0"
355 
+	"paddusb\0"
356 
+	"paddusw\0"
357 
+	"paddw\0"
358 
+	"palignr\0"
359 
+	"pand\0"
360 
+	"pandn\0"
361 
+	"pause\0"
362 
+	"pavgb\0"
363 
+	"pavgw\0"
364 
+	"pblendvb\0"
365 
+	"pblendw\0"
366 
+	"pcmpeqb\0"
367 
+	"pcmpeqd\0"
368 
+	"pcmpeqq\0"
369 
+	"pcmpeqw\0"
370 
+	"pcmpestri\0"
371 
+	"pcmpestrm\0"
372 
+	"pcmpgtb\0"
373 
+	"pcmpgtd\0"
374 
+	"pcmpgtq\0"
375 
+	"pcmpgtw\0"
376 
+	"pcmpistri\0"
377 
+	"pcmpistrm\0"
378 
+	"pextrb\0"
379 
+	"pextrd\0"
380 
+	"pextrq\0"
381 
+	"pextrw\0"
382 
+	"pf2id\0"
383 
+	"pf2iw\0"
384 
+	"pfacc\0"
385 
+	"pfadd\0"
386 
+	"pfcmpeq\0"
387 
+	"pfcmpge\0"
388 
+	"pfcmpgt\0"
389 
+	"pfmax\0"
390 
+	"pfmin\0"
391 
+	"pfmul\0"
392 
+	"pfnacc\0"
393 
+	"pfpnacc\0"
394 
+	"pfrcp\0"
395 
+	"pfrcpit1\0"
396 
+	"pfrcpit2\0"
397 
+	"pfrsqit1\0"
398 
+	"pfrsqrt\0"
399 
+	"pfsub\0"
400 
+	"pfsubr\0"
401 
+	"phaddd\0"
402 
+	"phaddsw\0"
403 
+	"phaddw\0"
404 
+	"phminposuw\0"
405 
+	"phsubd\0"
406 
+	"phsubsw\0"
407 
+	"phsubw\0"
408 
+	"pi2fd\0"
409 
+	"pi2fw\0"
410 
+	"pinsrb\0"
411 
+	"pinsrd\0"
412 
+	"pinsrq\0"
413 
+	"pinsrw\0"
414 
+	"pmaddubsw\0"
415 
+	"pmaddwd\0"
416 
+	"pmaxsb\0"
417 
+	"pmaxsd\0"
418 
+	"pmaxsw\0"
419 
+	"pmaxub\0"
420 
+	"pmaxud\0"
421 
+	"pmaxuw\0"
422 
+	"pminsb\0"
423 
+	"pminsd\0"
424 
+	"pminsw\0"
425 
+	"pminub\0"
426 
+	"pminud\0"
427 
+	"pminuw\0"
428 
+	"pmovmskb\0"
429 
+	"pmovsxbd\0"
430 
+	"pmovsxbq\0"
431 
+	"pmovsxbw\0"
432 
+	"pmovsxdq\0"
433 
+	"pmovsxwd\0"
434 
+	"pmovsxwq\0"
435 
+	"pmovzxbd\0"
436 
+	"pmovzxbq\0"
437 
+	"pmovzxbw\0"
438 
+	"pmovzxdq\0"
439 
+	"pmovzxwd\0"
440 
+	"pmovzxwq\0"
441 
+	"pmuldq\0"
442 
+	"pmulhrsw\0"
443 
+	"pmulhuw\0"
444 
+	"pmulhw\0"
445 
+	"pmulld\0"
446 
+	"pmullw\0"
447 
+	"pmuludq\0"
448 
+	"pop\0"
449 
+	"popad\0"
450 
+	"popcnt\0"
451 
+	"popfd\0"
452 
+	"popfq\0"
453 
+	"por\0"
454 
+	"prefetch\0"
455 
+	"psadbw\0"
456 
+	"pshufb\0"
457 
+	"pshufd\0"
458 
+	"pshufw\0"
459 
+	"pshufhw\0"
460 
+	"pshuflw\0"
461 
+	"psignb\0"
462 
+	"psignd\0"
463 
+	"psignw\0"
464 
+	"pslld\0"
465 
+	"pslldq\0"
466 
+	"psllq\0"
467 
+	"psllw\0"
468 
+	"psrad\0"
469 
+	"psraw\0"
470 
+	"psrld\0"
471 
+	"psrldq\0"
472 
+	"psrlq\0"
473 
+	"psrlw\0"
474 
+	"psubb\0"
475 
+	"psubd\0"
476 
+	"psubq\0"
477 
+	"psubsb\0"
478 
+	"psubsw\0"
479 
+	"psubusb\0"
480 
+	"psubusw\0"
481 
+	"psubw\0"
482 
+	"pswapd\0"
483 
+	"ptest\0"
484 
+	"punpckhbw\0"
485 
+	"punpckhdq\0"
486 
+	"punpckhqdq\0"
487 
+	"punpckhwd\0"
488 
+	"punpcklbw\0"
489 
+	"punpckldq\0"
490 
+	"punpcklqdq\0"
491 
+	"punpcklwd\0"
492 
+	"push\0"
493 
+	"pushad\0"
494 
+	"pushfd\0"
495 
+	"pushfq\0"
496 
+	"pxor\0"
497 
+	"rcl\0"
498 
+	"rcpps\0"
499 
+	"rcpss\0"
500 
+	"rcr\0"
501 
+	"rdtsc\0"
502 
+	"rdtscp\0"
503 
+	"rep lodsb\0"
504 
+	"rep lodsd\0"
505 
+	"rep lodsq\0"
506 
+	"rep lodsw\0"
507 
+	"rep movsb\0"
508 
+	"rep movsd\0"
509 
+	"rep movsq\0"
510 
+	"rep movsw\0"
511 
+	"rep stosb\0"
512 
+	"rep stosd\0"
513 
+	"rep stosq\0"
514 
+	"rep stosw\0"
515 
+	"repe cmpsb\0"
516 
+	"repe cmpsd\0"
517 
+	"repe cmpsq\0"
518 
+	"repe cmpsw\0"
519 
+	"repe scasb\0"
520 
+	"repe scasd\0"
521 
+	"repe scasq\0"
522 
+	"repe scasw\0"
523 
+	"repne cmpsb\0"
524 
+	"repne cmpsd\0"
525 
+	"repne cmpsq\0"
526 
+	"repne cmpsw\0"
527 
+	"repne scasb\0"
528 
+	"repne scasd\0"
529 
+	"repne scasq\0"
530 
+	"repne scasw\0"
531 
+	"ret\0"
532 
+	"rol\0"
533 
+	"ror\0"
534 
+	"roundpd\0"
535 
+	"roundps\0"
536 
+	"roundsd\0"
537 
+	"roundss\0"
538 
+	"rsqrtps\0"
539 
+	"rsqrtss\0"
540 
+	"sahf\0"
541 
+	"sal\0"
542 
+	"sar\0"
543 
+	"sbb\0"
544 
+	"seta\0"
545 
+	"setae\0"
546 
+	"setb\0"
547 
+	"setbe\0"
548 
+	"setc\0"
549 
+	"sete\0"
550 
+	"setg\0"
551 
+	"setge\0"
552 
+	"setl\0"
553 
+	"setle\0"
554 
+	"setna\0"
555 
+	"setnae\0"
556 
+	"setnb\0"
557 
+	"setnbe\0"
558 
+	"setnc\0"
559 
+	"setne\0"
560 
+	"setng\0"
561 
+	"setnge\0"
562 
+	"setnl\0"
563 
+	"setnle\0"
564 
+	"setno\0"
565 
+	"setnp\0"
566 
+	"setns\0"
567 
+	"setnz\0"
568 
+	"seto\0"
569 
+	"setp\0"
570 
+	"setpe\0"
571 
+	"setpo\0"
572 
+	"sets\0"
573 
+	"setz\0"
574 
+	"sfence\0"
575 
+	"shl\0"
576 
+	"shld\0"
577 
+	"shr\0"
578 
+	"shrd\0"
579 
+	"shufpd\0"
580 
+	"shufps\0"
581 
+	"sqrtpd\0"
582 
+	"sqrtps\0"
583 
+	"sqrtsd\0"
584 
+	"sqrtss\0"
585 
+	"stc\0"
586 
+	"std\0"
587 
+	"stmxcsr\0"
588 
+	"sub\0"
589 
+	"subpd\0"
590 
+	"subps\0"
591 
+	"subsd\0"
592 
+	"subss\0"
593 
+	"test\0"
594 
+	"ucomisd\0"
595 
+	"ucomiss\0"
596 
+	"ud2\0"
597 
+	"unpckhpd\0"
598 
+	"unpckhps\0"
599 
+	"unpcklpd\0"
600 
+	"unpcklps\0"
601 
+	"xadd\0"
602 
+	"xchg\0"
603 
+	"xor\0"
604 
+	"xorpd\0"
605 
+	"xorps\0";
606 606
607 607 
 #define INDEX_kInstNone 0
608 608 
 #define INDEX_kX86InstAdc 1
... ... 
@@ -1190,7 +1190,7 @@ const char x86InstName[] =
1190 1190 
 // ============================================================================
1191 1191
1192 1192 
 #define INST(_Code_, _Name_, _Group_, _Flags_, _OpFlags0_, _OpFlags1_, _OpReg_, _OpCode0_, _OpCode1_) \
1193 
-  { _Code_, INDEX_##_Code_, _Group_, _Flags_, { _OpFlags0_, _OpFlags1_ }, _OpReg_, { _OpCode0_, _OpCode1_ } }
1193 
+	{ _Code_, INDEX_##_Code_, _Group_, _Flags_, { _OpFlags0_, _OpFlags1_ }, _OpReg_, { _OpCode0_, _OpCode1_ } }
1194 1194
1195 1195 
 #define G(_Group_) kX86InstGroup##_Group_
1196 1196 
 #define F(_Flags_) kX86InstFlag##_Flags_
... ... 
@@ -1198,586 +1198,586 @@ const char x86InstName[] =
1198 1198
1199 1199 
 const X86InstInfo x86InstInfo[] =
1200 1200 
 {
1201 
-  // Instruction code           | Instruction name   | Instruction group| Instruction flags| Operand flags[0]    | Operand flags[1]    | r| opCode[0] | opcode[1]
1202 
-  INST(kInstNone                , ""                 , G(None)          , F(None)          , 0                   , 0                   , 0, 0         , 0),
1203 
-  INST(kX86InstAdc              , "adc"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 2, 0x00000010, 0x00000080),
1204 
-  INST(kX86InstAdd              , "add"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 0, 0x00000000, 0x00000080),
1205 
-  INST(kX86InstAddPD            , "addpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F58, 0),
1206 
-  INST(kX86InstAddPS            , "addps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F58, 0),
1207 
-  INST(kX86InstAddSD            , "addsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F58, 0),
1208 
-  INST(kX86InstAddSS            , "addss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F58, 0),
1209 
-  INST(kX86InstAddSubPD         , "addsubpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000FD0, 0),
1210 
-  INST(kX86InstAddSubPS         , "addsubps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000FD0, 0),
1211 
-  INST(kX86InstAmdPrefetch      , "amd_prefetch"     , G(Mem)           , F(None)          , O(Mem)              , 0                   , 0, 0x00000F0D, 0),
1212 
-  INST(kX86InstAmdPrefetchW     , "amd_prefetchw"    , G(Mem)           , F(None)          , O(Mem)              , 0                   , 1, 0x00000F0D, 0),
1213 
-  INST(kX86InstAnd              , "and"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 4, 0x00000020, 0x00000080),
1214 
-  INST(kX86InstAndnPD           , "andnpd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F55, 0),
1215 
-  INST(kX86InstAndnPS           , "andnps"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F55, 0),
1216 
-  INST(kX86InstAndPD            , "andpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F54, 0),
1217 
-  INST(kX86InstAndPS            , "andps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F54, 0),
1218 
-  INST(kX86InstBlendPD          , "blendpd"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0D, 0),
1219 
-  INST(kX86InstBlendPS          , "blendps"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0C, 0),
1220 
-  INST(kX86InstBlendVPD         , "blendvpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3815, 0),
1221 
-  INST(kX86InstBlendVPS         , "blendvps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3814, 0),
1222 
-  INST(kX86InstBsf              , "bsf"              , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000FBC, 0),
1223 
-  INST(kX86InstBsr              , "bsr"              , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000FBD, 0),
1224 
-  INST(kX86InstBSwap            , "bswap"            , G(BSwap)         , F(None)          , O(Gqd)              , 0                   , 0, 0         , 0),
1225 
-  INST(kX86InstBt               , "bt"               , G(BTest)         , F(None)          , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 4, 0x00000FA3, 0x00000FBA),
1226 
-  INST(kX86InstBtc              , "btc"              , G(BTest)         , F(Lockable)      , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 7, 0x00000FBB, 0x00000FBA),
1227 
-  INST(kX86InstBtr              , "btr"              , G(BTest)         , F(Lockable)      , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 6, 0x00000FB3, 0x00000FBA),
1228 
-  INST(kX86InstBts              , "bts"              , G(BTest)         , F(Lockable)      , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 5, 0x00000FAB, 0x00000FBA),
1229 
-  INST(kX86InstCall             , "call"             , G(Call)          , F(Jump)          , O(Gqd) |O(Mem)      , 0                   , 0, 0         , 0),
1230 
-  INST(kX86InstCbw              , "cbw"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x66000098, 0),
1231 
-  INST(kX86InstCdq              , "cdq"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000099, 0),
1232 
-  INST(kX86InstCdqe             , "cdqe"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x48000098, 0),
1233 
-  INST(kX86InstClc              , "clc"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000F8, 0),
1234 
-  INST(kX86InstCld              , "cld"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000FC, 0),
1235 
-  INST(kX86InstClFlush          , "clflush"          , G(Mem)           , F(None)          , O(Mem)              , 0                   , 7, 0x00000FAE, 0),
1236 
-  INST(kX86InstCmc              , "cmc"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000F5, 0),
1237 
-  INST(kX86InstCMovA            , "cmova"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F47, 0),
1238 
-  INST(kX86InstCMovAE           , "cmovae"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F43, 0),
1239 
-  INST(kX86InstCMovB            , "cmovb"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F42, 0),
1240 
-  INST(kX86InstCMovBE           , "cmovbe"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F46, 0),
1241 
-  INST(kX86InstCMovC            , "cmovc"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F42, 0),
1242 
-  INST(kX86InstCMovE            , "cmove"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F44, 0),
1243 
-  INST(kX86InstCMovG            , "cmovg"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4F, 0),
1244 
-  INST(kX86InstCMovGE           , "cmovge"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4D, 0),
1245 
-  INST(kX86InstCMovL            , "cmovl"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4C, 0),
1246 
-  INST(kX86InstCMovLE           , "cmovle"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4E, 0),
1247 
-  INST(kX86InstCMovNA           , "cmovna"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F46, 0),
1248 
-  INST(kX86InstCMovNAE          , "cmovnae"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F42, 0),
1249 
-  INST(kX86InstCMovNB           , "cmovnb"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F43, 0),
1250 
-  INST(kX86InstCMovNBE          , "cmovnbe"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F47, 0),
1251 
-  INST(kX86InstCMovNC           , "cmovnc"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F43, 0),
1252 
-  INST(kX86InstCMovNE           , "cmovne"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F45, 0),
1253 
-  INST(kX86InstCMovNG           , "cmovng"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4E, 0),
1254 
-  INST(kX86InstCMovNGE          , "cmovnge"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4C, 0),
1255 
-  INST(kX86InstCMovNL           , "cmovnl"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4D, 0),
1256 
-  INST(kX86InstCMovNLE          , "cmovnle"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4F, 0),
1257 
-  INST(kX86InstCMovNO           , "cmovno"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F41, 0),
1258 
-  INST(kX86InstCMovNP           , "cmovnp"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4B, 0),
1259 
-  INST(kX86InstCMovNS           , "cmovns"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F49, 0),
1260 
-  INST(kX86InstCMovNZ           , "cmovnz"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F45, 0),
1261 
-  INST(kX86InstCMovO            , "cmovo"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F40, 0),
1262 
-  INST(kX86InstCMovP            , "cmovp"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4A, 0),
1263 
-  INST(kX86InstCMovPE           , "cmovpe"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4A, 0),
1264 
-  INST(kX86InstCMovPO           , "cmovpo"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4B, 0),
1265 
-  INST(kX86InstCMovS            , "cmovs"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F48, 0),
1266 
-  INST(kX86InstCMovZ            , "cmovz"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F44, 0),
1267 
-  INST(kX86InstCmp              , "cmp"              , G(Arith)         , F(None)          , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 7, 0x00000038, 0x00000080),
1268 
-  INST(kX86InstCmpPD            , "cmppd"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000FC2, 0),
1269 
-  INST(kX86InstCmpPS            , "cmpps"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000FC2, 0),
1270 
-  INST(kX86InstCmpSD            , "cmpsd"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000FC2, 0),
1271 
-  INST(kX86InstCmpSS            , "cmpss"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000FC2, 0),
1272 
-  INST(kX86InstCmpXCHG          , "cmpxchg"          , G(RmReg)         , F(Special)|F(Lockable), 0              , 0                   , 0, 0x00000FB0, 0),
1273 
-  INST(kX86InstCmpXCHG16B       , "cmpxchg16b"       , G(Mem)           , F(Special)       , O(Mem)              , 0                   , 1, 0x00000FC7, 1 /* RexW */),
1274 
-  INST(kX86InstCmpXCHG8B        , "cmpxchg8b"        , G(Mem)           , F(Special)       , O(Mem)              , 0                   , 1, 0x00000FC7, 0),
1275 
-  INST(kX86InstComISD           , "comisd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F2F, 0),
1276 
-  INST(kX86InstComISS           , "comiss"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F2F, 0),
1277 
-  INST(kX86InstCpuId            , "cpuid"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000FA2, 0),
1278 
-  INST(kX86InstCqo              , "cqo"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x48000099, 0), // TODO, set RexW bit instead?
1279 
-  INST(kX86InstCrc32            , "crc32"            , G(Crc32)         , F(None)          , O(Gqd)              , O(GqdwbMem)         , 0, 0xF20F38F0, 0),
1280 
-  INST(kX86InstCvtDQ2PD         , "cvtdq2pd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000FE6, 0),
1281 
-  INST(kX86InstCvtDQ2PS         , "cvtdq2ps"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5B, 0),
1282 
-  INST(kX86InstCvtPD2DQ         , "cvtpd2dq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF2000FE6, 0),
1283 
-  INST(kX86InstCvtPD2PI         , "cvtpd2pi"         , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x66000F2D, 0),
1284 
-  INST(kX86InstCvtPD2PS         , "cvtpd2ps"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5A, 0),
1285 
-  INST(kX86InstCvtPI2PD         , "cvtpi2pd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(MmMem)            , 0, 0x66000F2A, 0),
1286 
-  INST(kX86InstCvtPI2PS         , "cvtpi2ps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(MmMem)            , 0, 0x00000F2A, 0),
1287 
-  INST(kX86InstCvtPS2DQ         , "cvtps2dq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5B, 0),
1288 
-  INST(kX86InstCvtPS2PD         , "cvtps2pd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5A, 0),
1289 
-  INST(kX86InstCvtPS2PI         , "cvtps2pi"         , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x00000F2D, 0),
1290 
-  INST(kX86InstCvtSD2SI         , "cvtsd2si"         , G(MmuRmI)        , F(Mov)           , O(Gqd)              , O(XmmMem)           , 0, 0xF2000F2D, 0),
1291 
-  INST(kX86InstCvtSD2SS         , "cvtsd2ss"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5A, 0),
1292 
-  INST(kX86InstCvtSI2SD         , "cvtsi2sd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Gqd)|O(Mem)       , 0, 0xF2000F2A, 0),
1293 
-  INST(kX86InstCvtSI2SS         , "cvtsi2ss"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Gqd)|O(Mem)       , 0, 0xF3000F2A, 0),
1294 
-  INST(kX86InstCvtSS2SD         , "cvtss2sd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5A, 0),
1295 
-  INST(kX86InstCvtSS2SI         , "cvtss2si"         , G(MmuRmI)        , F(None)          , O(Gqd)              , O(XmmMem)           , 0, 0xF3000F2D, 0),
1296 
-  INST(kX86InstCvttPD2DQ        , "cvttpd2dq"        , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000FE6, 0),
1297 
-  INST(kX86InstCvttPD2PI        , "cvttpd2pi"        , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x66000F2C, 0),
1298 
-  INST(kX86InstCvttPS2DQ        , "cvttps2dq"        , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5B, 0),
1299 
-  INST(kX86InstCvttPS2PI        , "cvttps2pi"        , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x00000F2C, 0),
1300 
-  INST(kX86InstCvttSD2SI        , "cvttsd2si"        , G(MmuRmI)        , F(None)          , O(Gqd)              , O(XmmMem)           , 0, 0xF2000F2C, 0),
1301 
-  INST(kX86InstCvttSS2SI        , "cvttss2si"        , G(MmuRmI)        , F(None)          , O(Gqd)              , O(XmmMem)           , 0, 0xF3000F2C, 0),
1302 
-  INST(kX86InstCwd              , "cwd"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x66000099, 0),
1303 
-  INST(kX86InstCwde             , "cwde"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000098, 0),
1304 
-  INST(kX86InstDaa              , "daa"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000027, 0),
1305 
-  INST(kX86InstDas              , "das"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000002F, 0),
1306 
-  INST(kX86InstDec              , "dec"              , G(IncDec)        , F(Lockable)      , O(GqdwbMem)         , 0                   , 1, 0x00000048, 0x000000FE),
1307 
-  INST(kX86InstDiv              , "div"              , G(Rm)            , F(Special)       , 0                   , 0                   , 6, 0x000000F6, 0),
1308 
-  INST(kX86InstDivPD            , "divpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5E, 0),
1309 
-  INST(kX86InstDivPS            , "divps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5E, 0),
1310 
-  INST(kX86InstDivSD            , "divsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5E, 0),
1311 
-  INST(kX86InstDivSS            , "divss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5E, 0),
1312 
-  INST(kX86InstDpPD             , "dppd"             , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A41, 0),
1313 
-  INST(kX86InstDpPS             , "dpps"             , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A40, 0),
1314 
-  INST(kX86InstEmms             , "emms"             , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x00000F77, 0),
1315 
-  INST(kX86InstEnter            , "enter"            , G(Enter)         , F(Special)       , 0                   , 0                   , 0, 0x000000C8, 0),
1316 
-  INST(kX86InstExtractPS        , "extractps"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A17, 0),
1317 
-  INST(kX86InstF2XM1            , "f2xm1"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F0, 0),
1318 
-  INST(kX86InstFAbs             , "fabs"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E1, 0),
1319 
-  INST(kX86InstFAdd             , "fadd"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 0, 0xD8DCC0C0, 0),
1320 
-  INST(kX86InstFAddP            , "faddp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEC0, 0),
1321 
-  INST(kX86InstFBLd             , "fbld"             , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 4, 0x000000DF, 0),
1322 
-  INST(kX86InstFBStP            , "fbstp"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x000000DF, 0),
1323 
-  INST(kX86InstFCHS             , "fchs"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E0, 0),
1324 
-  INST(kX86InstFClex            , "fclex"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x9B00DBE2, 0),
1325 
-  INST(kX86InstFCMovB           , "fcmovb"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAC0, 0),
1326 
-  INST(kX86InstFCMovBE          , "fcmovbe"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAD0, 0),
1327 
-  INST(kX86InstFCMovE           , "fcmove"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAC8, 0),
1328 
-  INST(kX86InstFCMovNB          , "fcmovnb"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBC0, 0),
1329 
-  INST(kX86InstFCMovNBE         , "fcmovnbe"         , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBD0, 0),
1330 
-  INST(kX86InstFCMovNE          , "fcmovne"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBC8, 0),
1331 
-  INST(kX86InstFCMovNU          , "fcmovnu"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBD8, 0),
1332 
-  INST(kX86InstFCMovU           , "fcmovu"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAD8, 0),
1333 
-  INST(kX86InstFCom             , "fcom"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 2, 0xD8DCD0D0, 0),
1334 
-  INST(kX86InstFComI            , "fcomi"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBF0, 0),
1335 
-  INST(kX86InstFComIP           , "fcomip"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DFF0, 0),
1336 
-  INST(kX86InstFComP            , "fcomp"            , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 3, 0xD8DCD8D8, 0),
1337 
-  INST(kX86InstFComPP           , "fcompp"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DED9, 0),
1338 
-  INST(kX86InstFCos             , "fcos"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FF, 0),
1339 
-  INST(kX86InstFDecStP          , "fdecstp"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F6, 0),
1340 
-  INST(kX86InstFDiv             , "fdiv"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 6, 0xD8DCF0F8, 0),
1341 
-  INST(kX86InstFDivP            , "fdivp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEF8, 0),
1342 
-  INST(kX86InstFDivR            , "fdivr"            , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 7, 0xD8DCF8F0, 0),
1343 
-  INST(kX86InstFDivRP           , "fdivrp"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEF0, 0),
1344 
-  INST(kX86InstFEmms            , "femms"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x00000F0E, 0),
1345 
-  INST(kX86InstFFree            , "ffree"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DDC0, 0),
1346 
-  INST(kX86InstFIAdd            , "fiadd"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 0, 0xDEDA0000, 0),
1347 
-  INST(kX86InstFICom            , "ficom"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 2, 0xDEDA0000, 0),
1348 
-  INST(kX86InstFIComP           , "ficomp"           , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 3, 0xDEDA0000, 0),
1349 
-  INST(kX86InstFIDiv            , "fidiv"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 6, 0xDEDA0000, 0),
1350 
-  INST(kX86InstFIDivR           , "fidivr"           , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 7, 0xDEDA0000, 0),
1351 
-  INST(kX86InstFILd             , "fild"             , G(X87Mem)        , F(Fpu)           , O(StM2_4_8)         , 0                   , 0, 0xDFDBDF05, 0),
1352 
-  INST(kX86InstFIMul            , "fimul"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 1, 0xDEDA0000, 0),
1353 
-  INST(kX86InstFIncStP          , "fincstp"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F7, 0),
1354 
-  INST(kX86InstFInit            , "finit"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x9B00DBE3, 0),
1355 
-  INST(kX86InstFISt             , "fist"             , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 2, 0xDFDB0000, 0),
1356 
-  INST(kX86InstFIStP            , "fistp"            , G(X87Mem)        , F(Fpu)           , O(StM2_4_8)         , 0                   , 3, 0xDFDBDF07, 0),
1357 
-  INST(kX86InstFISttP           , "fisttp"           , G(X87Mem)        , F(Fpu)           , O(StM2_4_8)         , 0                   , 1, 0xDFDBDD01, 0),
1358 
-  INST(kX86InstFISub            , "fisub"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 4, 0xDEDA0000, 0),
1359 
-  INST(kX86InstFISubR           , "fisubr"           , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 5, 0xDEDA0000, 0),
1360 
-  INST(kX86InstFLd              , "fld"              , G(X87FldFst)     , F(Fpu)           , O(StM4_8_10)        , 0                   , 0, 0x00D9DD00, 0xD9C0DB05),
1361 
-  INST(kX86InstFLd1             , "fld1"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E8, 0),
1362 
-  INST(kX86InstFLdCw            , "fldcw"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 5, 0x000000D9, 0),
1363 
-  INST(kX86InstFLdEnv           , "fldenv"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 4, 0x000000D9, 0),
1364 
-  INST(kX86InstFLdL2E           , "fldl2e"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EA, 0),
1365 
-  INST(kX86InstFLdL2T           , "fldl2t"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E9, 0),
1366 
-  INST(kX86InstFLdLg2           , "fldlg2"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EC, 0),
1367 
-  INST(kX86InstFLdLn2           , "fldln2"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9ED, 0),
1368 
-  INST(kX86InstFLdPi            , "fldpi"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EB, 0),
1369 
-  INST(kX86InstFLdZ             , "fldz"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EE, 0),
1370 
-  INST(kX86InstFMul             , "fmul"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 1, 0xD8DCC8C8, 0),
1371 
-  INST(kX86InstFMulP            , "fmulp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEC8, 0),
1372 
-  INST(kX86InstFNClex           , "fnclex"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBE2, 0),
1373 
-  INST(kX86InstFNInit           , "fninit"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBE3, 0),
1374 
-  INST(kX86InstFNop             , "fnop"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9D0, 0),
1375 
-  INST(kX86InstFNSave           , "fnsave"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x000000DD, 0),
1376 
-  INST(kX86InstFNStCw           , "fnstcw"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 7, 0x000000D9, 0),
1377 
-  INST(kX86InstFNStEnv          , "fnstenv"          , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x000000D9, 0),
1378 
-  INST(kX86InstFNStSw           , "fnstsw"           , G(X87Status)     , F(Fpu)           , O(Mem)              , 0                   , 7, 0x000000DD, 0x0000DFE0),
1379 
-  INST(kX86InstFPAtan           , "fpatan"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F3, 0),
1380 
-  INST(kX86InstFPRem            , "fprem"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F8, 0),
1381 
-  INST(kX86InstFPRem1           , "fprem1"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F5, 0),
1382 
-  INST(kX86InstFPTan            , "fptan"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F2, 0),
1383 
-  INST(kX86InstFRndInt          , "frndint"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FC, 0),
1384 
-  INST(kX86InstFRstor           , "frstor"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 4, 0x000000DD, 0),
1385 
-  INST(kX86InstFSave            , "fsave"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x9B0000DD, 0),
1386 
-  INST(kX86InstFScale           , "fscale"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FD, 0),
1387 
-  INST(kX86InstFSin             , "fsin"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FE, 0),
1388 
-  INST(kX86InstFSinCos          , "fsincos"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FB, 0),
1389 
-  INST(kX86InstFSqrt            , "fsqrt"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FA, 0),
1390 
-  INST(kX86InstFSt              , "fst"              , G(X87FldFst)     , F(Fpu)           , O(StM4_8)           , 0                   , 2, 0x00D9DD02, 0xDDD00000),
1391 
-  INST(kX86InstFStCw            , "fstcw"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 7, 0x9B0000D9, 0),
1392 
-  INST(kX86InstFStEnv           , "fstenv"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x9B0000D9, 0),
1393 
-  INST(kX86InstFStP             , "fstp"             , G(X87FldFst)     , F(Fpu)           , O(StM4_8_10)        , 0                   , 3, 0x00D9DD03, 0xDDD8DB07),
1394 
-  INST(kX86InstFStSw            , "fstsw"            , G(X87Status)     , F(Fpu)           , O(Mem)              , 0                   , 7, 0x9B0000DD, 0x9B00DFE0),
1395 
-  INST(kX86InstFSub             , "fsub"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 4, 0xD8DCE0E8, 0),
1396 
-  INST(kX86InstFSubP            , "fsubp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEE8, 0),
1397 
-  INST(kX86InstFSubR            , "fsubr"            , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 5, 0xD8DCE8E0, 0),
1398 
-  INST(kX86InstFSubRP           , "fsubrp"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEE0, 0),
1399 
-  INST(kX86InstFTst             , "ftst"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E4, 0),
1400 
-  INST(kX86InstFUCom            , "fucom"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DDE0, 0),
1401 
-  INST(kX86InstFUComI           , "fucomi"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBE8, 0),
1402 
-  INST(kX86InstFUComIP          , "fucomip"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DFE8, 0),
1403 
-  INST(kX86InstFUComP           , "fucomp"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DDE8, 0),
1404 
-  INST(kX86InstFUComPP          , "fucompp"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAE9, 0),
1405 
-  INST(kX86InstFWait            , "fwait"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x000000DB, 0),
1406 
-  INST(kX86InstFXam             , "fxam"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E5, 0),
1407 
-  INST(kX86InstFXch             , "fxch"             , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9C8, 0),
1408 
-  INST(kX86InstFXRstor          , "fxrstor"          , G(Mem)           , F(Fpu)           , 0                   , 0                   , 1, 0x00000FAE, 0),
1409 
-  INST(kX86InstFXSave           , "fxsave"           , G(Mem)           , F(Fpu)           , 0                   , 0                   , 0, 0x00000FAE, 0),
1410 
-  INST(kX86InstFXtract          , "fxtract"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F4, 0),
1411 
-  INST(kX86InstFYL2X            , "fyl2x"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F1, 0),
1412 
-  INST(kX86InstFYL2XP1          , "fyl2xp1"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F9, 0),
1413 
-  INST(kX86InstHAddPD           , "haddpd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F7C, 0),
1414 
-  INST(kX86InstHAddPS           , "haddps"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F7C, 0),
1415 
-  INST(kX86InstHSubPD           , "hsubpd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F7D, 0),
1416 
-  INST(kX86InstHSubPS           , "hsubps"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F7D, 0),
1417 
-  INST(kX86InstIDiv             , "idiv"             , G(Rm)            , F(Special)       , 0                   , 0                   , 7, 0x000000F6, 0),
1418 
-  INST(kX86InstIMul             , "imul"             , G(IMul)          , F(Special)       , 0                   , 0                   , 0, 0         , 0),
1419 
-  INST(kX86InstInc              , "inc"              , G(IncDec)        , F(Lockable)      , O(GqdwbMem)         , 0                   , 0, 0x00000040, 0x000000FE),
1420 
-  INST(kX86InstInt3             , "int3"             , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000CC, 0),
1421 
-  INST(kX86InstJA               , "ja"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x7       , 0),
1422 
-  INST(kX86InstJAE              , "jae"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x3       , 0),
1423 
-  INST(kX86InstJB               , "jb"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x2       , 0),
1424 
-  INST(kX86InstJBE              , "jbe"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x6       , 0),
1425 
-  INST(kX86InstJC               , "jc"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x2       , 0),
1426 
-  INST(kX86InstJE               , "je"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x4       , 0),
1427 
-  INST(kX86InstJG               , "jg"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xF       , 0),
1428 
-  INST(kX86InstJGE              , "jge"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xD       , 0),
1429 
-  INST(kX86InstJL               , "jl"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xC       , 0),
1430 
-  INST(kX86InstJLE              , "jle"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xE       , 0),
1431 
-  INST(kX86InstJNA              , "jna"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x6       , 0),
1432 
-  INST(kX86InstJNAE             , "jnae"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x2       , 0),
1433 
-  INST(kX86InstJNB              , "jnb"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x3       , 0),
1434 
-  INST(kX86InstJNBE             , "jnbe"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x7       , 0),
1435 
-  INST(kX86InstJNC              , "jnc"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x3       , 0),
1436 
-  INST(kX86InstJNE              , "jne"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x5       , 0),
1437 
-  INST(kX86InstJNG              , "jng"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xE       , 0),
1438 
-  INST(kX86InstJNGE             , "jnge"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xC       , 0),
1439 
-  INST(kX86InstJNL              , "jnl"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xD       , 0),
1440 
-  INST(kX86InstJNLE             , "jnle"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xF       , 0),
1441 
-  INST(kX86InstJNO              , "jno"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x1       , 0),
1442 
-  INST(kX86InstJNP              , "jnp"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xB       , 0),
1443 
-  INST(kX86InstJNS              , "jns"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x9       , 0),
1444 
-  INST(kX86InstJNZ              , "jnz"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x5       , 0),
1445 
-  INST(kX86InstJO               , "jo"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x0       , 0),
1446 
-  INST(kX86InstJP               , "jp"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xA       , 0),
1447 
-  INST(kX86InstJPE              , "jpe"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xA       , 0),
1448 
-  INST(kX86InstJPO              , "jpo"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xB       , 0),
1449 
-  INST(kX86InstJS               , "js"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x8       , 0),
1450 
-  INST(kX86InstJZ               , "jz"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x4       , 0),
1451 
-  INST(kX86InstJmp              , "jmp"              , G(Jmp)           , F(Jump)          , 0                   , 0                   , 0, 0         , 0),
1452 
-  INST(kX86InstLdDQU            , "lddqu"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Mem)              , 0, 0xF2000FF0, 0),
1453 
-  INST(kX86InstLdMXCSR          , "ldmxcsr"          , G(Mem)           , F(None)          , O(Mem)              , 0                   , 2, 0x00000FAE, 0),
1454 
-  INST(kX86InstLahf             , "lahf"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009F, 0),
1455 
-  INST(kX86InstLea              , "lea"              , G(Lea)           , F(None)          , O(Gqd)              , O(Mem)              , 0, 0         , 0),
1456 
-  INST(kX86InstLeave            , "leave"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000000C9, 0),
1457 
-  INST(kX86InstLFence           , "lfence"           , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000FAEE8, 0),
1458 
-  INST(kX86InstMaskMovDQU       , "maskmovdqu"       , G(MmuRmI)        , F(Special)       , O(Xmm)              , O(Xmm)              , 0, 0x66000F57, 0),
1459 
-  INST(kX86InstMaskMovQ         , "maskmovq"         , G(MmuRmI)        , F(Special)       , O(Mm)               , O(Mm)               , 0, 0x00000FF7, 0),
1460 
-  INST(kX86InstMaxPD            , "maxpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5F, 0),
1461 
-  INST(kX86InstMaxPS            , "maxps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5F, 0),
1462 
-  INST(kX86InstMaxSD            , "maxsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5F, 0),
1463 
-  INST(kX86InstMaxSS            , "maxss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5F, 0),
1464 
-  INST(kX86InstMFence           , "mfence"           , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000FAEF0, 0),
1465 
-  INST(kX86InstMinPD            , "minpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5D, 0),
1466 
-  INST(kX86InstMinPS            , "minps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5D, 0),
1467 
-  INST(kX86InstMinSD            , "minsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5D, 0),
1468 
-  INST(kX86InstMinSS            , "minss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5D, 0),
1469 
-  INST(kX86InstMonitor          , "monitor"          , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000F01C8, 0),
1470 
-  INST(kX86InstMov              , "mov"              , G(Mov)           , F(Mov)           , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 0, 0         , 0),
1471 
-  INST(kX86InstMovAPD           , "movapd"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F28, 0x66000F29),
1472 
-  INST(kX86InstMovAPS           , "movaps"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F28, 0x00000F29),
1473 
-  INST(kX86InstMovBE            , "movbe"            , G(MovBE)         , F(Mov)           , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Mem)      , 0, 0x000F38F0, 0x000F38F1),
1474 
-  INST(kX86InstMovD             , "movd"             , G(MmuMovD)       , F(Mov)           , O(Gd)|O(MmXmmMem)   , O(Gd)|O(MmXmmMem)   , 0, 0         , 0),
1475 
-  INST(kX86InstMovDDup          , "movddup"          , G(MmuMov)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F12, 0),
1476 
-  INST(kX86InstMovDQ2Q          , "movdq2q"          , G(MmuMov)        , F(Mov)           , O(Mm)               , O(Xmm)              , 0, 0xF2000FD6, 0),
1477 
-  INST(kX86InstMovDQA           , "movdqa"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F6F, 0x66000F7F),
1478 
-  INST(kX86InstMovDQU           , "movdqu"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0xF3000F6F, 0xF3000F7F),
1479 
-  INST(kX86InstMovHLPS          , "movhlps"          , G(MmuMov)        , F(None)          , O(Xmm)              , O(Xmm)              , 0, 0x00000F12, 0),
1480 
-  INST(kX86InstMovHPD           , "movhpd"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F16, 0x66000F17),
1481 
-  INST(kX86InstMovHPS           , "movhps"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F16, 0x00000F17),
1482 
-  INST(kX86InstMovLHPS          , "movlhps"          , G(MmuMov)        , F(None)          , O(Xmm)              , O(Xmm)              , 0, 0x00000F16, 0),
1483 
-  INST(kX86InstMovLPD           , "movlpd"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F12, 0x66000F13),
1484 
-  INST(kX86InstMovLPS           , "movlps"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F12, 0x00000F13),
1485 
-  INST(kX86InstMovMskPD         , "movmskpd"         , G(MmuMov)        , F(Mov)           , O(Gqd)|O(NoRex)     , O(Xmm)              , 0, 0x66000F50, 0),
1486 
-  INST(kX86InstMovMskPS         , "movmskps"         , G(MmuMov)        , F(Mov)           , O(Gqd)|O(NoRex)     , O(Xmm)              , 0, 0x00000F50, 0),
1487 
-  INST(kX86InstMovNTDQ          , "movntdq"          , G(MmuMov)        , F(None)          , O(Mem)              , O(Xmm)              , 0, 0         , 0x66000FE7),
1488 
-  INST(kX86InstMovNTDQA         , "movntdqa"         , G(MmuMov)        , F(Mov)           , O(Xmm)              , O(Mem)              , 0, 0x660F382A, 0),
1489 
-  INST(kX86InstMovNTI           , "movnti"           , G(MmuMov)        , F(Mov)           , O(Mem)              , O(Gqd)              , 0, 0         , 0x00000FC3),
1490 
-  INST(kX86InstMovNTPD          , "movntpd"          , G(MmuMov)        , F(None)          , O(Mem)              , O(Xmm)              , 0, 0         , 0x66000F2B),
1491 
-  INST(kX86InstMovNTPS          , "movntps"          , G(MmuMov)        , F(None)          , O(Mem)              , O(Xmm)              , 0, 0         , 0x00000F2B),
1492 
-  INST(kX86InstMovNTQ           , "movntq"           , G(MmuMov)        , F(None)          , O(Mem)              , O(Mm)               , 0, 0         , 0x00000FE7),
1493 
-  INST(kX86InstMovQ             , "movq"             , G(MmuMovQ)       , F(Mov)           , O(Gq)|O(MmXmmMem)   , O(Gq)|O(MmXmmMem)   , 0, 0         , 0),
1494 
-  INST(kX86InstMovQ2DQ          , "movq2dq"          , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(Mm)               , 0, 0xF3000FD6, 0),
1495 
-  INST(kX86InstMovSD            , "movsd"            , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0xF2000F10, 0xF2000F11),
1496 
-  INST(kX86InstMovSHDup         , "movshdup"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F16, 0),
1497 
-  INST(kX86InstMovSLDup         , "movsldup"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F12, 0),
1498 
-  INST(kX86InstMovSS            , "movss"            , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0xF3000F10, 0xF3000F11),
1499 
-  INST(kX86InstMovSX            , "movsx"            , G(MovSxMovZx)    , F(None)          , O(Gqdw)             , O(GwbMem)           , 0, 0x00000FBE, 0),
1500 
-  INST(kX86InstMovSXD           , "movsxd"           , G(MovSxD)        , F(None)          , O(Gq)               , O(GdMem)            , 0, 0         , 0),
1501 
-  INST(kX86InstMovUPD           , "movupd"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F10, 0x66000F11),
1502 
-  INST(kX86InstMovUPS           , "movups"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F10, 0x00000F11),
1503 
-  INST(kX86InstMovZX            , "movzx"            , G(MovSxMovZx)    , F(Mov)           , O(Gqdw)             , O(GwbMem)           , 0, 0x00000FB6, 0),
1504 
-  INST(kX86InstMovPtr           , "mov_ptr"          , G(MovPtr)        , F(Mov)|F(Special), O(Gqdwb)            , O(Imm)              , 0, 0         , 0),
1505 
-  INST(kX86InstMPSADBW          , "mpsadbw"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A42, 0),
1506 
-  INST(kX86InstMul              , "mul"              , G(Rm)            , F(Special)       , 0                   , 0                   , 4, 0x000000F6, 0),
1507 
-  INST(kX86InstMulPD            , "mulpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F59, 0),
1508 
-  INST(kX86InstMulPS            , "mulps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F59, 0),
1509 
-  INST(kX86InstMulSD            , "mulsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F59, 0),
1510 
-  INST(kX86InstMulSS            , "mulss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F59, 0),
1511 
-  INST(kX86InstMWait            , "mwait"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000F01C9, 0),
1512 
-  INST(kX86InstNeg              , "neg"              , G(Rm)            , F(Lockable)      , O(GqdwbMem)         , 0                   , 3, 0x000000F6, 0),
1513 
-  INST(kX86InstNop              , "nop"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x00000090, 0),
1514 
-  INST(kX86InstNot              , "not"              , G(Rm)            , F(Lockable)      , O(GqdwbMem)         , 0                   , 2, 0x000000F6, 0),
1515 
-  INST(kX86InstOr               , "or"               , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 1, 0x00000008, 0x00000080),
1516 
-  INST(kX86InstOrPD             , "orpd"             , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F56, 0),
1517 
-  INST(kX86InstOrPS             , "orps"             , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F56, 0),
1518 
-  INST(kX86InstPAbsB            , "pabsb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F381C, 0),
1519 
-  INST(kX86InstPAbsD            , "pabsd"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F381E, 0),
1520 
-  INST(kX86InstPAbsW            , "pabsw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F381D, 0),
1521 
-  INST(kX86InstPackSSDW         , "packssdw"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F6B, 0),
1522 
-  INST(kX86InstPackSSWB         , "packsswb"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F63, 0),
1523 
-  INST(kX86InstPackUSDW         , "packusdw"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F382B, 0),
1524 
-  INST(kX86InstPackUSWB         , "packuswb"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F67, 0),
1525 
-  INST(kX86InstPAddB            , "paddb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFC, 0),
1526 
-  INST(kX86InstPAddD            , "paddd"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFE, 0),
1527 
-  INST(kX86InstPAddQ            , "paddq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD4, 0),
1528 
-  INST(kX86InstPAddSB           , "paddsb"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEC, 0),
1529 
-  INST(kX86InstPAddSW           , "paddsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FED, 0),
1530 
-  INST(kX86InstPAddUSB          , "paddusb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDC, 0),
1531 
-  INST(kX86InstPAddUSW          , "paddusw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDD, 0),
1532 
-  INST(kX86InstPAddW            , "paddw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFD, 0),
1533 
-  INST(kX86InstPAlignR          , "palignr"          , G(MmuRmImm8)     , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3A0F, 0),
1534 
-  INST(kX86InstPAnd             , "pand"             , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDB, 0),
1535 
-  INST(kX86InstPAndN            , "pandn"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDF, 0),
1536 
-  INST(kX86InstPause            , "pause"            , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0xF3000090, 0),
1537 
-  INST(kX86InstPAvgB            , "pavgb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE0, 0),
1538 
-  INST(kX86InstPAvgW            , "pavgw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE3, 0),
1539 
-  INST(kX86InstPBlendVB         , "pblendvb"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3810, 0),
1540 
-  INST(kX86InstPBlendW          , "pblendw"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0E, 0),
1541 
-  INST(kX86InstPCmpEqB          , "pcmpeqb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F74, 0),
1542 
-  INST(kX86InstPCmpEqD          , "pcmpeqd"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F76, 0),
1543 
-  INST(kX86InstPCmpEqQ          , "pcmpeqq"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3829, 0),
1544 
-  INST(kX86InstPCmpEqW          , "pcmpeqw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F75, 0),
1545 
-  INST(kX86InstPCmpEStrI        , "pcmpestri"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A61, 0),
1546 
-  INST(kX86InstPCmpEStrM        , "pcmpestrm"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A60, 0),
1547 
-  INST(kX86InstPCmpGtB          , "pcmpgtb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F64, 0),
1548 
-  INST(kX86InstPCmpGtD          , "pcmpgtd"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F66, 0),
1549 
-  INST(kX86InstPCmpGtQ          , "pcmpgtq"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3837, 0),
1550 
-  INST(kX86InstPCmpGtW          , "pcmpgtw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F65, 0),
1551 
-  INST(kX86InstPCmpIStrI        , "pcmpistri"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A63, 0),
1552 
-  INST(kX86InstPCmpIStrM        , "pcmpistrm"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A62, 0),
1553 
-  INST(kX86InstPExtrB           , "pextrb"           , G(MmuExtract)    , F(None)          , O(Gd)|O(Gb)|O(Mem)  , O(Xmm)              , 0, 0x000F3A14, 0),
1554 
-  INST(kX86InstPExtrD           , "pextrd"           , G(MmuExtract)    , F(None)          , O(Gd)      |O(Mem)  , O(Xmm)              , 0, 0x000F3A16, 0),
1555 
-  INST(kX86InstPExtrQ           , "pextrq"           , G(MmuExtract)    , F(None)          , O(Gqd)     |O(Mem)  , O(Xmm)              , 1, 0x000F3A16, 0),
1556 
-  INST(kX86InstPExtrW           , "pextrw"           , G(MmuExtract)    , F(None)          , O(Gd)      |O(Mem)  , O(MmXmm)            , 0, 0x000F3A15, 0),
1557 
-  INST(kX86InstPF2ID            , "pf2id"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x1D),
1558 
-  INST(kX86InstPF2IW            , "pf2iw"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x1C),
1559 
-  INST(kX86InstPFAcc            , "pfacc"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xAE),
1560 
-  INST(kX86InstPFAdd            , "pfadd"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x9E),
1561 
-  INST(kX86InstPFCmpEQ          , "pfcmpeq"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xB0),
1562 
-  INST(kX86InstPFCmpGE          , "pfcmpge"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x90),
1563 
-  INST(kX86InstPFCmpGT          , "pfcmpgt"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA0),
1564 
-  INST(kX86InstPFMax            , "pfmax"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA4),
1565 
-  INST(kX86InstPFMin            , "pfmin"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x94),
1566 
-  INST(kX86InstPFMul            , "pfmul"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xB4),
1567 
-  INST(kX86InstPFNAcc           , "pfnacc"           , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x8A),
1568 
-  INST(kX86InstPFPNAcc          , "pfpnacc"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x8E),
1569 
-  INST(kX86InstPFRcp            , "pfrcp"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x96),
1570 
-  INST(kX86InstPFRcpIt1         , "pfrcpit1"         , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA6),
1571 
-  INST(kX86InstPFRcpIt2         , "pfrcpit2"         , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xB6),
1572 
-  INST(kX86InstPFRSqIt1         , "pfrsqit1"         , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA7),
1573 
-  INST(kX86InstPFRSqrt          , "pfrsqrt"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x97),
1574 
-  INST(kX86InstPFSub            , "pfsub"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x9A),
1575 
-  INST(kX86InstPFSubR           , "pfsubr"           , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xAA),
1576 
-  INST(kX86InstPHAddD           , "phaddd"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3802, 0),
1577 
-  INST(kX86InstPHAddSW          , "phaddsw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3803, 0),
1578 
-  INST(kX86InstPHAddW           , "phaddw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3801, 0),
1579 
-  INST(kX86InstPHMinPOSUW       , "phminposuw"       , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3841, 0),
1580 
-  INST(kX86InstPHSubD           , "phsubd"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3806, 0),
1581 
-  INST(kX86InstPHSubSW          , "phsubsw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3807, 0),
1582 
-  INST(kX86InstPHSubW           , "phsubw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3805, 0),
1583 
-  INST(kX86InstPI2FD            , "pi2fd"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x0D),
1584 
-  INST(kX86InstPI2FW            , "pi2fw"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x0C),
1585 
-  INST(kX86InstPInsRB           , "pinsrb"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(Gd) | O(Mem)      , 0, 0x660F3A20, 0),
1586 
-  INST(kX86InstPInsRD           , "pinsrd"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(Gd) | O(Mem)      , 0, 0x660F3A22, 0),
1587 
-  INST(kX86InstPInsRQ           , "pinsrq"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(Gq) | O(Mem)      , 0, 0x660F3A22, 0),
1588 
-  INST(kX86InstPInsRW           , "pinsrw"           , G(MmuRmImm8)     , F(None)          , O(MmXmm)            , O(Gd) | O(Mem)      , 0, 0x00000FC4, 0),
1589 
-  INST(kX86InstPMAddUBSW        , "pmaddubsw"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3804, 0),
1590 
-  INST(kX86InstPMAddWD          , "pmaddwd"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF5, 0),
1591 
-  INST(kX86InstPMaxSB           , "pmaxsb"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383C, 0),
1592 
-  INST(kX86InstPMaxSD           , "pmaxsd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383D, 0),
1593 
-  INST(kX86InstPMaxSW           , "pmaxsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEE, 0),
1594 
-  INST(kX86InstPMaxUB           , "pmaxub"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDE, 0),
1595 
-  INST(kX86InstPMaxUD           , "pmaxud"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383F, 0),
1596 
-  INST(kX86InstPMaxUW           , "pmaxuw"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383E, 0),
1597 
-  INST(kX86InstPMinSB           , "pminsb"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3838, 0),
1598 
-  INST(kX86InstPMinSD           , "pminsd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3839, 0),
1599 
-  INST(kX86InstPMinSW           , "pminsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEA, 0),
1600 
-  INST(kX86InstPMinUB           , "pminub"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDA, 0),
1601 
-  INST(kX86InstPMinUD           , "pminud"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383B, 0),
1602 
-  INST(kX86InstPMinUW           , "pminuw"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383A, 0),
1603 
-  INST(kX86InstPMovMskB         , "pmovmskb"         , G(MmuRmI)        , F(Mov)           , O(Gqd)              , O(MmXmm)            , 0, 0x00000FD7, 0),
1604 
-  INST(kX86InstPMovSXBD         , "pmovsxbd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3821, 0),
1605 
-  INST(kX86InstPMovSXBQ         , "pmovsxbq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3822, 0),
1606 
-  INST(kX86InstPMovSXBW         , "pmovsxbw"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3820, 0),
1607 
-  INST(kX86InstPMovSXDQ         , "pmovsxdq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3825, 0),
1608 
-  INST(kX86InstPMovSXWD         , "pmovsxwd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3823, 0),
1609 
-  INST(kX86InstPMovSXWQ         , "pmovsxwq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3824, 0),
1610 
-  INST(kX86InstPMovZXBD         , "pmovzxbd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3831, 0),
1611 
-  INST(kX86InstPMovZXBQ         , "pmovzxbq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3832, 0),
1612 
-  INST(kX86InstPMovZXBW         , "pmovzxbw"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3830, 0),
1613 
-  INST(kX86InstPMovZXDQ         , "pmovzxdq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3835, 0),
1614 
-  INST(kX86InstPMovZXWD         , "pmovzxwd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3833, 0),
1615 
-  INST(kX86InstPMovZXWQ         , "pmovzxwq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3834, 0),
1616 
-  INST(kX86InstPMulDQ           , "pmuldq"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3828, 0),
1617 
-  INST(kX86InstPMulHRSW         , "pmulhrsw"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F380B, 0),
1618 
-  INST(kX86InstPMulHUW          , "pmulhuw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE4, 0),
1619 
-  INST(kX86InstPMulHW           , "pmulhw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE5, 0),
1620 
-  INST(kX86InstPMulLD           , "pmulld"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3840, 0),
1621 
-  INST(kX86InstPMulLW           , "pmullw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD5, 0),
1622 
-  INST(kX86InstPMulUDQ          , "pmuludq"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF4, 0),
1623 
-  INST(kX86InstPop              , "pop"              , G(Pop)           , F(Special)       , 0                   , 0                   , 0, 0x00000058, 0x0000008F),
1624 
-  INST(kX86InstPopAD            , "popad"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000061, 0),
1625 
-  INST(kX86InstPopCnt           , "popcnt"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0xF3000FB8, 0),
1626 
-  INST(kX86InstPopFD            , "popfd"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009D, 0),
1627 
-  INST(kX86InstPopFQ            , "popfq"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009D, 0),
1628 
-  INST(kX86InstPOr              , "por"              , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEB, 0),
1629 
-  INST(kX86InstPrefetch         , "prefetch"         , G(MmuPrefetch)   , F(None)          , O(Mem)              , O(Imm)              , 0, 0         , 0),
1630 
-  INST(kX86InstPSADBW           , "psadbw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF6, 0),
1631 
-  INST(kX86InstPShufB           , "pshufb"           , G(MmuRmI)        , F(Mov)           , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3800, 0),
1632 
-  INST(kX86InstPShufD           , "pshufd"           , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F70, 0),
1633 
-  INST(kX86InstPShufW           , "pshufw"           , G(MmuRmImm8)     , F(Mov)           , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F70, 0),
1634 
-  INST(kX86InstPShufHW          , "pshufhw"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F70, 0),
1635 
-  INST(kX86InstPShufLW          , "pshuflw"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F70, 0),
1636 
-  INST(kX86InstPSignB           , "psignb"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3808, 0),
1637 
-  INST(kX86InstPSignD           , "psignd"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F380A, 0),
1638 
-  INST(kX86InstPSignW           , "psignw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3809, 0),
1639 
-  INST(kX86InstPSllD            , "pslld"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 6, 0x00000FF2, 0x00000F72),
1640 
-  INST(kX86InstPSllDQ           , "pslldq"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Imm)              , 7, 0         , 0x66000F73),
1641 
-  INST(kX86InstPSllQ            , "psllq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 6, 0x00000FF3, 0x00000F73),
1642 
-  INST(kX86InstPSllW            , "psllw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 6, 0x00000FF1, 0x00000F71),
1643 
-  INST(kX86InstPSraD            , "psrad"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 4, 0x00000FE2, 0x00000F72),
1644 
-  INST(kX86InstPSraW            , "psraw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 4, 0x00000FE1, 0x00000F71),
1645 
-  INST(kX86InstPSrlD            , "psrld"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 2, 0x00000FD2, 0x00000F72),
1646 
-  INST(kX86InstPSrlDQ           , "psrldq"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Imm)              , 3, 0         , 0x66000F73),
1647 
-  INST(kX86InstPSrlQ            , "psrlq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 2, 0x00000FD3, 0x00000F73),
1648 
-  INST(kX86InstPSrlW            , "psrlw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 2, 0x00000FD1, 0x00000F71),
1649 
-  INST(kX86InstPSubB            , "psubb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF8, 0),
1650 
-  INST(kX86InstPSubD            , "psubd"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFA, 0),
1651 
-  INST(kX86InstPSubQ            , "psubq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFB, 0),
1652 
-  INST(kX86InstPSubSB           , "psubsb"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE8, 0),
1653 
-  INST(kX86InstPSubSW           , "psubsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE9, 0),
1654 
-  INST(kX86InstPSubUSB          , "psubusb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD8, 0),
1655 
-  INST(kX86InstPSubUSW          , "psubusw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD9, 0),
1656 
-  INST(kX86InstPSubW            , "psubw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF9, 0),
1657 
-  INST(kX86InstPSwapD           , "pswapd"           , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xBB),
1658 
-  INST(kX86InstPTest            , "ptest"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3817, 0),
1659 
-  INST(kX86InstPunpckHBW        , "punpckhbw"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F68, 0),
1660 
-  INST(kX86InstPunpckHDQ        , "punpckhdq"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F6A, 0),
1661 
-  INST(kX86InstPunpckHQDQ       , "punpckhqdq"       , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F6D, 0),
1662 
-  INST(kX86InstPunpckHWD        , "punpckhwd"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F69, 0),
1663 
-  INST(kX86InstPunpckLBW        , "punpcklbw"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F60, 0),
1664 
-  INST(kX86InstPunpckLDQ        , "punpckldq"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F62, 0),
1665 
-  INST(kX86InstPunpckLQDQ       , "punpcklqdq"       , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F6C, 0),
1666 
-  INST(kX86InstPunpckLWD        , "punpcklwd"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F61, 0),
1667 
-  INST(kX86InstPush             , "push"             , G(Push)          , F(Special)       , 0                   , 0                   , 6, 0x00000050, 0x000000FF),
1668 
-  INST(kX86InstPushAD           , "pushad"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000060, 0),
1669 
-  INST(kX86InstPushFD           , "pushfd"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009C, 0),
1670 
-  INST(kX86InstPushFQ           , "pushfq"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009C, 0),
1671 
-  INST(kX86InstPXor             , "pxor"             , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEF, 0),
1672 
-  INST(kX86InstRcl              , "rcl"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 2, 0         , 0),
1673 
-  INST(kX86InstRcpPS            , "rcpps"            , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F53, 0),
1674 
-  INST(kX86InstRcpSS            , "rcpss"            , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F53, 0),
1675 
-  INST(kX86InstRcr              , "rcr"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 3, 0         , 0),
1676 
-  INST(kX86InstRdtsc            , "rdtsc"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000F31, 0),
1677 
-  INST(kX86InstRdtscP           , "rdtscp"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000F01F9, 0),
1678 
-  INST(kX86InstRepLodSB         , "rep lodsb"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 1 /* Size of mem */),
1679 
-  INST(kX86InstRepLodSD         , "rep lodsd"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 4 /* Size of mem */),
1680 
-  INST(kX86InstRepLodSQ         , "rep lodsq"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 8 /* Size of mem */),
1681 
-  INST(kX86InstRepLodSW         , "rep lodsw"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 2 /* Size of mem */),
1682 
-  INST(kX86InstRepMovSB         , "rep movsb"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 1 /* Size of mem */),
1683 
-  INST(kX86InstRepMovSD         , "rep movsd"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 4 /* Size of mem */),
1684 
-  INST(kX86InstRepMovSQ         , "rep movsq"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 8 /* Size of mem */),
1685 
-  INST(kX86InstRepMovSW         , "rep movsw"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 2 /* Size of mem */),
1686 
-  INST(kX86InstRepStoSB         , "rep stosb"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 1 /* Size of mem */),
1687 
-  INST(kX86InstRepStoSD         , "rep stosd"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 4 /* Size of mem */),
1688 
-  INST(kX86InstRepStoSQ         , "rep stosq"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 8 /* Size of mem */),
1689 
-  INST(kX86InstRepStoSW         , "rep stosw"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 2 /* Size of mem */),
1690 
-  INST(kX86InstRepECmpSB        , "repe cmpsb"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 1 /* Size of mem */),
1691 
-  INST(kX86InstRepECmpSD        , "repe cmpsd"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 4 /* Size of mem */),
1692 
-  INST(kX86InstRepECmpSQ        , "repe cmpsq"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 8 /* Size of mem */),
1693 
-  INST(kX86InstRepECmpSW        , "repe cmpsw"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 2 /* Size of mem */),
1694 
-  INST(kX86InstRepEScaSB        , "repe scasb"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 1 /* Size of mem */),
1695 
-  INST(kX86InstRepEScaSD        , "repe scasd"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 4 /* Size of mem */),
1696 
-  INST(kX86InstRepEScaSQ        , "repe scasq"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 8 /* Size of mem */),
1697 
-  INST(kX86InstRepEScaSW        , "repe scasw"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 2 /* Size of mem */),
1698 
-  INST(kX86InstRepNECmpSB       , "repne cmpsb"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 1 /* Size of mem */),
1699 
-  INST(kX86InstRepNECmpSD       , "repne cmpsd"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 4 /* Size of mem */),
1700 
-  INST(kX86InstRepNECmpSQ       , "repne cmpsq"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 8 /* Size of mem */),
1701 
-  INST(kX86InstRepNECmpSW       , "repne cmpsw"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 2 /* Size of mem */),
1702 
-  INST(kX86InstRepNEScaSB       , "repne scasb"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 1 /* Size of mem */),
1703 
-  INST(kX86InstRepNEScaSD       , "repne scasd"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 4 /* Size of mem */),
1704 
-  INST(kX86InstRepNEScaSQ       , "repne scasq"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 8 /* Size of mem */),
1705 
-  INST(kX86InstRepNEScaSW       , "repne scasw"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 2 /* Size of mem */),
1706 
-  INST(kX86InstRet              , "ret"              , G(Ret)           , F(Special)       , 0                   , 0                   , 0, 0         , 0),
1707 
-  INST(kX86InstRol              , "rol"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 0, 0         , 0),
1708 
-  INST(kX86InstRor              , "ror"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 1, 0         , 0),
1709 
-  INST(kX86InstRoundPD          , "roundpd"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A09, 0),
1710 
-  INST(kX86InstRoundPS          , "roundps"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A08, 0),
1711 
-  INST(kX86InstRoundSD          , "roundsd"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0B, 0),
1712 
-  INST(kX86InstRoundSS          , "roundss"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0A, 0),
1713 
-  INST(kX86InstRSqrtPS          , "rsqrtps"          , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F52, 0),
1714 
-  INST(kX86InstRSqrtSS          , "rsqrtss"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F52, 0),
1715 
-  INST(kX86InstSahf             , "sahf"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009E, 0),
1716 
-  INST(kX86InstSal              , "sal"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 4, 0         , 0),
1717 
-  INST(kX86InstSar              , "sar"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 7, 0         , 0),
1718 
-  INST(kX86InstSbb              , "sbb"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 3, 0x00000018, 0x00000080),
1719 
-  INST(kX86InstSetA             , "seta"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F97, 0),
1720 
-  INST(kX86InstSetAE            , "setae"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F93, 0),
1721 
-  INST(kX86InstSetB             , "setb"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F92, 0),
1722 
-  INST(kX86InstSetBE            , "setbe"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F96, 0),
1723 
-  INST(kX86InstSetC             , "setc"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F92, 0),
1724 
-  INST(kX86InstSetE             , "sete"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F94, 0),
1725 
-  INST(kX86InstSetG             , "setg"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9F, 0),
1726 
-  INST(kX86InstSetGE            , "setge"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9D, 0),
1727 
-  INST(kX86InstSetL             , "setl"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9C, 0),
1728 
-  INST(kX86InstSetLE            , "setle"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9E, 0),
1729 
-  INST(kX86InstSetNA            , "setna"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F96, 0),
1730 
-  INST(kX86InstSetNAE           , "setnae"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F92, 0),
1731 
-  INST(kX86InstSetNB            , "setnb"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F93, 0),
1732 
-  INST(kX86InstSetNBE           , "setnbe"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F97, 0),
1733 
-  INST(kX86InstSetNC            , "setnc"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F93, 0),
1734 
-  INST(kX86InstSetNE            , "setne"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F95, 0),
1735 
-  INST(kX86InstSetNG            , "setng"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9E, 0),
1736 
-  INST(kX86InstSetNGE           , "setnge"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9C, 0),
1737 
-  INST(kX86InstSetNL            , "setnl"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9D, 0),
1738 
-  INST(kX86InstSetNLE           , "setnle"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9F, 0),
1739 
-  INST(kX86InstSetNO            , "setno"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F91, 0),
1740 
-  INST(kX86InstSetNP            , "setnp"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9B, 0),
1741 
-  INST(kX86InstSetNS            , "setns"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F99, 0),
1742 
-  INST(kX86InstSetNZ            , "setnz"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F95, 0),
1743 
-  INST(kX86InstSetO             , "seto"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F90, 0),
1744 
-  INST(kX86InstSetP             , "setp"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9A, 0),
1745 
-  INST(kX86InstSetPE            , "setpe"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9A, 0),
1746 
-  INST(kX86InstSetPO            , "setpo"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9B, 0),
1747 
-  INST(kX86InstSetS             , "sets"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F98, 0),
1748 
-  INST(kX86InstSetZ             , "setz"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F94, 0),
1749 
-  INST(kX86InstSFence           , "sfence"           , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000FAEF8, 0),
1750 
-  INST(kX86InstShl              , "shl"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 4, 0         , 0),
1751 
-  INST(kX86InstShld             , "shld"             , G(ShldShrd)      , F(Special)       , O(GqdwbMem)         , O(Gb)               , 0, 0x00000FA4, 0),
1752 
-  INST(kX86InstShr              , "shr"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 5, 0         , 0),
1753 
-  INST(kX86InstShrd             , "shrd"             , G(ShldShrd)      , F(Special)       , O(GqdwbMem)         , O(Gqdwb)            , 0, 0x00000FAC, 0),
1754 
-  INST(kX86InstShufPD           , "shufpd"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000FC6, 0),
1755 
-  INST(kX86InstShufPS           , "shufps"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000FC6, 0),
1756 
-  INST(kX86InstSqrtPD           , "sqrtpd"           , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F51, 0),
1757 
-  INST(kX86InstSqrtPS           , "sqrtps"           , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F51, 0),
1758 
-  INST(kX86InstSqrtSD           , "sqrtsd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F51, 0),
1759 
-  INST(kX86InstSqrtSS           , "sqrtss"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F51, 0),
1760 
-  INST(kX86InstStc              , "stc"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000F9, 0),
1761 
-  INST(kX86InstStd              , "std"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000FD, 0),
1762 
-  INST(kX86InstStMXCSR          , "stmxcsr"          , G(Mem)           , F(None)          , O(Mem)              , 0                   , 3, 0x00000FAE, 0),
1763 
-  INST(kX86InstSub              , "sub"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 5, 0x00000028, 0x00000080),
1764 
-  INST(kX86InstSubPD            , "subpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5C, 0),
1765 
-  INST(kX86InstSubPS            , "subps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5C, 0),
1766 
-  INST(kX86InstSubSD            , "subsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5C, 0),
1767 
-  INST(kX86InstSubSS            , "subss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5C, 0),
1768 
-  INST(kX86InstTest             , "test"             , G(Test)          , F(None)          , O(GqdwbMem)         , O(Gqdwb)|O(Imm)     , 0, 0         , 0),
1769 
-  INST(kX86InstUComISD          , "ucomisd"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F2E, 0),
1770 
-  INST(kX86InstUComISS          , "ucomiss"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F2E, 0),
1771 
-  INST(kX86InstUd2              , "ud2"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x00000F0B, 0),
1772 
-  INST(kX86InstUnpckHPD         , "unpckhpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F15, 0),
1773 
-  INST(kX86InstUnpckHPS         , "unpckhps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F15, 0),
1774 
-  INST(kX86InstUnpckLPD         , "unpcklpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F14, 0),
1775 
-  INST(kX86InstUnpckLPS         , "unpcklps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F14, 0),
1776 
-  INST(kX86InstXadd             , "xadd"             , G(RmReg)         , F(Lockable)      , O(GqdwbMem)         , O(Gqdwb)            , 0, 0x00000FC0, 0),
1777 
-  INST(kX86InstXchg             , "xchg"             , G(Xchg)          , F(Lockable)      , O(GqdwbMem)         , O(Gqdwb)            , 0, 0         , 0),
1778 
-  INST(kX86InstXor              , "xor"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 6, 0x00000030, 0x00000080),
1779 
-  INST(kX86InstXorPD            , "xorpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F57, 0),
1780 
-  INST(kX86InstXorPS            , "xorps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F57, 0)
1201 
+	// Instruction code           | Instruction name   | Instruction group| Instruction flags| Operand flags[0]    | Operand flags[1]    | r| opCode[0] | opcode[1]
1202 
+	INST(kInstNone                , ""                 , G(None)          , F(None)          , 0                   , 0                   , 0, 0         , 0),
1203 
+	INST(kX86InstAdc              , "adc"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 2, 0x00000010, 0x00000080),
1204 
+	INST(kX86InstAdd              , "add"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 0, 0x00000000, 0x00000080),
1205 
+	INST(kX86InstAddPD            , "addpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F58, 0),
1206 
+	INST(kX86InstAddPS            , "addps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F58, 0),
1207 
+	INST(kX86InstAddSD            , "addsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F58, 0),
1208 
+	INST(kX86InstAddSS            , "addss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F58, 0),
1209 
+	INST(kX86InstAddSubPD         , "addsubpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000FD0, 0),
1210 
+	INST(kX86InstAddSubPS         , "addsubps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000FD0, 0),
1211 
+	INST(kX86InstAmdPrefetch      , "amd_prefetch"     , G(Mem)           , F(None)          , O(Mem)              , 0                   , 0, 0x00000F0D, 0),
1212 
+	INST(kX86InstAmdPrefetchW     , "amd_prefetchw"    , G(Mem)           , F(None)          , O(Mem)              , 0                   , 1, 0x00000F0D, 0),
1213 
+	INST(kX86InstAnd              , "and"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 4, 0x00000020, 0x00000080),
1214 
+	INST(kX86InstAndnPD           , "andnpd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F55, 0),
1215 
+	INST(kX86InstAndnPS           , "andnps"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F55, 0),
1216 
+	INST(kX86InstAndPD            , "andpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F54, 0),
1217 
+	INST(kX86InstAndPS            , "andps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F54, 0),
1218 
+	INST(kX86InstBlendPD          , "blendpd"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0D, 0),
1219 
+	INST(kX86InstBlendPS          , "blendps"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0C, 0),
1220 
+	INST(kX86InstBlendVPD         , "blendvpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3815, 0),
1221 
+	INST(kX86InstBlendVPS         , "blendvps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3814, 0),
1222 
+	INST(kX86InstBsf              , "bsf"              , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000FBC, 0),
1223 
+	INST(kX86InstBsr              , "bsr"              , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000FBD, 0),
1224 
+	INST(kX86InstBSwap            , "bswap"            , G(BSwap)         , F(None)          , O(Gqd)              , 0                   , 0, 0         , 0),
1225 
+	INST(kX86InstBt               , "bt"               , G(BTest)         , F(None)          , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 4, 0x00000FA3, 0x00000FBA),
1226 
+	INST(kX86InstBtc              , "btc"              , G(BTest)         , F(Lockable)      , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 7, 0x00000FBB, 0x00000FBA),
1227 
+	INST(kX86InstBtr              , "btr"              , G(BTest)         , F(Lockable)      , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 6, 0x00000FB3, 0x00000FBA),
1228 
+	INST(kX86InstBts              , "bts"              , G(BTest)         , F(Lockable)      , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Imm)      , 5, 0x00000FAB, 0x00000FBA),
1229 
+	INST(kX86InstCall             , "call"             , G(Call)          , F(Jump)          , O(Gqd) |O(Mem)      , 0                   , 0, 0         , 0),
1230 
+	INST(kX86InstCbw              , "cbw"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x66000098, 0),
1231 
+	INST(kX86InstCdq              , "cdq"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000099, 0),
1232 
+	INST(kX86InstCdqe             , "cdqe"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x48000098, 0),
1233 
+	INST(kX86InstClc              , "clc"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000F8, 0),
1234 
+	INST(kX86InstCld              , "cld"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000FC, 0),
1235 
+	INST(kX86InstClFlush          , "clflush"          , G(Mem)           , F(None)          , O(Mem)              , 0                   , 7, 0x00000FAE, 0),
1236 
+	INST(kX86InstCmc              , "cmc"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000F5, 0),
1237 
+	INST(kX86InstCMovA            , "cmova"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F47, 0),
1238 
+	INST(kX86InstCMovAE           , "cmovae"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F43, 0),
1239 
+	INST(kX86InstCMovB            , "cmovb"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F42, 0),
1240 
+	INST(kX86InstCMovBE           , "cmovbe"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F46, 0),
1241 
+	INST(kX86InstCMovC            , "cmovc"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F42, 0),
1242 
+	INST(kX86InstCMovE            , "cmove"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F44, 0),
1243 
+	INST(kX86InstCMovG            , "cmovg"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4F, 0),
1244 
+	INST(kX86InstCMovGE           , "cmovge"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4D, 0),
1245 
+	INST(kX86InstCMovL            , "cmovl"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4C, 0),
1246 
+	INST(kX86InstCMovLE           , "cmovle"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4E, 0),
1247 
+	INST(kX86InstCMovNA           , "cmovna"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F46, 0),
1248 
+	INST(kX86InstCMovNAE          , "cmovnae"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F42, 0),
1249 
+	INST(kX86InstCMovNB           , "cmovnb"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F43, 0),
1250 
+	INST(kX86InstCMovNBE          , "cmovnbe"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F47, 0),
1251 
+	INST(kX86InstCMovNC           , "cmovnc"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F43, 0),
1252 
+	INST(kX86InstCMovNE           , "cmovne"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F45, 0),
1253 
+	INST(kX86InstCMovNG           , "cmovng"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4E, 0),
1254 
+	INST(kX86InstCMovNGE          , "cmovnge"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4C, 0),
1255 
+	INST(kX86InstCMovNL           , "cmovnl"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4D, 0),
1256 
+	INST(kX86InstCMovNLE          , "cmovnle"          , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4F, 0),
1257 
+	INST(kX86InstCMovNO           , "cmovno"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F41, 0),
1258 
+	INST(kX86InstCMovNP           , "cmovnp"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4B, 0),
1259 
+	INST(kX86InstCMovNS           , "cmovns"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F49, 0),
1260 
+	INST(kX86InstCMovNZ           , "cmovnz"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F45, 0),
1261 
+	INST(kX86InstCMovO            , "cmovo"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F40, 0),
1262 
+	INST(kX86InstCMovP            , "cmovp"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4A, 0),
1263 
+	INST(kX86InstCMovPE           , "cmovpe"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4A, 0),
1264 
+	INST(kX86InstCMovPO           , "cmovpo"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F4B, 0),
1265 
+	INST(kX86InstCMovS            , "cmovs"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F48, 0),
1266 
+	INST(kX86InstCMovZ            , "cmovz"            , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0x00000F44, 0),
1267 
+	INST(kX86InstCmp              , "cmp"              , G(Arith)         , F(None)          , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 7, 0x00000038, 0x00000080),
1268 
+	INST(kX86InstCmpPD            , "cmppd"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000FC2, 0),
1269 
+	INST(kX86InstCmpPS            , "cmpps"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000FC2, 0),
1270 
+	INST(kX86InstCmpSD            , "cmpsd"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000FC2, 0),
1271 
+	INST(kX86InstCmpSS            , "cmpss"            , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000FC2, 0),
1272 
+	INST(kX86InstCmpXCHG          , "cmpxchg"          , G(RmReg)         , F(Special)|F(Lockable), 0              , 0                   , 0, 0x00000FB0, 0),
1273 
+	INST(kX86InstCmpXCHG16B       , "cmpxchg16b"       , G(Mem)           , F(Special)       , O(Mem)              , 0                   , 1, 0x00000FC7, 1 /* RexW */),
1274 
+	INST(kX86InstCmpXCHG8B        , "cmpxchg8b"        , G(Mem)           , F(Special)       , O(Mem)              , 0                   , 1, 0x00000FC7, 0),
1275 
+	INST(kX86InstComISD           , "comisd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F2F, 0),
1276 
+	INST(kX86InstComISS           , "comiss"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F2F, 0),
1277 
+	INST(kX86InstCpuId            , "cpuid"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000FA2, 0),
1278 
+	INST(kX86InstCqo              , "cqo"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x48000099, 0), // TODO, set RexW bit instead?
1279 
+	INST(kX86InstCrc32            , "crc32"            , G(Crc32)         , F(None)          , O(Gqd)              , O(GqdwbMem)         , 0, 0xF20F38F0, 0),
1280 
+	INST(kX86InstCvtDQ2PD         , "cvtdq2pd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000FE6, 0),
1281 
+	INST(kX86InstCvtDQ2PS         , "cvtdq2ps"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5B, 0),
1282 
+	INST(kX86InstCvtPD2DQ         , "cvtpd2dq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF2000FE6, 0),
1283 
+	INST(kX86InstCvtPD2PI         , "cvtpd2pi"         , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x66000F2D, 0),
1284 
+	INST(kX86InstCvtPD2PS         , "cvtpd2ps"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5A, 0),
1285 
+	INST(kX86InstCvtPI2PD         , "cvtpi2pd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(MmMem)            , 0, 0x66000F2A, 0),
1286 
+	INST(kX86InstCvtPI2PS         , "cvtpi2ps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(MmMem)            , 0, 0x00000F2A, 0),
1287 
+	INST(kX86InstCvtPS2DQ         , "cvtps2dq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5B, 0),
1288 
+	INST(kX86InstCvtPS2PD         , "cvtps2pd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5A, 0),
1289 
+	INST(kX86InstCvtPS2PI         , "cvtps2pi"         , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x00000F2D, 0),
1290 
+	INST(kX86InstCvtSD2SI         , "cvtsd2si"         , G(MmuRmI)        , F(Mov)           , O(Gqd)              , O(XmmMem)           , 0, 0xF2000F2D, 0),
1291 
+	INST(kX86InstCvtSD2SS         , "cvtsd2ss"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5A, 0),
1292 
+	INST(kX86InstCvtSI2SD         , "cvtsi2sd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Gqd)|O(Mem)       , 0, 0xF2000F2A, 0),
1293 
+	INST(kX86InstCvtSI2SS         , "cvtsi2ss"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Gqd)|O(Mem)       , 0, 0xF3000F2A, 0),
1294 
+	INST(kX86InstCvtSS2SD         , "cvtss2sd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5A, 0),
1295 
+	INST(kX86InstCvtSS2SI         , "cvtss2si"         , G(MmuRmI)        , F(None)          , O(Gqd)              , O(XmmMem)           , 0, 0xF3000F2D, 0),
1296 
+	INST(kX86InstCvttPD2DQ        , "cvttpd2dq"        , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000FE6, 0),
1297 
+	INST(kX86InstCvttPD2PI        , "cvttpd2pi"        , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x66000F2C, 0),
1298 
+	INST(kX86InstCvttPS2DQ        , "cvttps2dq"        , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5B, 0),
1299 
+	INST(kX86InstCvttPS2PI        , "cvttps2pi"        , G(MmuRmI)        , F(Mov)           , O(Mm)               , O(XmmMem)           , 0, 0x00000F2C, 0),
1300 
+	INST(kX86InstCvttSD2SI        , "cvttsd2si"        , G(MmuRmI)        , F(None)          , O(Gqd)              , O(XmmMem)           , 0, 0xF2000F2C, 0),
1301 
+	INST(kX86InstCvttSS2SI        , "cvttss2si"        , G(MmuRmI)        , F(None)          , O(Gqd)              , O(XmmMem)           , 0, 0xF3000F2C, 0),
1302 
+	INST(kX86InstCwd              , "cwd"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x66000099, 0),
1303 
+	INST(kX86InstCwde             , "cwde"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000098, 0),
1304 
+	INST(kX86InstDaa              , "daa"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000027, 0),
1305 
+	INST(kX86InstDas              , "das"              , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000002F, 0),
1306 
+	INST(kX86InstDec              , "dec"              , G(IncDec)        , F(Lockable)      , O(GqdwbMem)         , 0                   , 1, 0x00000048, 0x000000FE),
1307 
+	INST(kX86InstDiv              , "div"              , G(Rm)            , F(Special)       , 0                   , 0                   , 6, 0x000000F6, 0),
1308 
+	INST(kX86InstDivPD            , "divpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5E, 0),
1309 
+	INST(kX86InstDivPS            , "divps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5E, 0),
1310 
+	INST(kX86InstDivSD            , "divsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5E, 0),
1311 
+	INST(kX86InstDivSS            , "divss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5E, 0),
1312 
+	INST(kX86InstDpPD             , "dppd"             , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A41, 0),
1313 
+	INST(kX86InstDpPS             , "dpps"             , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A40, 0),
1314 
+	INST(kX86InstEmms             , "emms"             , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x00000F77, 0),
1315 
+	INST(kX86InstEnter            , "enter"            , G(Enter)         , F(Special)       , 0                   , 0                   , 0, 0x000000C8, 0),
1316 
+	INST(kX86InstExtractPS        , "extractps"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A17, 0),
1317 
+	INST(kX86InstF2XM1            , "f2xm1"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F0, 0),
1318 
+	INST(kX86InstFAbs             , "fabs"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E1, 0),
1319 
+	INST(kX86InstFAdd             , "fadd"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 0, 0xD8DCC0C0, 0),
1320 
+	INST(kX86InstFAddP            , "faddp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEC0, 0),
1321 
+	INST(kX86InstFBLd             , "fbld"             , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 4, 0x000000DF, 0),
1322 
+	INST(kX86InstFBStP            , "fbstp"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x000000DF, 0),
1323 
+	INST(kX86InstFCHS             , "fchs"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E0, 0),
1324 
+	INST(kX86InstFClex            , "fclex"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x9B00DBE2, 0),
1325 
+	INST(kX86InstFCMovB           , "fcmovb"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAC0, 0),
1326 
+	INST(kX86InstFCMovBE          , "fcmovbe"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAD0, 0),
1327 
+	INST(kX86InstFCMovE           , "fcmove"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAC8, 0),
1328 
+	INST(kX86InstFCMovNB          , "fcmovnb"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBC0, 0),
1329 
+	INST(kX86InstFCMovNBE         , "fcmovnbe"         , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBD0, 0),
1330 
+	INST(kX86InstFCMovNE          , "fcmovne"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBC8, 0),
1331 
+	INST(kX86InstFCMovNU          , "fcmovnu"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBD8, 0),
1332 
+	INST(kX86InstFCMovU           , "fcmovu"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAD8, 0),
1333 
+	INST(kX86InstFCom             , "fcom"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 2, 0xD8DCD0D0, 0),
1334 
+	INST(kX86InstFComI            , "fcomi"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBF0, 0),
1335 
+	INST(kX86InstFComIP           , "fcomip"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DFF0, 0),
1336 
+	INST(kX86InstFComP            , "fcomp"            , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 3, 0xD8DCD8D8, 0),
1337 
+	INST(kX86InstFComPP           , "fcompp"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DED9, 0),
1338 
+	INST(kX86InstFCos             , "fcos"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FF, 0),
1339 
+	INST(kX86InstFDecStP          , "fdecstp"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F6, 0),
1340 
+	INST(kX86InstFDiv             , "fdiv"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 6, 0xD8DCF0F8, 0),
1341 
+	INST(kX86InstFDivP            , "fdivp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEF8, 0),
1342 
+	INST(kX86InstFDivR            , "fdivr"            , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 7, 0xD8DCF8F0, 0),
1343 
+	INST(kX86InstFDivRP           , "fdivrp"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEF0, 0),
1344 
+	INST(kX86InstFEmms            , "femms"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x00000F0E, 0),
1345 
+	INST(kX86InstFFree            , "ffree"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DDC0, 0),
1346 
+	INST(kX86InstFIAdd            , "fiadd"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 0, 0xDEDA0000, 0),
1347 
+	INST(kX86InstFICom            , "ficom"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 2, 0xDEDA0000, 0),
1348 
+	INST(kX86InstFIComP           , "ficomp"           , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 3, 0xDEDA0000, 0),
1349 
+	INST(kX86InstFIDiv            , "fidiv"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 6, 0xDEDA0000, 0),
1350 
+	INST(kX86InstFIDivR           , "fidivr"           , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 7, 0xDEDA0000, 0),
1351 
+	INST(kX86InstFILd             , "fild"             , G(X87Mem)        , F(Fpu)           , O(StM2_4_8)         , 0                   , 0, 0xDFDBDF05, 0),
1352 
+	INST(kX86InstFIMul            , "fimul"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 1, 0xDEDA0000, 0),
1353 
+	INST(kX86InstFIncStP          , "fincstp"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F7, 0),
1354 
+	INST(kX86InstFInit            , "finit"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x9B00DBE3, 0),
1355 
+	INST(kX86InstFISt             , "fist"             , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 2, 0xDFDB0000, 0),
1356 
+	INST(kX86InstFIStP            , "fistp"            , G(X87Mem)        , F(Fpu)           , O(StM2_4_8)         , 0                   , 3, 0xDFDBDF07, 0),
1357 
+	INST(kX86InstFISttP           , "fisttp"           , G(X87Mem)        , F(Fpu)           , O(StM2_4_8)         , 0                   , 1, 0xDFDBDD01, 0),
1358 
+	INST(kX86InstFISub            , "fisub"            , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 4, 0xDEDA0000, 0),
1359 
+	INST(kX86InstFISubR           , "fisubr"           , G(X87Mem)        , F(Fpu)           , O(StM2_4)           , 0                   , 5, 0xDEDA0000, 0),
1360 
+	INST(kX86InstFLd              , "fld"              , G(X87FldFst)     , F(Fpu)           , O(StM4_8_10)        , 0                   , 0, 0x00D9DD00, 0xD9C0DB05),
1361 
+	INST(kX86InstFLd1             , "fld1"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E8, 0),
1362 
+	INST(kX86InstFLdCw            , "fldcw"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 5, 0x000000D9, 0),
1363 
+	INST(kX86InstFLdEnv           , "fldenv"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 4, 0x000000D9, 0),
1364 
+	INST(kX86InstFLdL2E           , "fldl2e"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EA, 0),
1365 
+	INST(kX86InstFLdL2T           , "fldl2t"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E9, 0),
1366 
+	INST(kX86InstFLdLg2           , "fldlg2"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EC, 0),
1367 
+	INST(kX86InstFLdLn2           , "fldln2"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9ED, 0),
1368 
+	INST(kX86InstFLdPi            , "fldpi"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EB, 0),
1369 
+	INST(kX86InstFLdZ             , "fldz"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9EE, 0),
1370 
+	INST(kX86InstFMul             , "fmul"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 1, 0xD8DCC8C8, 0),
1371 
+	INST(kX86InstFMulP            , "fmulp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEC8, 0),
1372 
+	INST(kX86InstFNClex           , "fnclex"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBE2, 0),
1373 
+	INST(kX86InstFNInit           , "fninit"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBE3, 0),
1374 
+	INST(kX86InstFNop             , "fnop"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9D0, 0),
1375 
+	INST(kX86InstFNSave           , "fnsave"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x000000DD, 0),
1376 
+	INST(kX86InstFNStCw           , "fnstcw"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 7, 0x000000D9, 0),
1377 
+	INST(kX86InstFNStEnv          , "fnstenv"          , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x000000D9, 0),
1378 
+	INST(kX86InstFNStSw           , "fnstsw"           , G(X87Status)     , F(Fpu)           , O(Mem)              , 0                   , 7, 0x000000DD, 0x0000DFE0),
1379 
+	INST(kX86InstFPAtan           , "fpatan"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F3, 0),
1380 
+	INST(kX86InstFPRem            , "fprem"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F8, 0),
1381 
+	INST(kX86InstFPRem1           , "fprem1"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F5, 0),
1382 
+	INST(kX86InstFPTan            , "fptan"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F2, 0),
1383 
+	INST(kX86InstFRndInt          , "frndint"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FC, 0),
1384 
+	INST(kX86InstFRstor           , "frstor"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 4, 0x000000DD, 0),
1385 
+	INST(kX86InstFSave            , "fsave"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x9B0000DD, 0),
1386 
+	INST(kX86InstFScale           , "fscale"           , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FD, 0),
1387 
+	INST(kX86InstFSin             , "fsin"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FE, 0),
1388 
+	INST(kX86InstFSinCos          , "fsincos"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FB, 0),
1389 
+	INST(kX86InstFSqrt            , "fsqrt"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9FA, 0),
1390 
+	INST(kX86InstFSt              , "fst"              , G(X87FldFst)     , F(Fpu)           , O(StM4_8)           , 0                   , 2, 0x00D9DD02, 0xDDD00000),
1391 
+	INST(kX86InstFStCw            , "fstcw"            , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 7, 0x9B0000D9, 0),
1392 
+	INST(kX86InstFStEnv           , "fstenv"           , G(Mem)           , F(Fpu)           , O(Mem)              , 0                   , 6, 0x9B0000D9, 0),
1393 
+	INST(kX86InstFStP             , "fstp"             , G(X87FldFst)     , F(Fpu)           , O(StM4_8_10)        , 0                   , 3, 0x00D9DD03, 0xDDD8DB07),
1394 
+	INST(kX86InstFStSw            , "fstsw"            , G(X87Status)     , F(Fpu)           , O(Mem)              , 0                   , 7, 0x9B0000DD, 0x9B00DFE0),
1395 
+	INST(kX86InstFSub             , "fsub"             , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 4, 0xD8DCE0E8, 0),
1396 
+	INST(kX86InstFSubP            , "fsubp"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEE8, 0),
1397 
+	INST(kX86InstFSubR            , "fsubr"            , G(X87StM)        , F(Fpu)           , 0                   , 0                   , 5, 0xD8DCE8E0, 0),
1398 
+	INST(kX86InstFSubRP           , "fsubrp"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DEE0, 0),
1399 
+	INST(kX86InstFTst             , "ftst"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E4, 0),
1400 
+	INST(kX86InstFUCom            , "fucom"            , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DDE0, 0),
1401 
+	INST(kX86InstFUComI           , "fucomi"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DBE8, 0),
1402 
+	INST(kX86InstFUComIP          , "fucomip"          , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DFE8, 0),
1403 
+	INST(kX86InstFUComP           , "fucomp"           , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000DDE8, 0),
1404 
+	INST(kX86InstFUComPP          , "fucompp"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000DAE9, 0),
1405 
+	INST(kX86InstFWait            , "fwait"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x000000DB, 0),
1406 
+	INST(kX86InstFXam             , "fxam"             , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9E5, 0),
1407 
+	INST(kX86InstFXch             , "fxch"             , G(X87StI)        , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9C8, 0),
1408 
+	INST(kX86InstFXRstor          , "fxrstor"          , G(Mem)           , F(Fpu)           , 0                   , 0                   , 1, 0x00000FAE, 0),
1409 
+	INST(kX86InstFXSave           , "fxsave"           , G(Mem)           , F(Fpu)           , 0                   , 0                   , 0, 0x00000FAE, 0),
1410 
+	INST(kX86InstFXtract          , "fxtract"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F4, 0),
1411 
+	INST(kX86InstFYL2X            , "fyl2x"            , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F1, 0),
1412 
+	INST(kX86InstFYL2XP1          , "fyl2xp1"          , G(Emit)          , F(Fpu)           , 0                   , 0                   , 0, 0x0000D9F9, 0),
1413 
+	INST(kX86InstHAddPD           , "haddpd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F7C, 0),
1414 
+	INST(kX86InstHAddPS           , "haddps"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F7C, 0),
1415 
+	INST(kX86InstHSubPD           , "hsubpd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F7D, 0),
1416 
+	INST(kX86InstHSubPS           , "hsubps"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F7D, 0),
1417 
+	INST(kX86InstIDiv             , "idiv"             , G(Rm)            , F(Special)       , 0                   , 0                   , 7, 0x000000F6, 0),
1418 
+	INST(kX86InstIMul             , "imul"             , G(IMul)          , F(Special)       , 0                   , 0                   , 0, 0         , 0),
1419 
+	INST(kX86InstInc              , "inc"              , G(IncDec)        , F(Lockable)      , O(GqdwbMem)         , 0                   , 0, 0x00000040, 0x000000FE),
1420 
+	INST(kX86InstInt3             , "int3"             , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000CC, 0),
1421 
+	INST(kX86InstJA               , "ja"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x7       , 0),
1422 
+	INST(kX86InstJAE              , "jae"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x3       , 0),
1423 
+	INST(kX86InstJB               , "jb"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x2       , 0),
1424 
+	INST(kX86InstJBE              , "jbe"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x6       , 0),
1425 
+	INST(kX86InstJC               , "jc"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x2       , 0),
1426 
+	INST(kX86InstJE               , "je"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x4       , 0),
1427 
+	INST(kX86InstJG               , "jg"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xF       , 0),
1428 
+	INST(kX86InstJGE              , "jge"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xD       , 0),
1429 
+	INST(kX86InstJL               , "jl"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xC       , 0),
1430 
+	INST(kX86InstJLE              , "jle"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xE       , 0),
1431 
+	INST(kX86InstJNA              , "jna"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x6       , 0),
1432 
+	INST(kX86InstJNAE             , "jnae"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x2       , 0),
1433 
+	INST(kX86InstJNB              , "jnb"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x3       , 0),
1434 
+	INST(kX86InstJNBE             , "jnbe"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x7       , 0),
1435 
+	INST(kX86InstJNC              , "jnc"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x3       , 0),
1436 
+	INST(kX86InstJNE              , "jne"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x5       , 0),
1437 
+	INST(kX86InstJNG              , "jng"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xE       , 0),
1438 
+	INST(kX86InstJNGE             , "jnge"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xC       , 0),
1439 
+	INST(kX86InstJNL              , "jnl"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xD       , 0),
1440 
+	INST(kX86InstJNLE             , "jnle"             , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xF       , 0),
1441 
+	INST(kX86InstJNO              , "jno"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x1       , 0),
1442 
+	INST(kX86InstJNP              , "jnp"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xB       , 0),
1443 
+	INST(kX86InstJNS              , "jns"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x9       , 0),
1444 
+	INST(kX86InstJNZ              , "jnz"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x5       , 0),
1445 
+	INST(kX86InstJO               , "jo"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x0       , 0),
1446 
+	INST(kX86InstJP               , "jp"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xA       , 0),
1447 
+	INST(kX86InstJPE              , "jpe"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xA       , 0),
1448 
+	INST(kX86InstJPO              , "jpo"              , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0xB       , 0),
1449 
+	INST(kX86InstJS               , "js"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x8       , 0),
1450 
+	INST(kX86InstJZ               , "jz"               , G(Jcc)           , F(Jump)          , 0                   , 0                   , 0, 0x4       , 0),
1451 
+	INST(kX86InstJmp              , "jmp"              , G(Jmp)           , F(Jump)          , 0                   , 0                   , 0, 0         , 0),
1452 
+	INST(kX86InstLdDQU            , "lddqu"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Mem)              , 0, 0xF2000FF0, 0),
1453 
+	INST(kX86InstLdMXCSR          , "ldmxcsr"          , G(Mem)           , F(None)          , O(Mem)              , 0                   , 2, 0x00000FAE, 0),
1454 
+	INST(kX86InstLahf             , "lahf"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009F, 0),
1455 
+	INST(kX86InstLea              , "lea"              , G(Lea)           , F(None)          , O(Gqd)              , O(Mem)              , 0, 0         , 0),
1456 
+	INST(kX86InstLeave            , "leave"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000000C9, 0),
1457 
+	INST(kX86InstLFence           , "lfence"           , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000FAEE8, 0),
1458 
+	INST(kX86InstMaskMovDQU       , "maskmovdqu"       , G(MmuRmI)        , F(Special)       , O(Xmm)              , O(Xmm)              , 0, 0x66000F57, 0),
1459 
+	INST(kX86InstMaskMovQ         , "maskmovq"         , G(MmuRmI)        , F(Special)       , O(Mm)               , O(Mm)               , 0, 0x00000FF7, 0),
1460 
+	INST(kX86InstMaxPD            , "maxpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5F, 0),
1461 
+	INST(kX86InstMaxPS            , "maxps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5F, 0),
1462 
+	INST(kX86InstMaxSD            , "maxsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5F, 0),
1463 
+	INST(kX86InstMaxSS            , "maxss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5F, 0),
1464 
+	INST(kX86InstMFence           , "mfence"           , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000FAEF0, 0),
1465 
+	INST(kX86InstMinPD            , "minpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5D, 0),
1466 
+	INST(kX86InstMinPS            , "minps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5D, 0),
1467 
+	INST(kX86InstMinSD            , "minsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5D, 0),
1468 
+	INST(kX86InstMinSS            , "minss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5D, 0),
1469 
+	INST(kX86InstMonitor          , "monitor"          , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000F01C8, 0),
1470 
+	INST(kX86InstMov              , "mov"              , G(Mov)           , F(Mov)           , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 0, 0         , 0),
1471 
+	INST(kX86InstMovAPD           , "movapd"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F28, 0x66000F29),
1472 
+	INST(kX86InstMovAPS           , "movaps"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F28, 0x00000F29),
1473 
+	INST(kX86InstMovBE            , "movbe"            , G(MovBE)         , F(Mov)           , O(Gqdw)|O(Mem)      , O(Gqdw)|O(Mem)      , 0, 0x000F38F0, 0x000F38F1),
1474 
+	INST(kX86InstMovD             , "movd"             , G(MmuMovD)       , F(Mov)           , O(Gd)|O(MmXmmMem)   , O(Gd)|O(MmXmmMem)   , 0, 0         , 0),
1475 
+	INST(kX86InstMovDDup          , "movddup"          , G(MmuMov)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F12, 0),
1476 
+	INST(kX86InstMovDQ2Q          , "movdq2q"          , G(MmuMov)        , F(Mov)           , O(Mm)               , O(Xmm)              , 0, 0xF2000FD6, 0),
1477 
+	INST(kX86InstMovDQA           , "movdqa"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F6F, 0x66000F7F),
1478 
+	INST(kX86InstMovDQU           , "movdqu"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0xF3000F6F, 0xF3000F7F),
1479 
+	INST(kX86InstMovHLPS          , "movhlps"          , G(MmuMov)        , F(None)          , O(Xmm)              , O(Xmm)              , 0, 0x00000F12, 0),
1480 
+	INST(kX86InstMovHPD           , "movhpd"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F16, 0x66000F17),
1481 
+	INST(kX86InstMovHPS           , "movhps"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F16, 0x00000F17),
1482 
+	INST(kX86InstMovLHPS          , "movlhps"          , G(MmuMov)        , F(None)          , O(Xmm)              , O(Xmm)              , 0, 0x00000F16, 0),
1483 
+	INST(kX86InstMovLPD           , "movlpd"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F12, 0x66000F13),
1484 
+	INST(kX86InstMovLPS           , "movlps"           , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F12, 0x00000F13),
1485 
+	INST(kX86InstMovMskPD         , "movmskpd"         , G(MmuMov)        , F(Mov)           , O(Gqd)|O(NoRex)     , O(Xmm)              , 0, 0x66000F50, 0),
1486 
+	INST(kX86InstMovMskPS         , "movmskps"         , G(MmuMov)        , F(Mov)           , O(Gqd)|O(NoRex)     , O(Xmm)              , 0, 0x00000F50, 0),
1487 
+	INST(kX86InstMovNTDQ          , "movntdq"          , G(MmuMov)        , F(None)          , O(Mem)              , O(Xmm)              , 0, 0         , 0x66000FE7),
1488 
+	INST(kX86InstMovNTDQA         , "movntdqa"         , G(MmuMov)        , F(Mov)           , O(Xmm)              , O(Mem)              , 0, 0x660F382A, 0),
1489 
+	INST(kX86InstMovNTI           , "movnti"           , G(MmuMov)        , F(Mov)           , O(Mem)              , O(Gqd)              , 0, 0         , 0x00000FC3),
1490 
+	INST(kX86InstMovNTPD          , "movntpd"          , G(MmuMov)        , F(None)          , O(Mem)              , O(Xmm)              , 0, 0         , 0x66000F2B),
1491 
+	INST(kX86InstMovNTPS          , "movntps"          , G(MmuMov)        , F(None)          , O(Mem)              , O(Xmm)              , 0, 0         , 0x00000F2B),
1492 
+	INST(kX86InstMovNTQ           , "movntq"           , G(MmuMov)        , F(None)          , O(Mem)              , O(Mm)               , 0, 0         , 0x00000FE7),
1493 
+	INST(kX86InstMovQ             , "movq"             , G(MmuMovQ)       , F(Mov)           , O(Gq)|O(MmXmmMem)   , O(Gq)|O(MmXmmMem)   , 0, 0         , 0),
1494 
+	INST(kX86InstMovQ2DQ          , "movq2dq"          , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(Mm)               , 0, 0xF3000FD6, 0),
1495 
+	INST(kX86InstMovSD            , "movsd"            , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0xF2000F10, 0xF2000F11),
1496 
+	INST(kX86InstMovSHDup         , "movshdup"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F16, 0),
1497 
+	INST(kX86InstMovSLDup         , "movsldup"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F12, 0),
1498 
+	INST(kX86InstMovSS            , "movss"            , G(MmuMov)        , F(None)          , O(XmmMem)           , O(XmmMem)           , 0, 0xF3000F10, 0xF3000F11),
1499 
+	INST(kX86InstMovSX            , "movsx"            , G(MovSxMovZx)    , F(None)          , O(Gqdw)             , O(GwbMem)           , 0, 0x00000FBE, 0),
1500 
+	INST(kX86InstMovSXD           , "movsxd"           , G(MovSxD)        , F(None)          , O(Gq)               , O(GdMem)            , 0, 0         , 0),
1501 
+	INST(kX86InstMovUPD           , "movupd"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x66000F10, 0x66000F11),
1502 
+	INST(kX86InstMovUPS           , "movups"           , G(MmuMov)        , F(Mov)           , O(XmmMem)           , O(XmmMem)           , 0, 0x00000F10, 0x00000F11),
1503 
+	INST(kX86InstMovZX            , "movzx"            , G(MovSxMovZx)    , F(Mov)           , O(Gqdw)             , O(GwbMem)           , 0, 0x00000FB6, 0),
1504 
+	INST(kX86InstMovPtr           , "mov_ptr"          , G(MovPtr)        , F(Mov)|F(Special), O(Gqdwb)            , O(Imm)              , 0, 0         , 0),
1505 
+	INST(kX86InstMPSADBW          , "mpsadbw"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A42, 0),
1506 
+	INST(kX86InstMul              , "mul"              , G(Rm)            , F(Special)       , 0                   , 0                   , 4, 0x000000F6, 0),
1507 
+	INST(kX86InstMulPD            , "mulpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F59, 0),
1508 
+	INST(kX86InstMulPS            , "mulps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F59, 0),
1509 
+	INST(kX86InstMulSD            , "mulsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F59, 0),
1510 
+	INST(kX86InstMulSS            , "mulss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F59, 0),
1511 
+	INST(kX86InstMWait            , "mwait"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000F01C9, 0),
1512 
+	INST(kX86InstNeg              , "neg"              , G(Rm)            , F(Lockable)      , O(GqdwbMem)         , 0                   , 3, 0x000000F6, 0),
1513 
+	INST(kX86InstNop              , "nop"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x00000090, 0),
1514 
+	INST(kX86InstNot              , "not"              , G(Rm)            , F(Lockable)      , O(GqdwbMem)         , 0                   , 2, 0x000000F6, 0),
1515 
+	INST(kX86InstOr               , "or"               , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 1, 0x00000008, 0x00000080),
1516 
+	INST(kX86InstOrPD             , "orpd"             , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F56, 0),
1517 
+	INST(kX86InstOrPS             , "orps"             , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F56, 0),
1518 
+	INST(kX86InstPAbsB            , "pabsb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F381C, 0),
1519 
+	INST(kX86InstPAbsD            , "pabsd"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F381E, 0),
1520 
+	INST(kX86InstPAbsW            , "pabsw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F381D, 0),
1521 
+	INST(kX86InstPackSSDW         , "packssdw"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F6B, 0),
1522 
+	INST(kX86InstPackSSWB         , "packsswb"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F63, 0),
1523 
+	INST(kX86InstPackUSDW         , "packusdw"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F382B, 0),
1524 
+	INST(kX86InstPackUSWB         , "packuswb"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F67, 0),
1525 
+	INST(kX86InstPAddB            , "paddb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFC, 0),
1526 
+	INST(kX86InstPAddD            , "paddd"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFE, 0),
1527 
+	INST(kX86InstPAddQ            , "paddq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD4, 0),
1528 
+	INST(kX86InstPAddSB           , "paddsb"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEC, 0),
1529 
+	INST(kX86InstPAddSW           , "paddsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FED, 0),
1530 
+	INST(kX86InstPAddUSB          , "paddusb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDC, 0),
1531 
+	INST(kX86InstPAddUSW          , "paddusw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDD, 0),
1532 
+	INST(kX86InstPAddW            , "paddw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFD, 0),
1533 
+	INST(kX86InstPAlignR          , "palignr"          , G(MmuRmImm8)     , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3A0F, 0),
1534 
+	INST(kX86InstPAnd             , "pand"             , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDB, 0),
1535 
+	INST(kX86InstPAndN            , "pandn"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDF, 0),
1536 
+	INST(kX86InstPause            , "pause"            , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0xF3000090, 0),
1537 
+	INST(kX86InstPAvgB            , "pavgb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE0, 0),
1538 
+	INST(kX86InstPAvgW            , "pavgw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE3, 0),
1539 
+	INST(kX86InstPBlendVB         , "pblendvb"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3810, 0),
1540 
+	INST(kX86InstPBlendW          , "pblendw"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0E, 0),
1541 
+	INST(kX86InstPCmpEqB          , "pcmpeqb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F74, 0),
1542 
+	INST(kX86InstPCmpEqD          , "pcmpeqd"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F76, 0),
1543 
+	INST(kX86InstPCmpEqQ          , "pcmpeqq"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3829, 0),
1544 
+	INST(kX86InstPCmpEqW          , "pcmpeqw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F75, 0),
1545 
+	INST(kX86InstPCmpEStrI        , "pcmpestri"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A61, 0),
1546 
+	INST(kX86InstPCmpEStrM        , "pcmpestrm"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A60, 0),
1547 
+	INST(kX86InstPCmpGtB          , "pcmpgtb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F64, 0),
1548 
+	INST(kX86InstPCmpGtD          , "pcmpgtd"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F66, 0),
1549 
+	INST(kX86InstPCmpGtQ          , "pcmpgtq"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3837, 0),
1550 
+	INST(kX86InstPCmpGtW          , "pcmpgtw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F65, 0),
1551 
+	INST(kX86InstPCmpIStrI        , "pcmpistri"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A63, 0),
1552 
+	INST(kX86InstPCmpIStrM        , "pcmpistrm"        , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A62, 0),
1553 
+	INST(kX86InstPExtrB           , "pextrb"           , G(MmuExtract)    , F(None)          , O(Gd)|O(Gb)|O(Mem)  , O(Xmm)              , 0, 0x000F3A14, 0),
1554 
+	INST(kX86InstPExtrD           , "pextrd"           , G(MmuExtract)    , F(None)          , O(Gd)      |O(Mem)  , O(Xmm)              , 0, 0x000F3A16, 0),
1555 
+	INST(kX86InstPExtrQ           , "pextrq"           , G(MmuExtract)    , F(None)          , O(Gqd)     |O(Mem)  , O(Xmm)              , 1, 0x000F3A16, 0),
1556 
+	INST(kX86InstPExtrW           , "pextrw"           , G(MmuExtract)    , F(None)          , O(Gd)      |O(Mem)  , O(MmXmm)            , 0, 0x000F3A15, 0),
1557 
+	INST(kX86InstPF2ID            , "pf2id"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x1D),
1558 
+	INST(kX86InstPF2IW            , "pf2iw"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x1C),
1559 
+	INST(kX86InstPFAcc            , "pfacc"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xAE),
1560 
+	INST(kX86InstPFAdd            , "pfadd"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x9E),
1561 
+	INST(kX86InstPFCmpEQ          , "pfcmpeq"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xB0),
1562 
+	INST(kX86InstPFCmpGE          , "pfcmpge"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x90),
1563 
+	INST(kX86InstPFCmpGT          , "pfcmpgt"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA0),
1564 
+	INST(kX86InstPFMax            , "pfmax"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA4),
1565 
+	INST(kX86InstPFMin            , "pfmin"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x94),
1566 
+	INST(kX86InstPFMul            , "pfmul"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xB4),
1567 
+	INST(kX86InstPFNAcc           , "pfnacc"           , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x8A),
1568 
+	INST(kX86InstPFPNAcc          , "pfpnacc"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x8E),
1569 
+	INST(kX86InstPFRcp            , "pfrcp"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x96),
1570 
+	INST(kX86InstPFRcpIt1         , "pfrcpit1"         , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA6),
1571 
+	INST(kX86InstPFRcpIt2         , "pfrcpit2"         , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xB6),
1572 
+	INST(kX86InstPFRSqIt1         , "pfrsqit1"         , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xA7),
1573 
+	INST(kX86InstPFRSqrt          , "pfrsqrt"          , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x97),
1574 
+	INST(kX86InstPFSub            , "pfsub"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x9A),
1575 
+	INST(kX86InstPFSubR           , "pfsubr"           , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xAA),
1576 
+	INST(kX86InstPHAddD           , "phaddd"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3802, 0),
1577 
+	INST(kX86InstPHAddSW          , "phaddsw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3803, 0),
1578 
+	INST(kX86InstPHAddW           , "phaddw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3801, 0),
1579 
+	INST(kX86InstPHMinPOSUW       , "phminposuw"       , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3841, 0),
1580 
+	INST(kX86InstPHSubD           , "phsubd"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3806, 0),
1581 
+	INST(kX86InstPHSubSW          , "phsubsw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3807, 0),
1582 
+	INST(kX86InstPHSubW           , "phsubw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3805, 0),
1583 
+	INST(kX86InstPI2FD            , "pi2fd"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x0D),
1584 
+	INST(kX86InstPI2FW            , "pi2fw"            , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0x0C),
1585 
+	INST(kX86InstPInsRB           , "pinsrb"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(Gd) | O(Mem)      , 0, 0x660F3A20, 0),
1586 
+	INST(kX86InstPInsRD           , "pinsrd"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(Gd) | O(Mem)      , 0, 0x660F3A22, 0),
1587 
+	INST(kX86InstPInsRQ           , "pinsrq"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(Gq) | O(Mem)      , 0, 0x660F3A22, 0),
1588 
+	INST(kX86InstPInsRW           , "pinsrw"           , G(MmuRmImm8)     , F(None)          , O(MmXmm)            , O(Gd) | O(Mem)      , 0, 0x00000FC4, 0),
1589 
+	INST(kX86InstPMAddUBSW        , "pmaddubsw"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3804, 0),
1590 
+	INST(kX86InstPMAddWD          , "pmaddwd"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF5, 0),
1591 
+	INST(kX86InstPMaxSB           , "pmaxsb"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383C, 0),
1592 
+	INST(kX86InstPMaxSD           , "pmaxsd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383D, 0),
1593 
+	INST(kX86InstPMaxSW           , "pmaxsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEE, 0),
1594 
+	INST(kX86InstPMaxUB           , "pmaxub"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDE, 0),
1595 
+	INST(kX86InstPMaxUD           , "pmaxud"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383F, 0),
1596 
+	INST(kX86InstPMaxUW           , "pmaxuw"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383E, 0),
1597 
+	INST(kX86InstPMinSB           , "pminsb"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3838, 0),
1598 
+	INST(kX86InstPMinSD           , "pminsd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3839, 0),
1599 
+	INST(kX86InstPMinSW           , "pminsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEA, 0),
1600 
+	INST(kX86InstPMinUB           , "pminub"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FDA, 0),
1601 
+	INST(kX86InstPMinUD           , "pminud"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383B, 0),
1602 
+	INST(kX86InstPMinUW           , "pminuw"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F383A, 0),
1603 
+	INST(kX86InstPMovMskB         , "pmovmskb"         , G(MmuRmI)        , F(Mov)           , O(Gqd)              , O(MmXmm)            , 0, 0x00000FD7, 0),
1604 
+	INST(kX86InstPMovSXBD         , "pmovsxbd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3821, 0),
1605 
+	INST(kX86InstPMovSXBQ         , "pmovsxbq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3822, 0),
1606 
+	INST(kX86InstPMovSXBW         , "pmovsxbw"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3820, 0),
1607 
+	INST(kX86InstPMovSXDQ         , "pmovsxdq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3825, 0),
1608 
+	INST(kX86InstPMovSXWD         , "pmovsxwd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3823, 0),
1609 
+	INST(kX86InstPMovSXWQ         , "pmovsxwq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3824, 0),
1610 
+	INST(kX86InstPMovZXBD         , "pmovzxbd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3831, 0),
1611 
+	INST(kX86InstPMovZXBQ         , "pmovzxbq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3832, 0),
1612 
+	INST(kX86InstPMovZXBW         , "pmovzxbw"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3830, 0),
1613 
+	INST(kX86InstPMovZXDQ         , "pmovzxdq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3835, 0),
1614 
+	INST(kX86InstPMovZXWD         , "pmovzxwd"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3833, 0),
1615 
+	INST(kX86InstPMovZXWQ         , "pmovzxwq"         , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3834, 0),
1616 
+	INST(kX86InstPMulDQ           , "pmuldq"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3828, 0),
1617 
+	INST(kX86InstPMulHRSW         , "pmulhrsw"         , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F380B, 0),
1618 
+	INST(kX86InstPMulHUW          , "pmulhuw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE4, 0),
1619 
+	INST(kX86InstPMulHW           , "pmulhw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE5, 0),
1620 
+	INST(kX86InstPMulLD           , "pmulld"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3840, 0),
1621 
+	INST(kX86InstPMulLW           , "pmullw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD5, 0),
1622 
+	INST(kX86InstPMulUDQ          , "pmuludq"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF4, 0),
1623 
+	INST(kX86InstPop              , "pop"              , G(Pop)           , F(Special)       , 0                   , 0                   , 0, 0x00000058, 0x0000008F),
1624 
+	INST(kX86InstPopAD            , "popad"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000061, 0),
1625 
+	INST(kX86InstPopCnt           , "popcnt"           , G(RegRm)         , F(None)          , O(Gqdw)             , O(GqdwMem)          , 0, 0xF3000FB8, 0),
1626 
+	INST(kX86InstPopFD            , "popfd"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009D, 0),
1627 
+	INST(kX86InstPopFQ            , "popfq"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009D, 0),
1628 
+	INST(kX86InstPOr              , "por"              , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEB, 0),
1629 
+	INST(kX86InstPrefetch         , "prefetch"         , G(MmuPrefetch)   , F(None)          , O(Mem)              , O(Imm)              , 0, 0         , 0),
1630 
+	INST(kX86InstPSADBW           , "psadbw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF6, 0),
1631 
+	INST(kX86InstPShufB           , "pshufb"           , G(MmuRmI)        , F(Mov)           , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3800, 0),
1632 
+	INST(kX86InstPShufD           , "pshufd"           , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F70, 0),
1633 
+	INST(kX86InstPShufW           , "pshufw"           , G(MmuRmImm8)     , F(Mov)           , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F70, 0),
1634 
+	INST(kX86InstPShufHW          , "pshufhw"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F70, 0),
1635 
+	INST(kX86InstPShufLW          , "pshuflw"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F70, 0),
1636 
+	INST(kX86InstPSignB           , "psignb"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3808, 0),
1637 
+	INST(kX86InstPSignD           , "psignd"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F380A, 0),
1638 
+	INST(kX86InstPSignW           , "psignw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x000F3809, 0),
1639 
+	INST(kX86InstPSllD            , "pslld"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 6, 0x00000FF2, 0x00000F72),
1640 
+	INST(kX86InstPSllDQ           , "pslldq"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Imm)              , 7, 0         , 0x66000F73),
1641 
+	INST(kX86InstPSllQ            , "psllq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 6, 0x00000FF3, 0x00000F73),
1642 
+	INST(kX86InstPSllW            , "psllw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 6, 0x00000FF1, 0x00000F71),
1643 
+	INST(kX86InstPSraD            , "psrad"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 4, 0x00000FE2, 0x00000F72),
1644 
+	INST(kX86InstPSraW            , "psraw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 4, 0x00000FE1, 0x00000F71),
1645 
+	INST(kX86InstPSrlD            , "psrld"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 2, 0x00000FD2, 0x00000F72),
1646 
+	INST(kX86InstPSrlDQ           , "psrldq"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(Imm)              , 3, 0         , 0x66000F73),
1647 
+	INST(kX86InstPSrlQ            , "psrlq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 2, 0x00000FD3, 0x00000F73),
1648 
+	INST(kX86InstPSrlW            , "psrlw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)|O(Imm)  , 2, 0x00000FD1, 0x00000F71),
1649 
+	INST(kX86InstPSubB            , "psubb"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF8, 0),
1650 
+	INST(kX86InstPSubD            , "psubd"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFA, 0),
1651 
+	INST(kX86InstPSubQ            , "psubq"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FFB, 0),
1652 
+	INST(kX86InstPSubSB           , "psubsb"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE8, 0),
1653 
+	INST(kX86InstPSubSW           , "psubsw"           , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FE9, 0),
1654 
+	INST(kX86InstPSubUSB          , "psubusb"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD8, 0),
1655 
+	INST(kX86InstPSubUSW          , "psubusw"          , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FD9, 0),
1656 
+	INST(kX86InstPSubW            , "psubw"            , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FF9, 0),
1657 
+	INST(kX86InstPSwapD           , "pswapd"           , G(MmuRm3dNow)    , F(None)          , O(Mm)               , O(MmMem)            , 0, 0x00000F0F, 0xBB),
1658 
+	INST(kX86InstPTest            , "ptest"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3817, 0),
1659 
+	INST(kX86InstPunpckHBW        , "punpckhbw"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F68, 0),
1660 
+	INST(kX86InstPunpckHDQ        , "punpckhdq"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F6A, 0),
1661 
+	INST(kX86InstPunpckHQDQ       , "punpckhqdq"       , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F6D, 0),
1662 
+	INST(kX86InstPunpckHWD        , "punpckhwd"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F69, 0),
1663 
+	INST(kX86InstPunpckLBW        , "punpcklbw"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F60, 0),
1664 
+	INST(kX86InstPunpckLDQ        , "punpckldq"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F62, 0),
1665 
+	INST(kX86InstPunpckLQDQ       , "punpcklqdq"       , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F6C, 0),
1666 
+	INST(kX86InstPunpckLWD        , "punpcklwd"        , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000F61, 0),
1667 
+	INST(kX86InstPush             , "push"             , G(Push)          , F(Special)       , 0                   , 0                   , 6, 0x00000050, 0x000000FF),
1668 
+	INST(kX86InstPushAD           , "pushad"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000060, 0),
1669 
+	INST(kX86InstPushFD           , "pushfd"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009C, 0),
1670 
+	INST(kX86InstPushFQ           , "pushfq"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009C, 0),
1671 
+	INST(kX86InstPXor             , "pxor"             , G(MmuRmI)        , F(None)          , O(MmXmm)            , O(MmXmmMem)         , 0, 0x00000FEF, 0),
1672 
+	INST(kX86InstRcl              , "rcl"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 2, 0         , 0),
1673 
+	INST(kX86InstRcpPS            , "rcpps"            , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F53, 0),
1674 
+	INST(kX86InstRcpSS            , "rcpss"            , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F53, 0),
1675 
+	INST(kX86InstRcr              , "rcr"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 3, 0         , 0),
1676 
+	INST(kX86InstRdtsc            , "rdtsc"            , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x00000F31, 0),
1677 
+	INST(kX86InstRdtscP           , "rdtscp"           , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x000F01F9, 0),
1678 
+	INST(kX86InstRepLodSB         , "rep lodsb"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 1 /* Size of mem */),
1679 
+	INST(kX86InstRepLodSD         , "rep lodsd"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 4 /* Size of mem */),
1680 
+	INST(kX86InstRepLodSQ         , "rep lodsq"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 8 /* Size of mem */),
1681 
+	INST(kX86InstRepLodSW         , "rep lodsw"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AC, 2 /* Size of mem */),
1682 
+	INST(kX86InstRepMovSB         , "rep movsb"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 1 /* Size of mem */),
1683 
+	INST(kX86InstRepMovSD         , "rep movsd"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 4 /* Size of mem */),
1684 
+	INST(kX86InstRepMovSQ         , "rep movsq"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 8 /* Size of mem */),
1685 
+	INST(kX86InstRepMovSW         , "rep movsw"        , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A4, 2 /* Size of mem */),
1686 
+	INST(kX86InstRepStoSB         , "rep stosb"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 1 /* Size of mem */),
1687 
+	INST(kX86InstRepStoSD         , "rep stosd"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 4 /* Size of mem */),
1688 
+	INST(kX86InstRepStoSQ         , "rep stosq"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 8 /* Size of mem */),
1689 
+	INST(kX86InstRepStoSW         , "rep stosw"        , G(Rep)           , F(Special)       , O(Mem)              , 0                   , 0, 0xF30000AA, 2 /* Size of mem */),
1690 
+	INST(kX86InstRepECmpSB        , "repe cmpsb"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 1 /* Size of mem */),
1691 
+	INST(kX86InstRepECmpSD        , "repe cmpsd"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 4 /* Size of mem */),
1692 
+	INST(kX86InstRepECmpSQ        , "repe cmpsq"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 8 /* Size of mem */),
1693 
+	INST(kX86InstRepECmpSW        , "repe cmpsw"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000A6, 2 /* Size of mem */),
1694 
+	INST(kX86InstRepEScaSB        , "repe scasb"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 1 /* Size of mem */),
1695 
+	INST(kX86InstRepEScaSD        , "repe scasd"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 4 /* Size of mem */),
1696 
+	INST(kX86InstRepEScaSQ        , "repe scasq"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 8 /* Size of mem */),
1697 
+	INST(kX86InstRepEScaSW        , "repe scasw"       , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF30000AE, 2 /* Size of mem */),
1698 
+	INST(kX86InstRepNECmpSB       , "repne cmpsb"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 1 /* Size of mem */),
1699 
+	INST(kX86InstRepNECmpSD       , "repne cmpsd"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 4 /* Size of mem */),
1700 
+	INST(kX86InstRepNECmpSQ       , "repne cmpsq"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 8 /* Size of mem */),
1701 
+	INST(kX86InstRepNECmpSW       , "repne cmpsw"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000A6, 2 /* Size of mem */),
1702 
+	INST(kX86InstRepNEScaSB       , "repne scasb"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 1 /* Size of mem */),
1703 
+	INST(kX86InstRepNEScaSD       , "repne scasd"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 4 /* Size of mem */),
1704 
+	INST(kX86InstRepNEScaSQ       , "repne scasq"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 8 /* Size of mem */),
1705 
+	INST(kX86InstRepNEScaSW       , "repne scasw"      , G(Rep)           , F(Special)       , O(Mem)              , O(Mem)              , 0, 0xF20000AE, 2 /* Size of mem */),
1706 
+	INST(kX86InstRet              , "ret"              , G(Ret)           , F(Special)       , 0                   , 0                   , 0, 0         , 0),
1707 
+	INST(kX86InstRol              , "rol"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 0, 0         , 0),
1708 
+	INST(kX86InstRor              , "ror"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 1, 0         , 0),
1709 
+	INST(kX86InstRoundPD          , "roundpd"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A09, 0),
1710 
+	INST(kX86InstRoundPS          , "roundps"          , G(MmuRmImm8)     , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A08, 0),
1711 
+	INST(kX86InstRoundSD          , "roundsd"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0B, 0),
1712 
+	INST(kX86InstRoundSS          , "roundss"          , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x660F3A0A, 0),
1713 
+	INST(kX86InstRSqrtPS          , "rsqrtps"          , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F52, 0),
1714 
+	INST(kX86InstRSqrtSS          , "rsqrtss"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F52, 0),
1715 
+	INST(kX86InstSahf             , "sahf"             , G(Emit)          , F(Special)       , 0                   , 0                   , 0, 0x0000009E, 0),
1716 
+	INST(kX86InstSal              , "sal"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 4, 0         , 0),
1717 
+	INST(kX86InstSar              , "sar"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 7, 0         , 0),
1718 
+	INST(kX86InstSbb              , "sbb"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 3, 0x00000018, 0x00000080),
1719 
+	INST(kX86InstSetA             , "seta"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F97, 0),
1720 
+	INST(kX86InstSetAE            , "setae"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F93, 0),
1721 
+	INST(kX86InstSetB             , "setb"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F92, 0),
1722 
+	INST(kX86InstSetBE            , "setbe"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F96, 0),
1723 
+	INST(kX86InstSetC             , "setc"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F92, 0),
1724 
+	INST(kX86InstSetE             , "sete"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F94, 0),
1725 
+	INST(kX86InstSetG             , "setg"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9F, 0),
1726 
+	INST(kX86InstSetGE            , "setge"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9D, 0),
1727 
+	INST(kX86InstSetL             , "setl"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9C, 0),
1728 
+	INST(kX86InstSetLE            , "setle"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9E, 0),
1729 
+	INST(kX86InstSetNA            , "setna"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F96, 0),
1730 
+	INST(kX86InstSetNAE           , "setnae"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F92, 0),
1731 
+	INST(kX86InstSetNB            , "setnb"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F93, 0),
1732 
+	INST(kX86InstSetNBE           , "setnbe"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F97, 0),
1733 
+	INST(kX86InstSetNC            , "setnc"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F93, 0),
1734 
+	INST(kX86InstSetNE            , "setne"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F95, 0),
1735 
+	INST(kX86InstSetNG            , "setng"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9E, 0),
1736 
+	INST(kX86InstSetNGE           , "setnge"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9C, 0),
1737 
+	INST(kX86InstSetNL            , "setnl"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9D, 0),
1738 
+	INST(kX86InstSetNLE           , "setnle"           , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9F, 0),
1739 
+	INST(kX86InstSetNO            , "setno"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F91, 0),
1740 
+	INST(kX86InstSetNP            , "setnp"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9B, 0),
1741 
+	INST(kX86InstSetNS            , "setns"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F99, 0),
1742 
+	INST(kX86InstSetNZ            , "setnz"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F95, 0),
1743 
+	INST(kX86InstSetO             , "seto"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F90, 0),
1744 
+	INST(kX86InstSetP             , "setp"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9A, 0),
1745 
+	INST(kX86InstSetPE            , "setpe"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9A, 0),
1746 
+	INST(kX86InstSetPO            , "setpo"            , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F9B, 0),
1747 
+	INST(kX86InstSetS             , "sets"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F98, 0),
1748 
+	INST(kX86InstSetZ             , "setz"             , G(RmByte)        , F(None)          , O(GbMem)            , 0                   , 0, 0x00000F94, 0),
1749 
+	INST(kX86InstSFence           , "sfence"           , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000FAEF8, 0),
1750 
+	INST(kX86InstShl              , "shl"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 4, 0         , 0),
1751 
+	INST(kX86InstShld             , "shld"             , G(ShldShrd)      , F(Special)       , O(GqdwbMem)         , O(Gb)               , 0, 0x00000FA4, 0),
1752 
+	INST(kX86InstShr              , "shr"              , G(Rot)           , F(Special)       , O(GqdwbMem)         , O(Gb)|O(Imm)        , 5, 0         , 0),
1753 
+	INST(kX86InstShrd             , "shrd"             , G(ShldShrd)      , F(Special)       , O(GqdwbMem)         , O(Gqdwb)            , 0, 0x00000FAC, 0),
1754 
+	INST(kX86InstShufPD           , "shufpd"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000FC6, 0),
1755 
+	INST(kX86InstShufPS           , "shufps"           , G(MmuRmImm8)     , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000FC6, 0),
1756 
+	INST(kX86InstSqrtPD           , "sqrtpd"           , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x66000F51, 0),
1757 
+	INST(kX86InstSqrtPS           , "sqrtps"           , G(MmuRmI)        , F(Mov)           , O(Xmm)              , O(XmmMem)           , 0, 0x00000F51, 0),
1758 
+	INST(kX86InstSqrtSD           , "sqrtsd"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F51, 0),
1759 
+	INST(kX86InstSqrtSS           , "sqrtss"           , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F51, 0),
1760 
+	INST(kX86InstStc              , "stc"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000F9, 0),
1761 
+	INST(kX86InstStd              , "std"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x000000FD, 0),
1762 
+	INST(kX86InstStMXCSR          , "stmxcsr"          , G(Mem)           , F(None)          , O(Mem)              , 0                   , 3, 0x00000FAE, 0),
1763 
+	INST(kX86InstSub              , "sub"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 5, 0x00000028, 0x00000080),
1764 
+	INST(kX86InstSubPD            , "subpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F5C, 0),
1765 
+	INST(kX86InstSubPS            , "subps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F5C, 0),
1766 
+	INST(kX86InstSubSD            , "subsd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF2000F5C, 0),
1767 
+	INST(kX86InstSubSS            , "subss"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0xF3000F5C, 0),
1768 
+	INST(kX86InstTest             , "test"             , G(Test)          , F(None)          , O(GqdwbMem)         , O(Gqdwb)|O(Imm)     , 0, 0         , 0),
1769 
+	INST(kX86InstUComISD          , "ucomisd"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F2E, 0),
1770 
+	INST(kX86InstUComISS          , "ucomiss"          , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F2E, 0),
1771 
+	INST(kX86InstUd2              , "ud2"              , G(Emit)          , F(None)          , 0                   , 0                   , 0, 0x00000F0B, 0),
1772 
+	INST(kX86InstUnpckHPD         , "unpckhpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F15, 0),
1773 
+	INST(kX86InstUnpckHPS         , "unpckhps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F15, 0),
1774 
+	INST(kX86InstUnpckLPD         , "unpcklpd"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F14, 0),
1775 
+	INST(kX86InstUnpckLPS         , "unpcklps"         , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F14, 0),
1776 
+	INST(kX86InstXadd             , "xadd"             , G(RmReg)         , F(Lockable)      , O(GqdwbMem)         , O(Gqdwb)            , 0, 0x00000FC0, 0),
1777 
+	INST(kX86InstXchg             , "xchg"             , G(Xchg)          , F(Lockable)      , O(GqdwbMem)         , O(Gqdwb)            , 0, 0         , 0),
1778 
+	INST(kX86InstXor              , "xor"              , G(Arith)         , F(Lockable)      , O(GqdwbMem)         , O(GqdwbMem)|O(Imm)  , 6, 0x00000030, 0x00000080),
1779 
+	INST(kX86InstXorPD            , "xorpd"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x66000F57, 0),
1780 
+	INST(kX86InstXorPS            , "xorps"            , G(MmuRmI)        , F(None)          , O(Xmm)              , O(XmmMem)           , 0, 0x00000F57, 0)
1781 1781 
 };
1782 1782
1783 1783 
 #undef G
... ... 
@@ -1795,17 +1795,17 @@ const X86InstInfo x86InstInfo[] =
1795 1795
1796 1796 
 const X86VarInfo x86VarInfo[] =
1797 1797 
 {
1798 
-  /*  0 */ { kX86RegTypeGpd   , 4 , C(Gp) , 0                , "Gpd"         },
1799 
-  /*  1 */ { kX86RegTypeGpq   , 8 , C(Gp) , 0                , "Gpq"         },
1800 
-  /*  2 */ { kX86RegTypeX87   , 4 , C(X87), F(SP)            , "X87"         },
1801 
-  /*  3 */ { kX86RegTypeX87   , 4 , C(X87), F(SP)            , "X87.SS"      },
1802 
-  /*  4 */ { kX86RegTypeX87   , 8 , C(X87), F(DP)            , "X87.SD"      },
1803 
-  /*  5 */ { kX86RegTypeMm    , 8 , C(Mm) , 0                , "Mm"          },
1804 
-  /*  6 */ { kX86RegTypeXmm   , 16, C(Xmm), 0                , "Xmm"         },
1805 
-  /*  7 */ { kX86RegTypeXmm   , 4 , C(Xmm), F(SP)            , "Xmm.SS"      },
1806 
-  /*  8 */ { kX86RegTypeXmm   , 8 , C(Xmm), F(DP)            , "Xmm.SD"      },
1807 
-  /*  9 */ { kX86RegTypeXmm   , 16, C(Xmm), F(SP) | F(Packed), "Xmm.PS"      },
1808 
-  /* 10 */ { kX86RegTypeXmm   , 16, C(Xmm), F(DP) | F(Packed), "Xmm.PD"      }
1798 
+	/*  0 */ { kX86RegTypeGpd   , 4 , C(Gp) , 0                , "Gpd"         },
1799 
+	/*  1 */ { kX86RegTypeGpq   , 8 , C(Gp) , 0                , "Gpq"         },
1800 
+	/*  2 */ { kX86RegTypeX87   , 4 , C(X87), F(SP)            , "X87"         },
1801 
+	/*  3 */ { kX86RegTypeX87   , 4 , C(X87), F(SP)            , "X87.SS"      },
1802 
+	/*  4 */ { kX86RegTypeX87   , 8 , C(X87), F(DP)            , "X87.SD"      },
1803 
+	/*  5 */ { kX86RegTypeMm    , 8 , C(Mm) , 0                , "Mm"          },
1804 
+	/*  6 */ { kX86RegTypeXmm   , 16, C(Xmm), 0                , "Xmm"         },
1805 
+	/*  7 */ { kX86RegTypeXmm   , 4 , C(Xmm), F(SP)            , "Xmm.SS"      },
1806 
+	/*  8 */ { kX86RegTypeXmm   , 8 , C(Xmm), F(DP)            , "Xmm.SD"      },
1807 
+	/*  9 */ { kX86RegTypeXmm   , 16, C(Xmm), F(SP) | F(Packed), "Xmm.PS"      },
1808 
+	/* 10 */ { kX86RegTypeXmm   , 16, C(Xmm), F(DP) | F(Packed), "Xmm.PD"      }
1809 1809 
 };
1810 1810
1811 1811 
 #undef F
src/in_2sf/desmume/utils/AsmJit/x86/x86func.cpp
History View file @ d07af85
... ... 
@@ -18,7 +18,8 @@
18 18 
 // [Api-Begin]
19 19 
 #include "../core/apibegin.h"
20 20
21 
-namespace AsmJit {
21 
+namespace AsmJit
22 
+{
22 23
23 24 
 // ============================================================================
24 25 
 // [AsmJit::X86FuncDecl - Accessors]
... ... 
@@ -26,335 +27,279 @@ namespace AsmJit {
26 27
27 28 
 uint32_t X86FuncDecl::findArgumentByRegCode(uint32_t regCode) const
28 29 
 {
29 
-  uint32_t type = regCode & kRegTypeMask;
30 
-  uint32_t idx = regCode & kRegIndexMask;
30 
+	uint32_t type = regCode & kRegTypeMask;
31 
+	uint32_t idx = regCode & kRegIndexMask;
31 32
32 
-  uint32_t clazz;
33 
+	uint32_t clazz;
33 34
34 
-  switch (type)
35 
-  {
36 
-    case kX86RegTypeGpd:
37 
-    case kX86RegTypeGpq:
38 
-      clazz = kX86VarClassGp;
39 
-      break;
35 
+	switch (type)
36 
+	{
37 
+		case kX86RegTypeGpd:
38 
+		case kX86RegTypeGpq:
39 
+			clazz = kX86VarClassGp;
40 
+			break;
40 41
41 
-    case kX86RegTypeX87:
42 
-      clazz = kX86VarClassX87;
43 
-      break;
42 
+		case kX86RegTypeX87:
43 
+			clazz = kX86VarClassX87;
44 
+			break;
44 45
45 
-    case kX86RegTypeMm:
46 
-      clazz = kX86VarClassMm;
47 
-      break;
46 
+		case kX86RegTypeMm:
47 
+			clazz = kX86VarClassMm;
48 
+			break;
48 49
49 
-    case kX86RegTypeXmm:
50 
-      clazz = kX86VarClassXmm;
51 
-      break;
50 
+		case kX86RegTypeXmm:
51 
+			clazz = kX86VarClassXmm;
52 
+			break;
52 53
53 
-    default:
54 
-      return kInvalidValue;
55 
-  }
54 
+		default:
55 
+			return kInvalidValue;
56 
+	}
56 57
57 
-  for (uint32_t i = 0; i < _argumentsCount; i++)
58 
-  {
59 
-    const FuncArg& arg = _arguments[i];
58 
+	for (uint32_t i = 0; i < this->_argumentsCount; ++i)
59 
+	{
60 
+		const FuncArg &arg = this->_arguments[i];
60 61
61 
-    if (arg.getRegIndex() == idx && (X86Util::getVarClassFromVarType(arg.getVarType()) & clazz))
62 
-      return i;
63 
-  }
62 
+		if (arg.getRegIndex() == idx && (X86Util::getVarClassFromVarType(arg.getVarType()) & clazz))
63 
+			return i;
64 
+	}
64 65
65 
-  return kInvalidValue;
66 
+	return kInvalidValue;
66 67 
 }
67 68
68 69 
 // ============================================================================
69 70 
 // [AsmJit::X86FuncDecl - SetPrototype - InitCallingConvention]
70 71 
 // ============================================================================
71 72
72 
-static void X86FuncDecl_initCallingConvention(X86FuncDecl* self, uint32_t convention)
73 
+static void X86FuncDecl_initCallingConvention(X86FuncDecl *self, uint32_t convention)
73 74 
 {
74 
-  uint32_t i;
75 
+	uint32_t i;
76 
+
77 
+	// --------------------------------------------------------------------------
78 
+	// [Inir]
79 
+	// --------------------------------------------------------------------------
80 
+
81 
+	self->_convention = convention;
82 
+	self->_calleePopsStack = false;
83 
+	self->_argumentsDirection = kFuncArgsRTL;
84 
+
85 
+	for (i = 0; i < ASMJIT_ARRAY_SIZE(self->_gpList); ++i)
86 
+		self->_gpList[i] = kRegIndexInvalid;
87 
+
88 
+	for (i = 0; i < ASMJIT_ARRAY_SIZE(self->_xmmList); ++i)
89 
+		self->_xmmList[i] = kRegIndexInvalid;
75 90
76 
-  // --------------------------------------------------------------------------
77 
-  // [Inir]
78 
-  // --------------------------------------------------------------------------
91 
+	self->_gpListMask = 0x0;
92 
+	self->_mmListMask = 0x0;
93 
+	self->_xmmListMask = 0x0;
79 94
80 
-  self->_convention = convention;
81 
-  self->_calleePopsStack = false;
82 
-  self->_argumentsDirection = kFuncArgsRTL;
95 
+	self->_gpPreservedMask = 0x0;
96 
+	self->_mmPreservedMask = 0x0;
97 
+	self->_xmmPreservedMask = 0x0;
83 98
84 
-  for (i = 0; i < ASMJIT_ARRAY_SIZE(self->_gpList); i++)
85 
-    self->_gpList[i] = kRegIndexInvalid;
99 
+	// --------------------------------------------------------------------------
100 
+	// [X86 Calling Conventions]
101 
+	// --------------------------------------------------------------------------
86 102
87 
-  for (i = 0; i < ASMJIT_ARRAY_SIZE(self->_xmmList); i++)
88 
-    self->_xmmList[i] = kRegIndexInvalid;
103 
+#ifdef ASMJIT_X86
104 
+	self->_gpPreservedMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEbx) | IntUtil::maskFromIndex(kX86RegIndexEsp) | IntUtil::maskFromIndex(kX86RegIndexEbp) |
105 
+		IntUtil::maskFromIndex(kX86RegIndexEsi) | IntUtil::maskFromIndex(kX86RegIndexEdi));
106 
+	self->_xmmPreservedMask = 0;
89 107
90 
-  self->_gpListMask = 0x0;
91 
-  self->_mmListMask = 0x0;
92 
-  self->_xmmListMask = 0x0;
108 
+	switch (convention)
109 
+	{
110 
+		// ------------------------------------------------------------------------
111 
+		// [CDecl]
112 
+		// ------------------------------------------------------------------------
93 113
94 
-  self->_gpPreservedMask = 0x0;
95 
-  self->_mmPreservedMask = 0x0;
96 
-  self->_xmmPreservedMask = 0x0;
114 
+		case kX86FuncConvCDecl:
115 
+			break;
97 116
98 
-  // --------------------------------------------------------------------------
99 
-  // [X86 Calling Conventions]
100 
-  // --------------------------------------------------------------------------
117 
+		// ------------------------------------------------------------------------
118 
+		// [StdCall]
119 
+		// ------------------------------------------------------------------------
101 120
102 
-#if defined(ASMJIT_X86)
103 
-  self->_gpPreservedMask = static_cast<uint16_t>(
104 
-    IntUtil::maskFromIndex(kX86RegIndexEbx) |
105 
-    IntUtil::maskFromIndex(kX86RegIndexEsp) |
106 
-    IntUtil::maskFromIndex(kX86RegIndexEbp) |
107 
-    IntUtil::maskFromIndex(kX86RegIndexEsi) |
108 
-    IntUtil::maskFromIndex(kX86RegIndexEdi));
109 
-  self->_xmmPreservedMask = 0;
121 
+		case kX86FuncConvStdCall:
122 
+			self->_calleePopsStack = true;
123 
+			break;
110 124
111 
-  switch (convention)
112 
-  {
113 
-    // ------------------------------------------------------------------------
114 
-    // [CDecl]
115 
-    // ------------------------------------------------------------------------
125 
+		// ------------------------------------------------------------------------
126 
+		// [MS-ThisCall]
127 
+		// ------------------------------------------------------------------------
116 128
117 
-    case kX86FuncConvCDecl:
118 
-      break;
129 
+		case kX86FuncConvMsThisCall:
130 
+			self->_calleePopsStack = true;
119 131
120 
-    // ------------------------------------------------------------------------
121 
-    // [StdCall]
122 
-    // ------------------------------------------------------------------------
132 
+			self->_gpList[0] = kX86RegIndexEcx;
123 133
124 
-    case kX86FuncConvStdCall:
125 
-      self->_calleePopsStack = true;
126 
-      break;
134 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEcx));
135 
+			break;
127 136
128 
-    // ------------------------------------------------------------------------
129 
-    // [MS-ThisCall]
130 
-    // ------------------------------------------------------------------------
137 
+		// ------------------------------------------------------------------------
138 
+		// [MS-FastCall]
139 
+		// ------------------------------------------------------------------------
131 140
132 
-    case kX86FuncConvMsThisCall:
133 
-      self->_calleePopsStack = true;
141 
+		case kX86FuncConvMsFastCall:
142 
+			self->_calleePopsStack = true;
134 143
135 
-      self->_gpList[0] = kX86RegIndexEcx;
144 
+			self->_gpList[0] = kX86RegIndexEcx;
145 
+			self->_gpList[1] = kX86RegIndexEdx;
136 146
137 
-      self->_gpListMask = static_cast<uint16_t>(
138 
-        IntUtil::maskFromIndex(kX86RegIndexEcx));
139 
-      break;
147 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEcx) | IntUtil::maskFromIndex(kX86RegIndexEdx));
148 
+			break;
140 149
141 
-    // ------------------------------------------------------------------------
142 
-    // [MS-FastCall]
143 
-    // ------------------------------------------------------------------------
150 
+		// ------------------------------------------------------------------------
151 
+		// [Borland-FastCall]
152 
+		// ------------------------------------------------------------------------
144 153
145 
-    case kX86FuncConvMsFastCall:
146 
-      self->_calleePopsStack = true;
154 
+		case kX86FuncConvBorlandFastCall:
155 
+			self->_calleePopsStack = true;
156 
+			self->_argumentsDirection = kFuncArgsLTR;
147 157
148 
-      self->_gpList[0] = kX86RegIndexEcx;
149 
-      self->_gpList[1] = kX86RegIndexEdx;
158 
+			self->_gpList[0] = kX86RegIndexEax;
159 
+			self->_gpList[1] = kX86RegIndexEdx;
160 
+			self->_gpList[2] = kX86RegIndexEcx;
150 161
151 
-      self->_gpListMask = static_cast<uint16_t>(
152 
-        IntUtil::maskFromIndex(kX86RegIndexEcx) |
153 
-        IntUtil::maskFromIndex(kX86RegIndexEdx));
154 
-      break;
162 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEax) | IntUtil::maskFromIndex(kX86RegIndexEdx) | IntUtil::maskFromIndex(kX86RegIndexEcx));
163 
+			break;
155 164
156 
-    // ------------------------------------------------------------------------
157 
-    // [Borland-FastCall]
158 
-    // ------------------------------------------------------------------------
165 
+		// ------------------------------------------------------------------------
166 
+		// [Gcc-FastCall]
167 
+		// ------------------------------------------------------------------------
159 168
160 
-    case kX86FuncConvBorlandFastCall:
161 
-      self->_calleePopsStack = true;
162 
-      self->_argumentsDirection = kFuncArgsLTR;
169 
+		case kX86FuncConvGccFastCall:
170 
+			self->_calleePopsStack = true;
163 171
164 
-      self->_gpList[0] = kX86RegIndexEax;
165 
-      self->_gpList[1] = kX86RegIndexEdx;
166 
-      self->_gpList[2] = kX86RegIndexEcx;
172 
+			self->_gpList[0] = kX86RegIndexEcx;
173 
+			self->_gpList[1] = kX86RegIndexEdx;
167 174
168 
-      self->_gpListMask = static_cast<uint16_t>(
169 
-        IntUtil::maskFromIndex(kX86RegIndexEax) |
170 
-        IntUtil::maskFromIndex(kX86RegIndexEdx) |
171 
-        IntUtil::maskFromIndex(kX86RegIndexEcx));
172 
-      break;
175 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEcx) | IntUtil::maskFromIndex(kX86RegIndexEdx));
176 
+			break;
173 177
174 
-    // ------------------------------------------------------------------------
175 
-    // [Gcc-FastCall]
176 
-    // ------------------------------------------------------------------------
177 
-
178 
-    case kX86FuncConvGccFastCall:
179 
-      self->_calleePopsStack = true;
180 
-
181 
-      self->_gpList[0] = kX86RegIndexEcx;
182 
-      self->_gpList[1] = kX86RegIndexEdx;
178 
+		// ------------------------------------------------------------------------
179 
+		// [Gcc-Regparm(1)]
180 
+		// ------------------------------------------------------------------------
183 181
184 
-      self->_gpListMask = static_cast<uint16_t>(
185 
-        IntUtil::maskFromIndex(kX86RegIndexEcx) |
186 
-        IntUtil::maskFromIndex(kX86RegIndexEdx));
187 
-      break;
188 
-
189 
-    // ------------------------------------------------------------------------
190 
-    // [Gcc-Regparm(1)]
191 
-    // ------------------------------------------------------------------------
192 
-
193 
-    case kX86FuncConvGccRegParm1:
194 
-      self->_calleePopsStack = false;
195 
-
196 
-      self->_gpList[0] = kX86RegIndexEax;
197 
-      self->_gpListMask = static_cast<uint16_t>(
198 
-        IntUtil::maskFromIndex(kX86RegIndexEax));
199 
-      break;
200 
-
201 
-    // ------------------------------------------------------------------------
202 
-    // [Gcc-Regparm(2)]
203 
-    // ------------------------------------------------------------------------
204 
-
205 
-    case kX86FuncConvGccRegParm2:
206 
-      self->_calleePopsStack = false;
182 
+		case kX86FuncConvGccRegParm1:
183 
+			self->_calleePopsStack = false;
207 184
208 
-      self->_gpList[0] = kX86RegIndexEax;
209 
-      self->_gpList[1] = kX86RegIndexEdx;
185 
+			self->_gpList[0] = kX86RegIndexEax;
186 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEax));
187 
+			break;
210 188
211 
-      self->_gpListMask = static_cast<uint16_t>(
212 
-        IntUtil::maskFromIndex(kX86RegIndexEax) |
213 
-        IntUtil::maskFromIndex(kX86RegIndexEdx));
214 
-      break;
189 
+		// ------------------------------------------------------------------------
190 
+		// [Gcc-Regparm(2)]
191 
+		// ------------------------------------------------------------------------
215 192
216 
-    // ------------------------------------------------------------------------
217 
-    // [Gcc-Regparm(3)]
218 
-    // ------------------------------------------------------------------------
193 
+		case kX86FuncConvGccRegParm2:
194 
+			self->_calleePopsStack = false;
219 195
220 
-    case kX86FuncConvGccRegParm3:
221 
-      self->_calleePopsStack = false;
196 
+			self->_gpList[0] = kX86RegIndexEax;
197 
+			self->_gpList[1] = kX86RegIndexEdx;
222 198
223 
-      self->_gpList[0] = kX86RegIndexEax;
224 
-      self->_gpList[1] = kX86RegIndexEdx;
225 
-      self->_gpList[2] = kX86RegIndexEcx;
199 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEax) | IntUtil::maskFromIndex(kX86RegIndexEdx));
200 
+			break;
226 201
227 
-      self->_gpListMask = static_cast<uint16_t>(
228 
-        IntUtil::maskFromIndex(kX86RegIndexEax) |
229 
-        IntUtil::maskFromIndex(kX86RegIndexEdx) |
230 
-        IntUtil::maskFromIndex(kX86RegIndexEcx));
231 
-      break;
202 
+		// ------------------------------------------------------------------------
203 
+		// [Gcc-Regparm(3)]
204 
+		// ------------------------------------------------------------------------
232 205
233 
-    // ------------------------------------------------------------------------
234 
-    // [Illegal]
235 
-    // ------------------------------------------------------------------------
206 
+		case kX86FuncConvGccRegParm3:
207 
+			self->_calleePopsStack = false;
236 208
237 
-    default:
238 
-      // Illegal calling convention.
239 
-      ASMJIT_ASSERT(0);
240 
-  }
209 
+			self->_gpList[0] = kX86RegIndexEax;
210 
+			self->_gpList[1] = kX86RegIndexEdx;
211 
+			self->_gpList[2] = kX86RegIndexEcx;
212 
+
213 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexEax) | IntUtil::maskFromIndex(kX86RegIndexEdx) | IntUtil::maskFromIndex(kX86RegIndexEcx));
214 
+			break;
215 
+
216 
+		// ------------------------------------------------------------------------
217 
+		// [Illegal]
218 
+		// ------------------------------------------------------------------------
219 
+
220 
+		default:
221 
+			// Illegal calling convention.
222 
+			ASMJIT_ASSERT(0);
223 
+	}
241 224 
 #endif // ASMJIT_X86
242 225
243 
-  // --------------------------------------------------------------------------
244 
-  // [X64 Calling Conventions]
245 
-  // --------------------------------------------------------------------------
246 
-
247 
-#if defined(ASMJIT_X64)
248 
-  switch (convention)
249 
-  {
250 
-    // ------------------------------------------------------------------------
251 
-    // [X64-Windows]
252 
-    // ------------------------------------------------------------------------
253 
-
254 
-    case kX86FuncConvX64W:
255 
-      self->_gpList[0] = kX86RegIndexRcx;
256 
-      self->_gpList[1] = kX86RegIndexRdx;
257 
-      self->_gpList[2] = kX86RegIndexR8;
258 
-      self->_gpList[3] = kX86RegIndexR9;
259 
-
260 
-      self->_xmmList[0] = kX86RegIndexXmm0;
261 
-      self->_xmmList[1] = kX86RegIndexXmm1;
262 
-      self->_xmmList[2] = kX86RegIndexXmm2;
263 
-      self->_xmmList[3] = kX86RegIndexXmm3;
264 
-
265 
-      self->_gpListMask = static_cast<uint16_t>(
266 
-        IntUtil::maskFromIndex(kX86RegIndexRcx  ) |
267 
-        IntUtil::maskFromIndex(kX86RegIndexRdx  ) |
268 
-        IntUtil::maskFromIndex(kX86RegIndexR8   ) |
269 
-        IntUtil::maskFromIndex(kX86RegIndexR9   ));
270 
-
271 
-      self->_xmmListMask = static_cast<uint16_t>(
272 
-        IntUtil::maskFromIndex(kX86RegIndexXmm0 ) |
273 
-        IntUtil::maskFromIndex(kX86RegIndexXmm1 ) |
274 
-        IntUtil::maskFromIndex(kX86RegIndexXmm2 ) |
275 
-        IntUtil::maskFromIndex(kX86RegIndexXmm3 ));
276 
-
277 
-      self->_gpPreservedMask = static_cast<uint16_t>(
278 
-        IntUtil::maskFromIndex(kX86RegIndexRbx  ) |
279 
-        IntUtil::maskFromIndex(kX86RegIndexRsp  ) |
280 
-        IntUtil::maskFromIndex(kX86RegIndexRbp  ) |
281 
-        IntUtil::maskFromIndex(kX86RegIndexRsi  ) |
282 
-        IntUtil::maskFromIndex(kX86RegIndexRdi  ) |
283 
-        IntUtil::maskFromIndex(kX86RegIndexR12  ) |
284 
-        IntUtil::maskFromIndex(kX86RegIndexR13  ) |
285 
-        IntUtil::maskFromIndex(kX86RegIndexR14  ) |
286 
-        IntUtil::maskFromIndex(kX86RegIndexR15  ));
287 
-
288 
-      self->_xmmPreservedMask = static_cast<uint16_t>(
289 
-        IntUtil::maskFromIndex(kX86RegIndexXmm6 ) |
290 
-        IntUtil::maskFromIndex(kX86RegIndexXmm7 ) |
291 
-        IntUtil::maskFromIndex(kX86RegIndexXmm8 ) |
292 
-        IntUtil::maskFromIndex(kX86RegIndexXmm9 ) |
293 
-        IntUtil::maskFromIndex(kX86RegIndexXmm10) |
294 
-        IntUtil::maskFromIndex(kX86RegIndexXmm11) |
295 
-        IntUtil::maskFromIndex(kX86RegIndexXmm12) |
296 
-        IntUtil::maskFromIndex(kX86RegIndexXmm13) |
297 
-        IntUtil::maskFromIndex(kX86RegIndexXmm14) |
298 
-        IntUtil::maskFromIndex(kX86RegIndexXmm15));
299 
-      break;
300 
-
301 
-    // ------------------------------------------------------------------------
302 
-    // [X64-Unix]
303 
-    // ------------------------------------------------------------------------
304 
-
305 
-    case kX86FuncConvX64U:
306 
-      self->_gpList[0] = kX86RegIndexRdi;
307 
-      self->_gpList[1] = kX86RegIndexRsi;
308 
-      self->_gpList[2] = kX86RegIndexRdx;
309 
-      self->_gpList[3] = kX86RegIndexRcx;
310 
-      self->_gpList[4] = kX86RegIndexR8;
311 
-      self->_gpList[5] = kX86RegIndexR9;
312 
-
313 
-      self->_xmmList[0] = kX86RegIndexXmm0;
314 
-      self->_xmmList[1] = kX86RegIndexXmm1;
315 
-      self->_xmmList[2] = kX86RegIndexXmm2;
316 
-      self->_xmmList[3] = kX86RegIndexXmm3;
317 
-      self->_xmmList[4] = kX86RegIndexXmm4;
318 
-      self->_xmmList[5] = kX86RegIndexXmm5;
319 
-      self->_xmmList[6] = kX86RegIndexXmm6;
320 
-      self->_xmmList[7] = kX86RegIndexXmm7;
321 
-
322 
-      self->_gpListMask = static_cast<uint16_t>(
323 
-        IntUtil::maskFromIndex(kX86RegIndexRdi  ) |
324 
-        IntUtil::maskFromIndex(kX86RegIndexRsi  ) |
325 
-        IntUtil::maskFromIndex(kX86RegIndexRdx  ) |
326 
-        IntUtil::maskFromIndex(kX86RegIndexRcx  ) |
327 
-        IntUtil::maskFromIndex(kX86RegIndexR8   ) |
328 
-        IntUtil::maskFromIndex(kX86RegIndexR9   ));
329 
-
330 
-      self->_xmmListMask = static_cast<uint16_t>(
331 
-        IntUtil::maskFromIndex(kX86RegIndexXmm0 ) |
332 
-        IntUtil::maskFromIndex(kX86RegIndexXmm1 ) |
333 
-        IntUtil::maskFromIndex(kX86RegIndexXmm2 ) |
334 
-        IntUtil::maskFromIndex(kX86RegIndexXmm3 ) |
335 
-        IntUtil::maskFromIndex(kX86RegIndexXmm4 ) |
336 
-        IntUtil::maskFromIndex(kX86RegIndexXmm5 ) |
337 
-        IntUtil::maskFromIndex(kX86RegIndexXmm6 ) |
338 
-        IntUtil::maskFromIndex(kX86RegIndexXmm7 ));
339 
-
340 
-      self->_gpPreservedMask = static_cast<uint16_t>(
341 
-        IntUtil::maskFromIndex(kX86RegIndexRbx  ) |
342 
-        IntUtil::maskFromIndex(kX86RegIndexRsp  ) |
343 
-        IntUtil::maskFromIndex(kX86RegIndexRbp  ) |
344 
-        IntUtil::maskFromIndex(kX86RegIndexR12  ) |
345 
-        IntUtil::maskFromIndex(kX86RegIndexR13  ) |
346 
-        IntUtil::maskFromIndex(kX86RegIndexR14  ) |
347 
-        IntUtil::maskFromIndex(kX86RegIndexR15  ));
348 
-      break;
349 
-
350 
-    // ------------------------------------------------------------------------
351 
-    // [Illegal]
352 
-    // ------------------------------------------------------------------------
353 
-
354 
-    default:
355 
-      // Illegal calling convention.
356 
-      ASMJIT_ASSERT(0);
357 
-  }
226 
+	// --------------------------------------------------------------------------
227 
+	// [X64 Calling Conventions]
228 
+	// --------------------------------------------------------------------------
229 
+
230 
+#ifdef ASMJIT_X64
231 
+	switch (convention)
232 
+	{
233 
+		// ------------------------------------------------------------------------
234 
+		// [X64-Windows]
235 
+		// ------------------------------------------------------------------------
236 
+
237 
+		case kX86FuncConvX64W:
238 
+			self->_gpList[0] = kX86RegIndexRcx;
239 
+			self->_gpList[1] = kX86RegIndexRdx;
240 
+			self->_gpList[2] = kX86RegIndexR8;
241 
+			self->_gpList[3] = kX86RegIndexR9;
242 
+
243 
+			self->_xmmList[0] = kX86RegIndexXmm0;
244 
+			self->_xmmList[1] = kX86RegIndexXmm1;
245 
+			self->_xmmList[2] = kX86RegIndexXmm2;
246 
+			self->_xmmList[3] = kX86RegIndexXmm3;
247 
+
248 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexRcx) | IntUtil::maskFromIndex(kX86RegIndexRdx) | IntUtil::maskFromIndex(kX86RegIndexR8) |
249 
+				IntUtil::maskFromIndex(kX86RegIndexR9));
250 
+
251 
+			self->_xmmListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexXmm0) | IntUtil::maskFromIndex(kX86RegIndexXmm1) | IntUtil::maskFromIndex(kX86RegIndexXmm2) |
252 
+				IntUtil::maskFromIndex(kX86RegIndexXmm3));
253 
+
254 
+			self->_gpPreservedMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexRbx) | IntUtil::maskFromIndex(kX86RegIndexRsp) | IntUtil::maskFromIndex(kX86RegIndexRbp) |
255 
+				IntUtil::maskFromIndex(kX86RegIndexRsi) | IntUtil::maskFromIndex(kX86RegIndexRdi) | IntUtil::maskFromIndex(kX86RegIndexR12) | IntUtil::maskFromIndex(kX86RegIndexR13) |
256 
+				IntUtil::maskFromIndex(kX86RegIndexR14) | IntUtil::maskFromIndex(kX86RegIndexR15));
257 
+
258 
+			self->_xmmPreservedMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexXmm6) | IntUtil::maskFromIndex(kX86RegIndexXmm7) | IntUtil::maskFromIndex(kX86RegIndexXmm8) |
259 
+				IntUtil::maskFromIndex(kX86RegIndexXmm9) | IntUtil::maskFromIndex(kX86RegIndexXmm10) | IntUtil::maskFromIndex(kX86RegIndexXmm11) | IntUtil::maskFromIndex(kX86RegIndexXmm12) |
260 
+				IntUtil::maskFromIndex(kX86RegIndexXmm13) | IntUtil::maskFromIndex(kX86RegIndexXmm14) | IntUtil::maskFromIndex(kX86RegIndexXmm15));
261 
+			break;
262 
+
263 
+		// ------------------------------------------------------------------------
264 
+		// [X64-Unix]
265 
+		// ------------------------------------------------------------------------
266 
+
267 
+		case kX86FuncConvX64U:
268 
+			self->_gpList[0] = kX86RegIndexRdi;
269 
+			self->_gpList[1] = kX86RegIndexRsi;
270 
+			self->_gpList[2] = kX86RegIndexRdx;
271 
+			self->_gpList[3] = kX86RegIndexRcx;
272 
+			self->_gpList[4] = kX86RegIndexR8;
273 
+			self->_gpList[5] = kX86RegIndexR9;
274 
+
275 
+			self->_xmmList[0] = kX86RegIndexXmm0;
276 
+			self->_xmmList[1] = kX86RegIndexXmm1;
277 
+			self->_xmmList[2] = kX86RegIndexXmm2;
278 
+			self->_xmmList[3] = kX86RegIndexXmm3;
279 
+			self->_xmmList[4] = kX86RegIndexXmm4;
280 
+			self->_xmmList[5] = kX86RegIndexXmm5;
281 
+			self->_xmmList[6] = kX86RegIndexXmm6;
282 
+			self->_xmmList[7] = kX86RegIndexXmm7;
283 
+
284 
+			self->_gpListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexRdi) | IntUtil::maskFromIndex(kX86RegIndexRsi) | IntUtil::maskFromIndex(kX86RegIndexRdx) |
285 
+				IntUtil::maskFromIndex(kX86RegIndexRcx) | IntUtil::maskFromIndex(kX86RegIndexR8) | IntUtil::maskFromIndex(kX86RegIndexR9));
286 
+
287 
+			self->_xmmListMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexXmm0) | IntUtil::maskFromIndex(kX86RegIndexXmm1) | IntUtil::maskFromIndex(kX86RegIndexXmm2) |
288 
+				IntUtil::maskFromIndex(kX86RegIndexXmm3) | IntUtil::maskFromIndex(kX86RegIndexXmm4) | IntUtil::maskFromIndex(kX86RegIndexXmm5) | IntUtil::maskFromIndex(kX86RegIndexXmm6) |
289 
+				IntUtil::maskFromIndex(kX86RegIndexXmm7));
290 
+
291 
+			self->_gpPreservedMask = static_cast<uint16_t>(IntUtil::maskFromIndex(kX86RegIndexRbx) | IntUtil::maskFromIndex(kX86RegIndexRsp) | IntUtil::maskFromIndex(kX86RegIndexRbp) |
292 
+				IntUtil::maskFromIndex(kX86RegIndexR12) | IntUtil::maskFromIndex(kX86RegIndexR13) | IntUtil::maskFromIndex(kX86RegIndexR14) | IntUtil::maskFromIndex(kX86RegIndexR15));
293 
+			break;
294 
+
295 
+		// ------------------------------------------------------------------------
296 
+		// [Illegal]
297 
+		// ------------------------------------------------------------------------
298 
+
299 
+		default:
300 
+			// Illegal calling convention.
301 
+			ASMJIT_ASSERT(0);
302 
+	}
358 303 
 #endif // ASMJIT_X64
359 304 
 }
360 305
... ... 
@@ -362,230 +307,227 @@ static void X86FuncDecl_initCallingConvention(X86FuncDecl* self, uint32_t conven
362 307 
 // [AsmJit::X86FuncDecl - SetPrototype - InitDefinition]
363 308 
 // ============================================================================
364 309
365 
-static void X86FuncDecl_initDefinition(X86FuncDecl* self,
366 
-  uint32_t returnType, const uint32_t* argumentsData, uint32_t argumentsCount)
310 
+static void X86FuncDecl_initDefinition(X86FuncDecl *self, uint32_t returnType, const uint32_t *argumentsData, uint32_t argumentsCount)
367 311 
 {
368 
-  ASMJIT_ASSERT(argumentsCount <= kFuncArgsMax);
369 
-
370 
-  // --------------------------------------------------------------------------
371 
-  // [Init]
372 
-  // --------------------------------------------------------------------------
373 
-
374 
-  int32_t i = 0;
375 
-  int32_t gpPos = 0;
376 
-  int32_t stackOffset = 0;
377 
-
378 
-  self->_returnType = returnType;
379 
-  self->_argumentsCount = static_cast<uint8_t>(argumentsCount);
380 
-
381 
-  while (i < static_cast<int32_t>(argumentsCount))
382 
-  {
383 
-    FuncArg& arg = self->_arguments[i];
384 
-
385 
-    arg._varType = static_cast<uint8_t>(argumentsData[i]);
386 
-    arg._regIndex = kRegIndexInvalid;
387 
-    arg._stackOffset = kFuncStackInvalid;
388 
-
389 
-    i++;
390 
-  }
391 
-
392 
-  while (i < kFuncArgsMax)
393 
-  {
394 
-    FuncArg& arg = self->_arguments[i];
395 
-    arg.reset();
396 
-
397 
-    i++;
398 
-  }
399 
-
400 
-  self->_argumentsStackSize = 0;
401 
-  self->_gpArgumentsMask = 0x0;
402 
-  self->_mmArgumentsMask = 0x0;
403 
-  self->_xmmArgumentsMask = 0x0;
404 
-
405 
-  if (!self->_argumentsCount)
406 
-    return;
407 
-
408 
-  // --------------------------------------------------------------------------
409 
-  // [X86 Calling Conventions (32-bit)]
410 
-  // --------------------------------------------------------------------------
411 
-
412 
-#if defined(ASMJIT_X86)
413 
-  // Register arguments (Integer), always left-to-right.
414 
-  for (i = 0; i != static_cast<int32_t>(argumentsCount); i++)
415 
-  {
416 
-    FuncArg& arg = self->_arguments[i];
417 
-    uint32_t varType = arg.getVarType();
418 
-
419 
-    if (X86Util::isVarTypeInt(varType) && gpPos < 16 && self->_gpList[gpPos] != kRegIndexInvalid)
420 
-    {
421 
-      arg._regIndex = self->_gpList[gpPos++];
422 
-      self->_gpArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
423 
-    }
424 
-  }
425 
-
426 
-  // Stack arguments.
427 
-  int32_t iStart = static_cast<int32_t>(argumentsCount - 1);
428 
-  int32_t iEnd   = -1;
429 
-  int32_t iStep  = -1;
430 
-
431 
-  if (self->_argumentsDirection == kFuncArgsLTR)
432 
-  {
433 
-    iStart = 0;
434 
-    iEnd   = static_cast<int32_t>(argumentsCount);
435 
-    iStep  = 1;
436 
-  }
437 
-
438 
-  for (i = iStart; i != iEnd; i += iStep)
439 
-  {
440 
-    FuncArg& arg = self->_arguments[i];
441 
-    uint32_t varType = arg.getVarType();
442 
-
443 
-    if (arg.hasRegIndex())
444 
-      continue;
445 
-
446 
-    if (X86Util::isVarTypeInt(varType))
447 
-    {
448 
-      stackOffset -= 4;
449 
-      arg._stackOffset = static_cast<int16_t>(stackOffset);
450 
-    }
451 
-    else if (X86Util::isVarTypeFloat(varType))
452 
-    {
453 
-      int32_t size = static_cast<int32_t>(x86VarInfo[varType].getSize());
454 
-      stackOffset -= size;
455 
-      arg._stackOffset = static_cast<int16_t>(stackOffset);
456 
-    }
457 
-  }
312 
+	ASMJIT_ASSERT(argumentsCount <= kFuncArgsMax);
313 
+
314 
+	// --------------------------------------------------------------------------
315 
+	// [Init]
316 
+	// --------------------------------------------------------------------------
317 
+
318 
+	int32_t i = 0;
319 
+	int32_t gpPos = 0;
320 
+	int32_t stackOffset = 0;
321 
+
322 
+	self->_returnType = returnType;
323 
+	self->_argumentsCount = static_cast<uint8_t>(argumentsCount);
324 
+
325 
+	while (i < static_cast<int32_t>(argumentsCount))
326 
+	{
327 
+		FuncArg &arg = self->_arguments[i];
328 
+
329 
+		arg._varType = static_cast<uint8_t>(argumentsData[i]);
330 
+		arg._regIndex = kRegIndexInvalid;
331 
+		arg._stackOffset = kFuncStackInvalid;
332 
+
333 
+		++i;
334 
+	}
335 
+
336 
+	while (i < kFuncArgsMax)
337 
+	{
338 
+		FuncArg &arg = self->_arguments[i];
339 
+		arg.reset();
340 
+
341 
+		++i;
342 
+	}
343 
+
344 
+	self->_argumentsStackSize = 0;
345 
+	self->_gpArgumentsMask = 0x0;
346 
+	self->_mmArgumentsMask = 0x0;
347 
+	self->_xmmArgumentsMask = 0x0;
348 
+
349 
+	if (!self->_argumentsCount)
350 
+		return;
351 
+
352 
+	// --------------------------------------------------------------------------
353 
+	// [X86 Calling Conventions (32-bit)]
354 
+	// --------------------------------------------------------------------------
355 
+
356 
+#ifdef ASMJIT_X86
357 
+	// Register arguments (Integer), always left-to-right.
358 
+	for (i = 0; i != static_cast<int32_t>(argumentsCount); ++i)
359 
+	{
360 
+		FuncArg &arg = self->_arguments[i];
361 
+		uint32_t varType = arg.getVarType();
362 
+
363 
+		if (X86Util::isVarTypeInt(varType) && gpPos < 16 && self->_gpList[gpPos] != kRegIndexInvalid)
364 
+		{
365 
+			arg._regIndex = self->_gpList[gpPos++];
366 
+			self->_gpArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
367 
+		}
368 
+	}
369 
+
370 
+	// Stack arguments.
371 
+	int32_t iStart = static_cast<int32_t>(argumentsCount - 1);
372 
+	int32_t iEnd = -1;
373 
+	int32_t iStep = -1;
374 
+
375 
+	if (self->_argumentsDirection == kFuncArgsLTR)
376 
+	{
377 
+		iStart = 0;
378 
+		iEnd = static_cast<int32_t>(argumentsCount);
379 
+		iStep = 1;
380 
+	}
381 
+
382 
+	for (i = iStart; i != iEnd; i += iStep)
383 
+	{
384 
+		FuncArg &arg = self->_arguments[i];
385 
+		uint32_t varType = arg.getVarType();
386 
+
387 
+		if (arg.hasRegIndex())
388 
+			continue;
389 
+
390 
+		if (X86Util::isVarTypeInt(varType))
391 
+		{
392 
+			stackOffset -= 4;
393 
+			arg._stackOffset = static_cast<int16_t>(stackOffset);
394 
+		}
395 
+		else if (X86Util::isVarTypeFloat(varType))
396 
+		{
397 
+			int32_t size = static_cast<int32_t>(x86VarInfo[varType].getSize());
398 
+			stackOffset -= size;
399 
+			arg._stackOffset = static_cast<int16_t>(stackOffset);
400 
+		}
401 
+	}
458 402 
 #endif // ASMJIT_X86
459 403
460 
-  // --------------------------------------------------------------------------
461 
-  // [X64 Calling Conventions (64-bit)]
462 
-  // --------------------------------------------------------------------------
463 
-
464 
-#if defined(ASMJIT_X64)
465 
-  // Windows 64-bit specific.
466 
-  if (self->_convention == kX86FuncConvX64W)
467 
-  {
468 
-    int32_t max = argumentsCount < 4 ? argumentsCount : 4;
469 
-
470 
-    // Register arguments (Integer / FP), always left-to-right.
471 
-    for (i = 0; i != max; i++)
472 
-    {
473 
-      FuncArg& arg = self->_arguments[i];
474 
-      uint32_t varType = arg.getVarType();
475 
-
476 
-      if (X86Util::isVarTypeInt(varType))
477 
-      {
478 
-        arg._regIndex = self->_gpList[i];
479 
-        self->_gpArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
480 
-      }
481 
-      else if (X86Util::isVarTypeFloat(varType))
482 
-      {
483 
-        arg._regIndex = self->_xmmList[i];
484 
-        self->_xmmArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
485 
-      }
486 
-    }
487 
-
488 
-    // Stack arguments (always right-to-left).
489 
-    for (i = argumentsCount - 1; i != -1; i--)
490 
-    {
491 
-      FuncArg& arg = self->_arguments[i];
492 
-      uint32_t varType = arg.getVarType();
493 
-
494 
-      if (arg.isAssigned())
495 
-        continue;
496 
-
497 
-      if (X86Util::isVarTypeInt(varType))
498 
-      {
499 
-        stackOffset -= 8; // Always 8 bytes.
500 
-        arg._stackOffset = stackOffset;
501 
-      }
502 
-      else if (X86Util::isVarTypeFloat(varType))
503 
-      {
504 
-        int32_t size = static_cast<int32_t>(x86VarInfo[varType].getSize());
505 
-        stackOffset -= size;
506 
-        arg._stackOffset = stackOffset;
507 
-      }
508 
-    }
509 
-
510 
-    // 32 bytes shadow space (X64W calling convention specific).
511 
-    stackOffset -= 4 * 8;
512 
-  }
513 
-  // Linux/Unix 64-bit (AMD64 calling convention).
514 
-  else
515 
-  {
516 
-    // Register arguments (Integer), always left-to-right.
517 
-    for (i = 0; i != static_cast<int32_t>(argumentsCount); i++)
518 
-    {
519 
-      FuncArg& arg = self->_arguments[i];
520 
-      uint32_t varType = arg.getVarType();
521 
-
522 
-      if (X86Util::isVarTypeInt(varType) && gpPos < 32 && self->_gpList[gpPos] != kRegIndexInvalid)
523 
-      {
524 
-        arg._regIndex = self->_gpList[gpPos++];
525 
-        self->_gpArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
526 
-      }
527 
-    }
528 
-
529 
-    // Register arguments (FP), always left-to-right.
530 
-    for (i = 0; i != static_cast<int32_t>(argumentsCount); i++)
531 
-    {
532 
-      FuncArg& arg = self->_arguments[i];
533 
-      uint32_t varType = arg.getVarType();
534 
-
535 
-      if (X86Util::isVarTypeFloat(varType))
536 
-      {
537 
-        arg._regIndex = self->_xmmList[xmmPos++];
538 
-        self->_xmmArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
539 
-      }
540 
-    }
541 
-
542 
-    // Stack arguments.
543 
-    for (i = argumentsCount - 1; i != -1; i--)
544 
-    {
545 
-      FuncArg& arg = self->_arguments[i];
546 
-      uint32_t varType = arg.getVarType();
547 
-
548 
-      if (arg.isAssigned())
549 
-        continue;
550 
-
551 
-      if (X86Util::isVarTypeInt(varType))
552 
-      {
553 
-        stackOffset -= 8;
554 
-        arg._stackOffset = static_cast<int16_t>(stackOffset);
555 
-      }
556 
-      else if (X86Util::isVarTypeFloat(varType))
557 
-      {
558 
-        int32_t size = (int32_t)x86VarInfo[varType].getSize();
559 
-
560 
-        stackOffset -= size;
561 
-        arg._stackOffset = static_cast<int16_t>(stackOffset);
562 
-      }
563 
-    }
564 
-  }
404 
+	// --------------------------------------------------------------------------
405 
+	// [X64 Calling Conventions (64-bit)]
406 
+	// --------------------------------------------------------------------------
407 
+
408 
+#ifdef ASMJIT_X64
409 
+	// Windows 64-bit specific.
410 
+	if (self->_convention == kX86FuncConvX64W)
411 
+	{
412 
+		int32_t max = argumentsCount < 4 ? argumentsCount : 4;
413 
+
414 
+		// Register arguments (Integer / FP), always left-to-right.
415 
+		for (i = 0; i != max; ++i)
416 
+		{
417 
+			FuncArg &arg = self->_arguments[i];
418 
+			uint32_t varType = arg.getVarType();
419 
+
420 
+			if (X86Util::isVarTypeInt(varType))
421 
+			{
422 
+				arg._regIndex = self->_gpList[i];
423 
+				self->_gpArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
424 
+			}
425 
+			else if (X86Util::isVarTypeFloat(varType))
426 
+			{
427 
+				arg._regIndex = self->_xmmList[i];
428 
+				self->_xmmArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
429 
+			}
430 
+		}
431 
+
432 
+		// Stack arguments (always right-to-left).
433 
+		for (i = argumentsCount - 1; i != -1; --i)
434 
+		{
435 
+			FuncArg &arg = self->_arguments[i];
436 
+			uint32_t varType = arg.getVarType();
437 
+
438 
+			if (arg.isAssigned())
439 
+				continue;
440 
+
441 
+			if (X86Util::isVarTypeInt(varType))
442 
+			{
443 
+				stackOffset -= 8; // Always 8 bytes.
444 
+				arg._stackOffset = stackOffset;
445 
+			}
446 
+			else if (X86Util::isVarTypeFloat(varType))
447 
+			{
448 
+				int32_t size = static_cast<int32_t>(x86VarInfo[varType].getSize());
449 
+				stackOffset -= size;
450 
+				arg._stackOffset = stackOffset;
451 
+			}
452 
+		}
453 
+
454 
+		// 32 bytes shadow space (X64W calling convention specific).
455 
+		stackOffset -= 4 * 8;
456 
+	}
457 
+	// Linux/Unix 64-bit (AMD64 calling convention).
458 
+	else
459 
+	{
460 
+		// Register arguments (Integer), always left-to-right.
461 
+		for (i = 0; i != static_cast<int32_t>(argumentsCount); ++i)
462 
+		{
463 
+			FuncArg &arg = self->_arguments[i];
464 
+			uint32_t varType = arg.getVarType();
465 
+
466 
+			if (X86Util::isVarTypeInt(varType) && gpPos < 32 && self->_gpList[gpPos] != kRegIndexInvalid)
467 
+			{
468 
+				arg._regIndex = self->_gpList[gpPos++];
469 
+				self->_gpArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
470 
+			}
471 
+		}
472 
+
473 
+		// Register arguments (FP), always left-to-right.
474 
+		for (i = 0; i != static_cast<int32_t>(argumentsCount); ++i)
475 
+		{
476 
+			FuncArg &arg = self->_arguments[i];
477 
+			uint32_t varType = arg.getVarType();
478 
+
479 
+			if (X86Util::isVarTypeFloat(varType))
480 
+			{
481 
+				arg._regIndex = self->_xmmList[xmmPos++];
482 
+				self->_xmmArgumentsMask |= static_cast<uint16_t>(IntUtil::maskFromIndex(arg.getRegIndex()));
483 
+			}
484 
+		}
485 
+
486 
+		// Stack arguments.
487 
+		for (i = argumentsCount - 1; i != -1; --i)
488 
+		{
489 
+			FuncArg &arg = self->_arguments[i];
490 
+			uint32_t varType = arg.getVarType();
491 
+
492 
+			if (arg.isAssigned())
493 
+				continue;
494 
+
495 
+			if (X86Util::isVarTypeInt(varType))
496 
+			{
497 
+				stackOffset -= 8;
498 
+				arg._stackOffset = static_cast<int16_t>(stackOffset);
499 
+			}
500 
+			else if (X86Util::isVarTypeFloat(varType))
501 
+			{
502 
+				int32_t size = static_cast<int32_t>(x86VarInfo[varType].getSize());
503 
+
504 
+				stackOffset -= size;
505 
+				arg._stackOffset = static_cast<int16_t>(stackOffset);
506 
+			}
507 
+		}
508 
+	}
565 509 
 #endif // ASMJIT_X64
566 510
567 
-  // Modify stack offset (all function parameters will be in positive stack
568 
-  // offset that is never zero).
569 
-  for (i = 0; i < (int32_t)argumentsCount; i++)
570 
-  {
571 
-    FuncArg& arg = self->_arguments[i];
572 
-    if (!arg.hasRegIndex())
573 
-    {
574 
-      arg._stackOffset += static_cast<uint16_t>(static_cast<int32_t>(sizeof(uintptr_t)) - stackOffset);
575 
-    }
576 
-  }
577 
-
578 
-  self->_argumentsStackSize = (uint32_t)(-stackOffset);
511 
+	// Modify stack offset (all function parameters will be in positive stack
512 
+	// offset that is never zero).
513 
+	for (i = 0; i < (int32_t)argumentsCount; ++i)
514 
+	{
515 
+		FuncArg &arg = self->_arguments[i];
516 
+		if (!arg.hasRegIndex())
517 
+			arg._stackOffset += static_cast<uint16_t>(static_cast<int32_t>(sizeof(uintptr_t)) - stackOffset);
518 
+	}
519 
+
520 
+	self->_argumentsStackSize = static_cast<uint32_t>(-stackOffset);
579 521 
 }
580 522
581 
-void X86FuncDecl::setPrototype(uint32_t convention, uint32_t returnType, const uint32_t* arguments, uint32_t argumentsCount)
523 
+void X86FuncDecl::setPrototype(uint32_t convention, uint32_t returnType, const uint32_t *arguments, uint32_t argumentsCount)
582 524 
 {
583 
-  // Limit maximum function arguments to kFuncArgsMax.
584 
-  if (argumentsCount > kFuncArgsMax)
585 
-    argumentsCount = kFuncArgsMax;
525 
+	// Limit maximum function arguments to kFuncArgsMax.
526 
+	if (argumentsCount > kFuncArgsMax)
527 
+		argumentsCount = kFuncArgsMax;
586 528
587 
-  X86FuncDecl_initCallingConvention(this, convention);
588 
-  X86FuncDecl_initDefinition(this, returnType, arguments, argumentsCount);
529 
+	X86FuncDecl_initCallingConvention(this, convention);
530 
+	X86FuncDecl_initDefinition(this, returnType, arguments, argumentsCount);
589 531 
 }
590 532
591 533 
 // ============================================================================
... ... 
@@ -594,48 +536,48 @@ void X86FuncDecl::setPrototype(uint32_t convention, uint32_t returnType, const u
594 536
595 537 
 void X86FuncDecl::reset()
596 538 
 {
597 
-  uint32_t i;
539 
+	uint32_t i;
598 540
599 
-  // --------------------------------------------------------------------------
600 
-  // [Core]
601 
-  // --------------------------------------------------------------------------
541 
+	// --------------------------------------------------------------------------
542 
+	// [Core]
543 
+	// --------------------------------------------------------------------------
602 544
603 
-  _returnType = kVarTypeInvalid;
604 
-  _argumentsCount = 0;
545 
+	this->_returnType = kVarTypeInvalid;
546 
+	this->_argumentsCount = 0;
605 547
606 
-  _reserved0[0] = 0;
607 
-  _reserved0[1] = 0;
548 
+	this->_reserved0[0] = 0;
549 
+	this->_reserved0[1] = 0;
608 550
609 
-  for (i = 0; i < ASMJIT_ARRAY_SIZE(_arguments); i++)
610 
-    _arguments[i].reset();
551 
+	for (i = 0; i < ASMJIT_ARRAY_SIZE(this->_arguments); ++i)
552 
+		this->_arguments[i].reset();
611 553
612 
-  _argumentsStackSize = 0;
613 
-  _gpArgumentsMask = 0x0;
614 
-  _mmArgumentsMask = 0x0;
615 
-  _xmmArgumentsMask = 0x0;
554 
+	this->_argumentsStackSize = 0;
555 
+	this->_gpArgumentsMask = 0x0;
556 
+	this->_mmArgumentsMask = 0x0;
557 
+	this->_xmmArgumentsMask = 0x0;
616 558
617 
-  // --------------------------------------------------------------------------
618 
-  // [Convention]
619 
-  // --------------------------------------------------------------------------
559 
+	// --------------------------------------------------------------------------
560 
+	// [Convention]
561 
+	// --------------------------------------------------------------------------
620 562
621 
-  _convention = kFuncConvNone;
622 
-  _calleePopsStack = false;
623 
-  _argumentsDirection = kFuncArgsRTL;
624 
-  _reserved1 = 0;
563 
+	this->_convention = kFuncConvNone;
564 
+	this->_calleePopsStack = false;
565 
+	this->_argumentsDirection = kFuncArgsRTL;
566 
+	this->_reserved1 = 0;
625 567
626 
-  for (i = 0; i < ASMJIT_ARRAY_SIZE(_gpList); i++)
627 
-    _gpList[i] = kRegIndexInvalid;
568 
+	for (i = 0; i < ASMJIT_ARRAY_SIZE(this->_gpList); ++i)
569 
+		this->_gpList[i] = kRegIndexInvalid;
628 570
629 
-  for (i = 0; i < ASMJIT_ARRAY_SIZE(_xmmList); i++)
630 
-    _xmmList[i] = kRegIndexInvalid;
571 
+	for (i = 0; i < ASMJIT_ARRAY_SIZE(this->_xmmList); ++i)
572 
+		this->_xmmList[i] = kRegIndexInvalid;
631 573
632 
-  _gpListMask = 0x0;
633 
-  _mmListMask = 0x0;
634 
-  _xmmListMask = 0x0;
574 
+	this->_gpListMask = 0x0;
575 
+	this->_mmListMask = 0x0;
576 
+	this->_xmmListMask = 0x0;
635 577
636 
-  _gpPreservedMask = 0x0;
637 
-  _mmPreservedMask = 0x0;
638 
-  _xmmPreservedMask = 0x0;
578 
+	this->_gpPreservedMask = 0x0;
579 
+	this->_mmPreservedMask = 0x0;
580 
+	this->_xmmPreservedMask = 0x0;
639 581 
 }
640 582
641 583 
 } // AsmJit namespace
src/in_2sf/desmume/utils/AsmJit/x86/x86operand.cpp
History View file @ d07af85
... ... 
@@ -13,7 +13,8 @@
13 13 
 // [Api-Begin]
14 14 
 #include "../core/apibegin.h"
15 15
16 
-namespace AsmJit {
16 
+namespace AsmJit
17 
+{
17 18
18 19 
 // ============================================================================
19 20 
 // [AsmJit::Registers - no_reg]
... ... 
@@ -30,7 +31,7 @@ const GpReg cl(_Initialize(), kX86RegCl);
30 31 
 const GpReg dl(_Initialize(), kX86RegDl);
31 32 
 const GpReg bl(_Initialize(), kX86RegBl);
32 33
33 
-#if defined(ASMJIT_X64)
34 
+#ifdef ASMJIT_X64
34 35 
 const GpReg spl(_Initialize(), kX86RegSpl);
35 36 
 const GpReg bpl(_Initialize(), kX86RegBpl);
36 37 
 const GpReg sil(_Initialize(), kX86RegSil);
... ... 
@@ -64,7 +65,7 @@ const GpReg bp(_Initialize(), kX86RegBp);
64 65 
 const GpReg si(_Initialize(), kX86RegSi);
65 66 
 const GpReg di(_Initialize(), kX86RegDi);
66 67
67 
-#if defined(ASMJIT_X64)
68 
+#ifdef ASMJIT_X64
68 69 
 const GpReg r8w(_Initialize(), kX86RegR8w);
69 70 
 const GpReg r9w(_Initialize(), kX86RegR9w);
70 71 
 const GpReg r10w(_Initialize(), kX86RegR10w);
... ... 
@@ -88,7 +89,7 @@ const GpReg ebp(_Initialize(), kX86RegEbp);
88 89 
 const GpReg esi(_Initialize(), kX86RegEsi);
89 90 
 const GpReg edi(_Initialize(), kX86RegEdi);
90 91
91 
-#if defined(ASMJIT_X64)
92 
+#ifdef ASMJIT_X64
92 93 
 const GpReg r8d(_Initialize(), kX86RegR8d);
93 94 
 const GpReg r9d(_Initialize(), kX86RegR9d);
94 95 
 const GpReg r10d(_Initialize(), kX86RegR10d);
... ... 
@@ -103,7 +104,7 @@ const GpReg r15d(_Initialize(), kX86RegR15d);
103 104 
 // [AsmJit::Registers - 64-bit]
104 105 
 // ============================================================================
105 106
106 
-#if defined(ASMJIT_X64)
107 
+#ifdef ASMJIT_X64
107 108 
 const GpReg rax(_Initialize(), kX86RegRax);
108 109 
 const GpReg rcx(_Initialize(), kX86RegRcx);
109 110 
 const GpReg rdx(_Initialize(), kX86RegRdx);
... ... 
@@ -162,7 +163,7 @@ const XmmReg xmm5(_Initialize(), kX86RegXmm5);
162 163 
 const XmmReg xmm6(_Initialize(), kX86RegXmm6);
163 164 
 const XmmReg xmm7(_Initialize(), kX86RegXmm7);
164 165
165 
-#if defined(ASMJIT_X64)
166 
+#ifdef ASMJIT_X64
166 167 
 const XmmReg xmm8(_Initialize(), kX86RegXmm8);
167 168 
 const XmmReg xmm9(_Initialize(), kX86RegXmm9);
168 169 
 const XmmReg xmm10(_Initialize(), kX86RegXmm10);
... ... 
@@ -188,195 +189,173 @@ const SegmentReg gs(_Initialize(), kX86RegGs);
188 189 
 // [AsmJit::Var]
189 190 
 // ============================================================================
190 191
191 
-Mem _BaseVarMem(const Var& var, uint32_t size)
192 
-{
193 
-  Mem m; //(_DontInitialize());
194 
-
195 
-  m._mem.op = kOperandMem;
196 
-  m._mem.size = static_cast<uint8_t>(size == kInvalidValue ? var.getSize() : size);
197 
-  m._mem.type = kOperandMemNative;
198 
-  m._mem.segment = kX86SegNone;
199 
-  m._mem.sizePrefix = 0;
200 
-  m._mem.shift = 0;
201 
-
202 
-  m._mem.id = var.getId();
203 
-  m._mem.base = kInvalidValue;
204 
-  m._mem.index = kInvalidValue;
205 
-
206 
-  m._mem.target = nullptr;
207 
-  m._mem.displacement = 0;
208 
-
209 
-  return m;
210 
-}
211 
-
212 
-
213 
-Mem _BaseVarMem(const Var& var, uint32_t size, sysint_t disp)
192 
+Mem _BaseVarMem(const Var &var, uint32_t size, sysint_t disp)
214 193 
 {
215 
-  Mem m; //(_DontInitialize());
194 
+	Mem m; //(_DontInitialize());
216 195
217 
-  m._mem.op = kOperandMem;
218 
-  m._mem.size = static_cast<uint8_t>(size == kInvalidValue ? var.getSize() : size);
219 
-  m._mem.type = kOperandMemNative;
220 
-  m._mem.segment = kX86SegNone;
221 
-  m._mem.sizePrefix = 0;
222 
-  m._mem.shift = 0;
196 
+	m._mem.op = kOperandMem;
197 
+	m._mem.size = static_cast<uint8_t>(size == kInvalidValue ? var.getSize() : size);
198 
+	m._mem.type = kOperandMemNative;
199 
+	m._mem.segment = kX86SegNone;
200 
+	m._mem.sizePrefix = 0;
201 
+	m._mem.shift = 0;
223 202
224 
-  m._mem.id = var.getId();
203 
+	m._mem.id = var.getId();
225 204
226 
-  m._mem.base = kInvalidValue;
227 
-  m._mem.index = kInvalidValue;
205 
+	m._mem.base = kInvalidValue;
206 
+	m._mem.index = kInvalidValue;
228 207
229 
-  m._mem.target = nullptr;
230 
-  m._mem.displacement = disp;
208 
+	m._mem.target = nullptr;
209 
+	m._mem.displacement = disp;
231 210
232 
-  return m;
211 
+	return m;
233 212 
 }
234 213
235 
-Mem _BaseVarMem(const Var& var, uint32_t size, const GpVar& index, uint32_t shift, sysint_t disp)
214 
+Mem _BaseVarMem(const Var &var, uint32_t size, const GpVar &index, uint32_t shift, sysint_t disp)
236 215 
 {
237 
-  Mem m; //(_DontInitialize());
216 
+	Mem m; //(_DontInitialize());
238 217
239 
-  m._mem.op = kOperandMem;
240 
-  m._mem.size = static_cast<uint8_t>(size == kInvalidValue ? var.getSize() : size);
241 
-  m._mem.type = kOperandMemNative;
242 
-  m._mem.segment = kX86SegNone;
243 
-  m._mem.sizePrefix = 0;
244 
-  m._mem.shift = shift;
218 
+	m._mem.op = kOperandMem;
219 
+	m._mem.size = static_cast<uint8_t>(size == kInvalidValue ? var.getSize() : size);
220 
+	m._mem.type = kOperandMemNative;
221 
+	m._mem.segment = kX86SegNone;
222 
+	m._mem.sizePrefix = 0;
223 
+	m._mem.shift = shift;
245 224
246 
-  m._mem.id = var.getId();
225 
+	m._mem.id = var.getId();
247 226
248 
-  m._mem.base = kInvalidValue;
249 
-  m._mem.index = index.getId();
227 
+	m._mem.base = kInvalidValue;
228 
+	m._mem.index = index.getId();
250 229
251 
-  m._mem.target = nullptr;
252 
-  m._mem.displacement = disp;
230 
+	m._mem.target = nullptr;
231 
+	m._mem.displacement = disp;
253 232
254 
-  return m;
233 
+	return m;
255 234 
 }
256 235
257 236 
 // ============================================================================
258 237 
 // [AsmJit::Mem - ptr[]]
259 238 
 // ============================================================================
260 239
261 
-Mem ptr(const Label& label, sysint_t disp, uint32_t size)
240 
+Mem ptr(const Label &label, sysint_t disp, uint32_t size)
262 241 
 {
263 
-  return Mem(label, disp, size);
242 
+	return Mem(label, disp, size);
264 243 
 }
265 244
266 
-Mem ptr(const Label& label, const GpReg& index, uint32_t shift, sysint_t disp, uint32_t size)
245 
+Mem ptr(const Label &label, const GpReg &index, uint32_t shift, sysint_t disp, uint32_t size)
267 246 
 {
268 
-  Mem m(label, disp, size);
247 
+	Mem m(label, disp, size);
269 248
270 
-  m._mem.index = index.getRegIndex();
271 
-  m._mem.shift = shift;
249 
+	m._mem.index = index.getRegIndex();
250 
+	m._mem.shift = shift;
272 251
273 
-  return m;
252 
+	return m;
274 253 
 }
275 254
276 
-Mem ptr(const Label& label, const GpVar& index, uint32_t shift, sysint_t disp, uint32_t size)
255 
+Mem ptr(const Label &label, const GpVar &index, uint32_t shift, sysint_t disp, uint32_t size)
277 256 
 {
278 
-  Mem m(label, disp, size);
257 
+	Mem m(label, disp, size);
279 258
280 
-  m._mem.index = index.getId();
281 
-  m._mem.shift = shift;
259 
+	m._mem.index = index.getId();
260 
+	m._mem.shift = shift;
282 261
283 
-  return m;
262 
+	return m;
284 263 
 }
285 264
286 265 
 // ============================================================================
287 266 
 // [AsmJit::Mem - ptr[] - Absolute Addressing]
288 267 
 // ============================================================================
289 268
290 
-ASMJIT_API Mem ptr_abs(void* target, sysint_t disp, uint32_t size)
269 
+ASMJIT_API Mem ptr_abs(void *target, sysint_t disp, uint32_t size)
291 270 
 {
292 
-  Mem m;
271 
+	Mem m;
293 272
294 
-  m._mem.size = size;
295 
-  m._mem.type = kOperandMemAbsolute;
296 
-  m._mem.segment = kX86SegNone;
273 
+	m._mem.size = size;
274 
+	m._mem.type = kOperandMemAbsolute;
275 
+	m._mem.segment = kX86SegNone;
297 276
298 
-  m._mem.target = target;
299 
-  m._mem.displacement = disp;
277 
+	m._mem.target = target;
278 
+	m._mem.displacement = disp;
300 279
301 
-  return m;
280 
+	return m;
302 281 
 }
303 282
304 
-ASMJIT_API Mem ptr_abs(void* target, const GpReg& index, uint32_t shift, sysint_t disp, uint32_t size)
283 
+ASMJIT_API Mem ptr_abs(void *target, const GpReg &index, uint32_t shift, sysint_t disp, uint32_t size)
305 284 
 {
306 
-  Mem m;// (_DontInitialize());
285 
+	Mem m;// (_DontInitialize());
307 286
308 
-  m._mem.op = kOperandMem;
309 
-  m._mem.size = size;
310 
-  m._mem.type = kOperandMemAbsolute;
311 
-  m._mem.segment = kX86SegNone;
287 
+	m._mem.op = kOperandMem;
288 
+	m._mem.size = size;
289 
+	m._mem.type = kOperandMemAbsolute;
290 
+	m._mem.segment = kX86SegNone;
312 291
313 
-#if defined(ASMJIT_X86)
314 
-  m._mem.sizePrefix = index.getSize() != 4;
292 
+#ifdef ASMJIT_X86
293 
+	m._mem.sizePrefix = index.getSize() != 4;
315 294 
 #else
316 
-  m._mem.sizePrefix = index.getSize() != 8;
295 
+	m._mem.sizePrefix = index.getSize() != 8;
317 296 
 #endif
318 297
319 
-  m._mem.shift = shift;
298 
+	m._mem.shift = shift;
320 299
321 
-  m._mem.id = kInvalidValue;
322 
-  m._mem.base = kInvalidValue;
323 
-  m._mem.index = index.getRegIndex();
300 
+	m._mem.id = kInvalidValue;
301 
+	m._mem.base = kInvalidValue;
302 
+	m._mem.index = index.getRegIndex();
324 303
325 
-  m._mem.target = target;
326 
-  m._mem.displacement = disp;
304 
+	m._mem.target = target;
305 
+	m._mem.displacement = disp;
327 306
328 
-  return m;
307 
+	return m;
329 308 
 }
330 309
331 
-ASMJIT_API Mem ptr_abs(void* target, const GpVar& index, uint32_t shift, sysint_t disp, uint32_t size)
310 
+ASMJIT_API Mem ptr_abs(void *target, const GpVar &index, uint32_t shift, sysint_t disp, uint32_t size)
332 311 
 {
333 
-  Mem m;// (_DontInitialize());
312 
+	Mem m;// (_DontInitialize());
334 313
335 
-  m._mem.op = kOperandMem;
336 
-  m._mem.size = size;
337 
-  m._mem.type = kOperandMemAbsolute;
338 
-  m._mem.segment = kX86SegNone;
314 
+	m._mem.op = kOperandMem;
315 
+	m._mem.size = size;
316 
+	m._mem.type = kOperandMemAbsolute;
317 
+	m._mem.segment = kX86SegNone;
339 318
340 
-#if defined(ASMJIT_X86)
341 
-  m._mem.sizePrefix = index.getSize() != 4;
319 
+#ifdef ASMJIT_X86
320 
+	m._mem.sizePrefix = index.getSize() != 4;
342 321 
 #else
343 
-  m._mem.sizePrefix = index.getSize() != 8;
322 
+	m._mem.sizePrefix = index.getSize() != 8;
344 323 
 #endif
345 324
346 
-  m._mem.shift = shift;
325 
+	m._mem.shift = shift;
347 326
348 
-  m._mem.id = kInvalidValue;
349 
-  m._mem.base = kInvalidValue;
350 
-  m._mem.index = index.getId();
327 
+	m._mem.id = kInvalidValue;
328 
+	m._mem.base = kInvalidValue;
329 
+	m._mem.index = index.getId();
351 330
352 
-  m._mem.target = target;
353 
-  m._mem.displacement = disp;
331 
+	m._mem.target = target;
332 
+	m._mem.displacement = disp;
354 333
355 
-  return m;
334 
+	return m;
356 335 
 }
357 336
358 337 
 // ============================================================================
359 338 
 // [AsmJit::Mem - ptr[base + displacement]]
360 339 
 // ============================================================================
361 340
362 
-Mem ptr(const GpReg& base, sysint_t disp, uint32_t size)
341 
+Mem ptr(const GpReg &base, sysint_t disp, uint32_t size)
363 342 
 {
364 
-  return Mem(base, disp, size);
343 
+	return Mem(base, disp, size);
365 344 
 }
366 345
367 
-Mem ptr(const GpReg& base, const GpReg& index, uint32_t shift, sysint_t disp, uint32_t size)
346 
+Mem ptr(const GpReg &base, const GpReg &index, uint32_t shift, sysint_t disp, uint32_t size)
368 347 
 {
369 
-  return Mem(base, index, shift, disp, size);
348 
+	return Mem(base, index, shift, disp, size);
370 349 
 }
371 350
372 
-Mem ptr(const GpVar& base, sysint_t disp, uint32_t size)
351 
+Mem ptr(const GpVar &base, sysint_t disp, uint32_t size)
373 352 
 {
374 
-  return Mem(base, disp, size);
353 
+	return Mem(base, disp, size);
375 354 
 }
376 355
377 
-Mem ptr(const GpVar& base, const GpVar& index, uint32_t shift, sysint_t disp, uint32_t size)
356 
+Mem ptr(const GpVar &base, const GpVar &index, uint32_t shift, sysint_t disp, uint32_t size)
378 357 
 {
379 
-  return Mem(base, index, shift, disp, size);
358 
+	return Mem(base, index, shift, disp, size);
380 359 
 }
381 360
382 361 
 } // AsmJit namespace
src/in_2sf/desmume/utils/AsmJit/x86/x86operand.h
History View file @ d07af85
... ... 
@@ -1169,8 +1169,7 @@ struct Mem : public Operand
1169 1169 
 // [AsmJit::Var]
1170 1170 
 // ============================================================================
1171 1171
1172 
-ASMJIT_API Mem _BaseVarMem(const Var &var, uint32_t size);
1173 
-ASMJIT_API Mem _BaseVarMem(const Var &var, uint32_t size, sysint_t disp);
1172 
+ASMJIT_API Mem _BaseVarMem(const Var &var, uint32_t size, sysint_t disp = 0);
1174 1173 
 ASMJIT_API Mem _BaseVarMem(const Var &var, uint32_t size, const GpVar &index, uint32_t shift, sysint_t disp);
1175 1174
1176 1175 
 //! @brief Base class for all variables.
src/in_2sf/desmume/utils/AsmJit/x86/x86util.cpp
History View file @ d07af85
... ... 
@@ -12,125 +12,126 @@
12 12 
 // [Api-Begin]
13 13 
 #include "../core/apibegin.h"
14 14
15 
-namespace AsmJit {
15 
+namespace AsmJit
16 
+{
16 17
17 18 
 // ============================================================================
18 19 
 // [AsmJit::_x86UtilJccFromCond]
19 20 
 // ============================================================================
20 21
21 
-const uint32_t _x86UtilJccFromCond[20] =
22 
+const uint32_t _x86UtilJccFromCond[] =
22 23 
 {
23 
-  kX86InstJO,
24 
-  kX86InstJNO,
25 
-  kX86InstJB,
26 
-  kX86InstJAE,
27 
-  kX86InstJE,
28 
-  kX86InstJNE,
29 
-  kX86InstJBE,
30 
-  kX86InstJA,
31 
-  kX86InstJS,
32 
-  kX86InstJNS,
33 
-  kX86InstJPE,
34 
-  kX86InstJPO,
35 
-  kX86InstJL,
36 
-  kX86InstJGE,
37 
-  kX86InstJLE,
38 
-  kX86InstJG,
39 
-
40 
-  kInstNone,
41 
-  kInstNone,
42 
-  kInstNone,
43 
-  kInstNone
24 
+	kX86InstJO,
25 
+	kX86InstJNO,
26 
+	kX86InstJB,
27 
+	kX86InstJAE,
28 
+	kX86InstJE,
29 
+	kX86InstJNE,
30 
+	kX86InstJBE,
31 
+	kX86InstJA,
32 
+	kX86InstJS,
33 
+	kX86InstJNS,
34 
+	kX86InstJPE,
35 
+	kX86InstJPO,
36 
+	kX86InstJL,
37 
+	kX86InstJGE,
38 
+	kX86InstJLE,
39 
+	kX86InstJG,
40 
+
41 
+	kInstNone,
42 
+	kInstNone,
43 
+	kInstNone,
44 
+	kInstNone
44 45 
 };
45 46
46 47 
 // ============================================================================
47 48 
 // [AsmJit::_x86UtilMovccFromCond]
48 49 
 // ============================================================================
49 50
50 
-const uint32_t _x86UtilMovccFromCond[20] =
51 
+const uint32_t _x86UtilMovccFromCond[] =
51 52 
 {
52 
-  kX86InstCMovO,
53 
-  kX86InstCMovNO,
54 
-  kX86InstCMovB,
55 
-  kX86InstCMovAE,
56 
-  kX86InstCMovE,
57 
-  kX86InstCMovNE,
58 
-  kX86InstCMovBE,
59 
-  kX86InstCMovA,
60 
-  kX86InstCMovS,
61 
-  kX86InstCMovNS,
62 
-  kX86InstCMovPE,
63 
-  kX86InstCMovPO,
64 
-  kX86InstCMovL,
65 
-  kX86InstCMovGE,
66 
-  kX86InstCMovLE,
67 
-  kX86InstCMovG,
68 
-
69 
-  kInstNone,
70 
-  kInstNone,
71 
-  kInstNone,
72 
-  kInstNone
53 
+	kX86InstCMovO,
54 
+	kX86InstCMovNO,
55 
+	kX86InstCMovB,
56 
+	kX86InstCMovAE,
57 
+	kX86InstCMovE,
58 
+	kX86InstCMovNE,
59 
+	kX86InstCMovBE,
60 
+	kX86InstCMovA,
61 
+	kX86InstCMovS,
62 
+	kX86InstCMovNS,
63 
+	kX86InstCMovPE,
64 
+	kX86InstCMovPO,
65 
+	kX86InstCMovL,
66 
+	kX86InstCMovGE,
67 
+	kX86InstCMovLE,
68 
+	kX86InstCMovG,
69 
+
70 
+	kInstNone,
71 
+	kInstNone,
72 
+	kInstNone,
73 
+	kInstNone
73 74 
 };
74 75
75 76 
 // ============================================================================
76 77 
 // [AsmJit::_x86UtilSetccFromCond]
77 78 
 // ============================================================================
78 79
79 
-const uint32_t _x86UtilSetccFromCond[20] =
80 
+const uint32_t _x86UtilSetccFromCond[] =
80 81 
 {
81 
-  kX86InstSetO,
82 
-  kX86InstSetNO,
83 
-  kX86InstSetB,
84 
-  kX86InstSetAE,
85 
-  kX86InstSetE,
86 
-  kX86InstSetNE,
87 
-  kX86InstSetBE,
88 
-  kX86InstSetA,
89 
-  kX86InstSetS,
90 
-  kX86InstSetNS,
91 
-  kX86InstSetPE,
92 
-  kX86InstSetPO,
93 
-  kX86InstSetL,
94 
-  kX86InstSetGE,
95 
-  kX86InstSetLE,
96 
-  kX86InstSetG,
97 
-
98 
-  kInstNone,
99 
-  kInstNone,
100 
-  kInstNone,
101 
-  kInstNone
82 
+	kX86InstSetO,
83 
+	kX86InstSetNO,
84 
+	kX86InstSetB,
85 
+	kX86InstSetAE,
86 
+	kX86InstSetE,
87 
+	kX86InstSetNE,
88 
+	kX86InstSetBE,
89 
+	kX86InstSetA,
90 
+	kX86InstSetS,
91 
+	kX86InstSetNS,
92 
+	kX86InstSetPE,
93 
+	kX86InstSetPO,
94 
+	kX86InstSetL,
95 
+	kX86InstSetGE,
96 
+	kX86InstSetLE,
97 
+	kX86InstSetG,
98 
+
99 
+	kInstNone,
100 
+	kInstNone,
101 
+	kInstNone,
102 
+	kInstNone
102 103 
 };
103 104
104 105 
 // ============================================================================
105 106 
 // [AsmJit::_x86UtilReversedCond]
106 107 
 // ============================================================================
107 108
108 
-const uint32_t _x86UtilReversedCond[20] =
109 
+const uint32_t _x86UtilReversedCond[] =
109 110 
 {
110 
-  /* x86CondO  -> */ kX86CondO,
111 
-  /* x86CondNO -> */ kX86CondNO,
112 
-  /* x86CondB  -> */ kX86CondA,
113 
-  /* x86CondAE -> */ kX86CondBE,
114 
-  /* x86CondE  -> */ kX86CondE,
115 
-  /* x86CondNE -> */ kX86CondNE,
116 
-  /* x86CondBE -> */ kX86CondAE,
117 
-  /* x86CondA  -> */ kX86CondB,
118 
-  /* x86CondS  -> */ kX86CondS,
119 
-  /* x86CondNS -> */ kX86CondNS,
120 
-  /* x86CondPE -> */ kX86CondPE,
121 
-  /* x86CondPO -> */ kX86CondPO,
122 
-
123 
-  /* x86CondL  -> */ kX86CondG,
124 
-  /* x86CondGE -> */ kX86CondLE,
125 
-
126 
-  /* x86CondLE -> */ kX86CondGE,
127 
-  /* x86CondG  -> */ kX86CondL,
128 
-
129 
-  /* kX86CondFpuUnordered    -> */ kX86CondFpuUnordered,
130 
-  /* kX86CondFpuNotUnordered -> */ kX86CondFpuNotUnordered,
131 
-
132 
-  0x12,
133 
-  0x13
111 
+	/* x86CondO  -> */ kX86CondO,
112 
+	/* x86CondNO -> */ kX86CondNO,
113 
+	/* x86CondB  -> */ kX86CondA,
114 
+	/* x86CondAE -> */ kX86CondBE,
115 
+	/* x86CondE  -> */ kX86CondE,
116 
+	/* x86CondNE -> */ kX86CondNE,
117 
+	/* x86CondBE -> */ kX86CondAE,
118 
+	/* x86CondA  -> */ kX86CondB,
119 
+	/* x86CondS  -> */ kX86CondS,
120 
+	/* x86CondNS -> */ kX86CondNS,
121 
+	/* x86CondPE -> */ kX86CondPE,
122 
+	/* x86CondPO -> */ kX86CondPO,
123 
+
124 
+	/* x86CondL  -> */ kX86CondG,
125 
+	/* x86CondGE -> */ kX86CondLE,
126 
+
127 
+	/* x86CondLE -> */ kX86CondGE,
128 
+	/* x86CondG  -> */ kX86CondL,
129 
+
130 
+	/* kX86CondFpuUnordered    -> */ kX86CondFpuUnordered,
131 
+	/* kX86CondFpuNotUnordered -> */ kX86CondFpuNotUnordered,
132 
+
133 
+	0x12,
134 
+	0x13
134 135 
 };
135 136
136 137 
 } // AsmJit namespace
src/in_2sf/desmume/version.cpp
History View file @ d07af85
... ... 
@@ -40,8 +40,10 @@
40 40 
 # define DESMUME_PLATFORM_STRING " ARM"
41 41 
 #elif defined(__thumb__)
42 42 
 # define DESMUME_PLATFORM_STRING " ARM-Thumb"
43 
+#elif defined(__ppc64__)
44 
+# define DESMUME_PLATFORM_STRING " PPC64"
43 45 
 #elif defined(__ppc__) || defined(_M_PPC)
44 
-# define DESMUME_PLATFORM_STRING " PowerPC"
46 
+# define DESMUME_PLATFORM_STRING " PPC"
45 47 
 #else
46 48 
 # define DESMUME_PLATFORM_STRING ""
47 49 
 #endif
... ... 
@@ -56,7 +58,7 @@
56 58 
 # define DESMUME_CPUEXT_STRING ""
57 59 
 #endif
58 60
59 
-#define DESMUME_SUBVERSION_STRING " svn 4598"
61 
+#define DESMUME_SUBVERSION_STRING " svn 4605"
60 62
61 63 
 #ifdef __INTEL_COMPILER
62 64 
 # define DESMUME_COMPILER " (Intel)"