desmume/src/utils/task_vita.cpp 000664 001750 001750 00000007114 12755534123 017773 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2009-2015 DeSmuME team
Copyright (C) 2015 Sergi Granell (xerpi)
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#include
#include
#include "../utils/task.h"
#include "debug.h"
class Task::Impl {
private:
SceUID _thread;
bool _isThreadRunning;
public:
Impl();
~Impl();
void start();
void execute(const TWork &work, void *param);
void* finish();
void shutdown();
//slock_t *mutex;
SceUID condWork;
TWork workFunc;
void *workFuncParam;
void *ret;
bool exitThread;
};
#define EVENT_WORK_START 1
#define EVENT_WORK_END 2
static int taskProc(SceSize args, void *argp)
{
Task::Impl *ctx = *(Task::Impl **)argp;
do {
while (!ctx->workFunc && !ctx->exitThread)
sceKernelWaitEventFlag(ctx->condWork, EVENT_WORK_START,
SCE_EVENT_WAITAND, NULL, NULL);
sceKernelClearEventFlag(ctx->condWork, ~EVENT_WORK_START);
if (ctx->workFunc)
ctx->ret = ctx->workFunc(ctx->workFuncParam);
else
ctx->ret = NULL;
ctx->workFunc = NULL;
sceKernelSetEventFlag(ctx->condWork, EVENT_WORK_END);
} while(!ctx->exitThread);
return 0;
}
Task::Impl::Impl()
{
_isThreadRunning = false;
workFunc = NULL;
workFuncParam = NULL;
ret = NULL;
exitThread = false;
condWork = sceKernelCreateEventFlag("desmume_cond_work", 0, 0, NULL);
}
Task::Impl::~Impl()
{
shutdown();
sceKernelDeleteEventFlag(condWork);
}
void Task::Impl::start()
{
if (this->_isThreadRunning)
{
return;
}
this->workFunc = NULL;
this->workFuncParam = NULL;
this->ret = NULL;
this->exitThread = false;
this->_thread = sceKernelCreateThread("desmume_task", taskProc,
0x10000100, 0x1000, 0, 0, NULL);
sceKernelClearEventFlag(condWork, ~(EVENT_WORK_START | EVENT_WORK_END));
Task::Impl *_this = this;
sceKernelStartThread(this->_thread, sizeof(_this), &_this);
this->_isThreadRunning = true;
}
void Task::Impl::execute(const TWork &work, void *param)
{
if (!work || !this->_isThreadRunning)
return;
this->workFunc = work;
this->workFuncParam = param;
sceKernelSetEventFlag(condWork, EVENT_WORK_START);
}
void* Task::Impl::finish()
{
void *returnValue = NULL;
if (!this->_isThreadRunning)
goto end;
while (this->workFunc != NULL)
sceKernelWaitEventFlag(condWork, EVENT_WORK_END,
SCE_EVENT_WAITAND, NULL, NULL);
sceKernelClearEventFlag(condWork, ~EVENT_WORK_END);
returnValue = this->ret;
end:
return returnValue;
}
void Task::Impl::shutdown()
{
if (!this->_isThreadRunning)
return;
this->workFunc = NULL;
this->exitThread = true;
sceKernelSetEventFlag(condWork, EVENT_WORK_START | EVENT_WORK_END);
sceKernelWaitThreadEnd(_thread, NULL, NULL);
sceKernelDeleteThread(_thread);
this->_isThreadRunning = false;
}
void Task::start() { impl->start(); }
void Task::shutdown() { impl->shutdown(); }
Task::Task() : impl(new Task::Impl()) {}
Task::~Task() { delete impl; }
void Task::execute(const TWork &work, void* param) { impl->execute(work,param); }
void* Task::finish() { return impl->finish(); }
desmume/src/libretro-common/lists/ 000700 001750 001750 00000000000 12756420131 020363 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/include/glsm/glsm.h 000664 001750 001750 00000011446 12755534123 022755 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this libretro SDK code part (glsm.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef LIBRETRO_SDK_GLSM_H
#define LIBRETRO_SDK_GLSM_H
#include
#include
#include
#include
RETRO_BEGIN_DECLS
#ifdef HAVE_OPENGLES2
typedef GLfloat GLdouble;
typedef GLclampf GLclampd;
#endif
#if defined(HAVE_OPENGLES2)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_OES
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT
#elif defined(OSX_PPC)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER_EXT
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_EXT
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT_EXT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT_EXT
#elif defined(HAVE_PSGL)
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER_OES
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8_SCE
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT_OES
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT_OES
#else
#define RARCH_GL_RENDERBUFFER GL_RENDERBUFFER
#define RARCH_GL_DEPTH24_STENCIL8 GL_DEPTH24_STENCIL8
#define RARCH_GL_DEPTH_ATTACHMENT GL_DEPTH_ATTACHMENT
#define RARCH_GL_STENCIL_ATTACHMENT GL_STENCIL_ATTACHMENT
#endif
#if defined(HAVE_PSGL)
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_OES
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
#elif defined(OSX_PPC)
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_EXT
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_EXT
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0_EXT
#else
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE
#define RARCH_GL_COLOR_ATTACHMENT0 GL_COLOR_ATTACHMENT0
#endif
#ifndef GL_FOG
#define GL_FOG 0x0B60
#endif
#ifndef GL_ALPHA_TEST
#define GL_ALPHA_TEST 0x0BC0
#endif
#ifndef GL_CLIP_DISTANCE0
#define GL_CLIP_DISTANCE0 0x3000
#endif
#define MAX_ATTRIB 8
enum
{
SGL_DEPTH_TEST = 0,
SGL_BLEND,
SGL_POLYGON_OFFSET_FILL,
SGL_FOG,
SGL_CULL_FACE,
SGL_ALPHA_TEST,
SGL_SCISSOR_TEST,
SGL_STENCIL_TEST,
#if !defined(HAVE_OPENGLES)
SGL_DEPTH_CLAMP,
SGL_CLIP_DISTANCE0,
#endif
SGL_DITHER,
SGL_SAMPLE_ALPHA_TO_COVERAGE,
SGL_SAMPLE_COVERAGE,
#ifndef HAVE_OPENGLES
SGL_COLOR_LOGIC_OP,
#endif
SGL_CAP_MAX
};
enum glsm_state_ctl
{
GLSM_CTL_NONE = 0,
GLSM_CTL_STATE_SETUP,
GLSM_CTL_STATE_BIND,
GLSM_CTL_STATE_UNBIND,
GLSM_CTL_STATE_CONTEXT_RESET,
GLSM_CTL_STATE_CONTEXT_DESTROY,
GLSM_CTL_STATE_CONTEXT_INIT,
GLSM_CTL_IS_IMM_VBO,
GLSM_CTL_SET_IMM_VBO,
GLSM_CTL_UNSET_IMM_VBO,
GLSM_CTL_IMM_VBO_DISABLE,
GLSM_CTL_IMM_VBO_DRAW,
GLSM_CTL_PROC_ADDRESS_GET
};
typedef bool (*glsm_imm_vbo_draw)(void *);
typedef bool (*glsm_imm_vbo_disable)(void *);
typedef bool (*glsm_framebuffer_lock)(void *);
typedef struct glsm_ctx_proc_address
{
retro_get_proc_address_t addr;
} glsm_ctx_proc_address_t;
typedef struct glsm_ctx_params
{
glsm_framebuffer_lock framebuffer_lock;
glsm_imm_vbo_draw imm_vbo_draw;
glsm_imm_vbo_disable imm_vbo_disable;
retro_hw_context_reset_t context_reset;
retro_hw_context_reset_t context_destroy;
retro_environment_t environ_cb;
bool stencil;
unsigned major;
unsigned minor;
} glsm_ctx_params_t;
GLuint glsm_get_current_framebuffer(void);
bool glsm_ctl(enum glsm_state_ctl state, void *data);
RETRO_END_DECLS
#endif
desmume/src/libretro-common/include/gfx/math/vector_2.h 000664 001750 001750 00000003351 12755534123 024305 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (vector_2.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_GFX_MATH_VECTOR_3_H__
#define __LIBRETRO_SDK_GFX_MATH_VECTOR_3_H__
#include
typedef float vec2_t[2];
float vec2_dot(const float *a, const float *b);
float vec2_cross(const float *a, const float *b) ;
void vec2_add(float *dst, const float *src);
void vec2_subtract(float *dst, const float *src);
void vec2_copy(float *dst, const float *src);
#endif
desmume/src/NDSSystem.cpp 000664 001750 001750 00000234647 12755534123 016514 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2006 yopyop
Copyright (C) 2008-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#include "NDSSystem.h"
#include
#include
#include
#include
#include
extern unsigned long crc32(unsigned long, const unsigned char*,unsigned int);
#include "utils/dlditool.h"
#include "utils/decrypt/decrypt.h"
#include "utils/decrypt/crc.h"
#include "utils/advanscene.h"
#include "utils/task.h"
#include "utils/bits.h"
#include "common.h"
#include "armcpu.h"
#include "render3D.h"
#include "MMU.h"
#include "gfx3d.h"
#include "GPU.h"
#include "cp15.h"
#include "bios.h"
#include "debug.h"
#include "cheatSystem.h"
#include "movie.h"
#include "emufile.h"
#ifdef DEBUG
#include "Disassembler.h"
#endif
#include "FIFO.h"
#include "readwrite.h"
#include "registers.h"
#ifdef DEBUG
#include "debug.h"
#endif
#include "driver.h"
#include "firmware.h"
#include "version.h"
#include "path.h"
#include "slot1.h"
#include "slot2.h"
#include "SPU.h"
#include "wifi.h"
//int xxctr=0;
//#define LOG_ARM9
//#define LOG_ARM7
//#define dolog (currFrameCounter>30)
bool dolog = false;
//#define LOG_TO_FILE
//#define LOG_TO_FILE_REGS
//===============================================================
FILE *fp_dis7 = NULL;
FILE *fp_dis9 = NULL;
PathInfo path;
TCommonSettings CommonSettings;
static BaseDriver _stub_driver;
BaseDriver* driver = &_stub_driver;
static BOOL LidClosed = FALSE;
static u8 countLid = 0;
GameInfo gameInfo;
NDSSystem nds;
CFIRMWARE *firmware = NULL;
using std::min;
using std::max;
bool singleStep;
bool nds_debug_continuing[2];
TSCalInfo TSCal;
extern "C" int DLDI_tryPatch(void* data, size_t size, unsigned int device);
void Desmume_InitOnce()
{
static bool initOnce = false;
if(initOnce) return;
initOnce = true;
}
int NDS_GetCPUCoreCount(void)
{
int amount = cpu_features_get_core_amount();
return amount;
}
void NDS_SetupDefaultFirmware()
{
NDS_FillDefaultFirmwareConfigData(&CommonSettings.fw_config);
}
void NDS_RunAdvansceneAutoImport()
{
if(CommonSettings.run_advanscene_import != "")
{
std::string fname = CommonSettings.run_advanscene_import;
std::string fname_out = fname + ".ddb";
EMUFILE_FILE outf(fname_out,"wb");
u32 ret = advsc.convertDB(fname.c_str(),&outf);
if(ret == 0)
exit(0);
else exit(1);
}
}
int NDS_Init()
{
nds.idleFrameCounter = 0;
memset(nds.runCycleCollector,0,sizeof(nds.runCycleCollector));
MMU_Init();
//got to print this somewhere..
printf("%s\n", EMU_DESMUME_NAME_AND_VERSION());
{
char buf[PATH_MAX_LENGTH];
memset(buf, 0, sizeof(buf));
strcpy(buf, path.pathToModule);
strcat(buf, "desmume.ddb"); // DeSmuME database :)
advsc.setDatabase(buf);
//why is this done here? shitty engineering. not intended.
NDS_RunAdvansceneAutoImport();
}
armcpu_new(&NDS_ARM9,0);
NDS_ARM9.SetBaseMemoryInterface(&arm9_base_memory_iface);
NDS_ARM9.SetBaseMemoryInterfaceData(NULL);
NDS_ARM9.ResetMemoryInterfaceToBase();
armcpu_new(&NDS_ARM7,1);
NDS_ARM7.SetBaseMemoryInterface(&arm7_base_memory_iface);
NDS_ARM7.SetBaseMemoryInterfaceData(NULL);
NDS_ARM7.ResetMemoryInterfaceToBase();
if (GPU != NULL)
delete GPU;
GPU = new GPUSubsystem;
if (SPU_Init(SNDCORE_DUMMY, 740) != 0)
return -1;
WIFI_Init() ;
cheats = new CHEATS();
return 0;
}
void NDS_DeInit(void)
{
gameInfo.closeROM();
SPU_DeInit();
delete GPU;
GPU = NULL;
MMU_DeInit();
WIFI_DeInit();
delete cheats;
cheats = NULL;
#ifdef HAVE_JIT
arm_jit_close();
#endif
#ifdef LOG_ARM7
if (fp_dis7 != NULL)
{
fclose(fp_dis7);
fp_dis7 = NULL;
}
#endif
#ifdef LOG_ARM9
if (fp_dis9 != NULL)
{
fclose(fp_dis9);
fp_dis9 = NULL;
}
#endif
}
NDS_header* NDS_getROMHeader(void)
{
NDS_header *newHeader = new NDS_header;
memcpy(newHeader, &gameInfo.header, sizeof(NDS_header));
return newHeader;
}
#ifdef DEBUG
void debug()
{
//if(NDS_ARM9.R[15]==0x020520DC) emu_halt();
//DSLinux
//if(NDS_ARM9.CPSR.bits.mode == 0) emu_halt();
//if((NDS_ARM9.R[15]&0xFFFFF000)==0) emu_halt();
//if((NDS_ARM9.R[15]==0x0201B4F4)/*&&(NDS_ARM9.R[1]==0x0)*/) emu_halt();
//AOE
//if((NDS_ARM9.R[15]==0x01FFE194)&&(NDS_ARM9.R[0]==0)) emu_halt();
//if((NDS_ARM9.R[15]==0x01FFE134)&&(NDS_ARM9.R[0]==0)) emu_halt();
//BBMAN
//if(NDS_ARM9.R[15]==0x02098B4C) emu_halt();
//if(NDS_ARM9.R[15]==0x02004924) emu_halt();
//if(NDS_ARM9.R[15]==0x02004890) emu_halt();
//if(NDS_ARM9.R[15]==0x0202B800) emu_halt();
//if(NDS_ARM9.R[15]==0x0202B3DC) emu_halt();
//if((NDS_ARM9.R[1]==0x9AC29AC1)&&(!fait)) {emu_halt();fait = TRUE;}
//if(NDS_ARM9.R[1]==0x0400004A) {emu_halt();fait = TRUE;}
/*if(NDS_ARM9.R[4]==0x2E33373C) emu_halt();
if(NDS_ARM9.R[15]==0x02036668) //emu_halt();
{
nds.logcount++;
sprintf(logbuf, "%d %08X", nds.logcount, NDS_ARM9.R[13]);
log::ajouter(logbuf);
if(nds.logcount==89) execute=FALSE;
}*/
//if(NDS_ARM9.instruction==0) emu_halt();
//if((NDS_ARM9.R[15]>>28)) emu_halt();
}
#endif
RomBanner::RomBanner(bool defaultInit)
{
if(!defaultInit) return;
version = 1; //Version (0001h)
crc16 = 0; //CRC16 across entries 020h..83Fh
memset(reserved,0,sizeof(reserved));
memset(bitmap,0,sizeof(bitmap));
memset(palette,0,sizeof(palette));
memset(titles,0,sizeof(titles));
memset(end0xFF,0,sizeof(end0xFF));
}
bool GameInfo::hasRomBanner()
{
if(header.IconOff + sizeof(RomBanner) > romsize)
return false;
else return true;
}
const RomBanner& GameInfo::getRomBanner()
{
return banner;
}
void GameInfo::populate()
{
const char regions_index[] = "JPFSEODIRKHXVWUC";
const char *regions[] = {
"???",
"JPN", // J
"EUR", // P
"FRA", // F
"ESP", // S
"USA", // E
"INT", // O
"NOE", // D
"ITA", // I
"RUS", // R
"KOR", // K
"HOL", // H
"EUU", // X
"EUU", // V
"EUU", // W
"AUS", // U
"CHN", // C
};
memset(ROMserial, 0, sizeof(ROMserial));
memset(ROMname, 0, sizeof(ROMname));
if(isHomebrew())
{
//we can't really make a serial for a homebrew game that hasnt set a game code
strcpy(ROMserial, "Homebrew");
}
else
{
if (isDSiEnhanced())
strcpy(ROMserial,"TWL- -");
else
strcpy(ROMserial,"NTR- -");
memcpy(ROMserial+4, header.gameCode, 4);
u32 regions_num = ARRAY_SIZE(regions);
u32 region = (u32)(std::max(strchr(regions_index,header.gameCode[3]) - regions_index + 1, 0));
if (region < regions_num)
strcat(ROMserial, regions[region]);
else
strcat(ROMserial, "???");
}
//rom name is probably set even in homebrew, so do it regardless
memset(ROMname, 0, sizeof(ROMname));
memcpy(ROMname, header.gameTile, 12);
string_trim_whitespace(ROMname);
/*if(header.IconOff < romsize)
{
u8 num = (T1ReadByte((u8*)romdata, header.IconOff) == 1)?6:7;
for (int i = 0; i < num; i++)
{
wcstombs(ROMfullName[i], (wchar_t *)(romdata+header.IconOff+0x240+(i*0x100)), 0x100);
trim(ROMfullName[i]);
}
}*/
}
bool GameInfo::loadROM(std::string fname, u32 type)
{
//printf("ROM %s\n", CommonSettings.loadToMemory?"loaded to RAM":"stream from disk");
closeROM();
fROM = fopen(fname.c_str(), "rb");
if (!fROM) return false;
headerOffset = (type == ROM_DSGBA)?DSGBA_LOADER_SIZE:0;
fseek(fROM, 0, SEEK_END);
romsize = ftell(fROM) - headerOffset;
fseek(fROM, headerOffset, SEEK_SET);
bool res = (fread(&header, 1, sizeof(header), fROM) == sizeof(header));
if (res)
{
#ifdef MSB_FIRST
//endian swap necessary fields. It would be better if we made accessors for these. I wonder if you could make a macro for a field accessor that would take the bitsize and do the swap on the fly
struct FieldSwap {
const size_t offset;
const size_t bytes;
};
static const FieldSwap fieldSwaps[] = {
{ offsetof(NDS_header,makerCode), 2},
{ offsetof(NDS_header,ARM9src), 4},
{ offsetof(NDS_header,ARM9exe), 4},
{ offsetof(NDS_header,ARM9cpy), 4},
{ offsetof(NDS_header,ARM9binSize), 4},
{ offsetof(NDS_header,ARM7src), 4},
{ offsetof(NDS_header,ARM7exe), 4},
{ offsetof(NDS_header,ARM7cpy), 4},
{ offsetof(NDS_header,ARM7binSize), 4},
{ offsetof(NDS_header,FNameTblOff), 4},
{ offsetof(NDS_header,FNameTblSize), 4},
{ offsetof(NDS_header,FATOff), 4},
{ offsetof(NDS_header,FATSize), 4},
{ offsetof(NDS_header,ARM9OverlayOff), 4},
{ offsetof(NDS_header,ARM9OverlaySize), 4},
{ offsetof(NDS_header,ARM7OverlayOff), 4},
{ offsetof(NDS_header,ARM7OverlaySize), 4},
{ offsetof(NDS_header,normalCmd), 4},
{ offsetof(NDS_header,Key1Cmd), 4},
{ offsetof(NDS_header,IconOff), 4},
{ offsetof(NDS_header,CRC16), 2},
{ offsetof(NDS_header,ROMtimeout), 2},
{ offsetof(NDS_header,ARM9autoload), 4},
{ offsetof(NDS_header,ARM7autoload), 4},
{ offsetof(NDS_header,endROMoffset), 4},
{ offsetof(NDS_header,HeaderSize), 4},
{ offsetof(NDS_header, ARM9module), 4},
{ offsetof(NDS_header, ARM7module), 4},
{ offsetof(NDS_header,logoCRC16), 2},
{ offsetof(NDS_header,headerCRC16), 2},
};
for(size_t i = 0; i < ARRAY_SIZE(fieldSwaps); i++)
{
const u8 *fieldAddr = (u8 *)&header + fieldSwaps[i].offset;
switch(fieldSwaps[i].bytes)
{
case 2:
*(u16 *)fieldAddr = LE_TO_LOCAL_16(*(u16 *)fieldAddr);
break;
case 4:
*(u32 *)fieldAddr = LE_TO_LOCAL_32(*(u32 *)fieldAddr);
break;
}
}
#endif
cardSize = (128 * 1024) << header.cardSize;
if (cardSize < romsize)
{
msgbox->warn("The ROM header is invalid.\nThe device size has been increased to allow for the provided file size.\n");
for (u32 i = header.cardSize; i < 0xF; i++)
{
if (((128 * 1024) << i) >= romsize)
{
header.cardSize = i;
cardSize = (128 * 1024) << i;
break;
}
}
}
mask = (cardSize - 1);
mask |= (mask >>1);
mask |= (mask >>2);
mask |= (mask >>4);
mask |= (mask >>8);
mask |= (mask >>16);
if (type == ROM_NDS)
{
size_t elements_read;
fseek(fROM, 0x4000 + headerOffset, SEEK_SET);
elements_read = fread(&secureArea[0], 1, 0x4000, fROM);
if (elements_read != 0x4000)
printf("Unexpectedly short post-header bit.\n");
}
if (CommonSettings.loadToMemory)
{
fseek(fROM, headerOffset, SEEK_SET);
romdata = new u8[romsize + 4];
if (fread(romdata, 1, romsize, fROM) != romsize)
{
delete [] romdata; romdata = NULL;
romsize = 0;
return false;
}
if(hasRomBanner())
{
memcpy(&banner, romdata + header.IconOff, sizeof(RomBanner));
banner.version = LE_TO_LOCAL_16(banner.version);
banner.crc16 = LE_TO_LOCAL_16(banner.crc16);
for(size_t i = 0; i < ARRAY_SIZE(banner.palette); i++)
{
banner.palette[i] = LE_TO_LOCAL_16(banner.palette[i]);
}
}
_isDSiEnhanced = (LE_TO_LOCAL_32(*(u32*)(romdata + 0x180) == 0x8D898581U) && LE_TO_LOCAL_32(*(u32*)(romdata + 0x184) == 0x8C888480U));
fclose(fROM); fROM = NULL;
return true;
}
_isDSiEnhanced = ((readROM(0x180) == 0x8D898581U) && (readROM(0x184) == 0x8C888480U));
if (hasRomBanner())
{
size_t elements_read;
const size_t elements_to_read = sizeof(RomBanner);
fseek(fROM, header.IconOff + headerOffset, SEEK_SET);
elements_read = fread(&banner, 1, elements_to_read, fROM);
if (elements_read != elements_to_read)
printf("Unexpectedly short post-header bit.\n");
banner.version = LE_TO_LOCAL_16(banner.version);
banner.crc16 = LE_TO_LOCAL_16(banner.crc16);
for(size_t i = 0; i < ARRAY_SIZE(banner.palette); i++)
{
banner.palette[i] = LE_TO_LOCAL_16(banner.palette[i]);
}
}
fseek(fROM, headerOffset, SEEK_SET);
lastReadPos = 0;
return true;
}
romsize = 0;
fclose(fROM); fROM = NULL;
return false;
}
void GameInfo::closeROM()
{
if (fROM)
fclose(fROM);
if (romdata)
delete [] romdata;
fROM = NULL;
romdata = NULL;
romsize = 0;
lastReadPos = 0xFFFFFFFF;
}
u32 GameInfo::readROM(u32 pos)
{
if (!romdata)
{
u32 data;
if (lastReadPos != pos)
fseek(fROM, pos + headerOffset, SEEK_SET);
u32 num = fread(&data, 1, 4, fROM);
lastReadPos = (pos + num);
return LE_TO_LOCAL_32(data);
}
else
{
if(pos + 4 > romsize)
{
printf("Panic! GameInfo reading out of buffer!\n");
exit(-1);
}
return LE_TO_LOCAL_32(*(u32*)(romdata + pos));
}
}
bool GameInfo::isDSiEnhanced()
{
return _isDSiEnhanced;
}
bool GameInfo::isHomebrew()
{
return ((header.ARM9src < 0x4000) && (T1ReadLong(header.logo, 0) != 0x51AEFF24) && (T1ReadLong(header.logo, 4) != 0x699AA221));
}
static int rom_init_path(const char *filename, const char *physicalName, const char *logicalFilename)
{
u32 type = ROM_NDS;
path.init(logicalFilename? logicalFilename : filename);
if ( path.isdsgba(path.path)) {
type = ROM_DSGBA;
gameInfo.loadROM(path.path, type);
}
else if ( !strcasecmp(path.extension().c_str(), "nds")) {
type = ROM_NDS;
gameInfo.loadROM(physicalName ? physicalName : path.path, type); //n.b. this does nothing if the file can't be found (i.e. if it was an extracted tempfile)...
//...but since the data was extracted to gameInfo then it is ok
}
//ds.gba in archives, it's already been loaded into memory at this point
else if (logicalFilename && path.isdsgba(std::string(logicalFilename))) {
type = ROM_DSGBA;
} else {
//well, try to load it as an nds rom anyway
type = ROM_NDS;
gameInfo.loadROM(physicalName ? physicalName : path.path, type);
}
//check that size is at least the size of the header
if (gameInfo.romsize < 352) {
return -1;
}
gameInfo.romType = type;
return 1;
}
int NDS_LoadROM(const char *filename, const char *physicalName, const char *logicalFilename)
{
int ret;
char buf[PATH_MAX_LENGTH];
if (filename == NULL)
return -1;
ret = rom_init_path(filename, physicalName, logicalFilename);
if (ret < 1)
return ret;
//check whether this rom is any kind of valid
if(!CheckValidRom((u8*)&gameInfo.header, gameInfo.secureArea))
{
printf("Specified file is not a valid rom\n");
return -1;
}
gameInfo.populate();
if (CommonSettings.loadToMemory)
gameInfo.crc = crc32(0, (u8*)gameInfo.romdata, gameInfo.romsize);
else
gameInfo.crc = 0;
gameInfo.chipID = 0xC2; // The Manufacturer ID is defined by JEDEC (C2h = Macronix)
if (!gameInfo.isHomebrew())
{
gameInfo.chipID |= ((((128 << gameInfo.header.cardSize) / 1024) - 1) << 8); // Chip size in megabytes minus 1
// (07h = 8MB, 0Fh = 16MB, 1Fh = 32MB, 3Fh = 64MB, 7Fh = 128MB)
// flags
// 0: Unknown
// 1: Unknown
// 2: Unknown
// 3: Unknown
// 4: Unknown
// 5: DSi? (if set to 1 then DSi Enhanced games send command D6h to Slot1)
// 6: Unknown
// 7: ROM speed (Secure Area Block transfer mode (trasfer 8x200h or 1000h bytes)
// TODO:
//if (gameInfo.isDSiEnhanced())
// gameInfo.chipID |= (0x40 << 24);
gameInfo.chipID |= (0x00 << 24);
}
#ifdef DEBUG
INFO("\nROM game code: %c%c%c%c\n", gameInfo.header.gameCode[0], gameInfo.header.gameCode[1], gameInfo.header.gameCode[2], gameInfo.header.gameCode[3]);
if (gameInfo.crc)
INFO("ROM crc: %08X\n", gameInfo.crc);
if (!gameInfo.isHomebrew())
{
INFO("ROM serial: %s\n", gameInfo.ROMserial);
INFO("ROM chipID: %08X\n", gameInfo.chipID);
INFO("ROM internal name: %s\n", gameInfo.ROMname);
if (gameInfo.isDSiEnhanced()) INFO("ROM DSi Enhanced\n");
}
INFO("ROM developer: %s\n", ((gameInfo.header.makerCode == 0) && gameInfo.isHomebrew())
? "Homebrew" :
getDeveloperNameByID(gameInfo.header.makerCode));
#endif
buf[0] = gameInfo.header.gameCode[0];
buf[1] = gameInfo.header.gameCode[1];
buf[2] = gameInfo.header.gameCode[2];
buf[3] = gameInfo.header.gameCode[3];
buf[4] = 0;
if (advsc.checkDB(buf, gameInfo.crc))
{
u8 sv = advsc.getSaveType();
printf("Found in game database by %s:\n", advsc.getIdMethod());
printf("\t* ROM serial:\t\t%s\n", advsc.getSerial());
printf("\t* ROM save type:\t");
if (sv == 0xFF)
printf("Unknown");
else
if (sv == 0xFE)
printf("None");
else
{
printf("%s", save_types[sv + 1].descr);
if (CommonSettings.autodetectBackupMethod == 1)
backup_setManualBackupType(sv + 1);
}
printf("\n\t* ROM crc:\t\t%08X\n", advsc.getCRC32());
}
printf("\n");
//for homebrew, try auto-patching DLDI. should be benign if there is no DLDI or if it fails
if(gameInfo.isHomebrew())
{
if(!CommonSettings.loadToMemory)
msgbox->warn("Sorry.. right now, you can't use the default (stream rom from disk) with homebrew due to a bug with DLDI-autopatching");
if (slot1_GetCurrentType() == NDS_SLOT1_R4)
DLDI_tryPatch((void*)gameInfo.romdata, gameInfo.romsize, 1);
else
if (slot2_GetCurrentType() == NDS_SLOT2_CFLASH)
DLDI_tryPatch((void*)gameInfo.romdata, gameInfo.romsize, 0);
}
if (cheats != NULL)
{
memset(buf, 0, sizeof(buf));
path.getpathnoext(path.CHEATS, buf);
strcat(buf, ".dct"); // DeSmuME cheat :)
cheats->init(buf);
}
NDS_Reset();
return ret;
}
void NDS_FreeROM(void)
{
gameInfo.closeROM();
}
void NDS_Sleep() { nds.sleeping = TRUE; }
void NDS_TriggerCardEjectIRQ()
{
NDS_makeIrq(ARMCPU_ARM7, IRQ_BIT_GC_IREQ_MC);
NDS_makeIrq(ARMCPU_ARM9, IRQ_BIT_GC_IREQ_MC); //zero added on 11-aug-2013 with no proof of accuracy
}
class FrameSkipper
{
public:
void RequestSkip()
{
nextSkip = true;
}
void OmitSkip(bool force, bool forceEvenIfCapturing=false)
{
nextSkip = false;
if((force && consecutiveNonCaptures > 30) || forceEvenIfCapturing)
{
SkipCur2DFrame = false;
SkipCur3DFrame = false;
SkipNext2DFrame = false;
if(forceEvenIfCapturing)
consecutiveNonCaptures = 0;
}
}
void Advance()
{
const GPUEngineA *mainEngine = GPU->GetEngineMain();
bool capturing = (mainEngine->dispCapCnt.enabled || (mainEngine->dispCapCnt.val & 0x80000000));
if(capturing && consecutiveNonCaptures > 30)
{
// the worst-looking graphics corruption problems from frameskip
// are the result of skipping the capture on first frame it turns on.
// so we do this to handle the capture immediately,
// despite the risk of 1 frame of 2d/3d mismatch or wrong screen display.
SkipNext2DFrame = false;
nextSkip = false;
}
else if((lastDisplayTarget != mainEngine->GetDisplayByID()) && lastSkip && !skipped)
{
// if we're switching from not skipping to skipping
// and the screens are also switching around this frame,
// go for 1 extra frame without skipping.
// this avoids the scenario where we only draw one of the two screens
// when a game is switching screens every frame.
nextSkip = false;
}
if(capturing)
consecutiveNonCaptures = 0;
else if(!(consecutiveNonCaptures > 9000)) // arbitrary cap to avoid eventual wrap
consecutiveNonCaptures++;
lastDisplayTarget = mainEngine->GetDisplayByID();
lastSkip = skipped;
skipped = nextSkip;
nextSkip = false;
SkipCur2DFrame = SkipNext2DFrame;
SkipCur3DFrame = skipped;
SkipNext2DFrame = skipped;
}
FORCEINLINE bool ShouldSkip2D()
{
return SkipCur2DFrame;
}
FORCEINLINE bool ShouldSkip3D()
{
return SkipCur3DFrame;
}
FrameSkipper()
{
nextSkip = false;
skipped = false;
lastSkip = false;
lastDisplayTarget = NDSDisplayID_Main;
SkipCur2DFrame = false;
SkipCur3DFrame = false;
SkipNext2DFrame = false;
consecutiveNonCaptures = 0;
}
private:
bool nextSkip;
bool skipped;
bool lastSkip;
NDSDisplayID lastDisplayTarget;
int consecutiveNonCaptures;
bool SkipCur2DFrame;
bool SkipCur3DFrame;
bool SkipNext2DFrame;
};
static FrameSkipper frameSkipper;
void NDS_SkipNextFrame() {
frameSkipper.RequestSkip();
}
void NDS_OmitFrameSkip(int force) {
frameSkipper.OmitSkip(force > 0, force > 1);
}
#define INDEX(i) ((((i)>>16)&0xFF0)|(((i)>>4)&0xF))
enum ESI_DISPCNT
{
ESI_DISPCNT_HStart, ESI_DISPCNT_HStartIRQ, ESI_DISPCNT_HDraw, ESI_DISPCNT_HBlank
};
u64 nds_timer;
u64 nds_arm9_timer, nds_arm7_timer;
static const u64 kNever = 0xFFFFFFFFFFFFFFFFULL;
struct TSequenceItem
{
u64 timestamp;
u32 param;
bool enabled;
virtual void save(EMUFILE* os)
{
write64le(timestamp,os);
write32le(param,os);
writebool(enabled,os);
}
virtual bool load(EMUFILE* is)
{
if(read64le(×tamp,is) != 1) return false;
if(read32le(¶m,is) != 1) return false;
if(readbool(&enabled,is) != 1) return false;
return true;
}
FORCEINLINE bool isTriggered()
{
return enabled && nds_timer >= timestamp;
}
FORCEINLINE u64 next()
{
return timestamp;
}
};
struct TSequenceItem_GXFIFO : public TSequenceItem
{
FORCEINLINE bool isTriggered()
{
return enabled && nds_timer >= MMU.gfx3dCycles;
}
FORCEINLINE void exec()
{
#ifndef NDEBUG
IF_DEVELOPER(DEBUG_statistics.sequencerExecutionCounters[4]++);
#endif
while(isTriggered()) {
enabled = false;
gfx3d_execute3D();
}
}
FORCEINLINE u64 next()
{
if(enabled) return MMU.gfx3dCycles;
else return kNever;
}
};
template struct TSequenceItem_Timer : public TSequenceItem
{
FORCEINLINE bool isTriggered()
{
return enabled && nds_timer >= nds.timerCycle[procnum][num];
}
FORCEINLINE void schedule()
{
enabled = MMU.timerON[procnum][num] && MMU.timerMODE[procnum][num] != 0xFFFF;
}
FORCEINLINE u64 next()
{
return nds.timerCycle[procnum][num];
}
FORCEINLINE void exec()
{
#ifndef NDEBUG
IF_DEVELOPER(DEBUG_statistics.sequencerExecutionCounters[13+procnum*4+num]++);
#endif
u8* regs = procnum==0?MMU.ARM9_REG:MMU.ARM7_REG;
bool first = true;
//we'll need to check chained timers..
for(int i=num;i<4;i++)
{
bool over = false;
//maybe too many checks if this is here, but we need it here for now
if(!MMU.timerON[procnum][i]) return;
if(MMU.timerMODE[procnum][i] == 0xFFFF)
{
++(MMU.timer[procnum][i]);
over = !MMU.timer[procnum][i];
}
else
{
if(!first) break; //this timer isn't chained. break the chain
first = false;
over = true;
int remain = 65536 - MMU.timerReload[procnum][i];
int ctr=0;
while(nds.timerCycle[procnum][i] <= nds_timer) {
nds.timerCycle[procnum][i] += (remain << MMU.timerMODE[procnum][i]);
ctr++;
}
#ifndef NDEBUG
if(ctr>1) {
printf("yikes!!!!! please report!\n");
}
#endif
}
if(over)
{
MMU.timer[procnum][i] = MMU.timerReload[procnum][i];
if(T1ReadWord(regs, 0x102 + i*4) & 0x40)
{
NDS_makeIrq(procnum, IRQ_BIT_TIMER_0 + i);
}
}
else
break; //no more chained timers to trigger. we're done here
}
}
};
template struct TSequenceItem_DMA : public TSequenceItem
{
DmaController* controller;
FORCEINLINE bool isTriggered()
{
return (controller->dmaCheck && nds_timer>= controller->nextEvent);
}
FORCEINLINE bool isEnabled() {
return controller->dmaCheck?TRUE:FALSE;
}
FORCEINLINE u64 next()
{
return controller->nextEvent;
}
FORCEINLINE void exec()
{
#ifndef NDEBUG
IF_DEVELOPER(DEBUG_statistics.sequencerExecutionCounters[5+procnum*4+chan]++);
#endif
//if (nds.freezeBus) return;
//printf("exec from TSequenceItem_DMA: %d %d\n",procnum,chan);
controller->exec();
// //give gxfifo dmas a chance to re-trigger
// if(MMU.DMAStartTime[procnum][chan] == EDMAMode_GXFifo) {
// MMU.DMAing[procnum][chan] = FALSE;
// if (gxFIFO.size <= 127)
// {
// execHardware_doDma(procnum,chan,EDMAMode_GXFifo);
// if (MMU.DMACompleted[procnum][chan])
// goto docomplete;
// else return;
// }
// }
//
//docomplete:
// if (MMU.DMACompleted[procnum][chan])
// {
// u8* regs = procnum==0?MMU.ARM9_REG:MMU.ARM7_REG;
//
// //disable the channel
// if(MMU.DMAStartTime[procnum][chan] != EDMAMode_GXFifo) {
// T1WriteLong(regs, 0xB8 + (0xC*chan), T1ReadLong(regs, 0xB8 + (0xC*chan)) & 0x7FFFFFFF);
// MMU.DMACrt[procnum][chan] &= 0x7FFFFFFF; //blehhh i hate this shit being mirrored in memory
// }
//
// if((MMU.DMACrt[procnum][chan])&(1<<30)) {
// if(procnum==0) NDS_makeARM9Int(8+chan);
// else NDS_makeARM7Int(8+chan);
// }
//
// MMU.DMAing[procnum][chan] = FALSE;
// }
}
};
struct TSequenceItem_divider : public TSequenceItem
{
FORCEINLINE bool isTriggered()
{
return MMU.divRunning && nds_timer >= MMU.divCycles;
}
bool isEnabled() { return MMU.divRunning!=0; }
FORCEINLINE u64 next()
{
return MMU.divCycles;
}
void exec()
{
#ifndef NDEBUG
IF_DEVELOPER(DEBUG_statistics.sequencerExecutionCounters[2]++);
#endif
MMU_new.div.busy = 0;
#ifdef HOST_64
T1WriteQuad(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2A0, MMU.divResult);
T1WriteQuad(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2A8, MMU.divMod);
#else
T1WriteLong(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2A0, (u32)MMU.divResult);
T1WriteLong(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2A4, (u32)(MMU.divResult >> 32));
T1WriteLong(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2A8, (u32)MMU.divMod);
T1WriteLong(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2AC, (u32)(MMU.divMod >> 32));
#endif
MMU.divRunning = FALSE;
}
};
struct TSequenceItem_sqrtunit : public TSequenceItem
{
FORCEINLINE bool isTriggered()
{
return MMU.sqrtRunning && nds_timer >= MMU.sqrtCycles;
}
bool isEnabled() { return MMU.sqrtRunning!=0; }
FORCEINLINE u64 next()
{
return MMU.sqrtCycles;
}
FORCEINLINE void exec()
{
#ifndef NDEBUG
IF_DEVELOPER(DEBUG_statistics.sequencerExecutionCounters[3]++);
#endif
MMU_new.sqrt.busy = 0;
T1WriteLong(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x2B4, MMU.sqrtResult);
MMU.sqrtRunning = FALSE;
}
};
struct Sequencer
{
bool nds_vblankEnded;
bool reschedule;
TSequenceItem dispcnt;
TSequenceItem wifi;
TSequenceItem_divider divider;
TSequenceItem_sqrtunit sqrtunit;
TSequenceItem_GXFIFO gxfifo;
TSequenceItem_DMA<0,0> dma_0_0; TSequenceItem_DMA<0,1> dma_0_1;
TSequenceItem_DMA<0,2> dma_0_2; TSequenceItem_DMA<0,3> dma_0_3;
TSequenceItem_DMA<1,0> dma_1_0; TSequenceItem_DMA<1,1> dma_1_1;
TSequenceItem_DMA<1,2> dma_1_2; TSequenceItem_DMA<1,3> dma_1_3;
TSequenceItem_Timer<0,0> timer_0_0; TSequenceItem_Timer<0,1> timer_0_1;
TSequenceItem_Timer<0,2> timer_0_2; TSequenceItem_Timer<0,3> timer_0_3;
TSequenceItem_Timer<1,0> timer_1_0; TSequenceItem_Timer<1,1> timer_1_1;
TSequenceItem_Timer<1,2> timer_1_2; TSequenceItem_Timer<1,3> timer_1_3;
void init();
void execHardware();
u64 findNext();
void save(EMUFILE* os)
{
write64le(nds_timer,os);
write64le(nds_arm9_timer,os);
write64le(nds_arm7_timer,os);
dispcnt.save(os);
divider.save(os);
sqrtunit.save(os);
gxfifo.save(os);
wifi.save(os);
#define SAVE(I,X,Y) I##_##X##_##Y .save(os);
SAVE(timer,0,0); SAVE(timer,0,1); SAVE(timer,0,2); SAVE(timer,0,3);
SAVE(timer,1,0); SAVE(timer,1,1); SAVE(timer,1,2); SAVE(timer,1,3);
SAVE(dma,0,0); SAVE(dma,0,1); SAVE(dma,0,2); SAVE(dma,0,3);
SAVE(dma,1,0); SAVE(dma,1,1); SAVE(dma,1,2); SAVE(dma,1,3);
#undef SAVE
}
bool load(EMUFILE* is, int version)
{
if(read64le(&nds_timer,is) != 1) return false;
if(read64le(&nds_arm9_timer,is) != 1) return false;
if(read64le(&nds_arm7_timer,is) != 1) return false;
if(!dispcnt.load(is)) return false;
if(!divider.load(is)) return false;
if(!sqrtunit.load(is)) return false;
if(!gxfifo.load(is)) return false;
if(version >= 1) if(!wifi.load(is)) return false;
#define LOAD(I,X,Y) if(!I##_##X##_##Y .load(is)) return false;
LOAD(timer,0,0); LOAD(timer,0,1); LOAD(timer,0,2); LOAD(timer,0,3);
LOAD(timer,1,0); LOAD(timer,1,1); LOAD(timer,1,2); LOAD(timer,1,3);
LOAD(dma,0,0); LOAD(dma,0,1); LOAD(dma,0,2); LOAD(dma,0,3);
LOAD(dma,1,0); LOAD(dma,1,1); LOAD(dma,1,2); LOAD(dma,1,3);
#undef LOAD
return true;
}
} sequencer;
void NDS_RescheduleGXFIFO(u32 cost)
{
if(!sequencer.gxfifo.enabled) {
MMU.gfx3dCycles = nds_timer;
sequencer.gxfifo.enabled = true;
}
MMU.gfx3dCycles += cost;
NDS_Reschedule();
}
void NDS_RescheduleTimers()
{
#define check(X,Y) sequencer.timer_##X##_##Y .schedule();
check(0,0); check(0,1); check(0,2); check(0,3);
check(1,0); check(1,1); check(1,2); check(1,3);
#undef check
NDS_Reschedule();
}
void NDS_RescheduleDMA()
{
//TBD
NDS_Reschedule();
}
static void initSchedule()
{
sequencer.init();
//begin at the very end of the last scanline
//so that at t=0 we can increment to scanline=0
nds.VCount = 262;
sequencer.nds_vblankEnded = false;
}
// 2196372 ~= (ARM7_CLOCK << 16) / 1000000
// This value makes more sense to me, because:
// ARM7_CLOCK = 33.51 mhz
// = 33513982 cycles per second
// = 33.513982 cycles per microsecond
const u64 kWifiCycles = 67;//34*2;
//(this isn't very precise. I don't think it needs to be)
void Sequencer::init()
{
NDS_RescheduleTimers();
NDS_RescheduleDMA();
reschedule = false;
nds_timer = 0;
nds_arm9_timer = 0;
nds_arm7_timer = 0;
dispcnt.enabled = true;
dispcnt.param = ESI_DISPCNT_HStart;
dispcnt.timestamp = 0;
gxfifo.enabled = false;
dma_0_0.controller = &MMU_new.dma[0][0];
dma_0_1.controller = &MMU_new.dma[0][1];
dma_0_2.controller = &MMU_new.dma[0][2];
dma_0_3.controller = &MMU_new.dma[0][3];
dma_1_0.controller = &MMU_new.dma[1][0];
dma_1_1.controller = &MMU_new.dma[1][1];
dma_1_2.controller = &MMU_new.dma[1][2];
dma_1_3.controller = &MMU_new.dma[1][3];
#ifdef EXPERIMENTAL_WIFI_COMM
wifi.enabled = true;
wifi.timestamp = kWifiCycles;
#else
wifi.enabled = false;
#endif
}
static void execHardware_hblank()
{
//this logic keeps moving around.
//now, we try and give the game as much time as possible to finish doing its work for the scanline,
//by drawing scanline N at the end of drawing time (but before subsequent interrupt or hdma-driven events happen)
//don't try to do this at the end of the scanline, because some games (sonic classics) may use hblank IRQ to set
//scroll regs for the next scanline
if(nds.VCount<192)
{
GPU->RenderLine(nds.VCount, frameSkipper.ShouldSkip2D());
//trigger hblank dmas
//but notice, we do that just after we finished drawing the line
//(values copied by this hdma should not be used until the next scanline)
triggerDma(EDMAMode_HBlank);
}
#if 0
if(nds.VCount==262)
{
//we need to trigger one last hblank dma since
//a. we're sort of lagged behind by one scanline
//b. i think that 193 hblanks actually fire (one for the hblank in scanline 262)
//this is demonstrated by NSMB splot-parallaxing clouds
//for some reason the game will setup two hdma scroll register buffers
//to be run consecutively, and unless we do this, the second buffer will be offset by one scanline
//causing a glitch in the 0th scanline
//triggerDma(EDMAMode_HBlank);
//BUT! this was removed in order to make glitches in megaman zero collection (mmz 4 1st level) work.
//and, it seems that it is no longer necessary in nsmb. perhaps something else fixed it
}
#endif
//turn on hblank status bit
T1WriteWord(MMU.ARM9_REG, 4, T1ReadWord(MMU.ARM9_REG, 4) | 2);
T1WriteWord(MMU.ARM7_REG, 4, T1ReadWord(MMU.ARM7_REG, 4) | 2);
//fire hblank interrupts if necessary
if(T1ReadWord(MMU.ARM9_REG, 4) & 0x10) NDS_makeIrq(ARMCPU_ARM9,IRQ_BIT_LCD_HBLANK);
if(T1ReadWord(MMU.ARM7_REG, 4) & 0x10) NDS_makeIrq(ARMCPU_ARM7,IRQ_BIT_LCD_HBLANK);
//emulation housekeeping. for some reason we always do this at hblank,
//even though it sounds more reasonable to do it at hstart
SPU_Emulate_core();
}
static void execHardware_hstart_vblankEnd()
{
sequencer.nds_vblankEnded = true;
sequencer.reschedule = true;
//turn off vblank status bit
T1WriteWord(MMU.ARM9_REG, 4, T1ReadWord(MMU.ARM9_REG, 4) & ~1);
T1WriteWord(MMU.ARM7_REG, 4, T1ReadWord(MMU.ARM7_REG, 4) & ~1);
//some emulation housekeeping
frameSkipper.Advance();
if (GPU->GetWillAutoBlitNativeToCustomBuffer())
{
GPU->GetEngineMain()->BlitNativeToCustomFramebuffer();
GPU->GetEngineSub()->BlitNativeToCustomFramebuffer();
}
}
static void execHardware_hstart_vblankStart()
{
//printf("--------VBLANK!!!--------\n");
//fire vblank interrupts if necessary
for(int i=0;i<2;i++)
if(MMU.reg_IF_pending[i] & (1<>8)|((vmatch<<1)&(1<<8)));
return vmatch;
}
static void execHardware_hstart_vcount_irq()
{
//trigger pending VMATCH irqs
if(MMU.reg_IF_pending[ARMCPU_ARM9] & (1<>8)|((vmatch<<1)&(1<<8)));
if(nds.VCount==vmatch)
{
//arm7 vmatch
T1WriteWord(MMU.ARM7_REG, 4, T1ReadWord(MMU.ARM7_REG, 4) | 4);
if(T1ReadWord(MMU.ARM7_REG, 4) & 32)
MMU.reg_IF_pending[ARMCPU_ARM7] |= (1<> (32-1)) & (c^d)) ^ d);
}
FORCEINLINE u64 _fast_min(u64 a, u64 b)
{
//you might find that this is faster on a 64bit system; someone should try it
//http://aggregate.org/MAGIC/#Integer%20Selection
//u64 ret = (((((s64)(a-b)) >> (64-1)) & (a^b)) ^ b);
//assert(ret==min(a,b));
//return ret;
//but this ends up being the fastest on 32bits
return a>= 63; //no 64bit shra in sse2, what a disappointment
//temp = _mm_and_si128(temp,xorval);
//temp = _mm_xor_si128(temp,__b);
//return temp.m128i_u64[0];
}
u64 Sequencer::findNext()
{
//this one is always enabled so dont bother to check it
u64 next = dispcnt.next();
if(divider.isEnabled()) next = _fast_min(next,divider.next());
if(sqrtunit.isEnabled()) next = _fast_min(next,sqrtunit.next());
if(gxfifo.enabled) next = _fast_min(next,gxfifo.next());
#ifdef EXPERIMENTAL_WIFI_COMM
next = _fast_min(next,wifi.next());
#endif
#define test(X,Y) if(dma_##X##_##Y .isEnabled()) next = _fast_min(next,dma_##X##_##Y .next());
test(0,0); test(0,1); test(0,2); test(0,3);
test(1,0); test(1,1); test(1,2); test(1,3);
#undef test
#define test(X,Y) if(timer_##X##_##Y .enabled) next = _fast_min(next,timer_##X##_##Y .next());
test(0,0); test(0,1); test(0,2); test(0,3);
test(1,0); test(1,1); test(1,2); test(1,3);
#undef test
return next;
}
void Sequencer::execHardware()
{
if(dispcnt.isTriggered())
{
#ifndef NDEBUG
IF_DEVELOPER(DEBUG_statistics.sequencerExecutionCounters[1]++);
#endif
switch(dispcnt.param)
{
case ESI_DISPCNT_HStart:
execHardware_hstart();
//(used to be 3168)
//hstart is actually 8 dots before the visible drawing begins
//we're going to run 1 here and then run 7 in the next case
dispcnt.timestamp += 1*6*2;
dispcnt.param = ESI_DISPCNT_HStartIRQ;
break;
case ESI_DISPCNT_HStartIRQ:
execHardware_hstart_irq();
dispcnt.timestamp += 7*6*2;
dispcnt.param = ESI_DISPCNT_HDraw;
break;
case ESI_DISPCNT_HDraw:
//execHardware_hdraw();
//duration of non-blanking period is ~1606 clocks (gbatek agrees) [but says its different on arm7]
//im gonna call this 267 dots = 267*6=1602
//so, this event lasts 267 dots minus the 8 dot preroll
dispcnt.timestamp += (267-8)*6*2;
dispcnt.param = ESI_DISPCNT_HBlank;
break;
case ESI_DISPCNT_HBlank:
execHardware_hblank();
//(once this was 1092 or 1092/12=91 dots.)
//there are surely 355 dots per scanline, less 267 for non-blanking period. the rest is hblank and then after that is hstart
dispcnt.timestamp += (355-267)*6*2;
dispcnt.param = ESI_DISPCNT_HStart;
break;
}
}
#ifdef EXPERIMENTAL_WIFI_COMM
if(wifi.isTriggered())
{
WIFI_usTrigger();
wifi.timestamp += kWifiCycles;
}
#endif
if(divider.isTriggered()) divider.exec();
if(sqrtunit.isTriggered()) sqrtunit.exec();
if(gxfifo.isTriggered()) gxfifo.exec();
#define test(X,Y) if(dma_##X##_##Y .isTriggered()) dma_##X##_##Y .exec();
test(0,0); test(0,1); test(0,2); test(0,3);
test(1,0); test(1,1); test(1,2); test(1,3);
#undef test
#define test(X,Y) if(timer_##X##_##Y .enabled) if(timer_##X##_##Y .isTriggered()) timer_##X##_##Y .exec();
test(0,0); test(0,1); test(0,2); test(0,3);
test(1,0); test(1,1); test(1,2); test(1,3);
#undef test
}
void execHardware_interrupts();
static void saveUserInput(EMUFILE* os);
static bool loadUserInput(EMUFILE* is, int version);
void nds_savestate(EMUFILE* os)
{
//version
write32le(3,os);
sequencer.save(os);
saveUserInput(os);
write32le(LidClosed,os);
write8le(countLid,os);
}
bool nds_loadstate(EMUFILE* is, int size)
{
// this isn't part of the savestate loading logic, but
// don't skip the next frame after loading a savestate
frameSkipper.OmitSkip(true, true);
//read version
u32 version;
if(read32le(&version,is) != 1) return false;
if(version > 3) return false;
bool temp = true;
temp &= sequencer.load(is, version);
if(version <= 1 || !temp) return temp;
temp &= loadUserInput(is, version);
if(version < 3) return temp;
read32le(&LidClosed,is);
read8le(&countLid,is);
return temp;
}
#ifdef LOG_ARM9
FORCEINLINE void arm9log()
{
if(dolog)
{
char dasmbuf[4096];
if(NDS_ARM9.CPSR.bits.T)
des_thumb_instructions_set[((NDS_ARM9.instruction)>>6)&1023](NDS_ARM9.instruct_adr, NDS_ARM9.instruction, dasmbuf);
else
des_arm_instructions_set[INDEX(NDS_ARM9.instruction)](NDS_ARM9.instruct_adr, NDS_ARM9.instruction, dasmbuf);
#ifdef LOG_TO_FILE
if (!fp_dis9) return;
#ifdef LOG_TO_FILE_REGS
fprintf(fp_dis9, "\t\t;%05d:%03d %12lld\n\t\t;R0:%08X R1:%08X R2:%08X R3:%08X R4:%08X R5:%08X R6:%08X R7:%08X R8:%08X R9:%08X\n\t\t;R10:%08X R11:%08X R12:%08X R13:%08X R14:%08X R15:%08X| next %08X, N:%i Z:%i C:%i V:%i\n",
currFrameCounter, nds.VCount, nds_timer,
NDS_ARM9.R[0], NDS_ARM9.R[1], NDS_ARM9.R[2], NDS_ARM9.R[3], NDS_ARM9.R[4], NDS_ARM9.R[5], NDS_ARM9.R[6], NDS_ARM9.R[7],
NDS_ARM9.R[8], NDS_ARM9.R[9], NDS_ARM9.R[10], NDS_ARM9.R[11], NDS_ARM9.R[12], NDS_ARM9.R[13], NDS_ARM9.R[14], NDS_ARM9.R[15],
NDS_ARM9.next_instruction, NDS_ARM9.CPSR.bits.N, NDS_ARM9.CPSR.bits.Z, NDS_ARM9.CPSR.bits.C, NDS_ARM9.CPSR.bits.V);
#endif
fprintf(fp_dis9, "%s %08X\t%08X \t%s\n", NDS_ARM9.CPSR.bits.T?"THUMB":"ARM", NDS_ARM9.instruct_adr, NDS_ARM9.instruction, dasmbuf);
/*if (NDS_ARM9.instruction == 0)
{
dolog = false;
INFO("Disassembler is stopped\n");
}*/
#else
printf("%05d:%03d %12lld 9:%08X %08X %-30s R00:%08X R01:%08X R02:%08X R03:%08X R04:%08X R05:%08X R06:%08X R07:%08X R08:%08X R09:%08X R10:%08X R11:%08X R12:%08X R13:%08X R14:%08X R15:%08X\n",
currFrameCounter, nds.VCount, nds_timer,
NDS_ARM9.instruct_adr,NDS_ARM9.instruction, dasmbuf,
NDS_ARM9.R[0], NDS_ARM9.R[1], NDS_ARM9.R[2], NDS_ARM9.R[3], NDS_ARM9.R[4], NDS_ARM9.R[5], NDS_ARM9.R[6], NDS_ARM9.R[7],
NDS_ARM9.R[8], NDS_ARM9.R[9], NDS_ARM9.R[10], NDS_ARM9.R[11], NDS_ARM9.R[12], NDS_ARM9.R[13], NDS_ARM9.R[14], NDS_ARM9.R[15]);
#endif
}
}
#endif
#ifdef LOG_ARM7
FORCEINLINE void arm7log()
{
if(dolog)
{
char dasmbuf[4096];
if(NDS_ARM7.CPSR.bits.T)
des_thumb_instructions_set[((NDS_ARM7.instruction)>>6)&1023](NDS_ARM7.instruct_adr, NDS_ARM7.instruction, dasmbuf);
else
des_arm_instructions_set[INDEX(NDS_ARM7.instruction)](NDS_ARM7.instruct_adr, NDS_ARM7.instruction, dasmbuf);
#ifdef LOG_TO_FILE
if (!fp_dis7) return;
#ifdef LOG_TO_FILE_REGS
fprintf(fp_dis7, "\t\t;%05d:%03d %12lld\n\t\t;R0:%08X R1:%08X R2:%08X R3:%08X R4:%08X R5:%08X R6:%08X R7:%08X R8:%08X R9:%08X\n\t\t;R10:%08X R11:%08X R12:%08X R13:%08X R14:%08X R15:%08X| next %08X, N:%i Z:%i C:%i V:%i\n",
currFrameCounter, nds.VCount, nds_timer,
NDS_ARM7.R[0], NDS_ARM7.R[1], NDS_ARM7.R[2], NDS_ARM7.R[3], NDS_ARM7.R[4], NDS_ARM7.R[5], NDS_ARM7.R[6], NDS_ARM7.R[7],
NDS_ARM7.R[8], NDS_ARM7.R[9], NDS_ARM7.R[10], NDS_ARM7.R[11], NDS_ARM7.R[12], NDS_ARM7.R[13], NDS_ARM7.R[14], NDS_ARM7.R[15],
NDS_ARM7.next_instruction, NDS_ARM7.CPSR.bits.N, NDS_ARM7.CPSR.bits.Z, NDS_ARM7.CPSR.bits.C, NDS_ARM7.CPSR.bits.V);
#endif
fprintf(fp_dis7, "%s %08X\t%08X \t%s\n", NDS_ARM7.CPSR.bits.T?"THUMB":"ARM", NDS_ARM7.instruct_adr, NDS_ARM7.instruction, dasmbuf);
/*if (NDS_ARM7.instruction == 0)
{
dolog = false;
INFO("Disassembler is stopped\n");
}*/
#else
printf("%05d:%03d %12lld 7:%08X %08X %-30s R00:%08X R01:%08X R02:%08X R03:%08X R04:%08X R05:%08X R06:%08X R07:%08X R08:%08X R09:%08X R10:%08X R11:%08X R12:%08X R13:%08X R14:%08X R15:%08X\n",
currFrameCounter, nds.VCount, nds_timer,
NDS_ARM7.instruct_adr,NDS_ARM7.instruction, dasmbuf,
NDS_ARM7.R[0], NDS_ARM7.R[1], NDS_ARM7.R[2], NDS_ARM7.R[3], NDS_ARM7.R[4], NDS_ARM7.R[5], NDS_ARM7.R[6], NDS_ARM7.R[7],
NDS_ARM7.R[8], NDS_ARM7.R[9], NDS_ARM7.R[10], NDS_ARM7.R[11], NDS_ARM7.R[12], NDS_ARM7.R[13], NDS_ARM7.R[14], NDS_ARM7.R[15]);
#endif
}
}
#endif
//these have not been tuned very well yet.
static const int kMaxWork = 4000;
static const int kIrqWait = 4000;
template
static FORCEINLINE s32 minarmtime(s32 arm9, s32 arm7)
{
if(doarm9)
{
if(doarm7)
return min(arm9,arm7);
return arm9;
}
return arm7;
}
#ifdef HAVE_JIT
template
#else
template
#endif
static /*donotinline*/ std::pair armInnerLoop(
const u64 nds_timer_base, const s32 s32next, s32 arm9, s32 arm7)
{
s32 timer = minarmtime(arm9,arm7);
while(timer < s32next && !sequencer.reschedule && execute)
{
if(doarm9 && (!doarm7 || arm9 <= timer))
{
if(!NDS_ARM9.waitIRQ&&!nds.freezeBus)
{
#ifdef LOG_ARM9
arm9log();
#endif
#ifdef DEBUG
debug();
#endif
#ifdef HAVE_JIT
arm9 += armcpu_exec();
#else
arm9 += armcpu_exec();
#endif
#ifdef DEVELOPER
nds_debug_continuing[0] = false;
#endif
}
else
{
s32 temp = arm9;
arm9 = min(s32next, arm9 + kIrqWait);
nds.idleCycles[0] += arm9-temp;
if (gxFIFO.size < 255) nds.freezeBus &= ~1;
}
}
if(doarm7 && (!doarm9 || arm7 <= timer))
{
if(!NDS_ARM7.waitIRQ&&!nds.freezeBus)
{
#ifdef LOG_ARM7
arm7log();
#endif
#ifdef HAVE_JIT
arm7 += (armcpu_exec()<<1);
#else
arm7 += (armcpu_exec()<<1);
#endif
#ifdef DEVELOPER
nds_debug_continuing[1] = false;
#endif
}
else
{
s32 temp = arm7;
arm7 = min(s32next, arm7 + kIrqWait);
nds.idleCycles[1] += arm7-temp;
if(arm7 == s32next)
{
nds_timer = nds_timer_base + minarmtime(arm9,arm7);
#ifdef HAVE_JIT
return armInnerLoop(nds_timer_base, s32next, arm9, arm7);
#else
return armInnerLoop(nds_timer_base, s32next, arm9, arm7);
#endif
}
}
}
timer = minarmtime(arm9,arm7);
nds_timer = nds_timer_base + timer;
}
return std::make_pair(arm9, arm7);
}
void NDS_debug_break()
{
NDS_ARM9.stalled = NDS_ARM7.stalled = 1;
//triggers an immediate exit from the cpu loop
NDS_Reschedule();
}
void NDS_debug_continue()
{
NDS_ARM9.stalled = NDS_ARM7.stalled = 0;
}
void NDS_debug_step()
{
NDS_debug_continue();
singleStep = true;
}
void NDS_exec(s32 nb)
{
sequencer.nds_vblankEnded = false;
nds.cpuloopIterationCount = 0;
#ifndef NDEBUG
IF_DEVELOPER(for(int i=0;i<32;i++) DEBUG_statistics.sequencerExecutionCounters[i] = 0);
#endif
if(nds.sleeping)
{
//speculative code: if ANY irq happens, wake up the arm7.
//I think the arm7 program analyzes the system and may decide not to wake up
//if it is dissatisfied with the conditions
if((MMU.reg_IE[1] & MMU.gen_IF<1>()))
nds.sleeping = FALSE;
}
else
{
for(;;)
{
//trap the debug-stalled condition
#ifdef DEVELOPER
singleStep = false;
//(gdb stub doesnt yet know how to trigger these immediately by calling reschedule)
if ((NDS_ARM9.stalled || NDS_ARM7.stalled) && execute)
{
driver->EMU_DebugIdleEnter();
while((NDS_ARM9.stalled || NDS_ARM7.stalled) && execute)
{
driver->EMU_DebugIdleUpdate();
nds_debug_continuing[0] = nds_debug_continuing[1] = true;
}
driver->EMU_DebugIdleWakeUp();
}
#endif
nds.cpuloopIterationCount++;
sequencer.execHardware();
//break out once per frame
if(sequencer.nds_vblankEnded) break;
//it should be benign to execute execHardware in the next frame,
//since there won't be anything for it to do (everything should be scheduled in the future)
//bail in case the system halted
if(!execute) break;
execHardware_interrupts();
//find next work unit:
u64 next = sequencer.findNext();
next = min(next,nds_timer+kMaxWork); //lets set an upper limit for now
//printf("%d\n",(next-nds_timer));
sequencer.reschedule = false;
//cast these down to 32bits so that things run faster on 32bit procs
u64 nds_timer_base = nds_timer;
s32 arm9 = (s32)(nds_arm9_timer-nds_timer);
s32 arm7 = (s32)(nds_arm7_timer-nds_timer);
s32 s32next = (s32)(next-nds_timer);
#ifdef DEVELOPER
if(singleStep)
{
s32next = 1;
}
#endif
#ifdef HAVE_JIT
std::pair arm9arm7 = CommonSettings.use_jit
? armInnerLoop(nds_timer_base,s32next,arm9,arm7)
: armInnerLoop(nds_timer_base,s32next,arm9,arm7);
#else
std::pair arm9arm7 = armInnerLoop(nds_timer_base,s32next,arm9,arm7);
#endif
#ifdef DEVELOPER
if(singleStep)
{
NDS_ARM9.stalled = NDS_ARM7.stalled = 1;
}
#endif
arm9 = arm9arm7.first;
arm7 = arm9arm7.second;
nds_arm7_timer = nds_timer_base+arm7;
nds_arm9_timer = nds_timer_base+arm9;
#ifndef NDEBUG
//what we find here is dependent on the timing constants above
//if(nds_timer>next && (nds_timer-next)>22)
// printf("curious. please report: over by %d\n",(int)(nds_timer-next));
#endif
//if we were waiting for an irq, don't wait too long:
//let's re-analyze it after this hardware event (this rolls back a big burst of irq waiting which may have been interrupted by a resynch)
if(NDS_ARM9.waitIRQ)
{
nds.idleCycles[0] -= (s32)(nds_arm9_timer-nds_timer);
nds_arm9_timer = nds_timer;
}
if(NDS_ARM7.waitIRQ)
{
nds.idleCycles[1] -= (s32)(nds_arm7_timer-nds_timer);
nds_arm7_timer = nds_timer;
}
}
}
currFrameCounter++;
#ifndef NDEBUG
DEBUG_Notify.NextFrame();
#endif
if (cheats)
cheats->process();
}
template static void execHardware_interrupts_core()
{
u32 IF = MMU.gen_IF();
u32 IE = MMU.reg_IE[PROCNUM];
u32 masked = IF & IE;
if(ARMPROC.halt_IE_and_IF && masked)
{
ARMPROC.halt_IE_and_IF = FALSE;
ARMPROC.waitIRQ = FALSE;
}
if(masked && MMU.reg_IME[PROCNUM] && !ARMPROC.CPSR.bits.I)
{
//printf("Executing IRQ on procnum %d with IF = %08X and IE = %08X\n",PROCNUM,IF,IE);
armcpu_irqException(&ARMPROC);
}
}
void execHardware_interrupts()
{
execHardware_interrupts_core();
execHardware_interrupts_core();
}
static void resetUserInput();
static void PrepareBiosARM7()
{
//begin with the bios unloaded
NDS_ARM7.BIOS_loaded = false;
memset(MMU.ARM7_BIOS, 0, sizeof(MMU.ARM7_BIOS));
if(CommonSettings.UseExtBIOS == true)
{
//read arm7 bios from inputfile and flag it if it succeeds
FILE *arm7inf = fopen(CommonSettings.ARM7BIOS,"rb");
if (arm7inf)
{
if (fread(MMU.ARM7_BIOS,1,16384,arm7inf) == 16384)
NDS_ARM7.BIOS_loaded = true;
fclose(arm7inf);
}
}
//choose to use SWI emulation or routines from bios
if((CommonSettings.SWIFromBIOS) && (NDS_ARM7.BIOS_loaded))
{
NDS_ARM7.swi_tab = 0;
//if we used routines from bios, apply patches
if (CommonSettings.PatchSWI3)
{
//[3801] SUB R0, #1 -> [4770] BX LR
T1WriteWord(MMU.ARM7_BIOS,0x2F08, 0x4770);
}
}
else
NDS_ARM7.swi_tab = ARM_swi_tab[ARMCPU_ARM7];
if(NDS_ARM7.BIOS_loaded)
{
#ifdef DEBUG
INFO("ARM7 BIOS load: %s.\n", NDS_ARM7.BIOS_loaded?"OK":"FAILED");
#endif
}
else
{
//fake bios content, critical to normal operations, since we dont have a real bios.
T1WriteLong(MMU.ARM7_BIOS, 0x0000, 0xEAFFFFFE); //B 00000000 (reset: infinite loop) (originally: 0xE25EF002 - SUBS PC, LR, #2
T1WriteLong(MMU.ARM7_BIOS, 0x0004, 0xEAFFFFFE); //B 00000004 (undefined instruction: infinite loop)
T1WriteLong(MMU.ARM7_BIOS, 0x0008, 0xEAFFFFFE); //B 00000280 (SWI: infinite loop [since we will be HLEing the SWI routines])
T1WriteLong(MMU.ARM7_BIOS, 0x000C, 0xEAFFFFFE); //B 0000000C (prefetch abort: infinite loop)
T1WriteLong(MMU.ARM7_BIOS, 0x0010, 0xEAFFFFFE); //B 00000010 (data abort: infinite loop)
T1WriteLong(MMU.ARM7_BIOS, 0x0018, 0xEA000000); //B 00000020 (IRQ: branch to handler)
T1WriteLong(MMU.ARM7_BIOS, 0x001C, 0xEAFFFFFE); //B 0000001C (FIQ vector: infinite loop)
//IRQ handler
T1WriteLong(MMU.ARM7_BIOS, 0x0020, 0xE92D500F); //STMDB SP!, {R0-R3,R12,LR}
T1WriteLong(MMU.ARM7_BIOS, 0x0024, 0xE3A00301); //MOV R0, #4000000
T1WriteLong(MMU.ARM7_BIOS, 0x0028, 0xE28FE000); //ADD LR, PC, #0
T1WriteLong(MMU.ARM7_BIOS, 0x002C, 0xE510F004); //LDR PC, [R0, -#4]
T1WriteLong(MMU.ARM7_BIOS, 0x0030, 0xE8BD500F); //LDMIA SP!, {R0-R3,R12,LR}
T1WriteLong(MMU.ARM7_BIOS, 0x0034, 0xE25EF004); //SUBS PC, LR, #4
}
}
static void PrepareBiosARM9()
{
//begin with the bios unloaded
memset(MMU.ARM9_BIOS, 0, sizeof(MMU.ARM9_BIOS));
NDS_ARM9.BIOS_loaded = false;
if(CommonSettings.UseExtBIOS == true)
{
//read arm9 bios from inputfile and flag it if it succeeds
FILE* arm9inf = fopen(CommonSettings.ARM9BIOS,"rb");
if (arm9inf)
{
if (fread(MMU.ARM9_BIOS,1,4096,arm9inf) == 4096)
NDS_ARM9.BIOS_loaded = true;
fclose(arm9inf);
}
}
//choose to use SWI emulation or routines from bios
if((CommonSettings.SWIFromBIOS) && (NDS_ARM9.BIOS_loaded))
{
NDS_ARM9.swi_tab = 0;
//if we used routines from bios, apply patches
//[3801] SUB R0, #1 -> [4770] BX LR
if (CommonSettings.PatchSWI3)
T1WriteWord(MMU.ARM9_BIOS, 0x07CC, 0x4770);
}
else NDS_ARM9.swi_tab = ARM_swi_tab[ARMCPU_ARM9];
if(NDS_ARM9.BIOS_loaded)
{
#ifdef DEBUG
INFO("ARM9 BIOS load: %s.\n", NDS_ARM9.BIOS_loaded?"OK":"FAILED");
#endif
}
else
{
//fake bios content, critical to normal operations, since we dont have a real bios.
//it'd be cool if we could write this in some kind of assembly language, inline or otherwise, without some bulky dependencies
//perhaps we could build it with devkitarm? but thats bulky (offline) dependencies, to be sure..
//reminder: bios chains data abort to fast irq
//exception vectors:
T1WriteLong(MMU.ARM9_BIOS, 0x0000, 0xEAFFFFFE); // (infinite loop for) Reset !!!
//T1WriteLong(MMU.ARM9_BIOS, 0x0004, 0xEAFFFFFE); // (infinite loop for) Undefined instruction
T1WriteLong(MMU.ARM9_BIOS, 0x0004, 0xEA000004); // Undefined instruction -> Fast IRQ (just guessing)
T1WriteLong(MMU.ARM9_BIOS, 0x0008, 0xEA00009C); // SWI -> ?????
T1WriteLong(MMU.ARM9_BIOS, 0x000C, 0xEAFFFFFE); // (infinite loop for) Prefetch Abort
T1WriteLong(MMU.ARM9_BIOS, 0x0010, 0xEA000001); // Data Abort -> Fast IRQ
T1WriteLong(MMU.ARM9_BIOS, 0x0014, 0x00000000); // Reserved
T1WriteLong(MMU.ARM9_BIOS, 0x0018, 0xEA000095); // Normal IRQ -> 0x0274
T1WriteLong(MMU.ARM9_BIOS, 0x001C, 0xEA00009D); // Fast IRQ -> 0x0298
//copy the logo content into the bios - Pokemon Platinum uses this in Pal Park trade
//it compares the logo from the arm9 bios to the logo in the GBA header.
//NOTE: in the unlikely event that the valid header is missing from the gameInfo, we'd be doing wrong here.
// however, its nice not to have the logo embedded here.
// TODO - take a CRC of the logo, check vs logoCRC16, and a hardcoded value, to make sure all is in order--report error if not
memcpy(&MMU.ARM9_BIOS[0x20], &gameInfo.header.logo[0], 0x9C);
T1WriteWord(MMU.ARM9_BIOS, 0x20 + 0x9C, gameInfo.header.logoCRC16);
//... and with that we are at 0xBC:
//(now what goes in this gap?? nothing we need, i guess)
//IRQ handler: get dtcm address and jump to a vector in it
T1WriteLong(MMU.ARM9_BIOS, 0x0274, 0xE92D500F); //STMDB SP!, {R0-R3,R12,LR}
T1WriteLong(MMU.ARM9_BIOS, 0x0278, 0xEE190F11); //MRC CP15, 0, R0, CR9, CR1, 0
T1WriteLong(MMU.ARM9_BIOS, 0x027C, 0xE1A00620); //MOV R0, R0, LSR #C
T1WriteLong(MMU.ARM9_BIOS, 0x0280, 0xE1A00600); //MOV R0, R0, LSL #C
T1WriteLong(MMU.ARM9_BIOS, 0x0284, 0xE2800C40); //ADD R0, R0, #4000
T1WriteLong(MMU.ARM9_BIOS, 0x0288, 0xE28FE000); //ADD LR, PC, #0
T1WriteLong(MMU.ARM9_BIOS, 0x028C, 0xE510F004); //LDR PC, [R0, -#4]
//????
T1WriteLong(MMU.ARM9_BIOS, 0x0290, 0xE8BD500F); //LDMIA SP!, {R0-R3,R12,LR}
T1WriteLong(MMU.ARM9_BIOS, 0x0294, 0xE25EF004); //SUBS PC, LR, #4
//-------
//FIQ and abort exception handler
//TODO - this code is copied from the bios. refactor it
//friendly reminder: to calculate an immediate offset: encoded = (desired_address-cur_address-8)
T1WriteLong(MMU.ARM9_BIOS, 0x0298, 0xE10FD000); //MRS SP, CPSR
T1WriteLong(MMU.ARM9_BIOS, 0x029C, 0xE38DD0C0); //ORR SP, SP, #C0
T1WriteLong(MMU.ARM9_BIOS, 0x02A0, 0xE12FF00D); //MSR CPSR_fsxc, SP
T1WriteLong(MMU.ARM9_BIOS, 0x02A4, 0xE59FD000 | (0x2D4-0x2A4-8)); //LDR SP, [FFFF02D4]
T1WriteLong(MMU.ARM9_BIOS, 0x02A8, 0xE28DD001); //ADD SP, SP, #1
T1WriteLong(MMU.ARM9_BIOS, 0x02AC, 0xE92D5000); //STMDB SP!, {R12,LR}
T1WriteLong(MMU.ARM9_BIOS, 0x02B0, 0xE14FE000); //MRS LR, SPSR
T1WriteLong(MMU.ARM9_BIOS, 0x02B4, 0xEE11CF10); //MRC CP15, 0, R12, CR1, CR0, 0
T1WriteLong(MMU.ARM9_BIOS, 0x02B8, 0xE92D5000); //STMDB SP!, {R12,LR}
T1WriteLong(MMU.ARM9_BIOS, 0x02BC, 0xE3CCC001); //BIC R12, R12, #1
T1WriteLong(MMU.ARM9_BIOS, 0x02C0, 0xEE01CF10); //MCR CP15, 0, R12, CR1, CR0, 0
T1WriteLong(MMU.ARM9_BIOS, 0x02C4, 0xE3CDC001); //BIC R12, SP, #1
T1WriteLong(MMU.ARM9_BIOS, 0x02C8, 0xE59CC010); //LDR R12, [R12, #10]
T1WriteLong(MMU.ARM9_BIOS, 0x02CC, 0xE35C0000); //CMP R12, #0
T1WriteLong(MMU.ARM9_BIOS, 0x02D0, 0x112FFF3C); //BLXNE R12
T1WriteLong(MMU.ARM9_BIOS, 0x02D4, 0x027FFD9C); //0x027FFD9C
//---------
}
}
static void JumbleMemory() { }
static void PrepareLogfiles()
{
#ifdef LOG_ARM7
if (fp_dis7 != NULL)
{
fclose(fp_dis7);
fp_dis7 = NULL;
}
fp_dis7 = fopen("D:\\desmume_dis7.asm", "w");
#endif
#ifdef LOG_ARM9
if (fp_dis9 != NULL)
{
fclose(fp_dis9);
fp_dis9 = NULL;
}
fp_dis9 = fopen("D:\\desmume_dis9.asm", "w");
#endif
}
bool NDS_LegitBoot()
{
#ifdef HAVE_JIT
//hack for firmware boot in JIT mode.
//we know that it takes certain jit parameters to successfully boot the firmware.
//CRAZYMAX: is it safe to accept anything smaller than 12?
CommonSettings.jit_max_block_size = std::min(CommonSettings.jit_max_block_size,12U);
#endif
//partially clobber the loaded firmware with the user settings from DFC
firmware->loadSettings();
//since firmware only boots encrypted roms, we have to make sure it's encrypted first
//this has not been validated on big endian systems. it almost positively doesn't work.
if (gameInfo.header.CRC16 != 0)
EncryptSecureArea((u8*)&gameInfo.header, (u8*)gameInfo.secureArea);
//boot processors from their bios entrypoints
armcpu_init(&NDS_ARM7, 0x00000000);
armcpu_init(&NDS_ARM9, 0xFFFF0000);
return true;
}
//the fake firmware boot-up process
bool NDS_FakeBoot()
{
NDS_header * header = NDS_getROMHeader();
#ifndef NDEBUG
DEBUG_reset();
#endif
if (!header) return false;
nds.isFakeBooted = true;
//since we're bypassing the code to decrypt the secure area, we need to make sure its decrypted first
//this has not been validated on big endian systems. it almost positively doesn't work.
if (gameInfo.header.CRC16 != 0)
{
bool okRom = DecryptSecureArea((u8*)&gameInfo.header, (u8*)gameInfo.secureArea);
if(!okRom) {
printf("Specified file is not a valid rom\n");
return false;
}
}
//bios (or firmware) sets this default, which is generally not important for retail games but some homebrews are depending on
_MMU_write08(REG_WRAMCNT,3);
//EDIT - whats this firmware and how is it relating to the dummy firmware below
//how do these even get used? what is the purpose of unpack and why is it not used by the firmware boot process?
if (CommonSettings.UseExtFirmware && firmware->loaded())
{
firmware->unpack();
firmware->loadSettings();
}
// Create the dummy firmware
//EDIT - whats dummy firmware and how is relating to the above?
//it seems to be emplacing basic firmware data into MMU.fw.data
NDS_CreateDummyFirmware(&CommonSettings.fw_config);
//firmware loads the game card arm9 and arm7 programs as specified in rom header
{
bool hasSecureArea = ((gameInfo.romType == ROM_NDS) && (gameInfo.header.CRC16 != 0));
//copy the arm9 program to the address specified by rom header
u32 src = header->ARM9src;
u32 dst = header->ARM9cpy;
for(u32 i = 0; i < header->ARM9binSize; i+=4)
{
u32 tmp = (hasSecureArea && ((src >= 0x4000) && (src < 0x8000)))?LE_TO_LOCAL_32(*(u32*)(gameInfo.secureArea + (src - 0x4000))):gameInfo.readROM(src);
_MMU_write32(dst, tmp);
dst += 4;
src += 4;
}
//copy the arm7 program to the address specified by rom header
src = header->ARM7src;
dst = header->ARM7cpy;
for(u32 i = 0; i < header->ARM7binSize; i+=4)
{
_MMU_write32(dst, gameInfo.readROM(src));
dst += 4;
src += 4;
}
}
//bios does this (thats weird, though. shouldnt it get changed when the card is swapped in the firmware menu?
//right now our firmware menu isnt detecting any change to the card.
//are some games depending on it being written here? please document.
//_MMU_write16(0x027FF808, T1ReadWord(MMU.CART_ROM, 0x15E));
//firmware sets up a copy of the firmware user settings in memory.
//TBD - this code is really clunky
//it seems to be copying the MMU.fw.data data into RAM in the user memory stash locations
u8 temp_buffer[NDS_FW_USER_SETTINGS_MEM_BYTE_COUNT];
if ( copy_firmware_user_data( temp_buffer, MMU.fw.data)) {
for ( int fw_index = 0; fw_index < NDS_FW_USER_SETTINGS_MEM_BYTE_COUNT; fw_index++)
_MMU_write08(0x027FFC80 + fw_index, temp_buffer[fw_index]);
}
//something copies the whole header to Main RAM 0x27FFE00 on startup. (http://nocash.emubase.de/gbatek.htm#dscartridgeheader)
//once upon a time this copied 0x90 more. this was thought to be wrong, and changed.
if(nds.Is_DSI())
{
//dsi needs this copied later in memory. there are probably a number of things that get copied to a later location in memory.. thats where the NDS consoles tend to stash stuff.
for (int i = 0; i < (0x170); i+=4)
_MMU_write32(0x027FFE00 + i, gameInfo.readROM(i));
}
else
{
for (int i = 0; i < (0x170); i+=4)
_MMU_write32(0x027FFE00 + i, gameInfo.readROM(i));
}
//the firmware will be booting to these entrypoint addresses via BX (well, the arm9 at least; is unverified for the arm7)
armcpu_init(&NDS_ARM7, header->ARM7exe);
armcpu_init(&NDS_ARM9, header->ARM9exe);
//firmware sets REG_POSTFLG to the value indicating post-firmware status
MMU.ARM9_REG[0x300] = 1;
MMU.ARM7_REG[0x300] = 1;
//firmware makes system think it's booted from card -- EXTREMELY IMPORTANT!!! This is actually checked by some things. (which things?) Thanks to cReDiAr
_MMU_write08(0x02FFFC40,0x1); // removed redundant write to ARM9, this is going to shared main memory. But one has to wonder why r3478 was made which corrected a typo resulting in only ARMCPU_ARM7 getting used.
//the chipId is read several times
//for some reason, each of those reads get stored here.
_MMU_write32(0x027FF800, gameInfo.chipID); //1st chipId
_MMU_write32(0x027FF804, gameInfo.chipID); //2nd (secure) chipId
_MMU_write32(0x027FFC00, gameInfo.chipID); //3rd (secure) chipId
// Write the header checksum to memory
_MMU_write16(0x027FF808, gameInfo.header.headerCRC16);
//bitbox 4k demo is so stripped down it relies on default stack values
//otherwise the arm7 will crash before making a sound
//(these according to gbatek softreset bios docs)
NDS_ARM7.R13_svc = 0x0380FFDC;
NDS_ARM7.R13_irq = 0x0380FFB0;
NDS_ARM7.R13_usr = 0x0380FF00;
NDS_ARM7.R[13] = NDS_ARM7.R13_usr;
//and let's set these for the arm9 while we're at it, though we have no proof
NDS_ARM9.R13_svc = 0x00803FC0;
NDS_ARM9.R13_irq = 0x00803FA0;
NDS_ARM9.R13_usr = 0x00803EC0;
NDS_ARM9.R13_abt = NDS_ARM9.R13_usr; //?????
//I think it is wrong to take gbatek's "SYS" and put it in USR--maybe USR doesnt matter.
//i think SYS is all the misc modes. please verify by setting nonsensical stack values for USR here
NDS_ARM9.R[13] = NDS_ARM9.R13_usr;
//n.b.: im not sure about all these, I dont know enough about arm9 svc/irq/etc modes
//and how theyre named in desmume to match them up correctly. i just guessed.
//--------------------------------
//setup the homebrew argv
//this is useful for nitrofs apps which are emulating themselves via cflash
//struct __argv {
// int argvMagic; //!< argv magic number, set to 0x5f617267 ('_arg') if valid
// char *commandLine; //!< base address of command line, set of null terminated strings
// int length; //!< total length of command line
// int argc; //!< internal use, number of arguments
// char **argv; //!< internal use, argv pointer
//};
std::string rompath = "fat:/" + path.RomName;
const u32 kCommandline = 0x027E0000;
//const u32 kCommandline = 0x027FFF84;
//homebrew-related stuff.
//its safe to put things in this position.. apparently nothing important is here.
//however, some games could be checking them as an anti-desmume measure, so we might have to control it with slot-1 settings to suggest booting a homebrew app
//perhaps we could automatically boot homebrew to an R4-like device.
_MMU_write32(0x02FFFE70, 0x5f617267);
_MMU_write32(0x02FFFE74, kCommandline); //(commandline starts here)
_MMU_write32(0x02FFFE78, rompath.size()+1);
//0x027FFF7C (argc)
//0x027FFF80 (argv)
for(size_t i=0;i(kCommandline+i, rompath[i]);
_MMU_write08(kCommandline+rompath.size(), 0);
//--------------------------------
//Call the card post_fakeboot hook to perform additional initialization
slot1_device->post_fakeboot(ARMCPU_ARM9);
slot1_device->post_fakeboot(ARMCPU_ARM7);
delete header;
return true;
}
void NDS_Reset()
{
PrepareLogfiles();
currFrameCounter = 0;
resetUserInput();
singleStep = false;
nds_debug_continuing[0] = nds_debug_continuing[1] = false;
nds.sleeping = FALSE;
nds.cardEjected = FALSE;
nds.freezeBus = 0;
nds.power1.lcd = nds.power1.gpuMain = nds.power1.gfx3d_render = nds.power1.gfx3d_geometry = nds.power1.gpuSub = nds.power1.dispswap = 1;
nds.power2.speakers = 1;
nds.power2.wifi = 0;
nds.wifiCycle = 0;
memset(nds.timerCycle, 0, sizeof(u64) * 2 * 4);
nds.old = 0;
nds.scr_touchX = nds.scr_touchY = nds.adc_touchX = nds.adc_touchY = 0;
nds.isTouch = 0;
nds.isFakeBooted = false;
nds.paddle = 0;
nds.ConsoleType = CommonSettings.ConsoleType;
nds._DebugConsole = CommonSettings.DebugConsole;
nds.ensataEmulation = CommonSettings.EnsataEmulation;
nds.stylusJitter = CommonSettings.StylusJitter;
nds.ensataHandshake = ENSATA_HANDSHAKE_none;
nds.ensataIpcSyncCounter = 0;
nds_timer = 0;
nds_arm9_timer = 0;
nds_arm7_timer = 0;
LidClosed = FALSE;
countLid = 0;
MMU_Reset();
SetupMMU(nds.Is_DebugConsole(),nds.Is_DSI());
JumbleMemory();
#ifdef HAVE_JIT
arm_jit_reset(CommonSettings.use_jit);
#endif
//initialize CP15 specially for this platform
//TODO - how much of this is necessary for firmware boot?
//(only ARM9 has CP15)
reconstruct(&cp15);
MMU.ARM9_RW_MODE = BIT7(cp15.ctrl);
NDS_ARM9.intVector = 0xFFFF0000 * (BIT13(cp15.ctrl));
NDS_ARM9.LDTBit = !BIT15(cp15.ctrl); //TBit
PrepareBiosARM7();
PrepareBiosARM9();
if (firmware)
{
delete firmware;
firmware = NULL;
}
firmware = new CFIRMWARE();
firmware->load();
//we will allow a proper firmware boot, if:
//1. we have the ARM7 and ARM9 bioses (its doubtful that our HLE bios implement the necessary functions)
//2. firmware is available
//3. user has requested booting from firmware
bool canBootFromFirmware = (NDS_ARM7.BIOS_loaded && NDS_ARM9.BIOS_loaded && CommonSettings.BootFromFirmware && firmware->loaded());
bool bootResult = false;
if(canBootFromFirmware)
bootResult = NDS_LegitBoot();
else
bootResult = NDS_FakeBoot();
// Init calibration info
memcpy(&TSCal, firmware->getTouchCalibrate(), sizeof(TSCalInfo));
GPU->Reset();
WIFI_Reset();
memcpy(FW_Mac, (MMU.fw.data + 0x36), 6);
SPU_DeInit();
SPU_ReInit(!canBootFromFirmware && bootResult);
//this needs to happen last, pretty much, since it establishes the correct scheduling state based on all of the above initialization
initSchedule();
}
//convert a 12.4 screen coordinate to an ADC value.
//the desmume host system will track the screen coordinate, but the hardware should be receiving the raw ADC values.
//so we'll need to use this to simulate the ADC values corresponding to the desired screen coords, based on the current TSC calibrations
u16 NDS_getADCTouchPosX(int scrX_lsl4)
{
scrX_lsl4 >>= 4;
int rv = ((scrX_lsl4 - TSCal.scr.x1 + 1) * TSCal.adc.width) / TSCal.scr.width + TSCal.adc.x1;
rv = min(0xFFF, max(0, rv));
return (u16)(rv);
}
u16 NDS_getADCTouchPosY(int scrY_lsl4)
{
scrY_lsl4 >>= 4;
int rv = ((scrY_lsl4 - TSCal.scr.y1 + 1) * TSCal.adc.height) / TSCal.scr.height + TSCal.adc.y1;
rv = min(0xFFF, max(0, rv));
return (u16)(rv);
}
static UserInput rawUserInput = {}; // requested input, generally what the user is physically pressing
static UserInput finalUserInput = {}; // what gets sent to the game and possibly recorded
const UserInput& NDS_getRawUserInput()
{
return rawUserInput;
}
UserInput& NDS_getProcessingUserInput()
{
return rawUserInput;
}
const UserInput& NDS_getFinalUserInput()
{
return finalUserInput;
}
static void saveUserInput(EMUFILE* os, UserInput& input)
{
os->fwrite((const char*)input.buttons.array, 14);
writebool(input.touch.isTouch, os);
write16le(input.touch.touchX, os);
write16le(input.touch.touchY, os);
write32le(input.mic.micButtonPressed, os);
}
static bool loadUserInput(EMUFILE* is, UserInput& input, int version)
{
is->fread((char*)input.buttons.array, 14);
readbool(&input.touch.isTouch, is);
read16le(&input.touch.touchX, is);
read16le(&input.touch.touchY, is);
read32le(&input.mic.micButtonPressed, is);
return true;
}
static void resetUserInput(UserInput& input)
{
memset(&input, 0, sizeof(UserInput));
}
// (userinput is kind of a misnomer, e.g. finalUserInput has to mirror nds.pad, nds.touchX, etc.)
static void saveUserInput(EMUFILE* os)
{
saveUserInput(os, finalUserInput);
saveUserInput(os, rawUserInput); // saved in case a savestate is made during input processing (which Lua could do if nothing else)
bool validToProcessInput = true;
writebool(validToProcessInput, os);
for(int i = 0; i < 14; i++)
write32le(0, os); // saved to make autofire more tolerable to use with re-recording
}
static bool loadUserInput(EMUFILE* is, int version)
{
bool rv = true;
bool validToProcessInput = true;
rv &= loadUserInput(is, finalUserInput, version);
rv &= loadUserInput(is, rawUserInput, version);
readbool(&validToProcessInput, is);
u32 j = 0;
for(int i = 0; i < 14; i++)
read32le((u32*)&j, is);
return rv;
}
static void resetUserInput()
{
resetUserInput(finalUserInput);
}
void NDS_setPad(bool R,bool L,bool D,bool U,bool T,bool S,bool B,bool A,bool Y,bool X,bool W,bool E,bool G, bool F)
{
UserButtons& rawButtons = rawUserInput.buttons;
rawButtons.R = R;
rawButtons.L = L;
rawButtons.D = D;
rawButtons.U = U;
rawButtons.T = T;
rawButtons.S = S;
rawButtons.B = B;
rawButtons.A = A;
rawButtons.Y = Y;
rawButtons.X = X;
rawButtons.W = W;
rawButtons.E = E;
rawButtons.G = G;
rawButtons.F = F;
}
void NDS_setTouchPos(u16 x, u16 y, u16 scale)
{
rawUserInput.touch.touchX = (x/scale)<<4;
rawUserInput.touch.touchY = (y/scale)<<4;
rawUserInput.touch.isTouch = true;
nds.stylusJitter = CommonSettings.StylusJitter;
}
void NDS_releaseTouch(void)
{
rawUserInput.touch.touchX = 0;
rawUserInput.touch.touchY = 0;
rawUserInput.touch.isTouch = false;
}
void NDS_setMic(bool pressed)
{
rawUserInput.mic.micButtonPressed = (pressed ? TRUE : FALSE);
}
static void NDS_applyFinalInput()
{
const UserInput& input = NDS_getFinalUserInput();
u16 pad = (0 |
((input.buttons.A ? 0 : 0x80) >> 7) |
((input.buttons.B ? 0 : 0x80) >> 6) |
((input.buttons.T ? 0 : 0x80) >> 5) |
((input.buttons.S ? 0 : 0x80) >> 4) |
((input.buttons.R ? 0 : 0x80) >> 3) |
((input.buttons.L ? 0 : 0x80) >> 2) |
((input.buttons.U ? 0 : 0x80) >> 1) |
((input.buttons.D ? 0 : 0x80) ) |
((input.buttons.E ? 0 : 0x80) << 1) |
((input.buttons.W ? 0 : 0x80) << 2)) ;
pad = LOCAL_TO_LE_16(pad);
((u16 *)MMU.ARM9_REG)[0x130>>1] = (u16)pad;
((u16 *)MMU.ARM7_REG)[0x130>>1] = (u16)pad;
u16 k_cnt = ((u16 *)MMU.ARM9_REG)[0x132>>1];
if ( k_cnt & (1<<14))
{
//INFO("ARM9: KeyPad IRQ (pad 0x%04X, cnt 0x%04X (condition %s))\n", pad, k_cnt, k_cnt&(1<<15)?"AND":"OR");
u16 k_cnt_selected = (k_cnt & 0x3F);
if (k_cnt&(1<<15)) // AND
{
if ((~pad & k_cnt_selected) == k_cnt_selected) NDS_makeIrq(ARMCPU_ARM9,IRQ_BIT_KEYPAD);
}
else // OR
{
if (~pad & k_cnt_selected) NDS_makeIrq(ARMCPU_ARM9,IRQ_BIT_KEYPAD);
}
}
k_cnt = ((u16 *)MMU.ARM7_REG)[0x132>>1];
if ( k_cnt & (1<<14))
{
//INFO("ARM7: KeyPad IRQ (pad 0x%04X, cnt 0x%04X (condition %s))\n", pad, k_cnt, k_cnt&(1<<15)?"AND":"OR");
u16 k_cnt_selected = (k_cnt & 0x3F);
if (k_cnt&(1<<15)) // AND
{
if ((~pad & k_cnt_selected) == k_cnt_selected) NDS_makeIrq(ARMCPU_ARM7,IRQ_BIT_KEYPAD);
}
else // OR
{
if (~pad & k_cnt_selected) NDS_makeIrq(ARMCPU_ARM7,IRQ_BIT_KEYPAD);
}
}
if(input.touch.isTouch)
{
u16 adc_x = NDS_getADCTouchPosX(input.touch.touchX);
u16 adc_y = NDS_getADCTouchPosY(input.touch.touchY);
nds.adc_touchX = adc_x;
nds.adc_touchY = adc_y;
nds.adc_jitterctr = 0;
nds.scr_touchX = input.touch.touchX;
nds.scr_touchY = input.touch.touchY;
nds.isTouch = 1;
}
else
{
nds.adc_touchX = 0;
nds.adc_touchY = 0;
nds.scr_touchX = 0;
nds.scr_touchY = 0;
nds.isTouch = 0;
}
if (input.buttons.F && !countLid)
{
LidClosed = (!LidClosed) & 0x01;
if (!LidClosed)
{
NDS_makeIrq(ARMCPU_ARM7,IRQ_BIT_ARM7_FOLD);
}
countLid = 30;
}
else
{
if (countLid > 0)
countLid--;
}
u16 padExt = ((input.buttons.X ? 0 : 0x80) >> 7) |
((input.buttons.Y ? 0 : 0x80) >> 6) |
((input.buttons.G ? 0 : 0x80) >> 4) |
((LidClosed) << 7) |
0x0034;
padExt = LOCAL_TO_LE_16(padExt);
padExt |= (((u16 *)MMU.ARM7_REG)[0x136>>1] & 0x0070);
((u16 *)MMU.ARM7_REG)[0x136>>1] = (u16)padExt;
//put into the format we want for the movie system
//fRLDUTSBAYXWEg
//we don't really need nds.pad anymore, but removing it would be a pain
nds.pad =
((input.buttons.R ? 1 : 0) << 12)|
((input.buttons.L ? 1 : 0) << 11)|
((input.buttons.D ? 1 : 0) << 10)|
((input.buttons.U ? 1 : 0) << 9)|
((input.buttons.T ? 1 : 0) << 8)|
((input.buttons.S ? 1 : 0) << 7)|
((input.buttons.B ? 1 : 0) << 6)|
((input.buttons.A ? 1 : 0) << 5)|
((input.buttons.Y ? 1 : 0) << 4)|
((input.buttons.X ? 1 : 0) << 3)|
((input.buttons.W ? 1 : 0) << 2)|
((input.buttons.E ? 1 : 0) << 1);
}
void NDS_beginProcessingInput()
{
}
void NDS_endProcessingInput()
{
// transfer the processed input
finalUserInput = rawUserInput;
// use the final input for a few things right away
NDS_applyFinalInput();
}
void NDS_suspendProcessingInput(bool suspend)
{
static int suspendCount = 0;
if(suspend)
suspendCount++;
else if(suspendCount)
suspendCount--;
}
void NDS_swapScreen()
{
if (GPU->GetDisplayMain()->GetEngineID() == GPUEngineID_Main)
{
GPU->GetDisplayMain()->SetEngineByID(GPUEngineID_Sub);
GPU->GetDisplayTouch()->SetEngineByID(GPUEngineID_Main);
}
else
{
GPU->GetDisplayMain()->SetEngineByID(GPUEngineID_Main);
GPU->GetDisplayTouch()->SetEngineByID(GPUEngineID_Sub);
}
}
#if defined(LOG_ARM9) || defined(LOG_ARM7)
void emu_halt()
{
//printf("halting emu: ARM9 PC=%08X/%08X, ARM7 PC=%08X/%08X\n", NDS_ARM9.R[15], NDS_ARM9.instruct_adr, NDS_ARM7.R[15], NDS_ARM7.instruct_adr);
execute = false;
#ifdef LOG_ARM9
if (fp_dis9)
{
char buf[256] = { 0 };
sprintf(buf, "halting emu: ARM9 PC=%08X/%08X\n", NDS_ARM9.R[15], NDS_ARM9.instruct_adr);
fwrite(buf, 1, strlen(buf), fp_dis9);
INFO("ARM9 halted\n");
}
#endif
#ifdef LOG_ARM7
if (fp_dis7)
{
char buf[256] = { 0 };
sprintf(buf, "halting emu: ARM7 PC=%08X/%08X\n", NDS_ARM7.R[15], NDS_ARM7.instruct_adr);
fwrite(buf, 1, strlen(buf), fp_dis7);
INFO("ARM7 halted\n");
}
#endif
}
#endif
//returns true if exmemcnt specifies satisfactory parameters for the device, which calls this function
bool ValidateSlot2Access(u32 procnum, u32 demandSRAMSpeed, u32 demand1stROMSpeed, u32 demand2ndROMSpeed, int clockbits)
{
static const u32 _sramSpeeds[] = {10,8,6,18};
static const u32 _rom1Speeds[] = {10,8,6,18};
static const u32 _rom2Speeds[] = {6,4};
u16 exmemcnt = T1ReadWord(MMU.MMU_MEM[procnum][0x40], 0x204);
u16 exmemcnt9 = T1ReadWord(MMU.MMU_MEM[ARMCPU_ARM9][0x40], 0x204);
u32 arm7access = (exmemcnt9 & EXMEMCNT_MASK_SLOT2_ARM7);
u32 sramSpeed = _sramSpeeds[(exmemcnt & EXMEMCNT_MASK_SLOT2_SRAM_TIME)];
u32 romSpeed1 = _rom1Speeds[(exmemcnt & EXMEMCNT_MASK_SLOT2_ROM_1ST_TIME)>>2];
u32 romSpeed2 = _rom2Speeds[(exmemcnt & EXMEMCNT_MASK_SLOT2_ROM_2ND_TIME)>>4];
u32 curclockbits = (exmemcnt & EXMEMCNT_MASK_SLOT2_CLOCKRATE)>>5;
if(procnum==ARMCPU_ARM9 && arm7access) return false;
if(procnum==ARMCPU_ARM7 && !arm7access) return false;
//what we're interested in here is whether the rom/ram are too low -> too fast. then accesses won't have enough time to work.
//i'm not sure if this gives us enough flexibility, but it is good enough for now.
//should make the arguments to this function bitmasks later if we need better.
if(sramSpeed < demandSRAMSpeed) return false;
if(romSpeed1 < demand1stROMSpeed) return false;
if(romSpeed2 < demand2ndROMSpeed) return false;
if(clockbits != -1 && clockbits != (int)curclockbits) return false;
return true;
}
desmume/src/libretro-common/include/features/ 000700 001750 001750 00000000000 12756420131 022466 5 ustar 00sergio sergio 000000 000000 desmume/src/utils/AsmJit/x86/x86util.cpp 000664 001750 001750 00000005500 12755534123 021142 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
#define ASMJIT_EXPORTS
// [Dependencies - AsmJit]
#include "../x86/x86defs.h"
// [Api-Begin]
#include "../core/apibegin.h"
namespace AsmJit {
// ============================================================================
// [AsmJit::_x86UtilJccFromCond]
// ============================================================================
const uint32_t _x86UtilJccFromCond[20] =
{
kX86InstJO,
kX86InstJNO,
kX86InstJB,
kX86InstJAE,
kX86InstJE,
kX86InstJNE,
kX86InstJBE,
kX86InstJA,
kX86InstJS,
kX86InstJNS,
kX86InstJPE,
kX86InstJPO,
kX86InstJL,
kX86InstJGE,
kX86InstJLE,
kX86InstJG,
kInstNone,
kInstNone,
kInstNone,
kInstNone
};
// ============================================================================
// [AsmJit::_x86UtilMovccFromCond]
// ============================================================================
const uint32_t _x86UtilMovccFromCond[20] =
{
kX86InstCMovO,
kX86InstCMovNO,
kX86InstCMovB,
kX86InstCMovAE,
kX86InstCMovE,
kX86InstCMovNE,
kX86InstCMovBE,
kX86InstCMovA,
kX86InstCMovS,
kX86InstCMovNS,
kX86InstCMovPE,
kX86InstCMovPO,
kX86InstCMovL,
kX86InstCMovGE,
kX86InstCMovLE,
kX86InstCMovG,
kInstNone,
kInstNone,
kInstNone,
kInstNone
};
// ============================================================================
// [AsmJit::_x86UtilSetccFromCond]
// ============================================================================
const uint32_t _x86UtilSetccFromCond[20] =
{
kX86InstSetO,
kX86InstSetNO,
kX86InstSetB,
kX86InstSetAE,
kX86InstSetE,
kX86InstSetNE,
kX86InstSetBE,
kX86InstSetA,
kX86InstSetS,
kX86InstSetNS,
kX86InstSetPE,
kX86InstSetPO,
kX86InstSetL,
kX86InstSetGE,
kX86InstSetLE,
kX86InstSetG,
kInstNone,
kInstNone,
kInstNone,
kInstNone
};
// ============================================================================
// [AsmJit::_x86UtilReversedCond]
// ============================================================================
const uint32_t _x86UtilReversedCond[20] =
{
/* x86CondO -> */ kX86CondO,
/* x86CondNO -> */ kX86CondNO,
/* x86CondB -> */ kX86CondA,
/* x86CondAE -> */ kX86CondBE,
/* x86CondE -> */ kX86CondE,
/* x86CondNE -> */ kX86CondNE,
/* x86CondBE -> */ kX86CondAE,
/* x86CondA -> */ kX86CondB,
/* x86CondS -> */ kX86CondS,
/* x86CondNS -> */ kX86CondNS,
/* x86CondPE -> */ kX86CondPE,
/* x86CondPO -> */ kX86CondPO,
/* x86CondL -> */ kX86CondG,
/* x86CondGE -> */ kX86CondLE,
/* x86CondLE -> */ kX86CondGE,
/* x86CondG -> */ kX86CondL,
/* kX86CondFpuUnordered -> */ kX86CondFpuUnordered,
/* kX86CondFpuNotUnordered -> */ kX86CondFpuNotUnordered,
0x12,
0x13
};
} // AsmJit namespace
#include "../core/apiend.h"
desmume/src/libretro-common/include/rthreads/rsemaphore.h 000664 001750 001750 00000003634 12755534123 025032 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (rsemaphore.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_SEMAPHORE_H
#define __LIBRETRO_SDK_SEMAPHORE_H
#include
RETRO_BEGIN_DECLS
typedef struct ssem ssem_t;
/**
* ssem_create:
* @value : initial value for the semaphore
*
* Create a new semaphore.
*
* Returns: pointer to new semaphore if successful, otherwise NULL.
*/
ssem_t *ssem_new(int value);
void ssem_free(ssem_t *semaphore);
int ssem_get(ssem_t *semaphore);
void ssem_wait(ssem_t *semaphore);
void ssem_signal(ssem_t *semaphore);
RETRO_END_DECLS
#endif /* __LIBRETRO_SDK_SEMAPHORE_H */
desmume/src/libretro-common/conversion/ 000700 001750 001750 00000000000 12756420131 021412 5 ustar 00sergio sergio 000000 000000 desmume/src/utils/libfat/common.h 000664 001750 001750 00000005425 12755534123 020207 0 ustar 00sergio sergio 000000 000000 /*
common.h
Common definitions and included files for the FATlib
Copyright (c) 2006 Michael "Chishm" Chisholm
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _COMMON_H
#define _COMMON_H
#define BYTES_PER_READ 512
#include
#ifndef _MSC_VER
#include
#endif
// When compiling for NDS, make sure NDS is defined
#ifndef NDS
#if defined ARM9 || defined ARM7
#define NDS
#endif
#endif
// Platform specific includes
#if defined(__gamecube__) || defined (__wii__)
#include
#include
#include
#elif defined(NDS)
#include
#include
#include
#elif defined(GBA)
#include
#include
#endif
#include
// Platform specific options
#if defined (__wii__)
#define DEFAULT_CACHE_PAGES 4
#define DEFAULT_SECTORS_PAGE 64
#define USE_LWP_LOCK
#define USE_RTC_TIME
#elif defined (__gamecube__)
#define DEFAULT_CACHE_PAGES 4
#define DEFAULT_SECTORS_PAGE 64
#define USE_LWP_LOCK
#define USE_RTC_TIME
#elif defined (NDS)
#define DEFAULT_CACHE_PAGES 4
#define DEFAULT_SECTORS_PAGE 8
#define USE_RTC_TIME
#elif defined (GBA)
#define DEFAULT_CACHE_PAGES 2
#define DEFAULT_SECTORS_PAGE 8
#define LIMIT_SECTORS 128
#else
#define LIBFAT_PC 1
//any particular reason for this?
#define DEFAULT_CACHE_PAGES 4
#define DEFAULT_SECTORS_PAGE 8
#endif
#include "libfat_pc.h"
#include "fat.h"
#endif // _COMMON_H
desmume/src/utils/AsmJit/core/assert.h 000664 001750 001750 00000003012 12755534123 021064 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
// [Guard]
#ifndef _ASMJIT_CORE_ASSERT_H
#define _ASMJIT_CORE_ASSERT_H
// [Dependencies - AsmJit]
#include "../core/build.h"
// [Api-Begin]
#include "../core/apibegin.h"
namespace AsmJit {
//! @addtogroup AsmJit_Core
//! @{
// ============================================================================
// [AsmJit::Assert]
// ============================================================================
//! @brief Called in debug build on assertion failure.
//! @param file Source file name where it happened.
//! @param line Line in the source file.
//! @param exp Expression what failed.
//!
//! If you have problems with assertions simply put a breakpoint into
//! AsmJit::assertionFailure() method (AsmJit/Core/Assert.cpp file) and examine
//! call stack.
ASMJIT_API void assertionFailure(const char* file, int line, const char* exp);
// ============================================================================
// [ASMJIT_ASSERT]
// ============================================================================
#if defined(ASMJIT_DEBUG)
#if !defined(ASMJIT_ASSERT)
#define ASMJIT_ASSERT(exp) \
do { \
if (!(exp)) ::AsmJit::assertionFailure(__FILE__, __LINE__, #exp); \
} while(0)
#endif
#else
#if !defined(ASMJIT_ASSERT)
#define ASMJIT_ASSERT(exp) ASMJIT_NOP()
#endif
#endif // DEBUG
//! @}
} // AsmJit namespace
// [Api-End]
#include "../core/apiend.h"
// [Guard]
#endif // _ASMJIT_CORE_ASSERT_H
desmume/src/libretro-common/include/compat/msvc/ 000700 001750 001750 00000000000 12756420131 023103 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/gfx/scaler/ 000700 001750 001750 00000000000 12756420131 021262 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/formats/jpeg/ 000700 001750 001750 00000000000 12756420131 021625 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/file/nbio/test/nbio_test 000755 001750 001750 00000036450 12755534123 024016 0 ustar 00sergio sergio 000000 000000 ELF > `@ @ (4 @ 8 @ $ ! @ @ @ @ @ À À @ @ @ @ Ô Ô Ø Ø` Ø` Ø à ð ð` ð` Ð Ð @ @ D D Påtd @ @ „ „ Qåtd /lib64/ld-linux-x86-64.so.2 GNU GNU ³çÙƒž4Ñá:Z¤ßðuñ8ö5<¢ k $ S > * Y 7 p E 1 L libc.so.6 fopen ftell puts realloc abort memset fseek memcmp fclose malloc fwrite fread __libc_start_main free __gmon_start__ GLIBC_2.2.5 ui À`
à` è` ð` ø` ` ` ` ` ` (` 0` 8`
@` H` HƒìH‹} H…Àtè HƒÄà ÿ5j ÿ%l @ ÿ%j h éàÿÿÿÿ%b h éÐÿÿÿÿ%Z h éÀÿÿÿÿ%R h é°ÿÿÿÿ%J h é ÿÿÿÿ%B h éÿÿÿÿ%: h é€ÿÿÿÿ%2 h épÿÿÿÿ%* h é`ÿÿÿÿ%" h éPÿÿÿÿ% h
é@ÿÿÿÿ% h é0ÿÿÿÿ%
h é ÿÿÿÿ% h
éÿÿÿÿ%j f 1íI‰Ñ^H‰âHƒäðPTIÇÀ @ HÇÁ°@ HÇÇ"
@ èGÿÿÿôf D ¸·` UH-°` HƒøH‰åv¸ H…Àt]¿°` ÿàf „ ]à @ f. „ ¾°` UHî°` HÁþH‰åH‰ðHÁè?HÆHÑþt¸ H…Àt ]¿°` ÿà ]Ãf D €=™ uUH‰åènÿÿÿ]Ɔ óà @ ¿è` Hƒ? uë“ ¸ H…ÀtñUH‰åÿÐ]ézÿÿÿUH‰åHƒì ÆEÿ HÇEð ¾ ¿8@ è¾ H‰EèH‹Eè¾ H‰Çè‡ HUàH‹EèH‰ÖH‰Çè H‰EðH‹EàH= t
¿A@ èÕýÿÿH‹E𺠾B H‰ÇèïýÿÿH‹EèH‰Çè- ëÆEÿH‹EèH‰Çè{ ƒð„Àué¶Eÿƒð„Àt
¿W@ è…ýÿÿH‹EèH‰Çè ÉÃUH‰åHƒì ÆEÿ ¾ ¿8@ è H‰EðHUàH‹EðH‰ÖH‰Çèk H‰EèH‹EàH= t
¿s@ è*ýÿÿHƒ}è t
¿@ èýÿÿH‹EðH‰Çè' ëÆEÿH‹EðH‰ÇèÕ ƒð„Àué¶Eÿƒð„Àt
¿¼@ èßüÿÿHUàH‹EðH‰ÖH‰Çèó H‰EèH‹EàH= t
¿×@ è²üÿÿH‹Eè¶ õÿÿÄ A†C
¿ d âõÿÿ A†C
„ Êöÿÿ A†C
P ¤ ¿öÿÿs A†C
n Ä øÿÿ` A†C
[ ä Røÿÿ` A†C
[ ’øÿÿ« A†C
¦ $ úÿÿ¢ A†C
D ŸúÿÿM A†C
H d Ìúÿÿ, A†C
g „ Øúÿÿu A†C
p D ¤ 8ûÿÿe BBŽE B(ŒH0†H8ƒM@r8A0A(B BBB ì `ûÿÿ 0@ @ 8@
$@ Ø` à` õþÿo `@ @ €@
‹ È` P è@ Ð@ þÿÿo °@ ÿÿÿo ðÿÿo Œ@ ð` v@ †@ –@ ¦@ ¶@ Æ@ Ö@ æ@ ö@ @ @ &@ 6@ F@ @ @ @ @ @ @ GCC: (GNU) 5.3.0 , V@ á , \ 7
@ n X Ø @ V@ á Ø8 ; ‹ » @ Î int _ ë ” ¥ V@ Ä œÖ ù - ‘Pä Ö ‘optr
w ‘`, â ‘X µ ž
Ý ô @ œ> ù - ‘Pä !Ö ‘o "â ‘`ptr #w ‘X ™ ;b "
@ œ ! ´ @ 7
@ n Ë Ø8 ; ‹ » @ Î int _ ƒi ˆ „i ë • ” R 0§ N Øñ$ ƒ òb ÷ v ø ’ ù 2 ú Ù û (5 ü 0) ý 8Š þ @ þ H ð P X b \ ` b h h b p b t ¢ p x – F € k T ‚ h ƒ x ˆ ¦ !{ Ä ) ˜ Ë * Ò + ¨ Ù , ° à .- ¸ & /b À ç 1~ Ä
C –· œ\ ‚ \ ç žb W ¢b + § • x † $ • Ž † ”
• Z 6 ž (ù f ù í ®
- len - op T ' T ! œ  f 7
@ s œf , Ž ‘X' M ‘T f ‘hf ù ‘`\ =S @ § Jª @ ` œ˜ Jf ‘h ! [
@ ` œÄ [f ‘h Ì k" j @ « œ" kf ‘X m- ‘h[
@ I z ƒ- ‘` µ ò •@ ¢ œc •f ‘hlen •- ‘` M « ·@ M œ¡ «f ‘hlen «¡ ‘` - ¶@ , œÓ ¶f ‘h ¿0@ u œÿ ¿f ‘h Ž † p ÿ €` % : ; I $ > $ > .: ; '@–B 4 : ; I 4 : ; I <
I . ?: ; 'I@–B % : ; I $ > $ > I : ;
: ; I8
: ;I8
: ; I ! I/
& I
: ; I8 .?: ; 'I@–B : ; I 4 : ; I 4 : ; I
: ; .?: ; '@–B : ; I .?: ; 'I@—B .?: ; '@—B Ç b û
/usr/lib/gcc/x86_64-unknown-linux-gnu/5.3.0/include nbio_test.c stddef.h V@ „Kƒ0g» Y¼ . J0 »?„K/h»Ÿu ¼ . J0 h»Ÿ ¬å »?KYŸ e ¦ û
.. /usr/lib/gcc/x86_64-unknown-linux-gnu/5.3.0/include /usr/include/bits /usr/include nbio_stdio.c stddef.h types.h stdio.h libio.h 7
@ åƒÉu د¼Îƒ‘*'» ÈËó„gf<(vÉ󻼃»Y1»w¼Ÿ[„ƒuÖ 1»w¼Ÿ[ƒƒvÖ 1»„u ’…¼»èW/Z¼ƒ»$Ÿw/#hKƒ1󯼟ZØŸ[»&ƒp 1»uuu廟Y1ƒwƒ $1»v¼ŸZåô»uÖ size_t GNU C99 5.3.0 -mtune=generic -march=x86-64 -g -std=gnu99 /home/squarepusher/libretro-super/retroarch/libretro-common/file/nbio/test unsigned char main nbio_t nbio_write_test _Bool short unsigned int short int nbio_test.c looped sizetype nbio_read_test __off_t _IO_read_ptr _chain _shortbuf _IO_buf_base long long unsigned int nbio_get_ptr long long int _fileno modes _IO_read_end _flags _IO_buf_end _cur_column _old_offset progress _IO_marker nbio_open nbio_iterate _IO_write_ptr _sbuf data nbio_resize _IO_save_base nbio_cancel _lock _flags2 _mode filename _IO_write_end _IO_lock_t _IO_FILE _pos error _markers _vtable_offset written _next __off64_t _IO_read_base _IO_save_end amount ../nbio_stdio.c __pad1 __pad2 __pad3 __pad4 __pad5 _unused2 _IO_backup_base nbio_begin_read nbio_free handle nbio_begin_write _IO_write_base @ @ <@ `@ €@ @ Œ@ °@ Ð@
è@ 8@ `@
P@ `@ $@ 0@ @ @ Ø` à` è` ð` À` È` `` °` ñÿ ñÿ è` @ " Ð@ 5 @ K °` Z à` 0@ Ø` ¬ ñÿ ¸ V@ Ä È @ × ñÿ ä €` 0 ñÿ ê Ð@ ø è` ñÿ à` ð` Ø` 1 @ D È` Z @ j | @ `` « ½ Ð °` × d $@ ë @ ¢ ÷ * > `` K ^ m h` z 0@ ‰ ·@ M – °@ e ¦ ª @ ` ¶ ¸` D `@ * Ê Ý ò °` þ "
@ j @ « 7
@ s - A 0@ u K
@ ` \ p °` | – @ , 8@ init.c crtstuff.c __JCR_LIST__ deregister_tm_clones __do_global_dtors_aux completed.6945 __do_global_dtors_aux_fini_array_entry frame_dummy __frame_dummy_init_array_entry nbio_test.c nbio_write_test nbio_read_test nbio_stdio.c modes __FRAME_END__ __JCR_END__ __init_array_end _DYNAMIC __init_array_start __GNU_EH_FRAME_HDR _GLOBAL_OFFSET_TABLE_ __libc_csu_fini free@@GLIBC_2.2.5 abort@@GLIBC_2.2.5 _ITM_deregisterTMCloneTable puts@@GLIBC_2.2.5 fread@@GLIBC_2.2.5 _edata fclose@@GLIBC_2.2.5 nbio_resize memset@@GLIBC_2.2.5 __libc_start_main@@GLIBC_2.2.5 memcmp@@GLIBC_2.2.5 __data_start ftell@@GLIBC_2.2.5 __gmon_start__ __dso_handle _IO_stdin_used nbio_get_ptr __libc_csu_init nbio_begin_read malloc@@GLIBC_2.2.5 fseek@@GLIBC_2.2.5 realloc@@GLIBC_2.2.5 __bss_start main nbio_iterate nbio_open fopen@@GLIBC_2.2.5 _Jv_RegisterClasses nbio_free nbio_begin_write fwrite@@GLIBC_2.2.5 __TMC_END__ _ITM_registerTMCloneTable nbio_cancel .symtab .strtab .shstrtab .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt.got .text .fini .rodata .eh_frame_hdr .eh_frame .init_array .fini_array .jcr .dynamic .got.plt .data .bss .comment .debug_aranges .debug_info .debug_abbrev .debug_line .debug_str @ # @ 1 <@ < $ D öÿÿo `@ ` N €@ € € V @ ‹ ^ ÿÿÿo Œ@ Œ k þÿÿo °@ ° z Ð@ Ð „ B è@ è P Ž 8@ 8 ‰ `@ ` ð ” P@ P `@ `  £ $@ $ © 0@ 0 ì ± @ „ ¿ @ 4 É Ø` Ø Õ à` à á è` è æ ð` ð Ð ˜ À` À ï È` È ˆ ø `` ` P þ °` ° 0 ° Á ` ! ' ¢ 5 § 4 A 0 Û" A Ú2 L & # 9 8/ ¢ desmume/src/libretro-common/memmap/memmap.c 000664 001750 001750 00000011166 12755534123 022150 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (memmap.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include
#include
#ifndef PROT_READ
#define PROT_READ 0x1 /* Page can be read */
#endif
#ifndef PROT_WRITE
#define PROT_WRITE 0x2 /* Page can be written. */
#endif
#ifndef PROT_READWRITE
#define PROT_READWRITE 0x3 /* Page can be written to and read from. */
#endif
#ifndef PROT_EXEC
#define PROT_EXEC 0x4 /* Page can be executed. */
#endif
#ifndef PROT_NONE
#define PROT_NONE 0x0 /* Page can not be accessed. */
#endif
#ifndef MAP_FAILED
#define MAP_FAILED ((void *) -1)
#endif
#ifdef _WIN32
void* mmap(void *addr, size_t len, int prot, int flags, int fildes, size_t offset)
{
void *map = (void*)NULL;
HANDLE handle = INVALID_HANDLE_VALUE;
switch (prot)
{
case PROT_READ:
default:
{
handle = CreateFileMapping((HANDLE) _get_osfhandle(fildes), 0, PAGE_READONLY, 0,
len, 0);
if (!handle)
break;
map = (void*)MapViewOfFile(handle, FILE_MAP_READ, 0, 0, len);
CloseHandle(handle);
break;
}
case PROT_WRITE:
{
handle = CreateFileMapping((HANDLE) _get_osfhandle(fildes),0,PAGE_READWRITE,0,
len, 0);
if (!handle)
break;
map = (void*)MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, len);
CloseHandle(handle);
break;
}
case PROT_READWRITE:
{
handle = CreateFileMapping((HANDLE) _get_osfhandle(fildes),0,PAGE_READWRITE,0,
len, 0);
if (!handle)
break;
map = (void*)MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, len);
CloseHandle(handle);
break;
}
}
if (map == (void*)NULL)
return((void*)MAP_FAILED);
return((void*) ((int8_t*)map + offset));
}
int munmap(void *addr, size_t length)
{
if (!UnmapViewOfFile(addr))
return -1;
return 0;
}
int mprotect(void *addr, size_t len, int prot)
{
/* Incomplete, just assumes PAGE_EXECUTE_READWRITE right now
* instead of correctly handling prot */
prot = 0;
if (prot & (PROT_READ | PROT_WRITE | PROT_EXEC))
prot = PAGE_EXECUTE_READWRITE;
return VirtualProtect(addr, len, prot, 0);
}
#elif !defined(HAVE_MMAN)
void* mmap(void *addr, size_t len, int prot, int flags, int fildes, size_t offset)
{
return malloc(len);
}
int munmap(void *addr, size_t len)
{
free(addr);
return 0;
}
int mprotect(void *addr, size_t len, int prot)
{
/* stub - not really needed at this point since this codepath has no dynarecs */
return 0;
}
#endif
#if defined(__MACH__) && defined(__arm__)
#include
#endif
int memsync(void *start, void *end)
{
size_t len = (char*)end - (char*)start;
#if defined(__MACH__) && defined(__arm__)
sys_dcache_flush(start ,len);
sys_icache_invalidate(start, len);
return 0;
#elif defined(__arm__) && !defined(__QNX__)
(void)len;
__clear_cache(start, end);
return 0;
#elif defined(HAVE_MMAN)
return msync(start, len, MS_SYNC | MS_INVALIDATE
#ifdef __QNX__
MS_CACHE_ONLY
#endif
);
#else
(void)len;
return 0;
#endif
}
int memprotect(void *addr, size_t len)
{
return mprotect(addr, len, PROT_READ | PROT_WRITE | PROT_EXEC);
}
desmume/src/utils/AsmJit/core/cpuinfo.h 000664 001750 001750 00000006653 12755534123 021244 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
// [Guard]
#ifndef _ASMJIT_CORE_CPUINFO_H
#define _ASMJIT_CORE_CPUINFO_H
// [Dependencies - AsmJit]
#include "../core/build.h"
// [Api-Begin]
#include "../core/apibegin.h"
namespace AsmJit {
//! @addtogroup AsmJit_Core
//! @{
// ============================================================================
// [AsmJit::CpuInfo]
// ============================================================================
//! @brief Informations about host cpu.
struct CpuInfo
{
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
inline CpuInfo(uint32_t size = sizeof(CpuInfo)) :
_size(size)
{
}
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Get CPU vendor string.
inline const char* getVendorString() const { return _vendorString; }
//! @brief Get CPU brand string.
inline const char* getBrandString() const { return _brandString; }
//! @brief Get CPU vendor ID.
inline uint32_t getVendorId() const { return _vendorId; }
//! @brief Get CPU family ID.
inline uint32_t getFamily() const { return _family; }
//! @brief Get CPU model ID.
inline uint32_t getModel() const { return _model; }
//! @brief Get CPU stepping.
inline uint32_t getStepping() const { return _stepping; }
//! @brief Get CPU count.
inline uint32_t getNumberOfProcessors() const { return _numberOfProcessors; }
//! @brief Get CPU features.
inline uint32_t getFeatures() const { return _features; }
//! @brief Get CPU bugs.
inline uint32_t getBugs() const { return _bugs; }
//! @brief Get whether CPU has feature @a feature.
inline bool hasFeature(uint32_t feature) { return (_features & feature) != 0; }
//! @brief Get whether CPU has bug @a bug.
inline bool hasBug(uint32_t bug) { return (_bugs & bug) != 0; }
// --------------------------------------------------------------------------
// [Statics]
// --------------------------------------------------------------------------
//! @brief Detect number of processors.
ASMJIT_API static uint32_t detectNumberOfProcessors();
//! @brief Get global instance of @ref CpuInfo.
ASMJIT_API static const CpuInfo* getGlobal();
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief Size of CpuInfo structure (in bytes).
uint32_t _size;
//! @brief Cpu short vendor string.
char _vendorString[16];
//! @brief Cpu long vendor string (brand).
char _brandString[64];
//! @brief Cpu vendor id (see @c AsmJit::CpuInfo::VendorId enum).
uint32_t _vendorId;
//! @brief Cpu family ID.
uint32_t _family;
//! @brief Cpu model ID.
uint32_t _model;
//! @brief Cpu stepping.
uint32_t _stepping;
//! @brief Number of processors or cores.
uint32_t _numberOfProcessors;
//! @brief Cpu features bitfield, see @c AsmJit::CpuInfo::Feature enum).
uint32_t _features;
//! @brief Cpu bugs bitfield, see @c AsmJit::CpuInfo::Bug enum).
uint32_t _bugs;
};
//! @}
} // AsmJit namespace
// [Api-End]
#include "../core/apiend.h"
// [Guard]
#endif // _ASMJIT_CORE_CPUINFO_H
desmume/src/libretro-common/formats/bmp/ 000700 001750 001750 00000000000 12756420131 021456 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/include/formats/image.h 000664 001750 001750 00000004567 12755534123 023614 0 ustar 00sergio sergio 000000 000000 /* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2016 - Daniel De Matteis
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see .
*/
#ifndef __RARCH_IMAGE_CONTEXT_H
#define __RARCH_IMAGE_CONTEXT_H
#include
#include
#include
RETRO_BEGIN_DECLS
enum image_process_code
{
IMAGE_PROCESS_ERROR = -2,
IMAGE_PROCESS_ERROR_END = -1,
IMAGE_PROCESS_NEXT = 0,
IMAGE_PROCESS_END = 1
};
struct texture_image
{
unsigned width;
unsigned height;
uint32_t *pixels;
};
enum image_type_enum
{
IMAGE_TYPE_NONE = 0,
IMAGE_TYPE_PNG,
IMAGE_TYPE_JPEG,
IMAGE_TYPE_BMP,
IMAGE_TYPE_TGA
};
bool image_texture_set_color_shifts(unsigned *r_shift, unsigned *g_shift,
unsigned *b_shift, unsigned *a_shift);
bool image_texture_color_convert(unsigned r_shift,
unsigned g_shift, unsigned b_shift, unsigned a_shift,
struct texture_image *out_img);
bool image_texture_load(struct texture_image *img, const char *path);
void image_texture_free(struct texture_image *img);
void image_texture_set_rgba(void);
void image_texture_unset_rgba(void);
/* Image transfer */
void image_transfer_free(void *data, enum image_type_enum type);
void *image_transfer_new(enum image_type_enum type);
bool image_transfer_start(void *data, enum image_type_enum type);
void image_transfer_set_buffer_ptr(
void *data,
enum image_type_enum type,
void *ptr);
int image_transfer_process(
void *data,
enum image_type_enum type,
uint32_t **buf, size_t size,
unsigned *width, unsigned *height);
bool image_transfer_iterate(void *data, enum image_type_enum type);
bool image_transfer_is_valid(void *data, enum image_type_enum type);
RETRO_END_DECLS
#endif
desmume/src/libretro-common/include/libco.h 000664 001750 001750 00000004373 12755534123 022142 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (libco.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef LIBCO_H
#define LIBCO_H
#include
#ifdef LIBCO_C
#ifdef LIBCO_MP
#define thread_local __thread
#else
#define thread_local
#endif
#endif
RETRO_BEGIN_DECLS
typedef void* cothread_t;
/**
* co_active:
*
* Gets the currently active context.
*
* Returns: active context.
**/
cothread_t co_active(void);
/**
* co_create:
* @int : stack size
* @funcptr : thread entry function callback
*
* Create a co_thread.
*
* Returns: cothread if successful, otherwise NULL.
*/
cothread_t co_create(unsigned int, void (*)(void));
/**
* co_delete:
* @cothread : cothread object
*
* Frees a co_thread.
*/
void co_delete(cothread_t cothread);
/**
* co_switch:
* @cothread : cothread object to switch to
*
* Do a context switch to @cothread.
*/
void co_switch(cothread_t cothread);
RETRO_END_DECLS
/* ifndef LIBCO_H */
#endif
desmume/src/readwrite.h 000664 001750 001750 00000004466 12755534123 016310 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2008-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#ifndef _READWRITE_H_
#define _READWRITE_H_
#include
#include
#include
#include
#include "types.h"
class EMUFILE;
//well. just for the sake of consistency
int write8le(u8 b, EMUFILE *fp);
int write16le(u16 b, EMUFILE* os);
int write32le(u32 b, EMUFILE* os);
int write64le(u64 b, EMUFILE* os);
int read8le(u8 *Bufo, EMUFILE*is);
int read16le(u16 *Bufo, EMUFILE*is);
int read32le(u32 *Bufo, EMUFILE*is);
int read64le(u64 *Bufo, EMUFILE*is);
static INLINE int write8le(u8* b, EMUFILE *fp)
{
return write8le(*b,fp);
}
static INLINE int write_double_le(double b, EMUFILE*is)
{
u64 temp = double_to_u64(b);
int ret = write64le(temp,is);
return ret;
}
static INLINE int read16le(s16 *Bufo, EMUFILE*is)
{
return read16le((u16*)Bufo,is);
}
static INLINE int read32le(s32 *Bufo, EMUFILE*is)
{
return read32le((u32*)Bufo,is);
}
static INLINE int read_double_le(double *Bufo, EMUFILE*is)
{
u64 temp;
int ret = read64le(&temp,is);
*Bufo = u64_to_double(temp);
return ret;
}
int read16le(u16 *Bufo, std::istream *is);
template
static INLINE int readle(T *Bufo, EMUFILE*is)
{
retro_assert(sizeof(T)==1||sizeof(T)==2||sizeof(T)==4||sizeof(T)==8);
switch(sizeof(T))
{
case 1:
return read8le((u8*)Bufo,is);
case 2:
return read16le((u16*)Bufo,is);
case 4:
return read32le((u32*)Bufo,is);
case 8:
return read64le((u64*)Bufo,is);
default:
break;
}
return 0;
}
int readbool(bool *b, EMUFILE* is);
void writebool(bool b, EMUFILE* os);
int readbuffer(std::vector &vec, EMUFILE* is);
int writebuffer(std::vector& vec, EMUFILE* os);
#endif
desmume/gpu-moderender.diff 000664 001750 001750 00000010071 12755534123 017116 0 ustar 00sergio sergio 000000 000000 diff --git a/desmume/src/GPU.cpp b/desmume/src/GPU.cpp
index 993f452..fb36fff 100644
--- a/desmume/src/GPU.cpp
+++ b/desmume/src/GPU.cpp
@@ -1307,23 +1307,13 @@ FORCEINLINE void apply_rot_fun(GPU *gpu, const BGxPARMS ¶m, const u16 LG, co
rot_scale_op(gpu, param, LG, wh, ht, map, tile, pal);
}
-
-template
-FORCEINLINE void rotBG2(GPU *gpu, const BGxPARMS ¶m, const u16 LG)
-{
- const size_t num = gpu->currBgNum;
- const u16 *pal = (u16 *)(MMU.ARM9_VMEM + gpu->core * ADDRESS_STEP_1KB);
-// printf("rot mode\n");
- apply_rot_fun< rot_tiled_8bit_entry >(gpu, param, LG, gpu->BG_map_ram[num], gpu->BG_tile_ram[num], pal);
-}
-
template
FORCEINLINE void extRotBG2(GPU *gpu, const BGxPARMS ¶m, const u16 LG)
{
const size_t num = gpu->currBgNum;
struct _DISPCNT * dispCnt = &(gpu->dispx_st)->dispx_DISPCNT.bits;
- u16 *pal = NULL;
+ u16 *pal = (u16 *)(MMU.ARM9_VMEM + gpu->core * ADDRESS_STEP_1KB);
switch(gpu->BGTypes[num])
{
@@ -1339,10 +1329,11 @@ FORCEINLINE void extRotBG2(GPU *gpu, const BGxPARMS ¶m, const u16 LG)
case BGType_AffineExt_256x1:
// 256 colors
- pal = (u16 *)(MMU.ARM9_VMEM + gpu->core * ADDRESS_STEP_1KB);
apply_rot_fun< rot_256_map >(gpu, param, LG, gpu->BG_bmp_ram[num], 0, pal);
break;
-
+ case BGType_Affine:
+ apply_rot_fun< rot_tiled_8bit_entry >(gpu, param, LG, gpu->BG_map_ram[num], gpu->BG_tile_ram[num], pal);
+ break;
case BGType_AffineExt_Direct:
// direct colors / BMP
apply_rot_fun< rot_BMP_map >(gpu, param, LG, gpu->BG_bmp_ram[num], 0, NULL);
@@ -1350,7 +1341,6 @@ FORCEINLINE void extRotBG2(GPU *gpu, const BGxPARMS ¶m, const u16 LG)
case BGType_Large8bpp:
// large screen 256 colors
- pal = (u16 *)(MMU.ARM9_VMEM + gpu->core * ADDRESS_STEP_1KB);
apply_rot_fun< rot_256_map >(gpu, param, LG, gpu->BG_bmp_large_ram[num], 0, pal);
break;
@@ -1359,39 +1349,8 @@ FORCEINLINE void extRotBG2(GPU *gpu, const BGxPARMS ¶m, const u16 LG)
}
}
-/*****************************************************************************/
-// BACKGROUND RENDERING -HELPER FUNCTIONS-
-/*****************************************************************************/
-
-#if 0
-static void lineNull(GPU *gpu)
-{
-}
-#endif
-
template void lineText(GPU *gpu)
{
- const u16 vofs = gpu->getVOFS(gpu->currBgNum);
- const u16 hofs = gpu->getHOFS(gpu->currBgNum);
- renderline_textBG(gpu, hofs, gpu->currLine + vofs, 256);
-}
-
-template void lineRot(GPU *gpu)
-{
- BGxPARMS ¶ms = (gpu->currBgNum == 2) ? (gpu->dispx_st)->dispx_BG2PARMS : (gpu->dispx_st)->dispx_BG3PARMS;
-
- rotBG2(gpu, params, 256);
- params.BGxX += params.BGxPB;
- params.BGxY += params.BGxPD;
-}
-
-template void lineExtRot(GPU *gpu)
-{
- BGxPARMS ¶ms = (gpu->currBgNum == 2) ? (gpu->dispx_st)->dispx_BG2PARMS : (gpu->dispx_st)->dispx_BG3PARMS;
-
- extRotBG2(gpu, params, 256);
- params.BGxX += params.BGxPB;
- params.BGxY += params.BGxPD;
}
/*****************************************************************************/
@@ -2954,10 +2913,20 @@ template void GPU::modeRender(const size_t layer)
{
switch(GPU_mode2type[dispCnt().BG_Mode][layer])
{
- case BGType_Text: lineText(this); break;
- case BGType_Affine: lineRot(this); break;
- case BGType_AffineExt: lineExtRot(this); break;
- case BGType_Large8bpp: lineExtRot(this); break;
+ case BGType_Text:
+ renderline_textBG(this, getHOFS(layer), currLine + getVOFS(layer), 256);
+ break;
+ case BGType_Affine:
+ case BGType_AffineExt:
+ case BGType_Large8bpp:
+ {
+ BGxPARMS ¶ms = (layer == 2) ? (dispx_st)->dispx_BG2PARMS : (dispx_st)->dispx_BG3PARMS;
+
+ extRotBG2(this, params, 256);
+ params.BGxX += params.BGxPB;
+ params.BGxY += params.BGxPD;
+ }
+ break;
case BGType_Invalid:
PROGINFO("Attempting to render an invalid BG type\n");
break;
desmume/src/addons/slot2_guitarGrip.cpp 000664 001750 001750 00000003043 12755534123 021353 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2009 CrazyMax
Copyright (C) 2009-2013 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#include "../slot2.h"
static u8 guitarKeyStatus;
class Slot2_GuitarGrip : public ISlot2Interface
{
private:
public:
virtual Slot2Info const* info()
{
static Slot2InfoSimple info("Guitar Grip", "Guitar Grip for Guitar Hero games", 0x04);
return &info;
}
virtual void connect()
{
guitarKeyStatus = 0;
}
virtual u8 readByte(u8 PROCNUM, u32 addr)
{
if (addr == 0x0A000000) return (~guitarKeyStatus);
return (addr & 1)?0xF9:0xFF;
}
virtual u16 readWord(u8 PROCNUM, u32 addr) { return 0xF9FF; }
virtual u32 readLong(u8 PROCNUM, u32 addr) { return 0xF9FFF9FF; }
};
ISlot2Interface* construct_Slot2_GuitarGrip() { return new Slot2_GuitarGrip(); }
void guitarGrip_setKey(bool green, bool red, bool yellow, bool blue)
{
guitarKeyStatus = 0 | (green << 6) | (red << 5) | (yellow << 4) | (blue << 3);
}
desmume/src/libretro-common/formats/tga/ 000700 001750 001750 00000000000 12756420131 021453 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/vulkan/ 000700 001750 001750 00000000000 12756420131 020525 5 ustar 00sergio sergio 000000 000000 desmume/src/utils/emufat.cpp 000664 001750 001750 00000173703 12755534123 017277 0 ustar 00sergio sergio 000000 000000 /*
Copyright 2009-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
//based on Arduino SdFat Library ( http://code.google.com/p/sdfatlib/ )
//Copyright (C) 2009 by William Greiman
//based on mkdosfs - utility to create FAT/MS-DOS filesystems
//Copyright (C) 1991 Linus Torvalds
//Copyright (C) 1992-1993 Remy Card
//Copyright (C) 1993-1994 David Hudson
//Copyright (C) 1998 H. Peter Anvin
//Copyright (C) 1998-2005 Roman Hodek
#include "emufat.h"
#include
#include
#include
#include
#include "../emufile.h"
#define LE16(x) (x)
#define LE32(x) (x)
#define MAX_CLUST_12 ((1 << 12) - 16)
#define MAX_CLUST_16 ((1 << 16) - 16)
#define MIN_CLUST_32 65529
/* M$ says the high 4 bits of a FAT32 FAT entry are reserved and don't belong
* to the cluster number. So the max. cluster# is based on 2^28 */
#define MAX_CLUST_32 ((1 << 28) - 16)
#define FAT12_THRESHOLD 4085
#define MSDOS_EXT_SIGN 0x29 /* extended boot sector signature */
#define MSDOS_FAT12_SIGN "FAT12 " /* FAT12 filesystem signature */
#define MSDOS_FAT16_SIGN "FAT16 " /* FAT16 filesystem signature */
#define MSDOS_FAT32_SIGN "FAT32 " /* FAT32 filesystem signature */
static const int sector_size = 512;
#define BLOCK_SIZE 512
#define HARD_SECTOR_SIZE 512
#define SECTORS_PER_BLOCK ( BLOCK_SIZE / HARD_SECTOR_SIZE )
#define FAT_EOF (0x0ffffff8)
#define BOOT_SIGN 0xAA55 /* Boot sector magic number */
struct __PACKED fat32_fsinfo {
u32 reserved1; /* Nothing as far as I can tell */
u32 signature; /* 0x61417272L */
u32 free_clusters; /* Free cluster count. -1 if unknown */
u32 next_cluster; /* Most recently allocated cluster.
* Unused under Linux. */
u32 reserved2[4];
};
//see mkdosfs for the disassembly
static const u8 mkdosfs_bootcode_fat32[420] =
{
0x0E, 0x1F, 0xBE, 0x77, 0x7C, 0xAC, 0x22, 0xC0, 0x74, 0x0B, 0x56, 0xB4, 0x0E, 0xBB, 0x07, 0x00,
0xCD, 0x10, 0x5E, 0xEB, 0xF0, 0x32, 0xE4, 0xCD, 0x16, 0xCD, 0x19, 0xEB, 0xFE, 0x54, 0x68, 0x69,
0x73, 0x20, 0x69, 0x73, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x74, 0x61,
0x62, 0x6C, 0x65, 0x20, 0x64, 0x69, 0x73, 0x6B, 0x2E, 0x20, 0x20, 0x50, 0x6C, 0x65, 0x61, 0x73,
0x65, 0x20, 0x69, 0x6E, 0x73, 0x65, 0x72, 0x74, 0x20, 0x61, 0x20, 0x62, 0x6F, 0x6F, 0x74, 0x61,
0x62, 0x6C, 0x65, 0x20, 0x66, 0x6C, 0x6F, 0x70, 0x70, 0x79, 0x20, 0x61, 0x6E, 0x64, 0x0D, 0x0A,
0x70, 0x72, 0x65, 0x73, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6B, 0x65, 0x79, 0x20, 0x74, 0x6F,
0x20, 0x74, 0x72, 0x79, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6E, 0x20, 0x2E, 0x2E, 0x2E, 0x20, 0x0D,
0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
EmuFat::EmuFat(const char* fname, bool readonly)
: m_readonly(readonly)
, m_owns(true)
{
m_pFile = new EMUFILE_FILE(fname,readonly?"rb":"rb+");
}
EmuFat::EmuFat()
: m_readonly(false)
, m_owns(true)
{
m_pFile = new EMUFILE_MEMORY();
}
EmuFat::EmuFat(EMUFILE* fileNotToDelete)
: m_pFile(fileNotToDelete)
, m_owns(false)
, m_readonly(false)
{
}
EmuFat::~EmuFat()
{
cacheFlush();
if(m_owns)
delete m_pFile;
}
u8 EmuFat::cacheRawBlock(u32 blockNumber, u8 action)
{
if (cache_.cacheBlockNumber_ != blockNumber) {
if (!cacheFlush()) return false;
if (!readBlock(blockNumber, cache_.cacheBuffer_.data)) return false;
cache_.cacheBlockNumber_ = blockNumber;
}
cache_.cacheDirty_ |= action;
return true;
}
u8 EmuFat::cacheZeroBlock(u32 blockNumber)
{
if (!cacheFlush()) return false;
// loop take less flash than memset(cacheBuffer_.data, 0, 512);
for (u16 i = 0; i < 512; i++) {
cache_.cacheBuffer_.data[i] = 0;
}
cache_.cacheBlockNumber_ = blockNumber;
cacheSetDirty();
return true;
}
void EmuFat::cacheReset()
{
reconstruct(&cache_);
}
u8 EmuFat::cacheFlush() {
if (cache_.cacheDirty_) {
if (!writeBlock(cache_.cacheBlockNumber_, cache_.cacheBuffer_.data)) {
return false;
}
// mirror FAT tables
if (cache_.cacheMirrorBlock_) {
if (!writeBlock(cache_.cacheMirrorBlock_, cache_.cacheBuffer_.data)) {
return false;
}
cache_.cacheMirrorBlock_ = 0;
}
cache_.cacheDirty_ = 0;
}
return true;
}
u8 EmuFat::readBlock(u32 block, u8* dst)
{
m_pFile->fseek(block*512,SEEK_SET);
m_pFile->fread(dst,512);
if(m_pFile->fail())
{
m_pFile->unfail();
return 0;
}
return 1;
}
u8 EmuFat::writeBlock(u32 blockNumber, const u8* src)
{
m_pFile->fseek(blockNumber*512,SEEK_SET);
m_pFile->fwrite(src,512);
if(m_pFile->fail())
{
m_pFile->unfail();
return 0;
}
return 1;
}
u8 EmuFat::readData(u32 block, u16 offset, u16 count, u8* dst)
{
m_pFile->fseek(block*512+offset,SEEK_SET);
m_pFile->fread(dst,count);
if(m_pFile->fail())
{
m_pFile->unfail();
return 0;
}
return 1;
}
void EmuFat::truncate(u32 size)
{
m_pFile->truncate(size);
}
//-------------------------------------------------------------------------------------
inline int cdiv (int a, int b)
{
return (a + b - 1) / b;
}
bool calculateClusterSize(TFat32BootSector* bsp, u32 avail_sectors, u32& cluster_count, u32& fat_length, int size_fat_by_user, int &size_fat)
{
TFat32BootSector &bs = *bsp;
const u32 fatdata = avail_sectors;
int maxclustsize = bsp->sectorsPerCluster;
u32 fatlength12, fatlength16, fatlength32;
u32 maxclust12, maxclust16, maxclust32;
u32 clust12, clust16, clust32;
do {
printf( "Trying with %d sectors/cluster:\n", bs.sectorsPerCluster );
/* The factor 2 below avoids cut-off errors for nr_fats == 1.
* The "nr_fats*3" is for the reserved first two FAT entries */
clust12 = 2*((u64) fatdata *sector_size + bs.fatCount*3) /
(2*(int) bs.sectorsPerCluster * sector_size + bs.fatCount*3);
fatlength12 = cdiv (((clust12+2) * 3 + 1) >> 1, sector_size);
/* Need to recalculate number of clusters, since the unused parts of the
* FATS and data area together could make up space for an additional,
* not really present cluster. */
clust12 = (fatdata - bs.fatCount*fatlength12)/bs.sectorsPerCluster;
maxclust12 = (fatlength12 * 2 * sector_size) / 3;
if (maxclust12 > MAX_CLUST_12)
maxclust12 = MAX_CLUST_12;
printf( "FAT12: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n",
clust12, fatlength12, maxclust12, MAX_CLUST_12 );
if (clust12 > maxclust12-2) {
clust12 = 0;
printf( "FAT12: too much clusters\n" );
}
clust16 = ((u64) fatdata *sector_size + bs.fatCount*4) /
((int) bs.sectorsPerCluster * sector_size + bs.fatCount*2);
fatlength16 = cdiv ((clust16+2) * 2, sector_size);
/* Need to recalculate number of clusters, since the unused parts of the
* FATS and data area together could make up space for an additional,
* not really present cluster. */
clust16 = (fatdata - bs.fatCount*fatlength16)/bs.sectorsPerCluster;
maxclust16 = (fatlength16 * sector_size) / 2;
if (maxclust16 > MAX_CLUST_16)
maxclust16 = MAX_CLUST_16;
printf( "FAT16: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n",
clust16, fatlength16, maxclust16, MAX_CLUST_16 );
if (clust16 > maxclust16-2) {
printf( "FAT16: too much clusters\n" );
clust16 = 0;
}
/* The < 4078 avoids that the filesystem will be misdetected as having a
* 12 bit FAT. */
if (clust16 < FAT12_THRESHOLD && !(size_fat_by_user && size_fat == 16)) {
printf( clust16 < FAT12_THRESHOLD ?
"FAT16: would be misdetected as FAT12\n" :
"FAT16: too much clusters\n" );
clust16 = 0;
}
clust32 = ((u64) fatdata *sector_size + bs.fatCount*8) /
((int) bs.sectorsPerCluster * sector_size + bs.fatCount*4);
fatlength32 = cdiv ((clust32+2) * 4, sector_size);
/* Need to recalculate number of clusters, since the unused parts of the
* FATS and data area together could make up space for an additional,
* not really present cluster. */
clust32 = (fatdata - bs.fatCount*fatlength32)/bs.sectorsPerCluster;
maxclust32 = (fatlength32 * sector_size) / 4;
if (maxclust32 > MAX_CLUST_32)
maxclust32 = MAX_CLUST_32;
if (clust32 && clust32 < MIN_CLUST_32 && !(size_fat_by_user && size_fat == 32)) {
clust32 = 0;
printf( "FAT32: not enough clusters (%d)\n", MIN_CLUST_32);
}
printf( "FAT32: #clu=%u, fatlen=%u, maxclu=%u, limit=%u\n",
clust32, fatlength32, maxclust32, MAX_CLUST_32 );
if (clust32 > maxclust32) {
clust32 = 0;
printf( "FAT32: too much clusters\n" );
}
if ((clust12 && (size_fat == 0 || size_fat == 12)) ||
(clust16 && (size_fat == 0 || size_fat == 16)) ||
(clust32 && size_fat == 32))
break;
bs.sectorsPerCluster <<= 1;
} while (bs.sectorsPerCluster && bs.sectorsPerCluster <= maxclustsize);
/* Use the optimal FAT size if not specified;
* FAT32 is (not yet) choosen automatically */
if (!size_fat) {
size_fat = (clust16 > clust12) ? 16 : 12;
printf( "Choosing %d bits for FAT\n", size_fat );
}
switch (size_fat) {
case 12:
cluster_count = clust12;
fat_length = fatlength12;
bs.sectorsPerFat16 = LE16(fatlength12);
break;
case 16:
if (clust16 < FAT12_THRESHOLD) {
if (size_fat_by_user) {
printf("WARNING: Not enough clusters for a "
"16 bit FAT! The filesystem will be\n"
"misinterpreted as having a 12 bit FAT without "
"mount option \"fat=16\".\n" );
return false;
}
else {
printf("This filesystem has an unfortunate size. "
"A 12 bit FAT cannot provide\n"
"enough clusters, but a 16 bit FAT takes up a little "
"bit more space so that\n"
"the total number of clusters becomes less than the "
"threshold value for\n"
"distinction between 12 and 16 bit FATs.\n" );
return false;
}
}
cluster_count = clust16;
fat_length = fatlength16;
bs.sectorsPerFat16 = LE16(fatlength16);
break;
case 32:
if (clust32 < MIN_CLUST_32)
printf("WARNING: Not enough clusters for a 32 bit FAT!\n");
cluster_count = clust32;
fat_length = fatlength32;
bs.sectorsPerFat16 = LE16(0);
bs.fat32.sectorsPerFat32 = LE32(fatlength32);
break;
}
return true;
}
static void mark_FAT_cluster (int size_fat, u8* fat, int cluster, unsigned int value)
{
switch( size_fat ) {
case 12:
value &= 0x0fff;
if (((cluster * 3) & 0x1) == 0)
{
fat[3 * cluster / 2] = (unsigned char) (value & 0x00ff);
fat[(3 * cluster / 2) + 1] = (unsigned char) ((fat[(3 * cluster / 2) + 1] & 0x00f0)
| ((value & 0x0f00) >> 8));
}
else
{
fat[3 * cluster / 2] = (unsigned char) ((fat[3 * cluster / 2] & 0x000f) | ((value & 0x000f) << 4));
fat[(3 * cluster / 2) + 1] = (unsigned char) ((value & 0x0ff0) >> 4);
}
break;
case 16:
value &= 0xffff;
fat[2 * cluster] = (unsigned char) (value & 0x00ff);
fat[(2 * cluster) + 1] = (unsigned char) (value >> 8);
break;
case 32:
value &= 0xfffffff;
fat[4 * cluster] = (unsigned char) (value & 0x000000ff);
fat[(4 * cluster) + 1] = (unsigned char) ((value & 0x0000ff00) >> 8);
fat[(4 * cluster) + 2] = (unsigned char) ((value & 0x00ff0000) >> 16);
fat[(4 * cluster) + 3] = (unsigned char) ((value & 0xff000000) >> 24);
break;
}
}
//use 36M as minimum fat32 size (or else mkdosfs complains)
//this function assumes fat32. it could be redone to be intelligent by making another pass through mkdosfs and analyzing it again
//but we onnly targeted fat32 our first time through
bool EmuFatVolume::formatNew(u32 sectors)
{
u32 volumeStartBlock = 0;
TFat32BootSector bsrec;
memset(&bsrec,0,sizeof(TFat32BootSector));
TFat32BootSector *bs = &bsrec;
//perform same analysis (we guess) as mkdosfs
//"fake values"
bs->sectorsPerTrack = 32;
bs->headCount = 64;
//def_hd_params:
bs->mediaType = 0xF8;
bs->rootDirEntryCount = LE16(512); //Default to 512 entries - N.B. this is overwritten later
static const u32 BLOCK_SIZE_BITS = 9;
const u32 sz_mb = (sectors+(1<<(20-BLOCK_SIZE_BITS))-1) >> (20-BLOCK_SIZE_BITS);
bs->sectorsPerCluster =
sz_mb > 16*1024 ? 32 :
sz_mb > 8*1024 ? 16 :
sz_mb > 260 ? 8 :
1;
//(fat16 and fat12 would start at 4 sectors per cluster)
memcpy (bs->oemName, "mkdosfs", 8);
bs->rootDirEntryCount = 0; //Under FAT32, the root dir is in a cluster chain, and this is signalled by bs.dir_entries being 0
bs->fat32.vi.volume_id = 0; //not generating a volume id.. just use 0 for determinism's sake
memcpy(bs->fat32.vi.volume_label," ",11);
bs->jmpToBootCode[0] = 0xEB;
bs->jmpToBootCode[1] = 0x58; //this value is only for fat32 //Patch in the correct offset to the boot code
bs->jmpToBootCode[2] = 0x90;
memcpy(bs->fat32.boot_code,mkdosfs_bootcode_fat32,420);
bs->boot_sign[0] = 0x55;
bs->boot_sign[1] = 0xAA;
bs->reservedSectorCount = LE16(32);
bs->fatCount = 2;
bs->hiddenSectors = LE32(0);
u32 fatdata = sectors - cdiv (bs->rootDirEntryCount * 32, 512) - bs->reservedSectorCount;
u32 cluster_count;
u32 fat_length;
int size_fat = 32;
if(!calculateClusterSize(bs, fatdata, cluster_count, fat_length, 1, size_fat))
return false;
//TODO - this function whacks values we set earlier. gross. either mkdosfs is sloppy or i dont understand it.
//anyway, whack that dup code
switch(size_fat)
{
case 12: memcpy(bs->oldfat.vi.fs_type, MSDOS_FAT12_SIGN, 8); break;
case 16: memcpy(bs->oldfat.vi.fs_type, MSDOS_FAT16_SIGN, 8); break;
case 32: memcpy(bs->fat32.vi.fs_type, MSDOS_FAT32_SIGN, 8); break;
}
bs->bytesPerSector = 512;
//set up additional FAT32 fields
bs->fat32.fat32Flags = LE16(0);
bs->fat32.fat32Version = LE16(0);
bs->fat32.fat32RootCluster = LE32(2);
bs->fat32.fat32FSInfo = LE16(1);
u32 backup_boot = (bs->reservedSectorCount>= 7) ? 6 : (bs->reservedSectorCount >= 2) ? bs->reservedSectorCount-1 : 0;
printf( "Using sector %d as backup boot sector (0 = none)\n",backup_boot );
bs->fat32.fat32BackBootBlock = LE16(backup_boot);
memset(bs->fat32.fat32Reserved,0,sizeof(bs->fat32.fat32Reserved));
if(sectors>= 65536) {
bs->totalSectors16 = LE16(0);
bs->totalSectors32 = LE32(sectors);
} else {
bs->totalSectors16 = LE16(sectors);
bs->totalSectors32 = LE32(0);
}
if (!cluster_count)
{
//if (sectors_per_cluster) /* If yes, die if we'd spec'd sectors per cluster */
// die ("Too many clusters for file system - try more sectors per cluster");
//else
printf("Attempting to create a too large file system");
return false;
}
u32 start_data_sector = (bs->reservedSectorCount + bs->fatCount * fat_length) * (sector_size/512);
u32 start_data_block = (start_data_sector + SECTORS_PER_BLOCK - 1) / SECTORS_PER_BLOCK;
if (sectors < start_data_block + 32) /* Arbitrary undersize file system! */
{
printf("Too few blocks for viable file system");
return false;
}
bs->fat32.vi.ext_boot_sign = MSDOS_EXT_SIGN;
//Make the file allocation tables!
u8* fat = new u8[fat_length * sector_size];
memset( fat, 0, fat_length * sector_size );
mark_FAT_cluster (size_fat, fat, 0, 0xffffffff); /* Initial fat entries */
mark_FAT_cluster (size_fat, fat, 1, 0xffffffff);
fat[0] = bs->mediaType; /* Put media type in first byte! */
if (size_fat == 32) {
/* Mark cluster 2 as EOF (used for root dir) */
mark_FAT_cluster (size_fat, fat, 2, FAT_EOF);
}
u32 size_root_dir = (size_fat == 32) ? bs->sectorsPerCluster*sector_size :
bs->rootDirEntryCount * sizeof (TDirectoryEntry);
//u8* root_dir = new u8[size_root_dir];
//memset(root_dir, 0, size_root_dir);
u32 size_root_dir_in_sectors = size_root_dir/512;
u8* info_sector = NULL;
if (size_fat == 32) {
/* For FAT32, create an info sector */
fat32_fsinfo *info;
info_sector = new u8[sector_size];
memset(info_sector, 0, sector_size);
/* fsinfo structure is at offset 0x1e0 in info sector by observation */
info = (fat32_fsinfo *)(info_sector + 0x1e0);
/* Info sector magic */
info_sector[0] = 'R';
info_sector[1] = 'R';
info_sector[2] = 'a';
info_sector[3] = 'A';
/* Magic for fsinfo structure */
info->signature = LE32(0x61417272);
/* We've allocated cluster 2 for the root dir. */
info->free_clusters = LE32(cluster_count - 1);
info->next_cluster = LE32(2);
/* Info sector also must have boot sign */
*(u16 *)(info_sector + 0x1fe) = LE16(BOOT_SIGN);
}
//-------------
//write_tables()
u8* blank_sector = new u8[512];
memset(blank_sector,0,512);
dev_->cacheReset();
dev_->truncate(0);
dev_->truncate(sectors*512);
/* clear all reserved sectors */
for(int i=0;ireservedSectorCount;i++)
dev_->writeBlock(0,blank_sector);
/* seek back to sector 0 and write the boot sector */
dev_->writeBlock(0,(const u8*)bs);
/* on FAT32, write the info sector and backup boot sector */
if (size_fat == 32)
{
dev_->writeBlock(bs->fat32.fat32FSInfo,info_sector);
if(bs->fat32.fat32BackBootBlock)
dev_->writeBlock(bs->fat32.fat32BackBootBlock,(const u8*)bs);
}
/* seek to start of FATS and write them all */
int ctr=bs->reservedSectorCount;
for (int i=0;ifatCount;i++)
for(int j=0;jwriteBlock(ctr,fat+j*sector_size);
/* Write the root directory directly after the last FAT. This is the root
* dir area on FAT12/16, and the first cluster on FAT32. */
for(int i=0;iwriteBlock(ctr,blank_sector);
delete[] blank_sector;
delete[] info_sector;
delete[] fat;
return init(dev_,0);
//return true;
}
//well, there are a lot of ways to format a disk. this is just a simple one.
//it would be nice if someone who understood fat better could modify the root
//directory setup to use reasonable code instead of magic arrays
bool EmuFatVolume::format(u32 sectors)
{
//u32 volumeStartBlock = 0;
//dev_->truncate(0);
//dev_->truncate(sectors*512);
//if (!dev_->cacheRawBlock(volumeStartBlock, EmuFat::CACHE_FOR_WRITE)) return false;
//memset(&dev_->cache_.cacheBuffer_,0,sizeof(dev_->cache_.cacheBuffer_));
//TFat32BootSector* bs = &dev_->cache_.cacheBuffer_.fbs;
//TBiosParmBlock* bpb = &bs->bpb;
//bs->jmpToBootCode[0] = 0xEB;
//bs->jmpToBootCode[1] = 0x3C;
//bs->jmpToBootCode[2] = 0x90;
//memcpy(bs->oemName,"mkdosfs",8);
//bs->driveNumber = 0;
//bs->reserved1 = 0;
//bs->bootSignature = 0x29;
//bs->volumeSerialNumber = 0;
//memcpy(bs->volumeLabel," ",11);
//memcpy(bs->fileSystemType,"FAT16 ",8);
//memcpy(bs->bootCode,mkdosfs_bootcode,420);
//bs->bootSectorSig0 = 0x55;
//bs->bootSectorSig1 = 0xAA;
//bpb->bytesPerSector = 512;
//bpb->sectorsPerCluster = 4;
//bpb->reservedSectorCount = 1;
//bpb->fatCount = 2;
//bpb->rootDirEntryCount = 512;
//bpb->totalSectors16 = 0;
//bpb->mediaType = 0xF8;
//bpb->sectorsPerFat16 = 32;
//bpb->sectorsPerTrack = 32;
//bpb->headCount = 64;
//bpb->hiddenSectors = 0;
//bpb->totalSectors32 = sectors;
//bpb->fat32Flags = 0xbe0d;
//bpb->fat32Version = 0x20Fd;
//bpb->fat32RootCluster = 0x20202020;
//bpb->fat32FSInfo = 0x2020;
//bpb->fat32BackBootBlock = 0x2020;
//if(!dev_->cacheFlush())
// return false;
//if (!dev_->cacheRawBlock(1, EmuFat::CACHE_FOR_WRITE)) return false;
//static const u8 rootEntry[8] =
//{
// 0xF8, 0xFF, 0xFF, 0xFF,
//} ;
//memcpy(dev_->cache_.cacheBuffer_.data,rootEntry,4);
//if(!dev_->cacheFlush())
// return false;
//if (!dev_->cacheRawBlock(33, EmuFat::CACHE_FOR_WRITE)) return false;
//memcpy(dev_->cache_.cacheBuffer_.data,rootEntry,4);
//if(!dev_->cacheFlush())
// return false;
//return init(dev_,0);
return false;
}
bool EmuFatVolume::init(EmuFat* dev, u8 part) {
u32 volumeStartBlock = 0;
dev_ = dev;
// if part == 0 assume super floppy with FAT boot sector in block zero
// if part > 0 assume mbr volume with partition table
if (part) {
if (part > 4) return false;
if (!dev->cacheRawBlock(volumeStartBlock, EmuFat::CACHE_FOR_READ)) return false;
TPartitionRecord* p = &dev->cache_.cacheBuffer_.mbr.part[part-1];
if ((p->boot & 0X7F) !=0 ||
p->totalSectors < 100 ||
p->firstSector == 0) {
// not a valid partition
return false;
}
volumeStartBlock = p->firstSector;
}
if (!dev->cacheRawBlock(volumeStartBlock, EmuFat::CACHE_FOR_READ)) return false;
TFat32BootSector* bs = &dev->cache_.cacheBuffer_.fbs;
if (bs->bytesPerSector != 512 ||
bs->fatCount == 0 ||
bs->reservedSectorCount == 0 ||
bs->sectorsPerCluster == 0) {
// not valid FAT volume
return false;
}
fatCount_ = bs->fatCount;
blocksPerCluster_ = bs->sectorsPerCluster;
// determine shift that is same as multiply by blocksPerCluster_
clusterSizeShift_ = 0;
while (blocksPerCluster_ != (1 << clusterSizeShift_)) {
// error if not power of 2
if (clusterSizeShift_++ > 7) return false;
}
blocksPerFat_ = bs->sectorsPerFat16 ?
bs->sectorsPerFat16 : bs->fat32.sectorsPerFat32;
fatStartBlock_ = volumeStartBlock + bs->reservedSectorCount;
// count for FAT16 zero for FAT32
rootDirEntryCount_ = bs->rootDirEntryCount;
// directory start for FAT16 dataStart for FAT32
rootDirStart_ = fatStartBlock_ + bs->fatCount * blocksPerFat_;
// data start for FAT16 and FAT32
dataStartBlock_ = rootDirStart_ + ((32 * bs->rootDirEntryCount + 511)/512);
// total blocks for FAT16 or FAT32
u32 totalBlocks = bs->totalSectors16 ?
bs->totalSectors16 : bs->totalSectors32;
// total data blocks
clusterCount_ = totalBlocks - (dataStartBlock_ - volumeStartBlock);
// divide by cluster size to get cluster count
clusterCount_ >>= clusterSizeShift_;
// FAT type is determined by cluster count
if (clusterCount_ < 4085) {
fatType_ = 12;
} else if (clusterCount_ < 65525) {
fatType_ = 16;
} else {
rootDirStart_ = bs->fat32.fat32RootCluster;
fatType_ = 32;
}
return true;
}
u8 EmuFatVolume::allocContiguous(u32 count, u32* curCluster) {
// start of group
u32 bgnCluster;
// flag to save place to start next search
u8 setStart;
// set search start cluster
if (*curCluster) {
// try to make file contiguous
bgnCluster = *curCluster + 1;
// don't save new start location
setStart = false;
} else {
// start at likely place for free cluster
bgnCluster = allocSearchStart_;
// save next search start if one cluster
setStart = 1 == count;
}
// end of group
u32 endCluster = bgnCluster;
// last cluster of FAT
u32 fatEnd = clusterCount_ + 1;
// search the FAT for free clusters
for (u32 n = 0;; n++, endCluster++) {
// can't find space checked all clusters
if (n >= clusterCount_) return false;
// past end - start from beginning of FAT
if (endCluster > fatEnd) {
bgnCluster = endCluster = 2;
}
u32 f;
if (!fatGet(endCluster, &f)) return false;
if (f != 0) {
// cluster in use try next cluster as bgnCluster
bgnCluster = endCluster + 1;
} else if ((endCluster - bgnCluster + 1) == count) {
// done - found space
break;
}
}
// mark end of chain
if (!fatPutEOC(endCluster)) return false;
// link clusters
while (endCluster > bgnCluster) {
if (!fatPut(endCluster - 1, endCluster)) return false;
endCluster--;
}
if (*curCluster != 0) {
// connect chains
if (!fatPut(*curCluster, bgnCluster)) return false;
}
// return first cluster number to caller
*curCluster = bgnCluster;
// remember possible next free cluster
if (setStart) allocSearchStart_ = bgnCluster + 1;
return true;
}
u8 EmuFatVolume::fatGet(u32 cluster, u32* value) const {
if (cluster > (clusterCount_ + 1)) return false;
u32 lba = fatStartBlock_;
lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;
if (lba != dev_->cache_.cacheBlockNumber_) {
if (!dev_->cacheRawBlock(lba, EmuFat::CACHE_FOR_READ)) return false;
}
if (fatType_ == 16) {
*value = dev_->cache_.cacheBuffer_.fat16[cluster & 0XFF];
} else {
*value = dev_->cache_.cacheBuffer_.fat32[cluster & 0X7F] & FAT32MASK;
}
return true;
}
// Store a FAT entry
u8 EmuFatVolume::fatPut(u32 cluster, u32 value) {
// error if reserved cluster
if (cluster < 2) return false;
// error if not in FAT
if (cluster > (clusterCount_ + 1)) return false;
// calculate block address for entry
u32 lba = fatStartBlock_;
lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;
if (lba != dev_->cache_.cacheBlockNumber_) {
if (!dev_->cacheRawBlock(lba, EmuFat::CACHE_FOR_READ)) return false;
}
// store entry
if (fatType_ == 16) {
dev_->cache_.cacheBuffer_.fat16[cluster & 0xFF] = value;
} else {
dev_->cache_.cacheBuffer_.fat32[cluster & 0x7F] = value;
}
dev_->cacheSetDirty();
// mirror second FAT
if (fatCount_ > 1) dev_->cache_.cacheMirrorBlock_ = lba + blocksPerFat_;
return true;
}
// return the size in bytes of a cluster chain
u8 EmuFatVolume::chainSize(u32 cluster, u32* size) const {
u32 s = 0;
do {
if (!fatGet(cluster, &cluster)) return false;
s += 512UL << clusterSizeShift_;
} while (!isEOC(cluster));
*size = s;
return true;
}
// free a cluster chain
u8 EmuFatVolume::freeChain(u32 cluster) {
// clear free cluster location
allocSearchStart_ = 2;
do {
u32 next;
if (!fatGet(cluster, &next)) return false;
// free cluster
if (!fatPut(cluster, 0)) return false;
cluster = next;
} while (!isEOC(cluster));
return true;
}
u8 EmuFatVolume::readData(u32 block, u16 offset, u16 count, u8* dst) {
return dev_->readData(block, offset, count, dst);
}
u8 EmuFatVolume::writeBlock(u32 block, const u8* dst) {
return dev_->writeBlock(block, dst);
}
//-----------------------------------------------------------------------------------
//EmuFatFile:
// add a cluster to a file
u8 EmuFatFile::addCluster() {
if (!vol_->allocContiguous(1, &curCluster_)) return false;
// if first cluster of file link to directory entry
if (firstCluster_ == 0) {
firstCluster_ = curCluster_;
flags_ |= F_FILE_DIR_DIRTY;
}
return true;
}
// Add a cluster to a directory file and zero the cluster.
// return with first block of cluster in the cache
u8 EmuFatFile::addDirCluster(void) {
if (!addCluster()) return false;
// zero data in cluster insure first cluster is in cache
u32 block = vol_->clusterStartBlock(curCluster_);
for (u8 i = vol_->blocksPerCluster_; i != 0; i--) {
if (!vol_->dev_->cacheZeroBlock(block + i - 1)) return false;
}
// Increase directory file size by cluster size
fileSize_ += 512UL << vol_->clusterSizeShift_;
return true;
}
// cache a file's directory entry
// return pointer to cached entry or null for failure
TDirectoryEntry* EmuFatFile::cacheDirEntry(u8 action) {
if (!vol_->dev_->cacheRawBlock(dirBlock_, action)) return NULL;
return vol_->dev_->cache_.cacheBuffer_.dir + dirIndex_;
}
/**
* Close a file and force cached data and directory information
* to be written to the storage device.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include no file is open or an I/O error.
*/
u8 EmuFatFile::close(void) {
if (!sync())return false;
type_ = FAT_FILE_TYPE_CLOSED;
return true;
}
/**
* Check for contiguous file and return its raw block range.
*
* \param[out] bgnBlock the first block address for the file.
* \param[out] endBlock the last block address for the file.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include file is not contiguous, file has zero length
* or an I/O error occurred.
*/
u8 EmuFatFile::contiguousRange(u32* bgnBlock, u32* endBlock) {
// error if no blocks
if (firstCluster_ == 0) return false;
for (u32 c = firstCluster_; ; c++) {
u32 next;
if (!vol_->fatGet(c, &next)) return false;
// check for contiguous
if (next != (c + 1)) {
// error if not end of chain
if (!vol_->isEOC(next)) return false;
*bgnBlock = vol_->clusterStartBlock(firstCluster_);
*endBlock = vol_->clusterStartBlock(c)
+ vol_->blocksPerCluster_ - 1;
return true;
}
}
}
//------------------------------------------------------------------------------
/**
* Create and open a new contiguous file of a specified size.
*
* \note This function only supports short DOS 8.3 names.
* See open() for more information.
*
* \param[in] dirFile The directory where the file will be created.
* \param[in] fileName A valid DOS 8.3 file name.
* \param[in] size The desired file size.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include \a fileName contains
* an invalid DOS 8.3 file name, the FAT volume has not been initialized,
* a file is already open, the file already exists, the root
* directory is full or an I/O error.
*
*/
u8 EmuFatFile::createContiguous(EmuFatFile* dirFile, const char* fileName, u32 size) {
// don't allow zero length file
if (size == 0) return false;
if (!open(dirFile, fileName, EO_CREAT | EO_EXCL | EO_RDWR)) return false;
// calculate number of clusters needed
u32 count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;
// allocate clusters
if (!vol_->allocContiguous(count, &firstCluster_)) {
remove();
return false;
}
fileSize_ = size;
// insure sync() will update dir entry
flags_ |= F_FILE_DIR_DIRTY;
return sync();
}
/**
* Return a files directory entry
*
* \param[out] dir Location for return of the files directory entry.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
*/
u8 EmuFatFile::dirEntry(TDirectoryEntry* dir) {
// make sure fields on SD are correct
if (!sync()) return false;
// read entry
TDirectoryEntry* p = cacheDirEntry(EmuFat::CACHE_FOR_READ);
if (!p) return false;
// copy to caller's struct
memcpy(dir, p, sizeof(TDirectoryEntry));
return true;
}
/**
* Format the name field of \a dir into the 13 byte array
* \a name in standard 8.3 short name format.
*
* \param[in] dir The directory structure containing the name.
* \param[out] name A 13 byte char array for the formatted name.
*/
void EmuFatFile::dirName(const TDirectoryEntry& dir, char* name) {
u8 j = 0;
for (u8 i = 0; i < 11; i++) {
if (dir.name[i] == ' ')continue;
if (i == 8) name[j++] = '.';
name[j++] = dir.name[i];
}
name[j] = 0;
}
// format directory name field from a 8.3 name string
u8 EmuFatFile::make83Name(const char* str, u8* name) {
u8 c;
u8 n = 7; // max index for part before dot
u8 i = 0;
// blank fill name and extension
while (i < 11) name[i++] = ' ';
i = 0;
while ((c = *str++) != '\0') {
if (c == '.') {
if (n == 10) return false; // only one dot allowed
n = 10; // max index for full 8.3 name
i = 8; // place for extension
} else {
// illegal FAT characters
static const char* px = "\\/:*?\"<>";
const char* p = px;
u8 b;
while ((b = *p++)) if (b == c) return false;
// check size and only allow ASCII printable characters
if (i > n || c < 0X21 || c > 0X7E)return false;
// only upper case allowed in 8.3 names - convert lower to upper
name[i++] = c < 'a' || c > 'z' ? c : c + ('A' - 'a');
}
}
// must have a file name, extension is optional
return name[0] != ' ';
}
/** Make a new directory.
*
* \param[in] dir An open SdFat instance for the directory that will containing
* the new directory.
*
* \param[in] dirName A valid 8.3 DOS name for the new directory.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include this SdFile is already open, \a dir is not a
* directory, \a dirName is invalid or already exists in \a dir.
*/
u8 EmuFatFile::makeDir(EmuFatFile* dir, const char* dirName) {
TDirectoryEntry d;
// create a normal file
if (!open(dir, dirName, EO_CREAT | EO_EXCL | EO_RDWR)) return false;
// convert SdFile to directory
flags_ = EO_READ;
type_ = FAT_FILE_TYPE_SUBDIR;
// allocate and zero first cluster
if (!addDirCluster())return false;
// force entry to SD
if (!sync()) return false;
// cache entry - should already be in cache due to sync() call
TDirectoryEntry* p = cacheDirEntry(EmuFat::CACHE_FOR_WRITE);
if (!p) return false;
// change directory entry attribute
p->attributes = DIR_ATT_DIRECTORY;
// make entry for '.'
memcpy(&d, p, sizeof(d));
for (u8 i = 1; i < 11; i++) d.name[i] = ' ';
d.name[0] = '.';
// cache block for '.' and '..'
u32 block = vol_->clusterStartBlock(firstCluster_);
if (!vol_->dev_->cacheRawBlock(block, EmuFat::CACHE_FOR_WRITE)) return false;
// copy '.' to block
memcpy(&vol_->dev_->cache_.cacheBuffer_.dir[0], &d, sizeof(d));
// make entry for '..'
d.name[1] = '.';
if (dir->isRoot()) {
d.firstClusterLow = 0;
d.firstClusterHigh = 0;
} else {
d.firstClusterLow = dir->firstCluster_ & 0XFFFF;
d.firstClusterHigh = dir->firstCluster_ >> 16;
}
// copy '..' to block
memcpy(&vol_->dev_->cache_.cacheBuffer_.dir[1], &d, sizeof(d));
// set position after '..'
curPosition_ = 2 * sizeof(d);
// write first block
return vol_->dev_->cacheFlush();
}
/**
* Open a file or directory by name.
*
* \param[in] dirFile An open SdFat instance for the directory containing the
* file to be opened.
*
* \param[in] fileName A valid 8.3 DOS name for a file to be opened.
*
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
* OR of flags from the following list
*
* O_READ - Open for reading.
*
* O_RDONLY - Same as O_READ.
*
* O_WRITE - Open for writing.
*
* O_WRONLY - Same as O_WRITE.
*
* O_RDWR - Open for reading and writing.
*
* O_APPEND - If set, the file offset shall be set to the end of the
* file prior to each write.
*
* O_CREAT - If the file exists, this flag has no effect except as noted
* under O_EXCL below. Otherwise, the file shall be created
*
* O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
*
* O_SYNC - Call sync() after each write. This flag should not be used with
* write(uint8_t), write_P(PGM_P), writeln_P(PGM_P), or the Arduino Print class.
* These functions do character at a time writes so sync() will be called
* after each byte.
*
* O_TRUNC - If the file exists and is a regular file, and the file is
* successfully opened and is not read only, its length shall be truncated to 0.
*
* \note Directory files must be opened read only. Write and truncation is
* not allowed for directory files.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include this SdFile is already open, \a difFile is not
* a directory, \a fileName is invalid, the file does not exist
* or can't be opened in the access mode specified by oflag.
*/
u8 EmuFatFile::open(EmuFatFile* dirFile, const char* fileName, u8 oflag) {
u8 dname[11];
TDirectoryEntry* p;
// error if already open
if (isOpen())return false;
if (!make83Name(fileName, dname)) return false;
vol_ = dirFile->vol_;
dirFile->rewind();
// bool for empty entry found
u8 emptyFound = false;
// search for file
while (dirFile->curPosition_ < dirFile->fileSize_) {
u8 index = 0XF & (dirFile->curPosition_ >> 5);
p = dirFile->readDirCache();
if (p == NULL) return false;
if (p->name[0] == DIR_NAME_FREE || p->name[0] == DIR_NAME_DELETED) {
// remember first empty slot
if (!emptyFound) {
emptyFound = true;
dirIndex_ = index;
dirBlock_ = vol_->dev_->cache_.cacheBlockNumber_;
}
// done if no entries follow
if (p->name[0] == DIR_NAME_FREE) break;
} else if (!memcmp(dname, p->name, 11)) {
// don't open existing file if O_CREAT and O_EXCL
if ((oflag & (EO_CREAT | EO_EXCL)) == (EO_CREAT | EO_EXCL)) return false;
// open found file
return openCachedEntry(0XF & index, oflag);
}
}
// only create file if O_CREAT and O_WRITE
if ((oflag & (EO_CREAT | EO_WRITE)) != (EO_CREAT | EO_WRITE)) return false;
// cache found slot or add cluster if end of file
if (emptyFound) {
p = cacheDirEntry(EmuFat::CACHE_FOR_WRITE);
if (!p) return false;
} else {
if (dirFile->type_ == FAT_FILE_TYPE_ROOT16) return false;
// add and zero cluster for dirFile - first cluster is in cache for write
if (!dirFile->addDirCluster()) return false;
// use first entry in cluster
dirIndex_ = 0;
p = vol_->dev_->cache_.cacheBuffer_.dir;
}
// initialize as empty file
memset(p, 0, sizeof(TDirectoryEntry));
memcpy(p->name, dname, 11);
// set timestamps
if (dateTime_) {
// call user function
dateTime_(&p->creationDate, &p->creationTime);
} else {
// use default date/time
p->creationDate = FAT_DEFAULT_DATE;
p->creationTime = FAT_DEFAULT_TIME;
}
p->lastAccessDate = p->creationDate;
p->lastWriteDate = p->creationDate;
p->lastWriteTime = p->creationTime;
// force write of entry to SD
if (!vol_->dev_->cacheFlush()) return false;
// open entry in cache
return openCachedEntry(dirIndex_, oflag);
}
/**
* Open a file by index.
*
* \param[in] dirFile An open SdFat instance for the directory.
*
* \param[in] index The \a index of the directory entry for the file to be
* opened. The value for \a index is (directory file position)/32.
*
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
* OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
*
* See open() by fileName for definition of flags and return values.
*
*/
u8 EmuFatFile::open(EmuFatFile* dirFile, u16 index, u8 oflag) {
// error if already open
if (isOpen())return false;
// don't open existing file if O_CREAT and O_EXCL - user call error
if ((oflag & (EO_CREAT | EO_EXCL)) == (EO_CREAT | EO_EXCL)) return false;
vol_ = dirFile->vol_;
// seek to location of entry
if (!dirFile->seekSet(32 * index)) return false;
// read entry into cache
TDirectoryEntry* p = dirFile->readDirCache();
if (p == NULL) return false;
// error if empty slot or '.' or '..'
if (p->name[0] == DIR_NAME_FREE ||
p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
return false;
}
// open cached entry
return openCachedEntry(index & 0XF, oflag);
}
//------------------------------------------------------------------------------
// open a cached directory entry. Assumes vol_ is initializes
u8 EmuFatFile::openCachedEntry(u8 dirIndex, u8 oflag) {
// location of entry in cache
TDirectoryEntry* p = vol_->dev_->cache_.cacheBuffer_.dir + dirIndex;
// write or truncate is an error for a directory or read-only file
if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
if (oflag & (EO_WRITE | EO_TRUNC)) return false;
}
// remember location of directory entry on SD
dirIndex_ = dirIndex;
dirBlock_ = vol_->dev_->cache_.cacheBlockNumber_;
// copy first cluster number for directory fields
firstCluster_ = (u32)p->firstClusterHigh << 16;
firstCluster_ |= p->firstClusterLow;
// make sure it is a normal file or subdirectory
if (DIR_IS_FILE(p)) {
fileSize_ = p->fileSize;
type_ = FAT_FILE_TYPE_NORMAL;
} else if (DIR_IS_SUBDIR(p)) {
if (!vol_->chainSize(firstCluster_, &fileSize_)) return false;
type_ = FAT_FILE_TYPE_SUBDIR;
} else {
return false;
}
// save open flags for read/write
flags_ = oflag & (EO_ACCMODE | EO_SYNC | EO_APPEND);
// set to start of file
curCluster_ = 0;
curPosition_ = 0;
// truncate file to zero length if requested
if (oflag & EO_TRUNC) return truncate(0);
return true;
}
//------------------------------------------------------------------------------
/**
* Open a volume's root directory.
*
* \param[in] vol The FAT volume containing the root directory to be opened.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include the FAT volume has not been initialized
* or it a FAT12 volume.
*/
u8 EmuFatFile::openRoot(EmuFatVolume* vol) {
// error if file is already open
if (isOpen()) return false;
if (vol->fatType() == 16) {
type_ = FAT_FILE_TYPE_ROOT16;
firstCluster_ = 0;
fileSize_ = 32 * vol->rootDirEntryCount();
} else if (vol->fatType() == 32) {
type_ = FAT_FILE_TYPE_ROOT32;
firstCluster_ = vol->rootDirStart();
if (!vol->chainSize(firstCluster_, &fileSize_)) return false;
} else {
// volume is not initialized or FAT12
return false;
}
vol_ = vol;
// read only
flags_ = EO_READ;
// set to start of file
curCluster_ = 0;
curPosition_ = 0;
// root has no directory entry
dirBlock_ = 0;
dirIndex_ = 0;
return true;
}
//------------------------------------------------------------------------------
/**
* Read data from a file starting at the current position.
*
* \param[out] buf Pointer to the location that will receive the data.
*
* \param[in] nbyte Maximum number of bytes to read.
*
* \return For success read() returns the number of bytes read.
* A value less than \a nbyte, including zero, will be returned
* if end of file is reached.
* If an error occurs, read() returns -1. Possible errors include
* read() called before a file has been opened, corrupt file system
* or an I/O error occurred.
*/
s32 EmuFatFile::read(void* buf, u32 nbyte) {
u8* dst = reinterpret_cast(buf);
// error if not open or write only
if (!isOpen() || !(flags_ & EO_READ)) return -1;
// max bytes left in file
if (nbyte > (fileSize_ - curPosition_)) nbyte = fileSize_ - curPosition_;
// amount left to read
u32 toRead = nbyte;
while (toRead > 0) {
u32 block; // raw device block number
u16 offset = curPosition_ & 0x1FF; // offset in block
if (type_ == FAT_FILE_TYPE_ROOT16) {
block = vol_->rootDirStart() + (curPosition_ >> 9);
} else {
u8 blockOfCluster = vol_->blockOfCluster(curPosition_);
if (offset == 0 && blockOfCluster == 0) {
// start of new cluster
if (curPosition_ == 0) {
// use first cluster in file
curCluster_ = firstCluster_;
} else {
// get next cluster from FAT
if (!vol_->fatGet(curCluster_, &curCluster_)) return -1;
}
}
block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
}
u32 n = toRead;
// amount to be read from current block
if (n > (512UL - offset)) n = 512 - offset;
// no buffering needed if n == 512 or user requests no buffering
if ((unbufferedRead() || n == 512) &&
block != vol_->dev_->cache_.cacheBlockNumber_) {
if (!vol_->readData(block, offset, n, dst)) return -1;
dst += n;
} else {
// read block to cache and copy data to caller
if (!vol_->dev_->cacheRawBlock(block, EmuFat::CACHE_FOR_READ)) return -1;
u8* src = vol_->dev_->cache_.cacheBuffer_.data + offset;
u8* end = src + n;
while (src != end) *dst++ = *src++;
}
curPosition_ += n;
toRead -= n;
}
return nbyte;
}
//------------------------------------------------------------------------------
/**
* Read the next directory entry from a directory file.
*
* \param[out] dir The dir_t struct that will receive the data.
*
* \return For success readDir() returns the number of bytes read.
* A value of zero will be returned if end of file is reached.
* If an error occurs, readDir() returns -1. Possible errors include
* readDir() called before a directory has been opened, this is not
* a directory file or an I/O error occurred.
*/
s8 EmuFatFile::readDir(TDirectoryEntry* dir) {
s16 n;
// if not a directory file or miss-positioned return an error
if (!isDir() || (0x1F & curPosition_)) return -1;
while ((n = read(dir, sizeof(TDirectoryEntry))) == sizeof(TDirectoryEntry)) {
// last entry if DIR_NAME_FREE
if (dir->name[0] == DIR_NAME_FREE) break;
// skip empty entries and entry for . and ..
if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') continue;
// return if normal file or subdirectory
if (DIR_IS_FILE_OR_SUBDIR(dir)) return (s8)n;
}
// error, end of file, or past last entry
return n < 0 ? -1 : 0;
}
// Read next directory entry into the cache
// Assumes file is correctly positioned
TDirectoryEntry* EmuFatFile::readDirCache(void) {
// error if not directory
if (!isDir()) return NULL;
// index of entry in cache
u8 i = (curPosition_ >> 5) & 0XF;
// use read to locate and cache block
if (read() < 0) return NULL;
// advance to next entry
curPosition_ += 31;
// return pointer to entry
return (vol_->dev_->cache_.cacheBuffer_.dir + i);
}
//------------------------------------------------------------------------------
/**
* Remove a file.
*
* The directory entry and all data for the file are deleted.
*
* \note This function should not be used to delete the 8.3 version of a
* file that has a long name. For example if a file has the long name
* "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include the file read-only, is a directory,
* or an I/O error occurred.
*/
u8 EmuFatFile::remove(void) {
// free any clusters - will fail if read-only or directory
if (!truncate(0)) return false;
// cache directory entry
TDirectoryEntry* d = cacheDirEntry(EmuFat::CACHE_FOR_WRITE);
if (!d) return false;
// mark entry deleted
d->name[0] = DIR_NAME_DELETED;
// set this SdFile closed
type_ = FAT_FILE_TYPE_CLOSED;
// write entry to SD
return vol_->dev_->cacheFlush();
}
//------------------------------------------------------------------------------
/**
* Remove a file.
*
* The directory entry and all data for the file are deleted.
*
* \param[in] dirFile The directory that contains the file.
* \param[in] fileName The name of the file to be removed.
*
* \note This function should not be used to delete the 8.3 version of a
* file that has a long name. For example if a file has the long name
* "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include the file is a directory, is read only,
* \a dirFile is not a directory, \a fileName is not found
* or an I/O error occurred.
*/
u8 EmuFatFile::remove(EmuFatFile* dirFile, const char* fileName) {
EmuFatFile file;
if (!file.open(dirFile, fileName, EO_WRITE)) return false;
return file.remove();
}
//------------------------------------------------------------------------------
/** Remove a directory file.
*
* The directory file will be removed only if it is empty and is not the
* root directory. rmDir() follows DOS and Windows and ignores the
* read-only attribute for the directory.
*
* \note This function should not be used to delete the 8.3 version of a
* directory that has a long name. For example if a directory has the
* long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include the file is not a directory, is the root
* directory, is not empty, or an I/O error occurred.
*/
u8 EmuFatFile::rmDir(void) {
// must be open subdirectory
if (!isSubDir()) return false;
rewind();
// make sure directory is empty
while (curPosition_ < fileSize_) {
TDirectoryEntry* p = readDirCache();
if (p == NULL) return false;
// done if past last used entry
if (p->name[0] == DIR_NAME_FREE) break;
// skip empty slot or '.' or '..'
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
// error not empty
if (DIR_IS_FILE_OR_SUBDIR(p)) return false;
}
// convert empty directory to normal file for remove
type_ = FAT_FILE_TYPE_NORMAL;
flags_ |= EO_WRITE;
return remove();
}
//------------------------------------------------------------------------------
/** Recursively delete a directory and all contained files.
*
* This is like the Unix/Linux 'rm -rf *' if called with the root directory
* hence the name.
*
* Warning - This will remove all contents of the directory including
* subdirectories. The directory will then be removed if it is not root.
* The read-only attribute for files will be ignored.
*
* \note This function should not be used to delete the 8.3 version of
* a directory that has a long name. See remove() and rmDir().
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
*/
u8 EmuFatFile::rmRfStar(void) {
rewind();
while (curPosition_ < fileSize_) {
EmuFatFile f;
// remember position
u16 index = curPosition_/32;
TDirectoryEntry* p = readDirCache();
if (!p) return false;
// done if past last entry
if (p->name[0] == DIR_NAME_FREE) break;
// skip empty slot or '.' or '..'
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
// skip if part of long file name or volume label in root
if (!DIR_IS_FILE_OR_SUBDIR(p)) continue;
if (!f.open(this, index, EO_READ)) return false;
if (f.isSubDir()) {
// recursively delete
return rmRfStar();
} else {
// ignore read-only
f.flags_ |= EO_WRITE;
if (!f.remove()) return false;
}
// position to next entry if required
if (curPosition_ != (32*(index + 1))) {
if (!seekSet(32*(index + 1))) return false;
}
}
// don't try to delete root
if (isRoot()) return true;
return rmDir();
}
u8 EmuFatFile::seekSet(u32 pos) {
// error if file not open or seek past end of file
if (!isOpen() || pos > fileSize_) return false;
if (type_ == FAT_FILE_TYPE_ROOT16) {
curPosition_ = pos;
return true;
}
if (pos == 0) {
// set position to start of file
curCluster_ = 0;
curPosition_ = 0;
return true;
}
// calculate cluster index for cur and new position
u32 nCur = (curPosition_ - 1) >> (vol_->clusterSizeShift_ + 9);
u32 nNew = (pos - 1) >> (vol_->clusterSizeShift_ + 9);
if (nNew < nCur || curPosition_ == 0) {
// must follow chain from first cluster
curCluster_ = firstCluster_;
} else {
// advance from curPosition
nNew -= nCur;
}
while (nNew--) {
if (!vol_->fatGet(curCluster_, &curCluster_)) return false;
}
curPosition_ = pos;
return true;
}
//------------------------------------------------------------------------------
/**
* The sync() call causes all modified data and directory fields
* to be written to the storage device.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include a call to sync() before a file has been
* opened or an I/O error.
*/
u8 EmuFatFile::sync(void) {
// only allow open files and directories
if (!isOpen()) return false;
if (flags_ & F_FILE_DIR_DIRTY) {
TDirectoryEntry* d = cacheDirEntry(EmuFat::CACHE_FOR_WRITE);
if (!d) return false;
// do not set filesize for dir files
if (!isDir()) d->fileSize = fileSize_;
// update first cluster fields
d->firstClusterLow = firstCluster_ & 0XFFFF;
d->firstClusterHigh = firstCluster_ >> 16;
// set modify time if user supplied a callback date/time function
if (dateTime_) {
dateTime_(&d->lastWriteDate, &d->lastWriteTime);
d->lastAccessDate = d->lastWriteDate;
}
// clear directory dirty
flags_ &= ~F_FILE_DIR_DIRTY;
}
return vol_->dev_->cacheFlush();
}
//------------------------------------------------------------------------------
/**
* Set a file's timestamps in its directory entry.
*
* \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
* OR of flags from the following list
*
* T_ACCESS - Set the file's last access date.
*
* T_CREATE - Set the file's creation date and time.
*
* T_WRITE - Set the file's last write/modification date and time.
*
* \param[in] year Valid range 1980 - 2107 inclusive.
*
* \param[in] month Valid range 1 - 12 inclusive.
*
* \param[in] day Valid range 1 - 31 inclusive.
*
* \param[in] hour Valid range 0 - 23 inclusive.
*
* \param[in] minute Valid range 0 - 59 inclusive.
*
* \param[in] second Valid range 0 - 59 inclusive
*
* \note It is possible to set an invalid date since there is no check for
* the number of days in a month.
*
* \note
* Modify and access timestamps may be overwritten if a date time callback
* function has been set by dateTimeCallback().
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
*/
u8 EmuFatFile::timestamp(u8 flags, u16 year, u8 month, u8 day, u8 hour, u8 minute, u8 second) {
if (!isOpen()
|| year < 1980
|| year > 2107
|| month < 1
|| month > 12
|| day < 1
|| day > 31
|| hour > 23
|| minute > 59
|| second > 59) {
return false;
}
TDirectoryEntry* d = cacheDirEntry(EmuFat::CACHE_FOR_WRITE);
if (!d) return false;
u16 dirDate = FAT_DATE(year, month, day);
u16 dirTime = FAT_TIME(hour, minute, second);
if (flags & T_ACCESS) {
d->lastAccessDate = dirDate;
}
if (flags & T_CREATE) {
d->creationDate = dirDate;
d->creationTime = dirTime;
// seems to be units of 1/100 second not 1/10 as Microsoft states
d->creationTimeTenths = second & 1 ? 100 : 0;
}
if (flags & T_WRITE) {
d->lastWriteDate = dirDate;
d->lastWriteTime = dirTime;
}
vol_->dev_->cacheSetDirty();
return sync();
}
//------------------------------------------------------------------------------
/**
* Truncate a file to a specified length. The current file position
* will be maintained if it is less than or equal to \a length otherwise
* it will be set to end of file.
*
* \param[in] length The desired length for the file.
*
* \return The value one, true, is returned for success and
* the value zero, false, is returned for failure.
* Reasons for failure include file is read only, file is a directory,
* \a length is greater than the current file size or an I/O error occurs.
*/
u8 EmuFatFile::truncate(u32 length) {
// error if not a normal file or read-only
if (!isFile() || !(flags_ & EO_WRITE)) return false;
// error if length is greater than current size
if (length > fileSize_) return false;
// fileSize and length are zero - nothing to do
if (fileSize_ == 0) return true;
// remember position for seek after truncation
u32 newPos = curPosition_ > length ? length : curPosition_;
// position to last cluster in truncated file
if (!seekSet(length)) return false;
if (length == 0) {
// free all clusters
if (!vol_->freeChain(firstCluster_)) return false;
firstCluster_ = 0;
} else {
u32 toFree;
if (!vol_->fatGet(curCluster_, &toFree)) return false;
if (!vol_->isEOC(toFree)) {
// free extra clusters
if (!vol_->freeChain(toFree)) return false;
// current cluster is end of chain
if (!vol_->fatPutEOC(curCluster_)) return false;
}
}
fileSize_ = length;
// need to update directory entry
flags_ |= F_FILE_DIR_DIRTY;
if (!sync()) return false;
// set file to correct position
return seekSet(newPos);
}
/**
* Write data to an open file.
*
* \note Data is moved to the cache but may not be written to the
* storage device until sync() is called.
*
* \param[in] buf Pointer to the location of the data to be written.
*
* \param[in] nbyte Number of bytes to write.
*
* \return For success write() returns the number of bytes written, always
* \a nbyte. If an error occurs, write() returns -1. Possible errors
* include write() is called before a file has been opened, write is called
* for a read-only file, device is full, a corrupt file system or an I/O error.
*
*/
s32 EmuFatFile::write(const void* buf, u32 nbyte) {
// convert void* to uint8_t* - must be before goto statements
const u8* src = reinterpret_cast(buf);
// number of bytes left to write - must be before goto statements
u32 nToWrite = nbyte;
// error if not a normal file or is read-only
if (!isFile() || !(flags_ & EO_WRITE)) goto writeErrorReturn;
// seek to end of file if append flag
if ((flags_ & EO_APPEND) && curPosition_ != fileSize_) {
if (!seekEnd()) goto writeErrorReturn;
}
while (nToWrite > 0) {
u8 blockOfCluster = vol_->blockOfCluster(curPosition_);
u16 blockOffset = curPosition_ & 0X1FF;
if (blockOfCluster == 0 && blockOffset == 0) {
// start of new cluster
if (curCluster_ == 0) {
if (firstCluster_ == 0) {
// allocate first cluster of file
if (!addCluster()) goto writeErrorReturn;
} else {
curCluster_ = firstCluster_;
}
} else {
u32 next;
if (!vol_->fatGet(curCluster_, &next)) return false;
if (vol_->isEOC(next)) {
// add cluster if at end of chain
if (!addCluster()) goto writeErrorReturn;
} else {
curCluster_ = next;
}
}
}
// max space in block
u32 n = 512 - blockOffset;
// lesser of space and amount to write
if (n > nToWrite) n = nToWrite;
// block for data write
u32 block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
if (n == 512) {
// full block - don't need to use cache
// invalidate cache if block is in cache
if (vol_->dev_->cache_.cacheBlockNumber_ == block) {
vol_->dev_->cache_.cacheBlockNumber_ = 0XFFFFFFFF;
}
if (!vol_->writeBlock(block, src)) goto writeErrorReturn;
src += 512;
} else {
if (blockOffset == 0 && curPosition_ >= fileSize_) {
// start of new block don't need to read into cache
if (!vol_->dev_->cacheFlush()) goto writeErrorReturn;
vol_->dev_->cache_.cacheBlockNumber_ = block;
vol_->dev_->cacheSetDirty();
} else {
// rewrite part of block
if (!vol_->dev_->cacheRawBlock(block, EmuFat::CACHE_FOR_WRITE)) {
goto writeErrorReturn;
}
}
u8* dst = vol_->dev_->cache_.cacheBuffer_.data + blockOffset;
u8* end = dst + n;
while (dst != end) *dst++ = *src++;
}
nToWrite -= n;
curPosition_ += n;
}
if (curPosition_ > fileSize_) {
// update fileSize and insure sync will update dir entry
fileSize_ = curPosition_;
flags_ |= F_FILE_DIR_DIRTY;
} else if (dateTime_ && nbyte) {
// insure sync will update modified date and time
flags_ |= F_FILE_DIR_DIRTY;
}
if (flags_ & EO_SYNC) {
if (!sync()) goto writeErrorReturn;
}
return nbyte;
writeErrorReturn:
// return for write error
writeError = true;
return -1;
}
desmume/src/libretro-common/gfx/scaler/scaler_int.c 000664 001750 001750 00000023542 12755534123 023601 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (scaler_int.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include
#include
#ifdef SCALER_NO_SIMD
#undef __SSE2__
#endif
#if defined(__SSE2__)
#include
#ifdef _WIN32
#include
#endif
#endif
/* ARGB8888 scaler is split in two:
*
* First, horizontal scaler is applied.
* Here, all 8-bit channels are expanded to 16-bit. Values are then shifted 7 to left to occupy 15 bits.
* The sign bit is kept empty as we have to do signed multiplication for the filter.
* A mulhi [(a * b) >> 16] is applied which loses some precision, but is very efficient for SIMD.
* It is accurate enough for 8-bit purposes.
*
* The fixed point 1.0 for filter is (1 << 14). After horizontal scale, the output is kept
* with 16-bit channels, and will now have 13 bits of precision as [(a * (1 << 14)) >> 16] is effectively a right shift by 2.
*
* Vertical scaler takes the 13 bit channels, and performs the same mulhi steps.
* Another 2 bits of precision is lost, which ends up as 11 bits.
* Scaling is now complete. Channels are shifted right by 3, and saturated into 8-bit values.
*
* The C version of scalers perform the exact same operations as the SIMD code for testing purposes.
*/
#if defined(__SSE2__)
void scaler_argb8888_vert(const struct scaler_ctx *ctx, void *output_, int stride)
{
int h, w, y;
const uint64_t *input = ctx->scaled.frame;
uint32_t *output = (uint32_t*)output_;
const int16_t *filter_vert = ctx->vert.filter;
for (h = 0; h < ctx->out_height; h++, filter_vert += ctx->vert.filter_stride, output += stride >> 2)
{
const uint64_t *input_base = input + ctx->vert.filter_pos[h] * (ctx->scaled.stride >> 3);
for (w = 0; w < ctx->out_width; w++)
{
__m128i final;
__m128i res = _mm_setzero_si128();
const uint64_t *input_base_y = input_base + w;
for (y = 0; (y + 1) < ctx->vert.filter_len; y += 2, input_base_y += (ctx->scaled.stride >> 2))
{
__m128i coeff = _mm_set_epi64x(filter_vert[y + 1] * 0x0001000100010001ll, filter_vert[y + 0] * 0x0001000100010001ll);
__m128i col = _mm_set_epi64x(input_base_y[ctx->scaled.stride >> 3], input_base_y[0]);
res = _mm_adds_epi16(_mm_mulhi_epi16(col, coeff), res);
}
for (; y < ctx->vert.filter_len; y++, input_base_y += (ctx->scaled.stride >> 3))
{
__m128i coeff = _mm_set_epi64x(0, filter_vert[y] * 0x0001000100010001ll);
__m128i col = _mm_set_epi64x(0, input_base_y[0]);
res = _mm_adds_epi16(_mm_mulhi_epi16(col, coeff), res);
}
res = _mm_adds_epi16(_mm_srli_si128(res, 8), res);
res = _mm_srai_epi16(res, (7 - 2 - 2));
final = _mm_packus_epi16(res, res);
output[w] = _mm_cvtsi128_si32(final);
}
}
}
#else
void scaler_argb8888_vert(const struct scaler_ctx *ctx, void *output_, int stride)
{
int h, w, y;
const uint64_t *input = ctx->scaled.frame;
uint32_t *output = (uint32_t*)output_;
const int16_t *filter_vert = ctx->vert.filter;
for (h = 0; h < ctx->out_height; h++, filter_vert += ctx->vert.filter_stride, output += stride >> 2)
{
const uint64_t *input_base = input + ctx->vert.filter_pos[h] * (ctx->scaled.stride >> 3);
for (w = 0; w < ctx->out_width; w++)
{
int16_t res_a = 0;
int16_t res_r = 0;
int16_t res_g = 0;
int16_t res_b = 0;
const uint64_t *input_base_y = input_base + w;
for (y = 0; y < ctx->vert.filter_len; y++, input_base_y += (ctx->scaled.stride >> 3))
{
uint64_t col = *input_base_y;
int16_t a = (col >> 48) & 0xffff;
int16_t r = (col >> 32) & 0xffff;
int16_t g = (col >> 16) & 0xffff;
int16_t b = (col >> 0) & 0xffff;
int16_t coeff = filter_vert[y];
res_a += (a * coeff) >> 16;
res_r += (r * coeff) >> 16;
res_g += (g * coeff) >> 16;
res_b += (b * coeff) >> 16;
}
res_a >>= (7 - 2 - 2);
res_r >>= (7 - 2 - 2);
res_g >>= (7 - 2 - 2);
res_b >>= (7 - 2 - 2);
output[w] = (clamp_8bit(res_a) << 24) | (clamp_8bit(res_r) << 16) | (clamp_8bit(res_g) << 8) | (clamp_8bit(res_b) << 0);
}
}
}
#endif
#if defined(__SSE2__)
void scaler_argb8888_horiz(const struct scaler_ctx *ctx, const void *input_, int stride)
{
int h, w, x;
const uint32_t *input = (const uint32_t*)input_;
uint64_t *output = ctx->scaled.frame;
for (h = 0; h < ctx->scaled.height; h++, input += stride >> 2, output += ctx->scaled.stride >> 3)
{
const int16_t *filter_horiz = ctx->horiz.filter;
for (w = 0; w < ctx->scaled.width; w++, filter_horiz += ctx->horiz.filter_stride)
{
__m128i res = _mm_setzero_si128();
const uint32_t *input_base_x = input + ctx->horiz.filter_pos[w];
for (x = 0; (x + 1) < ctx->horiz.filter_len; x += 2)
{
__m128i coeff = _mm_set_epi64x(filter_horiz[x + 1] * 0x0001000100010001ll, filter_horiz[x + 0] * 0x0001000100010001ll);
__m128i col = _mm_unpacklo_epi8(_mm_set_epi64x(0,
((uint64_t)input_base_x[x + 1] << 32) | input_base_x[x + 0]), _mm_setzero_si128());
col = _mm_slli_epi16(col, 7);
res = _mm_adds_epi16(_mm_mulhi_epi16(col, coeff), res);
}
for (; x < ctx->horiz.filter_len; x++)
{
__m128i coeff = _mm_set_epi64x(0, filter_horiz[x] * 0x0001000100010001ll);
__m128i col = _mm_unpacklo_epi8(_mm_set_epi32(0, 0, 0, input_base_x[x]), _mm_setzero_si128());
col = _mm_slli_epi16(col, 7);
res = _mm_adds_epi16(_mm_mulhi_epi16(col, coeff), res);
}
res = _mm_adds_epi16(_mm_srli_si128(res, 8), res);
#ifdef __x86_64__
output[w] = _mm_cvtsi128_si64(res);
#else /* 32-bit doesn't have si64. Do it in two steps. */
union
{
uint32_t *u32;
uint64_t *u64;
} u;
u.u64 = output + w;
u.u32[0] = _mm_cvtsi128_si32(res);
u.u32[1] = _mm_cvtsi128_si32(_mm_srli_si128(res, 4));
#endif
}
}
}
#else
static INLINE uint64_t build_argb64(uint16_t a, uint16_t r, uint16_t g, uint16_t b)
{
return ((uint64_t)a << 48) | ((uint64_t)r << 32) | ((uint64_t)g << 16) | ((uint64_t)b << 0);
}
void scaler_argb8888_horiz(const struct scaler_ctx *ctx, const void *input_, int stride)
{
int h, w, x;
const uint32_t *input = (uint32_t*)input_;
uint64_t *output = ctx->scaled.frame;
for (h = 0; h < ctx->scaled.height; h++, input += stride >> 2, output += ctx->scaled.stride >> 3)
{
const int16_t *filter_horiz = ctx->horiz.filter;
for (w = 0; w < ctx->scaled.width; w++, filter_horiz += ctx->horiz.filter_stride)
{
const uint32_t *input_base_x = input + ctx->horiz.filter_pos[w];
int16_t res_a = 0;
int16_t res_r = 0;
int16_t res_g = 0;
int16_t res_b = 0;
for (x = 0; x < ctx->horiz.filter_len; x++)
{
uint32_t col = input_base_x[x];
int16_t a = (col >> (24 - 7)) & (0xff << 7);
int16_t r = (col >> (16 - 7)) & (0xff << 7);
int16_t g = (col >> ( 8 - 7)) & (0xff << 7);
int16_t b = (col << ( 0 + 7)) & (0xff << 7);
int16_t coeff = filter_horiz[x];
res_a += (a * coeff) >> 16;
res_r += (r * coeff) >> 16;
res_g += (g * coeff) >> 16;
res_b += (b * coeff) >> 16;
}
output[w] = build_argb64(res_a, res_r, res_g, res_b);
}
}
}
#endif
void scaler_argb8888_point_special(const struct scaler_ctx *ctx,
void *output_, const void *input_,
int out_width, int out_height,
int in_width, int in_height,
int out_stride, int in_stride)
{
int h, w;
const uint32_t *input = NULL;
uint32_t *output = NULL;
int x_pos = (1 << 15) * in_width / out_width - (1 << 15);
int x_step = (1 << 16) * in_width / out_width;
int y_pos = (1 << 15) * in_height / out_height - (1 << 15);
int y_step = (1 << 16) * in_height / out_height;
(void)ctx;
if (x_pos < 0)
x_pos = 0;
if (y_pos < 0)
y_pos = 0;
input = (const uint32_t*)input_;
output = (uint32_t*)output_;
for (h = 0; h < out_height; h++, y_pos += y_step, output += out_stride >> 2)
{
int x = x_pos;
const uint32_t *inp = input + (y_pos >> 16) * (in_stride >> 2);
for (w = 0; w < out_width; w++, x += x_step)
output[w] = inp[x >> 16];
}
}
desmume/src/libretro-common/formats/png/test/ 000700 001750 001750 00000000000 12756420131 022443 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/compat/compat_strl.c 000664 001750 001750 00000004037 12755534123 023231 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (compat_strl.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include
#include
#include
#include
/* Implementation of strlcpy()/strlcat() based on OpenBSD. */
#ifndef __MACH__
size_t strlcpy(char *dest, const char *source, size_t size)
{
size_t src_size = 0;
size_t n = size;
if (n)
while (--n && (*dest++ = *source++)) src_size++;
if (!n)
{
if (size) *dest = '\0';
while (*source++) src_size++;
}
return src_size;
}
size_t strlcat(char *dest, const char *source, size_t size)
{
size_t len = strlen(dest);
dest += len;
if (len > size)
size = 0;
else
size -= len;
return len + strlcpy(dest, source, size);
}
#endif
desmume/src/utils/AsmJit/core/assembler.h 000664 001750 001750 00000042405 12755534123 021551 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
// [Guard]
#ifndef _ASMJIT_CORE_ASSEMBLER_H
#define _ASMJIT_CORE_ASSEMBLER_H
// [Dependencies - AsmJit]
#include "../core/buffer.h"
#include "../core/context.h"
#include "../core/defs.h"
#include "../core/logger.h"
#include "../core/podvector.h"
#include "../core/zonememory.h"
// [Api-Begin]
#include "../core/apibegin.h"
namespace AsmJit {
//! @addtogroup AsmJit_Core
//! @{
// ============================================================================
// [AsmJit::Assembler]
// ============================================================================
//! @brief Base class for @ref Assembler.
//!
//! This class implements core setialization API only. The platform specific
//! methods and intrinsics is implemented by derived classes.
//!
//! @sa @c Assembler.
struct Assembler
{
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Creates Assembler instance.
ASMJIT_API Assembler(Context* context);
//! @brief Destroys Assembler instance
ASMJIT_API virtual ~Assembler();
// --------------------------------------------------------------------------
// [LabelLink]
// --------------------------------------------------------------------------
//! @brief Data structure used to link linked-labels.
struct LabelLink
{
//! @brief Previous link.
LabelLink* prev;
//! @brief Offset.
sysint_t offset;
//! @brief Inlined displacement.
sysint_t displacement;
//! @brief RelocId if link must be absolute when relocated.
sysint_t relocId;
};
// --------------------------------------------------------------------------
// [LabelData]
// --------------------------------------------------------------------------
//! @brief Label data.
struct LabelData
{
//! @brief Label offset.
sysint_t offset;
//! @brief Label links chain.
LabelLink* links;
};
// --------------------------------------------------------------------------
// [RelocData]
// --------------------------------------------------------------------------
// X86 architecture uses 32-bit absolute addressing model by memory operands,
// but 64-bit mode uses relative addressing model (RIP + displacement). In
// code we are always using relative addressing model for referencing labels
// and embedded data. In 32-bit mode we must patch all references to absolute
// address before we can call generated function. We are patching only memory
// operands.
//! @brief Code relocation data (relative vs absolute addresses).
struct RelocData
{
//! @brief Type of relocation.
uint32_t type;
//! @brief Size of relocation (4 or 8 bytes).
uint32_t size;
//! @brief Offset from code begin address.
sysint_t offset;
//! @brief Relative displacement or absolute address.
union
{
//! @brief Relative displacement from code begin address (not to @c offset).
sysint_t destination;
//! @brief Absolute address where to jump;
void* address;
};
};
// --------------------------------------------------------------------------
// [Context]
// --------------------------------------------------------------------------
//! @brief Get code generator.
inline Context* getContext() const
{ return _context; }
// --------------------------------------------------------------------------
// [Memory Management]
// --------------------------------------------------------------------------
//! @brief Get zone memory manager.
inline ZoneMemory* getZoneMemory() const
{ return const_cast(&_zoneMemory); }
// --------------------------------------------------------------------------
// [Logging]
// --------------------------------------------------------------------------
//! @brief Get logger.
inline Logger* getLogger() const
{ return _logger; }
//! @brief Set logger to @a logger.
ASMJIT_API virtual void setLogger(Logger* logger);
// --------------------------------------------------------------------------
// [Error Handling]
// --------------------------------------------------------------------------
//! @brief Get error code.
inline uint32_t getError() const
{ return _error; }
//! @brief Set error code.
//!
//! This method is virtual, because higher classes can use it to catch all
//! errors.
ASMJIT_API virtual void setError(uint32_t error);
// --------------------------------------------------------------------------
// [Properties]
// --------------------------------------------------------------------------
//! @brief Get assembler property.
ASMJIT_API virtual uint32_t getProperty(uint32_t propertyId) const;
//! @brief Set assembler property.
ASMJIT_API virtual void setProperty(uint32_t propertyId, uint32_t value);
// --------------------------------------------------------------------------
// [Capacity]
// --------------------------------------------------------------------------
//! @brief Get capacity of internal code buffer.
inline size_t getCapacity() const
{ return _buffer.getCapacity(); }
// --------------------------------------------------------------------------
// [Offset]
// --------------------------------------------------------------------------
//! @brief Return current offset in buffer.
inline size_t getOffset() const
{ return _buffer.getOffset(); }
//! @brief Set offset to @a o and returns previous offset.
//!
//! This method can be used to truncate code (previous offset is not
//! recorded) or to overwrite instruction stream at position @a o.
//!
//! @return Previous offset value that can be uset to set offset back later.
inline size_t toOffset(size_t o)
{ return _buffer.toOffset(o); }
// --------------------------------------------------------------------------
// [GetCode / GetCodeSize]
// --------------------------------------------------------------------------
//! @brief Return start of assembler code buffer.
//!
//! Note that buffer address can change if you emit instruction or something
//! else. Use this pointer only when you finished or make sure you do not
//! use returned pointer after emitting.
inline uint8_t* getCode() const
{ return _buffer.getData(); }
//! @brief Return current offset in buffer (same as getOffset() + getTramplineSize()).
inline size_t getCodeSize() const
{ return _buffer.getOffset() + getTrampolineSize(); }
// --------------------------------------------------------------------------
// [TakeCode]
// --------------------------------------------------------------------------
//! @brief Take internal code buffer and NULL all pointers (you take the ownership).
ASMJIT_API uint8_t* takeCode();
// --------------------------------------------------------------------------
// [Clear / Reset]
// --------------------------------------------------------------------------
//! @brief Clear everything, but not deallocate buffers.
ASMJIT_API void clear();
//! @brief Reset everything (means also to free all buffers).
ASMJIT_API void reset();
//! @brief Called by clear() and reset() to clear all data related to derived
//! class implementation.
ASMJIT_API virtual void _purge();
// --------------------------------------------------------------------------
// [EnsureSpace]
// --------------------------------------------------------------------------
//! @brief Ensure space for next instruction.
//!
//! Note that this method can return false. It's rare and probably you never
//! get this, but in some situations it's still possible.
inline bool ensureSpace()
{ return _buffer.ensureSpace(); }
// --------------------------------------------------------------------------
// [GetTrampolineSize]
// --------------------------------------------------------------------------
//! @brief Get size of all possible trampolines needed to successfuly generate
//! relative jumps to absolute addresses. This value is only non-zero if jmp
//! of call instructions were used with immediate operand (this means jump or
//! call absolute address directly).
//!
//! Currently only _emitJmpOrCallReloc() method can increase trampoline size
//! value.
inline size_t getTrampolineSize() const
{ return _trampolineSize; }
// --------------------------------------------------------------------------
// [Buffer - Getters]
// --------------------------------------------------------------------------
//! @brief Get byte at position @a pos.
inline uint8_t getByteAt(size_t pos) const
{ return _buffer.getByteAt(pos); }
//! @brief Get word at position @a pos.
inline uint16_t getWordAt(size_t pos) const
{ return _buffer.getWordAt(pos); }
//! @brief Get dword at position @a pos.
inline uint32_t getDWordAt(size_t pos) const
{ return _buffer.getDWordAt(pos); }
//! @brief Get qword at position @a pos.
inline uint64_t getQWordAt(size_t pos) const
{ return _buffer.getQWordAt(pos); }
//! @brief Get int32_t at position @a pos.
inline int32_t getInt32At(size_t pos) const
{ return (int32_t)_buffer.getDWordAt(pos); }
//! @brief Get int64_t at position @a pos.
inline int64_t getInt64At(size_t pos) const
{ return (int64_t)_buffer.getQWordAt(pos); }
//! @brief Get intptr_t at position @a pos.
inline intptr_t getIntPtrTAt(size_t pos) const
{ return _buffer.getIntPtrTAt(pos); }
//! @brief Get uintptr_t at position @a pos.
inline uintptr_t getUIntPtrTAt(size_t pos) const
{ return _buffer.getUIntPtrTAt(pos); }
//! @brief Get uintptr_t at position @a pos.
inline size_t getSizeTAt(size_t pos) const
{ return _buffer.getSizeTAt(pos); }
// --------------------------------------------------------------------------
// [Buffer - Setters]
// --------------------------------------------------------------------------
//! @brief Set byte at position @a pos.
inline void setByteAt(size_t pos, uint8_t x)
{ _buffer.setByteAt(pos, x); }
//! @brief Set word at position @a pos.
inline void setWordAt(size_t pos, uint16_t x)
{ _buffer.setWordAt(pos, x); }
//! @brief Set dword at position @a pos.
inline void setDWordAt(size_t pos, uint32_t x)
{ _buffer.setDWordAt(pos, x); }
//! @brief Set qword at position @a pos.
inline void setQWordAt(size_t pos, uint64_t x)
{ _buffer.setQWordAt(pos, x); }
//! @brief Set int32_t at position @a pos.
inline void setInt32At(size_t pos, int32_t x)
{ _buffer.setDWordAt(pos, (uint32_t)x); }
//! @brief Set int64_t at position @a pos.
inline void setInt64At(size_t pos, int64_t x)
{ _buffer.setQWordAt(pos, (uint64_t)x); }
//! @brief Set intptr_t at position @a pos.
inline void setIntPtrTAt(size_t pos, intptr_t x)
{ _buffer.setIntPtrTAt(pos, x); }
//! @brief Set uintptr_t at position @a pos.
inline void setUInt64At(size_t pos, uintptr_t x)
{ _buffer.setUIntPtrTAt(pos, x); }
//! @brief Set size_t at position @a pos.
inline void setSizeTAt(size_t pos, size_t x)
{ _buffer.setSizeTAt(pos, x); }
// --------------------------------------------------------------------------
// [CanEmit]
// --------------------------------------------------------------------------
//! @brief Get whether the instruction can be emitted.
//!
//! This function behaves like @c ensureSpace(), but it also checks if
//! assembler is in error state and in that case it returns @c false.
//! Assembler internally always uses this function before new instruction is
//! emitted.
//!
//! It's implemented like:
//! return ensureSpace() && !getError();
inline bool canEmit()
{
// If there is an error, we can't emit another instruction until last error
// is cleared by calling @c setError(kErrorOk). If something caused the
// error while generating code it's probably fatal in all cases. You can't
// use generated code anymore, because you are not sure about the status.
if (_error)
return false;
// The ensureSpace() method returns true on success and false on failure. We
// are catching return value and setting error code here.
if (ensureSpace())
return true;
// If we are here, there is memory allocation error. Note that this is HEAP
// allocation error, virtual allocation error can be caused only by
// AsmJit::VirtualMemory class!
setError(kErrorNoHeapMemory);
return false;
}
// --------------------------------------------------------------------------
// [Emit]
//
// These functions are not protected against buffer overrun. Each place of
// code which calls these functions ensures that there is some space using
// canEmit() method. Emitters are internally protected in AsmJit::Buffer,
// but only in debug builds.
// --------------------------------------------------------------------------
//! @brief Emit Byte to internal buffer.
inline void _emitByte(uint8_t x)
{ _buffer.emitByte(x); }
//! @brief Emit word (2 bytes) to internal buffer.
inline void _emitWord(uint16_t x)
{ _buffer.emitWord(x); }
//! @brief Emit dword (4 bytes) to internal buffer.
inline void _emitDWord(uint32_t x)
{ _buffer.emitDWord(x); }
//! @brief Emit qword (8 bytes) to internal buffer.
inline void _emitQWord(uint64_t x)
{ _buffer.emitQWord(x); }
//! @brief Emit Int32 (4 bytes) to internal buffer.
inline void _emitInt32(int32_t x)
{ _buffer.emitDWord((uint32_t)x); }
//! @brief Emit Int64 (8 bytes) to internal buffer.
inline void _emitInt64(int64_t x)
{ _buffer.emitQWord((uint64_t)x); }
//! @brief Emit intptr_t (4 or 8 bytes) to internal buffer.
inline void _emitIntPtrT(intptr_t x)
{ _buffer.emitIntPtrT(x); }
//! @brief Emit uintptr_t (4 or 8 bytes) to internal buffer.
inline void _emitUIntPtrT(uintptr_t x)
{ _buffer.emitUIntPtrT(x); }
//! @brief Emit size_t (4 or 8 bytes) to internal buffer.
inline void _emitSizeT(size_t x)
{ _buffer.emitSizeT(x); }
//! @brief Embed data into instruction stream.
ASMJIT_API void embed(const void* data, size_t len);
// --------------------------------------------------------------------------
// [Reloc]
// --------------------------------------------------------------------------
//! @brief Relocate code to a given address @a dst.
//!
//! @param dst Where the relocated code should me stored. The pointer can be
//! address returned by virtual memory allocator or your own address if you
//! want only to store the code for later reuse (or load, etc...).
//! @param addressBase Base address used for relocation. When using JIT code
//! generation, this will be the same as @a dst, only casted to system
//! integer type. But when generating code for remote process then the value
//! can be different.
//!
//! @retval The bytes used. Code-generator can create trampolines which are
//! used when calling other functions inside the JIT code. However, these
//! trampolines can be unused so the relocCode() returns the exact size needed
//! for the function.
//!
//! A given buffer will be overwritten, to get number of bytes required use
//! @c getCodeSize().
virtual size_t relocCode(void* dst, sysuint_t addressBase) const = 0;
//! @brief Simplifed version of @c relocCode() method designed for JIT.
//!
//! @overload
inline size_t relocCode(void* dst) const
{ return relocCode(dst, (uintptr_t)dst); }
// --------------------------------------------------------------------------
// [Make]
// --------------------------------------------------------------------------
//! @brief Make is convenience method to make currently serialized code and
//! return pointer to generated function.
//!
//! What you need is only to cast this pointer to your function type and call
//! it. Note that if there was an error and calling @c getError() method not
//! returns @c kErrorOk (zero) then this function always return @c NULL and
//! error value remains the same.
virtual void* make() = 0;
// --------------------------------------------------------------------------
// [Helpers]
// --------------------------------------------------------------------------
ASMJIT_API LabelLink* _newLabelLink();
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief ZoneMemory management.
ZoneMemory _zoneMemory;
//! @brief Binary code buffer.
Buffer _buffer;
//! @brief Context (for example @ref JitContext).
Context* _context;
//! @brief Logger.
Logger* _logger;
//! @brief Error code.
uint32_t _error;
//! @brief Properties.
uint32_t _properties;
//! @brief Emit flags for next instruction (cleared after emit).
uint32_t _emitOptions;
//! @brief Size of possible trampolines.
uint32_t _trampolineSize;
//! @brief Inline comment that will be logged by the next instruction and
//! set to NULL.
const char* _inlineComment;
//! @brief Linked list of unused links (@c LabelLink* structures)
LabelLink* _unusedLinks;
//! @brief Labels data.
PodVector _labels;
//! @brief Relocations data.
PodVector _relocData;
};
//! @}
} // AsmJit namespace
// [Api-End]
#include "../core/apiend.h"
// [Guard]
#endif // _ASMJIT_CORE_ASSEMBLER_H
desmume/src/addons/slot1_retail_mcrom_debug.cpp 000664 001750 001750 00000012310 12755534123 023055 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2013-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#include "slot1comp_mc.h"
#include "slot1comp_rom.h"
#include "slot1comp_protocol.h"
#include
#include
#include "../slot1.h"
#include "../path.h"
#include "../NDSSystem.h"
#include "../utils/fsnitro.h"
//quick architecture overview:
//MCROM receives GC bus commands from MMU.cpp
//those are passed on to the protocol component for parsing
//protocol calls back into MCROM via ISlot1Comp_Protocol_Client interface for things the protocol doesnt know about (the contents of the rom, chiefly)
//MCROM utilizes the rom component for address logic and delivering data
class Slot1_Retail_DEBUG : public ISlot1Interface, public ISlot1Comp_Protocol_Client
{
private:
Slot1Comp_Protocol protocol;
Slot1Comp_Rom rom;
FILE *fpROM;
FS_NITRO *fs;
u16 curr_file_id;
string pathData;
public:
virtual Slot1Info const* info()
{
static Slot1InfoSimple info("Retail DEBUG","Slot1 Retail (standard) card emulation + FS Nitro DEBUG", 0x04);
return &info;
}
virtual void connect()
{
protocol.reset(this);
protocol.chipId = gameInfo.chipID;
protocol.gameCode = T1ReadLong((u8*)gameInfo.header.gameCode,0);
curr_file_id = 0xFFFF;
fpROM = NULL;
fs = NULL;
if (!CommonSettings.loadToMemory)
{
printf("NitroFS: change load type to \"Load to RAM\"\n");
return;
}
pathData = path.getpath(path.SLOT1D) + path.GetRomNameWithoutExtension();
printf("Path to Slot1 data: %s\n", pathData.c_str());
fs = new FS_NITRO(gameInfo.romdata);
fs->rebuildFAT(pathData);
}
virtual u8 auxspi_transaction(int PROCNUM, u8 value)
{
return g_Slot1Comp_MC.auxspi_transaction(PROCNUM,value);
}
virtual void auxspi_reset(int PROCNUM)
{
g_Slot1Comp_MC.auxspi_reset(PROCNUM);
}
virtual void write_command(u8 PROCNUM, GC_Command command)
{
protocol.write_command(command);
}
virtual void write_GCDATAIN(u8 PROCNUM, u32 val)
{
protocol.write_GCDATAIN(PROCNUM, val);
}
virtual u32 read_GCDATAIN(u8 PROCNUM)
{
return protocol.read_GCDATAIN(PROCNUM);
}
virtual void post_fakeboot(int PROCNUM)
{
// The BIOS leaves the card in NORMAL mode
protocol.mode = eCardMode_NORMAL;
}
virtual void savestate(EMUFILE* os)
{
protocol.savestate(os);
rom.savestate(os);
}
virtual void loadstate(EMUFILE* is)
{
protocol.loadstate(is);
rom.loadstate(is);
}
virtual void slot1client_startOperation(eSlot1Operation operation)
{
if (protocol.operation == eSlot1Operation_B7_Read)
{
u16 file_id = 0xFFFF; u32 offset = 0;
bool bFromFile = false;
if (fs && fs->isFAT(protocol.address))
{
fs->rebuildFAT(protocol.address, protocol.length, pathData);
}
else
{
if (fs && fs->getFileIdByAddr(protocol.address, file_id, offset))
{
if (file_id != curr_file_id)
{
string tmp = fs->getFullPathByFileID(file_id);
printf("%04X:[%08X, ofs %08X] %s\n", file_id, protocol.address, offset, tmp.c_str());
if (fpROM)
{
fclose(fpROM);
fpROM = NULL;
}
tmp = pathData + tmp;
fpROM = fopen(tmp.c_str(), "rb");
if (fpROM)
{
bFromFile = true;
printf("\t * found at disk, offset %08X\n", offset);
if (fseek(fpROM, offset, SEEK_SET) != 0)
{
printf("\t\t - ERROR seek file position\n");
}
}
}
else
{
if (fpROM)
{
bFromFile = true;
if (ftell(fpROM) != offset)
{
printf("\t * new file seek %08Xh\n", offset);
fseek(fpROM, offset, SEEK_SET);
}
}
}
}
}
if (!bFromFile && fpROM)
{
fclose(fpROM);
fpROM = NULL;
}
curr_file_id = file_id;
}
rom.start(operation, protocol.address);
}
private:
u32 slot1client_read_GCDATAIN(eSlot1Operation operation)
{
if (protocol.operation == eSlot1Operation_B7_Read)
{
u32 address = rom.getAddress();
if (fs && fs->isFAT(address))
{
u32 res = fs->getFATRecord(address);
if (res != 0xFFFFFFFF)
{
rom.incAddress();
return res;
}
}
else
if (fpROM)
{
u32 data = 0;
u32 readed = fread(&data, 1, 4, fpROM);
if (readed)
{
rom.incAddress();
if (readed < 4)
data |= ((u32)0xFFFFFFFF << (readed * 8));
return data;
}
fclose(fpROM);
fpROM = NULL;
}
}
return rom.read();
}
};
ISlot1Interface* construct_Slot1_Retail_DEBUG() { return new Slot1_Retail_DEBUG(); }
desmume/src/utils/libfat/file_allocation_table.h 000664 001750 001750 00000005565 12755534123 023217 0 ustar 00sergio sergio 000000 000000 /*
file_allocation_table.h
Reading, writing and manipulation of the FAT structure on
a FAT partition
Copyright (c) 2006 Michael "Chishm" Chisholm
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _FAT_H
#define _FAT_H
#include "common.h"
#include "partition.h"
#define CLUSTER_EOF_16 0xFFFF
#define CLUSTER_EOF 0x0FFFFFFF
#define CLUSTER_FREE 0x00000000
#define CLUSTER_ROOT 0x00000000
#define CLUSTER_FIRST 0x00000002
#define CLUSTER_ERROR 0xFFFFFFFF
#define CLUSTERS_PER_FAT12 4085
#define CLUSTERS_PER_FAT16 65525
#ifdef __cplusplus
extern "C" {
#endif
uint32_t _FAT_fat_nextCluster(PARTITION* partition, uint32_t cluster);
uint32_t _FAT_fat_linkFreeCluster(PARTITION* partition, uint32_t cluster);
uint32_t _FAT_fat_linkFreeClusterCleared (PARTITION* partition, uint32_t cluster);
bool _FAT_fat_clearLinks (PARTITION* partition, uint32_t cluster);
uint32_t _FAT_fat_trimChain (PARTITION* partition, uint32_t startCluster, unsigned int chainLength);
uint32_t _FAT_fat_lastCluster (PARTITION* partition, uint32_t cluster);
unsigned int _FAT_fat_freeClusterCount (PARTITION* partition);
static inline sec_t _FAT_fat_clusterToSector (PARTITION* partition, uint32_t cluster) {
return (cluster >= CLUSTER_FIRST) ?
((cluster - CLUSTER_FIRST) * (sec_t)partition->sectorsPerCluster) + partition->dataStart :
partition->rootDirStart;
}
static inline bool _FAT_fat_isValidCluster (PARTITION* partition, uint32_t cluster) {
return (cluster >= CLUSTER_FIRST) && (cluster <= partition->fat.lastCluster /* This will catch CLUSTER_ERROR */);
}
#ifdef __cplusplus
}
#endif
#endif // _FAT_H
desmume/src/utils/xstring.cpp 000664 001750 001750 00000004577 12755534123 017516 0 ustar 00sergio sergio 000000 000000 //taken from fceux on 10/27/08
//subsequently modified for desmume
/*
Copyright (C) 2008-2009 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#include "xstring.h"
#include
#include
///Sub-String replacement routine
/// \brief convert input string into vector of string tokens
///
/// \note consecutive delimiters will be treated as single delimiter
/// \note delimiters are _not_ included in return data
///
/// \param input string to be parsed
/// \param delims list of delimiters.
std::vector tokenize_str(const std::string & str,
const std::string & delims=", \t")
{
using namespace std;
// Skip delims at beginning, find start of first token
string::size_type lastPos = str.find_first_not_of(delims, 0);
// Find next delimiter @ end of token
string::size_type pos = str.find_first_of(delims, lastPos);
// output vector
vector tokens;
while (string::npos != pos || string::npos != lastPos)
{
// Found a token, add it to the vector.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// Skip delims. Note the "not_of". this is beginning of token
lastPos = str.find_first_not_of(delims, pos);
// Find next delimiter at end of token.
pos = str.find_first_of(delims, lastPos);
}
return tokens;
}
std::string stditoa(int n)
{
char tempbuf[16];
sprintf(tempbuf, "%d", n);
return tempbuf;
}
// replace all instances of victim with replacement
std::string mass_replace(const std::string &source, const std::string &victim, const std::string &replacement)
{
std::string answer = source;
std::string::size_type j = 0;
while ((j = answer.find(victim, j)) != std::string::npos )
{
answer.replace(j, victim.length(), replacement);
j+= replacement.length();
}
return answer;
}
desmume/src/slot2.h 000664 001750 001750 00000011705 12755534123 015357 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2009-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#ifndef __SLOT2_H__
#define __SLOT2_H__
#include
#include "types.h"
#define GBA_SRAM_FILE_EXT "sav"
class EMUFILE;
class Slot2Info
{
public:
virtual const char* name() const = 0;
virtual const char* descr() const = 0;
virtual const u8 id() const = 0;
};
class Slot2InfoSimple : public Slot2Info
{
public:
Slot2InfoSimple(const char* _name, const char* _descr, const u8 _id)
: mName(_name)
, mDescr(_descr)
, mID(_id)
{
}
virtual const char* name() const { return mName; }
virtual const char* descr() const { return mDescr; }
virtual const u8 id() const { return mID; }
private:
const char* mName, *mDescr;
const u8 mID;
};
class ISlot2Interface
{
public:
//called to get info about device (description)
virtual Slot2Info const* info() = 0;
//called once when the emulator starts up, or when the device springs into existence
virtual bool init() { return true; }
//called when the emulator connects the device
virtual void connect() { }
//called when the emulator disconnects the device
virtual void disconnect() { }
//called when the emulator shuts down, or when the device disappears from existence
virtual void shutdown() { }
virtual void writeByte(u8 PROCNUM, u32 addr, u8 val) {};
virtual void writeWord(u8 PROCNUM, u32 addr, u16 val) {};
virtual void writeLong(u8 PROCNUM, u32 addr, u32 val) {};
virtual u8 readByte(u8 PROCNUM, u32 addr) { return 0xFF; };
virtual u16 readWord(u8 PROCNUM, u32 addr) { return 0xFFFF; };
virtual u32 readLong(u8 PROCNUM, u32 addr) { return 0xFFFFFFFF; };
virtual void savestate(EMUFILE* os) {}
virtual void loadstate(EMUFILE* is) {}
};
typedef ISlot2Interface* TISlot2InterfaceConstructor();
enum NDS_SLOT2_TYPE
{
NDS_SLOT2_NONE, // 0xFF
NDS_SLOT2_AUTO, // 0xFE - Auto-select
NDS_SLOT2_CFLASH, // 0x01 - Compact flash
NDS_SLOT2_RUMBLEPAK, // 0x02 - RumblePak
NDS_SLOT2_GBACART, // 0x03 - GBA cartrindge in slot
NDS_SLOT2_GUITARGRIP, // 0x04 - Guitar Grip
NDS_SLOT2_EXPMEMORY, // 0x05 - Memory Expansion Pak
NDS_SLOT2_EASYPIANO, // 0x06 - Easy Piano
NDS_SLOT2_PADDLE, // 0x07 - Arkanoids DS paddle
NDS_SLOT2_PASSME, // 0x08 - PassME/Homebrew
NDS_SLOT2_COUNT // use for counter addons - MUST TO BE LAST!!!
};
extern ISlot2Interface* slot2_device; //the current slot2 device instance
extern ISlot2Interface* slot2_List[NDS_SLOT2_COUNT];
extern NDS_SLOT2_TYPE slot2_selected_type;
void slot2_Init();
bool slot2_Connect();
void slot2_Disconnect();
void slot2_Shutdown();
void slot2_Savestate(EMUFILE* os);
void slot2_Loadstate(EMUFILE* is);
//just disconnects and reconnects the device. ideally, the disconnection and connection would be called with sensible timing
void slot2_Reset();
//change the current device
bool slot2_Change(NDS_SLOT2_TYPE type);
void slot2_setDeviceByType(NDS_SLOT2_TYPE theType);
bool slot2_getTypeByID(u8 ID, NDS_SLOT2_TYPE &type);
//change the current device by ID
bool slot2_ChangeByID(u8 ID);
//check on the current device
NDS_SLOT2_TYPE slot2_GetCurrentType();
NDS_SLOT2_TYPE slot2_GetSelectedType();
//determine which device type is appropriate for the loaded ROM
NDS_SLOT2_TYPE slot2_DetermineType();
NDS_SLOT2_TYPE slot2_DetermineTypeByGameCode(const char *theGameCode);
template
bool slot2_write(u32 addr, T val);
template
bool slot2_read(u32 addr, T &val);
// =================================================================================
extern std::string GBACartridge_RomPath;
extern std::string GBACartridge_SRAMPath;
extern void (*FeedbackON)(bool enable); // feedback on/off
enum ADDON_CFLASH_MODE
{
ADDON_CFLASH_MODE_Path, ADDON_CFLASH_MODE_File, ADDON_CFLASH_MODE_RomPath
};
extern ADDON_CFLASH_MODE CFlash_Mode;
extern std::string CFlash_Path;
inline bool CFlash_IsUsingPath() { return CFlash_Mode==ADDON_CFLASH_MODE_Path || CFlash_Mode==ADDON_CFLASH_MODE_RomPath; }
u16 Paddle_GetValue();
void Paddle_SetValue(u16 theValue);
extern void guitarGrip_setKey(bool green, bool red, bool yellow, bool blue); // Guitar grip keys
extern void piano_setKey(bool c, bool cs, bool d, bool ds, bool e, bool f, bool fs, bool g, bool gs, bool a, bool as, bool b, bool hic); //piano keys
#endif //__SLOT_H__
desmume/src/libretro-common/include/streams/memory_stream.h 000664 001750 001750 00000004244 12755534123 025410 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (memory_stream.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef _LIBRETRO_SDK_FILE_MEMORY_STREAM_H
#define _LIBRETRO_SDK_FILE_MEMORY_STREAM_H
#include
#include
typedef struct memstream memstream_t;
memstream_t *memstream_open(unsigned writing);
void memstream_close(memstream_t *stream);
size_t memstream_read(memstream_t *stream, void *data, size_t bytes);
size_t memstream_write(memstream_t *stream, const void *data, size_t bytes);
int memstream_getc(memstream_t *stream);
void memstream_putc(memstream_t *stream, int c);
char *memstream_gets(memstream_t *stream, char *buffer, size_t len);
size_t memstream_pos(memstream_t *stream);
void memstream_rewind(memstream_t *stream);
int memstream_seek(memstream_t *stream, int offset, int whence);
void memstream_set_buffer(uint8_t *buffer, size_t size);
size_t memstream_get_last_size(void);
#endif
desmume/src/utils/AsmJit/x86/x86defs.cpp 000664 001750 001750 00000353732 12755534123 021123 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
#define ASMJIT_EXPORTS
// [Dependencies - AsmJit]
#include "../x86/x86defs.h"
// [Api-Begin]
#include "../core/apibegin.h"
namespace AsmJit {
// ============================================================================
// [AsmJit::x86InstName]
// ============================================================================
// Following {DATA SECTION} is auto-generated by generate-defs.py tool using
// X86InstInfo data.
//
// ${X86_INST_DATA:BEGIN}
const char x86InstName[] =
"\0"
"adc\0"
"add\0"
"addpd\0"
"addps\0"
"addsd\0"
"addss\0"
"addsubpd\0"
"addsubps\0"
"amd_prefetch\0"
"amd_prefetchw\0"
"and\0"
"andnpd\0"
"andnps\0"
"andpd\0"
"andps\0"
"blendpd\0"
"blendps\0"
"blendvpd\0"
"blendvps\0"
"bsf\0"
"bsr\0"
"bswap\0"
"bt\0"
"btc\0"
"btr\0"
"bts\0"
"call\0"
"cbw\0"
"cdq\0"
"cdqe\0"
"clc\0"
"cld\0"
"clflush\0"
"cmc\0"
"cmova\0"
"cmovae\0"
"cmovb\0"
"cmovbe\0"
"cmovc\0"
"cmove\0"
"cmovg\0"
"cmovge\0"
"cmovl\0"
"cmovle\0"
"cmovna\0"
"cmovnae\0"
"cmovnb\0"
"cmovnbe\0"
"cmovnc\0"
"cmovne\0"
"cmovng\0"
"cmovnge\0"
"cmovnl\0"
"cmovnle\0"
"cmovno\0"
"cmovnp\0"
"cmovns\0"
"cmovnz\0"
"cmovo\0"
"cmovp\0"
"cmovpe\0"
"cmovpo\0"
"cmovs\0"
"cmovz\0"
"cmp\0"
"cmppd\0"
"cmpps\0"
"cmpsd\0"
"cmpss\0"
"cmpxchg\0"
"cmpxchg16b\0"
"cmpxchg8b\0"
"comisd\0"
"comiss\0"
"cpuid\0"
"cqo\0"
"crc32\0"
"cvtdq2pd\0"
"cvtdq2ps\0"
"cvtpd2dq\0"
"cvtpd2pi\0"
"cvtpd2ps\0"
"cvtpi2pd\0"
"cvtpi2ps\0"
"cvtps2dq\0"
"cvtps2pd\0"
"cvtps2pi\0"
"cvtsd2si\0"
"cvtsd2ss\0"
"cvtsi2sd\0"
"cvtsi2ss\0"
"cvtss2sd\0"
"cvtss2si\0"
"cvttpd2dq\0"
"cvttpd2pi\0"
"cvttps2dq\0"
"cvttps2pi\0"
"cvttsd2si\0"
"cvttss2si\0"
"cwd\0"
"cwde\0"
"daa\0"
"das\0"
"dec\0"
"div\0"
"divpd\0"
"divps\0"
"divsd\0"
"divss\0"
"dppd\0"
"dpps\0"
"emms\0"
"enter\0"
"extractps\0"
"f2xm1\0"
"fabs\0"
"fadd\0"
"faddp\0"
"fbld\0"
"fbstp\0"
"fchs\0"
"fclex\0"
"fcmovb\0"
"fcmovbe\0"
"fcmove\0"
"fcmovnb\0"
"fcmovnbe\0"
"fcmovne\0"
"fcmovnu\0"
"fcmovu\0"
"fcom\0"
"fcomi\0"
"fcomip\0"
"fcomp\0"
"fcompp\0"
"fcos\0"
"fdecstp\0"
"fdiv\0"
"fdivp\0"
"fdivr\0"
"fdivrp\0"
"femms\0"
"ffree\0"
"fiadd\0"
"ficom\0"
"ficomp\0"
"fidiv\0"
"fidivr\0"
"fild\0"
"fimul\0"
"fincstp\0"
"finit\0"
"fist\0"
"fistp\0"
"fisttp\0"
"fisub\0"
"fisubr\0"
"fld\0"
"fld1\0"
"fldcw\0"
"fldenv\0"
"fldl2e\0"
"fldl2t\0"
"fldlg2\0"
"fldln2\0"
"fldpi\0"
"fldz\0"
"fmul\0"
"fmulp\0"
"fnclex\0"
"fninit\0"
"fnop\0"
"fnsave\0"
"fnstcw\0"
"fnstenv\0"
"fnstsw\0"
"fpatan\0"
"fprem\0"
"fprem1\0"
"fptan\0"
"frndint\0"
"frstor\0"
"fsave\0"
"fscale\0"
"fsin\0"
"fsincos\0"
"fsqrt\0"
"fst\0"
"fstcw\0"
"fstenv\0"
"fstp\0"
"fstsw\0"
"fsub\0"
"fsubp\0"
"fsubr\0"
"fsubrp\0"
"ftst\0"
"fucom\0"
"fucomi\0"
"fucomip\0"
"fucomp\0"
"fucompp\0"
"fwait\0"
"fxam\0"
"fxch\0"
"fxrstor\0"
"fxsave\0"
"fxtract\0"
"fyl2x\0"
"fyl2xp1\0"
"haddpd\0"
"haddps\0"
"hsubpd\0"
"hsubps\0"
"idiv\0"
"imul\0"
"inc\0"
"int3\0"
"ja\0"
"jae\0"
"jb\0"
"jbe\0"
"jc\0"
"je\0"
"jg\0"
"jge\0"
"jl\0"
"jle\0"
"jna\0"
"jnae\0"
"jnb\0"
"jnbe\0"
"jnc\0"
"jne\0"
"jng\0"
"jnge\0"
"jnl\0"
"jnle\0"
"jno\0"
"jnp\0"
"jns\0"
"jnz\0"
"jo\0"
"jp\0"
"jpe\0"
"jpo\0"
"js\0"
"jz\0"
"jmp\0"
"lddqu\0"
"ldmxcsr\0"
"lahf\0"
"lea\0"
"leave\0"
"lfence\0"
"maskmovdqu\0"
"maskmovq\0"
"maxpd\0"
"maxps\0"
"maxsd\0"
"maxss\0"
"mfence\0"
"minpd\0"
"minps\0"
"minsd\0"
"minss\0"
"monitor\0"
"mov\0"
"movapd\0"
"movaps\0"
"movbe\0"
"movd\0"
"movddup\0"
"movdq2q\0"
"movdqa\0"
"movdqu\0"
"movhlps\0"
"movhpd\0"
"movhps\0"
"movlhps\0"
"movlpd\0"
"movlps\0"
"movmskpd\0"
"movmskps\0"
"movntdq\0"
"movntdqa\0"
"movnti\0"
"movntpd\0"
"movntps\0"
"movntq\0"
"movq\0"
"movq2dq\0"
"movsd\0"
"movshdup\0"
"movsldup\0"
"movss\0"
"movsx\0"
"movsxd\0"
"movupd\0"
"movups\0"
"movzx\0"
"mov_ptr\0"
"mpsadbw\0"
"mul\0"
"mulpd\0"
"mulps\0"
"mulsd\0"
"mulss\0"
"mwait\0"
"neg\0"
"nop\0"
"not\0"
"or\0"
"orpd\0"
"orps\0"
"pabsb\0"
"pabsd\0"
"pabsw\0"
"packssdw\0"
"packsswb\0"
"packusdw\0"
"packuswb\0"
"paddb\0"
"paddd\0"
"paddq\0"
"paddsb\0"
"paddsw\0"
"paddusb\0"
"paddusw\0"
"paddw\0"
"palignr\0"
"pand\0"
"pandn\0"
"pause\0"
"pavgb\0"
"pavgw\0"
"pblendvb\0"
"pblendw\0"
"pcmpeqb\0"
"pcmpeqd\0"
"pcmpeqq\0"
"pcmpeqw\0"
"pcmpestri\0"
"pcmpestrm\0"
"pcmpgtb\0"
"pcmpgtd\0"
"pcmpgtq\0"
"pcmpgtw\0"
"pcmpistri\0"
"pcmpistrm\0"
"pextrb\0"
"pextrd\0"
"pextrq\0"
"pextrw\0"
"pf2id\0"
"pf2iw\0"
"pfacc\0"
"pfadd\0"
"pfcmpeq\0"
"pfcmpge\0"
"pfcmpgt\0"
"pfmax\0"
"pfmin\0"
"pfmul\0"
"pfnacc\0"
"pfpnacc\0"
"pfrcp\0"
"pfrcpit1\0"
"pfrcpit2\0"
"pfrsqit1\0"
"pfrsqrt\0"
"pfsub\0"
"pfsubr\0"
"phaddd\0"
"phaddsw\0"
"phaddw\0"
"phminposuw\0"
"phsubd\0"
"phsubsw\0"
"phsubw\0"
"pi2fd\0"
"pi2fw\0"
"pinsrb\0"
"pinsrd\0"
"pinsrq\0"
"pinsrw\0"
"pmaddubsw\0"
"pmaddwd\0"
"pmaxsb\0"
"pmaxsd\0"
"pmaxsw\0"
"pmaxub\0"
"pmaxud\0"
"pmaxuw\0"
"pminsb\0"
"pminsd\0"
"pminsw\0"
"pminub\0"
"pminud\0"
"pminuw\0"
"pmovmskb\0"
"pmovsxbd\0"
"pmovsxbq\0"
"pmovsxbw\0"
"pmovsxdq\0"
"pmovsxwd\0"
"pmovsxwq\0"
"pmovzxbd\0"
"pmovzxbq\0"
"pmovzxbw\0"
"pmovzxdq\0"
"pmovzxwd\0"
"pmovzxwq\0"
"pmuldq\0"
"pmulhrsw\0"
"pmulhuw\0"
"pmulhw\0"
"pmulld\0"
"pmullw\0"
"pmuludq\0"
"pop\0"
"popad\0"
"popcnt\0"
"popfd\0"
"popfq\0"
"por\0"
"prefetch\0"
"psadbw\0"
"pshufb\0"
"pshufd\0"
"pshufw\0"
"pshufhw\0"
"pshuflw\0"
"psignb\0"
"psignd\0"
"psignw\0"
"pslld\0"
"pslldq\0"
"psllq\0"
"psllw\0"
"psrad\0"
"psraw\0"
"psrld\0"
"psrldq\0"
"psrlq\0"
"psrlw\0"
"psubb\0"
"psubd\0"
"psubq\0"
"psubsb\0"
"psubsw\0"
"psubusb\0"
"psubusw\0"
"psubw\0"
"pswapd\0"
"ptest\0"
"punpckhbw\0"
"punpckhdq\0"
"punpckhqdq\0"
"punpckhwd\0"
"punpcklbw\0"
"punpckldq\0"
"punpcklqdq\0"
"punpcklwd\0"
"push\0"
"pushad\0"
"pushfd\0"
"pushfq\0"
"pxor\0"
"rcl\0"
"rcpps\0"
"rcpss\0"
"rcr\0"
"rdtsc\0"
"rdtscp\0"
"rep lodsb\0"
"rep lodsd\0"
"rep lodsq\0"
"rep lodsw\0"
"rep movsb\0"
"rep movsd\0"
"rep movsq\0"
"rep movsw\0"
"rep stosb\0"
"rep stosd\0"
"rep stosq\0"
"rep stosw\0"
"repe cmpsb\0"
"repe cmpsd\0"
"repe cmpsq\0"
"repe cmpsw\0"
"repe scasb\0"
"repe scasd\0"
"repe scasq\0"
"repe scasw\0"
"repne cmpsb\0"
"repne cmpsd\0"
"repne cmpsq\0"
"repne cmpsw\0"
"repne scasb\0"
"repne scasd\0"
"repne scasq\0"
"repne scasw\0"
"ret\0"
"rol\0"
"ror\0"
"roundpd\0"
"roundps\0"
"roundsd\0"
"roundss\0"
"rsqrtps\0"
"rsqrtss\0"
"sahf\0"
"sal\0"
"sar\0"
"sbb\0"
"seta\0"
"setae\0"
"setb\0"
"setbe\0"
"setc\0"
"sete\0"
"setg\0"
"setge\0"
"setl\0"
"setle\0"
"setna\0"
"setnae\0"
"setnb\0"
"setnbe\0"
"setnc\0"
"setne\0"
"setng\0"
"setnge\0"
"setnl\0"
"setnle\0"
"setno\0"
"setnp\0"
"setns\0"
"setnz\0"
"seto\0"
"setp\0"
"setpe\0"
"setpo\0"
"sets\0"
"setz\0"
"sfence\0"
"shl\0"
"shld\0"
"shr\0"
"shrd\0"
"shufpd\0"
"shufps\0"
"sqrtpd\0"
"sqrtps\0"
"sqrtsd\0"
"sqrtss\0"
"stc\0"
"std\0"
"stmxcsr\0"
"sub\0"
"subpd\0"
"subps\0"
"subsd\0"
"subss\0"
"test\0"
"ucomisd\0"
"ucomiss\0"
"ud2\0"
"unpckhpd\0"
"unpckhps\0"
"unpcklpd\0"
"unpcklps\0"
"xadd\0"
"xchg\0"
"xor\0"
"xorpd\0"
"xorps\0"
;
#define INDEX_kInstNone 0
#define INDEX_kX86InstAdc 1
#define INDEX_kX86InstAdd 5
#define INDEX_kX86InstAddPD 9
#define INDEX_kX86InstAddPS 15
#define INDEX_kX86InstAddSD 21
#define INDEX_kX86InstAddSS 27
#define INDEX_kX86InstAddSubPD 33
#define INDEX_kX86InstAddSubPS 42
#define INDEX_kX86InstAmdPrefetch 51
#define INDEX_kX86InstAmdPrefetchW 64
#define INDEX_kX86InstAnd 78
#define INDEX_kX86InstAndnPD 82
#define INDEX_kX86InstAndnPS 89
#define INDEX_kX86InstAndPD 96
#define INDEX_kX86InstAndPS 102
#define INDEX_kX86InstBlendPD 108
#define INDEX_kX86InstBlendPS 116
#define INDEX_kX86InstBlendVPD 124
#define INDEX_kX86InstBlendVPS 133
#define INDEX_kX86InstBsf 142
#define INDEX_kX86InstBsr 146
#define INDEX_kX86InstBSwap 150
#define INDEX_kX86InstBt 156
#define INDEX_kX86InstBtc 159
#define INDEX_kX86InstBtr 163
#define INDEX_kX86InstBts 167
#define INDEX_kX86InstCall 171
#define INDEX_kX86InstCbw 176
#define INDEX_kX86InstCdq 180
#define INDEX_kX86InstCdqe 184
#define INDEX_kX86InstClc 189
#define INDEX_kX86InstCld 193
#define INDEX_kX86InstClFlush 197
#define INDEX_kX86InstCmc 205
#define INDEX_kX86InstCMovA 209
#define INDEX_kX86InstCMovAE 215
#define INDEX_kX86InstCMovB 222
#define INDEX_kX86InstCMovBE 228
#define INDEX_kX86InstCMovC 235
#define INDEX_kX86InstCMovE 241
#define INDEX_kX86InstCMovG 247
#define INDEX_kX86InstCMovGE 253
#define INDEX_kX86InstCMovL 260
#define INDEX_kX86InstCMovLE 266
#define INDEX_kX86InstCMovNA 273
#define INDEX_kX86InstCMovNAE 280
#define INDEX_kX86InstCMovNB 288
#define INDEX_kX86InstCMovNBE 295
#define INDEX_kX86InstCMovNC 303
#define INDEX_kX86InstCMovNE 310
#define INDEX_kX86InstCMovNG 317
#define INDEX_kX86InstCMovNGE 324
#define INDEX_kX86InstCMovNL 332
#define INDEX_kX86InstCMovNLE 339
#define INDEX_kX86InstCMovNO 347
#define INDEX_kX86InstCMovNP 354
#define INDEX_kX86InstCMovNS 361
#define INDEX_kX86InstCMovNZ 368
#define INDEX_kX86InstCMovO 375
#define INDEX_kX86InstCMovP 381
#define INDEX_kX86InstCMovPE 387
#define INDEX_kX86InstCMovPO 394
#define INDEX_kX86InstCMovS 401
#define INDEX_kX86InstCMovZ 407
#define INDEX_kX86InstCmp 413
#define INDEX_kX86InstCmpPD 417
#define INDEX_kX86InstCmpPS 423
#define INDEX_kX86InstCmpSD 429
#define INDEX_kX86InstCmpSS 435
#define INDEX_kX86InstCmpXCHG 441
#define INDEX_kX86InstCmpXCHG16B 449
#define INDEX_kX86InstCmpXCHG8B 460
#define INDEX_kX86InstComISD 470
#define INDEX_kX86InstComISS 477
#define INDEX_kX86InstCpuId 484
#define INDEX_kX86InstCqo 490
#define INDEX_kX86InstCrc32 494
#define INDEX_kX86InstCvtDQ2PD 500
#define INDEX_kX86InstCvtDQ2PS 509
#define INDEX_kX86InstCvtPD2DQ 518
#define INDEX_kX86InstCvtPD2PI 527
#define INDEX_kX86InstCvtPD2PS 536
#define INDEX_kX86InstCvtPI2PD 545
#define INDEX_kX86InstCvtPI2PS 554
#define INDEX_kX86InstCvtPS2DQ 563
#define INDEX_kX86InstCvtPS2PD 572
#define INDEX_kX86InstCvtPS2PI 581
#define INDEX_kX86InstCvtSD2SI 590
#define INDEX_kX86InstCvtSD2SS 599
#define INDEX_kX86InstCvtSI2SD 608
#define INDEX_kX86InstCvtSI2SS 617
#define INDEX_kX86InstCvtSS2SD 626
#define INDEX_kX86InstCvtSS2SI 635
#define INDEX_kX86InstCvttPD2DQ 644
#define INDEX_kX86InstCvttPD2PI 654
#define INDEX_kX86InstCvttPS2DQ 664
#define INDEX_kX86InstCvttPS2PI 674
#define INDEX_kX86InstCvttSD2SI 684
#define INDEX_kX86InstCvttSS2SI 694
#define INDEX_kX86InstCwd 704
#define INDEX_kX86InstCwde 708
#define INDEX_kX86InstDaa 713
#define INDEX_kX86InstDas 717
#define INDEX_kX86InstDec 721
#define INDEX_kX86InstDiv 725
#define INDEX_kX86InstDivPD 729
#define INDEX_kX86InstDivPS 735
#define INDEX_kX86InstDivSD 741
#define INDEX_kX86InstDivSS 747
#define INDEX_kX86InstDpPD 753
#define INDEX_kX86InstDpPS 758
#define INDEX_kX86InstEmms 763
#define INDEX_kX86InstEnter 768
#define INDEX_kX86InstExtractPS 774
#define INDEX_kX86InstF2XM1 784
#define INDEX_kX86InstFAbs 790
#define INDEX_kX86InstFAdd 795
#define INDEX_kX86InstFAddP 800
#define INDEX_kX86InstFBLd 806
#define INDEX_kX86InstFBStP 811
#define INDEX_kX86InstFCHS 817
#define INDEX_kX86InstFClex 822
#define INDEX_kX86InstFCMovB 828
#define INDEX_kX86InstFCMovBE 835
#define INDEX_kX86InstFCMovE 843
#define INDEX_kX86InstFCMovNB 850
#define INDEX_kX86InstFCMovNBE 858
#define INDEX_kX86InstFCMovNE 867
#define INDEX_kX86InstFCMovNU 875
#define INDEX_kX86InstFCMovU 883
#define INDEX_kX86InstFCom 890
#define INDEX_kX86InstFComI 895
#define INDEX_kX86InstFComIP 901
#define INDEX_kX86InstFComP 908
#define INDEX_kX86InstFComPP 914
#define INDEX_kX86InstFCos 921
#define INDEX_kX86InstFDecStP 926
#define INDEX_kX86InstFDiv 934
#define INDEX_kX86InstFDivP 939
#define INDEX_kX86InstFDivR 945
#define INDEX_kX86InstFDivRP 951
#define INDEX_kX86InstFEmms 958
#define INDEX_kX86InstFFree 964
#define INDEX_kX86InstFIAdd 970
#define INDEX_kX86InstFICom 976
#define INDEX_kX86InstFIComP 982
#define INDEX_kX86InstFIDiv 989
#define INDEX_kX86InstFIDivR 995
#define INDEX_kX86InstFILd 1002
#define INDEX_kX86InstFIMul 1007
#define INDEX_kX86InstFIncStP 1013
#define INDEX_kX86InstFInit 1021
#define INDEX_kX86InstFISt 1027
#define INDEX_kX86InstFIStP 1032
#define INDEX_kX86InstFISttP 1038
#define INDEX_kX86InstFISub 1045
#define INDEX_kX86InstFISubR 1051
#define INDEX_kX86InstFLd 1058
#define INDEX_kX86InstFLd1 1062
#define INDEX_kX86InstFLdCw 1067
#define INDEX_kX86InstFLdEnv 1073
#define INDEX_kX86InstFLdL2E 1080
#define INDEX_kX86InstFLdL2T 1087
#define INDEX_kX86InstFLdLg2 1094
#define INDEX_kX86InstFLdLn2 1101
#define INDEX_kX86InstFLdPi 1108
#define INDEX_kX86InstFLdZ 1114
#define INDEX_kX86InstFMul 1119
#define INDEX_kX86InstFMulP 1124
#define INDEX_kX86InstFNClex 1130
#define INDEX_kX86InstFNInit 1137
#define INDEX_kX86InstFNop 1144
#define INDEX_kX86InstFNSave 1149
#define INDEX_kX86InstFNStCw 1156
#define INDEX_kX86InstFNStEnv 1163
#define INDEX_kX86InstFNStSw 1171
#define INDEX_kX86InstFPAtan 1178
#define INDEX_kX86InstFPRem 1185
#define INDEX_kX86InstFPRem1 1191
#define INDEX_kX86InstFPTan 1198
#define INDEX_kX86InstFRndInt 1204
#define INDEX_kX86InstFRstor 1212
#define INDEX_kX86InstFSave 1219
#define INDEX_kX86InstFScale 1225
#define INDEX_kX86InstFSin 1232
#define INDEX_kX86InstFSinCos 1237
#define INDEX_kX86InstFSqrt 1245
#define INDEX_kX86InstFSt 1251
#define INDEX_kX86InstFStCw 1255
#define INDEX_kX86InstFStEnv 1261
#define INDEX_kX86InstFStP 1268
#define INDEX_kX86InstFStSw 1273
#define INDEX_kX86InstFSub 1279
#define INDEX_kX86InstFSubP 1284
#define INDEX_kX86InstFSubR 1290
#define INDEX_kX86InstFSubRP 1296
#define INDEX_kX86InstFTst 1303
#define INDEX_kX86InstFUCom 1308
#define INDEX_kX86InstFUComI 1314
#define INDEX_kX86InstFUComIP 1321
#define INDEX_kX86InstFUComP 1329
#define INDEX_kX86InstFUComPP 1336
#define INDEX_kX86InstFWait 1344
#define INDEX_kX86InstFXam 1350
#define INDEX_kX86InstFXch 1355
#define INDEX_kX86InstFXRstor 1360
#define INDEX_kX86InstFXSave 1368
#define INDEX_kX86InstFXtract 1375
#define INDEX_kX86InstFYL2X 1383
#define INDEX_kX86InstFYL2XP1 1389
#define INDEX_kX86InstHAddPD 1397
#define INDEX_kX86InstHAddPS 1404
#define INDEX_kX86InstHSubPD 1411
#define INDEX_kX86InstHSubPS 1418
#define INDEX_kX86InstIDiv 1425
#define INDEX_kX86InstIMul 1430
#define INDEX_kX86InstInc 1435
#define INDEX_kX86InstInt3 1439
#define INDEX_kX86InstJA 1444
#define INDEX_kX86InstJAE 1447
#define INDEX_kX86InstJB 1451
#define INDEX_kX86InstJBE 1454
#define INDEX_kX86InstJC 1458
#define INDEX_kX86InstJE 1461
#define INDEX_kX86InstJG 1464
#define INDEX_kX86InstJGE 1467
#define INDEX_kX86InstJL 1471
#define INDEX_kX86InstJLE 1474
#define INDEX_kX86InstJNA 1478
#define INDEX_kX86InstJNAE 1482
#define INDEX_kX86InstJNB 1487
#define INDEX_kX86InstJNBE 1491
#define INDEX_kX86InstJNC 1496
#define INDEX_kX86InstJNE 1500
#define INDEX_kX86InstJNG 1504
#define INDEX_kX86InstJNGE 1508
#define INDEX_kX86InstJNL 1513
#define INDEX_kX86InstJNLE 1517
#define INDEX_kX86InstJNO 1522
#define INDEX_kX86InstJNP 1526
#define INDEX_kX86InstJNS 1530
#define INDEX_kX86InstJNZ 1534
#define INDEX_kX86InstJO 1538
#define INDEX_kX86InstJP 1541
#define INDEX_kX86InstJPE 1544
#define INDEX_kX86InstJPO 1548
#define INDEX_kX86InstJS 1552
#define INDEX_kX86InstJZ 1555
#define INDEX_kX86InstJmp 1558
#define INDEX_kX86InstLdDQU 1562
#define INDEX_kX86InstLdMXCSR 1568
#define INDEX_kX86InstLahf 1576
#define INDEX_kX86InstLea 1581
#define INDEX_kX86InstLeave 1585
#define INDEX_kX86InstLFence 1591
#define INDEX_kX86InstMaskMovDQU 1598
#define INDEX_kX86InstMaskMovQ 1609
#define INDEX_kX86InstMaxPD 1618
#define INDEX_kX86InstMaxPS 1624
#define INDEX_kX86InstMaxSD 1630
#define INDEX_kX86InstMaxSS 1636
#define INDEX_kX86InstMFence 1642
#define INDEX_kX86InstMinPD 1649
#define INDEX_kX86InstMinPS 1655
#define INDEX_kX86InstMinSD 1661
#define INDEX_kX86InstMinSS 1667
#define INDEX_kX86InstMonitor 1673
#define INDEX_kX86InstMov 1681
#define INDEX_kX86InstMovAPD 1685
#define INDEX_kX86InstMovAPS 1692
#define INDEX_kX86InstMovBE 1699
#define INDEX_kX86InstMovD 1705
#define INDEX_kX86InstMovDDup 1710
#define INDEX_kX86InstMovDQ2Q 1718
#define INDEX_kX86InstMovDQA 1726
#define INDEX_kX86InstMovDQU 1733
#define INDEX_kX86InstMovHLPS 1740
#define INDEX_kX86InstMovHPD 1748
#define INDEX_kX86InstMovHPS 1755
#define INDEX_kX86InstMovLHPS 1762
#define INDEX_kX86InstMovLPD 1770
#define INDEX_kX86InstMovLPS 1777
#define INDEX_kX86InstMovMskPD 1784
#define INDEX_kX86InstMovMskPS 1793
#define INDEX_kX86InstMovNTDQ 1802
#define INDEX_kX86InstMovNTDQA 1810
#define INDEX_kX86InstMovNTI 1819
#define INDEX_kX86InstMovNTPD 1826
#define INDEX_kX86InstMovNTPS 1834
#define INDEX_kX86InstMovNTQ 1842
#define INDEX_kX86InstMovQ 1849
#define INDEX_kX86InstMovQ2DQ 1854
#define INDEX_kX86InstMovSD 1862
#define INDEX_kX86InstMovSHDup 1868
#define INDEX_kX86InstMovSLDup 1877
#define INDEX_kX86InstMovSS 1886
#define INDEX_kX86InstMovSX 1892
#define INDEX_kX86InstMovSXD 1898
#define INDEX_kX86InstMovUPD 1905
#define INDEX_kX86InstMovUPS 1912
#define INDEX_kX86InstMovZX 1919
#define INDEX_kX86InstMovPtr 1925
#define INDEX_kX86InstMPSADBW 1933
#define INDEX_kX86InstMul 1941
#define INDEX_kX86InstMulPD 1945
#define INDEX_kX86InstMulPS 1951
#define INDEX_kX86InstMulSD 1957
#define INDEX_kX86InstMulSS 1963
#define INDEX_kX86InstMWait 1969
#define INDEX_kX86InstNeg 1975
#define INDEX_kX86InstNop 1979
#define INDEX_kX86InstNot 1983
#define INDEX_kX86InstOr 1987
#define INDEX_kX86InstOrPD 1990
#define INDEX_kX86InstOrPS 1995
#define INDEX_kX86InstPAbsB 2000
#define INDEX_kX86InstPAbsD 2006
#define INDEX_kX86InstPAbsW 2012
#define INDEX_kX86InstPackSSDW 2018
#define INDEX_kX86InstPackSSWB 2027
#define INDEX_kX86InstPackUSDW 2036
#define INDEX_kX86InstPackUSWB 2045
#define INDEX_kX86InstPAddB 2054
#define INDEX_kX86InstPAddD 2060
#define INDEX_kX86InstPAddQ 2066
#define INDEX_kX86InstPAddSB 2072
#define INDEX_kX86InstPAddSW 2079
#define INDEX_kX86InstPAddUSB 2086
#define INDEX_kX86InstPAddUSW 2094
#define INDEX_kX86InstPAddW 2102
#define INDEX_kX86InstPAlignR 2108
#define INDEX_kX86InstPAnd 2116
#define INDEX_kX86InstPAndN 2121
#define INDEX_kX86InstPause 2127
#define INDEX_kX86InstPAvgB 2133
#define INDEX_kX86InstPAvgW 2139
#define INDEX_kX86InstPBlendVB 2145
#define INDEX_kX86InstPBlendW 2154
#define INDEX_kX86InstPCmpEqB 2162
#define INDEX_kX86InstPCmpEqD 2170
#define INDEX_kX86InstPCmpEqQ 2178
#define INDEX_kX86InstPCmpEqW 2186
#define INDEX_kX86InstPCmpEStrI 2194
#define INDEX_kX86InstPCmpEStrM 2204
#define INDEX_kX86InstPCmpGtB 2214
#define INDEX_kX86InstPCmpGtD 2222
#define INDEX_kX86InstPCmpGtQ 2230
#define INDEX_kX86InstPCmpGtW 2238
#define INDEX_kX86InstPCmpIStrI 2246
#define INDEX_kX86InstPCmpIStrM 2256
#define INDEX_kX86InstPExtrB 2266
#define INDEX_kX86InstPExtrD 2273
#define INDEX_kX86InstPExtrQ 2280
#define INDEX_kX86InstPExtrW 2287
#define INDEX_kX86InstPF2ID 2294
#define INDEX_kX86InstPF2IW 2300
#define INDEX_kX86InstPFAcc 2306
#define INDEX_kX86InstPFAdd 2312
#define INDEX_kX86InstPFCmpEQ 2318
#define INDEX_kX86InstPFCmpGE 2326
#define INDEX_kX86InstPFCmpGT 2334
#define INDEX_kX86InstPFMax 2342
#define INDEX_kX86InstPFMin 2348
#define INDEX_kX86InstPFMul 2354
#define INDEX_kX86InstPFNAcc 2360
#define INDEX_kX86InstPFPNAcc 2367
#define INDEX_kX86InstPFRcp 2375
#define INDEX_kX86InstPFRcpIt1 2381
#define INDEX_kX86InstPFRcpIt2 2390
#define INDEX_kX86InstPFRSqIt1 2399
#define INDEX_kX86InstPFRSqrt 2408
#define INDEX_kX86InstPFSub 2416
#define INDEX_kX86InstPFSubR 2422
#define INDEX_kX86InstPHAddD 2429
#define INDEX_kX86InstPHAddSW 2436
#define INDEX_kX86InstPHAddW 2444
#define INDEX_kX86InstPHMinPOSUW 2451
#define INDEX_kX86InstPHSubD 2462
#define INDEX_kX86InstPHSubSW 2469
#define INDEX_kX86InstPHSubW 2477
#define INDEX_kX86InstPI2FD 2484
#define INDEX_kX86InstPI2FW 2490
#define INDEX_kX86InstPInsRB 2496
#define INDEX_kX86InstPInsRD 2503
#define INDEX_kX86InstPInsRQ 2510
#define INDEX_kX86InstPInsRW 2517
#define INDEX_kX86InstPMAddUBSW 2524
#define INDEX_kX86InstPMAddWD 2534
#define INDEX_kX86InstPMaxSB 2542
#define INDEX_kX86InstPMaxSD 2549
#define INDEX_kX86InstPMaxSW 2556
#define INDEX_kX86InstPMaxUB 2563
#define INDEX_kX86InstPMaxUD 2570
#define INDEX_kX86InstPMaxUW 2577
#define INDEX_kX86InstPMinSB 2584
#define INDEX_kX86InstPMinSD 2591
#define INDEX_kX86InstPMinSW 2598
#define INDEX_kX86InstPMinUB 2605
#define INDEX_kX86InstPMinUD 2612
#define INDEX_kX86InstPMinUW 2619
#define INDEX_kX86InstPMovMskB 2626
#define INDEX_kX86InstPMovSXBD 2635
#define INDEX_kX86InstPMovSXBQ 2644
#define INDEX_kX86InstPMovSXBW 2653
#define INDEX_kX86InstPMovSXDQ 2662
#define INDEX_kX86InstPMovSXWD 2671
#define INDEX_kX86InstPMovSXWQ 2680
#define INDEX_kX86InstPMovZXBD 2689
#define INDEX_kX86InstPMovZXBQ 2698
#define INDEX_kX86InstPMovZXBW 2707
#define INDEX_kX86InstPMovZXDQ 2716
#define INDEX_kX86InstPMovZXWD 2725
#define INDEX_kX86InstPMovZXWQ 2734
#define INDEX_kX86InstPMulDQ 2743
#define INDEX_kX86InstPMulHRSW 2750
#define INDEX_kX86InstPMulHUW 2759
#define INDEX_kX86InstPMulHW 2767
#define INDEX_kX86InstPMulLD 2774
#define INDEX_kX86InstPMulLW 2781
#define INDEX_kX86InstPMulUDQ 2788
#define INDEX_kX86InstPop 2796
#define INDEX_kX86InstPopAD 2800
#define INDEX_kX86InstPopCnt 2806
#define INDEX_kX86InstPopFD 2813
#define INDEX_kX86InstPopFQ 2819
#define INDEX_kX86InstPOr 2825
#define INDEX_kX86InstPrefetch 2829
#define INDEX_kX86InstPSADBW 2838
#define INDEX_kX86InstPShufB 2845
#define INDEX_kX86InstPShufD 2852
#define INDEX_kX86InstPShufW 2859
#define INDEX_kX86InstPShufHW 2866
#define INDEX_kX86InstPShufLW 2874
#define INDEX_kX86InstPSignB 2882
#define INDEX_kX86InstPSignD 2889
#define INDEX_kX86InstPSignW 2896
#define INDEX_kX86InstPSllD 2903
#define INDEX_kX86InstPSllDQ 2909
#define INDEX_kX86InstPSllQ 2916
#define INDEX_kX86InstPSllW 2922
#define INDEX_kX86InstPSraD 2928
#define INDEX_kX86InstPSraW 2934
#define INDEX_kX86InstPSrlD 2940
#define INDEX_kX86InstPSrlDQ 2946
#define INDEX_kX86InstPSrlQ 2953
#define INDEX_kX86InstPSrlW 2959
#define INDEX_kX86InstPSubB 2965
#define INDEX_kX86InstPSubD 2971
#define INDEX_kX86InstPSubQ 2977
#define INDEX_kX86InstPSubSB 2983
#define INDEX_kX86InstPSubSW 2990
#define INDEX_kX86InstPSubUSB 2997
#define INDEX_kX86InstPSubUSW 3005
#define INDEX_kX86InstPSubW 3013
#define INDEX_kX86InstPSwapD 3019
#define INDEX_kX86InstPTest 3026
#define INDEX_kX86InstPunpckHBW 3032
#define INDEX_kX86InstPunpckHDQ 3042
#define INDEX_kX86InstPunpckHQDQ 3052
#define INDEX_kX86InstPunpckHWD 3063
#define INDEX_kX86InstPunpckLBW 3073
#define INDEX_kX86InstPunpckLDQ 3083
#define INDEX_kX86InstPunpckLQDQ 3093
#define INDEX_kX86InstPunpckLWD 3104
#define INDEX_kX86InstPush 3114
#define INDEX_kX86InstPushAD 3119
#define INDEX_kX86InstPushFD 3126
#define INDEX_kX86InstPushFQ 3133
#define INDEX_kX86InstPXor 3140
#define INDEX_kX86InstRcl 3145
#define INDEX_kX86InstRcpPS 3149
#define INDEX_kX86InstRcpSS 3155
#define INDEX_kX86InstRcr 3161
#define INDEX_kX86InstRdtsc 3165
#define INDEX_kX86InstRdtscP 3171
#define INDEX_kX86InstRepLodSB 3178
#define INDEX_kX86InstRepLodSD 3188
#define INDEX_kX86InstRepLodSQ 3198
#define INDEX_kX86InstRepLodSW 3208
#define INDEX_kX86InstRepMovSB 3218
#define INDEX_kX86InstRepMovSD 3228
#define INDEX_kX86InstRepMovSQ 3238
#define INDEX_kX86InstRepMovSW 3248
#define INDEX_kX86InstRepStoSB 3258
#define INDEX_kX86InstRepStoSD 3268
#define INDEX_kX86InstRepStoSQ 3278
#define INDEX_kX86InstRepStoSW 3288
#define INDEX_kX86InstRepECmpSB 3298
#define INDEX_kX86InstRepECmpSD 3309
#define INDEX_kX86InstRepECmpSQ 3320
#define INDEX_kX86InstRepECmpSW 3331
#define INDEX_kX86InstRepEScaSB 3342
#define INDEX_kX86InstRepEScaSD 3353
#define INDEX_kX86InstRepEScaSQ 3364
#define INDEX_kX86InstRepEScaSW 3375
#define INDEX_kX86InstRepNECmpSB 3386
#define INDEX_kX86InstRepNECmpSD 3398
#define INDEX_kX86InstRepNECmpSQ 3410
#define INDEX_kX86InstRepNECmpSW 3422
#define INDEX_kX86InstRepNEScaSB 3434
#define INDEX_kX86InstRepNEScaSD 3446
#define INDEX_kX86InstRepNEScaSQ 3458
#define INDEX_kX86InstRepNEScaSW 3470
#define INDEX_kX86InstRet 3482
#define INDEX_kX86InstRol 3486
#define INDEX_kX86InstRor 3490
#define INDEX_kX86InstRoundPD 3494
#define INDEX_kX86InstRoundPS 3502
#define INDEX_kX86InstRoundSD 3510
#define INDEX_kX86InstRoundSS 3518
#define INDEX_kX86InstRSqrtPS 3526
#define INDEX_kX86InstRSqrtSS 3534
#define INDEX_kX86InstSahf 3542
#define INDEX_kX86InstSal 3547
#define INDEX_kX86InstSar 3551
#define INDEX_kX86InstSbb 3555
#define INDEX_kX86InstSetA 3559
#define INDEX_kX86InstSetAE 3564
#define INDEX_kX86InstSetB 3570
#define INDEX_kX86InstSetBE 3575
#define INDEX_kX86InstSetC 3581
#define INDEX_kX86InstSetE 3586
#define INDEX_kX86InstSetG 3591
#define INDEX_kX86InstSetGE 3596
#define INDEX_kX86InstSetL 3602
#define INDEX_kX86InstSetLE 3607
#define INDEX_kX86InstSetNA 3613
#define INDEX_kX86InstSetNAE 3619
#define INDEX_kX86InstSetNB 3626
#define INDEX_kX86InstSetNBE 3632
#define INDEX_kX86InstSetNC 3639
#define INDEX_kX86InstSetNE 3645
#define INDEX_kX86InstSetNG 3651
#define INDEX_kX86InstSetNGE 3657
#define INDEX_kX86InstSetNL 3664
#define INDEX_kX86InstSetNLE 3670
#define INDEX_kX86InstSetNO 3677
#define INDEX_kX86InstSetNP 3683
#define INDEX_kX86InstSetNS 3689
#define INDEX_kX86InstSetNZ 3695
#define INDEX_kX86InstSetO 3701
#define INDEX_kX86InstSetP 3706
#define INDEX_kX86InstSetPE 3711
#define INDEX_kX86InstSetPO 3717
#define INDEX_kX86InstSetS 3723
#define INDEX_kX86InstSetZ 3728
#define INDEX_kX86InstSFence 3733
#define INDEX_kX86InstShl 3740
#define INDEX_kX86InstShld 3744
#define INDEX_kX86InstShr 3749
#define INDEX_kX86InstShrd 3753
#define INDEX_kX86InstShufPD 3758
#define INDEX_kX86InstShufPS 3765
#define INDEX_kX86InstSqrtPD 3772
#define INDEX_kX86InstSqrtPS 3779
#define INDEX_kX86InstSqrtSD 3786
#define INDEX_kX86InstSqrtSS 3793
#define INDEX_kX86InstStc 3800
#define INDEX_kX86InstStd 3804
#define INDEX_kX86InstStMXCSR 3808
#define INDEX_kX86InstSub 3816
#define INDEX_kX86InstSubPD 3820
#define INDEX_kX86InstSubPS 3826
#define INDEX_kX86InstSubSD 3832
#define INDEX_kX86InstSubSS 3838
#define INDEX_kX86InstTest 3844
#define INDEX_kX86InstUComISD 3849
#define INDEX_kX86InstUComISS 3857
#define INDEX_kX86InstUd2 3865
#define INDEX_kX86InstUnpckHPD 3869
#define INDEX_kX86InstUnpckHPS 3878
#define INDEX_kX86InstUnpckLPD 3887
#define INDEX_kX86InstUnpckLPS 3896
#define INDEX_kX86InstXadd 3905
#define INDEX_kX86InstXchg 3910
#define INDEX_kX86InstXor 3915
#define INDEX_kX86InstXorPD 3919
#define INDEX_kX86InstXorPS 3925
// ${X86_INST_DATA:END}
// ============================================================================
// [AsmJit::x86InstInfo]
// ============================================================================
#define INST(_Code_, _Name_, _Group_, _Flags_, _OpFlags0_, _OpFlags1_, _OpReg_, _OpCode0_, _OpCode1_) \
{ _Code_, INDEX_##_Code_, _Group_, _Flags_, { _OpFlags0_, _OpFlags1_ }, _OpReg_, { _OpCode0_, _OpCode1_ } }
#define G(_Group_) kX86InstGroup##_Group_
#define F(_Flags_) kX86InstFlag##_Flags_
#define O(_Op_) kX86InstOp##_Op_
const X86InstInfo x86InstInfo[] =
{
// Instruction code | Instruction name | Instruction group| Instruction flags| Operand flags[0] | Operand flags[1] | r| opCode[0] | opcode[1]
INST(kInstNone , "" , G(None) , F(None) , 0 , 0 , 0, 0 , 0),
INST(kX86InstAdc , "adc" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 2, 0x00000010, 0x00000080),
INST(kX86InstAdd , "add" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 0, 0x00000000, 0x00000080),
INST(kX86InstAddPD , "addpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F58, 0),
INST(kX86InstAddPS , "addps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F58, 0),
INST(kX86InstAddSD , "addsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F58, 0),
INST(kX86InstAddSS , "addss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F58, 0),
INST(kX86InstAddSubPD , "addsubpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000FD0, 0),
INST(kX86InstAddSubPS , "addsubps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000FD0, 0),
INST(kX86InstAmdPrefetch , "amd_prefetch" , G(Mem) , F(None) , O(Mem) , 0 , 0, 0x00000F0D, 0),
INST(kX86InstAmdPrefetchW , "amd_prefetchw" , G(Mem) , F(None) , O(Mem) , 0 , 1, 0x00000F0D, 0),
INST(kX86InstAnd , "and" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 4, 0x00000020, 0x00000080),
INST(kX86InstAndnPD , "andnpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F55, 0),
INST(kX86InstAndnPS , "andnps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F55, 0),
INST(kX86InstAndPD , "andpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F54, 0),
INST(kX86InstAndPS , "andps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F54, 0),
INST(kX86InstBlendPD , "blendpd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A0D, 0),
INST(kX86InstBlendPS , "blendps" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A0C, 0),
INST(kX86InstBlendVPD , "blendvpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3815, 0),
INST(kX86InstBlendVPS , "blendvps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3814, 0),
INST(kX86InstBsf , "bsf" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000FBC, 0),
INST(kX86InstBsr , "bsr" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000FBD, 0),
INST(kX86InstBSwap , "bswap" , G(BSwap) , F(None) , O(Gqd) , 0 , 0, 0 , 0),
INST(kX86InstBt , "bt" , G(BTest) , F(None) , O(Gqdw)|O(Mem) , O(Gqdw)|O(Imm) , 4, 0x00000FA3, 0x00000FBA),
INST(kX86InstBtc , "btc" , G(BTest) , F(Lockable) , O(Gqdw)|O(Mem) , O(Gqdw)|O(Imm) , 7, 0x00000FBB, 0x00000FBA),
INST(kX86InstBtr , "btr" , G(BTest) , F(Lockable) , O(Gqdw)|O(Mem) , O(Gqdw)|O(Imm) , 6, 0x00000FB3, 0x00000FBA),
INST(kX86InstBts , "bts" , G(BTest) , F(Lockable) , O(Gqdw)|O(Mem) , O(Gqdw)|O(Imm) , 5, 0x00000FAB, 0x00000FBA),
INST(kX86InstCall , "call" , G(Call) , F(Jump) , O(Gqd) |O(Mem) , 0 , 0, 0 , 0),
INST(kX86InstCbw , "cbw" , G(Emit) , F(Special) , 0 , 0 , 0, 0x66000098, 0),
INST(kX86InstCdq , "cdq" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000099, 0),
INST(kX86InstCdqe , "cdqe" , G(Emit) , F(Special) , 0 , 0 , 0, 0x48000098, 0),
INST(kX86InstClc , "clc" , G(Emit) , F(None) , 0 , 0 , 0, 0x000000F8, 0),
INST(kX86InstCld , "cld" , G(Emit) , F(None) , 0 , 0 , 0, 0x000000FC, 0),
INST(kX86InstClFlush , "clflush" , G(Mem) , F(None) , O(Mem) , 0 , 7, 0x00000FAE, 0),
INST(kX86InstCmc , "cmc" , G(Emit) , F(None) , 0 , 0 , 0, 0x000000F5, 0),
INST(kX86InstCMovA , "cmova" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F47, 0),
INST(kX86InstCMovAE , "cmovae" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F43, 0),
INST(kX86InstCMovB , "cmovb" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F42, 0),
INST(kX86InstCMovBE , "cmovbe" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F46, 0),
INST(kX86InstCMovC , "cmovc" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F42, 0),
INST(kX86InstCMovE , "cmove" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F44, 0),
INST(kX86InstCMovG , "cmovg" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4F, 0),
INST(kX86InstCMovGE , "cmovge" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4D, 0),
INST(kX86InstCMovL , "cmovl" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4C, 0),
INST(kX86InstCMovLE , "cmovle" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4E, 0),
INST(kX86InstCMovNA , "cmovna" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F46, 0),
INST(kX86InstCMovNAE , "cmovnae" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F42, 0),
INST(kX86InstCMovNB , "cmovnb" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F43, 0),
INST(kX86InstCMovNBE , "cmovnbe" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F47, 0),
INST(kX86InstCMovNC , "cmovnc" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F43, 0),
INST(kX86InstCMovNE , "cmovne" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F45, 0),
INST(kX86InstCMovNG , "cmovng" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4E, 0),
INST(kX86InstCMovNGE , "cmovnge" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4C, 0),
INST(kX86InstCMovNL , "cmovnl" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4D, 0),
INST(kX86InstCMovNLE , "cmovnle" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4F, 0),
INST(kX86InstCMovNO , "cmovno" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F41, 0),
INST(kX86InstCMovNP , "cmovnp" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4B, 0),
INST(kX86InstCMovNS , "cmovns" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F49, 0),
INST(kX86InstCMovNZ , "cmovnz" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F45, 0),
INST(kX86InstCMovO , "cmovo" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F40, 0),
INST(kX86InstCMovP , "cmovp" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4A, 0),
INST(kX86InstCMovPE , "cmovpe" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4A, 0),
INST(kX86InstCMovPO , "cmovpo" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F4B, 0),
INST(kX86InstCMovS , "cmovs" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F48, 0),
INST(kX86InstCMovZ , "cmovz" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0x00000F44, 0),
INST(kX86InstCmp , "cmp" , G(Arith) , F(None) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 7, 0x00000038, 0x00000080),
INST(kX86InstCmpPD , "cmppd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000FC2, 0),
INST(kX86InstCmpPS , "cmpps" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000FC2, 0),
INST(kX86InstCmpSD , "cmpsd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000FC2, 0),
INST(kX86InstCmpSS , "cmpss" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000FC2, 0),
INST(kX86InstCmpXCHG , "cmpxchg" , G(RmReg) , F(Special)|F(Lockable), 0 , 0 , 0, 0x00000FB0, 0),
INST(kX86InstCmpXCHG16B , "cmpxchg16b" , G(Mem) , F(Special) , O(Mem) , 0 , 1, 0x00000FC7, 1 /* RexW */),
INST(kX86InstCmpXCHG8B , "cmpxchg8b" , G(Mem) , F(Special) , O(Mem) , 0 , 1, 0x00000FC7, 0),
INST(kX86InstComISD , "comisd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F2F, 0),
INST(kX86InstComISS , "comiss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F2F, 0),
INST(kX86InstCpuId , "cpuid" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000FA2, 0),
INST(kX86InstCqo , "cqo" , G(Emit) , F(Special) , 0 , 0 , 0, 0x48000099, 0), // TODO, set RexW bit instead?
INST(kX86InstCrc32 , "crc32" , G(Crc32) , F(None) , O(Gqd) , O(GqdwbMem) , 0, 0xF20F38F0, 0),
INST(kX86InstCvtDQ2PD , "cvtdq2pd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF3000FE6, 0),
INST(kX86InstCvtDQ2PS , "cvtdq2ps" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x00000F5B, 0),
INST(kX86InstCvtPD2DQ , "cvtpd2dq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF2000FE6, 0),
INST(kX86InstCvtPD2PI , "cvtpd2pi" , G(MmuRmI) , F(Mov) , O(Mm) , O(XmmMem) , 0, 0x66000F2D, 0),
INST(kX86InstCvtPD2PS , "cvtpd2ps" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x66000F5A, 0),
INST(kX86InstCvtPI2PD , "cvtpi2pd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(MmMem) , 0, 0x66000F2A, 0),
INST(kX86InstCvtPI2PS , "cvtpi2ps" , G(MmuRmI) , F(None) , O(Xmm) , O(MmMem) , 0, 0x00000F2A, 0),
INST(kX86InstCvtPS2DQ , "cvtps2dq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x66000F5B, 0),
INST(kX86InstCvtPS2PD , "cvtps2pd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x00000F5A, 0),
INST(kX86InstCvtPS2PI , "cvtps2pi" , G(MmuRmI) , F(Mov) , O(Mm) , O(XmmMem) , 0, 0x00000F2D, 0),
INST(kX86InstCvtSD2SI , "cvtsd2si" , G(MmuRmI) , F(Mov) , O(Gqd) , O(XmmMem) , 0, 0xF2000F2D, 0),
INST(kX86InstCvtSD2SS , "cvtsd2ss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F5A, 0),
INST(kX86InstCvtSI2SD , "cvtsi2sd" , G(MmuRmI) , F(None) , O(Xmm) , O(Gqd)|O(Mem) , 0, 0xF2000F2A, 0),
INST(kX86InstCvtSI2SS , "cvtsi2ss" , G(MmuRmI) , F(None) , O(Xmm) , O(Gqd)|O(Mem) , 0, 0xF3000F2A, 0),
INST(kX86InstCvtSS2SD , "cvtss2sd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F5A, 0),
INST(kX86InstCvtSS2SI , "cvtss2si" , G(MmuRmI) , F(None) , O(Gqd) , O(XmmMem) , 0, 0xF3000F2D, 0),
INST(kX86InstCvttPD2DQ , "cvttpd2dq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x66000FE6, 0),
INST(kX86InstCvttPD2PI , "cvttpd2pi" , G(MmuRmI) , F(Mov) , O(Mm) , O(XmmMem) , 0, 0x66000F2C, 0),
INST(kX86InstCvttPS2DQ , "cvttps2dq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF3000F5B, 0),
INST(kX86InstCvttPS2PI , "cvttps2pi" , G(MmuRmI) , F(Mov) , O(Mm) , O(XmmMem) , 0, 0x00000F2C, 0),
INST(kX86InstCvttSD2SI , "cvttsd2si" , G(MmuRmI) , F(None) , O(Gqd) , O(XmmMem) , 0, 0xF2000F2C, 0),
INST(kX86InstCvttSS2SI , "cvttss2si" , G(MmuRmI) , F(None) , O(Gqd) , O(XmmMem) , 0, 0xF3000F2C, 0),
INST(kX86InstCwd , "cwd" , G(Emit) , F(Special) , 0 , 0 , 0, 0x66000099, 0),
INST(kX86InstCwde , "cwde" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000098, 0),
INST(kX86InstDaa , "daa" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000027, 0),
INST(kX86InstDas , "das" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000002F, 0),
INST(kX86InstDec , "dec" , G(IncDec) , F(Lockable) , O(GqdwbMem) , 0 , 1, 0x00000048, 0x000000FE),
INST(kX86InstDiv , "div" , G(Rm) , F(Special) , 0 , 0 , 6, 0x000000F6, 0),
INST(kX86InstDivPD , "divpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F5E, 0),
INST(kX86InstDivPS , "divps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F5E, 0),
INST(kX86InstDivSD , "divsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F5E, 0),
INST(kX86InstDivSS , "divss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F5E, 0),
INST(kX86InstDpPD , "dppd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A41, 0),
INST(kX86InstDpPS , "dpps" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A40, 0),
INST(kX86InstEmms , "emms" , G(Emit) , F(None) , 0 , 0 , 0, 0x00000F77, 0),
INST(kX86InstEnter , "enter" , G(Enter) , F(Special) , 0 , 0 , 0, 0x000000C8, 0),
INST(kX86InstExtractPS , "extractps" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A17, 0),
INST(kX86InstF2XM1 , "f2xm1" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F0, 0),
INST(kX86InstFAbs , "fabs" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9E1, 0),
INST(kX86InstFAdd , "fadd" , G(X87StM) , F(Fpu) , 0 , 0 , 0, 0xD8DCC0C0, 0),
INST(kX86InstFAddP , "faddp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DEC0, 0),
INST(kX86InstFBLd , "fbld" , G(Mem) , F(Fpu) , O(Mem) , 0 , 4, 0x000000DF, 0),
INST(kX86InstFBStP , "fbstp" , G(Mem) , F(Fpu) , O(Mem) , 0 , 6, 0x000000DF, 0),
INST(kX86InstFCHS , "fchs" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9E0, 0),
INST(kX86InstFClex , "fclex" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x9B00DBE2, 0),
INST(kX86InstFCMovB , "fcmovb" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DAC0, 0),
INST(kX86InstFCMovBE , "fcmovbe" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DAD0, 0),
INST(kX86InstFCMovE , "fcmove" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DAC8, 0),
INST(kX86InstFCMovNB , "fcmovnb" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DBC0, 0),
INST(kX86InstFCMovNBE , "fcmovnbe" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DBD0, 0),
INST(kX86InstFCMovNE , "fcmovne" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DBC8, 0),
INST(kX86InstFCMovNU , "fcmovnu" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DBD8, 0),
INST(kX86InstFCMovU , "fcmovu" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DAD8, 0),
INST(kX86InstFCom , "fcom" , G(X87StM) , F(Fpu) , 0 , 0 , 2, 0xD8DCD0D0, 0),
INST(kX86InstFComI , "fcomi" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DBF0, 0),
INST(kX86InstFComIP , "fcomip" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DFF0, 0),
INST(kX86InstFComP , "fcomp" , G(X87StM) , F(Fpu) , 0 , 0 , 3, 0xD8DCD8D8, 0),
INST(kX86InstFComPP , "fcompp" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000DED9, 0),
INST(kX86InstFCos , "fcos" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9FF, 0),
INST(kX86InstFDecStP , "fdecstp" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F6, 0),
INST(kX86InstFDiv , "fdiv" , G(X87StM) , F(Fpu) , 0 , 0 , 6, 0xD8DCF0F8, 0),
INST(kX86InstFDivP , "fdivp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DEF8, 0),
INST(kX86InstFDivR , "fdivr" , G(X87StM) , F(Fpu) , 0 , 0 , 7, 0xD8DCF8F0, 0),
INST(kX86InstFDivRP , "fdivrp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DEF0, 0),
INST(kX86InstFEmms , "femms" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x00000F0E, 0),
INST(kX86InstFFree , "ffree" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DDC0, 0),
INST(kX86InstFIAdd , "fiadd" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 0, 0xDEDA0000, 0),
INST(kX86InstFICom , "ficom" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 2, 0xDEDA0000, 0),
INST(kX86InstFIComP , "ficomp" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 3, 0xDEDA0000, 0),
INST(kX86InstFIDiv , "fidiv" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 6, 0xDEDA0000, 0),
INST(kX86InstFIDivR , "fidivr" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 7, 0xDEDA0000, 0),
INST(kX86InstFILd , "fild" , G(X87Mem) , F(Fpu) , O(StM2_4_8) , 0 , 0, 0xDFDBDF05, 0),
INST(kX86InstFIMul , "fimul" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 1, 0xDEDA0000, 0),
INST(kX86InstFIncStP , "fincstp" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F7, 0),
INST(kX86InstFInit , "finit" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x9B00DBE3, 0),
INST(kX86InstFISt , "fist" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 2, 0xDFDB0000, 0),
INST(kX86InstFIStP , "fistp" , G(X87Mem) , F(Fpu) , O(StM2_4_8) , 0 , 3, 0xDFDBDF07, 0),
INST(kX86InstFISttP , "fisttp" , G(X87Mem) , F(Fpu) , O(StM2_4_8) , 0 , 1, 0xDFDBDD01, 0),
INST(kX86InstFISub , "fisub" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 4, 0xDEDA0000, 0),
INST(kX86InstFISubR , "fisubr" , G(X87Mem) , F(Fpu) , O(StM2_4) , 0 , 5, 0xDEDA0000, 0),
INST(kX86InstFLd , "fld" , G(X87FldFst) , F(Fpu) , O(StM4_8_10) , 0 , 0, 0x00D9DD00, 0xD9C0DB05),
INST(kX86InstFLd1 , "fld1" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9E8, 0),
INST(kX86InstFLdCw , "fldcw" , G(Mem) , F(Fpu) , O(Mem) , 0 , 5, 0x000000D9, 0),
INST(kX86InstFLdEnv , "fldenv" , G(Mem) , F(Fpu) , O(Mem) , 0 , 4, 0x000000D9, 0),
INST(kX86InstFLdL2E , "fldl2e" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9EA, 0),
INST(kX86InstFLdL2T , "fldl2t" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9E9, 0),
INST(kX86InstFLdLg2 , "fldlg2" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9EC, 0),
INST(kX86InstFLdLn2 , "fldln2" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9ED, 0),
INST(kX86InstFLdPi , "fldpi" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9EB, 0),
INST(kX86InstFLdZ , "fldz" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9EE, 0),
INST(kX86InstFMul , "fmul" , G(X87StM) , F(Fpu) , 0 , 0 , 1, 0xD8DCC8C8, 0),
INST(kX86InstFMulP , "fmulp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DEC8, 0),
INST(kX86InstFNClex , "fnclex" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000DBE2, 0),
INST(kX86InstFNInit , "fninit" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000DBE3, 0),
INST(kX86InstFNop , "fnop" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9D0, 0),
INST(kX86InstFNSave , "fnsave" , G(Mem) , F(Fpu) , O(Mem) , 0 , 6, 0x000000DD, 0),
INST(kX86InstFNStCw , "fnstcw" , G(Mem) , F(Fpu) , O(Mem) , 0 , 7, 0x000000D9, 0),
INST(kX86InstFNStEnv , "fnstenv" , G(Mem) , F(Fpu) , O(Mem) , 0 , 6, 0x000000D9, 0),
INST(kX86InstFNStSw , "fnstsw" , G(X87Status) , F(Fpu) , O(Mem) , 0 , 7, 0x000000DD, 0x0000DFE0),
INST(kX86InstFPAtan , "fpatan" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F3, 0),
INST(kX86InstFPRem , "fprem" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F8, 0),
INST(kX86InstFPRem1 , "fprem1" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F5, 0),
INST(kX86InstFPTan , "fptan" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F2, 0),
INST(kX86InstFRndInt , "frndint" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9FC, 0),
INST(kX86InstFRstor , "frstor" , G(Mem) , F(Fpu) , O(Mem) , 0 , 4, 0x000000DD, 0),
INST(kX86InstFSave , "fsave" , G(Mem) , F(Fpu) , O(Mem) , 0 , 6, 0x9B0000DD, 0),
INST(kX86InstFScale , "fscale" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9FD, 0),
INST(kX86InstFSin , "fsin" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9FE, 0),
INST(kX86InstFSinCos , "fsincos" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9FB, 0),
INST(kX86InstFSqrt , "fsqrt" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9FA, 0),
INST(kX86InstFSt , "fst" , G(X87FldFst) , F(Fpu) , O(StM4_8) , 0 , 2, 0x00D9DD02, 0xDDD00000),
INST(kX86InstFStCw , "fstcw" , G(Mem) , F(Fpu) , O(Mem) , 0 , 7, 0x9B0000D9, 0),
INST(kX86InstFStEnv , "fstenv" , G(Mem) , F(Fpu) , O(Mem) , 0 , 6, 0x9B0000D9, 0),
INST(kX86InstFStP , "fstp" , G(X87FldFst) , F(Fpu) , O(StM4_8_10) , 0 , 3, 0x00D9DD03, 0xDDD8DB07),
INST(kX86InstFStSw , "fstsw" , G(X87Status) , F(Fpu) , O(Mem) , 0 , 7, 0x9B0000DD, 0x9B00DFE0),
INST(kX86InstFSub , "fsub" , G(X87StM) , F(Fpu) , 0 , 0 , 4, 0xD8DCE0E8, 0),
INST(kX86InstFSubP , "fsubp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DEE8, 0),
INST(kX86InstFSubR , "fsubr" , G(X87StM) , F(Fpu) , 0 , 0 , 5, 0xD8DCE8E0, 0),
INST(kX86InstFSubRP , "fsubrp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DEE0, 0),
INST(kX86InstFTst , "ftst" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9E4, 0),
INST(kX86InstFUCom , "fucom" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DDE0, 0),
INST(kX86InstFUComI , "fucomi" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DBE8, 0),
INST(kX86InstFUComIP , "fucomip" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DFE8, 0),
INST(kX86InstFUComP , "fucomp" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000DDE8, 0),
INST(kX86InstFUComPP , "fucompp" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000DAE9, 0),
INST(kX86InstFWait , "fwait" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x000000DB, 0),
INST(kX86InstFXam , "fxam" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9E5, 0),
INST(kX86InstFXch , "fxch" , G(X87StI) , F(Fpu) , 0 , 0 , 0, 0x0000D9C8, 0),
INST(kX86InstFXRstor , "fxrstor" , G(Mem) , F(Fpu) , 0 , 0 , 1, 0x00000FAE, 0),
INST(kX86InstFXSave , "fxsave" , G(Mem) , F(Fpu) , 0 , 0 , 0, 0x00000FAE, 0),
INST(kX86InstFXtract , "fxtract" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F4, 0),
INST(kX86InstFYL2X , "fyl2x" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F1, 0),
INST(kX86InstFYL2XP1 , "fyl2xp1" , G(Emit) , F(Fpu) , 0 , 0 , 0, 0x0000D9F9, 0),
INST(kX86InstHAddPD , "haddpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F7C, 0),
INST(kX86InstHAddPS , "haddps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F7C, 0),
INST(kX86InstHSubPD , "hsubpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F7D, 0),
INST(kX86InstHSubPS , "hsubps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F7D, 0),
INST(kX86InstIDiv , "idiv" , G(Rm) , F(Special) , 0 , 0 , 7, 0x000000F6, 0),
INST(kX86InstIMul , "imul" , G(IMul) , F(Special) , 0 , 0 , 0, 0 , 0),
INST(kX86InstInc , "inc" , G(IncDec) , F(Lockable) , O(GqdwbMem) , 0 , 0, 0x00000040, 0x000000FE),
INST(kX86InstInt3 , "int3" , G(Emit) , F(None) , 0 , 0 , 0, 0x000000CC, 0),
INST(kX86InstJA , "ja" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x7 , 0),
INST(kX86InstJAE , "jae" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x3 , 0),
INST(kX86InstJB , "jb" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x2 , 0),
INST(kX86InstJBE , "jbe" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x6 , 0),
INST(kX86InstJC , "jc" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x2 , 0),
INST(kX86InstJE , "je" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x4 , 0),
INST(kX86InstJG , "jg" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xF , 0),
INST(kX86InstJGE , "jge" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xD , 0),
INST(kX86InstJL , "jl" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xC , 0),
INST(kX86InstJLE , "jle" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xE , 0),
INST(kX86InstJNA , "jna" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x6 , 0),
INST(kX86InstJNAE , "jnae" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x2 , 0),
INST(kX86InstJNB , "jnb" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x3 , 0),
INST(kX86InstJNBE , "jnbe" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x7 , 0),
INST(kX86InstJNC , "jnc" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x3 , 0),
INST(kX86InstJNE , "jne" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x5 , 0),
INST(kX86InstJNG , "jng" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xE , 0),
INST(kX86InstJNGE , "jnge" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xC , 0),
INST(kX86InstJNL , "jnl" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xD , 0),
INST(kX86InstJNLE , "jnle" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xF , 0),
INST(kX86InstJNO , "jno" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x1 , 0),
INST(kX86InstJNP , "jnp" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xB , 0),
INST(kX86InstJNS , "jns" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x9 , 0),
INST(kX86InstJNZ , "jnz" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x5 , 0),
INST(kX86InstJO , "jo" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x0 , 0),
INST(kX86InstJP , "jp" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xA , 0),
INST(kX86InstJPE , "jpe" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xA , 0),
INST(kX86InstJPO , "jpo" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0xB , 0),
INST(kX86InstJS , "js" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x8 , 0),
INST(kX86InstJZ , "jz" , G(Jcc) , F(Jump) , 0 , 0 , 0, 0x4 , 0),
INST(kX86InstJmp , "jmp" , G(Jmp) , F(Jump) , 0 , 0 , 0, 0 , 0),
INST(kX86InstLdDQU , "lddqu" , G(MmuRmI) , F(None) , O(Xmm) , O(Mem) , 0, 0xF2000FF0, 0),
INST(kX86InstLdMXCSR , "ldmxcsr" , G(Mem) , F(None) , O(Mem) , 0 , 2, 0x00000FAE, 0),
INST(kX86InstLahf , "lahf" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000009F, 0),
INST(kX86InstLea , "lea" , G(Lea) , F(None) , O(Gqd) , O(Mem) , 0, 0 , 0),
INST(kX86InstLeave , "leave" , G(Emit) , F(Special) , 0 , 0 , 0, 0x000000C9, 0),
INST(kX86InstLFence , "lfence" , G(Emit) , F(None) , 0 , 0 , 0, 0x000FAEE8, 0),
INST(kX86InstMaskMovDQU , "maskmovdqu" , G(MmuRmI) , F(Special) , O(Xmm) , O(Xmm) , 0, 0x66000F57, 0),
INST(kX86InstMaskMovQ , "maskmovq" , G(MmuRmI) , F(Special) , O(Mm) , O(Mm) , 0, 0x00000FF7, 0),
INST(kX86InstMaxPD , "maxpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F5F, 0),
INST(kX86InstMaxPS , "maxps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F5F, 0),
INST(kX86InstMaxSD , "maxsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F5F, 0),
INST(kX86InstMaxSS , "maxss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F5F, 0),
INST(kX86InstMFence , "mfence" , G(Emit) , F(None) , 0 , 0 , 0, 0x000FAEF0, 0),
INST(kX86InstMinPD , "minpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F5D, 0),
INST(kX86InstMinPS , "minps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F5D, 0),
INST(kX86InstMinSD , "minsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F5D, 0),
INST(kX86InstMinSS , "minss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F5D, 0),
INST(kX86InstMonitor , "monitor" , G(Emit) , F(Special) , 0 , 0 , 0, 0x000F01C8, 0),
INST(kX86InstMov , "mov" , G(Mov) , F(Mov) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 0, 0 , 0),
INST(kX86InstMovAPD , "movapd" , G(MmuMov) , F(Mov) , O(XmmMem) , O(XmmMem) , 0, 0x66000F28, 0x66000F29),
INST(kX86InstMovAPS , "movaps" , G(MmuMov) , F(Mov) , O(XmmMem) , O(XmmMem) , 0, 0x00000F28, 0x00000F29),
INST(kX86InstMovBE , "movbe" , G(MovBE) , F(Mov) , O(Gqdw)|O(Mem) , O(Gqdw)|O(Mem) , 0, 0x000F38F0, 0x000F38F1),
INST(kX86InstMovD , "movd" , G(MmuMovD) , F(Mov) , O(Gd)|O(MmXmmMem) , O(Gd)|O(MmXmmMem) , 0, 0 , 0),
INST(kX86InstMovDDup , "movddup" , G(MmuMov) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF2000F12, 0),
INST(kX86InstMovDQ2Q , "movdq2q" , G(MmuMov) , F(Mov) , O(Mm) , O(Xmm) , 0, 0xF2000FD6, 0),
INST(kX86InstMovDQA , "movdqa" , G(MmuMov) , F(Mov) , O(XmmMem) , O(XmmMem) , 0, 0x66000F6F, 0x66000F7F),
INST(kX86InstMovDQU , "movdqu" , G(MmuMov) , F(Mov) , O(XmmMem) , O(XmmMem) , 0, 0xF3000F6F, 0xF3000F7F),
INST(kX86InstMovHLPS , "movhlps" , G(MmuMov) , F(None) , O(Xmm) , O(Xmm) , 0, 0x00000F12, 0),
INST(kX86InstMovHPD , "movhpd" , G(MmuMov) , F(None) , O(XmmMem) , O(XmmMem) , 0, 0x66000F16, 0x66000F17),
INST(kX86InstMovHPS , "movhps" , G(MmuMov) , F(None) , O(XmmMem) , O(XmmMem) , 0, 0x00000F16, 0x00000F17),
INST(kX86InstMovLHPS , "movlhps" , G(MmuMov) , F(None) , O(Xmm) , O(Xmm) , 0, 0x00000F16, 0),
INST(kX86InstMovLPD , "movlpd" , G(MmuMov) , F(None) , O(XmmMem) , O(XmmMem) , 0, 0x66000F12, 0x66000F13),
INST(kX86InstMovLPS , "movlps" , G(MmuMov) , F(None) , O(XmmMem) , O(XmmMem) , 0, 0x00000F12, 0x00000F13),
INST(kX86InstMovMskPD , "movmskpd" , G(MmuMov) , F(Mov) , O(Gqd)|O(NoRex) , O(Xmm) , 0, 0x66000F50, 0),
INST(kX86InstMovMskPS , "movmskps" , G(MmuMov) , F(Mov) , O(Gqd)|O(NoRex) , O(Xmm) , 0, 0x00000F50, 0),
INST(kX86InstMovNTDQ , "movntdq" , G(MmuMov) , F(None) , O(Mem) , O(Xmm) , 0, 0 , 0x66000FE7),
INST(kX86InstMovNTDQA , "movntdqa" , G(MmuMov) , F(Mov) , O(Xmm) , O(Mem) , 0, 0x660F382A, 0),
INST(kX86InstMovNTI , "movnti" , G(MmuMov) , F(Mov) , O(Mem) , O(Gqd) , 0, 0 , 0x00000FC3),
INST(kX86InstMovNTPD , "movntpd" , G(MmuMov) , F(None) , O(Mem) , O(Xmm) , 0, 0 , 0x66000F2B),
INST(kX86InstMovNTPS , "movntps" , G(MmuMov) , F(None) , O(Mem) , O(Xmm) , 0, 0 , 0x00000F2B),
INST(kX86InstMovNTQ , "movntq" , G(MmuMov) , F(None) , O(Mem) , O(Mm) , 0, 0 , 0x00000FE7),
INST(kX86InstMovQ , "movq" , G(MmuMovQ) , F(Mov) , O(Gq)|O(MmXmmMem) , O(Gq)|O(MmXmmMem) , 0, 0 , 0),
INST(kX86InstMovQ2DQ , "movq2dq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(Mm) , 0, 0xF3000FD6, 0),
INST(kX86InstMovSD , "movsd" , G(MmuMov) , F(None) , O(XmmMem) , O(XmmMem) , 0, 0xF2000F10, 0xF2000F11),
INST(kX86InstMovSHDup , "movshdup" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF3000F16, 0),
INST(kX86InstMovSLDup , "movsldup" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF3000F12, 0),
INST(kX86InstMovSS , "movss" , G(MmuMov) , F(None) , O(XmmMem) , O(XmmMem) , 0, 0xF3000F10, 0xF3000F11),
INST(kX86InstMovSX , "movsx" , G(MovSxMovZx) , F(None) , O(Gqdw) , O(GwbMem) , 0, 0x00000FBE, 0),
INST(kX86InstMovSXD , "movsxd" , G(MovSxD) , F(None) , O(Gq) , O(GdMem) , 0, 0 , 0),
INST(kX86InstMovUPD , "movupd" , G(MmuMov) , F(Mov) , O(XmmMem) , O(XmmMem) , 0, 0x66000F10, 0x66000F11),
INST(kX86InstMovUPS , "movups" , G(MmuMov) , F(Mov) , O(XmmMem) , O(XmmMem) , 0, 0x00000F10, 0x00000F11),
INST(kX86InstMovZX , "movzx" , G(MovSxMovZx) , F(Mov) , O(Gqdw) , O(GwbMem) , 0, 0x00000FB6, 0),
INST(kX86InstMovPtr , "mov_ptr" , G(MovPtr) , F(Mov)|F(Special), O(Gqdwb) , O(Imm) , 0, 0 , 0),
INST(kX86InstMPSADBW , "mpsadbw" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A42, 0),
INST(kX86InstMul , "mul" , G(Rm) , F(Special) , 0 , 0 , 4, 0x000000F6, 0),
INST(kX86InstMulPD , "mulpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F59, 0),
INST(kX86InstMulPS , "mulps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F59, 0),
INST(kX86InstMulSD , "mulsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F59, 0),
INST(kX86InstMulSS , "mulss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F59, 0),
INST(kX86InstMWait , "mwait" , G(Emit) , F(Special) , 0 , 0 , 0, 0x000F01C9, 0),
INST(kX86InstNeg , "neg" , G(Rm) , F(Lockable) , O(GqdwbMem) , 0 , 3, 0x000000F6, 0),
INST(kX86InstNop , "nop" , G(Emit) , F(None) , 0 , 0 , 0, 0x00000090, 0),
INST(kX86InstNot , "not" , G(Rm) , F(Lockable) , O(GqdwbMem) , 0 , 2, 0x000000F6, 0),
INST(kX86InstOr , "or" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 1, 0x00000008, 0x00000080),
INST(kX86InstOrPD , "orpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F56, 0),
INST(kX86InstOrPS , "orps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F56, 0),
INST(kX86InstPAbsB , "pabsb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F381C, 0),
INST(kX86InstPAbsD , "pabsd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F381E, 0),
INST(kX86InstPAbsW , "pabsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F381D, 0),
INST(kX86InstPackSSDW , "packssdw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F6B, 0),
INST(kX86InstPackSSWB , "packsswb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F63, 0),
INST(kX86InstPackUSDW , "packusdw" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F382B, 0),
INST(kX86InstPackUSWB , "packuswb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F67, 0),
INST(kX86InstPAddB , "paddb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FFC, 0),
INST(kX86InstPAddD , "paddd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FFE, 0),
INST(kX86InstPAddQ , "paddq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FD4, 0),
INST(kX86InstPAddSB , "paddsb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FEC, 0),
INST(kX86InstPAddSW , "paddsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FED, 0),
INST(kX86InstPAddUSB , "paddusb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FDC, 0),
INST(kX86InstPAddUSW , "paddusw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FDD, 0),
INST(kX86InstPAddW , "paddw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FFD, 0),
INST(kX86InstPAlignR , "palignr" , G(MmuRmImm8) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3A0F, 0),
INST(kX86InstPAnd , "pand" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FDB, 0),
INST(kX86InstPAndN , "pandn" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FDF, 0),
INST(kX86InstPause , "pause" , G(Emit) , F(None) , 0 , 0 , 0, 0xF3000090, 0),
INST(kX86InstPAvgB , "pavgb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FE0, 0),
INST(kX86InstPAvgW , "pavgw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FE3, 0),
INST(kX86InstPBlendVB , "pblendvb" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3810, 0),
INST(kX86InstPBlendW , "pblendw" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A0E, 0),
INST(kX86InstPCmpEqB , "pcmpeqb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F74, 0),
INST(kX86InstPCmpEqD , "pcmpeqd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F76, 0),
INST(kX86InstPCmpEqQ , "pcmpeqq" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3829, 0),
INST(kX86InstPCmpEqW , "pcmpeqw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F75, 0),
INST(kX86InstPCmpEStrI , "pcmpestri" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A61, 0),
INST(kX86InstPCmpEStrM , "pcmpestrm" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A60, 0),
INST(kX86InstPCmpGtB , "pcmpgtb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F64, 0),
INST(kX86InstPCmpGtD , "pcmpgtd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F66, 0),
INST(kX86InstPCmpGtQ , "pcmpgtq" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3837, 0),
INST(kX86InstPCmpGtW , "pcmpgtw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F65, 0),
INST(kX86InstPCmpIStrI , "pcmpistri" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A63, 0),
INST(kX86InstPCmpIStrM , "pcmpistrm" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A62, 0),
INST(kX86InstPExtrB , "pextrb" , G(MmuExtract) , F(None) , O(Gd)|O(Gb)|O(Mem) , O(Xmm) , 0, 0x000F3A14, 0),
INST(kX86InstPExtrD , "pextrd" , G(MmuExtract) , F(None) , O(Gd) |O(Mem) , O(Xmm) , 0, 0x000F3A16, 0),
INST(kX86InstPExtrQ , "pextrq" , G(MmuExtract) , F(None) , O(Gqd) |O(Mem) , O(Xmm) , 1, 0x000F3A16, 0),
INST(kX86InstPExtrW , "pextrw" , G(MmuExtract) , F(None) , O(Gd) |O(Mem) , O(MmXmm) , 0, 0x000F3A15, 0),
INST(kX86InstPF2ID , "pf2id" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x1D),
INST(kX86InstPF2IW , "pf2iw" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x1C),
INST(kX86InstPFAcc , "pfacc" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xAE),
INST(kX86InstPFAdd , "pfadd" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x9E),
INST(kX86InstPFCmpEQ , "pfcmpeq" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xB0),
INST(kX86InstPFCmpGE , "pfcmpge" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x90),
INST(kX86InstPFCmpGT , "pfcmpgt" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xA0),
INST(kX86InstPFMax , "pfmax" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xA4),
INST(kX86InstPFMin , "pfmin" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x94),
INST(kX86InstPFMul , "pfmul" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xB4),
INST(kX86InstPFNAcc , "pfnacc" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x8A),
INST(kX86InstPFPNAcc , "pfpnacc" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x8E),
INST(kX86InstPFRcp , "pfrcp" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x96),
INST(kX86InstPFRcpIt1 , "pfrcpit1" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xA6),
INST(kX86InstPFRcpIt2 , "pfrcpit2" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xB6),
INST(kX86InstPFRSqIt1 , "pfrsqit1" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xA7),
INST(kX86InstPFRSqrt , "pfrsqrt" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x97),
INST(kX86InstPFSub , "pfsub" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x9A),
INST(kX86InstPFSubR , "pfsubr" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xAA),
INST(kX86InstPHAddD , "phaddd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3802, 0),
INST(kX86InstPHAddSW , "phaddsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3803, 0),
INST(kX86InstPHAddW , "phaddw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3801, 0),
INST(kX86InstPHMinPOSUW , "phminposuw" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3841, 0),
INST(kX86InstPHSubD , "phsubd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3806, 0),
INST(kX86InstPHSubSW , "phsubsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3807, 0),
INST(kX86InstPHSubW , "phsubw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3805, 0),
INST(kX86InstPI2FD , "pi2fd" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x0D),
INST(kX86InstPI2FW , "pi2fw" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0x0C),
INST(kX86InstPInsRB , "pinsrb" , G(MmuRmImm8) , F(None) , O(Xmm) , O(Gd) | O(Mem) , 0, 0x660F3A20, 0),
INST(kX86InstPInsRD , "pinsrd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(Gd) | O(Mem) , 0, 0x660F3A22, 0),
INST(kX86InstPInsRQ , "pinsrq" , G(MmuRmImm8) , F(None) , O(Xmm) , O(Gq) | O(Mem) , 0, 0x660F3A22, 0),
INST(kX86InstPInsRW , "pinsrw" , G(MmuRmImm8) , F(None) , O(MmXmm) , O(Gd) | O(Mem) , 0, 0x00000FC4, 0),
INST(kX86InstPMAddUBSW , "pmaddubsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3804, 0),
INST(kX86InstPMAddWD , "pmaddwd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FF5, 0),
INST(kX86InstPMaxSB , "pmaxsb" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F383C, 0),
INST(kX86InstPMaxSD , "pmaxsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F383D, 0),
INST(kX86InstPMaxSW , "pmaxsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FEE, 0),
INST(kX86InstPMaxUB , "pmaxub" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FDE, 0),
INST(kX86InstPMaxUD , "pmaxud" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F383F, 0),
INST(kX86InstPMaxUW , "pmaxuw" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F383E, 0),
INST(kX86InstPMinSB , "pminsb" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3838, 0),
INST(kX86InstPMinSD , "pminsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3839, 0),
INST(kX86InstPMinSW , "pminsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FEA, 0),
INST(kX86InstPMinUB , "pminub" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FDA, 0),
INST(kX86InstPMinUD , "pminud" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F383B, 0),
INST(kX86InstPMinUW , "pminuw" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F383A, 0),
INST(kX86InstPMovMskB , "pmovmskb" , G(MmuRmI) , F(Mov) , O(Gqd) , O(MmXmm) , 0, 0x00000FD7, 0),
INST(kX86InstPMovSXBD , "pmovsxbd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3821, 0),
INST(kX86InstPMovSXBQ , "pmovsxbq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3822, 0),
INST(kX86InstPMovSXBW , "pmovsxbw" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3820, 0),
INST(kX86InstPMovSXDQ , "pmovsxdq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3825, 0),
INST(kX86InstPMovSXWD , "pmovsxwd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3823, 0),
INST(kX86InstPMovSXWQ , "pmovsxwq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3824, 0),
INST(kX86InstPMovZXBD , "pmovzxbd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3831, 0),
INST(kX86InstPMovZXBQ , "pmovzxbq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3832, 0),
INST(kX86InstPMovZXBW , "pmovzxbw" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3830, 0),
INST(kX86InstPMovZXDQ , "pmovzxdq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3835, 0),
INST(kX86InstPMovZXWD , "pmovzxwd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3833, 0),
INST(kX86InstPMovZXWQ , "pmovzxwq" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3834, 0),
INST(kX86InstPMulDQ , "pmuldq" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3828, 0),
INST(kX86InstPMulHRSW , "pmulhrsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F380B, 0),
INST(kX86InstPMulHUW , "pmulhuw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FE4, 0),
INST(kX86InstPMulHW , "pmulhw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FE5, 0),
INST(kX86InstPMulLD , "pmulld" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3840, 0),
INST(kX86InstPMulLW , "pmullw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FD5, 0),
INST(kX86InstPMulUDQ , "pmuludq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FF4, 0),
INST(kX86InstPop , "pop" , G(Pop) , F(Special) , 0 , 0 , 0, 0x00000058, 0x0000008F),
INST(kX86InstPopAD , "popad" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000061, 0),
INST(kX86InstPopCnt , "popcnt" , G(RegRm) , F(None) , O(Gqdw) , O(GqdwMem) , 0, 0xF3000FB8, 0),
INST(kX86InstPopFD , "popfd" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000009D, 0),
INST(kX86InstPopFQ , "popfq" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000009D, 0),
INST(kX86InstPOr , "por" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FEB, 0),
INST(kX86InstPrefetch , "prefetch" , G(MmuPrefetch) , F(None) , O(Mem) , O(Imm) , 0, 0 , 0),
INST(kX86InstPSADBW , "psadbw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FF6, 0),
INST(kX86InstPShufB , "pshufb" , G(MmuRmI) , F(Mov) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3800, 0),
INST(kX86InstPShufD , "pshufd" , G(MmuRmImm8) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x66000F70, 0),
INST(kX86InstPShufW , "pshufw" , G(MmuRmImm8) , F(Mov) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F70, 0),
INST(kX86InstPShufHW , "pshufhw" , G(MmuRmImm8) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF3000F70, 0),
INST(kX86InstPShufLW , "pshuflw" , G(MmuRmImm8) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF2000F70, 0),
INST(kX86InstPSignB , "psignb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3808, 0),
INST(kX86InstPSignD , "psignd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F380A, 0),
INST(kX86InstPSignW , "psignw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x000F3809, 0),
INST(kX86InstPSllD , "pslld" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 6, 0x00000FF2, 0x00000F72),
INST(kX86InstPSllDQ , "pslldq" , G(MmuRmI) , F(None) , O(Xmm) , O(Imm) , 7, 0 , 0x66000F73),
INST(kX86InstPSllQ , "psllq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 6, 0x00000FF3, 0x00000F73),
INST(kX86InstPSllW , "psllw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 6, 0x00000FF1, 0x00000F71),
INST(kX86InstPSraD , "psrad" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 4, 0x00000FE2, 0x00000F72),
INST(kX86InstPSraW , "psraw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 4, 0x00000FE1, 0x00000F71),
INST(kX86InstPSrlD , "psrld" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 2, 0x00000FD2, 0x00000F72),
INST(kX86InstPSrlDQ , "psrldq" , G(MmuRmI) , F(None) , O(Xmm) , O(Imm) , 3, 0 , 0x66000F73),
INST(kX86InstPSrlQ , "psrlq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 2, 0x00000FD3, 0x00000F73),
INST(kX86InstPSrlW , "psrlw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem)|O(Imm) , 2, 0x00000FD1, 0x00000F71),
INST(kX86InstPSubB , "psubb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FF8, 0),
INST(kX86InstPSubD , "psubd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FFA, 0),
INST(kX86InstPSubQ , "psubq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FFB, 0),
INST(kX86InstPSubSB , "psubsb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FE8, 0),
INST(kX86InstPSubSW , "psubsw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FE9, 0),
INST(kX86InstPSubUSB , "psubusb" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FD8, 0),
INST(kX86InstPSubUSW , "psubusw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FD9, 0),
INST(kX86InstPSubW , "psubw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FF9, 0),
INST(kX86InstPSwapD , "pswapd" , G(MmuRm3dNow) , F(None) , O(Mm) , O(MmMem) , 0, 0x00000F0F, 0xBB),
INST(kX86InstPTest , "ptest" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3817, 0),
INST(kX86InstPunpckHBW , "punpckhbw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F68, 0),
INST(kX86InstPunpckHDQ , "punpckhdq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F6A, 0),
INST(kX86InstPunpckHQDQ , "punpckhqdq" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F6D, 0),
INST(kX86InstPunpckHWD , "punpckhwd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F69, 0),
INST(kX86InstPunpckLBW , "punpcklbw" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F60, 0),
INST(kX86InstPunpckLDQ , "punpckldq" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F62, 0),
INST(kX86InstPunpckLQDQ , "punpcklqdq" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F6C, 0),
INST(kX86InstPunpckLWD , "punpcklwd" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000F61, 0),
INST(kX86InstPush , "push" , G(Push) , F(Special) , 0 , 0 , 6, 0x00000050, 0x000000FF),
INST(kX86InstPushAD , "pushad" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000060, 0),
INST(kX86InstPushFD , "pushfd" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000009C, 0),
INST(kX86InstPushFQ , "pushfq" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000009C, 0),
INST(kX86InstPXor , "pxor" , G(MmuRmI) , F(None) , O(MmXmm) , O(MmXmmMem) , 0, 0x00000FEF, 0),
INST(kX86InstRcl , "rcl" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 2, 0 , 0),
INST(kX86InstRcpPS , "rcpps" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x00000F53, 0),
INST(kX86InstRcpSS , "rcpss" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0xF3000F53, 0),
INST(kX86InstRcr , "rcr" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 3, 0 , 0),
INST(kX86InstRdtsc , "rdtsc" , G(Emit) , F(Special) , 0 , 0 , 0, 0x00000F31, 0),
INST(kX86InstRdtscP , "rdtscp" , G(Emit) , F(Special) , 0 , 0 , 0, 0x000F01F9, 0),
INST(kX86InstRepLodSB , "rep lodsb" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AC, 1 /* Size of mem */),
INST(kX86InstRepLodSD , "rep lodsd" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AC, 4 /* Size of mem */),
INST(kX86InstRepLodSQ , "rep lodsq" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AC, 8 /* Size of mem */),
INST(kX86InstRepLodSW , "rep lodsw" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AC, 2 /* Size of mem */),
INST(kX86InstRepMovSB , "rep movsb" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A4, 1 /* Size of mem */),
INST(kX86InstRepMovSD , "rep movsd" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A4, 4 /* Size of mem */),
INST(kX86InstRepMovSQ , "rep movsq" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A4, 8 /* Size of mem */),
INST(kX86InstRepMovSW , "rep movsw" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A4, 2 /* Size of mem */),
INST(kX86InstRepStoSB , "rep stosb" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AA, 1 /* Size of mem */),
INST(kX86InstRepStoSD , "rep stosd" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AA, 4 /* Size of mem */),
INST(kX86InstRepStoSQ , "rep stosq" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AA, 8 /* Size of mem */),
INST(kX86InstRepStoSW , "rep stosw" , G(Rep) , F(Special) , O(Mem) , 0 , 0, 0xF30000AA, 2 /* Size of mem */),
INST(kX86InstRepECmpSB , "repe cmpsb" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A6, 1 /* Size of mem */),
INST(kX86InstRepECmpSD , "repe cmpsd" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A6, 4 /* Size of mem */),
INST(kX86InstRepECmpSQ , "repe cmpsq" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A6, 8 /* Size of mem */),
INST(kX86InstRepECmpSW , "repe cmpsw" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000A6, 2 /* Size of mem */),
INST(kX86InstRepEScaSB , "repe scasb" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000AE, 1 /* Size of mem */),
INST(kX86InstRepEScaSD , "repe scasd" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000AE, 4 /* Size of mem */),
INST(kX86InstRepEScaSQ , "repe scasq" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000AE, 8 /* Size of mem */),
INST(kX86InstRepEScaSW , "repe scasw" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF30000AE, 2 /* Size of mem */),
INST(kX86InstRepNECmpSB , "repne cmpsb" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000A6, 1 /* Size of mem */),
INST(kX86InstRepNECmpSD , "repne cmpsd" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000A6, 4 /* Size of mem */),
INST(kX86InstRepNECmpSQ , "repne cmpsq" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000A6, 8 /* Size of mem */),
INST(kX86InstRepNECmpSW , "repne cmpsw" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000A6, 2 /* Size of mem */),
INST(kX86InstRepNEScaSB , "repne scasb" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000AE, 1 /* Size of mem */),
INST(kX86InstRepNEScaSD , "repne scasd" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000AE, 4 /* Size of mem */),
INST(kX86InstRepNEScaSQ , "repne scasq" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000AE, 8 /* Size of mem */),
INST(kX86InstRepNEScaSW , "repne scasw" , G(Rep) , F(Special) , O(Mem) , O(Mem) , 0, 0xF20000AE, 2 /* Size of mem */),
INST(kX86InstRet , "ret" , G(Ret) , F(Special) , 0 , 0 , 0, 0 , 0),
INST(kX86InstRol , "rol" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 0, 0 , 0),
INST(kX86InstRor , "ror" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 1, 0 , 0),
INST(kX86InstRoundPD , "roundpd" , G(MmuRmImm8) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3A09, 0),
INST(kX86InstRoundPS , "roundps" , G(MmuRmImm8) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x660F3A08, 0),
INST(kX86InstRoundSD , "roundsd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A0B, 0),
INST(kX86InstRoundSS , "roundss" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x660F3A0A, 0),
INST(kX86InstRSqrtPS , "rsqrtps" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x00000F52, 0),
INST(kX86InstRSqrtSS , "rsqrtss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F52, 0),
INST(kX86InstSahf , "sahf" , G(Emit) , F(Special) , 0 , 0 , 0, 0x0000009E, 0),
INST(kX86InstSal , "sal" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 4, 0 , 0),
INST(kX86InstSar , "sar" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 7, 0 , 0),
INST(kX86InstSbb , "sbb" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 3, 0x00000018, 0x00000080),
INST(kX86InstSetA , "seta" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F97, 0),
INST(kX86InstSetAE , "setae" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F93, 0),
INST(kX86InstSetB , "setb" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F92, 0),
INST(kX86InstSetBE , "setbe" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F96, 0),
INST(kX86InstSetC , "setc" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F92, 0),
INST(kX86InstSetE , "sete" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F94, 0),
INST(kX86InstSetG , "setg" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9F, 0),
INST(kX86InstSetGE , "setge" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9D, 0),
INST(kX86InstSetL , "setl" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9C, 0),
INST(kX86InstSetLE , "setle" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9E, 0),
INST(kX86InstSetNA , "setna" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F96, 0),
INST(kX86InstSetNAE , "setnae" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F92, 0),
INST(kX86InstSetNB , "setnb" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F93, 0),
INST(kX86InstSetNBE , "setnbe" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F97, 0),
INST(kX86InstSetNC , "setnc" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F93, 0),
INST(kX86InstSetNE , "setne" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F95, 0),
INST(kX86InstSetNG , "setng" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9E, 0),
INST(kX86InstSetNGE , "setnge" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9C, 0),
INST(kX86InstSetNL , "setnl" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9D, 0),
INST(kX86InstSetNLE , "setnle" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9F, 0),
INST(kX86InstSetNO , "setno" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F91, 0),
INST(kX86InstSetNP , "setnp" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9B, 0),
INST(kX86InstSetNS , "setns" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F99, 0),
INST(kX86InstSetNZ , "setnz" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F95, 0),
INST(kX86InstSetO , "seto" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F90, 0),
INST(kX86InstSetP , "setp" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9A, 0),
INST(kX86InstSetPE , "setpe" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9A, 0),
INST(kX86InstSetPO , "setpo" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F9B, 0),
INST(kX86InstSetS , "sets" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F98, 0),
INST(kX86InstSetZ , "setz" , G(RmByte) , F(None) , O(GbMem) , 0 , 0, 0x00000F94, 0),
INST(kX86InstSFence , "sfence" , G(Emit) , F(None) , 0 , 0 , 0, 0x000FAEF8, 0),
INST(kX86InstShl , "shl" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 4, 0 , 0),
INST(kX86InstShld , "shld" , G(ShldShrd) , F(Special) , O(GqdwbMem) , O(Gb) , 0, 0x00000FA4, 0),
INST(kX86InstShr , "shr" , G(Rot) , F(Special) , O(GqdwbMem) , O(Gb)|O(Imm) , 5, 0 , 0),
INST(kX86InstShrd , "shrd" , G(ShldShrd) , F(Special) , O(GqdwbMem) , O(Gqdwb) , 0, 0x00000FAC, 0),
INST(kX86InstShufPD , "shufpd" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000FC6, 0),
INST(kX86InstShufPS , "shufps" , G(MmuRmImm8) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000FC6, 0),
INST(kX86InstSqrtPD , "sqrtpd" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x66000F51, 0),
INST(kX86InstSqrtPS , "sqrtps" , G(MmuRmI) , F(Mov) , O(Xmm) , O(XmmMem) , 0, 0x00000F51, 0),
INST(kX86InstSqrtSD , "sqrtsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F51, 0),
INST(kX86InstSqrtSS , "sqrtss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F51, 0),
INST(kX86InstStc , "stc" , G(Emit) , F(None) , 0 , 0 , 0, 0x000000F9, 0),
INST(kX86InstStd , "std" , G(Emit) , F(None) , 0 , 0 , 0, 0x000000FD, 0),
INST(kX86InstStMXCSR , "stmxcsr" , G(Mem) , F(None) , O(Mem) , 0 , 3, 0x00000FAE, 0),
INST(kX86InstSub , "sub" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 5, 0x00000028, 0x00000080),
INST(kX86InstSubPD , "subpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F5C, 0),
INST(kX86InstSubPS , "subps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F5C, 0),
INST(kX86InstSubSD , "subsd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF2000F5C, 0),
INST(kX86InstSubSS , "subss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0xF3000F5C, 0),
INST(kX86InstTest , "test" , G(Test) , F(None) , O(GqdwbMem) , O(Gqdwb)|O(Imm) , 0, 0 , 0),
INST(kX86InstUComISD , "ucomisd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F2E, 0),
INST(kX86InstUComISS , "ucomiss" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F2E, 0),
INST(kX86InstUd2 , "ud2" , G(Emit) , F(None) , 0 , 0 , 0, 0x00000F0B, 0),
INST(kX86InstUnpckHPD , "unpckhpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F15, 0),
INST(kX86InstUnpckHPS , "unpckhps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F15, 0),
INST(kX86InstUnpckLPD , "unpcklpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F14, 0),
INST(kX86InstUnpckLPS , "unpcklps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F14, 0),
INST(kX86InstXadd , "xadd" , G(RmReg) , F(Lockable) , O(GqdwbMem) , O(Gqdwb) , 0, 0x00000FC0, 0),
INST(kX86InstXchg , "xchg" , G(Xchg) , F(Lockable) , O(GqdwbMem) , O(Gqdwb) , 0, 0 , 0),
INST(kX86InstXor , "xor" , G(Arith) , F(Lockable) , O(GqdwbMem) , O(GqdwbMem)|O(Imm) , 6, 0x00000030, 0x00000080),
INST(kX86InstXorPD , "xorpd" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x66000F57, 0),
INST(kX86InstXorPS , "xorps" , G(MmuRmI) , F(None) , O(Xmm) , O(XmmMem) , 0, 0x00000F57, 0)
};
#undef G
#undef F
#undef O
#undef INST
// ============================================================================
// [AsmJit::x86VarInfo]
// ============================================================================
#define C(_Class_) kX86VarClass##_Class_
#define F(_Flag_) kX86VarFlag##_Flag_
const X86VarInfo x86VarInfo[] =
{
/* 0 */ { kX86RegTypeGpd , 4 , C(Gp) , 0 , "Gpd" },
/* 1 */ { kX86RegTypeGpq , 8 , C(Gp) , 0 , "Gpq" },
/* 2 */ { kX86RegTypeX87 , 4 , C(X87), F(SP) , "X87" },
/* 3 */ { kX86RegTypeX87 , 4 , C(X87), F(SP) , "X87.SS" },
/* 4 */ { kX86RegTypeX87 , 8 , C(X87), F(DP) , "X87.SD" },
/* 5 */ { kX86RegTypeMm , 8 , C(Mm) , 0 , "Mm" },
/* 6 */ { kX86RegTypeXmm , 16, C(Xmm), 0 , "Xmm" },
/* 7 */ { kX86RegTypeXmm , 4 , C(Xmm), F(SP) , "Xmm.SS" },
/* 8 */ { kX86RegTypeXmm , 8 , C(Xmm), F(DP) , "Xmm.SD" },
/* 9 */ { kX86RegTypeXmm , 16, C(Xmm), F(SP) | F(Packed), "Xmm.PS" },
/* 10 */ { kX86RegTypeXmm , 16, C(Xmm), F(DP) | F(Packed), "Xmm.PD" }
};
#undef F
#undef C
} // AsmJit namespace
#include "../core/apiend.h"
desmume/src/utils/libfat/file_allocation_table.c 000664 001750 001750 00000026476 12755534123 023216 0 ustar 00sergio sergio 000000 000000 /*
file_allocation_table.c
Reading, writing and manipulation of the FAT structure on
a FAT partition
Copyright (c) 2006 Michael "Chishm" Chisholm
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include "file_allocation_table.h"
#include "partition.h"
/*
Gets the cluster linked from input cluster
*/
uint32_t _FAT_fat_nextCluster(PARTITION* partition, uint32_t cluster)
{
uint32_t nextCluster = CLUSTER_FREE;
sec_t sector;
int offset;
if (cluster == CLUSTER_FREE) {
return CLUSTER_FREE;
}
switch (partition->filesysType)
{
case FS_UNKNOWN:
return CLUSTER_ERROR;
break;
case FS_FAT12:
{
uint32_t nextCluster_h;
sector = partition->fat.fatStart + (((cluster * 3) / 2) / BYTES_PER_READ);
offset = ((cluster * 3) / 2) % BYTES_PER_READ;
_FAT_cache_readLittleEndianValue (partition->cache, &nextCluster, sector, offset, sizeof(uint8_t));
offset++;
if (offset >= BYTES_PER_READ) {
offset = 0;
sector++;
}
nextCluster_h = 0;
_FAT_cache_readLittleEndianValue (partition->cache, &nextCluster_h, sector, offset, sizeof(uint8_t));
nextCluster |= (nextCluster_h << 8);
if (cluster & 0x01) {
nextCluster = nextCluster >> 4;
} else {
nextCluster &= 0x0FFF;
}
if (nextCluster >= 0x0FF7)
{
nextCluster = CLUSTER_EOF;
}
break;
}
case FS_FAT16:
sector = partition->fat.fatStart + ((cluster << 1) / BYTES_PER_READ);
offset = (cluster % (BYTES_PER_READ >> 1)) << 1;
_FAT_cache_readLittleEndianValue (partition->cache, &nextCluster, sector, offset, sizeof(uint16_t));
if (nextCluster >= 0xFFF7) {
nextCluster = CLUSTER_EOF;
}
break;
case FS_FAT32:
sector = partition->fat.fatStart + ((cluster << 2) / BYTES_PER_READ);
offset = (cluster % (BYTES_PER_READ >> 2)) << 2;
_FAT_cache_readLittleEndianValue (partition->cache, &nextCluster, sector, offset, sizeof(uint32_t));
if (nextCluster >= 0x0FFFFFF7) {
nextCluster = CLUSTER_EOF;
}
break;
default:
return CLUSTER_ERROR;
break;
}
return nextCluster;
}
/*
writes value into the correct offset within a partition's FAT, based
on the cluster number.
*/
static bool _FAT_fat_writeFatEntry (PARTITION* partition, uint32_t cluster, uint32_t value) {
sec_t sector;
int offset;
uint32_t oldValue;
if ((cluster < CLUSTER_FIRST) || (cluster > partition->fat.lastCluster /* This will catch CLUSTER_ERROR */))
{
return false;
}
switch (partition->filesysType)
{
case FS_UNKNOWN:
return false;
break;
case FS_FAT12:
sector = partition->fat.fatStart + (((cluster * 3) / 2) / BYTES_PER_READ);
offset = ((cluster * 3) / 2) % BYTES_PER_READ;
if (cluster & 0x01) {
_FAT_cache_readLittleEndianValue (partition->cache, &oldValue, sector, offset, sizeof(uint8_t));
value = (value << 4) | (oldValue & 0x0F);
_FAT_cache_writeLittleEndianValue (partition->cache, value & 0xFF, sector, offset, sizeof(uint8_t));
offset++;
if (offset >= BYTES_PER_READ) {
offset = 0;
sector++;
}
_FAT_cache_writeLittleEndianValue (partition->cache, (value >> 8) & 0xFF, sector, offset, sizeof(uint8_t));
} else {
_FAT_cache_writeLittleEndianValue (partition->cache, value, sector, offset, sizeof(uint8_t));
offset++;
if (offset >= BYTES_PER_READ) {
offset = 0;
sector++;
}
_FAT_cache_readLittleEndianValue (partition->cache, &oldValue, sector, offset, sizeof(uint8_t));
value = ((value >> 8) & 0x0F) | (oldValue & 0xF0);
_FAT_cache_writeLittleEndianValue (partition->cache, value, sector, offset, sizeof(uint8_t));
}
break;
case FS_FAT16:
sector = partition->fat.fatStart + ((cluster << 1) / BYTES_PER_READ);
offset = (cluster % (BYTES_PER_READ >> 1)) << 1;
_FAT_cache_writeLittleEndianValue (partition->cache, value, sector, offset, sizeof(uint16_t));
break;
case FS_FAT32:
sector = partition->fat.fatStart + ((cluster << 2) / BYTES_PER_READ);
offset = (cluster % (BYTES_PER_READ >> 2)) << 2;
_FAT_cache_writeLittleEndianValue (partition->cache, value, sector, offset, sizeof(uint32_t));
break;
default:
return false;
break;
}
return true;
}
/*-----------------------------------------------------------------
gets the first available free cluster, sets it
to end of file, links the input cluster to it then returns the
cluster number
If an error occurs, return CLUSTER_ERROR
-----------------------------------------------------------------*/
uint32_t _FAT_fat_linkFreeCluster(PARTITION* partition, uint32_t cluster) {
uint32_t firstFree;
uint32_t curLink;
uint32_t lastCluster;
bool loopedAroundFAT = false;
lastCluster = partition->fat.lastCluster;
if (cluster > lastCluster) {
return CLUSTER_ERROR;
}
// Check if the cluster already has a link, and return it if so
curLink = _FAT_fat_nextCluster(partition, cluster);
if ((curLink >= CLUSTER_FIRST) && (curLink <= lastCluster)) {
return curLink; // Return the current link - don't allocate a new one
}
// Get a free cluster
firstFree = partition->fat.firstFree;
// Start at first valid cluster
if (firstFree < CLUSTER_FIRST) {
firstFree = CLUSTER_FIRST;
}
// Search until a free cluster is found
while (_FAT_fat_nextCluster(partition, firstFree) != CLUSTER_FREE) {
firstFree++;
if (firstFree > lastCluster) {
if (loopedAroundFAT) {
// If couldn't get a free cluster then return an error
partition->fat.firstFree = firstFree;
return CLUSTER_ERROR;
} else {
// Try looping back to the beginning of the FAT
// This was suggested by loopy
firstFree = CLUSTER_FIRST;
loopedAroundFAT = true;
}
}
}
partition->fat.firstFree = firstFree;
if ((cluster >= CLUSTER_FIRST) && (cluster < lastCluster))
{
// Update the linked from FAT entry
_FAT_fat_writeFatEntry (partition, cluster, firstFree);
}
// Create the linked to FAT entry
_FAT_fat_writeFatEntry (partition, firstFree, CLUSTER_EOF);
return firstFree;
}
/*-----------------------------------------------------------------
gets the first available free cluster, sets it
to end of file, links the input cluster to it, clears the new
cluster to 0 valued bytes, then returns the cluster number
If an error occurs, return CLUSTER_ERROR
-----------------------------------------------------------------*/
uint32_t _FAT_fat_linkFreeClusterCleared (PARTITION* partition, uint32_t cluster) {
uint32_t newCluster;
uint32_t i;
uint8_t emptySector[BYTES_PER_READ];
// Link the cluster
newCluster = _FAT_fat_linkFreeCluster(partition, cluster);
if (newCluster == CLUSTER_FREE || newCluster == CLUSTER_ERROR) {
return CLUSTER_ERROR;
}
// Clear all the sectors within the cluster
memset (emptySector, 0, BYTES_PER_READ);
for (i = 0; i < partition->sectorsPerCluster; i++) {
_FAT_cache_writeSectors (partition->cache,
_FAT_fat_clusterToSector (partition, newCluster) + i,
1, emptySector);
}
return newCluster;
}
/*-----------------------------------------------------------------
_FAT_fat_clearLinks
frees any cluster used by a file
-----------------------------------------------------------------*/
bool _FAT_fat_clearLinks (PARTITION* partition, uint32_t cluster) {
uint32_t nextCluster;
if ((cluster < CLUSTER_FIRST) || (cluster > partition->fat.lastCluster /* This will catch CLUSTER_ERROR */))
return false;
// If this clears up more space in the FAT before the current free pointer, move it backwards
if (cluster < partition->fat.firstFree) {
partition->fat.firstFree = cluster;
}
while ((cluster != CLUSTER_EOF) && (cluster != CLUSTER_FREE) && (cluster != CLUSTER_ERROR)) {
// Store next cluster before erasing the link
nextCluster = _FAT_fat_nextCluster (partition, cluster);
// Erase the link
_FAT_fat_writeFatEntry (partition, cluster, CLUSTER_FREE);
// Move onto next cluster
cluster = nextCluster;
}
return true;
}
/*-----------------------------------------------------------------
_FAT_fat_trimChain
Drop all clusters past the chainLength.
If chainLength is 0, all clusters are dropped.
If chainLength is 1, the first cluster is kept and the rest are
dropped, and so on.
Return the last cluster left in the chain.
-----------------------------------------------------------------*/
uint32_t _FAT_fat_trimChain (PARTITION* partition, uint32_t startCluster, unsigned int chainLength) {
uint32_t nextCluster;
if (chainLength == 0) {
// Drop the entire chain
_FAT_fat_clearLinks (partition, startCluster);
return CLUSTER_FREE;
} else {
// Find the last cluster in the chain, and the one after it
chainLength--;
nextCluster = _FAT_fat_nextCluster (partition, startCluster);
while ((chainLength > 0) && (nextCluster != CLUSTER_FREE) && (nextCluster != CLUSTER_EOF)) {
chainLength--;
startCluster = nextCluster;
nextCluster = _FAT_fat_nextCluster (partition, startCluster);
}
// Drop all clusters after the last in the chain
if (nextCluster != CLUSTER_FREE && nextCluster != CLUSTER_EOF) {
_FAT_fat_clearLinks (partition, nextCluster);
}
// Mark the last cluster in the chain as the end of the file
_FAT_fat_writeFatEntry (partition, startCluster, CLUSTER_EOF);
return startCluster;
}
}
/*-----------------------------------------------------------------
_FAT_fat_lastCluster
Trace the cluster links until the last one is found
-----------------------------------------------------------------*/
uint32_t _FAT_fat_lastCluster (PARTITION* partition, uint32_t cluster) {
while ((_FAT_fat_nextCluster(partition, cluster) != CLUSTER_FREE) && (_FAT_fat_nextCluster(partition, cluster) != CLUSTER_EOF)) {
cluster = _FAT_fat_nextCluster(partition, cluster);
}
return cluster;
}
/*-----------------------------------------------------------------
_FAT_fat_freeClusterCount
Return the number of free clusters available
-----------------------------------------------------------------*/
unsigned int _FAT_fat_freeClusterCount (PARTITION* partition) {
unsigned int count = 0;
uint32_t curCluster;
for (curCluster = CLUSTER_FIRST; curCluster <= partition->fat.lastCluster; curCluster++) {
if (_FAT_fat_nextCluster(partition, curCluster) == CLUSTER_FREE) {
count++;
}
}
return count;
}
desmume/src/libretro-common/include/rthreads/async_job.h 000664 001750 001750 00000003273 12755534123 024633 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (async_job.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_ASYNC_JOB_H
#define __LIBRETRO_SDK_ASYNC_JOB_H
typedef struct async_job async_job_t;
typedef void (*async_task_t)(void *payload);
async_job_t *async_job_new(void);
void async_job_free(async_job_t *ajob);
int async_job_add(async_job_t *ajob, async_task_t task, void *payload);
#endif /* __LIBRETRO_SDK_ASYNC_JOB_H */
desmume/src/libretro/jni/Android.mk 000664 001750 001750 00000002077 12755534123 020460 0 ustar 00sergio sergio 000000 000000 HAVE_GRIFFIN := 0
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
CORE_DIR = ../..
JIT=
DESMUME_JIT=0
ifeq ($(TARGET_ARCH),arm)
LOCAL_CXXFLAGS := -DANDROID_ARM
LOCAL_ARM_MODE := arm
DESMUME_JIT_ARM = 1
JIT = -D__RETRO_ARM__ -DHAVE_JIT
endif
ifeq ($(TARGET_ARCH),x86)
LOCAL_CXXFLAGS := -DANDROID_X86
DESMUME_JIT = 1
JIT = -DHAVE_JIT
endif
ifeq ($(TARGET_ARCH),mips)
LOCAL_CXXFLAGS := -DANDROID_MIPS -D__mips__ -D__MIPSEL__
endif
ifeq ($(TARGET_ARCH),mips64)
LOCAL_CXXFLAGS := -DANDROID_MIPS -D__mips__ -D__MIPSEL__
endif
LOCAL_MODULE := libretro
include ../../../Makefile.common
LOCAL_SRC_FILES := $(SOURCES_CXX) $(SOURCES_C)
GLOBAL_DEFINES := $(JIT) -fexceptions
LOCAL_CXXFLAGS += -O3 -D__LIBRETRO__ -Wno-write-strings -DANDROID -DFRONTEND_SUPPORTS_RGB565 $(GLOBAL_DEFINES) $(INCDIR)
LOCAL_CFLAGS = -O3 -D__LIBRETRO__ -Wno-psabi -Wno-write-strings -DANDROID -DFRONTEND_SUPPORTS_RGB565 $(GLOBAL_DEFINES) $(INCDIR)
LOCAL_C_INCLUDES = -I$(CORE_DIR)/libretro/zlib -iquote $(CORE_DIR) -iquote $(CORE_DIR)/libretro
LOCAL_LDLIBS += -lz
include $(BUILD_SHARED_LIBRARY)
desmume/src/emufile.h 000664 001750 001750 00000020306 12755534123 015737 0 ustar 00sergio sergio 000000 000000 /*
The MIT License
Copyright (C) 2009-2014 DeSmuME team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
//don't use emufile for files bigger than 2GB! you have been warned! some day this will be fixed.
#ifndef EMUFILE_H
#define EMUFILE_H
#include
#include
#include
#include
#include
#include
#include
#include "types.h"
#ifdef HOST_WINDOWS
#include
#else
#include
#endif
class EMUFILE_MEMORY;
class EMUFILE {
protected:
bool failbit;
public:
EMUFILE()
: failbit(false)
{}
//returns a new EMUFILE which is guranteed to be in memory. the EMUFILE you call this on may be deleted. use the returned EMUFILE in its place
virtual EMUFILE* memwrap() = 0;
virtual ~EMUFILE() {}
static bool readAllBytes(std::vector* buf, const std::string& fname);
bool fail(bool unset=false) { bool ret = failbit; if(unset) unfail(); return ret; }
void unfail() { failbit=false; }
bool eof() { return size()==ftell(); }
size_t fread(const void *ptr, size_t bytes){
return _fread(ptr,bytes);
}
void unget() { fseek(-1,SEEK_CUR); }
//virtuals
public:
virtual FILE *get_fp() = 0;
virtual int fprintf(const char *format, ...) = 0;
virtual int fgetc() = 0;
virtual int fputc(int c) = 0;
virtual size_t _fread(const void *ptr, size_t bytes) = 0;
//removing these return values for now so we can find any code that might be using them and make sure
//they handle the return values correctly
virtual void fwrite(const void *ptr, size_t bytes) = 0;
void write64le(u64* val);
void write64le(u64 val);
size_t read64le(u64* val);
u64 read64le();
void write32le(u32* val);
void write32le(s32* val) { write32le((u32*)val); }
void write32le(u32 val);
size_t read32le(u32* val);
size_t read32le(s32* val);
u32 read32le();
void write16le(u16* val);
void write16le(s16* val) { write16le((u16*)val); }
void write16le(u16 val);
size_t read16le(s16* Bufo);
size_t read16le(u16* val);
u16 read16le();
void write8le(u8* val);
void write8le(u8 val);
size_t read8le(u8* val);
u8 read8le();
void writedouble(double* val);
void writedouble(double val);
double readdouble();
size_t readdouble(double* val);
virtual int fseek(int offset, int origin) = 0;
virtual int ftell() = 0;
virtual int size() = 0;
virtual void fflush() = 0;
virtual void truncate(s32 length) = 0;
void writeMemoryStream(EMUFILE_MEMORY* ms);
void readMemoryStream(EMUFILE_MEMORY* ms);
};
//todo - handle read-only specially?
class EMUFILE_MEMORY : public EMUFILE {
protected:
std::vector *vec;
bool ownvec;
s32 pos, len;
void reserve(u32 amt) {
if(vec->size() < amt)
vec->resize(amt);
}
public:
EMUFILE_MEMORY(std::vector *underlying) : vec(underlying), ownvec(false), pos(0), len((s32)underlying->size()) { }
EMUFILE_MEMORY(u32 preallocate) : vec(new std::vector()), ownvec(true), pos(0), len(0) {
vec->resize(preallocate);
len = preallocate;
}
EMUFILE_MEMORY() : vec(new std::vector()), ownvec(true), pos(0), len(0) { vec->reserve(1024); }
EMUFILE_MEMORY(void* buf, s32 size) : vec(new std::vector()), ownvec(true), pos(0), len(size) {
vec->resize(size);
if(size != 0)
memcpy(&vec->front(),buf,size);
}
~EMUFILE_MEMORY() {
if(ownvec) delete vec;
}
virtual EMUFILE* memwrap();
virtual void truncate(s32 length)
{
vec->resize(length);
len = length;
if(pos>length) pos=length;
}
u8* buf() {
if(size()==0) reserve(1);
return &(*vec)[0];
}
std::vector* get_vec() const { return vec; };
virtual FILE *get_fp() { return NULL; }
virtual int fprintf(const char *format, ...) {
std::va_list argptr;
va_start(argptr, format);
//we dont generate straight into the buffer because it will null terminate (one more byte than we want)
int amt = vsnprintf(0,0,format,argptr);
char* tempbuf = new char[amt+1];
va_end(argptr);
va_start(argptr, format);
vsprintf(tempbuf,format,argptr);
fwrite(tempbuf,amt);
delete[] tempbuf;
va_end(argptr);
return amt;
};
virtual int fgetc() {
u8 temp;
//need an optimized codepath
//if(_fread(&temp,1) != 1)
// return EOF;
//else return temp;
u32 remain = len-pos;
if(remain<1) {
failbit = true;
return -1;
}
temp = buf()[pos];
pos++;
return temp;
}
virtual int fputc(int c) {
u8 temp = (u8)c;
//TODO
//if(fwrite(&temp,1)!=1) return EOF;
fwrite(&temp,1);
return 0;
}
virtual size_t _fread(const void *ptr, size_t bytes);
//removing these return values for now so we can find any code that might be using them and make sure
//they handle the return values correctly
virtual void fwrite(const void *ptr, size_t bytes){
reserve(pos+(s32)bytes);
memcpy(buf()+pos,ptr,bytes);
pos += (s32)bytes;
len = std::max(pos,len);
}
virtual int fseek(int offset, int origin){
//work differently for read-only...?
switch(origin) {
case SEEK_SET:
pos = offset;
break;
case SEEK_CUR:
pos += offset;
break;
case SEEK_END:
pos = size()+offset;
break;
default:
assert(false);
}
reserve(pos);
return 0;
}
virtual int ftell() {
return pos;
}
virtual void fflush() {}
void trim()
{
vec->resize(len);
}
virtual int size() { return (int)len; }
};
class EMUFILE_FILE : public EMUFILE {
protected:
FILE* fp;
std::string fname;
char mode[16];
long mFilePosition;
bool mPositionCacheEnabled;
enum eCondition
{
eCondition_Clean,
eCondition_Unknown,
eCondition_Read,
eCondition_Write
} mCondition;
private:
void open(const char* fname, const char* mode)
{
mPositionCacheEnabled = false;
mCondition = eCondition_Clean;
fp = fopen(fname,mode);
if(!fp)
failbit = true;
this->fname = fname;
strcpy(this->mode,mode);
}
public:
EMUFILE_FILE(const std::string& fname, const char* mode) { open(fname.c_str(),mode); }
EMUFILE_FILE(const char* fname, const char* mode) { open(fname,mode); }
void EnablePositionCache();
virtual ~EMUFILE_FILE() {
if(NULL != fp)
fclose(fp);
}
virtual FILE *get_fp() {
return fp;
}
virtual EMUFILE* memwrap();
bool is_open() { return fp != NULL; }
void DemandCondition(eCondition cond);
virtual void truncate(s32 length);
virtual int fprintf(const char *format, ...) {
std::va_list argptr;
va_start(argptr, format);
int ret = ::vfprintf(fp, format, argptr);
va_end(argptr);
return ret;
};
virtual int fgetc() {
return ::fgetc(fp);
}
virtual int fputc(int c) {
return ::fputc(c, fp);
}
virtual size_t _fread(const void *ptr, size_t bytes);
//removing these return values for now so we can find any code that might be using them and make sure
//they handle the return values correctly
virtual void fwrite(const void *ptr, size_t bytes);
virtual int fseek(int offset, int origin);
virtual int ftell();
virtual int size() {
int oldpos = ftell();
fseek(0,SEEK_END);
int len = ftell();
fseek(oldpos,SEEK_SET);
return len;
}
virtual void fflush() {
::fflush(fp);
}
};
#endif
desmume/src/libretro-common/net/ 000700 001750 001750 00000000000 12756420131 020013 5 ustar 00sergio sergio 000000 000000 desmume/src/armcpu.h 000664 001750 001750 00000022472 12755534123 015606 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2006 yopyop
Copyright (C) 2006-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#ifndef ARM_CPU
#define ARM_CPU
#include "types.h"
#include "MMU.h"
#define CONDITION(i) ((i)>>28)
#define REG_POS(i,n) (((i)>>n) & 0xF)
#define CODE(i) (((i)>>25)&0x7)
#define OPCODE(i) (((i)>>21)&0xF)
#define SIGNEBIT(i) (((i)>>20) & 1)
#define EXCEPTION_RESET 0x00
#define EXCEPTION_UNDEFINED_INSTRUCTION 0x04
#define EXCEPTION_SWI 0x08
#define EXCEPTION_PREFETCH_ABORT 0x0C
#define EXCEPTION_DATA_ABORT 0x10
#define EXCEPTION_RESERVED_0x14 0x14
#define EXCEPTION_IRQ 0x18
#define EXCEPTION_FAST_IRQ 0x1C
#define INSTRUCTION_INDEX(i) ((((i)>>16)&0xFF0)|(((i)>>4)&0xF))
inline u32 ROR(u32 i, u32 j) { return ((((u32)(i))>>(j)) | (((u32)(i))<<(32-(j)))); }
template
inline T UNSIGNED_OVERFLOW(T a,T b,T c) { return BIT31(((a)&(b)) | (((a)|(b))&(~c))); }
template
inline T UNSIGNED_UNDERFLOW(T a,T b,T c) { return BIT31(((~a)&(b)) | (((~a)|(b))&(c))); }
template
inline T SIGNED_OVERFLOW(T a,T b,T c) { return BIT31(((a)&(b)&(~c)) | ((~a)&(~(b))&(c))); }
template
inline T SIGNED_UNDERFLOW(T a,T b,T c) { return BIT31(((a)&(~(b))&(~c)) | ((~a)&(b)&(c))); }
#if !defined(bswap32)
#define bswap32(val) \
( (val << 24) & 0xFF000000) | \
( (val << 8) & 0x00FF0000) | \
( (val >> 8) & 0x0000FF00) | \
( (val >> 24) & 0x000000FF)
#endif
#if !defined(bswap64)
#define bswap64(x) \
( (x << 56) & 0xff00000000000000ULL ) | \
( (x << 40) & 0x00ff000000000000ULL ) | \
( (x << 24) & 0x0000ff0000000000ULL ) | \
( (x << 8) & 0x000000ff00000000ULL ) | \
( (x >> 8) & 0x00000000ff000000ULL ) | \
( (x >> 24) & 0x0000000000ff0000ULL ) | \
( (x >> 40) & 0x000000000000ff00ULL ) | \
( (x >> 56) & 0x00000000000000ffULL )
#endif
// ============================= CPRS flags funcs
inline bool CarryFrom(s32 left, s32 right)
{
u32 res = (0xFFFFFFFFU - (u32)left);
return ((u32)right > res);
}
inline bool BorrowFrom(s32 left, s32 right)
{
return ((u32)right > (u32)left);
}
inline bool OverflowFromADD(s32 alu_out, s32 left, s32 right)
{
return ((left >= 0 && right >= 0) || (left < 0 && right < 0))
&& ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
}
inline bool OverflowFromSUB(s32 alu_out, s32 left, s32 right)
{
return ((left < 0 && right >= 0) || (left >= 0 && right < 0))
&& ((left < 0 && alu_out >= 0) || (left >= 0 && alu_out < 0));
}
//zero 15-feb-2009 - these werent getting used and they were getting in my way
//#define EQ 0x0
//#define NE 0x1
//#define CS 0x2
//#define CC 0x3
//#define MI 0x4
//#define PL 0x5
//#define VS 0x6
//#define VC 0x7
//#define HI 0x8
//#define LS 0x9
//#define GE 0xA
//#define LT 0xB
//#define GT 0xC
//#define LE 0xD
//#define AL 0xE
static const u8 arm_cond_table[16*16] = {
// N=0, Z=0, C=0, V=0
0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF, // 0x00
0x00,0xFF,0xFF,0x00,0xFF,0x00,0xFF,0x20, // 0x00
// N=0, Z=0, C=0, V=1
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x00, // 0x10
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=0, Z=0, C=1, V=0
0x00,0xFF,0xFF,0x00,0x00,0xFF,0x00,0xFF, // 0x20
0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x20,
// N=0, Z=0, C=1, V=1
0x00,0xFF,0xFF,0x00,0x00,0xFF,0xFF,0x00, // 0x30
0xFF,0x00,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=0, Z=1, C=0, V=0
0xFF,0x00,0x00,0xFF,0x00,0xFF,0x00,0xFF, // 0x40
0x00,0xFF,0xFF,0x00,0x00,0xFF,0xFF,0x20,
// N=0, Z=1, C=0, V=1
0xFF,0x00,0x00,0xFF,0x00,0xFF,0xFF,0x00, // 0x50
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=0, Z=1, C=1, V=0
0xFF,0x00,0xFF,0x00,0x00,0xFF,0x00,0xFF, // 0x60
0x00,0xFF,0xFF,0x00,0x00,0xFF,0xFF,0x20,
// N=0, Z=1, C=1, V=1
0xFF,0x00,0xFF,0x00,0x00,0xFF,0xFF,0x00, // 0x70
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=1, Z=0, C=0, V=0
0x00,0xFF,0x00,0xFF,0xFF,0x00,0x00,0xFF, // 0x80
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=1, Z=0, C=0, V=1
0x00,0xFF,0x00,0xFF,0xFF,0x00,0xFF,0x00, // 0x90
0x00,0xFF,0xFF,0x00,0xFF,0x00,0xFF,0x20,
// N=1, Z=0, C=1, V=0
0x00,0xFF,0xFF,0x00,0xFF,0x00,0x00,0xFF, // 0xA0
0xFF,0x00,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=1, Z=0, C=1, V=1
0x00,0xFF,0xFF,0x00,0xFF,0x00,0xFF,0x00, // 0xB0
0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x20,
// N=1, Z=1, C=0, V=0
0xFF,0x00,0x00,0xFF,0xFF,0x00,0x00,0xFF, // 0xC0
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=1, Z=1, C=0, V=1
0xFF,0x00,0x00,0xFF,0xFF,0x00,0xFF,0x00, // 0xD0
0x00,0xFF,0xFF,0x00,0x00,0xFF,0xFF,0x20,
// N=1, Z=1, C=1, V=0
0xFF,0x00,0xFF,0x00,0xFF,0x00,0x00,0xFF, // 0xE0
0x00,0xFF,0x00,0xFF,0x00,0xFF,0xFF,0x20,
// N=1, Z=1, C=1, V=1
0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00, // 0xF0
0x00,0xFF,0xFF,0x00,0x00,0xFF,0xFF,0x20
};
#define TEST_COND(cond, inst, CPSR) ((arm_cond_table[((CPSR.val >> 24) & 0xf0)|(cond)]) & (1 << (inst)))
enum Mode
{
USR = 0x10,
FIQ = 0x11,
IRQ = 0x12,
SVC = 0x13,
ABT = 0x17,
UND = 0x1B,
SYS = 0x1F
};
typedef union
{
struct
{
#ifdef MSB_FIRST
u32 N : 1,
Z : 1,
C : 1,
V : 1,
Q : 1,
RAZ : 19,
I : 1,
F : 1,
T : 1,
mode : 5;
#else
u32 mode : 5,
T : 1,
F : 1,
I : 1,
RAZ : 19,
Q : 1,
V : 1,
C : 1,
Z : 1,
N : 1;
#endif
} bits;
u32 val;
} Status_Reg;
/**
* The control interface to a CPU
*/
struct armcpu_ctrl_iface
{
/** stall the processor */
void (*stall)( void *instance);
/** unstall the processor */
void (*unstall)( void *instance);
/** read a register value */
u32 (*read_reg)( void *instance, u32 reg_num);
/** set a register value */
void (*set_reg)( void *instance, u32 reg_num, u32 value);
/** install the post execute function */
void (*install_post_ex_fn)( void *instance,
void (*fn)( void *, u32 adr, int thumb),
void *fn_data);
/** remove the post execute function */
void (*remove_post_ex_fn)( void *instance);
/** the private data passed to all interface functions */
void *data;
};
typedef void* armcp_t;
struct armcpu_t
{
u32 proc_ID;
u32 instruction; //4
u32 instruct_adr; //8
u32 next_instruction; //12
u32 R[16]; //16
Status_Reg CPSR; //80
Status_Reg SPSR;
void SetControlInterface(const armcpu_ctrl_iface *theCtrlInterface);
armcpu_ctrl_iface* GetControlInterface();
void SetControlInterfaceData(void *theData);
void* GetControlInterfaceData();
void SetCurrentMemoryInterface(armcpu_memory_iface *theMemInterface);
armcpu_memory_iface* GetCurrentMemoryInterface();
void SetCurrentMemoryInterfaceData(void *theData);
void* GetCurrentMemoryInterfaceData();
void SetBaseMemoryInterface(const armcpu_memory_iface *theMemInterface);
armcpu_memory_iface* GetBaseMemoryInterface();
void SetBaseMemoryInterfaceData(void *theData);
void* GetBaseMemoryInterfaceData();
void ResetMemoryInterfaceToBase();
void changeCPSR();
u32 R13_usr, R14_usr;
u32 R13_svc, R14_svc;
u32 R13_abt, R14_abt;
u32 R13_und, R14_und;
u32 R13_irq, R14_irq;
u32 R8_fiq, R9_fiq, R10_fiq, R11_fiq, R12_fiq, R13_fiq, R14_fiq;
Status_Reg SPSR_svc, SPSR_abt, SPSR_und, SPSR_irq, SPSR_fiq;
u32 intVector;
u8 LDTBit; //1 : ARMv5 style 0 : non ARMv5 (earlier)
BOOL waitIRQ;
BOOL halt_IE_and_IF; //the cpu is halted, waiting for IE&IF to signal something
u8 intrWaitARM_state;
BOOL BIOS_loaded;
u32 (* *swi_tab)();
// flag indicating if the processor is stalled (for debugging)
int stalled;
#if defined(_M_X64) || defined(__x86_64__)
u8 cond_table[16*16];
#endif
/** there is a pending irq for the cpu */
int irq_flag;
/** the post executed function (if installed) */
void (*post_ex_fn)( void *, u32 adr, int thumb);
/** data for the post executed function */
void *post_ex_fn_data;
/** the memory interface */
armcpu_memory_iface *mem_if; // This is the memory interface currently in use.
armcpu_memory_iface base_mem_if; // This is the CPU's base memory interface.
/** the ctrl interface */
armcpu_ctrl_iface ctrl_iface;
};
int armcpu_new( armcpu_t *armcpu, u32 id);
void armcpu_init(armcpu_t *armcpu, u32 adr);
u32 armcpu_switchMode(armcpu_t *armcpu, u8 mode);
BOOL armcpu_irqException(armcpu_t *armcpu);
BOOL armcpu_flagIrq( armcpu_t *armcpu);
void armcpu_exception(armcpu_t *cpu, u32 number);
u32 TRAPUNDEF(armcpu_t* cpu);
u32 armcpu_Wait4IRQ(armcpu_t *cpu);
extern armcpu_t NDS_ARM7;
extern armcpu_t NDS_ARM9;
extern const armcpu_ctrl_iface arm_default_ctrl_iface;
template u32 armcpu_exec();
#ifdef HAVE_JIT
template u32 armcpu_exec();
#endif
void setIF(int PROCNUM, u32 flag);
static INLINE void NDS_makeIrq(int PROCNUM, u32 num)
{
setIF(PROCNUM,1<
#endif
#endif
#endif
desmume/src/libretro-common/ 000700 001750 001750 00000000000 12756420131 017225 5 ustar 00sergio sergio 000000 000000 desmume/src/cp15.h 000664 001750 001750 00000010443 12755534123 015062 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2006 yopyop
Copyright (C) 2006-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#ifndef __CP15_H__
#define __CP15_H__
#include
#include "types.h"
class EMUFILE;
#define CP15_ACCESS_WRITE 0
#define CP15_ACCESS_READ 2
#define CP15_ACCESS_EXECUTE 4
#define CP15_ACCESS_WRITEUSR CP15_ACCESS_WRITE
#define CP15_ACCESS_WRITESYS 1
#define CP15_ACCESS_READUSR CP15_ACCESS_READ
#define CP15_ACCESS_READSYS 3
#define CP15_ACCESS_EXECUSR CP15_ACCESS_EXECUTE
#define CP15_ACCESS_EXECSYS 5
#define CP15_SIZEBINARY(val) (1 << (CP15_SIZEIDENTIFIER(val)+1))
#define CP15_SIZEIDENTIFIER(val) ((((val) >> 1) & 0x1F))
#define CP15_MASKFROMREG(val) (~((CP15_SIZEBINARY(val)-1) | 0x3F))
#define CP15_SETFROMREG(val) ((val) & CP15_MASKFROMREG(val))
struct armcp15_t
{
public:
u32 IDCode;
u32 cacheType;
u32 TCMSize;
u32 ctrl;
u32 DCConfig;
u32 ICConfig;
u32 writeBuffCtrl;
u32 und;
u32 DaccessPerm;
u32 IaccessPerm;
u32 protectBaseSize[8];
u32 cacheOp;
u32 DcacheLock;
u32 IcacheLock;
u32 ITCMRegion;
u32 DTCMRegion;
u32 processID;
u32 RAM_TAG;
u32 testState;
u32 cacheDbg;
/* calculated bitmasks for the regions to decide rights uppon */
/* calculation is done in the MCR instead of on mem access for performance */
u32 regionWriteMask_USR[8] ;
u32 regionWriteMask_SYS[8] ;
u32 regionReadMask_USR[8] ;
u32 regionReadMask_SYS[8] ;
u32 regionExecuteMask_USR[8] ;
u32 regionExecuteMask_SYS[8] ;
u32 regionWriteSet_USR[8] ;
u32 regionWriteSet_SYS[8] ;
u32 regionReadSet_USR[8] ;
u32 regionReadSet_SYS[8] ;
u32 regionExecuteSet_USR[8] ;
u32 regionExecuteSet_SYS[8] ;
void setSingleRegionAccess(u8 num, u32 mask, u32 set);
void maskPrecalc();
public:
armcp15_t() : IDCode(0x41059461),
cacheType(0x0F0D2112),
TCMSize(0x00140180),
ctrl(0x00012078),
DCConfig(0),
ICConfig(0),
writeBuffCtrl(0),
und(0),
DaccessPerm(0x22222222),
IaccessPerm(0x22222222),
cacheOp(0),
DcacheLock(0),
IcacheLock(0),
ITCMRegion(0x0C),
DTCMRegion(0x0080000A),
processID(0),
RAM_TAG(0),
testState(0),
cacheDbg(0)
{
//printf("CP15 Reset\n");
memset(&protectBaseSize[0], 0, sizeof(protectBaseSize));
memset(®ionWriteMask_USR[0], 0, sizeof(regionWriteMask_USR));
memset(®ionWriteMask_SYS[0], 0, sizeof(regionWriteMask_SYS));
memset(®ionReadMask_USR[0], 0, sizeof(regionReadMask_USR));
memset(®ionReadMask_SYS[0], 0, sizeof(regionReadMask_SYS));
memset(®ionExecuteMask_USR[0], 0, sizeof(regionExecuteMask_USR));
memset(®ionExecuteMask_SYS[0], 0, sizeof(regionExecuteMask_SYS));
memset(®ionWriteSet_USR[0], 0, sizeof(regionWriteSet_USR));
memset(®ionWriteSet_SYS[0], 0, sizeof(regionWriteSet_SYS));
memset(®ionReadSet_USR[0], 0, sizeof(regionReadSet_USR));
memset(®ionReadSet_SYS[0], 0, sizeof(regionReadSet_SYS));
memset(®ionExecuteSet_USR[0], 0, sizeof(regionExecuteSet_USR));
memset(®ionExecuteSet_SYS[0], 0, sizeof(regionExecuteSet_SYS));
}
BOOL dataProcess(u8 CRd, u8 CRn, u8 CRm, u8 opcode1, u8 opcode2);
BOOL load(u8 CRd, u8 adr);
BOOL store(u8 CRd, u8 adr);
BOOL moveCP2ARM(u32 * R, u8 CRn, u8 CRm, u8 opcode1, u8 opcode2);
BOOL moveARM2CP(u32 val, u8 CRn, u8 CRm, u8 opcode1, u8 opcode2);
BOOL isAccessAllowed(u32 address,u32 access);
// savestate
void saveone(EMUFILE* os);
bool loadone(EMUFILE* is);
};
extern armcp15_t cp15;
#endif /* __CP15_H__*/
desmume/src/libretro-common/utils/sha1.c 000664 001750 001750 00000036013 12755534123 021412 0 ustar 00sergio sergio 000000 000000 /*
* sha1.h
*
* Copyright (C) 1998, 2009
* Paul E. Jones
* All Rights Reserved
*
*****************************************************************************
* $Id: sha1.h 12 2009-06-22 19:34:25Z paulej $
*****************************************************************************
*
* Description:
* This class implements the Secure Hashing Standard as defined
* in FIPS PUB 180-1 published April 17, 1995.
*
* Many of the variable names in the SHA1Context, especially the
* single character names, were used because those were the names
* used in the publication.
*
* Please read the file sha1.c for more information.
*
*/
#ifndef _SHA1_H_
#define _SHA1_H_
/*
* This structure will hold context information for the hashing
* operation
*/
typedef struct SHA1Context
{
unsigned Message_Digest[5]; /* Message Digest (output) */
unsigned Length_Low; /* Message length in bits */
unsigned Length_High; /* Message length in bits */
unsigned char Message_Block[64]; /* 512-bit message blocks */
int Message_Block_Index; /* Index into message block array */
int Computed; /* Is the digest computed? */
int Corrupted; /* Is the message digest corruped? */
} SHA1Context;
/*
* Function Prototypes
*/
void SHA1Reset(SHA1Context *);
int SHA1Result(SHA1Context *);
void SHA1Input( SHA1Context *,
const unsigned char *,
unsigned);
#endif
/*
* sha1.c
*
* Copyright (C) 1998, 2009
* Paul E. Jones
* All Rights Reserved
*
*****************************************************************************
* $Id: sha1.c 12 2009-06-22 19:34:25Z paulej $
*****************************************************************************
*
* Description:
* This file implements the Secure Hashing Standard as defined
* in FIPS PUB 180-1 published April 17, 1995.
*
* The Secure Hashing Standard, which uses the Secure Hashing
* Algorithm (SHA), produces a 160-bit message digest for a
* given data stream. In theory, it is highly improbable that
* two messages will produce the same message digest. Therefore,
* this algorithm can serve as a means of providing a "fingerprint"
* for a message.
*
* Portability Issues:
* SHA-1 is defined in terms of 32-bit "words". This code was
* written with the expectation that the processor has at least
* a 32-bit machine word size. If the machine word size is larger,
* the code should still function properly. One caveat to that
* is that the input functions taking characters and character
* arrays assume that only 8 bits of information are stored in each
* character.
*
* Caveats:
* SHA-1 is designed to work with messages less than 2^64 bits
* long. Although SHA-1 allows a message digest to be generated for
* messages of any number of bits less than 2^64, this
* implementation only works with messages with a length that is a
* multiple of the size of an 8-bit character.
*
*/
/*#include "sha1.h"*/
/*
* Define the circular shift macro
*/
#define SHA1CircularShift(bits,word) \
((((word) << (bits)) & 0xFFFFFFFF) | \
((word) >> (32-(bits))))
/* Function prototypes */
void SHA1ProcessMessageBlock(SHA1Context *);
void SHA1PadMessage(SHA1Context *);
/*
* SHA1Reset
*
* Description:
* This function will initialize the SHA1Context in preparation
* for computing a new message digest.
*
* Parameters:
* context: [in/out]
* The context to reset.
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void SHA1Reset(SHA1Context *context)
{
context->Length_Low = 0;
context->Length_High = 0;
context->Message_Block_Index = 0;
context->Message_Digest[0] = 0x67452301;
context->Message_Digest[1] = 0xEFCDAB89;
context->Message_Digest[2] = 0x98BADCFE;
context->Message_Digest[3] = 0x10325476;
context->Message_Digest[4] = 0xC3D2E1F0;
context->Computed = 0;
context->Corrupted = 0;
}
/*
* SHA1Result
*
* Description:
* This function will return the 160-bit message digest into the
* Message_Digest array within the SHA1Context provided
*
* Parameters:
* context: [in/out]
* The context to use to calculate the SHA-1 hash.
*
* Returns:
* 1 if successful, 0 if it failed.
*
* Comments:
*
*/
int SHA1Result(SHA1Context *context)
{
if (context->Corrupted)
return 0;
if (!context->Computed)
{
SHA1PadMessage(context);
context->Computed = 1;
}
return 1;
}
/*
* SHA1Input
*
* Description:
* This function accepts an array of octets as the next portion of
* the message.
*
* Parameters:
* context: [in/out]
* The SHA-1 context to update
* message_array: [in]
* An array of characters representing the next portion of the
* message.
* length: [in]
* The length of the message in message_array
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void SHA1Input( SHA1Context *context,
const unsigned char *message_array,
unsigned length)
{
if (!length)
return;
if (context->Computed || context->Corrupted)
{
context->Corrupted = 1;
return;
}
while(length-- && !context->Corrupted)
{
context->Message_Block[context->Message_Block_Index++] =
(*message_array & 0xFF);
context->Length_Low += 8;
/* Force it to 32 bits */
context->Length_Low &= 0xFFFFFFFF;
if (context->Length_Low == 0)
{
context->Length_High++;
/* Force it to 32 bits */
context->Length_High &= 0xFFFFFFFF;
if (context->Length_High == 0)
{
/* Message is too long */
context->Corrupted = 1;
}
}
if (context->Message_Block_Index == 64)
SHA1ProcessMessageBlock(context);
message_array++;
}
}
/*
* SHA1ProcessMessageBlock
*
* Description:
* This function will process the next 512 bits of the message
* stored in the Message_Block array.
*
* Parameters:
* None.
*
* Returns:
* Nothing.
*
* Comments:
* Many of the variable names in the SHAContext, especially the
* single character names, were used because those were the names
* used in the publication.
*
*
*/
void SHA1ProcessMessageBlock(SHA1Context *context)
{
const unsigned K[] = /* Constants defined in SHA-1 */
{
0x5A827999,
0x6ED9EBA1,
0x8F1BBCDC,
0xCA62C1D6
};
int t; /* Loop counter */
unsigned temp; /* Temporary word value */
unsigned W[80]; /* Word sequence */
unsigned A, B, C, D, E; /* Word buffers */
/*
* Initialize the first 16 words in the array W
*/
for(t = 0; t < 16; t++)
{
W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
}
for(t = 16; t < 80; t++)
{
W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
}
A = context->Message_Digest[0];
B = context->Message_Digest[1];
C = context->Message_Digest[2];
D = context->Message_Digest[3];
E = context->Message_Digest[4];
for(t = 0; t < 20; t++)
{
temp = SHA1CircularShift(5,A) +
((B & C) | ((~B) & D)) + E + W[t] + K[0];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 20; t < 40; t++)
{
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 40; t < 60; t++)
{
temp = SHA1CircularShift(5,A) +
((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
for(t = 60; t < 80; t++)
{
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = SHA1CircularShift(30,B);
B = A;
A = temp;
}
context->Message_Digest[0] =
(context->Message_Digest[0] + A) & 0xFFFFFFFF;
context->Message_Digest[1] =
(context->Message_Digest[1] + B) & 0xFFFFFFFF;
context->Message_Digest[2] =
(context->Message_Digest[2] + C) & 0xFFFFFFFF;
context->Message_Digest[3] =
(context->Message_Digest[3] + D) & 0xFFFFFFFF;
context->Message_Digest[4] =
(context->Message_Digest[4] + E) & 0xFFFFFFFF;
context->Message_Block_Index = 0;
}
/*
* SHA1PadMessage
*
* Description:
* According to the standard, the message must be padded to an even
* 512 bits. The first padding bit must be a '1'. The last 64
* bits represent the length of the original message. All bits in
* between should be 0. This function will pad the message
* according to those rules by filling the Message_Block array
* accordingly. It will also call SHA1ProcessMessageBlock()
* appropriately. When it returns, it can be assumed that the
* message digest has been computed.
*
* Parameters:
* context: [in/out]
* The context to pad
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void SHA1PadMessage(SHA1Context *context)
{
/*
* Check to see if the current message block is too small to hold
* the initial padding bits and length. If so, we will pad the
* block, process it, and then continue padding into a second
* block.
*/
if (context->Message_Block_Index > 55)
{
context->Message_Block[context->Message_Block_Index++] = 0x80;
while(context->Message_Block_Index < 64)
context->Message_Block[context->Message_Block_Index++] = 0;
SHA1ProcessMessageBlock(context);
while(context->Message_Block_Index < 56)
context->Message_Block[context->Message_Block_Index++] = 0;
}
else
{
context->Message_Block[context->Message_Block_Index++] = 0x80;
while(context->Message_Block_Index < 56)
context->Message_Block[context->Message_Block_Index++] = 0;
}
/*
* Store the message length as the last 8 octets
*/
context->Message_Block[56] = (context->Length_High >> 24) & 0xFF;
context->Message_Block[57] = (context->Length_High >> 16) & 0xFF;
context->Message_Block[58] = (context->Length_High >> 8) & 0xFF;
context->Message_Block[59] = (context->Length_High) & 0xFF;
context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF;
context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF;
context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF;
context->Message_Block[63] = (context->Length_Low) & 0xFF;
SHA1ProcessMessageBlock(context);
}
/*
* sha.cpp
*
* Copyright (C) 1998, 2009
* Paul E. Jones
* All Rights Reserved
*
*****************************************************************************
* $Id: sha.c 12 2009-06-22 19:34:25Z paulej $
*****************************************************************************
*
* Description:
* This utility will display the message digest (fingerprint) for
* the specified file(s).
*
* Portability Issues:
* None.
*/
#include
#include
#ifdef WIN32
#include
#endif
#include
/*#include "sha1.h"*/
/*
* Function prototype
*/
void usage(void);
/*
* main
*
* Description:
* This is the entry point for the program
*
* Parameters:
* argc: [in]
* This is the count of arguments in the argv array
* argv: [in]
* This is an array of filenames for which to compute message
* digests
*
* Returns:
* Nothing.
*
* Comments:
*
*/
int main(int argc, char *argv[])
{
SHA1Context sha; /* SHA-1 context */
FILE *fp; /* File pointer for reading files*/
char c; /* Character read from file */
int i; /* Counter */
int reading_stdin; /* Are we reading standard in? */
int read_stdin = 0; /* Have we read stdin? */
/*
* Check the program arguments and print usage information if -?
* or --help is passed as the first argument.
*/
if (argc > 1 && (!strcmp(argv[1],"-?") ||
!strcmp(argv[1],"--help")))
{
usage();
return 1;
}
/*
* For each filename passed in on the command line, calculate the
* SHA-1 value and display it.
*/
for(i = 0; i < argc; i++)
{
/*
* We start the counter at 0 to guarantee entry into the for
* loop. So if 'i' is zero, we will increment it now. If there
* is no argv[1], we will use STDIN below.
*/
if (i == 0)
i++;
if (argc == 1 || !strcmp(argv[i],"-"))
{
#ifdef WIN32
setmode(fileno(stdin), _O_BINARY);
#endif
fp = stdin;
reading_stdin = 1;
}
else
{
if (!(fp = fopen(argv[i],"rb")))
{
fprintf(stderr,
"sha: unable to open file %s\n",
argv[i]);
return 2;
}
reading_stdin = 0;
}
/*
* We do not want to read STDIN multiple times
*/
if (reading_stdin)
{
if (read_stdin)
continue;
read_stdin = 1;
}
/*
* Reset the SHA-1 context and process input
*/
SHA1Reset(&sha);
c = fgetc(fp);
while(!feof(fp))
{
SHA1Input(&sha, &c, 1);
c = fgetc(fp);
}
if (!reading_stdin)
fclose(fp);
if (!SHA1Result(&sha))
{
fprintf(stderr,
"sha: could not compute message digest for %s\n",
reading_stdin?"STDIN":argv[i]);
}
else
{
printf( "%08X %08X %08X %08X %08X - %s\n",
sha.Message_Digest[0],
sha.Message_Digest[1],
sha.Message_Digest[2],
sha.Message_Digest[3],
sha.Message_Digest[4],
reading_stdin?"STDIN":argv[i]);
}
}
return 0;
}
/*
* usage
*
* Description:
* This function will display program usage information to the
* user.
*
* Parameters:
* None.
*
* Returns:
* Nothing.
*
* Comments:
*
*/
void usage(void)
{
printf("usage: sha [ ...]\n");
printf("\tThis program will display the message digest\n");
printf("\tfor files using the Secure Hashing Algorithm (SHA-1).\n");
}
desmume/src/libretro-common/formats/png/ 000700 001750 001750 00000000000 12756420131 021464 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/include/string/ 000700 001750 001750 00000000000 12756420131 022156 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/gfx/math/ 000700 001750 001750 00000000000 12756420131 020742 5 ustar 00sergio sergio 000000 000000 desmume/src/libretro-common/gfx/scaler/scaler.c 000664 001750 001750 00000024611 12755534123 022725 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (scaler.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include
#include
#include
#include
#include
#include
#include
#include
/**
* scaler_alloc:
* @elem_size : size of the elements to be used.
* @siz : size of the image that the scaler needs to handle.
*
* Allocate and returns a scaler object.
*
* Returns: pointer to a scaler object of type 'void *' on success,
* NULL in case of error. Has to be freed manually.
**/
void *scaler_alloc(size_t elem_size, size_t size)
{
void *ptr = calloc(elem_size, size);
if (!ptr)
return NULL;
return ptr;
}
/**
* scaler_free:
* @ptr : pointer to scaler object.
*
* Frees a scaler object.
**/
void scaler_free(void *ptr)
{
if (ptr)
free(ptr);
}
static bool allocate_frames(struct scaler_ctx *ctx)
{
ctx->scaled.stride = ((ctx->out_width + 7) & ~7) * sizeof(uint64_t);
ctx->scaled.width = ctx->out_width;
ctx->scaled.height = ctx->in_height;
ctx->scaled.frame = (uint64_t*)
scaler_alloc(sizeof(uint64_t),
(ctx->scaled.stride * ctx->scaled.height) >> 3);
if (!ctx->scaled.frame)
return false;
if (ctx->in_fmt != SCALER_FMT_ARGB8888)
{
ctx->input.stride = ((ctx->in_width + 7) & ~7) * sizeof(uint32_t);
ctx->input.frame = (uint32_t*)
scaler_alloc(sizeof(uint32_t),
(ctx->input.stride * ctx->in_height) >> 2);
if (!ctx->input.frame)
return false;
}
if (ctx->out_fmt != SCALER_FMT_ARGB8888)
{
ctx->output.stride = ((ctx->out_width + 7) & ~7) * sizeof(uint32_t);
ctx->output.frame = (uint32_t*)
scaler_alloc(sizeof(uint32_t),
(ctx->output.stride * ctx->out_height) >> 2);
if (!ctx->output.frame)
return false;
}
return true;
}
/**
* set_direct_pix_conv:
* @ctx : pointer to scaler context object.
*
* Bind a pixel converter callback function to the 'direct_pixconv' function pointer
* of the scaler context object.
*
* Returns: true if a pixel converter function callback could be bound, false if not.
* If false, the function callback 'direct_pixconv' is still unbound.
**/
static bool set_direct_pix_conv(struct scaler_ctx *ctx)
{
if (ctx->in_fmt == ctx->out_fmt)
{
ctx->direct_pixconv = conv_copy;
return true;
}
switch (ctx->in_fmt)
{
case SCALER_FMT_0RGB1555:
switch (ctx->out_fmt)
{
case SCALER_FMT_ARGB8888:
ctx->direct_pixconv = conv_0rgb1555_argb8888;
break;
case SCALER_FMT_RGB565:
ctx->direct_pixconv = conv_0rgb1555_rgb565;
break;
case SCALER_FMT_BGR24:
ctx->direct_pixconv = conv_0rgb1555_bgr24;
break;
default:
break;
}
break;
case SCALER_FMT_RGB565:
switch (ctx->out_fmt)
{
case SCALER_FMT_ARGB8888:
ctx->direct_pixconv = conv_rgb565_argb8888;
break;
case SCALER_FMT_BGR24:
ctx->direct_pixconv = conv_rgb565_bgr24;
break;
case SCALER_FMT_0RGB1555:
ctx->direct_pixconv = conv_rgb565_0rgb1555;
break;
default:
break;
}
break;
case SCALER_FMT_BGR24:
switch (ctx->out_fmt)
{
case SCALER_FMT_ARGB8888:
ctx->direct_pixconv = conv_bgr24_argb8888;
break;
default:
break;
}
break;
case SCALER_FMT_ARGB8888:
switch (ctx->out_fmt)
{
case SCALER_FMT_0RGB1555:
ctx->direct_pixconv = conv_argb8888_0rgb1555;
break;
case SCALER_FMT_BGR24:
ctx->direct_pixconv = conv_argb8888_bgr24;
break;
case SCALER_FMT_ABGR8888:
ctx->direct_pixconv = conv_argb8888_abgr8888;
break;
case SCALER_FMT_RGBA4444:
ctx->direct_pixconv = conv_argb8888_rgba4444;
break;
default:
break;
}
break;
case SCALER_FMT_YUYV:
switch (ctx->out_fmt)
{
case SCALER_FMT_ARGB8888:
ctx->direct_pixconv = conv_yuyv_argb8888;
break;
default:
break;
}
break;
case SCALER_FMT_RGBA4444:
switch (ctx->out_fmt)
{
case SCALER_FMT_ARGB8888:
ctx->direct_pixconv = conv_rgba4444_argb8888;
break;
case SCALER_FMT_RGB565:
ctx->direct_pixconv = conv_rgba4444_rgb565;
break;
default:
break;
}
break;
case SCALER_FMT_ABGR8888:
/* FIXME/TODO */
break;
}
if (!ctx->direct_pixconv)
return false;
return true;
}
static bool set_pix_conv(struct scaler_ctx *ctx)
{
switch (ctx->in_fmt)
{
case SCALER_FMT_ARGB8888:
/* No need to convert :D */
break;
case SCALER_FMT_0RGB1555:
ctx->in_pixconv = conv_0rgb1555_argb8888;
break;
case SCALER_FMT_RGB565:
ctx->in_pixconv = conv_rgb565_argb8888;
break;
case SCALER_FMT_BGR24:
ctx->in_pixconv = conv_bgr24_argb8888;
break;
case SCALER_FMT_RGBA4444:
ctx->in_pixconv = conv_rgba4444_argb8888;
break;
default:
return false;
}
switch (ctx->out_fmt)
{
case SCALER_FMT_ARGB8888:
/* No need to convert :D */
break;
case SCALER_FMT_RGBA4444:
ctx->out_pixconv = conv_argb8888_rgba4444;
break;
case SCALER_FMT_0RGB1555:
ctx->out_pixconv = conv_argb8888_0rgb1555;
break;
case SCALER_FMT_BGR24:
ctx->out_pixconv = conv_argb8888_bgr24;
break;
default:
return false;
}
return true;
}
bool scaler_ctx_gen_filter(struct scaler_ctx *ctx)
{
scaler_ctx_gen_reset(ctx);
if (ctx->in_width == ctx->out_width && ctx->in_height == ctx->out_height)
ctx->unscaled = true; /* Only pixel format conversion ... */
else
{
ctx->scaler_horiz = scaler_argb8888_horiz;
ctx->scaler_vert = scaler_argb8888_vert;
ctx->unscaled = false;
}
ctx->scaler_special = NULL;
if (!allocate_frames(ctx))
return false;
if (ctx->unscaled)
{
if (!set_direct_pix_conv(ctx))
return false;
}
else
{
if (!set_pix_conv(ctx))
return false;
}
if (!ctx->unscaled && !scaler_gen_filter(ctx))
return false;
return true;
}
void scaler_ctx_gen_reset(struct scaler_ctx *ctx)
{
scaler_free(ctx->horiz.filter);
scaler_free(ctx->horiz.filter_pos);
scaler_free(ctx->vert.filter);
scaler_free(ctx->vert.filter_pos);
scaler_free(ctx->scaled.frame);
scaler_free(ctx->input.frame);
scaler_free(ctx->output.frame);
memset(&ctx->horiz, 0, sizeof(ctx->horiz));
memset(&ctx->vert, 0, sizeof(ctx->vert));
memset(&ctx->scaled, 0, sizeof(ctx->scaled));
memset(&ctx->input, 0, sizeof(ctx->input));
memset(&ctx->output, 0, sizeof(ctx->output));
}
/**
* scaler_ctx_scale:
* @ctx : pointer to scaler context object.
* @output : pointer to output image.
* @input : pointer to input image.
*
* Scales an input image to an output image.
**/
void scaler_ctx_scale(struct scaler_ctx *ctx,
void *output, const void *input)
{
const void *input_frame = input;
void *output_frame = output;
int input_stride = ctx->in_stride;
int output_stride = ctx->out_stride;
if (ctx->unscaled)
{
/* Just perform straight pixel conversion. */
ctx->direct_pixconv(output, input,
ctx->out_width, ctx->out_height,
ctx->out_stride, ctx->in_stride);
return;
}
if (ctx->in_fmt != SCALER_FMT_ARGB8888)
{
ctx->in_pixconv(ctx->input.frame, input,
ctx->in_width, ctx->in_height,
ctx->input.stride, ctx->in_stride);
input_frame = ctx->input.frame;
input_stride = ctx->input.stride;
}
if (ctx->out_fmt != SCALER_FMT_ARGB8888)
{
output_frame = ctx->output.frame;
output_stride = ctx->output.stride;
}
if (ctx->scaler_special)
{
/* Take some special, and (hopefully) more optimized path. */
ctx->scaler_special(ctx, output_frame, input_frame,
ctx->out_width, ctx->out_height,
ctx->in_width, ctx->in_height,
output_stride, input_stride);
}
else
{
/* Take generic filter path. */
if (ctx->scaler_horiz)
ctx->scaler_horiz(ctx, input_frame, input_stride);
if (ctx->scaler_vert)
ctx->scaler_vert (ctx, output, output_stride);
}
if (ctx->out_fmt != SCALER_FMT_ARGB8888)
ctx->out_pixconv(output, ctx->output.frame,
ctx->out_width, ctx->out_height,
ctx->out_stride, ctx->output.stride);
}
desmume/src/addons/slot2_paddle.cpp 000664 001750 001750 00000007625 12755534123 020501 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2011-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
/*
this device seems to have a 12bit value (like 20.12 fixed point.. get it?) located at 0x0A000000
clockwise = right = increases.
it returns the correct little endian bytes through byte reads.
through halfword reads, it returns the LSB twice
through full word reads, it returns the LSB four times.
after that everything is 0x00.
if the slot2 timings are wrong, then this device will return glitchy or 0xFF output.
so this emulation code will attempt to validate that.
arkanoid was setting REG_EXMEMCNT = 0x082F
the rom returns 0xEFFF for all addresses and should be used to detect this device
writing any byte to SRAM or writing any halfword/word to rom results in a reset or some kind of recalibrate
the resulting value may be 0x000,0x001, or 0xFFF. seems mostly random, though once it is reset, resetting again won't change it.
you must wait until the paddle has been moved.
conclusion:
The emulation in all the handling of erroneous cases is not perfect, and some other users of the paddle (do any other games use it?)
maybe legally configure the paddle differently, which could be rejected here; in which case this code will need finetuning
*/
#include
#include "../slot2.h"
#include "../NDSSystem.h"
class Slot2_Paddle : public ISlot2Interface
{
private:
void calibrate() { nds.paddle = 0; }
bool Validate(u32 procnum, bool rom)
{
if(rom)
return ValidateSlot2Access(procnum, 0, 0, 0, -1);
else
return ValidateSlot2Access(procnum, 18, 0, 0, 1);
}
public:
virtual Slot2Info const* info()
{
static Slot2InfoSimple info("Paddle Controller", "Taito Paddle Controller", 0x07);
return &info;
}
virtual void writeByte(u8 PROCNUM, u32 addr, u8 val)
{
if (addr < 0x0A000000)
calibrate();
}
virtual void writeWord(u8 PROCNUM, u32 addr, u16 val)
{
if (addr < 0x0A000000)
calibrate();
}
virtual void writeLong(u8 PROCNUM, u32 addr, u32 val)
{
if (addr < 0x0A000000)
calibrate();
}
virtual u8 readByte(u8 PROCNUM, u32 addr)
{
//printf("paddle: read 08 at 0x%08X\n", addr);
if (!Validate(PROCNUM, (addr < 0x0A000000)))
return 0xFF;
if (addr < 0x0A000000)
return (addr & 1)?0xFF:0xEF;
if (addr == 0x0A000000)
return (nds.paddle & 0xFF);
if (addr == 0x0A000001)
return ((nds.paddle >> 8) & 0x0F);
return 0x00;
}
virtual u16 readWord(u8 PROCNUM, u32 addr)
{
//printf("paddle: read 16 at 0x%08X\n", addr);
if (!Validate(PROCNUM, (addr < 0x0A000000)))
return 0xFFFF;
if (addr < 0x0A000000)
return 0xEFFF;
if (addr == 0x0A000000)
{
u8 val = (nds.paddle & 0xFF);
return (val | (val << 8));
}
return 0x0000;
}
virtual u32 readLong(u8 PROCNUM, u32 addr)
{
//printf("paddle: read 32 at 0x%08X\n", addr);
if (!Validate(PROCNUM, (addr < 0x0A000000)))
return 0xFFFFFFFF;
if (addr < 0x0A000000)
return 0xEFFFEFFF;
if (addr == 0x0A000000)
{
u8 val = (nds.paddle & 0xFF);
return (val | (val << 8) | (val << 16) | (val << 24));
}
return 0x00000000;
}
};
u16 Paddle_GetValue()
{
return nds.paddle;
}
void Paddle_SetValue(u16 theValue)
{
nds.paddle = theValue;
}
ISlot2Interface* construct_Slot2_Paddle() { return new Slot2_Paddle(); }
desmume/src/addons/slot1comp_protocol.h 000664 001750 001750 00000007200 12755534123 021421 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2013-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
//this file contains the components used for emulating standard gamecard protocol.
//this largely means the complex boot-up process.
//i think there's no reason why proprietary cards couldn't speak any protocol they wish, as long as they didn't mind being unbootable.
//TODO - could this be refactored into a base class? that's probably more reasonable. but we've gone with this modular mix-in architecture so... not yet.
#ifndef _SLOT1COMP_PROTOCOL_H
#define _SLOT1COMP_PROTOCOL_H
#include "../types.h"
#include "../MMU.h"
class EMUFILE;
enum eSlot1Operation
{
//----------
//RAW mode operations
//before encrypted communications can be established, some values from the rom header must be read.
//this is the only way to read the header, actually, since the only reading commands available to games (after KEY2 mode is set) are
eSlot1Operation_00_ReadHeader_Unencrypted,
//it's not clear why this exists
eSlot1Operation_9F_Dummy,
eSlot1Operation_90_ChipID,
//----------
//----------
//KEY1 mode operations
eSlot1Operation_1x_ChipID,
eSlot1Operation_2x_SecureAreaLoad,
//----------
//----------
//NORMAL mode operations
//the main rom data reading command
eSlot1Operation_B7_Read,
eSlot1Operation_B8_ChipID,
//----------
eSlot1Operation_Unknown
};
class ISlot1Comp_Protocol_Client
{
public:
virtual void slot1client_startOperation(eSlot1Operation operation) {}
virtual u32 slot1client_read_GCDATAIN(eSlot1Operation operation) = 0;
virtual void slot1client_write_GCDATAIN(eSlot1Operation operation, u32 val) {}
};
class Slot1Comp_Protocol
{
public:
void savestate(EMUFILE* os);
void loadstate(EMUFILE* is);
//set some kind of protocol/hardware reset state
void reset(ISlot1Comp_Protocol_Client* client);
//signals from the GC bus
void write_command(GC_Command command);
void write_GCDATAIN(u8 PROCNUM, u32 val);
u32 read_GCDATAIN(u8 PROCNUM);
//helpers for write_command()
void write_command_RAW(GC_Command command);
void write_command_KEY1(GC_Command command);
void write_command_NORMAL(GC_Command command);
//operations not related to obscurities of the protocol or otherwise unknown are passed through to the client here
ISlot1Comp_Protocol_Client* client;
//--state--
//the major operational mode. the protocol shifts modes and interprets commands into operations differently depending on the mode
eCardMode mode;
//the current operational state
eSlot1Operation operation;
//the command we're currently crunching on
GC_Command command;
//most operations are defined in terms of returning a series of bytes
//the meaning of these varies by operation. they are provided publicly as a service to clients
u32 address;
s32 length, delay; //the expected length and delay of this state
//chipId which should be returned by the various chipId commands
u32 chipId;
//gameCode used by the protocol KEY1 crypto
u32 gameCode;
};
#endif //_SLOT1COMP_PROTOCOL_H desmume/src/libretro-common/include/gfx/math/matrix_3x3.h 000664 001750 001750 00000006720 12755534123 024566 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (matrix_3x3.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_GFX_MATH_MATRIX_3X3_H__
#define __LIBRETRO_SDK_GFX_MATH_MATRIX_3X3_H__
#include
typedef struct math_matrix_3x3
{
float data[9];
} math_matrix_3x3;
#define MAT_ELEM_3X3(mat, r, c) ((mat).data[3 * (r) + (c)])
void matrix_3x3_inits(math_matrix_3x3 *mat,
const float n11, const float n12, const float n13,
const float n21, const float n22, const float n23,
const float n31, const float n32, const float n33);
void matrix_3x3_identity(math_matrix_3x3 *mat);
void matrix_3x3_transpose(math_matrix_3x3 *out, const math_matrix_3x3 *in);
void matrix_3x3_multiply(math_matrix_3x3 *out,
const math_matrix_3x3 *a, const math_matrix_3x3 *b);
void matrix_3x3_divide_scalar(math_matrix_3x3 *mat, const float s);
float matrix_3x3_determinant(const math_matrix_3x3 *mat);
void matrix_3x3_adjoint(math_matrix_3x3 *mat);
bool matrix_3x3_invert(math_matrix_3x3 *mat);
bool matrix_3x3_square_to_quad(const float dx0, const float dy0,
const float dx1, const float dy1,
const float dx3, const float dy3,
const float dx2, const float dy2,
math_matrix_3x3 *mat);
bool matrix_3x3_quad_to_square(const float sx0, const float sy0,
const float sx1, const float sy1,
const float sx2, const float sy2,
const float sx3, const float sy3,
math_matrix_3x3 *mat);
bool matrix_3x3_quad_to_quad(const float dx0, const float dy0,
const float dx1, const float dy1,
const float dx2, const float dy2,
const float dx3, const float dy3,
const float sx0, const float sy0,
const float sx1, const float sy1,
const float sx2, const float sy2,
const float sx3, const float sy3,
math_matrix_3x3 *mat);
#endif
desmume/src/utils/AsmJit/core/compileritem.h 000664 001750 001750 00000044530 12755534123 022266 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
// [Guard]
#ifndef _ASMJIT_CORE_COMPILERITEM_H
#define _ASMJIT_CORE_COMPILERITEM_H
// [Dependencies - AsmJit]
#include "../core/compiler.h"
// [Api-Begin]
#include "../core/apibegin.h"
namespace AsmJit {
// ============================================================================
// [AsmJit::CompilerItem]
// ============================================================================
//! @brief Compiler item.
//!
//! @ref CompilerItem represents items generated by compiler by calling its
//! methods to build functions, instruction stream, bind labels, etc... Each
//! item contains its type information and virtual methods which are called at
//! various compilation steps.
struct CompilerItem
{
ASMJIT_NO_COPY(CompilerItem)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create new @ref CompilerItem.
//!
//! @note Always use @ref Compiler to create an item!
ASMJIT_API CompilerItem(Compiler* compiler, uint32_t type);
//! @brief Destroy @ref CompilerItem.
//!
//! @note @ref Compiler keeps links into all items so it can destroy them
//! when code generation finished or in the case that @ref Compiler was
//! destroyed early (for example if an error happened). Never destroy items
//! manually!
ASMJIT_API virtual ~CompilerItem();
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Get associated compiler instance.
inline Compiler* getCompiler() const
{ return _compiler; }
//! @brief Get previous item in the compiler stream.
inline CompilerItem* getPrev() const
{ return _prev; }
//! @brief Get next item in the compiler stream.
inline CompilerItem* getNext() const
{ return _next; }
//! @brief Get comment string.
inline const char* getComment() const
{ return _comment; }
//! @brief Get type of item, see @ref kCompilerItem.
inline uint32_t getType() const
{ return _type; }
//! @brief Get whether the item was translated.
inline bool isTranslated() const
{ return _isTranslated; }
//! @brief Get whether the item is unreachable.
inline bool isUnreachable() const
{ return _isUnreachable; }
//! @brief Get the item offset in the compiler stream.
//!
//! The offset is not byte offset, each item increments offset by 1 and this
//! value is then used by register allocator. The offset is set by compiler
//! by the register allocator, don't use it in your code.
inline uint32_t getOffset() const
{ return _offset; }
// --------------------------------------------------------------------------
// [Interface]
// --------------------------------------------------------------------------
//! @brief Step 1. Extract item variables, update statistics, ...
ASMJIT_API virtual void prepare(CompilerContext& cc);
//! @brief Step 2. Translate instruction, alloc variables, ...
ASMJIT_API virtual CompilerItem* translate(CompilerContext& cc);
//! @brief Step 3. Emit to @c Assembler.
ASMJIT_API virtual void emit(Assembler& a);
//! @brief Step 4. Last post step (verify, add data, etc).
ASMJIT_API virtual void post(Assembler& a);
// --------------------------------------------------------------------------
// [Misc]
// --------------------------------------------------------------------------
//! @brief Get maximum size of of this when serialized into @ref Assembler
//! item in bytes.
ASMJIT_API virtual int getMaxSize() const;
//! @brief Try to unuse the variable @a.
//!
//! Returns @c true only if the variable will be unused by the instruction,
//! otherwise @c false is returned.
ASMJIT_API virtual bool _tryUnuseVar(CompilerVar* v);
// --------------------------------------------------------------------------
// [Comment]
// --------------------------------------------------------------------------
//! @brief Set comment string to @a str.
ASMJIT_API void setComment(const char* str);
//! @brief Format comment string using @a fmt string and variable argument list.
ASMJIT_API void formatComment(const char* fmt, ...);
// --------------------------------------------------------------------------
// [Protected]
// --------------------------------------------------------------------------
protected:
//! @brief Mark item as translated and return next.
inline CompilerItem* translated()
{
ASMJIT_ASSERT(_isTranslated == false);
_isTranslated = true;
return _next;
}
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
public:
//! @brief Compiler which owns this item.
Compiler* _compiler;
//! @brief Previous item.
CompilerItem* _prev;
//! @brief Next item.
CompilerItem* _next;
//! @brief Inline comment string, initially set to NULL.
const char* _comment;
//! @brief Type of the item, see @ref kCompilerItem.
uint32_t _type : 8;
//! @brief Whether the item was translated, see @c translate().
uint32_t _isTranslated : 1;
//! @brief Whether the item is unreachable.
uint32_t _isUnreachable : 1;
//! @brief Reserved for future use.
uint32_t _reserved : 22;
//! @brief Stream offset (not byte-offset).
uint32_t _offset;
};
// ============================================================================
// [AsmJit::CompilerMark]
// ============================================================================
//! @brief Compiler mark item.
//!
//! This item does nothing and it's only used by @ref Compiler to mark some
//! specific location in the compiler stream.
struct CompilerMark : public CompilerItem
{
ASMJIT_NO_COPY(CompilerMark)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerMark instance.
ASMJIT_API CompilerMark(Compiler* compiler);
//! @brief Destroy the @ref CompilerMark instance.
ASMJIT_API virtual ~CompilerMark();
// --------------------------------------------------------------------------
// [Misc]
// --------------------------------------------------------------------------
ASMJIT_API virtual int getMaxSize() const;
};
// ============================================================================
// [AsmJit::CompilerComment]
// ============================================================================
//! @brief Compiler comment item.
//!
//! Comments allows to comment your assembler stream for better debugging
//! and visualization. Comments are usually ignored in release builds unless
//! the logger is present.
struct CompilerComment : public CompilerItem
{
ASMJIT_NO_COPY(CompilerComment)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerComment instance.
ASMJIT_API CompilerComment(Compiler* compiler, const char* comment = NULL);
//! @brief Destroy the @ref CompilerComment instance.
ASMJIT_API virtual ~CompilerComment();
// --------------------------------------------------------------------------
// [Interface]
// --------------------------------------------------------------------------
ASMJIT_API virtual void emit(Assembler& a);
// --------------------------------------------------------------------------
// [Misc]
// --------------------------------------------------------------------------
ASMJIT_API virtual int getMaxSize() const;
};
// ============================================================================
// [AsmJit::CompilerEmbed]
// ============================================================================
//! @brief Compiler embed item.
//!
//! Embed item is used to embed data into final assembler stream. The data is
//! considered to be RAW, there is no analysis.
struct CompilerEmbed : public CompilerItem
{
ASMJIT_NO_COPY(CompilerEmbed)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerEmbed instance.
ASMJIT_API CompilerEmbed(Compiler* compiler, const void* data, size_t length);
//! @brief Destroy the @ref CompilerEmbed instance.
ASMJIT_API virtual ~CompilerEmbed();
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Get pointer to embedded data.
uint8_t* getData() const
{ return const_cast(_data); }
//! @brief Get length of embedded data.
size_t getLength() const
{ return _length; }
// --------------------------------------------------------------------------
// [Interface]
// --------------------------------------------------------------------------
ASMJIT_API virtual void emit(Assembler& a);
// --------------------------------------------------------------------------
// [Misc]
// --------------------------------------------------------------------------
ASMJIT_API virtual int getMaxSize() const;
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief Data length.
size_t _length;
//! @brief Data buffer (that will be embedded to the assembler stream).
uint8_t _data[sizeof(void*)];
};
// ============================================================================
// [AsmJit::CompilerAlign]
// ============================================================================
//! @brief Compiler align item.
struct CompilerAlign : public CompilerItem
{
ASMJIT_NO_COPY(CompilerAlign)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerAlign instance.
ASMJIT_API CompilerAlign(Compiler* compiler, uint32_t size = 0);
//! @brief Destroy the @ref CompilerAlign instance.
ASMJIT_API virtual ~CompilerAlign();
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Get align size in bytes.
inline uint32_t getSize() const
{ return _size; }
//! @brief Set align size in bytes to @a size.
inline void setSize(uint32_t size)
{ _size = size; }
// --------------------------------------------------------------------------
// [Misc]
// --------------------------------------------------------------------------
ASMJIT_API virtual int getMaxSize() const;
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief Align size.
uint32_t _size;
};
// ============================================================================
// [AsmJit::CompilerHint]
// ============================================================================
//! @brief Compiler variable hint item.
struct CompilerHint : public CompilerItem
{
ASMJIT_NO_COPY(CompilerHint)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerHint instance.
ASMJIT_API CompilerHint(Compiler* compiler, CompilerVar* var, uint32_t hintId, uint32_t hintValue);
//! @brief Destroy the @ref CompilerHint instance.
ASMJIT_API virtual ~CompilerHint();
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Get variable.
inline CompilerVar* getVar() const
{ return _var; }
//! @brief Get hint it (see @ref kVarHint).
inline uint32_t getHintId() const
{ return _hintId; }
//! @brief Set hint it (see @ref kVarHint).
inline void setHintId(uint32_t hintId)
{ _hintId = hintId; }
//! @brief Get hint value.
inline uint32_t getHintValue() const
{ return _hintValue; }
//! @brief Set hint value.
inline void setHintValue(uint32_t hintValue)
{ _hintValue = hintValue; }
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief Variable.
CompilerVar* _var;
//! @brief Variable hint id.
uint32_t _hintId;
//! @brief Variable hint value.
uint32_t _hintValue;
};
// ============================================================================
// [AsmJit::CompilerTarget]
// ============================================================================
//! @brief Compiler target item.
struct CompilerTarget : public CompilerItem
{
ASMJIT_NO_COPY(CompilerTarget)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerTarget instance.
ASMJIT_API CompilerTarget(Compiler* compiler, const Label& target);
//! @brief Destroy the @ref CompilerTarget instance.
ASMJIT_API virtual ~CompilerTarget();
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Return label bound to this target.
inline const Label& getLabel() const
{ return _label; }
//! @brief Get first jmp instruction.
inline CompilerInst* getFrom() const
{ return _from; }
//! @brief Get register allocator state for this target.
inline CompilerState* getState() const
{ return _state; }
//! @brief Get number of jumps to this target.
inline uint32_t getJumpsCount() const
{ return _jumpsCount; }
// --------------------------------------------------------------------------
// [Misc]
// --------------------------------------------------------------------------
ASMJIT_API virtual int getMaxSize() const;
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief Label.
Label _label;
//! @brief First jump instruction that points to this target (label).
CompilerInst* _from;
//! @brief State at this location.
CompilerState* _state;
//! @brief Count of jumps here.
uint32_t _jumpsCount;
};
// ============================================================================
// [AsmJit::CompilerInst]
// ============================================================================
//! @brief Compiler instruction item.
struct CompilerInst : public CompilerItem
{
ASMJIT_NO_COPY(CompilerInst)
// --------------------------------------------------------------------------
// [Construction / Destruction]
// --------------------------------------------------------------------------
//! @brief Create a new @ref CompilerInst instance.
ASMJIT_API CompilerInst(Compiler* compiler, uint32_t code, Operand* opData, uint32_t opCount);
//! @brief Destroy the @ref CompilerInst instance.
ASMJIT_API virtual ~CompilerInst();
// --------------------------------------------------------------------------
// [Accessors]
// --------------------------------------------------------------------------
//! @brief Get instruction code, see @c kInstCode.
inline uint32_t getCode() const
{ return _code; }
//! @brief Set instruction code to @a code.
//!
//! Please do not modify instruction code if you are not know what you are
//! doing. Incorrect instruction code or operands can raise assertion() at
//! runtime.
inline void setCode(uint32_t code)
{ _code = code; }
//! @brief Get emit options (compiler specific).
inline uint32_t getEmitOptions() const
{ return _emitOptions; }
//! @brief Get instruction flags (compiler specific).
inline uint32_t getInstFlags() const
{ return _instFlags; }
//! @brief Get whether the instruction has flag @a flag.
inline bool hasInstFlag(uint8_t flag) const
{ return (_instFlags & flag) != 0; }
//! @brief Set instruction @a flag.
inline void setInstFlag(uint8_t flag)
{ _instFlags |= flag; }
//! @brief Clear instruction @a flag.
inline void clearInstFlag(uint8_t flag)
{ _instFlags &= ~flag; }
//! @brief Get count of operands in operands array.
inline uint32_t getOperandsCount() const
{ return _operandsCount; }
//! @brief Get count of variables in variables array.
inline uint32_t getVariablesCount() const
{ return _variablesCount; }
//! @brief Get operands array (3 operands total).
inline Operand* getOperands() { return _operands; }
//! @brief Get operands array (3 operands total).
inline const Operand* getOperands() const { return _operands; }
// --------------------------------------------------------------------------
// [GetJumpTarget]
// --------------------------------------------------------------------------
//! @brief Get possible jump target.
//!
//! If this instruction is conditional or normal jump then return value is
//! the label location (@ref CompilerTarget), otherwise the return value is
//! @c NULL.
ASMJIT_API virtual CompilerTarget* getJumpTarget() const;
// --------------------------------------------------------------------------
// [Members]
// --------------------------------------------------------------------------
//! @brief Instruction code, see @c kInstCode.
uint32_t _code;
//! @brief Emit options.
uint8_t _emitOptions;
//! @brief Instruction flags.
uint8_t _instFlags;
//! @brief Operands count.
uint8_t _operandsCount;
//! @brief Variables count.
uint8_t _variablesCount;
//! @brief Operands.
Operand* _operands;
};
} // AsmJit namespace
// [Api-End]
#include "../core/apiend.h"
// [Guard]
#endif // _ASMJIT_CORE_COMPILERITEM_H
desmume/src/mc.h 000664 001750 001750 00000012761 12755534123 014716 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2006 thoduv
Copyright (C) 2006 Theo Berkau
Copyright (C) 2008-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#ifndef __MC_H__
#define __MC_H__
#include
#include
#include
#include "types.h"
#define MAX_SAVE_TYPES 13
#define MC_TYPE_AUTODETECT 0x0
#define MC_TYPE_EEPROM1 0x1
#define MC_TYPE_EEPROM2 0x2
#define MC_TYPE_FLASH 0x3
#define MC_TYPE_FRAM 0x4
#define MC_SIZE_4KBITS 0x000200
#define MC_SIZE_64KBITS 0x002000
#define MC_SIZE_256KBITS 0x008000
#define MC_SIZE_512KBITS 0x010000
#define MC_SIZE_1MBITS 0x020000
#define MC_SIZE_2MBITS 0x040000
#define MC_SIZE_4MBITS 0x080000
#define MC_SIZE_8MBITS 0x100000
#define MC_SIZE_16MBITS 0x200000
#define MC_SIZE_32MBITS 0x400000
#define MC_SIZE_64MBITS 0x800000
#define MC_SIZE_128MBITS 0x1000000
#define MC_SIZE_256MBITS 0x2000000
#define MC_SIZE_512MBITS 0x4000000
class EMUFILE;
class EMUFILE_FILE;
//This "backup device" represents a typical retail NDS save memory accessible via AUXSPI.
//It is managed as a core emulator service for historical reasons which are bad,
//and possible infrastructural simplification reasons which are good.
//Slot-1 devices will map their AUXSPI accesses through to the core-managed BackupDevice to access it for the running software.
class BackupDevice
{
public:
BackupDevice();
~BackupDevice();
//signals the save system that we are in MOVIE mode. doesnt load up a rom, and never saves it. initializes for that case.
void reset();
void close_rom();
void forceManualBackupType();
void reset_hardware();
std::string getFilename() { return filename; }
u8 readByte(u32 addr, const u8 init);
u16 readWord(u32 addr, const u16 init);
u32 readLong(u32 addr, const u32 init);
u8 readByte(const u8 init);
u16 readWord(const u16 init);
u32 readLong(const u32 init);
void writeByte(u32 addr, u8 val);
void writeWord(u32 addr, u16 val);
void writeLong(u32 addr, u32 val);
void writeByte(u8 val);
void writeWord(u16 val);
void writeLong(u32 val);
void seek(u32 pos);
void flushBackup();
u8 searchFileSaveType(u32 size);
bool save_state(EMUFILE* os);
bool load_state(EMUFILE* is);
//commands from mmu
void reset_command() { reset_command_state = true; };
u8 data_command(u8, u8);
//this info was saved before the last reset (used for savestate compatibility)
struct SavedInfo
{
u32 addr_size;
} savedInfo;
void ensure(u32 addr, EMUFILE_FILE *fpOut = NULL);
void ensure(u32 addr, u8 val, EMUFILE_FILE *fpOut = NULL);
//and these are used by old savestates
void load_old_state(u32 addr_size, u8* data, u32 datasize);
static u32 addr_size_for_old_save_size(int bupmem_size);
static u32 addr_size_for_old_save_type(int bupmem_type);
static u32 pad_up_size(u32 startSize);
void raw_applyUserSettings(u32& size, bool manual = false);
u32 trim(void *buf, u32 size);
u32 fillLeft(u32 size);
u32 get_save_duc_size(const char* filename);
u32 get_save_nogba_size(const char* filename);
u32 get_save_nogba_size(u8 *data);
u32 get_save_raw_size(const char* filename);
bool import_duc(const char* filename, u32 force_size = 0);
bool import_no_gba(const char *fname, u32 force_size = 0);
bool import_raw(const char* filename, u32 force_size = 0);
bool export_no_gba(const char* fname);
bool export_raw(const char* filename);
bool no_gba_unpack(u8 *&buf, u32 &size);
struct {
u32 size,padSize,type,addr_size,mem_size;
} info;
u32 importDataSize(const char *filename);
bool importData(const char *filename, u32 force_size = 0);
bool exportData(const char *filename);
//the value contained in memory when shipped from factory (before user program ever writes to it). more details commented elsewhere.
u8 uninitializedValue;
private:
EMUFILE_FILE *fpMC;
std::string filename;
u32 fsize;
int readFooter();
bool write(u8 val);
u8 read();
bool saveBuffer(u8 *data, u32 size, bool _rewind, bool _truncate = false);
bool write_enable;
bool reset_command_state;
u32 com; //persistent command actually handled
u32 addr_size, addr_counter;
u32 addr;
u8 write_protect;
std::vector data_autodetect;
enum STATE {
DETECTING = 0, RUNNING = 1
} state;
enum MOTION_INIT_STATE
{
MOTION_INIT_STATE_IDLE, MOTION_INIT_STATE_RECEIVED_4, MOTION_INIT_STATE_RECEIVED_4_B,
MOTION_INIT_STATE_FE, MOTION_INIT_STATE_FD, MOTION_INIT_STATE_FB
};
enum MOTION_FLAG
{
MOTION_FLAG_NONE=0,
MOTION_FLAG_ENABLED=1,
MOTION_FLAG_SENSORMODE=2
};
u8 motionInitState, motionFlag;
void checkReset();
void detect();
};
void backup_setManualBackupType(int type);
void backup_forceManualBackupType();
struct SAVE_TYPE
{
const char* descr;
int media_type;
int size;
int addr_size;
};
extern const SAVE_TYPE save_types[];
#endif /*__FW_H__*/
desmume/src/utils/AsmJit/core/assert.cpp 000664 001750 001750 00000001275 12755534123 021430 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
#define ASMJIT_EXPORTS
// [Dependencies - AsmJit]
#include "../core/assert.h"
// [Api-Begin]
#include "../core/apibegin.h"
// helpers
namespace AsmJit {
// ============================================================================
// [AsmJit::Assert]
// ============================================================================
void assertionFailure(const char* file, int line, const char* exp)
{
fprintf(stderr,
"*** ASSERTION FAILURE at %s (line %d)\n"
"*** %s\n", file, line, exp);
exit(1);
}
} // AsmJit namespace
// [Api-End]
#include "../core/apiend.h"
desmume/src/emufile.cpp 000664 001750 001750 00000014530 12755534123 016274 0 ustar 00sergio sergio 000000 000000 /*
The MIT License
Copyright (C) 2009-2014 DeSmuME team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#if !defined(WIN32)
#include
#endif
#if defined(PSP)
//forward declaration - PSP/Vita doesn't have this so have to bake it in
int ftruncate(int fd, off_t length);
#elif defined(VITA)
int ftruncate(int fd, off_t length)
{
/* TODO/FIXME - can't be bothered to implement this right now - doesn't seem to matter either */
}
#endif
#include "emufile.h"
#include
bool EMUFILE::readAllBytes(std::vector* dstbuf, const std::string& fname)
{
EMUFILE_FILE file(fname.c_str(),"rb");
if(file.fail()) return false;
int size = file.size();
dstbuf->resize(size);
file.fread(&dstbuf->at(0),size);
return true;
}
size_t EMUFILE_MEMORY::_fread(const void *ptr, size_t bytes){
u32 remain = len-pos;
u32 todo = std::min(remain,(u32)bytes);
if(len==0)
{
failbit = true;
return 0;
}
if(todo<=4)
{
u8* src = buf()+pos;
u8* dst = (u8*)ptr;
for(size_t i=0;ibuf(),size());
return mem;
}
EMUFILE* EMUFILE_MEMORY::memwrap()
{
return this;
}
void EMUFILE::write64le(u64* val)
{
write64le(*val);
}
void EMUFILE::write64le(u64 val)
{
val = LOCAL_TO_LE_64(val);
fwrite(&val,8);
}
size_t EMUFILE::read64le(u64 *Bufo)
{
u64 buf;
if(fread((char*)&buf,8) != 8)
return 0;
*Bufo = LE_TO_LOCAL_64(buf);
return 1;
}
u64 EMUFILE::read64le()
{
u64 temp;
read64le(&temp);
return temp;
}
void EMUFILE::write32le(u32* val)
{
write32le(*val);
}
void EMUFILE::write32le(u32 val)
{
val = LOCAL_TO_LE_32(val);
fwrite(&val,4);
}
size_t EMUFILE::read32le(s32* Bufo) { return read32le((u32*)Bufo); }
size_t EMUFILE::read32le(u32* Bufo)
{
u32 buf;
if(fread(&buf,4)<4)
return 0;
*Bufo = LE_TO_LOCAL_32(buf);
return 1;
}
u32 EMUFILE::read32le()
{
u32 ret;
read32le(&ret);
return ret;
}
void EMUFILE::write16le(u16* val)
{
write16le(*val);
}
void EMUFILE::write16le(u16 val)
{
val = LOCAL_TO_LE_16(val);
fwrite(&val,2);
}
size_t EMUFILE::read16le(s16* Bufo) { return read16le((u16*)Bufo); }
size_t EMUFILE::read16le(u16* Bufo)
{
u32 buf;
if(fread(&buf,2)<2)
return 0;
*Bufo = LE_TO_LOCAL_16(buf);
return 1;
}
u16 EMUFILE::read16le()
{
u16 ret;
read16le(&ret);
return ret;
}
void EMUFILE::write8le(u8* val)
{
write8le(*val);
}
void EMUFILE::write8le(u8 val)
{
fwrite(&val,1);
}
size_t EMUFILE::read8le(u8* val)
{
return fread(val,1);
}
u8 EMUFILE::read8le()
{
u8 temp;
fread(&temp,1);
return temp;
}
void EMUFILE::writedouble(double* val)
{
write64le(double_to_u64(*val));
}
void EMUFILE::writedouble(double val)
{
write64le(double_to_u64(val));
}
double EMUFILE::readdouble()
{
double temp;
readdouble(&temp);
return temp;
}
size_t EMUFILE::readdouble(double* val)
{
u64 temp;
size_t ret = read64le(&temp);
*val = u64_to_double(temp);
return ret;
}
void EMUFILE::writeMemoryStream(EMUFILE_MEMORY* ms)
{
s32 size = (s32)ms->size();
write32le(size);
if(size>0)
{
std::vector* vec = ms->get_vec();
fwrite(&vec->at(0),size);
}
}
void EMUFILE::readMemoryStream(EMUFILE_MEMORY* ms)
{
s32 size = read32le();
if(size != 0)
{
std::vector temp(size);
fread(&temp[0],size);
ms->fwrite(&temp[0],size);
}
}
desmume/src/libretro-common/include/formats/rxml.h 000664 001750 001750 00000006657 12755534123 023516 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (rxml.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_FORMAT_RXML_H__
#define __LIBRETRO_SDK_FORMAT_RXML_H__
#include
RETRO_BEGIN_DECLS
/* Total NIH. Very trivial "XML" implementation for use in RetroArch.
* Error checking is minimal. Invalid documents may lead to very
* buggy behavior, but memory corruption should never happen.
*
* Only parts of standard that RetroArch cares about is supported.
* Nothing more, nothing less. "Clever" XML documents will
* probably break the implementation.
*
* Do *NOT* try to use this for anything else. You have been warned.
*/
typedef struct rxml_document rxml_document_t;
struct rxml_attrib_node
{
char *attrib;
char *value;
struct rxml_attrib_node *next;
};
struct rxml_node
{
char *name;
char *data;
struct rxml_attrib_node *attrib;
struct rxml_node *children;
struct rxml_node *next;
/* Dummy. Used by libxml2 compat.
* Is always set to 0, so XML_ELEMENT_NODE check goes through. */
int type;
};
rxml_document_t *rxml_load_document(const char *path);
void rxml_free_document(rxml_document_t *doc);
struct rxml_node *rxml_root_node(rxml_document_t *doc);
/* Drop const-correctness here to avoid warnings
* when used as libxml2 compat.
* xmlGetProp() returns xmlChar*, which is supposed
* to be passed to xmlFree(). */
char *rxml_node_attrib(struct rxml_node *node, const char *attrib);
#ifdef RXML_LIBXML2_COMPAT
/* Compat for part of libxml2 that RetroArch uses. */
#define LIBXML_TEST_VERSION ((void)0)
typedef char xmlChar; /* It's really unsigned char, but it doesn't matter. */
typedef struct rxml_node *xmlNodePtr;
typedef void *xmlParserCtxtPtr;
typedef rxml_document_t *xmlDocPtr;
#define XML_ELEMENT_NODE (0)
#define xmlNewParserCtxt() ((void*)-1)
#define xmlCtxtReadFile(ctx, path, a, b) rxml_load_document(path)
#define xmlGetProp(node, prop) rxml_node_attrib(node, prop)
#define xmlFree(p) ((void)0)
#define xmlNodeGetContent(node) (node->data)
#define xmlDocGetRootElement(doc) rxml_root_node(doc)
#define xmlFreeDoc(doc) rxml_free_document(doc)
#define xmlFreeParserCtxt(ctx) ((void)0)
#endif
RETRO_END_DECLS
#endif
desmume/src/GPU.h 000664 001750 001750 00000105355 12755534123 014754 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2006 yopyop
Copyright (C) 2006-2007 Theo Berkau
Copyright (C) 2007 shash
Copyright (C) 2009-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#ifndef GPU_H
#define GPU_H
#include
#include
#include "types.h"
#ifdef ENABLE_SSE2
#include
#endif
class EMUFILE;
struct MMU_struct;
//#undef FORCEINLINE
//#define FORCEINLINE
#define GPU_FRAMEBUFFER_NATIVE_WIDTH 256
#define GPU_FRAMEBUFFER_NATIVE_HEIGHT 192
#define GPU_VRAM_BLOCK_LINES 256
void gpu_savestate(EMUFILE* os);
bool gpu_loadstate(EMUFILE* is, int size);
/*******************************************************************************
this structure is for display control,
it holds flags for general display
*******************************************************************************/
#ifdef MSB_FIRST
struct _DISPCNT
{
/* 7*/ u8 ForceBlank:1; // A+B:
/* 6*/ u8 OBJ_BMP_mapping:1; // A+B: 0=2D (128KB), 1=1D (128..256KB)
/* 5*/ u8 OBJ_BMP_2D_dim:1; // A+B: 0=128x512, 1=256x256 pixels
/* 4*/ u8 OBJ_Tile_mapping:1;// A+B: 0=2D (32KB), 1=1D (32..256KB)
/* 3*/ u8 BG0_3D:1; // A : 0=2D, 1=3D
/* 0*/ u8 BG_Mode:3; // A+B:
/*15*/ u8 WinOBJ_Enable:1; // A+B: 0=disable, 1=Enable
/*14*/ u8 Win1_Enable:1; // A+B: 0=disable, 1=Enable
/*13*/ u8 Win0_Enable:1; // A+B: 0=disable, 1=Enable
/*12*/ u8 OBJ_Enable:1; // A+B: 0=disable, 1=Enable
/*11*/ u8 BG3_Enable:1; // A+B: 0=disable, 1=Enable
/*10*/ u8 BG2_Enable:1; // A+B: 0=disable, 1=Enable
/* 9*/ u8 BG1_Enable:1; // A+B: 0=disable, 1=Enable
/* 8*/ u8 BG0_Enable:1; // A+B: 0=disable, 1=Enable
/*23*/ u8 OBJ_HBlank_process:1; // A+B: OBJ processed during HBlank (GBA bit5)
/*22*/ u8 OBJ_BMP_1D_Bound:1; // A :
/*20*/ u8 OBJ_Tile_1D_Bound:2; // A+B:
/*18*/ u8 VRAM_Block:2; // A : VRAM block (0..3=A..D)
/*16*/ u8 DisplayMode:2; // A+B: coreA(0..3) coreB(0..1) GBA(Green Swap)
// 0=off (white screen)
// 1=on (normal BG & OBJ layers)
// 2=VRAM display (coreA only)
// 3=RAM display (coreA only, DMA transfers)
/*31*/ u8 ExOBJPalette_Enable:1; // A+B: 0=disable, 1=Enable OBJ extended Palette
/*30*/ u8 ExBGxPalette_Enable:1; // A+B: 0=disable, 1=Enable BG extended Palette
/*27*/ u8 ScreenBase_Block:3; // A : Screen Base (64K step)
/*24*/ u8 CharacBase_Block:3; // A : Character Base (64K step)
};
#else
struct _DISPCNT
{
/* 0*/ u8 BG_Mode:3; // A+B:
/* 3*/ u8 BG0_3D:1; // A : 0=2D, 1=3D
/* 4*/ u8 OBJ_Tile_mapping:1; // A+B: 0=2D (32KB), 1=1D (32..256KB)
/* 5*/ u8 OBJ_BMP_2D_dim:1; // A+B: 0=128x512, 1=256x256 pixels
/* 6*/ u8 OBJ_BMP_mapping:1; // A+B: 0=2D (128KB), 1=1D (128..256KB)
// 7-15 same as GBA
/* 7*/ u8 ForceBlank:1; // A+B:
/* 8*/ u8 BG0_Enable:1; // A+B: 0=disable, 1=Enable
/* 9*/ u8 BG1_Enable:1; // A+B: 0=disable, 1=Enable
/*10*/ u8 BG2_Enable:1; // A+B: 0=disable, 1=Enable
/*11*/ u8 BG3_Enable:1; // A+B: 0=disable, 1=Enable
/*12*/ u8 OBJ_Enable:1; // A+B: 0=disable, 1=Enable
/*13*/ u8 Win0_Enable:1; // A+B: 0=disable, 1=Enable
/*14*/ u8 Win1_Enable:1; // A+B: 0=disable, 1=Enable
/*15*/ u8 WinOBJ_Enable:1; // A+B: 0=disable, 1=Enable
/*16*/ u8 DisplayMode:2; // A+B: coreA(0..3) coreB(0..1) GBA(Green Swap)
// 0=off (white screen)
// 1=on (normal BG & OBJ layers)
// 2=VRAM display (coreA only)
// 3=RAM display (coreA only, DMA transfers)
/*18*/ u8 VRAM_Block:2; // A : VRAM block (0..3=A..D)
/*20*/ u8 OBJ_Tile_1D_Bound:2; // A+B:
/*22*/ u8 OBJ_BMP_1D_Bound:1; // A :
/*23*/ u8 OBJ_HBlank_process:1; // A+B: OBJ processed during HBlank (GBA bit5)
/*24*/ u8 CharacBase_Block:3; // A : Character Base (64K step)
/*27*/ u8 ScreenBase_Block:3; // A : Screen Base (64K step)
/*30*/ u8 ExBGxPalette_Enable:1; // A+B: 0=disable, 1=Enable BG extended Palette
/*31*/ u8 ExOBJPalette_Enable:1; // A+B: 0=disable, 1=Enable OBJ extended Palette
};
#endif
union FragmentColor
{
u32 color;
struct
{
u8 r,g,b,a;
};
};
typedef union
{
struct _DISPCNT bits;
u32 val;
} DISPCNT;
#define BGxENABLED(cnt,num) ((num<8)? ((cnt.val>>8) & num):0)
enum BlendFunc
{
NoBlend, Blend, Increase, Decrease
};
/*******************************************************************************
this structure is for display control of a specific layer,
there are 4 background layers
their priority indicate which one to draw on top of the other
some flags indicate special drawing mode, size, FX
*******************************************************************************/
#ifdef MSB_FIRST
struct _BGxCNT
{
/* 7*/ u8 Palette_256:1; // 0=16x16, 1=1*256 palette
/* 6*/ u8 Mosaic_Enable:1; // 0=disable, 1=Enable mosaic
/* 2*/ u8 CharacBase_Block:4; // individual character base offset (n*16KB)
/* 0*/ u8 Priority:2; // 0..3=high..low
/*14*/ u8 ScreenSize:2; // text : 256x256 512x256 256x512 512x512
// x/rot/s : 128x128 256x256 512x512 1024x1024
// bmp : 128x128 256x256 512x256 512x512
// large : 512x1024 1024x512 - -
/*13*/ u8 PaletteSet_Wrap:1; // BG0 extended palette set 0=set0, 1=set2
// BG1 extended palette set 0=set1, 1=set3
// BG2 overflow area wraparound 0=off, 1=wrap
// BG3 overflow area wraparound 0=off, 1=wrap
/* 8*/ u8 ScreenBase_Block:5; // individual screen base offset (text n*2KB, BMP n*16KB)
};
#else
struct _BGxCNT
{
/* 0*/ u8 Priority:2; // 0..3=high..low
/* 2*/ u8 CharacBase_Block:4; // individual character base offset (n*16KB)
/* 6*/ u8 Mosaic_Enable:1; // 0=disable, 1=Enable mosaic
/* 7*/ u8 Palette_256:1; // 0=16x16, 1=1*256 palette
/* 8*/ u8 ScreenBase_Block:5; // individual screen base offset (text n*2KB, BMP n*16KB)
/*13*/ u8 PaletteSet_Wrap:1; // BG0 extended palette set 0=set0, 1=set2
// BG1 extended palette set 0=set1, 1=set3
// BG2 overflow area wraparound 0=off, 1=wrap
// BG3 overflow area wraparound 0=off, 1=wrap
/*14*/ u8 ScreenSize:2; // text : 256x256 512x256 256x512 512x512
// x/rot/s : 128x128 256x256 512x512 1024x1024
// bmp : 128x128 256x256 512x256 512x512
// large : 512x1024 1024x512 - -
};
#endif
typedef union
{
struct _BGxCNT bits;
u16 val;
} BGxCNT;
/*******************************************************************************
this structure is for background offset
*******************************************************************************/
typedef struct {
u16 BGxHOFS;
u16 BGxVOFS;
} BGxOFS;
/*******************************************************************************
this structure is for rotoscale parameters
*******************************************************************************/
typedef struct {
s16 BGxPA;
s16 BGxPB;
s16 BGxPC;
s16 BGxPD;
s32 BGxX;
s32 BGxY;
} BGxPARMS;
/*******************************************************************************
these structures are for window description,
windows are square regions and can "subclass"
background layers or object layers (i.e window controls the layers)
screen
|
+-- Window0/Window1/OBJwindow/OutOfWindows
|
+-- BG0/BG1/BG2/BG3/OBJ
*******************************************************************************/
typedef union {
struct {
u8 end:8;
u8 start:8;
} bits ;
u16 val;
} WINxDIM;
#ifdef MSB_FIRST
typedef struct {
/* 6*/ u8 :2;
/* 5*/ u8 WINx_Effect_Enable:1;
/* 4*/ u8 WINx_OBJ_Enable:1;
/* 3*/ u8 WINx_BG3_Enable:1;
/* 2*/ u8 WINx_BG2_Enable:1;
/* 1*/ u8 WINx_BG1_Enable:1;
/* 0*/ u8 WINx_BG0_Enable:1;
} WINxBIT;
#else
typedef struct {
/* 0*/ u8 WINx_BG0_Enable:1;
/* 1*/ u8 WINx_BG1_Enable:1;
/* 2*/ u8 WINx_BG2_Enable:1;
/* 3*/ u8 WINx_BG3_Enable:1;
/* 4*/ u8 WINx_OBJ_Enable:1;
/* 5*/ u8 WINx_Effect_Enable:1;
/* 6*/ u8 :2;
} WINxBIT;
#endif
#ifdef MSB_FIRST
typedef union {
struct {
WINxBIT win0;
WINxBIT win1;
} bits;
struct {
u8 :3;
u8 win0_en:5;
u8 :3;
u8 win1_en:5;
} packed_bits;
struct {
u8 low;
u8 high;
} bytes;
u16 val ;
} WINxCNT ;
#else
typedef union {
struct {
WINxBIT win0;
WINxBIT win1;
} bits;
struct {
u8 win0_en:5;
u8 :3;
u8 win1_en:5;
u8 :3;
} packed_bits;
struct {
u8 low;
u8 high;
} bytes;
u16 val ;
} WINxCNT ;
#endif
/*
typedef struct {
WINxDIM WIN0H;
WINxDIM WIN1H;
WINxDIM WIN0V;
WINxDIM WIN1V;
WINxCNT WININ;
WINxCNT WINOUT;
} WINCNT;
*/
/*******************************************************************************
this structure is for miscellanous settings
//TODO: needs further description
*******************************************************************************/
typedef struct {
u16 MOSAIC;
u16 unused1;
u16 unused2;//BLDCNT;
u16 unused3;//BLDALPHA;
u16 unused4;//BLDY;
u16 unused5;
/*
u16 unused6;
u16 unused7;
u16 unused8;
u16 unused9;
*/
} MISCCNT;
/*******************************************************************************
this structure is for 3D settings
*******************************************************************************/
struct _DISP3DCNT
{
/* 0*/ u8 EnableTexMapping:1; //
/* 1*/ u8 PolygonShading:1; // 0=Toon Shading, 1=Highlight Shading
/* 2*/ u8 EnableAlphaTest:1; // see ALPHA_TEST_REF
/* 3*/ u8 EnableAlphaBlending:1; // see various Alpha values
/* 4*/ u8 EnableAntiAliasing:1; //
/* 5*/ u8 EnableEdgeMarking:1; // see EDGE_COLOR
/* 6*/ u8 FogOnlyAlpha:1; // 0=Alpha and Color, 1=Only Alpha (see FOG_COLOR)
/* 7*/ u8 EnableFog:1; // Fog Master Enable
/* 8*/ u8 FogShiftSHR:4; // 0..10 SHR-Divider (see FOG_OFFSET)
/*12*/ u8 AckColorBufferUnderflow:1; // Color Buffer RDLINES Underflow (0=None, 1=Underflow/Acknowledge)
/*13*/ u8 AckVertexRAMOverflow:1; // Polygon/Vertex RAM Overflow (0=None, 1=Overflow/Acknowledge)
/*14*/ u8 RearPlaneMode:1; // 0=Blank, 1=Bitmap
/*15*/ u8 :1;
/*16*/ u16 :16;
};
typedef union
{
struct _DISP3DCNT bits;
u32 val;
} DISP3DCNT;
/*******************************************************************************
this structure is for capture control (core A only)
source:
http://nocash.emubase.de/gbatek.htm#dsvideocaptureandmainmemorydisplaymode
*******************************************************************************/
struct DISPCAPCNT
{
enum CAPX {
_128, _256
} capx;
u32 val;
BOOL enabled;
u8 EVA;
u8 EVB;
u8 writeBlock;
u8 writeOffset;
u16 capy;
u8 srcA;
u8 srcB;
u8 readBlock;
u8 readOffset;
u8 capSrc;
} ;
/*******************************************************************************
this structure holds everything and should be mapped to
* core A : 0x04000000
* core B : 0x04001000
*******************************************************************************/
typedef struct _reg_dispx {
DISPCNT dispx_DISPCNT; // 0x0400x000
u16 dispA_DISPSTAT; // 0x04000004
u16 dispx_VCOUNT; // 0x0400x006
BGxCNT dispx_BGxCNT[4]; // 0x0400x008
BGxOFS dispx_BGxOFS[4]; // 0x0400x010
BGxPARMS dispx_BG2PARMS; // 0x0400x020
BGxPARMS dispx_BG3PARMS; // 0x0400x030
u8 filler[12]; // 0x0400x040
MISCCNT dispx_MISC; // 0x0400x04C
DISP3DCNT dispA_DISP3DCNT; // 0x04000060
DISPCAPCNT dispA_DISPCAPCNT; // 0x04000064
u32 dispA_DISPMMEMFIFO; // 0x04000068
} REG_DISPx ;
enum GPUEngineID
{
GPUEngineID_Main = 0,
GPUEngineID_Sub = 1
};
/* human readable bitmask names */
#define ADDRESS_STEP_512B 0x00200
#define ADDRESS_STEP_1KB 0x00400
#define ADDRESS_STEP_2KB 0x00800
#define ADDRESS_STEP_4KB 0x01000
#define ADDRESS_STEP_8KB 0x02000
#define ADDRESS_STEP_16KB 0x04000
#define ADDRESS_STEP_32KB 0x08000
#define ADDRESS_STEP_64KB 0x10000
#define ADDRESS_STEP_128KB 0x20000
#define ADDRESS_STEP_256KB 0x40000
#define ADDRESS_STEP_512KB 0x80000
#define ADDRESS_MASK_256KB (ADDRESS_STEP_256KB-1)
#ifdef MSB_FIRST
struct _TILEENTRY
{
/*14*/ unsigned Palette:4;
/*13*/ unsigned VFlip:1; // VERTICAL FLIP (top<-->bottom)
/*12*/ unsigned HFlip:1; // HORIZONTAL FLIP (left<-->right)
/* 0*/ unsigned TileNum:10;
};
#else
struct _TILEENTRY
{
/* 0*/ unsigned TileNum:10;
/*12*/ unsigned HFlip:1; // HORIZONTAL FLIP (left<-->right)
/*13*/ unsigned VFlip:1; // VERTICAL FLIP (top<-->bottom)
/*14*/ unsigned Palette:4;
};
#endif
typedef union
{
struct _TILEENTRY bits;
u16 val;
} TILEENTRY;
struct _ROTOCOORD
{
u32 Fraction:8;
s32 Integer:20;
u32 pad:4;
};
typedef union
{
struct _ROTOCOORD bits;
s32 val;
} ROTOCOORD;
/*
this structure is for color representation,
it holds 5 meaningful bits per color channel (red,green,blue)
and 1 meaningful bit for alpha representation
this bit can be unused or used for special FX
*/
struct _COLOR { // abgr x555
#ifdef MSB_FIRST
unsigned alpha:1; // sometimes it is unused (pad)
unsigned blue:5;
unsigned green:5;
unsigned red:5;
#else
unsigned red:5;
unsigned green:5;
unsigned blue:5;
unsigned alpha:1; // sometimes it is unused (pad)
#endif
};
struct _COLORx { // abgr x555
unsigned bgr:15;
unsigned alpha:1; // sometimes it is unused (pad)
};
typedef union
{
struct _COLOR bits;
struct _COLORx bitx;
u16 val;
} COLOR;
struct _COLOR32 { // ARGB
unsigned :3;
unsigned blue:5;
unsigned :3;
unsigned green:5;
unsigned :3;
unsigned red:5;
unsigned :7;
unsigned alpha:1; // sometimes it is unused (pad)
};
typedef union
{
struct _COLOR32 bits;
u32 val;
} COLOR32;
#define COLOR_16_32(w,i) \
/* doesnt matter who's 16bit who's 32bit */ \
i.bits.red = w.bits.red; \
i.bits.green = w.bits.green; \
i.bits.blue = w.bits.blue; \
i.bits.alpha = w.bits.alpha;
// (00: Normal, 01: Transparent, 10: Object window, 11: Bitmap)
enum GPU_OBJ_MODE
{
GPU_OBJ_MODE_Normal = 0,
GPU_OBJ_MODE_Transparent = 1,
GPU_OBJ_MODE_Window = 2,
GPU_OBJ_MODE_Bitmap = 3
};
typedef union
{
u16 attr[4];
struct
{
#ifdef MSB_FIRST
//attr0
unsigned Shape:2;
unsigned Depth:1;
unsigned Mosaic:1;
unsigned Mode:2;
unsigned RotScale:2;
unsigned Y:8;
//attr1
unsigned Size:2;
unsigned VFlip:1;
unsigned HFlip:1;
unsigned RotScalIndex:3;
signed X:9;
//attr2
unsigned PaletteIndex:4;
unsigned Priority:2;
unsigned TileIndex:10;
//attr3
unsigned attr3:16; // Whenever this is used, you will need to explicitly convert endianness.
#else
//attr0
unsigned Y:8;
unsigned RotScale:2;
unsigned Mode:2;
unsigned Mosaic:1;
unsigned Depth:1;
unsigned Shape:2;
//attr1
signed X:9;
unsigned RotScalIndex:3;
unsigned HFlip:1;
unsigned VFlip:1;
unsigned Size:2;
//attr2
unsigned TileIndex:10;
unsigned Priority:2;
unsigned PaletteIndex:4;
//attr3
unsigned attr3:16; // Whenever this is used, you will need to explicitly convert endianness.
#endif
};
} OAMAttributes;
enum SpriteRenderMode
{
SpriteRenderMode_Sprite1D = 0,
SpriteRenderMode_Sprite2D = 1
};
typedef struct
{
s16 x;
s16 y;
} SpriteSize;
typedef u8 TBlendTable[32][32];
#define NB_PRIORITIES 4
#define NB_BG 4
//this structure holds information for rendering.
typedef struct
{
u8 PixelsX[256];
u8 BGs[NB_BG], nbBGs;
u8 pad[1];
u16 nbPixelsX;
//256+8:
u8 pad2[248];
//things were slower when i organized this struct this way. whatever.
//u8 PixelsX[256];
//int BGs[NB_BG], nbBGs;
//int nbPixelsX;
////<-- 256 + 24
//u8 pad2[256-24];
} itemsForPriority_t;
#define MMU_ABG 0x06000000
#define MMU_BBG 0x06200000
#define MMU_AOBJ 0x06400000
#define MMU_BOBJ 0x06600000
#define MMU_LCDC 0x06800000
enum GPULayerID
{
GPULayerID_BG0 = 0,
GPULayerID_BG1 = 1,
GPULayerID_BG2 = 2,
GPULayerID_BG3 = 3,
GPULayerID_OBJ = 4,
GPULayerID_None = 5
};
enum BGType
{
BGType_Invalid = 0,
BGType_Text = 1,
BGType_Affine = 2,
BGType_Large8bpp = 3,
BGType_AffineExt = 4,
BGType_AffineExt_256x16 = 5,
BGType_AffineExt_256x1 = 6,
BGType_AffineExt_Direct = 7
};
enum GPUDisplayMode
{
GPUDisplayMode_Off = 0,
GPUDisplayMode_Normal = 1,
GPUDisplayMode_VRAM = 2,
GPUDisplayMode_MainMemory = 3
};
enum GPUMasterBrightMode
{
GPUMasterBrightMode_Disable = 0,
GPUMasterBrightMode_Up = 1,
GPUMasterBrightMode_Down = 2,
GPUMasterBrightMode_Reserved = 3
};
enum GPULayerType
{
GPULayerType_3D = 0,
GPULayerType_BG = 1,
GPULayerType_OBJ = 2
};
enum NDSDisplayID
{
NDSDisplayID_Main = 0,
NDSDisplayID_Touch = 1
};
typedef struct
{
u8 blockIndexDisplayVRAM;
bool isBlockUsed[4];
} VRAM3DUsageProperties;
typedef struct
{
bool isCustomSizeRequested; // true - The user requested a custom size; false - The user requested the native size
size_t customWidth; // The custom buffer width, measured in pixels
size_t customHeight; // The custom buffer height, measured in pixels
u16 *masterCustomBuffer; // Pointer to the head of the master custom buffer.
u16 *masterNativeBuffer; // Pointer to the head of the master native buffer.
u16 *customBuffer[2]; // Pointer to a display's custom size framebuffer
u16 *nativeBuffer[2]; // Pointer to a display's native size framebuffer
bool didPerformCustomRender[2]; // true - The display performed a custom render; false - The display performed a native render
size_t renderedWidth[2]; // The display rendered at this width, measured in pixels
size_t renderedHeight[2]; // The display rendered at this height, measured in pixels
u16 *renderedBuffer[2]; // The display rendered to this buffer
} NDSDisplayInfo;
#define VRAM_NO_3D_USAGE 0xFF
class GPUEngineBase
{
protected:
static CACHE_ALIGN u16 _fadeInColors[17][0x8000];
static CACHE_ALIGN u16 _fadeOutColors[17][0x8000];
static CACHE_ALIGN u8 _blendTable555[17][17][32][32];
static const CACHE_ALIGN SpriteSize _sprSizeTab[4][4];
static const CACHE_ALIGN BGType _mode2type[8][4];
static const CACHE_ALIGN u16 _sizeTab[8][4][2];
static const CACHE_ALIGN u8 _winEmpty[GPU_FRAMEBUFFER_NATIVE_WIDTH];
static struct MosaicLookup {
struct TableEntry {
u8 begin, trunc;
} table[16][256];
MosaicLookup() {
for(int m=0;m<16;m++)
for(int i=0;i<256;i++) {
int mosaic = m+1;
TableEntry &te = table[m][i];
te.begin = (i%mosaic==0);
te.trunc = i/mosaic*mosaic;
}
}
TableEntry *width, *height;
int widthValue, heightValue;
} _mosaicLookup;
CACHE_ALIGN u16 _sprColor[GPU_FRAMEBUFFER_NATIVE_WIDTH];
CACHE_ALIGN u8 _sprAlpha[GPU_FRAMEBUFFER_NATIVE_WIDTH];
CACHE_ALIGN u8 _sprType[GPU_FRAMEBUFFER_NATIVE_WIDTH];
CACHE_ALIGN u8 _sprPrio[GPU_FRAMEBUFFER_NATIVE_WIDTH];
CACHE_ALIGN u8 _sprWin[GPU_FRAMEBUFFER_NATIVE_WIDTH];
bool _enableLayer[5];
itemsForPriority_t _itemsForPriority[NB_PRIORITIES];
struct MosaicColor {
u16 bg[4][256];
struct Obj {
u16 color;
u8 alpha;
u8 opaque;
} obj[256];
} _mosaicColors;
GPUEngineID _engineID;
u8 _bgPrio[5];
bool _bg0HasHighestPrio;
OAMAttributes *_oamList;
u32 _sprMem;
u8 _sprBoundary;
u8 _sprBMPBoundary;
u8 _sprBMPMode;
u32 _sprEnable;
u16 *_currentFadeInColors;
u16 *_currentFadeOutColors;
bool _blend1;
bool _blend2[8];
TBlendTable *_blendTable;
u32 _BG_bmp_large_ram[4];
u32 _BG_bmp_ram[4];
u32 _BG_tile_ram[4];
u32 _BG_map_ram[4];
BGType _BGTypes[4];
GPUDisplayMode _dispMode;
u8 _vramBlock;
CACHE_ALIGN u8 _sprNum[256];
CACHE_ALIGN u8 _h_win[2][GPU_FRAMEBUFFER_NATIVE_WIDTH];
const u8 *_curr_win[2];
NDSDisplayID _targetDisplayID;
u16 *_VRAMaddrNative;
u16 *_VRAMaddrCustom;
bool _curr_mosaic_enabled;
int _finalColorBckFuncID;
int _finalColor3DFuncID;
int _finalColorSpriteFuncID;
SpriteRenderMode _spriteRenderMode;
u8 *_bgPixels;
u8 _WIN0H0;
u8 _WIN0H1;
u8 _WIN0V0;
u8 _WIN0V1;
u8 _WIN1H0;
u8 _WIN1H1;
u8 _WIN1V0;
u8 _WIN1V1;
u8 _WININ0;
bool _WININ0_SPECIAL;
u8 _WININ1;
bool _WININ1_SPECIAL;
u8 _WINOUT;
bool _WINOUT_SPECIAL;
u8 _WINOBJ;
bool _WINOBJ_SPECIAL;
u8 _WIN0_ENABLED;
u8 _WIN1_ENABLED;
u8 _WINOBJ_ENABLED;
u16 _BLDCNT;
u8 _BLDALPHA_EVA;
u8 _BLDALPHA_EVB;
u8 _BLDY_EVY;
void _InitLUTs();
void _Reset_Base();
void _MosaicSpriteLinePixel(const size_t x, u16 l, u16 *dst, u8 *dst_alpha, u8 *typeTab, u8 *prioTab);
void _MosaicSpriteLine(u16 l, u16 *dst, u8 *dst_alpha, u8 *typeTab, u8 *prioTab);
template void _LineLarge8bpp();
template void _RenderLine_TextBG(u16 XBG, u16 YBG, u16 LG);
template void _RotBG2(const BGxPARMS ¶m, const u16 LG);
template void _ExtRotBG2(const BGxPARMS ¶m, const u16 LG);
template void _LineText();
template void _LineRot();
template void _LineExtRot();
// check whether (x,y) is within the rectangle (including wraparounds)
template u8 _WithinRect(const size_t x) const;
template void _RenderLine_CheckWindows(const size_t srcX, bool &draw, bool &effect) const;
template void _RenderLine_Layer(const u16 l, u16 *dstLine, const size_t dstLineWidth, const size_t dstLineCount);
template void _RenderLine_MasterBrightness(u16 *dstLine, const size_t dstLineWidth, const size_t dstLineCount);
template void _UpdateWINH();
template void _SetupWindows();
template void _ModeRender();
template
FORCEINLINE FASTCALL bool _master_setFinalBGColor(const size_t srcX, const size_t dstX, const u16 *dstLine, const u8 *bgPixelsLine, u16 &outColor);
template
FORCEINLINE FASTCALL void _master_setFinal3dColor(const size_t srcX, const size_t dstX, u16 *dstLine, u8 *bgPixelsLine, const FragmentColor src);
template
FORCEINLINE FASTCALL void _master_setFinalOBJColor(const size_t srcX, const size_t dstX, u16 *dstLine, u8 *bgPixelsLine, const u16 src, const u8 alpha, const u8 type);
template void _SetFinalColorBG(const size_t srcX, const size_t dstX, u16 *dstLine, u8 *bgPixelsLine, u16 src);
template void _SetFinalColor3D(const size_t srcX, const size_t dstX, u16 *dstLine, u8 *bgPixelsLine, const FragmentColor src);
template void _SetFinalColorSprite(const size_t srcX, const size_t dstX, u16 *dstLine, u8 *bgPixelsLine, const u16 src, const u8 alpha, const u8 type);
u16 _FinalColorBlend(const u16 colA, const u16 colB);
FORCEINLINE u16 _FinalColorBlendFunc(const u16 colA, const u16 colB, const TBlendTable *blendTable);
void _RenderSpriteBMP(const u8 spriteNum, const u16 l, u16 *dst, const u32 srcadr, u8 *dst_alpha, u8 *typeTab, u8 *prioTab, const u8 prio, const size_t lg, size_t sprX, size_t x, const s32 xdir, const u8 alpha);
void _RenderSprite256(const u8 spriteNum, const u16 l, u16 *dst, const u32 srcadr, const u16 *pal, u8 *dst_alpha, u8 *typeTab, u8 *prioTab, const u8 prio, const size_t lg, size_t sprX, size_t x, const s32 xdir, const u8 alpha);
void _RenderSprite16(const u16 l, u16 *dst, const u32 srcadr, const u16 *pal, u8 *dst_alpha, u8 *typeTab, u8 *prioTab, const u8 prio, const size_t lg, size_t sprX, size_t x, const s32 xdir, const u8 alpha);
void _RenderSpriteWin(const u8 *src, const bool col256, const size_t lg, size_t sprX, size_t x, const s32 xdir);
bool _ComputeSpriteVars(const OAMAttributes &spriteInfo, const u16 l, SpriteSize &sprSize, s32 &sprX, s32 &sprY, s32 &x, s32 &y, s32 &lg, s32 &xdir);
u32 _SpriteAddressBMP(const OAMAttributes &spriteInfo, const SpriteSize sprSize, const s32 y);
template void _SpriteRenderPerform(u16 *dst, u8 *dst_alpha, u8 *typeTab, u8 *prioTab);
public:
GPUEngineBase();
virtual ~GPUEngineBase();
virtual void Reset();
void ResortBGLayers();
void SetMasterBrightness(const u16 val);
void SetupFinalPixelBlitter();
void SetVideoProp(const u32 ctrlBits);
void SetBGProp(const size_t num, const u16 ctrlBits);
template void RenderLine(const u16 l, bool skip);
// some structs are becoming redundant
// some functions too (no need to recopy some vars as it is done by MMU)
REG_DISPx *dispx_st;
//this indicates whether this gpu is handling debug tools
bool debug;
_BGxCNT & bgcnt(int num) { return (dispx_st)->dispx_BGxCNT[num].bits; }
const _DISPCNT& dispCnt() const { return dispx_st->dispx_DISPCNT.bits; }
u16 BGSize[4][2];
u8 BGExtPalSlot[4];
bool isCustomRenderingNeeded;
bool is3DEnabled;
u8 vramBGLayer;
u8 vramBlockBGIndex;
u8 vramBlockOBJIndex;
u16 *customBuffer;
u16 *nativeBuffer;
size_t renderedWidth;
size_t renderedHeight;
u16 *renderedBuffer;
u16 *workingScanline;
GPUMasterBrightMode MasterBrightMode;
u32 MasterBrightFactor;
u32 currLine;
u16 *currDst;
bool need_update_winh[2];
struct AffineInfo {
AffineInfo() : x(0), y(0) {}
u32 x, y;
} affineInfo[2];
bool GetEnableState();
void SetEnableState(bool theState);
bool GetLayerEnableState(const size_t layerIndex);
void SetLayerEnableState(const size_t layerIndex, bool theState);
template FORCEINLINE void ____setFinalColorBck(const u16 color, const size_t srcX);
template FORCEINLINE void ___setFinalColorBck(u16 color, const size_t srcX, const bool opaque);
template FORCEINLINE void __setFinalColorBck(u16 color, const size_t srcX, const bool opaque);
void UpdateVRAM3DUsageProperties_BGLayer(const size_t bankIndex, VRAM3DUsageProperties &outProperty);
void UpdateVRAM3DUsageProperties_OBJLayer(const size_t bankIndex, VRAM3DUsageProperties &outProperty);
void setAffineStart(const size_t layer, int xy, u32 val);
void setAffineStartWord(const size_t layer, int xy, u16 val, int word);
u32 getAffineStart(const size_t layer, int xy);
void refreshAffineStartRegs(const int num, const int xy);
void SpriteRender(u16 *dst, u8 *dst_alpha, u8 *typeTab, u8 *prioTab);
void ModeRenderDebug(const GPULayerID layerID);
template void HandleDisplayModeOff(u16 *dstLine, const size_t l, const size_t dstLineWidth, const size_t dstLineCount);
template void HandleDisplayModeNormal(u16 *dstLine, const size_t l, const size_t dstLineWidth, const size_t dstLineCount);
template void HandleDisplayModeVRAM(u16 *dstLine, const size_t l, const size_t dstLineWidth, const size_t dstLineCount);
template void HandleDisplayModeMainMemory(u16 *dstLine, const size_t l, const size_t dstLineWidth, const size_t dstLineCount);
u32 GetHOFS(const size_t bg) const;
u32 GetVOFS(const size_t bg) const;
void UpdateBLDALPHA();
void SetBLDALPHA(const u16 val);
void SetBLDALPHA_EVA(const u8 val);
void SetBLDALPHA_EVB(const u8 val);
// Blending
void SetBLDCNT_LOW(const u8 val);
void SetBLDCNT_HIGH(const u8 val);
void SetBLDCNT(const u16 val);
void SetBLDY_EVY(const u8 val);
void SetWIN0_H(const u16 val);
void SetWIN0_H0(const u8 val);
void SetWIN0_H1(const u8 val);
void SetWIN0_V(const u16 val);
void SetWIN0_V0(const u8 val);
void SetWIN0_V1(const u8 val);
void SetWIN1_H(const u16 val);
void SetWIN1_H0(const u8 val);
void SetWIN1_H1(const u8 val);
void SetWIN1_V(const u16 val);
void SetWIN1_V0(const u8 val);
void SetWIN1_V1(const u8 val);
void SetWININ(const u16 val);
void SetWININ0(const u8 val);
void SetWININ1(const u8 val);
void SetWINOUT16(const u16 val);
void SetWINOUT(const u8 val);
void SetWINOBJ(const u8 val);
int GetFinalColorBckFuncID() const;
void SetFinalColorBckFuncID(int funcID);
NDSDisplayID GetDisplayByID() const;
void SetDisplayByID(const NDSDisplayID theDisplayID);
GPUEngineID GetEngineID() const;
virtual void SetCustomFramebufferSize(size_t w, size_t h);
void BlitNativeToCustomFramebuffer();
void REG_DISPx_pack_test();
};
class GPUEngineA : public GPUEngineBase
{
protected:
FragmentColor *_3DFramebufferRGBA6665;
u16 *_3DFramebufferRGBA5551;
template void _RenderLine_Layer(const u16 l, u16 *dstLine, const size_t dstLineWidth, const size_t dstLineCount);
template void _RenderLine_DisplayCapture(const u16 l);
void _RenderLine_DispCapture_FIFOToBuffer(u16 *fifoLineBuffer);
template
void _RenderLine_DispCapture_Copy(const u16 *__restrict src, u16 *__restrict dst, const size_t captureLengthExt, const size_t captureLineCount);
u16 _RenderLine_DispCapture_BlendFunc(const u16 srcA, const u16 srcB, const u8 blendEVA, const u8 blendEVB);
#ifdef ENABLE_SSE2
__m128i _RenderLine_DispCapture_BlendFunc_SSE2(__m128i &srcA, __m128i &srcB, const __m128i &blendEVA, const __m128i &blendEVB);
#endif
template
void _RenderLine_DispCapture_BlendToCustomDstBuffer(const u16 *__restrict srcA, const u16 *__restrict srcB, u16 *__restrict dst, const u8 blendEVA, const u8 blendEVB, const size_t length, size_t l);
template
void _RenderLine_DispCapture_Blend(const u16 *__restrict srcA, const u16 *__restrict srcB, u16 *__restrict dst, const size_t captureLengthExt, const size_t l);
public:
DISPCAPCNT dispCapCnt;
GPUEngineA();
~GPUEngineA();
virtual void Reset();
void SetDISPCAPCNT(u32 val);
GPUDisplayMode GetDisplayMode() const;
u8 GetVRAMBlock() const;
FragmentColor* Get3DFramebufferRGBA6665() const;
u16* Get3DFramebufferRGBA5551() const;
virtual void SetCustomFramebufferSize(size_t w, size_t h);
template void RenderLine(const u16 l, bool skip);
};
class GPUEngineB : public GPUEngineBase
{
protected:
template void _RenderLine_Layer(const u16 l, u16 *dstLine, const size_t dstLineWidth, const size_t dstLineCount);
public:
GPUEngineB();
virtual void Reset();
template void RenderLine(const u16 l, bool skip);
};
class NDSDisplay
{
private:
NDSDisplayID _ID;
GPUEngineBase *_gpu;
public:
NDSDisplay();
NDSDisplay(const NDSDisplayID displayID);
NDSDisplay(const NDSDisplayID displayID, GPUEngineBase *theEngine);
GPUEngineBase* GetEngine();
void SetEngine(GPUEngineBase *theEngine);
GPUEngineID GetEngineID();
void SetEngineByID(const GPUEngineID theID);
};
class GPUSubsystem
{
private:
GPUEngineA *_engineMain;
GPUEngineB *_engineSub;
NDSDisplay *_displayMain;
NDSDisplay *_displayTouch;
bool _willAutoBlitNativeToCustomBuffer;
VRAM3DUsageProperties _VRAM3DUsage;
u16 *_customVRAM;
u16 *_customVRAMBlank;
CACHE_ALIGN u16 _nativeFramebuffer[GPU_FRAMEBUFFER_NATIVE_WIDTH * GPU_FRAMEBUFFER_NATIVE_HEIGHT * 2];
u16 *_customFramebuffer;
NDSDisplayInfo _displayInfo;
public:
GPUSubsystem();
~GPUSubsystem();
void Reset();
VRAM3DUsageProperties& GetVRAM3DUsageProperties();
const NDSDisplayInfo& GetDisplayInfo(); // Frontends need to call this whenever they need to read the video buffers from the emulator core
void SetDisplayDidCustomRender(NDSDisplayID displayID, bool theState);
GPUEngineA* GetEngineMain();
GPUEngineB* GetEngineSub();
NDSDisplay* GetDisplayMain();
NDSDisplay* GetDisplayTouch();
u16* GetNativeFramebuffer();
u16* GetNativeFramebuffer(const NDSDisplayID theDisplayID);
u16* GetCustomFramebuffer();
u16* GetCustomFramebuffer(const NDSDisplayID theDisplayID);
u16* GetCustomVRAMBuffer();
u16* GetCustomVRAMBlankBuffer();
size_t GetCustomFramebufferWidth() const;
size_t GetCustomFramebufferHeight() const;
void SetCustomFramebufferSize(size_t w, size_t h);
void UpdateVRAM3DUsageProperties();
// Normally, the GPUs will automatically blit their native buffers to the master
// framebuffer at the end of V-blank so that all rendered graphics are contained
// within a single common buffer. This is necessary for when someone wants to read
// the NDS framebuffers, but the reader can only read a single buffer at a time.
// Certain functions, such as taking screenshots, as well as many frontends running
// the NDS video displays, require that they read from only a single buffer.
//
// However, if SetWillAutoBlitNativeToCustomBuffer() is passed "false", then the
// frontend becomes responsible for calling GetDisplayInfo() and reading the native
// and custom buffers properly for each display. If a single buffer is still needed
// for certain cases, then the frontend must manually call
// GPUEngineBase::BlitNativeToCustomFramebuffer() for each GPU before reading the
// master framebuffer.
bool GetWillAutoBlitNativeToCustomBuffer() const;
void SetWillAutoBlitNativeToCustomBuffer(const bool willAutoBlit);
void RenderLine(const u16 l, bool skip = false);
void ClearWithColor(const u16 colorBGRA5551);
};
extern GPUSubsystem *GPU;
extern MMU_struct MMU;
inline FragmentColor MakeFragmentColor(const u8 r, const u8 g, const u8 b, const u8 a)
{
FragmentColor ret;
ret.r = r; ret.g = g; ret.b = b; ret.a = a;
return ret;
}
#endif
desmume/src/libretro-common/include/libretro.h 000664 001750 001750 00000307731 12755534123 022700 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this libretro API header (libretro.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef LIBRETRO_H__
#define LIBRETRO_H__
#include
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __cplusplus
#if defined(_MSC_VER) && !defined(SN_TARGET_PS3)
/* Hack applied for MSVC when compiling in C89 mode
* as it isn't C99-compliant. */
#define bool unsigned char
#define true 1
#define false 0
#else
#include
#endif
#endif
#ifndef RETRO_CALLCONV
# if defined(__GNUC__) && defined(__i386__) && !defined(__x86_64__)
# define RETRO_CALLCONV __attribute__((cdecl))
# elif defined(_MSC_VER) && defined(_M_X86) && !defined(_M_X64)
# define RETRO_CALLCONV __cdecl
# else
# define RETRO_CALLCONV /* all other platforms only have one calling convention each */
# endif
#endif
#ifndef RETRO_API
# if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
# ifdef RETRO_IMPORT_SYMBOLS
# ifdef __GNUC__
# define RETRO_API RETRO_CALLCONV __attribute__((__dllimport__))
# else
# define RETRO_API RETRO_CALLCONV __declspec(dllimport)
# endif
# else
# ifdef __GNUC__
# define RETRO_API RETRO_CALLCONV __attribute__((__dllexport__))
# else
# define RETRO_API RETRO_CALLCONV __declspec(dllexport)
# endif
# endif
# else
# if defined(__GNUC__) && __GNUC__ >= 4 && !defined(__CELLOS_LV2__)
# define RETRO_API RETRO_CALLCONV __attribute__((__visibility__("default")))
# else
# define RETRO_API RETRO_CALLCONV
# endif
# endif
#endif
/* Used for checking API/ABI mismatches that can break libretro
* implementations.
* It is not incremented for compatible changes to the API.
*/
#define RETRO_API_VERSION 1
/*
* Libretro's fundamental device abstractions.
*
* Libretro's input system consists of some standardized device types,
* such as a joypad (with/without analog), mouse, keyboard, lightgun
* and a pointer.
*
* The functionality of these devices are fixed, and individual cores
* map their own concept of a controller to libretro's abstractions.
* This makes it possible for frontends to map the abstract types to a
* real input device, and not having to worry about binding input
* correctly to arbitrary controller layouts.
*/
#define RETRO_DEVICE_TYPE_SHIFT 8
#define RETRO_DEVICE_MASK ((1 << RETRO_DEVICE_TYPE_SHIFT) - 1)
#define RETRO_DEVICE_SUBCLASS(base, id) (((id + 1) << RETRO_DEVICE_TYPE_SHIFT) | base)
/* Input disabled. */
#define RETRO_DEVICE_NONE 0
/* The JOYPAD is called RetroPad. It is essentially a Super Nintendo
* controller, but with additional L2/R2/L3/R3 buttons, similar to a
* PS1 DualShock. */
#define RETRO_DEVICE_JOYPAD 1
/* The mouse is a simple mouse, similar to Super Nintendo's mouse.
* X and Y coordinates are reported relatively to last poll (poll callback).
* It is up to the libretro implementation to keep track of where the mouse
* pointer is supposed to be on the screen.
* The frontend must make sure not to interfere with its own hardware
* mouse pointer.
*/
#define RETRO_DEVICE_MOUSE 2
/* KEYBOARD device lets one poll for raw key pressed.
* It is poll based, so input callback will return with the current
* pressed state.
* For event/text based keyboard input, see
* RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK.
*/
#define RETRO_DEVICE_KEYBOARD 3
/* Lightgun X/Y coordinates are reported relatively to last poll,
* similar to mouse. */
#define RETRO_DEVICE_LIGHTGUN 4
/* The ANALOG device is an extension to JOYPAD (RetroPad).
* Similar to DualShock it adds two analog sticks.
* This is treated as a separate device type as it returns values in the
* full analog range of [-0x8000, 0x7fff]. Positive X axis is right.
* Positive Y axis is down.
* Only use ANALOG type when polling for analog values of the axes.
*/
#define RETRO_DEVICE_ANALOG 5
/* Abstracts the concept of a pointing mechanism, e.g. touch.
* This allows libretro to query in absolute coordinates where on the
* screen a mouse (or something similar) is being placed.
* For a touch centric device, coordinates reported are the coordinates
* of the press.
*
* Coordinates in X and Y are reported as:
* [-0x7fff, 0x7fff]: -0x7fff corresponds to the far left/top of the screen,
* and 0x7fff corresponds to the far right/bottom of the screen.
* The "screen" is here defined as area that is passed to the frontend and
* later displayed on the monitor.
*
* The frontend is free to scale/resize this screen as it sees fit, however,
* (X, Y) = (-0x7fff, -0x7fff) will correspond to the top-left pixel of the
* game image, etc.
*
* To check if the pointer coordinates are valid (e.g. a touch display
* actually being touched), PRESSED returns 1 or 0.
*
* If using a mouse on a desktop, PRESSED will usually correspond to the
* left mouse button, but this is a frontend decision.
* PRESSED will only return 1 if the pointer is inside the game screen.
*
* For multi-touch, the index variable can be used to successively query
* more presses.
* If index = 0 returns true for _PRESSED, coordinates can be extracted
* with _X, _Y for index = 0. One can then query _PRESSED, _X, _Y with
* index = 1, and so on.
* Eventually _PRESSED will return false for an index. No further presses
* are registered at this point. */
#define RETRO_DEVICE_POINTER 6
/* Buttons for the RetroPad (JOYPAD).
* The placement of these is equivalent to placements on the
* Super Nintendo controller.
* L2/R2/L3/R3 buttons correspond to the PS1 DualShock. */
#define RETRO_DEVICE_ID_JOYPAD_B 0
#define RETRO_DEVICE_ID_JOYPAD_Y 1
#define RETRO_DEVICE_ID_JOYPAD_SELECT 2
#define RETRO_DEVICE_ID_JOYPAD_START 3
#define RETRO_DEVICE_ID_JOYPAD_UP 4
#define RETRO_DEVICE_ID_JOYPAD_DOWN 5
#define RETRO_DEVICE_ID_JOYPAD_LEFT 6
#define RETRO_DEVICE_ID_JOYPAD_RIGHT 7
#define RETRO_DEVICE_ID_JOYPAD_A 8
#define RETRO_DEVICE_ID_JOYPAD_X 9
#define RETRO_DEVICE_ID_JOYPAD_L 10
#define RETRO_DEVICE_ID_JOYPAD_R 11
#define RETRO_DEVICE_ID_JOYPAD_L2 12
#define RETRO_DEVICE_ID_JOYPAD_R2 13
#define RETRO_DEVICE_ID_JOYPAD_L3 14
#define RETRO_DEVICE_ID_JOYPAD_R3 15
/* Index / Id values for ANALOG device. */
#define RETRO_DEVICE_INDEX_ANALOG_LEFT 0
#define RETRO_DEVICE_INDEX_ANALOG_RIGHT 1
#define RETRO_DEVICE_ID_ANALOG_X 0
#define RETRO_DEVICE_ID_ANALOG_Y 1
/* Id values for MOUSE. */
#define RETRO_DEVICE_ID_MOUSE_X 0
#define RETRO_DEVICE_ID_MOUSE_Y 1
#define RETRO_DEVICE_ID_MOUSE_LEFT 2
#define RETRO_DEVICE_ID_MOUSE_RIGHT 3
#define RETRO_DEVICE_ID_MOUSE_WHEELUP 4
#define RETRO_DEVICE_ID_MOUSE_WHEELDOWN 5
#define RETRO_DEVICE_ID_MOUSE_MIDDLE 6
#define RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELUP 7
#define RETRO_DEVICE_ID_MOUSE_HORIZ_WHEELDOWN 8
/* Id values for LIGHTGUN types. */
#define RETRO_DEVICE_ID_LIGHTGUN_X 0
#define RETRO_DEVICE_ID_LIGHTGUN_Y 1
#define RETRO_DEVICE_ID_LIGHTGUN_TRIGGER 2
#define RETRO_DEVICE_ID_LIGHTGUN_CURSOR 3
#define RETRO_DEVICE_ID_LIGHTGUN_TURBO 4
#define RETRO_DEVICE_ID_LIGHTGUN_PAUSE 5
#define RETRO_DEVICE_ID_LIGHTGUN_START 6
/* Id values for POINTER. */
#define RETRO_DEVICE_ID_POINTER_X 0
#define RETRO_DEVICE_ID_POINTER_Y 1
#define RETRO_DEVICE_ID_POINTER_PRESSED 2
/* Returned from retro_get_region(). */
#define RETRO_REGION_NTSC 0
#define RETRO_REGION_PAL 1
/* Id values for LANGUAGE */
enum retro_language
{
RETRO_LANGUAGE_ENGLISH = 0,
RETRO_LANGUAGE_JAPANESE = 1,
RETRO_LANGUAGE_FRENCH = 2,
RETRO_LANGUAGE_SPANISH = 3,
RETRO_LANGUAGE_GERMAN = 4,
RETRO_LANGUAGE_ITALIAN = 5,
RETRO_LANGUAGE_DUTCH = 6,
RETRO_LANGUAGE_PORTUGUESE = 7,
RETRO_LANGUAGE_RUSSIAN = 8,
RETRO_LANGUAGE_KOREAN = 9,
RETRO_LANGUAGE_CHINESE_TRADITIONAL = 10,
RETRO_LANGUAGE_CHINESE_SIMPLIFIED = 11,
RETRO_LANGUAGE_ESPERANTO = 12,
RETRO_LANGUAGE_POLISH = 13,
RETRO_LANGUAGE_LAST,
/* Ensure sizeof(enum) == sizeof(int) */
RETRO_LANGUAGE_DUMMY = INT_MAX
};
/* Passed to retro_get_memory_data/size().
* If the memory type doesn't apply to the
* implementation NULL/0 can be returned.
*/
#define RETRO_MEMORY_MASK 0xff
/* Regular save RAM. This RAM is usually found on a game cartridge,
* backed up by a battery.
* If save game data is too complex for a single memory buffer,
* the SAVE_DIRECTORY (preferably) or SYSTEM_DIRECTORY environment
* callback can be used. */
#define RETRO_MEMORY_SAVE_RAM 0
/* Some games have a built-in clock to keep track of time.
* This memory is usually just a couple of bytes to keep track of time.
*/
#define RETRO_MEMORY_RTC 1
/* System ram lets a frontend peek into a game systems main RAM. */
#define RETRO_MEMORY_SYSTEM_RAM 2
/* Video ram lets a frontend peek into a game systems video RAM (VRAM). */
#define RETRO_MEMORY_VIDEO_RAM 3
/* Keysyms used for ID in input state callback when polling RETRO_KEYBOARD. */
enum retro_key
{
RETROK_UNKNOWN = 0,
RETROK_FIRST = 0,
RETROK_BACKSPACE = 8,
RETROK_TAB = 9,
RETROK_CLEAR = 12,
RETROK_RETURN = 13,
RETROK_PAUSE = 19,
RETROK_ESCAPE = 27,
RETROK_SPACE = 32,
RETROK_EXCLAIM = 33,
RETROK_QUOTEDBL = 34,
RETROK_HASH = 35,
RETROK_DOLLAR = 36,
RETROK_AMPERSAND = 38,
RETROK_QUOTE = 39,
RETROK_LEFTPAREN = 40,
RETROK_RIGHTPAREN = 41,
RETROK_ASTERISK = 42,
RETROK_PLUS = 43,
RETROK_COMMA = 44,
RETROK_MINUS = 45,
RETROK_PERIOD = 46,
RETROK_SLASH = 47,
RETROK_0 = 48,
RETROK_1 = 49,
RETROK_2 = 50,
RETROK_3 = 51,
RETROK_4 = 52,
RETROK_5 = 53,
RETROK_6 = 54,
RETROK_7 = 55,
RETROK_8 = 56,
RETROK_9 = 57,
RETROK_COLON = 58,
RETROK_SEMICOLON = 59,
RETROK_LESS = 60,
RETROK_EQUALS = 61,
RETROK_GREATER = 62,
RETROK_QUESTION = 63,
RETROK_AT = 64,
RETROK_LEFTBRACKET = 91,
RETROK_BACKSLASH = 92,
RETROK_RIGHTBRACKET = 93,
RETROK_CARET = 94,
RETROK_UNDERSCORE = 95,
RETROK_BACKQUOTE = 96,
RETROK_a = 97,
RETROK_b = 98,
RETROK_c = 99,
RETROK_d = 100,
RETROK_e = 101,
RETROK_f = 102,
RETROK_g = 103,
RETROK_h = 104,
RETROK_i = 105,
RETROK_j = 106,
RETROK_k = 107,
RETROK_l = 108,
RETROK_m = 109,
RETROK_n = 110,
RETROK_o = 111,
RETROK_p = 112,
RETROK_q = 113,
RETROK_r = 114,
RETROK_s = 115,
RETROK_t = 116,
RETROK_u = 117,
RETROK_v = 118,
RETROK_w = 119,
RETROK_x = 120,
RETROK_y = 121,
RETROK_z = 122,
RETROK_DELETE = 127,
RETROK_KP0 = 256,
RETROK_KP1 = 257,
RETROK_KP2 = 258,
RETROK_KP3 = 259,
RETROK_KP4 = 260,
RETROK_KP5 = 261,
RETROK_KP6 = 262,
RETROK_KP7 = 263,
RETROK_KP8 = 264,
RETROK_KP9 = 265,
RETROK_KP_PERIOD = 266,
RETROK_KP_DIVIDE = 267,
RETROK_KP_MULTIPLY = 268,
RETROK_KP_MINUS = 269,
RETROK_KP_PLUS = 270,
RETROK_KP_ENTER = 271,
RETROK_KP_EQUALS = 272,
RETROK_UP = 273,
RETROK_DOWN = 274,
RETROK_RIGHT = 275,
RETROK_LEFT = 276,
RETROK_INSERT = 277,
RETROK_HOME = 278,
RETROK_END = 279,
RETROK_PAGEUP = 280,
RETROK_PAGEDOWN = 281,
RETROK_F1 = 282,
RETROK_F2 = 283,
RETROK_F3 = 284,
RETROK_F4 = 285,
RETROK_F5 = 286,
RETROK_F6 = 287,
RETROK_F7 = 288,
RETROK_F8 = 289,
RETROK_F9 = 290,
RETROK_F10 = 291,
RETROK_F11 = 292,
RETROK_F12 = 293,
RETROK_F13 = 294,
RETROK_F14 = 295,
RETROK_F15 = 296,
RETROK_NUMLOCK = 300,
RETROK_CAPSLOCK = 301,
RETROK_SCROLLOCK = 302,
RETROK_RSHIFT = 303,
RETROK_LSHIFT = 304,
RETROK_RCTRL = 305,
RETROK_LCTRL = 306,
RETROK_RALT = 307,
RETROK_LALT = 308,
RETROK_RMETA = 309,
RETROK_LMETA = 310,
RETROK_LSUPER = 311,
RETROK_RSUPER = 312,
RETROK_MODE = 313,
RETROK_COMPOSE = 314,
RETROK_HELP = 315,
RETROK_PRINT = 316,
RETROK_SYSREQ = 317,
RETROK_BREAK = 318,
RETROK_MENU = 319,
RETROK_POWER = 320,
RETROK_EURO = 321,
RETROK_UNDO = 322,
RETROK_LAST,
RETROK_DUMMY = INT_MAX /* Ensure sizeof(enum) == sizeof(int) */
};
enum retro_mod
{
RETROKMOD_NONE = 0x0000,
RETROKMOD_SHIFT = 0x01,
RETROKMOD_CTRL = 0x02,
RETROKMOD_ALT = 0x04,
RETROKMOD_META = 0x08,
RETROKMOD_NUMLOCK = 0x10,
RETROKMOD_CAPSLOCK = 0x20,
RETROKMOD_SCROLLOCK = 0x40,
RETROKMOD_DUMMY = INT_MAX /* Ensure sizeof(enum) == sizeof(int) */
};
/* If set, this call is not part of the public libretro API yet. It can
* change or be removed at any time. */
#define RETRO_ENVIRONMENT_EXPERIMENTAL 0x10000
/* Environment callback to be used internally in frontend. */
#define RETRO_ENVIRONMENT_PRIVATE 0x20000
/* Environment commands. */
#define RETRO_ENVIRONMENT_SET_ROTATION 1 /* const unsigned * --
* Sets screen rotation of graphics.
* Is only implemented if rotation can be accelerated by hardware.
* Valid values are 0, 1, 2, 3, which rotates screen by 0, 90, 180,
* 270 degrees counter-clockwise respectively.
*/
#define RETRO_ENVIRONMENT_GET_OVERSCAN 2 /* bool * --
* Boolean value whether or not the implementation should use overscan,
* or crop away overscan.
*/
#define RETRO_ENVIRONMENT_GET_CAN_DUPE 3 /* bool * --
* Boolean value whether or not frontend supports frame duping,
* passing NULL to video frame callback.
*/
/* Environ 4, 5 are no longer supported (GET_VARIABLE / SET_VARIABLES),
* and reserved to avoid possible ABI clash.
*/
#define RETRO_ENVIRONMENT_SET_MESSAGE 6 /* const struct retro_message * --
* Sets a message to be displayed in implementation-specific manner
* for a certain amount of 'frames'.
* Should not be used for trivial messages, which should simply be
* logged via RETRO_ENVIRONMENT_GET_LOG_INTERFACE (or as a
* fallback, stderr).
*/
#define RETRO_ENVIRONMENT_SHUTDOWN 7 /* N/A (NULL) --
* Requests the frontend to shutdown.
* Should only be used if game has a specific
* way to shutdown the game from a menu item or similar.
*/
#define RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL 8
/* const unsigned * --
* Gives a hint to the frontend how demanding this implementation
* is on a system. E.g. reporting a level of 2 means
* this implementation should run decently on all frontends
* of level 2 and up.
*
* It can be used by the frontend to potentially warn
* about too demanding implementations.
*
* The levels are "floating".
*
* This function can be called on a per-game basis,
* as certain games an implementation can play might be
* particularly demanding.
* If called, it should be called in retro_load_game().
*/
#define RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY 9
/* const char ** --
* Returns the "system" directory of the frontend.
* This directory can be used to store system specific
* content such as BIOSes, configuration data, etc.
* The returned value can be NULL.
* If so, no such directory is defined,
* and it's up to the implementation to find a suitable directory.
*
* NOTE: Some cores used this folder also for "save" data such as
* memory cards, etc, for lack of a better place to put it.
* This is now discouraged, and if possible, cores should try to
* use the new GET_SAVE_DIRECTORY.
*/
#define RETRO_ENVIRONMENT_SET_PIXEL_FORMAT 10
/* const enum retro_pixel_format * --
* Sets the internal pixel format used by the implementation.
* The default pixel format is RETRO_PIXEL_FORMAT_0RGB1555.
* This pixel format however, is deprecated (see enum retro_pixel_format).
* If the call returns false, the frontend does not support this pixel
* format.
*
* This function should be called inside retro_load_game() or
* retro_get_system_av_info().
*/
#define RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS 11
/* const struct retro_input_descriptor * --
* Sets an array of retro_input_descriptors.
* It is up to the frontend to present this in a usable way.
* The array is terminated by retro_input_descriptor::description
* being set to NULL.
* This function can be called at any time, but it is recommended
* to call it as early as possible.
*/
#define RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK 12
/* const struct retro_keyboard_callback * --
* Sets a callback function used to notify core about keyboard events.
*/
#define RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE 13
/* const struct retro_disk_control_callback * --
* Sets an interface which frontend can use to eject and insert
* disk images.
* This is used for games which consist of multiple images and
* must be manually swapped out by the user (e.g. PSX).
*/
#define RETRO_ENVIRONMENT_SET_HW_RENDER 14
/* struct retro_hw_render_callback * --
* Sets an interface to let a libretro core render with
* hardware acceleration.
* Should be called in retro_load_game().
* If successful, libretro cores will be able to render to a
* frontend-provided framebuffer.
* The size of this framebuffer will be at least as large as
* max_width/max_height provided in get_av_info().
* If HW rendering is used, pass only RETRO_HW_FRAME_BUFFER_VALID or
* NULL to retro_video_refresh_t.
*/
#define RETRO_ENVIRONMENT_GET_VARIABLE 15
/* struct retro_variable * --
* Interface to acquire user-defined information from environment
* that cannot feasibly be supported in a multi-system way.
* 'key' should be set to a key which has already been set by
* SET_VARIABLES.
* 'data' will be set to a value or NULL.
*/
#define RETRO_ENVIRONMENT_SET_VARIABLES 16
/* const struct retro_variable * --
* Allows an implementation to signal the environment
* which variables it might want to check for later using
* GET_VARIABLE.
* This allows the frontend to present these variables to
* a user dynamically.
* This should be called as early as possible (ideally in
* retro_set_environment).
*
* 'data' points to an array of retro_variable structs
* terminated by a { NULL, NULL } element.
* retro_variable::key should be namespaced to not collide
* with other implementations' keys. E.g. A core called
* 'foo' should use keys named as 'foo_option'.
* retro_variable::value should contain a human readable
* description of the key as well as a '|' delimited list
* of expected values.
*
* The number of possible options should be very limited,
* i.e. it should be feasible to cycle through options
* without a keyboard.
*
* First entry should be treated as a default.
*
* Example entry:
* { "foo_option", "Speed hack coprocessor X; false|true" }
*
* Text before first ';' is description. This ';' must be
* followed by a space, and followed by a list of possible
* values split up with '|'.
*
* Only strings are operated on. The possible values will
* generally be displayed and stored as-is by the frontend.
*/
#define RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE 17
/* bool * --
* Result is set to true if some variables are updated by
* frontend since last call to RETRO_ENVIRONMENT_GET_VARIABLE.
* Variables should be queried with GET_VARIABLE.
*/
#define RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME 18
/* const bool * --
* If true, the libretro implementation supports calls to
* retro_load_game() with NULL as argument.
* Used by cores which can run without particular game data.
* This should be called within retro_set_environment() only.
*/
#define RETRO_ENVIRONMENT_GET_LIBRETRO_PATH 19
/* const char ** --
* Retrieves the absolute path from where this libretro
* implementation was loaded.
* NULL is returned if the libretro was loaded statically
* (i.e. linked statically to frontend), or if the path cannot be
* determined.
* Mostly useful in cooperation with SET_SUPPORT_NO_GAME as assets can
* be loaded without ugly hacks.
*/
/* Environment 20 was an obsolete version of SET_AUDIO_CALLBACK.
* It was not used by any known core at the time,
* and was removed from the API. */
#define RETRO_ENVIRONMENT_SET_AUDIO_CALLBACK 22
/* const struct retro_audio_callback * --
* Sets an interface which is used to notify a libretro core about audio
* being available for writing.
* The callback can be called from any thread, so a core using this must
* have a thread safe audio implementation.
* It is intended for games where audio and video are completely
* asynchronous and audio can be generated on the fly.
* This interface is not recommended for use with emulators which have
* highly synchronous audio.
*
* The callback only notifies about writability; the libretro core still
* has to call the normal audio callbacks
* to write audio. The audio callbacks must be called from within the
* notification callback.
* The amount of audio data to write is up to the implementation.
* Generally, the audio callback will be called continously in a loop.
*
* Due to thread safety guarantees and lack of sync between audio and
* video, a frontend can selectively disallow this interface based on
* internal configuration. A core using this interface must also
* implement the "normal" audio interface.
*
* A libretro core using SET_AUDIO_CALLBACK should also make use of
* SET_FRAME_TIME_CALLBACK.
*/
#define RETRO_ENVIRONMENT_SET_FRAME_TIME_CALLBACK 21
/* const struct retro_frame_time_callback * --
* Lets the core know how much time has passed since last
* invocation of retro_run().
* The frontend can tamper with the timing to fake fast-forward,
* slow-motion, frame stepping, etc.
* In this case the delta time will use the reference value
* in frame_time_callback..
*/
#define RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE 23
/* struct retro_rumble_interface * --
* Gets an interface which is used by a libretro core to set
* state of rumble motors in controllers.
* A strong and weak motor is supported, and they can be
* controlled indepedently.
*/
#define RETRO_ENVIRONMENT_GET_INPUT_DEVICE_CAPABILITIES 24
/* uint64_t * --
* Gets a bitmask telling which device type are expected to be
* handled properly in a call to retro_input_state_t.
* Devices which are not handled or recognized always return
* 0 in retro_input_state_t.
* Example bitmask: caps = (1 << RETRO_DEVICE_JOYPAD) | (1 << RETRO_DEVICE_ANALOG).
* Should only be called in retro_run().
*/
#define RETRO_ENVIRONMENT_GET_SENSOR_INTERFACE (25 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* struct retro_sensor_interface * --
* Gets access to the sensor interface.
* The purpose of this interface is to allow
* setting state related to sensors such as polling rate,
* enabling/disable it entirely, etc.
* Reading sensor state is done via the normal
* input_state_callback API.
*/
#define RETRO_ENVIRONMENT_GET_CAMERA_INTERFACE (26 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* struct retro_camera_callback * --
* Gets an interface to a video camera driver.
* A libretro core can use this interface to get access to a
* video camera.
* New video frames are delivered in a callback in same
* thread as retro_run().
*
* GET_CAMERA_INTERFACE should be called in retro_load_game().
*
* Depending on the camera implementation used, camera frames
* will be delivered as a raw framebuffer,
* or as an OpenGL texture directly.
*
* The core has to tell the frontend here which types of
* buffers can be handled properly.
* An OpenGL texture can only be handled when using a
* libretro GL core (SET_HW_RENDER).
* It is recommended to use a libretro GL core when
* using camera interface.
*
* The camera is not started automatically. The retrieved start/stop
* functions must be used to explicitly
* start and stop the camera driver.
*/
#define RETRO_ENVIRONMENT_GET_LOG_INTERFACE 27
/* struct retro_log_callback * --
* Gets an interface for logging. This is useful for
* logging in a cross-platform way
* as certain platforms cannot use use stderr for logging.
* It also allows the frontend to
* show logging information in a more suitable way.
* If this interface is not used, libretro cores should
* log to stderr as desired.
*/
#define RETRO_ENVIRONMENT_GET_PERF_INTERFACE 28
/* struct retro_perf_callback * --
* Gets an interface for performance counters. This is useful
* for performance logging in a cross-platform way and for detecting
* architecture-specific features, such as SIMD support.
*/
#define RETRO_ENVIRONMENT_GET_LOCATION_INTERFACE 29
/* struct retro_location_callback * --
* Gets access to the location interface.
* The purpose of this interface is to be able to retrieve
* location-based information from the host device,
* such as current latitude / longitude.
*/
#define RETRO_ENVIRONMENT_GET_CONTENT_DIRECTORY 30 /* Old name, kept for compatibility. */
#define RETRO_ENVIRONMENT_GET_CORE_ASSETS_DIRECTORY 30
/* const char ** --
* Returns the "core assets" directory of the frontend.
* This directory can be used to store specific assets that the
* core relies upon, such as art assets,
* input data, etc etc.
* The returned value can be NULL.
* If so, no such directory is defined,
* and it's up to the implementation to find a suitable directory.
*/
#define RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY 31
/* const char ** --
* Returns the "save" directory of the frontend.
* This directory can be used to store SRAM, memory cards,
* high scores, etc, if the libretro core
* cannot use the regular memory interface (retro_get_memory_data()).
*
* NOTE: libretro cores used to check GET_SYSTEM_DIRECTORY for
* similar things before.
* They should still check GET_SYSTEM_DIRECTORY if they want to
* be backwards compatible.
* The path here can be NULL. It should only be non-NULL if the
* frontend user has set a specific save path.
*/
#define RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO 32
/* const struct retro_system_av_info * --
* Sets a new av_info structure. This can only be called from
* within retro_run().
* This should *only* be used if the core is completely altering the
* internal resolutions, aspect ratios, timings, sampling rate, etc.
* Calling this can require a full reinitialization of video/audio
* drivers in the frontend,
*
* so it is important to call it very sparingly, and usually only with
* the users explicit consent.
* An eventual driver reinitialize will happen so that video and
* audio callbacks
* happening after this call within the same retro_run() call will
* target the newly initialized driver.
*
* This callback makes it possible to support configurable resolutions
* in games, which can be useful to
* avoid setting the "worst case" in max_width/max_height.
*
* ***HIGHLY RECOMMENDED*** Do not call this callback every time
* resolution changes in an emulator core if it's
* expected to be a temporary change, for the reasons of possible
* driver reinitialization.
* This call is not a free pass for not trying to provide
* correct values in retro_get_system_av_info(). If you need to change
* things like aspect ratio or nominal width/height,
* use RETRO_ENVIRONMENT_SET_GEOMETRY, which is a softer variant
* of SET_SYSTEM_AV_INFO.
*
* If this returns false, the frontend does not acknowledge a
* changed av_info struct.
*/
#define RETRO_ENVIRONMENT_SET_PROC_ADDRESS_CALLBACK 33
/* const struct retro_get_proc_address_interface * --
* Allows a libretro core to announce support for the
* get_proc_address() interface.
* This interface allows for a standard way to extend libretro where
* use of environment calls are too indirect,
* e.g. for cases where the frontend wants to call directly into the core.
*
* If a core wants to expose this interface, SET_PROC_ADDRESS_CALLBACK
* **MUST** be called from within retro_set_environment().
*/
#define RETRO_ENVIRONMENT_SET_SUBSYSTEM_INFO 34
/* const struct retro_subsystem_info * --
* This environment call introduces the concept of libretro "subsystems".
* A subsystem is a variant of a libretro core which supports
* different kinds of games.
* The purpose of this is to support e.g. emulators which might
* have special needs, e.g. Super Nintendo's Super GameBoy, Sufami Turbo.
* It can also be used to pick among subsystems in an explicit way
* if the libretro implementation is a multi-system emulator itself.
*
* Loading a game via a subsystem is done with retro_load_game_special(),
* and this environment call allows a libretro core to expose which
* subsystems are supported for use with retro_load_game_special().
* A core passes an array of retro_game_special_info which is terminated
* with a zeroed out retro_game_special_info struct.
*
* If a core wants to use this functionality, SET_SUBSYSTEM_INFO
* **MUST** be called from within retro_set_environment().
*/
#define RETRO_ENVIRONMENT_SET_CONTROLLER_INFO 35
/* const struct retro_controller_info * --
* This environment call lets a libretro core tell the frontend
* which controller types are recognized in calls to
* retro_set_controller_port_device().
*
* Some emulators such as Super Nintendo
* support multiple lightgun types which must be specifically
* selected from.
* It is therefore sometimes necessary for a frontend to be able
* to tell the core about a special kind of input device which is
* not covered by the libretro input API.
*
* In order for a frontend to understand the workings of an input device,
* it must be a specialized type
* of the generic device types already defined in the libretro API.
*
* Which devices are supported can vary per input port.
* The core must pass an array of const struct retro_controller_info which
* is terminated with a blanked out struct. Each element of the struct
* corresponds to an ascending port index to
* retro_set_controller_port_device().
* Even if special device types are set in the libretro core,
* libretro should only poll input based on the base input device types.
*/
#define RETRO_ENVIRONMENT_SET_MEMORY_MAPS (36 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* const struct retro_memory_map * --
* This environment call lets a libretro core tell the frontend
* about the memory maps this core emulates.
* This can be used to implement, for example, cheats in a core-agnostic way.
*
* Should only be used by emulators; it doesn't make much sense for
* anything else.
* It is recommended to expose all relevant pointers through
* retro_get_memory_* as well.
*
* Can be called from retro_init and retro_load_game.
*/
#define RETRO_ENVIRONMENT_SET_GEOMETRY 37
/* const struct retro_game_geometry * --
* This environment call is similar to SET_SYSTEM_AV_INFO for changing
* video parameters, but provides a guarantee that drivers will not be
* reinitialized.
* This can only be called from within retro_run().
*
* The purpose of this call is to allow a core to alter nominal
* width/heights as well as aspect ratios on-the-fly, which can be
* useful for some emulators to change in run-time.
*
* max_width/max_height arguments are ignored and cannot be changed
* with this call as this could potentially require a reinitialization or a
* non-constant time operation.
* If max_width/max_height are to be changed, SET_SYSTEM_AV_INFO is required.
*
* A frontend must guarantee that this environment call completes in
* constant time.
*/
#define RETRO_ENVIRONMENT_GET_USERNAME 38
/* const char **
* Returns the specified username of the frontend, if specified by the user.
* This username can be used as a nickname for a core that has online facilities
* or any other mode where personalization of the user is desirable.
* The returned value can be NULL.
* If this environ callback is used by a core that requires a valid username,
* a default username should be specified by the core.
*/
#define RETRO_ENVIRONMENT_GET_LANGUAGE 39
/* unsigned * --
* Returns the specified language of the frontend, if specified by the user.
* It can be used by the core for localization purposes.
*/
#define RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER (40 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* struct retro_framebuffer * --
* Returns a preallocated framebuffer which the core can use for rendering
* the frame into when not using SET_HW_RENDER.
* The framebuffer returned from this call must not be used
* after the current call to retro_run() returns.
*
* The goal of this call is to allow zero-copy behavior where a core
* can render directly into video memory, avoiding extra bandwidth cost by copying
* memory from core to video memory.
*
* If this call succeeds and the core renders into it,
* the framebuffer pointer and pitch can be passed to retro_video_refresh_t.
* If the buffer from GET_CURRENT_SOFTWARE_FRAMEBUFFER is to be used,
* the core must pass the exact
* same pointer as returned by GET_CURRENT_SOFTWARE_FRAMEBUFFER;
* i.e. passing a pointer which is offset from the
* buffer is undefined. The width, height and pitch parameters
* must also match exactly to the values obtained from GET_CURRENT_SOFTWARE_FRAMEBUFFER.
*
* It is possible for a frontend to return a different pixel format
* than the one used in SET_PIXEL_FORMAT. This can happen if the frontend
* needs to perform conversion.
*
* It is still valid for a core to render to a different buffer
* even if GET_CURRENT_SOFTWARE_FRAMEBUFFER succeeds.
*
* A frontend must make sure that the pointer obtained from this function is
* writeable (and readable).
*/
enum retro_hw_render_interface_type
{
RETRO_HW_RENDER_INTERFACE_VULKAN = 0,
RETRO_HW_RENDER_INTERFACE_DUMMY = INT_MAX
};
/* Base struct. All retro_hw_render_interface_* types
* contain at least these fields. */
struct retro_hw_render_interface
{
enum retro_hw_render_interface_type interface_type;
unsigned interface_version;
};
#define RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE (41 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* const struct retro_hw_render_interface ** --
* Returns an API specific rendering interface for accessing API specific data.
* Not all HW rendering APIs support or need this.
* The contents of the returned pointer is specific to the rendering API
* being used. See the various headers like libretro_vulkan.h, etc.
*
* GET_HW_RENDER_INTERFACE cannot be called before context_reset has been called.
* Similarly, after context_destroyed callback returns,
* the contents of the HW_RENDER_INTERFACE are invalidated.
*/
#define RETRO_ENVIRONMENT_SET_SUPPORT_ACHIEVEMENTS (42 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* const bool * --
* If true, the libretro implementation supports achievements
* either via memory descriptors set with RETRO_ENVIRONMENT_SET_MEMORY_MAPS
* or via retro_get_memory_data/retro_get_memory_size.
*
* This must be called before the first call to retro_run.
*/
enum retro_hw_render_context_negotiation_interface_type
{
RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN = 0,
RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_DUMMY = INT_MAX
};
/* Base struct. All retro_hw_render_context_negotiation_interface_* types
* contain at least these fields. */
struct retro_hw_render_context_negotiation_interface
{
enum retro_hw_render_context_negotiation_interface_type interface_type;
unsigned interface_version;
};
#define RETRO_ENVIRONMENT_SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE (43 | RETRO_ENVIRONMENT_EXPERIMENTAL)
/* const struct retro_hw_render_context_negotiation_interface * --
* Sets an interface which lets the libretro core negotiate with frontend how a context is created.
* The semantics of this interface depends on which API is used in SET_HW_RENDER earlier.
* This interface will be used when the frontend is trying to create a HW rendering context,
* so it will be used after SET_HW_RENDER, but before the context_reset callback.
*/
#define RETRO_MEMDESC_CONST (1 << 0) /* The frontend will never change this memory area once retro_load_game has returned. */
#define RETRO_MEMDESC_BIGENDIAN (1 << 1) /* The memory area contains big endian data. Default is little endian. */
#define RETRO_MEMDESC_ALIGN_2 (1 << 16) /* All memory access in this area is aligned to their own size, or 2, whichever is smaller. */
#define RETRO_MEMDESC_ALIGN_4 (2 << 16)
#define RETRO_MEMDESC_ALIGN_8 (3 << 16)
#define RETRO_MEMDESC_MINSIZE_2 (1 << 24) /* All memory in this region is accessed at least 2 bytes at the time. */
#define RETRO_MEMDESC_MINSIZE_4 (2 << 24)
#define RETRO_MEMDESC_MINSIZE_8 (3 << 24)
struct retro_memory_descriptor
{
uint64_t flags;
/* Pointer to the start of the relevant ROM or RAM chip.
* It's strongly recommended to use 'offset' if possible, rather than
* doing math on the pointer.
*
* If the same byte is mapped my multiple descriptors, their descriptors
* must have the same pointer.
* If 'start' does not point to the first byte in the pointer, put the
* difference in 'offset' instead.
*
* May be NULL if there's nothing usable here (e.g. hardware registers and
* open bus). No flags should be set if the pointer is NULL.
* It's recommended to minimize the number of descriptors if possible,
* but not mandatory. */
void *ptr;
size_t offset;
/* This is the location in the emulated address space
* where the mapping starts. */
size_t start;
/* Which bits must be same as in 'start' for this mapping to apply.
* The first memory descriptor to claim a certain byte is the one
* that applies.
* A bit which is set in 'start' must also be set in this.
* Can be zero, in which case each byte is assumed mapped exactly once.
* In this case, 'len' must be a power of two. */
size_t select;
/* If this is nonzero, the set bits are assumed not connected to the
* memory chip's address pins. */
size_t disconnect;
/* This one tells the size of the current memory area.
* If, after start+disconnect are applied, the address is higher than
* this, the highest bit of the address is cleared.
*
* If the address is still too high, the next highest bit is cleared.
* Can be zero, in which case it's assumed to be infinite (as limited
* by 'select' and 'disconnect'). */
size_t len;
/* To go from emulated address to physical address, the following
* order applies:
* Subtract 'start', pick off 'disconnect', apply 'len', add 'offset'. */
/* The address space name must consist of only a-zA-Z0-9_-,
* should be as short as feasible (maximum length is 8 plus the NUL),
* and may not be any other address space plus one or more 0-9A-F
* at the end.
* However, multiple memory descriptors for the same address space is
* allowed, and the address space name can be empty. NULL is treated
* as empty.
*
* Address space names are case sensitive, but avoid lowercase if possible.
* The same pointer may exist in multiple address spaces.
*
* Examples:
* blank+blank - valid (multiple things may be mapped in the same namespace)
* 'Sp'+'Sp' - valid (multiple things may be mapped in the same namespace)
* 'A'+'B' - valid (neither is a prefix of each other)
* 'S'+blank - valid ('S' is not in 0-9A-F)
* 'a'+blank - valid ('a' is not in 0-9A-F)
* 'a'+'A' - valid (neither is a prefix of each other)
* 'AR'+blank - valid ('R' is not in 0-9A-F)
* 'ARB'+blank - valid (the B can't be part of the address either, because
* there is no namespace 'AR')
* blank+'B' - not valid, because it's ambigous which address space B1234
* would refer to.
* The length can't be used for that purpose; the frontend may want
* to append arbitrary data to an address, without a separator. */
const char *addrspace;
/* TODO: When finalizing this one, add a description field, which should be
* "WRAM" or something roughly equally long. */
/* TODO: When finalizing this one, replace 'select' with 'limit', which tells
* which bits can vary and still refer to the same address (limit = ~select).
* TODO: limit? range? vary? something else? */
/* TODO: When finalizing this one, if 'len' is above what 'select' (or
* 'limit') allows, it's bankswitched. Bankswitched data must have both 'len'
* and 'select' != 0, and the mappings don't tell how the system switches the
* banks. */
/* TODO: When finalizing this one, fix the 'len' bit removal order.
* For len=0x1800, pointer 0x1C00 should go to 0x1400, not 0x0C00.
* Algorithm: Take bits highest to lowest, but if it goes above len, clear
* the most recent addition and continue on the next bit.
* TODO: Can the above be optimized? Is "remove the lowest bit set in both
* pointer and 'len'" equivalent? */
/* TODO: Some emulators (MAME?) emulate big endian systems by only accessing
* the emulated memory in 32-bit chunks, native endian. But that's nothing
* compared to Darek Mihocka
* (section Emulation 103 - Nearly Free Byte Reversal) - he flips the ENTIRE
* RAM backwards! I'll want to represent both of those, via some flags.
*
* I suspect MAME either didn't think of that idea, or don't want the #ifdef.
* Not sure which, nor do I really care. */
/* TODO: Some of those flags are unused and/or don't really make sense. Clean
* them up. */
};
/* The frontend may use the largest value of 'start'+'select' in a
* certain namespace to infer the size of the address space.
*
* If the address space is larger than that, a mapping with .ptr=NULL
* should be at the end of the array, with .select set to all ones for
* as long as the address space is big.
*
* Sample descriptors (minus .ptr, and RETRO_MEMFLAG_ on the flags):
* SNES WRAM:
* .start=0x7E0000, .len=0x20000
* (Note that this must be mapped before the ROM in most cases; some of the
* ROM mappers
* try to claim $7E0000, or at least $7E8000.)
* SNES SPC700 RAM:
* .addrspace="S", .len=0x10000
* SNES WRAM mirrors:
* .flags=MIRROR, .start=0x000000, .select=0xC0E000, .len=0x2000
* .flags=MIRROR, .start=0x800000, .select=0xC0E000, .len=0x2000
* SNES WRAM mirrors, alternate equivalent descriptor:
* .flags=MIRROR, .select=0x40E000, .disconnect=~0x1FFF
* (Various similar constructions can be created by combining parts of
* the above two.)
* SNES LoROM (512KB, mirrored a couple of times):
* .flags=CONST, .start=0x008000, .select=0x408000, .disconnect=0x8000, .len=512*1024
* .flags=CONST, .start=0x400000, .select=0x400000, .disconnect=0x8000, .len=512*1024
* SNES HiROM (4MB):
* .flags=CONST, .start=0x400000, .select=0x400000, .len=4*1024*1024
* .flags=CONST, .offset=0x8000, .start=0x008000, .select=0x408000, .len=4*1024*1024
* SNES ExHiROM (8MB):
* .flags=CONST, .offset=0, .start=0xC00000, .select=0xC00000, .len=4*1024*1024
* .flags=CONST, .offset=4*1024*1024, .start=0x400000, .select=0xC00000, .len=4*1024*1024
* .flags=CONST, .offset=0x8000, .start=0x808000, .select=0xC08000, .len=4*1024*1024
* .flags=CONST, .offset=4*1024*1024+0x8000, .start=0x008000, .select=0xC08000, .len=4*1024*1024
* Clarify the size of the address space:
* .ptr=NULL, .select=0xFFFFFF
* .len can be implied by .select in many of them, but was included for clarity.
*/
struct retro_memory_map
{
const struct retro_memory_descriptor *descriptors;
unsigned num_descriptors;
};
struct retro_controller_description
{
/* Human-readable description of the controller. Even if using a generic
* input device type, this can be set to the particular device type the
* core uses. */
const char *desc;
/* Device type passed to retro_set_controller_port_device(). If the device
* type is a sub-class of a generic input device type, use the
* RETRO_DEVICE_SUBCLASS macro to create an ID.
*
* E.g. RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 1). */
unsigned id;
};
struct retro_controller_info
{
const struct retro_controller_description *types;
unsigned num_types;
};
struct retro_subsystem_memory_info
{
/* The extension associated with a memory type, e.g. "psram". */
const char *extension;
/* The memory type for retro_get_memory(). This should be at
* least 0x100 to avoid conflict with standardized
* libretro memory types. */
unsigned type;
};
struct retro_subsystem_rom_info
{
/* Describes what the content is (SGB BIOS, GB ROM, etc). */
const char *desc;
/* Same definition as retro_get_system_info(). */
const char *valid_extensions;
/* Same definition as retro_get_system_info(). */
bool need_fullpath;
/* Same definition as retro_get_system_info(). */
bool block_extract;
/* This is set if the content is required to load a game.
* If this is set to false, a zeroed-out retro_game_info can be passed. */
bool required;
/* Content can have multiple associated persistent
* memory types (retro_get_memory()). */
const struct retro_subsystem_memory_info *memory;
unsigned num_memory;
};
struct retro_subsystem_info
{
/* Human-readable string of the subsystem type, e.g. "Super GameBoy" */
const char *desc;
/* A computer friendly short string identifier for the subsystem type.
* This name must be [a-z].
* E.g. if desc is "Super GameBoy", this can be "sgb".
* This identifier can be used for command-line interfaces, etc.
*/
const char *ident;
/* Infos for each content file. The first entry is assumed to be the
* "most significant" content for frontend purposes.
* E.g. with Super GameBoy, the first content should be the GameBoy ROM,
* as it is the most "significant" content to a user.
* If a frontend creates new file paths based on the content used
* (e.g. savestates), it should use the path for the first ROM to do so. */
const struct retro_subsystem_rom_info *roms;
/* Number of content files associated with a subsystem. */
unsigned num_roms;
/* The type passed to retro_load_game_special(). */
unsigned id;
};
typedef void (RETRO_CALLCONV *retro_proc_address_t)(void);
/* libretro API extension functions:
* (None here so far).
*
* Get a symbol from a libretro core.
* Cores should only return symbols which are actual
* extensions to the libretro API.
*
* Frontends should not use this to obtain symbols to standard
* libretro entry points (static linking or dlsym).
*
* The symbol name must be equal to the function name,
* e.g. if void retro_foo(void); exists, the symbol must be called "retro_foo".
* The returned function pointer must be cast to the corresponding type.
*/
typedef retro_proc_address_t (RETRO_CALLCONV *retro_get_proc_address_t)(const char *sym);
struct retro_get_proc_address_interface
{
retro_get_proc_address_t get_proc_address;
};
enum retro_log_level
{
RETRO_LOG_DEBUG = 0,
RETRO_LOG_INFO,
RETRO_LOG_WARN,
RETRO_LOG_ERROR,
RETRO_LOG_DUMMY = INT_MAX
};
/* Logging function. Takes log level argument as well. */
typedef void (RETRO_CALLCONV *retro_log_printf_t)(enum retro_log_level level,
const char *fmt, ...);
struct retro_log_callback
{
retro_log_printf_t log;
};
/* Performance related functions */
/* ID values for SIMD CPU features */
#define RETRO_SIMD_SSE (1 << 0)
#define RETRO_SIMD_SSE2 (1 << 1)
#define RETRO_SIMD_VMX (1 << 2)
#define RETRO_SIMD_VMX128 (1 << 3)
#define RETRO_SIMD_AVX (1 << 4)
#define RETRO_SIMD_NEON (1 << 5)
#define RETRO_SIMD_SSE3 (1 << 6)
#define RETRO_SIMD_SSSE3 (1 << 7)
#define RETRO_SIMD_MMX (1 << 8)
#define RETRO_SIMD_MMXEXT (1 << 9)
#define RETRO_SIMD_SSE4 (1 << 10)
#define RETRO_SIMD_SSE42 (1 << 11)
#define RETRO_SIMD_AVX2 (1 << 12)
#define RETRO_SIMD_VFPU (1 << 13)
#define RETRO_SIMD_PS (1 << 14)
#define RETRO_SIMD_AES (1 << 15)
#define RETRO_SIMD_VFPV3 (1 << 16)
#define RETRO_SIMD_VFPV4 (1 << 17)
#define RETRO_SIMD_POPCNT (1 << 18)
#define RETRO_SIMD_MOVBE (1 << 19)
typedef uint64_t retro_perf_tick_t;
typedef int64_t retro_time_t;
struct retro_perf_counter
{
const char *ident;
retro_perf_tick_t start;
retro_perf_tick_t total;
retro_perf_tick_t call_cnt;
bool registered;
};
/* Returns current time in microseconds.
* Tries to use the most accurate timer available.
*/
typedef retro_time_t (RETRO_CALLCONV *retro_perf_get_time_usec_t)(void);
/* A simple counter. Usually nanoseconds, but can also be CPU cycles.
* Can be used directly if desired (when creating a more sophisticated
* performance counter system).
* */
typedef retro_perf_tick_t (RETRO_CALLCONV *retro_perf_get_counter_t)(void);
/* Returns a bit-mask of detected CPU features (RETRO_SIMD_*). */
typedef uint64_t (RETRO_CALLCONV *retro_get_cpu_features_t)(void);
/* Asks frontend to log and/or display the state of performance counters.
* Performance counters can always be poked into manually as well.
*/
typedef void (RETRO_CALLCONV *retro_perf_log_t)(void);
/* Register a performance counter.
* ident field must be set with a discrete value and other values in
* retro_perf_counter must be 0.
* Registering can be called multiple times. To avoid calling to
* frontend redundantly, you can check registered field first. */
typedef void (RETRO_CALLCONV *retro_perf_register_t)(struct retro_perf_counter *counter);
/* Starts a registered counter. */
typedef void (RETRO_CALLCONV *retro_perf_start_t)(struct retro_perf_counter *counter);
/* Stops a registered counter. */
typedef void (RETRO_CALLCONV *retro_perf_stop_t)(struct retro_perf_counter *counter);
/* For convenience it can be useful to wrap register, start and stop in macros.
* E.g.:
* #ifdef LOG_PERFORMANCE
* #define RETRO_PERFORMANCE_INIT(perf_cb, name) static struct retro_perf_counter name = {#name}; if (!name.registered) perf_cb.perf_register(&(name))
* #define RETRO_PERFORMANCE_START(perf_cb, name) perf_cb.perf_start(&(name))
* #define RETRO_PERFORMANCE_STOP(perf_cb, name) perf_cb.perf_stop(&(name))
* #else
* ... Blank macros ...
* #endif
*
* These can then be used mid-functions around code snippets.
*
* extern struct retro_perf_callback perf_cb; * Somewhere in the core.
*
* void do_some_heavy_work(void)
* {
* RETRO_PERFORMANCE_INIT(cb, work_1;
* RETRO_PERFORMANCE_START(cb, work_1);
* heavy_work_1();
* RETRO_PERFORMANCE_STOP(cb, work_1);
*
* RETRO_PERFORMANCE_INIT(cb, work_2);
* RETRO_PERFORMANCE_START(cb, work_2);
* heavy_work_2();
* RETRO_PERFORMANCE_STOP(cb, work_2);
* }
*
* void retro_deinit(void)
* {
* perf_cb.perf_log(); * Log all perf counters here for example.
* }
*/
struct retro_perf_callback
{
retro_perf_get_time_usec_t get_time_usec;
retro_get_cpu_features_t get_cpu_features;
retro_perf_get_counter_t get_perf_counter;
retro_perf_register_t perf_register;
retro_perf_start_t perf_start;
retro_perf_stop_t perf_stop;
retro_perf_log_t perf_log;
};
/* FIXME: Document the sensor API and work out behavior.
* It will be marked as experimental until then.
*/
enum retro_sensor_action
{
RETRO_SENSOR_ACCELEROMETER_ENABLE = 0,
RETRO_SENSOR_ACCELEROMETER_DISABLE,
RETRO_SENSOR_DUMMY = INT_MAX
};
/* Id values for SENSOR types. */
#define RETRO_SENSOR_ACCELEROMETER_X 0
#define RETRO_SENSOR_ACCELEROMETER_Y 1
#define RETRO_SENSOR_ACCELEROMETER_Z 2
typedef bool (RETRO_CALLCONV *retro_set_sensor_state_t)(unsigned port,
enum retro_sensor_action action, unsigned rate);
typedef float (RETRO_CALLCONV *retro_sensor_get_input_t)(unsigned port, unsigned id);
struct retro_sensor_interface
{
retro_set_sensor_state_t set_sensor_state;
retro_sensor_get_input_t get_sensor_input;
};
enum retro_camera_buffer
{
RETRO_CAMERA_BUFFER_OPENGL_TEXTURE = 0,
RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER,
RETRO_CAMERA_BUFFER_DUMMY = INT_MAX
};
/* Starts the camera driver. Can only be called in retro_run(). */
typedef bool (RETRO_CALLCONV *retro_camera_start_t)(void);
/* Stops the camera driver. Can only be called in retro_run(). */
typedef void (RETRO_CALLCONV *retro_camera_stop_t)(void);
/* Callback which signals when the camera driver is initialized
* and/or deinitialized.
* retro_camera_start_t can be called in initialized callback.
*/
typedef void (RETRO_CALLCONV *retro_camera_lifetime_status_t)(void);
/* A callback for raw framebuffer data. buffer points to an XRGB8888 buffer.
* Width, height and pitch are similar to retro_video_refresh_t.
* First pixel is top-left origin.
*/
typedef void (RETRO_CALLCONV *retro_camera_frame_raw_framebuffer_t)(const uint32_t *buffer,
unsigned width, unsigned height, size_t pitch);
/* A callback for when OpenGL textures are used.
*
* texture_id is a texture owned by camera driver.
* Its state or content should be considered immutable, except for things like
* texture filtering and clamping.
*
* texture_target is the texture target for the GL texture.
* These can include e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE, and possibly
* more depending on extensions.
*
* affine points to a packed 3x3 column-major matrix used to apply an affine
* transform to texture coordinates. (affine_matrix * vec3(coord_x, coord_y, 1.0))
* After transform, normalized texture coord (0, 0) should be bottom-left
* and (1, 1) should be top-right (or (width, height) for RECTANGLE).
*
* GL-specific typedefs are avoided here to avoid relying on gl.h in
* the API definition.
*/
typedef void (RETRO_CALLCONV *retro_camera_frame_opengl_texture_t)(unsigned texture_id,
unsigned texture_target, const float *affine);
struct retro_camera_callback
{
/* Set by libretro core.
* Example bitmask: caps = (1 << RETRO_CAMERA_BUFFER_OPENGL_TEXTURE) | (1 << RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER).
*/
uint64_t caps;
/* Desired resolution for camera. Is only used as a hint. */
unsigned width;
unsigned height;
/* Set by frontend. */
retro_camera_start_t start;
retro_camera_stop_t stop;
/* Set by libretro core if raw framebuffer callbacks will be used. */
retro_camera_frame_raw_framebuffer_t frame_raw_framebuffer;
/* Set by libretro core if OpenGL texture callbacks will be used. */
retro_camera_frame_opengl_texture_t frame_opengl_texture;
/* Set by libretro core. Called after camera driver is initialized and
* ready to be started.
* Can be NULL, in which this callback is not called.
*/
retro_camera_lifetime_status_t initialized;
/* Set by libretro core. Called right before camera driver is
* deinitialized.
* Can be NULL, in which this callback is not called.
*/
retro_camera_lifetime_status_t deinitialized;
};
/* Sets the interval of time and/or distance at which to update/poll
* location-based data.
*
* To ensure compatibility with all location-based implementations,
* values for both interval_ms and interval_distance should be provided.
*
* interval_ms is the interval expressed in milliseconds.
* interval_distance is the distance interval expressed in meters.
*/
typedef void (RETRO_CALLCONV *retro_location_set_interval_t)(unsigned interval_ms,
unsigned interval_distance);
/* Start location services. The device will start listening for changes to the
* current location at regular intervals (which are defined with
* retro_location_set_interval_t). */
typedef bool (RETRO_CALLCONV *retro_location_start_t)(void);
/* Stop location services. The device will stop listening for changes
* to the current location. */
typedef void (RETRO_CALLCONV *retro_location_stop_t)(void);
/* Get the position of the current location. Will set parameters to
* 0 if no new location update has happened since the last time. */
typedef bool (RETRO_CALLCONV *retro_location_get_position_t)(double *lat, double *lon,
double *horiz_accuracy, double *vert_accuracy);
/* Callback which signals when the location driver is initialized
* and/or deinitialized.
* retro_location_start_t can be called in initialized callback.
*/
typedef void (RETRO_CALLCONV *retro_location_lifetime_status_t)(void);
struct retro_location_callback
{
retro_location_start_t start;
retro_location_stop_t stop;
retro_location_get_position_t get_position;
retro_location_set_interval_t set_interval;
retro_location_lifetime_status_t initialized;
retro_location_lifetime_status_t deinitialized;
};
enum retro_rumble_effect
{
RETRO_RUMBLE_STRONG = 0,
RETRO_RUMBLE_WEAK = 1,
RETRO_RUMBLE_DUMMY = INT_MAX
};
/* Sets rumble state for joypad plugged in port 'port'.
* Rumble effects are controlled independently,
* and setting e.g. strong rumble does not override weak rumble.
* Strength has a range of [0, 0xffff].
*
* Returns true if rumble state request was honored.
* Calling this before first retro_run() is likely to return false. */
typedef bool (RETRO_CALLCONV *retro_set_rumble_state_t)(unsigned port,
enum retro_rumble_effect effect, uint16_t strength);
struct retro_rumble_interface
{
retro_set_rumble_state_t set_rumble_state;
};
/* Notifies libretro that audio data should be written. */
typedef void (RETRO_CALLCONV *retro_audio_callback_t)(void);
/* True: Audio driver in frontend is active, and callback is
* expected to be called regularily.
* False: Audio driver in frontend is paused or inactive.
* Audio callback will not be called until set_state has been
* called with true.
* Initial state is false (inactive).
*/
typedef void (RETRO_CALLCONV *retro_audio_set_state_callback_t)(bool enabled);
struct retro_audio_callback
{
retro_audio_callback_t callback;
retro_audio_set_state_callback_t set_state;
};
/* Notifies a libretro core of time spent since last invocation
* of retro_run() in microseconds.
*
* It will be called right before retro_run() every frame.
* The frontend can tamper with timing to support cases like
* fast-forward, slow-motion and framestepping.
*
* In those scenarios the reference frame time value will be used. */
typedef int64_t retro_usec_t;
typedef void (RETRO_CALLCONV *retro_frame_time_callback_t)(retro_usec_t usec);
struct retro_frame_time_callback
{
retro_frame_time_callback_t callback;
/* Represents the time of one frame. It is computed as
* 1000000 / fps, but the implementation will resolve the
* rounding to ensure that framestepping, etc is exact. */
retro_usec_t reference;
};
/* Pass this to retro_video_refresh_t if rendering to hardware.
* Passing NULL to retro_video_refresh_t is still a frame dupe as normal.
* */
#define RETRO_HW_FRAME_BUFFER_VALID ((void*)-1)
/* Invalidates the current HW context.
* Any GL state is lost, and must not be deinitialized explicitly.
* If explicit deinitialization is desired by the libretro core,
* it should implement context_destroy callback.
* If called, all GPU resources must be reinitialized.
* Usually called when frontend reinits video driver.
* Also called first time video driver is initialized,
* allowing libretro core to initialize resources.
*/
typedef void (RETRO_CALLCONV *retro_hw_context_reset_t)(void);
/* Gets current framebuffer which is to be rendered to.
* Could change every frame potentially.
*/
typedef uintptr_t (RETRO_CALLCONV *retro_hw_get_current_framebuffer_t)(void);
/* Get a symbol from HW context. */
typedef retro_proc_address_t (RETRO_CALLCONV *retro_hw_get_proc_address_t)(const char *sym);
enum retro_hw_context_type
{
RETRO_HW_CONTEXT_NONE = 0,
/* OpenGL 2.x. Driver can choose to use latest compatibility context. */
RETRO_HW_CONTEXT_OPENGL = 1,
/* OpenGL ES 2.0. */
RETRO_HW_CONTEXT_OPENGLES2 = 2,
/* Modern desktop core GL context. Use version_major/
* version_minor fields to set GL version. */
RETRO_HW_CONTEXT_OPENGL_CORE = 3,
/* OpenGL ES 3.0 */
RETRO_HW_CONTEXT_OPENGLES3 = 4,
/* OpenGL ES 3.1+. Set version_major/version_minor. For GLES2 and GLES3,
* use the corresponding enums directly. */
RETRO_HW_CONTEXT_OPENGLES_VERSION = 5,
/* Vulkan, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE. */
RETRO_HW_CONTEXT_VULKAN = 6,
RETRO_HW_CONTEXT_DUMMY = INT_MAX
};
struct retro_hw_render_callback
{
/* Which API to use. Set by libretro core. */
enum retro_hw_context_type context_type;
/* Called when a context has been created or when it has been reset.
* An OpenGL context is only valid after context_reset() has been called.
*
* When context_reset is called, OpenGL resources in the libretro
* implementation are guaranteed to be invalid.
*
* It is possible that context_reset is called multiple times during an
* application lifecycle.
* If context_reset is called without any notification (context_destroy),
* the OpenGL context was lost and resources should just be recreated
* without any attempt to "free" old resources.
*/
retro_hw_context_reset_t context_reset;
/* Set by frontend.
* TODO: This is rather obsolete. The frontend should not
* be providing preallocated framebuffers. */
retro_hw_get_current_framebuffer_t get_current_framebuffer;
/* Set by frontend. */
retro_hw_get_proc_address_t get_proc_address;
/* Set if render buffers should have depth component attached.
* TODO: Obsolete. */
bool depth;
/* Set if stencil buffers should be attached.
* TODO: Obsolete. */
bool stencil;
/* If depth and stencil are true, a packed 24/8 buffer will be added.
* Only attaching stencil is invalid and will be ignored. */
/* Use conventional bottom-left origin convention. If false,
* standard libretro top-left origin semantics are used.
* TODO: Move to GL specific interface. */
bool bottom_left_origin;
/* Major version number for core GL context or GLES 3.1+. */
unsigned version_major;
/* Minor version number for core GL context or GLES 3.1+. */
unsigned version_minor;
/* If this is true, the frontend will go very far to avoid
* resetting context in scenarios like toggling fullscreen, etc.
* TODO: Obsolete? Maybe frontend should just always assume this ...
*/
bool cache_context;
/* The reset callback might still be called in extreme situations
* such as if the context is lost beyond recovery.
*
* For optimal stability, set this to false, and allow context to be
* reset at any time.
*/
/* A callback to be called before the context is destroyed in a
* controlled way by the frontend. */
retro_hw_context_reset_t context_destroy;
/* OpenGL resources can be deinitialized cleanly at this step.
* context_destroy can be set to NULL, in which resources will
* just be destroyed without any notification.
*
* Even when context_destroy is non-NULL, it is possible that
* context_reset is called without any destroy notification.
* This happens if context is lost by external factors (such as
* notified by GL_ARB_robustness).
*
* In this case, the context is assumed to be already dead,
* and the libretro implementation must not try to free any OpenGL
* resources in the subsequent context_reset.
*/
/* Creates a debug context. */
bool debug_context;
};
/* Callback type passed in RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK.
* Called by the frontend in response to keyboard events.
* down is set if the key is being pressed, or false if it is being released.
* keycode is the RETROK value of the char.
* character is the text character of the pressed key. (UTF-32).
* key_modifiers is a set of RETROKMOD values or'ed together.
*
* The pressed/keycode state can be indepedent of the character.
* It is also possible that multiple characters are generated from a
* single keypress.
* Keycode events should be treated separately from character events.
* However, when possible, the frontend should try to synchronize these.
* If only a character is posted, keycode should be RETROK_UNKNOWN.
*
* Similarily if only a keycode event is generated with no corresponding
* character, character should be 0.
*/
typedef void (RETRO_CALLCONV *retro_keyboard_event_t)(bool down, unsigned keycode,
uint32_t character, uint16_t key_modifiers);
struct retro_keyboard_callback
{
retro_keyboard_event_t callback;
};
/* Callbacks for RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE.
* Should be set for implementations which can swap out multiple disk
* images in runtime.
*
* If the implementation can do this automatically, it should strive to do so.
* However, there are cases where the user must manually do so.
*
* Overview: To swap a disk image, eject the disk image with
* set_eject_state(true).
* Set the disk index with set_image_index(index). Insert the disk again
* with set_eject_state(false).
*/
/* If ejected is true, "ejects" the virtual disk tray.
* When ejected, the disk image index can be set.
*/
typedef bool (RETRO_CALLCONV *retro_set_eject_state_t)(bool ejected);
/* Gets current eject state. The initial state is 'not ejected'. */
typedef bool (RETRO_CALLCONV *retro_get_eject_state_t)(void);
/* Gets current disk index. First disk is index 0.
* If return value is >= get_num_images(), no disk is currently inserted.
*/
typedef unsigned (RETRO_CALLCONV *retro_get_image_index_t)(void);
/* Sets image index. Can only be called when disk is ejected.
* The implementation supports setting "no disk" by using an
* index >= get_num_images().
*/
typedef bool (RETRO_CALLCONV *retro_set_image_index_t)(unsigned index);
/* Gets total number of images which are available to use. */
typedef unsigned (RETRO_CALLCONV *retro_get_num_images_t)(void);
struct retro_game_info;
/* Replaces the disk image associated with index.
* Arguments to pass in info have same requirements as retro_load_game().
* Virtual disk tray must be ejected when calling this.
*
* Replacing a disk image with info = NULL will remove the disk image
* from the internal list.
* As a result, calls to get_image_index() can change.
*
* E.g. replace_image_index(1, NULL), and previous get_image_index()
* returned 4 before.
* Index 1 will be removed, and the new index is 3.
*/
typedef bool (RETRO_CALLCONV *retro_replace_image_index_t)(unsigned index,
const struct retro_game_info *info);
/* Adds a new valid index (get_num_images()) to the internal disk list.
* This will increment subsequent return values from get_num_images() by 1.
* This image index cannot be used until a disk image has been set
* with replace_image_index. */
typedef bool (RETRO_CALLCONV *retro_add_image_index_t)(void);
struct retro_disk_control_callback
{
retro_set_eject_state_t set_eject_state;
retro_get_eject_state_t get_eject_state;
retro_get_image_index_t get_image_index;
retro_set_image_index_t set_image_index;
retro_get_num_images_t get_num_images;
retro_replace_image_index_t replace_image_index;
retro_add_image_index_t add_image_index;
};
enum retro_pixel_format
{
/* 0RGB1555, native endian.
* 0 bit must be set to 0.
* This pixel format is default for compatibility concerns only.
* If a 15/16-bit pixel format is desired, consider using RGB565. */
RETRO_PIXEL_FORMAT_0RGB1555 = 0,
/* XRGB8888, native endian.
* X bits are ignored. */
RETRO_PIXEL_FORMAT_XRGB8888 = 1,
/* RGB565, native endian.
* This pixel format is the recommended format to use if a 15/16-bit
* format is desired as it is the pixel format that is typically
* available on a wide range of low-power devices.
*
* It is also natively supported in APIs like OpenGL ES. */
RETRO_PIXEL_FORMAT_RGB565 = 2,
/* Ensure sizeof() == sizeof(int). */
RETRO_PIXEL_FORMAT_UNKNOWN = INT_MAX
};
struct retro_message
{
const char *msg; /* Message to be displayed. */
unsigned frames; /* Duration in frames of message. */
};
/* Describes how the libretro implementation maps a libretro input bind
* to its internal input system through a human readable string.
* This string can be used to better let a user configure input. */
struct retro_input_descriptor
{
/* Associates given parameters with a description. */
unsigned port;
unsigned device;
unsigned index;
unsigned id;
/* Human readable description for parameters.
* The pointer must remain valid until
* retro_unload_game() is called. */
const char *description;
};
struct retro_system_info
{
/* All pointers are owned by libretro implementation, and pointers must
* remain valid until retro_deinit() is called. */
const char *library_name; /* Descriptive name of library. Should not
* contain any version numbers, etc. */
const char *library_version; /* Descriptive version of core. */
const char *valid_extensions; /* A string listing probably content
* extensions the core will be able to
* load, separated with pipe.
* I.e. "bin|rom|iso".
* Typically used for a GUI to filter
* out extensions. */
/* If true, retro_load_game() is guaranteed to provide a valid pathname
* in retro_game_info::path.
* ::data and ::size are both invalid.
*
* If false, ::data and ::size are guaranteed to be valid, but ::path
* might not be valid.
*
* This is typically set to true for libretro implementations that must
* load from file.
* Implementations should strive for setting this to false, as it allows
* the frontend to perform patching, etc. */
bool need_fullpath;
/* If true, the frontend is not allowed to extract any archives before
* loading the real content.
* Necessary for certain libretro implementations that load games
* from zipped archives. */
bool block_extract;
};
struct retro_game_geometry
{
unsigned base_width; /* Nominal video width of game. */
unsigned base_height; /* Nominal video height of game. */
unsigned max_width; /* Maximum possible width of game. */
unsigned max_height; /* Maximum possible height of game. */
float aspect_ratio; /* Nominal aspect ratio of game. If
* aspect_ratio is <= 0.0, an aspect ratio
* of base_width / base_height is assumed.
* A frontend could override this setting,
* if desired. */
};
struct retro_system_timing
{
double fps; /* FPS of video content. */
double sample_rate; /* Sampling rate of audio. */
};
struct retro_system_av_info
{
struct retro_game_geometry geometry;
struct retro_system_timing timing;
};
struct retro_variable
{
/* Variable to query in RETRO_ENVIRONMENT_GET_VARIABLE.
* If NULL, obtains the complete environment string if more
* complex parsing is necessary.
* The environment string is formatted as key-value pairs
* delimited by semicolons as so:
* "key1=value1;key2=value2;..."
*/
const char *key;
/* Value to be obtained. If key does not exist, it is set to NULL. */
const char *value;
};
struct retro_game_info
{
const char *path; /* Path to game, UTF-8 encoded.
* Usually used as a reference.
* May be NULL if rom was loaded from stdin
* or similar.
* retro_system_info::need_fullpath guaranteed
* that this path is valid. */
const void *data; /* Memory buffer of loaded game. Will be NULL
* if need_fullpath was set. */
size_t size; /* Size of memory buffer. */
const char *meta; /* String of implementation specific meta-data. */
};
#define RETRO_MEMORY_ACCESS_WRITE (1 << 0)
/* The core will write to the buffer provided by retro_framebuffer::data. */
#define RETRO_MEMORY_ACCESS_READ (1 << 1)
/* The core will read from retro_framebuffer::data. */
#define RETRO_MEMORY_TYPE_CACHED (1 << 0)
/* The memory in data is cached.
* If not cached, random writes and/or reading from the buffer is expected to be very slow. */
struct retro_framebuffer
{
void *data; /* The framebuffer which the core can render into.
Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER.
The initial contents of data are unspecified. */
unsigned width; /* The framebuffer width used by the core. Set by core. */
unsigned height; /* The framebuffer height used by the core. Set by core. */
size_t pitch; /* The number of bytes between the beginning of a scanline,
and beginning of the next scanline.
Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. */
enum retro_pixel_format format; /* The pixel format the core must use to render into data.
This format could differ from the format used in
SET_PIXEL_FORMAT.
Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. */
unsigned access_flags; /* How the core will access the memory in the framebuffer.
RETRO_MEMORY_ACCESS_* flags.
Set by core. */
unsigned memory_flags; /* Flags telling core how the memory has been mapped.
RETRO_MEMORY_TYPE_* flags.
Set by frontend in GET_CURRENT_SOFTWARE_FRAMEBUFFER. */
};
/* Callbacks */
/* Environment callback. Gives implementations a way of performing
* uncommon tasks. Extensible. */
typedef bool (RETRO_CALLCONV *retro_environment_t)(unsigned cmd, void *data);
/* Render a frame. Pixel format is 15-bit 0RGB1555 native endian
* unless changed (see RETRO_ENVIRONMENT_SET_PIXEL_FORMAT).
*
* Width and height specify dimensions of buffer.
* Pitch specifices length in bytes between two lines in buffer.
*
* For performance reasons, it is highly recommended to have a frame
* that is packed in memory, i.e. pitch == width * byte_per_pixel.
* Certain graphic APIs, such as OpenGL ES, do not like textures
* that are not packed in memory.
*/
typedef void (RETRO_CALLCONV *retro_video_refresh_t)(const void *data, unsigned width,
unsigned height, size_t pitch);
/* Renders a single audio frame. Should only be used if implementation
* generates a single sample at a time.
* Format is signed 16-bit native endian.
*/
typedef void (RETRO_CALLCONV *retro_audio_sample_t)(int16_t left, int16_t right);
/* Renders multiple audio frames in one go.
*
* One frame is defined as a sample of left and right channels, interleaved.
* I.e. int16_t buf[4] = { l, r, l, r }; would be 2 frames.
* Only one of the audio callbacks must ever be used.
*/
typedef size_t (RETRO_CALLCONV *retro_audio_sample_batch_t)(const int16_t *data,
size_t frames);
/* Polls input. */
typedef void (RETRO_CALLCONV *retro_input_poll_t)(void);
/* Queries for input for player 'port'. device will be masked with
* RETRO_DEVICE_MASK.
*
* Specialization of devices such as RETRO_DEVICE_JOYPAD_MULTITAP that
* have been set with retro_set_controller_port_device()
* will still use the higher level RETRO_DEVICE_JOYPAD to request input.
*/
typedef int16_t (RETRO_CALLCONV *retro_input_state_t)(unsigned port, unsigned device,
unsigned index, unsigned id);
/* Sets callbacks. retro_set_environment() is guaranteed to be called
* before retro_init().
*
* The rest of the set_* functions are guaranteed to have been called
* before the first call to retro_run() is made. */
RETRO_API void retro_set_environment(retro_environment_t);
RETRO_API void retro_set_video_refresh(retro_video_refresh_t);
RETRO_API void retro_set_audio_sample(retro_audio_sample_t);
RETRO_API void retro_set_audio_sample_batch(retro_audio_sample_batch_t);
RETRO_API void retro_set_input_poll(retro_input_poll_t);
RETRO_API void retro_set_input_state(retro_input_state_t);
/* Library global initialization/deinitialization. */
RETRO_API void retro_init(void);
RETRO_API void retro_deinit(void);
/* Must return RETRO_API_VERSION. Used to validate ABI compatibility
* when the API is revised. */
RETRO_API unsigned retro_api_version(void);
/* Gets statically known system info. Pointers provided in *info
* must be statically allocated.
* Can be called at any time, even before retro_init(). */
RETRO_API void retro_get_system_info(struct retro_system_info *info);
/* Gets information about system audio/video timings and geometry.
* Can be called only after retro_load_game() has successfully completed.
* NOTE: The implementation of this function might not initialize every
* variable if needed.
* E.g. geom.aspect_ratio might not be initialized if core doesn't
* desire a particular aspect ratio. */
RETRO_API void retro_get_system_av_info(struct retro_system_av_info *info);
/* Sets device to be used for player 'port'.
* By default, RETRO_DEVICE_JOYPAD is assumed to be plugged into all
* available ports.
* Setting a particular device type is not a guarantee that libretro cores
* will only poll input based on that particular device type. It is only a
* hint to the libretro core when a core cannot automatically detect the
* appropriate input device type on its own. It is also relevant when a
* core can change its behavior depending on device type. */
RETRO_API void retro_set_controller_port_device(unsigned port, unsigned device);
/* Resets the current game. */
RETRO_API void retro_reset(void);
/* Runs the game for one video frame.
* During retro_run(), input_poll callback must be called at least once.
*
* If a frame is not rendered for reasons where a game "dropped" a frame,
* this still counts as a frame, and retro_run() should explicitly dupe
* a frame if GET_CAN_DUPE returns true.
* In this case, the video callback can take a NULL argument for data.
*/
RETRO_API void retro_run(void);
/* Returns the amount of data the implementation requires to serialize
* internal state (save states).
* Between calls to retro_load_game() and retro_unload_game(), the
* returned size is never allowed to be larger than a previous returned
* value, to ensure that the frontend can allocate a save state buffer once.
*/
RETRO_API size_t retro_serialize_size(void);
/* Serializes internal state. If failed, or size is lower than
* retro_serialize_size(), it should return false, true otherwise. */
RETRO_API bool retro_serialize(void *data, size_t size);
RETRO_API bool retro_unserialize(const void *data, size_t size);
RETRO_API void retro_cheat_reset(void);
RETRO_API void retro_cheat_set(unsigned index, bool enabled, const char *code);
/* Loads a game. */
RETRO_API bool retro_load_game(const struct retro_game_info *game);
/* Loads a "special" kind of game. Should not be used,
* except in extreme cases. */
RETRO_API bool retro_load_game_special(
unsigned game_type,
const struct retro_game_info *info, size_t num_info
);
/* Unloads a currently loaded game. */
RETRO_API void retro_unload_game(void);
/* Gets region of game. */
RETRO_API unsigned retro_get_region(void);
/* Gets region of memory. */
RETRO_API void *retro_get_memory_data(unsigned id);
RETRO_API size_t retro_get_memory_size(unsigned id);
#ifdef __cplusplus
}
#endif
#endif
desmume/src/libretro-common/include/formats/ 000700 001750 001750 00000000000 12756420131 022323 5 ustar 00sergio sergio 000000 000000 desmume/src/addons/slot2_auto.cpp 000664 001750 001750 00000004614 12755534123 020213 0 ustar 00sergio sergio 000000 000000 /*
Copyright (C) 2013-2015 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see .
*/
#include
#include "../slot2.h"
class Slot2_Auto : public ISlot2Interface
{
private:
ISlot2Interface *mSelectedImplementation;
public:
Slot2_Auto()
: mSelectedImplementation(NULL)
{
}
virtual Slot2Info const* info()
{
static Slot2InfoSimple info("Auto","Slot2 (auto-selection) device emulation", 0xFE);
return &info;
}
virtual void connect()
{
slot2_selected_type = slot2_DetermineType();
mSelectedImplementation = slot2_List[slot2_selected_type];
mSelectedImplementation->connect();
printf("Slot2 auto-selected device type: %s (0x%02X)\n", mSelectedImplementation->info()->name(), mSelectedImplementation->info()->id());
}
virtual void disconnect()
{
if(mSelectedImplementation) mSelectedImplementation->disconnect();
mSelectedImplementation = NULL;
}
virtual void writeByte(u8 PROCNUM, u32 addr, u8 val) { mSelectedImplementation->writeByte(PROCNUM, addr, val); }
virtual void writeWord(u8 PROCNUM, u32 addr, u16 val) { mSelectedImplementation->writeWord(PROCNUM, addr, val); }
virtual void writeLong(u8 PROCNUM, u32 addr, u32 val) { mSelectedImplementation->writeLong(PROCNUM, addr, val); }
virtual u8 readByte(u8 PROCNUM, u32 addr) { return mSelectedImplementation->readByte(PROCNUM, addr); }
virtual u16 readWord(u8 PROCNUM, u32 addr) { return mSelectedImplementation->readWord(PROCNUM, addr); }
virtual u32 readLong(u8 PROCNUM, u32 addr) { return mSelectedImplementation->readLong(PROCNUM, addr); }
virtual void savestate(EMUFILE* os)
{
mSelectedImplementation->savestate(os);
}
virtual void loadstate(EMUFILE* is)
{
mSelectedImplementation->loadstate(is);
}
};
ISlot2Interface* construct_Slot2_Auto() { return new Slot2_Auto(); }
desmume/src/utils/AsmJit/core/apibegin.h 000664 001750 001750 00000002160 12755534123 021344 0 ustar 00sergio sergio 000000 000000 // [AsmJit]
// Complete JIT Assembler for C++ Language.
//
// [License]
// Zlib - See COPYING file in this package.
// [MSVC]
#if defined(_MSC_VER)
// Disable some warnings we know about
#pragma warning(push)
#pragma warning(disable: 4127) // conditional expression is constant
#pragma warning(disable: 4251) // struct needs to have dll-interface to be used
// by clients of struct ...
#pragma warning(disable: 4275) // non dll-interface struct ... used as base for
// dll-interface struct
#pragma warning(disable: 4355) // this used in base member initializer list
#pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
// Rename symbols.
#ifndef vsnprintf
#define vsnprintf _vsnprintf
#endif
#ifndef snprintf
#define snprintf _snprintf
#endif
#endif // _MSC_VER
// [GNUC]
#if defined(__GNUC__)
// GCC warnings fix: I can't understand why GCC has no interface to push/pop
// specific warnings.
// # if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 402001
// # pragma GCC diagnostic ignored "-w"
// # endif
#endif // __GNUC__
desmume/src/libretro-common/include/compat/intrinsics.h 000664 001750 001750 00000005036 12755534123 024517 0 ustar 00sergio sergio 000000 000000 /* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (intrinsics.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_COMPAT_INTRINSICS_H
#define __LIBRETRO_SDK_COMPAT_INTRINSICS_H
#include
#include
#include
#include
#include
#ifdef _MSC_VER
#if (_MSC_VER > 1310)
#include