{"id":2219730,"url":"http://patchwork.ozlabs.org/api/1.1/patches/2219730/?format=json","web_url":"http://patchwork.ozlabs.org/project/gcc/patch/20260404022637.3094-1-gerris.rs@gmail.com/","project":{"id":17,"url":"http://patchwork.ozlabs.org/api/1.1/projects/17/?format=json","name":"GNU Compiler Collection","link_name":"gcc","list_id":"gcc-patches.gcc.gnu.org","list_email":"gcc-patches@gcc.gnu.org","web_url":null,"scm_url":null,"webscm_url":null},"msgid":"<20260404022637.3094-1-gerris.rs@gmail.com>","date":"2026-04-04T02:26:36","name":"[gccrs,COMMIT,1/2] intrinsic: Add cttz and cttz_nonzero intrinsics","commit_ref":null,"pull_url":null,"state":"new","archived":false,"hash":"34ffba5da9228511ac652af49e27ea558d908344","submitter":{"id":92092,"url":"http://patchwork.ozlabs.org/api/1.1/people/92092/?format=json","name":null,"email":"gerris.rs@gmail.com"},"delegate":null,"mbox":"http://patchwork.ozlabs.org/project/gcc/patch/20260404022637.3094-1-gerris.rs@gmail.com/mbox/","series":[{"id":498695,"url":"http://patchwork.ozlabs.org/api/1.1/series/498695/?format=json","web_url":"http://patchwork.ozlabs.org/project/gcc/list/?series=498695","date":"2026-04-04T02:26:36","name":"[gccrs,COMMIT,1/2] intrinsic: Add cttz and cttz_nonzero intrinsics","version":1,"mbox":"http://patchwork.ozlabs.org/series/498695/mbox/"}],"comments":"http://patchwork.ozlabs.org/api/patches/2219730/comments/","check":"pending","checks":"http://patchwork.ozlabs.org/api/patches/2219730/checks/","tags":{},"headers":{"Return-Path":"","X-Original-To":["incoming@patchwork.ozlabs.org","gcc-patches@gcc.gnu.org"],"Delivered-To":["patchwork-incoming@legolas.ozlabs.org","gcc-patches@gcc.gnu.org"],"Authentication-Results":["legolas.ozlabs.org;\n\tdkim=pass (2048-bit key;\n unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256\n header.s=20251104 header.b=qS5pkUAa;\n\tdkim-atps=neutral","legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=2620:52:6:3111::32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)","sourceware.org;\n\tdkim=pass (2048-bit key,\n unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256\n header.s=20251104 header.b=qS5pkUAa","sourceware.org;\n dmarc=pass (p=none dis=none) header.from=gmail.com","sourceware.org; spf=pass smtp.mailfrom=gmail.com","server2.sourceware.org;\n arc=none smtp.remote-ip=209.85.222.178"],"Received":["from vm01.sourceware.org (vm01.sourceware.org\n [IPv6:2620:52:6:3111::32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4fnfcj3fQfz1xtJ\n\tfor ; Sat, 04 Apr 2026 13:27:16 +1100 (AEDT)","from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 2CF544BA23FF\n\tfor ; Sat, 4 Apr 2026 02:27:14 +0000 (GMT)","from mail-qk1-f178.google.com (mail-qk1-f178.google.com\n [209.85.222.178])\n by sourceware.org (Postfix) with ESMTPS id 9F1144BA2E09\n for ; Sat, 4 Apr 2026 02:26:41 +0000 (GMT)","by mail-qk1-f178.google.com with SMTP id\n af79cd13be357-8cfc497a604so276976785a.3\n for ; Fri, 03 Apr 2026 19:26:41 -0700 (PDT)","from\n runnervm727z3.oyxxliiq5pgedpchvcbsaosj3d.bx.internal.cloudapp.net\n ([20.119.41.197]) by smtp.gmail.com with ESMTPSA id\n af79cd13be357-8d2a8647b4esm581945585a.32.2026.04.03.19.26.38\n (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);\n Fri, 03 Apr 2026 19:26:39 -0700 (PDT)"],"DKIM-Filter":["OpenDKIM Filter v2.11.0 sourceware.org 2CF544BA23FF","OpenDKIM Filter v2.11.0 sourceware.org 9F1144BA2E09"],"DMARC-Filter":"OpenDMARC Filter v1.4.2 sourceware.org 9F1144BA2E09","ARC-Filter":"OpenARC Filter v1.0.0 sourceware.org 9F1144BA2E09","ARC-Seal":"i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1775269601; cv=none;\n b=NC1Ii2vVAY9jSdw+QEb3QWaUV5FiYo0paPAthpJBxmfl+P4lYHQB202HmI25W82GDBzDg4Pl/YhU+etjcEYeAPuAIEpyWvuHKo+QOjGA5jt5DhJv4td3iRsZ2ER4BVLAT4E/4Vq9KuuOwHlPHiWotedKWJL74pcx2sQhKXA5/60=","ARC-Message-Signature":"i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1775269601; c=relaxed/simple;\n bh=zaLIuWUId/qlj/Pfw8ItNaRPB7OEMKIV7m0b5U+kVeM=;\n h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version;\n b=XOtv0xw9w3GTsOZlNTEUeRDKwxCEA6Dj/sRo9DQNon6smDnDaieB8pAtKggKlbPpbqhWux3Y27f2xVHzwkaab6480d2D9/Jkfql0wmSw0Nu382WFT4+Eqvgk87+Gz/tRquPVmf+3hsg1bFZEJF0DtXm8B7Vy7QQNCBw5CbgLIY8=","ARC-Authentication-Results":"i=1; server2.sourceware.org","DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=gmail.com; s=20251104; t=1775269601; x=1775874401; darn=gcc.gnu.org;\n h=content-transfer-encoding:mime-version:message-id:date:subject:cc\n :to:from:from:to:cc:subject:date:message-id:reply-to;\n bh=QG6NQ0DW4gYX4jyZkp882u+2iyRm7P3QnWDZZO4NoLg=;\n b=qS5pkUAaoZtXmvXXNU6F4z6OAtbo1Hbh6+ignrs8DMFchgifv1QgNe61d1HNGRYgwo\n GiIWEJp23kf65HTAHCs2YdMoYr4v0fuiarioF8uQSyyZSDVLXThcbd3DqIYGA9j5Gj8e\n O3RLm6eQ1UmOwMUNDhCXyXoKFBeIapp8RRF1L1dBSG7J8QECyVzF8+itjHlUMTv69l0Z\n l7405wQnH9db4lyzH3fYbiqhSeBYraODL5GHMXaLckjwyQfIFYzYsjxP92MACnfYT/iF\n suH25C083OHiPBgYNRDwZK/CvjGkzhzccOErQigmqVRQBxU0G3HrGE3mFha2yitPDZKt\n bv4w==","X-Google-DKIM-Signature":"v=1; a=rsa-sha256; c=relaxed/relaxed;\n d=1e100.net; s=20251104; t=1775269601; x=1775874401;\n h=content-transfer-encoding:mime-version:message-id:date:subject:cc\n :to:from:x-gm-gg:x-gm-message-state:from:to:cc:subject:date\n :message-id:reply-to;\n bh=QG6NQ0DW4gYX4jyZkp882u+2iyRm7P3QnWDZZO4NoLg=;\n b=nXVAbpQHfpu+0/iWLulF0fo1nSC7okNlZMERVJS8e1lE303pqr/Fj5auEyL5UyA4bH\n glIqKXwVHskCEuNcExQLUiCOcbysvMEPwwyplqhJA2Vl7+HXIgvCuU43f/i5GGvrViuz\n AtOyz9CF2u0te3DlNArFwrH8Xa7s5jEJ+auswGmjYZ38XPc3P8VUgxZc/8GwJ087a34D\n Fcz/J5nkp3XuKuYV3/Un72BXqRlMTLZJY99Uv4c1Y/baMzjCLHTL+Wdv4lHJHUoIm6qs\n SP8unIl8Mi1cAKQZYF2CV3qF6OqG4pbfX2WoRM95B6BF1xtpKNxDlzBJfInDTXW1+jYT\n +gYQ==","X-Gm-Message-State":"AOJu0Yyoxc6n3g6h+RU3ZVKCcXwLug4JZpMUrHn22Tyr/UA72ORKgQbH\n uUWsIB73Cj/bcoOEd54Ww4jNwqmyjUSlDaE7MzN/Y5/CalZz/FX/+OwpNYGYsnYX","X-Gm-Gg":"AeBDietLHKAt8MHyXTUfkOoDJhx90gbJpFbbtI1EZVZZFNprl5+anOXPa9akSH4/zy8\n j7aiHLc5/uIyUBiH4/I1iH1VSYpO3k6iCyXAeHlCI/mmZqXP10ds8oFKkr96ercYuP9Y8yU7be3\n TDoKT8DpCgGYqjNGorNLvCrlRybTPihGr1RtyUskZdbwwLYK1BEjR4tXSWZ2pGNb0pomwW2Z5Wz\n 2sIdaKL5oRBfI+1++7lvgPyVwmLU+RQNa25c1PrtJEJ3SHJPtxGX3qtNIE2DwCd+fU08YyJRMJg\n vyLk2ugTIv/6B/LFGRUtvKIU7MTb5Ig03T7Lk+7+BC6kktcTESzCRx9vCjXE0qhjenzqsr0BXqS\n w6EeUq8/WW0a9LS7HU653cAFB4EU0v5+Iim78E5KKR/9wutHOyDBTQDBykPUedKOQXw0Obth+K1\n x9KEDjLw+9HKgt3YFUgBMMW70VMRIA/+lgNpearBZmwKDFP0YvtQXwbi3G4ulT9YuQfAZUPC8/U\n rj2gGM+VHGYwApGFcypMw==","X-Received":"by 2002:a05:620a:40d5:b0:8ca:2e36:18b0 with SMTP id\n af79cd13be357-8d41da56befmr851572385a.39.1775269600918;\n Fri, 03 Apr 2026 19:26:40 -0700 (PDT)","From":"gerris.rs@gmail.com","To":"gcc-patches@gcc.gnu.org,\n\tgcc-rust@gcc.gnu.org","Cc":"pierre-emmanuel.patry@embecosm.com, arthur.cohen@embecosm.com,\n dkm+gccrs@kataplop.net, Mohamed Ali ","Subject":"[gccrs COMMIT 1/2] intrinsic: Add cttz and cttz_nonzero intrinsics","Date":"Sat, 4 Apr 2026 02:26:36 +0000","Message-ID":"<20260404022637.3094-1-gerris.rs@gmail.com>","X-Mailer":"git-send-email 2.43.0","MIME-Version":"1.0","Content-Type":"text/plain; charset=UTF-8","Content-Transfer-Encoding":"8bit","X-BeenThere":"gcc-patches@gcc.gnu.org","X-Mailman-Version":"2.1.30","Precedence":"list","List-Id":"Gcc-patches mailing list ","List-Unsubscribe":",\n ","List-Archive":"","List-Post":"","List-Help":"","List-Subscribe":",\n ","Errors-To":"gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org"},"content":"From: Mohamed Ali \n\nThis commit introduces the cttz and cttz_nonzero intrinsics for counting leading zeros\nin integer types.\n\nThe implementation includes handlers for both intrinsics, which validate input types and utilize\n\nAddresses: Rust-GCC#658\n\ngcc/rust/ChangeLog:\n\n\t* backend/rust-compile-intrinsic.cc: Register cttz and cttz_nonzero intrinsics.\n\t* backend/rust-intrinsic-handlers.cc (cttz_handler): Implemnt cttz_handler.\n\t(cttz_nonzero_handler): Implemnt cttz_nonzero_handler.\n\t* backend/rust-intrinsic-handlers.h (cttz_handler): Add decl for cttz_handler.\n\t(cttz_nonzero_handler): Add decl for cttz_handler.\n\t* util/rust-intrinsic-values.h: map cttz_nonzero to its name.\n\nSigned-off-by: Mohamed Ali \n---\nThis change was merged into the gccrs repository and is posted here for\nupstream visibility and potential drive-by review, as requested by GCC\nrelease managers.\nEach commit email contains a link to its details on github from where you can\nfind the Pull-Request and associated discussions.\n\n\nCommit on github: https://github.com/Rust-GCC/gccrs/commit/2e6205babb0fcd025490cbb94b022f33f5a3035e\n\nThe commit has been mentioned in the following pull-request(s):\n - https://github.com/Rust-GCC/gccrs/pull/4511\n\n gcc/rust/backend/rust-compile-intrinsic.cc | 4 +-\n gcc/rust/backend/rust-intrinsic-handlers.cc | 142 ++++++++++++++++++++\n gcc/rust/backend/rust-intrinsic-handlers.h | 2 +\n gcc/rust/util/rust-intrinsic-values.h | 1 +\n 4 files changed, 148 insertions(+), 1 deletion(-)\n\n\nbase-commit: 6211b044aa5192c737ced7e2aa1fad2ff1423293","diff":"diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc\nindex 9263883e9..1456f88df 100644\n--- a/gcc/rust/backend/rust-compile-intrinsic.cc\n+++ b/gcc/rust/backend/rust-compile-intrinsic.cc\n@@ -70,7 +70,9 @@ static const std::map generic_intrinsics\n {IValue::VARIANT_COUNT, handlers::variant_count},\n {IValue::BSWAP, handlers::bswap_handler},\n {IValue::CTLZ, handlers::ctlz_handler},\n- {IValue::CTLZ_NONZERO, handlers::ctlz_nonzero_handler}};\n+ {IValue::CTLZ_NONZERO, handlers::ctlz_nonzero_handler},\n+ {IValue::CTTZ, handlers::cttz_handler},\n+ {IValue::CTTZ_NONZERO, handlers::cttz_nonzero_handler}};\n \n Intrinsics::Intrinsics (Context *ctx) : ctx (ctx) {}\n \ndiff --git a/gcc/rust/backend/rust-intrinsic-handlers.cc b/gcc/rust/backend/rust-intrinsic-handlers.cc\nindex eb86c8ad9..8cbcb9ca4 100644\n--- a/gcc/rust/backend/rust-intrinsic-handlers.cc\n+++ b/gcc/rust/backend/rust-intrinsic-handlers.cc\n@@ -893,6 +893,136 @@ ctlz_handler (Context *ctx, TyTy::FnType *fntype, bool nonzero)\n return fndecl;\n }\n \n+// Shared inner implementation for cttz and cttz_nonzero.\n+//\n+// nonzero=false → cttz: cttz(0) is well-defined in Rust and must return\n+// bit_size, but __builtin_ctz*(0) is undefined behaviour in C, so an\n+// explicit arg==0 guard is emitted.\n+//\n+// nonzero=true → cttz_nonzero: the caller guarantees arg != 0 (passing 0\n+// is immediate UB in Rust), so the zero guard is omitted entirely.\n+static tree\n+cttz_handler (Context *ctx, TyTy::FnType *fntype, bool nonzero)\n+{\n+ rust_assert (fntype->get_params ().size () == 1);\n+\n+ tree lookup = NULL_TREE;\n+ if (check_for_cached_intrinsic (ctx, fntype, &lookup))\n+ return lookup;\n+\n+ auto fndecl = compile_intrinsic_function (ctx, fntype);\n+\n+ std::vector param_vars;\n+ compile_fn_params (ctx, fntype, fndecl, ¶m_vars);\n+\n+ auto arg_param = param_vars.at (0);\n+ if (!Backend::function_set_parameters (fndecl, param_vars))\n+ return error_mark_node;\n+\n+ rust_assert (fntype->get_num_substitutions () == 1);\n+ auto *monomorphized_type\n+ = fntype->get_substs ().at (0).get_param_ty ()->resolve ();\n+ if (!check_for_basic_integer_type (\"cttz\", fntype->get_locus (),\n+\t\t\t\t monomorphized_type))\n+ return error_mark_node;\n+\n+ enter_intrinsic_block (ctx, fndecl);\n+\n+ // BUILTIN cttz FN BODY BEGIN\n+ auto locus = fntype->get_locus ();\n+ auto arg_expr = Backend::var_expression (arg_param, locus);\n+ tree arg_type = TREE_TYPE (arg_expr);\n+ unsigned bit_size = TYPE_PRECISION (arg_type);\n+\n+ // Convert signed types to their same-width unsigned equivalent before\n+ // widening. For cttz this is not strictly required for correctness (sign\n+ // extension fills high bits with 1s, which does not alter the trailing-zero\n+ // count at the low end), but it avoids relying on signed-integer\n+ // representations and keeps the approach consistent with ctlz.\n+ tree unsigned_type\n+ = !TYPE_UNSIGNED (arg_type) ? unsigned_type_for (arg_type) : arg_type;\n+ tree unsigned_arg = fold_convert (unsigned_type, arg_expr);\n+\n+ // Pick the narrowest GCC ctz builtin whose operand type is wide enough to\n+ // hold bit_size bits. Unlike ctlz, no diff adjustment is needed: widening\n+ // a value zero-extends it (fills the added high bits with 0s), which does\n+ // not introduce new trailing zeros at the low end.\n+ //\n+ // Example: cttz(0b00001000_u8) = 3\n+ // Widened to u32: 0x00000008. __builtin_ctz(0x00000008) = 3.\n+ //\n+ // TODO: 128-bit integers are not yet handled.\n+ unsigned int_prec = TYPE_PRECISION (unsigned_type_node);\n+ unsigned long_prec = TYPE_PRECISION (long_unsigned_type_node);\n+ unsigned longlong_prec = TYPE_PRECISION (long_long_unsigned_type_node);\n+\n+ const char *builtin_name = nullptr;\n+ tree cast_type = NULL_TREE;\n+\n+ if (bit_size <= int_prec)\n+ {\n+ // Fits in unsigned int: covers 8/16/32-bit integers on most targets.\n+ builtin_name = \"__builtin_ctz\";\n+ cast_type = unsigned_type_node;\n+ }\n+ else if (bit_size <= long_prec)\n+ {\n+ // Fits in unsigned long but not unsigned int.\n+ builtin_name = \"__builtin_ctzl\";\n+ cast_type = long_unsigned_type_node;\n+ }\n+ else if (bit_size <= longlong_prec)\n+ {\n+ // Fits in unsigned long long but not unsigned long.\n+ builtin_name = \"__builtin_ctzll\";\n+ cast_type = long_long_unsigned_type_node;\n+ }\n+ else\n+ {\n+ rust_sorry_at (locus, \"cttz for %u-bit integers is not yet implemented\",\n+\t\t bit_size);\n+ return error_mark_node;\n+ }\n+\n+ tree call_arg = fold_convert (cast_type, unsigned_arg);\n+\n+ tree builtin_decl = error_mark_node;\n+ BuiltinsContext::get ().lookup_simple_builtin (builtin_name, &builtin_decl);\n+ rust_assert (builtin_decl != error_mark_node);\n+\n+ tree builtin_fn = build_fold_addr_expr_loc (locus, builtin_decl);\n+ tree ctz_expr\n+ = Backend::call_expression (builtin_fn, {call_arg}, nullptr, locus);\n+\n+ ctz_expr = fold_convert (uint32_type_node, ctz_expr);\n+\n+ tree final_expr;\n+ if (!nonzero)\n+ {\n+ // cttz(0) must return bit_size per the Rust reference.\n+ // We cannot pass 0 to __builtin_ctz* (UB), so emit:\n+ // arg == 0 ? bit_size : ctz_expr\n+ tree zero = build_int_cst (arg_type, 0);\n+ tree cmp = fold_build2 (EQ_EXPR, boolean_type_node, arg_expr, zero);\n+ tree width_cst = build_int_cst (uint32_type_node, bit_size);\n+ final_expr\n+\t= fold_build3 (COND_EXPR, uint32_type_node, cmp, width_cst, ctz_expr);\n+ }\n+ else\n+ {\n+ // cttz_nonzero: arg != 0 is guaranteed by the caller, no guard needed.\n+ final_expr = ctz_expr;\n+ }\n+\n+ tree result = fold_convert (TREE_TYPE (DECL_RESULT (fndecl)), final_expr);\n+ auto return_stmt = Backend::return_statement (fndecl, result, locus);\n+ ctx->add_statement (return_stmt);\n+ // BUILTIN cttz FN BODY END\n+\n+ finalize_intrinsic_block (ctx, fndecl);\n+ return fndecl;\n+}\n+\n } // namespace inner\n \n const HandlerBuilder\n@@ -1687,6 +1817,18 @@ ctlz_nonzero_handler (Context *ctx, TyTy::FnType *fntype)\n return inner::ctlz_handler (ctx, fntype, true);\n }\n \n+tree\n+cttz_handler (Context *ctx, TyTy::FnType *fntype)\n+{\n+ return inner::cttz_handler (ctx, fntype, false);\n+}\n+\n+tree\n+cttz_nonzero_handler (Context *ctx, TyTy::FnType *fntype)\n+{\n+ return inner::cttz_handler (ctx, fntype, true);\n+}\n+\n } // namespace handlers\n } // namespace Compile\n } // namespace Rust\ndiff --git a/gcc/rust/backend/rust-intrinsic-handlers.h b/gcc/rust/backend/rust-intrinsic-handlers.h\nindex 52462407f..f4c36b3fe 100644\n--- a/gcc/rust/backend/rust-intrinsic-handlers.h\n+++ b/gcc/rust/backend/rust-intrinsic-handlers.h\n@@ -67,6 +67,8 @@ tree variant_count (Context *ctx, TyTy::FnType *fntype);\n tree bswap_handler (Context *ctx, TyTy::FnType *fntype);\n tree ctlz_handler (Context *ctx, TyTy::FnType *fntype);\n tree ctlz_nonzero_handler (Context *ctx, TyTy::FnType *fntype);\n+tree cttz_handler (Context *ctx, TyTy::FnType *fntype);\n+tree cttz_nonzero_handler (Context *ctx, TyTy::FnType *fntype);\n \n tree prefetch_data (Context *ctx, TyTy::FnType *fntype, Prefetch kind);\n \ndiff --git a/gcc/rust/util/rust-intrinsic-values.h b/gcc/rust/util/rust-intrinsic-values.h\nindex 1b2d968b9..c868c851d 100644\n--- a/gcc/rust/util/rust-intrinsic-values.h\n+++ b/gcc/rust/util/rust-intrinsic-values.h\n@@ -83,6 +83,7 @@ public:\n static constexpr auto &CTLZ = \"ctlz\";\n static constexpr auto &CTLZ_NONZERO = \"ctlz_nonzero\";\n static constexpr auto &CTTZ = \"cttz\";\n+ static constexpr auto &CTTZ_NONZERO = \"cttz_nonzero\";\n static constexpr auto &BSWAP = \"bswap\";\n static constexpr auto &BITREVERSE = \"bitreverse\";\n static constexpr auto &TYPE_ID = \"type_id\";\n","prefixes":["gccrs","COMMIT","1/2"]}