[turbofan] Introduce dedicated CallFrequency class.

src/compiler/js-operator.h

 // Copyright 2013 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.
 
 #ifndef V8_COMPILER_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
 #include "src/base/compiler-specific.h"
 #include "src/globals.h"
 #include "src/handles.h"
 #include "src/runtime/runtime.h"
 #include "src/type-hints.h"
 
 namespace v8 {
 namespace internal {
 
 class AllocationSite;
 class BoilerplateDescription;
 class ConstantElementsPair;
 class SharedFunctionInfo;
 class FeedbackVector;
 
 namespace compiler {
 
 // Forward declarations.
 class Operator;
 struct JSOperatorGlobalCache;
 
+// Defines the frequency a given Call/Construct site was executed. For some
+// call sites the frequency is not known.
+class CallFrequency final {
+ public:
+  CallFrequency() : value_(std::numeric_limits<float>::quiet_NaN()) {}
+  explicit CallFrequency(float value) : value_(value) {
+    DCHECK(!std::isnan(value));
+  }
+
+  bool IsKnown() const { return !IsUnknown(); }
+  bool IsUnknown() const { return std::isnan(value_); }
+  float value() const {
+    DCHECK(IsKnown());
+    return value_;
+  }
+
+  bool operator==(CallFrequency const& that) const {
+    return bit_cast<uint32_t>(this->value_) == bit_cast<uint32_t>(that.value_);
+  }
+  bool operator!=(CallFrequency const& that) const { return !(*this == that); }
+
+  friend size_t hash_value(CallFrequency f) {
+    return bit_cast<uint32_t>(f.value_);
+  }
+
+ private:
+  float value_;
+};
+
+std::ostream& operator<<(std::ostream&, CallFrequency);
+
 // Defines a pair of {FeedbackVector} and {FeedbackSlot}, which
 // is used to access the type feedback for a certain {Node}.
 class V8_EXPORT_PRIVATE VectorSlotPair {
  public:
   VectorSlotPair();
   VectorSlotPair(Handle<FeedbackVector> vector, FeedbackSlot slot)
       : vector_(vector), slot_(slot) {}
 
   bool IsValid() const { return !vector_.is_null() && !slot_.IsInvalid(); }
 
@@ skipping 18 matching lines @@
 
 
 // The ToBooleanHints are used as parameter by JSToBoolean operators.
 ToBooleanHints ToBooleanHintsOf(Operator const* op);
 
 
 // Defines the arity and the feedback for a JavaScript constructor call. This is
 // used as a parameter by JSConstruct operators.
 class ConstructParameters final {
  public:
-  ConstructParameters(uint32_t arity, float frequency,
+  ConstructParameters(uint32_t arity, CallFrequency frequency,
                       VectorSlotPair const& feedback)
       : arity_(arity), frequency_(frequency), feedback_(feedback) {}
 
   uint32_t arity() const { return arity_; }
-  float frequency() const { return frequency_; }
+  CallFrequency frequency() const { return frequency_; }
   VectorSlotPair const& feedback() const { return feedback_; }
 
  private:
   uint32_t const arity_;
-  float const frequency_;
+  CallFrequency const frequency_;
   VectorSlotPair const feedback_;
 };
 
 bool operator==(ConstructParameters const&, ConstructParameters const&);
 bool operator!=(ConstructParameters const&, ConstructParameters const&);
 
 size_t hash_value(ConstructParameters const&);
 
 std::ostream& operator<<(std::ostream&, ConstructParameters const&);
 
@@ skipping 57 matching lines @@
 
 std::ostream& operator<<(std::ostream&, CallForwardVarargsParameters const&);
 
 CallForwardVarargsParameters const& CallForwardVarargsParametersOf(
     Operator const*) WARN_UNUSED_RESULT;
 
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCall operators.
 class CallParameters final {
  public:
-  CallParameters(size_t arity, float frequency, VectorSlotPair const& feedback,
-                 TailCallMode tail_call_mode, ConvertReceiverMode convert_mode)
+  CallParameters(size_t arity, CallFrequency frequency,
+                 VectorSlotPair const& feedback, TailCallMode tail_call_mode,
+                 ConvertReceiverMode convert_mode)
       : bit_field_(ArityField::encode(arity) |
                    ConvertReceiverModeField::encode(convert_mode) |
                    TailCallModeField::encode(tail_call_mode)),
         frequency_(frequency),
         feedback_(feedback) {}
 
   size_t arity() const { return ArityField::decode(bit_field_); }
-  float frequency() const { return frequency_; }
+  CallFrequency frequency() const { return frequency_; }
   ConvertReceiverMode convert_mode() const {
     return ConvertReceiverModeField::decode(bit_field_);
   }
   TailCallMode tail_call_mode() const {
     return TailCallModeField::decode(bit_field_);
   }
   VectorSlotPair const& feedback() const { return feedback_; }
 
   bool operator==(CallParameters const& that) const {
     return this->bit_field_ == that.bit_field_ &&
            this->frequency_ == that.frequency_ &&
            this->feedback_ == that.feedback_;
   }
   bool operator!=(CallParameters const& that) const { return !(*this == that); }
 
  private:
   friend size_t hash_value(CallParameters const& p) {
     return base::hash_combine(p.bit_field_, p.frequency_, p.feedback_);
   }
 
   typedef BitField<size_t, 0, 29> ArityField;
   typedef BitField<ConvertReceiverMode, 29, 2> ConvertReceiverModeField;
   typedef BitField<TailCallMode, 31, 1> TailCallModeField;
 
   uint32_t const bit_field_;
-  float const frequency_;
+  CallFrequency const frequency_;
   VectorSlotPair const feedback_;
 };
 
 size_t hash_value(CallParameters const&);
 
 std::ostream& operator<<(std::ostream&, CallParameters const&);
 
 const CallParameters& CallParametersOf(const Operator* op);
 
 
@@ skipping 428 matching lines @@
                                      int number_of_elements);
   const Operator* CreateLiteralObject(Handle<BoilerplateDescription> constant,
                                       int literal_flags, int literal_index,
                                       int number_of_properties);
   const Operator* CreateLiteralRegExp(Handle<String> constant_pattern,
                                       int literal_flags, int literal_index);
 
   const Operator* CallForwardVarargs(uint32_t start_index,
                                      TailCallMode tail_call_mode);
   const Operator* Call(
-      size_t arity, float frequency = 0.0f,
+      size_t arity, CallFrequency frequency = CallFrequency(),
       VectorSlotPair const& feedback = VectorSlotPair(),
       ConvertReceiverMode convert_mode = ConvertReceiverMode::kAny,
       TailCallMode tail_call_mode = TailCallMode::kDisallow);
   const Operator* CallWithSpread(uint32_t arity);
   const Operator* CallRuntime(Runtime::FunctionId id);
   const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
   const Operator* CallRuntime(const Runtime::Function* function, size_t arity);
-  const Operator* Construct(uint32_t arity, float frequency,
-                            VectorSlotPair const& feedback);
+  const Operator* Construct(uint32_t arity,
+                            CallFrequency frequency = CallFrequency(),
+                            VectorSlotPair const& feedback = VectorSlotPair());
   const Operator* ConstructWithSpread(uint32_t arity);
 
   const Operator* ConvertReceiver(ConvertReceiverMode convert_mode);
 
   const Operator* LoadProperty(VectorSlotPair const& feedback);
   const Operator* LoadNamed(Handle<Name> name, VectorSlotPair const& feedback);
 
   const Operator* StoreProperty(LanguageMode language_mode,
                                 VectorSlotPair const& feedback);
   const Operator* StoreNamed(LanguageMode language_mode, Handle<Name> name,
@@ skipping 59 matching lines @@
   Zone* const zone_;
 
   DISALLOW_COPY_AND_ASSIGN(JSOperatorBuilder);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_