Method dynamic_arith_value_lock

source/emulation/cpu/armv8/jitArmV8CodeGen.cpp:5959–6004

}

void JitArmV8CodeGen::dynamic_arith_value_lock(JitWidth width, DecodedOp* op, U32 value, LazyFlagType flagsType, std::function<void(RegPtr src, RegPtr dst, RegPtr address)> atomicCallback, std::function<void(RegPtr result, RegPtr dst, U32 src)> callback) {
    JitCodeGen::write(width, calculateEaa(op), nullptr, [value, atomicCallback, width, flagsType, op, callback, this](MemPtr mem) {
        RegPtr address = calculateAddress(mem);
        const LazyFlags* flags = lazyFlags[flagsType];        
        JitFlags flagData(this, cpu, op, flagsType, value, nullptr);

        RegPtr dst = getTmpReg();
        RegPtr result = getTmpReg();
        
#ifdef BOXEDWINE_HOST_EXCEPTIONS
        if (rt.cpu_features().has(asmjit::CpuFeatures::ARM::kLSE)) {
            RegPtr reg = loadConst(value);
            atomicCallback(reg, dst, address);
            if (flags && flags->usesResult(flagData.needsToSetFlags)) {
                callback(result, dst, value);
            }
        } else 
#endif
        if (rt.cpu_features().has(asmjit::CpuFeatures::ARM::kLSE)) {
            Label label = compiler.new_label();
            RegPtr cond = getTmpReg();
            RegPtr prvMemSrc = getTmpReg();

            readHost(width, createMemPtr(address, 0), dst, false);

            compiler.bind(label);

            compiler.mov(R32(prvMemSrc), R32(dst));
            callback(result, dst, value);
            casal(width, R32(dst), R32(result), Mem(R64(address)));
            compiler.sub(R32(cond), R32(dst), R32(prvMemSrc));
            compiler.cbnz(R32(cond), label);
            dst = prvMemSrc;
        } else {
            Label label = compiler.new_label();
            RegPtr cond = getTmpReg();

            compiler.bind(label);
            ldaxr(width, R32(dst), Mem(R64(address)));
            callback(result, dst, value);
            stlxr(width, R32(cond), R32(result), Mem(R64(address)));
            compiler.cbnz(R32(cond), label);
        }
        flagData.commit(result, dst);
    });
}
void JitArmV8CodeGen::dynamic_xaddr32e32_lock(DecodedOp* op) {
    dynamic_arith_lock(JitWidth::b32, op, FLAGS_ADD32, [this](RegPtr src, RegPtr dst, RegPtr address) {
        compiler.ldaddal(R32(src), R32(dst), Mem(R64(address)));