Fixed 2 space leaks in CreateMemmoveFunction, finally making valgrind happy.

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 159 matching lines @@
   CPU::FlushICache(buffer, actual_size);
   OS::ProtectCode(buffer, actual_size);
   return FUNCTION_CAST<UnaryMathFunction>(buffer);
 }
 
 
 // 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 { 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,
@@ skipping 51 matching lines @@
   __ pop(esi);
   __ pop(edi);
   __ ret(0);
 }
 
 
 #undef __
 #define __ masm.
 
 
+class LabelConverter {
+ public:
+  explicit LabelConverter(byte* buffer) : buffer_(buffer) {}
+  int32_t address(Label* l) const {
+    return reinterpret_cast<int32_t>(buffer_) + l->pos();
+  }
+ private:
+  byte* buffer_;
+};
+
+
 OS::MemMoveFunction CreateMemMoveFunction() {
   size_t actual_size;
   // Allocate buffer in executable space.
   byte* buffer = static_cast<byte*>(OS::Allocate(1 * KB, &actual_size, true));
   if (buffer == NULL) return NULL;
   MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
+  LabelConverter conv(buffer);
 
   // Generated code is put into a fixed, unmovable buffer, and not into
   // the V8 heap. We can't, and don't, refer to any relocatable addresses
   // (e.g. the JavaScript nan-object).
 
   // 32-bit C declaration function calls pass arguments on stack.
 
   // Stack layout:
   // esp[12]: Third argument, size.
   // esp[8]: Second argument, source pointer.
@@ skipping 173 matching lines @@
       __ sub(dst, count);
       __ sub(src, count);
       __ cmp(count, kSmallCopySize);
       __ j(below_equal, &small_size);
       __ jmp(&medium_size);
     }
     {
       // Special handlers for 9 <= copy_size < 64. No assumptions about
       // alignment or move distance, so all reads must be unaligned and
       // must happen before any writes.
-      Label f9_16, f17_32, f33_48, f49_63;
+      Label medium_handlers, f9_16, f17_32, f33_48, f49_63;
 
       __ bind(&f9_16);
       __ movdbl(xmm0, Operand(src, 0));
       __ movdbl(xmm1, Operand(src, count, times_1, -8));
       __ movdbl(Operand(dst, 0), xmm0);
       __ movdbl(Operand(dst, count, times_1, -8), xmm1);
       MemMoveEmitPopAndReturn(&masm);
 
       __ bind(&f17_32);
       __ movdqu(xmm0, Operand(src, 0));
@@ skipping 15 matching lines @@
       __ movdqu(xmm0, Operand(src, 0x00));
       __ movdqu(xmm1, Operand(src, 0x10));
       __ movdqu(xmm2, Operand(src, 0x20));
       __ movdqu(xmm3, Operand(src, count, times_1, -0x10));
       __ movdqu(Operand(dst, 0x00), xmm0);
       __ movdqu(Operand(dst, 0x10), xmm1);
       __ movdqu(Operand(dst, 0x20), xmm2);
       __ movdqu(Operand(dst, count, times_1, -0x10), xmm3);
       MemMoveEmitPopAndReturn(&masm);
 
-      medium_handlers = new size_t[4];
-      medium_handlers[0] = reinterpret_cast<intptr_t>(buffer) + f9_16.pos();
-      medium_handlers[1] = reinterpret_cast<intptr_t>(buffer) + f17_32.pos();
-      medium_handlers[2] = reinterpret_cast<intptr_t>(buffer) + f33_48.pos();
-      medium_handlers[3] = reinterpret_cast<intptr_t>(buffer) + f49_63.pos();
+      __ bind(&medium_handlers);
+      __ dd(conv.address(&f9_16));
+      __ dd(conv.address(&f17_32));
+      __ dd(conv.address(&f33_48));
+      __ dd(conv.address(&f49_63));
 
       __ bind(&medium_size);  // Entry point into this block.
       __ mov(eax, count);
       __ dec(eax);
       __ shr(eax, 4);
       if (FLAG_debug_code) {
         Label ok;
         __ cmp(eax, 3);
         __ j(below_equal, &ok);
         __ int3();
         __ bind(&ok);
       }
-      __ mov(eax, Operand(eax, times_4,
-                          reinterpret_cast<intptr_t>(medium_handlers)));
+      __ mov(eax, Operand(eax, times_4, conv.address(&medium_handlers)));
       __ jmp(eax);
     }
     {
       // Specialized copiers for copy_size <= 8 bytes.
-      Label f0, f1, f2, f3, f4, f5_8;
+      Label small_handlers, f0, f1, f2, f3, f4, f5_8;
       __ bind(&f0);
       MemMoveEmitPopAndReturn(&masm);
 
       __ bind(&f1);
       __ mov_b(eax, Operand(src, 0));
       __ mov_b(Operand(dst, 0), eax);
       MemMoveEmitPopAndReturn(&masm);
 
       __ bind(&f2);
       __ mov_w(eax, Operand(src, 0));
@@ skipping 12 matching lines @@
       __ mov(Operand(dst, 0), eax);
       MemMoveEmitPopAndReturn(&masm);
 
       __ bind(&f5_8);
       __ mov(eax, Operand(src, 0));
       __ mov(edx, Operand(src, count, times_1, -4));
       __ mov(Operand(dst, 0), eax);
       __ mov(Operand(dst, count, times_1, -4), edx);
       MemMoveEmitPopAndReturn(&masm);
 
-      small_handlers = new size_t[9];
-      small_handlers[0] = reinterpret_cast<intptr_t>(buffer) + f0.pos();
-      small_handlers[1] = reinterpret_cast<intptr_t>(buffer) + f1.pos();
-      small_handlers[2] = reinterpret_cast<intptr_t>(buffer) + f2.pos();
-      small_handlers[3] = reinterpret_cast<intptr_t>(buffer) + f3.pos();
-      small_handlers[4] = reinterpret_cast<intptr_t>(buffer) + f4.pos();
-      small_handlers[5] = reinterpret_cast<intptr_t>(buffer) + f5_8.pos();
-      small_handlers[6] = reinterpret_cast<intptr_t>(buffer) + f5_8.pos();
-      small_handlers[7] = reinterpret_cast<intptr_t>(buffer) + f5_8.pos();
-      small_handlers[8] = reinterpret_cast<intptr_t>(buffer) + f5_8.pos();
+      __ bind(&small_handlers);
+      __ dd(conv.address(&f0));
+      __ dd(conv.address(&f1));
+      __ dd(conv.address(&f2));
+      __ dd(conv.address(&f3));
+      __ dd(conv.address(&f4));
+      __ dd(conv.address(&f5_8));
+      __ dd(conv.address(&f5_8));
+      __ dd(conv.address(&f5_8));
+      __ dd(conv.address(&f5_8));
 
       __ bind(&small_size);  // Entry point into this block.
       if (FLAG_debug_code) {
         Label ok;
         __ cmp(count, 8);
         __ j(below_equal, &ok);
         __ int3();
         __ bind(&ok);
       }
-      __ mov(eax, Operand(count, times_4,
-                          reinterpret_cast<intptr_t>(small_handlers)));
+      __ mov(eax, Operand(count, times_4, conv.address(&small_handlers)));
       __ jmp(eax);
     }
   } else {
     // No SSE2.
     Label forward;
     __ cmp(count, 0);
     __ j(equal, &pop_and_return);
     __ cmp(dst, src);
     __ j(above, &backward);
     __ jmp(&forward);
@@ skipping 594 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