Fix 64-bit VS2010 build

src/compiler/instruction.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/compiler/instruction.h"
 
 #include "src/compiler/common-operator.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 300 matching lines @@
   return GetBlockStart(block)->label();
 }
 
 
 BlockStartInstruction* InstructionSequence::GetBlockStart(BasicBlock* block) {
   return BlockStartInstruction::cast(InstructionAt(block->code_start_));
 }
 
 
 void InstructionSequence::StartBlock(BasicBlock* block) {
-  block->code_start_ = instructions_.size();
+  block->code_start_ = static_cast<int>(instructions_.size());
   BlockStartInstruction* block_start =
       BlockStartInstruction::New(zone(), block);
   AddInstruction(block_start, block);
 }
 
 
 void InstructionSequence::EndBlock(BasicBlock* block) {
-  int end = instructions_.size();
+  int end = static_cast<int>(instructions_.size());
   ASSERT(block->code_start_ >= 0 && block->code_start_ < end);
   block->code_end_ = end;
 }
 
 
 int InstructionSequence::AddInstruction(Instruction* instr, BasicBlock* block) {
   // TODO(titzer): the order of these gaps is a holdover from Lithium.
   GapInstruction* gap = GapInstruction::New(zone());
   if (instr->IsControl()) instructions_.push_back(gap);
-  int index = instructions_.size();
+  int index = static_cast<int>(instructions_.size());
   instructions_.push_back(instr);
   if (!instr->IsControl()) instructions_.push_back(gap);
   if (instr->NeedsPointerMap()) {
     ASSERT(instr->pointer_map() == NULL);
     PointerMap* pointer_map = new (zone()) PointerMap(zone());
     pointer_map->set_instruction_position(index);
     instr->set_pointer_map(pointer_map);
     pointer_maps_.push_back(pointer_map);
   }
   return index;
@@ skipping 34 matching lines @@
 
 void InstructionSequence::AddGapMove(int index, InstructionOperand* from,
                                      InstructionOperand* to) {
   GapAt(index)->GetOrCreateParallelMove(GapInstruction::START, zone())->AddMove(
       from, to, zone());
 }
 
 
 int InstructionSequence::AddDeoptimizationEntry(
     const FrameStateDescriptor& descriptor) {
-  int deoptimization_id = deoptimization_entries_.size();
+  int deoptimization_id = static_cast<int>(deoptimization_entries_.size());
   deoptimization_entries_.push_back(descriptor);
   return deoptimization_id;
 }
 
 FrameStateDescriptor InstructionSequence::GetDeoptimizationEntry(
     int deoptimization_id) {
   return deoptimization_entries_[deoptimization_id];
 }
 
 
 int InstructionSequence::GetDeoptimizationEntryCount() {
-  return deoptimization_entries_.size();
+  return static_cast<int>(deoptimization_entries_.size());
 }
 
 
 OStream& operator<<(OStream& os, const InstructionSequence& code) {
   for (size_t i = 0; i < code.immediates_.size(); ++i) {
     Constant constant = code.immediates_[i];
     os << "IMM#" << i << ": " << constant << "\n";
   }
   int i = 0;
   for (ConstantMap::const_iterator it = code.constants_.begin();
@@ skipping 53 matching lines @@
       os << " B" << (*iter)->id();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8