[turbofan] Run everything after representation selection concurrently.

src/handles.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HANDLES_H_
 #define V8_HANDLES_H_
 
 #include "include/v8.h"
 #include "src/base/functional.h"
 #include "src/base/macros.h"
@@ skipping 25 matching lines @@
                  this->IsDereferenceAllowed(NO_DEFERRED_CHECK)) &&
                 (that.location_ == nullptr ||
                  that.IsDereferenceAllowed(NO_DEFERRED_CHECK)));
     if (this->location_ == that.location_) return true;
     if (this->location_ == NULL || that.location_ == NULL) return false;
     return *this->location_ == *that.location_;
   }
 
   V8_INLINE bool is_null() const { return location_ == nullptr; }
 
+  // Returns the raw address where this handle is stored. This should only be
+  // used for hashing handles; do not ever try to dereference it.
+  V8_INLINE Address address() const { return bit_cast<Address>(location_); }
+
  protected:
   // Provides the C++ dereference operator.
   V8_INLINE Object* operator*() const {
     SLOW_DCHECK(IsDereferenceAllowed(INCLUDE_DEFERRED_CHECK));
     return *location_;
   }
 
   // Returns the address to where the raw pointer is stored.
   V8_INLINE Object** location() const {
     SLOW_DCHECK(location_ == nullptr ||
@@ skipping 69 matching lines @@
     return Handle<T>(reinterpret_cast<T**>(that.location_));
   }
 
   // TODO(yangguo): Values that contain empty handles should be declared as
   // MaybeHandle to force validation before being used as handles.
   static const Handle<T> null() { return Handle<T>(); }
 
   // Provide function object for location equality comparison.
   struct equal_to : public std::binary_function<Handle<T>, Handle<T>, bool> {
     V8_INLINE bool operator()(Handle<T> lhs, Handle<T> rhs) const {
-      return lhs.location() == rhs.location();
+      return lhs.address() == rhs.address();
     }
   };
 
   // Provide function object for location hashing.
   struct hash : public std::unary_function<Handle<T>, size_t> {
     V8_INLINE size_t operator()(Handle<T> const& handle) const {
-      return base::hash<void*>()(handle.location());
+      return base::hash<void*>()(handle.address());
     }
   };
 
  private:
   // Handles of different classes are allowed to access each other's location_.
   template <typename>
   friend class Handle;
   // MaybeHandle is allowed to access location_.
   template <typename>
   friend class MaybeHandle;
@@ skipping 246 matching lines @@
     next = limit = NULL;
     sealed_level = level = 0;
     canonical_scope = NULL;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HANDLES_H_