Merge changes up to V8 version 2.1.3 into the partial snapshots

src/jump-target.cc

 // Copyright 2009 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 82 matching lines @@
 
   // Compute elements based on the other reaching frames.
   if (reaching_frames_.length() > 1) {
     for (int i = 0; i < length; i++) {
       FrameElement* element = elements[i];
       for (int j = 1; j < reaching_frames_.length(); j++) {
         // Element computation is monotonic: new information will not
         // change our decision about undetermined or invalid elements.
         if (element == NULL || !element->is_valid()) break;
 
-        element = element->Combine(&reaching_frames_[j]->elements_[i]);
-
         FrameElement* other = &reaching_frames_[j]->elements_[i];
+        element = element->Combine(other);
         if (element != NULL && !element->is_copy()) {
           ASSERT(other != NULL);
           // We overwrite the number information of one of the incoming frames.
           // This is safe because we only use the frame for emitting merge code.
           // The number information of incoming frames is not used anymore.
           element->set_number_info(NumberInfo::Combine(element->number_info(),
                                                        other->number_info()));
         }
       }
       elements[i] = element;
@@ skipping 13 matching lines @@
     if (target != NULL) {
       entry_frame_->elements_[index] = *target;
       InitializeEntryElement(index, target);
     }
   }
   // Then fill in the rest of the frame with new elements.
   for (; index < length; index++) {
     FrameElement* target = elements[index];
     if (target == NULL) {
       entry_frame_->elements_.Add(
-          FrameElement::MemoryElement(NumberInfo::kUninitialized));
+          FrameElement::MemoryElement(NumberInfo::Uninitialized()));
     } else {
       entry_frame_->elements_.Add(*target);
       InitializeEntryElement(index, target);
     }
   }
 
   // Allocate any still-undetermined frame elements to registers or
   // memory, from the top down.
   for (int i = length - 1; i >= 0; i--) {
     if (elements[i] == NULL) {
       // Loop over all the reaching frames to check whether the element
       // is synced on all frames and to count the registers it occupies.
       bool is_synced = true;
       RegisterFile candidate_registers;
       int best_count = kMinInt;
       int best_reg_num = RegisterAllocator::kInvalidRegister;
-      NumberInfo::Type info = NumberInfo::kUninitialized;
+      NumberInfo info = NumberInfo::Uninitialized();
 
       for (int j = 0; j < reaching_frames_.length(); j++) {
         FrameElement element = reaching_frames_[j]->elements_[i];
         if (direction_ == BIDIRECTIONAL) {
-            info = NumberInfo::kUnknown;
+          info = NumberInfo::Unknown();
         } else if (!element.is_copy()) {
           info = NumberInfo::Combine(info, element.number_info());
         } else {
           // New elements will not be copies, so get number information from
           // backing element in the reaching frame.
           info = NumberInfo::Combine(info,
             reaching_frames_[j]->elements_[element.index()].number_info());
         }
         is_synced = is_synced && element.is_synced();
         if (element.is_register() && !entry_frame_->is_used(element.reg())) {
           // Count the register occurrence and remember it if better
           // than the previous best.
           int num = RegisterAllocator::ToNumber(element.reg());
           candidate_registers.Use(num);
           if (candidate_registers.count(num) > best_count) {
             best_count = candidate_registers.count(num);
             best_reg_num = num;
           }
         }
       }
 
       // We must have a number type information now (not for copied elements).
       ASSERT(entry_frame_->elements_[i].is_copy()
-             || info != NumberInfo::kUninitialized);
+             || !info.IsUninitialized());
 
       // If the value is synced on all frames, put it in memory.  This
       // costs nothing at the merge code but will incur a
       // memory-to-register move when the value is needed later.
       if (is_synced) {
         // Already recorded as a memory element.
         // Set combined number info.
         entry_frame_->elements_[i].set_number_info(info);
         continue;
       }
 
       // Try to put it in a register.  If there was no best choice
       // consider any free register.
       if (best_reg_num == RegisterAllocator::kInvalidRegister) {
         for (int j = 0; j < RegisterAllocator::kNumRegisters; j++) {
           if (!entry_frame_->is_used(j)) {
             best_reg_num = j;
             break;
           }
         }
       }
 
       if (best_reg_num != RegisterAllocator::kInvalidRegister) {
         // If there was a register choice, use it.  Preserve the copied
         // flag on the element.
         bool is_copied = entry_frame_->elements_[i].is_copied();
         Register reg = RegisterAllocator::ToRegister(best_reg_num);
         entry_frame_->elements_[i] =
             FrameElement::RegisterElement(reg, FrameElement::NOT_SYNCED,
-                                          NumberInfo::kUninitialized);
+                                          NumberInfo::Uninitialized());
         if (is_copied) entry_frame_->elements_[i].set_copied();
         entry_frame_->set_register_location(reg, i);
       }
       // Set combined number info.
       entry_frame_->elements_[i].set_number_info(info);
     }
   }
 
   // If we have incoming backward edges assert we forget all number information.
 #ifdef DEBUG
   if (direction_ == BIDIRECTIONAL) {
     for (int i = 0; i < length; ++i) {
       if (!entry_frame_->elements_[i].is_copy()) {
-        ASSERT(entry_frame_->elements_[i].number_info() ==
-               NumberInfo::kUnknown);
+        ASSERT(entry_frame_->elements_[i].number_info().IsUnknown());
       }
     }
   }
 #endif
 
   // The stack pointer is at the highest synced element or the base of
   // the expression stack.
   int stack_pointer = length - 1;
   while (stack_pointer >= entry_frame_->expression_base_index() &&
          !entry_frame_->elements_[stack_pointer].is_synced()) {
@@ skipping 175 matching lines @@
   temp.CopyTo(this);
   temp.Unuse();
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 
 } }  // namespace v8::internal