496697df4e
This utility will be used to simplify Linkage and fix representation inference to work with graphs where parameters and return values are something other than tagged. It will also make testing representation inference a lot easier, since we can then exactly nail down the machine types of parameters and returns. This CL also adds c-signature.h, which demonstrates how to convert C function signatures into MachineSignatures. The CSignatures will be used in tests to make it easier and simpler to codegen tests. R=jarin@chromium.org BUG= Review URL: https://codereview.chromium.org/515173002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23490 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
128 lines
4.0 KiB
C++
128 lines
4.0 KiB
C++
// 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_
|