Import Reversed adapter from Chromium and use it in v8.

Review URL: https://codereview.chromium.org/1098863003

Cr-Commit-Position: refs/heads/master@{#27947}

diff --git a/BUILD.gn b/BUILD.gn
index 9fe40e6be30b7aa2463ec01e280850f162e2c45f..866943b98a9dc74a0774effcb9d0ea6edd8be1eb 100644 (file)
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1336,6 +1336,7 @@ source_set("v8_libbase") {
   visibility = [ ":*" ]  # Only targets in this file can depend on this.
 
   sources = [
+    "src/base/adapters.h",
     "src/base/atomicops.h",
     "src/base/atomicops_internals_arm64_gcc.h",
     "src/base/atomicops_internals_arm_gcc.h",

diff --git a/src/base/adapters.h b/src/base/adapters.h
new file mode 100644 (file)
index 0000000..f04391e
--- /dev/null
+++ b/src/base/adapters.h
@@ -0,0 +1,51 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Slightly adapted for inclusion in V8.
+// Copyright 2014 the V8 project authors. All rights reserved.
+
+#ifndef V8_BASE_ADAPTERS_H_
+#define V8_BASE_ADAPTERS_H_
+
+#include "src/base/macros.h"
+
+namespace v8 {
+namespace base {
+
+// Internal adapter class for implementing base::Reversed.
+template <typename T>
+class ReversedAdapter {
+ public:
+  typedef decltype(static_cast<T*>(nullptr)->rbegin()) Iterator;
+
+  explicit ReversedAdapter(T& t) : t_(t) {}
+  ReversedAdapter(const ReversedAdapter& ra) : t_(ra.t_) {}
+
+  Iterator begin() const { return t_.rbegin(); }
+  Iterator end() const { return t_.rend(); }
+
+ private:
+  T& t_;
+
+  DISALLOW_ASSIGN(ReversedAdapter);
+};
+
+// Reversed returns a container adapter usable in a range-based "for" statement
+// for iterating a reversible container in reverse order.
+//
+// Example:
+//
+//   std::vector<int> v = ...;
+//   for (int i : base::Reversed(v)) {
+//     // iterates through v from back to front
+//   }
+template <typename T>
+ReversedAdapter<T> Reversed(T& t) {
+  return ReversedAdapter<T>(t);
+}
+
+}  // namespace base
+}  // namespace v8
+
+#endif  // V8_BASE_ADAPTERS_H_

diff --git a/src/base/macros.h b/src/base/macros.h
index ce75f8bed757145f2c4687431f1dda023f43aec9..49ca386aabd7c788e59d2ab4c88277be55b70eb1 100644 (file)
--- a/src/base/macros.h
+++ b/src/base/macros.h
@@ -228,6 +228,10 @@ V8_INLINE Dest bit_cast(Source const& source) {
 }
 
 
+// Put this in the private: declarations for a class to be unassignable.
+#define DISALLOW_ASSIGN(TypeName) void operator=(const TypeName&)
+
+
 // A macro to disallow the evil copy constructor and operator= functions
 // This should be used in the private: declarations for a class
 #define DISALLOW_COPY_AND_ASSIGN(TypeName)  \

diff --git a/src/compiler/arm/instruction-selector-arm.cc b/src/compiler/arm/instruction-selector-arm.cc
index f0040474f4a6ae416d08c1615fbf8e8aee2e8c26..73ea636e42c7b5a270f1016a58c6b294138b09ca 100644 (file)
--- a/src/compiler/arm/instruction-selector-arm.cc
+++ b/src/compiler/arm/instruction-selector-arm.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/adapters.h"
 #include "src/base/bits.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
@@ -1099,9 +1100,8 @@ void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
 
   // TODO(dcarney): might be possible to use claim/poke instead
   // Push any stack arguments.
-  for (auto i = buffer.pushed_nodes.rbegin(); i != buffer.pushed_nodes.rend();
-       ++i) {
-    Emit(kArmPush, g.NoOutput(), g.UseRegister(*i));
+  for (Node* node : base::Reversed(buffer.pushed_nodes)) {
+    Emit(kArmPush, g.NoOutput(), g.UseRegister(node));
   }
 
   // Pass label of exception handler block.

diff --git a/src/compiler/ia32/instruction-selector-ia32.cc b/src/compiler/ia32/instruction-selector-ia32.cc
index 639a275099881b73e24772502ddf6ba2e327ebb9..72dd48e84438afe4c6fcdf79e3c20424f78b06f3 100644 (file)
--- a/src/compiler/ia32/instruction-selector-ia32.cc
+++ b/src/compiler/ia32/instruction-selector-ia32.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
@@ -831,13 +832,12 @@ void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
   InitializeCallBuffer(node, &buffer, true, true);
 
   // Push any stack arguments.
-  for (auto i = buffer.pushed_nodes.rbegin(); i != buffer.pushed_nodes.rend();
-       ++i) {
+  for (Node* node : base::Reversed(buffer.pushed_nodes)) {
     // TODO(titzer): handle pushing double parameters.
     InstructionOperand value =
-        g.CanBeImmediate(*i) ? g.UseImmediate(*i) : IsSupported(ATOM)
-                                                        ? g.UseRegister(*i)
-                                                        : g.Use(*i);
+        g.CanBeImmediate(node)
+            ? g.UseImmediate(node)
+            : IsSupported(ATOM) ? g.UseRegister(node) : g.Use(node);
     Emit(kIA32Push, g.NoOutput(), value);
   }
 

diff --git a/src/compiler/instruction-selector.cc b/src/compiler/instruction-selector.cc
index 4734e75aa8180f197d3e8abd828ba254c2edd3d7..8c94129713bd22696470d3dab36801b2b65b5cde 100644 (file)
--- a/src/compiler/instruction-selector.cc
+++ b/src/compiler/instruction-selector.cc
@@ -6,6 +6,7 @@
 
 #include <limits>
 
+#include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
@@ -465,9 +466,7 @@ void InstructionSelector::VisitBlock(BasicBlock* block) {
 
   // Visit code in reverse control flow order, because architecture-specific
   // matching may cover more than one node at a time.
-  for (BasicBlock::reverse_iterator i = block->rbegin(); i != block->rend();
-       ++i) {
-    Node* node = *i;
+  for (auto node : base::Reversed(*block)) {
     // Skip nodes that are unused or already defined.
     if (!IsUsed(node) || IsDefined(node)) continue;
     // Generate code for this node "top down", but schedule the code "bottom

diff --git a/src/compiler/liveness-analyzer.cc b/src/compiler/liveness-analyzer.cc
index 301106d1c3a4d5eff4d6553c8cfd7efafe6e6ab4..fe458b8f9fccf0557b1875b8e65190c3dfbd6a28 100644 (file)
--- a/src/compiler/liveness-analyzer.cc
+++ b/src/compiler/liveness-analyzer.cc
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "src/compiler/liveness-analyzer.h"
+#include "src/base/adapters.h"
 #include "src/compiler/js-graph.h"
+#include "src/compiler/liveness-analyzer.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/state-values-utils.h"
@@ -97,8 +98,7 @@ void LivenessAnalyzerBlock::Process(BitVector* result,
   // Copy the bitvector to the target bit vector.
   result->CopyFrom(live_);
 
-  for (auto i = entries_.rbegin(); i != entries_.rend(); i++) {
-    auto entry = *i;
+  for (auto entry : base::Reversed(entries_)) {
     switch (entry.kind()) {
       case Entry::kLookup:
         result->Add(entry.var());

diff --git a/src/compiler/mips/instruction-selector-mips.cc b/src/compiler/mips/instruction-selector-mips.cc
index e66979a6820900151cd1925ec9d97ded6b51d9e8..f5b107b6b83776e202f64fb6c5a77eac42a2fc49 100644 (file)
--- a/src/compiler/mips/instruction-selector-mips.cc
+++ b/src/compiler/mips/instruction-selector-mips.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/adapters.h"
 #include "src/base/bits.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
@@ -519,9 +520,8 @@ void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
          g.TempImmediate(push_count << kPointerSizeLog2));
   }
   int slot = buffer.pushed_nodes.size() - 1;
-  for (auto i = buffer.pushed_nodes.rbegin(); i != buffer.pushed_nodes.rend();
-       ++i) {
-    Emit(kMipsStoreToStackSlot, g.NoOutput(), g.UseRegister(*i),
+  for (Node* node : base::Reversed(buffer.pushed_nodes)) {
+    Emit(kMipsStoreToStackSlot, g.NoOutput(), g.UseRegister(node),
          g.TempImmediate(slot << kPointerSizeLog2));
     slot--;
   }

diff --git a/src/compiler/mips64/instruction-selector-mips64.cc b/src/compiler/mips64/instruction-selector-mips64.cc
index dd7640ae7f2b650becfbb73297d90a9f9aa9979e..5b32e10ee04f94cb8ce2409ead221d0da2f9119a 100644 (file)
--- a/src/compiler/mips64/instruction-selector-mips64.cc
+++ b/src/compiler/mips64/instruction-selector-mips64.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/adapters.h"
 #include "src/base/bits.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
@@ -668,9 +669,8 @@ void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
          g.TempImmediate(push_count << kPointerSizeLog2));
   }
   int slot = buffer.pushed_nodes.size() - 1;
-  for (auto i = buffer.pushed_nodes.rbegin(); i != buffer.pushed_nodes.rend();
-       ++i) {
-    Emit(kMips64StoreToStackSlot, g.NoOutput(), g.UseRegister(*i),
+  for (Node* node : base::Reversed(buffer.pushed_nodes)) {
+    Emit(kMips64StoreToStackSlot, g.NoOutput(), g.UseRegister(node),
          g.TempImmediate(slot << kPointerSizeLog2));
     slot--;
   }

diff --git a/src/compiler/ppc/instruction-selector-ppc.cc b/src/compiler/ppc/instruction-selector-ppc.cc
index c2c4de0f2101cb46398d2f1aebfe316bbb6c012d..46516e47cacd57dbb215dbd5395a45ef05521ee9 100644 (file)
--- a/src/compiler/ppc/instruction-selector-ppc.cc
+++ b/src/compiler/ppc/instruction-selector-ppc.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
@@ -1453,9 +1454,8 @@ void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
 
   // Push any stack arguments.
   // TODO(mbrandy): reverse order and use push only for first
-  for (auto i = buffer.pushed_nodes.rbegin(); i != buffer.pushed_nodes.rend();
-       i++) {
-    Emit(kPPC_Push, g.NoOutput(), g.UseRegister(*i));
+  for (Node* node : base::Reversed(buffer.pushed_nodes)) {
+    Emit(kPPC_Push, g.NoOutput(), g.UseRegister(node));
   }
 
   // Pass label of exception handler block.

diff --git a/src/compiler/register-allocator.cc b/src/compiler/register-allocator.cc
index ec4120ea2e17ea4f11725cac22499739555655ca..924a53e7bd7421bc20a51bff0817530d797224ce 100644 (file)
--- a/src/compiler/register-allocator.cc
+++ b/src/compiler/register-allocator.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/base/adapters.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
@@ -1314,9 +1315,8 @@ void LiveRangeBuilder::MeetRegisterConstraints() {
 
 void LiveRangeBuilder::ResolvePhis() {
   // Process the blocks in reverse order.
-  for (auto i = code()->instruction_blocks().rbegin();
-       i != code()->instruction_blocks().rend(); ++i) {
-    ResolvePhis(*i);
+  for (InstructionBlock* block : base::Reversed(code()->instruction_blocks())) {
+    ResolvePhis(block);
   }
 }
 

diff --git a/src/compiler/scheduler.cc b/src/compiler/scheduler.cc
index 1185cacab7b95cca5a01687021ce78b7c03f6a2f..9851dba4fec00eec5688557c86aac96bea752798 100644 (file)
--- a/src/compiler/scheduler.cc
+++ b/src/compiler/scheduler.cc
@@ -6,6 +6,7 @@
 
 #include <iomanip>
 
+#include "src/base/adapters.h"
 #include "src/bit-vector.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/control-equivalence.h"
@@ -1622,8 +1623,8 @@ void Scheduler::SealFinalSchedule() {
   for (NodeVector& nodes : scheduled_nodes_) {
     BasicBlock::Id id = BasicBlock::Id::FromInt(block_num++);
     BasicBlock* block = schedule_->GetBlockById(id);
-    for (auto i = nodes.rbegin(); i != nodes.rend(); ++i) {
-      schedule_->AddNode(block, *i);
+    for (Node* node : base::Reversed(nodes)) {
+      schedule_->AddNode(block, node);
     }
   }
 }

diff --git a/src/compiler/x64/instruction-selector-x64.cc b/src/compiler/x64/instruction-selector-x64.cc
index c00117e75690975738bdf3bfed5e06fe33addd30..e0e97acfce5c4ed181ec86efd00639c1f263300b 100644 (file)
--- a/src/compiler/x64/instruction-selector-x64.cc
+++ b/src/compiler/x64/instruction-selector-x64.cc
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 
+#include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
@@ -1034,13 +1035,12 @@ void InstructionSelector::VisitCall(Node* node, BasicBlock* handler) {
   InitializeCallBuffer(node, &buffer, true, true);
 
   // Push any stack arguments.
-  for (auto i = buffer.pushed_nodes.rbegin(); i != buffer.pushed_nodes.rend();
-       ++i) {
+  for (Node* node : base::Reversed(buffer.pushed_nodes)) {
     // TODO(titzer): handle pushing double parameters.
     InstructionOperand value =
-        g.CanBeImmediate(*i) ? g.UseImmediate(*i) : IsSupported(ATOM)
-                                                        ? g.UseRegister(*i)
-                                                        : g.Use(*i);
+        g.CanBeImmediate(node)
+            ? g.UseImmediate(node)
+            : IsSupported(ATOM) ? g.UseRegister(node) : g.Use(node);
     Emit(kX64Push, g.NoOutput(), value);
   }
 

diff --git a/src/utils.h b/src/utils.h
index dd4712903126bd0e2f08917dae07df553309b212..5790d878b9a4b87d24f74466c831d35241d1d935 100644 (file)
--- a/src/utils.h
+++ b/src/utils.h
@@ -1101,21 +1101,6 @@ class BailoutId {
 };
 
 
-template <class C>
-class ContainerPointerWrapper {
- public:
-  typedef typename C::iterator iterator;
-  typedef typename C::reverse_iterator reverse_iterator;
-  explicit ContainerPointerWrapper(C* container) : container_(container) {}
-  iterator begin() { return container_->begin(); }
-  iterator end() { return container_->end(); }
-  reverse_iterator rbegin() { return container_->rbegin(); }
-  reverse_iterator rend() { return container_->rend(); }
- private:
-  C* container_;
-};
-
-
 // ----------------------------------------------------------------------------
 // I/O support.
 

diff --git a/tools/gyp/v8.gyp b/tools/gyp/v8.gyp
index 3cf134c481c34a71eb472d8e0419298461076af2..7587afb34382e95bee86769b82240fd024976c74 100644 (file)
--- a/tools/gyp/v8.gyp
+++ b/tools/gyp/v8.gyp
@@ -1330,6 +1330,7 @@
         '../..',
       ],
       'sources': [
+        '../../src/base/adapters.h',
         '../../src/base/atomicops.h',
         '../../src/base/atomicops_internals_arm64_gcc.h',
         '../../src/base/atomicops_internals_arm_gcc.h',