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: 25324 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-Google-Smtp-Source: ACJfBotu4eCYD6mZKw2uxUpj1a4ScEOOW/jshVZPt5tWVclnZzfgVwsltcxmIu7VmSvSAZvFIKnJ4A== 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(-) 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)