Rename NumberInfo to TypeInfo....

src/virtual-frame.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 25 matching lines @@
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 // Create a duplicate of an existing valid frame element.
 // We can pass an optional number type information that will override the
 // existing information about the backing element. The new information must
 // not conflict with the existing type information and must be equally or
 // more precise. The default parameter value kUninitialized means that there
 // is no additional information.
-FrameElement VirtualFrame::CopyElementAt(int index, NumberInfo info) {
+FrameElement VirtualFrame::CopyElementAt(int index, TypeInfo info) {
   ASSERT(index >= 0);
   ASSERT(index < element_count());
 
   FrameElement target = elements_[index];
   FrameElement result;
 
   switch (target.type()) {
     case FrameElement::CONSTANT:
       // We do not copy constants and instead return a fresh unsynced
       // constant.
@@ skipping 10 matching lines @@
 
     case FrameElement::MEMORY:  // Fall through.
     case FrameElement::REGISTER: {
       // All copies are backed by memory or register locations.
       result.set_type(FrameElement::COPY);
       result.clear_copied();
       result.clear_sync();
       result.set_index(index);
       elements_[index].set_copied();
       // Update backing element's number information.
-      NumberInfo existing = elements_[index].number_info();
+      TypeInfo existing = elements_[index].type_info();
       ASSERT(!existing.IsUninitialized());
       // Assert that the new type information (a) does not conflict with the
       // existing one and (b) is equally or more precise.
       ASSERT((info.ToInt() & existing.ToInt()) == existing.ToInt());
       ASSERT((info.ToInt() | existing.ToInt()) == info.ToInt());
 
-      elements_[index].set_number_info(!info.IsUninitialized()
+      elements_[index].set_type_info(!info.IsUninitialized()
                                        ? info
                                        : existing);
       break;
     }
     case FrameElement::INVALID:
       // We should not try to copy invalid elements.
       UNREACHABLE();
       break;
   }
   return result;
 }
 
 
 // Modify the state of the virtual frame to match the actual frame by adding
 // extra in-memory elements to the top of the virtual frame.  The extra
 // elements will be externally materialized on the actual frame (eg, by
 // pushing an exception handler).  No code is emitted.
 void VirtualFrame::Adjust(int count) {
   ASSERT(count >= 0);
   ASSERT(stack_pointer_ == element_count() - 1);
 
   for (int i = 0; i < count; i++) {
-    elements_.Add(FrameElement::MemoryElement(NumberInfo::Unknown()));
+    elements_.Add(FrameElement::MemoryElement(TypeInfo::Unknown()));
   }
   stack_pointer_ += count;
 }
 
 
 void VirtualFrame::ForgetElements(int count) {
   ASSERT(count >= 0);
   ASSERT(element_count() >= count);
 
   for (int i = 0; i < count; i++) {
@@ skipping 27 matching lines @@
 }
 
 
 // Make the type of the element at a given index be MEMORY.
 void VirtualFrame::SpillElementAt(int index) {
   if (!elements_[index].is_valid()) return;
 
   SyncElementAt(index);
   // Number type information is preserved.
   // Copies get their number information from their backing element.
-  NumberInfo info;
+  TypeInfo info;
   if (!elements_[index].is_copy()) {
-    info = elements_[index].number_info();
+    info = elements_[index].type_info();
   } else {
-    info = elements_[elements_[index].index()].number_info();
+    info = elements_[elements_[index].index()].type_info();
   }
   // The element is now in memory.  Its copied flag is preserved.
   FrameElement new_element = FrameElement::MemoryElement(info);
   if (elements_[index].is_copied()) {
     new_element.set_copied();
   }
   if (elements_[index].is_untagged_int32()) {
     new_element.set_untagged_int32(true);
   }
   if (elements_[index].is_register()) {
@@ skipping 141 matching lines @@
             elements_[j].set_index(frame_index);
           }
         }
       }
     } else {
       // The register value->reg() was not already used on the frame.
       Use(value->reg(), frame_index);
       elements_[frame_index] =
           FrameElement::RegisterElement(value->reg(),
                                         FrameElement::NOT_SYNCED,
-                                        value->number_info());
+                                        value->type_info());
     }
   } else {
     ASSERT(value->is_constant());
     elements_[frame_index] =
         FrameElement::ConstantElement(value->handle(),
                                       FrameElement::NOT_SYNCED);
   }
   value->Unuse();
 }
 
 
 // Specialization of List::ResizeAdd to non-inlined version for FrameElements.
 // The function ResizeAdd becomes a real function, whose implementation is the
 // inlined ResizeAddInternal.
 template <>
 void List<FrameElement,
           FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element) {
   ResizeAddInternal(element);
 }
 
 } }  // namespace v8::internal