Fix tracing in escape-analysis.cc.

src/compiler/escape-analysis.cc

 // Copyright 2015 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/escape-analysis.h"
 
 #include <limits>
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
@@ skipping 150 matching lines @@
         owner_(owner) {
     fields_.resize(field_number);
     phi_.resize(field_number, false);
   }
 
   Node* GetField(size_t offset) { return fields_[offset]; }
 
   bool IsCreatedPhi(size_t offset) { return phi_[offset]; }
 
   void SetField(size_t offset, Node* node, bool created_phi = false) {
-    TRACE("    VirtualObject(%p)[%zu] changes from #%i to #%i\n", this, offset,
+    TRACE("    VirtualObject(%p)[%zu] changes from #%i to #%i\n",
+          static_cast<void*>(this), offset,
           fields_[offset] ? fields_[offset]->id() : -1, node ? node->id() : -1);
     fields_[offset] = node;
     phi_[offset] = created_phi;
   }
   bool IsTracked() const { return status_ & kTracked; }
   bool IsInitialized() const { return status_ & kInitialized; }
   bool SetInitialized() { return status_ |= kInitialized; }
   VirtualState* owner() const { return owner_; }
 
   Node** fields_array() { return &fields_.front(); }
@@ skipping 47 matching lines @@
   ZoneVector<bool> phi_;
   Node* object_state_;
   VirtualState* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(VirtualObject);
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(VirtualObject::StatusFlags)
 
 bool VirtualObject::UpdateFrom(const VirtualObject& other) {
-  TRACE("%p.UpdateFrom(%p)\n", this, &other);
+  TRACE("%p.UpdateFrom(%p)\n", static_cast<void*>(this),
+        static_cast<const void*>(&other));
   bool changed = status_ != other.status_;
   status_ = other.status_;
   phi_ = other.phi_;
   if (fields_.size() != other.fields_.size()) {
     fields_ = other.fields_;
     return true;
   }
   for (size_t i = 0; i < fields_.size(); ++i) {
     if (fields_[i] != other.fields_[i]) {
       changed = true;
@@ skipping 996 matching lines @@
       status_analysis_->IsDanglingEffectNode(node)) {
     PrintF("Dangeling effect node: #%d (%s)\n", node->id(),
            node->op()->mnemonic());
     UNREACHABLE();
   }
 #endif  // DEBUG
   Node* effect = NodeProperties::GetEffectInput(node);
   DCHECK_NOT_NULL(virtual_states_[effect->id()]);
   if (virtual_states_[node->id()]) {
     TRACE("Updating virtual state %p at %s#%d from virtual state %p at %s#%d\n",
-          virtual_states_[node->id()], node->op()->mnemonic(), node->id(),
-          virtual_states_[effect->id()], effect->op()->mnemonic(),
-          effect->id());
+          static_cast<void*>(virtual_states_[node->id()]),
+          node->op()->mnemonic(), node->id(),
+          static_cast<void*>(virtual_states_[effect->id()]),
+          effect->op()->mnemonic(), effect->id());
     virtual_states_[node->id()]->UpdateFrom(virtual_states_[effect->id()],
                                             zone());
   } else {
     virtual_states_[node->id()] = virtual_states_[effect->id()];
     TRACE("Forwarding object state %p from %s#%d to %s#%d",
           static_cast<void*>(virtual_states_[effect->id()]),
           effect->op()->mnemonic(), effect->id(), node->op()->mnemonic(),
           node->id());
     if (status_analysis_->IsEffectBranchPoint(effect)) {
       virtual_states_[node->id()]->SetCopyRequired();
@@ skipping 504 matching lines @@
     }
   }
   return false;
 }
 
 Graph* EscapeAnalysis::graph() const { return status_analysis_->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8