Fix 64-bit VS2010 build

src/compiler/instruction.h

 // 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.
 
 #ifndef V8_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 427 matching lines @@
   static Instruction* New(Zone* zone, InstructionCode opcode,
                           size_t output_count, InstructionOperand** outputs,
                           size_t input_count, InstructionOperand** inputs,
                           size_t temp_count, InstructionOperand** temps) {
     ASSERT(opcode >= 0);
     ASSERT(output_count == 0 || outputs != NULL);
     ASSERT(input_count == 0 || inputs != NULL);
     ASSERT(temp_count == 0 || temps != NULL);
     InstructionOperand* none = NULL;
     USE(none);
-    size_t size = RoundUp(sizeof(Instruction), kPointerSize) +
-                  (output_count + input_count + temp_count - 1) * sizeof(none);
+    int size = static_cast<int>(RoundUp(sizeof(Instruction), kPointerSize) +
+                                (output_count + input_count + temp_count - 1) *
+                                    sizeof(none));
     return new (zone->New(size)) Instruction(
         opcode, output_count, outputs, input_count, inputs, temp_count, temps);
   }
 
   // TODO(titzer): another holdover from lithium days; register allocator
   // should not need to know about control instructions.
   Instruction* MarkAsControl() {
     bit_field_ = IsControlField::update(bit_field_, true);
     return this;
   }
@@ skipping 336 matching lines @@
     ConstantMap::const_iterator it = constants_.find(virtual_register);
     ASSERT(it != constants_.end());
     ASSERT_EQ(virtual_register, it->first);
     return it->second;
   }
 
   typedef ConstantDeque Immediates;
   const Immediates& immediates() const { return immediates_; }
 
   int AddImmediate(Constant constant) {
-    int index = immediates_.size();
+    int index = static_cast<int>(immediates_.size());
     immediates_.push_back(constant);
     return index;
   }
   Constant GetImmediate(int index) const {
     ASSERT(index >= 0);
     ASSERT(index < static_cast<int>(immediates_.size()));
     return immediates_[index];
   }
 
   int AddDeoptimizationEntry(const FrameStateDescriptor& descriptor);
@@ skipping 19 matching lines @@
   DeoptimizationVector deoptimization_entries_;
 };
 
 OStream& operator<<(OStream& os, const InstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_