Implement bigint mulAdd and sqrAdd intrinsics on ARM.

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 1018 matching lines @@
 
 
 // TODO(regis): Once this intrinsic is implemented on all architectures, the
 // corresponding Dart method will be untested. Add a test with --no-intrinsify.
 void Intrinsifier::Bigint_mulAdd(Assembler* assembler) {
   // Pseudo code:
   // static void _mulAdd(Uint32List x_digits, int xi,
   //                     Uint32List m_digits, int i,
   //                     Uint32List a_digits, int j, int n) {
   //   uint32_t x = x_digits[xi >> 1];  // xi is Smi.
-  //   if (x == 0  || n == 0) {
+  //   if (x == 0 || n == 0) {
   //     return;
   //   }
   //   uint32_t* mip = &m_digits[i >> 1];  // i is Smi.
   //   uint32_t* ajp = &a_digits[j >> 1];  // j is Smi.
   //   uint32_t c = 0;
   //   SmiUntag(n);
   //   do {
   //     uint32_t mi = *mip++;
   //     uint32_t aj = *ajp;
   //     uint64_t t = x*mi + aj + c;  // 32-bit * 32-bit -> 64-bit.
@@ skipping 121 matching lines @@
   //     *ajp++ = low32(t);
   //     c = high64(t);  // 33-bit.
   //   }
   //   uint32_t aj = *ajp;
   //   uint64_t t = aj + c;  // 32-bit + 33-bit -> 34-bit.
   //   *ajp++ = low32(t);
   //   *ajp = high32(t);
   // }
 
   // EDI = xip = &x_digits[i >> 1]
-  __ movl(EDI, Address(ESP, 4 * kWordSize));  // m_digits
+  __ 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));
 
   // 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));
 
-  // int n = used - i - 1;  // All Smi.
+  // 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)
 
@@ skipping 35 matching lines @@
   __ movl(Address(ESI, 0), EAX);
   __ addl(ESI, Immediate(kWordSize));
 
   // c = high64(t)
   __ movl(cl_addr, EDX);
   __ movl(ch_addr, ECX);
 
   __ jmp(&loop, Assembler::kNearJump);
 
   __ Bind(&done);
-  // uint32_t aj = *ajp;
-  __ movl(EAX, Address(ESI, 0));
-
-  // uint64_t t = aj + c;  // 32-bit + 33-bit -> 34-bit.
+  // uint64_t t = aj + c
   __ movl(EAX, cl_addr);  // t = c
   __ movl(EDX, ch_addr);
-  __ addl(EAX, Address(ESI, 0));  // t += aj
+  __ addl(EAX, Address(ESI, 0));  // t += *ajp
   __ adcl(EDX, Immediate(0));
 
-  // *ajp++ = low32(t);
+  // *ajp++ = low32(t)
+  // *ajp = high32(t)
   __ movl(Address(ESI, 0), EAX);
-  __ addl(ESI, Immediate(kWordSize));
-
-  // *ajp = high32(t);
-  __ movl(Address(ESI, 0), EDX);
+  __ movl(Address(ESI, kWordSize), EDX);
 
   // Restore CTX and return.
   __ Drop(3);
   __ popl(CTX);
   __ Bind(&x_zero);
   // TODO(regis): Confirm that returning Object::null() is not required.
   __ ret();
 }
 
 
@@ skipping 813 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