Fix crash when --ll_prof is enabled after cb29f9c

src/log.cc

 // Copyright 2011 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/log.h"
 
 #include <cstdarg>
 #include <sstream>
 
 #include "src/bailout-reason.h"
@@ skipping 280 matching lines @@
 #define LL_LOG(Call) if (ll_logger_) ll_logger_->Call;
 
 class LowLevelLogger : public CodeEventLogger {
  public:
   explicit LowLevelLogger(const char* file_name);
   ~LowLevelLogger() override;
 
   void CodeMoveEvent(AbstractCode* from, Address to) override;
   void CodeDisableOptEvent(AbstractCode* code,
                            SharedFunctionInfo* shared) override {}
-  void SnapshotPositionEvent(Address addr, int pos);
+  void SnapshotPositionEvent(HeapObject* obj, int pos);
   void CodeMovingGCEvent() override;
 
  private:
   void LogRecordedBuffer(AbstractCode* code, SharedFunctionInfo* shared,
                          const char* name, int length) override;
 
   // Low-level profiling event structures.
   struct CodeCreateStruct {
     static const char kTag = 'C';
 
@@ skipping 102 matching lines @@
 }
 
 void LowLevelLogger::CodeMoveEvent(AbstractCode* from, Address to) {
   CodeMoveStruct event;
   event.from_address = from->instruction_start();
   size_t header_size = from->instruction_start() - from->address();
   event.to_address = to + header_size;
   LogWriteStruct(event);
 }
 
-void LowLevelLogger::SnapshotPositionEvent(Address addr, int pos) {
-  HeapObject* obj = HeapObject::FromAddress(addr);
+void LowLevelLogger::SnapshotPositionEvent(HeapObject* obj, int pos) {
   if (obj->IsAbstractCode()) {
     SnapshotPositionStruct event;
     event.address =
-        addr + (obj->IsCode() ? Code::kHeaderSize : BytecodeArray::kHeaderSize);
+        obj->address() +
+        (obj->IsCode() ? Code::kHeaderSize : BytecodeArray::kHeaderSize);
     event.position = pos;
     LogWriteStruct(event);
   }
 }
 
 
 void LowLevelLogger::LogWriteBytes(const char* bytes, int size) {
   size_t rv = fwrite(bytes, 1, size, ll_output_handle_);
   DCHECK(static_cast<size_t>(size) == rv);
   USE(rv);
@@ skipping 847 matching lines @@
 
 
 void Logger::CodeNameEvent(Address addr, int pos, const char* code_name) {
   if (code_name == NULL) return;  // Not a code object.
   Log::MessageBuilder msg(log_);
   msg.Append("%s,%d,", kLogEventsNames[SNAPSHOT_CODE_NAME_EVENT], pos);
   msg.AppendDoubleQuotedString(code_name);
   msg.WriteToLogFile();
 }
 
-
-void Logger::SnapshotPositionEvent(Address addr, int pos) {
+void Logger::SnapshotPositionEvent(HeapObject* obj, int pos) {
   if (!log_->IsEnabled()) return;
-  LL_LOG(SnapshotPositionEvent(addr, pos));
+  LL_LOG(SnapshotPositionEvent(obj, pos));
   if (!FLAG_log_snapshot_positions) return;
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[SNAPSHOT_POSITION_EVENT]);
-  msg.AppendAddress(addr);
+  msg.AppendAddress(obj->address());
   msg.Append(",%d", pos);
   msg.WriteToLogFile();
 }
 
 
 void Logger::SharedFunctionInfoMoveEvent(Address from, Address to) {
   if (!is_logging_code_events()) return;
   MoveEventInternal(SHARED_FUNC_MOVE_EVENT, from, to);
 }
 
@@ skipping 521 matching lines @@
     removeCodeEventListener(jit_logger_);
     delete jit_logger_;
     jit_logger_ = NULL;
   }
 
   return log_->Close();
 }
 
 }  // namespace internal
 }  // namespace v8