[strong] Refactor ObjectStrength into a replacement for strong boolean args

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 <cstring>
 #include <iosfwd>
 
@@ skipping 3762 matching lines @@
 
   int32_t int32_value_;
   double double_value_;
   ExternalReference external_reference_value_;
 };
 
 
 class HBinaryOperation : public HTemplateInstruction<3> {
  public:
   HBinaryOperation(HValue* context, HValue* left, HValue* right,
-                   LanguageMode language_mode, HType type = HType::Tagged())
-      : HTemplateInstruction<3>(type), language_mode_(language_mode),
+                   Strength strength, HType type = HType::Tagged())
+      : HTemplateInstruction<3>(type),
+        strength_(strength),
         observed_output_representation_(Representation::None()) {
     DCHECK(left != NULL && right != NULL);
     SetOperandAt(0, context);
     SetOperandAt(1, left);
     SetOperandAt(2, right);
     observed_input_representation_[0] = Representation::None();
     observed_input_representation_[1] = Representation::None();
   }
 
   HValue* context() const { return OperandAt(0); }
   HValue* left() const { return OperandAt(1); }
   HValue* right() const { return OperandAt(2); }
-  LanguageMode language_mode() const { return language_mode_; }
+  Strength strength() const { return strength_; }
 
   // True if switching left and right operands likely generates better code.
   bool AreOperandsBetterSwitched() {
     if (!IsCommutative()) return false;
 
     // Constant operands are better off on the right, they can be inlined in
     // many situations on most platforms.
     if (left()->IsConstant()) return true;
     if (right()->IsConstant()) return false;
 
@@ skipping 55 matching lines @@
 
   bool RightIsPowerOf2() {
     if (!right()->IsInteger32Constant()) return false;
     int32_t value = right()->GetInteger32Constant();
     if (value < 0) {
       return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(-value));
     }
     return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(value));
   }
 
-  LanguageMode language_mode() {
-    return language_mode_;
-  }
+  Strength strength() { return strength_; }
 
   DECLARE_ABSTRACT_INSTRUCTION(BinaryOperation)
 
  private:
   bool IgnoreObservedOutputRepresentation(Representation current_rep);
-  LanguageMode language_mode_;
+  Strength strength_;
 
   Representation observed_input_representation_[2];
   Representation observed_output_representation_;
 };
 
 
 class HWrapReceiver final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*);
 
@@ skipping 249 matching lines @@
   std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   int RedefinedOperandIndex() override { return 0; }
   bool IsPurelyInformativeDefinition() override { return true; }
 };
 
 
 class HBitwiseBinaryOperation : public HBinaryOperation {
  public:
   HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right,
-                          LanguageMode language_mode,
-                          HType type = HType::TaggedNumber())
-      : HBinaryOperation(context, left, right, language_mode, type) {
+                          Strength strength, HType type = HType::TaggedNumber())
+      : HBinaryOperation(context, left, right, strength, type) {
     SetFlag(kFlexibleRepresentation);
     SetFlag(kTruncatingToInt32);
     SetFlag(kAllowUndefinedAsNaN);
     SetAllSideEffects();
   }
 
   void RepresentationChanged(Representation to) override {
     if (to.IsTagged() &&
         (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) {
       SetAllSideEffects();
@@ skipping 38 matching lines @@
                                               HValue*,
                                               HValue*);
 
   DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
  private:
   HMathFloorOfDiv(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right, SLOPPY) {
+      : HBinaryOperation(context, left, right, Strength::WEAK) {
     set_representation(Representation::Integer32());
     SetFlag(kUseGVN);
     SetFlag(kCanOverflow);
     SetFlag(kCanBeDivByZero);
     SetFlag(kLeftCanBeMinInt);
     SetFlag(kLeftCanBeNegative);
     SetFlag(kLeftCanBePositive);
     SetFlag(kAllowUndefinedAsNaN);
   }
 
   Range* InferRange(Zone* zone) override;
 
   bool IsDeletable() const override { return true; }
 };
 
 
 class HArithmeticBinaryOperation : public HBinaryOperation {
  public:
   HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right,
-                             LanguageMode language_mode)
-      : HBinaryOperation(context, left, right, language_mode,
+                             Strength strength)
+      : HBinaryOperation(context, left, right, strength,
                          HType::TaggedNumber()) {
     SetAllSideEffects();
     SetFlag(kFlexibleRepresentation);
     SetFlag(kAllowUndefinedAsNaN);
   }
 
   void RepresentationChanged(Representation to) override {
     if (to.IsTagged() &&
         (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) {
       SetAllSideEffects();
       ClearFlag(kUseGVN);
     } else {
       ClearAllSideEffects();
       SetFlag(kUseGVN);
     }
     if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion);
   }
 
   DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
 
  private:
   bool IsDeletable() const override { return true; }
 };
 
 
 class HCompareGeneric final : public HBinaryOperation {
  public:
   static HCompareGeneric* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right, Token::Value token,
-                           LanguageMode language_mode = SLOPPY) {
-    return new(zone) HCompareGeneric(context, left, right, token,
-                                     language_mode);
+                              HValue* left, HValue* right, Token::Value token,
+                              Strength strength = Strength::WEAK) {
+    return new (zone) HCompareGeneric(context, left, right, token, strength);
   }
 
   Representation RequiredInputRepresentation(int index) override {
     return index == 0
         ? Representation::Tagged()
         : representation();
   }
 
   Token::Value token() const { return token_; }
   std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
 
  private:
-  HCompareGeneric(HValue* context,
-                  HValue* left,
-                  HValue* right,
-                  Token::Value token,
-                  LanguageMode language_mode)
-      : HBinaryOperation(context, left, right, language_mode, HType::Boolean()),
+  HCompareGeneric(HValue* context, HValue* left, HValue* right,
+                  Token::Value token, Strength strength)
+      : HBinaryOperation(context, left, right, strength, HType::Boolean()),
         token_(token) {
     DCHECK(Token::IsCompareOp(token));
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
   Token::Value token_;
 };
 
 
@@ skipping 438 matching lines @@
   Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
 
  private:
   HInstanceOf(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right, SLOPPY, HType::Boolean()) {
+      : HBinaryOperation(context, left, right, Strength::WEAK,
+                         HType::Boolean()) {
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 };
 
 
 class HInstanceOfKnownGlobal final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOfKnownGlobal,
                                               HValue*,
@@ skipping 58 matching lines @@
   bool IsDeletable() const override {
     return !right()->representation().IsTagged();
   }
 };
 
 
 class HAdd final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   // Add is only commutative if two integer values are added and not if two
   // tagged values are added (because it might be a String concatenation).
   // We also do not commute (pointer + offset).
   bool IsCommutative() const override {
     return !representation().IsTagged() && !representation().IsExternal();
   }
 
   HValue* Canonicalize() override;
 
@@ skipping 30 matching lines @@
   Representation RequiredInputRepresentation(int index) override;
 
   DECLARE_CONCRETE_INSTRUCTION(Add)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HAdd(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HArithmeticBinaryOperation(context, left, right, language_mode) {
+  HAdd(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HArithmeticBinaryOperation(context, left, right, strength) {
     SetFlag(kCanOverflow);
   }
 };
 
 
 class HSub final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   HValue* Canonicalize() override;
 
   bool TryDecompose(DecompositionResult* decomposition) override {
     if (right()->IsInteger32Constant()) {
       decomposition->Apply(left(), -right()->GetInteger32Constant());
       return true;
     } else {
       return false;
     }
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Sub)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HSub(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HArithmeticBinaryOperation(context, left, right, language_mode) {
+  HSub(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HArithmeticBinaryOperation(context, left, right, strength) {
     SetFlag(kCanOverflow);
   }
 };
 
 
 class HMul final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   static HInstruction* NewImul(Isolate* isolate, Zone* zone, HValue* context,
                                HValue* left, HValue* right,
-                               LanguageMode language_mode = SLOPPY) {
-    HInstruction* instr = HMul::New(isolate, zone, context, left, right,
-                                    language_mode);
+                               Strength strength = Strength::WEAK) {
+    HInstruction* instr =
+        HMul::New(isolate, zone, context, left, right, strength);
     if (!instr->IsMul()) return instr;
     HMul* mul = HMul::cast(instr);
     // TODO(mstarzinger): Prevent bailout on minus zero for imul.
     mul->AssumeRepresentation(Representation::Integer32());
     mul->ClearFlag(HValue::kCanOverflow);
     return mul;
   }
 
   HValue* Canonicalize() override;
 
   // Only commutative if it is certain that not two objects are multiplicated.
   bool IsCommutative() const override { return !representation().IsTagged(); }
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   bool MulMinusOne();
 
   DECLARE_CONCRETE_INSTRUCTION(Mul)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HMul(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HArithmeticBinaryOperation(context, left, right, language_mode) {
+  HMul(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HArithmeticBinaryOperation(context, left, right, strength) {
     SetFlag(kCanOverflow);
   }
 };
 
 
 class HMod final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   HValue* Canonicalize() override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     if (new_rep.IsSmi()) new_rep = Representation::Integer32();
     HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Mod)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HMod(HValue* context,
-       HValue* left,
-       HValue* right,
-       LanguageMode language_mode) : HArithmeticBinaryOperation(context, left,
-                                                                right,
-                                                                language_mode) {
+  HMod(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HArithmeticBinaryOperation(context, left, right, strength) {
     SetFlag(kCanBeDivByZero);
     SetFlag(kCanOverflow);
     SetFlag(kLeftCanBeNegative);
   }
 };
 
 
 class HDiv final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   HValue* Canonicalize() override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     if (new_rep.IsSmi()) new_rep = Representation::Integer32();
     HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Div)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HDiv(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HArithmeticBinaryOperation(context, left, right, language_mode) {
+  HDiv(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HArithmeticBinaryOperation(context, left, right, strength) {
     SetFlag(kCanBeDivByZero);
     SetFlag(kCanOverflow);
   }
 };
 
 
 class HMathMinMax final : public HArithmeticBinaryOperation {
  public:
   enum Operation { kMathMin, kMathMax };
 
@@ skipping 25 matching lines @@
  protected:
   bool DataEquals(HValue* other) override {
     return other->IsMathMinMax() &&
         HMathMinMax::cast(other)->operation_ == operation_;
   }
 
   Range* InferRange(Zone* zone) override;
 
  private:
   HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
-      : HArithmeticBinaryOperation(context, left, right, SLOPPY),
-        operation_(op) { }
+      : HArithmeticBinaryOperation(context, left, right, Strength::WEAK),
+        operation_(op) {}
 
   Operation operation_;
 };
 
 
 class HBitwise final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            Token::Value op, HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   Token::Value op() const { return op_; }
 
   bool IsCommutative() const override { return true; }
 
   HValue* Canonicalize() override;
 
   std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(Bitwise)
 
  protected:
   bool DataEquals(HValue* other) override {
     return op() == HBitwise::cast(other)->op();
   }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HBitwise(HValue* context,
-           Token::Value op,
-           HValue* left,
-           HValue* right,
-           LanguageMode language_mode)
-      : HBitwiseBinaryOperation(context, left, right, language_mode),
-        op_(op) {
+  HBitwise(HValue* context, Token::Value op, HValue* left, HValue* right,
+           Strength strength)
+      : HBitwiseBinaryOperation(context, left, right, strength), op_(op) {
     DCHECK(op == Token::BIT_AND || op == Token::BIT_OR || op == Token::BIT_XOR);
     // BIT_AND with a smi-range positive value will always unset the
     // entire sign-extension of the smi-sign.
     if (op == Token::BIT_AND &&
         ((left->IsConstant() &&
           left->representation().IsSmi() &&
           HConstant::cast(left)->Integer32Value() >= 0) ||
          (right->IsConstant() &&
           right->representation().IsSmi() &&
           HConstant::cast(right)->Integer32Value() >= 0))) {
@@ skipping 14 matching lines @@
   }
 
   Token::Value op_;
 };
 
 
 class HShl final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   Range* InferRange(Zone* zone) override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     if (new_rep.IsSmi() &&
         !(right()->IsInteger32Constant() &&
           right()->GetInteger32Constant() >= 0)) {
       new_rep = Representation::Integer32();
     }
     HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Shl)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
  private:
-  HShl(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HBitwiseBinaryOperation(context, left, right, language_mode) { }
+  HShl(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HBitwiseBinaryOperation(context, left, right, strength) {}
 };
 
 
 class HShr final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   bool TryDecompose(DecompositionResult* decomposition) override {
     if (right()->IsInteger32Constant()) {
       if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
         // This is intended to look for HAdd and HSub, to handle compounds
         // like ((base + offset) >> scale) with one single decomposition.
         left()->TryDecompose(decomposition);
         return true;
       }
     }
     return false;
   }
 
   Range* InferRange(Zone* zone) override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     if (new_rep.IsSmi()) new_rep = Representation::Integer32();
     HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Shr)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
  private:
-  HShr(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HBitwiseBinaryOperation(context, left, right, language_mode) { }
+  HShr(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HBitwiseBinaryOperation(context, left, right, strength) {}
 };
 
 
 class HSar final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY);
+                           Strength strength = Strength::WEAK);
 
   bool TryDecompose(DecompositionResult* decomposition) override {
     if (right()->IsInteger32Constant()) {
       if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
         // This is intended to look for HAdd and HSub, to handle compounds
         // like ((base + offset) >> scale) with one single decomposition.
         left()->TryDecompose(decomposition);
         return true;
       }
     }
     return false;
   }
 
   Range* InferRange(Zone* zone) override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     if (new_rep.IsSmi()) new_rep = Representation::Integer32();
     HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Sar)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
  private:
-  HSar(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-      : HBitwiseBinaryOperation(context, left, right, language_mode) { }
+  HSar(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HBitwiseBinaryOperation(context, left, right, strength) {}
 };
 
 
 class HRor final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
-                           LanguageMode language_mode = SLOPPY) {
-    return new(zone) HRor(context, left, right, language_mode);
+                           Strength strength = Strength::WEAK) {
+    return new (zone) HRor(context, left, right, strength);
   }
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
                                     const char* reason) override {
     if (new_rep.IsSmi()) new_rep = Representation::Integer32();
     HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Ror)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
  private:
-  HRor(HValue* context, HValue* left, HValue* right, LanguageMode language_mode)
-       : HBitwiseBinaryOperation(context, left, right, language_mode) {
+  HRor(HValue* context, HValue* left, HValue* right, Strength strength)
+      : HBitwiseBinaryOperation(context, left, right, strength) {
     ChangeRepresentation(Representation::Integer32());
   }
 };
 
 
 class HOsrEntry final : public HTemplateInstruction<0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HOsrEntry, BailoutId);
 
   BailoutId ast_id() const { return ast_id_; }
@@ skipping 1954 matching lines @@
   Unique<Map> original_map_;
   Unique<Map> transitioned_map_;
   uint32_t bit_field_;
 };
 
 
 class HStringAdd final : public HBinaryOperation {
  public:
   static HInstruction* New(
       Isolate* isolate, Zone* zone, HValue* context, HValue* left,
-      HValue* right, LanguageMode language_mode = SLOPPY,
+      HValue* right, Strength strength = Strength::WEAK,
       PretenureFlag pretenure_flag = NOT_TENURED,
       StringAddFlags flags = STRING_ADD_CHECK_BOTH,
       Handle<AllocationSite> allocation_site = Handle<AllocationSite>::null());
 
   StringAddFlags flags() const { return flags_; }
   PretenureFlag pretenure_flag() const { return pretenure_flag_; }
 
   Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(StringAdd)
 
  protected:
   bool DataEquals(HValue* other) override {
     return flags_ == HStringAdd::cast(other)->flags_ &&
         pretenure_flag_ == HStringAdd::cast(other)->pretenure_flag_;
   }
 
  private:
-  HStringAdd(HValue* context,
-             HValue* left,
-             HValue* right,
-             LanguageMode language_mode,
-             PretenureFlag pretenure_flag,
-             StringAddFlags flags,
+  HStringAdd(HValue* context, HValue* left, HValue* right, Strength strength,
+             PretenureFlag pretenure_flag, StringAddFlags flags,
              Handle<AllocationSite> allocation_site)
-      : HBinaryOperation(context, left, right, language_mode, HType::String()),
-        flags_(flags), pretenure_flag_(pretenure_flag) {
+      : HBinaryOperation(context, left, right, strength, HType::String()),
+        flags_(flags),
+        pretenure_flag_(pretenure_flag) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetDependsOnFlag(kMaps);
     SetChangesFlag(kNewSpacePromotion);
     if (FLAG_trace_pretenuring) {
       PrintF("HStringAdd with AllocationSite %p %s\n",
              allocation_site.is_null()
                  ? static_cast<void*>(NULL)
                  : static_cast<void*>(*allocation_site),
              pretenure_flag == TENURED ? "tenured" : "not tenured");
@@ skipping 629 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_