Store both major and minor key on code stubs.

src/debug.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 355 matching lines @@
 
 
 bool BreakLocationIterator::IsStepInLocation(Isolate* isolate) {
   if (RelocInfo::IsConstructCall(original_rmode())) {
     return true;
   } else if (RelocInfo::IsCodeTarget(rmode())) {
     HandleScope scope(debug_info_->GetIsolate());
     Address target = original_rinfo()->target_address();
     Handle<Code> target_code(Code::GetCodeFromTargetAddress(target));
     if (target_code->kind() == Code::STUB) {
-      return target_code->major_key() == CodeStub::CallFunction;
+      return CodeStub::GetMajorKey(*target_code) == CodeStub::CallFunction;
     }
     return target_code->is_call_stub();
   }
   return false;
 }
 
 
 void BreakLocationIterator::PrepareStepIn(Isolate* isolate) {
 #ifdef DEBUG
   HandleScope scope(isolate);
   // Step in can only be prepared if currently positioned on an IC call,
   // construct call or CallFunction stub call.
   Address target = rinfo()->target_address();
   Handle<Code> target_code(Code::GetCodeFromTargetAddress(target));
   // All the following stuff is needed only for assertion checks so the code
   // is wrapped in ifdef.
   Handle<Code> maybe_call_function_stub = target_code;
   if (IsDebugBreak()) {
     Address original_target = original_rinfo()->target_address();
     maybe_call_function_stub =
         Handle<Code>(Code::GetCodeFromTargetAddress(original_target));
   }
   bool is_call_function_stub =
       (maybe_call_function_stub->kind() == Code::STUB &&
-       maybe_call_function_stub->major_key() == CodeStub::CallFunction);
+       CodeStub::GetMajorKey(*maybe_call_function_stub) ==
+           CodeStub::CallFunction);
 
   // Step in through construct call requires no changes to the running code.
   // Step in through getters/setters should already be prepared as well
   // because caller of this function (Debug::PrepareStep) is expected to
   // flood the top frame's function with one shot breakpoints.
   // Step in through CallFunction stub should also be prepared by caller of
   // this function (Debug::PrepareStep) which should flood target function
   // with breakpoints.
   ASSERT(RelocInfo::IsConstructCall(rmode()) ||
          target_code->is_inline_cache_stub() ||
@@ skipping 56 matching lines @@
     }
   }
   if (RelocInfo::IsConstructCall(mode)) {
     if (code->has_function_cache()) {
       return isolate->builtins()->CallConstructStub_Recording_DebugBreak();
     } else {
       return isolate->builtins()->CallConstructStub_DebugBreak();
     }
   }
   if (code->kind() == Code::STUB) {
-    ASSERT(code->major_key() == CodeStub::CallFunction);
+    ASSERT(CodeStub::GetMajorKey(*code) == CodeStub::CallFunction);
     return isolate->builtins()->CallFunctionStub_DebugBreak();
   }
 
   UNREACHABLE();
   return Handle<Code>::null();
 }
 
 
 void BreakLocationIterator::SetDebugBreakAtIC() {
   // Patch the original code with the current address as the current address
@@ skipping 923 matching lines @@
       // Check if target code is CallFunction stub.
       Code* maybe_call_function_stub = code;
       // If there is a breakpoint at this line look at the original code to
       // check if it is a CallFunction stub.
       if (it.IsDebugBreak()) {
         Address original_target = it.original_rinfo()->target_address();
         maybe_call_function_stub =
             Code::GetCodeFromTargetAddress(original_target);
       }
       if ((maybe_call_function_stub->kind() == Code::STUB &&
-           maybe_call_function_stub->major_key() == CodeStub::CallFunction) ||
+           CodeStub::GetMajorKey(maybe_call_function_stub) ==
+               CodeStub::CallFunction) ||
           maybe_call_function_stub->kind() == Code::CALL_IC) {
         // Save reference to the code as we may need it to find out arguments
         // count for 'step in' later.
         call_function_stub = Handle<Code>(maybe_call_function_stub);
       }
     }
   } else {
     is_at_restarted_function = true;
   }
 
@@ skipping 59 matching lines @@
       // Get the STUB key and extract major and minor key.
       uint32_t key = Smi::cast(*obj)->value();
       // Argc in the stub is the number of arguments passed - not the
       // expected arguments of the called function.
       int call_function_arg_count = is_call_ic
           ? CallICStub::ExtractArgcFromMinorKey(CodeStub::MinorKeyFromKey(key))
           : CallFunctionStub::ExtractArgcFromMinorKey(
               CodeStub::MinorKeyFromKey(key));
 
       ASSERT(is_call_ic ||
-             call_function_stub->major_key() == CodeStub::MajorKeyFromKey(key));
+             CodeStub::GetMajorKey(*call_function_stub) ==
+                 CodeStub::MajorKeyFromKey(key));
 
       // Find target function on the expression stack.
       // Expression stack looks like this (top to bottom):
       // argN
       // ...
       // arg0
       // Receiver
       // Function to call
       int expressions_count = frame->ComputeExpressionsCount();
       ASSERT(expressions_count - 2 - call_function_arg_count >= 0);
@@ skipping 1884 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal