From nobody Tue Feb 10 13:01:42 2026 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1524251779223230.7373825299095; Fri, 20 Apr 2018 12:16:19 -0700 (PDT) Received: from localhost ([::1]:53960 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1f9bVs-0006Wv-3V for importer@patchew.org; Fri, 20 Apr 2018 15:16:04 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:60652) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1f9bBx-0005fc-Bd for qemu-devel@nongnu.org; Fri, 20 Apr 2018 14:55:34 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1f9bBq-000214-DH for qemu-devel@nongnu.org; Fri, 20 Apr 2018 14:55:29 -0400 Received: from out3-smtp.messagingengine.com ([66.111.4.27]:45467) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1f9bBq-00020Q-3z; Fri, 20 Apr 2018 14:55:22 -0400 Received: from compute4.internal (compute4.nyi.internal [10.202.2.44]) by mailout.nyi.internal (Postfix) with ESMTP id 6FA7D21D37; Fri, 20 Apr 2018 14:55:21 -0400 (EDT) Received: from mailfrontend2 ([10.202.2.163]) by compute4.internal (MEProxy); Fri, 20 Apr 2018 14:55:21 -0400 Received: from localhost (flamenco.cs.columbia.edu [128.59.20.216]) by mail.messagingengine.com (Postfix) with ESMTPA id 194F510256; Fri, 20 Apr 2018 14:55:21 -0400 (EDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=braap.org; h=cc :date:from:in-reply-to:message-id:references:subject:to :x-me-sender:x-me-sender:x-sasl-enc; s=mesmtp; bh=f83m1HBSVtpd6j 4/Tv8vk497d0oaX1jTlPfkiPYDNxQ=; b=LGOn5XgHFTkx2LN8C7hqSWlEW680yV nSB9qSrlIQBkXdtOJEGf+LsvVN1A3O2fUViK2aNrbSjK/gthU5Zce/EZl/geBNLc JoZ0zfePvnahP5JeQYUxDIatfaJaILyU4XThuFo6oHe8n8n5lGcyuor9QiFfA17S w+ocpLzUTawOM= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:date:from:in-reply-to:message-id :references:subject:to:x-me-sender:x-me-sender:x-sasl-enc; s= fm2; bh=f83m1HBSVtpd6j4/Tv8vk497d0oaX1jTlPfkiPYDNxQ=; b=dd95MIqq gKnr/GzTFGX5VKX7mhbZXTMkVpwGj0MahsTEL95c0ZmFxQyq+CiQVf+3u4Oe/THe kbdyL/GZjpbgA6Ym2x1fBoQiX2QHyhSNH3f6E24WNlpF8UFbz807pyLS3FvlZ0aA 4O0NcqsoDT/MqiXsHOKimbQQH8mcEaJC8EOOzvYfQhBkcurqkMvh37tZ6axwscgM eYVSg9lLfDQreLG6uUG2t/EJQ2NTkBsU7pwE6YJ5IQJk1f0ag0PQeVgkigd5FspC bo8CJwUYhBpuDvCoefuuDElzRmdPLNd4gXyYwrkcKyC4fyvCNnxOFXAgJ6gR+70Q /fRMyg3Dt+9jqg== X-ME-Sender: From: "Emilio G. Cota" To: qemu-devel@nongnu.org Date: Fri, 20 Apr 2018 14:55:11 -0400 Message-Id: <1524250517-28032-13-git-send-email-cota@braap.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1524250517-28032-1-git-send-email-cota@braap.org> References: <1524250517-28032-1-git-send-email-cota@braap.org> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] [fuzzy] X-Received-From: 66.111.4.27 Subject: [Qemu-devel] [PATCH 12/18] target/s390x: convert to DisasContextBase X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: qemu-s390x@nongnu.org, Cornelia Huck , Richard Henderson , Alexander Graf , David Hildenbrand Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Notes: - Did not convert {num,max}_insns and is_jmp, since the corresponding code will go away in the next patch. - Avoided a checkpatch error in use_exit_tb. - As suggested by David, (1) Drop ctx.pc and use ctx.base.pc_next instead, and (2) Rename ctx.next_pc to ctx.pc_tmp and add a comment about it. Acked-by: Cornelia Huck Suggested-by: David Hildenbrand Reviewed-by: David Hildenbrand Reviewed-by: Richard Henderson Cc: David Hildenbrand Cc: Cornelia Huck Cc: Alexander Graf Cc: qemu-s390x@nongnu.org Signed-off-by: Emilio G. Cota --- target/s390x/translate.c | 148 ++++++++++++++++++++++++-------------------= ---- 1 file changed, 76 insertions(+), 72 deletions(-) diff --git a/target/s390x/translate.c b/target/s390x/translate.c index d08c109..5094128 100644 --- a/target/s390x/translate.c +++ b/target/s390x/translate.c @@ -52,14 +52,18 @@ typedef struct DisasInsn DisasInsn; typedef struct DisasFields DisasFields; =20 struct DisasContext { - struct TranslationBlock *tb; + DisasContextBase base; const DisasInsn *insn; DisasFields *fields; uint64_t ex_value; - uint64_t pc, next_pc; + /* + * During translate_one(), pc_tmp is used to determine the instruction + * to be executed after base.pc_next - e.g. next sequential instruction + * or a branch target. + */ + uint64_t pc_tmp; uint32_t ilen; enum cc_op cc_op; - bool singlestep_enabled; }; =20 /* Information carried about a condition to be evaluated. */ @@ -81,8 +85,8 @@ static uint64_t inline_branch_miss[CC_OP_MAX]; =20 static uint64_t pc_to_link_info(DisasContext *s, uint64_t pc) { - if (!(s->tb->flags & FLAG_MASK_64)) { - if (s->tb->flags & FLAG_MASK_32) { + if (!(s->base.tb->flags & FLAG_MASK_64)) { + if (s->base.tb->flags & FLAG_MASK_32) { return pc | 0x80000000; } } @@ -188,16 +192,16 @@ static void return_low128(TCGv_i64 dest) static void update_psw_addr(DisasContext *s) { /* psw.addr */ - tcg_gen_movi_i64(psw_addr, s->pc); + tcg_gen_movi_i64(psw_addr, s->base.pc_next); } =20 static void per_branch(DisasContext *s, bool to_next) { #ifndef CONFIG_USER_ONLY - tcg_gen_movi_i64(gbea, s->pc); + tcg_gen_movi_i64(gbea, s->base.pc_next); =20 - if (s->tb->flags & FLAG_MASK_PER) { - TCGv_i64 next_pc =3D to_next ? tcg_const_i64(s->next_pc) : psw_add= r; + if (s->base.tb->flags & FLAG_MASK_PER) { + TCGv_i64 next_pc =3D to_next ? tcg_const_i64(s->pc_tmp) : psw_addr; gen_helper_per_branch(cpu_env, gbea, next_pc); if (to_next) { tcg_temp_free_i64(next_pc); @@ -210,16 +214,16 @@ static void per_branch_cond(DisasContext *s, TCGCond = cond, TCGv_i64 arg1, TCGv_i64 arg2) { #ifndef CONFIG_USER_ONLY - if (s->tb->flags & FLAG_MASK_PER) { + if (s->base.tb->flags & FLAG_MASK_PER) { TCGLabel *lab =3D gen_new_label(); tcg_gen_brcond_i64(tcg_invert_cond(cond), arg1, arg2, lab); =20 - tcg_gen_movi_i64(gbea, s->pc); + tcg_gen_movi_i64(gbea, s->base.pc_next); gen_helper_per_branch(cpu_env, gbea, psw_addr); =20 gen_set_label(lab); } else { - TCGv_i64 pc =3D tcg_const_i64(s->pc); + TCGv_i64 pc =3D tcg_const_i64(s->base.pc_next); tcg_gen_movcond_i64(cond, gbea, arg1, arg2, gbea, pc); tcg_temp_free_i64(pc); } @@ -228,7 +232,7 @@ static void per_branch_cond(DisasContext *s, TCGCond co= nd, =20 static void per_breaking_event(DisasContext *s) { - tcg_gen_movi_i64(gbea, s->pc); + tcg_gen_movi_i64(gbea, s->base.pc_next); } =20 static void update_cc_op(DisasContext *s) @@ -250,11 +254,11 @@ static inline uint64_t ld_code4(CPUS390XState *env, u= int64_t pc) =20 static int get_mem_index(DisasContext *s) { - if (!(s->tb->flags & FLAG_MASK_DAT)) { + if (!(s->base.tb->flags & FLAG_MASK_DAT)) { return MMU_REAL_IDX; } =20 - switch (s->tb->flags & FLAG_MASK_ASC) { + switch (s->base.tb->flags & FLAG_MASK_ASC) { case PSW_ASC_PRIMARY >> FLAG_MASK_PSW_SHIFT: return MMU_PRIMARY_IDX; case PSW_ASC_SECONDARY >> FLAG_MASK_PSW_SHIFT: @@ -319,7 +323,7 @@ static inline void gen_trap(DisasContext *s) #ifndef CONFIG_USER_ONLY static void check_privileged(DisasContext *s) { - if (s->tb->flags & FLAG_MASK_PSTATE) { + if (s->base.tb->flags & FLAG_MASK_PSTATE) { gen_program_exception(s, PGM_PRIVILEGED); } } @@ -328,7 +332,7 @@ static void check_privileged(DisasContext *s) static TCGv_i64 get_address(DisasContext *s, int x2, int b2, int d2) { TCGv_i64 tmp =3D tcg_temp_new_i64(); - bool need_31 =3D !(s->tb->flags & FLAG_MASK_64); + bool need_31 =3D !(s->base.tb->flags & FLAG_MASK_64); =20 /* Note that d2 is limited to 20 bits, signed. If we crop negative displacements early we create larger immedate addends. */ @@ -541,9 +545,9 @@ static void gen_op_calc_cc(DisasContext *s) =20 static bool use_exit_tb(DisasContext *s) { - return (s->singlestep_enabled || - (tb_cflags(s->tb) & CF_LAST_IO) || - (s->tb->flags & FLAG_MASK_PER)); + return s->base.singlestep_enabled || + (tb_cflags(s->base.tb) & CF_LAST_IO) || + (s->base.tb->flags & FLAG_MASK_PER); } =20 static bool use_goto_tb(DisasContext *s, uint64_t dest) @@ -552,8 +556,8 @@ static bool use_goto_tb(DisasContext *s, uint64_t dest) return false; } #ifndef CONFIG_USER_ONLY - return (dest & TARGET_PAGE_MASK) =3D=3D (s->tb->pc & TARGET_PAGE_MASK)= || - (dest & TARGET_PAGE_MASK) =3D=3D (s->pc & TARGET_PAGE_MASK); + return (dest & TARGET_PAGE_MASK) =3D=3D (s->base.tb->pc & TARGET_PAGE_= MASK) || + (dest & TARGET_PAGE_MASK) =3D=3D (s->base.pc_next & TARGET_PAGE= _MASK); #else return true; #endif @@ -1145,7 +1149,7 @@ static void help_l2_shift(DisasContext *s, DisasField= s *f, =20 static DisasJumpType help_goto_direct(DisasContext *s, uint64_t dest) { - if (dest =3D=3D s->next_pc) { + if (dest =3D=3D s->pc_tmp) { per_branch(s, true); return DISAS_NEXT; } @@ -1154,7 +1158,7 @@ static DisasJumpType help_goto_direct(DisasContext *s= , uint64_t dest) per_breaking_event(s); tcg_gen_goto_tb(0); tcg_gen_movi_i64(psw_addr, dest); - tcg_gen_exit_tb((uintptr_t)s->tb); + tcg_gen_exit_tb((uintptr_t)s->base.tb); return DISAS_GOTO_TB; } else { tcg_gen_movi_i64(psw_addr, dest); @@ -1167,7 +1171,7 @@ static DisasJumpType help_branch(DisasContext *s, Dis= asCompare *c, bool is_imm, int imm, TCGv_i64 cdest) { DisasJumpType ret; - uint64_t dest =3D s->pc + 2 * imm; + uint64_t dest =3D s->base.pc_next + 2 * imm; TCGLabel *lab; =20 /* Take care of the special cases first. */ @@ -1176,7 +1180,7 @@ static DisasJumpType help_branch(DisasContext *s, Dis= asCompare *c, goto egress; } if (is_imm) { - if (dest =3D=3D s->next_pc) { + if (dest =3D=3D s->pc_tmp) { /* Branch to next. */ per_branch(s, true); ret =3D DISAS_NEXT; @@ -1200,7 +1204,7 @@ static DisasJumpType help_branch(DisasContext *s, Dis= asCompare *c, } } =20 - if (use_goto_tb(s, s->next_pc)) { + if (use_goto_tb(s, s->pc_tmp)) { if (is_imm && use_goto_tb(s, dest)) { /* Both exits can use goto_tb. */ update_cc_op(s); @@ -1214,15 +1218,15 @@ static DisasJumpType help_branch(DisasContext *s, D= isasCompare *c, =20 /* Branch not taken. */ tcg_gen_goto_tb(0); - tcg_gen_movi_i64(psw_addr, s->next_pc); - tcg_gen_exit_tb((uintptr_t)s->tb + 0); + tcg_gen_movi_i64(psw_addr, s->pc_tmp); + tcg_gen_exit_tb((uintptr_t)s->base.tb + 0); =20 /* Branch taken. */ gen_set_label(lab); per_breaking_event(s); tcg_gen_goto_tb(1); tcg_gen_movi_i64(psw_addr, dest); - tcg_gen_exit_tb((uintptr_t)s->tb + 1); + tcg_gen_exit_tb((uintptr_t)s->base.tb + 1); =20 ret =3D DISAS_GOTO_TB; } else { @@ -1244,8 +1248,8 @@ static DisasJumpType help_branch(DisasContext *s, Dis= asCompare *c, /* Branch not taken. */ update_cc_op(s); tcg_gen_goto_tb(0); - tcg_gen_movi_i64(psw_addr, s->next_pc); - tcg_gen_exit_tb((uintptr_t)s->tb + 0); + tcg_gen_movi_i64(psw_addr, s->pc_tmp); + tcg_gen_exit_tb((uintptr_t)s->base.tb + 0); =20 gen_set_label(lab); if (is_imm) { @@ -1259,7 +1263,7 @@ static DisasJumpType help_branch(DisasContext *s, Dis= asCompare *c, Most commonly we're single-stepping or some other condition that disables all use of goto_tb. Just update the PC and exit. */ =20 - TCGv_i64 next =3D tcg_const_i64(s->next_pc); + TCGv_i64 next =3D tcg_const_i64(s->pc_tmp); if (is_imm) { cdest =3D tcg_const_i64(dest); } @@ -1448,7 +1452,7 @@ static DisasJumpType op_ni(DisasContext *s, DisasOps = *o) =20 static DisasJumpType op_bas(DisasContext *s, DisasOps *o) { - tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->next_pc)); + tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->pc_tmp)); if (o->in2) { tcg_gen_mov_i64(psw_addr, o->in2); per_branch(s, false); @@ -1460,8 +1464,8 @@ static DisasJumpType op_bas(DisasContext *s, DisasOps= *o) =20 static DisasJumpType op_basi(DisasContext *s, DisasOps *o) { - tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->next_pc)); - return help_goto_direct(s, s->pc + 2 * get_field(s->fields, i2)); + tcg_gen_movi_i64(o->out, pc_to_link_info(s, s->pc_tmp)); + return help_goto_direct(s, s->base.pc_next + 2 * get_field(s->fields, = i2)); } =20 static DisasJumpType op_bc(DisasContext *s, DisasOps *o) @@ -1994,7 +1998,7 @@ static DisasJumpType op_cdsg(DisasContext *s, DisasOp= s *o) addr =3D get_address(s, 0, b2, d2); t_r1 =3D tcg_const_i32(r1); t_r3 =3D tcg_const_i32(r3); - if (tb_cflags(s->tb) & CF_PARALLEL) { + if (tb_cflags(s->base.tb) & CF_PARALLEL) { gen_helper_cdsg_parallel(cpu_env, addr, t_r1, t_r3); } else { gen_helper_cdsg(cpu_env, addr, t_r1, t_r3); @@ -2012,7 +2016,7 @@ static DisasJumpType op_csst(DisasContext *s, DisasOp= s *o) int r3 =3D get_field(s->fields, r3); TCGv_i32 t_r3 =3D tcg_const_i32(r3); =20 - if (tb_cflags(s->tb) & CF_PARALLEL) { + if (tb_cflags(s->base.tb) & CF_PARALLEL) { gen_helper_csst_parallel(cc_op, cpu_env, t_r3, o->in1, o->in2); } else { gen_helper_csst(cc_op, cpu_env, t_r3, o->in1, o->in2); @@ -2972,7 +2976,7 @@ static DisasJumpType op_lpd(DisasContext *s, DisasOps= *o) TCGMemOp mop =3D s->insn->data; =20 /* In a parallel context, stop the world and single step. */ - if (tb_cflags(s->tb) & CF_PARALLEL) { + if (tb_cflags(s->base.tb) & CF_PARALLEL) { update_psw_addr(s); update_cc_op(s); gen_exception(EXCP_ATOMIC); @@ -2994,7 +2998,7 @@ static DisasJumpType op_lpd(DisasContext *s, DisasOps= *o) =20 static DisasJumpType op_lpq(DisasContext *s, DisasOps *o) { - if (tb_cflags(s->tb) & CF_PARALLEL) { + if (tb_cflags(s->base.tb) & CF_PARALLEL) { gen_helper_lpq_parallel(o->out, cpu_env, o->in2); } else { gen_helper_lpq(o->out, cpu_env, o->in2); @@ -3044,7 +3048,7 @@ static DisasJumpType op_mov2e(DisasContext *s, DisasO= ps *o) o->in2 =3D NULL; o->g_in2 =3D false; =20 - switch (s->tb->flags & FLAG_MASK_ASC) { + switch (s->base.tb->flags & FLAG_MASK_ASC) { case PSW_ASC_PRIMARY >> FLAG_MASK_PSW_SHIFT: tcg_gen_movi_i64(ar1, 0); break; @@ -3694,11 +3698,11 @@ static DisasJumpType op_sam(DisasContext *s, DisasO= ps *o) /* Bizarre but true, we check the address of the current insn for the specification exception, not the next to be executed. Thus the PoO documents that Bad Things Happen two bytes before the end. */ - if (s->pc & ~mask) { + if (s->base.pc_next & ~mask) { gen_program_exception(s, PGM_SPECIFICATION); return DISAS_NORETURN; } - s->next_pc &=3D mask; + s->pc_tmp &=3D mask; =20 tsam =3D tcg_const_i64(sam); tcg_gen_deposit_i64(psw_mask, psw_mask, tsam, 31, 2); @@ -4411,7 +4415,7 @@ static DisasJumpType op_stmh(DisasContext *s, DisasOp= s *o) =20 static DisasJumpType op_stpq(DisasContext *s, DisasOps *o) { - if (tb_cflags(s->tb) & CF_PARALLEL) { + if (tb_cflags(s->base.tb) & CF_PARALLEL) { gen_helper_stpq_parallel(cpu_env, o->in2, o->out2, o->out); } else { gen_helper_stpq(cpu_env, o->in2, o->out2, o->out); @@ -4500,8 +4504,8 @@ static DisasJumpType op_tam(DisasContext *s, DisasOps= *o) { int cc =3D 0; =20 - cc |=3D (s->tb->flags & FLAG_MASK_64) ? 2 : 0; - cc |=3D (s->tb->flags & FLAG_MASK_32) ? 1 : 0; + cc |=3D (s->base.tb->flags & FLAG_MASK_64) ? 2 : 0; + cc |=3D (s->base.tb->flags & FLAG_MASK_32) ? 1 : 0; gen_op_movi_cc(s, cc); return DISAS_NEXT; } @@ -5625,7 +5629,7 @@ static void in2_a2(DisasContext *s, DisasFields *f, D= isasOps *o) =20 static void in2_ri2(DisasContext *s, DisasFields *f, DisasOps *o) { - o->in2 =3D tcg_const_i64(s->pc + (int64_t)get_field(f, i2) * 2); + o->in2 =3D tcg_const_i64(s->base.pc_next + (int64_t)get_field(f, i2) *= 2); } #define SPEC_in2_ri2 0 =20 @@ -5926,7 +5930,7 @@ static void extract_field(DisasFields *o, const Disas= Field *f, uint64_t insn) static const DisasInsn *extract_insn(CPUS390XState *env, DisasContext *s, DisasFields *f) { - uint64_t insn, pc =3D s->pc; + uint64_t insn, pc =3D s->base.pc_next; int op, op2, ilen; const DisasInsn *info; =20 @@ -5958,7 +5962,7 @@ static const DisasInsn *extract_insn(CPUS390XState *e= nv, DisasContext *s, g_assert_not_reached(); } } - s->next_pc =3D s->pc + ilen; + s->pc_tmp =3D s->base.pc_next + ilen; s->ilen =3D ilen; =20 /* We can't actually determine the insn format until we've looked up @@ -6043,8 +6047,8 @@ static DisasJumpType translate_one(CPUS390XState *env= , DisasContext *s) } =20 #ifndef CONFIG_USER_ONLY - if (s->tb->flags & FLAG_MASK_PER) { - TCGv_i64 addr =3D tcg_const_i64(s->pc); + if (s->base.tb->flags & FLAG_MASK_PER) { + TCGv_i64 addr =3D tcg_const_i64(s->base.pc_next); gen_helper_per_ifetch(cpu_env, addr); tcg_temp_free_i64(addr); } @@ -6138,10 +6142,10 @@ static DisasJumpType translate_one(CPUS390XState *e= nv, DisasContext *s) } =20 #ifndef CONFIG_USER_ONLY - if (s->tb->flags & FLAG_MASK_PER) { + if (s->base.tb->flags & FLAG_MASK_PER) { /* An exception might be triggered, save PSW if not already done. = */ if (ret =3D=3D DISAS_NEXT || ret =3D=3D DISAS_PC_STALE) { - tcg_gen_movi_i64(psw_addr, s->next_pc); + tcg_gen_movi_i64(psw_addr, s->pc_tmp); } =20 /* Call the helper to check for a possible PER exception. */ @@ -6150,7 +6154,7 @@ static DisasJumpType translate_one(CPUS390XState *env= , DisasContext *s) #endif =20 /* Advance to the next instruction. */ - s->pc =3D s->next_pc; + s->base.pc_next =3D s->pc_tmp; return ret; } =20 @@ -6158,26 +6162,25 @@ void gen_intermediate_code(CPUState *cs, struct Tra= nslationBlock *tb) { CPUS390XState *env =3D cs->env_ptr; DisasContext dc; - target_ulong pc_start; uint64_t page_start; int num_insns, max_insns; DisasJumpType status; bool do_debug; =20 - pc_start =3D tb->pc; - + dc.base.pc_first =3D tb->pc; /* 31-bit mode */ if (!(tb->flags & FLAG_MASK_64)) { - pc_start &=3D 0x7fffffff; + dc.base.pc_first &=3D 0x7fffffff; } + dc.base.pc_next =3D dc.base.pc_first; + dc.base.tb =3D tb; + dc.base.singlestep_enabled =3D cs->singlestep_enabled; =20 - dc.tb =3D tb; - dc.pc =3D pc_start; dc.cc_op =3D CC_OP_DYNAMIC; - dc.ex_value =3D tb->cs_base; - do_debug =3D dc.singlestep_enabled =3D cs->singlestep_enabled; + dc.ex_value =3D dc.base.tb->cs_base; + do_debug =3D cs->singlestep_enabled; =20 - page_start =3D pc_start & TARGET_PAGE_MASK; + page_start =3D dc.base.pc_first & TARGET_PAGE_MASK; =20 num_insns =3D 0; max_insns =3D tb_cflags(tb) & CF_COUNT_MASK; @@ -6191,17 +6194,17 @@ void gen_intermediate_code(CPUState *cs, struct Tra= nslationBlock *tb) gen_tb_start(tb); =20 do { - tcg_gen_insn_start(dc.pc, dc.cc_op); + tcg_gen_insn_start(dc.base.pc_next, dc.cc_op); num_insns++; =20 - if (unlikely(cpu_breakpoint_test(cs, dc.pc, BP_ANY))) { + if (unlikely(cpu_breakpoint_test(cs, dc.base.pc_next, BP_ANY))) { status =3D DISAS_PC_STALE; do_debug =3D true; /* The address covered by the breakpoint must be included in [tb->pc, tb->pc + tb->size) in order to for it to be properly cleared -- thus we increment the PC here so that the logic setting tb->size below does the right thing. */ - dc.pc +=3D 2; + dc.base.pc_next +=3D 2; break; } =20 @@ -6214,11 +6217,11 @@ void gen_intermediate_code(CPUState *cs, struct Tra= nslationBlock *tb) /* If we reach a page boundary, are single stepping, or exhaust instruction count, stop generation. */ if (status =3D=3D DISAS_NEXT - && (dc.pc - page_start >=3D TARGET_PAGE_SIZE + && (dc.base.pc_next - page_start >=3D TARGET_PAGE_SIZE || tcg_op_buf_full() || num_insns >=3D max_insns || singlestep - || cs->singlestep_enabled + || dc.base.singlestep_enabled || dc.ex_value)) { status =3D DISAS_TOO_MANY; } @@ -6258,19 +6261,20 @@ void gen_intermediate_code(CPUState *cs, struct Tra= nslationBlock *tb) =20 gen_tb_end(tb, num_insns); =20 - tb->size =3D dc.pc - pc_start; + tb->size =3D dc.base.pc_next - dc.base.pc_first; tb->icount =3D num_insns; =20 #if defined(S390X_DEBUG_DISAS) if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM) - && qemu_log_in_addr_range(pc_start)) { + && qemu_log_in_addr_range(dc.base.pc_first)) { qemu_log_lock(); if (unlikely(dc.ex_value)) { /* ??? Unfortunately log_target_disas can't use host memory. = */ qemu_log("IN: EXECUTE %016" PRIx64 "\n", dc.ex_value); } else { - qemu_log("IN: %s\n", lookup_symbol(pc_start)); - log_target_disas(cs, pc_start, dc.pc - pc_start); + qemu_log("IN: %s\n", lookup_symbol(dc.base.pc_first)); + log_target_disas(cs, dc.base.pc_first, + dc.base.pc_next - dc.base.pc_first); qemu_log("\n"); } qemu_log_unlock(); --=20 2.7.4