Fix 64-bit VS2010 build

src/compiler/code-generator.cc

 // Copyright 2013 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/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/linkage.h"
 
 namespace v8 {
@@ skipping 156 matching lines @@
         static_cast<GapInstruction::InnerPosition>(i);
     ParallelMove* move = instr->GetParallelMove(inner_pos);
     if (move != NULL) resolver()->Resolve(move);
   }
 }
 
 
 void CodeGenerator::PopulateDeoptimizationData(Handle<Code> code_object) {
   CompilationInfo* info = linkage()->info();
   int deopt_count = code()->GetDeoptimizationEntryCount();
-  int patch_count = lazy_deoptimization_entries_.size();
+  int patch_count = static_cast<int>(lazy_deoptimization_entries_.size());
   if (patch_count == 0 && deopt_count == 0) return;
   Handle<DeoptimizationInputData> data = DeoptimizationInputData::New(
       isolate(), deopt_count, patch_count, TENURED);
 
   Handle<ByteArray> translation_array =
       translations_.CreateByteArray(isolate()->factory());
 
   data->SetTranslationByteArray(*translation_array);
   data->SetInlinedFunctionCount(Smi::FromInt(0));
   data->SetOptimizationId(Smi::FromInt(info->optimization_id()));
   // TODO(jarin) The following code was copied over from Lithium, not sure
   // whether the scope or the IsOptimizing condition are really needed.
   if (info->IsOptimizing()) {
     // Reference to shared function info does not change between phases.
     AllowDeferredHandleDereference allow_handle_dereference;
     data->SetSharedFunctionInfo(*info->shared_info());
   } else {
     data->SetSharedFunctionInfo(Smi::FromInt(0));
   }
 
   Handle<FixedArray> literals = isolate()->factory()->NewFixedArray(
-      deoptimization_literals_.size(), TENURED);
+      static_cast<int>(deoptimization_literals_.size()), TENURED);
   {
     AllowDeferredHandleDereference copy_handles;
     for (unsigned i = 0; i < deoptimization_literals_.size(); i++) {
       literals->set(i, *deoptimization_literals_[i]);
     }
     data->SetLiteralArray(*literals);
   }
 
   // No OSR in Turbofan yet...
   BailoutId osr_ast_id = BailoutId::None();
@@ skipping 23 matching lines @@
 }
 
 
 void CodeGenerator::RecordLazyDeoptimizationEntry(Instruction* instr) {
   InstructionOperandConverter i(this, instr);
 
   Label after_call;
   masm()->bind(&after_call);
 
   // The continuation and deoptimization are the last two inputs:
-  BasicBlock* cont_block = i.InputBlock(instr->InputCount() - 2);
-  BasicBlock* deopt_block = i.InputBlock(instr->InputCount() - 1);
+  BasicBlock* cont_block =
+      i.InputBlock(static_cast<int>(instr->InputCount()) - 2);
+  BasicBlock* deopt_block =
+      i.InputBlock(static_cast<int>(instr->InputCount()) - 1);
 
   Label* cont_label = code_->GetLabel(cont_block);
   Label* deopt_label = code_->GetLabel(deopt_block);
 
   lazy_deoptimization_entries_.push_back(
       LazyDeoptimizationEntry(after_call.pos(), cont_label, deopt_label));
 }
 
 
 int CodeGenerator::DefineDeoptimizationLiteral(Handle<Object> literal) {
-  int result = deoptimization_literals_.size();
+  int result = static_cast<int>(deoptimization_literals_.size());
   for (unsigned i = 0; i < deoptimization_literals_.size(); ++i) {
     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
   }
   deoptimization_literals_.push_back(literal);
   return result;
 }
 
 
 void CodeGenerator::BuildTranslation(Instruction* instr,
                                      int deoptimization_id) {
@@ skipping 13 matching lines @@
       DefineDeoptimizationLiteral(isolate()->factory()->undefined_value());
   translation.StoreLiteral(undefined_literal_id);
 
   deoptimization_states_[deoptimization_id] =
       new (zone()) DeoptimizationState(translation.index());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8