[interpreter] Introduce bytecode generation pipeline.

src/interpreter/bytecode-writer.cc

Index: src/interpreter/bytecode-writer.cc
diff --git a/src/interpreter/bytecode-writer.cc b/src/interpreter/bytecode-writer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7a6ada642d12c9c01756d31a0a41e8ab07ade2aa
--- /dev/null
+++ b/src/interpreter/bytecode-writer.cc
@@ -0,0 +1,235 @@
+// 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-writer.h"
+
+#include <iomanip>
+#include "src/interpreter/source-position-table.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+void BytecodeSourceInfo::Update(const BytecodeSourceInfo& entry) {
+  DCHECK(entry.is_valid());
+  if (!is_valid() || (entry.is_statement() && !is_statement()) ||
+      (entry.is_statement() && is_statement() &&
+       entry.source_position() > source_position())) {

[rmcilroy, 2016/05/06 15:25:48]

Could we get rid of the whole candidate_ source position entry logic in
source-position-table-builder now that this is dealt with here?

[oth, 2016/05/09 11:02:17]

Done.

+    // Position is updated if there is no existing position. Or the
+    // incoming position is a statement and the current position is an
+    // expression. Or we already have a statement and incoming
+    // statement is later. This last piece is needed for the first
+    // statement in a function.
+    source_position_ = entry.source_position_;
+    is_statement_ = entry.is_statement_;
+  }
+}
+
+BytecodeNode::BytecodeNode(BytecodeNodeAllocator* allocator)
+    : bytecode_(Bytecode::kIllegal),
+      operand_scale_(OperandScale::kSingle),
+      allocator_(allocator) {}
+
+void BytecodeNode::set_bytecode(Bytecode bytecode) {
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 0);
+  bytecode_ = bytecode;
+  operand_scale_ = OperandScale::kSingle;
+}
+
+void BytecodeNode::set_bytecode(Bytecode bytecode, uint32_t operand0,
+                                OperandScale operand_scale) {
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 1);
+  bytecode_ = bytecode;
+  operands_[0] = operand0;
+  operand_scale_ = operand_scale;
+}
+
+void BytecodeNode::set_bytecode(Bytecode bytecode, uint32_t operand0,
+                                uint32_t operand1, OperandScale operand_scale) {
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 2);
+  bytecode_ = bytecode;
+  operands_[0] = operand0;
+  operands_[1] = operand1;
+  operand_scale_ = operand_scale;
+}
+
+void BytecodeNode::set_bytecode(Bytecode bytecode, uint32_t operand0,
+                                uint32_t operand1, uint32_t operand2,
+                                OperandScale operand_scale) {
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 3);
+  bytecode_ = bytecode;
+  operands_[0] = operand0;
+  operands_[1] = operand1;
+  operands_[2] = operand2;
+  operand_scale_ = operand_scale;
+}
+
+void BytecodeNode::set_bytecode(Bytecode bytecode, uint32_t operand0,
+                                uint32_t operand1, uint32_t operand2,
+                                uint32_t operand3, OperandScale operand_scale) {
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 4);
+  bytecode_ = bytecode;
+  operands_[0] = operand0;
+  operands_[1] = operand1;
+  operands_[2] = operand2;
+  operands_[3] = operand3;
+  operand_scale_ = operand_scale;
+}
+
+size_t BytecodeNode::Size() const {
+  size_t size = Bytecodes::Size(bytecode_, operand_scale_);
+  if (Bytecodes::OperandScaleRequiresPrefixBytecode(operand_scale_)) {
+    size += 1;
+  }
+  return size;
+}
+
+void BytecodeNode::Release() {
+  bytecode_ = Bytecode::kIllegal;
+  source_info_.set_invalid();
+  allocator_->Release(this);
+}
+
+void BytecodeNode::Print(std::ostream& os) {

[rmcilroy, 2016/05/06 15:25:48]

Unused - is this useful for debugging?

[oth, 2016/05/09 11:02:17]

Yes, I'd opt to keep this around for a while.

+#ifdef DEBUG
+  std::ios saved_state(nullptr);
+  saved_state.copyfmt(os);
+
+  os << Bytecodes::ToString(bytecode_);
+  if (Bytecodes::OperandScaleRequiresPrefixBytecode(operand_scale_)) {
+    Bytecode scale_prefix =
+        Bytecodes::OperandScaleToPrefixBytecode(operand_scale_);
+    os << '.' << Bytecodes::ToString(scale_prefix);
+  }
+
+  for (int i = 0; i < operand_count(); ++i) {
+    os << ' ' << std::setw(8) << std::setfill('0') << std::hex << operands_[i];
+  }
+  os.copyfmt(saved_state);
+
+  if (source_info_.is_valid()) {
+    char type = source_info_.is_statement() ? 'S' : 'E';
+    os << ' ' << type << '@' << source_info_.source_position();
+  }
+  os << '\n';
+#endif  // DEBUG
+}
+
+BytecodeNode* BytecodeNodeAllocator::Allocate() {
+  if (free_list_ != nullptr) {
+    BytecodeNode* node = free_list_;
+    free_list_ = free_list_->next_;
+    return node;
+  } else {
+    DCHECK_LT(allocation_count_, kMaxDebugAllocations);
+    allocation_count_++;
+    return new (zone()) BytecodeNode(this);
+  }
+}
+
+void BytecodeNodeAllocator::Release(BytecodeNode* node) {
+  node->next_ = free_list_;
+  free_list_ = node;
+}
+
+FinalStageBytecodeWriter::FinalStageBytecodeWriter(
+    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
+FinalStageBytecodeWriter::~FinalStageBytecodeWriter() {}
+
+// override
+size_t FinalStageBytecodeWriter::FlushForOffset() {
+  return bytecodes()->size();
+}
+
+// override
+void FinalStageBytecodeWriter::Write(BytecodeNode* node) {
+  UpdateSourcePositionTable(node);
+  EmitBytecode(node);
+  node->Release();
+}
+
+void FinalStageBytecodeWriter::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(
+          bytecode_offset, source_info.source_position());
+    } else {
+      source_position_table_builder_->AddExpressionPosition(
+          bytecode_offset, source_info.source_position());
+    }
+  }
+}
+
+void FinalStageBytecodeWriter::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_ =
+          std::max(frame_register_count_, reg.index() + count);
+    }
+  }
+}
+
+// override
+void FinalStageBytecodeWriter::LeaveBasicBlock() {}
+
+int FinalStageBytecodeWriter::GetMeasuredFrameSize() {
+  return frame_register_count_ * kPointerSize;
+}
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8