Hello_User/XenonRecomp
1
0
Fork 0
mirror of https://github.com/hedge-dev/XenonRecomp.git synced 2025-07-24 22:13:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial Commit

Browse Source
This commit is contained in:
Sajid
2024-09-07 18:00:09 +06:00
commit 0f9a53f75a
3352 changed files with 1563708 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
thirdparty/capstone/arch/HPPA/HPPAConstants.h vendored Normal file
View File

@@ -0,0 +1,74 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
/* This file defines constants and macros used for parsing a HPPA instruction */
#ifndef CS_HPPA_CONSTANTS_H
#define CS_HPPA_CONSTANTS_H
#define HPPA_OP_TYPE(byte) (byte) >> 2
#define MODE_IS_HPPA_20(mode) (((mode)&CS_MODE_HPPA_20) != 0)
#define MODE_IS_HPPA_20W(mode) (((mode) & (1 << 3)) != 0)
///> HPPA opcode types
#define HPPA_OP_TYPE_SYSOP 0x00
#define HPPA_OP_TYPE_MEMMGMT 0x01
#define HPPA_OP_TYPE_ALU 0x02
#define HPPA_OP_TYPE_IDXMEM 0x03
#define HPPA_OP_TYPE_SPOP 0x04
#define HPPA_OP_TYPE_DIAG 0x05
#define HPPA_OP_TYPE_FMPYADD 0x06
#define HPPA_OP_TYPE_LDIL 0x08
#define HPPA_OP_TYPE_COPRW 0x09
#define HPPA_OP_TYPE_ADDIL 0x0a
#define HPPA_OP_TYPE_COPRDW 0x0b
#define HPPA_OP_TYPE_COPR 0x0c
#define HPPA_OP_TYPE_LDO 0x0d
#define HPPA_OP_TYPE_FLOAT 0x0e
#define HPPA_OP_TYPE_PRDSPEC 0x0f
#define HPPA_OP_TYPE_LDB 0x10
#define HPPA_OP_TYPE_LDH 0x11
#define HPPA_OP_TYPE_LDW 0x12
#define HPPA_OP_TYPE_LDWM 0x13
#define HPPA_OP_TYPE_LOADDW 0x14
#define HPPA_OP_TYPE_FLDW 0x16
#define HPPA_OP_TYPE_LOADW 0x17
#define HPPA_OP_TYPE_STB 0x18
#define HPPA_OP_TYPE_STH 0x19
#define HPPA_OP_TYPE_STW 0x1a
#define HPPA_OP_TYPE_STWM 0x1b
#define HPPA_OP_TYPE_STOREDW 0x1c
#define HPPA_OP_TYPE_FSTW 0x1e
#define HPPA_OP_TYPE_STOREW 0x1f
#define HPPA_OP_TYPE_CMPBT 0x20
#define HPPA_OP_TYPE_CMPIBT 0x21
#define HPPA_OP_TYPE_CMPBF 0x22
#define HPPA_OP_TYPE_CMPIBF 0x23
#define HPPA_OP_TYPE_CMPICLR 0x24
#define HPPA_OP_TYPE_SUBI 0x25
#define HPPA_OP_TYPE_FMPYSUB 0x26
#define HPPA_OP_TYPE_CMPBDWT 0x27
#define HPPA_OP_TYPE_ADDBT 0x28
#define HPPA_OP_TYPE_ADDIBT 0x29
#define HPPA_OP_TYPE_ADDBF 0x2a
#define HPPA_OP_TYPE_ADDIBF 0x2b
#define HPPA_OP_TYPE_ADDIT 0x2c
#define HPPA_OP_TYPE_ADDI 0x2d
#define HPPA_OP_TYPE_FPFUSED 0x2e
#define HPPA_OP_TYPE_CMPBDWF 0x2f
#define HPPA_OP_TYPE_BBS 0x30
#define HPPA_OP_TYPE_BB 0x31
#define HPPA_OP_TYPE_MOVB 0x32
#define HPPA_OP_TYPE_MOVIB 0x33
#define HPPA_OP_TYPE_SHEXDEP0 0x34
#define HPPA_OP_TYPE_SHEXDEP1 0x35
#define HPPA_OP_TYPE_SHEXDEP2 0x36
#define HPPA_OP_TYPE_BE 0x38
#define HPPA_OP_TYPE_BLE 0x39
#define HPPA_OP_TYPE_BRANCH 0x3a
#define HPPA_OP_TYPE_CMPIBDW 0x3b
#define HPPA_OP_TYPE_SHEXDEP3 0x3c
#define HPPA_OP_TYPE_SHEXDEP4 0x3d
#define HPPA_OP_TYPE_MULTMED 0x3e
#endif // CS_HPPA_CONSTANTS_H

3837
thirdparty/capstone/arch/HPPA/HPPADisassembler.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

13
thirdparty/capstone/arch/HPPA/HPPADisassembler.h vendored Normal file
View File

@@ -0,0 +1,13 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifndef CS_HPPA_DISASSEMBLER_H
#define CS_HPPA_DISASSEMBLER_H
#include "../../MCInst.h"
bool HPPA_getInstruction(csh ud, const uint8_t *code, size_t code_len,
MCInst *instr, uint16_t *size, uint64_t address,
void *info);
#endif

839
thirdparty/capstone/arch/HPPA/HPPAInstPrinter.c vendored Normal file
View File

@@ -0,0 +1,839 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifdef CAPSTONE_HAS_HPPA
#include <capstone/platform.h>
#include "../../Mapping.h"
#include "../../utils.h"
#include "HPPAInstPrinter.h"
#include "HPPAMapping.h"
static const struct pa_insn pa_insns[] = {
{ HPPA_INS_LDI, HPPA_GRP_LONG_IMM },
{ HPPA_INS_CMPIB, HPPA_GRP_BRANCH },
{ HPPA_INS_COMIB, HPPA_GRP_BRANCH },
{ HPPA_INS_CMPB, HPPA_GRP_BRANCH },
{ HPPA_INS_COMB, HPPA_GRP_BRANCH },
{ HPPA_INS_ADDB, HPPA_GRP_BRANCH },
{ HPPA_INS_ADDIB, HPPA_GRP_BRANCH },
{ HPPA_INS_NOP, HPPA_GRP_COMPUTATION },
{ HPPA_INS_COPY, HPPA_GRP_COMPUTATION },
{ HPPA_INS_MTSAR, HPPA_GRP_SYSCTRL },
{ HPPA_INS_LDD, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDW, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDH, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDB, HPPA_GRP_MEM_REF },
{ HPPA_INS_STD, HPPA_GRP_MEM_REF },
{ HPPA_INS_STW, HPPA_GRP_MEM_REF },
{ HPPA_INS_STH, HPPA_GRP_MEM_REF },
{ HPPA_INS_STB, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDWM, HPPA_GRP_MEM_REF },
{ HPPA_INS_STWM, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDWX, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDHX, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDBX, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDWA, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDCW, HPPA_GRP_MEM_REF },
{ HPPA_INS_STWA, HPPA_GRP_MEM_REF },
{ HPPA_INS_STBY, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDDA, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDCD, HPPA_GRP_MEM_REF },
{ HPPA_INS_STDA, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDWAX, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDCWX, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDWS, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDHS, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDBS, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDWAS, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDCWS, HPPA_GRP_MEM_REF },
{ HPPA_INS_STWS, HPPA_GRP_MEM_REF },
{ HPPA_INS_STHS, HPPA_GRP_MEM_REF },
{ HPPA_INS_STBS, HPPA_GRP_MEM_REF },
{ HPPA_INS_STWAS, HPPA_GRP_MEM_REF },
{ HPPA_INS_STDBY, HPPA_GRP_MEM_REF },
{ HPPA_INS_STBYS, HPPA_GRP_MEM_REF },
{ HPPA_INS_LDO, HPPA_GRP_LONG_IMM },
{ HPPA_INS_LDIL, HPPA_GRP_LONG_IMM },
{ HPPA_INS_ADDIL, HPPA_GRP_LONG_IMM },
{ HPPA_INS_B, HPPA_GRP_BRANCH },
{ HPPA_INS_BL, HPPA_GRP_BRANCH },
{ HPPA_INS_GATE, HPPA_GRP_BRANCH },
{ HPPA_INS_BLR, HPPA_GRP_BRANCH },
{ HPPA_INS_BV, HPPA_GRP_BRANCH },
{ HPPA_INS_BVE, HPPA_GRP_BRANCH },
{ HPPA_INS_BE, HPPA_GRP_BRANCH },
{ HPPA_INS_BLE, HPPA_GRP_BRANCH },
{ HPPA_INS_MOVB, HPPA_GRP_BRANCH },
{ HPPA_INS_MOVIB, HPPA_GRP_BRANCH },
{ HPPA_INS_COMBT, HPPA_GRP_BRANCH },
{ HPPA_INS_COMBF, HPPA_GRP_BRANCH },
{ HPPA_INS_COMIBT, HPPA_GRP_BRANCH },
{ HPPA_INS_COMIBF, HPPA_GRP_BRANCH },
{ HPPA_INS_ADDBT, HPPA_GRP_BRANCH },
{ HPPA_INS_ADDBF, HPPA_GRP_BRANCH },
{ HPPA_INS_ADDIBT, HPPA_GRP_BRANCH },
{ HPPA_INS_ADDIBF, HPPA_GRP_BRANCH },
{ HPPA_INS_BB, HPPA_GRP_BRANCH },
{ HPPA_INS_BVB, HPPA_GRP_BRANCH },
{ HPPA_INS_CLRBTS, HPPA_GRP_BRANCH },
{ HPPA_INS_POPBTS, HPPA_GRP_BRANCH },
{ HPPA_INS_PUSHNOM, HPPA_GRP_BRANCH },
{ HPPA_INS_PUSHBTS, HPPA_GRP_BRANCH },
{ HPPA_INS_CMPCLR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_COMCLR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_OR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_XOR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_AND, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ANDCM, HPPA_GRP_COMPUTATION },
{ HPPA_INS_UXOR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_UADDCM, HPPA_GRP_COMPUTATION },
{ HPPA_INS_UADDCMT, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DCOR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_IDCOR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDIO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDIT, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDITO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDL, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDC, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ADDCO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUB, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBB, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBBO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBT, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBTO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DS, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SUBIO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_CMPICLR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_COMICLR, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SHLADD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH1ADD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH1ADDL, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH1ADDO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH2ADD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH2ADDL, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH2ADDO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH3ADD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH3ADDL, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SH3ADDO, HPPA_GRP_COMPUTATION },
{ HPPA_INS_HADD, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_HAVG, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_HSHL, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_HSHLADD, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_HSHR, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_HSHRADD, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_HSUB, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_MIXH, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_MIXW, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_PERMH, HPPA_GRP_MULTIMEDIA },
{ HPPA_INS_SHRPD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SHRPW, HPPA_GRP_COMPUTATION },
{ HPPA_INS_VSHD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_SHD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_EXTRD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_EXTRW, HPPA_GRP_COMPUTATION },
{ HPPA_INS_VEXTRU, HPPA_GRP_COMPUTATION },
{ HPPA_INS_VEXTRS, HPPA_GRP_COMPUTATION },
{ HPPA_INS_EXTRU, HPPA_GRP_COMPUTATION },
{ HPPA_INS_EXTRS, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DEPD, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DEPDI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DEPW, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DEPWI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ZVDEP, HPPA_GRP_COMPUTATION },
{ HPPA_INS_VDEP, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ZDEP, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DEP, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ZVDEPI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_VDEPI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_ZDEPI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_DEPI, HPPA_GRP_COMPUTATION },
{ HPPA_INS_BREAK, HPPA_GRP_SYSCTRL },
{ HPPA_INS_RFI, HPPA_GRP_SYSCTRL },
{ HPPA_INS_RFIR, HPPA_GRP_SYSCTRL },
{ HPPA_INS_SSM, HPPA_GRP_SYSCTRL },
{ HPPA_INS_RSM, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MTSM, HPPA_GRP_SYSCTRL },
{ HPPA_INS_LDSID, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MTSP, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MTCTL, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MTSARCM, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MFIA, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MFSP, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MFCTL, HPPA_GRP_SYSCTRL },
{ HPPA_INS_SYNC, HPPA_GRP_SYSCTRL },
{ HPPA_INS_SYNCDMA, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PROBE, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PROBEI, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PROBER, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PROBERI, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PROBEW, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PROBEWI, HPPA_GRP_SYSCTRL },
{ HPPA_INS_LPA, HPPA_GRP_SYSCTRL },
{ HPPA_INS_LCI, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PDTLB, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PITLB, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PDTLBE, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PITLBE, HPPA_GRP_SYSCTRL },
{ HPPA_INS_IDTLBA, HPPA_GRP_SYSCTRL },
{ HPPA_INS_IITLBA, HPPA_GRP_SYSCTRL },
{ HPPA_INS_IDTLBP, HPPA_GRP_SYSCTRL },
{ HPPA_INS_IITLBP, HPPA_GRP_SYSCTRL },
{ HPPA_INS_PDC, HPPA_GRP_SYSCTRL },
{ HPPA_INS_FDC, HPPA_GRP_SYSCTRL },
{ HPPA_INS_FIC, HPPA_GRP_SYSCTRL },
{ HPPA_INS_FDCE, HPPA_GRP_SYSCTRL },
{ HPPA_INS_FICE, HPPA_GRP_SYSCTRL },
{ HPPA_INS_DIAG, HPPA_GRP_SYSCTRL },
{ HPPA_INS_IDTLBT, HPPA_GRP_SYSCTRL },
{ HPPA_INS_IITLBT, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MTCPU, HPPA_GRP_SYSCTRL },
{ HPPA_INS_MFCPU, HPPA_GRP_SYSCTRL },
{ HPPA_INS_TOCEN, HPPA_GRP_SYSCTRL },
{ HPPA_INS_TOCDIS, HPPA_GRP_SYSCTRL },
{ HPPA_INS_SHDWGR, HPPA_GRP_SYSCTRL },
{ HPPA_INS_GRSHDW, HPPA_GRP_SYSCTRL },
{ HPPA_INS_GFW, HPPA_GRP_SYSCTRL },
{ HPPA_INS_GFR, HPPA_GRP_SYSCTRL },
{ HPPA_INS_FLDW, HPPA_GRP_FLOAT },
{ HPPA_INS_FLDD, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTW, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTD, HPPA_GRP_FLOAT },
{ HPPA_INS_FLDWX, HPPA_GRP_FLOAT },
{ HPPA_INS_FLDDX, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTWX, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTDX, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTQX, HPPA_GRP_FLOAT },
{ HPPA_INS_FLDWS, HPPA_GRP_FLOAT },
{ HPPA_INS_FLDDS, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTWS, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTDS, HPPA_GRP_FLOAT },
{ HPPA_INS_FSTQS, HPPA_GRP_FLOAT },
{ HPPA_INS_FADD, HPPA_GRP_FLOAT },
{ HPPA_INS_FSUB, HPPA_GRP_FLOAT },
{ HPPA_INS_FMPY, HPPA_GRP_FLOAT },
{ HPPA_INS_FDIV, HPPA_GRP_FLOAT },
{ HPPA_INS_FSQRT, HPPA_GRP_FLOAT },
{ HPPA_INS_FABS, HPPA_GRP_FLOAT },
{ HPPA_INS_FREM, HPPA_GRP_FLOAT },
{ HPPA_INS_FRND, HPPA_GRP_FLOAT },
{ HPPA_INS_FCPY, HPPA_GRP_FLOAT },
{ HPPA_INS_FCNVFF, HPPA_GRP_FLOAT },
{ HPPA_INS_FCNVXF, HPPA_GRP_FLOAT },
{ HPPA_INS_FCNVFX, HPPA_GRP_FLOAT },
{ HPPA_INS_FCNVFXT, HPPA_GRP_FLOAT },
{ HPPA_INS_FMPYFADD, HPPA_GRP_FLOAT },
{ HPPA_INS_FMPYNFADD, HPPA_GRP_FLOAT },
{ HPPA_INS_FNEG, HPPA_GRP_FLOAT },
{ HPPA_INS_FNEGABS, HPPA_GRP_FLOAT },
{ HPPA_INS_FCNV, HPPA_GRP_FLOAT },
{ HPPA_INS_FCMP, HPPA_GRP_FLOAT },
{ HPPA_INS_XMPYU, HPPA_GRP_FLOAT },
{ HPPA_INS_FMPYADD, HPPA_GRP_FLOAT },
{ HPPA_INS_FMPYSUB, HPPA_GRP_FLOAT },
{ HPPA_INS_FTEST, HPPA_GRP_FLOAT },
{ HPPA_INS_FID, HPPA_GRP_FLOAT },
{ HPPA_INS_PMDIS, HPPA_GRP_PERFMON },
{ HPPA_INS_PMENB, HPPA_GRP_PERFMON },
{ HPPA_INS_SPOP0, HPPA_GRP_ASSIST },
{ HPPA_INS_SPOP1, HPPA_GRP_ASSIST },
{ HPPA_INS_SPOP2, HPPA_GRP_ASSIST },
{ HPPA_INS_SPOP3, HPPA_GRP_ASSIST },
{ HPPA_INS_COPR, HPPA_GRP_ASSIST },
{ HPPA_INS_CLDW, HPPA_GRP_ASSIST },
{ HPPA_INS_CLDD, HPPA_GRP_ASSIST },
{ HPPA_INS_CSTW, HPPA_GRP_ASSIST },
{ HPPA_INS_CSTD, HPPA_GRP_ASSIST },
{ HPPA_INS_CLDWX, HPPA_GRP_ASSIST },
{ HPPA_INS_CLDDX, HPPA_GRP_ASSIST },
{ HPPA_INS_CSTWX, HPPA_GRP_ASSIST },
{ HPPA_INS_CSTDX, HPPA_GRP_ASSIST },
{ HPPA_INS_CLDWS, HPPA_GRP_ASSIST },
{ HPPA_INS_CLDDS, HPPA_GRP_ASSIST },
{ HPPA_INS_CSTWS, HPPA_GRP_ASSIST },
{ HPPA_INS_CSTDS, HPPA_GRP_ASSIST },
{ HPPA_INS_CALL, HPPA_GRP_INVALID },
{ HPPA_INS_RET, HPPA_GRP_INVALID },
};
static void set_op_imm(cs_hppa *hppa, uint64_t val)
{
cs_hppa_op *op = &hppa->operands[hppa->op_count++];
op->type = HPPA_OP_IMM;
op->imm = val;
}
static void set_op_reg(cs_hppa *hppa, uint64_t val, cs_ac_type access)
{
cs_hppa_op *op = &hppa->operands[hppa->op_count++];
op->type = HPPA_OP_REG;
op->reg = val;
op->access = access;
}
static void set_op_idx_reg(cs_hppa *hppa, uint64_t reg)
{
cs_hppa_op *op = &hppa->operands[hppa->op_count++];
op->type = HPPA_OP_IDX_REG;
op->reg = reg;
op->access = CS_AC_READ;
}
static void set_op_disp(cs_hppa *hppa, uint64_t val)
{
cs_hppa_op *op = &hppa->operands[hppa->op_count++];
op->type = HPPA_OP_DISP;
op->imm = val;
}
static void set_op_target(cs_hppa *hppa, uint64_t val)
{
cs_hppa_op *op = &hppa->operands[hppa->op_count++];
op->type = HPPA_OP_TARGET;
op->imm = val;
}
static void set_op_mem(cs_hppa *hppa, uint32_t base, uint32_t space,
cs_ac_type base_access)
{
cs_hppa_op *op = &hppa->operands[hppa->op_count++];
op->type = HPPA_OP_MEM;
op->mem.base = base;
op->mem.space = space;
op->mem.base_access = base_access;
}
/* HPPA instruction formats (access)
i - imm arguments
R - read access register
W - write access register
w - read + write access register
r - index register (read only)
T - offset (pc relative)
o - displacement (imm)
x - [r] or [o] defined by the operand kind
b - base register (may be writable in some cases)
*/
static const struct pa_insn_fmt pa_formats[] = {
{ HPPA_INS_LDI, "iW", false },
{ HPPA_INS_CMPIB, "iRT", false },
{ HPPA_INS_COMIB, "iRT", false },
{ HPPA_INS_CMPB, "RRT", false },
{ HPPA_INS_COMB, "RRT", false },
{ HPPA_INS_ADDB, "RwT", false },
{ HPPA_INS_ADDIB, "iwT", false },
{ HPPA_INS_NOP, "", false },
{ HPPA_INS_COPY, "RW", false },
{ HPPA_INS_MTSAR, "R", false },
{ HPPA_INS_LDD, "x(Rb)W", false },
{ HPPA_INS_LDW, "x(Rb)W", false },
{ HPPA_INS_LDH, "x(Rb)W", false },
{ HPPA_INS_LDB, "x(Rb)W", false },
{ HPPA_INS_STD, "Ro(Rb)", false },
{ HPPA_INS_STW, "Ro(Rb)", false },
{ HPPA_INS_STH, "Ro(Rb)", false },
{ HPPA_INS_STB, "Ro(Rb)", false },
{ HPPA_INS_LDWM, "o(Rw)W", false },
{ HPPA_INS_STWM, "Ro(Rw)", false },
{ HPPA_INS_LDWX, "r(Rb)W", false },
{ HPPA_INS_LDHX, "r(Rb)W", false },
{ HPPA_INS_LDBX, "r(Rb)W", false },
{ HPPA_INS_LDWA, "x(R)W", false },
{ HPPA_INS_LDCW, "x(Rb)W", false },
{ HPPA_INS_STWA, "Ro(b)", false },
{ HPPA_INS_STBY, "Ro(Rb)", false },
{ HPPA_INS_LDDA, "x(b)W", false },
{ HPPA_INS_LDCD, "x(Rb)W", false },
{ HPPA_INS_STDA, "Ro(b)", false },
{ HPPA_INS_LDWAX, "r(b)W", false },
{ HPPA_INS_LDCWX, "r(Rb)W", false },
{ HPPA_INS_LDWS, "o(Rb)W", false },
{ HPPA_INS_LDHS, "o(Rb)W", false },
{ HPPA_INS_LDBS, "o(Rb)W", false },
{ HPPA_INS_LDWAS, "o(b)W", false },
{ HPPA_INS_LDCWS, "o(Rb)W", false },
{ HPPA_INS_STWS, "Ro(Rb)", false },
{ HPPA_INS_STHS, "Ro(Rb)", false },
{ HPPA_INS_STBS, "Ro(Rb)", false },
{ HPPA_INS_STWAS, "Ro(b)", false },
{ HPPA_INS_STDBY, "Ro(Rb)", false },
{ HPPA_INS_STBYS, "Ro(Rb)", false },
{ HPPA_INS_LDO, "o(R)W", false },
{ HPPA_INS_LDIL, "iW", false },
{ HPPA_INS_ADDIL, "iR", false },
{ HPPA_INS_B, "TW", false },
{ HPPA_INS_BL, "TW", false },
{ HPPA_INS_GATE, "TW", false },
{ HPPA_INS_BLR, "RW", false },
{ HPPA_INS_BV, "x(R)", false },
{ HPPA_INS_BVE, "(b)", false },
{ HPPA_INS_BVE, "(b)W", true },
{ HPPA_INS_BE, "o(RR)", false },
{ HPPA_INS_BE, "o(RR)WW", true },
{ HPPA_INS_BLE, "o(RR)", false },
{ HPPA_INS_MOVB, "RWT", false },
{ HPPA_INS_MOVIB, "iWT", false },
{ HPPA_INS_COMBT, "RRT", false },
{ HPPA_INS_COMBF, "RRT", false },
{ HPPA_INS_COMIBT, "iRT", false },
{ HPPA_INS_COMIBF, "iRT", false },
{ HPPA_INS_ADDBT, "RwT", false },
{ HPPA_INS_ADDBF, "RwT", false },
{ HPPA_INS_ADDIBT, "iwT", false },
{ HPPA_INS_ADDIBF, "iwT", false },
{ HPPA_INS_BB, "RiT", false },
{ HPPA_INS_BVB, "RT", false },
{ HPPA_INS_CLRBTS, "", false },
{ HPPA_INS_POPBTS, "i", false },
{ HPPA_INS_PUSHNOM, "", false },
{ HPPA_INS_PUSHBTS, "R", false },
{ HPPA_INS_CMPCLR, "RRW", false },
{ HPPA_INS_COMCLR, "RRW", false },
{ HPPA_INS_OR, "RRW", false },
{ HPPA_INS_XOR, "RRW", false },
{ HPPA_INS_AND, "RRW", false },
{ HPPA_INS_ANDCM, "RRW", false },
{ HPPA_INS_UXOR, "RRW", false },
{ HPPA_INS_UADDCM, "RRW", false },
{ HPPA_INS_UADDCMT, "RRW", false },
{ HPPA_INS_DCOR, "RW", false },
{ HPPA_INS_IDCOR, "RW", false },
{ HPPA_INS_ADDI, "iRW", false },
{ HPPA_INS_ADDIO, "iRW", false },
{ HPPA_INS_ADDIT, "iRW", false },
{ HPPA_INS_ADDITO, "iRW", false },
{ HPPA_INS_ADD, "RRW", false },
{ HPPA_INS_ADDL, "RRW", false },
{ HPPA_INS_ADDO, "RRW", false },
{ HPPA_INS_ADDC, "RRW", false },
{ HPPA_INS_ADDCO, "RRW", false },
{ HPPA_INS_SUB, "RRW", false },
{ HPPA_INS_SUBO, "RRW", false },
{ HPPA_INS_SUBB, "RRW", false },
{ HPPA_INS_SUBBO, "RRW", false },
{ HPPA_INS_SUBT, "RRW", false },
{ HPPA_INS_SUBTO, "RRW", false },
{ HPPA_INS_DS, "RRW", false },
{ HPPA_INS_SUBI, "iRW", false },
{ HPPA_INS_SUBIO, "iRW", false },
{ HPPA_INS_CMPICLR, "iRW", false },
{ HPPA_INS_COMICLR, "iRW", false },
{ HPPA_INS_SHLADD, "RiRW", false },
{ HPPA_INS_SH1ADD, "RRW", false },
{ HPPA_INS_SH1ADDL, "RRW", false },
{ HPPA_INS_SH1ADDO, "RRW", false },
{ HPPA_INS_SH2ADD, "RRW", false },
{ HPPA_INS_SH2ADDL, "RRW", false },
{ HPPA_INS_SH2ADDO, "RRW", false },
{ HPPA_INS_SH3ADD, "RRW", false },
{ HPPA_INS_SH3ADDL, "RRW", false },
{ HPPA_INS_SH3ADDO, "RRW", false },
{ HPPA_INS_HADD, "RRW", false },
{ HPPA_INS_HAVG, "RRW", false },
{ HPPA_INS_HSHL, "RiW", false },
{ HPPA_INS_HSHLADD, "RiRW", false },
{ HPPA_INS_HSHR, "RiW", false },
{ HPPA_INS_HSHRADD, "RiRW", false },
{ HPPA_INS_HSUB, "RRW", false },
{ HPPA_INS_MIXH, "RRW", false },
{ HPPA_INS_MIXW, "RRW", false },
{ HPPA_INS_PERMH, "RW", false },
{ HPPA_INS_SHRPD, "RRiW", false },
{ HPPA_INS_SHRPD, "RRRW", true },
{ HPPA_INS_SHRPW, "RRiW", false },
{ HPPA_INS_SHRPW, "RRRW", true },
{ HPPA_INS_VSHD, "RRW", false },
{ HPPA_INS_SHD, "RRiW", false },
{ HPPA_INS_EXTRD, "RiiW", false },
{ HPPA_INS_EXTRD, "RRiW", true },
{ HPPA_INS_EXTRW, "RiiW", false },
{ HPPA_INS_EXTRW, "RRiW", true },
{ HPPA_INS_VEXTRU, "RiW", false },
{ HPPA_INS_VEXTRS, "RiW", false },
{ HPPA_INS_EXTRU, "RiiW", false },
{ HPPA_INS_EXTRS, "RiiW", false },
{ HPPA_INS_DEPD, "RiiW", false },
{ HPPA_INS_DEPDI, "iiiW", false },
{ HPPA_INS_DEPW, "RiiW", false },
{ HPPA_INS_DEPW, "RRiW", true },
{ HPPA_INS_DEPWI, "iiiW", false },
{ HPPA_INS_DEPWI, "iRiW", true },
{ HPPA_INS_ZVDEP, "RiW", false },
{ HPPA_INS_VDEP, "RiW", false },
{ HPPA_INS_ZDEP, "RiiW", false },
{ HPPA_INS_DEP, "RiiW", false },
{ HPPA_INS_ZVDEPI, "iiW", false },
{ HPPA_INS_VDEPI, "iiW", false },
{ HPPA_INS_ZDEPI, "iiiW", false },
{ HPPA_INS_DEPI, "iiiW", false },
{ HPPA_INS_BREAK, "ii", false },
{ HPPA_INS_RFI, "", false },
{ HPPA_INS_RFIR, "", false },
{ HPPA_INS_SSM, "iW", false },
{ HPPA_INS_RSM, "iW", false },
{ HPPA_INS_MTSM, "R", false },
{ HPPA_INS_LDSID, "(RR)W", false },
{ HPPA_INS_MTSP, "RW", false },
{ HPPA_INS_MTCTL, "RW", false },
{ HPPA_INS_MTSARCM, "R", false },
{ HPPA_INS_MFIA, "W", false },
{ HPPA_INS_MFSP, "RW", false },
{ HPPA_INS_MFCTL, "RW", false },
{ HPPA_INS_SYNC, "", false },
{ HPPA_INS_SYNCDMA, "", false },
{ HPPA_INS_PROBE, "(RR)RW", false },
{ HPPA_INS_PROBEI, "(RR)iW", false },
{ HPPA_INS_PROBER, "(RR)RW", false },
{ HPPA_INS_PROBERI, "(RR)iW", false },
{ HPPA_INS_PROBEW, "(RR)RW", false },
{ HPPA_INS_PROBEWI, "(RR)iW", false },
{ HPPA_INS_LPA, "r(Rb)W", false },
{ HPPA_INS_LCI, "r(RR)W", false },
{ HPPA_INS_PDTLB, "r(Rb)", false },
{ HPPA_INS_PITLB, "r(Rb)", false },
{ HPPA_INS_PDTLBE, "r(Rb)", false },
{ HPPA_INS_PITLBE, "r(Rb)", false },
{ HPPA_INS_IDTLBA, "R(RR)", false },
{ HPPA_INS_IITLBA, "R(RR)", false },
{ HPPA_INS_IDTLBP, "R(RR)", false },
{ HPPA_INS_IITLBP, "R(RR)", false },
{ HPPA_INS_PDC, "r(Rb)", false },
{ HPPA_INS_FDC, "x(Rb)", false },
{ HPPA_INS_FIC, "r(Rb)", false },
{ HPPA_INS_FDCE, "r(Rb)", false },
{ HPPA_INS_FICE, "r(Rb)", false },
{ HPPA_INS_DIAG, "i", false },
{ HPPA_INS_IDTLBT, "RR", false },
{ HPPA_INS_IITLBT, "RR", false },
{ HPPA_INS_FLDW, "x(Rb)W", false },
{ HPPA_INS_FLDD, "x(Rb)W", false },
{ HPPA_INS_FSTW, "Rx(Rb)", false },
{ HPPA_INS_FSTD, "Rx(Rb)", false },
{ HPPA_INS_FLDWX, "r(Rb)W", false },
{ HPPA_INS_FLDDX, "r(Rb)W", false },
{ HPPA_INS_FSTWX, "Rr(Rb)", false },
{ HPPA_INS_FSTDX, "Rr(Rb)", false },
{ HPPA_INS_FSTQX, "", false },
{ HPPA_INS_FLDWS, "o(Rb)W", false },
{ HPPA_INS_FLDDS, "o(Rb)W", false },
{ HPPA_INS_FSTWS, "Ro(Rb)", false },
{ HPPA_INS_FSTDS, "Ro(Rb)", false },
{ HPPA_INS_FSTQS, "Ro(Rb)", false },
{ HPPA_INS_FADD, "RRW", false },
{ HPPA_INS_FSUB, "RRW", false },
{ HPPA_INS_FMPY, "RRW", false },
{ HPPA_INS_FDIV, "RRW", false },
{ HPPA_INS_FSQRT, "RW", false },
{ HPPA_INS_FABS, "RW", false },
{ HPPA_INS_FREM, "", false },
{ HPPA_INS_FRND, "RW", false },
{ HPPA_INS_FCPY, "RW", false },
{ HPPA_INS_FCNVFF, "RW", false },
{ HPPA_INS_FCNVXF, "RW", false },
{ HPPA_INS_FCNVFX, "RW", false },
{ HPPA_INS_FCNVFXT, "RW", false },
{ HPPA_INS_FMPYFADD, "RRRW", false },
{ HPPA_INS_FMPYNFADD, "RRRW", false },
{ HPPA_INS_FNEG, "RW", false },
{ HPPA_INS_FNEGABS, "RW", false },
{ HPPA_INS_FCNV, "RW", false },
{ HPPA_INS_FCMP, "RR", false },
{ HPPA_INS_FCMP, "RRi", true },
{ HPPA_INS_XMPYU, "RRW", false },
{ HPPA_INS_FMPYADD, "RRWRw", false },
{ HPPA_INS_FMPYSUB, "RRWRw", false },
{ HPPA_INS_FTEST, "", false },
{ HPPA_INS_FTEST, "i", true },
{ HPPA_INS_FID, "", false },
{ HPPA_INS_PMDIS, "", false },
{ HPPA_INS_PMENB, "", false },
{ HPPA_INS_SPOP0, "", false },
{ HPPA_INS_SPOP1, "W", false },
{ HPPA_INS_SPOP2, "R", false },
{ HPPA_INS_SPOP3, "RR", false },
{ HPPA_INS_COPR, "", false },
{ HPPA_INS_CLDW, "x(Rb)W", false },
{ HPPA_INS_CLDD, "o(Rb)W", false },
{ HPPA_INS_CSTW, "Rx(Rb)", false },
{ HPPA_INS_CSTD, "Rx(Rb)", false },
{ HPPA_INS_CLDWX, "r(Rb)W", false },
{ HPPA_INS_CLDDX, "r(Rb)W", false },
{ HPPA_INS_CSTWX, "Rr(Rb)", false },
{ HPPA_INS_CSTDX, "Rr(Rb)", false },
{ HPPA_INS_CLDWS, "o(Rb)W", false },
{ HPPA_INS_CLDDS, "o(Rb)W", false },
{ HPPA_INS_CSTWS, "Ro(Rb)", false },
{ HPPA_INS_CSTDS, "Ro(Rb)", false },
{ HPPA_INS_CALL, "", false },
{ HPPA_INS_RET, "", false },
};
static void print_operand(MCInst *MI, SStream *O, const cs_hppa_op *op)
{
switch (op->type) {
case HPPA_OP_INVALID:
SStream_concat(O, "invalid");
break;
case HPPA_OP_REG:
SStream_concat(O, HPPA_reg_name((csh)MI->csh, op->reg));
break;
case HPPA_OP_IMM:
printInt32(O, op->imm);
break;
case HPPA_OP_DISP:
printInt32(O, op->imm);
break;
case HPPA_OP_IDX_REG:
SStream_concat(O, HPPA_reg_name((csh)MI->csh, op->reg));
break;
case HPPA_OP_MEM:
SStream_concat(O, "(");
if (op->mem.space != HPPA_REG_INVALID &&
op->mem.space != HPPA_REG_SR0) {
SStream_concat(O, HPPA_reg_name((csh)MI->csh,
op->mem.space));
SStream_concat(O, ",");
}
SStream_concat(O, HPPA_reg_name((csh)MI->csh, op->mem.base));
SStream_concat(O, ")");
break;
case HPPA_OP_TARGET:
printUInt64(O, MI->address + op->imm);
break;
}
}
#define NUMFMTS ARR_SIZE(pa_formats)
static void fill_operands(MCInst *MI, cs_hppa *hppa)
{
hppa->op_count = 0;
unsigned mc_op_count = MCInst_getNumOperands(MI);
if (mc_op_count == 0)
return;
hppa_ext *hppa_ext = &MI->hppa_ext;
uint32_t opcode = MCInst_getOpcode(MI);
for (int i = 0; i < NUMFMTS; ++i) {
const struct pa_insn_fmt *pa_fmt = &pa_formats[i];
if (opcode != pa_fmt->insn_id ||
hppa_ext->is_alternative != pa_fmt->is_alternative) {
continue;
}
const char *fmt = pa_fmt->format;
uint8_t idx = 0;
uint32_t space_regs[2] = { HPPA_REG_INVALID, HPPA_REG_INVALID };
uint8_t space_reg_idx = 0;
cs_ac_type base_access = CS_AC_INVALID;
MCOperand *op = NULL;
while (*fmt) {
op = MCInst_getOperand(MI, idx++);
switch (*fmt++) {
case 'i':
if (MCOperand_isReg(op)) {
set_op_reg(hppa, MCOperand_getReg(op),
CS_AC_READ);
} else {
set_op_imm(hppa, MCOperand_getImm(op));
}
break;
case 'o':
set_op_disp(hppa, MCOperand_getImm(op));
break;
case 'R':
set_op_reg(hppa, MCOperand_getReg(op),
CS_AC_READ);
break;
case 'W':
set_op_reg(hppa, MCOperand_getReg(op),
CS_AC_WRITE);
break;
case 'w':
set_op_reg(hppa, MCOperand_getReg(op),
CS_AC_READ_WRITE);
break;
case 'r':
set_op_idx_reg(hppa, MCOperand_getReg(op));
break;
case 'T':
set_op_target(hppa, MCOperand_getImm(op) + 8);
break;
case 'x':
if (MCOperand_isReg(op)) {
set_op_idx_reg(hppa,
MCOperand_getReg(op));
} else {
set_op_disp(hppa, MCOperand_getImm(op));
}
break;
case '(':
while (*fmt != ')') {
if (space_reg_idx > 0) {
op = MCInst_getOperand(MI,
idx++);
}
assert(space_reg_idx <
ARR_SIZE(space_regs));
space_regs[space_reg_idx] =
MCOperand_getReg(op);
if (*fmt == 'R') {
base_access = CS_AC_READ;
} else if (*fmt == 'W') {
base_access = CS_AC_WRITE;
} else if (*fmt == 'b') {
base_access = CS_AC_READ;
if (hppa_ext->b_writeble)
base_access |=
CS_AC_WRITE;
}
fmt++;
space_reg_idx++;
}
if (space_regs[1] == HPPA_REG_INVALID)
set_op_mem(hppa, space_regs[0],
space_regs[1], base_access);
else
set_op_mem(hppa, space_regs[1],
space_regs[0], base_access);
fmt++;
break;
default:
printf("Unknown: %c\n", *(fmt - 1));
break;
}
}
break;
}
}
static void print_modifiers(MCInst *MI, SStream *O)
{
hppa_ext *hppa_ext = &MI->hppa_ext;
for (uint8_t i = 0; i < hppa_ext->mod_num; ++i) {
SStream_concat(O, ",");
if (hppa_ext->modifiers[i].type == HPPA_MOD_STR)
SStream_concat(O, hppa_ext->modifiers[i].str_mod);
else
SStream_concat(O, "%d", hppa_ext->modifiers[i].int_mod);
}
}
static void add_groups(MCInst *MI)
{
unsigned int opcode = MCInst_getOpcode(MI);
for (unsigned i = 0; i < ARR_SIZE(pa_insns); ++i) {
if (pa_insns[i].insn != opcode) {
continue;
}
add_group(MI, pa_insns[i].grp);
}
}
#ifndef CAPSTONE_DIET
static void update_regs_access(MCInst *MI, unsigned int opcode)
{
if (opcode == HPPA_INS_INVALID)
return;
hppa_ext *hppa_ext = &MI->hppa_ext;
switch (opcode) {
default:
break;
case HPPA_INS_BLE:
map_add_implicit_write(MI, HPPA_REG_GR31);
map_add_implicit_write(MI, HPPA_REG_SR0);
break;
case HPPA_INS_BVB:
map_add_implicit_read(MI, HPPA_REG_CR11);
break;
case HPPA_INS_RFI:
if (hppa_ext->mod_num == 0) {
break;
}
// fallthrough
case HPPA_INS_RFIR:
map_add_implicit_write(MI, HPPA_REG_GR1);
map_add_implicit_write(MI, HPPA_REG_GR8);
map_add_implicit_write(MI, HPPA_REG_GR9);
map_add_implicit_write(MI, HPPA_REG_GR16);
map_add_implicit_write(MI, HPPA_REG_GR17);
map_add_implicit_write(MI, HPPA_REG_GR24);
map_add_implicit_write(MI, HPPA_REG_GR25);
break;
case HPPA_INS_VDEP:
case HPPA_INS_VDEPI:
case HPPA_INS_VEXTRS:
case HPPA_INS_VEXTRU:
case HPPA_INS_VSHD:
case HPPA_INS_ZVDEPI:
map_add_implicit_read(MI, HPPA_REG_CR11);
break;
case HPPA_INS_ADDIL:
map_add_implicit_write(MI, HPPA_REG_GR1);
break;
}
}
#endif
void HPPA_printInst(MCInst *MI, SStream *O, void *Info)
{
cs_hppa hppa;
/* set pubOpcode as instruction id */
MCInst_setOpcodePub(MI, MCInst_getOpcode(MI));
SStream_concat(O, HPPA_insn_name((csh)MI->csh, MCInst_getOpcode(MI)));
print_modifiers(MI, O);
SStream_concat(O, " ");
fill_operands(MI, &hppa);
for (int i = 0; i < hppa.op_count; i++) {
cs_hppa_op *op = &hppa.operands[i];
print_operand(MI, O, op);
if (op->type != HPPA_OP_IDX_REG && op->type != HPPA_OP_DISP &&
i != hppa.op_count - 1) {
SStream_concat(O, ",");
}
}
if (detail_is_set(MI)) {
cs_hppa *hppa_detail = HPPA_get_detail(MI);
*hppa_detail = hppa;
add_groups(MI);
#ifndef CAPSTONE_DIET
update_regs_access(MI, MCInst_getOpcode(MI));
#endif
}
}
#endif

25
thirdparty/capstone/arch/HPPA/HPPAInstPrinter.h vendored Normal file
View File

@@ -0,0 +1,25 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifndef CS_HPPAINSTPRINTER_H
#define CS_HPPAINSTPRINTER_H
#include <capstone/capstone.h>
#include "../../MCInst.h"
#include "../../SStream.h"
struct pa_insn {
hppa_insn insn;
hppa_insn_group grp;
};
struct pa_insn_fmt {
hppa_insn insn_id;
const char *format;
bool is_alternative; ///< true if some completer affects the instruction format
};
void HPPA_printInst(MCInst *MI, SStream *O, void *Info);
#endif

442
thirdparty/capstone/arch/HPPA/HPPAMapping.c vendored Normal file
View File

@@ -0,0 +1,442 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifdef CAPSTONE_HAS_HPPA
#include <string.h>
#include <stdlib.h>
#include "HPPAMapping.h"
#include "HPPAConstants.h"
#include "../../Mapping.h"
#include "../../utils.h"
#ifndef CAPSTONE_DIET
static const name_map group_name_maps[] = {
{ HPPA_GRP_INVALID, NULL },
{ HPPA_GRP_COMPUTATION, "computation" },
{ HPPA_GRP_MULTIMEDIA, "multimedia" },
{ HPPA_GRP_MEM_REF, "memory_reference" },
{ HPPA_GRP_LONG_IMM, "long_imm" },
{ HPPA_GRP_BRANCH, "branch" },
{ HPPA_GRP_SYSCTRL, "system_control" },
{ HPPA_GRP_ASSIST, "assist" },
{ HPPA_GRP_FLOAT, "float" },
};
#endif
const char *HPPA_group_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);
#else
return NULL;
#endif
}
#ifndef CAPSTONE_DIET
static const name_map insn_name_maps[HPPA_INS_ENDING] = {
{ HPPA_INS_INVALID, NULL },
{ HPPA_INS_ADD, "add" },
{ HPPA_INS_ADDI, "addi" },
{ HPPA_INS_ADDIO, "addio" },
{ HPPA_INS_ADDIT, "addit" },
{ HPPA_INS_ADDITO, "addito" },
{ HPPA_INS_ADDB, "addb" },
{ HPPA_INS_ADDBT, "addbt" },
{ HPPA_INS_ADDBF, "addbf" },
{ HPPA_INS_ADDIB, "addib" },
{ HPPA_INS_ADDIBT, "addibt" },
{ HPPA_INS_ADDIBF, "addibf" },
{ HPPA_INS_ADDIL, "addil" },
{ HPPA_INS_ADDC, "addc" },
{ HPPA_INS_ADDCO, "addco" },
{ HPPA_INS_ADDL, "addl" },
{ HPPA_INS_ADDO, "addo" },
{ HPPA_INS_AND, "and" },
{ HPPA_INS_ANDCM, "andcm" },
{ HPPA_INS_B, "b" },
{ HPPA_INS_BB, "bb" },
{ HPPA_INS_BE, "be" },
{ HPPA_INS_BL, "bl" },
{ HPPA_INS_BLE, "ble" },
{ HPPA_INS_BLR, "blr" },
{ HPPA_INS_BREAK, "break" },
{ HPPA_INS_BV, "bv" },
{ HPPA_INS_BVB, "bvb" },
{ HPPA_INS_BVE, "bve" },
{ HPPA_INS_CALL, "call" },
{ HPPA_INS_CLDD, "cldd" },
{ HPPA_INS_CLDDS, "cldds" },
{ HPPA_INS_CLDDX, "clddx" },
{ HPPA_INS_CLDW, "cldw" },
{ HPPA_INS_CLDWS, "cldws" },
{ HPPA_INS_CLDWX, "cldwx" },
{ HPPA_INS_CLRBTS, "clrbts" },
{ HPPA_INS_CMPB, "cmpb" },
{ HPPA_INS_CMPCLR, "cmpclr" },
{ HPPA_INS_CMPIB, "cmpib" },
{ HPPA_INS_CMPICLR, "cmpiclr" },
{ HPPA_INS_COMB, "comb" },
{ HPPA_INS_COMBT, "combt" },
{ HPPA_INS_COMBF, "combf" },
{ HPPA_INS_COMCLR, "comclr" },
{ HPPA_INS_COMIB, "comib" },
{ HPPA_INS_COMIBT, "comibt" },
{ HPPA_INS_COMIBF, "comibf" },
{ HPPA_INS_COMICLR, "comiclr" },
{ HPPA_INS_COPR, "copr" },
{ HPPA_INS_COPY, "copy" },
{ HPPA_INS_CSTD, "cstd" },
{ HPPA_INS_CSTDS, "cstds" },
{ HPPA_INS_CSTDX, "cstdx" },
{ HPPA_INS_CSTW, "cstw" },
{ HPPA_INS_CSTWS, "cstws" },
{ HPPA_INS_CSTWX, "cstwx" },
{ HPPA_INS_DCOR, "dcor" },
{ HPPA_INS_DEP, "dep" },
{ HPPA_INS_DEPI, "depi" },
{ HPPA_INS_DEPD, "depd" },
{ HPPA_INS_DEPDI, "depdi" },
{ HPPA_INS_DEPW, "depw" },
{ HPPA_INS_DEPWI, "depwi" },
{ HPPA_INS_DIAG, "diag" },
{ HPPA_INS_DS, "ds" },
{ HPPA_INS_EXTRD, "extrd" },
{ HPPA_INS_EXTRS, "extrs" },
{ HPPA_INS_EXTRU, "extru" },
{ HPPA_INS_EXTRW, "extrw" },
{ HPPA_INS_FABS, "fabs" },
{ HPPA_INS_FADD, "fadd" },
{ HPPA_INS_FCMP, "fcmp" },
{ HPPA_INS_FCNV, "fcnv" },
{ HPPA_INS_FCNVFF, "fcnvff" },
{ HPPA_INS_FCNVFX, "fcnvfx" },
{ HPPA_INS_FCNVFXT, "fcnvfxt" },
{ HPPA_INS_FCNVXF, "fcnvxf" },
{ HPPA_INS_FCPY, "fcpy" },
{ HPPA_INS_FDC, "fdc" },
{ HPPA_INS_FDCE, "fdce" },
{ HPPA_INS_FDIV, "fdiv" },
{ HPPA_INS_FIC, "fic" },
{ HPPA_INS_FICE, "fice" },
{ HPPA_INS_FID, "fid" },
{ HPPA_INS_FLDD, "fldd" },
{ HPPA_INS_FLDDS, "fldds" },
{ HPPA_INS_FLDDX, "flddx" },
{ HPPA_INS_FLDW, "fldw" },
{ HPPA_INS_FLDWS, "fldws" },
{ HPPA_INS_FLDWX, "fldwx" },
{ HPPA_INS_FMPY, "fmpy" },
{ HPPA_INS_FMPYADD, "fmpyadd" },
{ HPPA_INS_FMPYFADD, "fmpyfadd" },
{ HPPA_INS_FMPYNFADD, "fmpynfadd" },
{ HPPA_INS_FMPYSUB, "fmpysub" },
{ HPPA_INS_FNEG, "fneg" },
{ HPPA_INS_FNEGABS, "fnegabs" },
{ HPPA_INS_FREM, "frem" },
{ HPPA_INS_FRND, "frnd" },
{ HPPA_INS_FSQRT, "fsqrt" },
{ HPPA_INS_FSTD, "fstd" },
{ HPPA_INS_FSTDS, "fstds" },
{ HPPA_INS_FSTDX, "fstdx" },
{ HPPA_INS_FSTW, "fstw" },
{ HPPA_INS_FSTWS, "fstws" },
{ HPPA_INS_FSTWX, "fstwx" },
{ HPPA_INS_FSTQS, "fstqs" },
{ HPPA_INS_FSTQX, "fstqx" },
{ HPPA_INS_FSUB, "fsub" },
{ HPPA_INS_FTEST, "ftest" },
{ HPPA_INS_GATE, "gate" },
{ HPPA_INS_GFR, "gfr" },
{ HPPA_INS_GFW, "gfw" },
{ HPPA_INS_GRSHDW, "grshdw" },
{ HPPA_INS_HADD, "hadd" },
{ HPPA_INS_HAVG, "havg" },
{ HPPA_INS_HSHL, "hshl" },
{ HPPA_INS_HSHLADD, "hshladd" },
{ HPPA_INS_HSHR, "hshr" },
{ HPPA_INS_HSHRADD, "hshradd" },
{ HPPA_INS_HSUB, "hsub" },
{ HPPA_INS_IDTLBA, "idtlba" },
{ HPPA_INS_IDTLBP, "idtlbp" },
{ HPPA_INS_IDTLBT, "idtlbt" },
{ HPPA_INS_IDCOR, "idcor" },
{ HPPA_INS_IITLBA, "iitlba" },
{ HPPA_INS_IITLBP, "iitlbp" },
{ HPPA_INS_IITLBT, "iitlbt" },
{ HPPA_INS_LCI, "lci" },
{ HPPA_INS_LDB, "ldb" },
{ HPPA_INS_LDBS, "ldbs" },
{ HPPA_INS_LDBX, "ldbx" },
{ HPPA_INS_LDCD, "ldcd" },
{ HPPA_INS_LDCW, "ldcw" },
{ HPPA_INS_LDCWS, "ldcws" },
{ HPPA_INS_LDCWX, "ldcwx" },
{ HPPA_INS_LDD, "ldd" },
{ HPPA_INS_LDDA, "ldda" },
{ HPPA_INS_LDH, "ldh" },
{ HPPA_INS_LDHS, "ldhs" },
{ HPPA_INS_LDHX, "ldhx" },
{ HPPA_INS_LDI, "ldi" },
{ HPPA_INS_LDIL, "ldil" },
{ HPPA_INS_LDO, "ldo" },
{ HPPA_INS_LDSID, "ldsid" },
{ HPPA_INS_LDW, "ldw" },
{ HPPA_INS_LDWA, "ldwa" },
{ HPPA_INS_LDWAS, "ldwas" },
{ HPPA_INS_LDWAX, "ldwax" },
{ HPPA_INS_LDWM, "ldwm" },
{ HPPA_INS_LDWS, "ldws" },
{ HPPA_INS_LDWX, "ldwx" },
{ HPPA_INS_LPA, "lpa" },
{ HPPA_INS_MFCPU, "mfcpu" },
{ HPPA_INS_MFCTL, "mfctl" },
{ HPPA_INS_MFIA, "mfia" },
{ HPPA_INS_MFSP, "mfsp" },
{ HPPA_INS_MIXH, "mixh" },
{ HPPA_INS_MIXW, "mixw" },
{ HPPA_INS_MOVB, "movb" },
{ HPPA_INS_MOVIB, "movib" },
{ HPPA_INS_MTCPU, "mtcpu" },
{ HPPA_INS_MTCTL, "mtctl" },
{ HPPA_INS_MTSAR, "mtsar" },
{ HPPA_INS_MTSARCM, "mtsarcm" },
{ HPPA_INS_MTSM, "mtsm" },
{ HPPA_INS_MTSP, "mtsp" },
{ HPPA_INS_NOP, "nop" },
{ HPPA_INS_OR, "or" },
{ HPPA_INS_PDC, "pdc" },
{ HPPA_INS_PDTLB, "pdtlb" },
{ HPPA_INS_PDTLBE, "pdtlbe" },
{ HPPA_INS_PERMH, "permh" },
{ HPPA_INS_PITLB, "pitlb" },
{ HPPA_INS_PITLBE, "pitlbe" },
{ HPPA_INS_PMDIS, "pmdis" },
{ HPPA_INS_PMENB, "pmenb" },
{ HPPA_INS_POPBTS, "popbts" },
{ HPPA_INS_PROBE, "probe" },
{ HPPA_INS_PROBEI, "probei" },
{ HPPA_INS_PROBER, "prober" },
{ HPPA_INS_PROBERI, "proberi" },
{ HPPA_INS_PROBEW, "probew" },
{ HPPA_INS_PROBEWI, "probewi" },
{ HPPA_INS_PUSHBTS, "pushbts" },
{ HPPA_INS_PUSHNOM, "pushnom" },
{ HPPA_INS_RET, "ret" },
{ HPPA_INS_RFI, "rfi" },
{ HPPA_INS_RFIR, "rfir" },
{ HPPA_INS_RSM, "rsm" },
{ HPPA_INS_SHDWGR, "shdwgr" },
{ HPPA_INS_SHLADD, "shladd" },
{ HPPA_INS_SH1ADD, "sh1add" },
{ HPPA_INS_SH1ADDL, "sh1addl" },
{ HPPA_INS_SH1ADDO, "sh1addo" },
{ HPPA_INS_SH2ADD, "sh2add" },
{ HPPA_INS_SH2ADDL, "sh2addl" },
{ HPPA_INS_SH2ADDO, "sh2addo" },
{ HPPA_INS_SH3ADD, "sh3add" },
{ HPPA_INS_SH3ADDL, "sh3addl" },
{ HPPA_INS_SH3ADDO, "sh3addo" },
{ HPPA_INS_SHD, "shd" },
{ HPPA_INS_SHRPD, "shrpd" },
{ HPPA_INS_SHRPW, "shrpw" },
{ HPPA_INS_SPOP0, "spop0" },
{ HPPA_INS_SPOP1, "spop1" },
{ HPPA_INS_SPOP2, "spop2" },
{ HPPA_INS_SPOP3, "spop3" },
{ HPPA_INS_SSM, "ssm" },
{ HPPA_INS_STB, "stb" },
{ HPPA_INS_STBS, "stbs" },
{ HPPA_INS_STBY, "stby" },
{ HPPA_INS_STBYS, "stbys" },
{ HPPA_INS_STD, "std" },
{ HPPA_INS_STDA, "stda" },
{ HPPA_INS_STDBY, "stdby" },
{ HPPA_INS_STH, "sth" },
{ HPPA_INS_STHS, "sths" },
{ HPPA_INS_STW, "stw" },
{ HPPA_INS_STWA, "stwa" },
{ HPPA_INS_STWAS, "stwas" },
{ HPPA_INS_STWS, "stws" },
{ HPPA_INS_STWM, "stwm" },
{ HPPA_INS_SUB, "sub" },
{ HPPA_INS_SUBB, "subb" },
{ HPPA_INS_SUBBO, "subbo" },
{ HPPA_INS_SUBI, "subi" },
{ HPPA_INS_SUBIO, "subio" },
{ HPPA_INS_SUBO, "subo" },
{ HPPA_INS_SUBT, "subt" },
{ HPPA_INS_SUBTO, "subto" },
{ HPPA_INS_SYNC, "sync" },
{ HPPA_INS_SYNCDMA, "syncdma" },
{ HPPA_INS_TOCDIS, "tocdis" },
{ HPPA_INS_TOCEN, "tocen" },
{ HPPA_INS_UADDCM, "uaddcm" },
{ HPPA_INS_UADDCMT, "uaddcmt" },
{ HPPA_INS_UXOR, "uxor" },
{ HPPA_INS_VDEP, "vdep" },
{ HPPA_INS_VDEPI, "vdepi" },
{ HPPA_INS_VEXTRS, "vextrs" },
{ HPPA_INS_VEXTRU, "vextru" },
{ HPPA_INS_VSHD, "vshd" },
{ HPPA_INS_XMPYU, "xmpyu" },
{ HPPA_INS_XOR, "xor" },
{ HPPA_INS_ZDEP, "zdep" },
{ HPPA_INS_ZDEPI, "zdepi" },
{ HPPA_INS_ZVDEP, "zvdep" },
{ HPPA_INS_ZVDEPI, "zvdepi" },
};
#endif
const char *HPPA_insn_name(csh handle, unsigned int id)
{
#ifndef CAPSTONE_DIET
return id2name(insn_name_maps, ARR_SIZE(insn_name_maps), id);
#else
return NULL;
#endif
}
#ifndef CAPSTONE_DIET
/* Integer register names, indexed by the numbers which appear in the
opcodes. */
static const char *const reg_names[] = {
"flags", "r1", "rp", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
"r24", "r25", "r26", "dp", "ret0", "ret1", "sp", "r31"
};
/* Floating point register names, indexed by the numbers which appear in the
opcodes. */
static const char *const fp_reg_names[] = {
"fpsr", "fpe2", "fpe4", "fpe6", "fr4", "fr5", "fr6", "fr7",
"fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
"fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
"fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31"
};
static const char *const control_reg[] = {
"rctr", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
"pidr1", "pidr2", "ccr", "sar", "pidr3", "pidr4", "iva", "eiem",
"itmr", "pcsq", "pcoq", "iir", "isr", "ior", "ipsw", "eirr",
"tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7"
};
static const char *const space_reg[] = { "sr0", "sr1", "sr2", "sr3",
"sr4", "sr5", "sr6", "sr7" };
static const char *const fpe_reg[] = {
"fpe1", "fpe3", "fpe5", "fpe7", "fr4R", "fr5R", "fr6R", "fr7R",
"fr8R", "fr9R", "fr10R", "fr11R", "fr12R", "fr13R", "fr14R", "fr15R",
"fr16R", "fr17R", "fr18R", "fr19R", "fr20R", "fr21R", "fr22R", "fr23R",
"fr24R", "fr25R", "fr26R", "fr27R", "fr28R", "fr29R", "fr30R", "fr31R"
};
static const char *const sp_fp_reg[] = {
"fr16L", "fr17L", "fr18L", "fr19L", "fr20L", "fr21L", "fr22L", "fr23L",
"fr24L", "fr25L", "fr26L", "fr27L", "fr28L", "fr29L", "fr30L", "fr31L",
"fr16R", "fr17R", "fr18R", "fr19R", "fr20R", "fr21R", "fr22R", "fr23R",
"fr24R", "fr25R", "fr26R", "fr27R", "fr28R", "fr29R", "fr30R", "fr31R"
};
#endif
const char *HPPA_reg_name(csh handle, unsigned int reg)
{
#ifndef CAPSTONE_DIET
if (reg >= HPPA_REG_GR0 && reg <= HPPA_REG_GR31)
return reg_names[reg - HPPA_REG_GR0];
else if (reg >= HPPA_REG_FPR0 && reg <= HPPA_REG_FPR31)
return fp_reg_names[reg - HPPA_REG_FPR0];
else if (reg >= HPPA_REG_SR0 && reg <= HPPA_REG_SR7)
return space_reg[reg - HPPA_REG_SR0];
else if (reg >= HPPA_REG_CR0 && reg <= HPPA_REG_CR31)
return control_reg[reg - HPPA_REG_CR0];
else if (reg >= HPPA_REG_FPE0 && reg <= HPPA_REG_FPE31)
return fpe_reg[reg - HPPA_REG_FPE0];
else if (reg >= HPPA_REG_SP_FPR0 && reg <= HPPA_REG_SP_FPR31)
return sp_fp_reg[reg - HPPA_REG_SP_FPR0];
return NULL;
#else
return NULL;
#endif
}
void HPPA_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int opcode)
{
insn->id = opcode;
}
static void sort_and_uniq(cs_regs arr, uint8_t n, uint8_t *new_n)
{
/* arr is always a tiny (usually n < 3) array,
* a simple O(n^2) sort is efficient enough. */
int i;
int j;
int iMin;
int tmp;
/* a modified selection sort for sorting and making unique */
for (j = 0; j < n; j++) {
/* arr[iMin] will be min(arr[j .. n-1]) */
iMin = j;
for (i = j + 1; i < n; i++) {
if (arr[i] < arr[iMin])
iMin = i;
}
if (j != 0 && arr[iMin] == arr[j - 1]) { // duplicate ele found
arr[iMin] = arr[n - 1];
--n;
} else {
tmp = arr[iMin];
arr[iMin] = arr[j];
arr[j] = tmp;
}
}
*new_n = n;
}
void HPPA_reg_access(const cs_insn *insn, cs_regs regs_read,
uint8_t *regs_read_count, cs_regs regs_write,
uint8_t *regs_write_count)
{
uint8_t read_count = 0;
uint8_t write_count = 0;
const cs_hppa *hppa = &(insn->detail->hppa);
for (unsigned i = 0; i < hppa->op_count; ++i) {
const cs_hppa_op *op = &(hppa->operands[i]);
switch (op->type) {
case HPPA_OP_REG:
case HPPA_OP_IDX_REG:
if (op->access & CS_AC_READ) {
regs_read[read_count++] = op->reg;
}
if (op->access & CS_AC_WRITE) {
regs_write[write_count++] = op->reg;
}
break;
case HPPA_OP_MEM:
if (op->mem.space != HPPA_REG_INVALID)
regs_read[read_count++] = op->mem.space;
if (op->mem.base_access & CS_AC_READ) {
regs_read[read_count++] = op->mem.base;
}
if (op->mem.base_access & CS_AC_WRITE) {
regs_write[write_count++] = op->mem.base;
}
break;
default:
break;
}
}
sort_and_uniq(regs_read, read_count, regs_read_count);
sort_and_uniq(regs_write, write_count, regs_write_count);
}
#endif

19
thirdparty/capstone/arch/HPPA/HPPAMapping.h vendored Normal file
View File

@@ -0,0 +1,19 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifndef CS_HPPAMAPPING_H
#define CS_HPPAMAPPING_H
#include <capstone/capstone.h>
#include "../../cs_priv.h"
const char *HPPA_group_name(csh handle, unsigned int id);
const char *HPPA_insn_name(csh handle, unsigned int id);
const char *HPPA_reg_name(csh handle, unsigned int reg);
void HPPA_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id);
void HPPA_reg_access(const cs_insn *insn, cs_regs regs_read,
uint8_t *regs_read_count, cs_regs regs_write,
uint8_t *regs_write_count);
#endif

34
thirdparty/capstone/arch/HPPA/HPPAModule.c vendored Normal file
View File

@@ -0,0 +1,34 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifdef CAPSTONE_HAS_HPPA
#include "HPPADisassembler.h"
#include "HPPAInstPrinter.h"
#include "HPPAMapping.h"
#include "HPPAModule.h"
cs_err HPPA_global_init(cs_struct *ud)
{
ud->printer = HPPA_printInst;
ud->reg_name = HPPA_reg_name;
ud->insn_id = HPPA_get_insn_id;
ud->insn_name = HPPA_insn_name;
ud->group_name = HPPA_group_name;
#ifndef CAPSTONE_DIET
ud->reg_access = HPPA_reg_access;
#endif
ud->disasm = HPPA_getInstruction;
return CS_ERR_OK;
}
cs_err HPPA_option(cs_struct *handle, cs_opt_type type, size_t value)
{
if (type == CS_OPT_MODE)
handle->mode = (cs_mode)value;
return CS_ERR_OK;
}
#endif

12
thirdparty/capstone/arch/HPPA/HPPAModule.h vendored Normal file
View File

@@ -0,0 +1,12 @@
/* Capstone Disassembly Engine */
/* By Dmitry Sibirtsev <sibirtsevdl@gmail.com>, 2023 */
#ifndef CS_HPPA_MODULE_H
#define CS_HPPA_MODULE_H
#include "../../utils.h"
cs_err HPPA_global_init(cs_struct *ud);
cs_err HPPA_option(cs_struct *handle, cs_opt_type type, size_t value);
#endif