From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id E739AC28B2E for ; Mon, 10 Mar 2025 15:47:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=LhVJSGyz4xstXDntJhN1WhaWRDHiRZTztyZkv4wMwb0=; b=3lfvcPA100mB2M 8BsCe8y0omnnRA2oT637NbjyMvU2YJNEClQnAM1VG1SkY85EVLPAlcRGloGkN35txqtvyNzcsrBcn gAzUVE/Au44Gi6s6fMg9l5/3iYm4Kx7BqyPiG/ZJcdA1TDKrG4g5CBPav8TxnxZzabik+vk0nMiJy w4oKVHjfeUfm9q6AjXI4G/FG1QIy7GZoTZTa/Fx/k2+BghguL8RzHR7iX6eX74PWj2rwekcrxrpHF AG/AvrhgPpW4Cynd8vr3LzCvGs4HNlBEphkt90ALR2nQOeyMup+aWdaipMMzKgtvFbGaMePt5mi+T zVQO8qQlniFhwzFJ1CRA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1trfM5-00000003GEM-26h6; Mon, 10 Mar 2025 15:47:49 +0000 Received: from mail-pl1-x62f.google.com ([2607:f8b0:4864:20::62f]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1trepx-00000003838-1Bam for kvm-riscv@lists.infradead.org; Mon, 10 Mar 2025 15:14:38 +0000 Received: by mail-pl1-x62f.google.com with SMTP id d9443c01a7336-2243803b776so68780875ad.0 for ; Mon, 10 Mar 2025 08:14:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1741619677; x=1742224477; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=VKDplUA2XX/hbzyOxbYWLc7Q9RboQ/w3e3i+SZL4wNg=; b=vroCAGr6EFIyTJVK17P9RUxGj2A65s8ERqEzeNH13BKvXKoIn/yBFIPZiVvfxHf7Qk lagqlZDPMjjZG2toS5hR7DwJ129QIBTba4TtVjw8FxyKlICHfHt+7AEfUDIiNK+MqYTe NkdPhSodiLnO5JZleZiMKbxDXe8joWVvtexBX6VWhnt3UOymlFUwBeFcKAmQZ8y2viTG QOIjX4ZNDIQy25McSAZdRPJXyxr+Gu0spWxcHJqGTV7+wnDrzvn7GTVZ7eZhe3iTkAyg JidBoLhlR/tpPQdp3RHn+jvIn1VU8ZkLFvEQ030rsZgr7aq4i3/TxElBC0sqRbToSzGC bqjg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1741619677; x=1742224477; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=VKDplUA2XX/hbzyOxbYWLc7Q9RboQ/w3e3i+SZL4wNg=; b=apu3283tCCvIZonoRaZxnXinm6UcyEPa3CV+rTossVxh72poZAsJ+V1cL0EfHwxpmW L5MoKH7En+hqPqjCp37FuhRSOdlCTTfzlba9fdujGuc03sEpCNYhOXgXBwEc+rU4yyF+ tiOn37uKCJ3Erju3vwWm1tiToHi56ldEFri5xFCqAfozCygDEhsF8XMBJx5uKQKDhiJW SRmJDKzBi0KIGpNwIIfuMB4vsi0QLwLHiG5pqnwaJ+EoG9lLkx1lHNBn8zpF09z3cQ69 1fPJ9CGpcvL0BrHO9PGW8sUUKJe5/GpO3WJf2BW4nLiYFPAiIIqT6/8+kEr7oGuAQnA/ OUxg== X-Forwarded-Encrypted: i=1; AJvYcCWaE2oV1saoSAe6ePM3U0F1wuckP/oDzH+CdPquYf0X69lY8cpaoXc7omGen4VAa+wonAY/boe9mFI=@lists.infradead.org X-Gm-Message-State: AOJu0YynIc4Hu1TPNY6xMPcC7gpIF9a/Vi/U5n40ZsElNUw8Px/Y5Em9 UbQy43WjHBjPpFQeQ0jHEopyVgdP8mx/ecqKglrYdWD0vmStGdlmVk4ZQkE8O0w= X-Gm-Gg: ASbGncttXUpBZ+5YbGb97ElyKJjzJSEg8zQkTvTQobTIWbirHwolnG+MUy9IwcXDWtZ eZLOG1FpSS5n4jBR5gYd9Y2O6fNDtRpv0wtggryqS4OY/9rtYMR85FyQfUUAxqg2JnO/ZOukTyJ 8RS7av3+yTRgeQLoewehgmV/876j4iXuT3nD9OoNe78RyAuuMonLQ7fQXn2VE78GhBGH2OVyeiB /CqqQydoLPaFjVmZ+j815sX/MxHPIisq9iezUWlJQX0wz2Rl4GXwU0Qnjh5U/kjDlegDZQmRd6K i1wvw6JkPD4bsfK0JpZ8AcycAb7173ZqbOQLvkGBGC4Tml6Xpvq/W3RH X-Google-Smtp-Source: AGHT+IHLPYH9Su/Xk8k0SCej8djbbsIZk7xOmrGvQm5ktmN7qNh0cYjE9gF9O+rc7TRVQLiHHoCCuw== X-Received: by 2002:a17:903:1ca:b0:21b:d105:26b8 with SMTP id d9443c01a7336-2242887b209mr175258155ad.7.1741619676619; Mon, 10 Mar 2025 08:14:36 -0700 (PDT) Received: from carbon-x1.. ([2a01:e0a:e17:9700:16d2:7456:6634:9626]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-224109e99dfsm79230515ad.91.2025.03.10.08.14.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Mar 2025 08:14:35 -0700 (PDT) From: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= To: Paul Walmsley , Palmer Dabbelt , Anup Patel , Atish Patra , Shuah Khan , Jonathan Corbet , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, kvm@vger.kernel.org, kvm-riscv@lists.infradead.org, linux-kselftest@vger.kernel.org Cc: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= , Samuel Holland Subject: [PATCH v3 13/17] selftests: riscv: add misaligned access testing Date: Mon, 10 Mar 2025 16:12:20 +0100 Message-ID: <20250310151229.2365992-14-cleger@rivosinc.com> X-Mailer: git-send-email 2.47.2 In-Reply-To: <20250310151229.2365992-1-cleger@rivosinc.com> References: <20250310151229.2365992-1-cleger@rivosinc.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250310_081437_329829_8522D6B1 X-CRM114-Status: GOOD ( 19.55 ) X-BeenThere: kvm-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kvm-riscv" Errors-To: kvm-riscv-bounces+kvm-riscv=archiver.kernel.org@lists.infradead.org Tm93IHRoYXQgdGhlIGtlcm5lbCBjYW4gZW11bGF0ZSBtaXNhbGlnbmVkIGFjY2VzcyBhbmQgY29u dHJvbCBpdHMKYmVoYXZpb3IsIGFkZCBhIHNlbGZ0ZXN0IGZvciB0aGF0LiBUaGlzIHNlbGZ0ZXN0 IHRlc3RzIGFsbCB0aGUgY3VycmVudGx5CmVtdWxhdGVkIGluc3RydWN0aW9uIChleGNlcHQgZm9y IHRoZSBSVjMyIGNvbXByZXNzZWQgb25lcyB3aGljaCBhcmUgbGVmdAphcyBhIGZ1dHVyZSBleGVy Y2lzZSBmb3IgYSBSVjMyIHVzZXIpLiBGb3IgdGhlIEZQVSBpbnN0cnVjdGlvbnMsIGFsbCB0aGUK RlBVIHJlZ2lzdGVycyBhcmUgdGVzdGVkLgoKU2lnbmVkLW9mZi1ieTogQ2zDqW1lbnQgTMOpZ2Vy IDxjbGVnZXJAcml2b3NpbmMuY29tPgotLS0KIC4uLi9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25l ZC8uZ2l0aWdub3JlICAgICB8ICAgMSArCiAuLi4vc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQv TWFrZWZpbGUgICAgICAgfCAgMTIgKwogLi4uL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2Nv bW1vbi5TICAgICAgIHwgIDMzICsrKwogLi4uL3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2Fs aWduZWQvZnB1LlMgIHwgMTgwICsrKysrKysrKysrKysKIHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3Rz L3Jpc2N2L21pc2FsaWduZWQvZ3AuUyB8IDEwMyArKysrKysrCiAuLi4vc2VsZnRlc3RzL3Jpc2N2 L21pc2FsaWduZWQvbWlzYWxpZ25lZC5jICAgfCAyNTQgKysrKysrKysrKysrKysrKysrCiA2IGZp bGVzIGNoYW5nZWQsIDU4MyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgdG9vbHMv dGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC8uZ2l0aWdub3JlCiBjcmVhdGUgbW9k ZSAxMDA2NDQgdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9NYWtlZmls ZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2Fs aWduZWQvY29tbW9uLlMKIGNyZWF0ZSBtb2RlIDEwMDY0NCB0b29scy90ZXN0aW5nL3NlbGZ0ZXN0 cy9yaXNjdi9taXNhbGlnbmVkL2ZwdS5TCiBjcmVhdGUgbW9kZSAxMDA2NDQgdG9vbHMvdGVzdGlu Zy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9ncC5TCiBjcmVhdGUgbW9kZSAxMDA2NDQgdG9v bHMvdGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9taXNhbGlnbmVkLmMKCmRpZmYg LS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkLy5naXRpZ25v cmUgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkLy5naXRpZ25vcmUK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi41ZWZmMTVhMWY5ODEKLS0t IC9kZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVk Ly5naXRpZ25vcmUKQEAgLTAsMCArMSBAQAorbWlzYWxpZ25lZApkaWZmIC0tZ2l0IGEvdG9vbHMv dGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9NYWtlZmlsZSBiL3Rvb2xzL3Rlc3Rp bmcvc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xYWE0MDExMGM1MGQKLS0tIC9kZXYvbnVsbAorKysgYi90 b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL01ha2VmaWxlCkBAIC0wLDAg KzEsMTIgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKyMgQ29weXJpZ2h0 IChDKSAyMDIxIEFSTSBMaW1pdGVkCisjIE9yaWdpbmFsbHkgdG9vbHMvdGVzdGluZy9hcm02NC9h YmkvTWFrZWZpbGUKKworQ0ZMQUdTICs9IC1JJCh0b3Bfc3JjZGlyKS90b29scy9pbmNsdWRlCisK K1RFU1RfR0VOX1BST0dTIDo9IG1pc2FsaWduZWQKKworaW5jbHVkZSAuLi8uLi9saWIubWsKKwor JChPVVRQVVQpL21pc2FsaWduZWQ6IG1pc2FsaWduZWQuYyBmcHUuUyBncC5TCisJJChDQykgLWcz IC1zdGF0aWMgLW8kQCAtbWFyY2g9cnY2NGltYWZkYyAkKENGTEFHUykgJChMREZMQUdTKSAkXgpk aWZmIC0tZ2l0IGEvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9jb21t b24uUyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQvY29tbW9uLlMK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi44ZmEwMDAzNWJkNWQKLS0t IC9kZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVk L2NvbW1vbi5TCkBAIC0wLDAgKzEsMzMgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wLW9ubHkgKi8KKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoK KyAqIEF1dGhvcnM6CisgKiAgICAgQ2zDqW1lbnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29t PgorICovCisKKy5tYWNybyBsYl9zYiB0ZW1wLCBvZmZzZXQsIHNyYywgZHN0CisJbGIgXHRlbXAs IFxvZmZzZXQoXHNyYykKKwlzYiBcdGVtcCwgXG9mZnNldChcZHN0KQorLmVuZG0KKworLm1hY3Jv IGNvcHlfbG9uZ190byB0ZW1wLCBzcmMsIGRzdAorCWxiX3NiIFx0ZW1wLCAwLCBcc3JjLCBcZHN0 LAorCWxiX3NiIFx0ZW1wLCAxLCBcc3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCAyLCBcc3JjLCBc ZHN0LAorCWxiX3NiIFx0ZW1wLCAzLCBcc3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA0LCBcc3Jj LCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA1LCBcc3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA2LCBc c3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA3LCBcc3JjLCBcZHN0LAorLmVuZG0KKworLm1hY3Jv IHNwX3N0YWNrX3Byb2xvZ3VlIG9mZnNldAorCWFkZGkgc3AsIHNwLCAtOAorCXN1YiBzcCwgc3As IFxvZmZzZXQKKy5lbmRtCisKKy5tYWNybyBzcF9zdGFja19lcGlsb2d1ZSBvZmZzZXQKKwlhZGQg c3AsIHNwLCBcb2Zmc2V0CisJYWRkaSBzcCwgc3AsIDgKKy5lbmRtCmRpZmYgLS1naXQgYS90b29s cy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2ZwdS5TIGIvdG9vbHMvdGVzdGlu Zy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9mcHUuUwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAuLmQwMDhiZmY1ODMxMAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xz L3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQvZnB1LlMKQEAgLTAsMCArMSwxODAg QEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KKy8qCisgKiBD b3B5cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoKKyAqIEF1dGhvcnM6CisgKiAgICAgQ2zD qW1lbnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29tPgorICovCisKKyNpbmNsdWRlICJjb21t b24uUyIKKworI2RlZmluZSBDQVNFX0FMSUdOCQk0CisKKy5tYWNybyBmcHVfbG9hZF9pbnN0IGZw cmVnLCBpbnN0LCBwcmVjaXNpb24sIGxvYWRfcmVnCisuYWxpZ24gQ0FTRV9BTElHTgorCVxpbnN0 IFxmcHJlZywgMChcbG9hZF9yZWcpCisJZm12LlxwcmVjaXNpb24gZmEwLCBcZnByZWcKKwlqIDJm CisuZW5kbQorCisjZGVmaW5lIGZsdyhfX2ZwcmVnKSBmcHVfbG9hZF9pbnN0IF9fZnByZWcsIGZs dywgcywgczEKKyNkZWZpbmUgZmxkKF9fZnByZWcpIGZwdV9sb2FkX2luc3QgX19mcHJlZywgZmxk LCBkLCBzMQorI2RlZmluZSBjX2ZsdyhfX2ZwcmVnKSBmcHVfbG9hZF9pbnN0IF9fZnByZWcsIGMu Zmx3LCBzLCBzMQorI2RlZmluZSBjX2ZsZChfX2ZwcmVnKSBmcHVfbG9hZF9pbnN0IF9fZnByZWcs IGMuZmxkLCBkLCBzMQorI2RlZmluZSBjX2ZsZHNwKF9fZnByZWcpIGZwdV9sb2FkX2luc3QgX19m cHJlZywgYy5mbGRzcCwgZCwgc3AKKworLm1hY3JvIGZwdV9zdG9yZV9pbnN0IGZwcmVnLCBpbnN0 LCBwcmVjaXNpb24sIHN0b3JlX3JlZworLmFsaWduIENBU0VfQUxJR04KKwlmbXYuXHByZWNpc2lv biBcZnByZWcsIGZhMAorCVxpbnN0IFxmcHJlZywgMChcc3RvcmVfcmVnKQorCWogMmYKKy5lbmRt CisKKyNkZWZpbmUgZnN3KF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnByZWcsIGZzdywgcywg czEKKyNkZWZpbmUgZnNkKF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnByZWcsIGZzZCwgZCwg czEKKyNkZWZpbmUgY19mc3coX19mcHJlZykgZnB1X3N0b3JlX2luc3QgX19mcHJlZywgYy5mc3cs IHMsIHMxCisjZGVmaW5lIGNfZnNkKF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnByZWcsIGMu ZnNkLCBkLCBzMQorI2RlZmluZSBjX2ZzZHNwKF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnBy ZWcsIGMuZnNkc3AsIGQsIHNwCisKKy5tYWNybyBmcF90ZXN0X3Byb2xvZ3VlCisJbW92ZSBzMSwg YTEKKwkvKgorCSAqIENvbXB1dGUganVtcCBvZmZzZXQgdG8gc3RvcmUgdGhlIGNvcnJlY3QgRlAg cmVnaXN0ZXIgc2luY2Ugd2UgZG9uJ3QKKwkgKiBoYXZlIGluZGlyZWN0IEZQIHJlZ2lzdGVyIGFj Y2VzcyAob3IgYXQgbGVhc3Qgd2UgZG9uJ3QgdXNlIHRoaXMKKwkgKiBleHRlbnNpb24gc28gdGhh dCB3b3JrcyBvbiBhbGwgYXJjaHMpCisJICovCisJc2xsIHQwLCBhMCwgQ0FTRV9BTElHTgorCWxh IHQyLCAxZgorCWFkZCB0MCwgdDAsIHQyCisJanIgdDAKKy5hbGlnbglDQVNFX0FMSUdOCisxOgor LmVuZG0KKworLm1hY3JvIGZwX3Rlc3RfcHJvbG9ndWVfY29tcHJlc3NlZAorCS8qIEZQIHJlZ2lz dGVycyBmb3IgY29tcHJlc3NlZCBpbnN0cnVjdGlvbnMgc3RhcnRzIGZyb20gOCB0byAxNiAqLwor CWFkZGkgYTAsIGEwLCAtOAorCWZwX3Rlc3RfcHJvbG9ndWUKKy5lbmRtCisKKyNkZWZpbmUgZnBf dGVzdF9ib2R5X2NvbXByZXNzZWQoX19pbnN0X2Z1bmMpIFwKKwlfX2luc3RfZnVuYyhmOCk7IFwK KwlfX2luc3RfZnVuYyhmOSk7IFwKKwlfX2luc3RfZnVuYyhmMTApOyBcCisJX19pbnN0X2Z1bmMo ZjExKTsgXAorCV9faW5zdF9mdW5jKGYxMik7IFwKKwlfX2luc3RfZnVuYyhmMTMpOyBcCisJX19p bnN0X2Z1bmMoZjE0KTsgXAorCV9faW5zdF9mdW5jKGYxNSk7IFwKKzI6CisKKyNkZWZpbmUgZnBf dGVzdF9ib2R5KF9faW5zdF9mdW5jKSBcCisJX19pbnN0X2Z1bmMoZjApOyBcCisJX19pbnN0X2Z1 bmMoZjEpOyBcCisJX19pbnN0X2Z1bmMoZjIpOyBcCisJX19pbnN0X2Z1bmMoZjMpOyBcCisJX19p bnN0X2Z1bmMoZjQpOyBcCisJX19pbnN0X2Z1bmMoZjUpOyBcCisJX19pbnN0X2Z1bmMoZjYpOyBc CisJX19pbnN0X2Z1bmMoZjcpOyBcCisJX19pbnN0X2Z1bmMoZjgpOyBcCisJX19pbnN0X2Z1bmMo ZjkpOyBcCisJX19pbnN0X2Z1bmMoZjEwKTsgXAorCV9faW5zdF9mdW5jKGYxMSk7IFwKKwlfX2lu c3RfZnVuYyhmMTIpOyBcCisJX19pbnN0X2Z1bmMoZjEzKTsgXAorCV9faW5zdF9mdW5jKGYxNCk7 IFwKKwlfX2luc3RfZnVuYyhmMTUpOyBcCisJX19pbnN0X2Z1bmMoZjE2KTsgXAorCV9faW5zdF9m dW5jKGYxNyk7IFwKKwlfX2luc3RfZnVuYyhmMTgpOyBcCisJX19pbnN0X2Z1bmMoZjE5KTsgXAor CV9faW5zdF9mdW5jKGYyMCk7IFwKKwlfX2luc3RfZnVuYyhmMjEpOyBcCisJX19pbnN0X2Z1bmMo ZjIyKTsgXAorCV9faW5zdF9mdW5jKGYyMyk7IFwKKwlfX2luc3RfZnVuYyhmMjQpOyBcCisJX19p bnN0X2Z1bmMoZjI1KTsgXAorCV9faW5zdF9mdW5jKGYyNik7IFwKKwlfX2luc3RfZnVuYyhmMjcp OyBcCisJX19pbnN0X2Z1bmMoZjI4KTsgXAorCV9faW5zdF9mdW5jKGYyOSk7IFwKKwlfX2luc3Rf ZnVuYyhmMzApOyBcCisJX19pbnN0X2Z1bmMoZjMxKTsgXAorMjoKKy50ZXh0CisKKyNkZWZpbmUg X19nZW5fdGVzdF9pbnN0KF9faW5zdCwgX19zdWZmaXgpIFwKKy5nbG9iYWwgdGVzdF8gIyMgX19p bnN0OyBcCit0ZXN0XyAjIyBfX2luc3Q6OyBcCisJZnBfdGVzdF9wcm9sb2d1ZSAjIyBfX3N1ZmZp eDsgXAorCWZwX3Rlc3RfYm9keSAjIyBfX3N1ZmZpeChfX2luc3QpOyBcCisJcmV0CisKKyNkZWZp bmUgZ2VuX3Rlc3RfaW5zdF9jb21wcmVzc2VkKF9faW5zdCkgXAorCS5vcHRpb24gYXJjaCwrYzsg XAorCV9fZ2VuX3Rlc3RfaW5zdChjXyAjIyBfX2luc3QsIF9jb21wcmVzc2VkKQorCisjZGVmaW5l IGdlbl90ZXN0X2luc3QoX19pbnN0KSBcCisJLmJhbGlnbiAxNjsgXAorCS5vcHRpb24gcHVzaDsg XAorCS5vcHRpb24gYXJjaCwtYzsgXAorCV9fZ2VuX3Rlc3RfaW5zdChfX2luc3QsICk7IFwKKwku b3B0aW9uIHBvcAorCisubWFjcm8gZnBfdGVzdF9wcm9sb2d1ZV9sb2FkX2NvbXByZXNzZWRfc3AK Kwljb3B5X2xvbmdfdG8gdDAsIGExLCBzcAorLmVuZG0KKworLm1hY3JvIGZwX3Rlc3RfZXBpbG9n dWVfbG9hZF9jb21wcmVzc2VkX3NwCisuZW5kbQorCisubWFjcm8gZnBfdGVzdF9wcm9sb2d1ZV9z dG9yZV9jb21wcmVzc2VkX3NwCisuZW5kbQorCisubWFjcm8gZnBfdGVzdF9lcGlsb2d1ZV9zdG9y ZV9jb21wcmVzc2VkX3NwCisJY29weV9sb25nX3RvIHQwLCBzcCwgYTEKKy5lbmRtCisKKyNkZWZp bmUgZ2VuX2luc3RfY29tcHJlc3NlZF9zcChfX2luc3QsIF9fdHlwZSkgXAorCS5nbG9iYWwgdGVz dF9jXyAjIyBfX2luc3QgIyMgc3A7IFwKKwl0ZXN0X2NfICMjIF9faW5zdCAjIyBzcDo7IFwKKwkJ c3Bfc3RhY2tfcHJvbG9ndWUgYTI7IFwKKwkJZnBfdGVzdF9wcm9sb2d1ZV8jIyBfX3R5cGUgIyMg X2NvbXByZXNzZWRfc3A7IFwKKwkJZnBfdGVzdF9wcm9sb2d1ZV9jb21wcmVzc2VkOyBcCisJCWZw X3Rlc3RfYm9keV9jb21wcmVzc2VkKGNfICMjIF9faW5zdCAjIyBzcCk7IFwKKwkJZnBfdGVzdF9l cGlsb2d1ZV8jIyBfX3R5cGUgIyMgX2NvbXByZXNzZWRfc3A7IFwKKwkJc3Bfc3RhY2tfZXBpbG9n dWUgYTI7IFwKKwkJcmV0CisKKyNkZWZpbmUgZ2VuX3Rlc3RfbG9hZF9jb21wcmVzc2VkX3NwKF9f aW5zdCkgZ2VuX2luc3RfY29tcHJlc3NlZF9zcChfX2luc3QsIGxvYWQpCisjZGVmaW5lIGdlbl90 ZXN0X3N0b3JlX2NvbXByZXNzZWRfc3AoX19pbnN0KSBnZW5faW5zdF9jb21wcmVzc2VkX3NwKF9f aW5zdCwgc3RvcmUpCisKKy8qCisgKiBmbG9hdF9mc3dfcmVnIC0gU2V0IGEgRlAgcmVnaXN0ZXIg ZnJvbSBhIHJlZ2lzdGVyIGNvbnRhaW5pbmcgdGhlIHZhbHVlCisgKiBhMCA9IEZQIHJlZ2lzdGVy IGluZGV4IHRvIGJlIHNldAorICogYTEgPSBhZGRyIHdoZXJlIHRvIHN0b3JlIHJlZ2lzdGVyIHZh bHVlCisgKiBhMiA9IGFkZHJlc3Mgb2Zmc2V0CisgKiBhMyA9IHZhbHVlIHRvIGJlIHN0b3JlCisg Ki8KK2dlbl90ZXN0X2luc3QoZnN3KQorCisvKgorICogZmxvYXRfZmx3X3JlZyAtIEdldCBhIEZQ IHJlZ2lzdGVyIHZhbHVlIGFuZCByZXR1cm4gaXQKKyAqIGEwID0gRlAgcmVnaXN0ZXIgaW5kZXgg dG8gYmUgcmV0cmlldmVkCisgKiBhMSA9IGFkZHIgdG8gbG9hZCByZWdpc3RlciBmcm9tCisgKiBh MiA9IGFkZHJlc3Mgb2Zmc2V0CisgKi8KK2dlbl90ZXN0X2luc3QoZmx3KQorCitnZW5fdGVzdF9p bnN0KGZzZCkKKyNpZmRlZiBfX3Jpc2N2X2NvbXByZXNzZWQKK2dlbl90ZXN0X2luc3RfY29tcHJl c3NlZChmc2QpCitnZW5fdGVzdF9zdG9yZV9jb21wcmVzc2VkX3NwKGZzZCkKKyNlbmRpZgorCitn ZW5fdGVzdF9pbnN0KGZsZCkKKyNpZmRlZiBfX3Jpc2N2X2NvbXByZXNzZWQKK2dlbl90ZXN0X2lu c3RfY29tcHJlc3NlZChmbGQpCitnZW5fdGVzdF9sb2FkX2NvbXByZXNzZWRfc3AoZmxkKQorI2Vu ZGlmCmRpZmYgLS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVk L2dwLlMgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2dwLlMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mNTNmNGM2ZDgxZGQKLS0tIC9k ZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2dw LlMKQEAgLTAsMCArMSwxMDMgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w LW9ubHkgKi8KKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoKKyAqIEF1 dGhvcnM6CisgKiAgICAgQ2zDqW1lbnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29tPgorICov CisKKyNpbmNsdWRlICJjb21tb24uUyIKKworLnRleHQKKworLm1hY3JvIF9fZ2VuX3Rlc3RfaW5z dCBpbnN0LCBzcmNfcmVnCisJXGluc3QgYTIsIDAoXHNyY19yZWcpCisJbW92ZSBhMCwgYTIKKy5l bmRtCisKKy5tYWNybyBnZW5fZnVuY19oZWFkZXIgZnVuY19uYW1lLCBydmMKKwkub3B0aW9uIGFy Y2gsXHJ2YworCS5nbG9iYWwgdGVzdF9cZnVuY19uYW1lCisJdGVzdF9cZnVuY19uYW1lOgorLmVu ZG0KKworLm1hY3JvIGdlbl90ZXN0X2luc3QgaW5zdAorCS5vcHRpb24gcHVzaAorCWdlbl9mdW5j X2hlYWRlciBcaW5zdCwgLWMKKwlfX2dlbl90ZXN0X2luc3QgXGluc3QsIGEwCisJLm9wdGlvbiBw b3AKKwlyZXQKKy5lbmRtCisKKy5tYWNybyBfX2dlbl90ZXN0X2luc3RfYyBuYW1lLCBzcmNfcmVn CisJLm9wdGlvbiBwdXNoCisJZ2VuX2Z1bmNfaGVhZGVyIGNfXG5hbWUsICtjCisJIF9fZ2VuX3Rl c3RfaW5zdCBjLlxuYW1lLCBcc3JjX3JlZworCS5vcHRpb24gcG9wCisJcmV0CisuZW5kbQorCisu bWFjcm8gZ2VuX3Rlc3RfaW5zdF9jIG5hbWUKKyAJX19nZW5fdGVzdF9pbnN0X2MgXG5hbWUsIGEw CisuZW5kbQorCisKKy5tYWNybyBnZW5fdGVzdF9pbnN0X2xvYWRfY19zcCBuYW1lCisJLm9wdGlv biBwdXNoCisJZ2VuX2Z1bmNfaGVhZGVyIGNfXG5hbWVcKClzcCwgK2MKKwlzcF9zdGFja19wcm9s b2d1ZSBhMQorCWNvcHlfbG9uZ190byB0MCwgYTAsIHNwCisJYy5sZHNwIGEwLCAwKHNwKQorCXNw X3N0YWNrX2VwaWxvZ3VlIGExCisJLm9wdGlvbiBwb3AKKwlyZXQKKy5lbmRtCisKKy5tYWNybyBs Yl9zcF9zYl9hMCByZWcsIG9mZnNldAorCWxiX3NiIFxyZWcsIFxvZmZzZXQsIHNwLCBhMAorLmVu ZG0KKworLm1hY3JvIGdlbl90ZXN0X2luc3Rfc3RvcmVfY19zcCBpbnN0X25hbWUKKwkub3B0aW9u IHB1c2gKKwlnZW5fZnVuY19oZWFkZXIgY19caW5zdF9uYW1lXCgpc3AsICtjCisJLyogTWlzYWxp Z24gc3RhY2sgcG9pbnRlciAqLworCXNwX3N0YWNrX3Byb2xvZ3VlIGExCisJLyogTWlzYWxpZ24g YWNjZXNzICovCisJYy5zZHNwIGEyLCAwKHNwKQorCWNvcHlfbG9uZ190byB0MCwgc3AsIGEwCisJ c3Bfc3RhY2tfZXBpbG9ndWUgYTEKKwkub3B0aW9uIHBvcAorCXJldAorLmVuZG0KKworCisgLyoK KyAqIGEwID0gYWRkciB0byBsb2FkIGZyb20KKyAqIGExID0gYWRkcmVzcyBvZmZzZXQKKyAqIGEy ID0gdmFsdWUgdG8gYmUgbG9hZGVkCisgKi8KK2dlbl90ZXN0X2luc3QgbGgKK2dlbl90ZXN0X2lu c3QgbGh1CitnZW5fdGVzdF9pbnN0IGx3CitnZW5fdGVzdF9pbnN0IGx3dQorZ2VuX3Rlc3RfaW5z dCBsZAorI2lmZGVmIF9fcmlzY3ZfY29tcHJlc3NlZAorZ2VuX3Rlc3RfaW5zdF9jIGx3CitnZW5f dGVzdF9pbnN0X2MgbGQKK2dlbl90ZXN0X2luc3RfbG9hZF9jX3NwIGxkCisjZW5kaWYKKworLyoK KyAqIGEwID0gYWRkciB3aGVyZSB0byBzdG9yZSB2YWx1ZQorICogYTEgPSBhZGRyZXNzIG9mZnNl dAorICogYTIgPSB2YWx1ZSB0byBiZSBzdG9yZWQKKyAqLworZ2VuX3Rlc3RfaW5zdCBzaAorZ2Vu X3Rlc3RfaW5zdCBzdworZ2VuX3Rlc3RfaW5zdCBzZAorI2lmZGVmIF9fcmlzY3ZfY29tcHJlc3Nl ZAorZ2VuX3Rlc3RfaW5zdF9jIHN3CitnZW5fdGVzdF9pbnN0X2Mgc2QKK2dlbl90ZXN0X2luc3Rf c3RvcmVfY19zcCBzZAorI2VuZGlmCisKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRl c3RzL3Jpc2N2L21pc2FsaWduZWQvbWlzYWxpZ25lZC5jIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVz dHMvcmlzY3YvbWlzYWxpZ25lZC9taXNhbGlnbmVkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi5jNjZhYTg3ZWMwM2UKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy90 ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL21pc2FsaWduZWQuYwpAQCAtMCwwICsx LDI1NCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBDb3B5 cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoKKyAqIEF1dGhvcnM6CisgKiAgICAgQ2zDqW1l bnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29tPgorICovCisjaW5jbHVkZSA8c2lnbmFsLmg+ CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxsaW51 eC9wdHJhY2UuaD4KKyNpbmNsdWRlICIuLi8uLi9rc2VsZnRlc3RfaGFybmVzcy5oIgorCisjaW5j bHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRpbnQuaD4K KyNpbmNsdWRlIDxmbG9hdC5oPgorI2luY2x1ZGUgPGVycm5vLmg+CisjaW5jbHVkZSA8bWF0aC5o PgorI2luY2x1ZGUgPHN0cmluZy5oPgorI2luY2x1ZGUgPHNpZ25hbC5oPgorI2luY2x1ZGUgPHN0 ZGJvb2wuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDxpbnR0eXBlcy5oPgorI2lu Y2x1ZGUgPHVjb250ZXh0Lmg+CisKKyNpbmNsdWRlIDxzeXMvcHJjdGwuaD4KKworI2RlZmluZSBz dHJpbmdpZnkocykgX19zdHJpbmdpZnkocykKKyNkZWZpbmUgX19zdHJpbmdpZnkocykgI3MKKwor I2RlZmluZSBWQUwxNgkweDEyMzQKKyNkZWZpbmUgVkFMMzIJMHhERUFEQkVFRgorI2RlZmluZSBW QUw2NAkweDQ1Njc0MzIxRDAwREY3ODkKKworI2RlZmluZSBWQUxfZmxvYXQJNzg5NTEuMjM0Mzc1 CisjZGVmaW5lIFZBTF9kb3VibGUJNTY3ODkwLjUxMjM5Njk2NTc4OTU4OTI5MAorCitzdGF0aWMg Ym9vbCBmbG9hdF9lcXVhbChmbG9hdCBhLCBmbG9hdCBiKQoreworCWZsb2F0IHNjYWxlZF9lcHNp bG9uOworCWZsb2F0IGRpZmZlcmVuY2UgPSBmYWJzZihhIC0gYik7CisKKwkvLyBTY2FsZSB0byB0 aGUgbGFyZ2VzdCB2YWx1ZS4KKwlhID0gZmFic2YoYSk7CisJYiA9IGZhYnNmKGIpOworCWlmIChh ID4gYikKKwkJc2NhbGVkX2Vwc2lsb24gPSBGTFRfRVBTSUxPTiAqIGE7CisJZWxzZQorCQlzY2Fs ZWRfZXBzaWxvbiA9IEZMVF9FUFNJTE9OICogYjsKKworCXJldHVybiBkaWZmZXJlbmNlIDw9IHNj YWxlZF9lcHNpbG9uOworfQorCitzdGF0aWMgYm9vbCBkb3VibGVfZXF1YWwoZG91YmxlIGEsIGRv dWJsZSBiKQoreworCWRvdWJsZSBzY2FsZWRfZXBzaWxvbjsKKwlkb3VibGUgZGlmZmVyZW5jZSA9 IGZhYnNmKGEgLSBiKTsKKworCS8vIFNjYWxlIHRvIHRoZSBsYXJnZXN0IHZhbHVlLgorCWEgPSBm YWJzKGEpOworCWIgPSBmYWJzKGIpOworCWlmIChhID4gYikKKwkJc2NhbGVkX2Vwc2lsb24gPSBE QkxfRVBTSUxPTiAqIGE7CisJZWxzZQorCQlzY2FsZWRfZXBzaWxvbiA9IERCTF9FUFNJTE9OICog YjsKKworCXJldHVybiBkaWZmZXJlbmNlIDw9IHNjYWxlZF9lcHNpbG9uOworfQorCisjZGVmaW5l IGZwdV9sb2FkX3Byb3RvKF9faW5zdCwgX190eXBlKSBcCitleHRlcm4gX190eXBlIHRlc3RfICMj IF9faW5zdCh1bnNpZ25lZCBsb25nIGZwX3JlZywgdm9pZCAqYWRkciwgdW5zaWduZWQgbG9uZyBv ZmZzZXQsIF9fdHlwZSB2YWx1ZSkKKworZnB1X2xvYWRfcHJvdG8oZmx3LCBmbG9hdCk7CitmcHVf bG9hZF9wcm90byhmbGQsIGRvdWJsZSk7CitmcHVfbG9hZF9wcm90byhjX2ZsdywgZmxvYXQpOwor ZnB1X2xvYWRfcHJvdG8oY19mbGQsIGRvdWJsZSk7CitmcHVfbG9hZF9wcm90byhjX2ZsZHNwLCBk b3VibGUpOworCisjZGVmaW5lIGZwdV9zdG9yZV9wcm90byhfX2luc3QsIF9fdHlwZSkgXAorZXh0 ZXJuIHZvaWQgdGVzdF8gIyMgX19pbnN0KHVuc2lnbmVkIGxvbmcgZnBfcmVnLCB2b2lkICphZGRy LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgX190eXBlIHZhbHVlKQorCitmcHVfc3RvcmVfcHJvdG8o ZnN3LCBmbG9hdCk7CitmcHVfc3RvcmVfcHJvdG8oZnNkLCBkb3VibGUpOworZnB1X3N0b3JlX3By b3RvKGNfZnN3LCBmbG9hdCk7CitmcHVfc3RvcmVfcHJvdG8oY19mc2QsIGRvdWJsZSk7CitmcHVf c3RvcmVfcHJvdG8oY19mc2RzcCwgZG91YmxlKTsKKworI2RlZmluZSBncF9sb2FkX3Byb3RvKF9f aW5zdCwgX190eXBlKSBcCitleHRlcm4gX190eXBlIHRlc3RfICMjIF9faW5zdCh2b2lkICphZGRy LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgX190eXBlIHZhbHVlKQorCitncF9sb2FkX3Byb3RvKGxo LCB1aW50MTZfdCk7CitncF9sb2FkX3Byb3RvKGxodSwgdWludDE2X3QpOworZ3BfbG9hZF9wcm90 byhsdywgdWludDMyX3QpOworZ3BfbG9hZF9wcm90byhsd3UsIHVpbnQzMl90KTsKK2dwX2xvYWRf cHJvdG8obGQsIHVpbnQ2NF90KTsKK2dwX2xvYWRfcHJvdG8oY19sdywgdWludDMyX3QpOworZ3Bf bG9hZF9wcm90byhjX2xkLCB1aW50NjRfdCk7CitncF9sb2FkX3Byb3RvKGNfbGRzcCwgdWludDY0 X3QpOworCisjZGVmaW5lIGdwX3N0b3JlX3Byb3RvKF9faW5zdCwgX190eXBlKSBcCitleHRlcm4g dm9pZCB0ZXN0XyAjIyBfX2luc3Qodm9pZCAqYWRkciwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIF9f dHlwZSB2YWx1ZSkKKworZ3Bfc3RvcmVfcHJvdG8oc2gsIHVpbnQxNl90KTsKK2dwX3N0b3JlX3By b3RvKHN3LCB1aW50MzJfdCk7CitncF9zdG9yZV9wcm90byhzZCwgdWludDY0X3QpOworZ3Bfc3Rv cmVfcHJvdG8oY19zdywgdWludDMyX3QpOworZ3Bfc3RvcmVfcHJvdG8oY19zZCwgdWludDY0X3Qp OworZ3Bfc3RvcmVfcHJvdG8oY19zZHNwLCB1aW50NjRfdCk7CisKKyNkZWZpbmUgVEVTVF9HUF9M T0FEKF9faW5zdCwgX190eXBlX3NpemUpCQkJCQlcCitURVNUKGdwX2xvYWRfICMjIF9faW5zdCkJ CQkJCQkJXAorewkJCQkJCQkJCQlcCisJaW50IG9mZnNldCwgcmV0OwkJCQkJCQlcCisJdWludDhf dCBidWZbMTZdIF9fYXR0cmlidXRlX18oKGFsaWduZWQoMTYpKSk7CQkJCVwKKwkJCQkJCQkJCQlc CisJcmV0ID0gcHJjdGwoUFJfU0VUX1VOQUxJR04sIFBSX1VOQUxJR05fTk9QUklOVCk7CQkJXAor CUFTU0VSVF9FUShyZXQsIDApOwkJCQkJCQlcCisJCQkJCQkJCQkJXAorCWZvciAob2Zmc2V0ID0g MTsgb2Zmc2V0IDwgX190eXBlX3NpemUgLyA4OyBvZmZzZXQrKykgewkJCVwKKwkJdWludCAjIyBf X3R5cGVfc2l6ZSAjIyBfdCB2YWwgPSBWQUwgIyMgX190eXBlX3NpemU7CQlcCisJCXVpbnQgIyMg X190eXBlX3NpemUgIyMgX3QgKnB0ciA9ICh1aW50ICMjIF9fdHlwZV9zaXplICMjIF90ICopIChi dWYgKyBvZmZzZXQpOyBcCisJCW1lbWNweShwdHIsICZ2YWwsIHNpemVvZih2YWwpKTsJCQkJCVwK KwkJdmFsID0gdGVzdF8gIyMgX19pbnN0KHB0ciwgb2Zmc2V0LCB2YWwpOwkJCVwKKwkJRVhQRUNU X0VRKFZBTCAjIyBfX3R5cGVfc2l6ZSwgdmFsKTsJCQkJXAorCX0JCQkJCQkJCQlcCit9CisKK1RF U1RfR1BfTE9BRChsaCwgMTYpOworVEVTVF9HUF9MT0FEKGxodSwgMTYpOworVEVTVF9HUF9MT0FE KGx3LCAzMik7CitURVNUX0dQX0xPQUQobHd1LCAzMik7CitURVNUX0dQX0xPQUQobGQsIDY0KTsK KyNpZmRlZiBfX3Jpc2N2X2NvbXByZXNzZWQKK1RFU1RfR1BfTE9BRChjX2x3LCAzMik7CitURVNU X0dQX0xPQUQoY19sZCwgNjQpOworVEVTVF9HUF9MT0FEKGNfbGRzcCwgNjQpOworI2VuZGlmCisK KyNkZWZpbmUgVEVTVF9HUF9TVE9SRShfX2luc3QsIF9fdHlwZV9zaXplKQkJCQkJXAorVEVTVChn cF9sb2FkXyAjIyBfX2luc3QpCQkJCQkJCVwKK3sJCQkJCQkJCQkJXAorCWludCBvZmZzZXQsIHJl dDsJCQkJCQkJXAorCXVpbnQ4X3QgYnVmWzE2XSBfX2F0dHJpYnV0ZV9fKChhbGlnbmVkKDE2KSkp OwkJCQlcCisJCQkJCQkJCQkJXAorCXJldCA9IHByY3RsKFBSX1NFVF9VTkFMSUdOLCBQUl9VTkFM SUdOX05PUFJJTlQpOwkJCVwKKwlBU1NFUlRfRVEocmV0LCAwKTsJCQkJCQkJXAorCQkJCQkJCQkJ CVwKKwlmb3IgKG9mZnNldCA9IDE7IG9mZnNldCA8IF9fdHlwZV9zaXplIC8gODsgb2Zmc2V0Kysp IHsJCQlcCisJCXVpbnQgIyMgX190eXBlX3NpemUgIyMgX3QgdmFsID0gVkFMICMjIF9fdHlwZV9z aXplOwkJXAorCQl1aW50ICMjIF9fdHlwZV9zaXplICMjIF90ICpwdHIgPSAodWludCAjIyBfX3R5 cGVfc2l6ZSAjIyBfdCAqKSAoYnVmICsgb2Zmc2V0KTsgXAorCQltZW1zZXQocHRyLCAwLCBzaXpl b2YodmFsKSk7CQkJCQlcCisJCXRlc3RfICMjIF9faW5zdChwdHIsIG9mZnNldCwgdmFsKTsJCQkJ XAorCQltZW1jcHkoJnZhbCwgcHRyLCBzaXplb2YodmFsKSk7CQkJCQlcCisJCUVYUEVDVF9FUShW QUwgIyMgX190eXBlX3NpemUsIHZhbCk7CQkJCVwKKwl9CQkJCQkJCQkJXAorfQorVEVTVF9HUF9T VE9SRShzaCwgMTYpOworVEVTVF9HUF9TVE9SRShzdywgMzIpOworVEVTVF9HUF9TVE9SRShzZCwg NjQpOworI2lmZGVmIF9fcmlzY3ZfY29tcHJlc3NlZAorVEVTVF9HUF9TVE9SRShjX3N3LCAzMik7 CitURVNUX0dQX1NUT1JFKGNfc2QsIDY0KTsKK1RFU1RfR1BfU1RPUkUoY19zZHNwLCA2NCk7Cisj ZW5kaWYKKworI2RlZmluZSBfX1RFU1RfRlBVX0xPQUQoX190eXBlLCBfX2luc3QsIF9fcmVnX3N0 YXJ0LCBfX3JlZ19lbmQpCQkJXAorVEVTVChmcHVfbG9hZF8gIyMgX19pbnN0KQkJCQkJCQlcCit7 CQkJCQkJCQkJCVwKKwlpbnQgaSwgcmV0LCBvZmZzZXQsIGZwX3JlZzsJCQkJCQlcCisJdWludDhf dCBidWZbMTZdIF9fYXR0cmlidXRlX18oKGFsaWduZWQoMTYpKSk7CQkJCVwKKwkJCQkJCQkJCQlc CisJcmV0ID0gcHJjdGwoUFJfU0VUX1VOQUxJR04sIFBSX1VOQUxJR05fTk9QUklOVCk7CQkJXAor CUFTU0VSVF9FUShyZXQsIDApOwkJCQkJCQlcCisJCQkJCQkJCQkJXAorCWZvciAoZnBfcmVnID0g X19yZWdfc3RhcnQ7IGZwX3JlZyA8IF9fcmVnX2VuZDsgZnBfcmVnKyspIHsJCVwKKwkJZm9yIChv ZmZzZXQgPSAxOyBvZmZzZXQgPCA0OyBvZmZzZXQrKykgewkJCVwKKwkJCXZvaWQgKmxvYWRfYWRk ciA9IChidWYgKyBvZmZzZXQpOwkJCVwKKwkJCV9fdHlwZSB2YWwgPSBWQUxfICMjIF9fdHlwZSA7 CQkJCVwKKwkJCQkJCQkJCQlcCisJCQltZW1jcHkobG9hZF9hZGRyLCAmdmFsLCBzaXplb2YodmFs KSk7CQkJXAorCQkJdmFsID0gdGVzdF8gIyMgX19pbnN0KGZwX3JlZywgbG9hZF9hZGRyLCBvZmZz ZXQsIHZhbCk7CVwKKwkJCUVYUEVDVF9UUlVFKF9fdHlwZSAjI19lcXVhbCh2YWwsIFZBTF8jIyBf X3R5cGUpKTsJXAorCQl9CQkJCQkJCQlcCisJfQkJCQkJCQkJCVwKK30KKyNkZWZpbmUgVEVTVF9G UFVfTE9BRChfX3R5cGUsIF9faW5zdCkgXAorCV9fVEVTVF9GUFVfTE9BRChfX3R5cGUsIF9faW5z dCwgMCwgMzIpCisjZGVmaW5lIFRFU1RfRlBVX0xPQURfQ09NUFJFU1NFRChfX3R5cGUsIF9faW5z dCkgXAorCV9fVEVTVF9GUFVfTE9BRChfX3R5cGUsIF9faW5zdCwgOCwgMTYpCisKK1RFU1RfRlBV X0xPQUQoZmxvYXQsIGZsdykKK1RFU1RfRlBVX0xPQUQoZG91YmxlLCBmbGQpCisjaWZkZWYgX19y aXNjdl9jb21wcmVzc2VkCitURVNUX0ZQVV9MT0FEX0NPTVBSRVNTRUQoZG91YmxlLCBjX2ZsZCkK K1RFU1RfRlBVX0xPQURfQ09NUFJFU1NFRChkb3VibGUsIGNfZmxkc3ApCisjZW5kaWYKKworI2Rl ZmluZSBfX1RFU1RfRlBVX1NUT1JFKF9fdHlwZSwgX19pbnN0LCBfX3JlZ19zdGFydCwgX19yZWdf ZW5kKQkJXAorVEVTVChmcHVfc3RvcmVfICMjIF9faW5zdCkJCQkJCQkJXAorewkJCQkJCQkJCQlc CisJaW50IGksIHJldCwgb2Zmc2V0LCBmcF9yZWc7CQkJCQkJXAorCXVpbnQ4X3QgYnVmWzE2XSBf X2F0dHJpYnV0ZV9fKChhbGlnbmVkKDE2KSkpOwkJCQlcCisJCQkJCQkJCQkJXAorCXJldCA9IHBy Y3RsKFBSX1NFVF9VTkFMSUdOLCBQUl9VTkFMSUdOX05PUFJJTlQpOwkJCVwKKwlBU1NFUlRfRVEo cmV0LCAwKTsJCQkJCQkJXAorCQkJCQkJCQkJCVwKKwlmb3IgKGZwX3JlZyA9IF9fcmVnX3N0YXJ0 OyBmcF9yZWcgPCBfX3JlZ19lbmQ7IGZwX3JlZysrKSB7CQlcCisJCWZvciAob2Zmc2V0ID0gMTsg b2Zmc2V0IDwgNDsgb2Zmc2V0KyspIHsJCQlcCisJCQkJCQkJCQkJXAorCQkJdm9pZCAqc3RvcmVf YWRkciA9IChidWYgKyBvZmZzZXQpOwkJCVwKKwkJCV9fdHlwZSB2YWwgPSBWQUxfICMjIF9fdHlw ZSA7CQkJCVwKKwkJCQkJCQkJCQlcCisJCQl0ZXN0XyAjIyBfX2luc3QoZnBfcmVnLCBzdG9yZV9h ZGRyLCBvZmZzZXQsIHZhbCk7CVwKKwkJCW1lbWNweSgmdmFsLCBzdG9yZV9hZGRyLCBzaXplb2Yo dmFsKSk7CQkJXAorCQkJRVhQRUNUX1RSVUUoX190eXBlICMjIF9lcXVhbCh2YWwsIFZBTF8jIyBf X3R5cGUpKTsJXAorCQl9CQkJCQkJCQlcCisJfQkJCQkJCQkJCVwKK30KKyNkZWZpbmUgVEVTVF9G UFVfU1RPUkUoX190eXBlLCBfX2luc3QpIFwKKwlfX1RFU1RfRlBVX1NUT1JFKF9fdHlwZSwgX19p bnN0LCAwLCAzMikKKyNkZWZpbmUgVEVTVF9GUFVfU1RPUkVfQ09NUFJFU1NFRChfX3R5cGUsIF9f aW5zdCkgXAorCV9fVEVTVF9GUFVfU1RPUkUoX190eXBlLCBfX2luc3QsIDgsIDE2KQorCitURVNU X0ZQVV9TVE9SRShmbG9hdCwgZnN3KQorVEVTVF9GUFVfU1RPUkUoZG91YmxlLCBmc2QpCisjaWZk ZWYgX19yaXNjdl9jb21wcmVzc2VkCitURVNUX0ZQVV9TVE9SRV9DT01QUkVTU0VEKGRvdWJsZSwg Y19mc2QpCitURVNUX0ZQVV9TVE9SRV9DT01QUkVTU0VEKGRvdWJsZSwgY19mc2RzcCkKKyNlbmRp ZgorCitURVNUX1NJR05BTChnZW5fc2lnYnVzLCBTSUdCVVMpCit7CisJdWludDMyX3QgKnB0cjsK Kwl1aW50OF90IGJ1ZlsxNl0gX19hdHRyaWJ1dGVfXygoYWxpZ25lZCgxNikpKTsKKwlpbnQgcmV0 OworCisJcmV0ID0gcHJjdGwoUFJfU0VUX1VOQUxJR04sIFBSX1VOQUxJR05fU0lHQlVTKTsKKwlB U1NFUlRfRVEocmV0LCAwKTsKKworCXB0ciA9ICh1aW50MzJfdCAqKShidWYgKyAxKTsKKwkqcHRy ID0gMHhERUFEQkVFRlVMTDsKK30KKworaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKiphcmd2KQor eworCWludCByZXQsIHZhbDsKKworCXJldCA9IHByY3RsKFBSX0dFVF9VTkFMSUdOLCAmdmFsKTsK KwlpZiAocmV0ID09IC0xICYmIGVycm5vID09IEVJTlZBTCkKKwkJa3NmdF9leGl0X3NraXAoIlNL SVAgR0VUX1VOQUxJR05fQ1RMIG5vdCBzdXBwb3J0ZWRcbiIpOworCisJZXhpdCh0ZXN0X2hhcm5l c3NfcnVuKGFyZ2MsIGFyZ3YpKTsKK30KLS0gCjIuNDcuMgoKCi0tIAprdm0tcmlzY3YgbWFpbGlu ZyBsaXN0Cmt2bS1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRl YWQub3JnL21haWxtYW4vbGlzdGluZm8va3ZtLXJpc2N2Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com [209.85.214.174]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6D68422DFAD for ; Mon, 10 Mar 2025 15:14:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.174 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741619679; cv=none; b=Gipt4CvKe1buPO1d4J1InYKm4tXvEQ4DfukzcoZWWGVARlr8r6lQj3dW1vTyKsRLq1d61MBbMQ2UAdsPZY6PuCcXGWvS1/uvYwCPWeRNFqPFaDThajC0rhvpDbJa3QAeOtlm2IvCe6U2Ix81R+Arj0NxMahWKkuqg56L0Ce9DG0= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1741619679; c=relaxed/simple; bh=qX5so5AU+yLLimNIkDktcyO1mUKmJ4t5Tli6ol780Y8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=fJ+/bvJnuDbTi7RIMVcVF4A+0rTBBG4kVbvnlMx5awM0lJ1+W3KhqWr4xb8RC4afY1o4dHfFVNuAlGi9Zoh/qmYU9Ctz00iH4Il7PwVoUTqaWqOcWVijyZ/qiOEFUevcwrpzbgdhl9GWXpplbCyY0+VFAXYme6dw8o+hPJaFMMY= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=rivosinc.com; spf=pass smtp.mailfrom=rivosinc.com; dkim=pass (2048-bit key) header.d=rivosinc-com.20230601.gappssmtp.com header.i=@rivosinc-com.20230601.gappssmtp.com header.b=NE8GRrdt; arc=none smtp.client-ip=209.85.214.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=rivosinc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=rivosinc.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=rivosinc-com.20230601.gappssmtp.com header.i=@rivosinc-com.20230601.gappssmtp.com header.b="NE8GRrdt" Received: by mail-pl1-f174.google.com with SMTP id d9443c01a7336-224019ad9edso99877045ad.1 for ; Mon, 10 Mar 2025 08:14:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1741619677; x=1742224477; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=VKDplUA2XX/hbzyOxbYWLc7Q9RboQ/w3e3i+SZL4wNg=; b=NE8GRrdtx3xmPEHNoz/TCO2Dn63CI502MZTeV4HYloik5rIaTumvJZKvwyF5x5s9sz q2O9L/5vVUcaC56eSbUPlJ0pha/Cl/itzhTiYuQ5/vboG+YIWXaV1ahiYGAomePtz16c ZOUQPOdsmRzZNe+CJ2lKRAWfKW4K+f+pAc2rU6vZvUE6CTwDN6/EVHgg0tFJQVPFvR0b irK8i6S+d6uweEq/wgpEfdiFa+CYzwNABrKXUQaahxS5fTTWDBZkTkBuhkGO++bKjw6y d2FJJIozFzXfO6EsJ0N1hdDYVRXINEQ/Dx9Y6iuZ/hAKYwFYVJFduzIU9jM2rYRyG6Tv 2YIA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1741619677; x=1742224477; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=VKDplUA2XX/hbzyOxbYWLc7Q9RboQ/w3e3i+SZL4wNg=; b=D+MKVXubK/fRON+oDTCg0weOCVei2R0em4TRNGM1hGPMPcUX7QnRewpOUlewpggPBL 3qfq+FlE7K0WBS2wu+6MjiqjTqaaLK8vJNsrqgsg5x0E7ei/CwOGphSHQKJS8NOp2f/F uD+fmlOIQqGAh9c0/ppKEf5Q8TKy1Hp9lCUHftFLvs/wCW955iI2zVTNlRQ0Pv9p+dwS IW5pW8gG9qjvUJBCGvxCPfVQsrY69amYVitIgACDkfo1wQ1BCbOk44kWFVAqH3AGVmW5 S+ljZhwQKjzfVbR7JzzDnO3QSIiBnoF6b9TPHC30mf0IsD4QSr6k7NrWVylUPtHKjD8O en3A== X-Forwarded-Encrypted: i=1; AJvYcCX+tYqzUOFbTdLJbwmw6wd2IaKSLKkRQUpje9celofNFiSa607qVGdPvhv4MB47HoG/mMw=@vger.kernel.org X-Gm-Message-State: AOJu0YwIe2xxbGr1PeiNO+YIOHQbzqG9YK0xgD9yaujPj/+xqT0pGHyB jEAyaYksUm51bjZ7X/VcAAaLX83kpSHjwWjqHOMvyVgYTXcQo8Cwq0aLi00X0ZE= X-Gm-Gg: ASbGncunAwnpxrAwvyI9z+OpVirt5zIPw8nEOF9S4+iHSdL4npIuCPmcSQBOrQDbHJz v4ZayIQw+KtJ1UpfHQiPeCHy8vQbUyNyBJTMbUVeM1iAR37+7l0YktVFzLBSnHYQZTKJScpr0pC OqRjUwIYA96Pj4aULXSiYHkKGB5PJuHA25YPGBKcp3BqT0J4j27dbqoBwnipeHchb+a2CVssmhC cPUaqRhDu8uuydw/AahygZLwEeQcbDCNgfLryCdJ1zWXYcQ1OyoAFJqg3X7oD3ie44/HrOlx0Rm 4YRoOBxQuipInJCAGqJl+1MunXEw9N5lRAI2DCgKoXQic6Wfs7Sj1T0s X-Google-Smtp-Source: AGHT+IHLPYH9Su/Xk8k0SCej8djbbsIZk7xOmrGvQm5ktmN7qNh0cYjE9gF9O+rc7TRVQLiHHoCCuw== X-Received: by 2002:a17:903:1ca:b0:21b:d105:26b8 with SMTP id d9443c01a7336-2242887b209mr175258155ad.7.1741619676619; Mon, 10 Mar 2025 08:14:36 -0700 (PDT) Received: from carbon-x1.. ([2a01:e0a:e17:9700:16d2:7456:6634:9626]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-224109e99dfsm79230515ad.91.2025.03.10.08.14.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Mar 2025 08:14:35 -0700 (PDT) From: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= To: Paul Walmsley , Palmer Dabbelt , Anup Patel , Atish Patra , Shuah Khan , Jonathan Corbet , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, kvm@vger.kernel.org, kvm-riscv@lists.infradead.org, linux-kselftest@vger.kernel.org Cc: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= , Samuel Holland Subject: [PATCH v3 13/17] selftests: riscv: add misaligned access testing Date: Mon, 10 Mar 2025 16:12:20 +0100 Message-ID: <20250310151229.2365992-14-cleger@rivosinc.com> X-Mailer: git-send-email 2.47.2 In-Reply-To: <20250310151229.2365992-1-cleger@rivosinc.com> References: <20250310151229.2365992-1-cleger@rivosinc.com> Precedence: bulk X-Mailing-List: kvm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Now that the kernel can emulate misaligned access and control its behavior, add a selftest for that. This selftest tests all the currently emulated instruction (except for the RV32 compressed ones which are left as a future exercise for a RV32 user). For the FPU instructions, all the FPU registers are tested. Signed-off-by: Clément Léger --- .../selftests/riscv/misaligned/.gitignore | 1 + .../selftests/riscv/misaligned/Makefile | 12 + .../selftests/riscv/misaligned/common.S | 33 +++ .../testing/selftests/riscv/misaligned/fpu.S | 180 +++++++++++++ tools/testing/selftests/riscv/misaligned/gp.S | 103 +++++++ .../selftests/riscv/misaligned/misaligned.c | 254 ++++++++++++++++++ 6 files changed, 583 insertions(+) create mode 100644 tools/testing/selftests/riscv/misaligned/.gitignore create mode 100644 tools/testing/selftests/riscv/misaligned/Makefile create mode 100644 tools/testing/selftests/riscv/misaligned/common.S create mode 100644 tools/testing/selftests/riscv/misaligned/fpu.S create mode 100644 tools/testing/selftests/riscv/misaligned/gp.S create mode 100644 tools/testing/selftests/riscv/misaligned/misaligned.c diff --git a/tools/testing/selftests/riscv/misaligned/.gitignore b/tools/testing/selftests/riscv/misaligned/.gitignore new file mode 100644 index 000000000000..5eff15a1f981 --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/.gitignore @@ -0,0 +1 @@ +misaligned diff --git a/tools/testing/selftests/riscv/misaligned/Makefile b/tools/testing/selftests/riscv/misaligned/Makefile new file mode 100644 index 000000000000..1aa40110c50d --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/Makefile @@ -0,0 +1,12 @@ +# SPDX-License-Identifier: GPL-2.0 +# Copyright (C) 2021 ARM Limited +# Originally tools/testing/arm64/abi/Makefile + +CFLAGS += -I$(top_srcdir)/tools/include + +TEST_GEN_PROGS := misaligned + +include ../../lib.mk + +$(OUTPUT)/misaligned: misaligned.c fpu.S gp.S + $(CC) -g3 -static -o$@ -march=rv64imafdc $(CFLAGS) $(LDFLAGS) $^ diff --git a/tools/testing/selftests/riscv/misaligned/common.S b/tools/testing/selftests/riscv/misaligned/common.S new file mode 100644 index 000000000000..8fa00035bd5d --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/common.S @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger + */ + +.macro lb_sb temp, offset, src, dst + lb \temp, \offset(\src) + sb \temp, \offset(\dst) +.endm + +.macro copy_long_to temp, src, dst + lb_sb \temp, 0, \src, \dst, + lb_sb \temp, 1, \src, \dst, + lb_sb \temp, 2, \src, \dst, + lb_sb \temp, 3, \src, \dst, + lb_sb \temp, 4, \src, \dst, + lb_sb \temp, 5, \src, \dst, + lb_sb \temp, 6, \src, \dst, + lb_sb \temp, 7, \src, \dst, +.endm + +.macro sp_stack_prologue offset + addi sp, sp, -8 + sub sp, sp, \offset +.endm + +.macro sp_stack_epilogue offset + add sp, sp, \offset + addi sp, sp, 8 +.endm diff --git a/tools/testing/selftests/riscv/misaligned/fpu.S b/tools/testing/selftests/riscv/misaligned/fpu.S new file mode 100644 index 000000000000..d008bff58310 --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/fpu.S @@ -0,0 +1,180 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger + */ + +#include "common.S" + +#define CASE_ALIGN 4 + +.macro fpu_load_inst fpreg, inst, precision, load_reg +.align CASE_ALIGN + \inst \fpreg, 0(\load_reg) + fmv.\precision fa0, \fpreg + j 2f +.endm + +#define flw(__fpreg) fpu_load_inst __fpreg, flw, s, s1 +#define fld(__fpreg) fpu_load_inst __fpreg, fld, d, s1 +#define c_flw(__fpreg) fpu_load_inst __fpreg, c.flw, s, s1 +#define c_fld(__fpreg) fpu_load_inst __fpreg, c.fld, d, s1 +#define c_fldsp(__fpreg) fpu_load_inst __fpreg, c.fldsp, d, sp + +.macro fpu_store_inst fpreg, inst, precision, store_reg +.align CASE_ALIGN + fmv.\precision \fpreg, fa0 + \inst \fpreg, 0(\store_reg) + j 2f +.endm + +#define fsw(__fpreg) fpu_store_inst __fpreg, fsw, s, s1 +#define fsd(__fpreg) fpu_store_inst __fpreg, fsd, d, s1 +#define c_fsw(__fpreg) fpu_store_inst __fpreg, c.fsw, s, s1 +#define c_fsd(__fpreg) fpu_store_inst __fpreg, c.fsd, d, s1 +#define c_fsdsp(__fpreg) fpu_store_inst __fpreg, c.fsdsp, d, sp + +.macro fp_test_prologue + move s1, a1 + /* + * Compute jump offset to store the correct FP register since we don't + * have indirect FP register access (or at least we don't use this + * extension so that works on all archs) + */ + sll t0, a0, CASE_ALIGN + la t2, 1f + add t0, t0, t2 + jr t0 +.align CASE_ALIGN +1: +.endm + +.macro fp_test_prologue_compressed + /* FP registers for compressed instructions starts from 8 to 16 */ + addi a0, a0, -8 + fp_test_prologue +.endm + +#define fp_test_body_compressed(__inst_func) \ + __inst_func(f8); \ + __inst_func(f9); \ + __inst_func(f10); \ + __inst_func(f11); \ + __inst_func(f12); \ + __inst_func(f13); \ + __inst_func(f14); \ + __inst_func(f15); \ +2: + +#define fp_test_body(__inst_func) \ + __inst_func(f0); \ + __inst_func(f1); \ + __inst_func(f2); \ + __inst_func(f3); \ + __inst_func(f4); \ + __inst_func(f5); \ + __inst_func(f6); \ + __inst_func(f7); \ + __inst_func(f8); \ + __inst_func(f9); \ + __inst_func(f10); \ + __inst_func(f11); \ + __inst_func(f12); \ + __inst_func(f13); \ + __inst_func(f14); \ + __inst_func(f15); \ + __inst_func(f16); \ + __inst_func(f17); \ + __inst_func(f18); \ + __inst_func(f19); \ + __inst_func(f20); \ + __inst_func(f21); \ + __inst_func(f22); \ + __inst_func(f23); \ + __inst_func(f24); \ + __inst_func(f25); \ + __inst_func(f26); \ + __inst_func(f27); \ + __inst_func(f28); \ + __inst_func(f29); \ + __inst_func(f30); \ + __inst_func(f31); \ +2: +.text + +#define __gen_test_inst(__inst, __suffix) \ +.global test_ ## __inst; \ +test_ ## __inst:; \ + fp_test_prologue ## __suffix; \ + fp_test_body ## __suffix(__inst); \ + ret + +#define gen_test_inst_compressed(__inst) \ + .option arch,+c; \ + __gen_test_inst(c_ ## __inst, _compressed) + +#define gen_test_inst(__inst) \ + .balign 16; \ + .option push; \ + .option arch,-c; \ + __gen_test_inst(__inst, ); \ + .option pop + +.macro fp_test_prologue_load_compressed_sp + copy_long_to t0, a1, sp +.endm + +.macro fp_test_epilogue_load_compressed_sp +.endm + +.macro fp_test_prologue_store_compressed_sp +.endm + +.macro fp_test_epilogue_store_compressed_sp + copy_long_to t0, sp, a1 +.endm + +#define gen_inst_compressed_sp(__inst, __type) \ + .global test_c_ ## __inst ## sp; \ + test_c_ ## __inst ## sp:; \ + sp_stack_prologue a2; \ + fp_test_prologue_## __type ## _compressed_sp; \ + fp_test_prologue_compressed; \ + fp_test_body_compressed(c_ ## __inst ## sp); \ + fp_test_epilogue_## __type ## _compressed_sp; \ + sp_stack_epilogue a2; \ + ret + +#define gen_test_load_compressed_sp(__inst) gen_inst_compressed_sp(__inst, load) +#define gen_test_store_compressed_sp(__inst) gen_inst_compressed_sp(__inst, store) + +/* + * float_fsw_reg - Set a FP register from a register containing the value + * a0 = FP register index to be set + * a1 = addr where to store register value + * a2 = address offset + * a3 = value to be store + */ +gen_test_inst(fsw) + +/* + * float_flw_reg - Get a FP register value and return it + * a0 = FP register index to be retrieved + * a1 = addr to load register from + * a2 = address offset + */ +gen_test_inst(flw) + +gen_test_inst(fsd) +#ifdef __riscv_compressed +gen_test_inst_compressed(fsd) +gen_test_store_compressed_sp(fsd) +#endif + +gen_test_inst(fld) +#ifdef __riscv_compressed +gen_test_inst_compressed(fld) +gen_test_load_compressed_sp(fld) +#endif diff --git a/tools/testing/selftests/riscv/misaligned/gp.S b/tools/testing/selftests/riscv/misaligned/gp.S new file mode 100644 index 000000000000..f53f4c6d81dd --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/gp.S @@ -0,0 +1,103 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger + */ + +#include "common.S" + +.text + +.macro __gen_test_inst inst, src_reg + \inst a2, 0(\src_reg) + move a0, a2 +.endm + +.macro gen_func_header func_name, rvc + .option arch,\rvc + .global test_\func_name + test_\func_name: +.endm + +.macro gen_test_inst inst + .option push + gen_func_header \inst, -c + __gen_test_inst \inst, a0 + .option pop + ret +.endm + +.macro __gen_test_inst_c name, src_reg + .option push + gen_func_header c_\name, +c + __gen_test_inst c.\name, \src_reg + .option pop + ret +.endm + +.macro gen_test_inst_c name + __gen_test_inst_c \name, a0 +.endm + + +.macro gen_test_inst_load_c_sp name + .option push + gen_func_header c_\name\()sp, +c + sp_stack_prologue a1 + copy_long_to t0, a0, sp + c.ldsp a0, 0(sp) + sp_stack_epilogue a1 + .option pop + ret +.endm + +.macro lb_sp_sb_a0 reg, offset + lb_sb \reg, \offset, sp, a0 +.endm + +.macro gen_test_inst_store_c_sp inst_name + .option push + gen_func_header c_\inst_name\()sp, +c + /* Misalign stack pointer */ + sp_stack_prologue a1 + /* Misalign access */ + c.sdsp a2, 0(sp) + copy_long_to t0, sp, a0 + sp_stack_epilogue a1 + .option pop + ret +.endm + + + /* + * a0 = addr to load from + * a1 = address offset + * a2 = value to be loaded + */ +gen_test_inst lh +gen_test_inst lhu +gen_test_inst lw +gen_test_inst lwu +gen_test_inst ld +#ifdef __riscv_compressed +gen_test_inst_c lw +gen_test_inst_c ld +gen_test_inst_load_c_sp ld +#endif + +/* + * a0 = addr where to store value + * a1 = address offset + * a2 = value to be stored + */ +gen_test_inst sh +gen_test_inst sw +gen_test_inst sd +#ifdef __riscv_compressed +gen_test_inst_c sw +gen_test_inst_c sd +gen_test_inst_store_c_sp sd +#endif + diff --git a/tools/testing/selftests/riscv/misaligned/misaligned.c b/tools/testing/selftests/riscv/misaligned/misaligned.c new file mode 100644 index 000000000000..c66aa87ec03e --- /dev/null +++ b/tools/testing/selftests/riscv/misaligned/misaligned.c @@ -0,0 +1,254 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 Rivos Inc. + * + * Authors: + * Clément Léger + */ +#include +#include +#include +#include +#include "../../kselftest_harness.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define stringify(s) __stringify(s) +#define __stringify(s) #s + +#define VAL16 0x1234 +#define VAL32 0xDEADBEEF +#define VAL64 0x45674321D00DF789 + +#define VAL_float 78951.234375 +#define VAL_double 567890.512396965789589290 + +static bool float_equal(float a, float b) +{ + float scaled_epsilon; + float difference = fabsf(a - b); + + // Scale to the largest value. + a = fabsf(a); + b = fabsf(b); + if (a > b) + scaled_epsilon = FLT_EPSILON * a; + else + scaled_epsilon = FLT_EPSILON * b; + + return difference <= scaled_epsilon; +} + +static bool double_equal(double a, double b) +{ + double scaled_epsilon; + double difference = fabsf(a - b); + + // Scale to the largest value. + a = fabs(a); + b = fabs(b); + if (a > b) + scaled_epsilon = DBL_EPSILON * a; + else + scaled_epsilon = DBL_EPSILON * b; + + return difference <= scaled_epsilon; +} + +#define fpu_load_proto(__inst, __type) \ +extern __type test_ ## __inst(unsigned long fp_reg, void *addr, unsigned long offset, __type value) + +fpu_load_proto(flw, float); +fpu_load_proto(fld, double); +fpu_load_proto(c_flw, float); +fpu_load_proto(c_fld, double); +fpu_load_proto(c_fldsp, double); + +#define fpu_store_proto(__inst, __type) \ +extern void test_ ## __inst(unsigned long fp_reg, void *addr, unsigned long offset, __type value) + +fpu_store_proto(fsw, float); +fpu_store_proto(fsd, double); +fpu_store_proto(c_fsw, float); +fpu_store_proto(c_fsd, double); +fpu_store_proto(c_fsdsp, double); + +#define gp_load_proto(__inst, __type) \ +extern __type test_ ## __inst(void *addr, unsigned long offset, __type value) + +gp_load_proto(lh, uint16_t); +gp_load_proto(lhu, uint16_t); +gp_load_proto(lw, uint32_t); +gp_load_proto(lwu, uint32_t); +gp_load_proto(ld, uint64_t); +gp_load_proto(c_lw, uint32_t); +gp_load_proto(c_ld, uint64_t); +gp_load_proto(c_ldsp, uint64_t); + +#define gp_store_proto(__inst, __type) \ +extern void test_ ## __inst(void *addr, unsigned long offset, __type value) + +gp_store_proto(sh, uint16_t); +gp_store_proto(sw, uint32_t); +gp_store_proto(sd, uint64_t); +gp_store_proto(c_sw, uint32_t); +gp_store_proto(c_sd, uint64_t); +gp_store_proto(c_sdsp, uint64_t); + +#define TEST_GP_LOAD(__inst, __type_size) \ +TEST(gp_load_ ## __inst) \ +{ \ + int offset, ret; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (offset = 1; offset < __type_size / 8; offset++) { \ + uint ## __type_size ## _t val = VAL ## __type_size; \ + uint ## __type_size ## _t *ptr = (uint ## __type_size ## _t *) (buf + offset); \ + memcpy(ptr, &val, sizeof(val)); \ + val = test_ ## __inst(ptr, offset, val); \ + EXPECT_EQ(VAL ## __type_size, val); \ + } \ +} + +TEST_GP_LOAD(lh, 16); +TEST_GP_LOAD(lhu, 16); +TEST_GP_LOAD(lw, 32); +TEST_GP_LOAD(lwu, 32); +TEST_GP_LOAD(ld, 64); +#ifdef __riscv_compressed +TEST_GP_LOAD(c_lw, 32); +TEST_GP_LOAD(c_ld, 64); +TEST_GP_LOAD(c_ldsp, 64); +#endif + +#define TEST_GP_STORE(__inst, __type_size) \ +TEST(gp_load_ ## __inst) \ +{ \ + int offset, ret; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (offset = 1; offset < __type_size / 8; offset++) { \ + uint ## __type_size ## _t val = VAL ## __type_size; \ + uint ## __type_size ## _t *ptr = (uint ## __type_size ## _t *) (buf + offset); \ + memset(ptr, 0, sizeof(val)); \ + test_ ## __inst(ptr, offset, val); \ + memcpy(&val, ptr, sizeof(val)); \ + EXPECT_EQ(VAL ## __type_size, val); \ + } \ +} +TEST_GP_STORE(sh, 16); +TEST_GP_STORE(sw, 32); +TEST_GP_STORE(sd, 64); +#ifdef __riscv_compressed +TEST_GP_STORE(c_sw, 32); +TEST_GP_STORE(c_sd, 64); +TEST_GP_STORE(c_sdsp, 64); +#endif + +#define __TEST_FPU_LOAD(__type, __inst, __reg_start, __reg_end) \ +TEST(fpu_load_ ## __inst) \ +{ \ + int i, ret, offset, fp_reg; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (fp_reg = __reg_start; fp_reg < __reg_end; fp_reg++) { \ + for (offset = 1; offset < 4; offset++) { \ + void *load_addr = (buf + offset); \ + __type val = VAL_ ## __type ; \ + \ + memcpy(load_addr, &val, sizeof(val)); \ + val = test_ ## __inst(fp_reg, load_addr, offset, val); \ + EXPECT_TRUE(__type ##_equal(val, VAL_## __type)); \ + } \ + } \ +} +#define TEST_FPU_LOAD(__type, __inst) \ + __TEST_FPU_LOAD(__type, __inst, 0, 32) +#define TEST_FPU_LOAD_COMPRESSED(__type, __inst) \ + __TEST_FPU_LOAD(__type, __inst, 8, 16) + +TEST_FPU_LOAD(float, flw) +TEST_FPU_LOAD(double, fld) +#ifdef __riscv_compressed +TEST_FPU_LOAD_COMPRESSED(double, c_fld) +TEST_FPU_LOAD_COMPRESSED(double, c_fldsp) +#endif + +#define __TEST_FPU_STORE(__type, __inst, __reg_start, __reg_end) \ +TEST(fpu_store_ ## __inst) \ +{ \ + int i, ret, offset, fp_reg; \ + uint8_t buf[16] __attribute__((aligned(16))); \ + \ + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_NOPRINT); \ + ASSERT_EQ(ret, 0); \ + \ + for (fp_reg = __reg_start; fp_reg < __reg_end; fp_reg++) { \ + for (offset = 1; offset < 4; offset++) { \ + \ + void *store_addr = (buf + offset); \ + __type val = VAL_ ## __type ; \ + \ + test_ ## __inst(fp_reg, store_addr, offset, val); \ + memcpy(&val, store_addr, sizeof(val)); \ + EXPECT_TRUE(__type ## _equal(val, VAL_## __type)); \ + } \ + } \ +} +#define TEST_FPU_STORE(__type, __inst) \ + __TEST_FPU_STORE(__type, __inst, 0, 32) +#define TEST_FPU_STORE_COMPRESSED(__type, __inst) \ + __TEST_FPU_STORE(__type, __inst, 8, 16) + +TEST_FPU_STORE(float, fsw) +TEST_FPU_STORE(double, fsd) +#ifdef __riscv_compressed +TEST_FPU_STORE_COMPRESSED(double, c_fsd) +TEST_FPU_STORE_COMPRESSED(double, c_fsdsp) +#endif + +TEST_SIGNAL(gen_sigbus, SIGBUS) +{ + uint32_t *ptr; + uint8_t buf[16] __attribute__((aligned(16))); + int ret; + + ret = prctl(PR_SET_UNALIGN, PR_UNALIGN_SIGBUS); + ASSERT_EQ(ret, 0); + + ptr = (uint32_t *)(buf + 1); + *ptr = 0xDEADBEEFULL; +} + +int main(int argc, char **argv) +{ + int ret, val; + + ret = prctl(PR_GET_UNALIGN, &val); + if (ret == -1 && errno == EINVAL) + ksft_exit_skip("SKIP GET_UNALIGN_CTL not supported\n"); + + exit(test_harness_run(argc, argv)); +} -- 2.47.2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id CBC4DC28B2E for ; Mon, 10 Mar 2025 15:47:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=wVWvRC8/VLO7BYBHF/O5hIm2lfB69o7sAsWj6vtOdtM=; b=f3yfOSl7uUpX+1 zBSMyc9pZiDhbL4TQTGPcjBv0wrEH/gLFTq2ZMdHXQuzY3ISK7iNZkEvkKy0BekIoMuU534RktkL5 JVxnn6mmaWEHSgq0KZWX8DMb0UwC3EA+T6D2wH4xw3INALamS4QDY35k/6s3+yl+bRbIewkk+gGhX bTavVx7vypmjMTxFla9bl3Mg4w7zRXbViAANz3GNZcNsS7FcSGoqFVvDQHtUDRMcbC1IPBO8WayYy qW3yyh2WgEb/Z8ce4FIjsEbdFZpkvd491h+Xhum9bz9pOUzOJNwpfcJg+CmFWaQnl0vjI3Iqr+fWG waHSiNTw5FkNxPFFx/5g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1trfM6-00000003GFW-0MGH; Mon, 10 Mar 2025 15:47:50 +0000 Received: from mail-pl1-x62e.google.com ([2607:f8b0:4864:20::62e]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1trepx-00000003837-1rdS for linux-riscv@lists.infradead.org; Mon, 10 Mar 2025 15:14:39 +0000 Received: by mail-pl1-x62e.google.com with SMTP id d9443c01a7336-2243803b776so68780845ad.0 for ; Mon, 10 Mar 2025 08:14:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1741619677; x=1742224477; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=VKDplUA2XX/hbzyOxbYWLc7Q9RboQ/w3e3i+SZL4wNg=; b=vroCAGr6EFIyTJVK17P9RUxGj2A65s8ERqEzeNH13BKvXKoIn/yBFIPZiVvfxHf7Qk lagqlZDPMjjZG2toS5hR7DwJ129QIBTba4TtVjw8FxyKlICHfHt+7AEfUDIiNK+MqYTe NkdPhSodiLnO5JZleZiMKbxDXe8joWVvtexBX6VWhnt3UOymlFUwBeFcKAmQZ8y2viTG QOIjX4ZNDIQy25McSAZdRPJXyxr+Gu0spWxcHJqGTV7+wnDrzvn7GTVZ7eZhe3iTkAyg JidBoLhlR/tpPQdp3RHn+jvIn1VU8ZkLFvEQ030rsZgr7aq4i3/TxElBC0sqRbToSzGC bqjg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1741619677; x=1742224477; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=VKDplUA2XX/hbzyOxbYWLc7Q9RboQ/w3e3i+SZL4wNg=; b=qaXpxFOgoVCOaRP3BLyd+E3S4Rmxcq2kv4ZDiuviRlCpclrgyd8Fx4S9cak+1yLgtl Of76iPGdzYbJanGMoF+4B0pIbbe4lmsvQiDptsFvPaYEC5o4yQzHBILZCyCFFjS9Zsye LMuBLD96xfJmGew+JyUZwqph0rIcRNHzUoEf8VM/Eyr+I7DP7MhSZpIGScI1PvK8lak5 R3E6cmjNZe8PuwpwN7BAUjYiSQIx5g+60hvbBzUHee2vqmsV0eyoqNerdPCURNpSIC2P e7E9obxVScuOcAFnQCc2+xy78g+r+JJhU0RWBWoxMxO65btiKj93iEYHxljDrMwcQmSH SBMA== X-Forwarded-Encrypted: i=1; AJvYcCW/OMlHGsnPZo9nygdFI0KGZFoCrkt2Uf1sUGOC6NZiplnDa+BauuxpsrsSh0xLQIBACcM399d56YNCRQ==@lists.infradead.org X-Gm-Message-State: AOJu0YyqaFN7I+drHQbCzdowJkew5y28Qo6oqVr4bwYgezMvdF07DgU/ z/UTgdJf3S+XBQGX2sG8ZpFLBGnBjYX3SKI2AaAePqjumJxqv+PaTZl16Zk6nF8= X-Gm-Gg: ASbGncsFnI/QShomlGzZX6fdKOR18D6AGdMq4kN6C1nuuVjOFp1YxTHtxttfLOAVYy8 7BAa+tkCti41+ZtYztP0JZEp1JKvNkK20wpJ/MjqP5/AUbvsfUTu29MclMdrxLMS8f5FfIelnDu l6uo1ADHh2oefTqPLeax6xl7KARI0SNqwhRyc69njaJ2/ufMEAzjbGT/tkGNjcE+7EMb9WbX8KC de5iZrqNoEVrTXWAf0MKsDhF2XZrgpm9qMsoRyQyn0TZQ6YCW6pPBZ7g7B3fIBfZFjA4CsKNKFr Z2MHQ1y4DO4j1uz5/R7c4IhHUrOSqm84qOMltcATwFvrEAk4bgNN19Mt X-Google-Smtp-Source: AGHT+IHLPYH9Su/Xk8k0SCej8djbbsIZk7xOmrGvQm5ktmN7qNh0cYjE9gF9O+rc7TRVQLiHHoCCuw== X-Received: by 2002:a17:903:1ca:b0:21b:d105:26b8 with SMTP id d9443c01a7336-2242887b209mr175258155ad.7.1741619676619; Mon, 10 Mar 2025 08:14:36 -0700 (PDT) Received: from carbon-x1.. ([2a01:e0a:e17:9700:16d2:7456:6634:9626]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-224109e99dfsm79230515ad.91.2025.03.10.08.14.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 10 Mar 2025 08:14:35 -0700 (PDT) From: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= To: Paul Walmsley , Palmer Dabbelt , Anup Patel , Atish Patra , Shuah Khan , Jonathan Corbet , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, kvm@vger.kernel.org, kvm-riscv@lists.infradead.org, linux-kselftest@vger.kernel.org Cc: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= , Samuel Holland Subject: [PATCH v3 13/17] selftests: riscv: add misaligned access testing Date: Mon, 10 Mar 2025 16:12:20 +0100 Message-ID: <20250310151229.2365992-14-cleger@rivosinc.com> X-Mailer: git-send-email 2.47.2 In-Reply-To: <20250310151229.2365992-1-cleger@rivosinc.com> References: <20250310151229.2365992-1-cleger@rivosinc.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250310_081437_490398_907150EC X-CRM114-Status: GOOD ( 19.55 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org Tm93IHRoYXQgdGhlIGtlcm5lbCBjYW4gZW11bGF0ZSBtaXNhbGlnbmVkIGFjY2VzcyBhbmQgY29u dHJvbCBpdHMKYmVoYXZpb3IsIGFkZCBhIHNlbGZ0ZXN0IGZvciB0aGF0LiBUaGlzIHNlbGZ0ZXN0 IHRlc3RzIGFsbCB0aGUgY3VycmVudGx5CmVtdWxhdGVkIGluc3RydWN0aW9uIChleGNlcHQgZm9y IHRoZSBSVjMyIGNvbXByZXNzZWQgb25lcyB3aGljaCBhcmUgbGVmdAphcyBhIGZ1dHVyZSBleGVy Y2lzZSBmb3IgYSBSVjMyIHVzZXIpLiBGb3IgdGhlIEZQVSBpbnN0cnVjdGlvbnMsIGFsbCB0aGUK RlBVIHJlZ2lzdGVycyBhcmUgdGVzdGVkLgoKU2lnbmVkLW9mZi1ieTogQ2zDqW1lbnQgTMOpZ2Vy IDxjbGVnZXJAcml2b3NpbmMuY29tPgotLS0KIC4uLi9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25l ZC8uZ2l0aWdub3JlICAgICB8ICAgMSArCiAuLi4vc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQv TWFrZWZpbGUgICAgICAgfCAgMTIgKwogLi4uL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2Nv bW1vbi5TICAgICAgIHwgIDMzICsrKwogLi4uL3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2Fs aWduZWQvZnB1LlMgIHwgMTgwICsrKysrKysrKysrKysKIHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3Rz L3Jpc2N2L21pc2FsaWduZWQvZ3AuUyB8IDEwMyArKysrKysrCiAuLi4vc2VsZnRlc3RzL3Jpc2N2 L21pc2FsaWduZWQvbWlzYWxpZ25lZC5jICAgfCAyNTQgKysrKysrKysrKysrKysrKysrCiA2IGZp bGVzIGNoYW5nZWQsIDU4MyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgdG9vbHMv dGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC8uZ2l0aWdub3JlCiBjcmVhdGUgbW9k ZSAxMDA2NDQgdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9NYWtlZmls ZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2Fs aWduZWQvY29tbW9uLlMKIGNyZWF0ZSBtb2RlIDEwMDY0NCB0b29scy90ZXN0aW5nL3NlbGZ0ZXN0 cy9yaXNjdi9taXNhbGlnbmVkL2ZwdS5TCiBjcmVhdGUgbW9kZSAxMDA2NDQgdG9vbHMvdGVzdGlu Zy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9ncC5TCiBjcmVhdGUgbW9kZSAxMDA2NDQgdG9v bHMvdGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9taXNhbGlnbmVkLmMKCmRpZmYg LS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkLy5naXRpZ25v cmUgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkLy5naXRpZ25vcmUK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi41ZWZmMTVhMWY5ODEKLS0t IC9kZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVk Ly5naXRpZ25vcmUKQEAgLTAsMCArMSBAQAorbWlzYWxpZ25lZApkaWZmIC0tZ2l0IGEvdG9vbHMv dGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9NYWtlZmlsZSBiL3Rvb2xzL3Rlc3Rp bmcvc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xYWE0MDExMGM1MGQKLS0tIC9kZXYvbnVsbAorKysgYi90 b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL01ha2VmaWxlCkBAIC0wLDAg KzEsMTIgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKyMgQ29weXJpZ2h0 IChDKSAyMDIxIEFSTSBMaW1pdGVkCisjIE9yaWdpbmFsbHkgdG9vbHMvdGVzdGluZy9hcm02NC9h YmkvTWFrZWZpbGUKKworQ0ZMQUdTICs9IC1JJCh0b3Bfc3JjZGlyKS90b29scy9pbmNsdWRlCisK K1RFU1RfR0VOX1BST0dTIDo9IG1pc2FsaWduZWQKKworaW5jbHVkZSAuLi8uLi9saWIubWsKKwor JChPVVRQVVQpL21pc2FsaWduZWQ6IG1pc2FsaWduZWQuYyBmcHUuUyBncC5TCisJJChDQykgLWcz IC1zdGF0aWMgLW8kQCAtbWFyY2g9cnY2NGltYWZkYyAkKENGTEFHUykgJChMREZMQUdTKSAkXgpk aWZmIC0tZ2l0IGEvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9jb21t b24uUyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQvY29tbW9uLlMK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi44ZmEwMDAzNWJkNWQKLS0t IC9kZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVk L2NvbW1vbi5TCkBAIC0wLDAgKzEsMzMgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wLW9ubHkgKi8KKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoK KyAqIEF1dGhvcnM6CisgKiAgICAgQ2zDqW1lbnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29t PgorICovCisKKy5tYWNybyBsYl9zYiB0ZW1wLCBvZmZzZXQsIHNyYywgZHN0CisJbGIgXHRlbXAs IFxvZmZzZXQoXHNyYykKKwlzYiBcdGVtcCwgXG9mZnNldChcZHN0KQorLmVuZG0KKworLm1hY3Jv IGNvcHlfbG9uZ190byB0ZW1wLCBzcmMsIGRzdAorCWxiX3NiIFx0ZW1wLCAwLCBcc3JjLCBcZHN0 LAorCWxiX3NiIFx0ZW1wLCAxLCBcc3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCAyLCBcc3JjLCBc ZHN0LAorCWxiX3NiIFx0ZW1wLCAzLCBcc3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA0LCBcc3Jj LCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA1LCBcc3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA2LCBc c3JjLCBcZHN0LAorCWxiX3NiIFx0ZW1wLCA3LCBcc3JjLCBcZHN0LAorLmVuZG0KKworLm1hY3Jv IHNwX3N0YWNrX3Byb2xvZ3VlIG9mZnNldAorCWFkZGkgc3AsIHNwLCAtOAorCXN1YiBzcCwgc3As IFxvZmZzZXQKKy5lbmRtCisKKy5tYWNybyBzcF9zdGFja19lcGlsb2d1ZSBvZmZzZXQKKwlhZGQg c3AsIHNwLCBcb2Zmc2V0CisJYWRkaSBzcCwgc3AsIDgKKy5lbmRtCmRpZmYgLS1naXQgYS90b29s cy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2ZwdS5TIGIvdG9vbHMvdGVzdGlu Zy9zZWxmdGVzdHMvcmlzY3YvbWlzYWxpZ25lZC9mcHUuUwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAuLmQwMDhiZmY1ODMxMAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xz L3Rlc3Rpbmcvc2VsZnRlc3RzL3Jpc2N2L21pc2FsaWduZWQvZnB1LlMKQEAgLTAsMCArMSwxODAg QEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KKy8qCisgKiBD b3B5cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoKKyAqIEF1dGhvcnM6CisgKiAgICAgQ2zD qW1lbnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29tPgorICovCisKKyNpbmNsdWRlICJjb21t b24uUyIKKworI2RlZmluZSBDQVNFX0FMSUdOCQk0CisKKy5tYWNybyBmcHVfbG9hZF9pbnN0IGZw cmVnLCBpbnN0LCBwcmVjaXNpb24sIGxvYWRfcmVnCisuYWxpZ24gQ0FTRV9BTElHTgorCVxpbnN0 IFxmcHJlZywgMChcbG9hZF9yZWcpCisJZm12LlxwcmVjaXNpb24gZmEwLCBcZnByZWcKKwlqIDJm CisuZW5kbQorCisjZGVmaW5lIGZsdyhfX2ZwcmVnKSBmcHVfbG9hZF9pbnN0IF9fZnByZWcsIGZs dywgcywgczEKKyNkZWZpbmUgZmxkKF9fZnByZWcpIGZwdV9sb2FkX2luc3QgX19mcHJlZywgZmxk LCBkLCBzMQorI2RlZmluZSBjX2ZsdyhfX2ZwcmVnKSBmcHVfbG9hZF9pbnN0IF9fZnByZWcsIGMu Zmx3LCBzLCBzMQorI2RlZmluZSBjX2ZsZChfX2ZwcmVnKSBmcHVfbG9hZF9pbnN0IF9fZnByZWcs IGMuZmxkLCBkLCBzMQorI2RlZmluZSBjX2ZsZHNwKF9fZnByZWcpIGZwdV9sb2FkX2luc3QgX19m cHJlZywgYy5mbGRzcCwgZCwgc3AKKworLm1hY3JvIGZwdV9zdG9yZV9pbnN0IGZwcmVnLCBpbnN0 LCBwcmVjaXNpb24sIHN0b3JlX3JlZworLmFsaWduIENBU0VfQUxJR04KKwlmbXYuXHByZWNpc2lv biBcZnByZWcsIGZhMAorCVxpbnN0IFxmcHJlZywgMChcc3RvcmVfcmVnKQorCWogMmYKKy5lbmRt CisKKyNkZWZpbmUgZnN3KF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnByZWcsIGZzdywgcywg czEKKyNkZWZpbmUgZnNkKF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnByZWcsIGZzZCwgZCwg czEKKyNkZWZpbmUgY19mc3coX19mcHJlZykgZnB1X3N0b3JlX2luc3QgX19mcHJlZywgYy5mc3cs IHMsIHMxCisjZGVmaW5lIGNfZnNkKF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnByZWcsIGMu ZnNkLCBkLCBzMQorI2RlZmluZSBjX2ZzZHNwKF9fZnByZWcpIGZwdV9zdG9yZV9pbnN0IF9fZnBy ZWcsIGMuZnNkc3AsIGQsIHNwCisKKy5tYWNybyBmcF90ZXN0X3Byb2xvZ3VlCisJbW92ZSBzMSwg YTEKKwkvKgorCSAqIENvbXB1dGUganVtcCBvZmZzZXQgdG8gc3RvcmUgdGhlIGNvcnJlY3QgRlAg cmVnaXN0ZXIgc2luY2Ugd2UgZG9uJ3QKKwkgKiBoYXZlIGluZGlyZWN0IEZQIHJlZ2lzdGVyIGFj Y2VzcyAob3IgYXQgbGVhc3Qgd2UgZG9uJ3QgdXNlIHRoaXMKKwkgKiBleHRlbnNpb24gc28gdGhh dCB3b3JrcyBvbiBhbGwgYXJjaHMpCisJICovCisJc2xsIHQwLCBhMCwgQ0FTRV9BTElHTgorCWxh IHQyLCAxZgorCWFkZCB0MCwgdDAsIHQyCisJanIgdDAKKy5hbGlnbglDQVNFX0FMSUdOCisxOgor LmVuZG0KKworLm1hY3JvIGZwX3Rlc3RfcHJvbG9ndWVfY29tcHJlc3NlZAorCS8qIEZQIHJlZ2lz dGVycyBmb3IgY29tcHJlc3NlZCBpbnN0cnVjdGlvbnMgc3RhcnRzIGZyb20gOCB0byAxNiAqLwor CWFkZGkgYTAsIGEwLCAtOAorCWZwX3Rlc3RfcHJvbG9ndWUKKy5lbmRtCisKKyNkZWZpbmUgZnBf dGVzdF9ib2R5X2NvbXByZXNzZWQoX19pbnN0X2Z1bmMpIFwKKwlfX2luc3RfZnVuYyhmOCk7IFwK KwlfX2luc3RfZnVuYyhmOSk7IFwKKwlfX2luc3RfZnVuYyhmMTApOyBcCisJX19pbnN0X2Z1bmMo ZjExKTsgXAorCV9faW5zdF9mdW5jKGYxMik7IFwKKwlfX2luc3RfZnVuYyhmMTMpOyBcCisJX19p bnN0X2Z1bmMoZjE0KTsgXAorCV9faW5zdF9mdW5jKGYxNSk7IFwKKzI6CisKKyNkZWZpbmUgZnBf dGVzdF9ib2R5KF9faW5zdF9mdW5jKSBcCisJX19pbnN0X2Z1bmMoZjApOyBcCisJX19pbnN0X2Z1 bmMoZjEpOyBcCisJX19pbnN0X2Z1bmMoZjIpOyBcCisJX19pbnN0X2Z1bmMoZjMpOyBcCisJX19p bnN0X2Z1bmMoZjQpOyBcCisJX19pbnN0X2Z1bmMoZjUpOyBcCisJX19pbnN0X2Z1bmMoZjYpOyBc CisJX19pbnN0X2Z1bmMoZjcpOyBcCisJX19pbnN0X2Z1bmMoZjgpOyBcCisJX19pbnN0X2Z1bmMo ZjkpOyBcCisJX19pbnN0X2Z1bmMoZjEwKTsgXAorCV9faW5zdF9mdW5jKGYxMSk7IFwKKwlfX2lu c3RfZnVuYyhmMTIpOyBcCisJX19pbnN0X2Z1bmMoZjEzKTsgXAorCV9faW5zdF9mdW5jKGYxNCk7 IFwKKwlfX2luc3RfZnVuYyhmMTUpOyBcCisJX19pbnN0X2Z1bmMoZjE2KTsgXAorCV9faW5zdF9m dW5jKGYxNyk7IFwKKwlfX2luc3RfZnVuYyhmMTgpOyBcCisJX19pbnN0X2Z1bmMoZjE5KTsgXAor CV9faW5zdF9mdW5jKGYyMCk7IFwKKwlfX2luc3RfZnVuYyhmMjEpOyBcCisJX19pbnN0X2Z1bmMo ZjIyKTsgXAorCV9faW5zdF9mdW5jKGYyMyk7IFwKKwlfX2luc3RfZnVuYyhmMjQpOyBcCisJX19p bnN0X2Z1bmMoZjI1KTsgXAorCV9faW5zdF9mdW5jKGYyNik7IFwKKwlfX2luc3RfZnVuYyhmMjcp OyBcCisJX19pbnN0X2Z1bmMoZjI4KTsgXAorCV9faW5zdF9mdW5jKGYyOSk7IFwKKwlfX2luc3Rf ZnVuYyhmMzApOyBcCisJX19pbnN0X2Z1bmMoZjMxKTsgXAorMjoKKy50ZXh0CisKKyNkZWZpbmUg X19nZW5fdGVzdF9pbnN0KF9faW5zdCwgX19zdWZmaXgpIFwKKy5nbG9iYWwgdGVzdF8gIyMgX19p bnN0OyBcCit0ZXN0XyAjIyBfX2luc3Q6OyBcCisJZnBfdGVzdF9wcm9sb2d1ZSAjIyBfX3N1ZmZp eDsgXAorCWZwX3Rlc3RfYm9keSAjIyBfX3N1ZmZpeChfX2luc3QpOyBcCisJcmV0CisKKyNkZWZp bmUgZ2VuX3Rlc3RfaW5zdF9jb21wcmVzc2VkKF9faW5zdCkgXAorCS5vcHRpb24gYXJjaCwrYzsg XAorCV9fZ2VuX3Rlc3RfaW5zdChjXyAjIyBfX2luc3QsIF9jb21wcmVzc2VkKQorCisjZGVmaW5l IGdlbl90ZXN0X2luc3QoX19pbnN0KSBcCisJLmJhbGlnbiAxNjsgXAorCS5vcHRpb24gcHVzaDsg XAorCS5vcHRpb24gYXJjaCwtYzsgXAorCV9fZ2VuX3Rlc3RfaW5zdChfX2luc3QsICk7IFwKKwku b3B0aW9uIHBvcAorCisubWFjcm8gZnBfdGVzdF9wcm9sb2d1ZV9sb2FkX2NvbXByZXNzZWRfc3AK Kwljb3B5X2xvbmdfdG8gdDAsIGExLCBzcAorLmVuZG0KKworLm1hY3JvIGZwX3Rlc3RfZXBpbG9n dWVfbG9hZF9jb21wcmVzc2VkX3NwCisuZW5kbQorCisubWFjcm8gZnBfdGVzdF9wcm9sb2d1ZV9z dG9yZV9jb21wcmVzc2VkX3NwCisuZW5kbQorCisubWFjcm8gZnBfdGVzdF9lcGlsb2d1ZV9zdG9y ZV9jb21wcmVzc2VkX3NwCisJY29weV9sb25nX3RvIHQwLCBzcCwgYTEKKy5lbmRtCisKKyNkZWZp bmUgZ2VuX2luc3RfY29tcHJlc3NlZF9zcChfX2luc3QsIF9fdHlwZSkgXAorCS5nbG9iYWwgdGVz dF9jXyAjIyBfX2luc3QgIyMgc3A7IFwKKwl0ZXN0X2NfICMjIF9faW5zdCAjIyBzcDo7IFwKKwkJ c3Bfc3RhY2tfcHJvbG9ndWUgYTI7IFwKKwkJZnBfdGVzdF9wcm9sb2d1ZV8jIyBfX3R5cGUgIyMg X2NvbXByZXNzZWRfc3A7IFwKKwkJZnBfdGVzdF9wcm9sb2d1ZV9jb21wcmVzc2VkOyBcCisJCWZw X3Rlc3RfYm9keV9jb21wcmVzc2VkKGNfICMjIF9faW5zdCAjIyBzcCk7IFwKKwkJZnBfdGVzdF9l cGlsb2d1ZV8jIyBfX3R5cGUgIyMgX2NvbXByZXNzZWRfc3A7IFwKKwkJc3Bfc3RhY2tfZXBpbG9n dWUgYTI7IFwKKwkJcmV0CisKKyNkZWZpbmUgZ2VuX3Rlc3RfbG9hZF9jb21wcmVzc2VkX3NwKF9f aW5zdCkgZ2VuX2luc3RfY29tcHJlc3NlZF9zcChfX2luc3QsIGxvYWQpCisjZGVmaW5lIGdlbl90 ZXN0X3N0b3JlX2NvbXByZXNzZWRfc3AoX19pbnN0KSBnZW5faW5zdF9jb21wcmVzc2VkX3NwKF9f aW5zdCwgc3RvcmUpCisKKy8qCisgKiBmbG9hdF9mc3dfcmVnIC0gU2V0IGEgRlAgcmVnaXN0ZXIg ZnJvbSBhIHJlZ2lzdGVyIGNvbnRhaW5pbmcgdGhlIHZhbHVlCisgKiBhMCA9IEZQIHJlZ2lzdGVy IGluZGV4IHRvIGJlIHNldAorICogYTEgPSBhZGRyIHdoZXJlIHRvIHN0b3JlIHJlZ2lzdGVyIHZh bHVlCisgKiBhMiA9IGFkZHJlc3Mgb2Zmc2V0CisgKiBhMyA9IHZhbHVlIHRvIGJlIHN0b3JlCisg Ki8KK2dlbl90ZXN0X2luc3QoZnN3KQorCisvKgorICogZmxvYXRfZmx3X3JlZyAtIEdldCBhIEZQ IHJlZ2lzdGVyIHZhbHVlIGFuZCByZXR1cm4gaXQKKyAqIGEwID0gRlAgcmVnaXN0ZXIgaW5kZXgg dG8gYmUgcmV0cmlldmVkCisgKiBhMSA9IGFkZHIgdG8gbG9hZCByZWdpc3RlciBmcm9tCisgKiBh MiA9IGFkZHJlc3Mgb2Zmc2V0CisgKi8KK2dlbl90ZXN0X2luc3QoZmx3KQorCitnZW5fdGVzdF9p bnN0KGZzZCkKKyNpZmRlZiBfX3Jpc2N2X2NvbXByZXNzZWQKK2dlbl90ZXN0X2luc3RfY29tcHJl c3NlZChmc2QpCitnZW5fdGVzdF9zdG9yZV9jb21wcmVzc2VkX3NwKGZzZCkKKyNlbmRpZgorCitn ZW5fdGVzdF9pbnN0KGZsZCkKKyNpZmRlZiBfX3Jpc2N2X2NvbXByZXNzZWQKK2dlbl90ZXN0X2lu c3RfY29tcHJlc3NlZChmbGQpCitnZW5fdGVzdF9sb2FkX2NvbXByZXNzZWRfc3AoZmxkKQorI2Vu ZGlmCmRpZmYgLS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVk L2dwLlMgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2dwLlMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mNTNmNGM2ZDgxZGQKLS0tIC9k ZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL2dw LlMKQEAgLTAsMCArMSwxMDMgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4w LW9ubHkgKi8KKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoKKyAqIEF1 dGhvcnM6CisgKiAgICAgQ2zDqW1lbnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29tPgorICov CisKKyNpbmNsdWRlICJjb21tb24uUyIKKworLnRleHQKKworLm1hY3JvIF9fZ2VuX3Rlc3RfaW5z dCBpbnN0LCBzcmNfcmVnCisJXGluc3QgYTIsIDAoXHNyY19yZWcpCisJbW92ZSBhMCwgYTIKKy5l bmRtCisKKy5tYWNybyBnZW5fZnVuY19oZWFkZXIgZnVuY19uYW1lLCBydmMKKwkub3B0aW9uIGFy Y2gsXHJ2YworCS5nbG9iYWwgdGVzdF9cZnVuY19uYW1lCisJdGVzdF9cZnVuY19uYW1lOgorLmVu ZG0KKworLm1hY3JvIGdlbl90ZXN0X2luc3QgaW5zdAorCS5vcHRpb24gcHVzaAorCWdlbl9mdW5j X2hlYWRlciBcaW5zdCwgLWMKKwlfX2dlbl90ZXN0X2luc3QgXGluc3QsIGEwCisJLm9wdGlvbiBw b3AKKwlyZXQKKy5lbmRtCisKKy5tYWNybyBfX2dlbl90ZXN0X2luc3RfYyBuYW1lLCBzcmNfcmVn CisJLm9wdGlvbiBwdXNoCisJZ2VuX2Z1bmNfaGVhZGVyIGNfXG5hbWUsICtjCisJIF9fZ2VuX3Rl c3RfaW5zdCBjLlxuYW1lLCBcc3JjX3JlZworCS5vcHRpb24gcG9wCisJcmV0CisuZW5kbQorCisu bWFjcm8gZ2VuX3Rlc3RfaW5zdF9jIG5hbWUKKyAJX19nZW5fdGVzdF9pbnN0X2MgXG5hbWUsIGEw CisuZW5kbQorCisKKy5tYWNybyBnZW5fdGVzdF9pbnN0X2xvYWRfY19zcCBuYW1lCisJLm9wdGlv biBwdXNoCisJZ2VuX2Z1bmNfaGVhZGVyIGNfXG5hbWVcKClzcCwgK2MKKwlzcF9zdGFja19wcm9s b2d1ZSBhMQorCWNvcHlfbG9uZ190byB0MCwgYTAsIHNwCisJYy5sZHNwIGEwLCAwKHNwKQorCXNw X3N0YWNrX2VwaWxvZ3VlIGExCisJLm9wdGlvbiBwb3AKKwlyZXQKKy5lbmRtCisKKy5tYWNybyBs Yl9zcF9zYl9hMCByZWcsIG9mZnNldAorCWxiX3NiIFxyZWcsIFxvZmZzZXQsIHNwLCBhMAorLmVu ZG0KKworLm1hY3JvIGdlbl90ZXN0X2luc3Rfc3RvcmVfY19zcCBpbnN0X25hbWUKKwkub3B0aW9u IHB1c2gKKwlnZW5fZnVuY19oZWFkZXIgY19caW5zdF9uYW1lXCgpc3AsICtjCisJLyogTWlzYWxp Z24gc3RhY2sgcG9pbnRlciAqLworCXNwX3N0YWNrX3Byb2xvZ3VlIGExCisJLyogTWlzYWxpZ24g YWNjZXNzICovCisJYy5zZHNwIGEyLCAwKHNwKQorCWNvcHlfbG9uZ190byB0MCwgc3AsIGEwCisJ c3Bfc3RhY2tfZXBpbG9ndWUgYTEKKwkub3B0aW9uIHBvcAorCXJldAorLmVuZG0KKworCisgLyoK KyAqIGEwID0gYWRkciB0byBsb2FkIGZyb20KKyAqIGExID0gYWRkcmVzcyBvZmZzZXQKKyAqIGEy ID0gdmFsdWUgdG8gYmUgbG9hZGVkCisgKi8KK2dlbl90ZXN0X2luc3QgbGgKK2dlbl90ZXN0X2lu c3QgbGh1CitnZW5fdGVzdF9pbnN0IGx3CitnZW5fdGVzdF9pbnN0IGx3dQorZ2VuX3Rlc3RfaW5z dCBsZAorI2lmZGVmIF9fcmlzY3ZfY29tcHJlc3NlZAorZ2VuX3Rlc3RfaW5zdF9jIGx3CitnZW5f dGVzdF9pbnN0X2MgbGQKK2dlbl90ZXN0X2luc3RfbG9hZF9jX3NwIGxkCisjZW5kaWYKKworLyoK KyAqIGEwID0gYWRkciB3aGVyZSB0byBzdG9yZSB2YWx1ZQorICogYTEgPSBhZGRyZXNzIG9mZnNl dAorICogYTIgPSB2YWx1ZSB0byBiZSBzdG9yZWQKKyAqLworZ2VuX3Rlc3RfaW5zdCBzaAorZ2Vu X3Rlc3RfaW5zdCBzdworZ2VuX3Rlc3RfaW5zdCBzZAorI2lmZGVmIF9fcmlzY3ZfY29tcHJlc3Nl ZAorZ2VuX3Rlc3RfaW5zdF9jIHN3CitnZW5fdGVzdF9pbnN0X2Mgc2QKK2dlbl90ZXN0X2luc3Rf c3RvcmVfY19zcCBzZAorI2VuZGlmCisKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRl c3RzL3Jpc2N2L21pc2FsaWduZWQvbWlzYWxpZ25lZC5jIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVz dHMvcmlzY3YvbWlzYWxpZ25lZC9taXNhbGlnbmVkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi5jNjZhYTg3ZWMwM2UKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy90 ZXN0aW5nL3NlbGZ0ZXN0cy9yaXNjdi9taXNhbGlnbmVkL21pc2FsaWduZWQuYwpAQCAtMCwwICsx LDI1NCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBDb3B5 cmlnaHQgKGMpIDIwMjUgUml2b3MgSW5jLgorICoKKyAqIEF1dGhvcnM6CisgKiAgICAgQ2zDqW1l bnQgTMOpZ2VyIDxjbGVnZXJAcml2b3NpbmMuY29tPgorICovCisjaW5jbHVkZSA8c2lnbmFsLmg+ CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxsaW51 eC9wdHJhY2UuaD4KKyNpbmNsdWRlICIuLi8uLi9rc2VsZnRlc3RfaGFybmVzcy5oIgorCisjaW5j bHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRpbnQuaD4K KyNpbmNsdWRlIDxmbG9hdC5oPgorI2luY2x1ZGUgPGVycm5vLmg+CisjaW5jbHVkZSA8bWF0aC5o PgorI2luY2x1ZGUgPHN0cmluZy5oPgorI2luY2x1ZGUgPHNpZ25hbC5oPgorI2luY2x1ZGUgPHN0 ZGJvb2wuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDxpbnR0eXBlcy5oPgorI2lu Y2x1ZGUgPHVjb250ZXh0Lmg+CisKKyNpbmNsdWRlIDxzeXMvcHJjdGwuaD4KKworI2RlZmluZSBz dHJpbmdpZnkocykgX19zdHJpbmdpZnkocykKKyNkZWZpbmUgX19zdHJpbmdpZnkocykgI3MKKwor I2RlZmluZSBWQUwxNgkweDEyMzQKKyNkZWZpbmUgVkFMMzIJMHhERUFEQkVFRgorI2RlZmluZSBW QUw2NAkweDQ1Njc0MzIxRDAwREY3ODkKKworI2RlZmluZSBWQUxfZmxvYXQJNzg5NTEuMjM0Mzc1 CisjZGVmaW5lIFZBTF9kb3VibGUJNTY3ODkwLjUxMjM5Njk2NTc4OTU4OTI5MAorCitzdGF0aWMg Ym9vbCBmbG9hdF9lcXVhbChmbG9hdCBhLCBmbG9hdCBiKQoreworCWZsb2F0IHNjYWxlZF9lcHNp bG9uOworCWZsb2F0IGRpZmZlcmVuY2UgPSBmYWJzZihhIC0gYik7CisKKwkvLyBTY2FsZSB0byB0 aGUgbGFyZ2VzdCB2YWx1ZS4KKwlhID0gZmFic2YoYSk7CisJYiA9IGZhYnNmKGIpOworCWlmIChh ID4gYikKKwkJc2NhbGVkX2Vwc2lsb24gPSBGTFRfRVBTSUxPTiAqIGE7CisJZWxzZQorCQlzY2Fs ZWRfZXBzaWxvbiA9IEZMVF9FUFNJTE9OICogYjsKKworCXJldHVybiBkaWZmZXJlbmNlIDw9IHNj YWxlZF9lcHNpbG9uOworfQorCitzdGF0aWMgYm9vbCBkb3VibGVfZXF1YWwoZG91YmxlIGEsIGRv dWJsZSBiKQoreworCWRvdWJsZSBzY2FsZWRfZXBzaWxvbjsKKwlkb3VibGUgZGlmZmVyZW5jZSA9 IGZhYnNmKGEgLSBiKTsKKworCS8vIFNjYWxlIHRvIHRoZSBsYXJnZXN0IHZhbHVlLgorCWEgPSBm YWJzKGEpOworCWIgPSBmYWJzKGIpOworCWlmIChhID4gYikKKwkJc2NhbGVkX2Vwc2lsb24gPSBE QkxfRVBTSUxPTiAqIGE7CisJZWxzZQorCQlzY2FsZWRfZXBzaWxvbiA9IERCTF9FUFNJTE9OICog YjsKKworCXJldHVybiBkaWZmZXJlbmNlIDw9IHNjYWxlZF9lcHNpbG9uOworfQorCisjZGVmaW5l IGZwdV9sb2FkX3Byb3RvKF9faW5zdCwgX190eXBlKSBcCitleHRlcm4gX190eXBlIHRlc3RfICMj IF9faW5zdCh1bnNpZ25lZCBsb25nIGZwX3JlZywgdm9pZCAqYWRkciwgdW5zaWduZWQgbG9uZyBv ZmZzZXQsIF9fdHlwZSB2YWx1ZSkKKworZnB1X2xvYWRfcHJvdG8oZmx3LCBmbG9hdCk7CitmcHVf bG9hZF9wcm90byhmbGQsIGRvdWJsZSk7CitmcHVfbG9hZF9wcm90byhjX2ZsdywgZmxvYXQpOwor ZnB1X2xvYWRfcHJvdG8oY19mbGQsIGRvdWJsZSk7CitmcHVfbG9hZF9wcm90byhjX2ZsZHNwLCBk b3VibGUpOworCisjZGVmaW5lIGZwdV9zdG9yZV9wcm90byhfX2luc3QsIF9fdHlwZSkgXAorZXh0 ZXJuIHZvaWQgdGVzdF8gIyMgX19pbnN0KHVuc2lnbmVkIGxvbmcgZnBfcmVnLCB2b2lkICphZGRy LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgX190eXBlIHZhbHVlKQorCitmcHVfc3RvcmVfcHJvdG8o ZnN3LCBmbG9hdCk7CitmcHVfc3RvcmVfcHJvdG8oZnNkLCBkb3VibGUpOworZnB1X3N0b3JlX3By b3RvKGNfZnN3LCBmbG9hdCk7CitmcHVfc3RvcmVfcHJvdG8oY19mc2QsIGRvdWJsZSk7CitmcHVf c3RvcmVfcHJvdG8oY19mc2RzcCwgZG91YmxlKTsKKworI2RlZmluZSBncF9sb2FkX3Byb3RvKF9f aW5zdCwgX190eXBlKSBcCitleHRlcm4gX190eXBlIHRlc3RfICMjIF9faW5zdCh2b2lkICphZGRy LCB1bnNpZ25lZCBsb25nIG9mZnNldCwgX190eXBlIHZhbHVlKQorCitncF9sb2FkX3Byb3RvKGxo LCB1aW50MTZfdCk7CitncF9sb2FkX3Byb3RvKGxodSwgdWludDE2X3QpOworZ3BfbG9hZF9wcm90 byhsdywgdWludDMyX3QpOworZ3BfbG9hZF9wcm90byhsd3UsIHVpbnQzMl90KTsKK2dwX2xvYWRf cHJvdG8obGQsIHVpbnQ2NF90KTsKK2dwX2xvYWRfcHJvdG8oY19sdywgdWludDMyX3QpOworZ3Bf bG9hZF9wcm90byhjX2xkLCB1aW50NjRfdCk7CitncF9sb2FkX3Byb3RvKGNfbGRzcCwgdWludDY0 X3QpOworCisjZGVmaW5lIGdwX3N0b3JlX3Byb3RvKF9faW5zdCwgX190eXBlKSBcCitleHRlcm4g dm9pZCB0ZXN0XyAjIyBfX2luc3Qodm9pZCAqYWRkciwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIF9f dHlwZSB2YWx1ZSkKKworZ3Bfc3RvcmVfcHJvdG8oc2gsIHVpbnQxNl90KTsKK2dwX3N0b3JlX3By b3RvKHN3LCB1aW50MzJfdCk7CitncF9zdG9yZV9wcm90byhzZCwgdWludDY0X3QpOworZ3Bfc3Rv cmVfcHJvdG8oY19zdywgdWludDMyX3QpOworZ3Bfc3RvcmVfcHJvdG8oY19zZCwgdWludDY0X3Qp OworZ3Bfc3RvcmVfcHJvdG8oY19zZHNwLCB1aW50NjRfdCk7CisKKyNkZWZpbmUgVEVTVF9HUF9M T0FEKF9faW5zdCwgX190eXBlX3NpemUpCQkJCQlcCitURVNUKGdwX2xvYWRfICMjIF9faW5zdCkJ CQkJCQkJXAorewkJCQkJCQkJCQlcCisJaW50IG9mZnNldCwgcmV0OwkJCQkJCQlcCisJdWludDhf dCBidWZbMTZdIF9fYXR0cmlidXRlX18oKGFsaWduZWQoMTYpKSk7CQkJCVwKKwkJCQkJCQkJCQlc CisJcmV0ID0gcHJjdGwoUFJfU0VUX1VOQUxJR04sIFBSX1VOQUxJR05fTk9QUklOVCk7CQkJXAor CUFTU0VSVF9FUShyZXQsIDApOwkJCQkJCQlcCisJCQkJCQkJCQkJXAorCWZvciAob2Zmc2V0ID0g MTsgb2Zmc2V0IDwgX190eXBlX3NpemUgLyA4OyBvZmZzZXQrKykgewkJCVwKKwkJdWludCAjIyBf X3R5cGVfc2l6ZSAjIyBfdCB2YWwgPSBWQUwgIyMgX190eXBlX3NpemU7CQlcCisJCXVpbnQgIyMg X190eXBlX3NpemUgIyMgX3QgKnB0ciA9ICh1aW50ICMjIF9fdHlwZV9zaXplICMjIF90ICopIChi dWYgKyBvZmZzZXQpOyBcCisJCW1lbWNweShwdHIsICZ2YWwsIHNpemVvZih2YWwpKTsJCQkJCVwK KwkJdmFsID0gdGVzdF8gIyMgX19pbnN0KHB0ciwgb2Zmc2V0LCB2YWwpOwkJCVwKKwkJRVhQRUNU X0VRKFZBTCAjIyBfX3R5cGVfc2l6ZSwgdmFsKTsJCQkJXAorCX0JCQkJCQkJCQlcCit9CisKK1RF U1RfR1BfTE9BRChsaCwgMTYpOworVEVTVF9HUF9MT0FEKGxodSwgMTYpOworVEVTVF9HUF9MT0FE KGx3LCAzMik7CitURVNUX0dQX0xPQUQobHd1LCAzMik7CitURVNUX0dQX0xPQUQobGQsIDY0KTsK KyNpZmRlZiBfX3Jpc2N2X2NvbXByZXNzZWQKK1RFU1RfR1BfTE9BRChjX2x3LCAzMik7CitURVNU X0dQX0xPQUQoY19sZCwgNjQpOworVEVTVF9HUF9MT0FEKGNfbGRzcCwgNjQpOworI2VuZGlmCisK KyNkZWZpbmUgVEVTVF9HUF9TVE9SRShfX2luc3QsIF9fdHlwZV9zaXplKQkJCQkJXAorVEVTVChn cF9sb2FkXyAjIyBfX2luc3QpCQkJCQkJCVwKK3sJCQkJCQkJCQkJXAorCWludCBvZmZzZXQsIHJl dDsJCQkJCQkJXAorCXVpbnQ4X3QgYnVmWzE2XSBfX2F0dHJpYnV0ZV9fKChhbGlnbmVkKDE2KSkp OwkJCQlcCisJCQkJCQkJCQkJXAorCXJldCA9IHByY3RsKFBSX1NFVF9VTkFMSUdOLCBQUl9VTkFM SUdOX05PUFJJTlQpOwkJCVwKKwlBU1NFUlRfRVEocmV0LCAwKTsJCQkJCQkJXAorCQkJCQkJCQkJ CVwKKwlmb3IgKG9mZnNldCA9IDE7IG9mZnNldCA8IF9fdHlwZV9zaXplIC8gODsgb2Zmc2V0Kysp IHsJCQlcCisJCXVpbnQgIyMgX190eXBlX3NpemUgIyMgX3QgdmFsID0gVkFMICMjIF9fdHlwZV9z aXplOwkJXAorCQl1aW50ICMjIF9fdHlwZV9zaXplICMjIF90ICpwdHIgPSAodWludCAjIyBfX3R5 cGVfc2l6ZSAjIyBfdCAqKSAoYnVmICsgb2Zmc2V0KTsgXAorCQltZW1zZXQocHRyLCAwLCBzaXpl b2YodmFsKSk7CQkJCQlcCisJCXRlc3RfICMjIF9faW5zdChwdHIsIG9mZnNldCwgdmFsKTsJCQkJ XAorCQltZW1jcHkoJnZhbCwgcHRyLCBzaXplb2YodmFsKSk7CQkJCQlcCisJCUVYUEVDVF9FUShW QUwgIyMgX190eXBlX3NpemUsIHZhbCk7CQkJCVwKKwl9CQkJCQkJCQkJXAorfQorVEVTVF9HUF9T VE9SRShzaCwgMTYpOworVEVTVF9HUF9TVE9SRShzdywgMzIpOworVEVTVF9HUF9TVE9SRShzZCwg NjQpOworI2lmZGVmIF9fcmlzY3ZfY29tcHJlc3NlZAorVEVTVF9HUF9TVE9SRShjX3N3LCAzMik7 CitURVNUX0dQX1NUT1JFKGNfc2QsIDY0KTsKK1RFU1RfR1BfU1RPUkUoY19zZHNwLCA2NCk7Cisj ZW5kaWYKKworI2RlZmluZSBfX1RFU1RfRlBVX0xPQUQoX190eXBlLCBfX2luc3QsIF9fcmVnX3N0 YXJ0LCBfX3JlZ19lbmQpCQkJXAorVEVTVChmcHVfbG9hZF8gIyMgX19pbnN0KQkJCQkJCQlcCit7 CQkJCQkJCQkJCVwKKwlpbnQgaSwgcmV0LCBvZmZzZXQsIGZwX3JlZzsJCQkJCQlcCisJdWludDhf dCBidWZbMTZdIF9fYXR0cmlidXRlX18oKGFsaWduZWQoMTYpKSk7CQkJCVwKKwkJCQkJCQkJCQlc CisJcmV0ID0gcHJjdGwoUFJfU0VUX1VOQUxJR04sIFBSX1VOQUxJR05fTk9QUklOVCk7CQkJXAor CUFTU0VSVF9FUShyZXQsIDApOwkJCQkJCQlcCisJCQkJCQkJCQkJXAorCWZvciAoZnBfcmVnID0g X19yZWdfc3RhcnQ7IGZwX3JlZyA8IF9fcmVnX2VuZDsgZnBfcmVnKyspIHsJCVwKKwkJZm9yIChv ZmZzZXQgPSAxOyBvZmZzZXQgPCA0OyBvZmZzZXQrKykgewkJCVwKKwkJCXZvaWQgKmxvYWRfYWRk ciA9IChidWYgKyBvZmZzZXQpOwkJCVwKKwkJCV9fdHlwZSB2YWwgPSBWQUxfICMjIF9fdHlwZSA7 CQkJCVwKKwkJCQkJCQkJCQlcCisJCQltZW1jcHkobG9hZF9hZGRyLCAmdmFsLCBzaXplb2YodmFs KSk7CQkJXAorCQkJdmFsID0gdGVzdF8gIyMgX19pbnN0KGZwX3JlZywgbG9hZF9hZGRyLCBvZmZz ZXQsIHZhbCk7CVwKKwkJCUVYUEVDVF9UUlVFKF9fdHlwZSAjI19lcXVhbCh2YWwsIFZBTF8jIyBf X3R5cGUpKTsJXAorCQl9CQkJCQkJCQlcCisJfQkJCQkJCQkJCVwKK30KKyNkZWZpbmUgVEVTVF9G UFVfTE9BRChfX3R5cGUsIF9faW5zdCkgXAorCV9fVEVTVF9GUFVfTE9BRChfX3R5cGUsIF9faW5z dCwgMCwgMzIpCisjZGVmaW5lIFRFU1RfRlBVX0xPQURfQ09NUFJFU1NFRChfX3R5cGUsIF9faW5z dCkgXAorCV9fVEVTVF9GUFVfTE9BRChfX3R5cGUsIF9faW5zdCwgOCwgMTYpCisKK1RFU1RfRlBV X0xPQUQoZmxvYXQsIGZsdykKK1RFU1RfRlBVX0xPQUQoZG91YmxlLCBmbGQpCisjaWZkZWYgX19y aXNjdl9jb21wcmVzc2VkCitURVNUX0ZQVV9MT0FEX0NPTVBSRVNTRUQoZG91YmxlLCBjX2ZsZCkK K1RFU1RfRlBVX0xPQURfQ09NUFJFU1NFRChkb3VibGUsIGNfZmxkc3ApCisjZW5kaWYKKworI2Rl ZmluZSBfX1RFU1RfRlBVX1NUT1JFKF9fdHlwZSwgX19pbnN0LCBfX3JlZ19zdGFydCwgX19yZWdf ZW5kKQkJXAorVEVTVChmcHVfc3RvcmVfICMjIF9faW5zdCkJCQkJCQkJXAorewkJCQkJCQkJCQlc CisJaW50IGksIHJldCwgb2Zmc2V0LCBmcF9yZWc7CQkJCQkJXAorCXVpbnQ4X3QgYnVmWzE2XSBf X2F0dHJpYnV0ZV9fKChhbGlnbmVkKDE2KSkpOwkJCQlcCisJCQkJCQkJCQkJXAorCXJldCA9IHBy Y3RsKFBSX1NFVF9VTkFMSUdOLCBQUl9VTkFMSUdOX05PUFJJTlQpOwkJCVwKKwlBU1NFUlRfRVEo cmV0LCAwKTsJCQkJCQkJXAorCQkJCQkJCQkJCVwKKwlmb3IgKGZwX3JlZyA9IF9fcmVnX3N0YXJ0 OyBmcF9yZWcgPCBfX3JlZ19lbmQ7IGZwX3JlZysrKSB7CQlcCisJCWZvciAob2Zmc2V0ID0gMTsg b2Zmc2V0IDwgNDsgb2Zmc2V0KyspIHsJCQlcCisJCQkJCQkJCQkJXAorCQkJdm9pZCAqc3RvcmVf YWRkciA9IChidWYgKyBvZmZzZXQpOwkJCVwKKwkJCV9fdHlwZSB2YWwgPSBWQUxfICMjIF9fdHlw ZSA7CQkJCVwKKwkJCQkJCQkJCQlcCisJCQl0ZXN0XyAjIyBfX2luc3QoZnBfcmVnLCBzdG9yZV9h ZGRyLCBvZmZzZXQsIHZhbCk7CVwKKwkJCW1lbWNweSgmdmFsLCBzdG9yZV9hZGRyLCBzaXplb2Yo dmFsKSk7CQkJXAorCQkJRVhQRUNUX1RSVUUoX190eXBlICMjIF9lcXVhbCh2YWwsIFZBTF8jIyBf X3R5cGUpKTsJXAorCQl9CQkJCQkJCQlcCisJfQkJCQkJCQkJCVwKK30KKyNkZWZpbmUgVEVTVF9G UFVfU1RPUkUoX190eXBlLCBfX2luc3QpIFwKKwlfX1RFU1RfRlBVX1NUT1JFKF9fdHlwZSwgX19p bnN0LCAwLCAzMikKKyNkZWZpbmUgVEVTVF9GUFVfU1RPUkVfQ09NUFJFU1NFRChfX3R5cGUsIF9f aW5zdCkgXAorCV9fVEVTVF9GUFVfU1RPUkUoX190eXBlLCBfX2luc3QsIDgsIDE2KQorCitURVNU X0ZQVV9TVE9SRShmbG9hdCwgZnN3KQorVEVTVF9GUFVfU1RPUkUoZG91YmxlLCBmc2QpCisjaWZk ZWYgX19yaXNjdl9jb21wcmVzc2VkCitURVNUX0ZQVV9TVE9SRV9DT01QUkVTU0VEKGRvdWJsZSwg Y19mc2QpCitURVNUX0ZQVV9TVE9SRV9DT01QUkVTU0VEKGRvdWJsZSwgY19mc2RzcCkKKyNlbmRp ZgorCitURVNUX1NJR05BTChnZW5fc2lnYnVzLCBTSUdCVVMpCit7CisJdWludDMyX3QgKnB0cjsK Kwl1aW50OF90IGJ1ZlsxNl0gX19hdHRyaWJ1dGVfXygoYWxpZ25lZCgxNikpKTsKKwlpbnQgcmV0 OworCisJcmV0ID0gcHJjdGwoUFJfU0VUX1VOQUxJR04sIFBSX1VOQUxJR05fU0lHQlVTKTsKKwlB U1NFUlRfRVEocmV0LCAwKTsKKworCXB0ciA9ICh1aW50MzJfdCAqKShidWYgKyAxKTsKKwkqcHRy ID0gMHhERUFEQkVFRlVMTDsKK30KKworaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKiphcmd2KQor eworCWludCByZXQsIHZhbDsKKworCXJldCA9IHByY3RsKFBSX0dFVF9VTkFMSUdOLCAmdmFsKTsK KwlpZiAocmV0ID09IC0xICYmIGVycm5vID09IEVJTlZBTCkKKwkJa3NmdF9leGl0X3NraXAoIlNL SVAgR0VUX1VOQUxJR05fQ1RMIG5vdCBzdXBwb3J0ZWRcbiIpOworCisJZXhpdCh0ZXN0X2hhcm5l c3NfcnVuKGFyZ2MsIGFyZ3YpKTsKK30KLS0gCjIuNDcuMgoKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51 eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21h aWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK