From nobody Tue Feb 10 03:40:32 2026 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zoho.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=linaro.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1550241353760752.4086344776939; Fri, 15 Feb 2019 06:35:53 -0800 (PST) Received: from localhost ([127.0.0.1]:40886 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gueak-0002Gt-MK for importer@patchew.org; Fri, 15 Feb 2019 09:35:50 -0500 Received: from eggs.gnu.org ([209.51.188.92]:59185) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gueWQ-0007qM-SQ for qemu-devel@nongnu.org; Fri, 15 Feb 2019 09:31:25 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gueWO-0000DR-JP for qemu-devel@nongnu.org; Fri, 15 Feb 2019 09:31:22 -0500 Received: from mail-wm1-x32a.google.com ([2a00:1450:4864:20::32a]:55252) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1gueWN-0000Bh-Up for qemu-devel@nongnu.org; Fri, 15 Feb 2019 09:31:20 -0500 Received: by mail-wm1-x32a.google.com with SMTP id a62so10153186wmh.4 for ; Fri, 15 Feb 2019 06:31:19 -0800 (PST) Received: from zen.linaroharston ([81.128.185.34]) by smtp.gmail.com with ESMTPSA id i192sm5902333wmg.7.2019.02.15.06.31.15 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Fri, 15 Feb 2019 06:31:17 -0800 (PST) Received: from zen.linaroharston. (localhost [127.0.0.1]) by zen.linaroharston (Postfix) with ESMTP id 6AA4A1FF86; Fri, 15 Feb 2019 14:31:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=h/QwSNZ4mgsPBoS8x2aW8GpKqB5WxTyDH3cEEHn5ZJw=; b=XrlXTb7BTrQe2+jISxgSwnRd8kwTMxa8fDvcVE1bhJ2CTA4jQS6M/m+pJBvRD3/QLr tC2OGEJaDn97k+HKC+/gKJ3JulO4fWIB2wYeUYxNVdaYH1emLIdbak9XolRfKmswkQkl pCmf2uxrP3bH+lL2r/WjRaI4I4xrBQzkdyvhwFJ69UYCQuohqUF+ZUyba4/ME1WFHgvW i2Hz5WvUKFDU+mfTFodfdlZj4iK1xdnLEdesmcBrcxOB8Zj9Qz4FBSZKAvRRfY/QE4CR NgKd65fi2UYoR3ITnoBGhCozfaP3x19ITNO74a++w/Ezm2hR4ohd/XW+J6tMwrNAKmIN yTRw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=h/QwSNZ4mgsPBoS8x2aW8GpKqB5WxTyDH3cEEHn5ZJw=; b=NhFP2NJofS9sJB1HMaBgUXd4FthS08nn9KFFVUBaG+RSiccvvPlE8wysYz2/XQwBkP 6W/2trunFoPIl24OBq1UsyMmP7Y9fZq/dq2ovJqsVTr9Bd13xkqXW+44TLClwR5+wjNE Yf2ExuyUroeA7iG2J7ZX0TXuN9YgjyD7zWFU0VooEs6pIU1Ap65cseo4odiAeNJKDL/D PLHVum/EgFYVi3Rp587Vok6yTdhrRCPPwalU0T4NXxFTP1orG5jVesK/4BjjXW8gVxAA x1MajnmxQSMGifaCaYYSDsRyjEHmhERjgFEJFAfNVwfkrLCBUmyDABvU/fCrGD2VtIfz tBGA== X-Gm-Message-State: AHQUAuZzH8Ug2BlIKTkV+xD9SaNmCzuv9udyr3/cQtHASkKy6dOpyD67 KXih9xkyINlDjj/e5tlL8j17zA== X-Google-Smtp-Source: AHgI3IaczALj/183IXVQ33XHrnyG6hbIZTCJutHogIODboEVZztmMuuMDz3H9XcY8ADd5X2leCNAMA== X-Received: by 2002:a1c:be04:: with SMTP id o4mr6533773wmf.19.1550241078771; Fri, 15 Feb 2019 06:31:18 -0800 (PST) From: =?UTF-8?q?Alex=20Benn=C3=A9e?= To: qemu-devel@nongnu.org Date: Fri, 15 Feb 2019 14:31:15 +0000 Message-Id: <20190215143115.28777-4-alex.bennee@linaro.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20190215143115.28777-1-alex.bennee@linaro.org> References: <20190215143115.28777-1-alex.bennee@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2a00:1450:4864:20::32a Subject: [Qemu-devel] [PATCH v3 3/3] accel/tcg: move unaligned helpers out of core helpers 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: =?UTF-8?q?Alex=20Benn=C3=A9e?= , cota@braap.org, mark.cave-ayland@ilande.co.uk Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Using __flatten__ ends up with fairly large functions. Attempt to ameliorate this by moving the unaligned handling out of the main helper. We can now use __always_inline__ instead of __flatten__ and keep the main functions relatively small. Signed-off-by: Alex Benn=C3=A9e --- v3 - take care to mask high bits in unaligned_load_helper --- accel/tcg/cputlb.c | 200 ++++++++++++++++++++++++--------------------- 1 file changed, 109 insertions(+), 91 deletions(-) diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c index 351f579fed..5f225e3623 100644 --- a/accel/tcg/cputlb.c +++ b/accel/tcg/cputlb.c @@ -1206,10 +1206,47 @@ static inline uint64_t handle_bswap(uint64_t val, i= nt size, bool big_endian) * is disassembled. It shouldn't be called directly by guest code. */ =20 -static tcg_target_ulong load_helper(CPUArchState *env, target_ulong addr, - TCGMemOpIdx oi, uintptr_t retaddr, - size_t size, bool big_endian, - bool code_read) +static inline __attribute__((__always_inline__)) +tcg_target_ulong load_helper(CPUArchState *env, target_ulong addr, + TCGMemOpIdx oi, uintptr_t retaddr, + size_t size, bool big_endian, + bool code_read); + +static tcg_target_ulong unaligned_load_helper(CPUArchState *env, target_ul= ong addr, + TCGMemOpIdx oi, uintptr_t re= taddr, + size_t size, bool big_endian, + bool code_read) +{ + target_ulong addr1, addr2; + tcg_target_ulong res, r1, r2; + const tcg_target_ulong size_mask =3D MAKE_64BIT_MASK(0, size * 8); + unsigned shift; + + addr1 =3D addr & ~(size - 1); + addr2 =3D addr1 + size; + + r1 =3D load_helper(env, addr1, oi, retaddr, size, big_endian, code_rea= d); + r2 =3D load_helper(env, addr2, oi, retaddr, size, big_endian, code_rea= d); + shift =3D (addr & (size - 1)) * 8; + + if (big_endian) { + /* Big-endian combine. */ + r2 &=3D size_mask; + res =3D (r1 << shift) | (r2 >> ((size * 8) - shift)); + } else { + /* Little-endian combine. */ + r1 &=3D size_mask; + res =3D (r1 >> shift) | (r2 << ((size * 8) - shift)); + } + return res; +} + + +static inline __attribute__((__always_inline__)) +tcg_target_ulong load_helper(CPUArchState *env, target_ulong addr, + TCGMemOpIdx oi, uintptr_t retaddr, + size_t size, bool big_endian, + bool code_read) { uintptr_t mmu_idx =3D get_mmuidx(oi); uintptr_t index =3D tlb_index(env, mmu_idx, addr); @@ -1247,7 +1284,8 @@ static tcg_target_ulong load_helper(CPUArchState *env= , target_ulong addr, uint64_t tmp; =20 if ((addr & (size - 1)) !=3D 0) { - goto do_unaligned_access; + return unaligned_load_helper(env, addr, oi, retaddr, + size, big_endian, code_read); } =20 tmp =3D io_readx(env, iotlbentry, mmu_idx, addr, retaddr, @@ -1260,24 +1298,9 @@ static tcg_target_ulong load_helper(CPUArchState *en= v, target_ulong addr, if (size > 1 && unlikely((addr & ~TARGET_PAGE_MASK) + size - 1 >=3D TARGET_PAGE_SIZE)) { - target_ulong addr1, addr2; - tcg_target_ulong r1, r2; - unsigned shift; - do_unaligned_access: - addr1 =3D addr & ~(size - 1); - addr2 =3D addr1 + size; - r1 =3D load_helper(env, addr1, oi, retaddr, size, big_endian, code= _read); - r2 =3D load_helper(env, addr2, oi, retaddr, size, big_endian, code= _read); - shift =3D (addr & (size - 1)) * 8; =20 - if (big_endian) { - /* Big-endian combine. */ - res =3D (r1 << shift) | (r2 >> ((size * 8) - shift)); - } else { - /* Little-endian combine. */ - res =3D (r1 >> shift) | (r2 << ((size * 8) - shift)); - } - return res; + return unaligned_load_helper(env, addr, oi, retaddr, + size, big_endian, code_read); } =20 haddr =3D addr + entry->addend; @@ -1325,50 +1348,49 @@ static tcg_target_ulong load_helper(CPUArchState *e= nv, target_ulong addr, * We don't bother with this widened value for SOFTMMU_CODE_ACCESS. */ =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_ret_ldub_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 1, false, false); } =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_le_lduw_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 2, false, false); } =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_be_lduw_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 2, true, false); } =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_le_ldul_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 4, false, false); } =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_be_ldul_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 4, true, false); } =20 -uint64_t __attribute__((flatten)) -helper_le_ldq_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, + +uint64_t helper_le_ldq_mmu(CPUArchState *env, target_ulong addr, TCGMemOpI= dx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 8, false, false); } =20 -uint64_t __attribute__((flatten)) -helper_be_ldq_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, +uint64_t helper_be_ldq_mmu(CPUArchState *env, target_ulong addr, TCGMemOpI= dx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 8, true, false); @@ -1379,22 +1401,21 @@ helper_be_ldq_mmu(CPUArchState *env, target_ulong a= ddr, TCGMemOpIdx oi, * avoid this for 64-bit data, or for 32-bit data on 32-bit host. */ =20 - -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_ret_ldsb_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return (int8_t)helper_ret_ldub_mmu(env, addr, oi, retaddr); } =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_le_ldsw_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return (int16_t)helper_le_lduw_mmu(env, addr, oi, retaddr); } =20 -tcg_target_ulong __attribute__((flatten)) +tcg_target_ulong helper_be_ldsw_mmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { @@ -1418,10 +1439,43 @@ helper_be_ldsl_mmu(CPUArchState *env, target_ulong = addr, TCGMemOpIdx oi, /* * Store Helpers */ +static inline __attribute__((__always_inline__)) +void store_helper(CPUArchState *env, target_ulong addr, uint64_t val, + TCGMemOpIdx oi, uintptr_t retaddr, size_t size, + bool big_endian); =20 -static void store_helper(CPUArchState *env, target_ulong addr, uint64_t va= l, - TCGMemOpIdx oi, uintptr_t retaddr, size_t size, - bool big_endian) + +static void +unaligned_store_helper(CPUArchState *env, target_ulong addr, uint64_t val, + TCGMemOpIdx oi, uintptr_t retaddr, size_t size, + bool big_endian) +{ + int i; + + /* + * This is inefficient but simple and hopefully on the slow path + * anyway. The loop must go in the forward direction to avoid + * issues with self-modifying code in Windows 64-bit. + */ + for (i =3D 0; i < size; ++i) { + uint8_t val8; + if (big_endian) { + /* Big-endian extract. */ + val8 =3D val >> (((size - 1) * 8) - (i * 8)); + } else { + /* Little-endian extract. */ + val8 =3D val >> (i * 8); + } + store_helper(env, addr + i, val8, oi, retaddr, 1, big_endian); + } + return; +} + + +static inline __attribute__((__always_inline__)) +void store_helper(CPUArchState *env, target_ulong addr, uint64_t val, + TCGMemOpIdx oi, uintptr_t retaddr, size_t size, + bool big_endian) { uintptr_t mmu_idx =3D get_mmuidx(oi); uintptr_t index =3D tlb_index(env, mmu_idx, addr); @@ -1452,7 +1506,8 @@ static void store_helper(CPUArchState *env, target_ul= ong addr, uint64_t val, CPUIOTLBEntry *iotlbentry =3D &env->iotlb[mmu_idx][index]; =20 if ((addr & (size - 1)) !=3D 0) { - goto do_unaligned_access; + unaligned_store_helper(env, addr, val, oi, retaddr, size, big_= endian); + return; } =20 io_writex(env, iotlbentry, mmu_idx, @@ -1465,44 +1520,7 @@ static void store_helper(CPUArchState *env, target_u= long addr, uint64_t val, if (size > 1 && unlikely((addr & ~TARGET_PAGE_MASK) + size - 1 >=3D TARGET_PAGE_SIZE)) { - int i; - uintptr_t index2; - CPUTLBEntry *entry2; - target_ulong page2, tlb_addr2; - do_unaligned_access: - /* - * Ensure the second page is in the TLB. Note that the first page - * is already guaranteed to be filled, and that the second page - * cannot evict the first. - */ - page2 =3D (addr + size) & TARGET_PAGE_MASK; - index2 =3D tlb_index(env, mmu_idx, page2); - entry2 =3D tlb_entry(env, mmu_idx, index2); - tlb_addr2 =3D tlb_addr_write(entry2); - if (!tlb_hit_page(tlb_addr2, page2) - && !VICTIM_TLB_HIT(addr_write, page2)) { - tlb_fill(ENV_GET_CPU(env), page2, size, MMU_DATA_STORE, - mmu_idx, retaddr); - index2 =3D tlb_index(env, mmu_idx, page2); - entry2 =3D tlb_entry(env, mmu_idx, index2); - } - - /* - * XXX: not efficient, but simple. - * This loop must go in the forward direction to avoid issues - * with self-modifying code in Windows 64-bit. - */ - for (i =3D 0; i < size; ++i) { - uint8_t val8; - if (big_endian) { - /* Big-endian extract. */ - val8 =3D val >> (((size - 1) * 8) - (i * 8)); - } else { - /* Little-endian extract. */ - val8 =3D val >> (i * 8); - } - store_helper(env, addr + i, val8, oi, retaddr, 1, big_endian); - } + unaligned_store_helper(env, addr, val, oi, retaddr, size, big_endi= an); return; } =20 @@ -1539,49 +1557,49 @@ static void store_helper(CPUArchState *env, target_= ulong addr, uint64_t val, } } =20 -void __attribute__((flatten)) +void helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val, TCGMemOpIdx oi, uintptr_t retaddr) { store_helper(env, addr, val, oi, retaddr, 1, false); } =20 -void __attribute__((flatten)) +void helper_le_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val, TCGMemOpIdx oi, uintptr_t retaddr) { store_helper(env, addr, val, oi, retaddr, 2, false); } =20 -void __attribute__((flatten)) +void helper_be_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val, TCGMemOpIdx oi, uintptr_t retaddr) { store_helper(env, addr, val, oi, retaddr, 2, true); } =20 -void __attribute__((flatten)) +void helper_le_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val, TCGMemOpIdx oi, uintptr_t retaddr) { store_helper(env, addr, val, oi, retaddr, 4, false); } =20 -void __attribute__((flatten)) +void helper_be_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val, TCGMemOpIdx oi, uintptr_t retaddr) { store_helper(env, addr, val, oi, retaddr, 4, true); } =20 -void __attribute__((flatten)) +void helper_le_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val, TCGMemOpIdx oi, uintptr_t retaddr) { store_helper(env, addr, val, oi, retaddr, 8, false); } =20 -void __attribute__((flatten)) +void helper_be_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val, TCGMemOpIdx oi, uintptr_t retaddr) { @@ -1647,49 +1665,49 @@ helper_be_stq_mmu(CPUArchState *env, target_ulong a= ddr, uint64_t val, =20 /* Code access functions. */ =20 -uint8_t __attribute__((flatten)) +uint8_t helper_ret_ldb_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 1, false, true); } =20 -uint16_t __attribute__((flatten)) +uint16_t helper_le_ldw_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 2, false, true); } =20 -uint16_t __attribute__((flatten)) +uint16_t helper_be_ldw_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 2, true, true); } =20 -uint32_t __attribute__((flatten)) +uint32_t helper_le_ldl_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 4, false, true); } =20 -uint32_t __attribute__((flatten)) +uint32_t helper_be_ldl_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 4, true, true); } =20 -uint64_t __attribute__((flatten)) +uint64_t helper_le_ldq_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { return load_helper(env, addr, oi, retaddr, 8, false, true); } =20 -uint64_t __attribute__((flatten)) +uint64_t helper_be_ldq_cmmu(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi, uintptr_t retaddr) { --=20 2.20.1