From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-pl1-f179.google.com (mail-pl1-f179.google.com [209.85.214.179]) (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 58F6B28CF5C; Mon, 30 Jun 2025 16:53:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.179 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751302389; cv=none; b=AxtE+u7IS4+5tpQwd5aVMLqb2xPtf5jTyDOIHAMrxeTDTBGoRRof1mKkKTpyi5DQ+aN1A9Dus/oSGyPVUct1IVdPN7UuLsYFlMFIujGgpqm03l060a9TGkSPmPalkkJ0Mn58OwlhwB/KtSNhPldgGnkgxmHzhOGDfg1B+CAKUrc= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751302389; c=relaxed/simple; bh=ep4H5DS3MTQP8H3Wh337KJZSDRJFmcIqp3N4/7e5CoI=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=WFzO/Ii6Zi8GNVxbI/4vL9oVuZJGTHRFK2DtNlqLFHJVVqeIZbrjaQec2i21wOfdS0AMvzPAGlJMO3dAR6kWHVbqKky3DeyIG6j8c1205Q4Pq615Xqg1x5JN6qkJZvODYOZIpsDNdqgIVF+ds16SeFvKm+EjGe2npn4Qn6bpujk= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=eH8g4433; arc=none smtp.client-ip=209.85.214.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="eH8g4433" Received: by mail-pl1-f179.google.com with SMTP id d9443c01a7336-23526264386so21071995ad.2; Mon, 30 Jun 2025 09:53:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1751302387; x=1751907187; darn=vger.kernel.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=rhwmu3jF4Je/8Qh/5IFiLV5HdTzjZvADtchCUmoZy+s=; b=eH8g4433xy2OQYhbkYSJLYLTVfZfUUF9PwYmZvJuzGgH3ldzZkoKi+7b1SoAyxWHq9 smD6ei1jGlYhEx9U2OBmjX8JyRDbYrac/eolmQZOGBPQ5se8UJN38DVnhGcN1qU0lFID joGWmu6jUyFUNTsCusieBmYcVyj8DEgeQcPsNEC+2X9xRdmCKhBGx0UJfB4gPX+RZ0hj 5pBD5ApTakKU58Uc2jzYJtbrv5j0e3CEhH1vkzeV9w2AE9B5znm44RvwKQ3Yqnh5bC5T ioddEQtClV3vkxVqQ8p6AdGiEjHtynu0guOlZ5RVKHU9v10xgDjf9bOecZuGwHsXsgF3 4gWw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1751302387; x=1751907187; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=rhwmu3jF4Je/8Qh/5IFiLV5HdTzjZvADtchCUmoZy+s=; b=oQtlQL4Gj9CbgJ+xH1tRkw8p+SMWy1srASSuJIk5Vklzxr0NliPmSJ4DX7yk8Mgl0I V+MbHqFaYm+BhnWnerK7VIFG6m0f9uR4QMK3sN1dkWBgZFX7YbWLCTlkj18rzIjgzJVx ElMGIQEvdI2N0mmvVHzgr6Ou6rVSoYVVKIryXgyXZhsJB1Hba/wLxQTuXQJPw7GQYN+E KZjjk8brvbEehRj0ooWnsMSUCBgOWUr1DTXsEoQ0hvh0r94e4O2N9PdZaSTWzPJnAX/u jfcsDjDVlc41OTSc7U0u+f7lHSlKFaN/GIQPD3zC/l7juF0VHGVwTEOZEYBzvN5PdLOU liOg== X-Forwarded-Encrypted: i=1; AJvYcCU1fHki83q21Z5rbn22gqgiFUwfdTKc0ULxg/vPzQaaPXz2IuiU1mOMnyM0GVn5bGXoiDdE+ButYv5LcM8j@vger.kernel.org, AJvYcCUN/hQfBxoMFetRU4ba7sr/Y9u1OrrCtPt16bNH0VMIoq14iSjW7F19sbopiFd19SkNRpSt+F6nabD/@vger.kernel.org X-Gm-Message-State: AOJu0YyZdr5XslLb1iXkLZiAJ7b2//Jq7wKPYTgRQo3xGUz2ZxJzYK2d 4CuffZ8iiICcKRBiQGUghqryXPdQ5IwPeoAiX0H7T+Dc1EmdUEl2yNK+ X-Gm-Gg: ASbGnctzVtb2tHEk0tRg/+X7QQFNZclHaKUZ9iGGO2uvpnnf4zOrw+FyRowjDqLXO6s n4DvhjhFLn8gfBp4i5Cln6U+yEy83dIFyk/rudrox2OgbkRhtgzpB4DnoPdWD0a/DHZyZISCsvU 1VNHscF7utfj3YmtIFsaqoiGsdpiu6oZ+dO7ttrj+kOk9NbnPE9BFBz3qdtATvx/GyqIRrlDBtS HO2uM3W5/KAUvpijBucpdsZwp74Ej5p2pIT6FN6iaqNVTkKefR7JZwYV70UNGYHr0yMFv+DgfVb Yy2xNz1Jq6q8Nt/76t+ICoWwWmwVEyDBIIeL6b6EGbafNgWA/PBTjMBbtdx4rA== X-Google-Smtp-Source: AGHT+IEmP9coDGlfmU5ZCxbp02gfgkkPWL9aLzFkh3gfnmqdK4vHzSxpJeZniUGXfUtnHdsMYRf2oA== X-Received: by 2002:a17:902:db10:b0:235:1706:1fe7 with SMTP id d9443c01a7336-23ac3bffb5fmr204787945ad.4.1751302386491; Mon, 30 Jun 2025 09:53:06 -0700 (PDT) Received: from localhost ([216.228.127.130]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23acb3c94b3sm84031335ad.245.2025.06.30.09.53.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Jun 2025 09:53:06 -0700 (PDT) Date: Mon, 30 Jun 2025 12:53:03 -0400 From: Yury Norov To: cp0613@linux.alibaba.com Cc: alex@ghiti.fr, aou@eecs.berkeley.edu, arnd@arndb.de, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, linux@rasmusvillemoes.dk, palmer@dabbelt.com, paul.walmsley@sifive.com Subject: Re: [PATCH 2/2] bitops: rotate: Add riscv implementation using Zbb extension Message-ID: References: <20250630120457.1941-1-cp0613@linux.alibaba.com> Precedence: bulk X-Mailing-List: linux-arch@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20250630120457.1941-1-cp0613@linux.alibaba.com> On Mon, Jun 30, 2025 at 08:04:53PM +0800, cp0613@linux.alibaba.com wrote: > On Sat, 28 Jun 2025 21:48:02 -0400, yury.norov@gmail.com wrote: > > > > > > +static inline u8 variable_ror8(u8 word, unsigned int shift) > > > > > +{ > > > > > + u32 word32 = ((u32)word << 24) | ((u32)word << 16) | ((u32)word << 8) | word; > > > > > > > > Can you add a comment about what is happening here? Are you sure it's > > > > optimized out in case of the 'legacy' alternative? > > > > > > Thank you for your review. Yes, I referred to the existing variable__fls() > > > implementation, which should be fine. > > > > No, it's not fine. Because you trimmed your original email completely, > > so there's no way to understand what I'm asking about; and because you > > didn't answer my question. So I'll ask again: what exactly you are doing > > in the line you've trimmed out? > > Sorry, I misunderstood your question. Now I have made up for the lost original > email. This is my answer. The RISC-V Zbb extension only provides 64-bit data > rotation instructions rol/ror and 32-bit data rotation instructions rolw/rorw. > Therefore, for 16-bit and 8-bit data, in order to use the rolw/rorw instruction > optimization, the data is cyclically spliced ​​here, and the corresponding number > of bits is truncated after processing to achieve the function. > > This data preparation process does introduce additional operations. Compared with > genneric's implementation, I use the web tool provided by David to illustrate. > > The two functions that need to be compared are briefly summarized as follows: > ``` > unsigned char generic_ror8(unsigned char word, unsigned int shift) > { > return (word >> (shift & 7)) | (word << ((-shift) & 7)); > } > > unsigned char zbb_opt_ror8(unsigned char word, unsigned int shift) > { > unsigned int word32 = ((unsigned int)word << 24) | \ > ((unsigned int)word << 16) | ((unsigned int)word << 8) | word; > #ifdef __riscv > __asm__ volatile("nop"); // ALTERNATIVE(nop) > > __asm__ volatile( > ".option push\n" > ".option arch,+zbb\n" > "rorw %0, %1, %2\n" > ".option pop\n" > : "=r" (word32) : "r" (word32), "r" (shift) :); > #endif > return (unsigned char)word32; > } > ``` > The disassembly obtained is: > ``` > generic_ror8: > andi a1,a1,7 > negw a5,a1 > andi a5,a5,7 > sllw a5,a0,a5 > srlw a0,a0,a1 > or a0,a0,a5 > andi a0,a0,0xff > ret > > zbb_opt_ror8: > slli a5,a0,8 > add a0,a5,a0 > slliw a5,a0,16 > addw a5,a5,a0 > nop > rorw a5, a5, a1 > andi a0,a5,0xff > ret > ``` > From the perspective of the total number of instructions, although zbb_opt_ror8 has > one more instruction, one of them is a nop, so the difference with generic_ror8 should > be very small, or using the solution provided by David would be better for non-x86. And what about performance? > > > I did consider it, but I did not find any toolchain that provides an > > > implementation similar to __builtin_ror or __builtin_rol. If there is one, > > > please help point it out. > > > > This is the example of the toolchain you're looking for: > > > > /** > > * rol64 - rotate a 64-bit value left > > * @word: value to rotate > > * @shift: bits to roll > > */ > > static inline __u64 rol64(__u64 word, unsigned int shift) > > { > > return (word << (shift & 63)) | (word >> ((-shift) & 63)); > > } > > > > What I'm asking is: please show me that compile-time rol/ror is still > > calculated at compile time, i.e. ror64(1234, 12) is evaluated at > > compile time. > > I see what you mean, I didn't consider the case of constants being evaluated > at compile time, as you pointed out earlier: > "you wire ror/rol() to the variable_ror/rol() unconditionally, and that breaks > compile-time rotation if the parameter is known at compile time." > > In the absence of compiler built-in function support, I think it can be handled > like this: > ``` > #define rol16(word, shift) \ > (__builtin_constant_p(word) && __builtin_constant_p(shift) ? \ > generic_ror16(word, shift) : variable_rol16(word, shift)) > ``` > How do you see? That's what I meant. > > > In addition, I did not consider it carefully before. If the rotate function > > > is to be genericized, all archneed to include . > > > I missed this step. > > > > Sorry, I'm lost here about what you've considered and what not. I'm OK > > about accelerating ror/rol, but I want to make sure that; > > > > 1. The most trivial compile-case is actually evaluated at compile time; and > > 2. Any arch-specific code is well explained; and > > 3. legacy case optimized just as well as non-legacy. > > 1. As in the above reply, use the generic implementation when compile-time evaluation > is possible。 > 2. I will improve the comments later. I'm particularly interested in ror8/rol8 case: u32 word32 = ((u32)word << 24) | ((u32)word << 16) | ((u32)word << 8) | word; When you expand it to 32-bit word, and want to rotate, you obviously need to copy lower quarterword to the higher one: 0xab >> 0xab0000ab That way generic (u8)ror32(0xab, shift) would work. But I don't understand why you copy the lower 8 bits to inner quarterwords. Is that a hardware requirement? Can you point to any arch documentation > 3. As mentioned before, only 8-bit rotation should have no optimization effect, and > 16-bit and above will have significant optimization. I asked you about the asm goto ("legacy") thing: you calculate that complex word32 _before_ evaluating the goto. So this word32 may get unused, and you waste cycles. I want to make sure this isn't the case. Please find attached a test for compile-time ror/rol evaluation. Please consider prepending your series with it. Thanks, Yury >From 5c5be22117a2bd0a656efae0efd6ed159d4168c5 Mon Sep 17 00:00:00 2001 From: Yury Norov Date: Mon, 30 Jun 2025 12:07:47 -0400 Subject: [PATCH] bitops: add compile-time test for ror() and rol() If parameters for the functions are passed at compile time, the compiler must calculate the result at compile time, as well. Now that architectures introduce accelerated implementations for bit rotation, we must make sure that they don't break compile-time evaluation. This patch adds a test for it, similarly to test_bitmap_const_eval(). Tested on x86_64. Signed-off-by: Yury Norov (NVIDIA) --- lib/test_bitops.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/lib/test_bitops.c b/lib/test_bitops.c index 55669624bb28..aa4c06df34f7 100644 --- a/lib/test_bitops.c +++ b/lib/test_bitops.c @@ -76,6 +76,56 @@ static int __init test_fns(void) return 0; } +static void __init test_bitops_const_eval(void) +{ + /* + * ror/rol operations on parameters known at compile-time must be + * optimized to compile-time constants on any supported optimization + * level (-O2, -Os) and all architectures. Otherwise, trigger a build + * bug. + */ + + u64 r64 = ror64(0x1234567890abcdefull, 24); + + BUILD_BUG_ON(!__builtin_constant_p(r64)); + BUILD_BUG_ON(r64 != 0xabcdef1234567890ull); + + u64 l64 = rol64(0x1234567890abcdefull, 24); + + BUILD_BUG_ON(!__builtin_constant_p(l64)); + BUILD_BUG_ON(l64 != 0x7890abcdef123456ull); + + u32 r32 = ror32(0x12345678, 24); + + BUILD_BUG_ON(!__builtin_constant_p(r32)); + BUILD_BUG_ON(r32 != 0x34567812); + + u32 l32 = rol32(0x12345678, 24); + + BUILD_BUG_ON(!__builtin_constant_p(l32)); + BUILD_BUG_ON(l32 != 0x78123456); + + u16 r16 = ror16(0x1234, 12); + + BUILD_BUG_ON(!__builtin_constant_p(r16)); + BUILD_BUG_ON(r16 != 0x2341); + + u16 l16 = rol16(0x1234, 12); + + BUILD_BUG_ON(!__builtin_constant_p(l16)); + BUILD_BUG_ON(l16 != 0x4123); + + u8 r8 = ror8(0x12, 6); + + BUILD_BUG_ON(!__builtin_constant_p(r16)); + BUILD_BUG_ON(r8 != 0x48); + + u8 l8 = rol8(0x12, 6); + + BUILD_BUG_ON(!__builtin_constant_p(l16)); + BUILD_BUG_ON(l8 != 0x84); +} + static int __init test_bitops_startup(void) { int i, bit_set; @@ -121,6 +171,7 @@ static int __init test_bitops_startup(void) pr_err("ERROR: FOUND SET BIT %d\n", bit_set); test_fns(); + test_bitops_const_eval(); pr_info("Completed bitops test\n"); -- 2.43.0 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 08DCDC83029 for ; Mon, 30 Jun 2025 17:55:42 +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:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=SvX6n18Mt/Cl7g58cNrXjmHmCMXhPOCbUNvUevVsgUg=; b=U78cLhKVcmpzlg inoSNGp/y/vqo6RNzfNKACb9m0zbFGTaPMLapUQAY5+Qs0B1wjbMzfghm05cKix3VNgXTUwWu664K d14aXHqvYqlniRaDwUsYAHPvncR61sa2WJ3QKWEn9nCNdfm7zVsn+w2xJW4s6/sudBtawpK8y2Kf3 yzFap6zoTQyWU683AW+i4FiC9bg2gHSjxcNewRRoOWTfoJ4sGsZl4t2RYidBuPWCa0v+UJHfvUTKS 5871rBpbyC0aJUQncy4pOquAHdxiE3JsXlvfl1vtL6+I9jDTa5nM4Y4Lm/LeEFHO7jE11WwGSMGEM yOnxDNDE1erkyEvSqXSg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uWIj9-000000037xv-2a2p; Mon, 30 Jun 2025 17:55:35 +0000 Received: from mail-pl1-x62d.google.com ([2607:f8b0:4864:20::62d]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1uWHkh-00000002zpy-3UT5 for linux-riscv@lists.infradead.org; Mon, 30 Jun 2025 16:53:08 +0000 Received: by mail-pl1-x62d.google.com with SMTP id d9443c01a7336-2349f096605so25007065ad.3 for ; Mon, 30 Jun 2025 09:53:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1751302387; x=1751907187; darn=lists.infradead.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=rhwmu3jF4Je/8Qh/5IFiLV5HdTzjZvADtchCUmoZy+s=; b=K5eQOp+QZaCHLF6uRgS5RfpiGUApbGZztVpMwCC4BKmHIfzhs4ALfikgcD/qPNyt+2 iR3klM4RJmSle2+cFU6jLzz1vbm0OGeJq+u1n+zSuRR8gDTYjRF3k0STg7wbvWXr9Gbx irOOuMbjsNp+d6qCKW771IgiNWoQ0f9RAvdNEE+Zfg0n0FMkzajVFl+cUWNjk6T21nxx uS8WkyggzAKIuW0xHGIAkXS3iwa81dx/AIhrje4znOD7W4RYJvOyZSOtGldTtE91OGb2 L0Ww+eDrdZPB+IOdHpHwI01IbavgSyYZRAwBsaA6hDCwGA1cYqrk6KJKMhRxHDYypZ0Y h7jg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1751302387; x=1751907187; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=rhwmu3jF4Je/8Qh/5IFiLV5HdTzjZvADtchCUmoZy+s=; b=rp9lPHTDPpmgvCnXSNKOWnhhYulexzQOKeVVynfDSGKfG+M/GItU7/5TZGOpXaA3bC hTRt9hfLF5N9orkTQ8U8RfHP6+1dMtIJbd3whjOMQeBt2ygPtfnN6wrgk2f9AgxmvE5P /dakP91BSULXHKVX/srD5aR8fJ9GjedcvaASSdVFtQ931vd2iu5TdrQq9rYrl79Q0gGk y/r2pPACxAqgraSbCTOnVGt+SawN0NHwHhVY8eaULIFRoDVWUccb8x56YzQliQelNG5E qdDcemtLeodB12qTJMwXz4Yd8VeypGji52f1j4HiIsSV1IuSUMpk8xy0+/bB0W+9EQWq NXiw== X-Forwarded-Encrypted: i=1; AJvYcCW49OIMrkDVZjmCHPZ+8+wNZBi4oa3wuUtIBOnVB27L9MOfXNvLvMrs4/eGNjowxVk94/o6JrocQj/yIA==@lists.infradead.org X-Gm-Message-State: AOJu0YzqLrsOUwnzKNfmIQm5aZ1R9Y4ysSJ9R1P2IQSs6wxmcB9EZR7A IZDznGRHo83hdmU5/OwXesPZvQ6gAMzaXgHzoUJzSKWhL8irPS/NaJD5 X-Gm-Gg: ASbGncupxJyiACYhKcBCPVm1LrCPzUfqdVuA1KX2K/PiYtK7BMQ4H3jsDgsTg9uOzVB NlJLKPNkJhD42FrTfEnVO85sTkLlj7Dm2uSFWSPqiH/Ciz08Nyt9+LGzsCmYsq23cFchSiZzUWI oApe0eHMjALJllmtFvbFETlbJ88nqIJcwM2Z+fHVS75EFlz3KKfUVuBWkvHyLcZAmBjTG0AhG6a rRyhcCcBp5KdC0WsG/DKq8HDqZ/zzfZJ4QwqHGTmAiRQWm5HLCJfCrY3JdoRJC2UJLacE/AROPh o8XFr5ZYdnvmdEtHrI+psqAOFJ36NmbL9ja/XwAJ2w2mqP2e3YmE/g6KoOuacQ== X-Google-Smtp-Source: AGHT+IEmP9coDGlfmU5ZCxbp02gfgkkPWL9aLzFkh3gfnmqdK4vHzSxpJeZniUGXfUtnHdsMYRf2oA== X-Received: by 2002:a17:902:db10:b0:235:1706:1fe7 with SMTP id d9443c01a7336-23ac3bffb5fmr204787945ad.4.1751302386491; Mon, 30 Jun 2025 09:53:06 -0700 (PDT) Received: from localhost ([216.228.127.130]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-23acb3c94b3sm84031335ad.245.2025.06.30.09.53.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Jun 2025 09:53:06 -0700 (PDT) Date: Mon, 30 Jun 2025 12:53:03 -0400 From: Yury Norov To: cp0613@linux.alibaba.com Cc: alex@ghiti.fr, aou@eecs.berkeley.edu, arnd@arndb.de, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, linux@rasmusvillemoes.dk, palmer@dabbelt.com, paul.walmsley@sifive.com Subject: Re: [PATCH 2/2] bitops: rotate: Add riscv implementation using Zbb extension Message-ID: References: <20250630120457.1941-1-cp0613@linux.alibaba.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20250630120457.1941-1-cp0613@linux.alibaba.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250630_095307_879575_8CE03A0A X-CRM114-Status: GOOD ( 50.47 ) 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 T24gTW9uLCBKdW4gMzAsIDIwMjUgYXQgMDg6MDQ6NTNQTSArMDgwMCwgY3AwNjEzQGxpbnV4LmFs aWJhYmEuY29tIHdyb3RlOgo+IE9uIFNhdCwgMjggSnVuIDIwMjUgMjE6NDg6MDIgLTA0MDAsIHl1 cnkubm9yb3ZAZ21haWwuY29tIHdyb3RlOgo+IAo+ID4gPiA+ID4gK3N0YXRpYyBpbmxpbmUgdTgg dmFyaWFibGVfcm9yOCh1OCB3b3JkLCB1bnNpZ25lZCBpbnQgc2hpZnQpCj4gPiA+ID4gPiArewo+ ID4gPiA+ID4gKwl1MzIgd29yZDMyID0gKCh1MzIpd29yZCA8PCAyNCkgfCAoKHUzMil3b3JkIDw8 IDE2KSB8ICgodTMyKXdvcmQgPDwgOCkgfCB3b3JkOwo+ID4gPiA+IAo+ID4gPiA+IENhbiB5b3Ug YWRkIGEgY29tbWVudCBhYm91dCB3aGF0IGlzIGhhcHBlbmluZyBoZXJlPyBBcmUgeW91IHN1cmUg aXQncwo+ID4gPiA+IG9wdGltaXplZCBvdXQgaW4gY2FzZSBvZiB0aGUgJ2xlZ2FjeScgYWx0ZXJu YXRpdmU/Cj4gPiA+IAo+ID4gPiBUaGFuayB5b3UgZm9yIHlvdXIgcmV2aWV3LiBZZXMsIEkgcmVm ZXJyZWQgdG8gdGhlIGV4aXN0aW5nIHZhcmlhYmxlX19mbHMoKQo+ID4gPiBpbXBsZW1lbnRhdGlv biwgd2hpY2ggc2hvdWxkIGJlIGZpbmUuCj4gPiAKPiA+IE5vLCBpdCdzIG5vdCBmaW5lLiBCZWNh dXNlIHlvdSB0cmltbWVkIHlvdXIgb3JpZ2luYWwgZW1haWwgY29tcGxldGVseSwKPiA+IHNvIHRo ZXJlJ3Mgbm8gd2F5IHRvIHVuZGVyc3RhbmQgd2hhdCBJJ20gYXNraW5nIGFib3V0OyBhbmQgYmVj YXVzZSB5b3UKPiA+IGRpZG4ndCBhbnN3ZXIgbXkgcXVlc3Rpb24uIFNvIEknbGwgYXNrIGFnYWlu OiB3aGF0IGV4YWN0bHkgeW91IGFyZSBkb2luZwo+ID4gaW4gdGhlIGxpbmUgeW91J3ZlIHRyaW1t ZWQgb3V0Pwo+IAo+IFNvcnJ5LCBJIG1pc3VuZGVyc3Rvb2QgeW91ciBxdWVzdGlvbi4gTm93IEkg aGF2ZSBtYWRlIHVwIGZvciB0aGUgbG9zdCBvcmlnaW5hbAo+IGVtYWlsLiBUaGlzIGlzIG15IGFu c3dlci4gVGhlIFJJU0MtViBaYmIgZXh0ZW5zaW9uIG9ubHkgcHJvdmlkZXMgNjQtYml0IGRhdGEK PiByb3RhdGlvbiBpbnN0cnVjdGlvbnMgcm9sL3JvciBhbmQgMzItYml0IGRhdGEgcm90YXRpb24g aW5zdHJ1Y3Rpb25zIHJvbHcvcm9ydy4KPiBUaGVyZWZvcmUsIGZvciAxNi1iaXQgYW5kIDgtYml0 IGRhdGEsIGluIG9yZGVyIHRvIHVzZSB0aGUgcm9sdy9yb3J3IGluc3RydWN0aW9uCj4gb3B0aW1p emF0aW9uLCB0aGUgZGF0YSBpcyBjeWNsaWNhbGx5IHNwbGljZWQg4oCL4oCLaGVyZSwgYW5kIHRo ZSBjb3JyZXNwb25kaW5nIG51bWJlcgo+IG9mIGJpdHMgaXMgdHJ1bmNhdGVkIGFmdGVyIHByb2Nl c3NpbmcgdG8gYWNoaWV2ZSB0aGUgZnVuY3Rpb24uCj4gCj4gVGhpcyBkYXRhIHByZXBhcmF0aW9u IHByb2Nlc3MgZG9lcyBpbnRyb2R1Y2UgYWRkaXRpb25hbCBvcGVyYXRpb25zLiBDb21wYXJlZCB3 aXRoCj4gZ2VubmVyaWMncyBpbXBsZW1lbnRhdGlvbiwgSSB1c2UgdGhlIHdlYiB0b29sIHByb3Zp ZGVkIGJ5IERhdmlkIHRvIGlsbHVzdHJhdGUuCj4gCj4gVGhlIHR3byBmdW5jdGlvbnMgdGhhdCBu ZWVkIHRvIGJlIGNvbXBhcmVkIGFyZSBicmllZmx5IHN1bW1hcml6ZWQgYXMgZm9sbG93czoKPiBg YGAKPiB1bnNpZ25lZCBjaGFyIGdlbmVyaWNfcm9yOCh1bnNpZ25lZCBjaGFyIHdvcmQsIHVuc2ln bmVkIGludCBzaGlmdCkKPiB7Cj4gCXJldHVybiAod29yZCA+PiAoc2hpZnQgJiA3KSkgfCAod29y ZCA8PCAoKC1zaGlmdCkgJiA3KSk7Cj4gfQo+IAo+IHVuc2lnbmVkIGNoYXIgemJiX29wdF9yb3I4 KHVuc2lnbmVkIGNoYXIgd29yZCwgdW5zaWduZWQgaW50IHNoaWZ0KQo+IHsKPiAJdW5zaWduZWQg aW50IHdvcmQzMiA9ICgodW5zaWduZWQgaW50KXdvcmQgPDwgMjQpIHwgXAo+IAkgICAgKCh1bnNp Z25lZCBpbnQpd29yZCA8PCAxNikgfCAoKHVuc2lnbmVkIGludCl3b3JkIDw8IDgpIHwgd29yZDsK PiAjaWZkZWYgX19yaXNjdgo+IAlfX2FzbV9fIHZvbGF0aWxlKCJub3AiKTsgLy8gQUxURVJOQVRJ VkUobm9wKQo+IAo+IAlfX2FzbV9fIHZvbGF0aWxlKAo+IAkJIi5vcHRpb24gcHVzaFxuIgo+IAkJ Ii5vcHRpb24gYXJjaCwremJiXG4iCj4gCQkicm9ydyAlMCwgJTEsICUyXG4iCj4gCQkiLm9wdGlv biBwb3BcbiIKPiAJCTogIj1yIiAod29yZDMyKSA6ICJyIiAod29yZDMyKSwgInIiIChzaGlmdCkg Oik7Cj4gI2VuZGlmCj4gCXJldHVybiAodW5zaWduZWQgY2hhcil3b3JkMzI7Cj4gfQo+IGBgYAo+ IFRoZSBkaXNhc3NlbWJseSBvYnRhaW5lZCBpczoKPiBgYGAKPiBnZW5lcmljX3Jvcjg6Cj4gICAg IGFuZGkgICAgYTEsYTEsNwo+ICAgICBuZWd3ICAgIGE1LGExCj4gICAgIGFuZGkgICAgYTUsYTUs Nwo+ICAgICBzbGx3ICAgIGE1LGEwLGE1Cj4gICAgIHNybHcgICAgYTAsYTAsYTEKPiAgICAgb3Ig ICAgICBhMCxhMCxhNQo+ICAgICBhbmRpICAgIGEwLGEwLDB4ZmYKPiAgICAgcmV0Cj4gCj4gemJi X29wdF9yb3I4Ogo+ICAgICBzbGxpICAgIGE1LGEwLDgKPiAgICAgYWRkICAgICBhMCxhNSxhMAo+ ICAgICBzbGxpdyAgIGE1LGEwLDE2Cj4gICAgIGFkZHcgICAgYTUsYTUsYTAKPiAgICAgbm9wCj4g ICAgIHJvcncgYTUsIGE1LCBhMQo+ICAgICBhbmRpICAgIGEwLGE1LDB4ZmYKPiAgICAgcmV0Cj4g YGBgCj4gRnJvbSB0aGUgcGVyc3BlY3RpdmUgb2YgdGhlIHRvdGFsIG51bWJlciBvZiBpbnN0cnVj dGlvbnMsIGFsdGhvdWdoIHpiYl9vcHRfcm9yOCBoYXMKPiBvbmUgbW9yZSBpbnN0cnVjdGlvbiwg b25lIG9mIHRoZW0gaXMgYSBub3AsIHNvIHRoZSBkaWZmZXJlbmNlIHdpdGggZ2VuZXJpY19yb3I4 IHNob3VsZAo+IGJlIHZlcnkgc21hbGwsIG9yIHVzaW5nIHRoZSBzb2x1dGlvbiBwcm92aWRlZCBi eSBEYXZpZCB3b3VsZCBiZSBiZXR0ZXIgZm9yIG5vbi14ODYuCgpBbmQgd2hhdCBhYm91dCBwZXJm b3JtYW5jZT8KCj4gPiA+IEkgZGlkIGNvbnNpZGVyIGl0LCBidXQgSSBkaWQgbm90IGZpbmQgYW55 IHRvb2xjaGFpbiB0aGF0IHByb3ZpZGVzIGFuCj4gPiA+IGltcGxlbWVudGF0aW9uIHNpbWlsYXIg dG8gX19idWlsdGluX3JvciBvciBfX2J1aWx0aW5fcm9sLiBJZiB0aGVyZSBpcyBvbmUsCj4gPiA+ IHBsZWFzZSBoZWxwIHBvaW50IGl0IG91dC4KPiA+IAo+ID4gVGhpcyBpcyB0aGUgZXhhbXBsZSBv ZiB0aGUgdG9vbGNoYWluIHlvdSdyZSBsb29raW5nIGZvcjoKPiA+IAo+ID4gICAvKioKPiA+ICAg ICogcm9sNjQgLSByb3RhdGUgYSA2NC1iaXQgdmFsdWUgbGVmdAo+ID4gICAgKiBAd29yZDogdmFs dWUgdG8gcm90YXRlCj4gPiAgICAqIEBzaGlmdDogYml0cyB0byByb2xsCj4gPiAgICAqLwo+ID4g ICBzdGF0aWMgaW5saW5lIF9fdTY0IHJvbDY0KF9fdTY0IHdvcmQsIHVuc2lnbmVkIGludCBzaGlm dCkKPiA+ICAgewo+ID4gICAgICAgICAgIHJldHVybiAod29yZCA8PCAoc2hpZnQgJiA2MykpIHwg KHdvcmQgPj4gKCgtc2hpZnQpICYgNjMpKTsKPiA+ICAgfQo+ID4gCj4gPiBXaGF0IEknbSBhc2tp bmcgaXM6IHBsZWFzZSBzaG93IG1lIHRoYXQgY29tcGlsZS10aW1lIHJvbC9yb3IgaXMgc3RpbGwK PiA+IGNhbGN1bGF0ZWQgYXQgY29tcGlsZSB0aW1lLCBpLmUuIHJvcjY0KDEyMzQsIDEyKSBpcyBl dmFsdWF0ZWQgYXQKPiA+IGNvbXBpbGUgdGltZS4KPiAKPiBJIHNlZSB3aGF0IHlvdSBtZWFuLCBJ IGRpZG4ndCBjb25zaWRlciB0aGUgY2FzZSBvZiBjb25zdGFudHMgYmVpbmcgZXZhbHVhdGVkCj4g YXQgY29tcGlsZSB0aW1lLCBhcyB5b3UgcG9pbnRlZCBvdXQgZWFybGllcjoKPiAieW91IHdpcmUg cm9yL3JvbCgpIHRvIHRoZSB2YXJpYWJsZV9yb3Ivcm9sKCkgdW5jb25kaXRpb25hbGx5LCBhbmQg dGhhdCBicmVha3MKPiBjb21waWxlLXRpbWUgcm90YXRpb24gaWYgdGhlIHBhcmFtZXRlciBpcyBr bm93biBhdCBjb21waWxlIHRpbWUuIgo+IAo+IEluIHRoZSBhYnNlbmNlIG9mIGNvbXBpbGVyIGJ1 aWx0LWluIGZ1bmN0aW9uIHN1cHBvcnQsIEkgdGhpbmsgaXQgY2FuIGJlIGhhbmRsZWQKPiBsaWtl IHRoaXM6Cj4gYGBgCj4gI2RlZmluZSByb2wxNih3b3JkLCBzaGlmdCkgXAo+IAkoX19idWlsdGlu X2NvbnN0YW50X3Aod29yZCkgJiYgX19idWlsdGluX2NvbnN0YW50X3Aoc2hpZnQpID8gXAo+IAln ZW5lcmljX3JvcjE2KHdvcmQsIHNoaWZ0KSA6IHZhcmlhYmxlX3JvbDE2KHdvcmQsIHNoaWZ0KSkK PiBgYGAKPiBIb3cgZG8geW91IHNlZT8KClRoYXQncyB3aGF0IEkgbWVhbnQuCiAKPiA+ID4gSW4g YWRkaXRpb24sIEkgZGlkIG5vdCBjb25zaWRlciBpdCBjYXJlZnVsbHkgYmVmb3JlLiBJZiB0aGUg cm90YXRlIGZ1bmN0aW9uCj4gPiA+IGlzIHRvIGJlIGdlbmVyaWNpemVkLCBhbGwgYXJjaG5lZWQg dG8gaW5jbHVkZSA8YXNtLWdlbmVyaWMvYml0b3BzL3JvdGF0ZS5oPi4KPiA+ID4gSSBtaXNzZWQg dGhpcyBzdGVwLgo+ID4gCj4gPiBTb3JyeSwgSSdtIGxvc3QgaGVyZSBhYm91dCB3aGF0IHlvdSd2 ZSBjb25zaWRlcmVkIGFuZCB3aGF0IG5vdC4gSSdtIE9LCj4gPiBhYm91dCBhY2NlbGVyYXRpbmcg cm9yL3JvbCwgYnV0IEkgd2FudCB0byBtYWtlIHN1cmUgdGhhdDsKPiA+IAo+ID4gMS4gVGhlIG1v c3QgdHJpdmlhbCBjb21waWxlLWNhc2UgaXMgYWN0dWFsbHkgZXZhbHVhdGVkIGF0IGNvbXBpbGUg dGltZTsgYW5kCj4gPiAyLiBBbnkgYXJjaC1zcGVjaWZpYyBjb2RlIGlzIHdlbGwgZXhwbGFpbmVk OyBhbmQKPiA+IDMuIGxlZ2FjeSBjYXNlIG9wdGltaXplZCBqdXN0IGFzIHdlbGwgYXMgbm9uLWxl Z2FjeS4KPiAKPiAxLiBBcyBpbiB0aGUgYWJvdmUgcmVwbHksIHVzZSB0aGUgZ2VuZXJpYyBpbXBs ZW1lbnRhdGlvbiB3aGVuIGNvbXBpbGUtdGltZSBldmFsdWF0aW9uCj4gICAgaXMgcG9zc2libGXj gIIKPiAyLiBJIHdpbGwgaW1wcm92ZSB0aGUgY29tbWVudHMgbGF0ZXIuCgpJJ20gcGFydGljdWxh cmx5IGludGVyZXN0ZWQgaW4gcm9yOC9yb2w4IGNhc2U6CgogICAgICAgIHUzMiB3b3JkMzIgPSAo KHUzMil3b3JkIDw8IDI0KSB8ICgodTMyKXdvcmQgPDwgMTYpIHwgKCh1MzIpd29yZCA8PCA4KSB8 IHdvcmQ7CgpXaGVuIHlvdSBleHBhbmQgaXQgdG8gMzItYml0IHdvcmQsIGFuZCB3YW50IHRvIHJv dGF0ZSwgeW91IG9idmlvdXNseQpuZWVkIHRvIGNvcHkgbG93ZXIgcXVhcnRlcndvcmQgdG8gdGhl IGhpZ2hlciBvbmU6CgogICAgICAgIDB4YWIgPj4gMHhhYjAwMDBhYgoKVGhhdCB3YXkgZ2VuZXJp YyAodTgpcm9yMzIoMHhhYiwgc2hpZnQpIHdvdWxkIHdvcmsuIEJ1dCBJIGRvbid0IHVuZGVyc3Rh bmQKd2h5IHlvdSBjb3B5IHRoZSBsb3dlciA4IGJpdHMgdG8gaW5uZXIgcXVhcnRlcndvcmRzLiBJ cyB0aGF0IGEgaGFyZHdhcmUKcmVxdWlyZW1lbnQ/IENhbiB5b3UgcG9pbnQgdG8gYW55IGFyY2gg ZG9jdW1lbnRhdGlvbiAKCj4gMy4gQXMgbWVudGlvbmVkIGJlZm9yZSwgb25seSA4LWJpdCByb3Rh dGlvbiBzaG91bGQgaGF2ZSBubyBvcHRpbWl6YXRpb24gZWZmZWN0LCBhbmQKPiAgICAxNi1iaXQg YW5kIGFib3ZlIHdpbGwgaGF2ZSBzaWduaWZpY2FudCBvcHRpbWl6YXRpb24uCgpJIGFza2VkIHlv dSBhYm91dCB0aGUgYXNtIGdvdG8gKCJsZWdhY3kiKSB0aGluZzogeW91IGNhbGN1bGF0ZSB0aGF0 CmNvbXBsZXggd29yZDMyIF9iZWZvcmVfIGV2YWx1YXRpbmcgdGhlIGdvdG8uIFNvIHRoaXMgd29y ZDMyIG1heSBnZXQKdW51c2VkLCBhbmQgeW91IHdhc3RlIGN5Y2xlcy4gSSB3YW50IHRvIG1ha2Ug c3VyZSB0aGlzIGlzbid0IHRoZSBjYXNlLgoKUGxlYXNlIGZpbmQgYXR0YWNoZWQgYSB0ZXN0IGZv ciBjb21waWxlLXRpbWUgcm9yL3JvbCBldmFsdWF0aW9uLgpQbGVhc2UgY29uc2lkZXIgcHJlcGVu ZGluZyB5b3VyIHNlcmllcyB3aXRoIGl0LgoKVGhhbmtzLApZdXJ5CgpGcm9tIDVjNWJlMjIxMTdh MmJkMGE2NTZlZmFlMGVmZDZlZDE1OWQ0MTY4YzUgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZy b206IFl1cnkgTm9yb3YgPHl1cnkubm9yb3ZAZ21haWwuY29tPgpEYXRlOiBNb24sIDMwIEp1biAy MDI1IDEyOjA3OjQ3IC0wNDAwClN1YmplY3Q6IFtQQVRDSF0gYml0b3BzOiBhZGQgY29tcGlsZS10 aW1lIHRlc3QgZm9yIHJvcigpIGFuZCByb2woKQoKSWYgcGFyYW1ldGVycyBmb3IgdGhlIGZ1bmN0 aW9ucyBhcmUgcGFzc2VkIGF0IGNvbXBpbGUgdGltZSwgdGhlIGNvbXBpbGVyCm11c3QgY2FsY3Vs YXRlIHRoZSByZXN1bHQgYXQgY29tcGlsZSB0aW1lLCBhcyB3ZWxsLgoKTm93IHRoYXQgYXJjaGl0 ZWN0dXJlcyBpbnRyb2R1Y2UgYWNjZWxlcmF0ZWQgaW1wbGVtZW50YXRpb25zIGZvciBiaXQKcm90 YXRpb24sIHdlIG11c3QgbWFrZSBzdXJlIHRoYXQgdGhleSBkb24ndCBicmVhayBjb21waWxlLXRp bWUKZXZhbHVhdGlvbi4KClRoaXMgcGF0Y2ggYWRkcyBhIHRlc3QgZm9yIGl0LCBzaW1pbGFybHkg dG8gdGVzdF9iaXRtYXBfY29uc3RfZXZhbCgpLgoKVGVzdGVkIG9uIHg4Nl82NC4KClNpZ25lZC1v ZmYtYnk6IFl1cnkgTm9yb3YgKE5WSURJQSkgPHl1cnkubm9yb3ZAZ21haWwuY29tPgotLS0KIGxp Yi90ZXN0X2JpdG9wcy5jIHwgNTEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA1MSBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0 IGEvbGliL3Rlc3RfYml0b3BzLmMgYi9saWIvdGVzdF9iaXRvcHMuYwppbmRleCA1NTY2OTYyNGJi MjguLmFhNGMwNmRmMzRmNyAxMDA2NDQKLS0tIGEvbGliL3Rlc3RfYml0b3BzLmMKKysrIGIvbGli L3Rlc3RfYml0b3BzLmMKQEAgLTc2LDYgKzc2LDU2IEBAIHN0YXRpYyBpbnQgX19pbml0IHRlc3Rf Zm5zKHZvaWQpCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIF9faW5pdCB0ZXN0X2JpdG9w c19jb25zdF9ldmFsKHZvaWQpCit7CisJLyoKKwkgKiByb3Ivcm9sIG9wZXJhdGlvbnMgb24gcGFy YW1ldGVycyBrbm93biBhdCBjb21waWxlLXRpbWUgbXVzdCBiZQorCSAqIG9wdGltaXplZCB0byBj b21waWxlLXRpbWUgY29uc3RhbnRzIG9uIGFueSBzdXBwb3J0ZWQgb3B0aW1pemF0aW9uCisJICog bGV2ZWwgKC1PMiwgLU9zKSBhbmQgYWxsIGFyY2hpdGVjdHVyZXMuIE90aGVyd2lzZSwgdHJpZ2dl ciBhIGJ1aWxkCisJICogYnVnLgorCSAqLworCisJdTY0IHI2NCA9IHJvcjY0KDB4MTIzNDU2Nzg5 MGFiY2RlZnVsbCwgMjQpOworCisJQlVJTERfQlVHX09OKCFfX2J1aWx0aW5fY29uc3RhbnRfcChy NjQpKTsKKwlCVUlMRF9CVUdfT04ocjY0ICE9IDB4YWJjZGVmMTIzNDU2Nzg5MHVsbCk7CisKKwl1 NjQgbDY0ID0gcm9sNjQoMHgxMjM0NTY3ODkwYWJjZGVmdWxsLCAyNCk7CisKKwlCVUlMRF9CVUdf T04oIV9fYnVpbHRpbl9jb25zdGFudF9wKGw2NCkpOworCUJVSUxEX0JVR19PTihsNjQgIT0gMHg3 ODkwYWJjZGVmMTIzNDU2dWxsKTsKKworCXUzMiByMzIgPSByb3IzMigweDEyMzQ1Njc4LCAyNCk7 CisKKwlCVUlMRF9CVUdfT04oIV9fYnVpbHRpbl9jb25zdGFudF9wKHIzMikpOworCUJVSUxEX0JV R19PTihyMzIgIT0gMHgzNDU2NzgxMik7CisKKwl1MzIgbDMyID0gcm9sMzIoMHgxMjM0NTY3OCwg MjQpOworCisJQlVJTERfQlVHX09OKCFfX2J1aWx0aW5fY29uc3RhbnRfcChsMzIpKTsKKwlCVUlM RF9CVUdfT04obDMyICE9IDB4NzgxMjM0NTYpOworCisJdTE2IHIxNiA9IHJvcjE2KDB4MTIzNCwg MTIpOworCisJQlVJTERfQlVHX09OKCFfX2J1aWx0aW5fY29uc3RhbnRfcChyMTYpKTsKKwlCVUlM RF9CVUdfT04ocjE2ICE9IDB4MjM0MSk7CisKKwl1MTYgbDE2ID0gcm9sMTYoMHgxMjM0LCAxMik7 CisKKwlCVUlMRF9CVUdfT04oIV9fYnVpbHRpbl9jb25zdGFudF9wKGwxNikpOworCUJVSUxEX0JV R19PTihsMTYgIT0gMHg0MTIzKTsKKworCXU4IHI4ID0gcm9yOCgweDEyLCA2KTsKKworCUJVSUxE X0JVR19PTighX19idWlsdGluX2NvbnN0YW50X3AocjE2KSk7CisJQlVJTERfQlVHX09OKHI4ICE9 IDB4NDgpOworCisJdTggbDggPSByb2w4KDB4MTIsIDYpOworCisJQlVJTERfQlVHX09OKCFfX2J1 aWx0aW5fY29uc3RhbnRfcChsMTYpKTsKKwlCVUlMRF9CVUdfT04obDggIT0gMHg4NCk7Cit9CisK IHN0YXRpYyBpbnQgX19pbml0IHRlc3RfYml0b3BzX3N0YXJ0dXAodm9pZCkKIHsKIAlpbnQgaSwg Yml0X3NldDsKQEAgLTEyMSw2ICsxNzEsNyBAQCBzdGF0aWMgaW50IF9faW5pdCB0ZXN0X2JpdG9w c19zdGFydHVwKHZvaWQpCiAJCXByX2VycigiRVJST1I6IEZPVU5EIFNFVCBCSVQgJWRcbiIsIGJp dF9zZXQpOwogCiAJdGVzdF9mbnMoKTsKKwl0ZXN0X2JpdG9wc19jb25zdF9ldmFsKCk7CiAKIAlw cl9pbmZvKCJDb21wbGV0ZWQgYml0b3BzIHRlc3RcbiIpOwogCi0tIAoyLjQzLjAKCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWls aW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5m cmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==