[interpreter] Introduce bytecode generation pipeline.

src/interpreter/bytecode-array-writer.cc

Index: src/interpreter/bytecode-array-writer.cc
diff --git a/src/interpreter/bytecode-array-writer.cc b/src/interpreter/bytecode-array-writer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..05b5cce50244fa3c90ffb33629d9eef511179b6e
--- /dev/null
+++ b/src/interpreter/bytecode-array-writer.cc
@@ -0,0 +1,111 @@
+// Copyright 2015 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/interpreter/bytecode-array-writer.h"
+
+#include <iomanip>
+#include "src/interpreter/source-position-table.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+BytecodeArrayWriter::BytecodeArrayWriter(
+    Zone* zone, SourcePositionTableBuilder* source_position_table_builder)
+    : bytecodes_(zone),
+      frame_register_count_(0),
+      source_position_table_builder_(source_position_table_builder) {
+  bytecodes_.reserve(256);
+}
+
+// override
+BytecodeArrayWriter::~BytecodeArrayWriter() {}
+
+// override
+size_t BytecodeArrayWriter::FlushForOffset() { return bytecodes()->size(); }
+
+// override
+void BytecodeArrayWriter::Write(BytecodeNode* node) {
+  UpdateSourcePositionTable(node);
+  EmitBytecode(node);
+  node->Release();
+}
+
+void BytecodeArrayWriter::UpdateSourcePositionTable(
+    const BytecodeNode* const node) {
+  int bytecode_offset = static_cast<int>(bytecodes()->size());
+  const BytecodeSourceInfo& source_info = node->source_info();
+  if (source_info.is_valid()) {
+    if (source_info.is_statement()) {
+      source_position_table_builder_->AddStatementPosition(

[rmcilroy, 2016/05/10 11:14:09]

nit - maybe just update SourcePositionTableBuilder to have one
AddPosition(size_t bytecode_offset, int source_position, bool is_statemtent)?

[oth, 2016/05/11 13:17:30]

Done.

+          bytecode_offset, source_info.source_position());
+    } else {
+      source_position_table_builder_->AddExpressionPosition(
+          bytecode_offset, source_info.source_position());
+    }
+  }
+}
+
+void BytecodeArrayWriter::EmitBytecode(const BytecodeNode* const node) {
+  OperandScale operand_scale = node->operand_scale();
+  if (operand_scale != OperandScale::kSingle) {
+    Bytecode prefix = Bytecodes::OperandScaleToPrefixBytecode(operand_scale);
+    bytecodes()->push_back(Bytecodes::ToByte(prefix));
+  }
+
+  Bytecode bytecode = node->bytecode();
+  bytecodes()->push_back(Bytecodes::ToByte(bytecode));
+
+  int register_operand_bitmap = Bytecodes::GetRegisterOperandBitmap(bytecode);
+  const uint32_t* const operands = node->operands();
+  const OperandType* operand_types = Bytecodes::GetOperandTypes(bytecode);
+  for (int i = 0; operand_types[i] != OperandType::kNone; ++i) {
+    OperandType operand_type = operand_types[i];
+    switch (Bytecodes::SizeOfOperand(operand_type, operand_scale)) {
+      case OperandSize::kNone:
+        UNREACHABLE();
+        break;
+      case OperandSize::kByte:
+        bytecodes()->push_back(static_cast<uint8_t>(operands[i]));
+        break;
+      case OperandSize::kShort: {
+        uint8_t operand_bytes[2];
+        WriteUnalignedUInt16(operand_bytes, operands[i]);
+        bytecodes()->insert(bytecodes()->end(), operand_bytes,
+                            operand_bytes + 2);
+        break;
+      }
+      case OperandSize::kQuad: {
+        uint8_t operand_bytes[4];
+        WriteUnalignedUInt32(operand_bytes, operands[i]);
+        bytecodes()->insert(bytecodes()->end(), operand_bytes,
+                            operand_bytes + 4);
+        break;
+      }
+    }
+
+    if ((register_operand_bitmap >> i) & 1) {
+      int count;
+      if (operand_types[i + 1] == OperandType::kRegCount) {
+        count = static_cast<int>(operands[i + 1]);
+      } else {
+        count = Bytecodes::GetNumberOfRegistersRepresentedBy(operand_type);
+      }
+      Register reg = Register::FromOperand(static_cast<int32_t>(operands[i]));
+      frame_register_count_ =

[rmcilroy, 2016/05/10 11:14:09]

Nit - max_register_count_ ?

[oth, 2016/05/11 13:17:30]

Done.

+          std::max(frame_register_count_, reg.index() + count);
+    }
+  }
+}
+
+// override
+void BytecodeArrayWriter::LeaveBasicBlock() {}
+
+int BytecodeArrayWriter::GetMeasuredFrameSize() {

[rmcilroy, 2016/05/10 11:14:09]

nit - GetMaxRegisterCount() ?

[oth, 2016/05/11 13:17:30]

The emphasis is on measured. Returning the size rather than the count keeps the
point of use relatively clean.

[rmcilroy, 2016/05/12 12:15:13]

How about GetMaximumFrameSizeUsed()?

[rmcilroy, 2016/05/12 15:19:47]

Did you miss this comment, or prefer GetMeasuredFrameSize()?

[oth, 2016/05/12 15:44:31]

Done.

+  return frame_register_count_ * kPointerSize;
+}
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8