LCOV - code coverage report
Current view: top level - src/interpreter - bytecode-array-accessor.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 133 140 95.0 %
Date: 2019-01-20 Functions: 34 38 89.5 %

          Line data    Source code
       1             : // Copyright 2015 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/interpreter/bytecode-array-accessor.h"
       6             : 
       7             : #include "src/feedback-vector.h"
       8             : #include "src/interpreter/bytecode-decoder.h"
       9             : #include "src/interpreter/interpreter-intrinsics.h"
      10             : #include "src/objects-inl.h"
      11             : #include "src/objects/code-inl.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : namespace interpreter {
      16             : 
      17     4871380 : BytecodeArrayAccessor::BytecodeArrayAccessor(
      18             :     Handle<BytecodeArray> bytecode_array, int initial_offset)
      19             :     : bytecode_array_(bytecode_array),
      20             :       bytecode_offset_(initial_offset),
      21             :       operand_scale_(OperandScale::kSingle),
      22     4871380 :       prefix_offset_(0) {
      23     4871380 :   UpdateOperandScale();
      24     4871396 : }
      25             : 
      26    49876726 : void BytecodeArrayAccessor::SetOffset(int offset) {
      27    49876726 :   bytecode_offset_ = offset;
      28    49876726 :   UpdateOperandScale();
      29    49876767 : }
      30             : 
      31     3810327 : void BytecodeArrayAccessor::ApplyDebugBreak() {
      32             :   // Get the raw bytecode from the bytecode array. This may give us a
      33             :   // scaling prefix, which we can patch with the matching debug-break
      34             :   // variant.
      35             :   interpreter::Bytecode bytecode =
      36     3810327 :       interpreter::Bytecodes::FromByte(bytecode_array_->get(bytecode_offset_));
      37     7620654 :   if (interpreter::Bytecodes::IsDebugBreak(bytecode)) return;
      38             :   interpreter::Bytecode debugbreak =
      39     3779422 :       interpreter::Bytecodes::GetDebugBreak(bytecode);
      40             :   bytecode_array_->set(bytecode_offset_,
      41     3779422 :                        interpreter::Bytecodes::ToByte(debugbreak));
      42             : }
      43             : 
      44    54748100 : void BytecodeArrayAccessor::UpdateOperandScale() {
      45    54748100 :   if (OffsetInBounds()) {
      46    53680444 :     uint8_t current_byte = bytecode_array()->get(bytecode_offset_);
      47             :     Bytecode current_bytecode = Bytecodes::FromByte(current_byte);
      48    53680470 :     if (Bytecodes::IsPrefixScalingBytecode(current_bytecode)) {
      49             :       operand_scale_ =
      50     3934053 :           Bytecodes::PrefixBytecodeToOperandScale(current_bytecode);
      51     3934053 :       prefix_offset_ = 1;
      52             :     } else {
      53    49746417 :       operand_scale_ = OperandScale::kSingle;
      54    49746417 :       prefix_offset_ = 0;
      55             :     }
      56             :   }
      57    54748155 : }
      58             : 
      59    54748109 : bool BytecodeArrayAccessor::OffsetInBounds() const {
      60   109496240 :   return bytecode_offset_ >= 0 && bytecode_offset_ < bytecode_array()->length();
      61             : }
      62             : 
      63   278211496 : Bytecode BytecodeArrayAccessor::current_bytecode() const {
      64             :   DCHECK(OffsetInBounds());
      65             :   uint8_t current_byte =
      66   278211496 :       bytecode_array()->get(bytecode_offset_ + current_prefix_offset());
      67             :   Bytecode current_bytecode = Bytecodes::FromByte(current_byte);
      68             :   DCHECK(!Bytecodes::IsPrefixScalingBytecode(current_bytecode));
      69   139105895 :   return current_bytecode;
      70             : }
      71             : 
      72    31797964 : int BytecodeArrayAccessor::current_bytecode_size() const {
      73             :   return current_prefix_offset() +
      74    63595925 :          Bytecodes::Size(current_bytecode(), current_operand_scale());
      75             : }
      76             : 
      77    11099372 : uint32_t BytecodeArrayAccessor::GetUnsignedOperand(
      78    33298135 :     int operand_index, OperandType operand_type) const {
      79             :   DCHECK_GE(operand_index, 0);
      80             :   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
      81             :   DCHECK_EQ(operand_type,
      82             :             Bytecodes::GetOperandType(current_bytecode(), operand_index));
      83             :   DCHECK(Bytecodes::IsUnsignedOperandType(operand_type));
      84             :   Address operand_start =
      85    22198752 :       bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ +
      86    11099383 :       current_prefix_offset() +
      87             :       Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
      88    22198759 :                                   current_operand_scale());
      89             :   return BytecodeDecoder::DecodeUnsignedOperand(operand_start, operand_type,
      90    11099383 :                                                 current_operand_scale());
      91             : }
      92             : 
      93      886597 : int32_t BytecodeArrayAccessor::GetSignedOperand(
      94     2659804 :     int operand_index, OperandType operand_type) const {
      95             :   DCHECK_GE(operand_index, 0);
      96             :   DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
      97             :   DCHECK_EQ(operand_type,
      98             :             Bytecodes::GetOperandType(current_bytecode(), operand_index));
      99             :   DCHECK(!Bytecodes::IsUnsignedOperandType(operand_type));
     100             :   Address operand_start =
     101     1773206 :       bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ +
     102      886598 :       current_prefix_offset() +
     103             :       Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
     104     1773201 :                                   current_operand_scale());
     105             :   return BytecodeDecoder::DecodeSignedOperand(operand_start, operand_type,
     106      886598 :                                               current_operand_scale());
     107             : }
     108             : 
     109      516633 : uint32_t BytecodeArrayAccessor::GetFlagOperand(int operand_index) const {
     110             :   DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
     111             :             OperandType::kFlag8);
     112      516633 :   return GetUnsignedOperand(operand_index, OperandType::kFlag8);
     113             : }
     114             : 
     115      139529 : uint32_t BytecodeArrayAccessor::GetUnsignedImmediateOperand(
     116             :     int operand_index) const {
     117             :   DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
     118             :             OperandType::kUImm);
     119     1711281 :   return GetUnsignedOperand(operand_index, OperandType::kUImm);
     120             : }
     121             : 
     122      877811 : int32_t BytecodeArrayAccessor::GetImmediateOperand(int operand_index) const {
     123             :   DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
     124             :             OperandType::kImm);
     125      886597 :   return GetSignedOperand(operand_index, OperandType::kImm);
     126             : }
     127             : 
     128      939362 : uint32_t BytecodeArrayAccessor::GetRegisterCountOperand(
     129             :     int operand_index) const {
     130             :   DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
     131             :             OperandType::kRegCount);
     132      939366 :   return GetUnsignedOperand(operand_index, OperandType::kRegCount);
     133             : }
     134             : 
     135     7757111 : uint32_t BytecodeArrayAccessor::GetIndexOperand(int operand_index) const {
     136             :   OperandType operand_type =
     137     7757111 :       Bytecodes::GetOperandType(current_bytecode(), operand_index);
     138             :   DCHECK_EQ(operand_type, OperandType::kIdx);
     139     7757115 :   return GetUnsignedOperand(operand_index, operand_type);
     140             : }
     141             : 
     142     1665282 : FeedbackSlot BytecodeArrayAccessor::GetSlotOperand(int operand_index) const {
     143     1665282 :   int index = GetIndexOperand(operand_index);
     144     1665283 :   return FeedbackVector::ToSlot(index);
     145             : }
     146             : 
     147    77788845 : Register BytecodeArrayAccessor::GetRegisterOperand(int operand_index) const {
     148             :   OperandType operand_type =
     149    19447200 :       Bytecodes::GetOperandType(current_bytecode(), operand_index);
     150             :   Address operand_start =
     151    38894434 :       bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ +
     152    19447211 :       current_prefix_offset() +
     153             :       Bytecodes::GetOperandOffset(current_bytecode(), operand_index,
     154    38894428 :                                   current_operand_scale());
     155             :   return BytecodeDecoder::DecodeRegisterOperand(operand_start, operand_type,
     156    19447211 :                                                 current_operand_scale());
     157             : }
     158             : 
     159          40 : int BytecodeArrayAccessor::GetRegisterOperandRange(int operand_index) const {
     160             :   DCHECK_LE(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
     161             :   const OperandType* operand_types =
     162          40 :       Bytecodes::GetOperandTypes(current_bytecode());
     163          40 :   OperandType operand_type = operand_types[operand_index];
     164             :   DCHECK(Bytecodes::IsRegisterOperandType(operand_type));
     165          80 :   if (operand_type == OperandType::kRegList ||
     166          40 :       operand_type == OperandType::kRegOutList) {
     167           8 :     return GetRegisterCountOperand(operand_index + 1);
     168             :   } else {
     169          36 :     return Bytecodes::GetNumberOfRegistersRepresentedBy(operand_type);
     170             :   }
     171             : }
     172             : 
     173      157162 : Runtime::FunctionId BytecodeArrayAccessor::GetRuntimeIdOperand(
     174             :     int operand_index) const {
     175             :   OperandType operand_type =
     176      157162 :       Bytecodes::GetOperandType(current_bytecode(), operand_index);
     177             :   DCHECK_EQ(operand_type, OperandType::kRuntimeId);
     178      157162 :   uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type);
     179      157162 :   return static_cast<Runtime::FunctionId>(raw_id);
     180             : }
     181             : 
     182         185 : uint32_t BytecodeArrayAccessor::GetNativeContextIndexOperand(
     183             :     int operand_index) const {
     184             :   OperandType operand_type =
     185         185 :       Bytecodes::GetOperandType(current_bytecode(), operand_index);
     186             :   DCHECK_EQ(operand_type, OperandType::kNativeContextIndex);
     187         185 :   return GetUnsignedOperand(operand_index, operand_type);
     188             : }
     189             : 
     190       17627 : Runtime::FunctionId BytecodeArrayAccessor::GetIntrinsicIdOperand(
     191             :     int operand_index) const {
     192             :   OperandType operand_type =
     193       17627 :       Bytecodes::GetOperandType(current_bytecode(), operand_index);
     194             :   DCHECK_EQ(operand_type, OperandType::kIntrinsicId);
     195       17627 :   uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type);
     196             :   return IntrinsicsHelper::ToRuntimeId(
     197       17627 :       static_cast<IntrinsicsHelper::IntrinsicId>(raw_id));
     198             : }
     199             : 
     200     3122213 : Object BytecodeArrayAccessor::GetConstantAtIndex(int index) const {
     201     6244435 :   return bytecode_array()->constant_pool()->get(index);
     202             : }
     203             : 
     204     3082496 : Object BytecodeArrayAccessor::GetConstantForIndexOperand(
     205             :     int operand_index) const {
     206     3082496 :   return GetConstantAtIndex(GetIndexOperand(operand_index));
     207             : }
     208             : 
     209     1577146 : int BytecodeArrayAccessor::GetJumpTargetOffset() const {
     210     1577146 :   Bytecode bytecode = current_bytecode();
     211     1577147 :   if (interpreter::Bytecodes::IsJumpImmediate(bytecode)) {
     212     1558599 :     int relative_offset = GetUnsignedImmediateOperand(0);
     213     1558599 :     if (bytecode == Bytecode::kJumpLoop) {
     214      158497 :       relative_offset = -relative_offset;
     215             :     }
     216     1558599 :     return GetAbsoluteOffset(relative_offset);
     217       18549 :   } else if (interpreter::Bytecodes::IsJumpConstant(bytecode)) {
     218       18549 :     Smi smi = Smi::cast(GetConstantForIndexOperand(0));
     219             :     return GetAbsoluteOffset(smi->value());
     220             :   } else {
     221           0 :     UNREACHABLE();
     222             :   }
     223             : }
     224             : 
     225       13154 : JumpTableTargetOffsets BytecodeArrayAccessor::GetJumpTableTargetOffsets()
     226             :     const {
     227             :   uint32_t table_start, table_size;
     228             :   int32_t case_value_base;
     229       13154 :   if (current_bytecode() == Bytecode::kSwitchOnGeneratorState) {
     230        4368 :     table_start = GetIndexOperand(1);
     231             :     table_size = GetUnsignedImmediateOperand(2);
     232             :     case_value_base = 0;
     233             :   } else {
     234             :     DCHECK_EQ(current_bytecode(), Bytecode::kSwitchOnSmiNoFeedback);
     235        8786 :     table_start = GetIndexOperand(0);
     236             :     table_size = GetUnsignedImmediateOperand(1);
     237             :     case_value_base = GetImmediateOperand(2);
     238             :   }
     239       26308 :   return JumpTableTargetOffsets(this, table_start, table_size, case_value_base);
     240             : }
     241             : 
     242     3233134 : int BytecodeArrayAccessor::GetAbsoluteOffset(int relative_offset) const {
     243     3233134 :   return current_offset() + relative_offset + current_prefix_offset();
     244             : }
     245             : 
     246           0 : bool BytecodeArrayAccessor::OffsetWithinBytecode(int offset) const {
     247           0 :   return current_offset() <= offset &&
     248           0 :          offset < current_offset() + current_bytecode_size();
     249             : }
     250             : 
     251          62 : std::ostream& BytecodeArrayAccessor::PrintTo(std::ostream& os) const {
     252             :   const uint8_t* bytecode_addr = reinterpret_cast<const uint8_t*>(
     253          62 :       bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_);
     254             :   return BytecodeDecoder::Decode(os, bytecode_addr,
     255          62 :                                  bytecode_array()->parameter_count());
     256             : }
     257             : 
     258           0 : JumpTableTargetOffsets::JumpTableTargetOffsets(
     259             :     const BytecodeArrayAccessor* accessor, int table_start, int table_size,
     260             :     int case_value_base)
     261             :     : accessor_(accessor),
     262             :       table_start_(table_start),
     263             :       table_size_(table_size),
     264       13154 :       case_value_base_(case_value_base) {}
     265             : 
     266       13154 : JumpTableTargetOffsets::iterator JumpTableTargetOffsets::begin() const {
     267             :   return iterator(case_value_base_, table_start_, table_start_ + table_size_,
     268       30442 :                   accessor_);
     269             : }
     270       13154 : JumpTableTargetOffsets::iterator JumpTableTargetOffsets::end() const {
     271             :   return iterator(case_value_base_ + table_size_, table_start_ + table_size_,
     272       30442 :                   table_start_ + table_size_, accessor_);
     273             : }
     274        4134 : int JumpTableTargetOffsets::size() const {
     275             :   int ret = 0;
     276             :   // TODO(leszeks): Is there a more efficient way of doing this than iterating?
     277       21050 :   for (const auto& entry : *this) {
     278             :     USE(entry);
     279        8458 :     ret++;
     280             :   }
     281        4134 :   return ret;
     282             : }
     283             : 
     284           0 : JumpTableTargetOffsets::iterator::iterator(
     285             :     int case_value, int table_offset, int table_end,
     286             :     const BytecodeArrayAccessor* accessor)
     287             :     : accessor_(accessor),
     288             :       current_(Smi::zero()),
     289             :       index_(case_value),
     290             :       table_offset_(table_offset),
     291       34576 :       table_end_(table_end) {
     292       34576 :   UpdateAndAdvanceToValid();
     293           0 : }
     294             : 
     295       39419 : JumpTableTargetOffset JumpTableTargetOffsets::iterator::operator*() {
     296             :   DCHECK_LT(table_offset_, table_end_);
     297       78838 :   return {index_, accessor_->GetAbsoluteOffset(Smi::ToInt(current_))};
     298             : }
     299             : 
     300       30961 : JumpTableTargetOffsets::iterator& JumpTableTargetOffsets::iterator::
     301             : operator++() {
     302             :   DCHECK_LT(table_offset_, table_end_);
     303       39419 :   ++table_offset_;
     304       39419 :   ++index_;
     305       39419 :   UpdateAndAdvanceToValid();
     306       30961 :   return *this;
     307             : }
     308             : 
     309       44115 : bool JumpTableTargetOffsets::iterator::operator!=(
     310             :     const JumpTableTargetOffsets::iterator& other) {
     311             :   DCHECK_EQ(accessor_, other.accessor_);
     312             :   DCHECK_EQ(table_end_, other.table_end_);
     313             :   DCHECK_EQ(index_ - other.index_, table_offset_ - other.table_offset_);
     314       56707 :   return index_ != other.index_;
     315             : }
     316             : 
     317       73995 : void JumpTableTargetOffsets::iterator::UpdateAndAdvanceToValid() {
     318      108293 :   if (table_offset_ >= table_end_) return;
     319             : 
     320       39697 :   Object current = accessor_->GetConstantAtIndex(table_offset_);
     321       79412 :   while (!current->IsSmi()) {
     322             :     DCHECK(current->IsTheHole());
     323         296 :     ++table_offset_;
     324         296 :     ++index_;
     325         296 :     if (table_offset_ >= table_end_) break;
     326          18 :     current = accessor_->GetConstantAtIndex(table_offset_);
     327             :   }
     328             :   // Make sure we haven't reached the end of the table with a hole in current.
     329       39697 :   if (current->IsSmi()) {
     330       39419 :     current_ = Smi::cast(current);
     331             :   }
     332             : }
     333             : 
     334             : }  // namespace interpreter
     335             : }  // namespace internal
     336      183867 : }  // namespace v8

Generated by: LCOV version 1.10