1 /* 2 * S/390 CPU dump to FILE 3 * 4 * Copyright (c) 2009 Ulrich Hecht 5 * Copyright (c) 2011 Alexander Graf 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 19 * 20 */ 21 22 #include "qemu/osdep.h" 23 #include "cpu.h" 24 #include "s390x-internal.h" 25 #include "qemu/qemu-print.h" 26 #include "sysemu/tcg.h" 27 28 void s390_cpu_dump_state(CPUState *cs, FILE *f, int flags) 29 { 30 S390CPU *cpu = S390_CPU(cs); 31 CPUS390XState *env = &cpu->env; 32 int i; 33 34 qemu_fprintf(f, "PSW=mask %016" PRIx64 " addr %016" PRIx64, 35 s390_cpu_get_psw_mask(env), env->psw.addr); 36 if (!tcg_enabled()) { 37 qemu_fprintf(f, "\n"); 38 } else if (env->cc_op > 3) { 39 qemu_fprintf(f, " cc %15s\n", cc_name(env->cc_op)); 40 } else { 41 qemu_fprintf(f, " cc %02x\n", env->cc_op); 42 } 43 44 for (i = 0; i < 16; i++) { 45 qemu_fprintf(f, "R%02d=%016" PRIx64, i, env->regs[i]); 46 if ((i % 4) == 3) { 47 qemu_fprintf(f, "\n"); 48 } else { 49 qemu_fprintf(f, " "); 50 } 51 } 52 53 if (flags & CPU_DUMP_FPU) { 54 if (s390_has_feat(S390_FEAT_VECTOR)) { 55 for (i = 0; i < 32; i++) { 56 qemu_fprintf(f, "V%02d=%016" PRIx64 "%016" PRIx64 "%c", 57 i, env->vregs[i][0], env->vregs[i][1], 58 i % 2 ? '\n' : ' '); 59 } 60 } else { 61 for (i = 0; i < 16; i++) { 62 qemu_fprintf(f, "F%02d=%016" PRIx64 "%c", 63 i, *get_freg(env, i), 64 (i % 4) == 3 ? '\n' : ' '); 65 } 66 } 67 } 68 69 #ifndef CONFIG_USER_ONLY 70 for (i = 0; i < 16; i++) { 71 qemu_fprintf(f, "C%02d=%016" PRIx64, i, env->cregs[i]); 72 if ((i % 4) == 3) { 73 qemu_fprintf(f, "\n"); 74 } else { 75 qemu_fprintf(f, " "); 76 } 77 } 78 #endif 79 80 #ifdef DEBUG_INLINE_BRANCHES 81 for (i = 0; i < CC_OP_MAX; i++) { 82 qemu_fprintf(f, " %15s = %10ld\t%10ld\n", cc_name(i), 83 inline_branch_miss[i], inline_branch_hit[i]); 84 } 85 #endif 86 87 qemu_fprintf(f, "\n"); 88 } 89 90 const char *cc_name(enum cc_op cc_op) 91 { 92 static const char * const cc_names[] = { 93 [CC_OP_CONST0] = "CC_OP_CONST0", 94 [CC_OP_CONST1] = "CC_OP_CONST1", 95 [CC_OP_CONST2] = "CC_OP_CONST2", 96 [CC_OP_CONST3] = "CC_OP_CONST3", 97 [CC_OP_DYNAMIC] = "CC_OP_DYNAMIC", 98 [CC_OP_STATIC] = "CC_OP_STATIC", 99 [CC_OP_NZ] = "CC_OP_NZ", 100 [CC_OP_ADDU] = "CC_OP_ADDU", 101 [CC_OP_SUBU] = "CC_OP_SUBU", 102 [CC_OP_LTGT_32] = "CC_OP_LTGT_32", 103 [CC_OP_LTGT_64] = "CC_OP_LTGT_64", 104 [CC_OP_LTUGTU_32] = "CC_OP_LTUGTU_32", 105 [CC_OP_LTUGTU_64] = "CC_OP_LTUGTU_64", 106 [CC_OP_LTGT0_32] = "CC_OP_LTGT0_32", 107 [CC_OP_LTGT0_64] = "CC_OP_LTGT0_64", 108 [CC_OP_ADD_64] = "CC_OP_ADD_64", 109 [CC_OP_SUB_64] = "CC_OP_SUB_64", 110 [CC_OP_ABS_64] = "CC_OP_ABS_64", 111 [CC_OP_NABS_64] = "CC_OP_NABS_64", 112 [CC_OP_ADD_32] = "CC_OP_ADD_32", 113 [CC_OP_SUB_32] = "CC_OP_SUB_32", 114 [CC_OP_ABS_32] = "CC_OP_ABS_32", 115 [CC_OP_NABS_32] = "CC_OP_NABS_32", 116 [CC_OP_COMP_32] = "CC_OP_COMP_32", 117 [CC_OP_COMP_64] = "CC_OP_COMP_64", 118 [CC_OP_TM_32] = "CC_OP_TM_32", 119 [CC_OP_TM_64] = "CC_OP_TM_64", 120 [CC_OP_NZ_F32] = "CC_OP_NZ_F32", 121 [CC_OP_NZ_F64] = "CC_OP_NZ_F64", 122 [CC_OP_NZ_F128] = "CC_OP_NZ_F128", 123 [CC_OP_ICM] = "CC_OP_ICM", 124 [CC_OP_SLA] = "CC_OP_SLA", 125 [CC_OP_FLOGR] = "CC_OP_FLOGR", 126 [CC_OP_LCBB] = "CC_OP_LCBB", 127 [CC_OP_VC] = "CC_OP_VC", 128 [CC_OP_MULS_32] = "CC_OP_MULS_32", 129 [CC_OP_MULS_64] = "CC_OP_MULS_64", 130 }; 131 132 return cc_names[cc_op]; 133 } 134