LCOV - code coverage report
Current view: top level - src/compiler - common-operator.h (source / functions) Hit Total Coverage
Test: app.info Lines: 12 13 92.3 %
Date: 2017-04-26 Functions: 3 3 100.0 %

          Line data    Source code
       1             : // Copyright 2014 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             : #ifndef V8_COMPILER_COMMON_OPERATOR_H_
       6             : #define V8_COMPILER_COMMON_OPERATOR_H_
       7             : 
       8             : #include "src/assembler.h"
       9             : #include "src/base/compiler-specific.h"
      10             : #include "src/compiler/frame-states.h"
      11             : #include "src/deoptimize-reason.h"
      12             : #include "src/globals.h"
      13             : #include "src/machine-type.h"
      14             : #include "src/zone/zone-containers.h"
      15             : 
      16             : namespace v8 {
      17             : namespace internal {
      18             : namespace compiler {
      19             : 
      20             : // Forward declarations.
      21             : class CallDescriptor;
      22             : struct CommonOperatorGlobalCache;
      23             : class Operator;
      24             : class Type;
      25             : class Node;
      26             : 
      27             : // Prediction hint for branches.
      28             : enum class BranchHint : uint8_t { kNone, kTrue, kFalse };
      29             : 
      30       13228 : inline BranchHint NegateBranchHint(BranchHint hint) {
      31       13228 :   switch (hint) {
      32             :     case BranchHint::kNone:
      33       13224 :       return hint;
      34             :     case BranchHint::kTrue:
      35             :       return BranchHint::kFalse;
      36             :     case BranchHint::kFalse:
      37           2 :       return BranchHint::kTrue;
      38             :   }
      39           0 :   UNREACHABLE();
      40             :   return hint;
      41             : }
      42             : 
      43       31398 : inline size_t hash_value(BranchHint hint) { return static_cast<size_t>(hint); }
      44             : 
      45             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, BranchHint);
      46             : 
      47             : V8_EXPORT_PRIVATE BranchHint BranchHintOf(const Operator* const);
      48             : 
      49             : // Helper function for return nodes, because returns have a hidden value input.
      50             : int ValueInputCountOfReturn(Operator const* const op);
      51             : 
      52             : // Parameters for the {Deoptimize} operator.
      53             : class DeoptimizeParameters final {
      54             :  public:
      55             :   DeoptimizeParameters(DeoptimizeKind kind, DeoptimizeReason reason)
      56             :       : kind_(kind), reason_(reason) {}
      57             : 
      58             :   DeoptimizeKind kind() const { return kind_; }
      59             :   DeoptimizeReason reason() const { return reason_; }
      60             : 
      61             :  private:
      62             :   DeoptimizeKind const kind_;
      63             :   DeoptimizeReason const reason_;
      64             : };
      65             : 
      66             : bool operator==(DeoptimizeParameters, DeoptimizeParameters);
      67             : bool operator!=(DeoptimizeParameters, DeoptimizeParameters);
      68             : 
      69             : size_t hast_value(DeoptimizeParameters p);
      70             : 
      71             : std::ostream& operator<<(std::ostream&, DeoptimizeParameters p);
      72             : 
      73             : DeoptimizeParameters const& DeoptimizeParametersOf(Operator const* const);
      74             : 
      75             : 
      76             : class SelectParameters final {
      77             :  public:
      78             :   explicit SelectParameters(MachineRepresentation representation,
      79             :                             BranchHint hint = BranchHint::kNone)
      80             :       : representation_(representation), hint_(hint) {}
      81             : 
      82             :   MachineRepresentation representation() const { return representation_; }
      83             :   BranchHint hint() const { return hint_; }
      84             : 
      85             :  private:
      86             :   const MachineRepresentation representation_;
      87             :   const BranchHint hint_;
      88             : };
      89             : 
      90             : bool operator==(SelectParameters const&, SelectParameters const&);
      91             : bool operator!=(SelectParameters const&, SelectParameters const&);
      92             : 
      93             : size_t hash_value(SelectParameters const& p);
      94             : 
      95             : std::ostream& operator<<(std::ostream&, SelectParameters const& p);
      96             : 
      97             : V8_EXPORT_PRIVATE SelectParameters const& SelectParametersOf(
      98             :     const Operator* const);
      99             : 
     100             : V8_EXPORT_PRIVATE CallDescriptor const* CallDescriptorOf(const Operator* const);
     101             : 
     102             : V8_EXPORT_PRIVATE size_t ProjectionIndexOf(const Operator* const);
     103             : 
     104             : V8_EXPORT_PRIVATE MachineRepresentation
     105             : PhiRepresentationOf(const Operator* const);
     106             : 
     107             : // The {IrOpcode::kParameter} opcode represents an incoming parameter to the
     108             : // function. This class bundles the index and a debug name for such operators.
     109             : class ParameterInfo final {
     110             :  public:
     111             :   ParameterInfo(int index, const char* debug_name)
     112             :       : index_(index), debug_name_(debug_name) {}
     113             : 
     114             :   int index() const { return index_; }
     115             :   const char* debug_name() const { return debug_name_; }
     116             : 
     117             :  private:
     118             :   int index_;
     119             :   const char* debug_name_;
     120             : };
     121             : 
     122             : std::ostream& operator<<(std::ostream&, ParameterInfo const&);
     123             : 
     124             : V8_EXPORT_PRIVATE int ParameterIndexOf(const Operator* const);
     125             : const ParameterInfo& ParameterInfoOf(const Operator* const);
     126             : 
     127             : class RelocatablePtrConstantInfo final {
     128             :  public:
     129             :   enum Type { kInt32, kInt64 };
     130             : 
     131             :   RelocatablePtrConstantInfo(int32_t value, RelocInfo::Mode rmode)
     132       10398 :       : value_(value), rmode_(rmode), type_(kInt32) {}
     133             :   RelocatablePtrConstantInfo(int64_t value, RelocInfo::Mode rmode)
     134             :       : value_(value), rmode_(rmode), type_(kInt64) {}
     135             : 
     136             :   intptr_t value() const { return value_; }
     137             :   RelocInfo::Mode rmode() const { return rmode_; }
     138             :   Type type() const { return type_; }
     139             : 
     140             :  private:
     141             :   intptr_t value_;
     142             :   RelocInfo::Mode rmode_;
     143             :   Type type_;
     144             : };
     145             : 
     146             : bool operator==(RelocatablePtrConstantInfo const& lhs,
     147             :                 RelocatablePtrConstantInfo const& rhs);
     148             : bool operator!=(RelocatablePtrConstantInfo const& lhs,
     149             :                 RelocatablePtrConstantInfo const& rhs);
     150             : 
     151             : std::ostream& operator<<(std::ostream&, RelocatablePtrConstantInfo const&);
     152             : 
     153             : size_t hash_value(RelocatablePtrConstantInfo const& p);
     154             : 
     155             : // Used to define a sparse set of inputs. This can be used to efficiently encode
     156             : // nodes that can have a lot of inputs, but where many inputs can have the same
     157             : // value.
     158             : class SparseInputMask final {
     159             :  public:
     160             :   typedef uint32_t BitMaskType;
     161             : 
     162             :   // The mask representing a dense input set.
     163             :   static const BitMaskType kDenseBitMask = 0x0;
     164             :   // The bits representing the end of a sparse input set.
     165             :   static const BitMaskType kEndMarker = 0x1;
     166             :   // The mask for accessing a sparse input entry in the bitmask.
     167             :   static const BitMaskType kEntryMask = 0x1;
     168             : 
     169             :   // The number of bits in the mask, minus one for the end marker.
     170             :   static const int kMaxSparseInputs = (sizeof(BitMaskType) * kBitsPerByte - 1);
     171             : 
     172             :   // An iterator over a node's sparse inputs.
     173             :   class InputIterator final {
     174             :    public:
     175             :     InputIterator() {}
     176             :     InputIterator(BitMaskType bit_mask, Node* parent);
     177             : 
     178             :     Node* parent() const { return parent_; }
     179             :     int real_index() const { return real_index_; }
     180             : 
     181             :     // Advance the iterator to the next sparse input. Only valid if the iterator
     182             :     // has not reached the end.
     183             :     void Advance();
     184             : 
     185             :     // Get the current sparse input's real node value. Only valid if the
     186             :     // current sparse input is real.
     187             :     Node* GetReal() const;
     188             : 
     189             :     // Get the current sparse input, returning either a real input node if
     190             :     // the current sparse input is real, or the given {empty_value} if the
     191             :     // current sparse input is empty.
     192    39277598 :     Node* Get(Node* empty_value) const {
     193    39277598 :       return IsReal() ? GetReal() : empty_value;
     194             :     }
     195             : 
     196             :     // True if the current sparse input is a real input node.
     197             :     bool IsReal() const;
     198             : 
     199             :     // True if the current sparse input is an empty value.
     200   128041144 :     bool IsEmpty() const { return !IsReal(); }
     201             : 
     202             :     // True if the iterator has reached the end of the sparse inputs.
     203             :     bool IsEnd() const;
     204             : 
     205             :    private:
     206             :     BitMaskType bit_mask_;
     207             :     Node* parent_;
     208             :     int real_index_;
     209             :   };
     210             : 
     211    13998784 :   explicit SparseInputMask(BitMaskType bit_mask) : bit_mask_(bit_mask) {}
     212             : 
     213             :   // Provides a SparseInputMask representing a dense input set.
     214             :   static SparseInputMask Dense() { return SparseInputMask(kDenseBitMask); }
     215             : 
     216    32490986 :   BitMaskType mask() const { return bit_mask_; }
     217             : 
     218     5865373 :   bool IsDense() const { return bit_mask_ == SparseInputMask::kDenseBitMask; }
     219             : 
     220             :   // Counts how many real values are in the sparse array. Only valid for
     221             :   // non-dense masks.
     222             :   int CountReal() const;
     223             : 
     224             :   // Returns an iterator over the sparse inputs of {node}.
     225             :   InputIterator IterateOverInputs(Node* node);
     226             : 
     227             :  private:
     228             :   //
     229             :   // The sparse input mask has a bitmask specifying if the node's inputs are
     230             :   // represented sparsely. If the bitmask value is 0, then the inputs are dense;
     231             :   // otherwise, they should be interpreted as follows:
     232             :   //
     233             :   //   * The bitmask represents which values are real, with 1 for real values
     234             :   //     and 0 for empty values.
     235             :   //   * The inputs to the node are the real values, in the order of the 1s from
     236             :   //     least- to most-significant.
     237             :   //   * The top bit of the bitmask is a guard indicating the end of the values,
     238             :   //     whether real or empty (and is not representative of a real input
     239             :   //     itself). This is used so that we don't have to additionally store a
     240             :   //     value count.
     241             :   //
     242             :   // So, for N 1s in the bitmask, there are N - 1 inputs into the node.
     243             :   BitMaskType bit_mask_;
     244             : };
     245             : 
     246             : bool operator==(SparseInputMask const& lhs, SparseInputMask const& rhs);
     247             : bool operator!=(SparseInputMask const& lhs, SparseInputMask const& rhs);
     248             : 
     249             : class TypedStateValueInfo final {
     250             :  public:
     251             :   TypedStateValueInfo(ZoneVector<MachineType> const* machine_types,
     252             :                       SparseInputMask sparse_input_mask)
     253             :       : machine_types_(machine_types), sparse_input_mask_(sparse_input_mask) {}
     254             : 
     255             :   ZoneVector<MachineType> const* machine_types() const {
     256             :     return machine_types_;
     257             :   }
     258             :   SparseInputMask sparse_input_mask() const { return sparse_input_mask_; }
     259             : 
     260             :  private:
     261             :   ZoneVector<MachineType> const* machine_types_;
     262             :   SparseInputMask sparse_input_mask_;
     263             : };
     264             : 
     265             : bool operator==(TypedStateValueInfo const& lhs, TypedStateValueInfo const& rhs);
     266             : bool operator!=(TypedStateValueInfo const& lhs, TypedStateValueInfo const& rhs);
     267             : 
     268             : std::ostream& operator<<(std::ostream&, TypedStateValueInfo const&);
     269             : 
     270             : size_t hash_value(TypedStateValueInfo const& p);
     271             : 
     272             : // Used to mark a region (as identified by BeginRegion/FinishRegion) as either
     273             : // JavaScript-observable or not (i.e. allocations are not JavaScript observable
     274             : // themselves, but transitioning stores are).
     275             : enum class RegionObservability : uint8_t { kObservable, kNotObservable };
     276             : 
     277             : size_t hash_value(RegionObservability);
     278             : 
     279             : std::ostream& operator<<(std::ostream&, RegionObservability);
     280             : 
     281             : RegionObservability RegionObservabilityOf(Operator const*) WARN_UNUSED_RESULT;
     282             : 
     283             : std::ostream& operator<<(std::ostream& os,
     284             :                          const ZoneVector<MachineType>* types);
     285             : 
     286             : Type* TypeGuardTypeOf(Operator const*) WARN_UNUSED_RESULT;
     287             : 
     288             : int OsrValueIndexOf(Operator const*);
     289             : 
     290             : enum class OsrGuardType { kUninitialized, kSignedSmall, kAny };
     291             : size_t hash_value(OsrGuardType type);
     292             : std::ostream& operator<<(std::ostream&, OsrGuardType);
     293             : OsrGuardType OsrGuardTypeOf(Operator const*);
     294             : 
     295             : SparseInputMask SparseInputMaskOf(Operator const*);
     296             : 
     297             : ZoneVector<MachineType> const* MachineTypesOf(Operator const*)
     298             :     WARN_UNUSED_RESULT;
     299             : 
     300             : // The ArgumentsElementsState and ArgumentsLengthState can either describe an
     301             : // unmapped arguments backing store or the backing store of the rest parameters.
     302             : // IsRestOf(op) is true in the second case.
     303             : bool IsRestOf(Operator const*);
     304             : 
     305             : // Interface for building common operators that can be used at any level of IR,
     306             : // including JavaScript, mid-level, and low-level.
     307             : class V8_EXPORT_PRIVATE CommonOperatorBuilder final
     308             :     : public NON_EXPORTED_BASE(ZoneObject) {
     309             :  public:
     310             :   explicit CommonOperatorBuilder(Zone* zone);
     311             : 
     312             :   const Operator* Dead();
     313             :   const Operator* End(size_t control_input_count);
     314             :   const Operator* Branch(BranchHint = BranchHint::kNone);
     315             :   const Operator* IfTrue();
     316             :   const Operator* IfFalse();
     317             :   const Operator* IfSuccess();
     318             :   const Operator* IfException();
     319             :   const Operator* Switch(size_t control_output_count);
     320             :   const Operator* IfValue(int32_t value);
     321             :   const Operator* IfDefault();
     322             :   const Operator* Throw();
     323             :   const Operator* Deoptimize(DeoptimizeKind kind, DeoptimizeReason reason);
     324             :   const Operator* DeoptimizeIf(DeoptimizeKind kind, DeoptimizeReason reason);
     325             :   const Operator* DeoptimizeUnless(DeoptimizeKind kind,
     326             :                                    DeoptimizeReason reason);
     327             :   const Operator* TrapIf(int32_t trap_id);
     328             :   const Operator* TrapUnless(int32_t trap_id);
     329             :   const Operator* Return(int value_input_count = 1);
     330             :   const Operator* Terminate();
     331             : 
     332             :   const Operator* Start(int value_output_count);
     333             :   const Operator* Loop(int control_input_count);
     334             :   const Operator* Merge(int control_input_count);
     335             :   const Operator* Parameter(int index, const char* debug_name = nullptr);
     336             : 
     337             :   const Operator* OsrNormalEntry();
     338             :   const Operator* OsrLoopEntry();
     339             :   const Operator* OsrValue(int index);
     340             :   const Operator* OsrGuard(OsrGuardType type);
     341             : 
     342             :   const Operator* Int32Constant(int32_t);
     343             :   const Operator* Int64Constant(int64_t);
     344             :   const Operator* Float32Constant(volatile float);
     345             :   const Operator* Float64Constant(volatile double);
     346             :   const Operator* ExternalConstant(const ExternalReference&);
     347             :   const Operator* NumberConstant(volatile double);
     348             :   const Operator* PointerConstant(intptr_t);
     349             :   const Operator* HeapConstant(const Handle<HeapObject>&);
     350             : 
     351             :   const Operator* RelocatableInt32Constant(int32_t value,
     352             :                                            RelocInfo::Mode rmode);
     353             :   const Operator* RelocatableInt64Constant(int64_t value,
     354             :                                            RelocInfo::Mode rmode);
     355             : 
     356             :   const Operator* Select(MachineRepresentation, BranchHint = BranchHint::kNone);
     357             :   const Operator* Phi(MachineRepresentation representation,
     358             :                       int value_input_count);
     359             :   const Operator* EffectPhi(int effect_input_count);
     360             :   const Operator* InductionVariablePhi(int value_input_count);
     361             :   const Operator* LoopExit();
     362             :   const Operator* LoopExitValue();
     363             :   const Operator* LoopExitEffect();
     364             :   const Operator* Checkpoint();
     365             :   const Operator* BeginRegion(RegionObservability);
     366             :   const Operator* FinishRegion();
     367             :   const Operator* StateValues(int arguments, SparseInputMask bitmask);
     368             :   const Operator* TypedStateValues(const ZoneVector<MachineType>* types,
     369             :                                    SparseInputMask bitmask);
     370             :   const Operator* ArgumentsElementsState(bool is_rest);
     371             :   const Operator* ArgumentsLengthState(bool is_rest);
     372             :   const Operator* ObjectState(int pointer_slots);
     373             :   const Operator* TypedObjectState(const ZoneVector<MachineType>* types);
     374             :   const Operator* FrameState(BailoutId bailout_id,
     375             :                              OutputFrameStateCombine state_combine,
     376             :                              const FrameStateFunctionInfo* function_info);
     377             :   const Operator* Call(const CallDescriptor* descriptor);
     378             :   const Operator* TailCall(const CallDescriptor* descriptor);
     379             :   const Operator* Projection(size_t index);
     380             :   const Operator* Retain();
     381             :   const Operator* TypeGuard(Type* type);
     382             : 
     383             :   // Constructs a new merge or phi operator with the same opcode as {op}, but
     384             :   // with {size} inputs.
     385             :   const Operator* ResizeMergeOrPhi(const Operator* op, int size);
     386             : 
     387             :   // Constructs function info for frame state construction.
     388             :   const FrameStateFunctionInfo* CreateFrameStateFunctionInfo(
     389             :       FrameStateType type, int parameter_count, int local_count,
     390             :       Handle<SharedFunctionInfo> shared_info);
     391             : 
     392             :  private:
     393             :   Zone* zone() const { return zone_; }
     394             : 
     395             :   const CommonOperatorGlobalCache& cache_;
     396             :   Zone* const zone_;
     397             : 
     398             :   DISALLOW_COPY_AND_ASSIGN(CommonOperatorBuilder);
     399             : };
     400             : 
     401             : }  // namespace compiler
     402             : }  // namespace internal
     403             : }  // namespace v8
     404             : 
     405             : #endif  // V8_COMPILER_COMMON_OPERATOR_H_

Generated by: LCOV version 1.10