[strong] Fix inlining issue

src/hydrogen-instructions.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/base/bits.h"
 #include "src/double.h"
 #include "src/factory.h"
 #include "src/hydrogen-infer-representation.h"
@@ skipping 3961 matching lines @@
 }
 
 
 #define H_CONSTANT_INT(val) \
   HConstant::New(isolate, zone, context, static_cast<int32_t>(val))
 #define H_CONSTANT_DOUBLE(val) \
   HConstant::New(isolate, zone, context, static_cast<double>(val))
 
 #define DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HInstr, op)                     \
   HInstruction* HInstr::New(Isolate* isolate, Zone* zone, HValue* context,   \
-                            HValue* left, HValue* right) {                   \
+                            HValue* left, HValue* right,                     \
+                            LanguageMode language_mode) {                    \
     if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {  \
       HConstant* c_left = HConstant::cast(left);                             \
       HConstant* c_right = HConstant::cast(right);                           \
       if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {         \
         double double_res = c_left->DoubleValue() op c_right->DoubleValue(); \
         if (IsInt32Double(double_res)) {                                     \
           return H_CONSTANT_INT(double_res);                                 \
         }                                                                    \
         return H_CONSTANT_DOUBLE(double_res);                                \
       }                                                                      \
     }                                                                        \
-    return new (zone) HInstr(context, left, right);                          \
+    return new (zone) HInstr(context, left, right, language_mode);           \
   }
 
 
 DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HAdd, +)
 DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HMul, *)
 DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HSub, -)
 
 #undef DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR
 
 
 HInstruction* HStringAdd::New(Isolate* isolate, Zone* zone, HValue* context,
                               HValue* left, HValue* right,
+                              LanguageMode language_mode,
                               PretenureFlag pretenure_flag,
                               StringAddFlags flags,
                               Handle<AllocationSite> allocation_site) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_right = HConstant::cast(right);
     HConstant* c_left = HConstant::cast(left);
     if (c_left->HasStringValue() && c_right->HasStringValue()) {
       Handle<String> left_string = c_left->StringValue();
       Handle<String> right_string = c_right->StringValue();
       // Prevent possible exception by invalid string length.
       if (left_string->length() + right_string->length() < String::kMaxLength) {
         MaybeHandle<String> concat = isolate->factory()->NewConsString(
             c_left->StringValue(), c_right->StringValue());
         return HConstant::New(isolate, zone, context, concat.ToHandleChecked());
       }
     }
   }
   return new(zone) HStringAdd(
-      context, left, right, pretenure_flag, flags, allocation_site);
+      context, left, right, language_mode, pretenure_flag, flags,
+      allocation_site);
 }
 
 
 std::ostream& HStringAdd::PrintDataTo(std::ostream& os) const {  // NOLINT
   if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_BOTH) {
     os << "_CheckBoth";
   } else if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_LEFT) {
     os << "_CheckLeft";
   } else if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_RIGHT) {
     os << "_CheckRight";
@@ skipping 177 matching lines @@
       }
       // All comparisons failed, must be NaN.
       return H_CONSTANT_DOUBLE(std::numeric_limits<double>::quiet_NaN());
     }
   }
   return new(zone) HMathMinMax(context, left, right, op);
 }
 
 
 HInstruction* HMod::New(Isolate* isolate, Zone* zone, HValue* context,
-                        HValue* left, HValue* right) {
+                        HValue* left, HValue* right,
+                        LanguageMode language_mode) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
     HConstant* c_right = HConstant::cast(right);
     if (c_left->HasInteger32Value() && c_right->HasInteger32Value()) {
       int32_t dividend = c_left->Integer32Value();
       int32_t divisor = c_right->Integer32Value();
       if (dividend == kMinInt && divisor == -1) {
         return H_CONSTANT_DOUBLE(-0.0);
       }
       if (divisor != 0) {
         int32_t res = dividend % divisor;
         if ((res == 0) && (dividend < 0)) {
           return H_CONSTANT_DOUBLE(-0.0);
         }
         return H_CONSTANT_INT(res);
       }
     }
   }
-  return new(zone) HMod(context, left, right);
+  return new(zone) HMod(context, left, right, language_mode);
 }
 
 
 HInstruction* HDiv::New(Isolate* isolate, Zone* zone, HValue* context,
-                        HValue* left, HValue* right) {
+                        HValue* left, HValue* right,
+                        LanguageMode language_mode) {
   // If left and right are constant values, try to return a constant value.
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
     HConstant* c_right = HConstant::cast(right);
     if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
       if (c_right->DoubleValue() != 0) {
         double double_res = c_left->DoubleValue() / c_right->DoubleValue();
         if (IsInt32Double(double_res)) {
           return H_CONSTANT_INT(double_res);
         }
         return H_CONSTANT_DOUBLE(double_res);
       } else {
         int sign = Double(c_left->DoubleValue()).Sign() *
                    Double(c_right->DoubleValue()).Sign();  // Right could be -0.
         return H_CONSTANT_DOUBLE(sign * V8_INFINITY);
       }
     }
   }
-  return new(zone) HDiv(context, left, right);
+  return new(zone) HDiv(context, left, right, language_mode);
 }
 
 
 HInstruction* HBitwise::New(Isolate* isolate, Zone* zone, HValue* context,
-                            Token::Value op, HValue* left, HValue* right) {
+                            Token::Value op, HValue* left, HValue* right,
+                            LanguageMode language_mode) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
     HConstant* c_right = HConstant::cast(right);
     if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
       int32_t result;
       int32_t v_left = c_left->NumberValueAsInteger32();
       int32_t v_right = c_right->NumberValueAsInteger32();
       switch (op) {
         case Token::BIT_XOR:
           result = v_left ^ v_right;
           break;
         case Token::BIT_AND:
           result = v_left & v_right;
           break;
         case Token::BIT_OR:
           result = v_left | v_right;
           break;
         default:
           result = 0;  // Please the compiler.
           UNREACHABLE();
       }
       return H_CONSTANT_INT(result);
     }
   }
-  return new(zone) HBitwise(context, op, left, right);
+  return new(zone) HBitwise(context, op, left, right, language_mode);
 }
 
 
 #define DEFINE_NEW_H_BITWISE_INSTR(HInstr, result)                          \
   HInstruction* HInstr::New(Isolate* isolate, Zone* zone, HValue* context,  \
-                            HValue* left, HValue* right) {                  \
+                            HValue* left, HValue* right,                    \
+                            LanguageMode language_mode) {                   \
     if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) { \
       HConstant* c_left = HConstant::cast(left);                            \
       HConstant* c_right = HConstant::cast(right);                          \
       if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {        \
         return H_CONSTANT_INT(result);                                      \
       }                                                                     \
     }                                                                       \
-    return new (zone) HInstr(context, left, right);                         \
+    return new (zone) HInstr(context, left, right, language_mode);          \
   }
 
 
 DEFINE_NEW_H_BITWISE_INSTR(HSar,
 c_left->NumberValueAsInteger32() >> (c_right->NumberValueAsInteger32() & 0x1f))
 DEFINE_NEW_H_BITWISE_INSTR(HShl,
 c_left->NumberValueAsInteger32() << (c_right->NumberValueAsInteger32() & 0x1f))
 
 #undef DEFINE_NEW_H_BITWISE_INSTR
 
 
 HInstruction* HShr::New(Isolate* isolate, Zone* zone, HValue* context,
-                        HValue* left, HValue* right) {
+                        HValue* left, HValue* right,
+                        LanguageMode language_mode) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
     HConstant* c_right = HConstant::cast(right);
     if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
       int32_t left_val = c_left->NumberValueAsInteger32();
       int32_t right_val = c_right->NumberValueAsInteger32() & 0x1f;
       if ((right_val == 0) && (left_val < 0)) {
         return H_CONSTANT_DOUBLE(static_cast<uint32_t>(left_val));
       }
       return H_CONSTANT_INT(static_cast<uint32_t>(left_val) >> right_val);
     }
   }
-  return new(zone) HShr(context, left, right);
+  return new(zone) HShr(context, left, right, language_mode);
 }
 
 
 HInstruction* HSeqStringGetChar::New(Isolate* isolate, Zone* zone,
                                      HValue* context, String::Encoding encoding,
                                      HValue* string, HValue* index) {
   if (FLAG_fold_constants && string->IsConstant() && index->IsConstant()) {
     HConstant* c_string = HConstant::cast(string);
     HConstant* c_index = HConstant::cast(index);
     if (c_string->HasStringValue() && c_index->HasInteger32Value()) {
@@ skipping 364 matching lines @@
       break;
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 } }  // namespace v8::internal