src/vm/jit/x86_64/emitfuncs.c

   1 /* vm/jit/x86_64/emitfuncs.c - x86_64 code emitter functions
   2
   3    Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Christian Thalinger
  28
  29    $Id: emitfuncs.c 2103 2005-03-28 22:12:23Z christian $
  30
  31 */
  32
  33
  34 #include "vm/jit/jit.h"
  35 #include "vm/jit/x86_64/codegen.h"
  36 #include "vm/jit/x86_64/emitfuncs.h"
  37 #include "vm/jit/x86_64/types.h"
  38
  39
  40 /* code generation functions */
  41
  42 void x86_64_emit_ialu(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
  43 {
  44         s4 s1 = src->prev->regoff;
  45         s4 s2 = src->regoff;
  46         s4 d = iptr->dst->regoff;
  47
  48         if (iptr->dst->flags & INMEMORY) {
  49                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  50                         if (s2 == d) {
  51                                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
  52                                 x86_64_alul_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, d * 8);
  53
  54                         } else if (s1 == d) {
  55                                 x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, REG_ITMP1);
  56                                 x86_64_alul_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, d * 8);
  57
  58                         } else {
  59                                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
  60                                 x86_64_alul_membase_reg(cd, alu_op, REG_SP, s2 * 8, REG_ITMP1);
  61                                 x86_64_movl_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
  62                         }
  63
  64                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
  65                         if (s2 == d) {
  66                                 x86_64_alul_reg_membase(cd, alu_op, s1, REG_SP, d * 8);
  67
  68                         } else {
  69                                 x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, REG_ITMP1);
  70                                 x86_64_alul_reg_reg(cd, alu_op, s1, REG_ITMP1);
  71                                 x86_64_movl_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
  72                         }
  73
  74                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  75                         if (s1 == d) {
  76                                 x86_64_alul_reg_membase(cd, alu_op, s2, REG_SP, d * 8);
  77
  78                         } else {
  79                                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
  80                                 x86_64_alul_reg_reg(cd, alu_op, s2, REG_ITMP1);
  81                                 x86_64_movl_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
  82                         }
  83
  84                 } else {
  85                         x86_64_movl_reg_membase(cd, s1, REG_SP, d * 8);
  86                         x86_64_alul_reg_membase(cd, alu_op, s2, REG_SP, d * 8);
  87                 }
  88
  89         } else {
  90                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  91                         x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, d);
  92                         x86_64_alul_membase_reg(cd, alu_op, REG_SP, s2 * 8, d);
  93
  94                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
  95                         M_INTMOVE(s1, d);
  96                         x86_64_alul_membase_reg(cd, alu_op, REG_SP, s2 * 8, d);
  97
  98                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
  99                         M_INTMOVE(s2, d);
 100                         x86_64_alul_membase_reg(cd, alu_op, REG_SP, s1 * 8, d);
 101
 102                 } else {
 103                         if (s2 == d) {
 104                                 x86_64_alul_reg_reg(cd, alu_op, s1, d);
 105
 106                         } else {
 107                                 M_INTMOVE(s1, d);
 108                                 x86_64_alul_reg_reg(cd, alu_op, s2, d);
 109                         }
 110                 }
 111         }
 112 }
 113
 114
 115 void x86_64_emit_lalu(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
 116 {
 117         s4 s1 = src->prev->regoff;
 118         s4 s2 = src->regoff;
 119         s4 d = iptr->dst->regoff;
 120
 121         if (iptr->dst->flags & INMEMORY) {
 122                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 123                         if (s2 == d) {
 124                                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 125                                 x86_64_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, d * 8);
 126
 127                         } else if (s1 == d) {
 128                                 x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, REG_ITMP1);
 129                                 x86_64_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, d * 8);
 130
 131                         } else {
 132                                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 133                                 x86_64_alu_membase_reg(cd, alu_op, REG_SP, s2 * 8, REG_ITMP1);
 134                                 x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 135                         }
 136
 137                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 138                         if (s2 == d) {
 139                                 x86_64_alu_reg_membase(cd, alu_op, s1, REG_SP, d * 8);
 140
 141                         } else {
 142                                 x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, REG_ITMP1);
 143                                 x86_64_alu_reg_reg(cd, alu_op, s1, REG_ITMP1);
 144                                 x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 145                         }
 146
 147                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 148                         if (s1 == d) {
 149                                 x86_64_alu_reg_membase(cd, alu_op, s2, REG_SP, d * 8);
 150
 151                         } else {
 152                                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 153                                 x86_64_alu_reg_reg(cd, alu_op, s2, REG_ITMP1);
 154                                 x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 155                         }
 156
 157                 } else {
 158                         x86_64_mov_reg_membase(cd, s1, REG_SP, d * 8);
 159                         x86_64_alu_reg_membase(cd, alu_op, s2, REG_SP, d * 8);
 160                 }
 161
 162         } else {
 163                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 164                         x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, d);
 165                         x86_64_alu_membase_reg(cd, alu_op, REG_SP, s2 * 8, d);
 166
 167                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 168                         M_INTMOVE(s1, d);
 169                         x86_64_alu_membase_reg(cd, alu_op, REG_SP, s2 * 8, d);
 170
 171                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 172                         M_INTMOVE(s2, d);
 173                         x86_64_alu_membase_reg(cd, alu_op, REG_SP, s1 * 8, d);
 174
 175                 } else {
 176                         if (s2 == d) {
 177                                 x86_64_alu_reg_reg(cd, alu_op, s1, d);
 178
 179                         } else {
 180                                 M_INTMOVE(s1, d);
 181                                 x86_64_alu_reg_reg(cd, alu_op, s2, d);
 182                         }
 183                 }
 184         }
 185 }
 186
 187
 188 void x86_64_emit_ialuconst(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
 189 {
 190         s4 s1 = src->regoff;
 191         s4 d = iptr->dst->regoff;
 192
 193         if (iptr->dst->flags & INMEMORY) {
 194                 if (src->flags & INMEMORY) {
 195                         if (s1 == d) {
 196                                 x86_64_alul_imm_membase(cd, alu_op, iptr->val.i, REG_SP, d * 8);
 197
 198                         } else {
 199                                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 200                                 x86_64_alul_imm_reg(cd, alu_op, iptr->val.i, REG_ITMP1);
 201                                 x86_64_movl_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 202                         }
 203
 204                 } else {
 205                         x86_64_movl_reg_membase(cd, s1, REG_SP, d * 8);
 206                         x86_64_alul_imm_membase(cd, alu_op, iptr->val.i, REG_SP, d * 8);
 207                 }
 208
 209         } else {
 210                 if (src->flags & INMEMORY) {
 211                         x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, d);
 212                         x86_64_alul_imm_reg(cd, alu_op, iptr->val.i, d);
 213
 214                 } else {
 215                         M_INTMOVE(s1, d);
 216                         x86_64_alul_imm_reg(cd, alu_op, iptr->val.i, d);
 217                 }
 218         }
 219 }
 220
 221
 222 void x86_64_emit_laluconst(codegendata *cd, s4 alu_op, stackptr src, instruction *iptr)
 223 {
 224         s4 s1 = src->regoff;
 225         s4 d = iptr->dst->regoff;
 226
 227         if (iptr->dst->flags & INMEMORY) {
 228                 if (src->flags & INMEMORY) {
 229                         if (s1 == d) {
 230                                 if (IS_IMM32(iptr->val.l)) {
 231                                         x86_64_alu_imm_membase(cd, alu_op, iptr->val.l, REG_SP, d * 8);
 232
 233                                 } else {
 234                                         x86_64_mov_imm_reg(cd, iptr->val.l, REG_ITMP1);
 235                                         x86_64_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, d * 8);
 236                                 }
 237
 238                         } else {
 239                                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 240
 241                                 if (IS_IMM32(iptr->val.l)) {
 242                                         x86_64_alu_imm_reg(cd, alu_op, iptr->val.l, REG_ITMP1);
 243
 244                                 } else {
 245                                         x86_64_mov_imm_reg(cd, iptr->val.l, REG_ITMP2);
 246                                         x86_64_alu_reg_reg(cd, alu_op, REG_ITMP2, REG_ITMP1);
 247                                 }
 248                                 x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 249                         }
 250
 251                 } else {
 252                         x86_64_mov_reg_membase(cd, s1, REG_SP, d * 8);
 253
 254                         if (IS_IMM32(iptr->val.l)) {
 255                                 x86_64_alu_imm_membase(cd, alu_op, iptr->val.l, REG_SP, d * 8);
 256
 257                         } else {
 258                                 x86_64_mov_imm_reg(cd, iptr->val.l, REG_ITMP1);
 259                                 x86_64_alu_reg_membase(cd, alu_op, REG_ITMP1, REG_SP, d * 8);
 260                         }
 261                 }
 262
 263         } else {
 264                 if (src->flags & INMEMORY) {
 265                         x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, d);
 266
 267                 } else {
 268                         M_INTMOVE(s1, d);
 269                 }
 270
 271                 if (IS_IMM32(iptr->val.l)) {
 272                         x86_64_alu_imm_reg(cd, alu_op, iptr->val.l, d);
 273
 274                 } else {
 275                         x86_64_mov_imm_reg(cd, iptr->val.l, REG_ITMP1);
 276                         x86_64_alu_reg_reg(cd, alu_op, REG_ITMP1, d);
 277                 }
 278         }
 279 }
 280
 281
 282 void x86_64_emit_ishift(codegendata *cd, s4 shift_op, stackptr src, instruction *iptr)
 283 {
 284         s4 s1 = src->prev->regoff;
 285         s4 s2 = src->regoff;
 286         s4 d = iptr->dst->regoff;
 287         s4 d_old;
 288
 289         M_INTMOVE(RCX, REG_ITMP1);    /* save RCX */
 290         if (iptr->dst->flags & INMEMORY) {
 291                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 292                         if (s1 == d) {
 293                                 x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, RCX);
 294                                 x86_64_shiftl_membase(cd, shift_op, REG_SP, d * 8);
 295
 296                         } else {
 297                                 x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, RCX);
 298                                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP2);
 299                                 x86_64_shiftl_reg(cd, shift_op, REG_ITMP2);
 300                                 x86_64_movl_reg_membase(cd, REG_ITMP2, REG_SP, d * 8);
 301                         }
 302
 303                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 304                         x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, RCX);
 305                         x86_64_movl_reg_membase(cd, s1, REG_SP, d * 8);
 306                         x86_64_shiftl_membase(cd, shift_op, REG_SP, d * 8);
 307
 308                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 309                         if (s1 == d) {
 310                                 M_INTMOVE(s2, RCX);
 311                                 x86_64_shiftl_membase(cd, shift_op, REG_SP, d * 8);
 312
 313                         } else {
 314                                 M_INTMOVE(s2, RCX);
 315                                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP2);
 316                                 x86_64_shiftl_reg(cd, shift_op, REG_ITMP2);
 317                                 x86_64_movl_reg_membase(cd, REG_ITMP2, REG_SP, d * 8);
 318                         }
 319
 320                 } else {
 321                         M_INTMOVE(s2, RCX);
 322                         x86_64_movl_reg_membase(cd, s1, REG_SP, d * 8);
 323                         x86_64_shiftl_membase(cd, shift_op, REG_SP, d * 8);
 324                 }
 325                 M_INTMOVE(REG_ITMP1, RCX);    /* restore RCX */
 326
 327         } else {
 328                 if (d == RCX) {
 329                         d_old = d;
 330                         d = REG_ITMP3;
 331                 }
 332
 333                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 334                         x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, RCX);
 335                         x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, d);
 336                         x86_64_shiftl_reg(cd, shift_op, d);
 337
 338                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 339                         M_INTMOVE(s1, d);    /* maybe src is RCX */
 340                         x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, RCX);
 341                         x86_64_shiftl_reg(cd, shift_op, d);
 342
 343                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 344                         M_INTMOVE(s2, RCX);
 345                         x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, d);
 346                         x86_64_shiftl_reg(cd, shift_op, d);
 347
 348                 } else {
 349                         if (s1 == RCX) {
 350                                 M_INTMOVE(s1, d);
 351                                 M_INTMOVE(s2, RCX);
 352
 353                         } else {
 354                                 M_INTMOVE(s2, RCX);
 355                                 M_INTMOVE(s1, d);
 356                         }
 357                         x86_64_shiftl_reg(cd, shift_op, d);
 358                 }
 359
 360                 if (d_old == RCX) {
 361                         M_INTMOVE(REG_ITMP3, RCX);
 362
 363                 } else {
 364                         M_INTMOVE(REG_ITMP1, RCX);    /* restore RCX */
 365                 }
 366         }
 367 }
 368
 369
 370 void x86_64_emit_lshift(codegendata *cd, s4 shift_op, stackptr src, instruction *iptr)
 371 {
 372         s4 s1 = src->prev->regoff;
 373         s4 s2 = src->regoff;
 374         s4 d = iptr->dst->regoff;
 375         s4 d_old;
 376
 377         d_old = -1;
 378         M_INTMOVE(RCX, REG_ITMP1);    /* save RCX */
 379         if (iptr->dst->flags & INMEMORY) {
 380                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 381                         if (s1 == d) {
 382                                 x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, RCX);
 383                                 x86_64_shift_membase(cd, shift_op, REG_SP, d * 8);
 384
 385                         } else {
 386                                 x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, RCX);
 387                                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP2);
 388                                 x86_64_shift_reg(cd, shift_op, REG_ITMP2);
 389                                 x86_64_mov_reg_membase(cd, REG_ITMP2, REG_SP, d * 8);
 390                         }
 391
 392                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 393                         x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, RCX);
 394                         x86_64_mov_reg_membase(cd, s1, REG_SP, d * 8);
 395                         x86_64_shift_membase(cd, shift_op, REG_SP, d * 8);
 396
 397                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 398                         if (s1 == d) {
 399                                 M_INTMOVE(s2, RCX);
 400                                 x86_64_shift_membase(cd, shift_op, REG_SP, d * 8);
 401
 402                         } else {
 403                                 M_INTMOVE(s2, RCX);
 404                                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP2);
 405                                 x86_64_shift_reg(cd, shift_op, REG_ITMP2);
 406                                 x86_64_mov_reg_membase(cd, REG_ITMP2, REG_SP, d * 8);
 407                         }
 408
 409                 } else {
 410                         M_INTMOVE(s2, RCX);
 411                         x86_64_mov_reg_membase(cd, s1, REG_SP, d * 8);
 412                         x86_64_shift_membase(cd, shift_op, REG_SP, d * 8);
 413                 }
 414                 M_INTMOVE(REG_ITMP1, RCX);    /* restore RCX */
 415
 416         } else {
 417                 if (d == RCX) {
 418                         d_old = d;
 419                         d = REG_ITMP3;
 420                 }
 421
 422                 if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 423                         x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, RCX);
 424                         x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, d);
 425                         x86_64_shift_reg(cd, shift_op, d);
 426
 427                 } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 428                         M_INTMOVE(s1, d);    /* maybe src is RCX */
 429                         x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, RCX);
 430                         x86_64_shift_reg(cd, shift_op, d);
 431
 432                 } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 433                         M_INTMOVE(s2, RCX);
 434                         x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, d);
 435                         x86_64_shift_reg(cd, shift_op, d);
 436
 437                 } else {
 438                         if (s1 == RCX) {
 439                                 M_INTMOVE(s1, d);
 440                                 M_INTMOVE(s2, RCX);
 441                         } else {
 442                                 M_INTMOVE(s2, RCX);
 443                                 M_INTMOVE(s1, d);
 444                         }
 445                         x86_64_shift_reg(cd, shift_op, d);
 446                 }
 447
 448                 if (d_old == RCX) {
 449                         M_INTMOVE(REG_ITMP3, RCX);
 450
 451                 } else {
 452                         M_INTMOVE(REG_ITMP1, RCX);    /* restore RCX */
 453                 }
 454         }
 455 }
 456
 457
 458 void x86_64_emit_ishiftconst(codegendata *cd, s4 shift_op, stackptr src, instruction *iptr)
 459 {
 460         s4 s1 = src->regoff;
 461         s4 d = iptr->dst->regoff;
 462
 463         if ((src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
 464                 if (s1 == d) {
 465                         x86_64_shiftl_imm_membase(cd, shift_op, iptr->val.i, REG_SP, d * 8);
 466
 467                 } else {
 468                         x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 469                         x86_64_shiftl_imm_reg(cd, shift_op, iptr->val.i, REG_ITMP1);
 470                         x86_64_movl_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 471                 }
 472
 473         } else if ((src->flags & INMEMORY) && !(iptr->dst->flags & INMEMORY)) {
 474                 x86_64_movl_membase_reg(cd, REG_SP, s1 * 8, d);
 475                 x86_64_shiftl_imm_reg(cd, shift_op, iptr->val.i, d);
 476
 477         } else if (!(src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
 478                 x86_64_movl_reg_membase(cd, s1, REG_SP, d * 8);
 479                 x86_64_shiftl_imm_membase(cd, shift_op, iptr->val.i, REG_SP, d * 8);
 480
 481         } else {
 482                 M_INTMOVE(s1, d);
 483                 x86_64_shiftl_imm_reg(cd, shift_op, iptr->val.i, d);
 484         }
 485 }
 486
 487
 488 void x86_64_emit_lshiftconst(codegendata *cd, s4 shift_op, stackptr src, instruction *iptr)
 489 {
 490         s4 s1 = src->regoff;
 491         s4 d = iptr->dst->regoff;
 492
 493         if ((src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
 494                 if (s1 == d) {
 495                         x86_64_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, d * 8);
 496
 497                 } else {
 498                         x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, REG_ITMP1);
 499                         x86_64_shift_imm_reg(cd, shift_op, iptr->val.i, REG_ITMP1);
 500                         x86_64_mov_reg_membase(cd, REG_ITMP1, REG_SP, d * 8);
 501                 }
 502
 503         } else if ((src->flags & INMEMORY) && !(iptr->dst->flags & INMEMORY)) {
 504                 x86_64_mov_membase_reg(cd, REG_SP, s1 * 8, d);
 505                 x86_64_shift_imm_reg(cd, shift_op, iptr->val.i, d);
 506
 507         } else if (!(src->flags & INMEMORY) && (iptr->dst->flags & INMEMORY)) {
 508                 x86_64_mov_reg_membase(cd, s1, REG_SP, d * 8);
 509                 x86_64_shift_imm_membase(cd, shift_op, iptr->val.i, REG_SP, d * 8);
 510
 511         } else {
 512                 M_INTMOVE(s1, d);
 513                 x86_64_shift_imm_reg(cd, shift_op, iptr->val.i, d);
 514         }
 515 }
 516
 517
 518 void x86_64_emit_ifcc(codegendata *cd, s4 if_op, stackptr src, instruction *iptr)
 519 {
 520         if (src->flags & INMEMORY) {
 521                 x86_64_alul_imm_membase(cd, X86_64_CMP, iptr->val.i, REG_SP, src->regoff * 8);
 522
 523         } else {
 524                 if (iptr->val.i == 0) {
 525                         x86_64_testl_reg_reg(cd, src->regoff, src->regoff);
 526
 527                 } else {
 528                         x86_64_alul_imm_reg(cd, X86_64_CMP, iptr->val.i, src->regoff);
 529                 }
 530         }
 531         x86_64_jcc(cd, if_op, 0);
 532         codegen_addreference(cd, BlockPtrOfPC(iptr->op1), cd->mcodeptr);
 533 }
 534
 535
 536 void x86_64_emit_if_lcc(codegendata *cd, s4 if_op, stackptr src, instruction *iptr)
 537 {
 538         s4 s1 = src->regoff;
 539
 540         if (src->flags & INMEMORY) {
 541                 if (IS_IMM32(iptr->val.l)) {
 542                         x86_64_alu_imm_membase(cd, X86_64_CMP, iptr->val.l, REG_SP, s1 * 8);
 543
 544                 } else {
 545                         x86_64_mov_imm_reg(cd, iptr->val.l, REG_ITMP1);
 546                         x86_64_alu_reg_membase(cd, X86_64_CMP, REG_ITMP1, REG_SP, s1 * 8);
 547                 }
 548
 549         } else {
 550                 if (iptr->val.l == 0) {
 551                         x86_64_test_reg_reg(cd, s1, s1);
 552
 553                 } else {
 554                         if (IS_IMM32(iptr->val.l)) {
 555                                 x86_64_alu_imm_reg(cd, X86_64_CMP, iptr->val.l, s1);
 556
 557                         } else {
 558                                 x86_64_mov_imm_reg(cd, iptr->val.l, REG_ITMP1);
 559                                 x86_64_alu_reg_reg(cd, X86_64_CMP, REG_ITMP1, s1);
 560                         }
 561                 }
 562         }
 563         x86_64_jcc(cd, if_op, 0);
 564         codegen_addreference(cd, BlockPtrOfPC(iptr->op1), cd->mcodeptr);
 565 }
 566
 567
 568 void x86_64_emit_if_icmpcc(codegendata *cd, s4 if_op, stackptr src, instruction *iptr)
 569 {
 570         s4 s1 = src->prev->regoff;
 571         s4 s2 = src->regoff;
 572
 573         if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 574                 x86_64_movl_membase_reg(cd, REG_SP, s2 * 8, REG_ITMP1);
 575                 x86_64_alul_reg_membase(cd, X86_64_CMP, REG_ITMP1, REG_SP, s1 * 8);
 576
 577         } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 578                 x86_64_alul_membase_reg(cd, X86_64_CMP, REG_SP, s2 * 8, s1);
 579
 580         } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 581                 x86_64_alul_reg_membase(cd, X86_64_CMP, s2, REG_SP, s1 * 8);
 582
 583         } else {
 584                 x86_64_alul_reg_reg(cd, X86_64_CMP, s2, s1);
 585         }
 586         x86_64_jcc(cd, if_op, 0);
 587         codegen_addreference(cd, BlockPtrOfPC(iptr->op1), cd->mcodeptr);
 588 }
 589
 590
 591 void x86_64_emit_if_lcmpcc(codegendata *cd, s4 if_op, stackptr src, instruction *iptr)
 592 {
 593         s4 s1 = src->prev->regoff;
 594         s4 s2 = src->regoff;
 595
 596         if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 597                 x86_64_mov_membase_reg(cd, REG_SP, s2 * 8, REG_ITMP1);
 598                 x86_64_alu_reg_membase(cd, X86_64_CMP, REG_ITMP1, REG_SP, s1 * 8);
 599
 600         } else if ((src->flags & INMEMORY) && !(src->prev->flags & INMEMORY)) {
 601                 x86_64_alu_membase_reg(cd, X86_64_CMP, REG_SP, s2 * 8, s1);
 602
 603         } else if (!(src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
 604                 x86_64_alu_reg_membase(cd, X86_64_CMP, s2, REG_SP, s1 * 8);
 605
 606         } else {
 607                 x86_64_alu_reg_reg(cd, X86_64_CMP, s2, s1);
 608         }
 609         x86_64_jcc(cd, if_op, 0);
 610         codegen_addreference(cd, BlockPtrOfPC(iptr->op1), cd->mcodeptr);
 611 }
 612
 613
 614 /*
 615  * mov ops
 616  */
 617 void x86_64_mov_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 618         x86_64_emit_rex(1,(reg),0,(dreg));
 619         *(cd->mcodeptr++) = 0x89;
 620         x86_64_emit_reg((reg),(dreg));
 621 }
 622
 623
 624 void x86_64_mov_imm_reg(codegendata *cd, s8 imm, s8 reg) {
 625         x86_64_emit_rex(1,0,0,(reg));
 626         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
 627         x86_64_emit_imm64((imm));
 628 }
 629
 630
 631 void x86_64_movl_imm_reg(codegendata *cd, s8 imm, s8 reg) {
 632         x86_64_emit_rex(0,0,0,(reg));
 633         *(cd->mcodeptr++) = 0xb8 + ((reg) & 0x07);
 634         x86_64_emit_imm32((imm));
 635 }
 636
 637
 638 void x86_64_mov_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
 639         x86_64_emit_rex(1,(reg),0,(basereg));
 640         *(cd->mcodeptr++) = 0x8b;
 641         x86_64_emit_membase((basereg),(disp),(reg));
 642 }
 643
 644
 645 void x86_64_movl_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
 646         x86_64_emit_rex(0,(reg),0,(basereg));
 647         *(cd->mcodeptr++) = 0x8b;
 648         x86_64_emit_membase((basereg),(disp),(reg));
 649 }
 650
 651
 652 /*
 653  * this one is for INVOKEVIRTUAL/INVOKEINTERFACE to have a
 654  * constant membase immediate length of 32bit
 655  */
 656 void x86_64_mov_membase32_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
 657         x86_64_emit_rex(1,(reg),0,(basereg));
 658         *(cd->mcodeptr++) = 0x8b;
 659         x86_64_address_byte(2, (reg), (basereg));
 660         x86_64_emit_imm32((disp));
 661 }
 662
 663
 664 void x86_64_mov_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
 665         x86_64_emit_rex(1,(reg),0,(basereg));
 666         *(cd->mcodeptr++) = 0x89;
 667         x86_64_emit_membase((basereg),(disp),(reg));
 668 }
 669
 670
 671 void x86_64_movl_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
 672         x86_64_emit_rex(0,(reg),0,(basereg));
 673         *(cd->mcodeptr++) = 0x89;
 674         x86_64_emit_membase((basereg),(disp),(reg));
 675 }
 676
 677
 678 void x86_64_mov_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
 679         x86_64_emit_rex(1,(reg),(indexreg),(basereg));
 680         *(cd->mcodeptr++) = 0x8b;
 681         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 682 }
 683
 684
 685 void x86_64_movl_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
 686         x86_64_emit_rex(0,(reg),(indexreg),(basereg));
 687         *(cd->mcodeptr++) = 0x8b;
 688         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 689 }
 690
 691
 692 void x86_64_mov_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
 693         x86_64_emit_rex(1,(reg),(indexreg),(basereg));
 694         *(cd->mcodeptr++) = 0x89;
 695         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 696 }
 697
 698
 699 void x86_64_movl_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
 700         x86_64_emit_rex(0,(reg),(indexreg),(basereg));
 701         *(cd->mcodeptr++) = 0x89;
 702         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 703 }
 704
 705
 706 void x86_64_movw_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
 707         *(cd->mcodeptr++) = 0x66;
 708         x86_64_emit_rex(0,(reg),(indexreg),(basereg));
 709         *(cd->mcodeptr++) = 0x89;
 710         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 711 }
 712
 713
 714 void x86_64_movb_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
 715         x86_64_emit_byte_rex((reg),(indexreg),(basereg));
 716         *(cd->mcodeptr++) = 0x88;
 717         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 718 }
 719
 720
 721 void x86_64_mov_imm_membase(codegendata *cd, s8 imm, s8 basereg, s8 disp) {
 722         x86_64_emit_rex(1,0,0,(basereg));
 723         *(cd->mcodeptr++) = 0xc7;
 724         x86_64_emit_membase((basereg),(disp),0);
 725         x86_64_emit_imm32((imm));
 726 }
 727
 728
 729 void x86_64_movl_imm_membase(codegendata *cd, s8 imm, s8 basereg, s8 disp) {
 730         x86_64_emit_rex(0,0,0,(basereg));
 731         *(cd->mcodeptr++) = 0xc7;
 732         x86_64_emit_membase((basereg),(disp),0);
 733         x86_64_emit_imm32((imm));
 734 }
 735
 736
 737 void x86_64_movsbq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 738         x86_64_emit_rex(1,(dreg),0,(reg));
 739         *(cd->mcodeptr++) = 0x0f;
 740         *(cd->mcodeptr++) = 0xbe;
 741         /* XXX: why do reg and dreg have to be exchanged */
 742         x86_64_emit_reg((dreg),(reg));
 743 }
 744
 745
 746 void x86_64_movsbq_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
 747         x86_64_emit_rex(1,(dreg),0,(basereg));
 748         *(cd->mcodeptr++) = 0x0f;
 749         *(cd->mcodeptr++) = 0xbe;
 750         x86_64_emit_membase((basereg),(disp),(dreg));
 751 }
 752
 753
 754 void x86_64_movswq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 755         x86_64_emit_rex(1,(dreg),0,(reg));
 756         *(cd->mcodeptr++) = 0x0f;
 757         *(cd->mcodeptr++) = 0xbf;
 758         /* XXX: why do reg and dreg have to be exchanged */
 759         x86_64_emit_reg((dreg),(reg));
 760 }
 761
 762
 763 void x86_64_movswq_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
 764         x86_64_emit_rex(1,(dreg),0,(basereg));
 765         *(cd->mcodeptr++) = 0x0f;
 766         *(cd->mcodeptr++) = 0xbf;
 767         x86_64_emit_membase((basereg),(disp),(dreg));
 768 }
 769
 770
 771 void x86_64_movslq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 772         x86_64_emit_rex(1,(dreg),0,(reg));
 773         *(cd->mcodeptr++) = 0x63;
 774         /* XXX: why do reg and dreg have to be exchanged */
 775         x86_64_emit_reg((dreg),(reg));
 776 }
 777
 778
 779 void x86_64_movslq_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
 780         x86_64_emit_rex(1,(dreg),0,(basereg));
 781         *(cd->mcodeptr++) = 0x63;
 782         x86_64_emit_membase((basereg),(disp),(dreg));
 783 }
 784
 785
 786 void x86_64_movzwq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 787         x86_64_emit_rex(1,(dreg),0,(reg));
 788         *(cd->mcodeptr++) = 0x0f;
 789         *(cd->mcodeptr++) = 0xb7;
 790         /* XXX: why do reg and dreg have to be exchanged */
 791         x86_64_emit_reg((dreg),(reg));
 792 }
 793
 794
 795 void x86_64_movzwq_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
 796         x86_64_emit_rex(1,(dreg),0,(basereg));
 797         *(cd->mcodeptr++) = 0x0f;
 798         *(cd->mcodeptr++) = 0xb7;
 799         x86_64_emit_membase((basereg),(disp),(dreg));
 800 }
 801
 802
 803 void x86_64_movswq_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
 804         x86_64_emit_rex(1,(reg),(indexreg),(basereg));
 805         *(cd->mcodeptr++) = 0x0f;
 806         *(cd->mcodeptr++) = 0xbf;
 807         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 808 }
 809
 810
 811 void x86_64_movsbq_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
 812         x86_64_emit_rex(1,(reg),(indexreg),(basereg));
 813         *(cd->mcodeptr++) = 0x0f;
 814         *(cd->mcodeptr++) = 0xbe;
 815         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 816 }
 817
 818
 819 void x86_64_movzwq_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 reg) {
 820         x86_64_emit_rex(1,(reg),(indexreg),(basereg));
 821         *(cd->mcodeptr++) = 0x0f;
 822         *(cd->mcodeptr++) = 0xb7;
 823         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
 824 }
 825
 826
 827 void x86_64_mov_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 828 {
 829         x86_64_emit_rex(1,0,(indexreg),(basereg));
 830         *(cd->mcodeptr++) = 0xc7;
 831         x86_64_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 832         x86_64_emit_imm32((imm));
 833 }
 834
 835
 836 void x86_64_movl_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 837 {
 838         x86_64_emit_rex(0,0,(indexreg),(basereg));
 839         *(cd->mcodeptr++) = 0xc7;
 840         x86_64_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 841         x86_64_emit_imm32((imm));
 842 }
 843
 844
 845 void x86_64_movw_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 846 {
 847         *(cd->mcodeptr++) = 0x66;
 848         x86_64_emit_rex(0,0,(indexreg),(basereg));
 849         *(cd->mcodeptr++) = 0xc7;
 850         x86_64_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 851         x86_64_emit_imm16((imm));
 852 }
 853
 854
 855 void x86_64_movb_imm_memindex(codegendata *cd, s4 imm, s4 disp, s4 basereg, s4 indexreg, s4 scale)
 856 {
 857         x86_64_emit_rex(0,0,(indexreg),(basereg));
 858         *(cd->mcodeptr++) = 0xc6;
 859         x86_64_emit_memindex(0,(disp),(basereg),(indexreg),(scale));
 860         x86_64_emit_imm8((imm));
 861 }
 862
 863
 864 /*
 865  * alu operations
 866  */
 867 void x86_64_alu_reg_reg(codegendata *cd, s8 opc, s8 reg, s8 dreg) {
 868         x86_64_emit_rex(1,(reg),0,(dreg));
 869         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
 870         x86_64_emit_reg((reg),(dreg));
 871 }
 872
 873
 874 void x86_64_alul_reg_reg(codegendata *cd, s8 opc, s8 reg, s8 dreg) {
 875         x86_64_emit_rex(0,(reg),0,(dreg));
 876         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
 877         x86_64_emit_reg((reg),(dreg));
 878 }
 879
 880
 881 void x86_64_alu_reg_membase(codegendata *cd, s8 opc, s8 reg, s8 basereg, s8 disp) {
 882         x86_64_emit_rex(1,(reg),0,(basereg));
 883         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
 884         x86_64_emit_membase((basereg),(disp),(reg));
 885 }
 886
 887
 888 void x86_64_alul_reg_membase(codegendata *cd, s8 opc, s8 reg, s8 basereg, s8 disp) {
 889         x86_64_emit_rex(0,(reg),0,(basereg));
 890         *(cd->mcodeptr++) = (((opc)) << 3) + 1;
 891         x86_64_emit_membase((basereg),(disp),(reg));
 892 }
 893
 894
 895 void x86_64_alu_membase_reg(codegendata *cd, s8 opc, s8 basereg, s8 disp, s8 reg) {
 896         x86_64_emit_rex(1,(reg),0,(basereg));
 897         *(cd->mcodeptr++) = (((opc)) << 3) + 3;
 898         x86_64_emit_membase((basereg),(disp),(reg));
 899 }
 900
 901
 902 void x86_64_alul_membase_reg(codegendata *cd, s8 opc, s8 basereg, s8 disp, s8 reg) {
 903         x86_64_emit_rex(0,(reg),0,(basereg));
 904         *(cd->mcodeptr++) = (((opc)) << 3) + 3;
 905         x86_64_emit_membase((basereg),(disp),(reg));
 906 }
 907
 908
 909 void x86_64_alu_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
 910         if (IS_IMM8(imm)) {
 911                 x86_64_emit_rex(1,0,0,(dreg));
 912                 *(cd->mcodeptr++) = 0x83;
 913                 x86_64_emit_reg((opc),(dreg));
 914                 x86_64_emit_imm8((imm));
 915         } else {
 916                 x86_64_emit_rex(1,0,0,(dreg));
 917                 *(cd->mcodeptr++) = 0x81;
 918                 x86_64_emit_reg((opc),(dreg));
 919                 x86_64_emit_imm32((imm));
 920         }
 921 }
 922
 923
 924 void x86_64_alul_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
 925         if (IS_IMM8(imm)) {
 926                 x86_64_emit_rex(0,0,0,(dreg));
 927                 *(cd->mcodeptr++) = 0x83;
 928                 x86_64_emit_reg((opc),(dreg));
 929                 x86_64_emit_imm8((imm));
 930         } else {
 931                 x86_64_emit_rex(0,0,0,(dreg));
 932                 *(cd->mcodeptr++) = 0x81;
 933                 x86_64_emit_reg((opc),(dreg));
 934                 x86_64_emit_imm32((imm));
 935         }
 936 }
 937
 938
 939 void x86_64_alu_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
 940         if (IS_IMM8(imm)) {
 941                 x86_64_emit_rex(1,(basereg),0,0);
 942                 *(cd->mcodeptr++) = 0x83;
 943                 x86_64_emit_membase((basereg),(disp),(opc));
 944                 x86_64_emit_imm8((imm));
 945         } else {
 946                 x86_64_emit_rex(1,(basereg),0,0);
 947                 *(cd->mcodeptr++) = 0x81;
 948                 x86_64_emit_membase((basereg),(disp),(opc));
 949                 x86_64_emit_imm32((imm));
 950         }
 951 }
 952
 953
 954 void x86_64_alul_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
 955         if (IS_IMM8(imm)) {
 956                 x86_64_emit_rex(0,(basereg),0,0);
 957                 *(cd->mcodeptr++) = 0x83;
 958                 x86_64_emit_membase((basereg),(disp),(opc));
 959                 x86_64_emit_imm8((imm));
 960         } else {
 961                 x86_64_emit_rex(0,(basereg),0,0);
 962                 *(cd->mcodeptr++) = 0x81;
 963                 x86_64_emit_membase((basereg),(disp),(opc));
 964                 x86_64_emit_imm32((imm));
 965         }
 966 }
 967
 968
 969 void x86_64_test_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 970         x86_64_emit_rex(1,(reg),0,(dreg));
 971         *(cd->mcodeptr++) = 0x85;
 972         x86_64_emit_reg((reg),(dreg));
 973 }
 974
 975
 976 void x86_64_testl_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
 977         x86_64_emit_rex(0,(reg),0,(dreg));
 978         *(cd->mcodeptr++) = 0x85;
 979         x86_64_emit_reg((reg),(dreg));
 980 }
 981
 982
 983 void x86_64_test_imm_reg(codegendata *cd, s8 imm, s8 reg) {
 984         *(cd->mcodeptr++) = 0xf7;
 985         x86_64_emit_reg(0,(reg));
 986         x86_64_emit_imm32((imm));
 987 }
 988
 989
 990 void x86_64_testw_imm_reg(codegendata *cd, s8 imm, s8 reg) {
 991         *(cd->mcodeptr++) = 0x66;
 992         *(cd->mcodeptr++) = 0xf7;
 993         x86_64_emit_reg(0,(reg));
 994         x86_64_emit_imm16((imm));
 995 }
 996
 997
 998 void x86_64_testb_imm_reg(codegendata *cd, s8 imm, s8 reg) {
 999         *(cd->mcodeptr++) = 0xf6;
1000         x86_64_emit_reg(0,(reg));
1001         x86_64_emit_imm8((imm));
1002 }
1003
1004
1005 void x86_64_lea_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
1006         x86_64_emit_rex(1,(reg),0,(basereg));
1007         *(cd->mcodeptr++) = 0x8d;
1008         x86_64_emit_membase((basereg),(disp),(reg));
1009 }
1010
1011
1012 void x86_64_leal_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 reg) {
1013         x86_64_emit_rex(0,(reg),0,(basereg));
1014         *(cd->mcodeptr++) = 0x8d;
1015         x86_64_emit_membase((basereg),(disp),(reg));
1016 }
1017
1018
1019
1020 /*
1021  * inc, dec operations
1022  */
1023 void x86_64_inc_reg(codegendata *cd, s8 reg) {
1024         x86_64_emit_rex(1,0,0,(reg));
1025         *(cd->mcodeptr++) = 0xff;
1026         x86_64_emit_reg(0,(reg));
1027 }
1028
1029
1030 void x86_64_incl_reg(codegendata *cd, s8 reg) {
1031         x86_64_emit_rex(0,0,0,(reg));
1032         *(cd->mcodeptr++) = 0xff;
1033         x86_64_emit_reg(0,(reg));
1034 }
1035
1036
1037 void x86_64_inc_membase(codegendata *cd, s8 basereg, s8 disp) {
1038         x86_64_emit_rex(1,(basereg),0,0);
1039         *(cd->mcodeptr++) = 0xff;
1040         x86_64_emit_membase((basereg),(disp),0);
1041 }
1042
1043
1044 void x86_64_incl_membase(codegendata *cd, s8 basereg, s8 disp) {
1045         x86_64_emit_rex(0,(basereg),0,0);
1046         *(cd->mcodeptr++) = 0xff;
1047         x86_64_emit_membase((basereg),(disp),0);
1048 }
1049
1050
1051 void x86_64_dec_reg(codegendata *cd, s8 reg) {
1052         x86_64_emit_rex(1,0,0,(reg));
1053         *(cd->mcodeptr++) = 0xff;
1054         x86_64_emit_reg(1,(reg));
1055 }
1056
1057
1058 void x86_64_decl_reg(codegendata *cd, s8 reg) {
1059         x86_64_emit_rex(0,0,0,(reg));
1060         *(cd->mcodeptr++) = 0xff;
1061         x86_64_emit_reg(1,(reg));
1062 }
1063
1064
1065 void x86_64_dec_membase(codegendata *cd, s8 basereg, s8 disp) {
1066         x86_64_emit_rex(1,(basereg),0,0);
1067         *(cd->mcodeptr++) = 0xff;
1068         x86_64_emit_membase((basereg),(disp),1);
1069 }
1070
1071
1072 void x86_64_decl_membase(codegendata *cd, s8 basereg, s8 disp) {
1073         x86_64_emit_rex(0,(basereg),0,0);
1074         *(cd->mcodeptr++) = 0xff;
1075         x86_64_emit_membase((basereg),(disp),1);
1076 }
1077
1078
1079
1080
1081 void x86_64_cltd(codegendata *cd) {
1082     *(cd->mcodeptr++) = 0x99;
1083 }
1084
1085
1086 void x86_64_cqto(codegendata *cd) {
1087         x86_64_emit_rex(1,0,0,0);
1088         *(cd->mcodeptr++) = 0x99;
1089 }
1090
1091
1092
1093 void x86_64_imul_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1094         x86_64_emit_rex(1,(dreg),0,(reg));
1095         *(cd->mcodeptr++) = 0x0f;
1096         *(cd->mcodeptr++) = 0xaf;
1097         x86_64_emit_reg((dreg),(reg));
1098 }
1099
1100
1101 void x86_64_imull_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1102         x86_64_emit_rex(0,(dreg),0,(reg));
1103         *(cd->mcodeptr++) = 0x0f;
1104         *(cd->mcodeptr++) = 0xaf;
1105         x86_64_emit_reg((dreg),(reg));
1106 }
1107
1108
1109 void x86_64_imul_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1110         x86_64_emit_rex(1,(dreg),0,(basereg));
1111         *(cd->mcodeptr++) = 0x0f;
1112         *(cd->mcodeptr++) = 0xaf;
1113         x86_64_emit_membase((basereg),(disp),(dreg));
1114 }
1115
1116
1117 void x86_64_imull_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1118         x86_64_emit_rex(0,(dreg),0,(basereg));
1119         *(cd->mcodeptr++) = 0x0f;
1120         *(cd->mcodeptr++) = 0xaf;
1121         x86_64_emit_membase((basereg),(disp),(dreg));
1122 }
1123
1124
1125 void x86_64_imul_imm_reg(codegendata *cd, s8 imm, s8 dreg) {
1126         if (IS_IMM8((imm))) {
1127                 x86_64_emit_rex(1,0,0,(dreg));
1128                 *(cd->mcodeptr++) = 0x6b;
1129                 x86_64_emit_reg(0,(dreg));
1130                 x86_64_emit_imm8((imm));
1131         } else {
1132                 x86_64_emit_rex(1,0,0,(dreg));
1133                 *(cd->mcodeptr++) = 0x69;
1134                 x86_64_emit_reg(0,(dreg));
1135                 x86_64_emit_imm32((imm));
1136         }
1137 }
1138
1139
1140 void x86_64_imul_imm_reg_reg(codegendata *cd, s8 imm, s8 reg, s8 dreg) {
1141         if (IS_IMM8((imm))) {
1142                 x86_64_emit_rex(1,(dreg),0,(reg));
1143                 *(cd->mcodeptr++) = 0x6b;
1144                 x86_64_emit_reg((dreg),(reg));
1145                 x86_64_emit_imm8((imm));
1146         } else {
1147                 x86_64_emit_rex(1,(dreg),0,(reg));
1148                 *(cd->mcodeptr++) = 0x69;
1149                 x86_64_emit_reg((dreg),(reg));
1150                 x86_64_emit_imm32((imm));
1151         }
1152 }
1153
1154
1155 void x86_64_imull_imm_reg_reg(codegendata *cd, s8 imm, s8 reg, s8 dreg) {
1156         if (IS_IMM8((imm))) {
1157                 x86_64_emit_rex(0,(dreg),0,(reg));
1158                 *(cd->mcodeptr++) = 0x6b;
1159                 x86_64_emit_reg((dreg),(reg));
1160                 x86_64_emit_imm8((imm));
1161         } else {
1162                 x86_64_emit_rex(0,(dreg),0,(reg));
1163                 *(cd->mcodeptr++) = 0x69;
1164                 x86_64_emit_reg((dreg),(reg));
1165                 x86_64_emit_imm32((imm));
1166         }
1167 }
1168
1169
1170 void x86_64_imul_imm_membase_reg(codegendata *cd, s8 imm, s8 basereg, s8 disp, s8 dreg) {
1171         if (IS_IMM8((imm))) {
1172                 x86_64_emit_rex(1,(dreg),0,(basereg));
1173                 *(cd->mcodeptr++) = 0x6b;
1174                 x86_64_emit_membase((basereg),(disp),(dreg));
1175                 x86_64_emit_imm8((imm));
1176         } else {
1177                 x86_64_emit_rex(1,(dreg),0,(basereg));
1178                 *(cd->mcodeptr++) = 0x69;
1179                 x86_64_emit_membase((basereg),(disp),(dreg));
1180                 x86_64_emit_imm32((imm));
1181         }
1182 }
1183
1184
1185 void x86_64_imull_imm_membase_reg(codegendata *cd, s8 imm, s8 basereg, s8 disp, s8 dreg) {
1186         if (IS_IMM8((imm))) {
1187                 x86_64_emit_rex(0,(dreg),0,(basereg));
1188                 *(cd->mcodeptr++) = 0x6b;
1189                 x86_64_emit_membase((basereg),(disp),(dreg));
1190                 x86_64_emit_imm8((imm));
1191         } else {
1192                 x86_64_emit_rex(0,(dreg),0,(basereg));
1193                 *(cd->mcodeptr++) = 0x69;
1194                 x86_64_emit_membase((basereg),(disp),(dreg));
1195                 x86_64_emit_imm32((imm));
1196         }
1197 }
1198
1199
1200 void x86_64_idiv_reg(codegendata *cd, s8 reg) {
1201         x86_64_emit_rex(1,0,0,(reg));
1202         *(cd->mcodeptr++) = 0xf7;
1203         x86_64_emit_reg(7,(reg));
1204 }
1205
1206
1207 void x86_64_idivl_reg(codegendata *cd, s8 reg) {
1208         x86_64_emit_rex(0,0,0,(reg));
1209         *(cd->mcodeptr++) = 0xf7;
1210         x86_64_emit_reg(7,(reg));
1211 }
1212
1213
1214
1215 void x86_64_ret(codegendata *cd) {
1216     *(cd->mcodeptr++) = 0xc3;
1217 }
1218
1219
1220
1221 /*
1222  * shift ops
1223  */
1224 void x86_64_shift_reg(codegendata *cd, s8 opc, s8 reg) {
1225         x86_64_emit_rex(1,0,0,(reg));
1226         *(cd->mcodeptr++) = 0xd3;
1227         x86_64_emit_reg((opc),(reg));
1228 }
1229
1230
1231 void x86_64_shiftl_reg(codegendata *cd, s8 opc, s8 reg) {
1232         x86_64_emit_rex(0,0,0,(reg));
1233         *(cd->mcodeptr++) = 0xd3;
1234         x86_64_emit_reg((opc),(reg));
1235 }
1236
1237
1238 void x86_64_shift_membase(codegendata *cd, s8 opc, s8 basereg, s8 disp) {
1239         x86_64_emit_rex(1,0,0,(basereg));
1240         *(cd->mcodeptr++) = 0xd3;
1241         x86_64_emit_membase((basereg),(disp),(opc));
1242 }
1243
1244
1245 void x86_64_shiftl_membase(codegendata *cd, s8 opc, s8 basereg, s8 disp) {
1246         x86_64_emit_rex(0,0,0,(basereg));
1247         *(cd->mcodeptr++) = 0xd3;
1248         x86_64_emit_membase((basereg),(disp),(opc));
1249 }
1250
1251
1252 void x86_64_shift_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
1253         if ((imm) == 1) {
1254                 x86_64_emit_rex(1,0,0,(dreg));
1255                 *(cd->mcodeptr++) = 0xd1;
1256                 x86_64_emit_reg((opc),(dreg));
1257         } else {
1258                 x86_64_emit_rex(1,0,0,(dreg));
1259                 *(cd->mcodeptr++) = 0xc1;
1260                 x86_64_emit_reg((opc),(dreg));
1261                 x86_64_emit_imm8((imm));
1262         }
1263 }
1264
1265
1266 void x86_64_shiftl_imm_reg(codegendata *cd, s8 opc, s8 imm, s8 dreg) {
1267         if ((imm) == 1) {
1268                 x86_64_emit_rex(0,0,0,(dreg));
1269                 *(cd->mcodeptr++) = 0xd1;
1270                 x86_64_emit_reg((opc),(dreg));
1271         } else {
1272                 x86_64_emit_rex(0,0,0,(dreg));
1273                 *(cd->mcodeptr++) = 0xc1;
1274                 x86_64_emit_reg((opc),(dreg));
1275                 x86_64_emit_imm8((imm));
1276         }
1277 }
1278
1279
1280 void x86_64_shift_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
1281         if ((imm) == 1) {
1282                 x86_64_emit_rex(1,0,0,(basereg));
1283                 *(cd->mcodeptr++) = 0xd1;
1284                 x86_64_emit_membase((basereg),(disp),(opc));
1285         } else {
1286                 x86_64_emit_rex(1,0,0,(basereg));
1287                 *(cd->mcodeptr++) = 0xc1;
1288                 x86_64_emit_membase((basereg),(disp),(opc));
1289                 x86_64_emit_imm8((imm));
1290         }
1291 }
1292
1293
1294 void x86_64_shiftl_imm_membase(codegendata *cd, s8 opc, s8 imm, s8 basereg, s8 disp) {
1295         if ((imm) == 1) {
1296                 x86_64_emit_rex(0,0,0,(basereg));
1297                 *(cd->mcodeptr++) = 0xd1;
1298                 x86_64_emit_membase((basereg),(disp),(opc));
1299         } else {
1300                 x86_64_emit_rex(0,0,0,(basereg));
1301                 *(cd->mcodeptr++) = 0xc1;
1302                 x86_64_emit_membase((basereg),(disp),(opc));
1303                 x86_64_emit_imm8((imm));
1304         }
1305 }
1306
1307
1308
1309 /*
1310  * jump operations
1311  */
1312 void x86_64_jmp_imm(codegendata *cd, s8 imm) {
1313         *(cd->mcodeptr++) = 0xe9;
1314         x86_64_emit_imm32((imm));
1315 }
1316
1317
1318 void x86_64_jmp_reg(codegendata *cd, s8 reg) {
1319         x86_64_emit_rex(0,0,0,(reg));
1320         *(cd->mcodeptr++) = 0xff;
1321         x86_64_emit_reg(4,(reg));
1322 }
1323
1324
1325 void x86_64_jcc(codegendata *cd, s8 opc, s8 imm) {
1326         *(cd->mcodeptr++) = 0x0f;
1327         *(cd->mcodeptr++) = (0x80 + (opc));
1328         x86_64_emit_imm32((imm));
1329 }
1330
1331
1332
1333 /*
1334  * conditional set and move operations
1335  */
1336
1337 /* we need the rex byte to get all low bytes */
1338 void x86_64_setcc_reg(codegendata *cd, s8 opc, s8 reg) {
1339         *(cd->mcodeptr++) = (0x40 | (((reg) >> 3) & 0x01));
1340         *(cd->mcodeptr++) = 0x0f;
1341         *(cd->mcodeptr++) = (0x90 + (opc));
1342         x86_64_emit_reg(0,(reg));
1343 }
1344
1345
1346 /* we need the rex byte to get all low bytes */
1347 void x86_64_setcc_membase(codegendata *cd, s8 opc, s8 basereg, s8 disp) {
1348         *(cd->mcodeptr++) = (0x40 | (((basereg) >> 3) & 0x01));
1349         *(cd->mcodeptr++) = 0x0f;
1350         *(cd->mcodeptr++) = (0x90 + (opc));
1351         x86_64_emit_membase((basereg),(disp),0);
1352 }
1353
1354
1355 void x86_64_cmovcc_reg_reg(codegendata *cd, s8 opc, s8 reg, s8 dreg) {
1356         x86_64_emit_rex(1,(dreg),0,(reg));
1357         *(cd->mcodeptr++) = 0x0f;
1358         *(cd->mcodeptr++) = (0x40 + (opc));
1359         x86_64_emit_reg((dreg),(reg));
1360 }
1361
1362
1363 void x86_64_cmovccl_reg_reg(codegendata *cd, s8 opc, s8 reg, s8 dreg) {
1364         x86_64_emit_rex(0,(dreg),0,(reg));
1365         *(cd->mcodeptr++) = 0x0f;
1366         *(cd->mcodeptr++) = (0x40 + (opc));
1367         x86_64_emit_reg((dreg),(reg));
1368 }
1369
1370
1371
1372 void x86_64_neg_reg(codegendata *cd, s8 reg) {
1373         x86_64_emit_rex(1,0,0,(reg));
1374         *(cd->mcodeptr++) = 0xf7;
1375         x86_64_emit_reg(3,(reg));
1376 }
1377
1378
1379 void x86_64_negl_reg(codegendata *cd, s8 reg) {
1380         x86_64_emit_rex(0,0,0,(reg));
1381         *(cd->mcodeptr++) = 0xf7;
1382         x86_64_emit_reg(3,(reg));
1383 }
1384
1385
1386 void x86_64_neg_membase(codegendata *cd, s8 basereg, s8 disp) {
1387         x86_64_emit_rex(1,0,0,(basereg));
1388         *(cd->mcodeptr++) = 0xf7;
1389         x86_64_emit_membase((basereg),(disp),3);
1390 }
1391
1392
1393 void x86_64_negl_membase(codegendata *cd, s8 basereg, s8 disp) {
1394         x86_64_emit_rex(0,0,0,(basereg));
1395         *(cd->mcodeptr++) = 0xf7;
1396         x86_64_emit_membase((basereg),(disp),3);
1397 }
1398
1399
1400 void x86_64_push_reg(codegendata *cd, s8 reg) {
1401         x86_64_emit_rex(0,0,0,(reg));
1402         *(cd->mcodeptr++) = 0x50 + (0x07 & (reg));
1403 }
1404
1405
1406 void x86_64_push_imm(codegendata *cd, s8 imm) {
1407         *(cd->mcodeptr++) = 0x68;
1408         x86_64_emit_imm32((imm));
1409 }
1410
1411
1412 void x86_64_pop_reg(codegendata *cd, s8 reg) {
1413         x86_64_emit_rex(0,0,0,(reg));
1414         *(cd->mcodeptr++) = 0x58 + (0x07 & (reg));
1415 }
1416
1417
1418 void x86_64_xchg_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1419         x86_64_emit_rex(1,(reg),0,(dreg));
1420         *(cd->mcodeptr++) = 0x87;
1421         x86_64_emit_reg((reg),(dreg));
1422 }
1423
1424
1425 void x86_64_nop(codegendata *cd) {
1426     *(cd->mcodeptr++) = 0x90;
1427 }
1428
1429
1430
1431 /*
1432  * call instructions
1433  */
1434 void x86_64_call_reg(codegendata *cd, s8 reg) {
1435         x86_64_emit_rex(1,0,0,(reg));
1436         *(cd->mcodeptr++) = 0xff;
1437         x86_64_emit_reg(2,(reg));
1438 }
1439
1440
1441 void x86_64_call_imm(codegendata *cd, s8 imm) {
1442         *(cd->mcodeptr++) = 0xe8;
1443         x86_64_emit_imm32((imm));
1444 }
1445
1446
1447 void x86_64_call_mem(codegendata *cd, s8 mem) {
1448         *(cd->mcodeptr++) = 0xff;
1449         x86_64_emit_mem(2,(mem));
1450 }
1451
1452
1453
1454 /*
1455  * floating point instructions (SSE2)
1456  */
1457 void x86_64_addsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1458         *(cd->mcodeptr++) = 0xf2;
1459         x86_64_emit_rex(0,(dreg),0,(reg));
1460         *(cd->mcodeptr++) = 0x0f;
1461         *(cd->mcodeptr++) = 0x58;
1462         x86_64_emit_reg((dreg),(reg));
1463 }
1464
1465
1466 void x86_64_addss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1467         *(cd->mcodeptr++) = 0xf3;
1468         x86_64_emit_rex(0,(dreg),0,(reg));
1469         *(cd->mcodeptr++) = 0x0f;
1470         *(cd->mcodeptr++) = 0x58;
1471         x86_64_emit_reg((dreg),(reg));
1472 }
1473
1474
1475 void x86_64_cvtsi2ssq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1476         *(cd->mcodeptr++) = 0xf3;
1477         x86_64_emit_rex(1,(dreg),0,(reg));
1478         *(cd->mcodeptr++) = 0x0f;
1479         *(cd->mcodeptr++) = 0x2a;
1480         x86_64_emit_reg((dreg),(reg));
1481 }
1482
1483
1484 void x86_64_cvtsi2ss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1485         *(cd->mcodeptr++) = 0xf3;
1486         x86_64_emit_rex(0,(dreg),0,(reg));
1487         *(cd->mcodeptr++) = 0x0f;
1488         *(cd->mcodeptr++) = 0x2a;
1489         x86_64_emit_reg((dreg),(reg));
1490 }
1491
1492
1493 void x86_64_cvtsi2sdq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1494         *(cd->mcodeptr++) = 0xf2;
1495         x86_64_emit_rex(1,(dreg),0,(reg));
1496         *(cd->mcodeptr++) = 0x0f;
1497         *(cd->mcodeptr++) = 0x2a;
1498         x86_64_emit_reg((dreg),(reg));
1499 }
1500
1501
1502 void x86_64_cvtsi2sd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1503         *(cd->mcodeptr++) = 0xf2;
1504         x86_64_emit_rex(0,(dreg),0,(reg));
1505         *(cd->mcodeptr++) = 0x0f;
1506         *(cd->mcodeptr++) = 0x2a;
1507         x86_64_emit_reg((dreg),(reg));
1508 }
1509
1510
1511 void x86_64_cvtss2sd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1512         *(cd->mcodeptr++) = 0xf3;
1513         x86_64_emit_rex(0,(dreg),0,(reg));
1514         *(cd->mcodeptr++) = 0x0f;
1515         *(cd->mcodeptr++) = 0x5a;
1516         x86_64_emit_reg((dreg),(reg));
1517 }
1518
1519
1520 void x86_64_cvtsd2ss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1521         *(cd->mcodeptr++) = 0xf2;
1522         x86_64_emit_rex(0,(dreg),0,(reg));
1523         *(cd->mcodeptr++) = 0x0f;
1524         *(cd->mcodeptr++) = 0x5a;
1525         x86_64_emit_reg((dreg),(reg));
1526 }
1527
1528
1529 void x86_64_cvttss2siq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1530         *(cd->mcodeptr++) = 0xf3;
1531         x86_64_emit_rex(1,(dreg),0,(reg));
1532         *(cd->mcodeptr++) = 0x0f;
1533         *(cd->mcodeptr++) = 0x2c;
1534         x86_64_emit_reg((dreg),(reg));
1535 }
1536
1537
1538 void x86_64_cvttss2si_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1539         *(cd->mcodeptr++) = 0xf3;
1540         x86_64_emit_rex(0,(dreg),0,(reg));
1541         *(cd->mcodeptr++) = 0x0f;
1542         *(cd->mcodeptr++) = 0x2c;
1543         x86_64_emit_reg((dreg),(reg));
1544 }
1545
1546
1547 void x86_64_cvttsd2siq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1548         *(cd->mcodeptr++) = 0xf2;
1549         x86_64_emit_rex(1,(dreg),0,(reg));
1550         *(cd->mcodeptr++) = 0x0f;
1551         *(cd->mcodeptr++) = 0x2c;
1552         x86_64_emit_reg((dreg),(reg));
1553 }
1554
1555
1556 void x86_64_cvttsd2si_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1557         *(cd->mcodeptr++) = 0xf2;
1558         x86_64_emit_rex(0,(dreg),0,(reg));
1559         *(cd->mcodeptr++) = 0x0f;
1560         *(cd->mcodeptr++) = 0x2c;
1561         x86_64_emit_reg((dreg),(reg));
1562 }
1563
1564
1565 void x86_64_divss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1566         *(cd->mcodeptr++) = 0xf3;
1567         x86_64_emit_rex(0,(dreg),0,(reg));
1568         *(cd->mcodeptr++) = 0x0f;
1569         *(cd->mcodeptr++) = 0x5e;
1570         x86_64_emit_reg((dreg),(reg));
1571 }
1572
1573
1574 void x86_64_divsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1575         *(cd->mcodeptr++) = 0xf2;
1576         x86_64_emit_rex(0,(dreg),0,(reg));
1577         *(cd->mcodeptr++) = 0x0f;
1578         *(cd->mcodeptr++) = 0x5e;
1579         x86_64_emit_reg((dreg),(reg));
1580 }
1581
1582
1583 void x86_64_movd_reg_freg(codegendata *cd, s8 reg, s8 freg) {
1584         *(cd->mcodeptr++) = 0x66;
1585         x86_64_emit_rex(1,(freg),0,(reg));
1586         *(cd->mcodeptr++) = 0x0f;
1587         *(cd->mcodeptr++) = 0x6e;
1588         x86_64_emit_reg((freg),(reg));
1589 }
1590
1591
1592 void x86_64_movd_freg_reg(codegendata *cd, s8 freg, s8 reg) {
1593         *(cd->mcodeptr++) = 0x66;
1594         x86_64_emit_rex(1,(freg),0,(reg));
1595         *(cd->mcodeptr++) = 0x0f;
1596         *(cd->mcodeptr++) = 0x7e;
1597         x86_64_emit_reg((freg),(reg));
1598 }
1599
1600
1601 void x86_64_movd_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1602         *(cd->mcodeptr++) = 0x66;
1603         x86_64_emit_rex(0,(reg),0,(basereg));
1604         *(cd->mcodeptr++) = 0x0f;
1605         *(cd->mcodeptr++) = 0x7e;
1606         x86_64_emit_membase((basereg),(disp),(reg));
1607 }
1608
1609
1610 void x86_64_movd_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1611         *(cd->mcodeptr++) = 0x66;
1612         x86_64_emit_rex(0,(reg),(indexreg),(basereg));
1613         *(cd->mcodeptr++) = 0x0f;
1614         *(cd->mcodeptr++) = 0x7e;
1615         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
1616 }
1617
1618
1619 void x86_64_movd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1620         *(cd->mcodeptr++) = 0x66;
1621         x86_64_emit_rex(1,(dreg),0,(basereg));
1622         *(cd->mcodeptr++) = 0x0f;
1623         *(cd->mcodeptr++) = 0x6e;
1624         x86_64_emit_membase((basereg),(disp),(dreg));
1625 }
1626
1627
1628 void x86_64_movdl_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1629         *(cd->mcodeptr++) = 0x66;
1630         x86_64_emit_rex(0,(dreg),0,(basereg));
1631         *(cd->mcodeptr++) = 0x0f;
1632         *(cd->mcodeptr++) = 0x6e;
1633         x86_64_emit_membase((basereg),(disp),(dreg));
1634 }
1635
1636
1637 void x86_64_movd_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 dreg) {
1638         *(cd->mcodeptr++) = 0x66;
1639         x86_64_emit_rex(0,(dreg),(indexreg),(basereg));
1640         *(cd->mcodeptr++) = 0x0f;
1641         *(cd->mcodeptr++) = 0x6e;
1642         x86_64_emit_memindex((dreg),(disp),(basereg),(indexreg),(scale));
1643 }
1644
1645
1646 void x86_64_movq_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1647         *(cd->mcodeptr++) = 0xf3;
1648         x86_64_emit_rex(0,(dreg),0,(reg));
1649         *(cd->mcodeptr++) = 0x0f;
1650         *(cd->mcodeptr++) = 0x7e;
1651         x86_64_emit_reg((dreg),(reg));
1652 }
1653
1654
1655 void x86_64_movq_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1656         *(cd->mcodeptr++) = 0x66;
1657         x86_64_emit_rex(0,(reg),0,(basereg));
1658         *(cd->mcodeptr++) = 0x0f;
1659         *(cd->mcodeptr++) = 0xd6;
1660         x86_64_emit_membase((basereg),(disp),(reg));
1661 }
1662
1663
1664 void x86_64_movq_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1665         *(cd->mcodeptr++) = 0xf3;
1666         x86_64_emit_rex(0,(dreg),0,(basereg));
1667         *(cd->mcodeptr++) = 0x0f;
1668         *(cd->mcodeptr++) = 0x7e;
1669         x86_64_emit_membase((basereg),(disp),(dreg));
1670 }
1671
1672
1673 void x86_64_movss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1674         *(cd->mcodeptr++) = 0xf3;
1675         x86_64_emit_rex(0,(reg),0,(dreg));
1676         *(cd->mcodeptr++) = 0x0f;
1677         *(cd->mcodeptr++) = 0x10;
1678         x86_64_emit_reg((reg),(dreg));
1679 }
1680
1681
1682 void x86_64_movsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1683         *(cd->mcodeptr++) = 0xf2;
1684         x86_64_emit_rex(0,(reg),0,(dreg));
1685         *(cd->mcodeptr++) = 0x0f;
1686         *(cd->mcodeptr++) = 0x10;
1687         x86_64_emit_reg((reg),(dreg));
1688 }
1689
1690
1691 void x86_64_movss_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1692         *(cd->mcodeptr++) = 0xf3;
1693         x86_64_emit_rex(0,(reg),0,(basereg));
1694         *(cd->mcodeptr++) = 0x0f;
1695         *(cd->mcodeptr++) = 0x11;
1696         x86_64_emit_membase((basereg),(disp),(reg));
1697 }
1698
1699
1700 void x86_64_movsd_reg_membase(codegendata *cd, s8 reg, s8 basereg, s8 disp) {
1701         *(cd->mcodeptr++) = 0xf2;
1702         x86_64_emit_rex(0,(reg),0,(basereg));
1703         *(cd->mcodeptr++) = 0x0f;
1704         *(cd->mcodeptr++) = 0x11;
1705         x86_64_emit_membase((basereg),(disp),(reg));
1706 }
1707
1708
1709 void x86_64_movss_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1710         *(cd->mcodeptr++) = 0xf3;
1711         x86_64_emit_rex(0,(dreg),0,(basereg));
1712         *(cd->mcodeptr++) = 0x0f;
1713         *(cd->mcodeptr++) = 0x10;
1714         x86_64_emit_membase((basereg),(disp),(dreg));
1715 }
1716
1717
1718 void x86_64_movlps_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1719         x86_64_emit_rex(0,(dreg),0,(basereg));
1720         *(cd->mcodeptr++) = 0x0f;
1721         *(cd->mcodeptr++) = 0x12;
1722         x86_64_emit_membase((basereg),(disp),(dreg));
1723 }
1724
1725
1726 void x86_64_movsd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1727         *(cd->mcodeptr++) = 0xf2;
1728         x86_64_emit_rex(0,(dreg),0,(basereg));
1729         *(cd->mcodeptr++) = 0x0f;
1730         *(cd->mcodeptr++) = 0x10;
1731         x86_64_emit_membase((basereg),(disp),(dreg));
1732 }
1733
1734
1735 void x86_64_movlpd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1736         *(cd->mcodeptr++) = 0x66;
1737         x86_64_emit_rex(0,(dreg),0,(basereg));
1738         *(cd->mcodeptr++) = 0x0f;
1739         *(cd->mcodeptr++) = 0x12;
1740         x86_64_emit_membase((basereg),(disp),(dreg));
1741 }
1742
1743
1744 void x86_64_movss_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1745         *(cd->mcodeptr++) = 0xf3;
1746         x86_64_emit_rex(0,(reg),(indexreg),(basereg));
1747         *(cd->mcodeptr++) = 0x0f;
1748         *(cd->mcodeptr++) = 0x11;
1749         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
1750 }
1751
1752
1753 void x86_64_movsd_reg_memindex(codegendata *cd, s8 reg, s8 disp, s8 basereg, s8 indexreg, s8 scale) {
1754         *(cd->mcodeptr++) = 0xf2;
1755         x86_64_emit_rex(0,(reg),(indexreg),(basereg));
1756         *(cd->mcodeptr++) = 0x0f;
1757         *(cd->mcodeptr++) = 0x11;
1758         x86_64_emit_memindex((reg),(disp),(basereg),(indexreg),(scale));
1759 }
1760
1761
1762 void x86_64_movss_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 dreg) {
1763         *(cd->mcodeptr++) = 0xf3;
1764         x86_64_emit_rex(0,(dreg),(indexreg),(basereg));
1765         *(cd->mcodeptr++) = 0x0f;
1766         *(cd->mcodeptr++) = 0x10;
1767         x86_64_emit_memindex((dreg),(disp),(basereg),(indexreg),(scale));
1768 }
1769
1770
1771 void x86_64_movsd_memindex_reg(codegendata *cd, s8 disp, s8 basereg, s8 indexreg, s8 scale, s8 dreg) {
1772         *(cd->mcodeptr++) = 0xf2;
1773         x86_64_emit_rex(0,(dreg),(indexreg),(basereg));
1774         *(cd->mcodeptr++) = 0x0f;
1775         *(cd->mcodeptr++) = 0x10;
1776         x86_64_emit_memindex((dreg),(disp),(basereg),(indexreg),(scale));
1777 }
1778
1779
1780 void x86_64_mulss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1781         *(cd->mcodeptr++) = 0xf3;
1782         x86_64_emit_rex(0,(dreg),0,(reg));
1783         *(cd->mcodeptr++) = 0x0f;
1784         *(cd->mcodeptr++) = 0x59;
1785         x86_64_emit_reg((dreg),(reg));
1786 }
1787
1788
1789 void x86_64_mulsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1790         *(cd->mcodeptr++) = 0xf2;
1791         x86_64_emit_rex(0,(dreg),0,(reg));
1792         *(cd->mcodeptr++) = 0x0f;
1793         *(cd->mcodeptr++) = 0x59;
1794         x86_64_emit_reg((dreg),(reg));
1795 }
1796
1797
1798 void x86_64_subss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1799         *(cd->mcodeptr++) = 0xf3;
1800         x86_64_emit_rex(0,(dreg),0,(reg));
1801         *(cd->mcodeptr++) = 0x0f;
1802         *(cd->mcodeptr++) = 0x5c;
1803         x86_64_emit_reg((dreg),(reg));
1804 }
1805
1806
1807 void x86_64_subsd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1808         *(cd->mcodeptr++) = 0xf2;
1809         x86_64_emit_rex(0,(dreg),0,(reg));
1810         *(cd->mcodeptr++) = 0x0f;
1811         *(cd->mcodeptr++) = 0x5c;
1812         x86_64_emit_reg((dreg),(reg));
1813 }
1814
1815
1816 void x86_64_ucomiss_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1817         x86_64_emit_rex(0,(dreg),0,(reg));
1818         *(cd->mcodeptr++) = 0x0f;
1819         *(cd->mcodeptr++) = 0x2e;
1820         x86_64_emit_reg((dreg),(reg));
1821 }
1822
1823
1824 void x86_64_ucomisd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1825         *(cd->mcodeptr++) = 0x66;
1826         x86_64_emit_rex(0,(dreg),0,(reg));
1827         *(cd->mcodeptr++) = 0x0f;
1828         *(cd->mcodeptr++) = 0x2e;
1829         x86_64_emit_reg((dreg),(reg));
1830 }
1831
1832
1833 void x86_64_xorps_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1834         x86_64_emit_rex(0,(dreg),0,(reg));
1835         *(cd->mcodeptr++) = 0x0f;
1836         *(cd->mcodeptr++) = 0x57;
1837         x86_64_emit_reg((dreg),(reg));
1838 }
1839
1840
1841 void x86_64_xorps_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1842         x86_64_emit_rex(0,(dreg),0,(basereg));
1843         *(cd->mcodeptr++) = 0x0f;
1844         *(cd->mcodeptr++) = 0x57;
1845         x86_64_emit_membase((basereg),(disp),(dreg));
1846 }
1847
1848
1849 void x86_64_xorpd_reg_reg(codegendata *cd, s8 reg, s8 dreg) {
1850         *(cd->mcodeptr++) = 0x66;
1851         x86_64_emit_rex(0,(dreg),0,(reg));
1852         *(cd->mcodeptr++) = 0x0f;
1853         *(cd->mcodeptr++) = 0x57;
1854         x86_64_emit_reg((dreg),(reg));
1855 }
1856
1857
1858 void x86_64_xorpd_membase_reg(codegendata *cd, s8 basereg, s8 disp, s8 dreg) {
1859         *(cd->mcodeptr++) = 0x66;
1860         x86_64_emit_rex(0,(dreg),0,(basereg));
1861         *(cd->mcodeptr++) = 0x0f;
1862         *(cd->mcodeptr++) = 0x57;
1863         x86_64_emit_membase((basereg),(disp),(dreg));
1864 }
1865
1866
1867 /*
1868  * These are local overrides for various environment variables in Emacs.
1869  * Please do not remove this and leave it at the end of the file, where
1870  * Emacs will automagically detect them.
1871  * ---------------------------------------------------------------------
1872  * Local variables:
1873  * mode: c
1874  * indent-tabs-mode: t
1875  * c-basic-offset: 4
1876  * tab-width: 4
1877  * End:
1878  */