自学教程：C++ HELPER_LOG函数代码示例

/* compare unsigned byte arrays */uint32_t HELPER(clc)(CPUS390XState *env, uint32_t l, uint64_t s1, uint64_t s2){    int i;    unsigned char x, y;    uint32_t cc;    HELPER_LOG("%s l %d s1 %" PRIx64 " s2 %" PRIx64 "/n",               __func__, l, s1, s2);    for (i = 0; i <= l; i++) {        x = cpu_ldub_data(env, s1 + i);        y = cpu_ldub_data(env, s2 + i);        HELPER_LOG("%02x (%c)/%02x (%c) ", x, x, y, y);        if (x < y) {            cc = 1;            goto done;        } else if (x > y) {            cc = 2;            goto done;        }    }    cc = 0; done:    HELPER_LOG("/n");    return cc;}

/* xor on array */uint32_t HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest,                    uint64_t src){    int i;    unsigned char x;    uint32_t cc = 0;    HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "/n",               __func__, l, dest, src);#ifndef CONFIG_USER_ONLY    /* xor with itself is the same as memset(0) */    if ((l > 32) && (src == dest) &&            (src & TARGET_PAGE_MASK) == ((src + l) & TARGET_PAGE_MASK)) {        mvc_fast_memset(env, l + 1, dest, 0);        return 0;    }#else    if (src == dest) {        memset(g2h(dest), 0, l + 1);        return 0;    }#endif    for (i = 0; i <= l; i++) {        x = cpu_ldub_data(env, dest + i) ^ cpu_ldub_data(env, src + i);        if (x) {            cc = 1;        }        cpu_stb_data(env, dest + i, x);    }    return cc;}

/* 64-bit FP multiply and subtract RR */void HELPER(msdbr)(CPUS390XState *env, uint32_t f1, uint32_t f3, uint32_t f2){    HELPER_LOG("%s: f1 %d f2 %d f3 %d/n", __func__, f1, f2, f3);    env->fregs[f1].d = float64_sub(float64_mul(env->fregs[f2].d,                                               env->fregs[f3].d,                                               &env->fpu_status),                                   env->fregs[f1].d, &env->fpu_status);}

/* Raise an exception statically from a TB.  */void HELPER(exception)(CPUS390XState *env, uint32_t excp){    CPUState *cs = CPU(s390_env_get_cpu(env));    HELPER_LOG("%s: exception %d/n", __func__, excp);    cs->exception_index = excp;    cpu_loop_exit(cs);}

/* Set Prefix */void HELPER(spx)(CPUS390XState *env, uint64_t a1){    CPUState *cs = CPU(s390_env_get_cpu(env));    uint32_t prefix = a1 & 0x7fffe000;    env->psa = prefix;    HELPER_LOG("prefix: %#x/n", prefix);    tlb_flush_page(cs, 0);    tlb_flush_page(cs, TARGET_PAGE_SIZE);}

/* absolute value 64-bit */uint64_t HELPER(abs_i64)(int64_t val){    HELPER_LOG("%s: val 0x%" PRIx64 "/n", __func__, val);    if (val < 0) {        return -val;    } else {        return val;    }}

uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1,                      uint64_t cpu_addr){    int cc = 0;    HELPER_LOG("%s: %016" PRIx64 " %08x %016" PRIx64 "/n",               __func__, order_code, r1, cpu_addr);    /* Remember: Use "R1 or R1 + 1, whichever is the odd-numbered register"       as parameter (input). Status (output) is always R1. */    switch (order_code) {    case SIGP_SET_ARCH:        /* switch arch */        break;    case SIGP_SENSE:        /* enumerate CPU status */        if (cpu_addr) {            /* XXX implement when SMP comes */            return 3;        }        env->regs[r1] &= 0xffffffff00000000ULL;        cc = 1;        break;#if !defined(CONFIG_USER_ONLY)    case SIGP_RESTART:        qemu_system_reset_request();        cpu_loop_exit(env);        break;    case SIGP_STOP:        qemu_system_shutdown_request();        cpu_loop_exit(env);        break;#endif    default:        /* unknown sigp */        fprintf(stderr, "XXX unknown sigp: 0x%" PRIx64 "/n", order_code);        cc = 3;    }    return cc;}

void HELPER(sacf)(CPUS390XState *env, uint64_t a1){    HELPER_LOG("%s: %16" PRIx64 "/n", __func__, a1);    switch (a1 & 0xf00) {    case 0x000:        env->psw.mask &= ~PSW_MASK_ASC;        env->psw.mask |= PSW_ASC_PRIMARY;        break;    case 0x100:        env->psw.mask &= ~PSW_MASK_ASC;        env->psw.mask |= PSW_ASC_SECONDARY;        break;    case 0x300:        env->psw.mask &= ~PSW_MASK_ASC;        env->psw.mask |= PSW_ASC_HOME;        break;    default:        qemu_log("unknown sacf mode: %" PRIx64 "/n", a1);        program_interrupt(env, PGM_SPECIFICATION, 2);        break;    }}

//.........这里部分代码省略.........        break;    case CC_OP_LTUGTU_64:        r =  cc_calc_ltugtu_64(src, dst);        break;    case CC_OP_TM_32:        r =  cc_calc_tm_32(src, dst);        break;    case CC_OP_TM_64:        r =  cc_calc_tm_64(src, dst);        break;    case CC_OP_NZ:        r =  cc_calc_nz(dst);        break;    case CC_OP_ADD_64:        r =  cc_calc_add_64(src, dst, vr);        break;    case CC_OP_ADDU_64:        r =  cc_calc_addu_64(src, dst, vr);        break;    case CC_OP_ADDC_64:        r =  cc_calc_addc_64(src, dst, vr);        break;    case CC_OP_SUB_64:        r =  cc_calc_sub_64(src, dst, vr);        break;    case CC_OP_SUBU_64:        r =  cc_calc_subu_64(src, dst, vr);        break;    case CC_OP_SUBB_64:        r =  cc_calc_subb_64(src, dst, vr);        break;    case CC_OP_ABS_64:        r =  cc_calc_abs_64(dst);        break;    case CC_OP_NABS_64:        r =  cc_calc_nabs_64(dst);        break;    case CC_OP_COMP_64:        r =  cc_calc_comp_64(dst);        break;    case CC_OP_ADD_32:        r =  cc_calc_add_32(src, dst, vr);        break;    case CC_OP_ADDU_32:        r =  cc_calc_addu_32(src, dst, vr);        break;    case CC_OP_ADDC_32:        r =  cc_calc_addc_32(src, dst, vr);        break;    case CC_OP_SUB_32:        r =  cc_calc_sub_32(src, dst, vr);        break;    case CC_OP_SUBU_32:        r =  cc_calc_subu_32(src, dst, vr);        break;    case CC_OP_SUBB_32:        r =  cc_calc_subb_32(src, dst, vr);        break;    case CC_OP_ABS_32:        r =  cc_calc_abs_32(dst);        break;    case CC_OP_NABS_32:        r =  cc_calc_nabs_32(dst);        break;    case CC_OP_COMP_32:        r =  cc_calc_comp_32(dst);        break;    case CC_OP_ICM:        r =  cc_calc_icm(src, dst);        break;    case CC_OP_SLA_32:        r =  cc_calc_sla_32(src, dst);        break;    case CC_OP_SLA_64:        r =  cc_calc_sla_64(src, dst);        break;    case CC_OP_FLOGR:        r = cc_calc_flogr(dst);        break;    case CC_OP_NZ_F32:        r = set_cc_nz_f32(dst);        break;    case CC_OP_NZ_F64:        r = set_cc_nz_f64(dst);        break;    case CC_OP_NZ_F128:        r = set_cc_nz_f128(make_float128(src, dst));        break;    default:        cpu_abort(CPU(cpu), "Unknown CC operation: %s/n", cc_name(cc_op));    }    HELPER_LOG("%s: %15s 0x%016lx 0x%016lx 0x%016lx = %d/n", __func__,               cc_name(cc_op), src, dst, vr, r);    return r;}