Fix Windows build

src/ia32/codegen-ia32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 165 matching lines @@
 // Helper functions for CreateMemMoveFunction.
 #undef __
 #define __ ACCESS_MASM(masm)
 
 // Keep around global pointers to these objects so that Valgrind won't complain.
 static size_t* medium_handlers = NULL;
 static size_t* small_handlers = NULL;
 
 
 enum Direction { FORWARD, BACKWARD };
-enum Alignment { ALIGNED, UNALIGNED };
+enum Alignment { MOVE_ALIGNED, MOVE_UNALIGNED };
 
 // Expects registers:
 // esi - source, aligned if alignment == ALIGNED
 // edi - destination, always aligned
 // ecx - count (copy size in bytes)
 // edx - loop count (number of 64 byte chunks)
 void MemMoveEmitMainLoop(MacroAssembler* masm,
                          Label* move_last_15,
                          Direction direction,
                          Alignment alignment) {
   Register src = esi;
   Register dst = edi;
   Register count = ecx;
   Register loop_count = edx;
   Label loop, move_last_31, move_last_63;
   __ cmp(loop_count, 0);
   __ j(equal, &move_last_63);
   __ bind(&loop);
   // Main loop. Copy in 64 byte chunks.
   if (direction == BACKWARD) __ sub(src, Immediate(0x40));
-  __ movdq(alignment == ALIGNED, xmm0, Operand(src, 0x00));
-  __ movdq(alignment == ALIGNED, xmm1, Operand(src, 0x10));
-  __ movdq(alignment == ALIGNED, xmm2, Operand(src, 0x20));
-  __ movdq(alignment == ALIGNED, xmm3, Operand(src, 0x30));
+  __ movdq(alignment == MOVE_ALIGNED, xmm0, Operand(src, 0x00));
+  __ movdq(alignment == MOVE_ALIGNED, xmm1, Operand(src, 0x10));
+  __ movdq(alignment == MOVE_ALIGNED, xmm2, Operand(src, 0x20));
+  __ movdq(alignment == MOVE_ALIGNED, xmm3, Operand(src, 0x30));
   if (direction == FORWARD) __ add(src, Immediate(0x40));
   if (direction == BACKWARD) __ sub(dst, Immediate(0x40));
   __ movdqa(Operand(dst, 0x00), xmm0);
   __ movdqa(Operand(dst, 0x10), xmm1);
   __ movdqa(Operand(dst, 0x20), xmm2);
   __ movdqa(Operand(dst, 0x30), xmm3);
   if (direction == FORWARD) __ add(dst, Immediate(0x40));
   __ dec(loop_count);
   __ j(not_zero, &loop);
   // At most 63 bytes left to copy.
   __ bind(&move_last_63);
   __ test(count, Immediate(0x20));
   __ j(zero, &move_last_31);
   if (direction == BACKWARD) __ sub(src, Immediate(0x20));
-  __ movdq(alignment == ALIGNED, xmm0, Operand(src, 0x00));
-  __ movdq(alignment == ALIGNED, xmm1, Operand(src, 0x10));
+  __ movdq(alignment == MOVE_ALIGNED, xmm0, Operand(src, 0x00));
+  __ movdq(alignment == MOVE_ALIGNED, xmm1, Operand(src, 0x10));
   if (direction == FORWARD) __ add(src, Immediate(0x20));
   if (direction == BACKWARD) __ sub(dst, Immediate(0x20));
   __ movdqa(Operand(dst, 0x00), xmm0);
   __ movdqa(Operand(dst, 0x10), xmm1);
   if (direction == FORWARD) __ add(dst, Immediate(0x20));
   // At most 31 bytes left to copy.
   __ bind(&move_last_31);
   __ test(count, Immediate(0x10));
   __ j(zero, move_last_15);
   if (direction == BACKWARD) __ sub(src, Immediate(0x10));
-  __ movdq(alignment == ALIGNED, xmm0, Operand(src, 0));
+  __ movdq(alignment == MOVE_ALIGNED, xmm0, Operand(src, 0));
   if (direction == FORWARD) __ add(src, Immediate(0x10));
   if (direction == BACKWARD) __ sub(dst, Immediate(0x10));
   __ movdqa(Operand(dst, 0), xmm0);
   if (direction == FORWARD) __ add(dst, Immediate(0x10));
 }
 
 
 void MemMoveEmitPopAndReturn(MacroAssembler* masm) {
   __ pop(esi);
   __ pop(edi);
@@ skipping 84 matching lines @@
       __ add(dst, edx);
       __ add(src, edx);
       __ sub(count, edx);
       // dst is now aligned. Main copy loop.
       __ mov(loop_count, count);
       __ shr(loop_count, 6);
       // Check if src is also aligned.
       __ test(src, Immediate(0xF));
       __ j(not_zero, &unaligned_source);
       // Copy loop for aligned source and destination.
-      MemMoveEmitMainLoop(&masm, &move_last_15, FORWARD, ALIGNED);
+      MemMoveEmitMainLoop(&masm, &move_last_15, FORWARD, MOVE_ALIGNED);
       // At most 15 bytes to copy. Copy 16 bytes at end of string.
       __ bind(&move_last_15);
       __ and_(count, 0xF);
       __ j(zero, &skip_last_move, Label::kNear);
       __ movdqu(xmm0, Operand(src, count, times_1, -0x10));
       __ movdqu(Operand(dst, count, times_1, -0x10), xmm0);
       __ bind(&skip_last_move);
       MemMoveEmitPopAndReturn(&masm);
 
       // Copy loop for unaligned source and aligned destination.
       __ bind(&unaligned_source);
-      MemMoveEmitMainLoop(&masm, &move_last_15, FORWARD, UNALIGNED);
+      MemMoveEmitMainLoop(&masm, &move_last_15, FORWARD, MOVE_UNALIGNED);
       __ jmp(&move_last_15);
 
       // Less than kMinMoveDistance offset between dst and src.
       Label loop_until_aligned, last_15_much_overlap;
       __ bind(&loop_until_aligned);
       __ mov_b(eax, Operand(src, 0));
       __ inc(src);
       __ mov_b(Operand(dst, 0), eax);
       __ inc(dst);
       __ dec(count);
       __ bind(&forward_much_overlap);  // Entry point into this block.
       __ test(dst, Immediate(0xF));
       __ j(not_zero, &loop_until_aligned);
       // dst is now aligned, src can't be. Main copy loop.
       __ mov(loop_count, count);
       __ shr(loop_count, 6);
-      MemMoveEmitMainLoop(&masm, &last_15_much_overlap, FORWARD, UNALIGNED);
+      MemMoveEmitMainLoop(&masm, &last_15_much_overlap,
+                          FORWARD, MOVE_UNALIGNED);
       __ bind(&last_15_much_overlap);
       __ and_(count, 0xF);
       __ j(zero, &pop_and_return);
       __ cmp(count, kSmallCopySize);
       __ j(below_equal, &small_size);
       __ jmp(&medium_size);
     }
 
     {
       // |dst| is a higher address than |src|. Copy backwards.
@@ skipping 15 matching lines @@
       __ sub(dst, edx);
       __ sub(src, edx);
       __ sub(count, edx);
       // dst is now aligned. Main copy loop.
       __ mov(loop_count, count);
       __ shr(loop_count, 6);
       // Check if src is also aligned.
       __ test(src, Immediate(0xF));
       __ j(not_zero, &unaligned_source);
       // Copy loop for aligned source and destination.
-      MemMoveEmitMainLoop(&masm, &move_first_15, BACKWARD, ALIGNED);
+      MemMoveEmitMainLoop(&masm, &move_first_15, BACKWARD, MOVE_ALIGNED);
       // At most 15 bytes to copy. Copy 16 bytes at beginning of string.
       __ bind(&move_first_15);
       __ and_(count, 0xF);
       __ j(zero, &skip_last_move, Label::kNear);
       __ sub(src, count);
       __ sub(dst, count);
       __ movdqu(xmm0, Operand(src, 0));
       __ movdqu(Operand(dst, 0), xmm0);
       __ bind(&skip_last_move);
       MemMoveEmitPopAndReturn(&masm);
 
       // Copy loop for unaligned source and aligned destination.
       __ bind(&unaligned_source);
-      MemMoveEmitMainLoop(&masm, &move_first_15, BACKWARD, UNALIGNED);
+      MemMoveEmitMainLoop(&masm, &move_first_15, BACKWARD, MOVE_UNALIGNED);
       __ jmp(&move_first_15);
 
       // Less than kMinMoveDistance offset between dst and src.
       Label loop_until_aligned, first_15_much_overlap;
       __ bind(&loop_until_aligned);
       __ dec(src);
       __ dec(dst);
       __ mov_b(eax, Operand(src, 0));
       __ mov_b(Operand(dst, 0), eax);
       __ dec(count);
       __ bind(&backward_much_overlap);  // Entry point into this block.
       __ test(dst, Immediate(0xF));
       __ j(not_zero, &loop_until_aligned);
       // dst is now aligned, src can't be. Main copy loop.
       __ mov(loop_count, count);
       __ shr(loop_count, 6);
-      MemMoveEmitMainLoop(&masm, &first_15_much_overlap, BACKWARD, UNALIGNED);
+      MemMoveEmitMainLoop(&masm, &first_15_much_overlap,
+                          BACKWARD, MOVE_UNALIGNED);
       __ bind(&first_15_much_overlap);
       __ and_(count, 0xF);
       __ j(zero, &pop_and_return);
       // Small/medium handlers expect dst/src to point to the beginning.
       __ sub(dst, count);
       __ sub(src, count);
       __ cmp(count, kSmallCopySize);
       __ j(below_equal, &small_size);
       __ jmp(&medium_size);
     }
@@ skipping 763 matching lines @@
     Code* stub = GetCodeAgeStub(age, parity);
     CodePatcher patcher(sequence, young_length);
     patcher.masm()->call(stub->instruction_start(), RelocInfo::NONE32);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32