108 lines
4.0 KiB
C++
108 lines
4.0 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2014 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "xenia/cpu/test_module.h"
|
|
|
|
#include "xenia/base/assert.h"
|
|
#include "xenia/base/platform.h"
|
|
#include "xenia/base/reset_scope.h"
|
|
#include "xenia/base/string.h"
|
|
#include "xenia/cpu/compiler/compiler_passes.h"
|
|
#include "xenia/cpu/processor.h"
|
|
|
|
namespace xe {
|
|
namespace cpu {
|
|
|
|
using xe::cpu::backend::Backend;
|
|
using xe::cpu::compiler::Compiler;
|
|
using xe::cpu::hir::HIRBuilder;
|
|
namespace passes = xe::cpu::compiler::passes;
|
|
|
|
TestModule::TestModule(Processor* processor, const std::string& name,
|
|
std::function<bool(uint32_t)> contains_address,
|
|
std::function<bool(hir::HIRBuilder&)> generate)
|
|
: Module(processor),
|
|
name_(name),
|
|
contains_address_(contains_address),
|
|
generate_(generate) {
|
|
builder_.reset(new HIRBuilder());
|
|
compiler_.reset(new Compiler(processor));
|
|
assembler_ = processor->backend()->CreateAssembler();
|
|
assembler_->Initialize();
|
|
|
|
// Merge blocks early. This will let us use more context in other passes.
|
|
// The CFG is required for simplification and dirtied by it.
|
|
compiler_->AddPass(std::make_unique<passes::ControlFlowAnalysisPass>());
|
|
compiler_->AddPass(std::make_unique<passes::ControlFlowSimplificationPass>());
|
|
compiler_->AddPass(std::make_unique<passes::ControlFlowAnalysisPass>());
|
|
|
|
// Passes are executed in the order they are added. Multiple of the same
|
|
// pass type may be used.
|
|
compiler_->AddPass(std::make_unique<passes::ContextPromotionPass>());
|
|
compiler_->AddPass(std::make_unique<passes::SimplificationPass>());
|
|
compiler_->AddPass(std::make_unique<passes::ConstantPropagationPass>());
|
|
compiler_->AddPass(std::make_unique<passes::SimplificationPass>());
|
|
// compiler_->AddPass(std::make_unique<passes::DeadStoreEliminationPass>());
|
|
compiler_->AddPass(std::make_unique<passes::DeadCodeEliminationPass>());
|
|
|
|
//// Removes all unneeded variables. Try not to add new ones after this.
|
|
// compiler_->AddPass(new passes::ValueReductionPass());
|
|
|
|
// Register allocation for the target backend.
|
|
// Will modify the HIR to add loads/stores.
|
|
// This should be the last pass before finalization, as after this all
|
|
// registers are assigned and ready to be emitted.
|
|
compiler_->AddPass(std::make_unique<passes::RegisterAllocationPass>(
|
|
processor->backend()->machine_info()));
|
|
|
|
// Must come last. The HIR is not really HIR after this.
|
|
compiler_->AddPass(std::make_unique<passes::FinalizationPass>());
|
|
}
|
|
|
|
TestModule::~TestModule() = default;
|
|
|
|
bool TestModule::ContainsAddress(uint32_t address) {
|
|
return contains_address_(address);
|
|
}
|
|
|
|
std::unique_ptr<Function> TestModule::CreateFunction(uint32_t address) {
|
|
return std::unique_ptr<Function>(
|
|
processor_->backend()->CreateGuestFunction(this, address));
|
|
}
|
|
|
|
Symbol::Status TestModule::DeclareFunction(uint32_t address,
|
|
Function** out_function) {
|
|
Symbol::Status status = Module::DeclareFunction(address, out_function);
|
|
if (status == Symbol::Status::kNew) {
|
|
auto function = static_cast<GuestFunction*>(*out_function);
|
|
|
|
// Reset() all caching when we leave.
|
|
xe::make_reset_scope(compiler_);
|
|
xe::make_reset_scope(assembler_);
|
|
|
|
if (!generate_(*builder_.get())) {
|
|
function->set_status(Symbol::Status::kFailed);
|
|
return Symbol::Status::kFailed;
|
|
}
|
|
|
|
// Run optimization passes.
|
|
compiler_->Compile(builder_.get());
|
|
|
|
// Assemble the function.
|
|
assembler_->Assemble(function, builder_.get(), 0, nullptr);
|
|
|
|
status = Symbol::Status::kDefined;
|
|
function->set_status(status);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
} // namespace cpu
|
|
} // namespace xe
|