From patchwork Wed Jan 10 12:47:55 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 124094 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp5237095qgn; Wed, 10 Jan 2018 04:51:37 -0800 (PST) X-Google-Smtp-Source: ACJfBovuM1JsKH9h7F9n5l4HB9ZPTg2+Qy7Yf5ljZivjAHF1ka+aYrosQcXU1KLyiIqU2m+1v0vm X-Received: by 10.101.97.204 with SMTP id j12mr14766616pgv.266.1515588697006; Wed, 10 Jan 2018 04:51:37 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1515588697; cv=none; d=google.com; s=arc-20160816; b=NuiE1gh3nX9jPG2Qm7K+cciC9AbF1WAYdIt7+RCyhobCUBI5wirRs0i5FEnRsA4nsE vCL9Vi2WEWA1n4dZSANdSxdfoEEyf39zBtNRqB9a2u2wyix9YXW49gH3sJ/RPMrQoA0M dUvcRIrYachstzuRq8KiWmOTkQftLfc/KPc2kfNo7qIeF7jo4l2BNgd9q+uBOR09mQNI PzePzGKqVAFM1zkCaqOCoaKj8yvjNkOg2NBQCBWclG8v+DFzmlBdH4huDtQZdSS7B+2b XHS1//ipGH+u/jLNRa9TjkCsqscZ5X5CwaPxwNL2KVeIYlHG40+JepGDdExy5EwbcFLs iQGg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :delivered-to:sender:list-help:list-post:list-archive:list-subscribe :list-unsubscribe:list-id:precedence:mailing-list:dkim-signature :domainkey-signature:arc-authentication-results; bh=NnHdlpEViY3pTBtyFSudZSz5tMtcULn1+FNNzpkAnvE=; b=w0I3P833tl0QiOWE1o0lZ+1LPii/9q66hxJZWnIvl9zHBWNfN7UpaS7sIFJ1zEqn8P 85yTHZC1s10zHzmMeqIa04LnattVleGJgxcD+VyS0JMbi41dnvq2xT2KMjaawUyxonj+ VhXwPu5NXyDXgLCrceWUSiGKUtBK8ATUsOErtPotQ7+WR8buJkEN9OfRjawvxjnoiKB6 dSY5Zntfj6paHsdiJh12CcbgW9Iq54Ect35+Pxs0uIVvAvlNGTxupv04C9DPFRf7iTM6 QK4w6jsSNBJ9bx2NEtpWWZrtIlxSiWvC5HCQbQgd1d5RV7jjwTdbV4/wD9U2aBMMgdwY tPiQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=F9Xae9hR; spf=pass (google.com: domain of libc-alpha-return-89017-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=libc-alpha-return-89017-patch=linaro.org@sourceware.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id 3si7836801pla.229.2018.01.10.04.51.36 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 10 Jan 2018 04:51:36 -0800 (PST) Received-SPF: pass (google.com: domain of libc-alpha-return-89017-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=F9Xae9hR; spf=pass (google.com: domain of libc-alpha-return-89017-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=libc-alpha-return-89017-patch=linaro.org@sourceware.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; q=dns; s=default; b=MG7/P0wcldxsWD4aEwnXHEPoL3xTzNp jHtvYsUXatSb9hsJixwovi49HpDVFQgRT+ATeKs9SETzUDvyY2uVCEA9OC7XviG3 0D5Z7dYc84GbfUQudA/cwKTJv+XOIihXL5mk4fJRBBV3su63w3iqYtaqcp7nM89a fCYRBh+HH8rU= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; s=default; bh=eJ/+cIsmjy4rnIukj/pe/+8QE0k=; b=F9Xae 9hRkzBhHkSGVSpyXGgGDlMbYFMcY4sXb7BFQn01EHAapAKtWpf4RDGZcIRKu0MkO 6BQIXbMyEIPmAb7WNtYZBICLBEiuBwe3zX38mYMBpIvnqsD9mYtpo5hPeFsCI43J hHBgR8UV5WfVzhJzUziJhD4t8KjHytz22LVKGQ= Received: (qmail 826 invoked by alias); 10 Jan 2018 12:48:49 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 121927 invoked by uid 89); 10 Jan 2018 12:48:29 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-qt0-f193.google.com 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; bh=NnHdlpEViY3pTBtyFSudZSz5tMtcULn1+FNNzpkAnvE=; b=WleFyH5XoEhvUZvDHqxbDPb8tG/ii5mPGV0BOfcGoUYHXnlQMbFM9Su6ytyaymouT2 GqKexrauIP3MXbb2/AHhLzqa631SvM4kk561D5YHVDCT4iCLi3kU6/6ZZzDk/TCFXzYq ReJuqt1FDCI25xIEOQhFBNMl0hYR33d04oWq4sDqvih1YkQhqDt0zd1tBVHIepGATWM1 3Olh2dvsG1HBpx+KgUC5aHpEVnYIAVE2MqN2xCI21zEeibo+JWJ4xxxXJoBSp6464et+ vJ2OJ7U+QNUaUxnCrN4z5Ga/AljISqH7dh3FlQ5u3ZLInLeQynw3GbOJupUwXe44+feo Z1bA== X-Gm-Message-State: AKwxytcYSW912pVtXNBLw4xDuLVpARpguyaIXOSJDOYSd8VCAV9ohXUO EdkS/HVr0VDJPmfn3c7OhMV6VGbHjNw= X-Received: by 10.237.35.208 with SMTP id k16mr24447568qtc.47.1515588506089; Wed, 10 Jan 2018 04:48:26 -0800 (PST) From: Adhemerval Zanella To: libc-alpha@sourceware.org Cc: Richard Henderson Subject: [PATCH v3 11/18] string: Improve generic strcmp Date: Wed, 10 Jan 2018 10:47:55 -0200 Message-Id: <1515588482-15744-12-git-send-email-adhemerval.zanella@linaro.org> In-Reply-To: <1515588482-15744-1-git-send-email-adhemerval.zanella@linaro.org> References: <1515588482-15744-1-git-send-email-adhemerval.zanella@linaro.org> From: Richard Henderson New generic implementation tries to use word operations along with the new string-fz{b,i} functions even for inputs with different alignments (with still uses aligned access plus merge operation to get a correct word by word comparison). Checked on x86_64-linux-gnu, i686-linux-gnu, sparc64-linux-gnu, and sparcv9-linux-gnu by removing the arch-specific assembly implementation and disabling multi-arch (it covers both LE and BE for 64 and 32 bits). Richard Henderson Adhemerval Zanella * string/strcmp.c: Rewrite using memcopy.h, string-fzb.h, string-fzi.h. --- string/strcmp.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 89 insertions(+), 8 deletions(-) -- 2.7.4 diff --git a/string/strcmp.c b/string/strcmp.c index e198d19..c346ab9 100644 --- a/string/strcmp.c +++ b/string/strcmp.c @@ -16,6 +16,12 @@ . */ #include +#include +#include +#include +#include +#include +#include #undef strcmp @@ -29,19 +35,94 @@ int STRCMP (const char *p1, const char *p2) { - const unsigned char *s1 = (const unsigned char *) p1; - const unsigned char *s2 = (const unsigned char *) p2; + const op_t *x1, *x2; + op_t w1, w2; unsigned char c1, c2; + uintptr_t i, n, ofs; + int diff; - do + /* Handle the unaligned bytes of p1 first. */ + n = -(uintptr_t)p1 % sizeof(op_t); + for (i = 0; i < n; ++i) { - c1 = (unsigned char) *s1++; - c2 = (unsigned char) *s2++; - if (c1 == '\0') - return c1 - c2; + c1 = *p1++; + c2 = *p2++; + diff = c1 - c2; + if (c1 == '\0' || diff) + return diff; } - while (c1 == c2); + /* P1 is now aligned to unsigned long. P2 may or may not be. */ + x1 = (const op_t *)p1; + w1 = *x1++; + ofs = (uintptr_t)p2 % sizeof(op_t); + if (ofs == 0) + { + x2 = (const op_t *)p2; + w2 = *x2++; + /* Aligned loop. If a difference is found, exit to compare the + bytes. Else if a zero is found we have equal strings. */ + while (w1 == w2) + { + if (has_zero (w1)) + return 0; + w1 = *x1++; + w2 = *x2++; + } + } + else + { + op_t w2a, w2b; + uintptr_t sh_1, sh_2; + + x2 = (const op_t *)(p2 - ofs); + w2a = *x2++; + sh_1 = ofs * CHAR_BIT; + sh_2 = sizeof(op_t) * CHAR_BIT - sh_1; + + /* Align the first partial of P2, with 0xff for the rest of the + bytes so that we can also apply the has_zero test to see if we + have already reached EOS. If we have, then we can simply fall + through to the final comparison. */ + w2 = MERGE (w2a, sh_1, (op_t)-1, sh_2); + if (!has_zero (w2)) + { + /* Unaligned loop. The invariant is that W2B, which is "ahead" + of W1, does not contain end-of-string. Therefore it is safe + (and necessary) to read another word from each while we do + not have a difference. */ + while (1) + { + w2b = *x2++; + w2 = MERGE (w2a, sh_1, w2b, sh_2); + if (w1 != w2) + goto final_cmp; + if (has_zero (w2b)) + break; + w1 = *x1++; + w2a = w2b; + } + + /* Zero found in the second partial of P2. If we had EOS + in the aligned word, we have equality. */ + if (has_zero (w1)) + return 0; + + /* Load the final word of P1 and align the final partial of P2. */ + w1 = *x1++; + w2 = MERGE (w2b, sh_1, 0, sh_2); + } + } + + final_cmp: + for (i = 0; i < sizeof (op_t); i++) + { + c1 = extractbyte (w1, i); + c2 = extractbyte (w2, i); + if (c1 == '\0' || c1 != c2) + return c1 - c2; + } return c1 - c2; } + libc_hidden_builtin_def (strcmp)