More memory leak fixes.

test/cctest/compiler/test-js-typed-lowering.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 242 matching lines @@
   } else {
     CHECK_EQ(NumberToI32(is_signed), new_input->opcode());
   }
 }
 
 
 // A helper class for testing lowering of bitwise shift operators.
 class JSBitwiseShiftTypedLoweringTester : public JSTypedLoweringTester {
  public:
   static const int kNumberOps = 6;
-  Operator** ops;
-  bool* signedness;
+  Operator* ops[kNumberOps];
+  bool signedness[kNumberOps];
 
   JSBitwiseShiftTypedLoweringTester() {
-    Operator* o[] = {javascript.ShiftLeft(),         machine.Word32Shl(),
-                     javascript.ShiftRight(),        machine.Word32Sar(),
-                     javascript.ShiftRightLogical(), machine.Word32Shr()};
+    int i = 0;
+    set(i++, javascript.ShiftLeft(), true);
+    set(i++, machine.Word32Shl(), false);
+    set(i++, javascript.ShiftRight(), true);
+    set(i++, machine.Word32Sar(), false);
+    set(i++, javascript.ShiftRightLogical(), false);
+    set(i++, machine.Word32Shr(), false);
+  }
 
-    ops = static_cast<Operator**>(malloc(sizeof(o)));
-    memcpy(ops, o, sizeof(o));
-
-    // Expected signedness of left and right conversions above.
-    bool s[] = {true, false, true, false, false, false};
-
-    signedness = static_cast<bool*>(malloc(sizeof(s)));
-    memcpy(signedness, s, sizeof(s));
+ private:
+  void set(int idx, Operator* op, bool s) {
+    ops[idx] = op;
+    signedness[idx] = s;
   }
 };
 
 
 TEST(Int32BitwiseShifts) {
   JSBitwiseShiftTypedLoweringTester R;
 
   Type* types[] = {
       Type::SignedSmall(), Type::UnsignedSmall(), Type::OtherSigned32(),
       Type::Unsigned32(),  Type::Signed32(),      Type::MinusZero(),
@@ skipping 23 matching lines @@
       }
     }
   }
 }
 
 
 // A helper class for testing lowering of bitwise operators.
 class JSBitwiseTypedLoweringTester : public JSTypedLoweringTester {
  public:
   static const int kNumberOps = 6;
-  Operator** ops;
-  bool* signedness;
+  Operator* ops[kNumberOps];
+  bool signedness[kNumberOps];
 
   JSBitwiseTypedLoweringTester() {
-    Operator* o[] = {javascript.BitwiseOr(),  machine.Word32Or(),
-                     javascript.BitwiseXor(), machine.Word32Xor(),
-                     javascript.BitwiseAnd(), machine.Word32And()};
+    int i = 0;
+    set(i++, javascript.BitwiseOr(), true);
+    set(i++, machine.Word32Or(), true);
+    set(i++, javascript.BitwiseXor(), true);
+    set(i++, machine.Word32Xor(), true);
+    set(i++, javascript.BitwiseAnd(), true);
+    set(i++, machine.Word32And(), true);
+  }
 
-    ops = static_cast<Operator**>(malloc(sizeof(o)));
-    memcpy(ops, o, sizeof(o));
-
-    // Expected signedness of left and right conversions above.
-    bool s[] = {true, true, true, true, true, true};
-
-    signedness = static_cast<bool*>(malloc(sizeof(s)));
-    memcpy(signedness, s, sizeof(s));
+ private:
+  void set(int idx, Operator* op, bool s) {
+    ops[idx] = op;
+    signedness[idx] = s;
   }
 };
 
 
 TEST(Int32BitwiseBinops) {
   JSBitwiseTypedLoweringTester R;
 
   Type* types[] = {
       Type::SignedSmall(), Type::UnsignedSmall(), Type::OtherSigned32(),
       Type::Unsigned32(),  Type::Signed32(),      Type::MinusZero(),
@@ skipping 988 matching lines @@
           CHECK_EQ(p1, r->InputAt(0));
           CHECK_EQ(p0, r->InputAt(1));
         } else {
           CHECK_EQ(p0, r->InputAt(0));
           CHECK_EQ(p1, r->InputAt(1));
         }
       }
     }
   }
 }