Replace unsafe uses of Add<> with AddUncasted<>.

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1283 matching lines @@
 
   HValue* current_capacity = AddLoadFixedArrayLength(elements);
 
   IfBuilder capacity_checker(this);
 
   capacity_checker.If<HCompareNumericAndBranch>(key, current_capacity,
                                                 Token::GTE);
   capacity_checker.Then();
 
   HValue* max_gap = Add<HConstant>(static_cast<int32_t>(JSObject::kMaxGap));
-  HValue* max_capacity = Add<HAdd>(current_capacity, max_gap);
+  HValue* max_capacity = AddUncasted<HAdd>(current_capacity, max_gap);
   IfBuilder key_checker(this);
   key_checker.If<HCompareNumericAndBranch>(key, max_capacity, Token::LT);
   key_checker.Then();
   key_checker.ElseDeopt("Key out of capacity range");
   key_checker.End();
 
   HValue* new_capacity = BuildNewElementsCapacity(key);
   HValue* new_elements = BuildGrowElementsCapacity(object, elements,
                                                    kind, kind, length,
                                                    new_capacity);
@@ skipping 96 matching lines @@
     HValue* hash,
     HValue* mask,
     int current_probe) {
   if (current_probe == kNumberDictionaryProbes) {
     return NULL;
   }
 
   int32_t offset = SeededNumberDictionary::GetProbeOffset(current_probe);
   HValue* raw_index = (current_probe == 0)
       ? hash
-      : Add<HAdd>(hash, Add<HConstant>(offset));
-  raw_index = Add<HBitwise>(Token::BIT_AND, raw_index, mask);
+      : AddUncasted<HAdd>(hash, Add<HConstant>(offset));
+  raw_index = AddUncasted<HBitwise>(Token::BIT_AND, raw_index, mask);
   int32_t entry_size = SeededNumberDictionary::kEntrySize;
-  raw_index = Add<HMul>(raw_index, Add<HConstant>(entry_size));
+  raw_index = AddUncasted<HMul>(raw_index, Add<HConstant>(entry_size));
   raw_index->ClearFlag(HValue::kCanOverflow);
 
   int32_t base_offset = SeededNumberDictionary::kElementsStartIndex;
-  HValue* key_index = Add<HAdd>(raw_index, Add<HConstant>(base_offset));
+  HValue* key_index = AddUncasted<HAdd>(raw_index, Add<HConstant>(base_offset));
   key_index->ClearFlag(HValue::kCanOverflow);
 
   HValue* candidate_key = Add<HLoadKeyed>(elements, key_index,
                                           static_cast<HValue*>(NULL),
                                           FAST_SMI_ELEMENTS);
 
   IfBuilder key_compare(this);
   key_compare.IfNot<HCompareObjectEqAndBranch>(key, candidate_key);
   key_compare.Then();
   {
     // Key at the current probe doesn't match, try at the next probe.
     HValue* result = BuildUncheckedDictionaryElementLoadHelper(
         elements, key, hash, mask, current_probe + 1);
     if (result == NULL) {
       key_compare.Deopt("probes exhausted in keyed load dictionary lookup");
       result = graph()->GetConstantUndefined();
     } else {
       Push(result);
     }
   }
   key_compare.Else();
   {
     // Key at current probe matches. Details must be zero, otherwise the
     // dictionary element requires special handling.
-    HValue* details_index = Add<HAdd>(raw_index,
-                                    Add<HConstant>(base_offset + 2));
+    HValue* details_index = AddUncasted<HAdd>(
+        raw_index, Add<HConstant>(base_offset + 2));
     details_index->ClearFlag(HValue::kCanOverflow);
 
     HValue* details = Add<HLoadKeyed>(elements, details_index,
                                       static_cast<HValue*>(NULL),
                                       FAST_SMI_ELEMENTS);
     IfBuilder details_compare(this);
     details_compare.If<HCompareNumericAndBranch>(details,
                                                  graph()->GetConstant0(),
                                                  Token::NE);
     details_compare.ThenDeopt("keyed load dictionary element not fast case");
 
     details_compare.Else();
     {
       // Key matches and details are zero --> fast case. Load and return the
       // value.
-      HValue* result_index = Add<HAdd>(raw_index,
-                                       Add<HConstant>(base_offset + 1));
+      HValue* result_index = AddUncasted<HAdd>(
+          raw_index, Add<HConstant>(base_offset + 1));
       result_index->ClearFlag(HValue::kCanOverflow);
 
       Push(Add<HLoadKeyed>(elements, result_index,
                            static_cast<HValue*>(NULL),
                            FAST_ELEMENTS));
     }
     details_compare.End();
   }
   key_compare.End();
 
   return Pop();
 }
 
 
 HValue* HGraphBuilder::BuildElementIndexHash(HValue* index) {
   int32_t seed_value = static_cast<uint32_t>(isolate()->heap()->HashSeed());
   HValue* seed = Add<HConstant>(seed_value);
-  HValue* hash = Add<HBitwise>(Token::BIT_XOR, index, seed);
+  HValue* hash = AddUncasted<HBitwise>(Token::BIT_XOR, index, seed);
 
   // hash = ~hash + (hash << 15);
-  HValue* shifted_hash = Add<HShl>(hash, Add<HConstant>(15));
-  HValue* not_hash = Add<HBitwise>(Token::BIT_XOR, hash,
-                                   graph()->GetConstantMinus1());
-  hash = Add<HAdd>(shifted_hash, not_hash);
+  HValue* shifted_hash = AddUncasted<HShl>(hash, Add<HConstant>(15));
+  HValue* not_hash = AddUncasted<HBitwise>(Token::BIT_XOR, hash,
+                                           graph()->GetConstantMinus1());
+  hash = AddUncasted<HAdd>(shifted_hash, not_hash);
 
   // hash = hash ^ (hash >> 12);
-  shifted_hash = Add<HShr>(hash, Add<HConstant>(12));
-  hash = Add<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
+  shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(12));
+  hash = AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 
   // hash = hash + (hash << 2);
-  shifted_hash = Add<HShl>(hash, Add<HConstant>(2));
-  hash = Add<HAdd>(hash, shifted_hash);
+  shifted_hash = AddUncasted<HShl>(hash, Add<HConstant>(2));
+  hash = AddUncasted<HAdd>(hash, shifted_hash);
 
   // hash = hash ^ (hash >> 4);
-  shifted_hash = Add<HShr>(hash, Add<HConstant>(4));
-  hash = Add<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
+  shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(4));
+  hash = AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 
   // hash = hash * 2057;
-  hash = Add<HMul>(hash, Add<HConstant>(2057));
+  hash = AddUncasted<HMul>(hash, Add<HConstant>(2057));
   hash->ClearFlag(HValue::kCanOverflow);
 
   // hash = hash ^ (hash >> 16);
-  shifted_hash = Add<HShr>(hash, Add<HConstant>(16));
-  return Add<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
+  shifted_hash = AddUncasted<HShr>(hash, Add<HConstant>(16));
+  return AddUncasted<HBitwise>(Token::BIT_XOR, hash, shifted_hash);
 }
 
 
 HValue* HGraphBuilder::BuildUncheckedDictionaryElementLoad(HValue* receiver,
                                                            HValue* key) {
   HValue* elements = AddLoadElements(receiver);
 
   HValue* hash = BuildElementIndexHash(key);
 
   HValue* capacity = Add<HLoadKeyed>(
@@ skipping 29 matching lines @@
   mask->set_type(HType::Smi());
   mask = Add<HSar>(mask, graph()->GetConstant1());
   mask = Add<HSub>(mask, graph()->GetConstant1());
 
   // Check whether object is a smi.
   IfBuilder if_objectissmi(this);
   if_objectissmi.If<HIsSmiAndBranch>(object);
   if_objectissmi.Then();
   {
     // Compute hash for smi similar to smi_get_hash().
-    HValue* hash = Add<HBitwise>(Token::BIT_AND, object, mask);
+    HValue* hash = AddUncasted<HBitwise>(Token::BIT_AND, object, mask);
 
     // Load the key.
-    HValue* key_index = Add<HShl>(hash, graph()->GetConstant1());
+    HValue* key_index = AddUncasted<HShl>(hash, graph()->GetConstant1());
     HValue* key = Add<HLoadKeyed>(number_string_cache, key_index,
                                   static_cast<HValue*>(NULL),
                                   FAST_ELEMENTS, ALLOW_RETURN_HOLE);
 
     // Check if object == key.
     IfBuilder if_objectiskey(this);
     if_objectiskey.If<HCompareObjectEqAndBranch>(object, key);
     if_objectiskey.Then();
     {
       // Make the key_index available.
@@ skipping 10 matching lines @@
       IfBuilder if_objectisnumber(this);
       if_objectisnumber.If<HCompareMap>(
           object, isolate()->factory()->heap_number_map());
       if_objectisnumber.Then();
       {
         // Compute hash for heap number similar to double_get_hash().
         HValue* low = Add<HLoadNamedField>(
             object, HObjectAccess::ForHeapNumberValueLowestBits());
         HValue* high = Add<HLoadNamedField>(
             object, HObjectAccess::ForHeapNumberValueHighestBits());
-        HValue* hash = Add<HBitwise>(Token::BIT_XOR, low, high);
-        hash = Add<HBitwise>(Token::BIT_AND, hash, mask);
+        HValue* hash = AddUncasted<HBitwise>(Token::BIT_XOR, low, high);
+        hash = AddUncasted<HBitwise>(Token::BIT_AND, hash, mask);
 
         // Load the key.
-        HValue* key_index = Add<HShl>(hash, graph()->GetConstant1());
+        HValue* key_index = AddUncasted<HShl>(hash, graph()->GetConstant1());
         HValue* key = Add<HLoadKeyed>(number_string_cache, key_index,
                                       static_cast<HValue*>(NULL),
                                       FAST_ELEMENTS, ALLOW_RETURN_HOLE);
 
         // Check if key is a heap number (the number string cache contains only
         // SMIs and heap number, so it is sufficient to do a SMI check here).
         IfBuilder if_keyisnotsmi(this);
         if_keyisnotsmi.IfNot<HIsSmiAndBranch>(key);
         if_keyisnotsmi.Then();
         {
@@ skipping 25 matching lines @@
 
   // Check for cache hit.
   IfBuilder if_found(this, &found);
   if_found.Then();
   {
     // Count number to string operation in native code.
     AddIncrementCounter(isolate()->counters()->number_to_string_native());
 
     // Load the value in case of cache hit.
     HValue* key_index = Pop();
-    HValue* value_index = Add<HAdd>(key_index, graph()->GetConstant1());
+    HValue* value_index = AddUncasted<HAdd>(key_index, graph()->GetConstant1());
     Push(Add<HLoadKeyed>(number_string_cache, value_index,
                          static_cast<HValue*>(NULL),
                          FAST_ELEMENTS, ALLOW_RETURN_HOLE));
   }
   if_found.Else();
   {
     // Cache miss, fallback to runtime.
     Add<HPushArgument>(object);
     Push(Add<HCallRuntime>(
             isolate()->factory()->empty_string(),
             Runtime::FunctionForId(Runtime::kNumberToStringSkipCache),
             1));
   }
   if_found.End();
 
   return Pop();
 }
 
 
 HValue* HGraphBuilder::BuildSeqStringSizeFor(HValue* length,
                                              String::Encoding encoding) {
   STATIC_ASSERT((SeqString::kHeaderSize & kObjectAlignmentMask) == 0);
   HValue* size = length;
   if (encoding == String::TWO_BYTE_ENCODING) {
-    size = Add<HShl>(length, graph()->GetConstant1());
+    size = AddUncasted<HShl>(length, graph()->GetConstant1());
     size->ClearFlag(HValue::kCanOverflow);
     size->SetFlag(HValue::kUint32);
   }
-  size = Add<HAdd>(size, Add<HConstant>(static_cast<int32_t>(
+  size = AddUncasted<HAdd>(size, Add<HConstant>(static_cast<int32_t>(
               SeqString::kHeaderSize + kObjectAlignmentMask)));
   size->ClearFlag(HValue::kCanOverflow);
-  size = Add<HBitwise>(
+  size = AddUncasted<HBitwise>(
       Token::BIT_AND, size, Add<HConstant>(static_cast<int32_t>(
               ~kObjectAlignmentMask)));
   return size;
 }
 
 
 void HGraphBuilder::BuildCopySeqStringChars(HValue* src,
                                             HValue* src_offset,
                                             String::Encoding src_encoding,
                                             HValue* dst,
                                             HValue* dst_offset,
                                             String::Encoding dst_encoding,
                                             HValue* length) {
   ASSERT(dst_encoding != String::ONE_BYTE_ENCODING ||
          src_encoding == String::ONE_BYTE_ENCODING);
   LoopBuilder loop(this, context(), LoopBuilder::kPostIncrement);
   HValue* index = loop.BeginBody(graph()->GetConstant0(), length, Token::LT);
   {
-    HValue* src_index = Add<HAdd>(src_offset, index);
+    HValue* src_index = AddUncasted<HAdd>(src_offset, index);
     HValue* value = Add<HSeqStringGetChar>(src_encoding, src, src_index);
-    HValue* dst_index = Add<HAdd>(dst_offset, index);
+    HValue* dst_index = AddUncasted<HAdd>(dst_offset, index);
     Add<HSeqStringSetChar>(dst_encoding, dst, dst_index, value);
   }
   loop.EndBody();
 }
 
 
 HValue* HGraphBuilder::BuildUncheckedStringAdd(HValue* left,
                                                HValue* right,
                                                PretenureFlag pretenure_flag) {
   // Determine the string lengths.
@@ skipping 24 matching lines @@
   {
     // Determine the string instance types.
     HLoadNamedField* left_instance_type = Add<HLoadNamedField>(
         Add<HLoadNamedField>(left, HObjectAccess::ForMap()),
         HObjectAccess::ForMapInstanceType());
     HLoadNamedField* right_instance_type = Add<HLoadNamedField>(
         Add<HLoadNamedField>(right, HObjectAccess::ForMap()),
         HObjectAccess::ForMapInstanceType());
 
     // Compute difference of instance types.
-    HValue* xored_instance_types = Add<HBitwise>(
+    HValue* xored_instance_types = AddUncasted<HBitwise>(
         Token::BIT_XOR, left_instance_type, right_instance_type);
 
     // Compute the length of the resulting string.
-    HValue* length = Add<HAdd>(left_length, right_length);
+    HValue* length = AddUncasted<HAdd>(left_length, right_length);
 
     // Check if we should create a cons string.
     IfBuilder if_createcons(this);
     if_createcons.If<HCompareNumericAndBranch>(
         length, Add<HConstant>(ConsString::kMinLength), Token::GTE);
     if_createcons.Then();
     {
       // Allocate the cons string object. HAllocate does not care whether we
       // pass CONS_STRING_TYPE or CONS_ASCII_STRING_TYPE here, so we just use
       // CONS_STRING_TYPE here. Below we decide whether the cons string is
       // one-byte or two-byte and set the appropriate map.
       HAllocate* string = Add<HAllocate>(Add<HConstant>(ConsString::kSize),
                                          HType::String(), pretenure_flag,
                                          CONS_STRING_TYPE);
 
       // Compute the intersection of instance types.
-      HValue* anded_instance_types = Add<HBitwise>(
+      HValue* anded_instance_types = AddUncasted<HBitwise>(
           Token::BIT_AND, left_instance_type, right_instance_type);
 
       // We create a one-byte cons string if
       // 1. both strings are one-byte, or
       // 2. at least one of the strings is two-byte, but happens to contain only
       //    one-byte characters.
       // To do this, we check
       // 1. if both strings are one-byte, or if the one-byte data hint is set in
       //    both strings, or
       // 2. if one of the strings has the one-byte data hint set and the other
       //    string is one-byte.
       IfBuilder if_onebyte(this);
       STATIC_ASSERT(kOneByteStringTag != 0);
       STATIC_ASSERT(kOneByteDataHintMask != 0);
       if_onebyte.If<HCompareNumericAndBranch>(
-          Add<HBitwise>(
+          AddUncasted<HBitwise>(
               Token::BIT_AND, anded_instance_types,
               Add<HConstant>(static_cast<int32_t>(
                       kStringEncodingMask | kOneByteDataHintMask))),
           graph()->GetConstant0(), Token::NE);
       if_onebyte.Or();
       STATIC_ASSERT(kOneByteStringTag != 0 &&
                     kOneByteDataHintTag != 0 &&
                     kOneByteDataHintTag != kOneByteStringTag);
       if_onebyte.If<HCompareNumericAndBranch>(
-          Add<HBitwise>(
+          AddUncasted<HBitwise>(
               Token::BIT_AND, xored_instance_types,
               Add<HConstant>(static_cast<int32_t>(
                       kOneByteStringTag | kOneByteDataHintTag))),
           Add<HConstant>(static_cast<int32_t>(
                   kOneByteStringTag | kOneByteDataHintTag)), Token::EQ);
       if_onebyte.Then();
       {
         // We can safely skip the write barrier for storing the map here.
         Handle<Map> map = isolate()->factory()->cons_ascii_string_map();
         AddStoreMapConstantNoWriteBarrier(string, map);
@@ skipping 13 matching lines @@
       Add<HStoreNamedField>(string, HObjectAccess::ForConsStringFirst(), left);
       Add<HStoreNamedField>(string, HObjectAccess::ForConsStringSecond(),
                             right);
 
       // Cons string is result.
       Push(string);
     }
     if_createcons.Else();
     {
       // Compute union of instance types.
-      HValue* ored_instance_types = Add<HBitwise>(
+      HValue* ored_instance_types = AddUncasted<HBitwise>(
           Token::BIT_OR, left_instance_type, right_instance_type);
 
       // Check if both strings have the same encoding and both are
       // sequential.
       IfBuilder if_sameencodingandsequential(this);
       if_sameencodingandsequential.If<HCompareNumericAndBranch>(
-          Add<HBitwise>(
+          AddUncasted<HBitwise>(
               Token::BIT_AND, xored_instance_types,
               Add<HConstant>(static_cast<int32_t>(kStringEncodingMask))),
           graph()->GetConstant0(), Token::EQ);
       if_sameencodingandsequential.And();
       STATIC_ASSERT(kSeqStringTag == 0);
       if_sameencodingandsequential.If<HCompareNumericAndBranch>(
-          Add<HBitwise>(
+          AddUncasted<HBitwise>(
               Token::BIT_AND, ored_instance_types,
               Add<HConstant>(static_cast<int32_t>(kStringRepresentationMask))),
           graph()->GetConstant0(), Token::EQ);
       if_sameencodingandsequential.Then();
       {
         // Check if the result is a one-byte string.
         IfBuilder if_onebyte(this);
         STATIC_ASSERT(kOneByteStringTag != 0);
         if_onebyte.If<HCompareNumericAndBranch>(
-            Add<HBitwise>(
+            AddUncasted<HBitwise>(
                 Token::BIT_AND, ored_instance_types,
                 Add<HConstant>(static_cast<int32_t>(kStringEncodingMask))),
             graph()->GetConstant0(), Token::NE);
         if_onebyte.Then();
         {
           // Calculate the number of bytes needed for the characters in the
           // string while observing object alignment.
           HValue* size = BuildSeqStringSizeFor(
               length, String::ONE_BYTE_ENCODING);
 
@@ skipping 302 matching lines @@
 
   if (IsFastDoubleElementsKind(kind)) {
     elements_size = kDoubleSize;
     instance_type = FIXED_DOUBLE_ARRAY_TYPE;
   } else {
     elements_size = kPointerSize;
     instance_type = FIXED_ARRAY_TYPE;
   }
 
   HConstant* elements_size_value = Add<HConstant>(elements_size);
-  HValue* mul = Add<HMul>(capacity, elements_size_value);
+  HValue* mul = AddUncasted<HMul>(capacity, elements_size_value);
   mul->ClearFlag(HValue::kCanOverflow);
 
   HConstant* header_size = Add<HConstant>(FixedArray::kHeaderSize);
-  HValue* total_size = Add<HAdd>(mul, header_size);
+  HValue* total_size = AddUncasted<HAdd>(mul, header_size);
   total_size->ClearFlag(HValue::kCanOverflow);
 
   return Add<HAllocate>(total_size, HType::JSArray(),
       isolate()->heap()->GetPretenureMode(), instance_type);
 }
 
 
 void HGraphBuilder::BuildInitializeElementsHeader(HValue* elements,
                                                   ElementsKind kind,
                                                   HValue* capacity) {
@@ skipping 2307 matching lines @@
   BreakAndContinueInfo break_info(stmt, 5);
   CHECK_BAILOUT(VisitLoopBody(stmt, loop_entry, &break_info));
 
   HBasicBlock* body_exit =
       JoinContinue(stmt, current_block(), break_info.continue_block());
 
   if (body_exit != NULL) {
     set_current_block(body_exit);
 
     HValue* current_index = Pop();
-    Push(Add<HAdd>(current_index, graph()->GetConstant1()));
+    Push(AddUncasted<HAdd>(current_index, graph()->GetConstant1()));
     body_exit = current_block();
   }
 
   HBasicBlock* loop_exit = CreateLoop(stmt,
                                       loop_entry,
                                       body_exit,
                                       loop_successor,
                                       break_info.break_block());
 
   set_current_block(loop_exit);
@@ skipping 6115 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal