Make more use of the NumberInfo data....

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::Type info) {
+FrameElement VirtualFrame::CopyElementAt(int index, NumberInfo 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::Type existing = elements_[index].number_info();
-      ASSERT(existing != NumberInfo::kUninitialized);
-      // Assert that the new type information (a) does not conflict with the
-      // existing one and (b) is equally or more precise.
-      ASSERT((info == NumberInfo::kUninitialized) ||
-             (existing | info) != NumberInfo::kUninitialized);
-      ASSERT(existing <= info);
-      elements_[index].set_number_info(info != NumberInfo::kUninitialized
+      NumberInfo existing = elements_[index].number_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()
                                        ? 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::kUnknown));
+    elements_.Add(FrameElement::MemoryElement(NumberInfo::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::Type info;
+  NumberInfo info;
   if (!elements_[index].is_copy()) {
     info = elements_[index].number_info();
   } else {
     info = elements_[elements_[index].index()].number_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();
   }
@@ skipping 164 matching lines @@
 // 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