99 lines
2.6 KiB
C++
99 lines
2.6 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/backend/x64/x64_code_cache.h"
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include "xenia/base/assert.h"
|
|
#include "xenia/base/math.h"
|
|
|
|
namespace xe {
|
|
namespace cpu {
|
|
namespace backend {
|
|
namespace x64 {
|
|
|
|
class X64CodeChunk {
|
|
public:
|
|
X64CodeChunk(size_t chunk_size);
|
|
~X64CodeChunk();
|
|
|
|
public:
|
|
X64CodeChunk* next;
|
|
size_t capacity;
|
|
uint8_t* buffer;
|
|
size_t offset;
|
|
};
|
|
|
|
X64CodeCache::X64CodeCache(size_t chunk_size)
|
|
: chunk_size_(chunk_size), head_chunk_(NULL), active_chunk_(NULL) {}
|
|
|
|
X64CodeCache::~X64CodeCache() {
|
|
std::lock_guard<std::mutex> guard(lock_);
|
|
auto chunk = head_chunk_;
|
|
while (chunk) {
|
|
auto next = chunk->next;
|
|
delete chunk;
|
|
chunk = next;
|
|
}
|
|
head_chunk_ = NULL;
|
|
}
|
|
|
|
int X64CodeCache::Initialize() { return 0; }
|
|
|
|
void* X64CodeCache::PlaceCode(void* machine_code, size_t code_size,
|
|
size_t stack_size) {
|
|
// Always move the code to land on 16b alignment. We do this by rounding up
|
|
// to 16b so that all offsets are aligned.
|
|
code_size = xe::round_up(code_size, 16);
|
|
|
|
lock_.lock();
|
|
|
|
if (active_chunk_) {
|
|
if (active_chunk_->capacity - active_chunk_->offset < code_size) {
|
|
auto next = active_chunk_->next;
|
|
if (!next) {
|
|
assert_true(code_size < chunk_size_, "need to support larger chunks");
|
|
next = new X64CodeChunk(chunk_size_);
|
|
active_chunk_->next = next;
|
|
}
|
|
active_chunk_ = next;
|
|
}
|
|
} else {
|
|
head_chunk_ = active_chunk_ = new X64CodeChunk(chunk_size_);
|
|
}
|
|
|
|
uint8_t* final_address = active_chunk_->buffer + active_chunk_->offset;
|
|
active_chunk_->offset += code_size;
|
|
|
|
lock_.unlock();
|
|
|
|
// Copy code.
|
|
memcpy(final_address, machine_code, code_size);
|
|
|
|
return final_address;
|
|
}
|
|
|
|
X64CodeChunk::X64CodeChunk(size_t chunk_size)
|
|
: next(NULL), capacity(chunk_size), buffer(0), offset(0) {
|
|
buffer = (uint8_t*)mmap(nullptr, chunk_size, PROT_WRITE | PROT_EXEC,
|
|
MAP_ANON | MAP_PRIVATE, -1, 0);
|
|
}
|
|
|
|
X64CodeChunk::~X64CodeChunk() {
|
|
if (buffer) {
|
|
munmap(buffer, capacity);
|
|
}
|
|
}
|
|
|
|
} // namespace x64
|
|
} // namespace backend
|
|
} // namespace cpu
|
|
} // namespace xe
|