Fix 64-bit VS2010 build

src/compiler/structured-machine-assembler.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/pipeline.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/structured-machine-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 164 matching lines @@
     }
     new_env->variables_.push_back(phi);
   }
   return new_env;
 }
 
 
 void StructuredMachineAssembler::MergeBackEdgesToLoopHeader(
     Environment* header, EnvironmentVector* environments) {
   // Only merge as many variables are were declared before this loop.
-  size_t n = header->variables_.size();
+  int n = static_cast<int>(header->variables_.size());
   // TODO(dcarney): invert loop order and extend phis once.
   for (EnvironmentVector::iterator i = environments->begin();
        i != environments->end(); ++i) {
     Environment* from = *i;
     if (from->is_dead_) continue;
     AddGoto(from, header);
-    for (size_t i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i) {
       Node* phi = header->variables_[i];
       if (phi == NULL) continue;
       phi->set_op(common()->Phi(phi->InputCount() + 1));
       phi->AppendInput(zone(), VariableAt(from, i));
     }
   }
 }
 
 
 void StructuredMachineAssembler::Merge(EnvironmentVector* environments,
@@ skipping 23 matching lines @@
     // Find first non equal variable.
     size_t i = 0;
     for (; i < n_envs; i++) {
       ASSERT(live_environments[i]->variables_.size() <= n_vars);
       Node* val = NULL;
       if (j < static_cast<size_t>(truncate_at)) {
         val = live_environments[i]->variables_.at(j);
         // TODO(dcarney): record start position at time of split.
         //                all variables after this should not be NULL.
         if (val != NULL) {
-          val = VariableAt(live_environments[i], j);
+          val = VariableAt(live_environments[i], static_cast<int>(j));
         }
       }
       if (val == resolved) continue;
       if (i != 0) break;
       resolved = val;
     }
     // Have to generate a phi.
     if (i < n_envs) {
       // All values thus far uninitialized, variable used out of scope.
       CHECK(resolved != NULL);
       // Init scratch buffer.
       if (scratch == NULL) {
         scratch = static_cast<Node**>(alloca(n_envs * sizeof(resolved)));
       }
       for (size_t k = 0; k < i; k++) {
         scratch[k] = resolved;
       }
       for (; i < n_envs; i++) {
         scratch[i] = live_environments[i]->variables_[j];
       }
-      resolved = graph()->NewNode(common()->Phi(n_envs), n_envs, scratch);
+      resolved = graph()->NewNode(common()->Phi(static_cast<int>(n_envs)),
+                                  static_cast<int>(n_envs), scratch);
       if (next->block_ != NULL) {
         schedule()->AddNode(next->block_, resolved);
       }
     }
     vars.push_back(resolved);
   }
 }
 
 
 void StructuredMachineAssembler::AddGoto(Environment* from, Environment* to) {
@@ skipping 369 matching lines @@
 
 
 void StructuredMachineAssembler::LoopBuilder::End() {
   ASSERT(!IsDone());
   if (smasm_->current_environment_ != NULL) {
     Continue();
   }
   // Do loop header merges.
   smasm_->MergeBackEdgesToLoopHeader(header_environment_,
                                      &pending_header_merges_);
-  int initial_size = header_environment_->variables_.size();
+  int initial_size = static_cast<int>(header_environment_->variables_.size());
   // Do loop exit merges, truncating loop variables away.
   smasm_->Merge(&pending_exit_merges_, initial_size);
   for (EnvironmentVector::iterator i = pending_exit_merges_.begin();
        i != pending_exit_merges_.end(); ++i) {
     smasm_->AddGoto(*i, smasm_->current_environment_);
   }
   pending_header_merges_.clear();
   pending_exit_merges_.clear();
   header_environment_ = NULL;
   ASSERT(IsDone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8