git.saurik.com Git - apple/javascriptcore.git/blob

3 #

4 # Redistribution and use in source and binary forms, with or without

5 # modification, are permitted provided that the following conditions

6 # are met:

7 # 1. Redistributions of source code must retain the above copyright

8 # notice, this list of conditions and the following disclaimer.

9 # 2. Redistributions in binary form must reproduce the above copyright

10 # notice, this list of conditions and the following disclaimer in the

11 # documentation and/or other materials provided with the distribution.

12 #

13 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

14 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

15 # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

16 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

17 # BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

18 # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

19 # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

20 # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

21 # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

22 # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

23 # THE POSSIBILITY OF SUCH DAMAGE.

25 require "config"

27 def isX64

28 case $activeBackend

29 when "X86"

30 false

31 when "X86_WIN"

32 false

33 when "X86_64"

34 true

35 when "X86_64_WIN"

36 true

37 else

38 raise "bad value for $activeBackend: #{$activeBackend}"

39 end

40 end

42 def useX87

43 case $activeBackend

44 when "X86"

45 true

46 when "X86_WIN"

47 true

48 when "X86_64"

49 false

50 when "X86_64_WIN"

51 false

52 else

53 raise "bad value for $activeBackend: #{$activeBackend}"

54 end

55 end

57 def isWindows

     ENV['OS'] == 'Windows_NT'

59 end

61 def isGCC

62 !isWindows

63 end

65 def isMSVC

66 isWindows

67 end

69 def isIntelSyntax

70 isWindows

71 end

73 def register(name)

74 isIntelSyntax ? name : "%" + name

75 end

 def offsetRegister(off, register)

     isIntelSyntax ? "[#{off} + #{register}]" : "#{off}(#{register})"

79 end

81 def callPrefix

82 isIntelSyntax ? "" : "*"

83 end

85 def orderOperands(opA, opB)

     isIntelSyntax ? "#{opB}, #{opA}" : "#{opA}, #{opB}"

87 end

89 def const(c)

     isIntelSyntax ? "#{c}" : "$#{c}"

91 end

93 def getSizeString(kind)

94 if !isIntelSyntax

95 return ""

96 end

98 size = ""

99 case kind

100 when :byte

101 size = "byte"

102 when :half

103 size = "word"

104 when :int

105 size = "dword"

106 when :ptr

         size =  isX64 ? "qword" : "dword"

108 when :double

109 size = "qword"

110 when :quad

111 size = "qword"

112 else

113 raise "Invalid kind #{kind}"

114 end

115

     return size + " " + "ptr" + " ";

117 end

118

119 class SpecialRegister < NoChildren

120 def x86Operand(kind)

121 raise unless @name =~ /^r/

122 raise unless isX64

123 case kind

124 when :half

             register(@name + "w")

126 when :int

             register(@name + "d")

128 when :ptr

129 register(@name)

130 when :quad

131 register(@name)

132 else

133 raise

134 end

135 end

136 def x86CallOperand(kind)

137 # Call operands are not allowed to be partial registers.

         "#{callPrefix}#{x86Operand(:quad)}"

139 end

140 end

141

 X64_SCRATCH_REGISTER = SpecialRegister.new("r11")

143

144 class RegisterID

145 def supports8BitOnX86

146 case name

         when "t0", "a0", "r0", "t1", "a1", "r1", "t2", "t3", "t4", "t5"

148 true

         when "cfr", "ttnr", "tmr"

150 false

151 when "t6"

152 isX64

153 else

154 raise

155 end

156 end

157

158 def x86Operand(kind)

159 case name

         when "t0", "a0", "r0"

161 case kind

162 when :byte

163 register("al")

164 when :half

165 register("ax")

166 when :int

167 register("eax")

168 when :ptr

                 isX64 ? register("rax") : register("eax")

170 when :quad

                 isX64 ? register("rax") : raise

172 else

                 raise "Invalid kind #{kind} for name #{name}"

174 end

         when "t1", "a1", "r1"

176 case kind

177 when :byte

178 register("dl")

179 when :half

180 register("dx")

181 when :int

182 register("edx")

183 when :ptr

                 isX64 ? register("rdx") : register("edx")

185 when :quad

                 isX64 ? register("rdx") : raise

187 else

188 raise

189 end

190 when "t2"

191 case kind

192 when :byte

193 register("cl")

194 when :half

195 register("cx")

196 when :int

197 register("ecx")

198 when :ptr

                 isX64 ? register("rcx") : register("ecx")

200 when :quad

                 isX64 ? register("rcx") : raise

202 else

203 raise

204 end

205 when "t3"

206 case kind

207 when :byte

208 register("bl")

209 when :half

210 register("bx")

211 when :int

212 register("ebx")

213 when :ptr

                 isX64 ? register("rbx") : register("ebx")

215 when :quad

                 isX64 ? register("rbx") : raise

217 else

218 raise

219 end

220 when "t4"

221 case kind

222 when :byte

223 register("dil")

224 when :half

225 register("di")

226 when :int

227 register("edi")

228 when :ptr

                 isX64 ? register("rdi") : register("edi")

230 when :quad

                 isX64 ? register("rdi") : raise

232 else

233 raise

234 end

235 when "cfr"

236 if isX64

237 case kind

238 when :half

239 register("bp")

240 when :int

241 register("ebp")

242 when :ptr

243 register("rbp")

244 when :quad

245 register("rbp")

246 else

247 raise

248 end

249 else

250 case kind

251 when :half

252 register("bp")

253 when :int

254 register("ebp")

255 when :ptr

256 register("ebp")

257 else

258 raise

259 end

260 end

261 when "sp"

262 case kind

263 when :byte

264 register("spl")

265 when :half

266 register("sp")

267 when :int

268 register("esp")

269 when :ptr

                 isX64 ? register("rsp") : register("esp")

271 when :quad

                 isX64 ? register("rsp") : raise

273 else

274 raise

275 end

276 when "t5"

277 case kind

278 when :byte

279 register("sil")

280 when :half

281 register("si")

282 when :int

283 register("esi")

284 when :ptr

                 isX64 ? register("rsi") : register("esi")

286 when :quad

                 isX64 ? register("rsi") : raise

288 end

289 when "t6"

             raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

291 case kind

292 when :half

293 register("r8w")

294 when :int

295 register("r8d")

296 when :ptr

297 register("r8")

298 when :quad

299 register("r8")

300 end

301 when "t7"

             raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

303 case kind

304 when :half

305 register("r9w")

306 when :int

307 register("r9d")

308 when :ptr

309 register("r9")

310 when :quad

311 register("r9")

312 end

313 when "csr1"

             raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

315 case kind

316 when :half

317 register("r14w")

318 when :int

319 register("r14d")

320 when :ptr

321 register("r14")

322 when :quad

323 register("r14")

324 end

325 when "csr2"

             raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64

327 case kind

328 when :half

329 register("r15w")

330 when :int

331 register("r15d")

332 when :ptr

333 register("r15")

334 when :quad

335 register("r15")

336 end

337 else

             raise "Bad register #{name} for X86 at #{codeOriginString}"

339 end

340 end

341 def x86CallOperand(kind)

         isX64 ? "#{callPrefix}#{x86Operand(:quad)}" : "#{callPrefix}#{x86Operand(:ptr)}"

343 end

344 end

345

346 class FPRegisterID

347 def x86Operand(kind)

348 raise unless kind == :double

349 raise if useX87

350 case name

         when "ft0", "fa0", "fr"

352 register("xmm0")

353 when "ft1", "fa1"

354 register("xmm1")

355 when "ft2", "fa2"

356 register("xmm2")

357 when "ft3", "fa3"

358 register("xmm3")

359 when "ft4"

360 register("xmm4")

361 when "ft5"

362 register("xmm5")

363 else

             raise "Bad register #{name} for X86 at #{codeOriginString}"

365 end

366 end

367 def x87DefaultStackPosition

368 case name

369 when "ft0", "fr"

370 0

371 when "ft1"

372 1

         when "ft2", "ft3", "ft4", "ft5"

             raise "Unimplemented register #{name} for X86 at #{codeOriginString}"

375 else

             raise "Bad register #{name} for X86 at #{codeOriginString}"

377 end

378 end

379 def x87Operand(offset)

380 raise unless useX87

         raise unless offset == 0 or offset == 1

         "#{register("st")}(#{x87DefaultStackPosition + offset})"

383 end

384 def x86CallOperand(kind)

         "#{callPrefix}#{x86Operand(kind)}"

386 end

387 end

388

389 class Immediate

390 def validX86Immediate?

391 if isX64

             value >= -0x80000000 and value <= 0x7fffffff

393 else

394 true

395 end

396 end

397 def x86Operand(kind)

398 "#{const(value)}"

399 end

400 def x86CallOperand(kind)

401 "#{value}"

402 end

403 end

404

405 class Address

406 def supports8BitOnX86

407 true

408 end

409

410 def x86AddressOperand(addressKind)

411 "#{offsetRegister(offset.value, base.x86Operand(addressKind))}"

412 end

413 def x86Operand(kind)

         "#{getSizeString(kind)}#{x86AddressOperand(:ptr)}"

415 end

416 def x86CallOperand(kind)

         "#{callPrefix}#{x86Operand(kind)}"

418 end

419 end

420

421 class BaseIndex

422 def supports8BitOnX86

423 true

424 end

425

426 def x86AddressOperand(addressKind)

427 if !isIntelSyntax

             "#{offset.value}(#{base.x86Operand(addressKind)}, #{index.x86Operand(addressKind)}, #{scale})"

429 else

             "#{getSizeString(addressKind)}[#{offset.value} + #{base.x86Operand(addressKind)} + #{index.x86Operand(addressKind)} * #{scale}]"

431 end

432 end

433

434 def x86Operand(kind)

435 if !isIntelSyntax

436 x86AddressOperand(:ptr)

437 else

             "#{getSizeString(kind)}[#{offset.value} + #{base.x86Operand(:ptr)} + #{index.x86Operand(:ptr)} * #{scale}]"

439 end

440 end

441

442 def x86CallOperand(kind)

443 "#{callPrefix}#{x86Operand(kind)}"

444 end

445 end

446

447 class AbsoluteAddress

448 def supports8BitOnX86

449 true

450 end

451

452 def x86AddressOperand(addressKind)

453 "#{address.value}"

454 end

455

456 def x86Operand(kind)

457 "#{address.value}"

458 end

459

460 def x86CallOperand(kind)

461 "#{callPrefix}#{address.value}"

462 end

463 end

464

465 class LabelReference

466 def x86CallOperand(kind)

467 asmLabel

468 end

469 end

470

471 class LocalLabelReference

472 def x86Operand(kind)

473 asmLabel

474 end

475 def x86CallOperand(kind)

476 asmLabel

477 end

478 end

479

480 class Sequence

481 def getModifiedListX86_64

482 newList = []

483

484 @list.each {

485 | node |

486 newNode = node

487 if node.is_a? Instruction

488 unless node.opcode == "move"

489 usedScratch = false

490 newOperands = node.operands.map {

491 | operand |

492 if operand.immediate? and not operand.validX86Immediate?

493 if usedScratch

494 raise "Attempt to use scratch register twice at #{operand.codeOriginString}"

495 end

496 newList << Instruction.new(operand.codeOrigin, "move", [operand, X64_SCRATCH_REGISTER])

497 usedScratch = true

498 X64_SCRATCH_REGISTER

499 else

500 operand

501 end

502 }

503 newNode = Instruction.new(node.codeOrigin, node.opcode, newOperands, node.annotation)

504 end

505 else

506 unless node.is_a? Label or

507 node.is_a? LocalLabel or

508 node.is_a? Skip

509 raise "Unexpected #{node.inspect} at #{node.codeOrigin}"

510 end

511 end

512 if newNode

513 newList << newNode

514 end

515 }

516

517 return newList

518 end

519 def getModifiedListX86_64_WIN

520 getModifiedListX86_64

521 end

522 end

523

524 class Instruction

     @@floatingPointCompareImplicitOperand = isIntelSyntax ? "st(0), " : ""

526

527 def x86Operands(*kinds)

528 raise unless kinds.size == operands.size

529 result = []

530 kinds.size.times {

531 | idx |

532 i = isIntelSyntax ? (kinds.size - idx - 1) : idx

533 result << operands[i].x86Operand(kinds[i])

534 }

535 result.join(", ")

536 end

537

538 def x86Suffix(kind)

539 if isIntelSyntax

540 return ""

541 end

542

543 case kind

544 when :byte

545 "b"

546 when :half

547 "w"

548 when :int

549 "l"

550 when :ptr

551 isX64 ? "q" : "l"

552 when :quad

553 isX64 ? "q" : raise

554 when :double

555 not useX87 ? "sd" : raise

556 else

557 raise

558 end

559 end

560

561 def x86Bytes(kind)

562 case kind

563 when :byte

564 1

565 when :half

566 2

567 when :int

568 4

569 when :ptr

570 isX64 ? 8 : 4

571 when :quad

572 isX64 ? 8 : raise

573 when :double

574 8

575 else

576 raise

577 end

578 end

579

580 def handleX86OpWithNumOperands(opcode, kind, numOperands)

581 if numOperands == 3

582 if operands[0] == operands[2]

583 $asm.puts "#{opcode} #{orderOperands(operands[1].x86Operand(kind), operands[2].x86Operand(kind))}"

584 elsif operands[1] == operands[2]

585 $asm.puts "#{opcode} #{orderOperands(operands[0].x86Operand(kind), operands[2].x86Operand(kind))}"

586 else

587 $asm.puts "mov#{x86Suffix(kind)} #{orderOperands(operands[0].x86Operand(kind), operands[2].x86Operand(kind))}"

588 $asm.puts "#{opcode} #{orderOperands(operands[1].x86Operand(kind), operands[2].x86Operand(kind))}"

589 end

590 else

591 $asm.puts "#{opcode} #{orderOperands(operands[0].x86Operand(kind), operands[1].x86Operand(kind))}"

592 end

593 end

594

595 def handleX86Op(opcode, kind)

596 handleX86OpWithNumOperands(opcode, kind, operands.size)

597 end

598

599 def handleX86Shift(opcode, kind)

600 if operands[0].is_a? Immediate or operands[0] == RegisterID.forName(nil, "t2")

601 $asm.puts "#{opcode} #{orderOperands(operands[0].x86Operand(:byte), operands[1].x86Operand(kind))}"

602 else

603 cx = RegisterID.forName(nil, "t2")

             $asm.puts "xchg#{x86Suffix(:ptr)} #{operands[0].x86Operand(:ptr)}, #{cx.x86Operand(:ptr)}"

605 $asm.puts "#{opcode} #{orderOperands(register("cl"), operands[1].x86Operand(kind))}"

             $asm.puts "xchg#{x86Suffix(:ptr)} #{operands[0].x86Operand(:ptr)}, #{cx.x86Operand(:ptr)}"

607 end

608 end

609

610 def handleX86DoubleBranch(branchOpcode, mode)

611 if useX87

612 handleX87Compare(mode)

613 else

614 case mode

615 when :normal

616 $asm.puts "ucomisd #{orderOperands(operands[1].x86Operand(:double), operands[0].x86Operand(:double))}"

617 when :reverse

618 $asm.puts "ucomisd #{orderOperands(operands[0].x86Operand(:double), operands[1].x86Operand(:double))}"

619 else

620 raise mode.inspect

621 end

622 end

623 $asm.puts "#{branchOpcode} #{operands[2].asmLabel}"

624 end

625

626 def handleX86IntCompare(opcodeSuffix, kind)

627 if operands[0].is_a? Immediate and operands[0].value == 0 and operands[1].is_a? RegisterID and (opcodeSuffix == "e" or opcodeSuffix == "ne")

628 $asm.puts "test#{x86Suffix(kind)} #{orderOperands(operands[1].x86Operand(kind), operands[1].x86Operand(kind))}"

629 elsif operands[1].is_a? Immediate and operands[1].value == 0 and operands[0].is_a? RegisterID and (opcodeSuffix == "e" or opcodeSuffix == "ne")

630 $asm.puts "test#{x86Suffix(kind)} #{orderOperands(operands[0].x86Operand(kind), operands[0].x86Operand(kind))}"

631 else

632 $asm.puts "cmp#{x86Suffix(kind)} #{orderOperands(operands[1].x86Operand(kind), operands[0].x86Operand(kind))}"

633 end

634 end

635

636 def handleX86IntBranch(branchOpcode, kind)

637 handleX86IntCompare(branchOpcode[1..-1], kind)

638 $asm.puts "#{branchOpcode} #{operands[2].asmLabel}"

639 end

640

641 def handleX86Set(setOpcode, operand)

642 if operand.supports8BitOnX86

643 $asm.puts "#{setOpcode} #{operand.x86Operand(:byte)}"

644 if !isIntelSyntax

                 $asm.puts "movzbl #{orderOperands(operand.x86Operand(:byte), operand.x86Operand(:int))}"

646 else

                 $asm.puts "movzx #{orderOperands(operand.x86Operand(:byte), operand.x86Operand(:int))}"

648 end

649 else

             ax = RegisterID.new(nil, "t0")

             $asm.puts "xchg#{x86Suffix(:ptr)} #{operand.x86Operand(:ptr)}, #{ax.x86Operand(:ptr)}"

             $asm.puts "#{setOpcode} %al"

653 $asm.puts "movzbl %al, %eax"

             $asm.puts "xchg#{x86Suffix(:ptr)} #{operand.x86Operand(:ptr)}, #{ax.x86Operand(:ptr)}"

655 end

656 end

657

     def handleX86IntCompareSet(setOpcode, kind)

         handleX86IntCompare(setOpcode[3..-1], kind)

         handleX86Set(setOpcode, operands[2])

661 end

662

663 def handleX86Test(kind)

664 value = operands[0]

665 case operands.size

666 when 2

             mask = Immediate.new(codeOrigin, -1)

668 when 3

669 mask = operands[1]

670 else

             raise "Expected 2 or 3 operands, but got #{operands.size} at #{codeOriginString}"

672 end

673

         if mask.is_a? Immediate and mask.value == -1

675 if value.is_a? RegisterID

                 $asm.puts "test#{x86Suffix(kind)} #{value.x86Operand(kind)}, #{value.x86Operand(kind)}"

677 else

                 $asm.puts "cmp#{x86Suffix(kind)} #{orderOperands(const(0), value.x86Operand(kind))}"

679 end

680 else

             $asm.puts "test#{x86Suffix(kind)} #{orderOperands(mask.x86Operand(kind), value.x86Operand(kind))}"

682 end

683 end

684

     def handleX86BranchTest(branchOpcode, kind)

686 handleX86Test(kind)

         $asm.puts "#{branchOpcode} #{operands.last.asmLabel}"

688 end

689

     def handleX86SetTest(setOpcode, kind)

691 handleX86Test(kind)

         handleX86Set(setOpcode, operands.last)

693 end

694

     def handleX86OpBranch(opcode, branchOpcode, kind)

         handleX86OpWithNumOperands(opcode, kind, operands.size - 1)

697 case operands.size

698 when 4

699 jumpTarget = operands[3]

700 when 3

701 jumpTarget = operands[2]

702 else

703 raise self.inspect

704 end

         $asm.puts "#{branchOpcode} #{jumpTarget.asmLabel}"

706 end

707

     def handleX86SubBranch(branchOpcode, kind)

         if operands.size == 4 and operands[1] == operands[2]

             $asm.puts "neg#{x86Suffix(kind)} #{operands[2].x86Operand(kind)}"

             $asm.puts "add#{x86Suffix(kind)} #{orderOperands(operands[0].x86Operand(kind), operands[2].x86Operand(kind))}"

712 else

             handleX86OpWithNumOperands("sub#{x86Suffix(kind)}", kind, operands.size - 1)

714 end

715 case operands.size

716 when 4

717 jumpTarget = operands[3]

718 when 3

719 jumpTarget = operands[2]

720 else

721 raise self.inspect

722 end

         $asm.puts "#{branchOpcode} #{jumpTarget.asmLabel}"

724 end

725

726 def handleX86Add(kind)

         if operands.size == 3 and operands[1] == operands[2]

             unless Immediate.new(nil, 0) == operands[0]

                 $asm.puts "add#{x86Suffix(kind)} #{orderOperands(operands[0].x86Operand(kind), operands[2].x86Operand(kind))}"

730 end

         elsif operands.size == 3 and operands[0].is_a? Immediate

             raise unless operands[1].is_a? RegisterID

             raise unless operands[2].is_a? RegisterID

             if operands[0].value == 0

                 unless operands[1] == operands[2]

                     $asm.puts "mov#{x86Suffix(kind)} #{orderOperands(operands[1].x86Operand(kind), operands[2].x86Operand(kind))}"

737 end

738 else

                 $asm.puts "lea#{x86Suffix(kind)} #{orderOperands(offsetRegister(operands[0].value, operands[1].x86Operand(kind)), operands[2].x86Operand(kind))}"

740 end

         elsif operands.size == 3 and operands[0].is_a? RegisterID

             raise unless operands[1].is_a? RegisterID

             raise unless operands[2].is_a? RegisterID

             if operands[0] == operands[2]

                 $asm.puts "add#{x86Suffix(kind)} #{orderOperands(operands[1].x86Operand(kind), operands[2].x86Operand(kind))}"

746 else

747 if !isIntelSyntax

                     $asm.puts "lea#{x86Suffix(kind)} (#{operands[0].x86Operand(kind)}, #{operands[1].x86Operand(kind)}), #{operands[2].x86Operand(kind)}"

749 else

                     $asm.puts "lea#{x86Suffix(kind)} #{operands[2].x86Operand(kind)}, [#{operands[0].x86Operand(kind)} + #{operands[1].x86Operand(kind)}]"

751 end

752 end

753 else

754 unless Immediate.new(nil, 0) == operands[0]

755 $asm.puts "add#{x86Suffix(kind)} #{x86Operands(kind, kind)}"

756 end

757 end

758 end

759

760 def handleX86Sub(kind)

761 if operands.size == 3 and operands[1] == operands[2]

762 $asm.puts "neg#{x86Suffix(kind)} #{operands[2].x86Operand(kind)}"

763 $asm.puts "add#{x86Suffix(kind)} #{orderOperands(operands[0].x86Operand(kind), operands[2].x86Operand(kind))}"

764 else

765 handleX86Op("sub#{x86Suffix(kind)}", kind)

766 end

767 end

768

769 def handleX86Mul(kind)

770 if operands.size == 3 and operands[0].is_a? Immediate

771 $asm.puts "imul#{x86Suffix(kind)} #{x86Operands(kind, kind, kind)}"

772 else

773 # FIXME: could do some peephole in case the left operand is immediate and it's

774 # a power of two.

775 handleX86Op("imul#{x86Suffix(kind)}", kind)

776 end

777 end

778

779 def handleX86Peek()

780 sp = RegisterID.new(nil, "sp")

781 opA = offsetRegister(operands[0].value * x86Bytes(:ptr), sp.x86Operand(:ptr))

782 opB = operands[1].x86Operand(:ptr)

783 $asm.puts "mov#{x86Suffix(:ptr)} #{orderOperands(opA, opB)}"

784 end

785

786 def handleX86Poke()

787 sp = RegisterID.new(nil, "sp")

788 opA = operands[0].x86Operand(:ptr)

789 opB = offsetRegister(operands[1].value * x86Bytes(:ptr), sp.x86Operand(:ptr))

790 $asm.puts "mov#{x86Suffix(:ptr)} #{orderOperands(opA, opB)}"

791 end

792

793 def handleMove

794 if Immediate.new(nil, 0) == operands[0] and operands[1].is_a? RegisterID

795 if isX64

                 $asm.puts "xor#{x86Suffix(:quad)} #{operands[1].x86Operand(:quad)}, #{operands[1].x86Operand(:quad)}"

797 else

                 $asm.puts "xor#{x86Suffix(:ptr)} #{operands[1].x86Operand(:ptr)}, #{operands[1].x86Operand(:ptr)}"

799 end

         elsif operands[0] != operands[1]

801 if isX64

                 $asm.puts "mov#{x86Suffix(:quad)} #{x86Operands(:quad, :quad)}"

803 else

                 $asm.puts "mov#{x86Suffix(:ptr)} #{x86Operands(:ptr, :ptr)}"

805 end

806 end

807 end

808

809 def handleX87Compare(mode)

810 case mode

811 when :normal

             if (operands[0].x87DefaultStackPosition == 0)

                 $asm.puts "fucomi #{@@floatingPointCompareImplicitOperand}#{operands[1].x87Operand(0)}"

814 else

                 $asm.puts "fld #{operands[0].x87Operand(0)}"

                 $asm.puts "fucomip #{@@floatingPointCompareImplicitOperand}#{operands[1].x87Operand(1)}"

817 end

818 when :reverse

             if (operands[1].x87DefaultStackPosition == 0)

                 $asm.puts "fucomi #{@@floatingPointCompareImplicitOperand}#{operands[0].x87Operand(0)}"

821 else

                 $asm.puts "fld #{operands[1].x87Operand(0)}"

                 $asm.puts "fucomip #{@@floatingPointCompareImplicitOperand}#{operands[0].x87Operand(1)}"

824 end

825 else

826 raise mode.inspect

827 end

828 end

829

     def handleX87BinOp(opcode, opcodereverse)

         if (operands[1].x87DefaultStackPosition == 0)

             $asm.puts "#{opcode} #{orderOperands(operands[0].x87Operand(0), register("st"))}"

         elsif (operands[0].x87DefaultStackPosition == 0)

834 if !isIntelSyntax

                 $asm.puts "#{opcodereverse} #{register("st")}, #{operands[1].x87Operand(0)}"

836 else

                 $asm.puts "#{opcode} #{operands[1].x87Operand(0)}, #{register("st")}"

838 end

839 else

             $asm.puts "fld #{operands[0].x87Operand(0)}"

             $asm.puts "#{opcodereverse}p #{orderOperands(register("st"), operands[1].x87Operand(1))}"

842 end

843 end

844

845 def lowerX86

846 raise unless $activeBackend == "X86"

847 lowerX86Common

848 end

849

850 def lowerX86_WIN

851 raise unless $activeBackend == "X86_WIN"

852 lowerX86Common

853 end

854

855 def lowerX86_64

856 raise unless $activeBackend == "X86_64"

857 lowerX86Common

858 end

859

860 def lowerX86_64_WIN

861 raise unless $activeBackend == "X86_64_WIN"

862 lowerX86Common

863 end

864

865 def lowerX86Common

866 $asm.codeOrigin codeOriginString if $enableCodeOriginComments

867 $asm.annotation annotation if $enableInstrAnnotations

868

869 case opcode

870 when "addi"

871 handleX86Add(:int)

872 when "addp"

873 handleX86Add(:ptr)

874 when "addq"

875 handleX86Add(:quad)

876 when "andi"

             handleX86Op("and#{x86Suffix(:int)}", :int)

878 when "andp"

             handleX86Op("and#{x86Suffix(:ptr)}", :ptr)

880 when "andq"

             handleX86Op("and#{x86Suffix(:quad)}", :quad)

882 when "lshifti"

             handleX86Shift("sal#{x86Suffix(:int)}", :int)

884 when "lshiftp"

             handleX86Shift("sal#{x86Suffix(:ptr)}", :ptr)

886 when "lshiftq"

             handleX86Shift("sal#{x86Suffix(:quad)}", :quad)

888 when "muli"

889 handleX86Mul(:int)

890 when "mulp"

891 handleX86Mul(:ptr)

892 when "mulq"

893 handleX86Mul(:quad)

894 when "negi"

             $asm.puts "neg#{x86Suffix(:int)} #{x86Operands(:int)}"

896 when "negp"

             $asm.puts "neg#{x86Suffix(:ptr)} #{x86Operands(:ptr)}"

898 when "negq"

             $asm.puts "neg#{x86Suffix(:quad)} #{x86Operands(:quad)}"

900 when "noti"

             $asm.puts "not#{x86Suffix(:int)} #{x86Operands(:int)}"

902 when "ori"

             handleX86Op("or#{x86Suffix(:int)}", :int)

904 when "orp"

             handleX86Op("or#{x86Suffix(:ptr)}", :ptr)

906 when "orq"

             handleX86Op("or#{x86Suffix(:quad)}", :quad)

908 when "rshifti"

             handleX86Shift("sar#{x86Suffix(:int)}", :int)

910 when "rshiftp"

             handleX86Shift("sar#{x86Suffix(:ptr)}", :ptr)

912 when "rshiftq"

             handleX86Shift("sar#{x86Suffix(:quad)}", :quad)

914 when "urshifti"

             handleX86Shift("shr#{x86Suffix(:int)}", :int)

916 when "urshiftp"

             handleX86Shift("shr#{x86Suffix(:ptr)}", :ptr)

918 when "urshiftq"

             handleX86Shift("shr#{x86Suffix(:quad)}", :quad)

920 when "subi"

921 handleX86Sub(:int)

922 when "subp"

923 handleX86Sub(:ptr)

924 when "subq"

925 handleX86Sub(:quad)

926 when "xori"

             handleX86Op("xor#{x86Suffix(:int)}", :int)

928 when "xorp"

             handleX86Op("xor#{x86Suffix(:ptr)}", :ptr)

930 when "xorq"

             handleX86Op("xor#{x86Suffix(:quad)}", :quad)

932 when "loadi", "storei"

             $asm.puts "mov#{x86Suffix(:int)} #{x86Operands(:int, :int)}"

934 when "loadis"

935 if isX64

936 if !isIntelSyntax

                     $asm.puts "movslq #{x86Operands(:int, :quad)}"

938 else

                     $asm.puts "movsxd #{x86Operands(:int, :quad)}"

940 end

941 else

                 $asm.puts "mov#{x86Suffix(:int)} #{x86Operands(:int, :int)}"

943 end

944 when "loadp", "storep"

             $asm.puts "mov#{x86Suffix(:ptr)} #{x86Operands(:ptr, :ptr)}"

946 when "loadq", "storeq"

             $asm.puts "mov#{x86Suffix(:quad)} #{x86Operands(:quad, :quad)}"

948 when "loadb"

949 if !isIntelSyntax

                 $asm.puts "movzbl #{orderOperands(operands[0].x86Operand(:byte), operands[1].x86Operand(:int))}"

951 else

                 $asm.puts "movzx #{orderOperands(operands[0].x86Operand(:byte), operands[1].x86Operand(:int))}"

953 end

954 when "loadbs"

             $asm.puts "movsbl #{operands[0].x86Operand(:byte)}, #{operands[1].x86Operand(:int)}"

956 when "loadh"

957 if !isIntelSyntax

                 $asm.puts "movzwl #{orderOperands(operands[0].x86Operand(:half), operands[1].x86Operand(:int))}"

959 else

                 $asm.puts "movzx #{orderOperands(operands[0].x86Operand(:half), operands[1].x86Operand(:int))}"

961 end

962 when "loadhs"

             $asm.puts "movswl #{operands[0].x86Operand(:half)}, #{operands[1].x86Operand(:int)}"

964 when "storeb"

             $asm.puts "mov#{x86Suffix(:byte)} #{x86Operands(:byte, :byte)}"

966 when "loadd"

967 if useX87

968 if !isIntelSyntax

                     $asm.puts "fldl #{operands[0].x86Operand(:double)}"

970 else

                     $asm.puts "fld #{operands[0].x86Operand(:double)}"

972 end

                 $asm.puts "fstp #{operands[1].x87Operand(1)}"

974 else

                 $asm.puts "movsd #{x86Operands(:double, :double)}"

976 end

977 when "moved"

978 if useX87

                 if (operands[0].x87DefaultStackPosition == 0)

                     $asm.puts "fst #{operands[1].x87Operand(0)}"

981 else

                     $asm.puts "fld #{operands[0].x87Operand(0)}"

                     $asm.puts "fstp #{operands[1].x87Operand(1)}"

984 end

985 else

                 $asm.puts "movsd #{x86Operands(:double, :double)}"

987 end

988 when "stored"

989 if useX87

                 if (operands[0].x87DefaultStackPosition == 0)

                     $asm.puts "fst#{x86Suffix(:int)} #{operands[1].x86Operand(:double)}"

992 else

                     $asm.puts "fld #{operands[0].x87Operand(0)}"

994 if !isIntelSyntax

                         $asm.puts "fstpl #{operands[1].x86Operand(:double)}"

996 else

                         $asm.puts "fstp #{operands[1].x86Operand(:double)}"

998 end

999 end

1000 else

                 $asm.puts "movsd #{x86Operands(:double, :double)}"

1002 end

1003 when "addd"

1004 if useX87

                 handleX87BinOp("fadd", "fadd")

1006 else

                 $asm.puts "addsd #{x86Operands(:double, :double)}"

1008 end

1009 when "muld"

1010 if useX87

                 handleX87BinOp("fmul", "fmul")

1012 else

                 $asm.puts "mulsd #{x86Operands(:double, :double)}"

1014 end

1015 when "subd"

1016 if useX87

                 handleX87BinOp("fsub", "fsubr")

1018 else

                 $asm.puts "subsd #{x86Operands(:double, :double)}"

1020 end

1021 when "divd"

1022 if useX87

                 handleX87BinOp("fdiv", "fdivr")

1024 else

                 $asm.puts "divsd #{x86Operands(:double, :double)}"

1026 end

1027 when "sqrtd"

1028 if useX87

                 $asm.puts "fld #{operands[0].x87Operand(0)}"

1030 $asm.puts "fsqrtl"

                 $asm.puts "fstp #{operands[1].x87Operand(1)}"

1032 else

                 $asm.puts "sqrtsd #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:double)}"

1034 end

1035 when "ci2d"

1036 if useX87

                 sp = RegisterID.new(nil, "sp")

                 $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(operands[0].x86Operand(:int), offsetRegister(-4, sp.x86Operand(:ptr)))}"

                 $asm.puts "fild#{x86Suffix(:ptr)} #{getSizeString(:ptr)}#{offsetRegister(-4, sp.x86Operand(:ptr))}"

                 $asm.puts "fstp #{operands[1].x87Operand(1)}"

1041 else

                 $asm.puts "cvtsi2sd #{orderOperands(operands[0].x86Operand(:int), operands[1].x86Operand(:double))}"

1043 end

1044 when "bdeq"

1045 if useX87

1046 handleX87Compare(:normal)

1047 else

                 $asm.puts "ucomisd #{orderOperands(operands[0].x86Operand(:double), operands[1].x86Operand(:double))}"

1049 end

             if operands[0] == operands[1]

1051 # This is just a jump ordered, which is a jnp.

                 $asm.puts "jnp #{operands[2].asmLabel}"

1053 else

                 isUnordered = LocalLabel.unique("bdeq")

                 $asm.puts "jp #{LabelReference.new(codeOrigin, isUnordered).asmLabel}"

                 $asm.puts "je #{LabelReference.new(codeOrigin, operands[2]).asmLabel}"

                 isUnordered.lower("X86")

1058 end

1059 when "bdneq"

             handleX86DoubleBranch("jne", :normal)

1061 when "bdgt"

             handleX86DoubleBranch("ja", :normal)

1063 when "bdgteq"

             handleX86DoubleBranch("jae", :normal)

1065 when "bdlt"

             handleX86DoubleBranch("ja", :reverse)

1067 when "bdlteq"

             handleX86DoubleBranch("jae", :reverse)

1069 when "bdequn"

             handleX86DoubleBranch("je", :normal)

1071 when "bdnequn"

1072 if useX87

1073 handleX87Compare(:normal)

1074 else

                 $asm.puts "ucomisd #{orderOperands(operands[0].x86Operand(:double), operands[1].x86Operand(:double))}"

1076 end

             if operands[0] == operands[1]

1078 # This is just a jump unordered, which is a jp.

                 $asm.puts "jp #{operands[2].asmLabel}"

1080 else

                 isUnordered = LocalLabel.unique("bdnequn")

                 isEqual = LocalLabel.unique("bdnequn")

                 $asm.puts "jp #{LabelReference.new(codeOrigin, isUnordered).asmLabel}"

                 $asm.puts "je #{LabelReference.new(codeOrigin, isEqual).asmLabel}"

                 isUnordered.lower("X86")

                 $asm.puts "jmp #{operands[2].asmLabel}"

                 isEqual.lower("X86")

1088 end

1089 when "bdgtun"

             handleX86DoubleBranch("jb", :reverse)

1091 when "bdgtequn"

             handleX86DoubleBranch("jbe", :reverse)

1093 when "bdltun"

             handleX86DoubleBranch("jb", :normal)

1095 when "bdltequn"

             handleX86DoubleBranch("jbe", :normal)

1097 when "btd2i"

1098 # FIXME: unused and unimplemented for x87

1099 raise if useX87

             $asm.puts "cvttsd2si #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:int)}"

             $asm.puts "cmpl $0x80000000 #{operands[1].x86Operand(:int)}"

             $asm.puts "je #{operands[2].asmLabel}"

1103 when "td2i"

1104 # FIXME: unused and unimplemented for x87

1105 raise if useX87

             $asm.puts "cvttsd2si #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:int)}"

1107 when "bcd2i"

1108 if useX87

                 sp = RegisterID.new(nil, "sp")

                 if (operands[0].x87DefaultStackPosition == 0)

                     $asm.puts "fistl -4(#{sp.x86Operand(:ptr)})"

1112 else

                     $asm.puts "fld #{operands[0].x87Operand(0)}"

                     $asm.puts "fistp#{x86Suffix(:ptr)} #{getSizeString(:ptr)}#{offsetRegister(-4, sp.x86Operand(:ptr))}"

1115 end

                 $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(offsetRegister(-4, sp.x86Operand(:ptr)), operands[1].x86Operand(:int))}"

                 $asm.puts "test#{x86Suffix(:int)} #{operands[1].x86Operand(:int)}, #{operands[1].x86Operand(:int)}"

                 $asm.puts "je #{operands[2].asmLabel}"

                 $asm.puts "fild#{x86Suffix(:int)} #{getSizeString(:int)}#{offsetRegister(-4, sp.x86Operand(:ptr))}"

                 $asm.puts "fucomip #{@@floatingPointCompareImplicitOperand}#{operands[0].x87Operand(1)}"

                 $asm.puts "jp #{operands[2].asmLabel}"

                 $asm.puts "jne #{operands[2].asmLabel}"

1123 else

                 $asm.puts "cvttsd2si #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:int)}"

                 $asm.puts "test#{x86Suffix(:int)} #{operands[1].x86Operand(:int)}, #{operands[1].x86Operand(:int)}"

                 $asm.puts "je #{operands[2].asmLabel}"

                 $asm.puts "cvtsi2sd #{operands[1].x86Operand(:int)}, %xmm7"

                 $asm.puts "ucomisd #{operands[0].x86Operand(:double)}, %xmm7"

                 $asm.puts "jp #{operands[2].asmLabel}"

                 $asm.puts "jne #{operands[2].asmLabel}"

1131 end

1132 when "movdz"

1133 if useX87

1134 $asm.puts "fldzl"

                 $asm.puts "fstp #{operands[0].x87Operand(1)}"

1136 else

                 $asm.puts "xorpd #{operands[0].x86Operand(:double)}, #{operands[0].x86Operand(:double)}"

1138 end

1139 when "pop"

1140 operands.each {

1141 | op |

                 $asm.puts "pop #{op.x86Operand(:ptr)}"

1143 }

1144 when "push"

1145 operands.each {

1146 | op |

                 $asm.puts "push #{op.x86Operand(:ptr)}"

1148 }

1149 when "move"

1150 handleMove

1151 when "sxi2q"

1152 if !isIntelSyntax

                 $asm.puts "movslq #{operands[0].x86Operand(:int)}, #{operands[1].x86Operand(:quad)}"

1154 else

                 $asm.puts "movsxd #{orderOperands(operands[0].x86Operand(:int), operands[1].x86Operand(:quad))}"

1156 end

1157 when "zxi2q"

             $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(operands[0].x86Operand(:int), operands[1].x86Operand(:int))}"

1159 when "nop"

1160 $asm.puts "nop"

1161 when "bieq"

             handleX86IntBranch("je", :int)

1163 when "bpeq"

             handleX86IntBranch("je", :ptr)

1165 when "bqeq"

             handleX86IntBranch("je", :quad)

1167 when "bineq"

             handleX86IntBranch("jne", :int)

1169 when "bpneq"

             handleX86IntBranch("jne", :ptr)

1171 when "bqneq"

             handleX86IntBranch("jne", :quad)

1173 when "bia"

             handleX86IntBranch("ja", :int)

1175 when "bpa"

             handleX86IntBranch("ja", :ptr)

1177 when "bqa"

             handleX86IntBranch("ja", :quad)

1179 when "biaeq"

             handleX86IntBranch("jae", :int)

1181 when "bpaeq"

             handleX86IntBranch("jae", :ptr)

1183 when "bqaeq"

             handleX86IntBranch("jae", :quad)

1185 when "bib"

             handleX86IntBranch("jb", :int)

1187 when "bpb"

             handleX86IntBranch("jb", :ptr)

1189 when "bqb"

             handleX86IntBranch("jb", :quad)

1191 when "bibeq"

             handleX86IntBranch("jbe", :int)

1193 when "bpbeq"

             handleX86IntBranch("jbe", :ptr)

1195 when "bqbeq"

             handleX86IntBranch("jbe", :quad)

1197 when "bigt"

             handleX86IntBranch("jg", :int)

1199 when "bpgt"

             handleX86IntBranch("jg", :ptr)

1201 when "bqgt"

             handleX86IntBranch("jg", :quad)

1203 when "bigteq"

             handleX86IntBranch("jge", :int)

1205 when "bpgteq"

             handleX86IntBranch("jge", :ptr)

1207 when "bqgteq"

             handleX86IntBranch("jge", :quad)

1209 when "bilt"

             handleX86IntBranch("jl", :int)

1211 when "bplt"

             handleX86IntBranch("jl", :ptr)

1213 when "bqlt"

             handleX86IntBranch("jl", :quad)

1215 when "bilteq"

             handleX86IntBranch("jle", :int)

1217 when "bplteq"

             handleX86IntBranch("jle", :ptr)

1219 when "bqlteq"

             handleX86IntBranch("jle", :quad)

1221 when "bbeq"

             handleX86IntBranch("je", :byte)

1223 when "bbneq"

             handleX86IntBranch("jne", :byte)

1225 when "bba"

             handleX86IntBranch("ja", :byte)

1227 when "bbaeq"

             handleX86IntBranch("jae", :byte)

1229 when "bbb"

             handleX86IntBranch("jb", :byte)

1231 when "bbbeq"

             handleX86IntBranch("jbe", :byte)

1233 when "bbgt"

             handleX86IntBranch("jg", :byte)

1235 when "bbgteq"

             handleX86IntBranch("jge", :byte)

1237 when "bblt"

             handleX86IntBranch("jl", :byte)

1239 when "bblteq"

             handleX86IntBranch("jlteq", :byte)

1241 when "btis"

             handleX86BranchTest("js", :int)

1243 when "btps"

             handleX86BranchTest("js", :ptr)

1245 when "btqs"

             handleX86BranchTest("js", :quad)

1247 when "btiz"

             handleX86BranchTest("jz", :int)

1249 when "btpz"

             handleX86BranchTest("jz", :ptr)

1251 when "btqz"

             handleX86BranchTest("jz", :quad)

1253 when "btinz"

             handleX86BranchTest("jnz", :int)

1255 when "btpnz"

             handleX86BranchTest("jnz", :ptr)

1257 when "btqnz"

             handleX86BranchTest("jnz", :quad)

1259 when "btbs"

             handleX86BranchTest("js", :byte)

1261 when "btbz"

             handleX86BranchTest("jz", :byte)

1263 when "btbnz"

             handleX86BranchTest("jnz", :byte)

1265 when "jmp"

             $asm.puts "jmp #{operands[0].x86CallOperand(:ptr)}"

1267 when "baddio"

             handleX86OpBranch("add#{x86Suffix(:int)}", "jo", :int)

1269 when "baddpo"

             handleX86OpBranch("add#{x86Suffix(:ptr)}", "jo", :ptr)

1271 when "baddqo"

             handleX86OpBranch("add#{x86Suffix(:quad)}", "jo", :quad)

1273 when "baddis"

             handleX86OpBranch("add#{x86Suffix(:int)}", "js", :int)

1275 when "baddps"

             handleX86OpBranch("add#{x86Suffix(:ptr)}", "js", :ptr)

1277 when "baddqs"

             handleX86OpBranch("add#{x86Suffix(:quad)}", "js", :quad)

1279 when "baddiz"

             handleX86OpBranch("add#{x86Suffix(:int)}", "jz", :int)

1281 when "baddpz"

             handleX86OpBranch("add#{x86Suffix(:ptr)}", "jz", :ptr)

1283 when "baddqz"

             handleX86OpBranch("add#{x86Suffix(:quad)}", "jz", :quad)

1285 when "baddinz"

             handleX86OpBranch("add#{x86Suffix(:int)}", "jnz", :int)

1287 when "baddpnz"

             handleX86OpBranch("add#{x86Suffix(:ptr)}", "jnz", :ptr)

1289 when "baddqnz"

             handleX86OpBranch("add#{x86Suffix(:quad)}", "jnz", :quad)

1291 when "bsubio"

             handleX86SubBranch("jo", :int)

1293 when "bsubis"

             handleX86SubBranch("js", :int)

1295 when "bsubiz"

             handleX86SubBranch("jz", :int)

1297 when "bsubinz"

             handleX86SubBranch("jnz", :int)

1299 when "bmulio"

             handleX86OpBranch("imul#{x86Suffix(:int)}", "jo", :int)

1301 when "bmulis"

             handleX86OpBranch("imul#{x86Suffix(:int)}", "js", :int)

1303 when "bmuliz"

             handleX86OpBranch("imul#{x86Suffix(:int)}", "jz", :int)

1305 when "bmulinz"

             handleX86OpBranch("imul#{x86Suffix(:int)}", "jnz", :int)

1307 when "borio"

             handleX86OpBranch("orl", "jo", :int)

1309 when "boris"

             handleX86OpBranch("orl", "js", :int)

1311 when "boriz"

             handleX86OpBranch("orl", "jz", :int)

1313 when "borinz"

             handleX86OpBranch("orl", "jnz", :int)

1315 when "break"

             $asm.puts "int #{const(3)}"

1317 when "call"

1318 if useX87

1319 2.times {

1320 | offset |

                     $asm.puts "ffree #{register("st")}(#{offset})"

1322 }

1323 end

             op = operands[0].x86CallOperand(:ptr)

             if operands[0].is_a? LabelReference

1326 operands[0].used

1327 end

             $asm.puts "call #{op}"

1329 when "ret"

1330 $asm.puts "ret"

1331 when "cieq"

             handleX86IntCompareSet("sete", :int)

1333 when "cbeq"

             handleX86IntCompareSet("sete", :byte)

1335 when "cpeq"

             handleX86IntCompareSet("sete", :ptr)

1337 when "cqeq"

             handleX86IntCompareSet("sete", :quad)

1339 when "cineq"

             handleX86IntCompareSet("setne", :int)

1341 when "cbneq"

             handleX86IntCompareSet("setne", :byte)

1343 when "cpneq"

             handleX86IntCompareSet("setne", :ptr)

1345 when "cqneq"

             handleX86IntCompareSet("setne", :quad)

1347 when "cia"

             handleX86IntCompareSet("seta", :int)

1349 when "cba"

             handleX86IntCompareSet("seta", :byte)

1351 when "cpa"

             handleX86IntCompareSet("seta", :ptr)

1353 when "cqa"

             handleX86IntCompareSet("seta", :quad)

1355 when "ciaeq"

             handleX86IntCompareSet("setae", :int)

1357 when "cbaeq"

             handleX86IntCompareSet("setae", :byte)

1359 when "cpaeq"

             handleX86IntCompareSet("setae", :ptr)

1361 when "cqaeq"

             handleX86IntCompareSet("setae", :quad)

1363 when "cib"

             handleX86IntCompareSet("setb", :int)

1365 when "cbb"

             handleX86IntCompareSet("setb", :byte)

1367 when "cpb"

             handleX86IntCompareSet("setb", :ptr)

1369 when "cqb"

             handleX86IntCompareSet("setb", :quad)

1371 when "cibeq"

             handleX86IntCompareSet("setbe", :int)

1373 when "cbbeq"

             handleX86IntCompareSet("setbe", :byte)

1375 when "cpbeq"

             handleX86IntCompareSet("setbe", :ptr)

1377 when "cqbeq"

             handleX86IntCompareSet("setbe", :quad)

1379 when "cigt"

             handleX86IntCompareSet("setg", :int)

1381 when "cbgt"

             handleX86IntCompareSet("setg", :byte)

1383 when "cpgt"

             handleX86IntCompareSet("setg", :ptr)

1385 when "cqgt"

             handleX86IntCompareSet("setg", :quad)

1387 when "cigteq"

             handleX86IntCompareSet("setge", :int)

1389 when "cbgteq"

             handleX86IntCompareSet("setge", :byte)

1391 when "cpgteq"

             handleX86IntCompareSet("setge", :ptr)

1393 when "cqgteq"

             handleX86IntCompareSet("setge", :quad)

1395 when "cilt"

             handleX86IntCompareSet("setl", :int)

1397 when "cblt"

             handleX86IntCompareSet("setl", :byte)

1399 when "cplt"

             handleX86IntCompareSet("setl", :ptr)

1401 when "cqlt"

             handleX86IntCompareSet("setl", :quad)

1403 when "cilteq"

             handleX86IntCompareSet("setle", :int)

1405 when "cblteq"

             handleX86IntCompareSet("setle", :byte)

1407 when "cplteq"

             handleX86IntCompareSet("setle", :ptr)

1409 when "cqlteq"

             handleX86IntCompareSet("setle", :quad)

1411 when "tis"

             handleX86SetTest("sets", :int)

1413 when "tiz"

             handleX86SetTest("setz", :int)

1415 when "tinz"

             handleX86SetTest("setnz", :int)

1417 when "tps"

             handleX86SetTest("sets", :ptr)

1419 when "tpz"

             handleX86SetTest("setz", :ptr)

1421 when "tpnz"

             handleX86SetTest("setnz", :ptr)

1423 when "tqs"

             handleX86SetTest("sets", :quad)

1425 when "tqz"

             handleX86SetTest("setz", :quad)

1427 when "tqnz"

             handleX86SetTest("setnz", :quad)

1429 when "tbs"

             handleX86SetTest("sets", :byte)

1431 when "tbz"

             handleX86SetTest("setz", :byte)

1433 when "tbnz"

             handleX86SetTest("setnz", :byte)

1435 when "peek"

1436 handleX86Peek()

1437 when "poke"

1438 handleX86Poke()

1439 when "cdqi"

1440 $asm.puts "cdq"

1441 when "idivi"

             $asm.puts "idiv#{x86Suffix(:int)} #{operands[0].x86Operand(:int)}"

1443 when "fii2d"

1444 if useX87

                 sp = RegisterID.new(nil, "sp")

                 $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(operands[0].x86Operand(:int), offsetRegister(-8, sp.x86Operand(:ptr)))}"

                 $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(operands[1].x86Operand(:int), offsetRegister(-4, sp.x86Operand(:ptr)))}"

                 $asm.puts "fld#{x86Suffix(:ptr)} #{getSizeString(:double)}#{offsetRegister(-8, sp.x86Operand(:ptr))}"

                 $asm.puts "fstp #{operands[2].x87Operand(1)}"

1450 else

                 $asm.puts "movd #{operands[0].x86Operand(:int)}, #{operands[2].x86Operand(:double)}"

                 $asm.puts "movd #{operands[1].x86Operand(:int)}, %xmm7"

1453 $asm.puts "psllq $32, %xmm7"

                 $asm.puts "por %xmm7, #{operands[2].x86Operand(:double)}"

1455 end

1456 when "fd2ii"

1457 if useX87

                 sp = RegisterID.new(nil, "sp")

                 if (operands[0].x87DefaultStackPosition == 0)

                     $asm.puts "fst#{x86Suffix(:ptr)} #{getSizeString(:double)}#{offsetRegister(-8, sp.x86Operand(:ptr))}"

1461 else

                     $asm.puts "fld #{operands[0].x87Operand(0)}"

                     $asm.puts "fstpl -8(#{sp.x86Operand(:ptr)})"

1464 end

                 $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(offsetRegister(-8, sp.x86Operand(:ptr)), operands[1].x86Operand(:int))}"

                 $asm.puts "mov#{x86Suffix(:int)} #{orderOperands(offsetRegister(-4, sp.x86Operand(:ptr)), operands[2].x86Operand(:int))}"

1467 else

                 $asm.puts "movd #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:int)}"

                 $asm.puts "movsd #{operands[0].x86Operand(:double)}, %xmm7"

1470 $asm.puts "psrlq $32, %xmm7"

                 $asm.puts "movd %xmm7, #{operands[2].x86Operand(:int)}"

1472 end

1473 when "fq2d"

1474 if useX87

                 sp = RegisterID.new(nil, "sp")

                 $asm.puts "movq #{operands[0].x86Operand(:quad)}, -8(#{sp.x86Operand(:ptr)})"

                 $asm.puts "fldl -8(#{sp.x86Operand(:ptr)})"

                 $asm.puts "fstp #{operands[1].x87Operand(1)}"

1479 else

1480 if !isIntelSyntax

                     $asm.puts "movq #{operands[0].x86Operand(:quad)}, #{operands[1].x86Operand(:double)}"

1482 else

1483 # MASM does not accept register operands with movq.

1484 # Debugging shows that movd actually moves a qword when using MASM.

                     $asm.puts "movd #{operands[1].x86Operand(:double)}, #{operands[0].x86Operand(:quad)}"

1486 end

1487 end

1488 when "fd2q"

1489 if useX87

                 sp = RegisterID.new(nil, "sp")

                 if (operands[0].x87DefaultStackPosition == 0)

                     $asm.puts "fst#{x86Suffix(:int)} #{getSizeString(:int)}#{offsetRegister(-8, sp.x86Operand(:ptr))}"

1493 else

                     $asm.puts "fld #{operands[0].x87Operand(0)}"

                     $asm.puts "fstpl -8(#{sp.x86Operand(:ptr)})"

1496 end

                 $asm.puts "movq -8(#{sp.x86Operand(:ptr)}), #{operands[1].x86Operand(:quad)}"

1498 else

1499 if !isIntelSyntax

                     $asm.puts "movq #{operands[0].x86Operand(:double)}, #{operands[1].x86Operand(:quad)}"

1501 else

1502 # MASM does not accept register operands with movq.

1503 # Debugging shows that movd actually moves a qword when using MASM.

                     $asm.puts "movd #{operands[1].x86Operand(:quad)}, #{operands[0].x86Operand(:double)}"

1505 end

1506 end

1507 when "bo"

             $asm.puts "jo #{operands[0].asmLabel}"

1509 when "bs"

             $asm.puts "js #{operands[0].asmLabel}"

1511 when "bz"

             $asm.puts "jz #{operands[0].asmLabel}"

1513 when "bnz"

             $asm.puts "jnz #{operands[0].asmLabel}"

1515 when "leai"

             $asm.puts "lea#{x86Suffix(:int)} #{orderOperands(operands[0].x86AddressOperand(:int), operands[1].x86Operand(:int))}"

1517 when "leap"

             $asm.puts "lea#{x86Suffix(:ptr)} #{orderOperands(operands[0].x86AddressOperand(:ptr), operands[1].x86Operand(:ptr))}"

1519 when "memfence"

1520 $asm.puts "mfence"

1521 else

1522 lowerDefault

1523 end

1524 end

1525 end

1526