From patchwork Sun Nov 8 01:19:31 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889369 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 43AC7697 for ; Sun, 8 Nov 2020 01:19:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 23A22208FE for ; Sun, 8 Nov 2020 01:19:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="ZEpdwkKf" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726132AbgKHBTp (ORCPT ); Sat, 7 Nov 2020 20:19:45 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57570 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725838AbgKHBTp (ORCPT ); Sat, 7 Nov 2020 20:19:45 -0500 Received: from mail-ej1-x641.google.com (mail-ej1-x641.google.com [IPv6:2a00:1450:4864:20::641]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 67E7AC0613CF for ; Sat, 7 Nov 2020 17:19:45 -0800 (PST) Received: by mail-ej1-x641.google.com with SMTP id s25so7254216ejy.6 for ; Sat, 07 Nov 2020 17:19:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=5EEkqOZFf7NeoiiPS3rHxKAiCD0FxssLtu57iKfw4uY=; b=ZEpdwkKf/xYZiQ/9l1dQfnsKiCFlDzuDP+GKbdDCsFx1WgiUEj5SYa3uCji2sIjjjn VS76PLKGEGVrqMo/crEvk5Z9C/A161ttCl5am0tUKDxoHICodtjms5NjPvjw7hCKKMKu 7ABAkKIH99ZOi5Iauna+7YxFRSEGD6A4DQRGXZfyIj6M8B7uQgruRe0vGxLE1jQCyCyr +fWTYgBSOtG4C1DtnfglF8he5JUjXkMygZhnuaqsz0JG4hxQF81VQosgjd3L8Fs/aC2T /e2m/iHWYtMi1wWOhli/ydOcx6yoYAgjbO2y0YvbQAYE/aLA1b92T1nZ6Io3YR4u6Hlw 4fWw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=5EEkqOZFf7NeoiiPS3rHxKAiCD0FxssLtu57iKfw4uY=; b=sKuo4IbSyxMRQzf4K2KKXbVln91GXfVtFbKX14hqIFYfoNem2jWi7pn3QIaTIUiBRO Vlx0Z89UFd1qZLZdd5dpJ4GWH61CBazUfJGOEVXxtVUANSI3V8Nmbuj2CMQMKYDCJezd iA3GScvRn9Sj/IemiMj/2Y/LwvxHYgXgLQEpbopaNGkzzP9ZWwkXqsox89QBu7OwTv9k n3YSe3EER4F0tEzGr/Cs7fsQehqW/638bQdZqFklzrj1hkf2yANRR0m+gq2q/lKvlPHx tcN9dWxL+nE/65L9+jrsmJ8A8TPb2Bq1kVVlJFwpNFaHXfsr++oi1wciZIJWULHIf/lU TVQg== X-Gm-Message-State: AOAM530EXjK6y9U9tU/JzEZo5pB4xs/WEFkNW/328avjFMFnYTNuHXhl Ni4L/EWQcopWS/iE0MeOPVsQOxnnG5I= X-Google-Smtp-Source: ABdhPJz5NhuioIPGOTDrh/EF5nBndg+7UH6PkXAs2VfiFX0Ge4B9UGI8/CXNsaB8+Kfgt/kwOvTpXQ== X-Received: by 2002:a17:906:5589:: with SMTP id y9mr773355ejp.412.1604798383799; Sat, 07 Nov 2020 17:19:43 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:43 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 01/16] cmp: adapt testcase for compares' canonicalization Date: Sun, 8 Nov 2020 02:19:31 +0100 Message-Id: <20201108011939.94252-2-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org The current testcase, because it's just checking test-linearize's output as-is, is very sensitive to small simplification changes. Fix this by changing the tests into equivalent tests and then just checking that these tests return '1'. This allows to test only what really matters for canonicalization and make these tests very robust. Signed-off-by: Luc Van Oostenryck --- validation/optim/canonical-cmp.c | 125 ++++--------------------------- 1 file changed, 14 insertions(+), 111 deletions(-) diff --git a/validation/optim/canonical-cmp.c b/validation/optim/canonical-cmp.c index e0ca7db36368..9b930b1cbeaa 100644 --- a/validation/optim/canonical-cmp.c +++ b/validation/optim/canonical-cmp.c @@ -1,124 +1,27 @@ typedef signed int sint; typedef unsigned int uint; -sint seq(sint p, sint a) { return (123 == p) ? a : 0; } -sint sne(sint p, sint a) { return (123 != p) ? a : 0; } +sint seq(sint p, sint a) { return (123 == p) == (p == 123); } +sint sne(sint p, sint a) { return (123 != p) == (p != 123); } -sint slt(sint p, sint a) { return (123 > p) ? a : 0; } -sint sle(sint p, sint a) { return (123 >= p) ? a : 0; } -sint sge(sint p, sint a) { return (123 <= p) ? a : 0; } -sint sgt(sint p, sint a) { return (123 < p) ? a : 0; } +sint slt(sint p, sint a) { return (123 > p) == (p < 123); } +sint sle(sint p, sint a) { return (123 >= p) == (p <= 123); } +sint sge(sint p, sint a) { return (123 <= p) == (p >= 123); } +sint sgt(sint p, sint a) { return (123 < p) == (p > 123); } -uint ueq(uint p, uint a) { return (123 == p) ? a : 0; } -uint une(uint p, uint a) { return (123 != p) ? a : 0; } +uint ueq(uint p, uint a) { return (123 == p) == (p == 123); } +uint une(uint p, uint a) { return (123 != p) == (p != 123); } -uint ubt(uint p, uint a) { return (123 > p) ? a : 0; } -uint ube(uint p, uint a) { return (123 >= p) ? a : 0; } -uint uae(uint p, uint a) { return (123 <= p) ? a : 0; } -uint uat(uint p, uint a) { return (123 < p) ? a : 0; } +uint ubt(uint p, uint a) { return (123 > p) == (p < 123); } +uint ube(uint p, uint a) { return (123 >= p) == (p <= 123); } +uint uae(uint p, uint a) { return (123 <= p) == (p >= 123); } +uint uat(uint p, uint a) { return (123 < p) == (p > 123); } /* * check-name: canonical-cmp + * check-description: check that constants move rightside * check-command: test-linearize -Wno-decl $file * + * check-output-ignore * check-output-excludes: \\$123, - * - * check-output-start -seq: -.L0: - - seteq.32 %r3 <- %arg1, $123 - select.32 %r4 <- %r3, %arg2, $0 - ret.32 %r4 - - -sne: -.L2: - - setne.32 %r8 <- %arg1, $123 - select.32 %r9 <- %r8, %arg2, $0 - ret.32 %r9 - - -slt: -.L4: - - setlt.32 %r13 <- %arg1, $123 - select.32 %r14 <- %r13, %arg2, $0 - ret.32 %r14 - - -sle: -.L6: - - setle.32 %r18 <- %arg1, $123 - select.32 %r19 <- %r18, %arg2, $0 - ret.32 %r19 - - -sge: -.L8: - - setge.32 %r23 <- %arg1, $123 - select.32 %r24 <- %r23, %arg2, $0 - ret.32 %r24 - - -sgt: -.L10: - - setgt.32 %r28 <- %arg1, $123 - select.32 %r29 <- %r28, %arg2, $0 - ret.32 %r29 - - -ueq: -.L12: - - seteq.32 %r33 <- %arg1, $123 - select.32 %r34 <- %r33, %arg2, $0 - ret.32 %r34 - - -une: -.L14: - - setne.32 %r38 <- %arg1, $123 - select.32 %r39 <- %r38, %arg2, $0 - ret.32 %r39 - - -ubt: -.L16: - - setb.32 %r43 <- %arg1, $123 - select.32 %r44 <- %r43, %arg2, $0 - ret.32 %r44 - - -ube: -.L18: - - setbe.32 %r48 <- %arg1, $123 - select.32 %r49 <- %r48, %arg2, $0 - ret.32 %r49 - - -uae: -.L20: - - setae.32 %r53 <- %arg1, $123 - select.32 %r54 <- %r53, %arg2, $0 - ret.32 %r54 - - -uat: -.L22: - - seta.32 %r58 <- %arg1, $123 - select.32 %r59 <- %r58, %arg2, $0 - ret.32 %r59 - - - * check-output-end */ From patchwork Sun Nov 8 01:19:32 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889371 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 97392697 for ; Sun, 8 Nov 2020 01:19:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7110620885 for ; Sun, 8 Nov 2020 01:19:47 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="XWxFmdE8" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725838AbgKHBTr (ORCPT ); Sat, 7 Nov 2020 20:19:47 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57574 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726060AbgKHBTr (ORCPT ); Sat, 7 Nov 2020 20:19:47 -0500 Received: from mail-ed1-x541.google.com (mail-ed1-x541.google.com [IPv6:2a00:1450:4864:20::541]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A6541C0613CF for ; Sat, 7 Nov 2020 17:19:46 -0800 (PST) Received: by mail-ed1-x541.google.com with SMTP id p93so5052467edd.7 for ; Sat, 07 Nov 2020 17:19:46 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=BTe4oqqkhVayZ3QUm41sr/PWpvwMOebFAsXf9ijucz8=; b=XWxFmdE8YPT3TrjJ401Udi0MLvM/GDqx56v2PaqEaBLLkFRTtrYpvUqKdwGGINqzLc mvvdB0CybyWArC2yJLfQQ4q0LEJnkXKWrWWLgOHw4XUivKhyzAMuH/n/biExA97rrPCZ gYDiAHdh131sPrX5w/4XRhBZ6luysyLUF/f0+gB/JZ+axaA/K4pZGeSRAMenM/GOyisG QbmVP+93em6fG1o+Vex/4/XgfCv16QrR+EYqZaHAhH/TwFhyJkMrQWBL/4fyzZWqV+XA X2kMF21ZgAO5dF6+DhHO+kSZ1u3UeoVwZ6LXU6tvO79NkQhF/3B0I+3WL34Yagt3hATE fnag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=BTe4oqqkhVayZ3QUm41sr/PWpvwMOebFAsXf9ijucz8=; b=YdL4KJQVZ+DLl10gwYDwxKC8uNY/3cT7Yp3qFiZK9SZHUsI85sXJQTddh1bI0bUG8X WkpOLBXkmxmflEp8wCeGw+7CYt75XRgW0tAH8lHmfmowSsEcPB6J/lFjfW/CmvV8Wie4 Pn+N/JwFRj+WPR1aH4n9MbFMhMdajMERUQuGcSRz6eKyAAI9iKKNiHBmtw+dKY1QOTfg 13ipaiM8fmwabqmw40fZkVbmSb6LBZHauyi08KLGPsHGtON90FYJIA6Twvry4G1ipfer ZSEAtr7n8b+KeCa/sMAbddGHB0ukMS20TiWopNQilu2j/BVcxySclkOSv7n3yRZJ/KLs 9reA== X-Gm-Message-State: AOAM533pAZ5GBL9t7c3nZ/KHvnKh0qThOK+EEV1MqZerKVh5YK7W6YQV w63ug0wBrqojqJi1/GSgIMs/oYHQZ1I= X-Google-Smtp-Source: ABdhPJxOjhD7N5svqmoV4lh8gN4BLo52jboZMGththjhnv2FJIoQ03DMNOFqtxTHHNEBQW0UH/KeUw== X-Received: by 2002:a50:e61a:: with SMTP id y26mr9128049edm.71.1604798384777; Sat, 07 Nov 2020 17:19:44 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:44 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 02/16] cmp: add testcases for the simplification of compares Date: Sun, 8 Nov 2020 02:19:32 +0100 Message-Id: <20201108011939.94252-3-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org Signed-off-by: Luc Van Oostenryck --- validation/optim/canonical-cmpu.c | 16 ++++++++++++++++ validation/optim/cmp-sext-sext.c | 18 ++++++++++++++++++ validation/optim/cmp-sext-simm.c | 30 ++++++++++++++++++++++++++++++ validation/optim/cmp-sext-uimm.c | 26 ++++++++++++++++++++++++++ validation/optim/cmp-sext.c | 24 ++++++++++++++++++++++++ validation/optim/cmp-zext-simm.c | 24 ++++++++++++++++++++++++ validation/optim/cmp-zext-uimm0.c | 21 +++++++++++++++++++++ validation/optim/cmp-zext-uimm1.c | 16 ++++++++++++++++ validation/optim/cmp-zext-uimm2.c | 30 ++++++++++++++++++++++++++++++ validation/optim/cmp-zext-zext.c | 18 ++++++++++++++++++ validation/optim/cmp-zext.c | 18 ++++++++++++++++++ validation/optim/set-uimm1.c | 11 +++++++++++ validation/optim/set-uimm2.c | 13 +++++++++++++ validation/optim/set-uimm3.c | 11 +++++++++++ validation/optim/zext-cmpu.c | 17 +++++++++++++++++ 15 files changed, 293 insertions(+) create mode 100644 validation/optim/canonical-cmpu.c create mode 100644 validation/optim/cmp-sext-sext.c create mode 100644 validation/optim/cmp-sext-simm.c create mode 100644 validation/optim/cmp-sext-uimm.c create mode 100644 validation/optim/cmp-sext.c create mode 100644 validation/optim/cmp-zext-simm.c create mode 100644 validation/optim/cmp-zext-uimm0.c create mode 100644 validation/optim/cmp-zext-uimm1.c create mode 100644 validation/optim/cmp-zext-uimm2.c create mode 100644 validation/optim/cmp-zext-zext.c create mode 100644 validation/optim/cmp-zext.c create mode 100644 validation/optim/set-uimm1.c create mode 100644 validation/optim/set-uimm2.c create mode 100644 validation/optim/set-uimm3.c create mode 100644 validation/optim/zext-cmpu.c diff --git a/validation/optim/canonical-cmpu.c b/validation/optim/canonical-cmpu.c new file mode 100644 index 000000000000..482408aa90c1 --- /dev/null +++ b/validation/optim/canonical-cmpu.c @@ -0,0 +1,16 @@ +// canonicalize to == or != +int cmp_ltu_eq0(unsigned int x) { return (x < 1) == (x == 0); } +int cmp_geu_ne0(unsigned int x) { return (x >= 1) == (x != 0); } + +// canonicalize to the smaller value +int cmp_ltu(unsigned int x) { return (x < 256) == (x <= 255); } +int cmp_geu(unsigned int x) { return (x >= 256) == (x > 255); } + +/* + * check-name: canonical-cmpu + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-sext-sext.c b/validation/optim/cmp-sext-sext.c new file mode 100644 index 000000000000..ba6ed54e940c --- /dev/null +++ b/validation/optim/cmp-sext-sext.c @@ -0,0 +1,18 @@ +#define T(TYPE) __##TYPE##_TYPE__ +#define cmp(TYPE, X, OP, Y) ((T(TYPE)) X OP (T(TYPE)) Y) +#define TEST(T1, T2, X, OP, Y) cmp(T1, X, OP, Y) == cmp(T2, X, OP, Y) + +#define ARGS(TYPE) T(TYPE) a, T(TYPE)b + +_Bool cmpe_sext_sext(ARGS(INT32)) { return TEST(UINT64, UINT32, a, ==, b); } +_Bool cmps_sext_sext(ARGS(INT32)) { return TEST( INT64, INT32, a, < , b); } +_Bool cmpu_sext_sext(ARGS(INT32)) { return TEST(UINT64, UINT32, a, < , b); } + +/* + * check-name: cmp-sext-sext + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-sext-simm.c b/validation/optim/cmp-sext-simm.c new file mode 100644 index 000000000000..c2099a6b8876 --- /dev/null +++ b/validation/optim/cmp-sext-simm.c @@ -0,0 +1,30 @@ +#define sext(X) ((long long) (X)) +#define POS (1LL << 31) +#define NEG (-POS - 1) + +static int lt_ge0(int x) { return (sext(x) < (POS + 0)) == 1; } +static int lt_ge1(int x) { return (sext(x) < (POS + 1)) == 1; } +static int le_ge0(int x) { return (sext(x) <= (POS + 0)) == 1; } +static int le_ge1(int x) { return (sext(x) <= (POS + 1)) == 1; } +static int lt_lt0(int x) { return (sext(x) < (NEG - 0)) == 1; } +static int lt_lt1(int x) { return (sext(x) < (NEG - 1)) == 1; } +static int le_lt0(int x) { return (sext(x) <= (NEG - 0)) == 1; } +static int le_lt1(int x) { return (sext(x) <= (NEG - 1)) == 1; } + +static int gt_ge0(int x) { return (sext(x) > (POS + 0)) == 0; } +static int gt_ge1(int x) { return (sext(x) > (POS + 1)) == 0; } +static int ge_ge0(int x) { return (sext(x) >= (POS + 0)) == 0; } +static int ge_ge1(int x) { return (sext(x) >= (POS + 1)) == 0; } +static int gt_lt0(int x) { return (sext(x) > (NEG - 0)) == 0; } +static int gt_lt1(int x) { return (sext(x) > (NEG - 1)) == 0; } +static int ge_lt0(int x) { return (sext(x) >= (NEG - 0)) == 0; } +static int ge_lt1(int x) { return (sext(x) >= (NEG - 1)) == 0; } + +/* + * check-name: cmp-sext-simm + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-sext-uimm.c b/validation/optim/cmp-sext-uimm.c new file mode 100644 index 000000000000..cc89a80694a1 --- /dev/null +++ b/validation/optim/cmp-sext-uimm.c @@ -0,0 +1,26 @@ +#define sext(X) ((unsigned long long) (X)) +#define POS (1ULL << 31) +#define NEG ((unsigned long long) -POS) + +int sext_ltu_p2(int x) { return (sext(x) < (POS + 2)) == (x >= 0); } +int sext_ltu_p1(int x) { return (sext(x) < (POS + 1)) == (x >= 0); } +int sext_ltu_p0(int x) { return (sext(x) < (POS + 0)) == (x >= 0); } + +int sext_leu_p1(int x) { return (sext(x) <= (POS + 1)) == (x >= 0); } +int sext_leu_p0(int x) { return (sext(x) <= (POS + 0)) == (x >= 0); } + +int sext_geu_m1(int x) { return (sext(x) >= (NEG - 1)) == (x < 0); } +int sext_geu_m2(int x) { return (sext(x) >= (NEG - 2)) == (x < 0); } + +int sext_gtu_m1(int x) { return (sext(x) > (NEG - 1)) == (x < 0); } +int sext_gtu_m2(int x) { return (sext(x) > (NEG - 2)) == (x < 0); } +int sext_gtu_m3(int x) { return (sext(x) > (NEG - 3)) == (x < 0); } + +/* + * check-name: cmp-sext-uimm + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-sext.c b/validation/optim/cmp-sext.c new file mode 100644 index 000000000000..2dd60fff064c --- /dev/null +++ b/validation/optim/cmp-sext.c @@ -0,0 +1,24 @@ +#define T(TYPE) __##TYPE##_TYPE__ +#define cmp(TYPE, X, OP, Y) ((T(TYPE)) X OP (T(TYPE)) Y) +#define TEST(T1, T2, X, OP, Y) cmp(T1, X, OP, Y) == cmp(T2, X, OP, Y) + +#define ARGS(TYPE) T(TYPE) a, T(TYPE)b + +_Bool cmpe_sextp(ARGS(INT32)) { return TEST(UINT64, UINT32, a, ==, 0x7fffffff); } +_Bool cmps_sextp(ARGS(INT32)) { return TEST( INT64, INT32, a, < , 0x7fffffff); } +_Bool cmpu_sextp(ARGS(INT32)) { return TEST(UINT64, UINT32, a, < , 0x7fffffff); } +_Bool cmpe_sextn(ARGS(INT32)) { return TEST(UINT64, UINT32, a, ==, -1); } +_Bool cmps_sextn(ARGS(INT32)) { return TEST( INT64, INT32, a, < , -1); } +_Bool cmpu_sextn(ARGS(INT32)) { return TEST(UINT64, UINT32, a, < , -1); } + +_Bool cmpltu_sext(int a) { return (a < 0x80000000ULL) == (a >= 0); } +_Bool cmpgtu_sext(int a) { return (a >= 0x80000000ULL) == (a < 0); } + +/* + * check-name: cmp-sext + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-zext-simm.c b/validation/optim/cmp-zext-simm.c new file mode 100644 index 000000000000..f89f8f8baa62 --- /dev/null +++ b/validation/optim/cmp-zext-simm.c @@ -0,0 +1,24 @@ +#define ZEXT(X) ((long long)(X)) +#define BITS ((long long)(~0U)) + +int zext_ult(unsigned int x) { return (ZEXT(x) < (BITS + 1)) == 1; } +int zext_ule(unsigned int x) { return (ZEXT(x) <= (BITS + 0)) == 1; } +int zext_uge(unsigned int x) { return (ZEXT(x) >= (BITS + 1)) == 0; } +int zext_ugt(unsigned int x) { return (ZEXT(x) > (BITS + 0)) == 0; } + +int zext_0le(unsigned int x) { return (ZEXT(x) <= 0) == (x == 0); } +int zext_0ge(unsigned int x) { return (ZEXT(x) > 0) == (x != 0); } + +int zext_llt(unsigned int x) { return (ZEXT(x) < -1) == 0; } +int zext_lle(unsigned int x) { return (ZEXT(x) <= -1) == 0; } +int zext_lge(unsigned int x) { return (ZEXT(x) >= -1) == 1; } +int zext_lgt(unsigned int x) { return (ZEXT(x) > -1) == 1; } + +/* + * check-name: cmp-zext-simm + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-zext-uimm0.c b/validation/optim/cmp-zext-uimm0.c new file mode 100644 index 000000000000..f7bec338ca8f --- /dev/null +++ b/validation/optim/cmp-zext-uimm0.c @@ -0,0 +1,21 @@ +#define zext(X) ((unsigned long long) (X)) +#define MAX (1ULL << 32) + +#define TEST(X,OP,VAL) (zext(X) OP (VAL)) == (X OP (VAL)) + +int zext_ltu_0(unsigned int x) { return TEST(x, < , MAX); } +int zext_ltu_m(unsigned int x) { return TEST(x, < , MAX - 1); } +int zext_lte_0(unsigned int x) { return TEST(x, <=, MAX); } +int zext_lte_m(unsigned int x) { return TEST(x, <=, MAX - 1); } +int zext_gte_0(unsigned int x) { return TEST(x, >=, MAX); } +int zext_gte_m(unsigned int x) { return TEST(x, >=, MAX - 1); } +int zext_gtu_0(unsigned int x) { return TEST(x, > , MAX); } +int zext_gtu_m(unsigned int x) { return TEST(x, > , MAX - 1); } + +/* + * check-name: cmp-zext-uimm0 + * check-command: test-linearize -Wno-decl $file + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-zext-uimm1.c b/validation/optim/cmp-zext-uimm1.c new file mode 100644 index 000000000000..ffcdaad5c1bd --- /dev/null +++ b/validation/optim/cmp-zext-uimm1.c @@ -0,0 +1,16 @@ +#define zext(X) ((unsigned long long) (X)) +#define BITS ((1ULL << 32) - 1) + +int zext_lt_p(unsigned int x) { return (zext(x) < (BITS + 1)) == 1; } +int zext_le_p(unsigned int x) { return (zext(x) <= (BITS )) == 1; } +int zext_ge_p(unsigned int x) { return (zext(x) >= (BITS + 1)) == 0; } +int zext_gt_p(unsigned int x) { return (zext(x) > (BITS )) == 0; } + +/* + * check-name: cmp-zext-uimm1 + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-zext-uimm2.c b/validation/optim/cmp-zext-uimm2.c new file mode 100644 index 000000000000..64f30b9a3df5 --- /dev/null +++ b/validation/optim/cmp-zext-uimm2.c @@ -0,0 +1,30 @@ +#define zext(X) ((unsigned long long) (X)) + +int zext_ltu_q(unsigned x) { return (zext(x) < 0x100000001UL) == 1; } +int zext_ltu_p(unsigned x) { return (zext(x) < 0x100000000UL) == 1; } +int zext_ltu_0(unsigned x) { return (zext(x) < 0x0ffffffffUL) == (x < 0xffffffff); } +int zext_ltu_m(unsigned x) { return (zext(x) < 0x0fffffffeUL) == (x < 0xfffffffe); } + +int zext_leu_q(unsigned x) { return (zext(x) <= 0x100000001UL) == 1; } +int zext_leu_p(unsigned x) { return (zext(x) <= 0x100000000UL) == 1; } +int zext_leu_0(unsigned x) { return (zext(x) <= 0x0ffffffffUL) == 1; } +int zext_leu_m(unsigned x) { return (zext(x) <= 0x0fffffffeUL) == (x <= 0xfffffffe); } + +int zext_geu_q(unsigned x) { return (zext(x) >= 0x100000001UL) == 0; } +int zext_geu_p(unsigned x) { return (zext(x) >= 0x100000000UL) == 0; } +int zext_geu_0(unsigned x) { return (zext(x) >= 0x0ffffffffUL) == (x >= 0xffffffff); } +int zext_geu_m(unsigned x) { return (zext(x) >= 0x0fffffffeUL) == (x >= 0xfffffffe); } + +int zext_gtu_q(unsigned x) { return (zext(x) > 0x100000001UL) == 0; } +int zext_gtu_p(unsigned x) { return (zext(x) > 0x100000000UL) == 0; } +int zext_gtu_0(unsigned x) { return (zext(x) > 0x0ffffffffUL) == 0; } +int zext_gtu_m(unsigned x) { return (zext(x) > 0x0fffffffeUL) == (x > 0xfffffffe); } + +/* + * check-name: cmp-zext-uimm2 + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-zext-zext.c b/validation/optim/cmp-zext-zext.c new file mode 100644 index 000000000000..9f188297e214 --- /dev/null +++ b/validation/optim/cmp-zext-zext.c @@ -0,0 +1,18 @@ +#define T(TYPE) __##TYPE##_TYPE__ +#define cmp(TYPE, X, OP, Y) ((T(TYPE)) X OP (T(TYPE)) Y) +#define TEST(T1, T2, X, OP, Y) cmp(T1, X, OP, Y) == cmp(T2, X, OP, Y) + +#define ARGS(TYPE) T(TYPE) a, T(TYPE)b + +_Bool cmpe_zext_zext(ARGS(UINT32)) { return TEST(UINT64, UINT32, a, ==, b); } +_Bool cmps_zext_zext(ARGS(UINT32)) { return TEST( INT64, UINT32, a, < , b); } +_Bool cmpu_zext_zext(ARGS(UINT32)) { return TEST(UINT64, UINT32, a, < , b); } + +/* + * check-name: cmp-zext-zext + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/cmp-zext.c b/validation/optim/cmp-zext.c new file mode 100644 index 000000000000..ecee6b5e9101 --- /dev/null +++ b/validation/optim/cmp-zext.c @@ -0,0 +1,18 @@ +#define T(TYPE) __##TYPE##_TYPE__ +#define cmp(TYPE, X, OP, Y) ((T(TYPE)) X OP (T(TYPE)) Y) +#define TEST(T1, T2, X, OP, Y) cmp(T1, X, OP, Y) == cmp(T2, X, OP, Y) + +#define ARGS(TYPE) T(TYPE) a, T(TYPE)b + +_Bool cmpe_zext(ARGS(UINT32)) { return TEST(UINT64, UINT32, a, ==, 0xffffffff); } +_Bool cmps_zext(ARGS(UINT32)) { return TEST( INT64, UINT32, a, < , 0xffffffff); } +_Bool cmpu_zext(ARGS(UINT32)) { return TEST(UINT64, UINT32, a, < , 0xffffffff); } + +/* + * check-name: cmp-zext + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/set-uimm1.c b/validation/optim/set-uimm1.c new file mode 100644 index 000000000000..d6928f59d044 --- /dev/null +++ b/validation/optim/set-uimm1.c @@ -0,0 +1,11 @@ +static _Bool setle_umax(unsigned int a) { return (a <= ~0) == 1; } +static _Bool setgt_umax(unsigned int a) { return (a > ~0) == 0; } + +/* + * check-name: set-uimm1 + * check-command: test-linearize $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/set-uimm2.c b/validation/optim/set-uimm2.c new file mode 100644 index 000000000000..efa326f532ce --- /dev/null +++ b/validation/optim/set-uimm2.c @@ -0,0 +1,13 @@ +static _Bool setlt_umax(unsigned int a) { return (a < ~0) == (a != ~0); } +static _Bool setle_umax(unsigned int a) { return (a <= ~1) == (a != ~0); } +static _Bool setge_umax(unsigned int a) { return (a >= ~0) == (a == ~0); } +static _Bool setgt_umax(unsigned int a) { return (a > ~1) == (a == ~0); } + +/* + * check-name: set-uimm2 + * check-command: test-linearize $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/set-uimm3.c b/validation/optim/set-uimm3.c new file mode 100644 index 000000000000..b72ef8d6e819 --- /dev/null +++ b/validation/optim/set-uimm3.c @@ -0,0 +1,11 @@ +int le(int x) { return (x <= 0x7fffffffU) == (x >= 0); } +int gt(int x) { return (x > 0x7fffffffU) == (x < 0); } + +/* + * check-name: set-uimm3 + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ diff --git a/validation/optim/zext-cmpu.c b/validation/optim/zext-cmpu.c new file mode 100644 index 000000000000..279ed70e0fda --- /dev/null +++ b/validation/optim/zext-cmpu.c @@ -0,0 +1,17 @@ +int ltg(unsigned x) { return (((long long)x) < 0x100000000ULL) == 1; } +int ltl(unsigned x) { return (((long long)x) < 0x0ffffffffULL) == (x < 0xffffffffU); } +int leg(unsigned x) { return (((long long)x) <= 0x0ffffffffULL) == 1; } +int lel(unsigned x) { return (((long long)x) <= 0x0fffffffeULL) == (x <= 0xfffffffeU); } +int geg(unsigned x) { return (((long long)x) >= 0x100000000ULL) == 0; } +int gel(unsigned x) { return (((long long)x) >= 0x0ffffffffULL) == (x >= 0xffffffffU); } +int gtg(unsigned x) { return (((long long)x) > 0x0ffffffffULL) == 0; } +int gtl(unsigned x) { return (((long long)x) > 0x0fffffffeULL) == (x > 0xfffffffeU); } + +/* + * check-name: zext-cmpu + * check-command: test-linearize -Wno-decl $file + * check-known-to-fail + * + * check-output-ignore + * check-output-returns: 1 + */ From patchwork Sun Nov 8 01:19:33 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889373 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id B3B66697 for ; Sun, 8 Nov 2020 01:19:48 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8C97C20885 for ; Sun, 8 Nov 2020 01:19:48 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="lTrx6/JU" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726171AbgKHBTs (ORCPT ); Sat, 7 Nov 2020 20:19:48 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57580 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726060AbgKHBTs (ORCPT ); Sat, 7 Nov 2020 20:19:48 -0500 Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com [IPv6:2a00:1450:4864:20::644]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BF434C0613CF for ; Sat, 7 Nov 2020 17:19:47 -0800 (PST) Received: by mail-ej1-x644.google.com with SMTP id o23so7240370ejn.11 for ; Sat, 07 Nov 2020 17:19:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=8gVPXs/rbigDWFwLnam3zKNJjYpp4HrSmOqZCzHuqe0=; b=lTrx6/JUP7RmRngGBDca/k6ZngqPpGUy5ZH78mxJlfcB0F8f7fYwrq+JYFDeEZWKf2 stT6VjQloy4F6s3/s5YDUGEJyVJ/9Cy/SOJJi2OvRN7qIEyM7qYo6obyGjfC0vfYvkKc PbVrSoVD4XgO+J8dRUKzHg/yhdtkWjshTgGTki7gX8L7kvAlYOMGTtFhuXWcLvNGL/Rp W0QwgMBvpqH3yNgWXkhcbZx06BE/66uDyAGBdRvALczZiS52wvrPE34/PaFuMu2vNtUz a6w4L+/EgAwITltforyDEXOe2teqYhZxdBqIYxK5vVBAeMt8zXs4xBUm8TygptII2TvN 7ahQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=8gVPXs/rbigDWFwLnam3zKNJjYpp4HrSmOqZCzHuqe0=; b=CUqGmFiMPJA+iW80YwjzPeTcNLCJvJDfPTjmzNbBswYamDD4gh6uZD2x4EOfMLqUY6 P0AQYc2J88he67EdwjcMDWMSv2BpgSEVRc4OZNai64CNq7LzmUsmfD1SFx0nGqvVnixU 50gSS9UEe08dti8osXqflB77M7iE0l8CO6T7gnydOXYMA5ydw0Jsr/sg4Mpx7ZoBE7hY 8TvBsCGIQGwHw+SOBkL6qC2dpHyyWX0xWsJQajL2QMBHsi5p+AG7cnbXf4yXqf9bZfwU IA9oND3zo75lpDSbSRJMrno9UVEObchTfQuTERKJOU2SqubvPDbhYdZQ6WWUL8OVSnsE oc7A== X-Gm-Message-State: AOAM530TVp7qTR4yzfvG7HlF9tMaOAdy1mlW/RIYwHXA1xrDszjp9AnD RCvXMAzL5fY7dDelwctMeJAJlr9Y1ck= X-Google-Smtp-Source: ABdhPJxeSIbtl9q7jUR34bhGje0USSomRrnpbBnJeD+8AUbU+VXZ4AxlSspCjweFHVFMK0zjWF1kwA== X-Received: by 2002:a17:906:ec9:: with SMTP id u9mr8794959eji.400.1604798386047; Sat, 07 Nov 2020 17:19:46 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:45 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 03/16] cmp: add signed/unsigned to opcode table Date: Sun, 8 Nov 2020 02:19:33 +0100 Message-Id: <20201108011939.94252-4-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org The opcode table allows to efficiently store some properties of the IR instructions and the correspondence between some of them. One of these correspondences the 'signed' / 'unsigned' version of otherwise identical instructions. This is useful for some transformation of compare instructions but is not present yet in the table. So, add this now. Signed-off-by: Luc Van Oostenryck --- opcode.c | 3 +- opcode.def | 164 ++++++++++++++++++++++++++--------------------------- opcode.h | 8 ++- 3 files changed, 90 insertions(+), 85 deletions(-) diff --git a/opcode.c b/opcode.c index 98ad768f8706..0cc7e435ed42 100644 --- a/opcode.c +++ b/opcode.c @@ -23,10 +23,11 @@ #include "opcode.h" const struct opcode_table opcode_table[OP_LAST] = { -#define OPCODE(OP,NG,SW,TF,N,FL) \ +#define OPCODE(OP,NG,SW,SG,TF,N,FL) \ [OP_##OP] = { \ .negate = OP_##NG, \ .swap = OP_##SW, \ + .sign = OP_##SG, \ .to_float = OP_##TF, \ .arity = N, \ .flags = FL, \ diff --git a/opcode.def b/opcode.def index c65722f0b9bb..2627abd4d894 100644 --- a/opcode.def +++ b/opcode.def @@ -1,114 +1,114 @@ -// OPCODE negated swaped float arity, flags +// OPCODE negated swaped sign float arity, flags -OPCODE(BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(BADOP, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) /* Entry */ -OPCODE(ENTRY, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(ENTRY, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) /* Terminator */ -OPCODE(RET, BADOP, BADOP, BADOP, 1, OPF_NONE) -OPCODE(BR, BADOP, BADOP, BADOP, 0, OPF_NONE) -OPCODE(CBR, BADOP, BADOP, BADOP, 1, OPF_NONE) -OPCODE(SWITCH, BADOP, BADOP, BADOP, 1, OPF_NONE) -OPCODE(UNREACH, BADOP, BADOP, BADOP, 0, OPF_NONE) -OPCODE(COMPUTEDGOTO, BADOP, BADOP, BADOP, 1, OPF_NONE) +OPCODE(RET, BADOP, BADOP, BADOP, BADOP, 1, OPF_NONE) +OPCODE(BR, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(CBR, BADOP, BADOP, BADOP, BADOP, 1, OPF_NONE) +OPCODE(SWITCH, BADOP, BADOP, BADOP, BADOP, 1, OPF_NONE) +OPCODE(UNREACH, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(COMPUTEDGOTO, BADOP, BADOP, BADOP, BADOP, 1, OPF_NONE) OPCODE_RANGE(TERMINATOR, RET, COMPUTEDGOTO) /* Binary */ -OPCODE(ADD, BADOP, BADOP, FADD, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) -OPCODE(MUL, BADOP, BADOP, FMUL, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) -OPCODE(SUB, BADOP, BADOP, FSUB, 2, OPF_TARGET|OPF_BINOP) -OPCODE(DIVU, BADOP, BADOP, FDIV, 2, OPF_TARGET|OPF_BINOP) -OPCODE(DIVS, BADOP, BADOP, FDIV, 2, OPF_TARGET|OPF_BINOP) -OPCODE(MODU, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_BINOP) -OPCODE(MODS, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_BINOP) -OPCODE(SHL, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_BINOP) -OPCODE(LSR, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_BINOP) -OPCODE(ASR, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_BINOP) +OPCODE(ADD, BADOP, BADOP, BADOP, FADD, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) +OPCODE(MUL, BADOP, BADOP, BADOP, FMUL, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) +OPCODE(SUB, BADOP, BADOP, BADOP, FSUB, 2, OPF_TARGET|OPF_BINOP) +OPCODE(DIVU, BADOP, BADOP, DIVS, FDIV, 2, OPF_TARGET|OPF_BINOP) +OPCODE(DIVS, BADOP, BADOP, DIVU, FDIV, 2, OPF_TARGET|OPF_BINOP) +OPCODE(MODU, BADOP, BADOP, MODS, BADOP, 2, OPF_TARGET|OPF_BINOP) +OPCODE(MODS, BADOP, BADOP, MODU, BADOP, 2, OPF_TARGET|OPF_BINOP) +OPCODE(LSR, BADOP, BADOP, ASR, BADOP, 2, OPF_TARGET|OPF_BINOP) +OPCODE(ASR, BADOP, BADOP, LSR, BADOP, 2, OPF_TARGET|OPF_BINOP) +OPCODE(SHL, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_BINOP) /* Floating-point binops */ -OPCODE(FADD, BADOP, BADOP, BADOP, 2, OPF_TARGET) -OPCODE(FSUB, BADOP, BADOP, BADOP, 2, OPF_TARGET) -OPCODE(FMUL, BADOP, BADOP, BADOP, 2, OPF_TARGET) -OPCODE(FDIV, BADOP, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FADD, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FSUB, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FMUL, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FDIV, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET) /* Logical */ -OPCODE(AND, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) -OPCODE(OR, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) -OPCODE(XOR, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) +OPCODE(AND, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) +OPCODE(OR, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) +OPCODE(XOR, BADOP, BADOP, BADOP, BADOP, 2, OPF_TARGET|OPF_COMMU|OPF_ASSOC|OPF_BINOP) OPCODE_RANGE(BINARY, ADD, XOR) /* floating-point comparison */ -OPCODE(FCMP_ORD, FCMP_UNO, FCMP_ORD, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_OEQ, FCMP_UNE, FCMP_OEQ, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_ONE, FCMP_UEQ, FCMP_ONE, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_UEQ, FCMP_ONE, FCMP_UEQ, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_UNE, FCMP_OEQ, FCMP_UNE, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_OLT, FCMP_UGE, FCMP_OGT, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_OLE, FCMP_UGT, FCMP_OGE, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_OGE, FCMP_ULT, FCMP_OLE, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_OGT, FCMP_ULE, FCMP_OLT, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_ULT, FCMP_OGE, FCMP_UGT, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_ULE, FCMP_OGT, FCMP_UGE, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_UGE, FCMP_OLT, FCMP_ULE, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_UGT, FCMP_OLE, FCMP_ULT, BADOP, 2, OPF_TARGET) -OPCODE(FCMP_UNO, FCMP_ORD, FCMP_UNO, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_ORD, FCMP_UNO, FCMP_ORD, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_OEQ, FCMP_UNE, FCMP_OEQ, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_ONE, FCMP_UEQ, FCMP_ONE, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_UEQ, FCMP_ONE, FCMP_UEQ, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_UNE, FCMP_OEQ, FCMP_UNE, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_OLT, FCMP_UGE, FCMP_OGT, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_OLE, FCMP_UGT, FCMP_OGE, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_OGE, FCMP_ULT, FCMP_OLE, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_OGT, FCMP_ULE, FCMP_OLT, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_ULT, FCMP_OGE, FCMP_UGT, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_ULE, FCMP_OGT, FCMP_UGE, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_UGE, FCMP_OLT, FCMP_ULE, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_UGT, FCMP_OLE, FCMP_ULT, BADOP, BADOP, 2, OPF_TARGET) +OPCODE(FCMP_UNO, FCMP_ORD, FCMP_UNO, BADOP, BADOP, 2, OPF_TARGET) OPCODE_RANGE(FPCMP, FCMP_ORD, FCMP_UNO) /* Binary comparison */ -OPCODE(SET_EQ, SET_NE, SET_EQ, FCMP_OEQ, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_COMMU) -OPCODE(SET_LT, SET_GE, SET_GT, FCMP_OLT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_LE, SET_GT, SET_GE, FCMP_OLE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_GE, SET_LT, SET_LE, FCMP_OGE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_GT, SET_LE, SET_LT, FCMP_OGT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_B, SET_AE, SET_A, FCMP_OLT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_BE, SET_A, SET_AE, FCMP_OLE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_AE, SET_B, SET_BE, FCMP_OGE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_A, SET_BE, SET_B, FCMP_OGT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE) -OPCODE(SET_NE, SET_EQ, SET_NE, FCMP_UNE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_COMMU) +OPCODE(SET_EQ, SET_NE, SET_EQ, SET_EQ, FCMP_OEQ, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_COMMU) +OPCODE(SET_LT, SET_GE, SET_GT, SET_B, FCMP_OLT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_SIGNED) +OPCODE(SET_LE, SET_GT, SET_GE, SET_BE, FCMP_OLE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_SIGNED) +OPCODE(SET_GE, SET_LT, SET_LE, SET_AE, FCMP_OGE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_SIGNED) +OPCODE(SET_GT, SET_LE, SET_LT, SET_A, FCMP_OGT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_SIGNED) +OPCODE(SET_B, SET_AE, SET_A, SET_LT, FCMP_OLT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_UNSIGNED) +OPCODE(SET_BE, SET_A, SET_AE, SET_LE, FCMP_OLE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_UNSIGNED) +OPCODE(SET_AE, SET_B, SET_BE, SET_GE, FCMP_OGE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_UNSIGNED) +OPCODE(SET_A, SET_BE, SET_B, SET_GT, FCMP_OGT, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_UNSIGNED) +OPCODE(SET_NE, SET_EQ, SET_NE, SET_NE, FCMP_UNE, 2, OPF_TARGET|OPF_BINOP|OPF_COMPARE|OPF_COMMU) OPCODE_RANGE(BINCMP, SET_EQ, SET_NE) /* Uni */ -OPCODE(NOT, BADOP, BADOP, BADOP, 1, OPF_TARGET|OPF_UNOP) -OPCODE(NEG, BADOP, BADOP, FNEG, 1, OPF_TARGET|OPF_UNOP) -OPCODE(FNEG, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(TRUNC, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(ZEXT, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(SEXT, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(FCVTU, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(FCVTS, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(UCVTF, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(SCVTF, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(FCVTF, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(UTPTR, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(PTRTU, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(PTRCAST, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(NOT, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET|OPF_UNOP) +OPCODE(NEG, BADOP, BADOP, BADOP, FNEG, 1, OPF_TARGET|OPF_UNOP) +OPCODE(FNEG, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(TRUNC, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(ZEXT, BADOP, BADOP, SEXT, BADOP, 1, OPF_TARGET) +OPCODE(SEXT, BADOP, BADOP, ZEXT, BADOP, 1, OPF_TARGET) +OPCODE(FCVTU, BADOP, BADOP, FCVTS, BADOP, 1, OPF_TARGET) +OPCODE(FCVTS, BADOP, BADOP, FCVTU, BADOP, 1, OPF_TARGET) +OPCODE(UCVTF, BADOP, BADOP, SCVTF, BADOP, 1, OPF_TARGET) +OPCODE(SCVTF, BADOP, BADOP, UCVTF, BADOP, 1, OPF_TARGET) +OPCODE(FCVTF, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(UTPTR, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(PTRTU, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(PTRCAST, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) OPCODE_RANGE(UNOP, NOT, PTRCAST) -OPCODE(SYMADDR, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(SLICE, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(SYMADDR, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(SLICE, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) /* Select - three input values */ -OPCODE(SEL, BADOP, BADOP, BADOP, 3, OPF_TARGET) -OPCODE(FMADD, BADOP, BADOP, BADOP, 3, OPF_TARGET) +OPCODE(SEL, BADOP, BADOP, BADOP, BADOP, 3, OPF_TARGET) +OPCODE(FMADD, BADOP, BADOP, BADOP, BADOP, 3, OPF_TARGET) /* Memory */ -OPCODE(LOAD, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(STORE, BADOP, BADOP, BADOP, 1, OPF_NONE) +OPCODE(LOAD, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(STORE, BADOP, BADOP, BADOP, BADOP, 1, OPF_NONE) /* Other */ -OPCODE(PHISOURCE, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(PHI, BADOP, BADOP, BADOP, 0, OPF_TARGET) -OPCODE(SETVAL, BADOP, BADOP, BADOP, 0, OPF_TARGET) -OPCODE(SETFVAL, BADOP, BADOP, BADOP, 0, OPF_TARGET) -OPCODE(CALL, BADOP, BADOP, BADOP, 1, OPF_TARGET) -OPCODE(INLINED_CALL, BADOP, BADOP, BADOP, 0, OPF_NONE) -OPCODE(NOP, BADOP, BADOP, BADOP, 0, OPF_NONE) -OPCODE(DEATHNOTE, BADOP, BADOP, BADOP, 0, OPF_NONE) -OPCODE(ASM, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(PHISOURCE, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(PHI, BADOP, BADOP, BADOP, BADOP, 0, OPF_TARGET) +OPCODE(SETVAL, BADOP, BADOP, BADOP, BADOP, 0, OPF_TARGET) +OPCODE(SETFVAL, BADOP, BADOP, BADOP, BADOP, 0, OPF_TARGET) +OPCODE(CALL, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(INLINED_CALL, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(NOP, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(DEATHNOTE, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(ASM, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) /* Sparse tagging (line numbers, context, whatever) */ -OPCODE(CONTEXT, BADOP, BADOP, BADOP, 0, OPF_NONE) -OPCODE(RANGE, BADOP, BADOP, BADOP, 3, OPF_NONE) +OPCODE(CONTEXT, BADOP, BADOP, BADOP, BADOP, 0, OPF_NONE) +OPCODE(RANGE, BADOP, BADOP, BADOP, BADOP, 3, OPF_NONE) /* Needed to translate SSA back to normal form */ -OPCODE(COPY, BADOP, BADOP, BADOP, 1, OPF_TARGET) +OPCODE(COPY, BADOP, BADOP, BADOP, BADOP, 1, OPF_TARGET) diff --git a/opcode.h b/opcode.h index bb94ec81c832..1524272f0320 100644 --- a/opcode.h +++ b/opcode.h @@ -4,7 +4,7 @@ #include "symbol.h" enum opcode { -#define OPCODE(OP,NG,SW,TF,N,FL) OP_##OP, +#define OPCODE(OP,NG,SW,SG,TF,N,FL) OP_##OP, #define OPCODE_RANGE(OP,S,E) OP_##OP = OP_##S, OP_##OP##_END = OP_##E, #include "opcode.def" #undef OPCODE @@ -15,9 +15,11 @@ enum opcode { extern const struct opcode_table { int negate:8; int swap:8; + int sign:8; int to_float:8; unsigned int arity:2; - unsigned int flags:6; + unsigned int :6; + unsigned int flags:8; #define OPF_NONE 0 #define OPF_TARGET (1 << 0) #define OPF_COMMU (1 << 1) @@ -25,6 +27,8 @@ extern const struct opcode_table { #define OPF_UNOP (1 << 3) #define OPF_BINOP (1 << 4) #define OPF_COMPARE (1 << 5) +#define OPF_SIGNED (1 << 6) +#define OPF_UNSIGNED (1 << 7) } opcode_table[]; From patchwork Sun Nov 8 01:19:34 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889375 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 78FB1139F for ; Sun, 8 Nov 2020 01:19:49 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5DDC5208FE for ; Sun, 8 Nov 2020 01:19:49 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="R705aTou" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726257AbgKHBTt (ORCPT ); Sat, 7 Nov 2020 20:19:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57584 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726060AbgKHBTt (ORCPT ); Sat, 7 Nov 2020 20:19:49 -0500 Received: from mail-ej1-x641.google.com (mail-ej1-x641.google.com [IPv6:2a00:1450:4864:20::641]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B148AC0613CF for ; Sat, 7 Nov 2020 17:19:48 -0800 (PST) Received: by mail-ej1-x641.google.com with SMTP id dk16so7208835ejb.12 for ; Sat, 07 Nov 2020 17:19:48 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=7zaMUEJV+xExPoaM1Wirnt/50amExEEGOj2vjGlf6nU=; b=R705aTouU1RIG5H/MATPF5C0lhHPMd32ikw8dmSHjBx1IVhvDCzF24uRfA26/ymX7Y 2mWkSMNAqMOG6hWJUtEcf2grsMVIWSU5hz8DnKWFX19fC3NiPKkXbBIagxuEGyyT2+wc LYI9PHogEvyPRN/yV5qQZYu6DoSfjDdLmVN1gf5nHDn9l9m01rueYm220kDGQXgzMAc+ 5dXVsAJfQ6SWUPxldDZXOdrem+fZda3264aOoZ3LBF9RRRI3IsKeZl2EnSeVE0OQJMyF 0qiPYa6wN2ZUfShxPQEq230G2Qyy/Q+nv7C8CaaOuJvuvyahyFdQPuCYaXTYFGuCvfju Ka7w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=7zaMUEJV+xExPoaM1Wirnt/50amExEEGOj2vjGlf6nU=; b=fMrwZI5QDL2sg1zh1gxPSmkT99PRVDxaNPvPeq+DDic34pRGvh+Bls0V3sRiWbdt31 Q7Oj7cdkyI+fQFchwgYI8htwNUoVS/FyM6WEotTixAylMwxV4GOBDTojtodRH626uwGA twWkMZHbQzC3dlZo+biH7g3nyzzM/ukM3OD90YdAIpUqSGvFaqJHHwvg9WBXCEh921uC aJKFVF1yGIfOdXcImTPB8fXV1xF+DhYy1AwKhGbsKIsoopNPXJGTXBiHmtCXDRNlw9zN dkqMwsbz84geEURZQ0X+yWZ0ePZHZiMpbyUi+wEilMxINRpObxuh+BkbxGjJLetI5t14 n2fQ== X-Gm-Message-State: AOAM5336wyI1Q4Ik3MvinoEON8PqtMO5WnbdybHcBgIbnqxEubfB9oyB /Igutuu0drK7oJHkrHxpT3MnEZr/z14= X-Google-Smtp-Source: ABdhPJzcsr9YgAKKf+D8daReCjqNhGlR7KC3D7LUckVS8OyqqdfPsR5IFFqqOYA+9YP/W24HEbehVg== X-Received: by 2002:a17:906:6949:: with SMTP id c9mr8879413ejs.482.1604798387244; Sat, 07 Nov 2020 17:19:47 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:46 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 04/16] cmp: move some code in a separate function: simplify_compare_constant() Date: Sun, 8 Nov 2020 02:19:34 +0100 Message-Id: <20201108011939.94252-5-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org simplify_constant_rightside() contains a few simplification regarding unsigned compares but much more can be done for unsigned and signed ones. So, move the current simplification in a separate function. Signed-off-by: Luc Van Oostenryck --- simplify.c | 74 +++++++++++++++++++++++++++++++----------------------- 1 file changed, 43 insertions(+), 31 deletions(-) diff --git a/simplify.c b/simplify.c index f2aaa52de84b..3338b72e6845 100644 --- a/simplify.c +++ b/simplify.c @@ -1057,6 +1057,43 @@ static int simplify_seteq_setne(struct instruction *insn, long long value) return 0; } +static int simplify_compare_constant(struct instruction *insn, long long value) +{ + switch (insn->opcode) { + case OP_SET_B: + if (!value) { // (x < 0) --> 0 + return replace_with_pseudo(insn, value_pseudo(0)); + } else if (value == 1) { // (x < 1) --> (x == 0) + insn->src2 = value_pseudo(0); + insn->opcode = OP_SET_EQ; + return REPEAT_CSE; + } + break; + case OP_SET_AE: + if (!value) { // (x >= 0) --> 1 + return replace_with_pseudo(insn, value_pseudo(1)); + } else if (value == 1) { // (x >= 1) --> (x != 0) + insn->src2 = value_pseudo(0); + insn->opcode = OP_SET_NE; + return REPEAT_CSE; + } + break; + case OP_SET_BE: + if (!value) { // (x <= 0) --> (x == 0) + insn->opcode = OP_SET_EQ; + return REPEAT_CSE; + } + break; + case OP_SET_A: + if (!value) { // (x > 0) --> (x != 0) + insn->opcode = OP_SET_NE; + return REPEAT_CSE; + } + break; + } + return 0; +} + static int simplify_constant_mask(struct instruction *insn, unsigned long long mask) { pseudo_t old = insn->src1; @@ -1169,37 +1206,12 @@ static int simplify_constant_rightside(struct instruction *insn) case OP_SET_NE: case OP_SET_EQ: - return simplify_seteq_setne(insn, value); - case OP_SET_B: - if (!value) { // (x < 0) --> 0 - return replace_with_pseudo(insn, value_pseudo(0)); - } else if (value == 1) { // (x < 1) --> (x == 0) - insn->src2 = value_pseudo(0); - insn->opcode = OP_SET_EQ; - return REPEAT_CSE; - } - break; - case OP_SET_AE: - if (!value) { // (x >= 0) --> 1 - return replace_with_pseudo(insn, value_pseudo(1)); - } else if (value == 1) { // (x >= 1) --> (x != 0) - insn->src2 = value_pseudo(0); - insn->opcode = OP_SET_NE; - return REPEAT_CSE; - } - break; - case OP_SET_BE: - if (!value) { // (x <= 0) --> (x == 0) - insn->opcode = OP_SET_EQ; - return REPEAT_CSE; - } - break; - case OP_SET_A: - if (!value) { // (x > 0) --> (x != 0) - insn->opcode = OP_SET_NE; - return REPEAT_CSE; - } - break; + if ((changed = simplify_seteq_setne(insn, value))) + return changed; + /* fallthrough */ + case OP_SET_LT: case OP_SET_LE: case OP_SET_GE: case OP_SET_GT: + case OP_SET_B: case OP_SET_BE: case OP_SET_AE: case OP_SET_A: + return simplify_compare_constant(insn, value); } return 0; } From patchwork Sun Nov 8 01:19:35 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889377 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 9A404697 for ; Sun, 8 Nov 2020 01:19:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7F9A3208FE for ; Sun, 8 Nov 2020 01:19:50 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="QW8AESS4" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727871AbgKHBTu (ORCPT ); Sat, 7 Nov 2020 20:19:50 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57588 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726060AbgKHBTu (ORCPT ); Sat, 7 Nov 2020 20:19:50 -0500 Received: from mail-ed1-x543.google.com (mail-ed1-x543.google.com [IPv6:2a00:1450:4864:20::543]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D1534C0613CF for ; Sat, 7 Nov 2020 17:19:49 -0800 (PST) Received: by mail-ed1-x543.google.com with SMTP id o20so5077201eds.3 for ; Sat, 07 Nov 2020 17:19:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=/2glrVwxHoe+54MBaX9AG99cybD+dpavIZChprse/WE=; b=QW8AESS4icI6NQZK52H+D+dx1kBsgdoHF60U5jdRIzANIgepqlu6gdyYeOfyNLUos7 w0V7K4Baqz3HRJpwsC4kPZUqRDRzFlPWSIU1r86EeOsSsCwfT73QqV63jwnUGTKmROBg jdSSmLDmqpdXwOBztjse5Qg+NXe7F8TFgV7uZfLgpDalsjFLgvuydapRy93TZQtNBxQY Q4gupecGJ8He4eAFU39QSE5IPW6VO/h2LUc6yf7DzV+CHK/f9vB6nQlTQNwOAm6EB4OQ rkhPWRULTUg33G4FEVrmNrK6GvvIMdKq2EzD0F7GMbSo/rCO8x4siawPle51v8+psSbg Y2KA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=/2glrVwxHoe+54MBaX9AG99cybD+dpavIZChprse/WE=; b=KaRWCuHWgEFHYoIEIrC5D+6KxqCghFqedidQWCbLD/5UbC8dICcJ6GWxdJDdcEb7XT eSlNu17E1iV/Wn4nKke0Rz4jPfg/bnVsUwf9ojuiEmh6TYWTnnEFe85eHSnhqr7KJEFq 4PIpKGxa50NaInOD7uga0qsSA/2+j9IwQ08/eucaK8ExzKRaNuFHnims+5QYYOs6P3LB AtmzI00DCNfqAjtGyWHzr8rcv5t0x+gkmWeFsU9DFVT7KQVztE7UYpibXgT/JNQh28lO OTC333BAreH/QzrabrC2FrX1Ku+U1WHgIET2r6w5QD3l5dQIULd0Q5A1gs9kh8dNxE+k E7AQ== X-Gm-Message-State: AOAM533NPcjC4oNeVd+sZr98taTah4QG/L3sKY68bX4ZiAmK9403aEIt +roxJ/uZd9rOqhRv2/hF6ijE64Tn168= X-Google-Smtp-Source: ABdhPJwdLCh7bZaWm33SplH02TJ5g/V3oYUIiL9IPumsPyIaMWJGvducFIe8L9GeWKlzMjv3NTUqlw== X-Received: by 2002:a05:6402:17ad:: with SMTP id j13mr8587380edy.347.1604798388342; Sat, 07 Nov 2020 17:19:48 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:47 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 05/16] cmp: use a few helpers for the simplification of compares Date: Sun, 8 Nov 2020 02:19:35 +0100 Message-Id: <20201108011939.94252-6-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org The current code for the simplification of compares is quite simple but also repetitive because everything must be done 4 times, one for each operations (<,<=,>=,>). So, add 2 helpers to factor out the details of the common parts. Signed-off-by: Luc Van Oostenryck --- simplify.c | 52 ++++++++++++++++++++++++++++++++-------------------- 1 file changed, 32 insertions(+), 20 deletions(-) diff --git a/simplify.c b/simplify.c index 3338b72e6845..59e6d1eee291 100644 --- a/simplify.c +++ b/simplify.c @@ -470,6 +470,28 @@ static inline int replace_with_unop(struct instruction *insn, int op, pseudo_t s return REPEAT_CSE; } +/// +// replace rightside's value +// @insn: the instruction to be replaced +// @op: the instruction's new opcode +// @src: the instruction's new operand +// @return: REPEAT_CSE +static inline int replace_binop_value(struct instruction *insn, int op, long long val) +{ + insn->opcode = op; + insn->src2 = value_pseudo(val); + return REPEAT_CSE; +} + +/// +// replace the opcode of an instruction +// @return: REPEAT_CSE +static inline int replace_opcode(struct instruction *insn, int op) +{ + insn->opcode = op; + return REPEAT_CSE; +} + static inline int def_opcode(pseudo_t p) { if (p->type != PSEUDO_REG) @@ -1061,34 +1083,24 @@ static int simplify_compare_constant(struct instruction *insn, long long value) { switch (insn->opcode) { case OP_SET_B: - if (!value) { // (x < 0) --> 0 + if (!value) // (x < 0) --> 0 return replace_with_pseudo(insn, value_pseudo(0)); - } else if (value == 1) { // (x < 1) --> (x == 0) - insn->src2 = value_pseudo(0); - insn->opcode = OP_SET_EQ; - return REPEAT_CSE; - } + if (value == 1) // (x < 1) --> (x == 0) + return replace_binop_value(insn, OP_SET_EQ, 0); break; case OP_SET_AE: - if (!value) { // (x >= 0) --> 1 + if (!value) // (x >= 0) --> 1 return replace_with_pseudo(insn, value_pseudo(1)); - } else if (value == 1) { // (x >= 1) --> (x != 0) - insn->src2 = value_pseudo(0); - insn->opcode = OP_SET_NE; - return REPEAT_CSE; - } + if (value == 1) // (x >= 1) --> (x != 0) + return replace_binop_value(insn, OP_SET_NE, 0); break; case OP_SET_BE: - if (!value) { // (x <= 0) --> (x == 0) - insn->opcode = OP_SET_EQ; - return REPEAT_CSE; - } + if (!value) // (x <= 0) --> (x == 0) + return replace_opcode(insn, OP_SET_EQ); break; case OP_SET_A: - if (!value) { // (x > 0) --> (x != 0) - insn->opcode = OP_SET_NE; - return REPEAT_CSE; - } + if (!value) // (x > 0) --> (x != 0) + return replace_opcode(insn, OP_SET_NE); break; } return 0; From patchwork Sun Nov 8 01:19:36 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889379 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 9F8F7697 for ; Sun, 8 Nov 2020 01:19:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 84ABA208FE for ; Sun, 8 Nov 2020 01:19:51 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="LjveBPVs" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728531AbgKHBTv (ORCPT ); Sat, 7 Nov 2020 20:19:51 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57592 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726060AbgKHBTv (ORCPT ); Sat, 7 Nov 2020 20:19:51 -0500 Received: from mail-ej1-x641.google.com (mail-ej1-x641.google.com [IPv6:2a00:1450:4864:20::641]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D3B8DC0613CF for ; Sat, 7 Nov 2020 17:19:50 -0800 (PST) Received: by mail-ej1-x641.google.com with SMTP id s25so7254354ejy.6 for ; Sat, 07 Nov 2020 17:19:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=OS4AcG1O4cpQ6/U2QD62EfC5C0OVzJBqlMYt0mJ9kXw=; b=LjveBPVsd8+DetQiFinRnIoP5I538ApePApMu+nYOKdglZKAb7SepKvWbVzMips/L1 WJvnFfgWSU5BWcXU6P39Pm3hfvcpO7InrHRAHLKvOw3nVh8vXSvwuusZ+AOME/jcUt/H n//i0nNJBfdQhUUCQyG4jsefwbVzXzCklkkflIfkRqq59GS8L0IH5+DUBc5ueAAZZMbf 6hyXQE4B7HnzepeE3gov1h//Vp+Oimh5/spYRzKTDJPpZlGCXnOD5P1eadZShmTJoML+ tSDdBUzhh0xcgbky3l87C//lwyFaPYafpZocf8Uau4iun+2ckZ3NZWTKTFOEk30nBf2k BiNA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=OS4AcG1O4cpQ6/U2QD62EfC5C0OVzJBqlMYt0mJ9kXw=; b=R92mjlhWWkdLxiPOzhbF7eqa55N0YPFzwW2rnZIs2/0TGJtDCxImkcvD8Jx2nSdJ4P 0W4o+OxFJSzbeF/sAk8XPKxXNfXuP84TOXOfAIzSQCXJU+l8brMAdY/2n+F9gqBqHL+G +yUHpS2+BHPamPxsfpPYgoX+XhQRz2RLomN449sauJbWpChO2q7t/eSqsgL77ru7r/6T eLthDzGfEIe6PRde3VM4yS5LvL/W3f9K/L4pkqM/O+Yv5QhIQQXBNIanHlKIZAj+G/uw 44sxRiSdPMtHGRYWliRb19uSoUahQLS3kU8sqLCNTs/JCu3EmBI80UZSN8GlXu3IhJDY xtJQ== X-Gm-Message-State: AOAM532gisNc7tgksKvjad2vgGnvZZYpiR1ZqDjKPBO+uTWXYgFYgyVQ dA4kccfS6NWv8I8pMwAcYx9T8kGLNrw= X-Google-Smtp-Source: ABdhPJyMGKVwt3mJEOprkjXTk29xMo8632FLTNcMuBI2aVdJf/gX5Fz8J7pDMBMcCuYMdZ7Mk+DP6g== X-Received: by 2002:a17:906:aecd:: with SMTP id me13mr909435ejb.433.1604798389381; Sat, 07 Nov 2020 17:19:49 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:48 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 06/16] cmp: canonicalize unsigned (x {<,>=} C) --> (x {<=,>} C-1) Date: Sun, 8 Nov 2020 02:19:36 +0100 Message-Id: <20201108011939.94252-7-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org An unsigned comparison like (x < 3) is equivalent to (x <= 2). Canonicalize '<' & '>=' to '<=' & '>', such that the smallest constant is used. Signed-off-by: Luc Van Oostenryck --- simplify.c | 8 +++++++- validation/optim/canonical-cmpu.c | 1 - 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/simplify.c b/simplify.c index 59e6d1eee291..b8dfbad1f077 100644 --- a/simplify.c +++ b/simplify.c @@ -1081,18 +1081,24 @@ static int simplify_seteq_setne(struct instruction *insn, long long value) static int simplify_compare_constant(struct instruction *insn, long long value) { + int changed = 0; + switch (insn->opcode) { case OP_SET_B: if (!value) // (x < 0) --> 0 return replace_with_pseudo(insn, value_pseudo(0)); if (value == 1) // (x < 1) --> (x == 0) return replace_binop_value(insn, OP_SET_EQ, 0); + else // (x < y) --> (x <= (y-1)) + changed |= replace_binop_value(insn, OP_SET_BE, value - 1); break; case OP_SET_AE: if (!value) // (x >= 0) --> 1 return replace_with_pseudo(insn, value_pseudo(1)); if (value == 1) // (x >= 1) --> (x != 0) return replace_binop_value(insn, OP_SET_NE, 0); + else // (x >= y) --> (x > (y-1) + changed |= replace_binop_value(insn, OP_SET_A, value - 1); break; case OP_SET_BE: if (!value) // (x <= 0) --> (x == 0) @@ -1103,7 +1109,7 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_opcode(insn, OP_SET_NE); break; } - return 0; + return changed; } static int simplify_constant_mask(struct instruction *insn, unsigned long long mask) diff --git a/validation/optim/canonical-cmpu.c b/validation/optim/canonical-cmpu.c index 482408aa90c1..29bbd0a8690a 100644 --- a/validation/optim/canonical-cmpu.c +++ b/validation/optim/canonical-cmpu.c @@ -9,7 +9,6 @@ int cmp_geu(unsigned int x) { return (x >= 256) == (x > 255); } /* * check-name: canonical-cmpu * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:19:37 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889383 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id EA83115E6 for ; Sun, 8 Nov 2020 01:19:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D0C7020885 for ; Sun, 8 Nov 2020 01:19:53 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Ha+kpcI0" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726060AbgKHBTx (ORCPT ); Sat, 7 Nov 2020 20:19:53 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57598 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728568AbgKHBTx (ORCPT ); Sat, 7 Nov 2020 20:19:53 -0500 Received: from mail-ej1-x643.google.com (mail-ej1-x643.google.com [IPv6:2a00:1450:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A8B1CC0613CF for ; Sat, 7 Nov 2020 17:19:51 -0800 (PST) Received: by mail-ej1-x643.google.com with SMTP id i19so7240699ejx.9 for ; Sat, 07 Nov 2020 17:19:51 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=WVscvQq2u4pMMO44qX3iV/3iy7b4PJ3CJXZcmwu1cTg=; b=Ha+kpcI0olcN0Orcp3yexQn5A8S64xm5nuE4IUeXo+xLBSkld/1Px/E6dW/bj4Yej4 xN+NYoPdoVEljxjhHD+SoN8vig229yEZ7by4R3AYhY/QdUkAcDRGbmZjqu0GZFdK+kT1 2FU9xZVEa+xj+6KwN9ufvzLv4qW+HHu2vY5TqxRW+87vZm2hyHvRy+CaVi6APQWd3mon j4Tf1Qit3VHH0kdOlX91//D2wSiFSFbZv5gRllnmqboMd6PKmZb1zres9TqE8lBjo69O nkPgmraMKEGbEz+21k9b+aLyZKHBieFxnYncczSLSLZo2/DJ23zURsHIiYfFh56RLn/o H5rA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=WVscvQq2u4pMMO44qX3iV/3iy7b4PJ3CJXZcmwu1cTg=; b=QSXUCQVIZUEDjyY7yaGi57z7vkFBJxGSG/BGP9vGFe+ZZjl9wVYbtvoZ+p+EPZr5NR 4/dLiffEkKQprMVRuBROqPTBOUWws9v1uCCLjbuxNSVGSt8iXhP9AtU7vGFoXPffFLwC OivqpesYJU+uwH1R7xCX3O5p47+AR0rUsQLGJZoszydrEZX447DmOHxlW5V1c1qwci3x zJcIIh/8wSCErjgFlH773BE7daNsxHkFmxQEXE4BhAVuIhT4qhtdt8WOAjESnzJoLvcS a601aKEWgiYqX5K1vOauoO2Gg7tNsMLETP75WpGEzaK18/tVpyLJUputReu/PW5BOyYt s/YA== X-Gm-Message-State: AOAM533YupDX/7KbI7xpdLTp1HEDOCEIyeoMfhSUEYdycJ025x2MR2B7 QQnE+DxMW2RhTD3T8Ncet+ME6he39qo= X-Google-Smtp-Source: ABdhPJyXXbx3wr90RaQbNrtunDTw6Hufz0QiRXxAc0NPmVSvjQMISgzJkOA5IjQKrp8TL78jVdhJxg== X-Received: by 2002:a17:906:1458:: with SMTP id q24mr9218479ejc.541.1604798390206; Sat, 07 Nov 2020 17:19:50 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:49 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 07/16] cmp: simplify unsigned (x {<=,>} UMAX) into {1,0} Date: Sun, 8 Nov 2020 02:19:37 +0100 Message-Id: <20201108011939.94252-8-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org These compares are always true or false, so simplify them. Signed-off-by: Luc Van Oostenryck --- simplify.c | 5 +++++ validation/optim/set-uimm1.c | 1 - 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index b8dfbad1f077..160a6ab15e7f 100644 --- a/simplify.c +++ b/simplify.c @@ -1081,6 +1081,7 @@ static int simplify_seteq_setne(struct instruction *insn, long long value) static int simplify_compare_constant(struct instruction *insn, long long value) { + unsigned long long bits = bits_mask(insn->itype->bit_size); int changed = 0; switch (insn->opcode) { @@ -1103,10 +1104,14 @@ static int simplify_compare_constant(struct instruction *insn, long long value) case OP_SET_BE: if (!value) // (x <= 0) --> (x == 0) return replace_opcode(insn, OP_SET_EQ); + if (value == bits) // (x <= ~0) --> 1 + return replace_with_pseudo(insn, value_pseudo(1)); break; case OP_SET_A: if (!value) // (x > 0) --> (x != 0) return replace_opcode(insn, OP_SET_NE); + if (value == bits) // (x > ~0) --> 0 + return replace_with_pseudo(insn, value_pseudo(0)); break; } return changed; diff --git a/validation/optim/set-uimm1.c b/validation/optim/set-uimm1.c index d6928f59d044..aa9f54c3ff82 100644 --- a/validation/optim/set-uimm1.c +++ b/validation/optim/set-uimm1.c @@ -4,7 +4,6 @@ static _Bool setgt_umax(unsigned int a) { return (a > ~0) == 0; } /* * check-name: set-uimm1 * check-command: test-linearize $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:19:38 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889381 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 98D59139F for ; Sun, 8 Nov 2020 01:19:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7E48E208FE for ; Sun, 8 Nov 2020 01:19:53 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="X1YLamVB" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728752AbgKHBTx (ORCPT ); Sat, 7 Nov 2020 20:19:53 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57602 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726060AbgKHBTx (ORCPT ); Sat, 7 Nov 2020 20:19:53 -0500 Received: from mail-ej1-x643.google.com (mail-ej1-x643.google.com [IPv6:2a00:1450:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C4941C0613D2 for ; Sat, 7 Nov 2020 17:19:52 -0800 (PST) Received: by mail-ej1-x643.google.com with SMTP id cw8so7243168ejb.8 for ; Sat, 07 Nov 2020 17:19:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=jKETXCOxbuPiYDn4OL3cUM1t7GC6XVLA7eZ9dGAEPbM=; b=X1YLamVBVgxymqFzTFoDqI7/8cducrhgc8AockGhEue56JFDEPoZy5sLPoQyTenay+ 5NZ1KD96SJuBWIm9XRu/zzetG1MYDw9AcWBxXM1+KUXeLFQB/6thS8idOafqC1hDZBCt PrOk3h6G9YEZ2D3SVPyfXlFz3Dch5y44W1Btl7hQ3E3KxpKuTniDOMaUoM2TQqkCq6ze f742jRRKwUrgy6vvf5r36+wMOAJ6ZlsiTFZNfdjoERmsBi4g4o4LBbDJx6I6fp63CN2w 6+KYFzCsObWbCY4mFCVRFOvVO2Flp6bsPj9dWaoHfHVHgX4fuJ+ccphrlwfqsT3RSsJO B+Ug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=jKETXCOxbuPiYDn4OL3cUM1t7GC6XVLA7eZ9dGAEPbM=; b=M+BK/Oy9nosAjsGt5ZsV3wON7iA1XAFztBpuv3XoZMRGor2zxOWhGuctDSv1jAfri3 3yVuT/AjkLjR448OYEJ4211aphqV2Iw81Rtt2Np3GQzUDLNkY72r2S0Ex7rc7nShQE31 hP7nOaSwIzq8Wh/PD6vyu/pE9lPp/ift1qTI4wxsEsuAJD+MB32IGcpbaWlr9KjAkCo5 p0dxUSAjhKqMhUCTDeOVspXhoNZLloHLC4fSYaTPtPNp9Y+6LgjHOq5pdXjG1vkvriun HNsNYZQRa9hRFBG+b/ZnLuY5W5u5eekeWb9jK08SEgdFWfRI8hc556wvwki7q42NkBTM uHXA== X-Gm-Message-State: AOAM533qsmcxTtn7bTUgThjK85/h/C7GN51LfjDOCA+/l/jjC3FbefSv tCdLTn4c+y6Hu5gtLoNvoMbX1P0B8WY= X-Google-Smtp-Source: ABdhPJwrEJrJrasZgIEmNKcJtHwglcxSdPeZIci44Dy56kk8LFVWTugA55lSeT61LThLQaChvFcwaA== X-Received: by 2002:a17:906:6d99:: with SMTP id h25mr8841408ejt.281.1604798391270; Sat, 07 Nov 2020 17:19:51 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:50 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 08/16] cmp: canonicalize unsigned compare with UMAX or UMAX-1 Date: Sun, 8 Nov 2020 02:19:38 +0100 Message-Id: <20201108011939.94252-9-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org Unsigned compares with UMAX (or UMAX-1) are equivalent to equality tests. These are preferable since it's easier to reason about them in other simplifications. So canonicalize these compares to equality tests. Signed-off-by: Luc Van Oostenryck --- simplify.c | 8 ++++++++ validation/optim/set-uimm2.c | 1 - 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index 160a6ab15e7f..7921300f7280 100644 --- a/simplify.c +++ b/simplify.c @@ -1090,6 +1090,8 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_with_pseudo(insn, value_pseudo(0)); if (value == 1) // (x < 1) --> (x == 0) return replace_binop_value(insn, OP_SET_EQ, 0); + else if (value == bits) // (x < ~0) --> (x != ~0) + return replace_binop_value(insn, OP_SET_NE, value); else // (x < y) --> (x <= (y-1)) changed |= replace_binop_value(insn, OP_SET_BE, value - 1); break; @@ -1098,6 +1100,8 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_with_pseudo(insn, value_pseudo(1)); if (value == 1) // (x >= 1) --> (x != 0) return replace_binop_value(insn, OP_SET_NE, 0); + else if (value == bits) // (x >= ~0) --> (x == ~0) + return replace_binop_value(insn, OP_SET_EQ, value); else // (x >= y) --> (x > (y-1) changed |= replace_binop_value(insn, OP_SET_A, value - 1); break; @@ -1106,12 +1110,16 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_opcode(insn, OP_SET_EQ); if (value == bits) // (x <= ~0) --> 1 return replace_with_pseudo(insn, value_pseudo(1)); + if (value == (bits - 1)) // (x <= ~1) --> (x != ~0) + return replace_binop_value(insn, OP_SET_NE, bits); break; case OP_SET_A: if (!value) // (x > 0) --> (x != 0) return replace_opcode(insn, OP_SET_NE); if (value == bits) // (x > ~0) --> 0 return replace_with_pseudo(insn, value_pseudo(0)); + if (value == (bits - 1)) // (x > ~1) --> (x == ~0) + return replace_binop_value(insn, OP_SET_EQ, bits); break; } return changed; diff --git a/validation/optim/set-uimm2.c b/validation/optim/set-uimm2.c index efa326f532ce..9138ae7276e7 100644 --- a/validation/optim/set-uimm2.c +++ b/validation/optim/set-uimm2.c @@ -6,7 +6,6 @@ static _Bool setgt_umax(unsigned int a) { return (a > ~1) == (a == ~0); } /* * check-name: set-uimm2 * check-command: test-linearize $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:19:39 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889385 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 83BC1697 for ; Sun, 8 Nov 2020 01:19:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 67BA620B1F for ; Sun, 8 Nov 2020 01:19:54 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="rLoxAE6B" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728568AbgKHBTy (ORCPT ); Sat, 7 Nov 2020 20:19:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57606 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728279AbgKHBTy (ORCPT ); Sat, 7 Nov 2020 20:19:54 -0500 Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com [IPv6:2a00:1450:4864:20::644]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B7282C0613CF for ; Sat, 7 Nov 2020 17:19:53 -0800 (PST) Received: by mail-ej1-x644.google.com with SMTP id k3so7238718ejj.10 for ; Sat, 07 Nov 2020 17:19:53 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xH1VUOFWIU3nomIe48C0/JIkSj0BwVm9wOVBaq6KPFU=; b=rLoxAE6BZkO5WiRXZ9yz/rxvfNZA8V+rHdeAgIcFQE8z5kHUhF3SWi5kGJsTM7cj02 6Fw7MjRTkauUJftlPjN/SkSocc6mI5io28CS84ozGtFKukY4tWSoMTxvwlhEasbafr4G 4mGAJQqWuYZxPf1b5ve3Ld/fOlG84Nn1fUtwBfr0ZgJC4AydI3bpyTR/v5URyvlbUTn5 YM7+9SHlPP1NDTeRpfijUGYinW8a/cbiUmoB7daSDXDdE2o98igqWZ6GsYvf1Yx2XRue kdjHh6TVECsTv4zCZ8w2bmp/p4XTHgQF5XV1AUdr3nM0iS45YJf8uYh377wzK1gXIMka I0pw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xH1VUOFWIU3nomIe48C0/JIkSj0BwVm9wOVBaq6KPFU=; b=Wd2xDkjvuk+WRS7Y16AKZekD5dAoxgR/LPRx9bc6XwZ/7dmW9oUcXLWakOYKF5HvWE x6XeZ+5NDAqB1kJvdMxMv+oUTr5q0NMyYzbbYD1F10CQmy4FZ9credwgfZfqEVfCpw6r FIap/na5pfqtz3ThqnKNEkNScvh6fBSOB4yIu2VQKrs0q6mEiWYaQXWBAtTzhDYff1Z6 d2wVk2yhUIpDKVDhmmuqwZtcTVjg0XJcaJPPI5wA5x0ZxPnPM/oRBrBNpjAUthqm2BXL BW/xH+CNcOn/kBxgqOuDQ74aS9V9F6mWlKfAEOAkJFudQUDKpY1tbQWRoqyRQ3/RYHS9 kZQQ== X-Gm-Message-State: AOAM532mzMiO3pvKyBYkl0gIuZvwOk+jWWdFmsQQTAza6+kWwN8ChPyI hf69vkaZ4/6B0Vv+Y5Uga60DvifvIhQ= X-Google-Smtp-Source: ABdhPJwdz0bu4MlZ4nl2z4dV/Yf7HYzFJhSbqYSRiOsy6GCnUh6aDLzEyUWhwpkYdECRO4SQhaCFYg== X-Received: by 2002:a17:906:c315:: with SMTP id s21mr8576556ejz.285.1604798392263; Sat, 07 Nov 2020 17:19:52 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id t22sm4545127edq.64.2020.11.07.17.19.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:19:51 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 09/16] cmp: canonicalize unsigned (x {<=,>} SMAX) Date: Sun, 8 Nov 2020 02:19:39 +0100 Message-Id: <20201108011939.94252-10-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org Unsigned <= or > against SMAX are equivalent to testing if the value is positive or not (when interpreted as a signed number). Canonicalize to this positive/negative test since it only needs the constant 0 which make it easier to handle at later steps. Signed-off-by: Luc Van Oostenryck --- simplify.c | 4 ++++ validation/optim/set-uimm3.c | 1 - 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index 7921300f7280..2176f90dc133 100644 --- a/simplify.c +++ b/simplify.c @@ -1112,6 +1112,8 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_with_pseudo(insn, value_pseudo(1)); if (value == (bits - 1)) // (x <= ~1) --> (x != ~0) return replace_binop_value(insn, OP_SET_NE, bits); + if (value == (bits >> 1)) // (x u<= SMAX) --> (x s>= 0) + changed |= replace_binop_value(insn, OP_SET_GE, 0); break; case OP_SET_A: if (!value) // (x > 0) --> (x != 0) @@ -1120,6 +1122,8 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_with_pseudo(insn, value_pseudo(0)); if (value == (bits - 1)) // (x > ~1) --> (x == ~0) return replace_binop_value(insn, OP_SET_EQ, bits); + if (value == (bits >> 1)) // (x u> SMAX) --> (x s< 0) + changed |= replace_binop_value(insn, OP_SET_LT, 0); break; } return changed; diff --git a/validation/optim/set-uimm3.c b/validation/optim/set-uimm3.c index b72ef8d6e819..5160f741d85b 100644 --- a/validation/optim/set-uimm3.c +++ b/validation/optim/set-uimm3.c @@ -4,7 +4,6 @@ int gt(int x) { return (x > 0x7fffffffU) == (x < 0); } /* * check-name: set-uimm3 * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:20 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889387 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 06661697 for ; Sun, 8 Nov 2020 01:21:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D7068208FE for ; Sun, 8 Nov 2020 01:21:31 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="IDgCWJmy" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726043AbgKHBVb (ORCPT ); Sat, 7 Nov 2020 20:21:31 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57852 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725838AbgKHBVb (ORCPT ); Sat, 7 Nov 2020 20:21:31 -0500 Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com [IPv6:2a00:1450:4864:20::644]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2B9CFC0613CF for ; Sat, 7 Nov 2020 17:21:31 -0800 (PST) Received: by mail-ej1-x644.google.com with SMTP id gn41so7255987ejc.4 for ; Sat, 07 Nov 2020 17:21:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=9ybkTI1DFG/k+ICg4+d9d+6SaAn12c8V5pJbjpzsC00=; b=IDgCWJmyQuCyvXjkN5v8bhcdg0s68e1lEE9TZMOl1Aq2WQyjPM2JQrfP5uRigzmLun aTRNrHmi4rOjRRdQwsoJWnj52HFI2uAAqm5u9GWfdLMy+PoJwp/YtU8rjEUadWnS2yTm AdBENYtSYMPsoCqJtFPlY2m7a7Yz/IYilTLuW5qeLigfVqIoXXzYx0Bf5lGQ3AwJx8SO TrFkeH4S6kxowPt2wTPnexcEe9FUdyexLEuGayVCkEuHOOSNcDS1AyCFCQuxrGD6fu3/ 6UB7dBNnOVpfNPbbiJXY/fRXOjhvdtxXDbzfzVMTYzoJp18Ez/jne6Vcf6ABdUZPlQT+ WazA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=9ybkTI1DFG/k+ICg4+d9d+6SaAn12c8V5pJbjpzsC00=; b=b2KwTUcwdQTDl0mBiUoDb6IwZ+lkQq87l1QD7HZLZDUr+B8/OURX0/p7i7XO2cLjKP nDy6QXXNx0KEbaxQZuqyW686UVMiLrnREk2wXFOkoOW1VTr9/H594UAMOWlRQqhpsvj6 GD2m/w2JlAxAicDEMY4Ptsvt/e+ObC1Ch+ETbliec2IK3nfb/rUx5lnh1NFIVHNjH/rB Rlh1Do8pPS2JopdF6WiLg/+wwvq5SEZAChrnt3puGL1js85B8PpSgn2Vg7SnfLr3g6J4 KeL0PPuRVLBoe1YvXkOoSwBhwvPhloJ9klUsPoG/WzZYWzlt4xblUh1kY4MRF9wRlhYc Xa7A== X-Gm-Message-State: AOAM533LxKv9wJBlpg0m3JmlVUR101dWkYZGzYklTwWrfDzlQuQIFQrC 340dGd8tgNSnAL9LzxzcohkN/bPyaQ0= X-Google-Smtp-Source: ABdhPJyfAf19zQ7aIxCM0RprJAz1aPRw0r2BacDOE3AxdW0TEPYQ6oYkeXXnrTkUZ0QYvR88DTgopA== X-Received: by 2002:a17:906:77c5:: with SMTP id m5mr8937646ejn.424.1604798489644; Sat, 07 Nov 2020 17:21:29 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:29 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 10/16] cmp: simplify sext(x) cmp C --> x cmp C Date: Sun, 8 Nov 2020 02:21:20 +0100 Message-Id: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org When doing a compare of a sign-extended value against a constant the, sign-extension can be dropped and the comparison done on the original type if the constant is within the original range. Simplify away these sign-extensions. Signed-off-by: Luc Van Oostenryck --- simplify.c | 24 ++++++++++++++++++++++++ validation/optim/cmp-sext.c | 1 - 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index 2176f90dc133..eb2c724f6307 100644 --- a/simplify.c +++ b/simplify.c @@ -415,6 +415,13 @@ static inline int constant(pseudo_t pseudo) return pseudo->type == PSEUDO_VAL; } +/// +// is this same signed value when interpreted with both size? +static inline bool is_signed_constant(long long val, unsigned osize, unsigned nsize) +{ + return bits_extend(val, osize, 1) == bits_extend(val, nsize, 1); +} + /// // replace the operand of an instruction // @insn: the instruction @@ -1082,6 +1089,9 @@ static int simplify_seteq_setne(struct instruction *insn, long long value) static int simplify_compare_constant(struct instruction *insn, long long value) { unsigned long long bits = bits_mask(insn->itype->bit_size); + struct instruction *def; + pseudo_t src1, src2; + unsigned int osize; int changed = 0; switch (insn->opcode) { @@ -1126,6 +1136,20 @@ static int simplify_compare_constant(struct instruction *insn, long long value) changed |= replace_binop_value(insn, OP_SET_LT, 0); break; } + + src1 = insn->src1; + src2 = insn->src2; + value = src2->value; + switch (DEF_OPCODE(def, src1)) { + case OP_SEXT: // sext(x) cmp C --> x cmp trunc(C) + osize = def->orig_type->bit_size; + if (is_signed_constant(value, osize, def->size)) { + insn->itype = def->orig_type; + insn->src2 = value_pseudo(zero_extend(value, osize)); + return replace_pseudo(insn, &insn->src1, def->src); + } + break; + } return changed; } diff --git a/validation/optim/cmp-sext.c b/validation/optim/cmp-sext.c index 2dd60fff064c..13f4fbdfad77 100644 --- a/validation/optim/cmp-sext.c +++ b/validation/optim/cmp-sext.c @@ -17,7 +17,6 @@ _Bool cmpgtu_sext(int a) { return (a >= 0x80000000ULL) == (a < 0); } /* * check-name: cmp-sext * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:21 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889389 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id F0929697 for ; Sun, 8 Nov 2020 01:21:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D4F34208FE for ; Sun, 8 Nov 2020 01:21:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="J9PbDJ9G" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726060AbgKHBVc (ORCPT ); Sat, 7 Nov 2020 20:21:32 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57858 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725838AbgKHBVc (ORCPT ); Sat, 7 Nov 2020 20:21:32 -0500 Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com [IPv6:2a00:1450:4864:20::644]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 19735C0613CF for ; Sat, 7 Nov 2020 17:21:32 -0800 (PST) Received: by mail-ej1-x644.google.com with SMTP id i19so7243132ejx.9 for ; Sat, 07 Nov 2020 17:21:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=8fNM+9Fl4SDVO1MpW++I3AWFAWGB9v0J0HGJYwUTPuM=; b=J9PbDJ9Ge3ZaTRyH2YliKJU/kI6YtEAE6o+xATgIhX9sZQ1VpMQk08FpHRTnTOuyxj IgLPn1nrqvAdKrcyM6Jyi4CkemTnDQCZotLHJed47/oG9HmVrjKKqhMbddVaI6CCUwkJ WHffdhSUCQubcEkUEdau9yIgr6JxZCvDxcmaU9sdfqkIklmsjd4Phpqo0LJPSNik/1Ny K6/Z5F6j+Dvm+nvYXComp0J75yCOWzC+pvWjuWRT+4nahsfM+cmLiaHn0V7gaeA8uE7E CqPDs2Gj8Oi73GQeidWX216Uu12+EjOEeCeTEm708QDMjXT4icUIUhobPgnCbtEuJ5nq epWg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=8fNM+9Fl4SDVO1MpW++I3AWFAWGB9v0J0HGJYwUTPuM=; b=e/ndcaAcGL4MfdppL3DybL1EE9f6XmHrgZpVdGaUQQhX1hQhMot9tOYf7hm8F4K0IV 2SWM23VpDUqr+aCFgXYhvkmUhgQtOEc/djfNS7vxDqaZVnSYB9vVYbRHl4umQNrSGqQ2 YZlnHfpAnEd6usXVs8N8XyQ22321UaCZgmWnt12AWjmBM1rcMIdjvZqodk/hhcmM69Iw sWJPIJgi2YUfbJFSu25oWb1GP5nSISSqPEgG3jV/UPr8Pjg1dxQ+4DCJnN1zJiEILPan uXynJN6J8XLAHlBlf6OG7L/w9GDhisOOzdtYHcjR70+XZmU0g4b8xggE8v5HDwf//nBS 45fA== X-Gm-Message-State: AOAM531mthtnp0HqdUJKJQrN7cjyhy+J6VVeo62kwcqzk36Nc7GNT4b/ apY+9QAO2rVspEYUZh9zPIZxkoCWTyw= X-Google-Smtp-Source: ABdhPJzm115WrC09p3tswhbNd63kZk83lUO+9C/GU8SaOpnYswO4vLYCY/az/Cpnocx/wKtfmyU59Q== X-Received: by 2002:a17:906:4bc2:: with SMTP id x2mr9182473ejv.525.1604798490643; Sat, 07 Nov 2020 17:21:30 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:30 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 11/16] cmp: simplify zext(x) cmp C --> x cmp C Date: Sun, 8 Nov 2020 02:21:21 +0100 Message-Id: <20201108012126.94339-2-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> <20201108012126.94339-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org When doing a compare of a zero-extended value against a constant, this extension can be dropped and the comparison done on the original type if the constant is within the original range and signed compares become the corresponding unsigned one. Simplify away these sign-extensions. Signed-off-by: Luc Van Oostenryck --- simplify.c | 11 +++++++++++ validation/optim/cmp-zext-uimm1.c | 1 - validation/optim/cmp-zext.c | 1 - validation/optim/zext-cmpu.c | 1 - 4 files changed, 11 insertions(+), 3 deletions(-) diff --git a/simplify.c b/simplify.c index eb2c724f6307..1cb5275b7a73 100644 --- a/simplify.c +++ b/simplify.c @@ -1149,6 +1149,17 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_pseudo(insn, &insn->src1, def->src); } break; + case OP_ZEXT: + osize = def->orig_type->bit_size; + bits = bits_mask(osize); + if (value <= bits) { + const struct opcode_table *op = &opcode_table[insn->opcode]; + if (op->flags & OPF_SIGNED) + insn->opcode = op->sign; + insn->itype = def->orig_type; + return replace_pseudo(insn, &insn->src1, def->src); + } + break; } return changed; } diff --git a/validation/optim/cmp-zext-uimm1.c b/validation/optim/cmp-zext-uimm1.c index ffcdaad5c1bd..c21780ea728d 100644 --- a/validation/optim/cmp-zext-uimm1.c +++ b/validation/optim/cmp-zext-uimm1.c @@ -9,7 +9,6 @@ int zext_gt_p(unsigned int x) { return (zext(x) > (BITS )) == 0; } /* * check-name: cmp-zext-uimm1 * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 diff --git a/validation/optim/cmp-zext.c b/validation/optim/cmp-zext.c index ecee6b5e9101..ac4847806251 100644 --- a/validation/optim/cmp-zext.c +++ b/validation/optim/cmp-zext.c @@ -11,7 +11,6 @@ _Bool cmpu_zext(ARGS(UINT32)) { return TEST(UINT64, UINT32, a, < , 0xffffffff); /* * check-name: cmp-zext * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 diff --git a/validation/optim/zext-cmpu.c b/validation/optim/zext-cmpu.c index 279ed70e0fda..9758e0710d7b 100644 --- a/validation/optim/zext-cmpu.c +++ b/validation/optim/zext-cmpu.c @@ -10,7 +10,6 @@ int gtl(unsigned x) { return (((long long)x) > 0x0fffffffeULL) == (x > 0xfffff /* * check-name: zext-cmpu * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:22 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889391 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 3EEE3139F for ; Sun, 8 Nov 2020 01:21:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 24038208FE for ; Sun, 8 Nov 2020 01:21:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="n2CZPYm0" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726132AbgKHBVd (ORCPT ); Sat, 7 Nov 2020 20:21:33 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57862 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725838AbgKHBVd (ORCPT ); Sat, 7 Nov 2020 20:21:33 -0500 Received: from mail-ej1-x643.google.com (mail-ej1-x643.google.com [IPv6:2a00:1450:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 13C2DC0613CF for ; Sat, 7 Nov 2020 17:21:33 -0800 (PST) Received: by mail-ej1-x643.google.com with SMTP id o23so7242834ejn.11 for ; Sat, 07 Nov 2020 17:21:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rl8oH1QkLHvtjj1QocWRnIRwLfAaT8UGP3+Efz8Kz1k=; b=n2CZPYm0SfcxbGoBzD2MGOjGC6tAosrd+un0aJc2JErVdgF/9GDPkDYiEGO4tlJG4t ++21o4w9wfs44GROYridPKzjORD0VKOdwePbsEgmNwM6v7mLSS4dY0D0PRJW0SylHaGC WBg37A58TJHhpJ49hGB5R4nh1l6yIhi/pn5ztZo3QIsLUACtf4h1j1XZfAdXDrwWmD0o lw1Q/YHwTFZF6BjbhM5ran4QLMHwNJ2A11lTyJc+viTYqszUVgRETMsZK0+7s/GXMKHy 164rTLYIT4LfjHyqgIb6UNYFWBJwiqn1DOMAg58kYljm4WU4gG2jw4fRANvb84dPCpl0 WfvA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=rl8oH1QkLHvtjj1QocWRnIRwLfAaT8UGP3+Efz8Kz1k=; b=QRJAAsVyTn71ANuN3TaxwdfQIJ7ZpLXvhtp/TwaYmAopzQ73ndvErtBRJ3F8lOL4tQ 92sJL+i6zM+0unFiv5gW7dmD8FdcL+8FTgGe8ayC4BX2IWYOuiRHEIXbxsfbXghgrF6y 87kcCuDTtBpOz1N9LF9U9ZxV3GZBEG2fzaFkFtZoCQXUCYa3WyQ80rqkqSG6h3VXwAf8 PEhZV3arlBruPCzGJNwOxSrXw19KP/HdD3Tn4gO5PCSpah8MVixm+Ia1eunSA6rvy50J Yb9PB7wEPCFgqaU2Mc7I/qtEyW4lCaWVaQJmbVvzBSANr+SKo6C2yWl0HELff5TWKKIO MPnw== X-Gm-Message-State: AOAM533rDnQywQ096QtMAhnL91TBgDlaMpVgCHHRcCMzNf3Z428gFhjQ l+99SQ4oZiisJmoixXllBbXRyLeTz2s= X-Google-Smtp-Source: ABdhPJxLF58CWac2FeqvdwwmGDluVHbXOFCotwcdie066v4d41fpWHRbOCwJ8edBPojjxxnf9LuShw== X-Received: by 2002:a17:907:6ef:: with SMTP id yh15mr8595759ejb.506.1604798491628; Sat, 07 Nov 2020 17:21:31 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:31 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 12/16] cmp: simplify sext(x) cmps {SMAX,SMIN} Date: Sun, 8 Nov 2020 02:21:22 +0100 Message-Id: <20201108012126.94339-3-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> <20201108012126.94339-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org A signed compare of a sign-extended value against a constant outside of the original range is statically known. Simplify to the corresponding 0/1. Signed-off-by: Luc Van Oostenryck --- simplify.c | 14 ++++++++++++++ validation/optim/cmp-sext-simm.c | 1 - 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index 1cb5275b7a73..a59918697762 100644 --- a/simplify.c +++ b/simplify.c @@ -1148,6 +1148,20 @@ static int simplify_compare_constant(struct instruction *insn, long long value) insn->src2 = value_pseudo(zero_extend(value, osize)); return replace_pseudo(insn, &insn->src1, def->src); } + switch (insn->opcode) { + case OP_SET_LT: case OP_SET_LE: + if (value >= sign_bit(osize)) + return replace_with_value(insn, 1); + else + return replace_with_value(insn, 0); + break; + case OP_SET_GE: case OP_SET_GT: + if (value >= sign_bit(osize)) + return replace_with_value(insn, 0); + else + return replace_with_value(insn, 1); + break; + } break; case OP_ZEXT: osize = def->orig_type->bit_size; diff --git a/validation/optim/cmp-sext-simm.c b/validation/optim/cmp-sext-simm.c index c2099a6b8876..a8b2a8f9feff 100644 --- a/validation/optim/cmp-sext-simm.c +++ b/validation/optim/cmp-sext-simm.c @@ -23,7 +23,6 @@ static int ge_lt1(int x) { return (sext(x) >= (NEG - 1)) == 0; } /* * check-name: cmp-sext-simm * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:23 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889393 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id F213C15E6 for ; Sun, 8 Nov 2020 01:21:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D73B0208FE for ; Sun, 8 Nov 2020 01:21:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="sMRxzBCr" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726171AbgKHBVe (ORCPT ); Sat, 7 Nov 2020 20:21:34 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57866 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725838AbgKHBVe (ORCPT ); Sat, 7 Nov 2020 20:21:34 -0500 Received: from mail-ej1-x642.google.com (mail-ej1-x642.google.com [IPv6:2a00:1450:4864:20::642]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 230A6C0613CF for ; Sat, 7 Nov 2020 17:21:34 -0800 (PST) Received: by mail-ej1-x642.google.com with SMTP id i19so7243186ejx.9 for ; Sat, 07 Nov 2020 17:21:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Kco6E19mF8RD+UzZRN8K70l4NpkdlnSFh1VJKe0zGfI=; b=sMRxzBCrnG5BW1k8x2MSWvjkgbAqyfMKZLjEk1khNTqzESK2JUrzNT54vZMm1V7zKy 9pwHUfeHxpuD7QagMK1kbC7SGk5Mc6jbBpLaPKJbJafLnwUdx0QVZHBtn3YasAjfJQFT xDs4+aYIkLney9ONhucVyiJ1QokvYbdn5iNB5XM0Fqn6wQu2eD6mDcNU8+LT1W3v4v57 9e8KqNtHbaSvp1MiYpV47BJtiV5R/7x6tZaEC+HQ8rbb2JZ4jTlZbp+eBjwblXIHrDVz j7EY26ofD3/Pf95HQoDiQ5hEl1t4NbEueGBIButA0wnBx538I3SleO2CHSexujFEmiEF o3qw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Kco6E19mF8RD+UzZRN8K70l4NpkdlnSFh1VJKe0zGfI=; b=W56NDZ6ZC3BVT+YZ3XvXgOXzb18WzpcSt2T8WuyJ3MJwG8pilaSrPqZ0n91e+42A5w gtKnrOWuejba97G+rGYktw84bOVCSNrHfP+utlnWY1Qis8BgF58jd5lc8OeadIALuGDJ VhuCOw0OglM7YpPE/7LL7ieOA+7S3dMO/3pcuO98THr9daegCeB+iH3Bhf5GV5GA67wu +ceuNE631b2QFeiGDsCMWdtMGgSYxHB7vu4KnGKevqWxvpqj/P5ooG7bp4WSb9hZh+Rd MrTJIsaQ3tvkaMcX9FB3w4kNK6uJA8rZof+4uPUnOn2JtOCSZnraB7koftURAG5zekK3 W+kw== X-Gm-Message-State: AOAM531Rm4sH5ezJEr/5FHO1GXa42i/xO4GlN3A3B9sYs+Lam6aH33Jt MDxJiNGQqeaco9RYZg2Fy+7EcHRX3Y8= X-Google-Smtp-Source: ABdhPJwFaFqeSNTayGLDcHR4/JfVH/pq1X4605TKl/8Ml7/7J06qPFAezCUurtx3Hao9cZh62RWpsw== X-Received: by 2002:a17:906:2e4a:: with SMTP id r10mr4770180eji.266.1604798492633; Sat, 07 Nov 2020 17:21:32 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:32 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 13/16] cmp: canonicalize sext(x) cmpu C (with C >= SMAX) Date: Sun, 8 Nov 2020 02:21:23 +0100 Message-Id: <20201108012126.94339-4-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> <20201108012126.94339-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org A unsigned compare of a sign-extended value against a value bigger than the original SMAX is equivalent to a signed compare against 0. Canonicalize to the signed compare against 0. Note: ultimately both forms are just a test of the sign bit. Signed-off-by: Luc Van Oostenryck --- simplify.c | 12 ++++++++++++ validation/optim/cmp-sext-uimm.c | 1 - 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index a59918697762..8a8b39b81e20 100644 --- a/simplify.c +++ b/simplify.c @@ -1149,6 +1149,18 @@ static int simplify_compare_constant(struct instruction *insn, long long value) return replace_pseudo(insn, &insn->src1, def->src); } switch (insn->opcode) { + case OP_SET_BE: + if (value >= sign_bit(osize)) { + replace_binop_value(insn, OP_SET_GE, 0); + return replace_pseudo(insn, &insn->src1, def->src); + } + break; + case OP_SET_A: + if (value >= sign_bit(osize)) { + replace_binop_value(insn, OP_SET_LT, 0); + return replace_pseudo(insn, &insn->src1, def->src); + } + break; case OP_SET_LT: case OP_SET_LE: if (value >= sign_bit(osize)) return replace_with_value(insn, 1); diff --git a/validation/optim/cmp-sext-uimm.c b/validation/optim/cmp-sext-uimm.c index cc89a80694a1..05da042f5030 100644 --- a/validation/optim/cmp-sext-uimm.c +++ b/validation/optim/cmp-sext-uimm.c @@ -19,7 +19,6 @@ int sext_gtu_m3(int x) { return (sext(x) > (NEG - 3)) == (x < 0); } /* * check-name: cmp-sext-uimm * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:24 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889399 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 5ED4A1752 for ; Sun, 8 Nov 2020 01:21:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 43A4A208FE for ; Sun, 8 Nov 2020 01:21:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="oD3ZDCnk" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725838AbgKHBVi (ORCPT ); Sat, 7 Nov 2020 20:21:38 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57874 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728279AbgKHBVh (ORCPT ); Sat, 7 Nov 2020 20:21:37 -0500 Received: from mail-ej1-x643.google.com (mail-ej1-x643.google.com [IPv6:2a00:1450:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DF722C0613CF for ; Sat, 7 Nov 2020 17:21:35 -0800 (PST) Received: by mail-ej1-x643.google.com with SMTP id za3so7262359ejb.5 for ; Sat, 07 Nov 2020 17:21:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=3RPgx3xhhprRiWjOjbrYFOQd++FJ5T9LSZ8rkyhtKwY=; b=oD3ZDCnkUj566aO+1S6zPxFtu/rYHM2+pF09OCU9bb8hixIrU1DBWDrqWhsrN4FRO3 jYKUi4lu0Vz5D4mlsEQEm2uHmCFvIE9WMLfLCZaDnCHLJ9A5/BCG/WWIMTL9+GgzV36y LpFfa5pKT98Iaor6QdgWoyyeZNZKFV/+MYQ5QKqqcvd/7Wrx1TzR0R/bZAwRywMhRXRa zgbJhUSa2XFBU1osKUgcpSOz+f9xEolvL0v7UCHaqnv0xjvYHnSzhm5mN5v7Io9NgsX8 rNxfTl0Wd0aA6uhIAtBl/m7Wpb538to6shiwmrjmtcoWYXEZrVfqxtTY7TvyGOTURjB9 9HxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3RPgx3xhhprRiWjOjbrYFOQd++FJ5T9LSZ8rkyhtKwY=; b=TjKzU/tF0vEiBMfskuHzi9OfNtFj7Erlg4hPdzrnTIfdBXIZXrHY+N8AGoC+PULb8c VifW1kp8voNx4Bbb6Y+17sU8RAcm70JE/HU++x0SgT0e4twZvto5oBSt6sQIHhp5aJx6 vKmczwuyKeOjSV8jHguQsVT77kRp99esggMozk3qS2EibCJKne6sWcS3IIr9RzyfkEZ3 MFC1eRkOVviQ2qKFPDEsV+LyTCnY8HCu7UmE/8LauHkQ5dr7e2Ll5BjEA3MwBk1TEycR 2A0etB0o2aeewE4pZQaVpMaGEEL/EHb2ESr9laL6VP0enFmHYt9tC/JSe6VZumm1ehE8 gqJQ== X-Gm-Message-State: AOAM531PuA0HLzFIUlw3jXM3cKJAdE9VshNMD6Tr/Yt4HzoWhBHJOt8R twNi4XKKJ+MGrJahByHr0o/+FMlWC7Y= X-Google-Smtp-Source: ABdhPJxD5oJ7tCVZsT8+9TQ3a9hFj4FUHA2TV/9d2OmYCxe0gQKDeL46iFgacHDlsY0AhBwQvhnNYg== X-Received: by 2002:a17:906:2512:: with SMTP id i18mr9158361ejb.184.1604798493432; Sat, 07 Nov 2020 17:21:33 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:32 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 14/16] cmp: simplify zext(x) cmps C Date: Sun, 8 Nov 2020 02:21:24 +0100 Message-Id: <20201108012126.94339-5-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> <20201108012126.94339-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org A signed compare of a zero-extended value against a constant outside of the original range is statically known. Simplify to the corresponding 0/1. Signed-off-by: Luc Van Oostenryck --- simplify.c | 14 ++++++++++++++ validation/optim/cmp-zext-simm.c | 1 - 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index 8a8b39b81e20..83ae763eac72 100644 --- a/simplify.c +++ b/simplify.c @@ -1185,6 +1185,20 @@ static int simplify_compare_constant(struct instruction *insn, long long value) insn->itype = def->orig_type; return replace_pseudo(insn, &insn->src1, def->src); } + switch (insn->opcode) { + case OP_SET_LT: case OP_SET_LE: + if (sign_extend(value, def->size) > (long long)bits) + return replace_with_value(insn, 1); + else + return replace_with_value(insn, 0); + break; + case OP_SET_GE: case OP_SET_GT: + if (sign_extend(value, def->size) > (long long)bits) + return replace_with_value(insn, 0); + else + return replace_with_value(insn, 1); + break; + } break; } return changed; diff --git a/validation/optim/cmp-zext-simm.c b/validation/optim/cmp-zext-simm.c index f89f8f8baa62..dda237d7257f 100644 --- a/validation/optim/cmp-zext-simm.c +++ b/validation/optim/cmp-zext-simm.c @@ -17,7 +17,6 @@ int zext_lgt(unsigned int x) { return (ZEXT(x) > -1) == 1; } /* * check-name: cmp-zext-simm * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:25 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889397 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 2E51715E6 for ; Sun, 8 Nov 2020 01:21:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1512320B1F for ; Sun, 8 Nov 2020 01:21:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="PT5DYhxW" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727871AbgKHBVh (ORCPT ); Sat, 7 Nov 2020 20:21:37 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57876 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728276AbgKHBVh (ORCPT ); Sat, 7 Nov 2020 20:21:37 -0500 Received: from mail-ej1-x643.google.com (mail-ej1-x643.google.com [IPv6:2a00:1450:4864:20::643]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EF89CC0613D2 for ; Sat, 7 Nov 2020 17:21:35 -0800 (PST) Received: by mail-ej1-x643.google.com with SMTP id o23so7242902ejn.11 for ; Sat, 07 Nov 2020 17:21:35 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=OYcfxfP7JfsJsqCV46fPWP5tjHEZ/zqMS2OWu7QVLyU=; b=PT5DYhxWXQcVpJPfv9sZoGzRvf7ZAB8B6V5S/C6yGC/Z53+evnDpskskf7n1FT1qxE +cPD3zM00wqo2MLZUBlAZhEe7cESYF8aiAHeYAA6lpUDgHW3RS3RWp1r1TExfGEdfYaE MdJQhXgMn2yDhFIUqZ6zrC6ki9LDbhEJoTUt444QBXBbjDkWHfUTZtq+RbQ5pzuYVPVh DMdtKt/rhyO9oxmucQyEZZAyDOSehurbjJz3kq7Ge7QQygzzTAaDnlopqpJWOzP2nUg8 BxO5q40ZAd5dOt5AvzMbqsL7HqIUF38h8PBiy3o3DMLNWx6hHPsNVFYkWPalhpMwa/Qd sOgA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=OYcfxfP7JfsJsqCV46fPWP5tjHEZ/zqMS2OWu7QVLyU=; b=NL5kLauV0uhov540Y4olDbRLv6GjhkMr26OBumlDaxO+hTZ0iutlHzkImPfhgdp8sP pTYftM5zNVbkfgk0e1RQ+esmfb+Jskxwu1vk/zCSDSj+78vMVuPYS5YCdASHCSgSCIII MoCF7uRQRIupUwlOhcP7hss7HN6GJgKX2oNHqLHfOSsB8oC7KOIDUbR70krfnoNeudgo Tfa5HsPx1tQAW6mBTCgzyEi9D820EdkgBbcWJSaXzSuojlP+Pf+VNBj8BEaQ32GVzX0C E4ji3urdB/K8gZeQHUdD4phWHEHimBHPb6B733/cs9wsX89l+pnzCf68ySif8+xBEGlQ qciw== X-Gm-Message-State: AOAM530Hwj+KKC8ESgq1R094by0LXzHKXB8QUjdFQKi4lBNbQYA8D+mt DEfYJHbyfxm8tZz6TLRabtbV8MZUd8k= X-Google-Smtp-Source: ABdhPJyNo1O/aeLJ4hABtgFSnW6QjC4xzVZF1lkINUHgEwejAftMa88rjrRLcPjNXCkhZsZiAzpkeA== X-Received: by 2002:a17:906:3fc1:: with SMTP id k1mr8555550ejj.287.1604798494484; Sat, 07 Nov 2020 17:21:34 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:33 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 15/16] cmp: simplify zext(x) cmpu C Date: Sun, 8 Nov 2020 02:21:25 +0100 Message-Id: <20201108012126.94339-6-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> <20201108012126.94339-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org An unsigned compare of a zero-extended value against a constant outside of the original range is statically known. Simplify to the corresponding 0/1. Signed-off-by: Luc Van Oostenryck --- simplify.c | 4 ++++ validation/optim/cmp-zext-uimm2.c | 1 - 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/simplify.c b/simplify.c index 83ae763eac72..7538c9393b41 100644 --- a/simplify.c +++ b/simplify.c @@ -1198,6 +1198,10 @@ static int simplify_compare_constant(struct instruction *insn, long long value) else return replace_with_value(insn, 1); break; + case OP_SET_B: case OP_SET_BE: + return replace_with_value(insn, 1); + case OP_SET_AE: case OP_SET_A: + return replace_with_value(insn, 0); } break; } diff --git a/validation/optim/cmp-zext-uimm2.c b/validation/optim/cmp-zext-uimm2.c index 64f30b9a3df5..214bd96fb4ce 100644 --- a/validation/optim/cmp-zext-uimm2.c +++ b/validation/optim/cmp-zext-uimm2.c @@ -23,7 +23,6 @@ int zext_gtu_m(unsigned x) { return (zext(x) > 0x0fffffffeUL) == (x > 0xffffff /* * check-name: cmp-zext-uimm2 * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 From patchwork Sun Nov 8 01:21:26 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Luc Van Oostenryck X-Patchwork-Id: 11889395 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E3F79697 for ; Sun, 8 Nov 2020 01:21:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C7A0820885 for ; Sun, 8 Nov 2020 01:21:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="HYmG5LQU" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728531AbgKHBVh (ORCPT ); Sat, 7 Nov 2020 20:21:37 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57880 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727871AbgKHBVh (ORCPT ); Sat, 7 Nov 2020 20:21:37 -0500 Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com [IPv6:2a00:1450:4864:20::644]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 05721C0613D3 for ; Sat, 7 Nov 2020 17:21:37 -0800 (PST) Received: by mail-ej1-x644.google.com with SMTP id o21so7266511ejb.3 for ; Sat, 07 Nov 2020 17:21:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=/9J992tTLG2w4CWdNXUkzfs6Rt3w4UoHYyRE09KHFY0=; b=HYmG5LQUB3e+culG/vzQftPNAv0mYhMHHFHO7ULdbQAgyyyh0ERo6YORaZI03hrHlu crIYPJd5sQmmRYKJ23p5kEaDFY1ZNCtJ5HJ97TFRAT4aoYv36sZSvjKDCuUDnz+/mm3+ 4KEPAaB8f6wK81dgIrT6xzmVolhv9aNLwS/gdtcI+HKnMBVdSLp2st7eIUl9Il8Um7UL 9R4NUMmWv91u/akFjAd2UVOk+4//xqJZYCfG+geeVrAlv19OEzFUoCKsK90EeQrnDTOY EFIuODu+2HzHr4MC8/dydEWqU9HDDCYw/yEBxA+Hwpu5yaTMADpPMSpFhDp8Thz7BcOG AVWg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=/9J992tTLG2w4CWdNXUkzfs6Rt3w4UoHYyRE09KHFY0=; b=UOtXUgOKVymLOz0rDeaPa68h2kCgGDlqQSCOQ6Iqu+0b4K+lYG9cRiEoc7THYHbNah adGMK55nI21pfkVDtdtJ8SuowRSKyV+srXcfzZx0M4m9cU8H0WUhn6u3LXibm0ciXbEx wBItiPeJY5uYv7Pp1tBofDVyedR1qbRupYs0rjs2SuuBKTxGivvyLO6tyXvUbUIOp0BP +Ol/aNjihOM+loFRFh+ipp0swf6d5tsU0UZS+TEUaqxISuUH1iVKE/hpICcSs5uN3XMA XcmmPxx0XZh4axurNQeQqCLwAq9DSpEFQuNVtSKBKLGgqKHZfWG+SkaUtgp0fyja6vGR TwhQ== X-Gm-Message-State: AOAM530ih8o96QBZpKCi7sIUb1+X/nNeOAP/pv67X6fuHW80UYNHJrhI yZGRd1vcu334ubUndQ5lI6jS28PGejk= X-Google-Smtp-Source: ABdhPJxRMsNqpAaKmi30ikXZnF8Sz2JaHO078SvxVNy916Rr7ccY7WOLUC/qdwuQyqi0MUWV3zOwHg== X-Received: by 2002:a17:906:400c:: with SMTP id v12mr9352913ejj.387.1604798495426; Sat, 07 Nov 2020 17:21:35 -0800 (PST) Received: from localhost.localdomain ([2a02:a03f:b7fe:f700:fce6:5cb0:27db:5e8c]) by smtp.gmail.com with ESMTPSA id u25sm4511426eje.99.2020.11.07.17.21.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 07 Nov 2020 17:21:34 -0800 (PST) From: Luc Van Oostenryck To: linux-sparse@vger.kernel.org Cc: Luc Van Oostenryck Subject: [PATCH 16/16] cmp: simplify compares and sign/zero extend Date: Sun, 8 Nov 2020 02:21:26 +0100 Message-Id: <20201108012126.94339-7-luc.vanoostenryck@gmail.com> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20201108012126.94339-1-luc.vanoostenryck@gmail.com> References: <20201108011939.94252-1-luc.vanoostenryck@gmail.com> <20201108012126.94339-1-luc.vanoostenryck@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-sparse@vger.kernel.org Compare instructions with both operands sign or zero-extended from the same original size are equivalent to a compare of the original values. If the values were zero-extended, a signed compare becomes an unsigned one. Simplify away the sign/zero-extensions. Signed-off-by: Luc Van Oostenryck --- simplify.c | 52 ++++++++++++++++++++++++++------ validation/optim/cmp-sext-sext.c | 1 - validation/optim/cmp-zext-zext.c | 1 - 3 files changed, 42 insertions(+), 12 deletions(-) diff --git a/simplify.c b/simplify.c index 7538c9393b41..d56d4c89a078 100644 --- a/simplify.c +++ b/simplify.c @@ -422,6 +422,22 @@ static inline bool is_signed_constant(long long val, unsigned osize, unsigned ns return bits_extend(val, osize, 1) == bits_extend(val, nsize, 1); } +/// +// is @src generated by an instruction with the given opcode and size? +static inline pseudo_t is_same_op(pseudo_t src, int op, unsigned osize) +{ + struct instruction *def; + + if (src->type != PSEUDO_REG) + return NULL; + def = src->def; + if (def->opcode != op) + return NULL; + if (def->orig_type->bit_size != osize) + return NULL; + return def->src; +} + /// // replace the operand of an instruction // @insn: the instruction @@ -1570,6 +1586,30 @@ static int simplify_sub(struct instruction *insn) return 0; } +static int simplify_compare(struct instruction *insn) +{ + pseudo_t src1 = insn->src1; + pseudo_t src2 = insn->src2; + struct instruction *def; + unsigned int osize; + pseudo_t src; + + switch (DEF_OPCODE(def, src1)) { + case OP_SEXT: case OP_ZEXT: + osize = def->orig_type->bit_size; + if ((src = is_same_op(src2, def->opcode, osize))) { + const struct opcode_table *op = &opcode_table[insn->opcode]; + if ((def->opcode == OP_ZEXT) && (op->flags & OPF_SIGNED)) + insn->opcode = op->sign; + insn->itype = def->orig_type; + replace_pseudo(insn, &insn->src1, def->src); + return replace_pseudo(insn, &insn->src2, src); + } + break; + } + return 0; +} + static int simplify_constant_unop(struct instruction *insn) { long long val = insn->src1->value; @@ -2083,17 +2123,9 @@ int simplify_instruction(struct instruction *insn) case OP_DIVS: case OP_MODU: case OP_MODS: - case OP_SET_EQ: - case OP_SET_NE: - case OP_SET_LE: - case OP_SET_GE: - case OP_SET_LT: - case OP_SET_GT: - case OP_SET_B: - case OP_SET_A: - case OP_SET_BE: - case OP_SET_AE: break; + case OP_BINCMP ... OP_BINCMP_END: + return simplify_compare(insn); case OP_LOAD: case OP_STORE: return simplify_memop(insn); diff --git a/validation/optim/cmp-sext-sext.c b/validation/optim/cmp-sext-sext.c index ba6ed54e940c..3bd22fb738ca 100644 --- a/validation/optim/cmp-sext-sext.c +++ b/validation/optim/cmp-sext-sext.c @@ -11,7 +11,6 @@ _Bool cmpu_sext_sext(ARGS(INT32)) { return TEST(UINT64, UINT32, a, < , b); } /* * check-name: cmp-sext-sext * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1 diff --git a/validation/optim/cmp-zext-zext.c b/validation/optim/cmp-zext-zext.c index 9f188297e214..88f9078f9480 100644 --- a/validation/optim/cmp-zext-zext.c +++ b/validation/optim/cmp-zext-zext.c @@ -11,7 +11,6 @@ _Bool cmpu_zext_zext(ARGS(UINT32)) { return TEST(UINT64, UINT32, a, < , b); } /* * check-name: cmp-zext-zext * check-command: test-linearize -Wno-decl $file - * check-known-to-fail * * check-output-ignore * check-output-returns: 1