CpuProfiler: replace raw position with SourcePosition for DeoptReason

src/assembler.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 447 matching lines @@
   uint32_t pc_delta = static_cast<uint32_t>(rinfo->pc() - last_pc_);
 
   // The two most common modes are given small tags, and usually fit in a byte.
   if (rmode == RelocInfo::EMBEDDED_OBJECT) {
     WriteTaggedPC(pc_delta, kEmbeddedObjectTag);
   } else if (rmode == RelocInfo::CODE_TARGET) {
     WriteTaggedPC(pc_delta, kCodeTargetTag);
     DCHECK(begin_pos - pos_ <= RelocInfo::kMaxCallSize);
   } else if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
     // Use signed delta-encoding for id.
-    DCHECK(static_cast<int>(rinfo->data()) == rinfo->data());
+    DCHECK_EQ(static_cast<int>(rinfo->data()), rinfo->data());
     int id_delta = static_cast<int>(rinfo->data()) - last_id_;
     // Check if delta is small enough to fit in a tagged byte.
     if (is_intn(id_delta, kSmallDataBits)) {
       WriteTaggedPC(pc_delta, kLocatableTag);
       WriteTaggedData(id_delta, kCodeWithIdTag);
     } else {
       // Otherwise, use costly encoding.
       WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
       WriteExtraTaggedIntData(id_delta, kCodeWithIdTag);
     }
     last_id_ = static_cast<int>(rinfo->data());
   } else if (rmode == RelocInfo::DEOPT_REASON) {
     DCHECK(rinfo->data() < (1 << kSmallDataBits));
     WriteTaggedPC(pc_delta, kLocatableTag);
     WriteTaggedData(rinfo->data(), kDeoptReasonTag);
   } else if (RelocInfo::IsPosition(rmode)) {
     // Use signed delta-encoding for position.
-    DCHECK(static_cast<int>(rinfo->data()) == rinfo->data());
+    DCHECK_EQ(static_cast<int>(rinfo->data()), rinfo->data());
     int pos_delta = static_cast<int>(rinfo->data()) - last_position_;
     if (rmode == RelocInfo::STATEMENT_POSITION) {
       WritePosition(pc_delta, pos_delta, rmode);
     } else {
-      DCHECK(rmode == RelocInfo::POSITION);
+      DCHECK_EQ(rmode, RelocInfo::POSITION);
       if (pc_delta != 0 || last_mode_ != RelocInfo::POSITION) {
         FlushPosition();
         next_position_candidate_pc_delta_ = pc_delta;
         next_position_candidate_pos_delta_ = pos_delta;
       } else {
         next_position_candidate_pos_delta_ += pos_delta;
       }
       next_position_candidate_flushed_ = false;
     }
     last_position_ = static_cast<int>(rinfo->data());
@@ skipping 1147 matching lines @@
   }
 
   // Return whether something was written.
   return written;
 }
 
 
 // Platform specific but identical code for all the platforms.
 
 
-void Assembler::RecordDeoptReason(const int reason, const int raw_position) {
+void Assembler::RecordDeoptReason(const int reason,
+                                  const SourcePosition position) {
   if (FLAG_trace_deopt || isolate()->cpu_profiler()->is_profiling()) {
     EnsureSpace ensure_space(this);
+    int raw_position = position.IsUnknown() ? 0 : position.raw();

[yurys, 2015/02/27 10:35:24]

Can we change SourcePosition so that raw() value of SourcePosition::Unknown() is
0 and avoid this code? Otherwise we rely on the fact that position.raw() cannot
return 0 which is non-obvious.

[loislo, 2015/02/27 12:04:28]

We use RelocInfo::kNoPosition in many other places, so it'd be non-trivial to
fix. I'd rather do this in another patch.

     RecordRelocInfo(RelocInfo::POSITION, raw_position);
     RecordRelocInfo(RelocInfo::DEOPT_REASON, reason);
   }
 }
 
 
 void Assembler::RecordComment(const char* msg) {
   if (FLAG_code_comments) {
     EnsureSpace ensure_space(this);
     RecordRelocInfo(RelocInfo::COMMENT, reinterpret_cast<intptr_t>(msg));
   }
 }
 
 
 void Assembler::RecordJSReturn() {
   positions_recorder()->WriteRecordedPositions();
   EnsureSpace ensure_space(this);
   RecordRelocInfo(RelocInfo::JS_RETURN);
 }
 
 
 void Assembler::RecordDebugBreakSlot() {
   positions_recorder()->WriteRecordedPositions();
   EnsureSpace ensure_space(this);
   RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT);
 }
 } }  // namespace v8::internal