diff options
Diffstat (limited to 'deps/v8/test/cctest/compiler/test-gap-resolver.cc')
-rw-r--r-- | deps/v8/test/cctest/compiler/test-gap-resolver.cc | 137 |
1 files changed, 93 insertions, 44 deletions
diff --git a/deps/v8/test/cctest/compiler/test-gap-resolver.cc b/deps/v8/test/cctest/compiler/test-gap-resolver.cc index 818a0bd238..a081ddb8fe 100644 --- a/deps/v8/test/cctest/compiler/test-gap-resolver.cc +++ b/deps/v8/test/cctest/compiler/test-gap-resolver.cc @@ -14,12 +14,10 @@ using namespace v8::internal::compiler; // that the actual values don't really matter, all we care about is equality. class InterpreterState { public: - typedef std::vector<MoveOperands> Moves; - - void ExecuteInParallel(Moves moves) { + void ExecuteInParallel(const ParallelMove* moves) { InterpreterState copy(*this); - for (Moves::iterator it = moves.begin(); it != moves.end(); ++it) { - if (!it->IsRedundant()) write(it->destination(), copy.read(it->source())); + for (const auto m : *moves) { + if (!m->IsRedundant()) write(m->destination(), copy.read(m->source())); } } @@ -32,17 +30,37 @@ class InterpreterState { } private: + struct Key { + bool is_constant; + AllocatedOperand::AllocatedKind kind; + int index; + + bool operator<(const Key& other) const { + if (this->is_constant != other.is_constant) { + return this->is_constant; + } + if (this->kind != other.kind) { + return this->kind < other.kind; + } + return this->index < other.index; + } + + bool operator==(const Key& other) const { + return this->is_constant == other.is_constant && + this->kind == other.kind && this->index == other.index; + } + }; + // Internally, the state is a normalized permutation of (kind,index) pairs. - typedef std::pair<InstructionOperand::Kind, int> Key; typedef Key Value; typedef std::map<Key, Value> OperandMap; - Value read(const InstructionOperand* op) const { + Value read(const InstructionOperand& op) const { OperandMap::const_iterator it = values_.find(KeyFor(op)); return (it == values_.end()) ? ValueFor(op) : it->second; } - void write(const InstructionOperand* op, Value v) { + void write(const InstructionOperand& op, Value v) { if (v == ValueFor(op)) { values_.erase(KeyFor(op)); } else { @@ -50,12 +68,29 @@ class InterpreterState { } } - static Key KeyFor(const InstructionOperand* op) { - return Key(op->kind(), op->index()); + static Key KeyFor(const InstructionOperand& op) { + bool is_constant = op.IsConstant(); + AllocatedOperand::AllocatedKind kind; + int index; + if (!is_constant) { + index = AllocatedOperand::cast(op).index(); + kind = AllocatedOperand::cast(op).allocated_kind(); + } else { + index = ConstantOperand::cast(op).virtual_register(); + kind = AllocatedOperand::REGISTER; + } + Key key = {is_constant, kind, index}; + return key; } - static Value ValueFor(const InstructionOperand* op) { - return Value(op->kind(), op->index()); + static Value ValueFor(const InstructionOperand& op) { return KeyFor(op); } + + static InstructionOperand FromKey(Key key) { + if (key.is_constant) { + return ConstantOperand(key.index); + } + return AllocatedOperand( + key.kind, InstructionSequence::DefaultRepresentation(), key.index); } friend std::ostream& operator<<(std::ostream& os, @@ -63,9 +98,9 @@ class InterpreterState { for (OperandMap::const_iterator it = is.values_.begin(); it != is.values_.end(); ++it) { if (it != is.values_.begin()) os << " "; - InstructionOperand source(it->first.first, it->first.second); - InstructionOperand destination(it->second.first, it->second.second); - MoveOperands mo(&source, &destination); + InstructionOperand source = FromKey(it->first); + InstructionOperand destination = FromKey(it->second); + MoveOperands mo(source, destination); PrintableMoveOperands pmo = {RegisterConfiguration::ArchDefault(), &mo}; os << pmo; } @@ -79,30 +114,31 @@ class InterpreterState { // An abstract interpreter for moves, swaps and parallel moves. class MoveInterpreter : public GapResolver::Assembler { public: + explicit MoveInterpreter(Zone* zone) : zone_(zone) {} + virtual void AssembleMove(InstructionOperand* source, - InstructionOperand* destination) OVERRIDE { - InterpreterState::Moves moves; - moves.push_back(MoveOperands(source, destination)); + InstructionOperand* destination) override { + ParallelMove* moves = new (zone_) ParallelMove(zone_); + moves->AddMove(*source, *destination); state_.ExecuteInParallel(moves); } virtual void AssembleSwap(InstructionOperand* source, - InstructionOperand* destination) OVERRIDE { - InterpreterState::Moves moves; - moves.push_back(MoveOperands(source, destination)); - moves.push_back(MoveOperands(destination, source)); + InstructionOperand* destination) override { + ParallelMove* moves = new (zone_) ParallelMove(zone_); + moves->AddMove(*source, *destination); + moves->AddMove(*destination, *source); state_.ExecuteInParallel(moves); } - void AssembleParallelMove(const ParallelMove* pm) { - InterpreterState::Moves moves(pm->move_operands()->begin(), - pm->move_operands()->end()); + void AssembleParallelMove(const ParallelMove* moves) { state_.ExecuteInParallel(moves); } InterpreterState state() const { return state_; } private: + Zone* const zone_; InterpreterState state_; }; @@ -113,11 +149,11 @@ class ParallelMoveCreator : public HandleAndZoneScope { ParallelMove* Create(int size) { ParallelMove* parallel_move = new (main_zone()) ParallelMove(main_zone()); - std::set<InstructionOperand*, InstructionOperandComparator> seen; + std::set<InstructionOperand, CompareOperandModuloType> seen; for (int i = 0; i < size; ++i) { - MoveOperands mo(CreateRandomOperand(), CreateRandomOperand()); + MoveOperands mo(CreateRandomOperand(true), CreateRandomOperand(false)); if (!mo.IsRedundant() && seen.find(mo.destination()) == seen.end()) { - parallel_move->AddMove(mo.source(), mo.destination(), main_zone()); + parallel_move->AddMove(mo.source(), mo.destination()); seen.insert(mo.destination()); } } @@ -125,30 +161,43 @@ class ParallelMoveCreator : public HandleAndZoneScope { } private: - struct InstructionOperandComparator { - bool operator()(const InstructionOperand* x, - const InstructionOperand* y) const { - return (x->kind() < y->kind()) || - (x->kind() == y->kind() && x->index() < y->index()); + MachineType RandomType() { + int index = rng_->NextInt(3); + switch (index) { + case 0: + return kRepWord32; + case 1: + return kRepWord64; + case 2: + return kRepTagged; } - }; + UNREACHABLE(); + return kMachNone; + } + + MachineType RandomDoubleType() { + int index = rng_->NextInt(2); + if (index == 0) return kRepFloat64; + return kRepFloat32; + } - InstructionOperand* CreateRandomOperand() { + InstructionOperand CreateRandomOperand(bool is_source) { int index = rng_->NextInt(6); - switch (rng_->NextInt(5)) { + // destination can't be Constant. + switch (rng_->NextInt(is_source ? 5 : 4)) { case 0: - return ConstantOperand::New(index, main_zone()); + return StackSlotOperand(RandomType(), index); case 1: - return StackSlotOperand::New(index, main_zone()); + return DoubleStackSlotOperand(RandomDoubleType(), index); case 2: - return DoubleStackSlotOperand::New(index, main_zone()); + return RegisterOperand(RandomType(), index); case 3: - return RegisterOperand::New(index, main_zone()); + return DoubleRegisterOperand(RandomDoubleType(), index); case 4: - return DoubleRegisterOperand::New(index, main_zone()); + return ConstantOperand(index); } UNREACHABLE(); - return NULL; + return InstructionOperand(); } private: @@ -163,10 +212,10 @@ TEST(FuzzResolver) { ParallelMove* pm = pmc.Create(size); // Note: The gap resolver modifies the ParallelMove, so interpret first. - MoveInterpreter mi1; + MoveInterpreter mi1(pmc.main_zone()); mi1.AssembleParallelMove(pm); - MoveInterpreter mi2; + MoveInterpreter mi2(pmc.main_zone()); GapResolver resolver(&mi2); resolver.Resolve(pm); |