void ll_to_n(num *a,ll n){ ll hover[N]; register int k=0; if(n==0){ a->n=1; a->a[0]=0; a->sbit=PLUS; return; } a->sbit=CMP(n,0); n=n*a->sbit; while(n){ hover[k++]=n%B; n/=B; } RM0(hover,k,a); }
C4Err compareResults(const void* expected, const void* calculated, size_t len, DumpFormatType format, char* comment ) { C4Err err = kC4Err_NoErr; err = CMP(expected, calculated, len) ? kC4Err_NoErr : kC4Err_SelfTestFailed; if( (err != kC4Err_NoErr) && IsntNull(comment) && (format != kResultFormat_None)) { OPTESTLogError( "\n\t\tFAILED %s\n",comment ); switch(format) { case kResultFormat_Byte: OPTESTLogError( "\t\texpected:\n"); dumpHex(IF_LOG_ERROR, ( uint8_t*) expected, (int)len, 0); OPTESTLogError( "\t\tcalulated:\n"); dumpHex(IF_LOG_ERROR,( uint8_t*) calculated, (int)len, 0); OPTESTLogError( "\n"); break; case kResultFormat_Long: OPTESTLogError( "\t\texpected:\n"); dump64(IF_LOG_ERROR,( uint8_t*) expected, len); OPTESTLogError( "\t\tcalulated:\n"); dump64(IF_LOG_ERROR,( uint8_t*) calculated, len ); OPTESTLogError( "\n"); break; case kResultFormat_Cstr: OPTESTLogError( "\t\texpected:\n"); dump8(IF_LOG_ERROR,( uint8_t*) expected, len); OPTESTLogError( "\t\tcalulated:\n"); dump8(IF_LOG_ERROR,( uint8_t*) calculated, len ); OPTESTLogError( "\n"); break; default: break; } } return err; }
static ERTS_INLINE int cmp_mon_ref(Eterm ref1, Eterm ref2) { Eterm *b1, *b2; b1 = boxed_val(ref1); b2 = boxed_val(ref2); if (is_ref_thing_header(*b1)) { if (is_ref_thing_header(*b2)) { return memcmp(b1+1,b2+1,ERTS_REF_WORDS*sizeof(Uint)); } return -1; } if (is_ref_thing_header(*b2)) { return 1; } return CMP(ref1,ref2); }
/* detect if a block is used in a particular pattern */ static int check_crc(const u_char *S, const u_char *buf, u_int32_t len) { u_int32_t crc; const u_char *c; crc = 0; for (c = buf; c < buf + len; c += SSH_BLOCKSIZE) { if (!CMP(S, c)) { crc_update(&crc, 1); crc_update(&crc, 0); } else { crc_update(&crc, 0); crc_update(&crc, 0); } } return crc == 0; }
int main(int argc, char* argv[]) { const size_t size = (argc > 1) ? atoi(argv[1]) : 32; cmpvec inputData; for (size_t i = 0; i < size; ++i) { inputData.push_back(CMP(0.1 + i, 0.2 * i)); } cmpvec bf; ft_bf(size, inputData, bf); if (0) { cmpvec gsl; ft_gsl(size, inputData, gsl); print_diff(bf, gsl); } if(0) { cmpvec fftw; ft_fftw(size, inputData, fftw); print_diff(bf, fftw); } if(0) { cmpvec fftw_d; const int isz = size; ft_fftw_d(1, &isz, inputData, fftw_d); print_diff(bf, fftw_d); } if(1) { cmpvec fftw_d1; const int sz1[] = { 3, 5 }; ft_fftw_d(2, &sz1[0], inputData, fftw_d1); cmpvec fftw_d2; const int sz2[] = { 5, 3 }; ft_fftw_d(2, &sz2[0], inputData, fftw_d2); print_both(fftw_d1, fftw_d2); } return 0; }
void vec4_tcs_visitor::emit_prolog() { invocation_id = src_reg(this, glsl_type::uint_type); emit(TCS_OPCODE_GET_INSTANCE_ID, dst_reg(invocation_id)); /* HS threads are dispatched with the dispatch mask set to 0xFF. * If there are an odd number of output vertices, then the final * HS instance dispatched will only have its bottom half doing real * work, and so we need to disable the upper half: */ if (nir->info->tcs.vertices_out % 2) { emit(CMP(dst_null_d(), invocation_id, brw_imm_ud(nir->info->tcs.vertices_out), BRW_CONDITIONAL_L)); /* Matching ENDIF is in emit_thread_end() */ emit(IF(BRW_PREDICATE_NORMAL)); } }
void JitArm::extsbx(UGeckoInstruction inst) { INSTRUCTION_START JITDISABLE(Integer) u32 a = inst.RA, s = inst.RS; if (gpr.IsImm(s)) { gpr.SetImmediate(a, (u32)(s32)(s8)gpr.GetImm(s)); if (inst.Rc) ComputeRC(gpr.GetImm(a), 0); return; } ARMReg rA = gpr.R(a); ARMReg rS = gpr.R(s); SXTB(rA, rS); if (inst.Rc){ CMP(rA, 0); ComputeRC(); } }
void heap_push(heap* h, heap_type datum) { // resize if necessary, with a doubling strategy if ( h->count == h->allocated ) { h->allocated <<= 1; h->data = SAFEREALLOC(h->data, sizeof(heap_type) * h->allocated); } // and insert element unsigned int index, parent; for ( index = h->count++, parent = (index - 1) >> 1; index && !CMP(h->data[parent], datum); index = parent, parent = (index - 1) >> 1) { h->data[index] = h->data[parent]; } h->data[index] = datum; }
// In: RAX: s64 _Value // Clobbers RCX void DSPEmitter::Update_SR_Register16_OverS32(Gen::X64Reg val) { OpArg sr_reg; gpr.GetReg(DSP_REG_SR, sr_reg); AND(16, sr_reg, Imm16(~SR_CMP_MASK)); // // 0x10 // if (_Value != (s32)_Value) g_dsp.r[DSP_REG_SR] |= SR_OVER_S32; MOVSX(64, 32, RCX, R(val)); CMP(64, R(RCX), R(val)); FixupBranch noOverS32 = J_CC(CC_E); OR(16, sr_reg, Imm16(SR_OVER_S32)); SetJumpTarget(noOverS32); gpr.PutReg(DSP_REG_SR); // // 0x20 - Checks if top bits of m are equal // if ((((u16)_Value >> 14) == 0) || (((u16)_Value >> 14) == 3)) // AND(32, R(val), Imm32(0xc0000000)); Update_SR_Register16(val); }
/* Verify anti-symmetry and transitivity for comparator CMP on sorted array of N SIZE-sized elements pointed to by BASE. */ void qsort_chk (void *base, size_t n, size_t size, int (*cmp)(const void *, const void *)) { #if 0 #define LIM(n) (n) #else /* Limit overall time complexity to O(n log n). */ #define LIM(n) ((n) <= 16 ? (n) : 12 + floor_log2 (n)) #endif #define ELT(i) ((const char *) base + (i) * size) #define CMP(i, j) cmp (ELT (i), ELT (j)) #define ERR2(i, j) qsort_chk_error (ELT (i), ELT (j), NULL, cmp) #define ERR3(i, j, k) qsort_chk_error (ELT (i), ELT (j), ELT (k), cmp) size_t i1, i2, i, j; /* This outer loop iterates over maximum spans [i1, i2) such that elements within each span compare equal to each other. */ for (i1 = 0; i1 < n; i1 = i2) { /* Position i2 one past last element that compares equal to i1'th. */ for (i2 = i1 + 1; i2 < n; i2++) if (CMP (i1, i2)) break; else if (CMP (i2, i1)) return ERR2 (i1, i2); size_t lim1 = LIM (i2 - i1), lim2 = LIM (n - i2); /* Verify that other pairs within current span compare equal. */ for (i = i1 + 1; i + 1 < i2; i++) for (j = i + 1; j < i1 + lim1; j++) if (CMP (i, j)) return ERR3 (i, i1, j); else if (CMP (j, i)) return ERR2 (i, j); /* Verify that elements within this span compare less than elements beyond the span. */ for (i = i1; i < i2; i++) for (j = i2; j < i2 + lim2; j++) if (CMP (i, j) >= 0) return ERR3 (i, i1, j); else if (CMP (j, i) <= 0) return ERR2 (i, j); } #undef ERR3 #undef ERR2 #undef CMP #undef ELT #undef LIM }
static int tm_is_lessthan(struct tm *x, struct tm *y) { #define CMP(f) \ if (x->f < y->f) \ return 1; \ else if (x->f > y->f) \ return 0; CMP(tm_year); CMP(tm_mon); CMP(tm_mday); CMP(tm_hour); CMP(tm_min); CMP(tm_sec); return 0; #undef CMP }
void Jit::WriteExit(u32 destination, int exit_num) { _dbg_assert_msg_(JIT, exit_num < MAX_JIT_BLOCK_EXITS, "Expected a valid exit_num"); if (!Memory::IsValidAddress(destination)) { ERROR_LOG_REPORT(JIT, "Trying to write block exit to illegal destination %08x: pc = %08x", destination, currentMIPS->pc); } // If we need to verify coreState and rewind, we may not jump yet. if (js.afterOp & (JitState::AFTER_CORE_STATE | JitState::AFTER_REWIND_PC_BAD_STATE)) { // CORE_RUNNING is <= CORE_NEXTFRAME. CMP(32, M((void*)&coreState), Imm32(CORE_NEXTFRAME)); FixupBranch skipCheck = J_CC(CC_LE); MOV(32, M(&mips_->pc), Imm32(js.compilerPC)); WriteSyscallExit(); SetJumpTarget(skipCheck); js.afterOp = JitState::AFTER_NONE; } WriteDowncount(); //If nobody has taken care of this yet (this can be removed when all branches are done) JitBlock *b = js.curBlock; b->exitAddress[exit_num] = destination; b->exitPtrs[exit_num] = GetWritableCodePtr(); // Link opportunity! int block = blocks.GetBlockNumberFromStartAddress(destination); if (block >= 0 && jo.enableBlocklink) { // It exists! Joy of joy! JMP(blocks.GetBlock(block)->checkedEntry, true); b->linkStatus[exit_num] = true; } else { // No blocklinking. MOV(32, M(&mips_->pc), Imm32(destination)); JMP(asm_.dispatcher, true); } }
static int conf_sort(const void *v1, const void *v2) { const struct conf *c1 = v1; const struct conf *c2 = v2; #define CMP(a, b, f) \ if ((a)->f > (b)->f) return -1; \ else if ((a)->f < (b)->f) return 1 CMP(c1, c2, c_ss.ss_family); CMP(c1, c2, c_lmask); CMP(c1, c2, c_port); CMP(c1, c2, c_proto); CMP(c1, c2, c_family); CMP(c1, c2, c_rmask); CMP(c1, c2, c_uid); #undef CMP return 0; }
// In: (val): s64 _Value // In: (carry_ovfl): 1 = carry, 2 = overflow // Clobbers RDX void DSPEmitter::Update_SR_Register64_Carry(X64Reg val, X64Reg carry_ovfl, bool carry_eq) { OpArg sr_reg; gpr.GetReg(DSP_REG_SR, sr_reg); // g_dsp.r[DSP_REG_SR] &= ~SR_CMP_MASK; AND(16, sr_reg, Imm16(~SR_CMP_MASK)); CMP(64, R(carry_ovfl), R(val)); // 0x01 // g_dsp.r[DSP_REG_SR] |= SR_CARRY; // Carry = (acc>res) // Carry2 = (acc>=res) FixupBranch noCarry = J_CC(carry_eq ? CC_B : CC_BE); OR(16, sr_reg, Imm16(SR_CARRY)); SetJumpTarget(noCarry); // 0x02 and 0x80 // g_dsp.r[DSP_REG_SR] |= SR_OVERFLOW; // g_dsp.r[DSP_REG_SR] |= SR_OVERFLOW_STICKY; // Overflow = ((acc ^ res) & (ax ^ res)) < 0 XOR(64, R(carry_ovfl), R(val)); XOR(64, R(RDX), R(val)); TEST(64, R(carry_ovfl), R(RDX)); FixupBranch noOverflow = J_CC(CC_GE); OR(16, sr_reg, Imm16(SR_OVERFLOW | SR_OVERFLOW_STICKY)); SetJumpTarget(noOverflow); gpr.PutReg(DSP_REG_SR); if (carry_eq) { Update_SR_Register(); } else { Update_SR_Register(val); } }
int hashset_add(hashset_p set, const void *item, size_t bytes) { slot_p slot = NULL, new_slot = NULL; slotlist_p slotlist = &set->slotlists[HASH(set, item, bytes) % set->slotlists_n]; slot_p *pslot = &slotlist->list; int is_new = !(slot = *pslot); while (slot) { if (!CMP(set, &slot->data, item, bytes)) { return -1; } pslot = &slot->next; slot = *pslot; } *pslot = new_slot = (slot_p) malloc(bytes + sizeof(slot_p)); if (!new_slot) { return -2; } new_slot->next = NULL; memcpy(&new_slot->data, item, bytes); if (!set->non_null) { set->non_null = slotlist; } else if (is_new) { set->non_null->pre = slotlist; slotlist->next = set->non_null; set->non_null = slotlist; } ++set->size; return 0; }
void JitArm::lfs(UGeckoInstruction inst) { INSTRUCTION_START JITDISABLE(LoadStoreFloating) Default(inst); return; ARMReg rA = gpr.GetReg(); ARMReg rB = gpr.GetReg(); LDR(rA, R9, STRUCT_OFF(PowerPC::ppcState, Exceptions)); CMP(rA, EXCEPTION_DSI); FixupBranch DoNotLoad = B_CC(CC_EQ); if (inst.RA) { MOVI2R(rB, inst.SIMM_16); ARMReg RA = gpr.R(inst.RA); ADD(rB, rB, RA); } else MOVI2R(rB, (u32)inst.SIMM_16); MOVI2R(rA, (u32)&Memory::Read_U32); PUSH(4, R0, R1, R2, R3); MOV(R0, rB); BL(rA); MOV(rA, R0); POP(4, R0, R1, R2, R3); ARMReg v0 = fpr.R0(inst.FD, false); ARMReg v1 = fpr.R1(inst.FD, false); VMOV(v0, rA, false); VMOV(v1, rA, false); gpr.Unlock(rA, rB); SetJumpTarget(DoNotLoad); }
//统计出现次数最多的前K种水果 void TopK(vector<string>& fruits) { //统计水果出现的次数 map<string, int> fruitCount; size_t size = fruits.size(); for (size_t i = 0; i < size; ++i) { fruitCount[fruits[i]]++; } //排序 vector<map<string, int>::iterator> v; //将数据保存在可以随机访问的容器里。 map<string, int>::iterator it = fruitCount.begin(); while (it != fruitCount.end()) { v.push_back(it); ++it; } struct CMP { bool operator()(const map<string, int>::iterator l, const map<string, int>::iterator r) const { return (l->second > r->second); } }; sort(v.begin(), v.end(), CMP()); //输出排序结果 for (size_t i = 0; i < v.size(); ++i) { cout << v[i]->first << "-" << v[i]->second << endl; } }
static int try_lcs(struct histindex *index, struct region *lcs, int b_ptr, int line1, int count1, int line2, int count2) { unsigned int b_next = b_ptr + 1; struct record *rec = index->records[TABLE_HASH(index, 2, b_ptr)]; unsigned int as, ae, bs, be, np, rc; int should_break; for (; rec; rec = rec->next) { if (rec->cnt > index->cnt) { if (!index->has_common) index->has_common = CMP(index, 1, rec->ptr, 2, b_ptr); continue; } as = rec->ptr; if (!CMP(index, 1, as, 2, b_ptr)) continue; index->has_common = 1; for (;;) { should_break = 0; np = NEXT_PTR(index, as); bs = b_ptr; ae = as; be = bs; rc = rec->cnt; while (line1 < (int)as && line2 < (int)bs && CMP(index, 1, as - 1, 2, bs - 1)) { as--; bs--; if (1 < rc) rc = XDL_MIN(rc, CNT(index, as)); } while ((int)ae < LINE_END(1) && (int)be < LINE_END(2) && CMP(index, 1, ae + 1, 2, be + 1)) { ae++; be++; if (1 < rc) rc = XDL_MIN(rc, CNT(index, ae)); } if (b_next <= be) b_next = be + 1; if (lcs->end1 - lcs->begin1 < ae - as || rc < index->cnt) { lcs->begin1 = as; lcs->begin2 = bs; lcs->end1 = ae; lcs->end2 = be; index->cnt = rc; } if (np == 0) break; while (np <= ae) { np = NEXT_PTR(index, np); if (np == 0) { should_break = 1; break; } } if (should_break) break; as = np; } } return b_next; }
/* Process 3OP Integer instructions */ bool eval_3OP_Int(struct lilith* vm, struct Instruction* c) { #ifdef DEBUG char Name[20] = "ILLEGAL_3OP"; #endif switch(c->raw_XOP) { case 0x000: /* ADD */ { #ifdef DEBUG strncpy(Name, "ADD", 19); #elif TRACE record_trace("ADD"); #endif ADD(vm, c); break; } case 0x001: /* ADDU */ { #ifdef DEBUG strncpy(Name, "ADDU", 19); #elif TRACE record_trace("ADDU"); #endif ADDU(vm, c); break; } case 0x002: /* SUB */ { #ifdef DEBUG strncpy(Name, "SUB", 19); #elif TRACE record_trace("SUB"); #endif SUB(vm, c); break; } case 0x003: /* SUBU */ { #ifdef DEBUG strncpy(Name, "SUBU", 19); #elif TRACE record_trace("SUBU"); #endif SUBU(vm, c); break; } case 0x004: /* CMP */ { #ifdef DEBUG strncpy(Name, "CMP", 19); #elif TRACE record_trace("CMP"); #endif CMP(vm, c); break; } case 0x005: /* CMPU */ { #ifdef DEBUG strncpy(Name, "CMPU", 19); #elif TRACE record_trace("CMPU"); #endif CMPU(vm, c); break; } case 0x006: /* MUL */ { #ifdef DEBUG strncpy(Name, "MUL", 19); #elif TRACE record_trace("MUL"); #endif MUL(vm, c); break; } case 0x007: /* MULH */ { #ifdef DEBUG strncpy(Name, "MULH", 19); #elif TRACE record_trace("MULH"); #endif MULH(vm, c); break; } case 0x008: /* MULU */ { #ifdef DEBUG strncpy(Name, "MULU", 19); #elif TRACE record_trace("MULU"); #endif MULU(vm, c); break; } case 0x009: /* MULUH */ { #ifdef DEBUG strncpy(Name, "MULUH", 19); #elif TRACE record_trace("MULUH"); #endif MULUH(vm, c); break; } case 0x00A: /* DIV */ { #ifdef DEBUG strncpy(Name, "DIV", 19); #elif TRACE record_trace("DIV"); #endif DIV(vm, c); break; } case 0x00B: /* MOD */ { #ifdef DEBUG strncpy(Name, "MOD", 19); #elif TRACE record_trace("MOD"); #endif MOD(vm, c); break; } case 0x00C: /* DIVU */ { #ifdef DEBUG strncpy(Name, "DIVU", 19); #elif TRACE record_trace("DIVU"); #endif DIVU(vm, c); break; } case 0x00D: /* MODU */ { #ifdef DEBUG strncpy(Name, "MODU", 19); #elif TRACE record_trace("MODU"); #endif MODU(vm, c); break; } case 0x010: /* MAX */ { #ifdef DEBUG strncpy(Name, "MAX", 19); #elif TRACE record_trace("MAX"); #endif MAX(vm, c); break; } case 0x011: /* MAXU */ { #ifdef DEBUG strncpy(Name, "MAXU", 19); #elif TRACE record_trace("MAXU"); #endif MAXU(vm, c); break; } case 0x012: /* MIN */ { #ifdef DEBUG strncpy(Name, "MIN", 19); #elif TRACE record_trace("MIN"); #endif MIN(vm, c); break; } case 0x013: /* MINU */ { #ifdef DEBUG strncpy(Name, "MINU", 19); #elif TRACE record_trace("MINU"); #endif MINU(vm, c); break; } case 0x014: /* PACK */ case 0x015: /* UNPACK */ case 0x016: /* PACK8.CO */ case 0x017: /* PACK8U.CO */ case 0x018: /* PACK16.CO */ case 0x019: /* PACK16U.CO */ case 0x01A: /* PACK32.CO */ case 0x01B: /* PACK32U.CO */ { illegal_instruction(vm, c); break; } case 0x020: /* AND */ { #ifdef DEBUG strncpy(Name, "AND", 19); #elif TRACE record_trace("AND"); #endif AND(vm, c); break; } case 0x021: /* OR */ { #ifdef DEBUG strncpy(Name, "OR", 19); #elif TRACE record_trace("OR"); #endif OR(vm, c); break; } case 0x022: /* XOR */ { #ifdef DEBUG strncpy(Name, "XOR", 19); #elif TRACE record_trace("XOR"); #endif XOR(vm, c); break; } case 0x023: /* NAND */ { #ifdef DEBUG strncpy(Name, "NAND", 19); #elif TRACE record_trace("NAND"); #endif NAND(vm, c); break; } case 0x024: /* NOR */ { #ifdef DEBUG strncpy(Name, "NOR", 19); #elif TRACE record_trace("NOR"); #endif NOR(vm, c); break; } case 0x025: /* XNOR */ { #ifdef DEBUG strncpy(Name, "XNOR", 19); #elif TRACE record_trace("XNOR"); #endif XNOR(vm, c); break; } case 0x026: /* MPQ */ { #ifdef DEBUG strncpy(Name, "MPQ", 19); #elif TRACE record_trace("MPQ"); #endif MPQ(vm, c); break; } case 0x027: /* LPQ */ { #ifdef DEBUG strncpy(Name, "LPQ", 19); #elif TRACE record_trace("LPQ"); #endif LPQ(vm, c); break; } case 0x028: /* CPQ */ { #ifdef DEBUG strncpy(Name, "CPQ", 19); #elif TRACE record_trace("CPQ"); #endif CPQ(vm, c); break; } case 0x029: /* BPQ */ { #ifdef DEBUG strncpy(Name, "BPQ", 19); #elif TRACE record_trace("BPQ"); #endif BPQ(vm, c); break; } case 0x030: /* SAL */ { #ifdef DEBUG strncpy(Name, "SAL", 19); #elif TRACE record_trace("SAL"); #endif SAL(vm, c); break; } case 0x031: /* SAR */ { #ifdef DEBUG strncpy(Name, "SAR", 19); #elif TRACE record_trace("SAR"); #endif SAR(vm, c); break; } case 0x032: /* SL0 */ { #ifdef DEBUG strncpy(Name, "SL0", 19); #elif TRACE record_trace("SL0"); #endif SL0(vm, c); break; } case 0x033: /* SR0 */ { #ifdef DEBUG strncpy(Name, "SR0", 19); #elif TRACE record_trace("SR0"); #endif SR0(vm, c); break; } case 0x034: /* SL1 */ { #ifdef DEBUG strncpy(Name, "SL1", 19); #elif TRACE record_trace("SL1"); #endif SL1(vm, c); break; } case 0x035: /* SR1 */ { #ifdef DEBUG strncpy(Name, "SR1", 19); #elif TRACE record_trace("SR1"); #endif SR1(vm, c); break; } case 0x036: /* ROL */ { #ifdef DEBUG strncpy(Name, "ROL", 19); #elif TRACE record_trace("ROL"); #endif ROL(vm, c); break; } case 0x037: /* ROR */ { #ifdef DEBUG strncpy(Name, "ROR", 19); #elif TRACE record_trace("ROR"); #endif ROR(vm, c); break; } case 0x038: /* LOADX */ { #ifdef DEBUG strncpy(Name, "LOADX", 19); #elif TRACE record_trace("LOADX"); #endif LOADX(vm, c); break; } case 0x039: /* LOADX8 */ { #ifdef DEBUG strncpy(Name, "LOADX8", 19); #elif TRACE record_trace("LOADX8"); #endif LOADX8(vm, c); break; } case 0x03A: /* LOADXU8 */ { #ifdef DEBUG strncpy(Name, "LOADXU8", 19); #elif TRACE record_trace("LOADXU8"); #endif LOADXU8(vm, c); break; } case 0x03B: /* LOADX16 */ { #ifdef DEBUG strncpy(Name, "LOADX16", 19); #elif TRACE record_trace("LOADX16"); #endif LOADX16(vm, c); break; } case 0x03C: /* LOADXU16 */ { #ifdef DEBUG strncpy(Name, "LOADXU16", 19); #elif TRACE record_trace("LOADXU16"); #endif LOADXU16(vm, c); break; } case 0x03D: /* LOADX32 */ { #ifdef DEBUG strncpy(Name, "LOADX32", 19); #elif TRACE record_trace("LOADX32"); #endif LOADX32(vm, c); break; } case 0x03E: /* LOADXU32 */ { #ifdef DEBUG strncpy(Name, "LOADXU32", 19); #elif TRACE record_trace("LOADXU32"); #endif LOADXU32(vm, c); break; } case 0x048: /* STOREX */ { #ifdef DEBUG strncpy(Name, "STOREX", 19); #elif TRACE record_trace("STOREX"); #endif STOREX(vm, c); break; } case 0x049: /* STOREX8 */ { #ifdef DEBUG strncpy(Name, "STOREX8", 19); #elif TRACE record_trace("STOREX8"); #endif STOREX8(vm, c); break; } case 0x04A: /* STOREX16 */ { #ifdef DEBUG strncpy(Name, "STOREX16", 19); #elif TRACE record_trace("STOREX16"); #endif STOREX16(vm, c); break; } case 0x04B: /* STOREX32 */ { #ifdef DEBUG strncpy(Name, "STOREX32", 19); #elif TRACE record_trace("STOREX32"); #endif STOREX32(vm, c); break; } case 0x050: /* CMPJUMP.G */ { #ifdef DEBUG strncpy(Name, "CMPJUMP.G", 19); #elif TRACE record_trace("CMPJUMP.G"); #endif CMPJUMP_G(vm, c); break; } case 0x051: /* CMPJUMP.GE */ { #ifdef DEBUG strncpy(Name, "CMPJUMP.GE", 19); #elif TRACE record_trace("CMPJUMP.GE"); #endif CMPJUMP_GE(vm, c); break; } case 0x052: /* CMPJUMP.E */ { #ifdef DEBUG strncpy(Name, "CMPJUMP.E", 19); #elif TRACE record_trace("CMPJUMP.E"); #endif CMPJUMP_E(vm, c); break; } case 0x053: /* CMPJUMP.NE */ { #ifdef DEBUG strncpy(Name, "CMPJUMP.NE", 19); #elif TRACE record_trace("CMPJUMP.NE"); #endif CMPJUMP_NE(vm, c); break; } case 0x054: /* CMPJUMP.LE */ { #ifdef DEBUG strncpy(Name, "CMPJUMP.LE", 19); #elif TRACE record_trace("CMPJUMP.LE"); #endif CMPJUMP_LE(vm, c); break; } case 0x055: /* CMPJUMP.L */ { #ifdef DEBUG strncpy(Name, "CMPJUMP.L", 19); #elif TRACE record_trace("CMPJUMP.L"); #endif CMPJUMP_L(vm, c); break; } case 0x060: /* CMPJUMPU.G */ { #ifdef DEBUG strncpy(Name, "CMPJUMPU.G", 19); #elif TRACE record_trace("CMPJUMPU.G"); #endif CMPJUMPU_G(vm, c); break; } case 0x061: /* CMPJUMPU.GE */ { #ifdef DEBUG strncpy(Name, "CMPJUMPU.GE", 19); #elif TRACE record_trace("CMPJUMPU.GE"); #endif CMPJUMPU_GE(vm, c); break; } case 0x064: /* CMPJUMPU.LE */ { #ifdef DEBUG strncpy(Name, "CMPJUMPU.LE", 19); #elif TRACE record_trace("CMPJUMPU.LE"); #endif CMPJUMPU_LE(vm, c); break; } case 0x065: /* CMPJUMPU.L */ { #ifdef DEBUG strncpy(Name, "CMPJUMPU.L", 19); #elif TRACE record_trace("CMPJUMPU.L"); #endif CMPJUMPU_L(vm, c); break; } default: { illegal_instruction(vm, c); break; } } #ifdef DEBUG fprintf(stdout, "# %s reg%u reg%u reg%u\n", Name, c->reg0, c->reg1, c->reg2); #endif return false; }
void JitArm::fctiwx(UGeckoInstruction inst) { INSTRUCTION_START JITDISABLE(bJITFloatingPointOff) u32 b = inst.FB; u32 d = inst.FD; ARMReg vB = fpr.R0(b); ARMReg vD = fpr.R0(d); ARMReg V0 = fpr.GetReg(); ARMReg V1 = fpr.GetReg(); ARMReg V2 = fpr.GetReg(); ARMReg rA = gpr.GetReg(); ARMReg fpscrReg = gpr.GetReg(); FixupBranch DoneMax, DoneMin; LDR(fpscrReg, R9, PPCSTATE_OFF(fpscr)); MOVI2R(rA, (u32)minmaxFloat); // Check if greater than max float { VLDR(V0, rA, 8); // Load Max VCMPE(vB, V0); VMRS(_PC); // Loads in to APSR FixupBranch noException = B_CC(CC_LE); VMOV(vD, V0); // Set to max SetFPException(fpscrReg, FPSCR_VXCVI); DoneMax = B(); SetJumpTarget(noException); } // Check if less than min float { VLDR(V0, rA, 0); VCMPE(vB, V0); VMRS(_PC); FixupBranch noException = B_CC(CC_GE); VMOV(vD, V0); SetFPException(fpscrReg, FPSCR_VXCVI); DoneMin = B(); SetJumpTarget(noException); } // Within ranges, convert to integer // Set rounding mode first // PPC <-> ARM rounding modes // 0, 1, 2, 3 <-> 0, 3, 1, 2 ARMReg rB = gpr.GetReg(); VMRS(rA); // Bits 22-23 BIC(rA, rA, Operand2(3, 5)); LDR(rB, R9, PPCSTATE_OFF(fpscr)); AND(rB, rB, 0x3); // Get the FPSCR rounding bits CMP(rB, 1); SetCC(CC_EQ); // zero ORR(rA, rA, Operand2(3, 5)); SetCC(CC_NEQ); CMP(rB, 2); // +inf SetCC(CC_EQ); ORR(rA, rA, Operand2(1, 5)); SetCC(CC_NEQ); CMP(rB, 3); // -inf SetCC(CC_EQ); ORR(rA, rA, Operand2(2, 5)); SetCC(); VMSR(rA); ORR(rA, rA, Operand2(3, 5)); VCVT(vD, vB, TO_INT | IS_SIGNED); VMSR(rA); gpr.Unlock(rB); VCMPE(vD, vB); VMRS(_PC); SetCC(CC_EQ); BIC(fpscrReg, fpscrReg, FRFIMask); FixupBranch DoneEqual = B(); SetCC(); SetFPException(fpscrReg, FPSCR_XX); ORR(fpscrReg, fpscrReg, FIMask); VABS(V1, vB); VABS(V2, vD); VCMPE(V2, V1); VMRS(_PC); SetCC(CC_GT); ORR(fpscrReg, fpscrReg, FRMask); SetCC(); SetJumpTarget(DoneEqual); SetJumpTarget(DoneMax); SetJumpTarget(DoneMin); MOVI2R(rA, (u32)&doublenum); VLDR(V0, rA, 0); NEONXEmitter nemit(this); nemit.VORR(vD, vD, V0); if (inst.Rc) Helper_UpdateCR1(fpscrReg, rA); STR(fpscrReg, R9, PPCSTATE_OFF(fpscr)); gpr.Unlock(rA); gpr.Unlock(fpscrReg); fpr.Unlock(V0); fpr.Unlock(V1); fpr.Unlock(V2); }
/** * Find the most likely shift in motion between two frames for a given * macroblock. Test each block against several shifts given by the rx * and ry attributes. Searches using a simple matrix of those shifts and * chooses the most likely shift by the smallest difference in blocks. */ static void find_block_motion(DeshakeContext *deshake, uint8_t *src1, uint8_t *src2, int cx, int cy, int stride, IntMotionVector *mv) { int x, y; int diff; int smallest = INT_MAX; int tmp, tmp2; #define CMP(i, j) deshake->c.sad[0](NULL, src1 + cy * stride + cx, \ src2 + (j) * stride + (i), stride, \ deshake->blocksize) if (deshake->search == EXHAUSTIVE) { // Compare every possible position - this is sloooow! for (y = -deshake->ry; y <= deshake->ry; y++) { for (x = -deshake->rx; x <= deshake->rx; x++) { diff = CMP(cx - x, cy - y); if (diff < smallest) { smallest = diff; mv->x = x; mv->y = y; } } } } else if (deshake->search == SMART_EXHAUSTIVE) { // Compare every other possible position and find the best match for (y = -deshake->ry + 1; y < deshake->ry; y += 2) { for (x = -deshake->rx + 1; x < deshake->rx; x += 2) { diff = CMP(cx - x, cy - y); if (diff < smallest) { smallest = diff; mv->x = x; mv->y = y; } } } // Hone in on the specific best match around the match we found above tmp = mv->x; tmp2 = mv->y; for (y = tmp2 - 1; y <= tmp2 + 1; y++) { for (x = tmp - 1; x <= tmp + 1; x++) { if (x == tmp && y == tmp2) continue; diff = CMP(cx - x, cy - y); if (diff < smallest) { smallest = diff; mv->x = x; mv->y = y; } } } } if (smallest > 512) { mv->x = -1; mv->y = -1; } emms_c(); //av_log(NULL, AV_LOG_ERROR, "%d\n", smallest); //av_log(NULL, AV_LOG_ERROR, "Final: (%d, %d) = %d x %d\n", cx, cy, mv->x, mv->y); }
static inline void neumann_bc(double curvature_motion_part[M][N][P]) { uint32_t i, j, k; for (j = 0; j < N; j++) { for (k = 0; k < P; k++) { #pragma AP pipeline CMP(0, j, k) = CMP(1, j, k); CMP(M - 1, j, k) = CMP(M - 2, j, k); } } for (i = 0; i < M; i++) { for (k = 0; k < P; k++) { #pragma AP pipeline CMP(i, 0, k) = CMP(i, 1, k); CMP(i, N - 1, k) = CMP(i, N - 2, k); } } for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { #pragma AP pipeline CMP(i, j, 0) = CMP(i, j, 1); CMP(i, j, P - 1) = CMP(i, j, P - 2); } } CMP(0, 0, 0) = CMP(1, 1, 1); CMP(M - 1, 0, 0) = CMP(M - 2, 1, 1); CMP(0, N - 1, 0) = CMP(1, N - 2, 1); CMP(0, 0, P - 1) = CMP(1, 1, P - 2); CMP(M - 1, N - 1, 0) = CMP(M - 2, N - 2, 1); CMP(M - 1, 0, P - 1) = CMP(M - 2, 1, P - 2); CMP(0, N - 1, P - 1) = CMP(1, N - 2, P - 2); CMP(M - 1, N - 1, P - 1) = CMP(M - 2, N - 2, P - 2); }
void two_phase_3d_op_explicit(double phi[M][N][P], const double u0[M][N][P], double curvature_motion_part[M][N][P], double dt, double c1, double c2) { double mu = TP_MU; double nu = TP_NU; double lambda1 = TP_LAMBDA1; double lambda2 = TP_LAMBDA2; double dx = 1.0; double dy = 1.0; double dz = 1.0; double dx2 = dx * 2.0; double dy2 = dy * 2.0; double dz2 = dz * 2.0; double Dx_p, Dx_m; double Dy_p, Dy_m; double Dz_p, Dz_m; double Dx_0, Dy_0, Dz_0; double Dxx, Dyy, Dzz; double Dxy, Dxz, Dyz; double Grad, K; double stencil[3][3][3]; #pragma AP array_partition variable=stencil complete dim=0 double numer, denom; uint32_t i, j, k, l; for (i = 1; i < M - 1; i++) { for (j = 1; j < N - 1; j++) { for (k = 1; k < P - 1; k++) { #pragma AP pipeline /* stencil code */ stencil[0][0][0] = stencil[0][0][1]; stencil[0][1][0] = stencil[0][1][1]; stencil[0][2][0] = stencil[0][2][1]; stencil[0][0][1] = stencil[0][0][2]; stencil[0][1][1] = stencil[0][1][2]; stencil[0][2][1] = stencil[0][2][2]; stencil[0][0][2] = PHI(i - 1, j - 1, k + 1); stencil[0][1][2] = PHI(i - 1, j, k + 1); stencil[0][2][2] = PHI(i - 1, j + 1, k + 1); stencil[1][0][0] = stencil[1][0][1]; stencil[1][1][0] = stencil[1][2][1]; stencil[1][2][0] = stencil[1][2][1]; stencil[1][0][1] = stencil[1][0][2]; stencil[1][1][1] = stencil[1][1][2]; stencil[1][2][1] = stencil[1][2][2]; stencil[1][0][2] = PHI(i, j - 1, k + 1); stencil[1][1][2] = PHI(i, j, k + 1); stencil[1][2][2] = PHI(i, j + 1, k + 1); stencil[2][0][0] = stencil[2][0][1]; stencil[2][1][0] = stencil[2][1][1]; stencil[2][2][0] = stencil[2][2][1]; stencil[2][0][1] = stencil[2][0][2]; stencil[2][1][1] = stencil[2][1][2]; stencil[2][2][1] = stencil[2][2][2]; stencil[2][0][2] = PHI(i + 1, j - 1, k + 1); stencil[2][1][2] = PHI(i + 1, j, k + 1); stencil[2][2][2] = PHI(i + 1, j + 1, k + 1); /* regular calculation here */ Dx_p = (stencil[2][1][1] - stencil[1][1][1]) / dx; Dx_m = (stencil[1][1][1] - stencil[0][1][1]) / dx; Dy_p = (stencil[1][2][1] - stencil[1][1][1]) / dy; Dy_m = (stencil[1][1][1] - stencil[1][0][1]) / dy; Dz_p = (stencil[1][1][2] - stencil[1][1][1]) / dz; Dz_m = (stencil[1][1][1] - stencil[1][1][0]) / dz; Dx_0 = (stencil[2][1][1] - stencil[0][1][1]) / dx2; Dy_0 = (stencil[1][2][1] - stencil[1][0][1]) / dy2; Dz_0 = (stencil[1][1][2] - stencil[1][1][0]) / dz2; Dxx = (Dx_p - Dx_m) / dx; Dyy = (Dy_p - Dy_m) / dy; Dzz = (Dz_p - Dz_m) / dz; Dxy = (stencil[2][2][1] - stencil[2][0][1] - stencil[0][2][1] - stencil[0][0][1]) / (4 * dx * dy); Dxz = (stencil[2][1][2] - stencil[2][1][0] - stencil[0][1][2] + stencil[0][1][0]) / (4 * dx * dz); Dyz = (stencil[1][2][2] - stencil[1][2][0] - stencil[1][0][2] + stencil[1][0][0]) / (4 * dy * dz); Grad = (SQR(Dx_0) + SQR(Dy_0) + SQR(Dz_0)); denom = Grad; /* denom = denom^1.5 */ for (l = 0; l < 3; l++) { #pragma AP unroll denom *= denom; } q3_sqrt(denom); numer = (Dx_0 * Dx_0 * Dyy - 2.0 * Dx_0 * Dy_0 * Dxy + Dy_0 * Dy_0 * Dxx + Dx_0 * Dx_0 * Dzz - 2.0 * Dx_0 * Dz_0 * Dxz + Dz_0 * Dz_0 * Dxx + Dy_0 * Dy_0 * Dzz - 2.0 * Dy_0 * Dz_0 * Dyz + Dz_0 * Dz_0 * Dyy); K = numer / denom; CMP(i, j, k) = Grad * (mu * K + lambda1 * (U0(i, j, k) - c1) * (U0(i, j, k) - c1) - lambda2 * (U0(i, j, k) - c2) * (U0(i, j, k) - c2)); } } } neumann_bc(curvature_motion_part); for (k = 0; k < P; k++) { for (j = 0; j < N; j++) { for (i = 0; i < M; i++) { #pragma AP pipeline PHI(i, j, k) += CMP(i, j, k) * dt; } } } }
ALU(ADDRY, eor), // 0x56 ALU(IDPY, eor), // 0x57 ALU(DP_IMM, eor), // 0x58 ALU(DPX_DPY, eor), // 0x59 ALUW(cmpw), // 0x5a RMW(DPIX, lsr), // 0x5b RMW(A, lsr), // 0x5c MOVE(X, a), // 0x5d ALUXY(y, addr), // 0x5e smp_op_jmp, // 0x5f smp_op_clrc, // 0x60 TCALL(6), // 0x61 SET1(3), // 0x62 BBS(3), // 0x63 CMP(a, dp), // 0x64 CMP(a, addr), // 0x65 CMP(a, dpx), // 0x66 CMP(a, idpx), // 0x67 CMP(a, const), // 0x68 CMP(dp, dp), // 0x69 ALU(BIT, andn1), // 0x6a RMW(DP, ror), // 0x6b RMW(ADDR, ror), // 0x6c smp_op_push_y, // 0x6d smp_op_dbnz_dp, // 0x6e smp_op_ret, // 0x6f BRANCH(v), // 0x70 TCALL(7), // 0x71 CLR1(3), // 0x72
TextureFormat string2TextureFormat(const char *str) { #define CMP(fmt, shrt) if (!strcmp_cns(str, #fmt) || (shrt && !strcmp_cns(str, shrt))) return TF_##fmt CMP(A8, 0); CMP(L8, 0); CMP(A8L8, 0); CMP(R8G8B8, "888"); CMP(R8G8B8A8, "8888"); CMP(R5G5B5A1, "5551"); CMP(R4G4B4A4, "4444"); CMP(R5G6B5, "565"); CMP(PVRTC_2RGB, 0); CMP(PVRTC_2RGBA, 0); CMP(PVRTC_4RGB, 0); CMP(PVRTC_4RGBA, 0); CMP(PVRTCII_2, 0); CMP(PVRTCII_4, 0); CMP(ETC1, 0); #undef CMP OX_ASSERT(!"string2TextureFormat undefined format"); return TF_UNDEFINED; }
//////////////////////////////////////////////////// // Run! void Cpu::run(timestamp_t runto) { if(cpuJammed && (curCyc() < runto)) { setMainTimestamp(runto); } while( curCyc() < runto ) { ///////////////////////////////////// // Are we to take an interrupt if(wantInterrupt) { performInterrupt(false); continue; } if( *tracer ) tracer->traceCpuLine( cpu ); ///////////////////////////////////// // No interrupt, do an instruction u8 opcode = rd( cpu.PC++ ); switch(opcode) { /* Branches */ case 0x10: adBranch( !cpu.getN() ); break; /* BPL */ case 0x30: adBranch( cpu.getN() ); break; /* BMI */ case 0x50: adBranch( !cpu.getV() ); break; /* BVC */ case 0x70: adBranch( cpu.getV() ); break; /* BVS */ case 0x90: adBranch( !cpu.getC() ); break; /* BCC */ case 0xB0: adBranch( cpu.getC() ); break; /* BCS */ case 0xD0: adBranch( !cpu.getZ() ); break; /* BNE */ case 0xF0: adBranch( cpu.getZ() ); break; /* BEQ */ /* Flag flip-flop */ case 0x18: adImplied(); cpu.setC(0); break; /* CLC */ case 0x38: adImplied(); cpu.setC(1); break; /* SEC */ case 0x58: adImplied(); cpu.setI(0); break; /* CLI */ case 0x78: adImplied(); cpu.setI(1); break; /* SEI */ case 0xB8: adImplied(); cpu.setV(0); break; /* CLV */ case 0xD8: adImplied(); cpu.setD(0); break; /* CLD */ case 0xF8: adImplied(); cpu.setD(1); break; /* SED */ /* Stack push/pull */ case 0x08: adPush( cpu.getStatus(true) ); break; /* PHP */ case 0x28: cpu.setStatus( adPull() ); break; /* PLP */ case 0x48: adPush( cpu.A ); break; /* PHA */ case 0x68: cpu.NZ( cpu.A = adPull() ); break; /* PLA */ /* Reg Xfer */ case 0xAA: adImplied(); cpu.NZ( cpu.X = cpu.A ); break; /* TAX */ case 0xA8: adImplied(); cpu.NZ( cpu.Y = cpu.A ); break; /* TAY */ case 0xBA: adImplied(); cpu.NZ( cpu.X = cpu.SP ); break; /* TSX */ case 0x8A: adImplied(); cpu.NZ( cpu.A = cpu.X ); break; /* TXA */ case 0x9A: adImplied(); cpu.SP = cpu.X; break; /* TXS */ case 0x98: adImplied(); cpu.NZ( cpu.A = cpu.Y ); break; /* TYA */ /* Misc */ case 0x00: performInterrupt(true); break; /* BRK */ case 0x4C: full_JMP(); break; /* JMP $xxxx */ case 0x6C: full_JMP_Indirect(); break; /* JMP ($xxxx) */ case 0x20: full_JSR(); break; /* JSR $xxxx */ case 0xEA: adImplied(); break; /* NOP */ case 0x40: full_RTI(); break; /* RTI */ case 0x60: full_RTS(); break; /* RTS */ /* ADC */ case 0x69: ADC( adRdIm() ); break; case 0x65: ADC( adRdZp() ); break; case 0x75: ADC( adRdZx() ); break; case 0x6D: ADC( adRdAb() ); break; case 0x7D: ADC( adRdAx() ); break; case 0x79: ADC( adRdAy() ); break; case 0x61: ADC( adRdIx() ); break; case 0x71: ADC( adRdIy() ); break; /* AND */ case 0x29: AND( adRdIm() ); break; case 0x25: AND( adRdZp() ); break; case 0x35: AND( adRdZx() ); break; case 0x2D: AND( adRdAb() ); break; case 0x3D: AND( adRdAx() ); break; case 0x39: AND( adRdAy() ); break; case 0x21: AND( adRdIx() ); break; case 0x31: AND( adRdIy() ); break; /* ASL */ case 0x0A: adImplied(); ASL(cpu.A); break; case 0x06: adRWZp( &Cpu::ASL ); break; case 0x16: adRWZx( &Cpu::ASL ); break; case 0x0E: adRWAb( &Cpu::ASL ); break; case 0x1E: adRWAx( &Cpu::ASL ); break; /* BIT */ case 0x24: BIT( adRdZp() ); break; case 0x2C: BIT( adRdAb() ); break; /* CMP */ case 0xC9: CMP( adRdIm() ); break; case 0xC5: CMP( adRdZp() ); break; case 0xD5: CMP( adRdZx() ); break; case 0xCD: CMP( adRdAb() ); break; case 0xDD: CMP( adRdAx() ); break; case 0xD9: CMP( adRdAy() ); break; case 0xC1: CMP( adRdIx() ); break; case 0xD1: CMP( adRdIy() ); break; /* CPX */ case 0xE0: CPX( adRdIm() ); break; case 0xE4: CPX( adRdZp() ); break; case 0xEC: CPX( adRdAb() ); break; /* CPY */ case 0xC0: CPY( adRdIm() ); break; case 0xC4: CPY( adRdZp() ); break; case 0xCC: CPY( adRdAb() ); break; /* DEC */ case 0xCA: adImplied(); DEC(cpu.X); break; /* DEX */ case 0x88: adImplied(); DEC(cpu.Y); break; /* DEY */ case 0xC6: adRWZp( &Cpu::DEC ); break; case 0xD6: adRWZx( &Cpu::DEC ); break; case 0xCE: adRWAb( &Cpu::DEC ); break; case 0xDE: adRWAx( &Cpu::DEC ); break; /* EOR */ case 0x49: EOR( adRdIm() ); break; case 0x45: EOR( adRdZp() ); break; case 0x55: EOR( adRdZx() ); break; case 0x4D: EOR( adRdAb() ); break; case 0x5D: EOR( adRdAx() ); break; case 0x59: EOR( adRdAy() ); break; case 0x41: EOR( adRdIx() ); break; case 0x51: EOR( adRdIy() ); break; /* INC */ case 0xE8: adImplied(); INC(cpu.X); break; /* INX */ case 0xC8: adImplied(); INC(cpu.Y); break; /* INY */ case 0xE6: adRWZp( &Cpu::INC ); break; case 0xF6: adRWZx( &Cpu::INC ); break; case 0xEE: adRWAb( &Cpu::INC ); break; case 0xFE: adRWAx( &Cpu::INC ); break; /* LDA */ case 0xA9: cpu.NZ( cpu.A = adRdIm() ); break; case 0xA5: cpu.NZ( cpu.A = adRdZp() ); break; case 0xB5: cpu.NZ( cpu.A = adRdZx() ); break; case 0xAD: cpu.NZ( cpu.A = adRdAb() ); break; case 0xBD: cpu.NZ( cpu.A = adRdAx() ); break; case 0xB9: cpu.NZ( cpu.A = adRdAy() ); break; case 0xA1: cpu.NZ( cpu.A = adRdIx() ); break; case 0xB1: cpu.NZ( cpu.A = adRdIy() ); break; /* LDX */ case 0xA2: cpu.NZ( cpu.X = adRdIm() ); break; case 0xA6: cpu.NZ( cpu.X = adRdZp() ); break; case 0xB6: cpu.NZ( cpu.X = adRdZy() ); break; case 0xAE: cpu.NZ( cpu.X = adRdAb() ); break; case 0xBE: cpu.NZ( cpu.X = adRdAy() ); break; /* LDY */ case 0xA0: cpu.NZ( cpu.Y = adRdIm() ); break; case 0xA4: cpu.NZ( cpu.Y = adRdZp() ); break; case 0xB4: cpu.NZ( cpu.Y = adRdZx() ); break; case 0xAC: cpu.NZ( cpu.Y = adRdAb() ); break; case 0xBC: cpu.NZ( cpu.Y = adRdAx() ); break; /* LSR */ case 0x4A: adImplied(); LSR(cpu.A); break; case 0x46: adRWZp( &Cpu::LSR ); break; case 0x56: adRWZx( &Cpu::LSR ); break; case 0x4E: adRWAb( &Cpu::LSR ); break; case 0x5E: adRWAx( &Cpu::LSR ); break; /* ORA */ case 0x09: ORA( adRdIm() ); break; case 0x05: ORA( adRdZp() ); break; case 0x15: ORA( adRdZx() ); break; case 0x0D: ORA( adRdAb() ); break; case 0x1D: ORA( adRdAx() ); break; case 0x19: ORA( adRdAy() ); break; case 0x01: ORA( adRdIx() ); break; case 0x11: ORA( adRdIy() ); break; /* ROL */ case 0x2A: adImplied(); ROL(cpu.A); break; case 0x26: adRWZp( &Cpu::ROL ); break; case 0x36: adRWZx( &Cpu::ROL ); break; case 0x2E: adRWAb( &Cpu::ROL ); break; case 0x3E: adRWAx( &Cpu::ROL ); break; /* ROR */ case 0x6A: adImplied(); ROR(cpu.A); break; case 0x66: adRWZp( &Cpu::ROR ); break; case 0x76: adRWZx( &Cpu::ROR ); break; case 0x6E: adRWAb( &Cpu::ROR ); break; case 0x7E: adRWAx( &Cpu::ROR ); break; /* SBC */ case 0xE9: SBC( adRdIm() ); break; case 0xE5: SBC( adRdZp() ); break; case 0xF5: SBC( adRdZx() ); break; case 0xED: SBC( adRdAb() ); break; case 0xFD: SBC( adRdAx() ); break; case 0xF9: SBC( adRdAy() ); break; case 0xE1: SBC( adRdIx() ); break; case 0xF1: SBC( adRdIy() ); break; /* STA */ case 0x85: adWrZp( cpu.A ); break; case 0x95: adWrZx( cpu.A ); break; case 0x8D: adWrAb( cpu.A ); break; case 0x9D: adWrAx( cpu.A ); break; case 0x99: adWrAy( cpu.A ); break; case 0x81: adWrIx( cpu.A ); break; case 0x91: adWrIy( cpu.A ); break; /* STX */ case 0x86: adWrZp( cpu.X ); break; case 0x96: adWrZy( cpu.X ); break; case 0x8E: adWrAb( cpu.X ); break; /* STY */ case 0x84: adWrZp( cpu.Y ); break; case 0x94: adWrZx( cpu.Y ); break; case 0x8C: adWrAb( cpu.Y ); break; ///////////////////////////////////// // Unofficial ops /* One offs */ case 0x0B: case 0x2B: ANC( adRdIm() ); break; /* ANC */ case 0x4B: ALR( adRdIm() ); break; /* ALR */ case 0x6B: ARR( adRdIm() ); break; /* ARR */ case 0xCB: AXS( adRdIm() ); break; /* AXS */ case 0xBB: LAS( adRdAy() ); break; /* LAS */ case 0xEB: SBC( adRdIm() ); break; /* alternative SBC */ case 0x9E: adWrAy_xxx( cpu.X ); break; /* SHX */ case 0x9C: adWrAx_xxx( cpu.Y ); break; /* SHY */ case 0x8B: XAA( adRdIm() ); break; /* XAA */ case 0x9B: cpu.SP = cpu.A & cpu.X; adWrAy_xxx( cpu.SP ); break; /* TAS */ /* AHX */ case 0x9F: adWrAy_xxx( cpu.A & cpu.X ); break; case 0x93: adWrIy_xxx( cpu.A & cpu.X ); break; /* DCP */ case 0xC7: adRWZp( &Cpu::DCP ); break; case 0xD7: adRWZx( &Cpu::DCP ); break; case 0xCF: adRWAb( &Cpu::DCP ); break; case 0xDF: adRWAx( &Cpu::DCP ); break; case 0xDB: adRWAy( &Cpu::DCP ); break; case 0xC3: adRWIx( &Cpu::DCP ); break; case 0xD3: adRWIy( &Cpu::DCP ); break; /* ISC */ case 0xE7: adRWZp( &Cpu::ISC ); break; case 0xF7: adRWZx( &Cpu::ISC ); break; case 0xEF: adRWAb( &Cpu::ISC ); break; case 0xFF: adRWAx( &Cpu::ISC ); break; case 0xFB: adRWAy( &Cpu::ISC ); break; case 0xE3: adRWIx( &Cpu::ISC ); break; case 0xF3: adRWIy( &Cpu::ISC ); break; /* LAX */ case 0xAB: LAX( adRdIm() ); break; case 0xA7: LAX( adRdZp() ); break; case 0xB7: LAX( adRdZy() ); break; case 0xAF: LAX( adRdAb() ); break; case 0xBF: LAX( adRdAy() ); break; case 0xA3: LAX( adRdIx() ); break; case 0xB3: LAX( adRdIy() ); break; /* NOP */ case 0x1A: case 0x3A: case 0x5A: case 0x7A: case 0xDA: case 0xFA: adImplied();break; case 0x04: case 0x44: case 0x64: adRdZp(); break; case 0x14: case 0x34: case 0x54: case 0x74: case 0xD4: case 0xF4: adRdZx(); break; case 0x80: case 0x82: case 0x89: case 0xC2: case 0xE2: adRdIm(); break; case 0x0C: adRdAb(); break; case 0x1C: case 0x3C: case 0x5C: case 0x7C: case 0xDC: case 0xFC: adRdAx(); break; /* RLA */ case 0x27: adRWZp( &Cpu::RLA ); break; case 0x37: adRWZx( &Cpu::RLA ); break; case 0x2F: adRWAb( &Cpu::RLA ); break; case 0x3F: adRWAx( &Cpu::RLA ); break; case 0x3B: adRWAy( &Cpu::RLA ); break; case 0x23: adRWIx( &Cpu::RLA ); break; case 0x33: adRWIy( &Cpu::RLA ); break; /* RRA */ case 0x67: adRWZp( &Cpu::RRA ); break; case 0x77: adRWZx( &Cpu::RRA ); break; case 0x6F: adRWAb( &Cpu::RRA ); break; case 0x7F: adRWAx( &Cpu::RRA ); break; case 0x7B: adRWAy( &Cpu::RRA ); break; case 0x63: adRWIx( &Cpu::RRA ); break; case 0x73: adRWIy( &Cpu::RRA ); break; /* SAX */ case 0x87: adWrZp( cpu.A & cpu.X ); break; case 0x97: adWrZy( cpu.A & cpu.X ); break; case 0x8F: adWrAb( cpu.A & cpu.X ); break; case 0x83: adWrIx( cpu.A & cpu.X ); break; /* SLO */ case 0x07: adRWZp( &Cpu::SLO ); break; case 0x17: adRWZx( &Cpu::SLO ); break; case 0x0F: adRWAb( &Cpu::SLO ); break; case 0x1F: adRWAx( &Cpu::SLO ); break; case 0x1B: adRWAy( &Cpu::SLO ); break; case 0x03: adRWIx( &Cpu::SLO ); break; case 0x13: adRWIy( &Cpu::SLO ); break; /* SRE */ case 0x47: adRWZp( &Cpu::SRE ); break; case 0x57: adRWZx( &Cpu::SRE ); break; case 0x4F: adRWAb( &Cpu::SRE ); break; case 0x5F: adRWAx( &Cpu::SRE ); break; case 0x5B: adRWAy( &Cpu::SRE ); break; case 0x43: adRWIx( &Cpu::SRE ); break; case 0x53: adRWIy( &Cpu::SRE ); break; /* STP */ case 0x02: case 0x12: case 0x22: case 0x32: case 0x42: case 0x52: case 0x62: case 0x72: case 0x92: case 0xB2: case 0xD2: case 0xF2: cpuJammed = true; setMainTimestamp(runto); break; } } }
static void avx_test () { __m256d source1, source2, dest; int i; CMP(_CMP_EQ_OQ, !isunordered(s1[i], s2[i]) && s1[i] == s2[i]); CMP(_CMP_LT_OS, !isunordered(s1[i], s2[i]) && s1[i] < s2[i]); CMP(_CMP_LE_OS, !isunordered(s1[i], s2[i]) && s1[i] <= s2[i]); CMP(_CMP_UNORD_Q, isunordered(s1[i], s2[i])); CMP(_CMP_NEQ_UQ, isunordered(s1[i], s2[i]) || s1[i] != s2[i]); CMP(_CMP_NLT_US, isunordered(s1[i], s2[i]) || s1[i] >= s2[i]); CMP(_CMP_NLE_US, isunordered(s1[i], s2[i]) || s1[i] > s2[i]); CMP(_CMP_ORD_Q, !isunordered(s1[i], s2[i])); CMP(_CMP_EQ_UQ, isunordered(s1[i], s2[i]) || s1[i] == s2[i]); CMP(_CMP_NGE_US, isunordered(s1[i], s2[i]) || s1[i] < s2[i]); CMP(_CMP_NGT_US, isunordered(s1[i], s2[i]) || s1[i] <= s2[i]); CMP(_CMP_FALSE_OQ, 0); CMP(_CMP_NEQ_OQ, !isunordered(s1[i], s2[i]) && s1[i] != s2[i]); CMP(_CMP_GE_OS, !isunordered(s1[i], s2[i]) && s1[i] >= s2[i]); CMP(_CMP_GT_OS, !isunordered(s1[i], s2[i]) && s1[i] > s2[i]); CMP(_CMP_TRUE_UQ, 1); CMP(_CMP_EQ_OS, !isunordered(s1[i], s2[i]) && s1[i] == s2[i]); CMP(_CMP_LT_OQ, !isunordered(s1[i], s2[i]) && s1[i] < s2[i]); CMP(_CMP_LE_OQ, !isunordered(s1[i], s2[i]) && s1[i] <= s2[i]); CMP(_CMP_UNORD_S, isunordered(s1[i], s2[i])); CMP(_CMP_NEQ_US, isunordered(s1[i], s2[i]) || s1[i] != s2[i]); CMP(_CMP_NLT_UQ, isunordered(s1[i], s2[i]) || s1[i] >= s2[i]); CMP(_CMP_NLE_UQ, isunordered(s1[i], s2[i]) || s1[i] > s2[i]); CMP(_CMP_ORD_S, !isunordered(s1[i], s2[i])); CMP(_CMP_EQ_US, isunordered(s1[i], s2[i]) || s1[i] == s2[i]); CMP(_CMP_NGE_UQ, isunordered(s1[i], s2[i]) || s1[i] < s2[i]); CMP(_CMP_NGT_UQ, isunordered(s1[i], s2[i]) || s1[i] <= s2[i]); CMP(_CMP_FALSE_OS, 0); CMP(_CMP_NEQ_OS, !isunordered(s1[i], s2[i]) && s1[i] != s2[i]); CMP(_CMP_GE_OQ, !isunordered(s1[i], s2[i]) && s1[i] >= s2[i]); CMP(_CMP_GT_OQ, !isunordered(s1[i], s2[i]) && s1[i] > s2[i]); CMP(_CMP_TRUE_US, 1); }
void Jit::Comp_FPU2op(u32 op) { CONDITIONAL_DISABLE; int fs = _FS; int fd = _FD; // logBlocks = 1; switch (op & 0x3f) { case 4: //F(fd) = sqrtf(F(fs)); break; //sqrt fpr.MapDirtyIn(fd, fs); VSQRT(fpr.R(fd), fpr.R(fs)); break; case 5: //F(fd) = fabsf(F(fs)); break; //abs fpr.MapDirtyIn(fd, fs); VABS(fpr.R(fd), fpr.R(fs)); break; case 6: //F(fd) = F(fs); break; //mov fpr.MapDirtyIn(fd, fs); VMOV(fpr.R(fd), fpr.R(fs)); break; case 7: //F(fd) = -F(fs); break; //neg fpr.MapDirtyIn(fd, fs); VNEG(fpr.R(fd), fpr.R(fs)); break; case 12: //FsI(fd) = (int)floorf(F(fs)+0.5f); break; //round.w.s fpr.MapDirtyIn(fd, fs); VCVT(fpr.R(fd), fpr.R(fs), TO_INT | IS_SIGNED); break; case 13: //FsI(fd) = Rto0(F(fs))); break; //trunc.w.s fpr.MapDirtyIn(fd, fs); VCVT(fpr.R(fd), fpr.R(fs), TO_INT | IS_SIGNED | ROUND_TO_ZERO); break; case 14: //FsI(fd) = (int)ceilf (F(fs)); break; //ceil.w.s fpr.MapDirtyIn(fd, fs); MOVI2F(S0, 0.5f, R0); VADD(S0,fpr.R(fs),S0); VCVT(fpr.R(fd), S0, TO_INT | IS_SIGNED); break; case 15: //FsI(fd) = (int)floorf(F(fs)); break; //floor.w.s fpr.MapDirtyIn(fd, fs); MOVI2F(S0, 0.5f, R0); VSUB(S0,fpr.R(fs),S0); VCVT(fpr.R(fd), S0, TO_INT | IS_SIGNED); break; case 32: //F(fd) = (float)FsI(fs); break; //cvt.s.w fpr.MapDirtyIn(fd, fs); VCVT(fpr.R(fd), fpr.R(fs), TO_FLOAT | IS_SIGNED); break; case 36: //FsI(fd) = (int) F(fs); break; //cvt.w.s fpr.MapDirtyIn(fd, fs); LDR(R0, CTXREG, offsetof(MIPSState, fcr31)); AND(R0, R0, Operand2(3)); // MIPS Rounding Mode: // 0: Round nearest // 1: Round to zero // 2: Round up (ceil) // 3: Round down (floor) CMP(R0, Operand2(2)); SetCC(CC_GE); MOVI2F(S0, 0.5f, R1); SetCC(CC_GT); VSUB(S0,fpr.R(fs),S0); SetCC(CC_EQ); VADD(S0,fpr.R(fs),S0); SetCC(CC_GE); VCVT(fpr.R(fd), S0, TO_INT | IS_SIGNED); /* 2,3 */ SetCC(CC_AL); CMP(R0, Operand2(1)); SetCC(CC_EQ); VCVT(fpr.R(fd), fpr.R(fs), TO_INT | IS_SIGNED | ROUND_TO_ZERO); /* 1 */ SetCC(CC_LT); VCVT(fpr.R(fd), fpr.R(fs), TO_INT | IS_SIGNED); /* 0 */ SetCC(CC_AL); break; default: DISABLE; } }
int main() { int op; uint32_t registro[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; char banderas[4]; do{ system("cls"); printf("seleccione la opcion 1 para mostrar los valores de los registros\n"); printf("seleccione la opcion 2 para sumar registros \n"); printf("seleccione la opcion 3 para multiplicacion logica (AND) de registros \n"); printf("seleccione la opcion 4 para Eor a nivel de bits \n"); printf("seleccione la opcion 5 para desplazar de un registro a otro \n"); printf("seleccione la opcion 6 para suma logica (OR) de registro\n"); printf("seleccione la opcion 7 para ADN sin almacenar, solo modifica banderas \n"); printf("seleccione la opcion 8 para comparar (SUB sin almacenar), solo modifica banderas\n"); printf("seleccione la opcion 9 Multiplicacion de registros, solo se alacenan 32 bits menos significativos\n"); printf("seleccione la opcion 10 AND sin almacenacmiento, solo modifica banderas\n"); printf("seleccione la opcion 11 para LSL desplazamiento logico a la izquierda \n"); printf("seleccione la opcion 12 para LSR desplazamiento logico a la derecha \n"); printf("seleccione la opcion 13 para ROR rotacion a la derecha \n"); printf("seleccione la opcion 14 para ASR desplazamiento aritmetico a la derecha \n"); printf("seleccione la opcion 15 para BIC Realiza una AND de un registro con otro negado \n"); printf("seleccione la opcion 16 para MUN guarda en un registro la negacion de otro\n"); printf("seleccione la opcion 17 para RSB niega un valor de registro\n"); printf("seleccione la opcion 18 para NOP da un retardo de un ciclo de reloj (no hace nada) \n"); printf("seleccione la opcion 19 para REV toma grupos de 8 bits y los desplaza \n"); printf("seleccione la opcion 20 para REVIG toma grupos de 16 bits y los agrupa en grupos de dos bytes\n"); printf("seleccione la opcion 21 para REVSH extencion con signo\n\n"); scanf("%d",&op); system("cls"); switch(op){ case 1: //mostrar_valores(registro); break; case 2: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); ADD(registro,®istro[0],registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 3: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); AND(registro,®istro[0],registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 4: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); EOR(registro,®istro[0],registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 5: printf("ingrese el valor del registro origen:\n"); scanf("%d",®istro[1]); MOV(registro,®istro[0],registro[1],banderas); printf("%d valor del resultado \n",registro[0]); break; case 7: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); CMN(registro,registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 8: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); CMP(registro,registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 9: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); MUL(registro,®istro[0],registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 10: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[2]); TST(registro,registro[1],registro[2],&banderas[0]); printf("%d valor del resultado \n",registro[0]); printf("%d valor del resultado bandera n \n",banderas[N]); printf("%d valor del resultado bandera z \n",banderas[Z]); printf("%d valor del resultado bandera c \n",banderas[C]); printf("%d valor del resultado bandera v \n",banderas[V]); break; case 11: printf("ingrese el valor del registro:\n"); scanf("%d",®istro[1]); printf("ingrese el numero de desplazamientos:\n"); scanf("%d",®istro[2]); LSL(registro,®istro[0],registro[1],registro[2],banderas); printf("%d valor del resultado \n",registro[0]); break; case 12: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese elnumero de desplazamientos:\n"); scanf("%d",®istro[2]); LSR(registro,®istro[0],registro[1],registro[2],banderas); printf("%d valor del resultado \n",registro[0]); break; case 13: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese elnumero de desplazamientos:\n"); scanf("%d",®istro[2]); ROR(registro,®istro[0],registro[1],registro[2],banderas); printf("%d valor del resultado \n",registro[0]); break; case 14: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[1]); printf("ingrese elnumero de desplazamientos:\n"); scanf("%d",®istro[2]); ASR(registro,®istro[0],registro[1],registro[2],banderas); printf("%d valor del resultado \n",registro[0]); break; case 15: printf("ingrese el valor del primer registro:\n"); scanf("%d",®istro[0]); printf("ingrese el valor del segundo registro:\n"); scanf("%d",®istro[1]); BIC(registro,®istro[0],registro[1],banderas); printf("%d valor del resultado \n",registro[0]); break; case 16: printf("ingrese un valor del registro origen\n"); scanf("%d",®istro[1]); MVN(registro,®istro[0],registro[1],banderas); printf("%d valor del resultado \n",registro[0]); break; case 17: printf("ingrese un valor de registro\n"); scanf("%d",®istro[1]); RSB(registro,®istro[0],registro[1],0,banderas); printf("%d valor del resultado \n",registro[0]); break; case 18: NOP(registro); break; case 19: printf("ingrese un valor de registro \n"); scanf("%d",®istro[0]); REV(registro,®istro[0]); printf("%d valor del resultado \n",registro[0]); break; case 20: printf("ingrese un valor de registro \n"); scanf("%d",®istro[0]); REVIG(registro,®istro[0]); printf("%d valor del resultado \n",registro[0]); break; case 21: printf("ingrese un valor de registro \n"); scanf("%d",®istro[0]); REVSH(registro,®istro[0]); printf("%d valor del resultado \n",registro[0]); break; default: printf("Opcion invalida\n\n"); break; } printf("\nDesea realizar otra operacion?\n<1>-si\n<0>-no\n"); scanf("%d",&op); system("cls"); }while(op); return 0; }
#ifdef SUPPORT_UCP if (common->use_ucp) { OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1); jump = CMP(SLJIT_C_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE); add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL)); OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll); OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll); OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_UNUSED, 0, SLJIT_C_LESS_EQUAL); OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll); OP2(SLJIT_SUB | SLJIT_SET_U, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd); OP_FLAGS(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_C_LESS_EQUAL); JUMPHERE(jump); } else #endif { #ifndef COMPILE_PCRE8 /* TMP2 may be destroyed by peek_char. */ OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0); jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255); #elif defined SUPPORT_UTF OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0); jump = NULL; if (common->utf) jump = CMP(SLJIT_C_GREATER, TMP1, 0, SLJIT_IMM, 255); #endif OP1(SLJIT_MOV_UB, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes); OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */); OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1); #ifndef COMPILE_PCRE8