Rename NumberInfo to TypeInfo....

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 89 matching lines @@
         // change our decision about undetermined or invalid elements.
         if (element == NULL || !element->is_valid()) break;
 
         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()));
+          element->set_type_info(TypeInfo::Combine(element->type_info(),
+                                                   other->type_info()));
         }
       }
       elements[i] = element;
     }
   }
 
   // Build the new frame.  A freshly allocated frame has memory elements
   // for the parameters and some platform-dependent elements (e.g.,
   // return address).  Replace those first.
   entry_frame_ = new VirtualFrame();
   int index = 0;
   for (; index < entry_frame_->element_count(); index++) {
     FrameElement* target = elements[index];
     // If the element is determined, set it now.  Count registers.  Mark
     // elements as copied exactly when they have a copy.  Undetermined
     // elements are initially recorded as if in memory.
     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::Uninitialized()));
+          FrameElement::MemoryElement(TypeInfo::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 info = NumberInfo::Uninitialized();
+      TypeInfo info = TypeInfo::Uninitialized();
 
       for (int j = 0; j < reaching_frames_.length(); j++) {
         FrameElement element = reaching_frames_[j]->elements_[i];
         if (direction_ == BIDIRECTIONAL) {
-          info = NumberInfo::Unknown();
+          info = TypeInfo::Unknown();
         } else if (!element.is_copy()) {
-          info = NumberInfo::Combine(info, element.number_info());
+          info = TypeInfo::Combine(info, element.type_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());
+          info = TypeInfo::Combine(info,
+            reaching_frames_[j]->elements_[element.index()].type_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.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);
+        entry_frame_->elements_[i].set_type_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::Uninitialized());
+                                          TypeInfo::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);
+      entry_frame_->elements_[i].set_type_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().IsUnknown());
+        ASSERT(entry_frame_->elements_[i].type_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