namespace compiler {
RawMachineAssembler::RawMachineAssembler(Isolate* isolate, Graph* graph,
- const MachineSignature* machine_sig,
+ CallDescriptor* call_descriptor,
MachineType word,
MachineOperatorBuilder::Flags flags)
: GraphBuilder(isolate, graph),
schedule_(new (zone()) Schedule(zone())),
machine_(zone(), word, flags),
common_(zone()),
- machine_sig_(machine_sig),
- call_descriptor_(
- Linkage::GetSimplifiedCDescriptor(graph->zone(), machine_sig)),
+ call_descriptor_(call_descriptor),
parameters_(NULL),
current_block_(schedule()->start()) {
int param_count = static_cast<int>(parameter_count());
};
RawMachineAssembler(Isolate* isolate, Graph* graph,
- const MachineSignature* machine_sig,
+ CallDescriptor* call_descriptor,
MachineType word = kMachPtr,
MachineOperatorBuilder::Flags flags =
MachineOperatorBuilder::Flag::kNoFlags);
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(); }
- const MachineSignature* machine_sig() const { return machine_sig_; }
+ size_t parameter_count() const { return machine_sig()->parameter_count(); }
+ const MachineSignature* machine_sig() const {
+ return call_descriptor_->GetMachineSignature();
+ }
Node* UndefinedConstant() {
Unique<HeapObject> unique = Unique<HeapObject>::CreateImmovable(
Schedule* schedule_;
MachineOperatorBuilder machine_;
CommonOperatorBuilder common_;
- const MachineSignature* machine_sig_;
CallDescriptor* call_descriptor_;
Node** parameters_;
BasicBlock* current_block_;
p2, p3, p4)),
RawMachineAssembler(
main_isolate(), new (main_zone()) Graph(main_zone()),
- CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0, p1,
- p2, p3, p4),
+ Linkage::GetSimplifiedCDescriptor(
+ main_zone(),
+ CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0,
+ p1, p2, p3, p4)),
kMachPtr, InstructionSelector::SupportedMachineOperatorFlags()) {}
void CheckNumber(double expected, Object* number) {
+++ /dev/null
-// 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_INSTRUCTION_SELECTOR_TEST_H_
-#define V8_CCTEST_COMPILER_INSTRUCTION_SELECTOR_TEST_H_
-
-#include <deque>
-#include <set>
-
-#include "src/compiler/instruction-selector.h"
-#include "src/compiler/raw-machine-assembler.h"
-#include "src/ostreams.h"
-#include "test/cctest/cctest.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-typedef std::set<int> VirtualRegisterSet;
-
-enum InstructionSelectorTesterMode { kTargetMode, kInternalMode };
-
-class InstructionSelectorTester : public HandleAndZoneScope,
- public RawMachineAssembler {
- public:
- enum Mode { kTargetMode, kInternalMode };
-
- static const int kParameterCount = 3;
- static MachineType* BuildParameterArray(Zone* zone) {
- MachineType* array = zone->NewArray<MachineType>(kParameterCount);
- for (int i = 0; i < kParameterCount; ++i) {
- array[i] = kMachInt32;
- }
- return array;
- }
-
- InstructionSelectorTester()
- : RawMachineAssembler(
- new (main_zone()) Graph(main_zone()),
- new (main_zone()) MachineCallDescriptorBuilder(
- kMachInt32, kParameterCount, BuildParameterArray(main_zone())),
- kMachPtr) {}
-
- void SelectInstructions(CpuFeature feature) {
- SelectInstructions(InstructionSelector::Features(feature));
- }
-
- void SelectInstructions(CpuFeature feature1, CpuFeature feature2) {
- SelectInstructions(InstructionSelector::Features(feature1, feature2));
- }
-
- void SelectInstructions(Mode mode = kTargetMode) {
- SelectInstructions(InstructionSelector::Features(), mode);
- }
-
- void SelectInstructions(InstructionSelector::Features features,
- Mode mode = kTargetMode) {
- OFStream out(stdout);
- Schedule* schedule = Export();
- CHECK_NE(0, graph()->NodeCount());
- CompilationInfo info(main_isolate(), main_zone());
- Linkage linkage(&info, call_descriptor());
- InstructionSequence sequence(&linkage, graph(), schedule);
- SourcePositionTable source_positions(graph());
- InstructionSelector selector(&sequence, &source_positions, features);
- selector.SelectInstructions();
- out << "--- Code sequence after instruction selection --- " << endl
- << sequence;
- for (InstructionSequence::const_iterator i = sequence.begin();
- i != sequence.end(); ++i) {
- Instruction* instr = *i;
- if (instr->opcode() < 0) continue;
- if (mode == kTargetMode) {
- switch (ArchOpcodeField::decode(instr->opcode())) {
-#define CASE(Name) \
- case k##Name: \
- break;
- TARGET_ARCH_OPCODE_LIST(CASE)
-#undef CASE
- default:
- continue;
- }
- }
- code.push_back(instr);
- }
- for (int vreg = 0; vreg < sequence.VirtualRegisterCount(); ++vreg) {
- if (sequence.IsDouble(vreg)) {
- CHECK(!sequence.IsReference(vreg));
- doubles.insert(vreg);
- }
- if (sequence.IsReference(vreg)) {
- CHECK(!sequence.IsDouble(vreg));
- references.insert(vreg);
- }
- }
- immediates.assign(sequence.immediates().begin(),
- sequence.immediates().end());
- }
-
- int32_t ToInt32(const InstructionOperand* operand) const {
- size_t i = operand->index();
- CHECK(i < immediates.size());
- CHECK_EQ(InstructionOperand::IMMEDIATE, operand->kind());
- return immediates[i].ToInt32();
- }
-
- std::deque<Instruction*> code;
- VirtualRegisterSet doubles;
- VirtualRegisterSet references;
- std::deque<Constant> immediates;
-};
-
-
-static inline void CheckSameVreg(InstructionOperand* exp,
- InstructionOperand* val) {
- CHECK_EQ(InstructionOperand::UNALLOCATED, exp->kind());
- CHECK_EQ(InstructionOperand::UNALLOCATED, val->kind());
- CHECK_EQ(UnallocatedOperand::cast(exp)->virtual_register(),
- UnallocatedOperand::cast(val)->virtual_register());
-}
-
-} // namespace compiler
-} // namespace internal
-} // namespace v8
-
-#endif // V8_CCTEST_COMPILER_INSTRUCTION_SELECTOR_TEST_H_
StreamBuilder(InstructionSelectorTest* test, MachineType return_type)
: RawMachineAssembler(
test->isolate(), new (test->zone()) Graph(test->zone()),
- MakeMachineSignature(test->zone(), return_type), kMachPtr,
+ MakeCallDescriptor(test->zone(), return_type), kMachPtr,
MachineOperatorBuilder::kAllOptionalOps),
test_(test) {}
StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
MachineType parameter0_type)
: RawMachineAssembler(
test->isolate(), new (test->zone()) Graph(test->zone()),
- MakeMachineSignature(test->zone(), return_type, parameter0_type),
+ MakeCallDescriptor(test->zone(), return_type, parameter0_type),
kMachPtr, MachineOperatorBuilder::kAllOptionalOps),
test_(test) {}
StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
MachineType parameter0_type, MachineType parameter1_type)
: RawMachineAssembler(
test->isolate(), new (test->zone()) Graph(test->zone()),
- MakeMachineSignature(test->zone(), return_type, parameter0_type,
- parameter1_type),
+ MakeCallDescriptor(test->zone(), return_type, parameter0_type,
+ parameter1_type),
kMachPtr, MachineOperatorBuilder::kAllOptionalOps),
test_(test) {}
StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
MachineType parameter2_type)
: RawMachineAssembler(
test->isolate(), new (test->zone()) Graph(test->zone()),
- MakeMachineSignature(test->zone(), return_type, parameter0_type,
- parameter1_type, parameter2_type),
+ MakeCallDescriptor(test->zone(), return_type, parameter0_type,
+ parameter1_type, parameter2_type),
kMachPtr, MachineOperatorBuilder::kAllOptionalOps),
test_(test) {}
int local_count);
private:
- MachineSignature* MakeMachineSignature(Zone* zone,
- MachineType return_type) {
+ CallDescriptor* MakeCallDescriptor(Zone* zone, MachineType return_type) {
MachineSignature::Builder builder(zone, 1, 0);
builder.AddReturn(return_type);
- return builder.Build();
+ return Linkage::GetSimplifiedCDescriptor(zone, builder.Build());
}
- MachineSignature* MakeMachineSignature(Zone* zone, MachineType return_type,
- MachineType parameter0_type) {
+ CallDescriptor* MakeCallDescriptor(Zone* zone, MachineType return_type,
+ MachineType parameter0_type) {
MachineSignature::Builder builder(zone, 1, 1);
builder.AddReturn(return_type);
builder.AddParam(parameter0_type);
- return builder.Build();
+ return Linkage::GetSimplifiedCDescriptor(zone, builder.Build());
}
- MachineSignature* MakeMachineSignature(Zone* zone, MachineType return_type,
- MachineType parameter0_type,
- MachineType parameter1_type) {
+ CallDescriptor* MakeCallDescriptor(Zone* zone, MachineType return_type,
+ MachineType parameter0_type,
+ MachineType parameter1_type) {
MachineSignature::Builder builder(zone, 1, 2);
builder.AddReturn(return_type);
builder.AddParam(parameter0_type);
builder.AddParam(parameter1_type);
- return builder.Build();
+ return Linkage::GetSimplifiedCDescriptor(zone, builder.Build());
}
- MachineSignature* MakeMachineSignature(Zone* zone, MachineType return_type,
- MachineType parameter0_type,
- MachineType parameter1_type,
- MachineType parameter2_type) {
+ CallDescriptor* MakeCallDescriptor(Zone* zone, MachineType return_type,
+ MachineType parameter0_type,
+ MachineType parameter1_type,
+ MachineType parameter2_type) {
MachineSignature::Builder builder(zone, 1, 3);
builder.AddReturn(return_type);
builder.AddParam(parameter0_type);
builder.AddParam(parameter1_type);
builder.AddParam(parameter2_type);
- return builder.Build();
+ return Linkage::GetSimplifiedCDescriptor(zone, builder.Build());
}
private: