001 package org.jikesrvm.compilers.opt.mir2mc.ia32;
002
003 import org.jikesrvm.*;
004
005 import org.jikesrvm.compilers.opt.*;
006
007 import org.jikesrvm.compilers.opt.ir.*;
008
009
010
011 /**
012 * This class is the automatically-generated assembler for
013 * the optimizing compiler. It consists of methods that
014 * understand the possible operand combinations of each
015 * instruction type, and how to translate those operands to
016 * calls to the Assember low-level emit method
017 *
018 * It is generated by GenerateAssembler.java
019 *
020 */
021 public abstract class AssemblerOpt extends AssemblerBase {
022
023 /**
024 * @see org.jikesrvm.ArchitectureSpecific.Assembler
025 */
026 public AssemblerOpt(int bcSize, boolean print, IR ir) {
027 super(bcSize, print, ir);
028 }
029
030 /**
031 * Emit the given instruction, assuming that
032 * it is a MIR_BinaryAcc instruction
033 * and has a FIMUL operator
034 *
035 * @param inst the instruction to assemble
036 */
037 private void doFIMUL(Instruction inst) {
038 if (isWord(inst)) {
039 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
040 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
041 emitFIMUL_Reg_Abs_Word(
042 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
043 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
044
045 } else {
046 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
047 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
048 emitFIMUL_Reg_RegDisp_Word(
049 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
050 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
051
052 } else {
053 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
054 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
055 emitFIMUL_Reg_RegOff_Word(
056 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
057 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
058
059 } else {
060 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
061 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
062 emitFIMUL_Reg_RegIdx_Word(
063 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
064 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
065
066 } else {
067 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
068 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
069 emitFIMUL_Reg_RegInd_Word(
070 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
071 getBase(MIR_BinaryAcc.getValue(inst)));
072 }
073 }
074 }
075 }
076
077 } else {
078 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
079 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
080 emitFIMUL_Reg_Abs(
081 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
082 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
083
084 } else {
085 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
086 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
087 emitFIMUL_Reg_RegDisp(
088 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
089 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
090
091 } else {
092 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
093 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
094 emitFIMUL_Reg_RegOff(
095 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
096 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
097
098 } else {
099 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
100 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
101 emitFIMUL_Reg_RegIdx(
102 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
103 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
104
105 } else {
106 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
107 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
108 emitFIMUL_Reg_RegInd(
109 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
110 getBase(MIR_BinaryAcc.getValue(inst)));
111 }
112 }
113 }
114 }
115 }
116 }
117
118 /**
119 * Emit the given instruction, assuming that
120 * it is a MIR_Nullary instruction
121 * and has a METHODSTART operator
122 *
123 * @param inst the instruction to assemble
124 */
125 private void doMETHODSTART(Instruction inst) {
126 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Nullary.getResult(inst))) VM._assert(false, inst.toString());
127 emitMETHODSTART_Reg(
128 getGPR_Reg(MIR_Nullary.getResult(inst)));
129 }
130
131 /**
132 * Emit the given instruction, assuming that
133 * it is a MIR_Unary instruction
134 * and has a CVTSS2SD operator
135 *
136 * @param inst the instruction to assemble
137 */
138 private void doCVTSS2SD(Instruction inst) {
139 if (isXMM_Reg(MIR_Unary.getVal(inst))) {
140 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
141 emitCVTSS2SD_Reg_Reg(
142 getXMM_Reg(MIR_Unary.getResult(inst)),
143 getXMM_Reg(MIR_Unary.getVal(inst)));
144
145 } else {
146 if (isAbs(MIR_Unary.getVal(inst))) {
147 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
148 emitCVTSS2SD_Reg_Abs(
149 getXMM_Reg(MIR_Unary.getResult(inst)),
150 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
151
152 } else {
153 if (isRegDisp(MIR_Unary.getVal(inst))) {
154 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
155 emitCVTSS2SD_Reg_RegDisp(
156 getXMM_Reg(MIR_Unary.getResult(inst)),
157 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
158
159 } else {
160 if (isRegOff(MIR_Unary.getVal(inst))) {
161 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
162 emitCVTSS2SD_Reg_RegOff(
163 getXMM_Reg(MIR_Unary.getResult(inst)),
164 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
165
166 } else {
167 if (isRegIdx(MIR_Unary.getVal(inst))) {
168 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
169 emitCVTSS2SD_Reg_RegIdx(
170 getXMM_Reg(MIR_Unary.getResult(inst)),
171 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
172
173 } else {
174 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
175 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
176 emitCVTSS2SD_Reg_RegInd(
177 getXMM_Reg(MIR_Unary.getResult(inst)),
178 getBase(MIR_Unary.getVal(inst)));
179 }
180 }
181 }
182 }
183 }
184 }
185
186 /**
187 * Emit the given instruction, assuming that
188 * it is a MIR_BinaryAcc instruction
189 * and has a CMPUNORDSS operator
190 *
191 * @param inst the instruction to assemble
192 */
193 private void doCMPUNORDSS(Instruction inst) {
194 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
195 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
196 emitCMPUNORDSS_Reg_Reg(
197 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
198 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
199
200 } else {
201 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
202 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
203 emitCMPUNORDSS_Reg_Abs(
204 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
205 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
206
207 } else {
208 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
209 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
210 emitCMPUNORDSS_Reg_RegDisp(
211 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
212 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
213
214 } else {
215 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
216 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
217 emitCMPUNORDSS_Reg_RegOff(
218 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
219 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
220
221 } else {
222 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
223 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
224 emitCMPUNORDSS_Reg_RegIdx(
225 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
226 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
227
228 } else {
229 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
230 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
231 emitCMPUNORDSS_Reg_RegInd(
232 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
233 getBase(MIR_BinaryAcc.getValue(inst)));
234 }
235 }
236 }
237 }
238 }
239 }
240
241 /**
242 * Emit the given instruction, assuming that
243 * it is a MIR_BinaryAcc instruction
244 * and has a MULSS operator
245 *
246 * @param inst the instruction to assemble
247 */
248 private void doMULSS(Instruction inst) {
249 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
250 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
251 emitMULSS_Reg_Reg(
252 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
253 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
254
255 } else {
256 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
257 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
258 emitMULSS_Reg_Abs(
259 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
260 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
261
262 } else {
263 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
264 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
265 emitMULSS_Reg_RegDisp(
266 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
267 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
268
269 } else {
270 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
271 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
272 emitMULSS_Reg_RegOff(
273 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
274 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
275
276 } else {
277 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
278 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
279 emitMULSS_Reg_RegIdx(
280 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
281 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
282
283 } else {
284 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
285 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
286 emitMULSS_Reg_RegInd(
287 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
288 getBase(MIR_BinaryAcc.getValue(inst)));
289 }
290 }
291 }
292 }
293 }
294 }
295
296 /**
297 * Emit the given instruction, assuming that
298 * it is a MIR_Unary instruction
299 * and has a CVTSS2SI operator
300 *
301 * @param inst the instruction to assemble
302 */
303 private void doCVTSS2SI(Instruction inst) {
304 if (isQuad(inst)) {
305 if (isXMM_Reg(MIR_Unary.getVal(inst))) {
306 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
307 emitCVTSS2SI_Reg_Reg_Quad(
308 getGPR_Reg(MIR_Unary.getResult(inst)),
309 getXMM_Reg(MIR_Unary.getVal(inst)));
310
311 } else {
312 if (isAbs(MIR_Unary.getVal(inst))) {
313 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
314 emitCVTSS2SI_Reg_Abs_Quad(
315 getGPR_Reg(MIR_Unary.getResult(inst)),
316 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
317
318 } else {
319 if (isRegDisp(MIR_Unary.getVal(inst))) {
320 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
321 emitCVTSS2SI_Reg_RegDisp_Quad(
322 getGPR_Reg(MIR_Unary.getResult(inst)),
323 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
324
325 } else {
326 if (isRegOff(MIR_Unary.getVal(inst))) {
327 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
328 emitCVTSS2SI_Reg_RegOff_Quad(
329 getGPR_Reg(MIR_Unary.getResult(inst)),
330 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
331
332 } else {
333 if (isRegIdx(MIR_Unary.getVal(inst))) {
334 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
335 emitCVTSS2SI_Reg_RegIdx_Quad(
336 getGPR_Reg(MIR_Unary.getResult(inst)),
337 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
338
339 } else {
340 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
341 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
342 emitCVTSS2SI_Reg_RegInd_Quad(
343 getGPR_Reg(MIR_Unary.getResult(inst)),
344 getBase(MIR_Unary.getVal(inst)));
345 }
346 }
347 }
348 }
349 }
350
351 } else {
352 if (isXMM_Reg(MIR_Unary.getVal(inst))) {
353 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
354 emitCVTSS2SI_Reg_Reg(
355 getGPR_Reg(MIR_Unary.getResult(inst)),
356 getXMM_Reg(MIR_Unary.getVal(inst)));
357
358 } else {
359 if (isAbs(MIR_Unary.getVal(inst))) {
360 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
361 emitCVTSS2SI_Reg_Abs(
362 getGPR_Reg(MIR_Unary.getResult(inst)),
363 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
364
365 } else {
366 if (isRegDisp(MIR_Unary.getVal(inst))) {
367 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
368 emitCVTSS2SI_Reg_RegDisp(
369 getGPR_Reg(MIR_Unary.getResult(inst)),
370 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
371
372 } else {
373 if (isRegOff(MIR_Unary.getVal(inst))) {
374 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
375 emitCVTSS2SI_Reg_RegOff(
376 getGPR_Reg(MIR_Unary.getResult(inst)),
377 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
378
379 } else {
380 if (isRegIdx(MIR_Unary.getVal(inst))) {
381 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
382 emitCVTSS2SI_Reg_RegIdx(
383 getGPR_Reg(MIR_Unary.getResult(inst)),
384 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
385
386 } else {
387 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
388 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
389 emitCVTSS2SI_Reg_RegInd(
390 getGPR_Reg(MIR_Unary.getResult(inst)),
391 getBase(MIR_Unary.getVal(inst)));
392 }
393 }
394 }
395 }
396 }
397 }
398 }
399
400 /**
401 * Emit the given instruction, assuming that
402 * it is a MIR_Move instruction
403 * and has a FSTP operator
404 *
405 * @param inst the instruction to assemble
406 */
407 private void doFSTP(Instruction inst) {
408 if (isQuad(inst)) {
409 if (isAbs(MIR_Move.getResult(inst))) {
410 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
411 emitFSTP_Abs_Reg_Quad(
412 getDisp(MIR_Move.getResult(inst)).toWord().toAddress(),
413 getFPR_Reg(MIR_Move.getValue(inst)));
414
415 } else {
416 if (isRegDisp(MIR_Move.getResult(inst))) {
417 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
418 emitFSTP_RegDisp_Reg_Quad(
419 getBase(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
420 getFPR_Reg(MIR_Move.getValue(inst)));
421
422 } else {
423 if (isRegOff(MIR_Move.getResult(inst))) {
424 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
425 emitFSTP_RegOff_Reg_Quad(
426 getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
427 getFPR_Reg(MIR_Move.getValue(inst)));
428
429 } else {
430 if (isRegIdx(MIR_Move.getResult(inst))) {
431 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
432 emitFSTP_RegIdx_Reg_Quad(
433 getBase(MIR_Move.getResult(inst)), getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
434 getFPR_Reg(MIR_Move.getValue(inst)));
435
436 } else {
437 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
438 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
439 emitFSTP_RegInd_Reg_Quad(
440 getBase(MIR_Move.getResult(inst)),
441 getFPR_Reg(MIR_Move.getValue(inst)));
442 }
443 }
444 }
445 }
446
447 } else {
448 if (isFPR_Reg(MIR_Move.getResult(inst))) {
449 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
450 emitFSTP_Reg_Reg(
451 getFPR_Reg(MIR_Move.getResult(inst)),
452 getFPR_Reg(MIR_Move.getValue(inst)));
453
454 } else {
455 if (isAbs(MIR_Move.getResult(inst))) {
456 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
457 emitFSTP_Abs_Reg(
458 getDisp(MIR_Move.getResult(inst)).toWord().toAddress(),
459 getFPR_Reg(MIR_Move.getValue(inst)));
460
461 } else {
462 if (isRegDisp(MIR_Move.getResult(inst))) {
463 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
464 emitFSTP_RegDisp_Reg(
465 getBase(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
466 getFPR_Reg(MIR_Move.getValue(inst)));
467
468 } else {
469 if (isRegOff(MIR_Move.getResult(inst))) {
470 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
471 emitFSTP_RegOff_Reg(
472 getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
473 getFPR_Reg(MIR_Move.getValue(inst)));
474
475 } else {
476 if (isRegIdx(MIR_Move.getResult(inst))) {
477 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
478 emitFSTP_RegIdx_Reg(
479 getBase(MIR_Move.getResult(inst)), getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
480 getFPR_Reg(MIR_Move.getValue(inst)));
481
482 } else {
483 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
484 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
485 emitFSTP_RegInd_Reg(
486 getBase(MIR_Move.getResult(inst)),
487 getFPR_Reg(MIR_Move.getValue(inst)));
488 }
489 }
490 }
491 }
492 }
493 }
494 }
495
496 /**
497 * Emit the given instruction, assuming that
498 * it is a MIR_Unary instruction
499 * and has a CVTTSD2SIQ operator
500 *
501 * @param inst the instruction to assemble
502 */
503 private void doCVTTSD2SIQ(Instruction inst) {
504 if (isXMM_Reg(MIR_Unary.getVal(inst))) {
505 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
506 if (VM.VerifyAssertions && !isQuad(inst)) VM._assert(false, inst.toString());
507 emitCVTTSD2SIQ_Reg_Reg_Quad(
508 getGPR_Reg(MIR_Unary.getResult(inst)),
509 getXMM_Reg(MIR_Unary.getVal(inst)));
510
511 } else {
512 if (isAbs(MIR_Unary.getVal(inst))) {
513 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
514 if (VM.VerifyAssertions && !isQuad(inst)) VM._assert(false, inst.toString());
515 emitCVTTSD2SIQ_Reg_Abs_Quad(
516 getGPR_Reg(MIR_Unary.getResult(inst)),
517 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
518
519 } else {
520 if (isRegDisp(MIR_Unary.getVal(inst))) {
521 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
522 if (VM.VerifyAssertions && !isQuad(inst)) VM._assert(false, inst.toString());
523 emitCVTTSD2SIQ_Reg_RegDisp_Quad(
524 getGPR_Reg(MIR_Unary.getResult(inst)),
525 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
526
527 } else {
528 if (isRegOff(MIR_Unary.getVal(inst))) {
529 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
530 if (VM.VerifyAssertions && !isQuad(inst)) VM._assert(false, inst.toString());
531 emitCVTTSD2SIQ_Reg_RegOff_Quad(
532 getGPR_Reg(MIR_Unary.getResult(inst)),
533 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
534
535 } else {
536 if (isRegIdx(MIR_Unary.getVal(inst))) {
537 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
538 if (VM.VerifyAssertions && !isQuad(inst)) VM._assert(false, inst.toString());
539 emitCVTTSD2SIQ_Reg_RegIdx_Quad(
540 getGPR_Reg(MIR_Unary.getResult(inst)),
541 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
542
543 } else {
544 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
545 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
546 if (VM.VerifyAssertions && !isQuad(inst)) VM._assert(false, inst.toString());
547 emitCVTTSD2SIQ_Reg_RegInd_Quad(
548 getGPR_Reg(MIR_Unary.getResult(inst)),
549 getBase(MIR_Unary.getVal(inst)));
550 }
551 }
552 }
553 }
554 }
555 }
556
557 /**
558 * Emit the given instruction, assuming that
559 * it is a MIR_ConvertDW2QW instruction
560 * and has a CDO operator
561 *
562 * @param inst the instruction to assemble
563 */
564 private void doCDO(Instruction inst) {
565 emitCDO();
566 }
567
568 /**
569 * Emit the given instruction, assuming that
570 * it is a MIR_BinaryAcc instruction
571 * and has a CMPLTSS operator
572 *
573 * @param inst the instruction to assemble
574 */
575 private void doCMPLTSS(Instruction inst) {
576 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
577 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
578 emitCMPLTSS_Reg_Reg(
579 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
580 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
581
582 } else {
583 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
584 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
585 emitCMPLTSS_Reg_Abs(
586 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
587 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
588
589 } else {
590 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
591 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
592 emitCMPLTSS_Reg_RegDisp(
593 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
594 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
595
596 } else {
597 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
598 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
599 emitCMPLTSS_Reg_RegOff(
600 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
601 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
602
603 } else {
604 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
605 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
606 emitCMPLTSS_Reg_RegIdx(
607 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
608 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
609
610 } else {
611 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
612 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
613 emitCMPLTSS_Reg_RegInd(
614 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
615 getBase(MIR_BinaryAcc.getValue(inst)));
616 }
617 }
618 }
619 }
620 }
621 }
622
623 /**
624 * Emit the given instruction, assuming that
625 * it is a MIR_ConvertDW2QW instruction
626 * and has a CDQ operator
627 *
628 * @param inst the instruction to assemble
629 */
630 private void doCDQ(Instruction inst) {
631 emitCDQ();
632 }
633
634 /**
635 * Emit the given instruction, assuming that
636 * it is a MIR_BinaryAcc instruction
637 * and has a ORPD operator
638 *
639 * @param inst the instruction to assemble
640 */
641 private void doORPD(Instruction inst) {
642 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
643 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
644 emitORPD_Reg_Reg(
645 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
646 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
647
648 } else {
649 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
650 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
651 emitORPD_Reg_Abs(
652 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
653 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
654
655 } else {
656 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
657 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
658 emitORPD_Reg_RegDisp(
659 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
660 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
661
662 } else {
663 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
664 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
665 emitORPD_Reg_RegOff(
666 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
667 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
668
669 } else {
670 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
671 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
672 emitORPD_Reg_RegIdx(
673 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
674 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
675
676 } else {
677 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
678 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
679 emitORPD_Reg_RegInd(
680 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
681 getBase(MIR_BinaryAcc.getValue(inst)));
682 }
683 }
684 }
685 }
686 }
687 }
688
689 /**
690 * Emit the given instruction, assuming that
691 * it is a MIR_CondMove instruction
692 * and has a FCMOV operator
693 *
694 * @param inst the instruction to assemble
695 */
696 private void doFCMOV(Instruction inst) {
697 if (VM.VerifyAssertions && !isCond(MIR_CondMove.getCond(inst))) VM._assert(false, inst.toString());
698 if (VM.VerifyAssertions && !isFPR_Reg(MIR_CondMove.getResult(inst))) VM._assert(false, inst.toString());
699 if (VM.VerifyAssertions && !isFPR_Reg(MIR_CondMove.getValue(inst))) VM._assert(false, inst.toString());
700 emitFCMOV_Cond_Reg_Reg(
701 getCond(MIR_CondMove.getCond(inst)),
702 getFPR_Reg(MIR_CondMove.getResult(inst)),
703 getFPR_Reg(MIR_CondMove.getValue(inst)));
704 }
705
706 /**
707 * Emit the given instruction, assuming that
708 * it is a MIR_Unary instruction
709 * and has a MOVSXQ operator
710 *
711 * @param inst the instruction to assemble
712 */
713 private void doMOVSXQ(Instruction inst) {
714 if (isByte(inst)) {
715 if (isGPR_Reg(MIR_Unary.getVal(inst))) {
716 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
717 emitMOVSXQ_Reg_Reg_Byte(
718 getGPR_Reg(MIR_Unary.getResult(inst)),
719 getGPR_Reg(MIR_Unary.getVal(inst)));
720
721 } else {
722 if (isAbs(MIR_Unary.getVal(inst))) {
723 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
724 emitMOVSXQ_Reg_Abs_Byte(
725 getGPR_Reg(MIR_Unary.getResult(inst)),
726 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
727
728 } else {
729 if (isRegDisp(MIR_Unary.getVal(inst))) {
730 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
731 emitMOVSXQ_Reg_RegDisp_Byte(
732 getGPR_Reg(MIR_Unary.getResult(inst)),
733 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
734
735 } else {
736 if (isRegOff(MIR_Unary.getVal(inst))) {
737 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
738 emitMOVSXQ_Reg_RegOff_Byte(
739 getGPR_Reg(MIR_Unary.getResult(inst)),
740 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
741
742 } else {
743 if (isRegIdx(MIR_Unary.getVal(inst))) {
744 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
745 emitMOVSXQ_Reg_RegIdx_Byte(
746 getGPR_Reg(MIR_Unary.getResult(inst)),
747 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
748
749 } else {
750 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
751 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
752 emitMOVSXQ_Reg_RegInd_Byte(
753 getGPR_Reg(MIR_Unary.getResult(inst)),
754 getBase(MIR_Unary.getVal(inst)));
755 }
756 }
757 }
758 }
759 }
760
761 } else {
762 if (isGPR_Reg(MIR_Unary.getVal(inst))) {
763 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
764 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
765 emitMOVSXQ_Reg_Reg_Word(
766 getGPR_Reg(MIR_Unary.getResult(inst)),
767 getGPR_Reg(MIR_Unary.getVal(inst)));
768
769 } else {
770 if (isAbs(MIR_Unary.getVal(inst))) {
771 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
772 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
773 emitMOVSXQ_Reg_Abs_Word(
774 getGPR_Reg(MIR_Unary.getResult(inst)),
775 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
776
777 } else {
778 if (isRegDisp(MIR_Unary.getVal(inst))) {
779 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
780 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
781 emitMOVSXQ_Reg_RegDisp_Word(
782 getGPR_Reg(MIR_Unary.getResult(inst)),
783 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
784
785 } else {
786 if (isRegOff(MIR_Unary.getVal(inst))) {
787 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
788 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
789 emitMOVSXQ_Reg_RegOff_Word(
790 getGPR_Reg(MIR_Unary.getResult(inst)),
791 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
792
793 } else {
794 if (isRegIdx(MIR_Unary.getVal(inst))) {
795 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
796 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
797 emitMOVSXQ_Reg_RegIdx_Word(
798 getGPR_Reg(MIR_Unary.getResult(inst)),
799 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
800
801 } else {
802 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
803 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
804 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
805 emitMOVSXQ_Reg_RegInd_Word(
806 getGPR_Reg(MIR_Unary.getResult(inst)),
807 getBase(MIR_Unary.getVal(inst)));
808 }
809 }
810 }
811 }
812 }
813 }
814 }
815
816 /**
817 * Emit the given instruction, assuming that
818 * it is a MIR_Nullary instruction
819 * and has a FLDLG2 operator
820 *
821 * @param inst the instruction to assemble
822 */
823 private void doFLDLG2(Instruction inst) {
824 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Nullary.getResult(inst))) VM._assert(false, inst.toString());
825 emitFLDLG2_Reg(
826 getFPR_Reg(MIR_Nullary.getResult(inst)));
827 }
828
829 /**
830 * Emit the given instruction, assuming that
831 * it is a MIR_BinaryAcc instruction
832 * and has a FSUB operator
833 *
834 * @param inst the instruction to assemble
835 */
836 private void doFSUB(Instruction inst) {
837 if (isQuad(inst)) {
838 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
839 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
840 emitFSUB_Reg_Abs_Quad(
841 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
842 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
843
844 } else {
845 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
846 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
847 emitFSUB_Reg_RegDisp_Quad(
848 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
849 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
850
851 } else {
852 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
853 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
854 emitFSUB_Reg_RegOff_Quad(
855 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
856 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
857
858 } else {
859 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
860 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
861 emitFSUB_Reg_RegIdx_Quad(
862 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
863 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
864
865 } else {
866 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
867 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
868 emitFSUB_Reg_RegInd_Quad(
869 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
870 getBase(MIR_BinaryAcc.getValue(inst)));
871 }
872 }
873 }
874 }
875
876 } else {
877 if (isFPR_Reg(MIR_BinaryAcc.getValue(inst))) {
878 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
879 emitFSUB_Reg_Reg(
880 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
881 getFPR_Reg(MIR_BinaryAcc.getValue(inst)));
882
883 } else {
884 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
885 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
886 emitFSUB_Reg_Abs(
887 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
888 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
889
890 } else {
891 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
892 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
893 emitFSUB_Reg_RegDisp(
894 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
895 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
896
897 } else {
898 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
899 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
900 emitFSUB_Reg_RegOff(
901 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
902 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
903
904 } else {
905 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
906 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
907 emitFSUB_Reg_RegIdx(
908 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
909 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
910
911 } else {
912 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
913 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
914 emitFSUB_Reg_RegInd(
915 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
916 getBase(MIR_BinaryAcc.getValue(inst)));
917 }
918 }
919 }
920 }
921 }
922 }
923 }
924
925 /**
926 * Emit the given instruction, assuming that
927 * it is a MIR_UnaryNoRes instruction
928 * and has a PUSH operator
929 *
930 * @param inst the instruction to assemble
931 */
932 private void doPUSH(Instruction inst) {
933 if (isImm(MIR_UnaryNoRes.getVal(inst))) {
934 emitPUSH_Imm(
935 getImm(MIR_UnaryNoRes.getVal(inst)));
936
937 } else {
938 if (isGPR_Reg(MIR_UnaryNoRes.getVal(inst))) {
939 emitPUSH_Reg(
940 getGPR_Reg(MIR_UnaryNoRes.getVal(inst)));
941
942 } else {
943 if (isAbs(MIR_UnaryNoRes.getVal(inst))) {
944 emitPUSH_Abs(
945 getDisp(MIR_UnaryNoRes.getVal(inst)).toWord().toAddress());
946
947 } else {
948 if (isRegDisp(MIR_UnaryNoRes.getVal(inst))) {
949 emitPUSH_RegDisp(
950 getBase(MIR_UnaryNoRes.getVal(inst)), getDisp(MIR_UnaryNoRes.getVal(inst)));
951
952 } else {
953 if (isRegOff(MIR_UnaryNoRes.getVal(inst))) {
954 emitPUSH_RegOff(
955 getIndex(MIR_UnaryNoRes.getVal(inst)), getScale(MIR_UnaryNoRes.getVal(inst)), getDisp(MIR_UnaryNoRes.getVal(inst)));
956
957 } else {
958 if (isRegIdx(MIR_UnaryNoRes.getVal(inst))) {
959 emitPUSH_RegIdx(
960 getBase(MIR_UnaryNoRes.getVal(inst)), getIndex(MIR_UnaryNoRes.getVal(inst)), getScale(MIR_UnaryNoRes.getVal(inst)), getDisp(MIR_UnaryNoRes.getVal(inst)));
961
962 } else {
963 if (VM.VerifyAssertions && !isRegInd(MIR_UnaryNoRes.getVal(inst))) VM._assert(false, inst.toString());
964 emitPUSH_RegInd(
965 getBase(MIR_UnaryNoRes.getVal(inst)));
966 }
967 }
968 }
969 }
970 }
971 }
972 }
973
974 /**
975 * Emit the given instruction, assuming that
976 * it is a MIR_BinaryAcc instruction
977 * and has a SUB operator
978 *
979 * @param inst the instruction to assemble
980 */
981 private void doSUB(Instruction inst) {
982 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
983 if (isByte(inst)) {
984 if (isImm(MIR_BinaryAcc.getValue(inst))) {
985 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
986 emitSUB_Reg_Imm_Byte(
987 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
988 getImm(MIR_BinaryAcc.getValue(inst)));
989
990 } else {
991 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
992 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
993 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
994 emitSUB_Reg_Reg_Byte(
995 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
996 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
997
998 } else {
999 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
1000 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
1001 emitSUB_Reg_Abs_Byte(
1002 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1003 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
1004
1005 } else {
1006 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
1007 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
1008 emitSUB_Reg_RegDisp_Byte(
1009 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1010 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1011
1012 } else {
1013 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
1014 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
1015 emitSUB_Reg_RegOff_Byte(
1016 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1017 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1018
1019 } else {
1020 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
1021 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
1022 emitSUB_Reg_RegIdx_Byte(
1023 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1024 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1025
1026 } else {
1027 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1028 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
1029 emitSUB_Reg_RegInd_Byte(
1030 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1031 getBase(MIR_BinaryAcc.getValue(inst)));
1032 }
1033 }
1034 }
1035 }
1036 }
1037 }
1038
1039 } else {
1040 if (isWord(inst)) {
1041 if (isImm(MIR_BinaryAcc.getValue(inst))) {
1042 emitSUB_Reg_Imm_Word(
1043 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1044 getImm(MIR_BinaryAcc.getValue(inst)));
1045
1046 } else {
1047 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
1048 emitSUB_Reg_Reg_Word(
1049 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1050 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1051
1052 } else {
1053 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
1054 emitSUB_Reg_Abs_Word(
1055 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1056 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
1057
1058 } else {
1059 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
1060 emitSUB_Reg_RegDisp_Word(
1061 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1062 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1063
1064 } else {
1065 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
1066 emitSUB_Reg_RegOff_Word(
1067 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1068 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1069
1070 } else {
1071 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
1072 emitSUB_Reg_RegIdx_Word(
1073 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1074 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1075
1076 } else {
1077 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1078 emitSUB_Reg_RegInd_Word(
1079 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1080 getBase(MIR_BinaryAcc.getValue(inst)));
1081 }
1082 }
1083 }
1084 }
1085 }
1086 }
1087
1088 } else {
1089 if (isQuad(inst)) {
1090 if (isImm(MIR_BinaryAcc.getValue(inst))) {
1091 emitSUB_Reg_Imm_Quad(
1092 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1093 getImm(MIR_BinaryAcc.getValue(inst)));
1094
1095 } else {
1096 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
1097 emitSUB_Reg_Reg_Quad(
1098 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1099 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1100
1101 } else {
1102 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
1103 emitSUB_Reg_Abs_Quad(
1104 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1105 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
1106
1107 } else {
1108 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
1109 emitSUB_Reg_RegDisp_Quad(
1110 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1111 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1112
1113 } else {
1114 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
1115 emitSUB_Reg_RegOff_Quad(
1116 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1117 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1118
1119 } else {
1120 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
1121 emitSUB_Reg_RegIdx_Quad(
1122 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1123 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1124
1125 } else {
1126 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1127 emitSUB_Reg_RegInd_Quad(
1128 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1129 getBase(MIR_BinaryAcc.getValue(inst)));
1130 }
1131 }
1132 }
1133 }
1134 }
1135 }
1136
1137 } else {
1138 if (isImm(MIR_BinaryAcc.getValue(inst))) {
1139 emitSUB_Reg_Imm(
1140 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1141 getImm(MIR_BinaryAcc.getValue(inst)));
1142
1143 } else {
1144 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
1145 emitSUB_Reg_Reg(
1146 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1147 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1148
1149 } else {
1150 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
1151 emitSUB_Reg_Abs(
1152 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1153 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
1154
1155 } else {
1156 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
1157 emitSUB_Reg_RegDisp(
1158 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1159 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1160
1161 } else {
1162 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
1163 emitSUB_Reg_RegOff(
1164 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1165 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1166
1167 } else {
1168 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
1169 emitSUB_Reg_RegIdx(
1170 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1171 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1172
1173 } else {
1174 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1175 emitSUB_Reg_RegInd(
1176 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
1177 getBase(MIR_BinaryAcc.getValue(inst)));
1178 }
1179 }
1180 }
1181 }
1182 }
1183 }
1184 }
1185 }
1186 }
1187
1188 } else {
1189 if (isImm(MIR_BinaryAcc.getValue(inst))) {
1190 if (isByte(inst)) {
1191 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1192 emitSUB_Abs_Imm_Byte(
1193 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1194 getImm(MIR_BinaryAcc.getValue(inst)));
1195
1196 } else {
1197 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1198 emitSUB_RegDisp_Imm_Byte(
1199 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1200 getImm(MIR_BinaryAcc.getValue(inst)));
1201
1202 } else {
1203 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1204 emitSUB_RegOff_Imm_Byte(
1205 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1206 getImm(MIR_BinaryAcc.getValue(inst)));
1207
1208 } else {
1209 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1210 emitSUB_RegIdx_Imm_Byte(
1211 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1212 getImm(MIR_BinaryAcc.getValue(inst)));
1213
1214 } else {
1215 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1216 emitSUB_RegInd_Imm_Byte(
1217 getBase(MIR_BinaryAcc.getResult(inst)),
1218 getImm(MIR_BinaryAcc.getValue(inst)));
1219 }
1220 }
1221 }
1222 }
1223
1224 } else {
1225 if (isWord(inst)) {
1226 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1227 emitSUB_Abs_Imm_Word(
1228 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1229 getImm(MIR_BinaryAcc.getValue(inst)));
1230
1231 } else {
1232 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1233 emitSUB_RegDisp_Imm_Word(
1234 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1235 getImm(MIR_BinaryAcc.getValue(inst)));
1236
1237 } else {
1238 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1239 emitSUB_RegOff_Imm_Word(
1240 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1241 getImm(MIR_BinaryAcc.getValue(inst)));
1242
1243 } else {
1244 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1245 emitSUB_RegIdx_Imm_Word(
1246 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1247 getImm(MIR_BinaryAcc.getValue(inst)));
1248
1249 } else {
1250 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1251 emitSUB_RegInd_Imm_Word(
1252 getBase(MIR_BinaryAcc.getResult(inst)),
1253 getImm(MIR_BinaryAcc.getValue(inst)));
1254 }
1255 }
1256 }
1257 }
1258
1259 } else {
1260 if (isQuad(inst)) {
1261 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1262 emitSUB_Abs_Imm_Quad(
1263 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1264 getImm(MIR_BinaryAcc.getValue(inst)));
1265
1266 } else {
1267 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1268 emitSUB_RegDisp_Imm_Quad(
1269 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1270 getImm(MIR_BinaryAcc.getValue(inst)));
1271
1272 } else {
1273 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1274 emitSUB_RegOff_Imm_Quad(
1275 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1276 getImm(MIR_BinaryAcc.getValue(inst)));
1277
1278 } else {
1279 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1280 emitSUB_RegIdx_Imm_Quad(
1281 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1282 getImm(MIR_BinaryAcc.getValue(inst)));
1283
1284 } else {
1285 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1286 emitSUB_RegInd_Imm_Quad(
1287 getBase(MIR_BinaryAcc.getResult(inst)),
1288 getImm(MIR_BinaryAcc.getValue(inst)));
1289 }
1290 }
1291 }
1292 }
1293
1294 } else {
1295 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1296 emitSUB_Abs_Imm(
1297 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1298 getImm(MIR_BinaryAcc.getValue(inst)));
1299
1300 } else {
1301 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1302 emitSUB_RegDisp_Imm(
1303 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1304 getImm(MIR_BinaryAcc.getValue(inst)));
1305
1306 } else {
1307 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1308 emitSUB_RegOff_Imm(
1309 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1310 getImm(MIR_BinaryAcc.getValue(inst)));
1311
1312 } else {
1313 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1314 emitSUB_RegIdx_Imm(
1315 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1316 getImm(MIR_BinaryAcc.getValue(inst)));
1317
1318 } else {
1319 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1320 emitSUB_RegInd_Imm(
1321 getBase(MIR_BinaryAcc.getResult(inst)),
1322 getImm(MIR_BinaryAcc.getValue(inst)));
1323 }
1324 }
1325 }
1326 }
1327 }
1328 }
1329 }
1330
1331 } else {
1332 if (isByte(inst)) {
1333 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1334 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1335 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
1336 emitSUB_Abs_Reg_Byte(
1337 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1338 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1339
1340 } else {
1341 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1342 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1343 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
1344 emitSUB_RegDisp_Reg_Byte(
1345 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1346 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1347
1348 } else {
1349 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1350 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1351 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
1352 emitSUB_RegOff_Reg_Byte(
1353 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1354 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1355
1356 } else {
1357 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1358 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1359 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
1360 emitSUB_RegIdx_Reg_Byte(
1361 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1362 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1363
1364 } else {
1365 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1366 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1367 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
1368 emitSUB_RegInd_Reg_Byte(
1369 getBase(MIR_BinaryAcc.getResult(inst)),
1370 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1371 }
1372 }
1373 }
1374 }
1375
1376 } else {
1377 if (isWord(inst)) {
1378 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1379 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1380 emitSUB_Abs_Reg_Word(
1381 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1382 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1383
1384 } else {
1385 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1386 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1387 emitSUB_RegDisp_Reg_Word(
1388 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1389 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1390
1391 } else {
1392 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1393 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1394 emitSUB_RegOff_Reg_Word(
1395 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1396 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1397
1398 } else {
1399 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1400 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1401 emitSUB_RegIdx_Reg_Word(
1402 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1403 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1404
1405 } else {
1406 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1407 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1408 emitSUB_RegInd_Reg_Word(
1409 getBase(MIR_BinaryAcc.getResult(inst)),
1410 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1411 }
1412 }
1413 }
1414 }
1415
1416 } else {
1417 if (isQuad(inst)) {
1418 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1419 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1420 emitSUB_Abs_Reg_Quad(
1421 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1422 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1423
1424 } else {
1425 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1426 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1427 emitSUB_RegDisp_Reg_Quad(
1428 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1429 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1430
1431 } else {
1432 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1433 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1434 emitSUB_RegOff_Reg_Quad(
1435 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1436 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1437
1438 } else {
1439 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1440 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1441 emitSUB_RegIdx_Reg_Quad(
1442 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1443 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1444
1445 } else {
1446 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1447 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1448 emitSUB_RegInd_Reg_Quad(
1449 getBase(MIR_BinaryAcc.getResult(inst)),
1450 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1451 }
1452 }
1453 }
1454 }
1455
1456 } else {
1457 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
1458 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1459 emitSUB_Abs_Reg(
1460 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
1461 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1462
1463 } else {
1464 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
1465 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1466 emitSUB_RegDisp_Reg(
1467 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1468 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1469
1470 } else {
1471 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
1472 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1473 emitSUB_RegOff_Reg(
1474 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1475 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1476
1477 } else {
1478 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
1479 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1480 emitSUB_RegIdx_Reg(
1481 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
1482 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1483
1484 } else {
1485 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1486 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1487 emitSUB_RegInd_Reg(
1488 getBase(MIR_BinaryAcc.getResult(inst)),
1489 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
1490 }
1491 }
1492 }
1493 }
1494 }
1495 }
1496 }
1497 }
1498 }
1499 }
1500
1501 /**
1502 * Emit the given instruction, assuming that
1503 * it is a MIR_BinaryAcc instruction
1504 * and has a CMPEQSD operator
1505 *
1506 * @param inst the instruction to assemble
1507 */
1508 private void doCMPEQSD(Instruction inst) {
1509 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
1510 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1511 emitCMPEQSD_Reg_Reg(
1512 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1513 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
1514
1515 } else {
1516 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
1517 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1518 emitCMPEQSD_Reg_Abs(
1519 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1520 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
1521
1522 } else {
1523 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
1524 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1525 emitCMPEQSD_Reg_RegDisp(
1526 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1527 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1528
1529 } else {
1530 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
1531 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1532 emitCMPEQSD_Reg_RegOff(
1533 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1534 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1535
1536 } else {
1537 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
1538 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1539 emitCMPEQSD_Reg_RegIdx(
1540 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1541 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1542
1543 } else {
1544 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1545 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1546 emitCMPEQSD_Reg_RegInd(
1547 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1548 getBase(MIR_BinaryAcc.getValue(inst)));
1549 }
1550 }
1551 }
1552 }
1553 }
1554 }
1555
1556 /**
1557 * Emit the given instruction, assuming that
1558 * it is a MIR_BinaryAcc instruction
1559 * and has a ORPS operator
1560 *
1561 * @param inst the instruction to assemble
1562 */
1563 private void doORPS(Instruction inst) {
1564 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
1565 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1566 emitORPS_Reg_Reg(
1567 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1568 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
1569
1570 } else {
1571 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
1572 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1573 emitORPS_Reg_Abs(
1574 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1575 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
1576
1577 } else {
1578 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
1579 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1580 emitORPS_Reg_RegDisp(
1581 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1582 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1583
1584 } else {
1585 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
1586 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1587 emitORPS_Reg_RegOff(
1588 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1589 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1590
1591 } else {
1592 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
1593 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1594 emitORPS_Reg_RegIdx(
1595 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1596 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
1597
1598 } else {
1599 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
1600 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
1601 emitORPS_Reg_RegInd(
1602 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
1603 getBase(MIR_BinaryAcc.getValue(inst)));
1604 }
1605 }
1606 }
1607 }
1608 }
1609 }
1610
1611 /**
1612 * Emit the given instruction, assuming that
1613 * it is a MIR_Compare instruction
1614 * and has a CMP operator
1615 *
1616 * @param inst the instruction to assemble
1617 */
1618 private void doCMP(Instruction inst) {
1619 if (isGPR_Reg(MIR_Compare.getVal1(inst))) {
1620 if (isByte(inst)) {
1621 if (isImm(MIR_Compare.getVal2(inst))) {
1622 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1623 emitCMP_Reg_Imm_Byte(
1624 getGPR_Reg(MIR_Compare.getVal1(inst)),
1625 getImm(MIR_Compare.getVal2(inst)));
1626
1627 } else {
1628 if (isGPR_Reg(MIR_Compare.getVal2(inst))) {
1629 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1630 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal2(inst)).value() < 4)) VM._assert(false, inst.toString());
1631 emitCMP_Reg_Reg_Byte(
1632 getGPR_Reg(MIR_Compare.getVal1(inst)),
1633 getGPR_Reg(MIR_Compare.getVal2(inst)));
1634
1635 } else {
1636 if (isAbs(MIR_Compare.getVal2(inst))) {
1637 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1638 emitCMP_Reg_Abs_Byte(
1639 getGPR_Reg(MIR_Compare.getVal1(inst)),
1640 getDisp(MIR_Compare.getVal2(inst)).toWord().toAddress());
1641
1642 } else {
1643 if (isRegDisp(MIR_Compare.getVal2(inst))) {
1644 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1645 emitCMP_Reg_RegDisp_Byte(
1646 getGPR_Reg(MIR_Compare.getVal1(inst)),
1647 getBase(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1648
1649 } else {
1650 if (isRegOff(MIR_Compare.getVal2(inst))) {
1651 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1652 emitCMP_Reg_RegOff_Byte(
1653 getGPR_Reg(MIR_Compare.getVal1(inst)),
1654 getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1655
1656 } else {
1657 if (isRegIdx(MIR_Compare.getVal2(inst))) {
1658 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1659 emitCMP_Reg_RegIdx_Byte(
1660 getGPR_Reg(MIR_Compare.getVal1(inst)),
1661 getBase(MIR_Compare.getVal2(inst)), getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1662
1663 } else {
1664 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1665 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal1(inst)).value() < 4)) VM._assert(false, inst.toString());
1666 emitCMP_Reg_RegInd_Byte(
1667 getGPR_Reg(MIR_Compare.getVal1(inst)),
1668 getBase(MIR_Compare.getVal2(inst)));
1669 }
1670 }
1671 }
1672 }
1673 }
1674 }
1675
1676 } else {
1677 if (isWord(inst)) {
1678 if (isImm(MIR_Compare.getVal2(inst))) {
1679 emitCMP_Reg_Imm_Word(
1680 getGPR_Reg(MIR_Compare.getVal1(inst)),
1681 getImm(MIR_Compare.getVal2(inst)));
1682
1683 } else {
1684 if (isGPR_Reg(MIR_Compare.getVal2(inst))) {
1685 emitCMP_Reg_Reg_Word(
1686 getGPR_Reg(MIR_Compare.getVal1(inst)),
1687 getGPR_Reg(MIR_Compare.getVal2(inst)));
1688
1689 } else {
1690 if (isAbs(MIR_Compare.getVal2(inst))) {
1691 emitCMP_Reg_Abs_Word(
1692 getGPR_Reg(MIR_Compare.getVal1(inst)),
1693 getDisp(MIR_Compare.getVal2(inst)).toWord().toAddress());
1694
1695 } else {
1696 if (isRegDisp(MIR_Compare.getVal2(inst))) {
1697 emitCMP_Reg_RegDisp_Word(
1698 getGPR_Reg(MIR_Compare.getVal1(inst)),
1699 getBase(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1700
1701 } else {
1702 if (isRegOff(MIR_Compare.getVal2(inst))) {
1703 emitCMP_Reg_RegOff_Word(
1704 getGPR_Reg(MIR_Compare.getVal1(inst)),
1705 getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1706
1707 } else {
1708 if (isRegIdx(MIR_Compare.getVal2(inst))) {
1709 emitCMP_Reg_RegIdx_Word(
1710 getGPR_Reg(MIR_Compare.getVal1(inst)),
1711 getBase(MIR_Compare.getVal2(inst)), getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1712
1713 } else {
1714 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1715 emitCMP_Reg_RegInd_Word(
1716 getGPR_Reg(MIR_Compare.getVal1(inst)),
1717 getBase(MIR_Compare.getVal2(inst)));
1718 }
1719 }
1720 }
1721 }
1722 }
1723 }
1724
1725 } else {
1726 if (isQuad(inst)) {
1727 if (isImm(MIR_Compare.getVal2(inst))) {
1728 emitCMP_Reg_Imm_Quad(
1729 getGPR_Reg(MIR_Compare.getVal1(inst)),
1730 getImm(MIR_Compare.getVal2(inst)));
1731
1732 } else {
1733 if (isGPR_Reg(MIR_Compare.getVal2(inst))) {
1734 emitCMP_Reg_Reg_Quad(
1735 getGPR_Reg(MIR_Compare.getVal1(inst)),
1736 getGPR_Reg(MIR_Compare.getVal2(inst)));
1737
1738 } else {
1739 if (isAbs(MIR_Compare.getVal2(inst))) {
1740 emitCMP_Reg_Abs_Quad(
1741 getGPR_Reg(MIR_Compare.getVal1(inst)),
1742 getDisp(MIR_Compare.getVal2(inst)).toWord().toAddress());
1743
1744 } else {
1745 if (isRegDisp(MIR_Compare.getVal2(inst))) {
1746 emitCMP_Reg_RegDisp_Quad(
1747 getGPR_Reg(MIR_Compare.getVal1(inst)),
1748 getBase(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1749
1750 } else {
1751 if (isRegOff(MIR_Compare.getVal2(inst))) {
1752 emitCMP_Reg_RegOff_Quad(
1753 getGPR_Reg(MIR_Compare.getVal1(inst)),
1754 getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1755
1756 } else {
1757 if (isRegIdx(MIR_Compare.getVal2(inst))) {
1758 emitCMP_Reg_RegIdx_Quad(
1759 getGPR_Reg(MIR_Compare.getVal1(inst)),
1760 getBase(MIR_Compare.getVal2(inst)), getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1761
1762 } else {
1763 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1764 emitCMP_Reg_RegInd_Quad(
1765 getGPR_Reg(MIR_Compare.getVal1(inst)),
1766 getBase(MIR_Compare.getVal2(inst)));
1767 }
1768 }
1769 }
1770 }
1771 }
1772 }
1773
1774 } else {
1775 if (isImm(MIR_Compare.getVal2(inst))) {
1776 emitCMP_Reg_Imm(
1777 getGPR_Reg(MIR_Compare.getVal1(inst)),
1778 getImm(MIR_Compare.getVal2(inst)));
1779
1780 } else {
1781 if (isGPR_Reg(MIR_Compare.getVal2(inst))) {
1782 emitCMP_Reg_Reg(
1783 getGPR_Reg(MIR_Compare.getVal1(inst)),
1784 getGPR_Reg(MIR_Compare.getVal2(inst)));
1785
1786 } else {
1787 if (isAbs(MIR_Compare.getVal2(inst))) {
1788 emitCMP_Reg_Abs(
1789 getGPR_Reg(MIR_Compare.getVal1(inst)),
1790 getDisp(MIR_Compare.getVal2(inst)).toWord().toAddress());
1791
1792 } else {
1793 if (isRegDisp(MIR_Compare.getVal2(inst))) {
1794 emitCMP_Reg_RegDisp(
1795 getGPR_Reg(MIR_Compare.getVal1(inst)),
1796 getBase(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1797
1798 } else {
1799 if (isRegOff(MIR_Compare.getVal2(inst))) {
1800 emitCMP_Reg_RegOff(
1801 getGPR_Reg(MIR_Compare.getVal1(inst)),
1802 getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1803
1804 } else {
1805 if (isRegIdx(MIR_Compare.getVal2(inst))) {
1806 emitCMP_Reg_RegIdx(
1807 getGPR_Reg(MIR_Compare.getVal1(inst)),
1808 getBase(MIR_Compare.getVal2(inst)), getIndex(MIR_Compare.getVal2(inst)), getScale(MIR_Compare.getVal2(inst)), getDisp(MIR_Compare.getVal2(inst)));
1809
1810 } else {
1811 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1812 emitCMP_Reg_RegInd(
1813 getGPR_Reg(MIR_Compare.getVal1(inst)),
1814 getBase(MIR_Compare.getVal2(inst)));
1815 }
1816 }
1817 }
1818 }
1819 }
1820 }
1821 }
1822 }
1823 }
1824
1825 } else {
1826 if (isImm(MIR_Compare.getVal2(inst))) {
1827 if (isByte(inst)) {
1828 if (isAbs(MIR_Compare.getVal1(inst))) {
1829 emitCMP_Abs_Imm_Byte(
1830 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
1831 getImm(MIR_Compare.getVal2(inst)));
1832
1833 } else {
1834 if (isRegDisp(MIR_Compare.getVal1(inst))) {
1835 emitCMP_RegDisp_Imm_Byte(
1836 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1837 getImm(MIR_Compare.getVal2(inst)));
1838
1839 } else {
1840 if (isRegOff(MIR_Compare.getVal1(inst))) {
1841 emitCMP_RegOff_Imm_Byte(
1842 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1843 getImm(MIR_Compare.getVal2(inst)));
1844
1845 } else {
1846 if (isRegIdx(MIR_Compare.getVal1(inst))) {
1847 emitCMP_RegIdx_Imm_Byte(
1848 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1849 getImm(MIR_Compare.getVal2(inst)));
1850
1851 } else {
1852 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
1853 emitCMP_RegInd_Imm_Byte(
1854 getBase(MIR_Compare.getVal1(inst)),
1855 getImm(MIR_Compare.getVal2(inst)));
1856 }
1857 }
1858 }
1859 }
1860
1861 } else {
1862 if (isWord(inst)) {
1863 if (isAbs(MIR_Compare.getVal1(inst))) {
1864 emitCMP_Abs_Imm_Word(
1865 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
1866 getImm(MIR_Compare.getVal2(inst)));
1867
1868 } else {
1869 if (isRegDisp(MIR_Compare.getVal1(inst))) {
1870 emitCMP_RegDisp_Imm_Word(
1871 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1872 getImm(MIR_Compare.getVal2(inst)));
1873
1874 } else {
1875 if (isRegOff(MIR_Compare.getVal1(inst))) {
1876 emitCMP_RegOff_Imm_Word(
1877 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1878 getImm(MIR_Compare.getVal2(inst)));
1879
1880 } else {
1881 if (isRegIdx(MIR_Compare.getVal1(inst))) {
1882 emitCMP_RegIdx_Imm_Word(
1883 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1884 getImm(MIR_Compare.getVal2(inst)));
1885
1886 } else {
1887 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
1888 emitCMP_RegInd_Imm_Word(
1889 getBase(MIR_Compare.getVal1(inst)),
1890 getImm(MIR_Compare.getVal2(inst)));
1891 }
1892 }
1893 }
1894 }
1895
1896 } else {
1897 if (isQuad(inst)) {
1898 if (isAbs(MIR_Compare.getVal1(inst))) {
1899 emitCMP_Abs_Imm_Quad(
1900 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
1901 getImm(MIR_Compare.getVal2(inst)));
1902
1903 } else {
1904 if (isRegDisp(MIR_Compare.getVal1(inst))) {
1905 emitCMP_RegDisp_Imm_Quad(
1906 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1907 getImm(MIR_Compare.getVal2(inst)));
1908
1909 } else {
1910 if (isRegOff(MIR_Compare.getVal1(inst))) {
1911 emitCMP_RegOff_Imm_Quad(
1912 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1913 getImm(MIR_Compare.getVal2(inst)));
1914
1915 } else {
1916 if (isRegIdx(MIR_Compare.getVal1(inst))) {
1917 emitCMP_RegIdx_Imm_Quad(
1918 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1919 getImm(MIR_Compare.getVal2(inst)));
1920
1921 } else {
1922 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
1923 emitCMP_RegInd_Imm_Quad(
1924 getBase(MIR_Compare.getVal1(inst)),
1925 getImm(MIR_Compare.getVal2(inst)));
1926 }
1927 }
1928 }
1929 }
1930
1931 } else {
1932 if (isAbs(MIR_Compare.getVal1(inst))) {
1933 emitCMP_Abs_Imm(
1934 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
1935 getImm(MIR_Compare.getVal2(inst)));
1936
1937 } else {
1938 if (isRegDisp(MIR_Compare.getVal1(inst))) {
1939 emitCMP_RegDisp_Imm(
1940 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1941 getImm(MIR_Compare.getVal2(inst)));
1942
1943 } else {
1944 if (isRegOff(MIR_Compare.getVal1(inst))) {
1945 emitCMP_RegOff_Imm(
1946 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1947 getImm(MIR_Compare.getVal2(inst)));
1948
1949 } else {
1950 if (isRegIdx(MIR_Compare.getVal1(inst))) {
1951 emitCMP_RegIdx_Imm(
1952 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1953 getImm(MIR_Compare.getVal2(inst)));
1954
1955 } else {
1956 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
1957 emitCMP_RegInd_Imm(
1958 getBase(MIR_Compare.getVal1(inst)),
1959 getImm(MIR_Compare.getVal2(inst)));
1960 }
1961 }
1962 }
1963 }
1964 }
1965 }
1966 }
1967
1968 } else {
1969 if (isByte(inst)) {
1970 if (isAbs(MIR_Compare.getVal1(inst))) {
1971 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1972 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal2(inst)).value() < 4)) VM._assert(false, inst.toString());
1973 emitCMP_Abs_Reg_Byte(
1974 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
1975 getGPR_Reg(MIR_Compare.getVal2(inst)));
1976
1977 } else {
1978 if (isRegDisp(MIR_Compare.getVal1(inst))) {
1979 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1980 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal2(inst)).value() < 4)) VM._assert(false, inst.toString());
1981 emitCMP_RegDisp_Reg_Byte(
1982 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1983 getGPR_Reg(MIR_Compare.getVal2(inst)));
1984
1985 } else {
1986 if (isRegOff(MIR_Compare.getVal1(inst))) {
1987 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1988 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal2(inst)).value() < 4)) VM._assert(false, inst.toString());
1989 emitCMP_RegOff_Reg_Byte(
1990 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1991 getGPR_Reg(MIR_Compare.getVal2(inst)));
1992
1993 } else {
1994 if (isRegIdx(MIR_Compare.getVal1(inst))) {
1995 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
1996 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal2(inst)).value() < 4)) VM._assert(false, inst.toString());
1997 emitCMP_RegIdx_Reg_Byte(
1998 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
1999 getGPR_Reg(MIR_Compare.getVal2(inst)));
2000
2001 } else {
2002 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
2003 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2004 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Compare.getVal2(inst)).value() < 4)) VM._assert(false, inst.toString());
2005 emitCMP_RegInd_Reg_Byte(
2006 getBase(MIR_Compare.getVal1(inst)),
2007 getGPR_Reg(MIR_Compare.getVal2(inst)));
2008 }
2009 }
2010 }
2011 }
2012
2013 } else {
2014 if (isWord(inst)) {
2015 if (isAbs(MIR_Compare.getVal1(inst))) {
2016 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2017 emitCMP_Abs_Reg_Word(
2018 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
2019 getGPR_Reg(MIR_Compare.getVal2(inst)));
2020
2021 } else {
2022 if (isRegDisp(MIR_Compare.getVal1(inst))) {
2023 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2024 emitCMP_RegDisp_Reg_Word(
2025 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2026 getGPR_Reg(MIR_Compare.getVal2(inst)));
2027
2028 } else {
2029 if (isRegOff(MIR_Compare.getVal1(inst))) {
2030 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2031 emitCMP_RegOff_Reg_Word(
2032 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2033 getGPR_Reg(MIR_Compare.getVal2(inst)));
2034
2035 } else {
2036 if (isRegIdx(MIR_Compare.getVal1(inst))) {
2037 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2038 emitCMP_RegIdx_Reg_Word(
2039 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2040 getGPR_Reg(MIR_Compare.getVal2(inst)));
2041
2042 } else {
2043 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
2044 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2045 emitCMP_RegInd_Reg_Word(
2046 getBase(MIR_Compare.getVal1(inst)),
2047 getGPR_Reg(MIR_Compare.getVal2(inst)));
2048 }
2049 }
2050 }
2051 }
2052
2053 } else {
2054 if (isQuad(inst)) {
2055 if (isAbs(MIR_Compare.getVal1(inst))) {
2056 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2057 emitCMP_Abs_Reg_Quad(
2058 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
2059 getGPR_Reg(MIR_Compare.getVal2(inst)));
2060
2061 } else {
2062 if (isRegDisp(MIR_Compare.getVal1(inst))) {
2063 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2064 emitCMP_RegDisp_Reg_Quad(
2065 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2066 getGPR_Reg(MIR_Compare.getVal2(inst)));
2067
2068 } else {
2069 if (isRegOff(MIR_Compare.getVal1(inst))) {
2070 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2071 emitCMP_RegOff_Reg_Quad(
2072 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2073 getGPR_Reg(MIR_Compare.getVal2(inst)));
2074
2075 } else {
2076 if (isRegIdx(MIR_Compare.getVal1(inst))) {
2077 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2078 emitCMP_RegIdx_Reg_Quad(
2079 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2080 getGPR_Reg(MIR_Compare.getVal2(inst)));
2081
2082 } else {
2083 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
2084 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2085 emitCMP_RegInd_Reg_Quad(
2086 getBase(MIR_Compare.getVal1(inst)),
2087 getGPR_Reg(MIR_Compare.getVal2(inst)));
2088 }
2089 }
2090 }
2091 }
2092
2093 } else {
2094 if (isAbs(MIR_Compare.getVal1(inst))) {
2095 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2096 emitCMP_Abs_Reg(
2097 getDisp(MIR_Compare.getVal1(inst)).toWord().toAddress(),
2098 getGPR_Reg(MIR_Compare.getVal2(inst)));
2099
2100 } else {
2101 if (isRegDisp(MIR_Compare.getVal1(inst))) {
2102 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2103 emitCMP_RegDisp_Reg(
2104 getBase(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2105 getGPR_Reg(MIR_Compare.getVal2(inst)));
2106
2107 } else {
2108 if (isRegOff(MIR_Compare.getVal1(inst))) {
2109 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2110 emitCMP_RegOff_Reg(
2111 getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2112 getGPR_Reg(MIR_Compare.getVal2(inst)));
2113
2114 } else {
2115 if (isRegIdx(MIR_Compare.getVal1(inst))) {
2116 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2117 emitCMP_RegIdx_Reg(
2118 getBase(MIR_Compare.getVal1(inst)), getIndex(MIR_Compare.getVal1(inst)), getScale(MIR_Compare.getVal1(inst)), getDisp(MIR_Compare.getVal1(inst)),
2119 getGPR_Reg(MIR_Compare.getVal2(inst)));
2120
2121 } else {
2122 if (VM.VerifyAssertions && !isRegInd(MIR_Compare.getVal1(inst))) VM._assert(false, inst.toString());
2123 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Compare.getVal2(inst))) VM._assert(false, inst.toString());
2124 emitCMP_RegInd_Reg(
2125 getBase(MIR_Compare.getVal1(inst)),
2126 getGPR_Reg(MIR_Compare.getVal2(inst)));
2127 }
2128 }
2129 }
2130 }
2131 }
2132 }
2133 }
2134 }
2135 }
2136 }
2137
2138 /**
2139 * Emit the given instruction, assuming that
2140 * it is a MIR_Move instruction
2141 * and has a FST operator
2142 *
2143 * @param inst the instruction to assemble
2144 */
2145 private void doFST(Instruction inst) {
2146 if (isQuad(inst)) {
2147 if (isAbs(MIR_Move.getResult(inst))) {
2148 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2149 emitFST_Abs_Reg_Quad(
2150 getDisp(MIR_Move.getResult(inst)).toWord().toAddress(),
2151 getFPR_Reg(MIR_Move.getValue(inst)));
2152
2153 } else {
2154 if (isRegDisp(MIR_Move.getResult(inst))) {
2155 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2156 emitFST_RegDisp_Reg_Quad(
2157 getBase(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
2158 getFPR_Reg(MIR_Move.getValue(inst)));
2159
2160 } else {
2161 if (isRegOff(MIR_Move.getResult(inst))) {
2162 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2163 emitFST_RegOff_Reg_Quad(
2164 getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
2165 getFPR_Reg(MIR_Move.getValue(inst)));
2166
2167 } else {
2168 if (isRegIdx(MIR_Move.getResult(inst))) {
2169 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2170 emitFST_RegIdx_Reg_Quad(
2171 getBase(MIR_Move.getResult(inst)), getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
2172 getFPR_Reg(MIR_Move.getValue(inst)));
2173
2174 } else {
2175 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
2176 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2177 emitFST_RegInd_Reg_Quad(
2178 getBase(MIR_Move.getResult(inst)),
2179 getFPR_Reg(MIR_Move.getValue(inst)));
2180 }
2181 }
2182 }
2183 }
2184
2185 } else {
2186 if (isFPR_Reg(MIR_Move.getResult(inst))) {
2187 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2188 emitFST_Reg_Reg(
2189 getFPR_Reg(MIR_Move.getResult(inst)),
2190 getFPR_Reg(MIR_Move.getValue(inst)));
2191
2192 } else {
2193 if (isAbs(MIR_Move.getResult(inst))) {
2194 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2195 emitFST_Abs_Reg(
2196 getDisp(MIR_Move.getResult(inst)).toWord().toAddress(),
2197 getFPR_Reg(MIR_Move.getValue(inst)));
2198
2199 } else {
2200 if (isRegDisp(MIR_Move.getResult(inst))) {
2201 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2202 emitFST_RegDisp_Reg(
2203 getBase(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
2204 getFPR_Reg(MIR_Move.getValue(inst)));
2205
2206 } else {
2207 if (isRegOff(MIR_Move.getResult(inst))) {
2208 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2209 emitFST_RegOff_Reg(
2210 getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
2211 getFPR_Reg(MIR_Move.getValue(inst)));
2212
2213 } else {
2214 if (isRegIdx(MIR_Move.getResult(inst))) {
2215 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2216 emitFST_RegIdx_Reg(
2217 getBase(MIR_Move.getResult(inst)), getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
2218 getFPR_Reg(MIR_Move.getValue(inst)));
2219
2220 } else {
2221 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
2222 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
2223 emitFST_RegInd_Reg(
2224 getBase(MIR_Move.getResult(inst)),
2225 getFPR_Reg(MIR_Move.getValue(inst)));
2226 }
2227 }
2228 }
2229 }
2230 }
2231 }
2232 }
2233
2234 /**
2235 * Emit the given instruction, assuming that
2236 * it is a MIR_Test instruction
2237 * and has a BTC operator
2238 *
2239 * @param inst the instruction to assemble
2240 */
2241 private void doBTC(Instruction inst) {
2242 if (isImm(MIR_Test.getVal2(inst))) {
2243 if (isGPR_Reg(MIR_Test.getVal1(inst))) {
2244 emitBTC_Reg_Imm(
2245 getGPR_Reg(MIR_Test.getVal1(inst)),
2246 getImm(MIR_Test.getVal2(inst)));
2247
2248 } else {
2249 if (isAbs(MIR_Test.getVal1(inst))) {
2250 emitBTC_Abs_Imm(
2251 getDisp(MIR_Test.getVal1(inst)).toWord().toAddress(),
2252 getImm(MIR_Test.getVal2(inst)));
2253
2254 } else {
2255 if (isRegDisp(MIR_Test.getVal1(inst))) {
2256 emitBTC_RegDisp_Imm(
2257 getBase(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
2258 getImm(MIR_Test.getVal2(inst)));
2259
2260 } else {
2261 if (isRegOff(MIR_Test.getVal1(inst))) {
2262 emitBTC_RegOff_Imm(
2263 getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
2264 getImm(MIR_Test.getVal2(inst)));
2265
2266 } else {
2267 if (isRegIdx(MIR_Test.getVal1(inst))) {
2268 emitBTC_RegIdx_Imm(
2269 getBase(MIR_Test.getVal1(inst)), getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
2270 getImm(MIR_Test.getVal2(inst)));
2271
2272 } else {
2273 if (VM.VerifyAssertions && !isRegInd(MIR_Test.getVal1(inst))) VM._assert(false, inst.toString());
2274 emitBTC_RegInd_Imm(
2275 getBase(MIR_Test.getVal1(inst)),
2276 getImm(MIR_Test.getVal2(inst)));
2277 }
2278 }
2279 }
2280 }
2281 }
2282
2283 } else {
2284 if (isGPR_Reg(MIR_Test.getVal1(inst))) {
2285 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
2286 emitBTC_Reg_Reg(
2287 getGPR_Reg(MIR_Test.getVal1(inst)),
2288 getGPR_Reg(MIR_Test.getVal2(inst)));
2289
2290 } else {
2291 if (isAbs(MIR_Test.getVal1(inst))) {
2292 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
2293 emitBTC_Abs_Reg(
2294 getDisp(MIR_Test.getVal1(inst)).toWord().toAddress(),
2295 getGPR_Reg(MIR_Test.getVal2(inst)));
2296
2297 } else {
2298 if (isRegDisp(MIR_Test.getVal1(inst))) {
2299 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
2300 emitBTC_RegDisp_Reg(
2301 getBase(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
2302 getGPR_Reg(MIR_Test.getVal2(inst)));
2303
2304 } else {
2305 if (isRegOff(MIR_Test.getVal1(inst))) {
2306 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
2307 emitBTC_RegOff_Reg(
2308 getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
2309 getGPR_Reg(MIR_Test.getVal2(inst)));
2310
2311 } else {
2312 if (isRegIdx(MIR_Test.getVal1(inst))) {
2313 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
2314 emitBTC_RegIdx_Reg(
2315 getBase(MIR_Test.getVal1(inst)), getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
2316 getGPR_Reg(MIR_Test.getVal2(inst)));
2317
2318 } else {
2319 if (VM.VerifyAssertions && !isRegInd(MIR_Test.getVal1(inst))) VM._assert(false, inst.toString());
2320 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
2321 emitBTC_RegInd_Reg(
2322 getBase(MIR_Test.getVal1(inst)),
2323 getGPR_Reg(MIR_Test.getVal2(inst)));
2324 }
2325 }
2326 }
2327 }
2328 }
2329 }
2330 }
2331
2332 /**
2333 * Emit the given instruction, assuming that
2334 * it is a MIR_Nullary instruction
2335 * and has a POP operator
2336 *
2337 * @param inst the instruction to assemble
2338 */
2339 private void doPOP(Instruction inst) {
2340 if (isGPR_Reg(MIR_Nullary.getResult(inst))) {
2341 emitPOP_Reg(
2342 getGPR_Reg(MIR_Nullary.getResult(inst)));
2343
2344 } else {
2345 if (isAbs(MIR_Nullary.getResult(inst))) {
2346 emitPOP_Abs(
2347 getDisp(MIR_Nullary.getResult(inst)).toWord().toAddress());
2348
2349 } else {
2350 if (isRegDisp(MIR_Nullary.getResult(inst))) {
2351 emitPOP_RegDisp(
2352 getBase(MIR_Nullary.getResult(inst)), getDisp(MIR_Nullary.getResult(inst)));
2353
2354 } else {
2355 if (isRegOff(MIR_Nullary.getResult(inst))) {
2356 emitPOP_RegOff(
2357 getIndex(MIR_Nullary.getResult(inst)), getScale(MIR_Nullary.getResult(inst)), getDisp(MIR_Nullary.getResult(inst)));
2358
2359 } else {
2360 if (isRegIdx(MIR_Nullary.getResult(inst))) {
2361 emitPOP_RegIdx(
2362 getBase(MIR_Nullary.getResult(inst)), getIndex(MIR_Nullary.getResult(inst)), getScale(MIR_Nullary.getResult(inst)), getDisp(MIR_Nullary.getResult(inst)));
2363
2364 } else {
2365 if (VM.VerifyAssertions && !isRegInd(MIR_Nullary.getResult(inst))) VM._assert(false, inst.toString());
2366 emitPOP_RegInd(
2367 getBase(MIR_Nullary.getResult(inst)));
2368 }
2369 }
2370 }
2371 }
2372 }
2373 }
2374
2375 /**
2376 * Emit the given instruction, assuming that
2377 * it is a MIR_UnaryNoRes instruction
2378 * and has a FLDCW operator
2379 *
2380 * @param inst the instruction to assemble
2381 */
2382 private void doFLDCW(Instruction inst) {
2383 if (isAbs(MIR_UnaryNoRes.getVal(inst))) {
2384 emitFLDCW_Abs(
2385 getDisp(MIR_UnaryNoRes.getVal(inst)).toWord().toAddress());
2386
2387 } else {
2388 if (isRegDisp(MIR_UnaryNoRes.getVal(inst))) {
2389 emitFLDCW_RegDisp(
2390 getBase(MIR_UnaryNoRes.getVal(inst)), getDisp(MIR_UnaryNoRes.getVal(inst)));
2391
2392 } else {
2393 if (isRegOff(MIR_UnaryNoRes.getVal(inst))) {
2394 emitFLDCW_RegOff(
2395 getIndex(MIR_UnaryNoRes.getVal(inst)), getScale(MIR_UnaryNoRes.getVal(inst)), getDisp(MIR_UnaryNoRes.getVal(inst)));
2396
2397 } else {
2398 if (isRegIdx(MIR_UnaryNoRes.getVal(inst))) {
2399 emitFLDCW_RegIdx(
2400 getBase(MIR_UnaryNoRes.getVal(inst)), getIndex(MIR_UnaryNoRes.getVal(inst)), getScale(MIR_UnaryNoRes.getVal(inst)), getDisp(MIR_UnaryNoRes.getVal(inst)));
2401
2402 } else {
2403 if (VM.VerifyAssertions && !isRegInd(MIR_UnaryNoRes.getVal(inst))) VM._assert(false, inst.toString());
2404 emitFLDCW_RegInd(
2405 getBase(MIR_UnaryNoRes.getVal(inst)));
2406 }
2407 }
2408 }
2409 }
2410 }
2411
2412 /**
2413 * Emit the given instruction, assuming that
2414 * it is a MIR_RDTSC instruction
2415 * and has a RDTSC operator
2416 *
2417 * @param inst the instruction to assemble
2418 */
2419 private void doRDTSC(Instruction inst) {
2420 emitRDTSC();
2421 }
2422
2423 /**
2424 * Emit the given instruction, assuming that
2425 * it is a MIR_Unary instruction
2426 * and has a MOVZX operator
2427 *
2428 * @param inst the instruction to assemble
2429 */
2430 private void doMOVZX(Instruction inst) {
2431 if (isByte(inst)) {
2432 if (isGPR_Reg(MIR_Unary.getVal(inst))) {
2433 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2434 emitMOVZX_Reg_Reg_Byte(
2435 getGPR_Reg(MIR_Unary.getResult(inst)),
2436 getGPR_Reg(MIR_Unary.getVal(inst)));
2437
2438 } else {
2439 if (isAbs(MIR_Unary.getVal(inst))) {
2440 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2441 emitMOVZX_Reg_Abs_Byte(
2442 getGPR_Reg(MIR_Unary.getResult(inst)),
2443 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
2444
2445 } else {
2446 if (isRegDisp(MIR_Unary.getVal(inst))) {
2447 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2448 emitMOVZX_Reg_RegDisp_Byte(
2449 getGPR_Reg(MIR_Unary.getResult(inst)),
2450 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
2451
2452 } else {
2453 if (isRegOff(MIR_Unary.getVal(inst))) {
2454 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2455 emitMOVZX_Reg_RegOff_Byte(
2456 getGPR_Reg(MIR_Unary.getResult(inst)),
2457 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
2458
2459 } else {
2460 if (isRegIdx(MIR_Unary.getVal(inst))) {
2461 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2462 emitMOVZX_Reg_RegIdx_Byte(
2463 getGPR_Reg(MIR_Unary.getResult(inst)),
2464 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
2465
2466 } else {
2467 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2468 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
2469 emitMOVZX_Reg_RegInd_Byte(
2470 getGPR_Reg(MIR_Unary.getResult(inst)),
2471 getBase(MIR_Unary.getVal(inst)));
2472 }
2473 }
2474 }
2475 }
2476 }
2477
2478 } else {
2479 if (isGPR_Reg(MIR_Unary.getVal(inst))) {
2480 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2481 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
2482 emitMOVZX_Reg_Reg_Word(
2483 getGPR_Reg(MIR_Unary.getResult(inst)),
2484 getGPR_Reg(MIR_Unary.getVal(inst)));
2485
2486 } else {
2487 if (isAbs(MIR_Unary.getVal(inst))) {
2488 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2489 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
2490 emitMOVZX_Reg_Abs_Word(
2491 getGPR_Reg(MIR_Unary.getResult(inst)),
2492 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
2493
2494 } else {
2495 if (isRegDisp(MIR_Unary.getVal(inst))) {
2496 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2497 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
2498 emitMOVZX_Reg_RegDisp_Word(
2499 getGPR_Reg(MIR_Unary.getResult(inst)),
2500 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
2501
2502 } else {
2503 if (isRegOff(MIR_Unary.getVal(inst))) {
2504 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2505 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
2506 emitMOVZX_Reg_RegOff_Word(
2507 getGPR_Reg(MIR_Unary.getResult(inst)),
2508 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
2509
2510 } else {
2511 if (isRegIdx(MIR_Unary.getVal(inst))) {
2512 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2513 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
2514 emitMOVZX_Reg_RegIdx_Word(
2515 getGPR_Reg(MIR_Unary.getResult(inst)),
2516 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
2517
2518 } else {
2519 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
2520 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
2521 if (VM.VerifyAssertions && !isWord(inst)) VM._assert(false, inst.toString());
2522 emitMOVZX_Reg_RegInd_Word(
2523 getGPR_Reg(MIR_Unary.getResult(inst)),
2524 getBase(MIR_Unary.getVal(inst)));
2525 }
2526 }
2527 }
2528 }
2529 }
2530 }
2531 }
2532
2533 /**
2534 * Emit the given instruction, assuming that
2535 * it is a MIR_BinaryAcc instruction
2536 * and has a CMPEQSS operator
2537 *
2538 * @param inst the instruction to assemble
2539 */
2540 private void doCMPEQSS(Instruction inst) {
2541 if (isXMM_Reg(MIR_BinaryAcc.getValue(inst))) {
2542 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2543 emitCMPEQSS_Reg_Reg(
2544 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
2545 getXMM_Reg(MIR_BinaryAcc.getValue(inst)));
2546
2547 } else {
2548 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
2549 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2550 emitCMPEQSS_Reg_Abs(
2551 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
2552 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
2553
2554 } else {
2555 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
2556 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2557 emitCMPEQSS_Reg_RegDisp(
2558 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
2559 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2560
2561 } else {
2562 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
2563 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2564 emitCMPEQSS_Reg_RegOff(
2565 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
2566 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2567
2568 } else {
2569 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
2570 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2571 emitCMPEQSS_Reg_RegIdx(
2572 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
2573 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2574
2575 } else {
2576 if (VM.VerifyAssertions && !isXMM_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2577 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2578 emitCMPEQSS_Reg_RegInd(
2579 getXMM_Reg(MIR_BinaryAcc.getResult(inst)),
2580 getBase(MIR_BinaryAcc.getValue(inst)));
2581 }
2582 }
2583 }
2584 }
2585 }
2586 }
2587
2588 /**
2589 * Emit the given instruction, assuming that
2590 * it is a MIR_BinaryAcc instruction
2591 * and has a FADDP operator
2592 *
2593 * @param inst the instruction to assemble
2594 */
2595 private void doFADDP(Instruction inst) {
2596 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2597 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2598 emitFADDP_Reg_Reg(
2599 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
2600 getFPR_Reg(MIR_BinaryAcc.getValue(inst)));
2601 }
2602
2603 /**
2604 * Emit the given instruction, assuming that
2605 * it is a MIR_ConvertDW2QW instruction
2606 * and has a CDQE operator
2607 *
2608 * @param inst the instruction to assemble
2609 */
2610 private void doCDQE(Instruction inst) {
2611 emitCDQE();
2612 }
2613
2614 /**
2615 * Emit the given instruction, assuming that
2616 * it is a MIR_BinaryAcc instruction
2617 * and has a XOR operator
2618 *
2619 * @param inst the instruction to assemble
2620 */
2621 private void doXOR(Instruction inst) {
2622 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
2623 if (isByte(inst)) {
2624 if (isImm(MIR_BinaryAcc.getValue(inst))) {
2625 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2626 emitXOR_Reg_Imm_Byte(
2627 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2628 getImm(MIR_BinaryAcc.getValue(inst)));
2629
2630 } else {
2631 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
2632 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2633 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
2634 emitXOR_Reg_Reg_Byte(
2635 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2636 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2637
2638 } else {
2639 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
2640 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2641 emitXOR_Reg_Abs_Byte(
2642 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2643 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
2644
2645 } else {
2646 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
2647 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2648 emitXOR_Reg_RegDisp_Byte(
2649 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2650 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2651
2652 } else {
2653 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
2654 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2655 emitXOR_Reg_RegOff_Byte(
2656 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2657 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2658
2659 } else {
2660 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
2661 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2662 emitXOR_Reg_RegIdx_Byte(
2663 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2664 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2665
2666 } else {
2667 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2668 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
2669 emitXOR_Reg_RegInd_Byte(
2670 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2671 getBase(MIR_BinaryAcc.getValue(inst)));
2672 }
2673 }
2674 }
2675 }
2676 }
2677 }
2678
2679 } else {
2680 if (isWord(inst)) {
2681 if (isImm(MIR_BinaryAcc.getValue(inst))) {
2682 emitXOR_Reg_Imm_Word(
2683 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2684 getImm(MIR_BinaryAcc.getValue(inst)));
2685
2686 } else {
2687 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
2688 emitXOR_Reg_Reg_Word(
2689 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2690 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2691
2692 } else {
2693 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
2694 emitXOR_Reg_Abs_Word(
2695 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2696 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
2697
2698 } else {
2699 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
2700 emitXOR_Reg_RegDisp_Word(
2701 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2702 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2703
2704 } else {
2705 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
2706 emitXOR_Reg_RegOff_Word(
2707 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2708 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2709
2710 } else {
2711 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
2712 emitXOR_Reg_RegIdx_Word(
2713 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2714 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2715
2716 } else {
2717 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2718 emitXOR_Reg_RegInd_Word(
2719 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2720 getBase(MIR_BinaryAcc.getValue(inst)));
2721 }
2722 }
2723 }
2724 }
2725 }
2726 }
2727
2728 } else {
2729 if (isQuad(inst)) {
2730 if (isImm(MIR_BinaryAcc.getValue(inst))) {
2731 emitXOR_Reg_Imm_Quad(
2732 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2733 getImm(MIR_BinaryAcc.getValue(inst)));
2734
2735 } else {
2736 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
2737 emitXOR_Reg_Reg_Quad(
2738 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2739 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2740
2741 } else {
2742 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
2743 emitXOR_Reg_Abs_Quad(
2744 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2745 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
2746
2747 } else {
2748 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
2749 emitXOR_Reg_RegDisp_Quad(
2750 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2751 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2752
2753 } else {
2754 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
2755 emitXOR_Reg_RegOff_Quad(
2756 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2757 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2758
2759 } else {
2760 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
2761 emitXOR_Reg_RegIdx_Quad(
2762 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2763 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2764
2765 } else {
2766 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2767 emitXOR_Reg_RegInd_Quad(
2768 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2769 getBase(MIR_BinaryAcc.getValue(inst)));
2770 }
2771 }
2772 }
2773 }
2774 }
2775 }
2776
2777 } else {
2778 if (isImm(MIR_BinaryAcc.getValue(inst))) {
2779 emitXOR_Reg_Imm(
2780 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2781 getImm(MIR_BinaryAcc.getValue(inst)));
2782
2783 } else {
2784 if (isGPR_Reg(MIR_BinaryAcc.getValue(inst))) {
2785 emitXOR_Reg_Reg(
2786 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2787 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2788
2789 } else {
2790 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
2791 emitXOR_Reg_Abs(
2792 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2793 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
2794
2795 } else {
2796 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
2797 emitXOR_Reg_RegDisp(
2798 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2799 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2800
2801 } else {
2802 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
2803 emitXOR_Reg_RegOff(
2804 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2805 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2806
2807 } else {
2808 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
2809 emitXOR_Reg_RegIdx(
2810 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2811 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
2812
2813 } else {
2814 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2815 emitXOR_Reg_RegInd(
2816 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
2817 getBase(MIR_BinaryAcc.getValue(inst)));
2818 }
2819 }
2820 }
2821 }
2822 }
2823 }
2824 }
2825 }
2826 }
2827
2828 } else {
2829 if (isImm(MIR_BinaryAcc.getValue(inst))) {
2830 if (isByte(inst)) {
2831 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
2832 emitXOR_Abs_Imm_Byte(
2833 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
2834 getImm(MIR_BinaryAcc.getValue(inst)));
2835
2836 } else {
2837 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
2838 emitXOR_RegDisp_Imm_Byte(
2839 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2840 getImm(MIR_BinaryAcc.getValue(inst)));
2841
2842 } else {
2843 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
2844 emitXOR_RegOff_Imm_Byte(
2845 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2846 getImm(MIR_BinaryAcc.getValue(inst)));
2847
2848 } else {
2849 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
2850 emitXOR_RegIdx_Imm_Byte(
2851 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2852 getImm(MIR_BinaryAcc.getValue(inst)));
2853
2854 } else {
2855 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2856 emitXOR_RegInd_Imm_Byte(
2857 getBase(MIR_BinaryAcc.getResult(inst)),
2858 getImm(MIR_BinaryAcc.getValue(inst)));
2859 }
2860 }
2861 }
2862 }
2863
2864 } else {
2865 if (isWord(inst)) {
2866 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
2867 emitXOR_Abs_Imm_Word(
2868 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
2869 getImm(MIR_BinaryAcc.getValue(inst)));
2870
2871 } else {
2872 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
2873 emitXOR_RegDisp_Imm_Word(
2874 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2875 getImm(MIR_BinaryAcc.getValue(inst)));
2876
2877 } else {
2878 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
2879 emitXOR_RegOff_Imm_Word(
2880 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2881 getImm(MIR_BinaryAcc.getValue(inst)));
2882
2883 } else {
2884 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
2885 emitXOR_RegIdx_Imm_Word(
2886 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2887 getImm(MIR_BinaryAcc.getValue(inst)));
2888
2889 } else {
2890 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2891 emitXOR_RegInd_Imm_Word(
2892 getBase(MIR_BinaryAcc.getResult(inst)),
2893 getImm(MIR_BinaryAcc.getValue(inst)));
2894 }
2895 }
2896 }
2897 }
2898
2899 } else {
2900 if (isQuad(inst)) {
2901 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
2902 emitXOR_Abs_Imm_Quad(
2903 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
2904 getImm(MIR_BinaryAcc.getValue(inst)));
2905
2906 } else {
2907 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
2908 emitXOR_RegDisp_Imm_Quad(
2909 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2910 getImm(MIR_BinaryAcc.getValue(inst)));
2911
2912 } else {
2913 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
2914 emitXOR_RegOff_Imm_Quad(
2915 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2916 getImm(MIR_BinaryAcc.getValue(inst)));
2917
2918 } else {
2919 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
2920 emitXOR_RegIdx_Imm_Quad(
2921 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2922 getImm(MIR_BinaryAcc.getValue(inst)));
2923
2924 } else {
2925 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2926 emitXOR_RegInd_Imm_Quad(
2927 getBase(MIR_BinaryAcc.getResult(inst)),
2928 getImm(MIR_BinaryAcc.getValue(inst)));
2929 }
2930 }
2931 }
2932 }
2933
2934 } else {
2935 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
2936 emitXOR_Abs_Imm(
2937 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
2938 getImm(MIR_BinaryAcc.getValue(inst)));
2939
2940 } else {
2941 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
2942 emitXOR_RegDisp_Imm(
2943 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2944 getImm(MIR_BinaryAcc.getValue(inst)));
2945
2946 } else {
2947 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
2948 emitXOR_RegOff_Imm(
2949 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2950 getImm(MIR_BinaryAcc.getValue(inst)));
2951
2952 } else {
2953 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
2954 emitXOR_RegIdx_Imm(
2955 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2956 getImm(MIR_BinaryAcc.getValue(inst)));
2957
2958 } else {
2959 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
2960 emitXOR_RegInd_Imm(
2961 getBase(MIR_BinaryAcc.getResult(inst)),
2962 getImm(MIR_BinaryAcc.getValue(inst)));
2963 }
2964 }
2965 }
2966 }
2967 }
2968 }
2969 }
2970
2971 } else {
2972 if (isByte(inst)) {
2973 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
2974 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2975 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
2976 emitXOR_Abs_Reg_Byte(
2977 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
2978 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2979
2980 } else {
2981 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
2982 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2983 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
2984 emitXOR_RegDisp_Reg_Byte(
2985 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2986 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2987
2988 } else {
2989 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
2990 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2991 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
2992 emitXOR_RegOff_Reg_Byte(
2993 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
2994 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
2995
2996 } else {
2997 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
2998 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
2999 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3000 emitXOR_RegIdx_Reg_Byte(
3001 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3002 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3003
3004 } else {
3005 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3006 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3007 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3008 emitXOR_RegInd_Reg_Byte(
3009 getBase(MIR_BinaryAcc.getResult(inst)),
3010 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3011 }
3012 }
3013 }
3014 }
3015
3016 } else {
3017 if (isWord(inst)) {
3018 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3019 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3020 emitXOR_Abs_Reg_Word(
3021 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3022 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3023
3024 } else {
3025 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3026 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3027 emitXOR_RegDisp_Reg_Word(
3028 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3029 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3030
3031 } else {
3032 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3033 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3034 emitXOR_RegOff_Reg_Word(
3035 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3036 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3037
3038 } else {
3039 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3040 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3041 emitXOR_RegIdx_Reg_Word(
3042 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3043 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3044
3045 } else {
3046 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3047 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3048 emitXOR_RegInd_Reg_Word(
3049 getBase(MIR_BinaryAcc.getResult(inst)),
3050 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3051 }
3052 }
3053 }
3054 }
3055
3056 } else {
3057 if (isQuad(inst)) {
3058 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3059 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3060 emitXOR_Abs_Reg_Quad(
3061 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3062 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3063
3064 } else {
3065 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3066 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3067 emitXOR_RegDisp_Reg_Quad(
3068 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3069 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3070
3071 } else {
3072 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3073 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3074 emitXOR_RegOff_Reg_Quad(
3075 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3076 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3077
3078 } else {
3079 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3080 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3081 emitXOR_RegIdx_Reg_Quad(
3082 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3083 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3084
3085 } else {
3086 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3087 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3088 emitXOR_RegInd_Reg_Quad(
3089 getBase(MIR_BinaryAcc.getResult(inst)),
3090 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3091 }
3092 }
3093 }
3094 }
3095
3096 } else {
3097 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3098 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3099 emitXOR_Abs_Reg(
3100 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3101 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3102
3103 } else {
3104 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3105 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3106 emitXOR_RegDisp_Reg(
3107 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3108 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3109
3110 } else {
3111 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3112 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3113 emitXOR_RegOff_Reg(
3114 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3115 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3116
3117 } else {
3118 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3119 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3120 emitXOR_RegIdx_Reg(
3121 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3122 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3123
3124 } else {
3125 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3126 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3127 emitXOR_RegInd_Reg(
3128 getBase(MIR_BinaryAcc.getResult(inst)),
3129 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3130 }
3131 }
3132 }
3133 }
3134 }
3135 }
3136 }
3137 }
3138 }
3139 }
3140
3141 /**
3142 * Emit the given instruction, assuming that
3143 * it is a MIR_BinaryAcc instruction
3144 * and has a RCL operator
3145 *
3146 * @param inst the instruction to assemble
3147 */
3148 private void doRCL(Instruction inst) {
3149 if (isImm(MIR_BinaryAcc.getValue(inst))) {
3150 if (isByte(inst)) {
3151 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3152 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
3153 emitRCL_Reg_Imm_Byte(
3154 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3155 getImm(MIR_BinaryAcc.getValue(inst)));
3156
3157 } else {
3158 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3159 emitRCL_Abs_Imm_Byte(
3160 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3161 getImm(MIR_BinaryAcc.getValue(inst)));
3162
3163 } else {
3164 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3165 emitRCL_RegDisp_Imm_Byte(
3166 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3167 getImm(MIR_BinaryAcc.getValue(inst)));
3168
3169 } else {
3170 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3171 emitRCL_RegOff_Imm_Byte(
3172 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3173 getImm(MIR_BinaryAcc.getValue(inst)));
3174
3175 } else {
3176 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3177 emitRCL_RegIdx_Imm_Byte(
3178 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3179 getImm(MIR_BinaryAcc.getValue(inst)));
3180
3181 } else {
3182 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3183 emitRCL_RegInd_Imm_Byte(
3184 getBase(MIR_BinaryAcc.getResult(inst)),
3185 getImm(MIR_BinaryAcc.getValue(inst)));
3186 }
3187 }
3188 }
3189 }
3190 }
3191
3192 } else {
3193 if (isWord(inst)) {
3194 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3195 emitRCL_Reg_Imm_Word(
3196 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3197 getImm(MIR_BinaryAcc.getValue(inst)));
3198
3199 } else {
3200 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3201 emitRCL_Abs_Imm_Word(
3202 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3203 getImm(MIR_BinaryAcc.getValue(inst)));
3204
3205 } else {
3206 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3207 emitRCL_RegDisp_Imm_Word(
3208 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3209 getImm(MIR_BinaryAcc.getValue(inst)));
3210
3211 } else {
3212 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3213 emitRCL_RegOff_Imm_Word(
3214 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3215 getImm(MIR_BinaryAcc.getValue(inst)));
3216
3217 } else {
3218 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3219 emitRCL_RegIdx_Imm_Word(
3220 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3221 getImm(MIR_BinaryAcc.getValue(inst)));
3222
3223 } else {
3224 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3225 emitRCL_RegInd_Imm_Word(
3226 getBase(MIR_BinaryAcc.getResult(inst)),
3227 getImm(MIR_BinaryAcc.getValue(inst)));
3228 }
3229 }
3230 }
3231 }
3232 }
3233
3234 } else {
3235 if (isQuad(inst)) {
3236 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3237 emitRCL_Reg_Imm_Quad(
3238 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3239 getImm(MIR_BinaryAcc.getValue(inst)));
3240
3241 } else {
3242 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3243 emitRCL_Abs_Imm_Quad(
3244 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3245 getImm(MIR_BinaryAcc.getValue(inst)));
3246
3247 } else {
3248 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3249 emitRCL_RegDisp_Imm_Quad(
3250 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3251 getImm(MIR_BinaryAcc.getValue(inst)));
3252
3253 } else {
3254 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3255 emitRCL_RegOff_Imm_Quad(
3256 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3257 getImm(MIR_BinaryAcc.getValue(inst)));
3258
3259 } else {
3260 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3261 emitRCL_RegIdx_Imm_Quad(
3262 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3263 getImm(MIR_BinaryAcc.getValue(inst)));
3264
3265 } else {
3266 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3267 emitRCL_RegInd_Imm_Quad(
3268 getBase(MIR_BinaryAcc.getResult(inst)),
3269 getImm(MIR_BinaryAcc.getValue(inst)));
3270 }
3271 }
3272 }
3273 }
3274 }
3275
3276 } else {
3277 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3278 emitRCL_Reg_Imm(
3279 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3280 getImm(MIR_BinaryAcc.getValue(inst)));
3281
3282 } else {
3283 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3284 emitRCL_Abs_Imm(
3285 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3286 getImm(MIR_BinaryAcc.getValue(inst)));
3287
3288 } else {
3289 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3290 emitRCL_RegDisp_Imm(
3291 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3292 getImm(MIR_BinaryAcc.getValue(inst)));
3293
3294 } else {
3295 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3296 emitRCL_RegOff_Imm(
3297 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3298 getImm(MIR_BinaryAcc.getValue(inst)));
3299
3300 } else {
3301 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3302 emitRCL_RegIdx_Imm(
3303 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3304 getImm(MIR_BinaryAcc.getValue(inst)));
3305
3306 } else {
3307 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3308 emitRCL_RegInd_Imm(
3309 getBase(MIR_BinaryAcc.getResult(inst)),
3310 getImm(MIR_BinaryAcc.getValue(inst)));
3311 }
3312 }
3313 }
3314 }
3315 }
3316 }
3317 }
3318 }
3319
3320 } else {
3321 if (isByte(inst)) {
3322 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3323 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3324 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
3325 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3326 emitRCL_Reg_Reg_Byte(
3327 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3328 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3329
3330 } else {
3331 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3332 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3333 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3334 emitRCL_Abs_Reg_Byte(
3335 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3336 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3337
3338 } else {
3339 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3340 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3341 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3342 emitRCL_RegDisp_Reg_Byte(
3343 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3344 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3345
3346 } else {
3347 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3348 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3349 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3350 emitRCL_RegOff_Reg_Byte(
3351 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3352 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3353
3354 } else {
3355 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3356 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3357 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3358 emitRCL_RegIdx_Reg_Byte(
3359 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3360 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3361
3362 } else {
3363 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3364 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3365 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
3366 emitRCL_RegInd_Reg_Byte(
3367 getBase(MIR_BinaryAcc.getResult(inst)),
3368 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3369 }
3370 }
3371 }
3372 }
3373 }
3374
3375 } else {
3376 if (isWord(inst)) {
3377 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3378 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3379 emitRCL_Reg_Reg_Word(
3380 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3381 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3382
3383 } else {
3384 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3385 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3386 emitRCL_Abs_Reg_Word(
3387 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3388 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3389
3390 } else {
3391 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3392 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3393 emitRCL_RegDisp_Reg_Word(
3394 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3395 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3396
3397 } else {
3398 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3399 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3400 emitRCL_RegOff_Reg_Word(
3401 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3402 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3403
3404 } else {
3405 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3406 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3407 emitRCL_RegIdx_Reg_Word(
3408 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3409 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3410
3411 } else {
3412 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3413 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3414 emitRCL_RegInd_Reg_Word(
3415 getBase(MIR_BinaryAcc.getResult(inst)),
3416 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3417 }
3418 }
3419 }
3420 }
3421 }
3422
3423 } else {
3424 if (isQuad(inst)) {
3425 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3426 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3427 emitRCL_Reg_Reg_Quad(
3428 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3429 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3430
3431 } else {
3432 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3433 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3434 emitRCL_Abs_Reg_Quad(
3435 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3436 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3437
3438 } else {
3439 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3440 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3441 emitRCL_RegDisp_Reg_Quad(
3442 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3443 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3444
3445 } else {
3446 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3447 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3448 emitRCL_RegOff_Reg_Quad(
3449 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3450 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3451
3452 } else {
3453 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3454 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3455 emitRCL_RegIdx_Reg_Quad(
3456 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3457 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3458
3459 } else {
3460 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3461 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3462 emitRCL_RegInd_Reg_Quad(
3463 getBase(MIR_BinaryAcc.getResult(inst)),
3464 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3465 }
3466 }
3467 }
3468 }
3469 }
3470
3471 } else {
3472 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3473 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3474 emitRCL_Reg_Reg(
3475 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3476 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3477
3478 } else {
3479 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3480 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3481 emitRCL_Abs_Reg(
3482 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3483 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3484
3485 } else {
3486 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3487 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3488 emitRCL_RegDisp_Reg(
3489 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3490 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3491
3492 } else {
3493 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3494 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3495 emitRCL_RegOff_Reg(
3496 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3497 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3498
3499 } else {
3500 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3501 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3502 emitRCL_RegIdx_Reg(
3503 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3504 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3505
3506 } else {
3507 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3508 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3509 emitRCL_RegInd_Reg(
3510 getBase(MIR_BinaryAcc.getResult(inst)),
3511 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
3512 }
3513 }
3514 }
3515 }
3516 }
3517 }
3518 }
3519 }
3520 }
3521 }
3522
3523 /**
3524 * Emit the given instruction, assuming that
3525 * it is a MIR_Move instruction
3526 * and has a FLD operator
3527 *
3528 * @param inst the instruction to assemble
3529 */
3530 private void doFLD(Instruction inst) {
3531 if (isQuad(inst)) {
3532 if (isAbs(MIR_Move.getValue(inst))) {
3533 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3534 emitFLD_Reg_Abs_Quad(
3535 getFPR_Reg(MIR_Move.getResult(inst)),
3536 getDisp(MIR_Move.getValue(inst)).toWord().toAddress());
3537
3538 } else {
3539 if (isRegDisp(MIR_Move.getValue(inst))) {
3540 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3541 emitFLD_Reg_RegDisp_Quad(
3542 getFPR_Reg(MIR_Move.getResult(inst)),
3543 getBase(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
3544
3545 } else {
3546 if (isRegOff(MIR_Move.getValue(inst))) {
3547 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3548 emitFLD_Reg_RegOff_Quad(
3549 getFPR_Reg(MIR_Move.getResult(inst)),
3550 getIndex(MIR_Move.getValue(inst)), getScale(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
3551
3552 } else {
3553 if (isRegIdx(MIR_Move.getValue(inst))) {
3554 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3555 emitFLD_Reg_RegIdx_Quad(
3556 getFPR_Reg(MIR_Move.getResult(inst)),
3557 getBase(MIR_Move.getValue(inst)), getIndex(MIR_Move.getValue(inst)), getScale(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
3558
3559 } else {
3560 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3561 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
3562 emitFLD_Reg_RegInd_Quad(
3563 getFPR_Reg(MIR_Move.getResult(inst)),
3564 getBase(MIR_Move.getValue(inst)));
3565 }
3566 }
3567 }
3568 }
3569
3570 } else {
3571 if (isFPR_Reg(MIR_Move.getValue(inst))) {
3572 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3573 emitFLD_Reg_Reg(
3574 getFPR_Reg(MIR_Move.getResult(inst)),
3575 getFPR_Reg(MIR_Move.getValue(inst)));
3576
3577 } else {
3578 if (isAbs(MIR_Move.getValue(inst))) {
3579 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3580 emitFLD_Reg_Abs(
3581 getFPR_Reg(MIR_Move.getResult(inst)),
3582 getDisp(MIR_Move.getValue(inst)).toWord().toAddress());
3583
3584 } else {
3585 if (isRegDisp(MIR_Move.getValue(inst))) {
3586 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3587 emitFLD_Reg_RegDisp(
3588 getFPR_Reg(MIR_Move.getResult(inst)),
3589 getBase(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
3590
3591 } else {
3592 if (isRegOff(MIR_Move.getValue(inst))) {
3593 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3594 emitFLD_Reg_RegOff(
3595 getFPR_Reg(MIR_Move.getResult(inst)),
3596 getIndex(MIR_Move.getValue(inst)), getScale(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
3597
3598 } else {
3599 if (isRegIdx(MIR_Move.getValue(inst))) {
3600 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3601 emitFLD_Reg_RegIdx(
3602 getFPR_Reg(MIR_Move.getResult(inst)),
3603 getBase(MIR_Move.getValue(inst)), getIndex(MIR_Move.getValue(inst)), getScale(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
3604
3605 } else {
3606 if (VM.VerifyAssertions && !isFPR_Reg(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
3607 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
3608 emitFLD_Reg_RegInd(
3609 getFPR_Reg(MIR_Move.getResult(inst)),
3610 getBase(MIR_Move.getValue(inst)));
3611 }
3612 }
3613 }
3614 }
3615 }
3616 }
3617 }
3618
3619 /**
3620 * Emit the given instruction, assuming that
3621 * it is a MIR_Test instruction
3622 * and has a BTR operator
3623 *
3624 * @param inst the instruction to assemble
3625 */
3626 private void doBTR(Instruction inst) {
3627 if (isImm(MIR_Test.getVal2(inst))) {
3628 if (isGPR_Reg(MIR_Test.getVal1(inst))) {
3629 emitBTR_Reg_Imm(
3630 getGPR_Reg(MIR_Test.getVal1(inst)),
3631 getImm(MIR_Test.getVal2(inst)));
3632
3633 } else {
3634 if (isAbs(MIR_Test.getVal1(inst))) {
3635 emitBTR_Abs_Imm(
3636 getDisp(MIR_Test.getVal1(inst)).toWord().toAddress(),
3637 getImm(MIR_Test.getVal2(inst)));
3638
3639 } else {
3640 if (isRegDisp(MIR_Test.getVal1(inst))) {
3641 emitBTR_RegDisp_Imm(
3642 getBase(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3643 getImm(MIR_Test.getVal2(inst)));
3644
3645 } else {
3646 if (isRegOff(MIR_Test.getVal1(inst))) {
3647 emitBTR_RegOff_Imm(
3648 getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3649 getImm(MIR_Test.getVal2(inst)));
3650
3651 } else {
3652 if (isRegIdx(MIR_Test.getVal1(inst))) {
3653 emitBTR_RegIdx_Imm(
3654 getBase(MIR_Test.getVal1(inst)), getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3655 getImm(MIR_Test.getVal2(inst)));
3656
3657 } else {
3658 if (VM.VerifyAssertions && !isRegInd(MIR_Test.getVal1(inst))) VM._assert(false, inst.toString());
3659 emitBTR_RegInd_Imm(
3660 getBase(MIR_Test.getVal1(inst)),
3661 getImm(MIR_Test.getVal2(inst)));
3662 }
3663 }
3664 }
3665 }
3666 }
3667
3668 } else {
3669 if (isGPR_Reg(MIR_Test.getVal1(inst))) {
3670 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3671 emitBTR_Reg_Reg(
3672 getGPR_Reg(MIR_Test.getVal1(inst)),
3673 getGPR_Reg(MIR_Test.getVal2(inst)));
3674
3675 } else {
3676 if (isAbs(MIR_Test.getVal1(inst))) {
3677 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3678 emitBTR_Abs_Reg(
3679 getDisp(MIR_Test.getVal1(inst)).toWord().toAddress(),
3680 getGPR_Reg(MIR_Test.getVal2(inst)));
3681
3682 } else {
3683 if (isRegDisp(MIR_Test.getVal1(inst))) {
3684 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3685 emitBTR_RegDisp_Reg(
3686 getBase(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3687 getGPR_Reg(MIR_Test.getVal2(inst)));
3688
3689 } else {
3690 if (isRegOff(MIR_Test.getVal1(inst))) {
3691 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3692 emitBTR_RegOff_Reg(
3693 getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3694 getGPR_Reg(MIR_Test.getVal2(inst)));
3695
3696 } else {
3697 if (isRegIdx(MIR_Test.getVal1(inst))) {
3698 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3699 emitBTR_RegIdx_Reg(
3700 getBase(MIR_Test.getVal1(inst)), getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3701 getGPR_Reg(MIR_Test.getVal2(inst)));
3702
3703 } else {
3704 if (VM.VerifyAssertions && !isRegInd(MIR_Test.getVal1(inst))) VM._assert(false, inst.toString());
3705 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3706 emitBTR_RegInd_Reg(
3707 getBase(MIR_Test.getVal1(inst)),
3708 getGPR_Reg(MIR_Test.getVal2(inst)));
3709 }
3710 }
3711 }
3712 }
3713 }
3714 }
3715 }
3716
3717 /**
3718 * Emit the given instruction, assuming that
3719 * it is a MIR_Test instruction
3720 * and has a BTS operator
3721 *
3722 * @param inst the instruction to assemble
3723 */
3724 private void doBTS(Instruction inst) {
3725 if (isImm(MIR_Test.getVal2(inst))) {
3726 if (isGPR_Reg(MIR_Test.getVal1(inst))) {
3727 emitBTS_Reg_Imm(
3728 getGPR_Reg(MIR_Test.getVal1(inst)),
3729 getImm(MIR_Test.getVal2(inst)));
3730
3731 } else {
3732 if (isAbs(MIR_Test.getVal1(inst))) {
3733 emitBTS_Abs_Imm(
3734 getDisp(MIR_Test.getVal1(inst)).toWord().toAddress(),
3735 getImm(MIR_Test.getVal2(inst)));
3736
3737 } else {
3738 if (isRegDisp(MIR_Test.getVal1(inst))) {
3739 emitBTS_RegDisp_Imm(
3740 getBase(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3741 getImm(MIR_Test.getVal2(inst)));
3742
3743 } else {
3744 if (isRegOff(MIR_Test.getVal1(inst))) {
3745 emitBTS_RegOff_Imm(
3746 getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3747 getImm(MIR_Test.getVal2(inst)));
3748
3749 } else {
3750 if (isRegIdx(MIR_Test.getVal1(inst))) {
3751 emitBTS_RegIdx_Imm(
3752 getBase(MIR_Test.getVal1(inst)), getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3753 getImm(MIR_Test.getVal2(inst)));
3754
3755 } else {
3756 if (VM.VerifyAssertions && !isRegInd(MIR_Test.getVal1(inst))) VM._assert(false, inst.toString());
3757 emitBTS_RegInd_Imm(
3758 getBase(MIR_Test.getVal1(inst)),
3759 getImm(MIR_Test.getVal2(inst)));
3760 }
3761 }
3762 }
3763 }
3764 }
3765
3766 } else {
3767 if (isGPR_Reg(MIR_Test.getVal1(inst))) {
3768 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3769 emitBTS_Reg_Reg(
3770 getGPR_Reg(MIR_Test.getVal1(inst)),
3771 getGPR_Reg(MIR_Test.getVal2(inst)));
3772
3773 } else {
3774 if (isAbs(MIR_Test.getVal1(inst))) {
3775 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3776 emitBTS_Abs_Reg(
3777 getDisp(MIR_Test.getVal1(inst)).toWord().toAddress(),
3778 getGPR_Reg(MIR_Test.getVal2(inst)));
3779
3780 } else {
3781 if (isRegDisp(MIR_Test.getVal1(inst))) {
3782 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3783 emitBTS_RegDisp_Reg(
3784 getBase(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3785 getGPR_Reg(MIR_Test.getVal2(inst)));
3786
3787 } else {
3788 if (isRegOff(MIR_Test.getVal1(inst))) {
3789 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3790 emitBTS_RegOff_Reg(
3791 getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3792 getGPR_Reg(MIR_Test.getVal2(inst)));
3793
3794 } else {
3795 if (isRegIdx(MIR_Test.getVal1(inst))) {
3796 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3797 emitBTS_RegIdx_Reg(
3798 getBase(MIR_Test.getVal1(inst)), getIndex(MIR_Test.getVal1(inst)), getScale(MIR_Test.getVal1(inst)), getDisp(MIR_Test.getVal1(inst)),
3799 getGPR_Reg(MIR_Test.getVal2(inst)));
3800
3801 } else {
3802 if (VM.VerifyAssertions && !isRegInd(MIR_Test.getVal1(inst))) VM._assert(false, inst.toString());
3803 if (VM.VerifyAssertions && !isGPR_Reg(MIR_Test.getVal2(inst))) VM._assert(false, inst.toString());
3804 emitBTS_RegInd_Reg(
3805 getBase(MIR_Test.getVal1(inst)),
3806 getGPR_Reg(MIR_Test.getVal2(inst)));
3807 }
3808 }
3809 }
3810 }
3811 }
3812 }
3813 }
3814
3815 /**
3816 * Emit the given instruction, assuming that
3817 * it is a MIR_BinaryAcc instruction
3818 * and has a RCR operator
3819 *
3820 * @param inst the instruction to assemble
3821 */
3822 private void doRCR(Instruction inst) {
3823 if (isImm(MIR_BinaryAcc.getValue(inst))) {
3824 if (isByte(inst)) {
3825 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3826 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
3827 emitRCR_Reg_Imm_Byte(
3828 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3829 getImm(MIR_BinaryAcc.getValue(inst)));
3830
3831 } else {
3832 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3833 emitRCR_Abs_Imm_Byte(
3834 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3835 getImm(MIR_BinaryAcc.getValue(inst)));
3836
3837 } else {
3838 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3839 emitRCR_RegDisp_Imm_Byte(
3840 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3841 getImm(MIR_BinaryAcc.getValue(inst)));
3842
3843 } else {
3844 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3845 emitRCR_RegOff_Imm_Byte(
3846 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3847 getImm(MIR_BinaryAcc.getValue(inst)));
3848
3849 } else {
3850 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3851 emitRCR_RegIdx_Imm_Byte(
3852 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3853 getImm(MIR_BinaryAcc.getValue(inst)));
3854
3855 } else {
3856 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3857 emitRCR_RegInd_Imm_Byte(
3858 getBase(MIR_BinaryAcc.getResult(inst)),
3859 getImm(MIR_BinaryAcc.getValue(inst)));
3860 }
3861 }
3862 }
3863 }
3864 }
3865
3866 } else {
3867 if (isWord(inst)) {
3868 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3869 emitRCR_Reg_Imm_Word(
3870 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3871 getImm(MIR_BinaryAcc.getValue(inst)));
3872
3873 } else {
3874 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3875 emitRCR_Abs_Imm_Word(
3876 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3877 getImm(MIR_BinaryAcc.getValue(inst)));
3878
3879 } else {
3880 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3881 emitRCR_RegDisp_Imm_Word(
3882 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3883 getImm(MIR_BinaryAcc.getValue(inst)));
3884
3885 } else {
3886 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3887 emitRCR_RegOff_Imm_Word(
3888 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3889 getImm(MIR_BinaryAcc.getValue(inst)));
3890
3891 } else {
3892 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3893 emitRCR_RegIdx_Imm_Word(
3894 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3895 getImm(MIR_BinaryAcc.getValue(inst)));
3896
3897 } else {
3898 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3899 emitRCR_RegInd_Imm_Word(
3900 getBase(MIR_BinaryAcc.getResult(inst)),
3901 getImm(MIR_BinaryAcc.getValue(inst)));
3902 }
3903 }
3904 }
3905 }
3906 }
3907
3908 } else {
3909 if (isQuad(inst)) {
3910 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3911 emitRCR_Reg_Imm_Quad(
3912 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3913 getImm(MIR_BinaryAcc.getValue(inst)));
3914
3915 } else {
3916 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3917 emitRCR_Abs_Imm_Quad(
3918 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3919 getImm(MIR_BinaryAcc.getValue(inst)));
3920
3921 } else {
3922 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3923 emitRCR_RegDisp_Imm_Quad(
3924 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3925 getImm(MIR_BinaryAcc.getValue(inst)));
3926
3927 } else {
3928 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3929 emitRCR_RegOff_Imm_Quad(
3930 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3931 getImm(MIR_BinaryAcc.getValue(inst)));
3932
3933 } else {
3934 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3935 emitRCR_RegIdx_Imm_Quad(
3936 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3937 getImm(MIR_BinaryAcc.getValue(inst)));
3938
3939 } else {
3940 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3941 emitRCR_RegInd_Imm_Quad(
3942 getBase(MIR_BinaryAcc.getResult(inst)),
3943 getImm(MIR_BinaryAcc.getValue(inst)));
3944 }
3945 }
3946 }
3947 }
3948 }
3949
3950 } else {
3951 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3952 emitRCR_Reg_Imm(
3953 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
3954 getImm(MIR_BinaryAcc.getValue(inst)));
3955
3956 } else {
3957 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
3958 emitRCR_Abs_Imm(
3959 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
3960 getImm(MIR_BinaryAcc.getValue(inst)));
3961
3962 } else {
3963 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
3964 emitRCR_RegDisp_Imm(
3965 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3966 getImm(MIR_BinaryAcc.getValue(inst)));
3967
3968 } else {
3969 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
3970 emitRCR_RegOff_Imm(
3971 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3972 getImm(MIR_BinaryAcc.getValue(inst)));
3973
3974 } else {
3975 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
3976 emitRCR_RegIdx_Imm(
3977 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
3978 getImm(MIR_BinaryAcc.getValue(inst)));
3979
3980 } else {
3981 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
3982 emitRCR_RegInd_Imm(
3983 getBase(MIR_BinaryAcc.getResult(inst)),
3984 getImm(MIR_BinaryAcc.getValue(inst)));
3985 }
3986 }
3987 }
3988 }
3989 }
3990 }
3991 }
3992 }
3993
3994 } else {
3995 if (isByte(inst)) {
3996 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
3997 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
3998 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
3999 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
4000 emitRCR_Reg_Reg_Byte(
4001 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
4002 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4003
4004 } else {
4005 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
4006 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4007 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
4008 emitRCR_Abs_Reg_Byte(
4009 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
4010 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4011
4012 } else {
4013 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
4014 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4015 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
4016 emitRCR_RegDisp_Reg_Byte(
4017 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4018 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4019
4020 } else {
4021 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
4022 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4023 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
4024 emitRCR_RegOff_Reg_Byte(
4025 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4026 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4027
4028 } else {
4029 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
4030 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4031 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
4032 emitRCR_RegIdx_Reg_Byte(
4033 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4034 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4035
4036 } else {
4037 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4038 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4039 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_BinaryAcc.getValue(inst)).value() < 4)) VM._assert(false, inst.toString());
4040 emitRCR_RegInd_Reg_Byte(
4041 getBase(MIR_BinaryAcc.getResult(inst)),
4042 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4043 }
4044 }
4045 }
4046 }
4047 }
4048
4049 } else {
4050 if (isWord(inst)) {
4051 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
4052 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4053 emitRCR_Reg_Reg_Word(
4054 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
4055 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4056
4057 } else {
4058 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
4059 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4060 emitRCR_Abs_Reg_Word(
4061 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
4062 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4063
4064 } else {
4065 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
4066 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4067 emitRCR_RegDisp_Reg_Word(
4068 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4069 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4070
4071 } else {
4072 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
4073 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4074 emitRCR_RegOff_Reg_Word(
4075 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4076 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4077
4078 } else {
4079 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
4080 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4081 emitRCR_RegIdx_Reg_Word(
4082 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4083 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4084
4085 } else {
4086 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4087 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4088 emitRCR_RegInd_Reg_Word(
4089 getBase(MIR_BinaryAcc.getResult(inst)),
4090 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4091 }
4092 }
4093 }
4094 }
4095 }
4096
4097 } else {
4098 if (isQuad(inst)) {
4099 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
4100 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4101 emitRCR_Reg_Reg_Quad(
4102 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
4103 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4104
4105 } else {
4106 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
4107 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4108 emitRCR_Abs_Reg_Quad(
4109 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
4110 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4111
4112 } else {
4113 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
4114 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4115 emitRCR_RegDisp_Reg_Quad(
4116 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4117 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4118
4119 } else {
4120 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
4121 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4122 emitRCR_RegOff_Reg_Quad(
4123 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4124 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4125
4126 } else {
4127 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
4128 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4129 emitRCR_RegIdx_Reg_Quad(
4130 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4131 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4132
4133 } else {
4134 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4135 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4136 emitRCR_RegInd_Reg_Quad(
4137 getBase(MIR_BinaryAcc.getResult(inst)),
4138 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4139 }
4140 }
4141 }
4142 }
4143 }
4144
4145 } else {
4146 if (isGPR_Reg(MIR_BinaryAcc.getResult(inst))) {
4147 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4148 emitRCR_Reg_Reg(
4149 getGPR_Reg(MIR_BinaryAcc.getResult(inst)),
4150 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4151
4152 } else {
4153 if (isAbs(MIR_BinaryAcc.getResult(inst))) {
4154 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4155 emitRCR_Abs_Reg(
4156 getDisp(MIR_BinaryAcc.getResult(inst)).toWord().toAddress(),
4157 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4158
4159 } else {
4160 if (isRegDisp(MIR_BinaryAcc.getResult(inst))) {
4161 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4162 emitRCR_RegDisp_Reg(
4163 getBase(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4164 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4165
4166 } else {
4167 if (isRegOff(MIR_BinaryAcc.getResult(inst))) {
4168 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4169 emitRCR_RegOff_Reg(
4170 getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4171 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4172
4173 } else {
4174 if (isRegIdx(MIR_BinaryAcc.getResult(inst))) {
4175 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4176 emitRCR_RegIdx_Reg(
4177 getBase(MIR_BinaryAcc.getResult(inst)), getIndex(MIR_BinaryAcc.getResult(inst)), getScale(MIR_BinaryAcc.getResult(inst)), getDisp(MIR_BinaryAcc.getResult(inst)),
4178 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4179
4180 } else {
4181 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4182 if (VM.VerifyAssertions && !isGPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4183 emitRCR_RegInd_Reg(
4184 getBase(MIR_BinaryAcc.getResult(inst)),
4185 getGPR_Reg(MIR_BinaryAcc.getValue(inst)));
4186 }
4187 }
4188 }
4189 }
4190 }
4191 }
4192 }
4193 }
4194 }
4195 }
4196
4197 /**
4198 * Emit the given instruction, assuming that
4199 * it is a MIR_Set instruction
4200 * and has a SET operator
4201 *
4202 * @param inst the instruction to assemble
4203 */
4204 private void doSET(Instruction inst) {
4205 if (isGPR_Reg(MIR_Set.getResult(inst))) {
4206 if (VM.VerifyAssertions && !isCond(MIR_Set.getCond(inst))) VM._assert(false, inst.toString());
4207 if (VM.VerifyAssertions && !isByte(inst)) VM._assert(false, inst.toString());
4208 if (VM.VerifyAssertions && !(getGPR_Reg(MIR_Set.getResult(inst)).value() < 4)) VM._assert(false, inst.toString());
4209 emitSET_Cond_Reg_Byte(
4210 getCond(MIR_Set.getCond(inst)),
4211 getGPR_Reg(MIR_Set.getResult(inst)));
4212
4213 } else {
4214 if (isAbs(MIR_Set.getResult(inst))) {
4215 if (VM.VerifyAssertions && !isCond(MIR_Set.getCond(inst))) VM._assert(false, inst.toString());
4216 if (VM.VerifyAssertions && !isByte(inst)) VM._assert(false, inst.toString());
4217 emitSET_Cond_Abs_Byte(
4218 getCond(MIR_Set.getCond(inst)),
4219 getDisp(MIR_Set.getResult(inst)).toWord().toAddress());
4220
4221 } else {
4222 if (isRegDisp(MIR_Set.getResult(inst))) {
4223 if (VM.VerifyAssertions && !isCond(MIR_Set.getCond(inst))) VM._assert(false, inst.toString());
4224 if (VM.VerifyAssertions && !isByte(inst)) VM._assert(false, inst.toString());
4225 emitSET_Cond_RegDisp_Byte(
4226 getCond(MIR_Set.getCond(inst)),
4227 getBase(MIR_Set.getResult(inst)), getDisp(MIR_Set.getResult(inst)));
4228
4229 } else {
4230 if (isRegOff(MIR_Set.getResult(inst))) {
4231 if (VM.VerifyAssertions && !isCond(MIR_Set.getCond(inst))) VM._assert(false, inst.toString());
4232 if (VM.VerifyAssertions && !isByte(inst)) VM._assert(false, inst.toString());
4233 emitSET_Cond_RegOff_Byte(
4234 getCond(MIR_Set.getCond(inst)),
4235 getIndex(MIR_Set.getResult(inst)), getScale(MIR_Set.getResult(inst)), getDisp(MIR_Set.getResult(inst)));
4236
4237 } else {
4238 if (isRegIdx(MIR_Set.getResult(inst))) {
4239 if (VM.VerifyAssertions && !isCond(MIR_Set.getCond(inst))) VM._assert(false, inst.toString());
4240 if (VM.VerifyAssertions && !isByte(inst)) VM._assert(false, inst.toString());
4241 emitSET_Cond_RegIdx_Byte(
4242 getCond(MIR_Set.getCond(inst)),
4243 getBase(MIR_Set.getResult(inst)), getIndex(MIR_Set.getResult(inst)), getScale(MIR_Set.getResult(inst)), getDisp(MIR_Set.getResult(inst)));
4244
4245 } else {
4246 if (VM.VerifyAssertions && !isCond(MIR_Set.getCond(inst))) VM._assert(false, inst.toString());
4247 if (VM.VerifyAssertions && !isRegInd(MIR_Set.getResult(inst))) VM._assert(false, inst.toString());
4248 if (VM.VerifyAssertions && !isByte(inst)) VM._assert(false, inst.toString());
4249 emitSET_Cond_RegInd_Byte(
4250 getCond(MIR_Set.getCond(inst)),
4251 getBase(MIR_Set.getResult(inst)));
4252 }
4253 }
4254 }
4255 }
4256 }
4257 }
4258
4259 /**
4260 * Emit the given instruction, assuming that
4261 * it is a MIR_BinaryAcc instruction
4262 * and has a FIDIVR operator
4263 *
4264 * @param inst the instruction to assemble
4265 */
4266 private void doFIDIVR(Instruction inst) {
4267 if (isWord(inst)) {
4268 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
4269 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4270 emitFIDIVR_Reg_Abs_Word(
4271 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4272 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
4273
4274 } else {
4275 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
4276 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4277 emitFIDIVR_Reg_RegDisp_Word(
4278 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4279 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4280
4281 } else {
4282 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
4283 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4284 emitFIDIVR_Reg_RegOff_Word(
4285 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4286 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4287
4288 } else {
4289 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
4290 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4291 emitFIDIVR_Reg_RegIdx_Word(
4292 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4293 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4294
4295 } else {
4296 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4297 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4298 emitFIDIVR_Reg_RegInd_Word(
4299 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4300 getBase(MIR_BinaryAcc.getValue(inst)));
4301 }
4302 }
4303 }
4304 }
4305
4306 } else {
4307 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
4308 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4309 emitFIDIVR_Reg_Abs(
4310 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4311 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
4312
4313 } else {
4314 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
4315 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4316 emitFIDIVR_Reg_RegDisp(
4317 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4318 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4319
4320 } else {
4321 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
4322 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4323 emitFIDIVR_Reg_RegOff(
4324 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4325 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4326
4327 } else {
4328 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
4329 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4330 emitFIDIVR_Reg_RegIdx(
4331 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4332 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4333
4334 } else {
4335 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4336 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4337 emitFIDIVR_Reg_RegInd(
4338 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4339 getBase(MIR_BinaryAcc.getValue(inst)));
4340 }
4341 }
4342 }
4343 }
4344 }
4345 }
4346
4347 /**
4348 * Emit the given instruction, assuming that
4349 * it is a MIR_FSave instruction
4350 * and has a FNSAVE operator
4351 *
4352 * @param inst the instruction to assemble
4353 */
4354 private void doFNSAVE(Instruction inst) {
4355 if (isAbs(MIR_FSave.getDestination(inst))) {
4356 emitFNSAVE_Abs(
4357 getDisp(MIR_FSave.getDestination(inst)).toWord().toAddress());
4358
4359 } else {
4360 if (isRegDisp(MIR_FSave.getDestination(inst))) {
4361 emitFNSAVE_RegDisp(
4362 getBase(MIR_FSave.getDestination(inst)), getDisp(MIR_FSave.getDestination(inst)));
4363
4364 } else {
4365 if (isRegOff(MIR_FSave.getDestination(inst))) {
4366 emitFNSAVE_RegOff(
4367 getIndex(MIR_FSave.getDestination(inst)), getScale(MIR_FSave.getDestination(inst)), getDisp(MIR_FSave.getDestination(inst)));
4368
4369 } else {
4370 if (isRegIdx(MIR_FSave.getDestination(inst))) {
4371 emitFNSAVE_RegIdx(
4372 getBase(MIR_FSave.getDestination(inst)), getIndex(MIR_FSave.getDestination(inst)), getScale(MIR_FSave.getDestination(inst)), getDisp(MIR_FSave.getDestination(inst)));
4373
4374 } else {
4375 if (VM.VerifyAssertions && !isRegInd(MIR_FSave.getDestination(inst))) VM._assert(false, inst.toString());
4376 emitFNSAVE_RegInd(
4377 getBase(MIR_FSave.getDestination(inst)));
4378 }
4379 }
4380 }
4381 }
4382 }
4383
4384 /**
4385 * Emit the given instruction, assuming that
4386 * it is a MIR_BinaryAcc instruction
4387 * and has a FDIVP operator
4388 *
4389 * @param inst the instruction to assemble
4390 */
4391 private void doFDIVP(Instruction inst) {
4392 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4393 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4394 emitFDIVP_Reg_Reg(
4395 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4396 getFPR_Reg(MIR_BinaryAcc.getValue(inst)));
4397 }
4398
4399 /**
4400 * Emit the given instruction, assuming that
4401 * it is a MIR_Move instruction
4402 * and has a MOVSD operator
4403 *
4404 * @param inst the instruction to assemble
4405 */
4406 private void doMOVSD(Instruction inst) {
4407 if (isXMM_Reg(MIR_Move.getResult(inst))) {
4408 if (isXMM_Reg(MIR_Move.getValue(inst))) {
4409 emitMOVSD_Reg_Reg(
4410 getXMM_Reg(MIR_Move.getResult(inst)),
4411 getXMM_Reg(MIR_Move.getValue(inst)));
4412
4413 } else {
4414 if (isAbs(MIR_Move.getValue(inst))) {
4415 emitMOVSD_Reg_Abs(
4416 getXMM_Reg(MIR_Move.getResult(inst)),
4417 getDisp(MIR_Move.getValue(inst)).toWord().toAddress());
4418
4419 } else {
4420 if (isRegDisp(MIR_Move.getValue(inst))) {
4421 emitMOVSD_Reg_RegDisp(
4422 getXMM_Reg(MIR_Move.getResult(inst)),
4423 getBase(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
4424
4425 } else {
4426 if (isRegOff(MIR_Move.getValue(inst))) {
4427 emitMOVSD_Reg_RegOff(
4428 getXMM_Reg(MIR_Move.getResult(inst)),
4429 getIndex(MIR_Move.getValue(inst)), getScale(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
4430
4431 } else {
4432 if (isRegIdx(MIR_Move.getValue(inst))) {
4433 emitMOVSD_Reg_RegIdx(
4434 getXMM_Reg(MIR_Move.getResult(inst)),
4435 getBase(MIR_Move.getValue(inst)), getIndex(MIR_Move.getValue(inst)), getScale(MIR_Move.getValue(inst)), getDisp(MIR_Move.getValue(inst)));
4436
4437 } else {
4438 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
4439 emitMOVSD_Reg_RegInd(
4440 getXMM_Reg(MIR_Move.getResult(inst)),
4441 getBase(MIR_Move.getValue(inst)));
4442 }
4443 }
4444 }
4445 }
4446 }
4447
4448 } else {
4449 if (isAbs(MIR_Move.getResult(inst))) {
4450 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
4451 emitMOVSD_Abs_Reg(
4452 getDisp(MIR_Move.getResult(inst)).toWord().toAddress(),
4453 getXMM_Reg(MIR_Move.getValue(inst)));
4454
4455 } else {
4456 if (isRegDisp(MIR_Move.getResult(inst))) {
4457 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
4458 emitMOVSD_RegDisp_Reg(
4459 getBase(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
4460 getXMM_Reg(MIR_Move.getValue(inst)));
4461
4462 } else {
4463 if (isRegOff(MIR_Move.getResult(inst))) {
4464 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
4465 emitMOVSD_RegOff_Reg(
4466 getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
4467 getXMM_Reg(MIR_Move.getValue(inst)));
4468
4469 } else {
4470 if (isRegIdx(MIR_Move.getResult(inst))) {
4471 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
4472 emitMOVSD_RegIdx_Reg(
4473 getBase(MIR_Move.getResult(inst)), getIndex(MIR_Move.getResult(inst)), getScale(MIR_Move.getResult(inst)), getDisp(MIR_Move.getResult(inst)),
4474 getXMM_Reg(MIR_Move.getValue(inst)));
4475
4476 } else {
4477 if (VM.VerifyAssertions && !isRegInd(MIR_Move.getResult(inst))) VM._assert(false, inst.toString());
4478 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Move.getValue(inst))) VM._assert(false, inst.toString());
4479 emitMOVSD_RegInd_Reg(
4480 getBase(MIR_Move.getResult(inst)),
4481 getXMM_Reg(MIR_Move.getValue(inst)));
4482 }
4483 }
4484 }
4485 }
4486 }
4487 }
4488
4489 /**
4490 * Emit the given instruction, assuming that
4491 * it is a MIR_BinaryAcc instruction
4492 * and has a FDIVR operator
4493 *
4494 * @param inst the instruction to assemble
4495 */
4496 private void doFDIVR(Instruction inst) {
4497 if (isQuad(inst)) {
4498 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
4499 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4500 emitFDIVR_Reg_Abs_Quad(
4501 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4502 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
4503
4504 } else {
4505 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
4506 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4507 emitFDIVR_Reg_RegDisp_Quad(
4508 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4509 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4510
4511 } else {
4512 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
4513 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4514 emitFDIVR_Reg_RegOff_Quad(
4515 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4516 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4517
4518 } else {
4519 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
4520 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4521 emitFDIVR_Reg_RegIdx_Quad(
4522 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4523 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4524
4525 } else {
4526 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4527 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4528 emitFDIVR_Reg_RegInd_Quad(
4529 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4530 getBase(MIR_BinaryAcc.getValue(inst)));
4531 }
4532 }
4533 }
4534 }
4535
4536 } else {
4537 if (isFPR_Reg(MIR_BinaryAcc.getValue(inst))) {
4538 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4539 emitFDIVR_Reg_Reg(
4540 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4541 getFPR_Reg(MIR_BinaryAcc.getValue(inst)));
4542
4543 } else {
4544 if (isAbs(MIR_BinaryAcc.getValue(inst))) {
4545 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4546 emitFDIVR_Reg_Abs(
4547 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4548 getDisp(MIR_BinaryAcc.getValue(inst)).toWord().toAddress());
4549
4550 } else {
4551 if (isRegDisp(MIR_BinaryAcc.getValue(inst))) {
4552 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4553 emitFDIVR_Reg_RegDisp(
4554 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4555 getBase(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4556
4557 } else {
4558 if (isRegOff(MIR_BinaryAcc.getValue(inst))) {
4559 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4560 emitFDIVR_Reg_RegOff(
4561 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4562 getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4563
4564 } else {
4565 if (isRegIdx(MIR_BinaryAcc.getValue(inst))) {
4566 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4567 emitFDIVR_Reg_RegIdx(
4568 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4569 getBase(MIR_BinaryAcc.getValue(inst)), getIndex(MIR_BinaryAcc.getValue(inst)), getScale(MIR_BinaryAcc.getValue(inst)), getDisp(MIR_BinaryAcc.getValue(inst)));
4570
4571 } else {
4572 if (VM.VerifyAssertions && !isFPR_Reg(MIR_BinaryAcc.getResult(inst))) VM._assert(false, inst.toString());
4573 if (VM.VerifyAssertions && !isRegInd(MIR_BinaryAcc.getValue(inst))) VM._assert(false, inst.toString());
4574 emitFDIVR_Reg_RegInd(
4575 getFPR_Reg(MIR_BinaryAcc.getResult(inst)),
4576 getBase(MIR_BinaryAcc.getValue(inst)));
4577 }
4578 }
4579 }
4580 }
4581 }
4582 }
4583 }
4584
4585 /**
4586 * Emit the given instruction, assuming that
4587 * it is a MIR_DoubleShift instruction
4588 * and has a SHRD operator
4589 *
4590 * @param inst the instruction to assemble
4591 */
4592 private void doSHRD(Instruction inst) {
4593 if (isQuad(inst)) {
4594 if (isImm(MIR_DoubleShift.getBitsToShift(inst))) {
4595 if (isGPR_Reg(MIR_DoubleShift.getResult(inst))) {
4596 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4597 emitSHRD_Reg_Reg_Imm_Quad(
4598 getGPR_Reg(MIR_DoubleShift.getResult(inst)),
4599 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4600 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4601
4602 } else {
4603 if (isAbs(MIR_DoubleShift.getResult(inst))) {
4604 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4605 emitSHRD_Abs_Reg_Imm_Quad(
4606 getDisp(MIR_DoubleShift.getResult(inst)).toWord().toAddress(),
4607 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4608 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4609
4610 } else {
4611 if (isRegDisp(MIR_DoubleShift.getResult(inst))) {
4612 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4613 emitSHRD_RegDisp_Reg_Imm_Quad(
4614 getBase(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4615 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4616 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4617
4618 } else {
4619 if (isRegOff(MIR_DoubleShift.getResult(inst))) {
4620 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4621 emitSHRD_RegOff_Reg_Imm_Quad(
4622 getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4623 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4624 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4625
4626 } else {
4627 if (isRegIdx(MIR_DoubleShift.getResult(inst))) {
4628 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4629 emitSHRD_RegIdx_Reg_Imm_Quad(
4630 getBase(MIR_DoubleShift.getResult(inst)), getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4631 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4632 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4633
4634 } else {
4635 if (VM.VerifyAssertions && !isRegInd(MIR_DoubleShift.getResult(inst))) VM._assert(false, inst.toString());
4636 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4637 emitSHRD_RegInd_Reg_Imm_Quad(
4638 getBase(MIR_DoubleShift.getResult(inst)),
4639 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4640 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4641 }
4642 }
4643 }
4644 }
4645 }
4646
4647 } else {
4648 if (isGPR_Reg(MIR_DoubleShift.getResult(inst))) {
4649 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4650 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4651 emitSHRD_Reg_Reg_Reg_Quad(
4652 getGPR_Reg(MIR_DoubleShift.getResult(inst)),
4653 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4654 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4655
4656 } else {
4657 if (isAbs(MIR_DoubleShift.getResult(inst))) {
4658 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4659 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4660 emitSHRD_Abs_Reg_Reg_Quad(
4661 getDisp(MIR_DoubleShift.getResult(inst)).toWord().toAddress(),
4662 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4663 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4664
4665 } else {
4666 if (isRegDisp(MIR_DoubleShift.getResult(inst))) {
4667 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4668 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4669 emitSHRD_RegDisp_Reg_Reg_Quad(
4670 getBase(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4671 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4672 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4673
4674 } else {
4675 if (isRegOff(MIR_DoubleShift.getResult(inst))) {
4676 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4677 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4678 emitSHRD_RegOff_Reg_Reg_Quad(
4679 getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4680 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4681 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4682
4683 } else {
4684 if (isRegIdx(MIR_DoubleShift.getResult(inst))) {
4685 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4686 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4687 emitSHRD_RegIdx_Reg_Reg_Quad(
4688 getBase(MIR_DoubleShift.getResult(inst)), getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4689 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4690 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4691
4692 } else {
4693 if (VM.VerifyAssertions && !isRegInd(MIR_DoubleShift.getResult(inst))) VM._assert(false, inst.toString());
4694 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4695 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4696 emitSHRD_RegInd_Reg_Reg_Quad(
4697 getBase(MIR_DoubleShift.getResult(inst)),
4698 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4699 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4700 }
4701 }
4702 }
4703 }
4704 }
4705 }
4706
4707 } else {
4708 if (isImm(MIR_DoubleShift.getBitsToShift(inst))) {
4709 if (isGPR_Reg(MIR_DoubleShift.getResult(inst))) {
4710 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4711 emitSHRD_Reg_Reg_Imm(
4712 getGPR_Reg(MIR_DoubleShift.getResult(inst)),
4713 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4714 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4715
4716 } else {
4717 if (isAbs(MIR_DoubleShift.getResult(inst))) {
4718 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4719 emitSHRD_Abs_Reg_Imm(
4720 getDisp(MIR_DoubleShift.getResult(inst)).toWord().toAddress(),
4721 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4722 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4723
4724 } else {
4725 if (isRegDisp(MIR_DoubleShift.getResult(inst))) {
4726 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4727 emitSHRD_RegDisp_Reg_Imm(
4728 getBase(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4729 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4730 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4731
4732 } else {
4733 if (isRegOff(MIR_DoubleShift.getResult(inst))) {
4734 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4735 emitSHRD_RegOff_Reg_Imm(
4736 getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4737 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4738 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4739
4740 } else {
4741 if (isRegIdx(MIR_DoubleShift.getResult(inst))) {
4742 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4743 emitSHRD_RegIdx_Reg_Imm(
4744 getBase(MIR_DoubleShift.getResult(inst)), getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4745 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4746 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4747
4748 } else {
4749 if (VM.VerifyAssertions && !isRegInd(MIR_DoubleShift.getResult(inst))) VM._assert(false, inst.toString());
4750 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4751 emitSHRD_RegInd_Reg_Imm(
4752 getBase(MIR_DoubleShift.getResult(inst)),
4753 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4754 getImm(MIR_DoubleShift.getBitsToShift(inst)));
4755 }
4756 }
4757 }
4758 }
4759 }
4760
4761 } else {
4762 if (isGPR_Reg(MIR_DoubleShift.getResult(inst))) {
4763 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4764 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4765 emitSHRD_Reg_Reg_Reg(
4766 getGPR_Reg(MIR_DoubleShift.getResult(inst)),
4767 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4768 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4769
4770 } else {
4771 if (isAbs(MIR_DoubleShift.getResult(inst))) {
4772 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4773 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4774 emitSHRD_Abs_Reg_Reg(
4775 getDisp(MIR_DoubleShift.getResult(inst)).toWord().toAddress(),
4776 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4777 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4778
4779 } else {
4780 if (isRegDisp(MIR_DoubleShift.getResult(inst))) {
4781 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4782 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4783 emitSHRD_RegDisp_Reg_Reg(
4784 getBase(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4785 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4786 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4787
4788 } else {
4789 if (isRegOff(MIR_DoubleShift.getResult(inst))) {
4790 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4791 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4792 emitSHRD_RegOff_Reg_Reg(
4793 getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4794 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4795 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4796
4797 } else {
4798 if (isRegIdx(MIR_DoubleShift.getResult(inst))) {
4799 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4800 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4801 emitSHRD_RegIdx_Reg_Reg(
4802 getBase(MIR_DoubleShift.getResult(inst)), getIndex(MIR_DoubleShift.getResult(inst)), getScale(MIR_DoubleShift.getResult(inst)), getDisp(MIR_DoubleShift.getResult(inst)),
4803 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4804 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4805
4806 } else {
4807 if (VM.VerifyAssertions && !isRegInd(MIR_DoubleShift.getResult(inst))) VM._assert(false, inst.toString());
4808 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getSource(inst))) VM._assert(false, inst.toString());
4809 if (VM.VerifyAssertions && !isGPR_Reg(MIR_DoubleShift.getBitsToShift(inst))) VM._assert(false, inst.toString());
4810 emitSHRD_RegInd_Reg_Reg(
4811 getBase(MIR_DoubleShift.getResult(inst)),
4812 getGPR_Reg(MIR_DoubleShift.getSource(inst)),
4813 getGPR_Reg(MIR_DoubleShift.getBitsToShift(inst)));
4814 }
4815 }
4816 }
4817 }
4818 }
4819 }
4820 }
4821 }
4822
4823 /**
4824 * Emit the given instruction, assuming that
4825 * it is a MIR_Unary instruction
4826 * and has a CVTSI2SD operator
4827 *
4828 * @param inst the instruction to assemble
4829 */
4830 private void doCVTSI2SD(Instruction inst) {
4831 if (isGPR_Reg(MIR_Unary.getVal(inst))) {
4832 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
4833 emitCVTSI2SD_Reg_Reg(
4834 getXMM_Reg(MIR_Unary.getResult(inst)),
4835 getGPR_Reg(MIR_Unary.getVal(inst)));
4836
4837 } else {
4838 if (isAbs(MIR_Unary.getVal(inst))) {
4839 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
4840 emitCVTSI2SD_Reg_Abs(
4841 getXMM_Reg(MIR_Unary.getResult(inst)),
4842 getDisp(MIR_Unary.getVal(inst)).toWord().toAddress());
4843
4844 } else {
4845 if (isRegDisp(MIR_Unary.getVal(inst))) {
4846 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
4847 emitCVTSI2SD_Reg_RegDisp(
4848 getXMM_Reg(MIR_Unary.getResult(inst)),
4849 getBase(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
4850
4851 } else {
4852 if (isRegOff(MIR_Unary.getVal(inst))) {
4853 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
4854 emitCVTSI2SD_Reg_RegOff(
4855 getXMM_Reg(MIR_Unary.getResult(inst)),
4856 getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
4857
4858 } else {
4859 if (isRegIdx(MIR_Unary.getVal(inst))) {
4860 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
4861 emitCVTSI2SD_Reg_RegIdx(
4862 getXMM_Reg(MIR_Unary.getResult(inst)),
4863 getBase(MIR_Unary.getVal(inst)), getIndex(MIR_Unary.getVal(inst)), getScale(MIR_Unary.getVal(inst)), getDisp(MIR_Unary.getVal(inst)));
4864
4865 } else {
4866 if (VM.VerifyAssertions && !isXMM_Reg(MIR_Unary.getResult(inst))) VM._assert(false, inst.toString());
4867 if (VM.VerifyAssertions && !isRegInd(MIR_Unary.getVal(inst))) VM._assert(false, inst.toString());
4868 emitCVTSI2SD_Reg_RegInd(
4869 getXMM_Reg(MIR_Unary.getResult(inst)),
4870 getBase(MIR_Unary.getVal(inst)));
4871 }
4872 }
4873 }
4874 }
4875 }
4876 }
4877
4878 /**