Implement bigint absAdd, absSub, mulAdd, sqrAdd, estQuotientDigit intrinsics,

runtime/vm/intrinsifier_ia32.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
@@ skipping 636 matching lines @@
 
   __ Bind(&overflow);
   // Arguments are Smi but the shift produced an overflow to Mint.
   __ cmpl(EBX, Immediate(0));
   // TODO(srdjan): Implement negative values, for now fall through.
   __ j(LESS, &fall_through, Assembler::kNearJump);
   __ SmiUntag(EBX);
   __ movl(EAX, EBX);
   __ shll(EBX, ECX);
   __ xorl(EDI, EDI);
-  __ shld(EDI, EAX);
+  __ shldl(EDI, EAX);
   // Result in EDI (high) and EBX (low).
   const Class& mint_class = Class::Handle(
       Isolate::Current()->object_store()->mint_class());
   __ TryAllocate(mint_class,
                  &fall_through,
                  Assembler::kNearJump,
                  EAX,  // Result register.
                  kNoRegister);
   // EBX and EDI are not objects but integer values.
   __ movl(FieldAddress(EAX, Mint::value_offset()), EBX);
@@ skipping 421 matching lines @@
   __ Bind(&muladd_loop);
   // x:   EBX
   // mip: EDI
   // ajp: ESI
   // c:   ECX
   // t:   EDX:EAX (not live at loop entry)
   // n:   ESP[0]
 
   // uint32_t mi = *mip++
   __ movl(EAX, Address(EDI, 0));
-  __ addl(EDI, Immediate(kWordSize));
+  __ addl(EDI, Immediate(Bigint::kBytesPerDigit));
 
   // uint64_t t = x*mi
   __ mull(EBX);  // t = EDX:EAX = EAX * EBX
   __ addl(EAX, ECX);  // t += c
   __ adcl(EDX, Immediate(0));
 
   // uint32_t aj = *ajp; t += aj
   __ addl(EAX, Address(ESI, 0));
   __ adcl(EDX, Immediate(0));
 
   // *ajp++ = low32(t)
   __ movl(Address(ESI, 0), EAX);
-  __ addl(ESI, Immediate(kWordSize));
+  __ addl(ESI, Immediate(Bigint::kBytesPerDigit));
 
   // c = high32(t)
   __ movl(ECX, EDX);
 
   // while (--n > 0)
   __ decl(n_addr);  // --n
   __ j(NOT_ZERO, &muladd_loop, Assembler::kNearJump);
 
   Label done;
   __ testl(ECX, ECX);
-  __ j(ZERO, &done);
+  __ j(ZERO, &done, Assembler::kNearJump);
 
   // *ajp += c
   __ addl(Address(ESI, 0), ECX);
   __ j(NOT_CARRY, &done, Assembler::kNearJump);
 
   Label propagate_carry_loop;
   __ Bind(&propagate_carry_loop);
-  __ addl(ESI, Immediate(kWordSize));
+  __ addl(ESI, Immediate(Bigint::kBytesPerDigit));
   __ incl(Address(ESI, 0));  // c == 0 or 1
   __ j(CARRY, &propagate_carry_loop, Assembler::kNearJump);
 
   __ Bind(&done);
   __ Drop(1);  // n
   // Restore CTX and return.
   __ popl(CTX);
 
   __ Bind(&no_op);
   // Returning Object::null() is not required, since this method is private.
@@ skipping 29 matching lines @@
 
   // EDI = xip = &x_digits[i >> 1]
   __ movl(EDI, Address(ESP, 4 * kWordSize));  // x_digits
   __ movl(EAX, Address(ESP, 3 * kWordSize));  // i is Smi
   __ leal(EDI, FieldAddress(EDI, EAX, TIMES_2, TypedData::data_offset()));
 
   // EBX = x = *xip++, return if x == 0
   Label x_zero;
   __ movl(EBX, Address(EDI, 0));
   __ cmpl(EBX, Immediate(0));
-  __ j(EQUAL, &x_zero);
-  __ addl(EDI, Immediate(kWordSize));
+  __ j(EQUAL, &x_zero, Assembler::kNearJump);
+  __ addl(EDI, Immediate(Bigint::kBytesPerDigit));
 
   // Preserve CTX to free ESI.
   __ pushl(CTX);
   ASSERT(CTX == ESI);
 
   // ESI = ajp = &a_digits[i]
   __ movl(ESI, Address(ESP, 3 * kWordSize));  // a_digits
   __ leal(ESI, FieldAddress(ESI, EAX, TIMES_4, TypedData::data_offset()));
 
   // EDX:EAX = t = x*x + *ajp
   __ movl(EAX, EBX);
   __ mull(EBX);
   __ addl(EAX, Address(ESI, 0));
   __ adcl(EDX, Immediate(0));
 
   // *ajp++ = low32(t)
   __ movl(Address(ESI, 0), EAX);
-  __ addl(ESI, Immediate(kWordSize));
+  __ addl(ESI, Immediate(Bigint::kBytesPerDigit));
 
   // int n = used - i - 1
   __ movl(EAX, Address(ESP, 2 * kWordSize));  // used is Smi
   __ subl(EAX, Address(ESP, 4 * kWordSize));  // i is Smi
   __ SmiUntag(EAX);
   __ decl(EAX);
   __ pushl(EAX);  // Save n on stack.
 
   // uint64_t c = high32(t)
   __ pushl(Immediate(0));  // push high32(c) == 0
   __ pushl(EDX);  // push low32(c) == high32(t)
 
   Address n_addr = Address(ESP, 2 * kWordSize);
   Address ch_addr = Address(ESP, 1 * kWordSize);
   Address cl_addr = Address(ESP, 0 * kWordSize);
 
   Label loop, done;
   __ Bind(&loop);
   // x:   EBX
   // xip: EDI
   // ajp: ESI
   // c:   ESP[1]:ESP[0]
   // t:   ECX:EDX:EAX (not live at loop entry)
   // n:   ESP[2]
 
   // while (--n >= 0)
   __ decl(Address(ESP, 2 * kWordSize));  // --n
-  __ j(NEGATIVE, &done);
+  __ j(NEGATIVE, &done, Assembler::kNearJump);
 
   // uint32_t xi = *xip++
   __ movl(EAX, Address(EDI, 0));
-  __ addl(EDI, Immediate(kWordSize));
+  __ addl(EDI, Immediate(Bigint::kBytesPerDigit));
 
   // uint96_t t = ECX:EDX:EAX = 2*x*xi + aj + c
   __ mull(EBX);  // EDX:EAX = EAX * EBX
   __ xorl(ECX, ECX);  // ECX = 0
-  __ shld(ECX, EDX, Immediate(1));
-  __ shld(EDX, EAX, Immediate(1));
+  __ shldl(ECX, EDX, Immediate(1));
+  __ shldl(EDX, EAX, Immediate(1));
   __ shll(EAX, Immediate(1));  // ECX:EDX:EAX <<= 1
   __ addl(EAX, Address(ESI, 0));  // t += aj
   __ adcl(EDX, Immediate(0));
   __ adcl(ECX, Immediate(0));
   __ addl(EAX, cl_addr);  // t += low32(c)
   __ adcl(EDX, ch_addr);  // t += high32(c) << 32
   __ adcl(ECX, Immediate(0));
 
   // *ajp++ = low32(t)
   __ movl(Address(ESI, 0), EAX);
-  __ addl(ESI, Immediate(kWordSize));
+  __ addl(ESI, Immediate(Bigint::kBytesPerDigit));
 
   // c = high64(t)
   __ movl(cl_addr, EDX);
   __ movl(ch_addr, ECX);
 
   __ jmp(&loop, Assembler::kNearJump);
 
   __ Bind(&done);
   // uint64_t t = aj + c
   __ movl(EAX, cl_addr);  // t = c
   __ movl(EDX, ch_addr);
   __ addl(EAX, Address(ESI, 0));  // t += *ajp
   __ adcl(EDX, Immediate(0));
 
   // *ajp++ = low32(t)
   // *ajp = high32(t)
   __ movl(Address(ESI, 0), EAX);
-  __ movl(Address(ESI, kWordSize), EDX);
+  __ movl(Address(ESI, Bigint::kBytesPerDigit), EDX);
 
   // Restore CTX and return.
   __ Drop(3);
   __ popl(CTX);
   __ Bind(&x_zero);
   // Returning Object::null() is not required, since this method is private.
   __ ret();
 }
 
 
@@ skipping 29 matching lines @@
 
   // EAX = qd = DIGIT_MASK = -1
   __ movl(EAX, Immediate(-1));
 
   // Return qd if dh == yt
   Label return_qd;
   __ cmpl(EDX, ECX);
   __ j(EQUAL, &return_qd, Assembler::kNearJump);
 
   // EAX = dl = dp[-1]
-  __ movl(EAX, Address(EBX, -kWordSize));
+  __ movl(EAX, Address(EBX, -Bigint::kBytesPerDigit));
 
   // EAX = qd = dh:dl / yt = EDX:EAX / ECX
   __ divl(ECX);
 
   __ Bind(&return_qd);
   // args[1] = qd
-  __ movl(FieldAddress(EDI, TypedData::data_offset() + kWordSize), EAX);
+  __ movl(FieldAddress(EDI, TypedData::data_offset() + Bigint::kBytesPerDigit),
+          EAX);
 
   // Returning Object::null() is not required, since this method is private.
   __ ret();
 }
 
 
 void Intrinsifier::Montgomery_mulMod(Assembler* assembler) {
   // Pseudo code:
   // static void _mulMod(Uint32List args, Uint32List digits, int i) {
   //   uint32_t rho = args[_RHO];  // _RHO == 0.
@@ skipping 10 matching lines @@
 
   // EAX = digits[i >> 1]
   __ movl(EBX, Address(ESP, 2 * kWordSize));  // digits
   __ movl(EAX, Address(ESP, 1 * kWordSize));  // i is Smi
   __ movl(EAX, FieldAddress(EBX, EAX, TIMES_2, TypedData::data_offset()));
 
   // EDX:EAX = t = rho*d
   __ mull(ECX);
 
   // args[1] = t mod DIGIT_BASE = low32(t)
-  __ movl(FieldAddress(EDI, TypedData::data_offset() + kWordSize), EAX);
+  __ movl(FieldAddress(EDI, TypedData::data_offset() + Bigint::kBytesPerDigit),
+          EAX);
 
   // Returning Object::null() is not required, since this method is private.
   __ ret();
 }
 
 
 // Check if the last argument is a double, jump to label 'is_smi' if smi
 // (easy to convert to double), otherwise jump to label 'not_double_smi',
 // Returns the last argument in EAX.
 static void TestLastArgumentIsDouble(Assembler* assembler,
@@ skipping 721 matching lines @@
                         Isolate::current_tag_offset());
   // Set return value to Isolate::current_tag_.
   __ movl(EAX, current_tag_addr);
   __ ret();
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32