Revision: 23681
Author: [email protected]
Date: Thu Sep 4 10:23:51 2014 UTC
Log: Move StructuredMachineAssembler into cctest suite.
[email protected]
Review URL: https://codereview.chromium.org/539903002
https://code.google.com/p/v8/source/detail?r=23681
Added:
/branches/bleeding_edge/test/cctest/compiler/structured-machine-assembler.cc
/branches/bleeding_edge/test/cctest/compiler/structured-machine-assembler.h
Deleted:
/branches/bleeding_edge/src/compiler/simplified-node-factory.h
/branches/bleeding_edge/src/compiler/structured-machine-assembler.cc
/branches/bleeding_edge/src/compiler/structured-machine-assembler.h
Modified:
/branches/bleeding_edge/BUILD.gn
/branches/bleeding_edge/test/cctest/cctest.gyp
/branches/bleeding_edge/test/cctest/compiler/codegen-tester.h
/branches/bleeding_edge/test/cctest/compiler/graph-builder-tester.h
/branches/bleeding_edge/test/cctest/compiler/simplified-graph-builder.cc
/branches/bleeding_edge/test/cctest/compiler/simplified-graph-builder.h
/branches/bleeding_edge/test/cctest/compiler/test-changes-lowering.cc
/branches/bleeding_edge/test/cctest/compiler/test-js-context-specialization.cc
/branches/bleeding_edge/test/cctest/compiler/test-simplified-lowering.cc
/branches/bleeding_edge/test/cctest/compiler/test-structured-machine-assembler.cc
/branches/bleeding_edge/tools/gyp/v8.gyp
=======================================
--- /dev/null
+++
/branches/bleeding_edge/test/cctest/compiler/structured-machine-assembler.cc
Thu Sep 4 10:23:51 2014 UTC
@@ -0,0 +1,664 @@
+// Copyright 2014 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/pipeline.h"
+#include "src/compiler/scheduler.h"
+#include "test/cctest/compiler/structured-machine-assembler.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+Node* Variable::Get() const { return smasm_->GetVariable(offset_); }
+
+
+void Variable::Set(Node* value) const { smasm_->SetVariable(offset_,
value); }
+
+
+StructuredMachineAssembler::StructuredMachineAssembler(
+ Graph* graph, MachineSignature* machine_sig, MachineType word)
+ : GraphBuilder(graph),
+ schedule_(new (zone()) Schedule(zone())),
+ machine_(zone(), word),
+ common_(zone()),
+ machine_sig_(machine_sig),
+ call_descriptor_(
+ Linkage::GetSimplifiedCDescriptor(graph->zone(), machine_sig)),
+ parameters_(NULL),
+ current_environment_(new (zone())
+ Environment(zone(), schedule()->start(),
false)),
+ number_of_variables_(0) {
+ int param_count = static_cast<int>(parameter_count());
+ Node* s = graph->NewNode(common_.Start(param_count));
+ graph->SetStart(s);
+ if (parameter_count() == 0) return;
+ parameters_ = zone()->NewArray<Node*>(param_count);
+ for (size_t i = 0; i < parameter_count(); ++i) {
+ parameters_[i] =
+ NewNode(common()->Parameter(static_cast<int>(i)), graph->start());
+ }
+}
+
+
+Schedule* StructuredMachineAssembler::Export() {
+ // Compute the correct codegen order.
+ DCHECK(schedule_->rpo_order()->empty());
+ Scheduler::ComputeSpecialRPO(schedule_);
+ // Invalidate MachineAssembler.
+ Schedule* schedule = schedule_;
+ schedule_ = NULL;
+ return schedule;
+}
+
+
+Node* StructuredMachineAssembler::Parameter(size_t index) {
+ DCHECK(index < parameter_count());
+ return parameters_[index];
+}
+
+
+Node* StructuredMachineAssembler::MakeNode(Operator* op, int input_count,
+ Node** inputs) {
+ DCHECK(ScheduleValid());
+ DCHECK(current_environment_ != NULL);
+ Node* node = graph()->NewNode(op, input_count, inputs);
+ BasicBlock* block = NULL;
+ switch (op->opcode()) {
+ case IrOpcode::kParameter:
+ case IrOpcode::kInt32Constant:
+ case IrOpcode::kInt64Constant:
+ case IrOpcode::kFloat64Constant:
+ case IrOpcode::kExternalConstant:
+ case IrOpcode::kNumberConstant:
+ case IrOpcode::kHeapConstant:
+ // Parameters and constants must be in start.
+ block = schedule()->start();
+ break;
+ default:
+ // Verify all leaf nodes handled above.
+ DCHECK((op->OutputCount() == 0) == (op->opcode() ==
IrOpcode::kStore));
+ block = current_environment_->block_;
+ break;
+ }
+ if (block != NULL) {
+ schedule()->AddNode(block, node);
+ }
+ return node;
+}
+
+
+Variable StructuredMachineAssembler::NewVariable(Node* initial_value) {
+ CHECK(initial_value != NULL);
+ int offset = number_of_variables_++;
+ // Extend current environment to correct number of values.
+ NodeVector* variables = CurrentVars();
+ size_t to_add = number_of_variables_ - variables->size();
+ if (to_add != 0) {
+ variables->reserve(number_of_variables_);
+ variables->insert(variables->end(), to_add, NULL);
+ }
+ variables->at(offset) = initial_value;
+ return Variable(this, offset);
+}
+
+
+Node* StructuredMachineAssembler::GetVariable(int offset) {
+ DCHECK(ScheduleValid());
+ return VariableAt(current_environment_, offset);
+}
+
+
+void StructuredMachineAssembler::SetVariable(int offset, Node* value) {
+ DCHECK(ScheduleValid());
+ Node*& ref = VariableAt(current_environment_, offset);
+ ref = value;
+}
+
+
+Node*& StructuredMachineAssembler::VariableAt(Environment* environment,
+ int32_t offset) {
+ // Variable used out of scope.
+ CHECK(static_cast<size_t>(offset) < environment->variables_.size());
+ Node*& value = environment->variables_.at(offset);
+ CHECK(value != NULL); // Variable used out of scope.
+ return value;
+}
+
+
+void StructuredMachineAssembler::Return(Node* value) {
+ BasicBlock* block = current_environment_->block_;
+ if (block != NULL) {
+ schedule()->AddReturn(block, value);
+ }
+ CopyCurrentAsDead();
+}
+
+
+void StructuredMachineAssembler::CopyCurrentAsDead() {
+ DCHECK(current_environment_ != NULL);
+ bool is_dead = current_environment_->is_dead_;
+ current_environment_->is_dead_ = true;
+ Environment* next = Copy(current_environment_);
+ current_environment_->is_dead_ = is_dead;
+ current_environment_ = next;
+}
+
+
+StructuredMachineAssembler::Environment* StructuredMachineAssembler::Copy(
+ Environment* env, int truncate_at) {
+ Environment* new_env = new (zone()) Environment(zone(), NULL,
env->is_dead_);
+ if (!new_env->is_dead_) {
+ new_env->block_ = schedule()->NewBasicBlock();
+ }
+ new_env->variables_.reserve(truncate_at);
+ NodeVectorIter end = env->variables_.end();
+ DCHECK(truncate_at <= static_cast<int>(env->variables_.size()));
+ end -= static_cast<int>(env->variables_.size()) - truncate_at;
+ new_env->variables_.insert(new_env->variables_.begin(),
+ env->variables_.begin(), end);
+ return new_env;
+}
+
+
+StructuredMachineAssembler::Environment*
+StructuredMachineAssembler::CopyForLoopHeader(Environment* env) {
+ Environment* new_env = new (zone()) Environment(zone(), NULL,
env->is_dead_);
+ if (!new_env->is_dead_) {
+ new_env->block_ = schedule()->NewBasicBlock();
+ }
+ new_env->variables_.reserve(env->variables_.size());
+ for (NodeVectorIter i = env->variables_.begin(); i !=
env->variables_.end();
+ ++i) {
+ Node* phi = NULL;
+ if (*i != NULL) {
+ phi = graph()->NewNode(common()->Phi(1), *i);
+ if (new_env->block_ != NULL) {
+ schedule()->AddNode(new_env->block_, phi);
+ }
+ }
+ new_env->variables_.push_back(phi);
+ }
+ return new_env;
+}
+
+
+void StructuredMachineAssembler::MergeBackEdgesToLoopHeader(
+ Environment* header, EnvironmentVector* environments) {
+ // Only merge as many variables are were declared before this loop.
+ int n = static_cast<int>(header->variables_.size());
+ // TODO(dcarney): invert loop order and extend phis once.
+ for (EnvironmentVector::iterator i = environments->begin();
+ i != environments->end(); ++i) {
+ Environment* from = *i;
+ if (from->is_dead_) continue;
+ AddGoto(from, header);
+ for (int i = 0; i < n; ++i) {
+ Node* phi = header->variables_[i];
+ if (phi == NULL) continue;
+ phi->set_op(common()->Phi(phi->InputCount() + 1));
+ phi->AppendInput(zone(), VariableAt(from, i));
+ }
+ }
+}
+
+
+void StructuredMachineAssembler::Merge(EnvironmentVector* environments,
+ int truncate_at) {
+ DCHECK(current_environment_ == NULL || current_environment_->is_dead_);
+ Environment* next = new (zone()) Environment(zone(), NULL, false);
+ current_environment_ = next;
+ size_t n_vars = number_of_variables_;
+ NodeVector& vars = next->variables_;
+ vars.reserve(n_vars);
+ Node** scratch = NULL;
+ size_t n_envs = environments->size();
+ Environment** live_environments =
+ zone()->NewArray<Environment*>(static_cast<int>(n_envs));
+ size_t n_live = 0;
+ for (size_t i = 0; i < n_envs; i++) {
+ if (environments->at(i)->is_dead_) continue;
+ live_environments[n_live++] = environments->at(i);
+ }
+ n_envs = n_live;
+ if (n_live == 0) next->is_dead_ = true;
+ if (!next->is_dead_) {
+ next->block_ = schedule()->NewBasicBlock();
+ }
+ for (size_t j = 0; j < n_vars; ++j) {
+ Node* resolved = NULL;
+ // Find first non equal variable.
+ size_t i = 0;
+ for (; i < n_envs; i++) {
+ DCHECK(live_environments[i]->variables_.size() <= n_vars);
+ Node* val = NULL;
+ if (j < static_cast<size_t>(truncate_at)) {
+ val = live_environments[i]->variables_.at(j);
+ // TODO(dcarney): record start position at time of split.
+ // all variables after this should not be NULL.
+ if (val != NULL) {
+ val = VariableAt(live_environments[i], static_cast<int>(j));
+ }
+ }
+ if (val == resolved) continue;
+ if (i != 0) break;
+ resolved = val;
+ }
+ // Have to generate a phi.
+ if (i < n_envs) {
+ // All values thus far uninitialized, variable used out of scope.
+ CHECK(resolved != NULL);
+ // Init scratch buffer.
+ if (scratch == NULL) {
+ scratch = zone()->NewArray<Node*>(static_cast<int>(n_envs));
+ }
+ for (size_t k = 0; k < i; k++) {
+ scratch[k] = resolved;
+ }
+ for (; i < n_envs; i++) {
+ scratch[i] = live_environments[i]->variables_[j];
+ }
+ resolved = graph()->NewNode(common()->Phi(static_cast<int>(n_envs)),
+ static_cast<int>(n_envs), scratch);
+ if (next->block_ != NULL) {
+ schedule()->AddNode(next->block_, resolved);
+ }
+ }
+ vars.push_back(resolved);
+ }
+}
+
+
+void StructuredMachineAssembler::AddGoto(Environment* from, Environment*
to) {
+ if (to->is_dead_) {
+ DCHECK(from->is_dead_);
+ return;
+ }
+ DCHECK(!from->is_dead_);
+ schedule()->AddGoto(from->block_, to->block_);
+}
+
+
+// TODO(dcarney): add pass before rpo to schedule to compute these.
+BasicBlock* StructuredMachineAssembler::TrampolineFor(BasicBlock* block) {
+ BasicBlock* trampoline = schedule()->NewBasicBlock();
+ schedule()->AddGoto(trampoline, block);
+ return trampoline;
+}
+
+
+void StructuredMachineAssembler::AddBranch(Environment* environment,
+ Node* condition,
+ Environment* true_val,
+ Environment* false_val) {
+ DCHECK(environment->is_dead_ == true_val->is_dead_);
+ DCHECK(environment->is_dead_ == false_val->is_dead_);
+ if (true_val->block_ == false_val->block_) {
+ if (environment->is_dead_) return;
+ AddGoto(environment, true_val);
+ return;
+ }
+ Node* branch = graph()->NewNode(common()->Branch(), condition);
+ if (environment->is_dead_) return;
+ BasicBlock* true_block = TrampolineFor(true_val->block_);
+ BasicBlock* false_block = TrampolineFor(false_val->block_);
+ schedule()->AddBranch(environment->block_, branch, true_block,
false_block);
+}
+
+
+StructuredMachineAssembler::Environment::Environment(Zone* zone,
+ BasicBlock* block,
+ bool is_dead)
+ : block_(block), variables_(zone), is_dead_(is_dead) {}
+
+
+StructuredMachineAssembler::IfBuilder::IfBuilder(
+ StructuredMachineAssembler* smasm)
+ : smasm_(smasm),
+ if_clauses_(smasm_->zone()),
+ pending_exit_merges_(smasm_->zone()) {
+ DCHECK(smasm_->current_environment_ != NULL);
+ PushNewIfClause();
+ DCHECK(!IsDone());
+}
+
+
+StructuredMachineAssembler::IfBuilder&
+StructuredMachineAssembler::IfBuilder::If() {
+ DCHECK(smasm_->current_environment_ != NULL);
+ IfClause* clause = CurrentClause();
+ if (clause->then_environment_ != NULL || clause->else_environment_ !=
NULL) {
+ PushNewIfClause();
+ }
+ return *this;
+}
+
+
+StructuredMachineAssembler::IfBuilder&
+StructuredMachineAssembler::IfBuilder::If(Node* condition) {
+ If();
+ IfClause* clause = CurrentClause();
+ // Store branch for future resolution.
+ UnresolvedBranch* next = new (smasm_->zone())
+ UnresolvedBranch(smasm_->current_environment_, condition, NULL);
+ if (clause->unresolved_list_tail_ != NULL) {
+ clause->unresolved_list_tail_->next_ = next;
+ }
+ clause->unresolved_list_tail_ = next;
+ // Push onto merge queues.
+ clause->pending_else_merges_.push_back(next);
+ clause->pending_then_merges_.push_back(next);
+ smasm_->current_environment_ = NULL;
+ return *this;
+}
+
+
+void StructuredMachineAssembler::IfBuilder::And() {
+ CurrentClause()->ResolvePendingMerges(smasm_, kCombineThen,
kExpressionTerm);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::Or() {
+ CurrentClause()->ResolvePendingMerges(smasm_, kCombineElse,
kExpressionTerm);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::Then() {
+ CurrentClause()->ResolvePendingMerges(smasm_, kCombineThen,
kExpressionDone);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::Else() {
+ AddCurrentToPending();
+ CurrentClause()->ResolvePendingMerges(smasm_, kCombineElse,
kExpressionDone);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::AddCurrentToPending() {
+ if (smasm_->current_environment_ != NULL &&
+ !smasm_->current_environment_->is_dead_) {
+ pending_exit_merges_.push_back(smasm_->current_environment_);
+ }
+ smasm_->current_environment_ = NULL;
+}
+
+
+void StructuredMachineAssembler::IfBuilder::PushNewIfClause() {
+ int curr_size =
+ static_cast<int>(smasm_->current_environment_->variables_.size());
+ IfClause* clause = new (smasm_->zone()) IfClause(smasm_->zone(),
curr_size);
+ if_clauses_.push_back(clause);
+}
+
+
+StructuredMachineAssembler::IfBuilder::IfClause::IfClause(
+ Zone* zone, int initial_environment_size)
+ : unresolved_list_tail_(NULL),
+ initial_environment_size_(initial_environment_size),
+ expression_states_(zone),
+ pending_then_merges_(zone),
+ pending_else_merges_(zone),
+ then_environment_(NULL),
+ else_environment_(NULL) {
+ PushNewExpressionState();
+}
+
+
+StructuredMachineAssembler::IfBuilder::PendingMergeStackRange
+StructuredMachineAssembler::IfBuilder::IfClause::ComputeRelevantMerges(
+ CombineType combine_type) {
+ DCHECK(!expression_states_.empty());
+ PendingMergeStack* stack;
+ int start;
+ if (combine_type == kCombineThen) {
+ stack = &pending_then_merges_;
+ start = expression_states_.back().pending_then_size_;
+ } else {
+ DCHECK(combine_type == kCombineElse);
+ stack = &pending_else_merges_;
+ start = expression_states_.back().pending_else_size_;
+ }
+ PendingMergeStackRange data;
+ data.merge_stack_ = stack;
+ data.start_ = start;
+ data.size_ = static_cast<int>(stack->size()) - start;
+ return data;
+}
+
+
+void StructuredMachineAssembler::IfBuilder::IfClause::ResolvePendingMerges(
+ StructuredMachineAssembler* smasm, CombineType combine_type,
+ ResolutionType resolution_type) {
+ DCHECK(smasm->current_environment_ == NULL);
+ PendingMergeStackRange data = ComputeRelevantMerges(combine_type);
+ DCHECK_EQ(data.merge_stack_->back(), unresolved_list_tail_);
+ DCHECK(data.size_ > 0);
+ // TODO(dcarney): assert no new variables created during expression
building.
+ int truncate_at = initial_environment_size_;
+ if (data.size_ == 1) {
+ // Just copy environment in common case.
+ smasm->current_environment_ =
+ smasm->Copy(unresolved_list_tail_->environment_, truncate_at);
+ } else {
+ EnvironmentVector environments(smasm->zone());
+ environments.reserve(data.size_);
+ CopyEnvironments(data, &environments);
+ DCHECK(static_cast<int>(environments.size()) == data.size_);
+ smasm->Merge(&environments, truncate_at);
+ }
+ Environment* then_environment = then_environment_;
+ Environment* else_environment = NULL;
+ if (resolution_type == kExpressionDone) {
+ DCHECK(expression_states_.size() == 1);
+ // Set the current then_ or else_environment_ to the new merged
environment.
+ if (combine_type == kCombineThen) {
+ DCHECK(then_environment_ == NULL && else_environment_ == NULL);
+ this->then_environment_ = smasm->current_environment_;
+ } else {
+ DCHECK(else_environment_ == NULL);
+ this->else_environment_ = smasm->current_environment_;
+ }
+ } else {
+ DCHECK(resolution_type == kExpressionTerm);
+ DCHECK(then_environment_ == NULL && else_environment_ == NULL);
+ }
+ if (combine_type == kCombineThen) {
+ then_environment = smasm->current_environment_;
+ } else {
+ DCHECK(combine_type == kCombineElse);
+ else_environment = smasm->current_environment_;
+ }
+ // Finalize branches and clear the pending stack.
+ FinalizeBranches(smasm, data, combine_type, then_environment,
+ else_environment);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::IfClause::CopyEnvironments(
+ const PendingMergeStackRange& data, EnvironmentVector* environments) {
+ PendingMergeStack::iterator i = data.merge_stack_->begin();
+ PendingMergeStack::iterator end = data.merge_stack_->end();
+ for (i += data.start_; i != end; ++i) {
+ environments->push_back((*i)->environment_);
+ }
+}
+
+
+void
StructuredMachineAssembler::IfBuilder::IfClause::PushNewExpressionState() {
+ ExpressionState next;
+ next.pending_then_size_ = static_cast<int>(pending_then_merges_.size());
+ next.pending_else_size_ = static_cast<int>(pending_else_merges_.size());
+ expression_states_.push_back(next);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::IfClause::PopExpressionState()
{
+ expression_states_.pop_back();
+ DCHECK(!expression_states_.empty());
+}
+
+
+void StructuredMachineAssembler::IfBuilder::IfClause::FinalizeBranches(
+ StructuredMachineAssembler* smasm, const PendingMergeStackRange& data,
+ CombineType combine_type, Environment* const then_environment,
+ Environment* const else_environment) {
+ DCHECK(unresolved_list_tail_ != NULL);
+ DCHECK(smasm->current_environment_ != NULL);
+ if (data.size_ == 0) return;
+ PendingMergeStack::iterator curr = data.merge_stack_->begin();
+ PendingMergeStack::iterator end = data.merge_stack_->end();
+ // Finalize everything but the head first,
+ // in the order the branches enter the merge block.
+ end -= 1;
+ Environment* true_val = then_environment;
+ Environment* false_val = else_environment;
+ Environment** next;
+ if (combine_type == kCombineThen) {
+ next = &false_val;
+ } else {
+ DCHECK(combine_type == kCombineElse);
+ next = &true_val;
+ }
+ for (curr += data.start_; curr != end; ++curr) {
+ UnresolvedBranch* branch = *curr;
+ *next = branch->next_->environment_;
+ smasm->AddBranch(branch->environment_, branch->condition_, true_val,
+ false_val);
+ }
+ DCHECK(curr + 1 == data.merge_stack_->end());
+ // Now finalize the tail if possible.
+ if (then_environment != NULL && else_environment != NULL) {
+ UnresolvedBranch* branch = *curr;
+ smasm->AddBranch(branch->environment_, branch->condition_,
then_environment,
+ else_environment);
+ }
+ // Clear the merge stack.
+ PendingMergeStack::iterator begin = data.merge_stack_->begin();
+ begin += data.start_;
+ data.merge_stack_->erase(begin, data.merge_stack_->end());
+ DCHECK_EQ(static_cast<int>(data.merge_stack_->size()), data.start_);
+}
+
+
+void StructuredMachineAssembler::IfBuilder::End() {
+ DCHECK(!IsDone());
+ AddCurrentToPending();
+ size_t current_pending = pending_exit_merges_.size();
+ // All unresolved branch edges are now set to pending.
+ for (IfClauses::iterator i = if_clauses_.begin(); i != if_clauses_.end();
+ ++i) {
+ IfClause* clause = *i;
+ DCHECK(clause->expression_states_.size() == 1);
+ PendingMergeStackRange data;
+ // Copy then environments.
+ data = clause->ComputeRelevantMerges(kCombineThen);
+ clause->CopyEnvironments(data, &pending_exit_merges_);
+ Environment* head = NULL;
+ // Will resolve the head node in the else_merge
+ if (data.size_ > 0 && clause->then_environment_ == NULL &&
+ clause->else_environment_ == NULL) {
+ head = pending_exit_merges_.back();
+ pending_exit_merges_.pop_back();
+ }
+ // Copy else environments.
+ data = clause->ComputeRelevantMerges(kCombineElse);
+ clause->CopyEnvironments(data, &pending_exit_merges_);
+ if (head != NULL) {
+ // Must have data to merge, or else head will never get a branch.
+ DCHECK(data.size_ != 0);
+ pending_exit_merges_.push_back(head);
+ }
+ }
+ smasm_->Merge(&pending_exit_merges_,
+ if_clauses_[0]->initial_environment_size_);
+ // Anything initally pending jumps into the new environment.
+ for (size_t i = 0; i < current_pending; ++i) {
+ smasm_->AddGoto(pending_exit_merges_[i], smasm_->current_environment_);
+ }
+ // Resolve all branches.
+ for (IfClauses::iterator i = if_clauses_.begin(); i != if_clauses_.end();
+ ++i) {
+ IfClause* clause = *i;
+ // Must finalize all environments, so ensure they are set correctly.
+ Environment* then_environment = clause->then_environment_;
+ if (then_environment == NULL) {
+ then_environment = smasm_->current_environment_;
+ }
+ Environment* else_environment = clause->else_environment_;
+ PendingMergeStackRange data;
+ // Finalize then environments.
+ data = clause->ComputeRelevantMerges(kCombineThen);
+ clause->FinalizeBranches(smasm_, data, kCombineThen, then_environment,
+ else_environment);
+ // Finalize else environments.
+ // Now set the else environment so head is finalized for edge case
above.
+ if (else_environment == NULL) {
+ else_environment = smasm_->current_environment_;
+ }
+ data = clause->ComputeRelevantMerges(kCombineElse);
+ clause->FinalizeBranches(smasm_, data, kCombineElse, then_environment,
+ else_environment);
+ }
+ // Future accesses to this builder should crash immediately.
+ pending_exit_merges_.clear();
+ if_clauses_.clear();
+ DCHECK(IsDone());
+}
+
+
+StructuredMachineAssembler::LoopBuilder::LoopBuilder(
+ StructuredMachineAssembler* smasm)
+ : smasm_(smasm),
+ header_environment_(NULL),
+ pending_header_merges_(smasm_->zone()),
+ pending_exit_merges_(smasm_->zone()) {
+ DCHECK(smasm_->current_environment_ != NULL);
+ // Create header environment.
+ header_environment_ =
smasm_->CopyForLoopHeader(smasm_->current_environment_);
+ smasm_->AddGoto(smasm_->current_environment_, header_environment_);
+ // Create body environment.
+ Environment* body = smasm_->Copy(header_environment_);
+ smasm_->AddGoto(header_environment_, body);
+ smasm_->current_environment_ = body;
+ DCHECK(!IsDone());
+}
+
+
+void StructuredMachineAssembler::LoopBuilder::Continue() {
+ DCHECK(!IsDone());
+ pending_header_merges_.push_back(smasm_->current_environment_);
+ smasm_->CopyCurrentAsDead();
+}
+
+
+void StructuredMachineAssembler::LoopBuilder::Break() {
+ DCHECK(!IsDone());
+ pending_exit_merges_.push_back(smasm_->current_environment_);
+ smasm_->CopyCurrentAsDead();
+}
+
+
+void StructuredMachineAssembler::LoopBuilder::End() {
+ DCHECK(!IsDone());
+ if (smasm_->current_environment_ != NULL) {
+ Continue();
+ }
+ // Do loop header merges.
+ smasm_->MergeBackEdgesToLoopHeader(header_environment_,
+ &pending_header_merges_);
+ int initial_size =
static_cast<int>(header_environment_->variables_.size());
+ // Do loop exit merges, truncating loop variables away.
+ smasm_->Merge(&pending_exit_merges_, initial_size);
+ for (EnvironmentVector::iterator i = pending_exit_merges_.begin();
+ i != pending_exit_merges_.end(); ++i) {
+ smasm_->AddGoto(*i, smasm_->current_environment_);
+ }
+ pending_header_merges_.clear();
+ pending_exit_merges_.clear();
+ header_environment_ = NULL;
+ DCHECK(IsDone());
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
=======================================
--- /dev/null
+++
/branches/bleeding_edge/test/cctest/compiler/structured-machine-assembler.h
Thu Sep 4 10:23:51 2014 UTC
@@ -0,0 +1,299 @@
+// Copyright 2014 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_CCTEST_COMPILER_STRUCTURED_MACHINE_ASSEMBLER_H_
+#define V8_CCTEST_COMPILER_STRUCTURED_MACHINE_ASSEMBLER_H_
+
+#include "src/v8.h"
+
+#include "src/compiler/common-operator.h"
+#include "src/compiler/graph-builder.h"
+#include "src/compiler/machine-node-factory.h"
+#include "src/compiler/machine-operator.h"
+#include "src/compiler/node.h"
+#include "src/compiler/operator.h"
+
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+class BasicBlock;
+class Schedule;
+class StructuredMachineAssembler;
+
+
+class Variable : public ZoneObject {
+ public:
+ Node* Get() const;
+ void Set(Node* value) const;
+
+ private:
+ Variable(StructuredMachineAssembler* smasm, int offset)
+ : smasm_(smasm), offset_(offset) {}
+
+ friend class StructuredMachineAssembler;
+ friend class StructuredMachineAssemblerFriend;
+ StructuredMachineAssembler* const smasm_;
+ const int offset_;
+};
+
+
+class StructuredMachineAssembler
+ : public GraphBuilder,
+ public MachineNodeFactory<StructuredMachineAssembler> {
+ public:
+ class Environment : public ZoneObject {
+ public:
+ Environment(Zone* zone, BasicBlock* block, bool is_dead_);
+
+ private:
+ BasicBlock* block_;
+ NodeVector variables_;
+ bool is_dead_;
+ friend class StructuredMachineAssembler;
+ DISALLOW_COPY_AND_ASSIGN(Environment);
+ };
+
+ class IfBuilder;
+ friend class IfBuilder;
+ class LoopBuilder;
+ friend class LoopBuilder;
+
+ StructuredMachineAssembler(Graph* graph, MachineSignature* machine_sig,
+ MachineType word = kMachPtr);
+ virtual ~StructuredMachineAssembler() {}
+
+ Isolate* isolate() const { return zone()->isolate(); }
+ Zone* zone() const { return graph()->zone(); }
+ MachineOperatorBuilder* machine() { return &machine_; }
+ CommonOperatorBuilder* common() { return &common_; }
+ CallDescriptor* call_descriptor() const { return call_descriptor_; }
+ size_t parameter_count() const { return machine_sig_->parameter_count();
}
+ MachineSignature* machine_sig() const { return machine_sig_; }
+
+ // Parameters.
+ Node* Parameter(size_t index);
+ // Variables.
+ Variable NewVariable(Node* initial_value);
+ // Control flow.
+ void Return(Node* value);
+
+ // MachineAssembler is invalid after export.
+ Schedule* Export();
+
+ protected:
+ virtual Node* MakeNode(Operator* op, int input_count, Node** inputs);
+
+ Schedule* schedule() {
+ DCHECK(ScheduleValid());
+ return schedule_;
+ }
+
+ private:
+ bool ScheduleValid() { return schedule_ != NULL; }
+
+ typedef ZoneVector<Environment*> EnvironmentVector;
+
+ NodeVector* CurrentVars() { return ¤t_environment_->variables_; }
+ Node*& VariableAt(Environment* environment, int offset);
+ Node* GetVariable(int offset);
+ void SetVariable(int offset, Node* value);
+
+ void AddBranch(Environment* environment, Node* condition,
+ Environment* true_val, Environment* false_val);
+ void AddGoto(Environment* from, Environment* to);
+ BasicBlock* TrampolineFor(BasicBlock* block);
+
+ void CopyCurrentAsDead();
+ Environment* Copy(Environment* environment) {
+ return Copy(environment,
static_cast<int>(environment->variables_.size()));
+ }
+ Environment* Copy(Environment* environment, int truncate_at);
+ void Merge(EnvironmentVector* environments, int truncate_at);
+ Environment* CopyForLoopHeader(Environment* environment);
+ void MergeBackEdgesToLoopHeader(Environment* header,
+ EnvironmentVector* environments);
+
+ Schedule* schedule_;
+ MachineOperatorBuilder machine_;
+ CommonOperatorBuilder common_;
+ MachineSignature* machine_sig_;
+ CallDescriptor* call_descriptor_;
+ Node** parameters_;
+ Environment* current_environment_;
+ int number_of_variables_;
+
+ friend class Variable;
+ // For testing only.
+ friend class StructuredMachineAssemblerFriend;
+ DISALLOW_COPY_AND_ASSIGN(StructuredMachineAssembler);
+};
+
+// IfBuilder constructs of nested if-else expressions which more or less
follow
+// C semantics. Foe example:
+//
+// if (x) {do_x} else if (y) {do_y} else {do_z}
+//
+// would look like this:
+//
+// IfBuilder b;
+// b.If(x).Then();
+// do_x
+// b.Else();
+// b.If().Then();
+// do_y
+// b.Else();
+// do_z
+// b.End();
+//
+// Then() and Else() can be skipped, representing an empty block in C.
+// Combinations like If(x).Then().If(x).Then() are legitimate, but
+// Else().Else() is not. That is, once you've nested an If(), you can't
get to a
+// higher level If() branch.
+// TODO(dcarney): describe expressions once the api is finalized.
+class StructuredMachineAssembler::IfBuilder {
+ public:
+ explicit IfBuilder(StructuredMachineAssembler* smasm);
+ ~IfBuilder() {
+ if (!IsDone()) End();
+ }
+
+ IfBuilder& If(); // TODO(dcarney): this should take an expression.
+ IfBuilder& If(Node* condition);
+ void Then();
+ void Else();
+ void End();
+
+ // The next 4 functions are exposed for expression support.
+ // They will be private once I have a nice expression api.
+ void And();
+ void Or();
+ IfBuilder& OpenParen() {
+ DCHECK(smasm_->current_environment_ != NULL);
+ CurrentClause()->PushNewExpressionState();
+ return *this;
+ }
+ IfBuilder& CloseParen() {
+ DCHECK(smasm_->current_environment_ == NULL);
+ CurrentClause()->PopExpressionState();
+ return *this;
+ }
+
+ private:
+ // UnresolvedBranch represents the chain of environments created while
+ // generating an expression. At this point, a branch Node
+ // cannot be created, as the target environments of the branch are not
yet
+ // available, so everything required to create the branch Node is
+ // stored in this structure until the target environments are resolved.
+ struct UnresolvedBranch : public ZoneObject {
+ UnresolvedBranch(Environment* environment, Node* condition,
+ UnresolvedBranch* next)
+ : environment_(environment), condition_(condition), next_(next) {}
+ // environment_ will eventually be terminated by a branch on
condition_.
+ Environment* environment_;
+ Node* condition_;
+ // next_ is the next link in the UnresolvedBranch chain, and will be
+ // either the true or false branch jumped to from environment_.
+ UnresolvedBranch* next_;
+ };
+
+ struct ExpressionState {
+ int pending_then_size_;
+ int pending_else_size_;
+ };
+
+ typedef ZoneVector<ExpressionState> ExpressionStates;
+ typedef ZoneVector<UnresolvedBranch*> PendingMergeStack;
+ struct IfClause;
+ typedef ZoneVector<IfClause*> IfClauses;
+
+ struct PendingMergeStackRange {
+ PendingMergeStack* merge_stack_;
+ int start_;
+ int size_;
+ };
+
+ enum CombineType { kCombineThen, kCombineElse };
+ enum ResolutionType { kExpressionTerm, kExpressionDone };
+
+ // IfClause represents one level of if-then-else nesting plus the
associated
+ // expression.
+ // A call to If() triggers creation of a new nesting level after
expression
+ // creation is complete - ie Then() or Else() has been called.
+ struct IfClause : public ZoneObject {
+ IfClause(Zone* zone, int initial_environment_size);
+ void CopyEnvironments(const PendingMergeStackRange& data,
+ EnvironmentVector* environments);
+ void ResolvePendingMerges(StructuredMachineAssembler* smasm,
+ CombineType combine_type,
+ ResolutionType resolution_type);
+ PendingMergeStackRange ComputeRelevantMerges(CombineType combine_type);
+ void FinalizeBranches(StructuredMachineAssembler* smasm,
+ const PendingMergeStackRange& offset_data,
+ CombineType combine_type,
+ Environment* then_environment,
+ Environment* else_environment);
+ void PushNewExpressionState();
+ void PopExpressionState();
+
+ // Each invocation of And or Or creates a new UnresolvedBranch.
+ // These form a singly-linked list, of which we only need to keep
track of
+ // the tail. On creation of an UnresolvedBranch, pending_then_merges_
and
+ // pending_else_merges_ each push a copy, which are removed on merges
to the
+ // respective environment.
+ UnresolvedBranch* unresolved_list_tail_;
+ int initial_environment_size_;
+ // expression_states_ keeps track of the state of pending_*_merges_,
+ // pushing and popping the lengths of these on
+ // OpenParend() and CloseParend() respectively.
+ ExpressionStates expression_states_;
+ PendingMergeStack pending_then_merges_;
+ PendingMergeStack pending_else_merges_;
+ // then_environment_ is created iff there is a call to Then(),
otherwise
+ // branches which would merge to it merge to the exit environment
instead.
+ // Likewise for else_environment_.
+ Environment* then_environment_;
+ Environment* else_environment_;
+ };
+
+ IfClause* CurrentClause() { return if_clauses_.back(); }
+ void AddCurrentToPending();
+ void PushNewIfClause();
+ bool IsDone() { return if_clauses_.empty(); }
+
+ StructuredMachineAssembler* smasm_;
+ IfClauses if_clauses_;
+ EnvironmentVector pending_exit_merges_;
+ DISALLOW_COPY_AND_ASSIGN(IfBuilder);
+};
+
+
+class StructuredMachineAssembler::LoopBuilder {
+ public:
+ explicit LoopBuilder(StructuredMachineAssembler* smasm);
+ ~LoopBuilder() {
+ if (!IsDone()) End();
+ }
+
+ void Break();
+ void Continue();
+ void End();
+
+ private:
+ friend class StructuredMachineAssembler;
+ bool IsDone() { return header_environment_ == NULL; }
+
+ StructuredMachineAssembler* smasm_;
+ Environment* header_environment_;
+ EnvironmentVector pending_header_merges_;
+ EnvironmentVector pending_exit_merges_;
+ DISALLOW_COPY_AND_ASSIGN(LoopBuilder);
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_CCTEST_COMPILER_STRUCTURED_MACHINE_ASSEMBLER_H_
=======================================
--- /branches/bleeding_edge/src/compiler/simplified-node-factory.h Wed Jul
30 13:54:45 2014 UTC
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright 2014 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_COMPILER_SIMPLIFIED_NODE_FACTORY_H_
-#define V8_COMPILER_SIMPLIFIED_NODE_FACTORY_H_
-
-#include "src/compiler/node.h"
-#include "src/compiler/simplified-operator.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-#define SIMPLIFIED() static_cast<NodeFactory*>(this)->simplified()
-#define NEW_NODE_1(op, a) static_cast<NodeFactory*>(this)->NewNode(op, a)
-#define NEW_NODE_2(op, a, b) static_cast<NodeFactory*>(this)->NewNode(op,
a, b)
-#define NEW_NODE_3(op, a, b, c) \
- static_cast<NodeFactory*>(this)->NewNode(op, a, b, c)
-
-template <typename NodeFactory>
-class SimplifiedNodeFactory {
- public:
- Node* BooleanNot(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->BooleanNot(), a);
- }
-
- Node* NumberEqual(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberEqual(), a, b);
- }
- Node* NumberNotEqual(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberNotEqual(), a, b);
- }
- Node* NumberLessThan(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberLessThan(), a, b);
- }
- Node* NumberLessThanOrEqual(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberLessThanOrEqual(), a, b);
- }
- Node* NumberAdd(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberAdd(), a, b);
- }
- Node* NumberSubtract(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberSubtract(), a, b);
- }
- Node* NumberMultiply(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberMultiply(), a, b);
- }
- Node* NumberDivide(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberDivide(), a, b);
- }
- Node* NumberModulus(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->NumberModulus(), a, b);
- }
- Node* NumberToInt32(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->NumberToInt32(), a);
- }
- Node* NumberToUint32(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->NumberToUint32(), a);
- }
-
- Node* ReferenceEqual(Type* type, Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->ReferenceEqual(), a, b);
- }
-
- Node* StringEqual(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->StringEqual(), a, b);
- }
- Node* StringLessThan(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->StringLessThan(), a, b);
- }
- Node* StringLessThanOrEqual(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->StringLessThanOrEqual(), a, b);
- }
- Node* StringAdd(Node* a, Node* b) {
- return NEW_NODE_2(SIMPLIFIED()->StringAdd(), a, b);
- }
-
- Node* ChangeTaggedToInt32(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeTaggedToInt32(), a);
- }
- Node* ChangeTaggedToUint32(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeTaggedToUint32(), a);
- }
- Node* ChangeTaggedToFloat64(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeTaggedToFloat64(), a);
- }
- Node* ChangeInt32ToTagged(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeInt32ToTagged(), a);
- }
- Node* ChangeUint32ToTagged(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeUint32ToTagged(), a);
- }
- Node* ChangeFloat64ToTagged(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeFloat64ToTagged(), a);
- }
- Node* ChangeBoolToBit(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeBoolToBit(), a);
- }
- Node* ChangeBitToBool(Node* a) {
- return NEW_NODE_1(SIMPLIFIED()->ChangeBitToBool(), a);
- }
-
- Node* LoadField(const FieldAccess& access, Node* object) {
- return NEW_NODE_1(SIMPLIFIED()->LoadField(access), object);
- }
- Node* StoreField(const FieldAccess& access, Node* object, Node* value) {
- return NEW_NODE_2(SIMPLIFIED()->StoreField(access), object, value);
- }
- Node* LoadElement(const ElementAccess& access, Node* object, Node*
index) {
- return NEW_NODE_2(SIMPLIFIED()->LoadElement(access), object, index);
- }
- Node* StoreElement(const ElementAccess& access, Node* object, Node*
index,
- Node* value) {
- return NEW_NODE_3(SIMPLIFIED()->StoreElement(access), object, index,
value);
- }
-};
-
-#undef NEW_NODE_1
-#undef NEW_NODE_2
-#undef NEW_NODE_3
-#undef SIMPLIFIED
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
-
-#endif // V8_COMPILER_SIMPLIFIED_NODE_FACTORY_H_
=======================================
--- /branches/bleeding_edge/src/compiler/structured-machine-assembler.cc
Wed Sep 3 13:54:25 2014 UTC
+++ /dev/null
@@ -1,664 +0,0 @@
-// Copyright 2014 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/pipeline.h"
-#include "src/compiler/scheduler.h"
-#include "src/compiler/structured-machine-assembler.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-Node* Variable::Get() const { return smasm_->GetVariable(offset_); }
-
-
-void Variable::Set(Node* value) const { smasm_->SetVariable(offset_,
value); }
-
-
-StructuredMachineAssembler::StructuredMachineAssembler(
- Graph* graph, MachineSignature* machine_sig, MachineType word)
- : GraphBuilder(graph),
- schedule_(new (zone()) Schedule(zone())),
- machine_(zone(), word),
- common_(zone()),
- machine_sig_(machine_sig),
- call_descriptor_(
- Linkage::GetSimplifiedCDescriptor(graph->zone(), machine_sig)),
- parameters_(NULL),
- current_environment_(new (zone())
- Environment(zone(), schedule()->start(),
false)),
- number_of_variables_(0) {
- int param_count = static_cast<int>(parameter_count());
- Node* s = graph->NewNode(common_.Start(param_count));
- graph->SetStart(s);
- if (parameter_count() == 0) return;
- parameters_ = zone()->NewArray<Node*>(param_count);
- for (size_t i = 0; i < parameter_count(); ++i) {
- parameters_[i] =
- NewNode(common()->Parameter(static_cast<int>(i)), graph->start());
- }
-}
-
-
-Schedule* StructuredMachineAssembler::Export() {
- // Compute the correct codegen order.
- DCHECK(schedule_->rpo_order()->empty());
- Scheduler::ComputeSpecialRPO(schedule_);
- // Invalidate MachineAssembler.
- Schedule* schedule = schedule_;
- schedule_ = NULL;
- return schedule;
-}
-
-
-Node* StructuredMachineAssembler::Parameter(size_t index) {
- DCHECK(index < parameter_count());
- return parameters_[index];
-}
-
-
-Node* StructuredMachineAssembler::MakeNode(Operator* op, int input_count,
- Node** inputs) {
- DCHECK(ScheduleValid());
- DCHECK(current_environment_ != NULL);
- Node* node = graph()->NewNode(op, input_count, inputs);
- BasicBlock* block = NULL;
- switch (op->opcode()) {
- case IrOpcode::kParameter:
- case IrOpcode::kInt32Constant:
- case IrOpcode::kInt64Constant:
- case IrOpcode::kFloat64Constant:
- case IrOpcode::kExternalConstant:
- case IrOpcode::kNumberConstant:
- case IrOpcode::kHeapConstant:
- // Parameters and constants must be in start.
- block = schedule()->start();
- break;
- default:
- // Verify all leaf nodes handled above.
- DCHECK((op->OutputCount() == 0) == (op->opcode() ==
IrOpcode::kStore));
- block = current_environment_->block_;
- break;
- }
- if (block != NULL) {
- schedule()->AddNode(block, node);
- }
- return node;
-}
-
-
-Variable StructuredMachineAssembler::NewVariable(Node* initial_value) {
- CHECK(initial_value != NULL);
- int offset = number_of_variables_++;
- // Extend current environment to correct number of values.
- NodeVector* variables = CurrentVars();
- size_t to_add = number_of_variables_ - variables->size();
- if (to_add != 0) {
- variables->reserve(number_of_variables_);
- variables->insert(variables->end(), to_add, NULL);
- }
- variables->at(offset) = initial_value;
- return Variable(this, offset);
-}
-
-
-Node* StructuredMachineAssembler::GetVariable(int offset) {
- DCHECK(ScheduleValid());
- return VariableAt(current_environment_, offset);
-}
-
-
-void StructuredMachineAssembler::SetVariable(int offset, Node* value) {
- DCHECK(ScheduleValid());
- Node*& ref = VariableAt(current_environment_, offset);
- ref = value;
-}
-
-
-Node*& StructuredMachineAssembler::VariableAt(Environment* environment,
- int32_t offset) {
- // Variable used out of scope.
- CHECK(static_cast<size_t>(offset) < environment->variables_.size());
- Node*& value = environment->variables_.at(offset);
- CHECK(value != NULL); // Variable used out of scope.
- return value;
-}
-
-
-void StructuredMachineAssembler::Return(Node* value) {
- BasicBlock* block = current_environment_->block_;
- if (block != NULL) {
- schedule()->AddReturn(block, value);
- }
- CopyCurrentAsDead();
-}
-
-
-void StructuredMachineAssembler::CopyCurrentAsDead() {
- DCHECK(current_environment_ != NULL);
- bool is_dead = current_environment_->is_dead_;
- current_environment_->is_dead_ = true;
- Environment* next = Copy(current_environment_);
- current_environment_->is_dead_ = is_dead;
- current_environment_ = next;
-}
-
-
-StructuredMachineAssembler::Environment* StructuredMachineAssembler::Copy(
- Environment* env, int truncate_at) {
- Environment* new_env = new (zone()) Environment(zone(), NULL,
env->is_dead_);
- if (!new_env->is_dead_) {
- new_env->block_ = schedule()->NewBasicBlock();
- }
- new_env->variables_.reserve(truncate_at);
- NodeVectorIter end = env->variables_.end();
- DCHECK(truncate_at <= static_cast<int>(env->variables_.size()));
- end -= static_cast<int>(env->variables_.size()) - truncate_at;
- new_env->variables_.insert(new_env->variables_.begin(),
- env->variables_.begin(), end);
- return new_env;
-}
-
-
-StructuredMachineAssembler::Environment*
-StructuredMachineAssembler::CopyForLoopHeader(Environment* env) {
- Environment* new_env = new (zone()) Environment(zone(), NULL,
env->is_dead_);
- if (!new_env->is_dead_) {
- new_env->block_ = schedule()->NewBasicBlock();
- }
- new_env->variables_.reserve(env->variables_.size());
- for (NodeVectorIter i = env->variables_.begin(); i !=
env->variables_.end();
- ++i) {
- Node* phi = NULL;
- if (*i != NULL) {
- phi = graph()->NewNode(common()->Phi(1), *i);
- if (new_env->block_ != NULL) {
- schedule()->AddNode(new_env->block_, phi);
- }
- }
- new_env->variables_.push_back(phi);
- }
- return new_env;
-}
-
-
-void StructuredMachineAssembler::MergeBackEdgesToLoopHeader(
- Environment* header, EnvironmentVector* environments) {
- // Only merge as many variables are were declared before this loop.
- int n = static_cast<int>(header->variables_.size());
- // TODO(dcarney): invert loop order and extend phis once.
- for (EnvironmentVector::iterator i = environments->begin();
- i != environments->end(); ++i) {
- Environment* from = *i;
- if (from->is_dead_) continue;
- AddGoto(from, header);
- for (int i = 0; i < n; ++i) {
- Node* phi = header->variables_[i];
- if (phi == NULL) continue;
- phi->set_op(common()->Phi(phi->InputCount() + 1));
- phi->AppendInput(zone(), VariableAt(from, i));
- }
- }
-}
-
-
-void StructuredMachineAssembler::Merge(EnvironmentVector* environments,
- int truncate_at) {
- DCHECK(current_environment_ == NULL || current_environment_->is_dead_);
- Environment* next = new (zone()) Environment(zone(), NULL, false);
- current_environment_ = next;
- size_t n_vars = number_of_variables_;
- NodeVector& vars = next->variables_;
- vars.reserve(n_vars);
- Node** scratch = NULL;
- size_t n_envs = environments->size();
- Environment** live_environments =
- zone()->NewArray<Environment*>(static_cast<int>(n_envs));
- size_t n_live = 0;
- for (size_t i = 0; i < n_envs; i++) {
- if (environments->at(i)->is_dead_) continue;
- live_environments[n_live++] = environments->at(i);
- }
- n_envs = n_live;
- if (n_live == 0) next->is_dead_ = true;
- if (!next->is_dead_) {
- next->block_ = schedule()->NewBasicBlock();
- }
- for (size_t j = 0; j < n_vars; ++j) {
- Node* resolved = NULL;
- // Find first non equal variable.
- size_t i = 0;
- for (; i < n_envs; i++) {
- DCHECK(live_environments[i]->variables_.size() <= n_vars);
- Node* val = NULL;
- if (j < static_cast<size_t>(truncate_at)) {
- val = live_environments[i]->variables_.at(j);
- // TODO(dcarney): record start position at time of split.
- // all variables after this should not be NULL.
- if (val != NULL) {
- val = VariableAt(live_environments[i], static_cast<int>(j));
- }
- }
- if (val == resolved) continue;
- if (i != 0) break;
- resolved = val;
- }
- // Have to generate a phi.
- if (i < n_envs) {
- // All values thus far uninitialized, variable used out of scope.
- CHECK(resolved != NULL);
- // Init scratch buffer.
- if (scratch == NULL) {
- scratch = zone()->NewArray<Node*>(static_cast<int>(n_envs));
- }
- for (size_t k = 0; k < i; k++) {
- scratch[k] = resolved;
- }
- for (; i < n_envs; i++) {
- scratch[i] = live_environments[i]->variables_[j];
- }
- resolved = graph()->NewNode(common()->Phi(static_cast<int>(n_envs)),
- static_cast<int>(n_envs), scratch);
- if (next->block_ != NULL) {
- schedule()->AddNode(next->block_, resolved);
- }
- }
- vars.push_back(resolved);
- }
-}
-
-
-void StructuredMachineAssembler::AddGoto(Environment* from, Environment*
to) {
- if (to->is_dead_) {
- DCHECK(from->is_dead_);
- return;
- }
- DCHECK(!from->is_dead_);
- schedule()->AddGoto(from->block_, to->block_);
-}
-
-
-// TODO(dcarney): add pass before rpo to schedule to compute these.
-BasicBlock* StructuredMachineAssembler::TrampolineFor(BasicBlock* block) {
- BasicBlock* trampoline = schedule()->NewBasicBlock();
- schedule()->AddGoto(trampoline, block);
- return trampoline;
-}
-
-
-void StructuredMachineAssembler::AddBranch(Environment* environment,
- Node* condition,
- Environment* true_val,
- Environment* false_val) {
- DCHECK(environment->is_dead_ == true_val->is_dead_);
- DCHECK(environment->is_dead_ == false_val->is_dead_);
- if (true_val->block_ == false_val->block_) {
- if (environment->is_dead_) return;
- AddGoto(environment, true_val);
- return;
- }
- Node* branch = graph()->NewNode(common()->Branch(), condition);
- if (environment->is_dead_) return;
- BasicBlock* true_block = TrampolineFor(true_val->block_);
- BasicBlock* false_block = TrampolineFor(false_val->block_);
- schedule()->AddBranch(environment->block_, branch, true_block,
false_block);
-}
-
-
-StructuredMachineAssembler::Environment::Environment(Zone* zone,
- BasicBlock* block,
- bool is_dead)
- : block_(block), variables_(zone), is_dead_(is_dead) {}
-
-
-StructuredMachineAssembler::IfBuilder::IfBuilder(
- StructuredMachineAssembler* smasm)
- : smasm_(smasm),
- if_clauses_(smasm_->zone()),
- pending_exit_merges_(smasm_->zone()) {
- DCHECK(smasm_->current_environment_ != NULL);
- PushNewIfClause();
- DCHECK(!IsDone());
-}
-
-
-StructuredMachineAssembler::IfBuilder&
-StructuredMachineAssembler::IfBuilder::If() {
- DCHECK(smasm_->current_environment_ != NULL);
- IfClause* clause = CurrentClause();
- if (clause->then_environment_ != NULL || clause->else_environment_ !=
NULL) {
- PushNewIfClause();
- }
- return *this;
-}
-
-
-StructuredMachineAssembler::IfBuilder&
-StructuredMachineAssembler::IfBuilder::If(Node* condition) {
- If();
- IfClause* clause = CurrentClause();
- // Store branch for future resolution.
- UnresolvedBranch* next = new (smasm_->zone())
- UnresolvedBranch(smasm_->current_environment_, condition, NULL);
- if (clause->unresolved_list_tail_ != NULL) {
- clause->unresolved_list_tail_->next_ = next;
- }
- clause->unresolved_list_tail_ = next;
- // Push onto merge queues.
- clause->pending_else_merges_.push_back(next);
- clause->pending_then_merges_.push_back(next);
- smasm_->current_environment_ = NULL;
- return *this;
-}
-
-
-void StructuredMachineAssembler::IfBuilder::And() {
- CurrentClause()->ResolvePendingMerges(smasm_, kCombineThen,
kExpressionTerm);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::Or() {
- CurrentClause()->ResolvePendingMerges(smasm_, kCombineElse,
kExpressionTerm);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::Then() {
- CurrentClause()->ResolvePendingMerges(smasm_, kCombineThen,
kExpressionDone);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::Else() {
- AddCurrentToPending();
- CurrentClause()->ResolvePendingMerges(smasm_, kCombineElse,
kExpressionDone);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::AddCurrentToPending() {
- if (smasm_->current_environment_ != NULL &&
- !smasm_->current_environment_->is_dead_) {
- pending_exit_merges_.push_back(smasm_->current_environment_);
- }
- smasm_->current_environment_ = NULL;
-}
-
-
-void StructuredMachineAssembler::IfBuilder::PushNewIfClause() {
- int curr_size =
- static_cast<int>(smasm_->current_environment_->variables_.size());
- IfClause* clause = new (smasm_->zone()) IfClause(smasm_->zone(),
curr_size);
- if_clauses_.push_back(clause);
-}
-
-
-StructuredMachineAssembler::IfBuilder::IfClause::IfClause(
- Zone* zone, int initial_environment_size)
- : unresolved_list_tail_(NULL),
- initial_environment_size_(initial_environment_size),
- expression_states_(zone),
- pending_then_merges_(zone),
- pending_else_merges_(zone),
- then_environment_(NULL),
- else_environment_(NULL) {
- PushNewExpressionState();
-}
-
-
-StructuredMachineAssembler::IfBuilder::PendingMergeStackRange
-StructuredMachineAssembler::IfBuilder::IfClause::ComputeRelevantMerges(
- CombineType combine_type) {
- DCHECK(!expression_states_.empty());
- PendingMergeStack* stack;
- int start;
- if (combine_type == kCombineThen) {
- stack = &pending_then_merges_;
- start = expression_states_.back().pending_then_size_;
- } else {
- DCHECK(combine_type == kCombineElse);
- stack = &pending_else_merges_;
- start = expression_states_.back().pending_else_size_;
- }
- PendingMergeStackRange data;
- data.merge_stack_ = stack;
- data.start_ = start;
- data.size_ = static_cast<int>(stack->size()) - start;
- return data;
-}
-
-
-void StructuredMachineAssembler::IfBuilder::IfClause::ResolvePendingMerges(
- StructuredMachineAssembler* smasm, CombineType combine_type,
- ResolutionType resolution_type) {
- DCHECK(smasm->current_environment_ == NULL);
- PendingMergeStackRange data = ComputeRelevantMerges(combine_type);
- DCHECK_EQ(data.merge_stack_->back(), unresolved_list_tail_);
- DCHECK(data.size_ > 0);
- // TODO(dcarney): assert no new variables created during expression
building.
- int truncate_at = initial_environment_size_;
- if (data.size_ == 1) {
- // Just copy environment in common case.
- smasm->current_environment_ =
- smasm->Copy(unresolved_list_tail_->environment_, truncate_at);
- } else {
- EnvironmentVector environments(smasm->zone());
- environments.reserve(data.size_);
- CopyEnvironments(data, &environments);
- DCHECK(static_cast<int>(environments.size()) == data.size_);
- smasm->Merge(&environments, truncate_at);
- }
- Environment* then_environment = then_environment_;
- Environment* else_environment = NULL;
- if (resolution_type == kExpressionDone) {
- DCHECK(expression_states_.size() == 1);
- // Set the current then_ or else_environment_ to the new merged
environment.
- if (combine_type == kCombineThen) {
- DCHECK(then_environment_ == NULL && else_environment_ == NULL);
- this->then_environment_ = smasm->current_environment_;
- } else {
- DCHECK(else_environment_ == NULL);
- this->else_environment_ = smasm->current_environment_;
- }
- } else {
- DCHECK(resolution_type == kExpressionTerm);
- DCHECK(then_environment_ == NULL && else_environment_ == NULL);
- }
- if (combine_type == kCombineThen) {
- then_environment = smasm->current_environment_;
- } else {
- DCHECK(combine_type == kCombineElse);
- else_environment = smasm->current_environment_;
- }
- // Finalize branches and clear the pending stack.
- FinalizeBranches(smasm, data, combine_type, then_environment,
- else_environment);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::IfClause::CopyEnvironments(
- const PendingMergeStackRange& data, EnvironmentVector* environments) {
- PendingMergeStack::iterator i = data.merge_stack_->begin();
- PendingMergeStack::iterator end = data.merge_stack_->end();
- for (i += data.start_; i != end; ++i) {
- environments->push_back((*i)->environment_);
- }
-}
-
-
-void
StructuredMachineAssembler::IfBuilder::IfClause::PushNewExpressionState() {
- ExpressionState next;
- next.pending_then_size_ = static_cast<int>(pending_then_merges_.size());
- next.pending_else_size_ = static_cast<int>(pending_else_merges_.size());
- expression_states_.push_back(next);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::IfClause::PopExpressionState()
{
- expression_states_.pop_back();
- DCHECK(!expression_states_.empty());
-}
-
-
-void StructuredMachineAssembler::IfBuilder::IfClause::FinalizeBranches(
- StructuredMachineAssembler* smasm, const PendingMergeStackRange& data,
- CombineType combine_type, Environment* const then_environment,
- Environment* const else_environment) {
- DCHECK(unresolved_list_tail_ != NULL);
- DCHECK(smasm->current_environment_ != NULL);
- if (data.size_ == 0) return;
- PendingMergeStack::iterator curr = data.merge_stack_->begin();
- PendingMergeStack::iterator end = data.merge_stack_->end();
- // Finalize everything but the head first,
- // in the order the branches enter the merge block.
- end -= 1;
- Environment* true_val = then_environment;
- Environment* false_val = else_environment;
- Environment** next;
- if (combine_type == kCombineThen) {
- next = &false_val;
- } else {
- DCHECK(combine_type == kCombineElse);
- next = &true_val;
- }
- for (curr += data.start_; curr != end; ++curr) {
- UnresolvedBranch* branch = *curr;
- *next = branch->next_->environment_;
- smasm->AddBranch(branch->environment_, branch->condition_, true_val,
- false_val);
- }
- DCHECK(curr + 1 == data.merge_stack_->end());
- // Now finalize the tail if possible.
- if (then_environment != NULL && else_environment != NULL) {
- UnresolvedBranch* branch = *curr;
- smasm->AddBranch(branch->environment_, branch->condition_,
then_environment,
- else_environment);
- }
- // Clear the merge stack.
- PendingMergeStack::iterator begin = data.merge_stack_->begin();
- begin += data.start_;
- data.merge_stack_->erase(begin, data.merge_stack_->end());
- DCHECK_EQ(static_cast<int>(data.merge_stack_->size()), data.start_);
-}
-
-
-void StructuredMachineAssembler::IfBuilder::End() {
- DCHECK(!IsDone());
- AddCurrentToPending();
- size_t current_pending = pending_exit_merges_.size();
- // All unresolved branch edges are now set to pending.
- for (IfClauses::iterator i = if_clauses_.begin(); i != if_clauses_.end();
- ++i) {
- IfClause* clause = *i;
- DCHECK(clause->expression_states_.size() == 1);
- PendingMergeStackRange data;
- // Copy then environments.
- data = clause->ComputeRelevantMerges(kCombineThen);
- clause->CopyEnvironments(data, &pending_exit_merges_);
- Environment* head = NULL;
- // Will resolve the head node in the else_merge
- if (data.size_ > 0 && clause->then_environment_ == NULL &&
- clause->else_environment_ == NULL) {
- head = pending_exit_merges_.back();
- pending_exit_merges_.pop_back();
- }
- // Copy else environments.
- data = clause->ComputeRelevantMerges(kCombineElse);
- clause->CopyEnvironments(data, &pending_exit_merges_);
- if (head != NULL) {
- // Must have data to merge, or else head will never get a branch.
- DCHECK(data.size_ != 0);
- pending_exit_merges_.push_back(head);
- }
- }
- smasm_->Merge(&pending_exit_merges_,
- if_clauses_[0]->initial_environment_size_);
- // Anything initally pending jumps into the new environment.
- for (size_t i = 0; i < current_pending; ++i) {
- smasm_->AddGoto(pending_exit_merges_[i], smasm_->current_environment_);
- }
- // Resolve all branches.
- for (IfClauses::iterator i = if_clauses_.begin(); i != if_clauses_.end();
- ++i) {
- IfClause* clause = *i;
- // Must finalize all environments, so ensure they are set correctly.
- Environment* then_environment = clause->then_environment_;
- if (then_environment == NULL) {
- then_environment = smasm_->current_environment_;
- }
- Environment* else_environment = clause->else_environment_;
- PendingMergeStackRange data;
- // Finalize then environments.
- data = clause->ComputeRelevantMerges(kCombineThen);
- clause->FinalizeBranches(smasm_, data, kCombineThen, then_environment,
- else_environment);
- // Finalize else environments.
- // Now set the else environment so head is finalized for edge case
above.
- if (else_environment == NULL) {
- else_environment = smasm_->current_environment_;
- }
- data = clause->ComputeRelevantMerges(kCombineElse);
- clause->FinalizeBranches(smasm_, data, kCombineElse, then_environment,
- else_environment);
- }
- // Future accesses to this builder should crash immediately.
- pending_exit_merges_.clear();
- if_clauses_.clear();
- DCHECK(IsDone());
-}
-
-
-StructuredMachineAssembler::LoopBuilder::LoopBuilder(
- StructuredMachineAssembler* smasm)
- : smasm_(smasm),
- header_environment_(NULL),
- pending_header_merges_(smasm_->zone()),
- pending_exit_merges_(smasm_->zone()) {
- DCHECK(smasm_->current_environment_ != NULL);
- // Create header environment.
- header_environment_ =
smasm_->CopyForLoopHeader(smasm_->current_environment_);
- smasm_->AddGoto(smasm_->current_environment_, header_environment_);
- // Create body environment.
- Environment* body = smasm_->Copy(header_environment_);
- smasm_->AddGoto(header_environment_, body);
- smasm_->current_environment_ = body;
- DCHECK(!IsDone());
-}
-
-
-void StructuredMachineAssembler::LoopBuilder::Continue() {
- DCHECK(!IsDone());
- pending_header_merges_.push_back(smasm_->current_environment_);
- smasm_->CopyCurrentAsDead();
-}
-
-
-void StructuredMachineAssembler::LoopBuilder::Break() {
- DCHECK(!IsDone());
- pending_exit_merges_.push_back(smasm_->current_environment_);
- smasm_->CopyCurrentAsDead();
-}
-
-
-void StructuredMachineAssembler::LoopBuilder::End() {
- DCHECK(!IsDone());
- if (smasm_->current_environment_ != NULL) {
- Continue();
- }
- // Do loop header merges.
- smasm_->MergeBackEdgesToLoopHeader(header_environment_,
- &pending_header_merges_);
- int initial_size =
static_cast<int>(header_environment_->variables_.size());
- // Do loop exit merges, truncating loop variables away.
- smasm_->Merge(&pending_exit_merges_, initial_size);
- for (EnvironmentVector::iterator i = pending_exit_merges_.begin();
- i != pending_exit_merges_.end(); ++i) {
- smasm_->AddGoto(*i, smasm_->current_environment_);
- }
- pending_header_merges_.clear();
- pending_exit_merges_.clear();
- header_environment_ = NULL;
- DCHECK(IsDone());
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
=======================================
--- /branches/bleeding_edge/src/compiler/structured-machine-assembler.h Wed
Sep 3 10:13:21 2014 UTC
+++ /dev/null
@@ -1,299 +0,0 @@
-// Copyright 2014 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_COMPILER_STRUCTURED_MACHINE_ASSEMBLER_H_
-#define V8_COMPILER_STRUCTURED_MACHINE_ASSEMBLER_H_
-
-#include "src/v8.h"
-
-#include "src/compiler/common-operator.h"
-#include "src/compiler/graph-builder.h"
-#include "src/compiler/machine-node-factory.h"
-#include "src/compiler/machine-operator.h"
-#include "src/compiler/node.h"
-#include "src/compiler/operator.h"
-
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class BasicBlock;
-class Schedule;
-class StructuredMachineAssembler;
-
-
-class Variable : public ZoneObject {
- public:
- Node* Get() const;
- void Set(Node* value) const;
-
- private:
- Variable(StructuredMachineAssembler* smasm, int offset)
- : smasm_(smasm), offset_(offset) {}
-
- friend class StructuredMachineAssembler;
- friend class StructuredMachineAssemblerFriend;
- StructuredMachineAssembler* const smasm_;
- const int offset_;
-};
-
-
-class StructuredMachineAssembler
- : public GraphBuilder,
- public MachineNodeFactory<StructuredMachineAssembler> {
- public:
- class Environment : public ZoneObject {
- public:
- Environment(Zone* zone, BasicBlock* block, bool is_dead_);
-
- private:
- BasicBlock* block_;
- NodeVector variables_;
- bool is_dead_;
- friend class StructuredMachineAssembler;
- DISALLOW_COPY_AND_ASSIGN(Environment);
- };
-
- class IfBuilder;
- friend class IfBuilder;
- class LoopBuilder;
- friend class LoopBuilder;
-
- StructuredMachineAssembler(Graph* graph, MachineSignature* machine_sig,
- MachineType word = kMachPtr);
- virtual ~StructuredMachineAssembler() {}
-
- Isolate* isolate() const { return zone()->isolate(); }
- Zone* zone() const { return graph()->zone(); }
- MachineOperatorBuilder* machine() { return &machine_; }
- CommonOperatorBuilder* common() { return &common_; }
- CallDescriptor* call_descriptor() const { return call_descriptor_; }
- size_t parameter_count() const { return machine_sig_->parameter_count();
}
- MachineSignature* machine_sig() const { return machine_sig_; }
-
- // Parameters.
- Node* Parameter(size_t index);
- // Variables.
- Variable NewVariable(Node* initial_value);
- // Control flow.
- void Return(Node* value);
-
- // MachineAssembler is invalid after export.
- Schedule* Export();
-
- protected:
- virtual Node* MakeNode(Operator* op, int input_count, Node** inputs);
-
- Schedule* schedule() {
- DCHECK(ScheduleValid());
- return schedule_;
- }
-
- private:
- bool ScheduleValid() { return schedule_ != NULL; }
-
- typedef ZoneVector<Environment*> EnvironmentVector;
-
- NodeVector* CurrentVars() { return ¤t_environment_->variables_; }
- Node*& VariableAt(Environment* environment, int offset);
- Node* GetVariable(int offset);
- void SetVariable(int offset, Node* value);
-
- void AddBranch(Environment* environment, Node* condition,
- Environment* true_val, Environment* false_val);
- void AddGoto(Environment* from, Environment* to);
- BasicBlock* TrampolineFor(BasicBlock* block);
-
- void CopyCurrentAsDead();
- Environment* Copy(Environment* environment) {
- return Copy(environment,
static_cast<int>(environment->variables_.size()));
- }
- Environment* Copy(Environment* environment, int truncate_at);
- void Merge(EnvironmentVector* environments, int truncate_at);
- Environment* CopyForLoopHeader(Environment* environment);
- void MergeBackEdgesToLoopHeader(Environment* header,
- EnvironmentVector* environments);
-
- Schedule* schedule_;
- MachineOperatorBuilder machine_;
- CommonOperatorBuilder common_;
- MachineSignature* machine_sig_;
- CallDescriptor* call_descriptor_;
- Node** parameters_;
- Environment* current_environment_;
- int number_of_variables_;
-
- friend class Variable;
- // For testing only.
- friend class StructuredMachineAssemblerFriend;
- DISALLOW_COPY_AND_ASSIGN(StructuredMachineAssembler);
-};
-
-// IfBuilder constructs of nested if-else expressions which more or less
follow
-// C semantics. Foe example:
-//
-// if (x) {do_x} else if (y) {do_y} else {do_z}
-//
-// would look like this:
-//
-// IfBuilder b;
-// b.If(x).Then();
-// do_x
-// b.Else();
-// b.If().Then();
-// do_y
-// b.Else();
-// do_z
-// b.End();
-//
-// Then() and Else() can be skipped, representing an empty block in C.
-// Combinations like If(x).Then().If(x).Then() are legitimate, but
-// Else().Else() is not. That is, once you've nested an If(), you can't
get to a
-// higher level If() branch.
-// TODO(dcarney): describe expressions once the api is finalized.
-class StructuredMachineAssembler::IfBuilder {
- public:
- explicit IfBuilder(StructuredMachineAssembler* smasm);
- ~IfBuilder() {
- if (!IsDone()) End();
- }
-
- IfBuilder& If(); // TODO(dcarney): this should take an expression.
- IfBuilder& If(Node* condition);
- void Then();
- void Else();
- void End();
-
- // The next 4 functions are exposed for expression support.
- // They will be private once I have a nice expression api.
- void And();
- void Or();
- IfBuilder& OpenParen() {
- DCHECK(smasm_->current_environment_ != NULL);
- CurrentClause()->PushNewExpressionState();
- return *this;
- }
- IfBuilder& CloseParen() {
- DCHECK(smasm_->current_environment_ == NULL);
- CurrentClause()->PopExpressionState();
- return *this;
- }
-
- private:
- // UnresolvedBranch represents the chain of environments created while
- // generating an expression. At this point, a branch Node
- // cannot be created, as the target environments of the branch are not
yet
- // available, so everything required to create the branch Node is
- // stored in this structure until the target environments are resolved.
- struct UnresolvedBranch : public ZoneObject {
- UnresolvedBranch(Environment* environment, Node* condition,
- UnresolvedBranch* next)
- : environment_(environment), condition_(condition), next_(next) {}
- // environment_ will eventually be terminated by a branch on
condition_.
- Environment* environment_;
- Node* condition_;
- // next_ is the next link in the UnresolvedBranch chain, and will be
- // either the true or false branch jumped to from environment_.
- UnresolvedBranch* next_;
- };
-
- struct ExpressionState {
- int pending_then_size_;
- int pending_else_size_;
- };
-
- typedef ZoneVector<ExpressionState> ExpressionStates;
- typedef ZoneVector<UnresolvedBranch*> PendingMergeStack;
- struct IfClause;
- typedef ZoneVector<IfClause*> IfClauses;
-
- struct PendingMergeStackRange {
- PendingMergeStack* merge_stack_;
- int start_;
- int size_;
- };
-
- enum CombineType { kCombineThen, kCombineElse };
- enum ResolutionType { kExpressionTerm, kExpressionDone };
-
- // IfClause represents one level of if-then-else nesting plus the
associated
- // expression.
- // A call to If() triggers creation of a new nesting level after
expression
- // creation is complete - ie Then() or Else() has been called.
- struct IfClause : public ZoneObject {
- IfClause(Zone* zone, int initial_environment_size);
- void CopyEnvironments(const PendingMergeStackRange& data,
- EnvironmentVector* environments);
- void ResolvePendingMerges(StructuredMachineAssembler* smasm,
- CombineType combine_type,
- ResolutionType resolution_type);
- PendingMergeStackRange ComputeRelevantMerges(CombineType combine_type);
- void FinalizeBranches(StructuredMachineAssembler* smasm,
- const PendingMergeStackRange& offset_data,
- CombineType combine_type,
- Environment* then_environment,
- Environment* else_environment);
- void PushNewExpressionState();
- void PopExpressionState();
-
- // Each invocation of And or Or creates a new UnresolvedBranch.
- // These form a singly-linked list, of which we only need to keep
track of
- // the tail. On creation of an UnresolvedBranch, pending_then_merges_
and
- // pending_else_merges_ each push a copy, which are removed on merges
to the
- // respective environment.
- UnresolvedBranch* unresolved_list_tail_;
- int initial_environment_size_;
- // expression_states_ keeps track of the state of pending_*_merges_,
- // pushing and popping the lengths of these on
- // OpenParend() and CloseParend() respectively.
- ExpressionStates expression_states_;
- PendingMergeStack pending_then_merges_;
- PendingMergeStack pending_else_merges_;
- // then_environment_ is created iff there is a call to Then(),
otherwise
- // branches which would merge to it merge to the exit environment
instead.
- // Likewise for else_environment_.
- Environment* then_environment_;
- Environment* else_environment_;
- };
-
- IfClause* CurrentClause() { return if_clauses_.back(); }
- void AddCurrentToPending();
- void PushNewIfClause();
- bool IsDone() { return if_clauses_.empty(); }
-
- StructuredMachineAssembler* smasm_;
- IfClauses if_clauses_;
- EnvironmentVector pending_exit_merges_;
- DISALLOW_COPY_AND_ASSIGN(IfBuilder);
-};
-
-
-class StructuredMachineAssembler::LoopBuilder {
- public:
- explicit LoopBuilder(StructuredMachineAssembler* smasm);
- ~LoopBuilder() {
- if (!IsDone()) End();
- }
-
- void Break();
- void Continue();
- void End();
-
- private:
- friend class StructuredMachineAssembler;
- bool IsDone() { return header_environment_ == NULL; }
-
- StructuredMachineAssembler* smasm_;
- Environment* header_environment_;
- EnvironmentVector pending_header_merges_;
- EnvironmentVector pending_exit_merges_;
- DISALLOW_COPY_AND_ASSIGN(LoopBuilder);
-};
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
-
-#endif // V8_COMPILER_STRUCTURED_MACHINE_ASSEMBLER_H_
=======================================
--- /branches/bleeding_edge/BUILD.gn Wed Sep 3 22:26:38 2014 UTC
+++ /branches/bleeding_edge/BUILD.gn Thu Sep 4 10:23:51 2014 UTC
@@ -546,15 +546,12 @@
"src/compiler/scheduler.h",
"src/compiler/simplified-lowering.cc",
"src/compiler/simplified-lowering.h",
- "src/compiler/simplified-node-factory.h",
"src/compiler/simplified-operator-reducer.cc",
"src/compiler/simplified-operator-reducer.h",
"src/compiler/simplified-operator.cc",
"src/compiler/simplified-operator.h",
"src/compiler/source-position.cc",
"src/compiler/source-position.h",
- "src/compiler/structured-machine-assembler.cc",
- "src/compiler/structured-machine-assembler.h",
"src/compiler/typer.cc",
"src/compiler/typer.h",
"src/compiler/verifier.cc",
=======================================
--- /branches/bleeding_edge/test/cctest/cctest.gyp Mon Sep 1 07:13:55 2014
UTC
+++ /branches/bleeding_edge/test/cctest/cctest.gyp Thu Sep 4 10:23:51 2014
UTC
@@ -53,6 +53,8 @@
'compiler/graph-tester.h',
'compiler/simplified-graph-builder.cc',
'compiler/simplified-graph-builder.h',
+ 'compiler/structured-machine-assembler.cc',
+ 'compiler/structured-machine-assembler.h',
'compiler/test-branch-combine.cc',
'compiler/test-changes-lowering.cc',
'compiler/test-codegen-deopt.cc',
=======================================
--- /branches/bleeding_edge/test/cctest/compiler/codegen-tester.h Wed Sep
3 10:13:21 2014 UTC
+++ /branches/bleeding_edge/test/cctest/compiler/codegen-tester.h Thu Sep
4 10:23:51 2014 UTC
@@ -9,9 +9,9 @@
#include "src/compiler/pipeline.h"
#include "src/compiler/raw-machine-assembler.h"
-#include "src/compiler/structured-machine-assembler.h"
#include "src/simulator.h"
#include "test/cctest/compiler/call-tester.h"
+#include "test/cctest/compiler/structured-machine-assembler.h"
namespace v8 {
namespace internal {
=======================================
--- /branches/bleeding_edge/test/cctest/compiler/graph-builder-tester.h Wed
Sep 3 10:13:21 2014 UTC
+++ /branches/bleeding_edge/test/cctest/compiler/graph-builder-tester.h Thu
Sep 4 10:23:51 2014 UTC
@@ -12,7 +12,6 @@
#include "src/compiler/graph-builder.h"
#include "src/compiler/machine-node-factory.h"
#include "src/compiler/machine-operator.h"
-#include "src/compiler/simplified-node-factory.h"
#include "src/compiler/simplified-operator.h"
#include "test/cctest/compiler/call-tester.h"
#include "test/cctest/compiler/simplified-graph-builder.h"
=======================================
---
/branches/bleeding_edge/test/cctest/compiler/simplified-graph-builder.cc
Tue Aug 5 08:47:39 2014 UTC
+++
/branches/bleeding_edge/test/cctest/compiler/simplified-graph-builder.cc
Thu Sep 4 10:23:51 2014 UTC
@@ -4,6 +4,9 @@
#include "test/cctest/compiler/simplified-graph-builder.h"
+#include "src/compiler/operator-properties.h"
+#include "src/compiler/operator-properties-inl.h"
+
namespace v8 {
namespace internal {
namespace compiler {
@@ -11,7 +14,10 @@
SimplifiedGraphBuilder::SimplifiedGraphBuilder(
Graph* graph, CommonOperatorBuilder* common,
MachineOperatorBuilder* machine, SimplifiedOperatorBuilder* simplified)
- : StructuredGraphBuilder(graph, common),
+ : GraphBuilder(graph),
+ effect_(NULL),
+ return_(NULL),
+ common_(common),
machine_(machine),
simplified_(simplified) {}
@@ -20,57 +26,62 @@
DCHECK(graph()->start() == NULL);
Node* start = graph()->NewNode(common()->Start(num_parameters));
graph()->SetStart(start);
- set_environment(new (zone()) Environment(this, start));
+ effect_ = start;
}
void SimplifiedGraphBuilder::Return(Node* value) {
- Node* control = NewNode(common()->Return(), value);
- UpdateControlDependencyToLeaveFunction(control);
+ return_ =
+ graph()->NewNode(common()->Return(), value, effect_,
graph()->start());
+ effect_ = NULL;
}
void SimplifiedGraphBuilder::End() {
- environment()->UpdateControlDependency(exit_control());
- graph()->SetEnd(NewNode(common()->End()));
+ Node* end = graph()->NewNode(common()->End(), return_);
+ graph()->SetEnd(end);
}
-SimplifiedGraphBuilder::Environment::Environment(
- SimplifiedGraphBuilder* builder, Node* control_dependency)
- : StructuredGraphBuilder::Environment(builder, control_dependency) {}
+Node* SimplifiedGraphBuilder::MakeNode(Operator* op, int value_input_count,
+ Node** value_inputs) {
+ DCHECK(op->InputCount() == value_input_count);
+ DCHECK(!OperatorProperties::HasContextInput(op));
+ DCHECK(!OperatorProperties::HasFrameStateInput(op));
+ bool has_control = OperatorProperties::GetControlInputCount(op) == 1;
+ bool has_effect = OperatorProperties::GetEffectInputCount(op) == 1;
-Node* SimplifiedGraphBuilder::Environment::Top() {
- DCHECK(!values()->empty());
- return values()->back();
-}
+ DCHECK(OperatorProperties::GetControlInputCount(op) < 2);
+ DCHECK(OperatorProperties::GetEffectInputCount(op) < 2);
-
-void SimplifiedGraphBuilder::Environment::Push(Node* node) {
- values()->push_back(node);
-}
-
-
-Node* SimplifiedGraphBuilder::Environment::Pop() {
- DCHECK(!values()->empty());
- Node* back = values()->back();
- values()->pop_back();
- return back;
-}
-
-
-void SimplifiedGraphBuilder::Environment::Poke(size_t depth, Node* node) {
- DCHECK(depth < values()->size());
- size_t index = values()->size() - depth - 1;
- values()->at(index) = node;
-}
-
+ Node* result = NULL;
+ if (!has_control && !has_effect) {
+ result = graph()->NewNode(op, value_input_count, value_inputs);
+ } else {
+ int input_count_with_deps = value_input_count;
+ if (has_control) ++input_count_with_deps;
+ if (has_effect) ++input_count_with_deps;
+ Node** buffer = zone()->NewArray<Node*>(input_count_with_deps);
+ memcpy(buffer, value_inputs, kPointerSize * value_input_count);
+ Node** current_input = buffer + value_input_count;
+ if (has_effect) {
+ *current_input++ = effect_;
+ }
+ if (has_control) {
+ *current_input++ = graph()->start();
+ }
+ result = graph()->NewNode(op, input_count_with_deps, buffer);
+ if (has_effect) {
+ effect_ = result;
+ }
+ if (OperatorProperties::HasControlOutput(result->op())) {
+ // This graph builder does not support control flow.
+ UNREACHABLE();
+ }
+ }
-Node* SimplifiedGraphBuilder::Environment::Peek(size_t depth) {
- DCHECK(depth < values()->size());
- size_t index = values()->size() - depth - 1;
- return values()->at(index);
+ return result;
}
} // namespace compiler
=======================================
--- /branches/bleeding_edge/test/cctest/compiler/simplified-graph-builder.h
Fri Aug 8 13:51:30 2014 UTC
+++ /branches/bleeding_edge/test/cctest/compiler/simplified-graph-builder.h
Thu Sep 4 10:23:51 2014 UTC
@@ -9,7 +9,6 @@
#include "src/compiler/graph-builder.h"
#include "src/compiler/machine-node-factory.h"
#include "src/compiler/machine-operator.h"
-#include "src/compiler/simplified-node-factory.h"
#include "src/compiler/simplified-operator.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/call-tester.h"
@@ -19,39 +18,19 @@
namespace compiler {
class SimplifiedGraphBuilder
- : public StructuredGraphBuilder,
- public MachineNodeFactory<SimplifiedGraphBuilder>,
- public SimplifiedNodeFactory<SimplifiedGraphBuilder> {
+ : public GraphBuilder,
+ public MachineNodeFactory<SimplifiedGraphBuilder> {
public:
SimplifiedGraphBuilder(Graph* graph, CommonOperatorBuilder* common,
MachineOperatorBuilder* machine,
SimplifiedOperatorBuilder* simplified);
virtual ~SimplifiedGraphBuilder() {}
- class Environment : public StructuredGraphBuilder::Environment {
- public:
- Environment(SimplifiedGraphBuilder* builder, Node* control_dependency);
-
- // TODO(dcarney): encode somehow and merge into StructuredGraphBuilder.
- // SSA renaming operations.
- Node* Top();
- void Push(Node* node);
- Node* Pop();
- void Poke(size_t depth, Node* node);
- Node* Peek(size_t depth);
- };
-
+ Zone* zone() const { return graph()->zone(); }
Isolate* isolate() const { return zone()->isolate(); }
- Zone* zone() const { return StructuredGraphBuilder::zone(); }
- CommonOperatorBuilder* common() const {
- return StructuredGraphBuilder::common();
- }
+ CommonOperatorBuilder* common() const { return common_; }
MachineOperatorBuilder* machine() const { return machine_; }
SimplifiedOperatorBuilder* simplified() const { return simplified_; }
- Environment* environment() {
- return reinterpret_cast<Environment*>(
- StructuredGraphBuilder::environment());
- }
// Initialize graph and builder.
void Begin(int num_parameters);
@@ -61,7 +40,99 @@
// Close the graph.
void End();
+ Node* BooleanNot(Node* a) { return NewNode(simplified()->BooleanNot(),
a); }
+
+ Node* NumberEqual(Node* a, Node* b) {
+ return NewNode(simplified()->NumberEqual(), a, b);
+ }
+ Node* NumberLessThan(Node* a, Node* b) {
+ return NewNode(simplified()->NumberLessThan(), a, b);
+ }
+ Node* NumberLessThanOrEqual(Node* a, Node* b) {
+ return NewNode(simplified()->NumberLessThanOrEqual(), a, b);
+ }
+ Node* NumberAdd(Node* a, Node* b) {
+ return NewNode(simplified()->NumberAdd(), a, b);
+ }
+ Node* NumberSubtract(Node* a, Node* b) {
+ return NewNode(simplified()->NumberSubtract(), a, b);
+ }
+ Node* NumberMultiply(Node* a, Node* b) {
+ return NewNode(simplified()->NumberMultiply(), a, b);
+ }
+ Node* NumberDivide(Node* a, Node* b) {
+ return NewNode(simplified()->NumberDivide(), a, b);
+ }
+ Node* NumberModulus(Node* a, Node* b) {
+ return NewNode(simplified()->NumberModulus(), a, b);
+ }
+ Node* NumberToInt32(Node* a) {
+ return NewNode(simplified()->NumberToInt32(), a);
+ }
+ Node* NumberToUint32(Node* a) {
+ return NewNode(simplified()->NumberToUint32(), a);
+ }
+
+ Node* StringEqual(Node* a, Node* b) {
+ return NewNode(simplified()->StringEqual(), a, b);
+ }
+ Node* StringLessThan(Node* a, Node* b) {
+ return NewNode(simplified()->StringLessThan(), a, b);
+ }
+ Node* StringLessThanOrEqual(Node* a, Node* b) {
+ return NewNode(simplified()->StringLessThanOrEqual(), a, b);
+ }
+ Node* StringAdd(Node* a, Node* b) {
+ return NewNode(simplified()->StringAdd(), a, b);
+ }
+
+ Node* ChangeTaggedToInt32(Node* a) {
+ return NewNode(simplified()->ChangeTaggedToInt32(), a);
+ }
+ Node* ChangeTaggedToUint32(Node* a) {
+ return NewNode(simplified()->ChangeTaggedToUint32(), a);
+ }
+ Node* ChangeTaggedToFloat64(Node* a) {
+ return NewNode(simplified()->ChangeTaggedToFloat64(), a);
+ }
+ Node* ChangeInt32ToTagged(Node* a) {
+ return NewNode(simplified()->ChangeInt32ToTagged(), a);
+ }
+ Node* ChangeUint32ToTagged(Node* a) {
+ return NewNode(simplified()->ChangeUint32ToTagged(), a);
+ }
+ Node* ChangeFloat64ToTagged(Node* a) {
+ return NewNode(simplified()->ChangeFloat64ToTagged(), a);
+ }
+ Node* ChangeBoolToBit(Node* a) {
+ return NewNode(simplified()->ChangeBoolToBit(), a);
+ }
+ Node* ChangeBitToBool(Node* a) {
+ return NewNode(simplified()->ChangeBitToBool(), a);
+ }
+
+ Node* LoadField(const FieldAccess& access, Node* object) {
+ return NewNode(simplified()->LoadField(access), object);
+ }
+ Node* StoreField(const FieldAccess& access, Node* object, Node* value) {
+ return NewNode(simplified()->StoreField(access), object, value);
+ }
+ Node* LoadElement(const ElementAccess& access, Node* object, Node*
index) {
+ return NewNode(simplified()->LoadElement(access), object, index);
+ }
+ Node* StoreElement(const ElementAccess& access, Node* object, Node*
index,
+ Node* value) {
+ return NewNode(simplified()->StoreElement(access), object, index,
value);
+ }
+
+ protected:
+ virtual Node* MakeNode(Operator* op, int value_input_count,
+ Node** value_inputs);
+
private:
+ Node* effect_;
+ Node* return_;
+ CommonOperatorBuilder* common_;
MachineOperatorBuilder* machine_;
SimplifiedOperatorBuilder* simplified_;
};
=======================================
--- /branches/bleeding_edge/test/cctest/compiler/test-changes-lowering.cc
Fri Aug 29 09:49:50 2014 UTC
+++ /branches/bleeding_edge/test/cctest/compiler/test-changes-lowering.cc
Thu Sep 4 10:23:51 2014 UTC
@@ -10,7 +10,6 @@
#include "src/compiler/js-graph.h"
#include "src/compiler/node-properties-inl.h"
#include "src/compiler/pipeline.h"
-#include "src/compiler/simplified-node-factory.h"
#include "src/compiler/typer.h"
#include "src/compiler/verifier.h"
#include "src/execution.h"
=======================================
---
/branches/bleeding_edge/test/cctest/compiler/test-js-context-specialization.cc
Thu Sep 4 09:37:25 2014 UTC
+++
/branches/bleeding_edge/test/cctest/compiler/test-js-context-specialization.cc
Thu Sep 4 10:23:51 2014 UTC
@@ -6,7 +6,6 @@
#include "src/compiler/js-operator.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties-inl.h"
-#include "src/compiler/simplified-node-factory.h"
#include "src/compiler/source-position.h"
#include "src/compiler/typer.h"
#include "test/cctest/cctest.h"
@@ -16,10 +15,8 @@
using namespace v8::internal;
using namespace v8::internal::compiler;
-class ContextSpecializationTester
- : public HandleAndZoneScope,
- public DirectGraphBuilder,
- public SimplifiedNodeFactory<ContextSpecializationTester> {
+class ContextSpecializationTester : public HandleAndZoneScope,
+ public DirectGraphBuilder {
public:
ContextSpecializationTester()
: DirectGraphBuilder(new (main_zone()) Graph(main_zone())),
@@ -214,11 +211,12 @@
const_context, const_context, effect_in);
- Node* value_use = t.ChangeTaggedToInt32(load);
+ Node* value_use = t.NewNode(t.simplified()->ChangeTaggedToInt32(),
load);
Node* other_load = t.NewNode(t.javascript()->LoadContext(0, slot,
true),
param_context, param_context, load);
Node* effect_use = other_load;
- Node* other_use = t.ChangeTaggedToInt32(other_load);
+ Node* other_use =
+ t.NewNode(t.simplified()->ChangeTaggedToInt32(), other_load);
Node* add = t.NewNode(t.javascript()->Add(), value_use, other_use,
param_context, other_load, start);
=======================================
---
/branches/bleeding_edge/test/cctest/compiler/test-simplified-lowering.cc
Wed Sep 3 12:43:41 2014 UTC
+++
/branches/bleeding_edge/test/cctest/compiler/test-simplified-lowering.cc
Thu Sep 4 10:23:51 2014 UTC
@@ -12,7 +12,6 @@
#include "src/compiler/pipeline.h"
#include "src/compiler/representation-change.h"
#include "src/compiler/simplified-lowering.h"
-#include "src/compiler/simplified-node-factory.h"
#include "src/compiler/typer.h"
#include "src/compiler/verifier.h"
#include "src/execution.h"
@@ -456,6 +455,8 @@
// Create and run code that copies the elements from {this} to {that}.
void RunCopyElements(AccessTester<E>* that) {
+// TODO(titzer): Rewrite this test without StructuredGraphBuilder support.
+#if 0
SimplifiedLoweringTester<Object*> t;
Node* one = t.Int32Constant(1);
@@ -491,6 +492,7 @@
Object* result = t.Call();
CHECK_EQ(t.isolate()->heap()->true_value(), result);
}
+#endif
}
E GetElement(int index) {
=======================================
---
/branches/bleeding_edge/test/cctest/compiler/test-structured-machine-assembler.cc
Thu Aug 28 13:17:38 2014 UTC
+++
/branches/bleeding_edge/test/cctest/compiler/test-structured-machine-assembler.cc
Thu Sep 4 10:23:51 2014 UTC
@@ -6,8 +6,8 @@
#include "test/cctest/cctest.h"
#include "src/base/utils/random-number-generator.h"
-#include "src/compiler/structured-machine-assembler.h"
#include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/structured-machine-assembler.h"
#include "test/cctest/compiler/value-helper.h"
#if V8_TURBOFAN_TARGET
=======================================
--- /branches/bleeding_edge/tools/gyp/v8.gyp Wed Sep 3 22:26:38 2014 UTC
+++ /branches/bleeding_edge/tools/gyp/v8.gyp Thu Sep 4 10:23:51 2014 UTC
@@ -458,15 +458,12 @@
'../../src/compiler/scheduler.h',
'../../src/compiler/simplified-lowering.cc',
'../../src/compiler/simplified-lowering.h',
- '../../src/compiler/simplified-node-factory.h',
'../../src/compiler/simplified-operator-reducer.cc',
'../../src/compiler/simplified-operator-reducer.h',
'../../src/compiler/simplified-operator.cc',
'../../src/compiler/simplified-operator.h',
'../../src/compiler/source-position.cc',
'../../src/compiler/source-position.h',
- '../../src/compiler/structured-machine-assembler.cc',
- '../../src/compiler/structured-machine-assembler.h',
'../../src/compiler/typer.cc',
'../../src/compiler/typer.h',
'../../src/compiler/verifier.cc',
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
