Version 3.28.71.3 (merged r23081)

src/hydrogen-instructions.h

 // 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.
 
 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
@@ skipping 533 matching lines @@
   // Declare virtual predicates for abstract HInstruction or HValue
   #define DECLARE_PREDICATE(type) \
     virtual bool Is##type() const { return false; }
     HYDROGEN_ABSTRACT_INSTRUCTION_LIST(DECLARE_PREDICATE)
   #undef DECLARE_PREDICATE
 
   bool IsBitwiseBinaryShift() {
     return IsShl() || IsShr() || IsSar();
   }
 
-  HValue(HType type = HType::Tagged())
+  explicit HValue(HType type = HType::Tagged())
       : block_(NULL),
         id_(kNoNumber),
         type_(type),
         use_list_(NULL),
         range_(NULL),
 #ifdef DEBUG
         range_poisoned_(false),
 #endif
         flags_(0) {}
   virtual ~HValue() {}
@@ skipping 633 matching lines @@
   virtual void Verify() V8_OVERRIDE;
 #endif
 
   bool CanDeoptimize();
 
   virtual bool HasStackCheck() { return false; }
 
   DECLARE_ABSTRACT_INSTRUCTION(Instruction)
 
  protected:
-  HInstruction(HType type = HType::Tagged())
+  explicit HInstruction(HType type = HType::Tagged())
       : HValue(type),
         next_(NULL),
         previous_(NULL),
         position_(RelocInfo::kNoPosition) {
     SetDependsOnFlag(kOsrEntries);
   }
 
   virtual void DeleteFromGraph() V8_OVERRIDE { Unlink(); }
 
  private:
@@ skipping 12 matching lines @@
 
 template<int V>
 class HTemplateInstruction : public HInstruction {
  public:
   virtual int OperandCount() const V8_FINAL V8_OVERRIDE { return V; }
   virtual HValue* OperandAt(int i) const V8_FINAL V8_OVERRIDE {
     return inputs_[i];
   }
 
  protected:
-  HTemplateInstruction(HType type = HType::Tagged()) : HInstruction(type) {}
+  explicit HTemplateInstruction(HType type = HType::Tagged())
+      : HInstruction(type) {}
 
   virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE {
     inputs_[i] = value;
   }
 
  private:
   EmbeddedContainer<HValue*, V> inputs_;
 };
 
 
@@ skipping 339 matching lines @@
   }
 
   DECLARE_CONCRETE_INSTRUCTION(AbnormalExit)
  private:
   HAbnormalExit() {}
 };
 
 
 class HUnaryOperation : public HTemplateInstruction<1> {
  public:
-  HUnaryOperation(HValue* value, HType type = HType::Tagged())
+  explicit HUnaryOperation(HValue* value, HType type = HType::Tagged())
       : HTemplateInstruction<1>(type) {
     SetOperandAt(0, value);
   }
 
   static HUnaryOperation* cast(HValue* value) {
     return reinterpret_cast<HUnaryOperation*>(value);
   }
 
   HValue* value() const { return OperandAt(0); }
   virtual OStream& PrintDataTo(OStream& os) const V8_OVERRIDE;  // NOLINT
@@ skipping 1097 matching lines @@
 
   DECLARE_CONCRETE_INSTRUCTION(LoadRoot)
 
  protected:
   virtual bool DataEquals(HValue* other) V8_OVERRIDE {
     HLoadRoot* b = HLoadRoot::cast(other);
     return index_ == b->index_;
   }
 
  private:
-  HLoadRoot(Heap::RootListIndex index, HType type = HType::Tagged())
+  explicit HLoadRoot(Heap::RootListIndex index, HType type = HType::Tagged())
       : HTemplateInstruction<0>(type), index_(index) {
     SetFlag(kUseGVN);
     // TODO(bmeurer): We'll need kDependsOnRoots once we add the
     // corresponding HStoreRoot instruction.
     SetDependsOnFlag(kCalls);
   }
 
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 
   const Heap::RootListIndex index_;
@@ skipping 969 matching lines @@
   virtual void Verify() V8_OVERRIDE { }
 #endif
 
   DECLARE_CONCRETE_INSTRUCTION(Constant)
 
  protected:
   virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
 
  private:
   friend class HGraph;
-  HConstant(Handle<Object> handle, Representation r = Representation::None());
+  explicit HConstant(Handle<Object> handle,
+                     Representation r = Representation::None());
   HConstant(int32_t value,
             Representation r = Representation::None(),
             bool is_not_in_new_space = true,
             Unique<Object> optional = Unique<Object>(Handle<Object>::null()));
   HConstant(double value,
             Representation r = Representation::None(),
             bool is_not_in_new_space = true,
             Unique<Object> optional = Unique<Object>(Handle<Object>::null()));
   HConstant(Unique<Object> object,
             Unique<Map> object_map,
@@ skipping 4137 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_