Revert of [turbofan] Improve memory layout of Node class.

src/compiler/node.cc

 // Copyright 2013 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.
 
 #include "src/compiler/node.h"
 
 #include <algorithm>
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 Node* Node::New(Zone* zone, NodeId id, const Operator* op, int input_count,
                 Node** inputs, bool has_extensible_inputs) {
-  size_t node_size = sizeof(Node) - sizeof(Input);
+  size_t node_size = sizeof(Node);
   int reserve_input_count = has_extensible_inputs ? kDefaultReservedInputs : 0;
-  size_t inputs_size = std::max<size_t>(
-      (input_count + reserve_input_count) * sizeof(Input), sizeof(InputDeque*));
+  size_t inputs_size = (input_count + reserve_input_count) * sizeof(Input);
   size_t uses_size = input_count * sizeof(Use);
   int size = static_cast<int>(node_size + inputs_size + uses_size);
   void* buffer = zone->New(size);
   Node* result = new (buffer) Node(id, op, input_count, reserve_input_count);
-  Input* input = result->inputs_.static_;
+  Input* input =
+      reinterpret_cast<Input*>(reinterpret_cast<char*>(buffer) + node_size);
   Use* use =
       reinterpret_cast<Use*>(reinterpret_cast<char*>(input) + inputs_size);
 
   for (int current = 0; current < input_count; ++current) {
     Node* to = *inputs++;
     input->to = to;
     input->use = use;
     use->input_index = current;
     use->from = result;
     to->AppendUse(use);
@@ skipping 134 matching lines @@
 
 Node::Node(NodeId id, const Operator* op, int input_count,
            int reserved_input_count)
     : op_(op),
       mark_(0),
       id_(id),
       bit_field_(InputCountField::encode(input_count) |
                  ReservedInputCountField::encode(reserved_input_count) |
                  HasAppendableInputsField::encode(false)),
       first_use_(nullptr),
-      last_use_(nullptr) {}
+      last_use_(nullptr) {
+  inputs_.static_ = reinterpret_cast<Input*>(this + 1);
+}
 
 
 void Node::EnsureAppendableInputs(Zone* zone) {
   if (!has_appendable_inputs()) {
     void* deque_buffer = zone->New(sizeof(InputDeque));
     InputDeque* deque = new (deque_buffer) InputDeque(zone);
     for (int i = 0; i < input_count(); ++i) {
       deque->push_back(inputs_.static_[i]);
     }
     inputs_.appendable_ = deque;
@@ skipping 78 matching lines @@
   ++(*this);
   return result;
 }
 
 
 bool Node::Uses::empty() const { return begin() == end(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8