)

set(HEADERS

config.h

version.h

)

#endif

#include "common/common.h"

#include "core/core.h"

#include "core/settings.h"

#include <QDialogButtonBox>

/* TODO(bunnei): ImplementMe

#include <QHBoxLayout>

#include <QLabel>

/* TODO(bunnei): ImplementMe

GStickConfig::GStickConfig(common::Config::Control leftid, common::Config::Control rightid, common::Config::Control upid, common::Config::Control downid, QObject* change_receiver, QWidget* parent) : QWidget(parent)

#include <QStandardItemModel>

#include "core/core.h"

#include "core/arm/arm_interface.h"

// Licensed under GPLv2 or any later version

// Refer to the license.txt file included.

#include "common/common.h"

#include "core/mem_map.h"

// Licensed under GPLv2 or any later version

// Refer to the license.txt file included.

#include <QListView>

#include <QVBoxLayout>

#include <QDebug>

#include <QVBoxLayout>

#include <QLabel>

BreakPointModel::BreakPointModel(std::shared_ptr<Pica::DebugContext> debug_context, QObject* parent)

: QAbstractListModel(parent), context_weak(debug_context),

#include "video_core/debug_utils/debug_utils.h"

QImage LoadTexture(u8* src, const Pica::DebugUtils::TextureInfo& info) {

QImage decoded_image(info.width, info.height, QImage::Format_ARGB32);

cmd_id < PICA_REG_INDEX(reg_name) + sizeof(decltype(Pica::registers.reg_name)) / 4)

void GPUCommandListWidget::OnCommandDoubleClicked(const QModelIndex& index) {

if (COMMAND_IN_RANGE(command_id, texture0) ||

COMMAND_IN_RANGE(command_id, texture1) ||

COMMAND_IN_RANGE(command_id, texture2)) {

void GPUCommandListWidget::SetCommandInfo(const QModelIndex& index) {

QWidget* new_info_widget;

if (COMMAND_IN_RANGE(command_id, texture0) ||

COMMAND_IN_RANGE(command_id, texture1) ||

COMMAND_IN_RANGE(command_id, texture2)) {

#include "video_core/color.h"

#include "video_core/pica.h"

BreakPointObserverDock::BreakPointObserverDock(std::shared_ptr<Pica::DebugContext> debug_context,

const QString& title, QWidget* parent)

}

}

{

if (framebuffer_width != new_value) {

framebuffer_width = new_value;

}

}

{

if (framebuffer_height != new_value) {

framebuffer_height = new_value;

{

QImage decoded_image(framebuffer_width, framebuffer_height, QImage::Format_ARGB32);

u32* color_buffer = (u32*)Memory::GetPointer(Pica::PAddrToVAddr(framebuffer_address));

u32 value = *(color_buffer + x + y * framebuffer_width);

decoded_image.setPixel(x, y, qRgba((value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF, 255/*value >> 24*/));

{

QImage decoded_image(framebuffer_width, framebuffer_height, QImage::Format_ARGB32);

u8* color_buffer = Memory::GetPointer(Pica::PAddrToVAddr(framebuffer_address));

u8* pixel_pointer = color_buffer + x * 3 + y * 3 * framebuffer_width;

decoded_image.setPixel(x, y, qRgba(pixel_pointer[0], pixel_pointer[1], pixel_pointer[2], 255/*value >> 24*/));

{

QImage decoded_image(framebuffer_width, framebuffer_height, QImage::Format_ARGB32);

u32* color_buffer = (u32*)Memory::GetPointer(Pica::PAddrToVAddr(framebuffer_address));

u16 value = *(u16*)(((u8*)color_buffer) + x * 2 + y * framebuffer_width * 2);

u8 r = Color::Convert5To8((value >> 11) & 0x1F);

u8 g = Color::Convert5To8((value >> 6) & 0x1F);

public slots:

void OnFramebufferSourceChanged(int new_value);

void OnFramebufferAddressChanged(qint64 new_value);

void OnFramebufferFormatChanged(int new_value);

void OnUpdate();

// Licensed under GPLv2 or any later version

// Refer to the license.txt file included.

#include "common/common.h"

#include "core/mem_map.h"

// Licensed under GPLv2 or any later version

// Refer to the license.txt file included.

#include "core/core.h"

#include "core/arm/arm_interface.h"

#include <QKeySequence>

#include <QSettings>

#include <map>

struct Hotkey

#include <QDesktopWidget>

#include <QFileDialog>

#include "qhexedit.h"

#include "common/common.h"

#include "common/logging/text_formatter.h"

#include <unistd.h>

#endif

//debugger

#include "core/settings.h"

#include "core/system.h"

#include "common/log.h"

CSpinBox::CSpinBox(QWidget* parent) : QAbstractSpinBox(parent), base(10), min_value(-100), max_value(100), value(0), num_digits(0)

{

#ifdef _MSC_VER

inline unsigned long long bswap64(unsigned long long x) { return _byteswap_uint64(x); }

inline unsigned int bswap32(unsigned int x) { return _byteswap_ulong(x); }

inline unsigned short bswap16(unsigned short x) { return _byteswap_ushort(x); }

#else

// TODO: speedup

inline unsigned short bswap16(unsigned short x) { return (x << 8) | (x >> 8); }

inline unsigned int bswap32(unsigned int x) { return (x >> 24) | ((x & 0xFF0000) >> 8) | ((x & 0xFF00) << 8) | (x << 24);}

#define JAP_DIR "JAP"

// Subdirs in the User dir returned by GetUserPath(D_USER_IDX)

// Filenames

// Files in the directory returned by GetUserPath(D_CONFIG_IDX)

#include <cmath>

#include <cstdint>

typedef std::uint8_t u8; ///< 8-bit unsigned byte

typedef std::uint16_t u16; ///< 16-bit unsigned short

u8 _u8[8]; ///< 8-bit unsigned char(s)

};

namespace Common {

/// Rectangle data structure

class Rect {

int x1_; ///< Rect bottom left X-coordinate

int y1_; ///< Rect bottom right Y-coordinate

inline bool operator == (const Rect& val) const {

return (x0_ == val.x0_ && y0_ == val.y0_ && x1_ == val.x1_ && y1_ == val.y1_);

paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;

paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;

paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;

paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;

paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;

paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;

paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;

paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;

paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;

paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;

paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;

paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;

paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;

D_STATESAVES_IDX,

D_SCREENSHOTS_IDX,

D_SDMC_IDX,

D_SYSDATA_IDX,

D_HIRESTEXTURES_IDX,

D_DUMP_IDX,

D_DUMPFRAMES_IDX,

#endif

#endif

#ifdef ANDROID

// Hopefully this ABI will never change...

#endif // Android

SYSTEM_INFO sysInfo;

#endif

// Windows mappings need to be on 64K boundaries, due to Alpha legacy.

#ifdef _WIN32

size_t roundup(size_t x) {

int gran = sysInfo.dwAllocationGranularity ? sysInfo.dwAllocationGranularity : 0x10000;

return (x + gran - 1) & ~(gran - 1);

}

#else

void MemArena::GrabLowMemSpace(size_t size)

{

#ifdef _WIN32

hMemoryMapping = CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, (DWORD)(size), nullptr);

GetSystemInfo(&sysInfo);

#elif defined(ANDROID)

// Use ashmem so we don't have to allocate a file on disk!

fd = ashmem_create_region("PPSSPP_RAM", size);

#ifdef _WIN32

CloseHandle(hMemoryMapping);

hMemoryMapping = 0;

#else

close(fd);

#endif

void *MemArena::CreateView(s64 offset, size_t size, void *base)

{

#ifdef _WIN32

size = roundup(size);

void *ptr = MapViewOfFileEx(hMemoryMapping, FILE_MAP_ALL_ACCESS, 0, (DWORD)((u64)offset), size, base);

return ptr;

#else

void *retval = mmap(base, size, PROT_READ | PROT_WRITE, MAP_SHARED |

// Do not sync memory to underlying file. Linux has this by default.

MAP_NOSYNC |

#endif

((base == nullptr) ? 0 : MAP_FIXED), fd, offset);

void MemArena::ReleaseView(void* view, size_t size)

{

#ifdef _WIN32

UnmapViewOfFile(view);

#else

munmap(view, size);

#endif

}

u8* MemArena::Find4GBBase()

{

#ifdef _M_X64

}

return base;

#else

void* base = mmap(0, 0x10000000, PROT_READ | PROT_WRITE,

MAP_ANON | MAP_SHARED, -1, 0);

if (base == MAP_FAILED) {

return 0;

}

munmap(base, 0x10000000);

return static_cast<u8*>(base);

#endif

#endif

}

// yeah, this could also be done in like two bitwise ops...

size_t position = 0;

size_t last_position = 0;

// Zero all the pointers to be sure.

for (int i = 0; i < num_views; i++)

{

position = last_position;

}

else {

*(view.out_ptr_low) = (u8*)arena->CreateView(position, view.size);

if (!*view.out_ptr_low)

goto bail;

}

#endif

last_position = position;

position += roundup(view.size);

}

total_mem += roundup(views[i].size);

}

// Grab some pagefile backed memory out of the void ...

arena->GrabLowMemSpace(total_mem);

// Now, create views in high memory where there's plenty of space.

#ifdef _M_X64

PanicAlert("MemoryMap_Setup: Failed finding a memory base.");

return 0;

}

#elif defined(_WIN32)

// Try a whole range of possible bases. Return once we got a valid one.

u32 max_base_addr = 0x7FFF0000 - 0x10000000;

break;

}

}

#else

// Linux32 is fine with the x64 method, although limited to 32-bit with no automirrors.

u8 *base = MemArena::Find4GBBase();

#include <windows.h>

#endif

#include "common/common.h"

// This class lets you create a block of anonymous RAM, and then arbitrarily map views into it.

void *CreateView(s64 offset, size_t size, void *base = 0);

void ReleaseView(void *view, size_t size);

// This only finds 1 GB in 32-bit

static u8 *Find4GBBase();

private:

#ifdef _WIN32

#define PLATFORM_MACOSX 2

#define PLATFORM_LINUX 3

#define PLATFORM_ANDROID 4

////////////////////////////////////////////////////////////////////////////////////////////////////

// Platform detection

// MSVC

#elif defined(_MSC_VER) && !defined(COMMON_BIG_ENDIAN) && !defined(COMMON_LITTLE_ENDIAN)

#define COMMON_LITTLE_ENDIAN 1

#endif

typedef arm_core_t arm_processor;

typedef unsigned int (*shtop_fp_t)(arm_processor *cpu, unsigned int sht_oper);

// Exclusive memory access

static int exclusive_detect(ARMul_State* state, ARMword addr){

return 0;

else

return -1;

}

static void add_exclusive_addr(ARMul_State* state, ARMword addr){

return;

}

state->exclusive_tag = 0xFFFFFFFF;

}

unsigned int DPO(Immediate)(arm_processor *cpu, unsigned int sht_oper) {

unsigned int immed_8 = BITS(sht_oper, 0, 7);

unsigned int rotate_imm = BITS(sht_oper, 8, 11);

unsigned int Rn;

} smla_inst;

typedef struct ssat_inst {

unsigned int Rn;

unsigned int Rd;

return inst_base;

}

ARM_INST_PTR INTERPRETER_TRANSLATE(smlaw)(unsigned int inst, int index)

{

add_exclusive_addr(cpu, read_addr);

cpu->exclusive_state = 1;

RD = Memory::Read32(read_addr);

RD2 = Memory::Read32(read_addr + 4);

}

SMLALXY_INST:

SMLAW_INST:

{

if ((exclusive_detect(cpu, write_addr) == 0) && (cpu->exclusive_state == 1)) {

remove_exclusive(cpu, write_addr);

cpu->exclusive_state = 0;

Memory::Write32(write_addr, cpu->Reg[inst_cream->Rm]);

Memory::Write32(write_addr + 4, cpu->Reg[inst_cream->Rm + 1]);

addr = RN;

unsigned int value = Memory::Read8(addr);

Memory::Write8(addr, (RM & 0xFF));

}

cpu->Reg[15] += GET_INST_SIZE(cpu);

INC_PC(sizeof(swp_inst));

unsigned ErrorCode; /* type of illegal instruction */

/* Order of the following register should not be modified */

ARMword Spsr_copy;

ARMword phys_pc;

ARMword Reg_usr[2];

ARMword exclusive_state;

ARMword exclusive_result;

ARMword CP15[VFP_BASE - CP15_BASE];

#include "core/file_sys/archive_extsavedata.h"

#include "core/file_sys/disk_archive.h"

#include "core/settings.h"

////////////////////////////////////////////////////////////////////////////////////////////////////

static std::string GetExtSaveDataPath(const std::string& mount_point, const Path& path) {

std::vector<u8> vec_data = path.AsBinary();

const u32* data = reinterpret_cast<const u32*>(vec_data.data());

u32 save_low = data[1];

u32 save_high = data[2];

}

}

bool Archive_ExtSaveData::Initialize() {

/// File system interface to the ExtSaveData archive

class Archive_ExtSaveData final : public DiskArchive {

public:

/**

* Initialize the archive.

#include "core/file_sys/archive_savedata.h"

#include "core/file_sys/disk_archive.h"

#include "core/settings.h"

////////////////////////////////////////////////////////////////////////////////////////////////////

namespace FileSys {

LOG_INFO(Service_FS, "Directory %s set as SaveData.", this->mount_point.c_str());

}

ResultCode Archive_SaveData::Open(const Path& path) {

if (concrete_mount_point.empty())

if (!FileUtil::Exists(concrete_mount_point)) {

// When a SaveData archive is created for the first time, it is not yet formatted

// and the save file/directory structure expected by the game has not yet been initialized.

#include "common/file_util.h"

#include "core/file_sys/archive_savedatacheck.h"

////////////////////////////////////////////////////////////////////////////////////////////////////

// FileSys namespace

namespace FileSys {

}

ResultCode Archive_SaveDataCheck::Open(const Path& path) {

// this archive again with a different path, will corrupt the previously open file.

auto vec = path.AsBinary();

const u32* data = reinterpret_cast<u32*>(vec.data());

FileUtil::IOFile file(file_path, "rb");

std::fill(raw_data.begin(), raw_data.end(), 0);

namespace FileSys {

}

bool Archive_SDMC::Initialize() {

#include "core/file_sys/archive_systemsavedata.h"

#include "core/file_sys/disk_archive.h"

#include "core/settings.h"

////////////////////////////////////////////////////////////////////////////////////////////////////

return Common::StringFromFormat("%s%08X/%08X/", mount_point.c_str(), save_low, save_high);

}

Archive_SystemSaveData::Archive_SystemSaveData(const std::string& mount_point, u64 save_id)

LOG_INFO(Service_FS, "Directory %s set as SystemSaveData.", this->mount_point.c_str());

}

namespace FileSys {

/// File system interface to the SystemSaveData archive

class Archive_SystemSaveData final : public DiskArchive {

public:

Archive_SystemSaveData(const std::string& mount_point, u64 save_id);

{0x00040040, nullptr, "Finalize?"},

{0x00050040, nullptr, "GetAppletManInfo?"},

{0x00060040, nullptr, "GetAppletInfo?"},

{0x003B0040, nullptr, "CancelLibraryApplet?"},

{0x00430040, nullptr, "NotifyToWait?"},

{0x004B00C2, nullptr, "AppletUtility?"},

{0x00550040, nullptr, "WriteInputToNsState?"},

};

////////////////////////////////////////////////////////////////////////////////////////////////////

void CFGInit() {

// TODO(Subv): In the future we should use the FS service to query this archive,

// currently it is not possible because you can only have one open archive of the same type at any time

cfg_system_save_data = Common::make_unique<FileSys::Archive_SystemSaveData>(

if (!cfg_system_save_data->Initialize()) {

LOG_CRITICAL(Service_CFG, "Could not initialize SystemSaveData archive for the CFG:U service");

return;

const Interface::FunctionInfo FunctionTable[] = {

{0x00010082, GetConfigInfoBlk2, "GetConfigInfoBlk2"},

{0x00020000, nullptr, "SecureInfoGetRegion"},

{0x00040000, nullptr, "GetRegionCanadaUSA"},

{0x00050000, GetSystemModel, "GetSystemModel"},

{0x00060000, GetModelNintendo2DS, "GetModelNintendo2DS"},

{0x00090040, GetCountryCodeString, "GetCountryCodeString"},

{0x000A0040, GetCountryCodeID, "GetCountryCodeID"},

};

const Interface::FunctionInfo FunctionTable[] = {

{0x00010140, nullptr, "Initialize"},

{0x00020000, nullptr, "Shutdown"},

{0x00090082, nullptr, "FlushDCache"},

{0x000A0082, nullptr, "StoreDCache"},

{0x000B0082, nullptr, "InvalidateDCache"},

};

////////////////////////////////////////////////////////////////////////////////////////////////////

};

}

namespace Service {

namespace FS {

void ArchiveInit() {

next_handle = 1;

std::string sdmc_directory = FileUtil::GetUserPath(D_SDMC_IDX);

auto sdmc_archive = Common::make_unique<FileSys::Archive_SDMC>(sdmc_directory);

if (sdmc_archive->Initialize())

CreateArchive(std::move(sdmc_archive), ArchiveIdCode::SDMC);

LOG_ERROR(Service_FS, "Can't instantiate SDMC archive with path %s", sdmc_directory.c_str());

// Create the SaveData archive

CreateArchive(std::move(savedata_archive), ArchiveIdCode::SaveData);

if (extsavedata_archive->Initialize())

CreateArchive(std::move(extsavedata_archive), ArchiveIdCode::ExtSaveData);

else

if (sharedextsavedata_archive->Initialize())

CreateArchive(std::move(sharedextsavedata_archive), ArchiveIdCode::SharedExtSaveData);

else

LOG_ERROR(Service_FS, "Can't instantiate SharedExtSaveData archive with path %s",

// Create the SaveDataCheck archive, basically a small variation of the RomFS archive

CreateArchive(std::move(savedatacheck_archive), ArchiveIdCode::SaveDataCheck);

}

#include "core/hle/kernel/kernel.h"

#include "core/hle/result.h"

namespace Service {

namespace FS {

{0x00010000, nullptr, "GetHandles"},

{0x00020080, nullptr, "Initialize"},

{0x00030000, nullptr, "Shutdown"},

};

////////////////////////////////////////////////////////////////////////////////////////////////////

const Interface::FunctionInfo FunctionTable[] = {

{0x000100C2, nullptr, "Initialize"},

};

////////////////////////////////////////////////////////////////////////////////////////////////////

namespace NDM_U {

const Interface::FunctionInfo FunctionTable[] = {

};

////////////////////////////////////////////////////////////////////////////////////////////////////

Register(FunctionTable, ARRAY_SIZE(FunctionTable));

// Create the SharedExtSaveData archive 0xF000000B and the gamecoin.dat file

// TODO(Subv): In the future we should use the FS service to query this archive

if (!ptm_shared_extsavedata->Initialize()) {

return;

}

FileSys::Path archive_path(ptm_shared_extdata_id);

////////////////////////////////////////////////////////////////////////////////////////////////////

// Service Manager class

void Manager::AddService(Interface* service) {

// TOOD(yuriks): Fix error reporting

m_port_map[service->GetPortName()] = Kernel::g_handle_table.Create(service).ValueOr(INVALID_HANDLE);

m_services.push_back(service);

}

void Manager::DeleteService(const std::string& port_name) {

Interface* service = FetchFromPortName(port_name);

m_services.erase(std::remove(m_services.begin(), m_services.end(), service), m_services.end());

m_port_map.erase(port_name);

}

Interface* Manager::FetchFromHandle(Handle handle) {

return Kernel::g_handle_table.Get<Interface>(handle);

}

Interface* Manager::FetchFromPortName(const std::string& port_name) {

auto itr = m_port_map.find(port_name);

if (itr == m_port_map.end()) {

/// Simple class to manage accessing services from ports and UID handles

class Manager {

public:

void AddService(Interface* service);

void DeleteService(const std::string& port_name);

/// Get a Service Interface from its port

Interface* FetchFromPortName(const std::string& port_name);

private:

std::vector<Interface*> m_services;

std::map<std::string, u32> m_port_map;

};

/// Initialize ServiceManager

u32 socket_handle = static_cast<u32>(::socket(domain, type, protocol));

open_sockets[socket_handle] = { socket_handle, true };

int result = 0;

result = TranslateError(GET_ERRNO);

cmd_buffer[1] = result;

socklen_t addr_len = sizeof(addr);

u32 ret = static_cast<u32>(::accept(socket_handle, &addr, &addr_len));

open_sockets[ret] = { ret, true };

int result = 0;

result = TranslateError(GET_ERRNO);

} else {

CTRSockAddr ctr_addr = CTRSockAddr::FromPlatform(addr);

}

const Interface::FunctionInfo FunctionTable[] = {

};

////////////////////////////////////////////////////////////////////////////////////////////////////