From patchwork Wed Mar 1 17:30:19 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Samuelsson X-Patchwork-Id: 62994 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:5915:0:0:0:0:0 with SMTP id v21csp3764366wrd; Wed, 1 Mar 2023 09:30:50 -0800 (PST) X-Google-Smtp-Source: AK7set8IJI56INIvQFKss+PtiZdDC7eOMfbjK69SUmN9Z2uZwEe3hW3Fql+eu8KXQJbAI9A2tu05 X-Received: by 2002:a17:906:b2c7:b0:88d:d76d:8527 with SMTP id cf7-20020a170906b2c700b0088dd76d8527mr7422485ejb.47.1677691850163; Wed, 01 Mar 2023 09:30:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1677691850; cv=none; d=google.com; s=arc-20160816; b=F4DZ1oVMPOa4Kb8UdLBkDsdPoRk4eDg4BvC6iJ+04nbNIHpgKaDh3H4acs1iFr/acB Ur14PrJSR4lGWS+UBX09cRh6+475J+/zpGjCRKV8ZaJgzeVccQ9xPtqjVfTs5G85gPqu 3VV0JOlEenLSBEEvp/j9OYGmyzQ58W/QRcuO5IUjxp83k1cb5SnTEhjOS+OJ4xQVjKrJ iXQAEgRSVTgJyaYQ1EPtnoiGcw4v6uCPmoGbArh+qLYDnZZ0LwbflhsKwrkxW8gbo+C+ ufJLNBe7bWNLoUhVZTUPZzvWrMs+MqfPvCkr4iGeTgbdoLhjwpGvdu2cW0fcmvkCcZux IJ7g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:message-id:date:subject:cc :to:dmarc-filter:delivered-to:dkim-signature:dkim-filter; bh=szA5ZYmSOpTgYaBIar02sJmOqiAmrFHi88DFFuTG7J8=; b=1Jz1xxlkHJ8MA+dMsATx07Lw70+Rzp45d8x/GQ4rmHn+nfgsjlCQRC3V7Zi6eB8RU0 MBjVtLoVZHUqnwOgqyB4gASRbFn8VaHogFdN7mA2L83uvRtMXs8wwQRXubQBk3ggNmps i2hg9JqSuNVCIFCvXODhZTa60oZOiXCo8limsQNCVZJPUofguAyuzfjz8fyGCT3wOJt0 0ML5C89DE73rpAOkUi4D/o9hvDt5mWwHbvDgeyg5qs+l78Jm4pAZ2pLfH7l4mfVPZzmX 5igsvcdxK70NZ1v1OkuvUgAgGzQsCcSyQFByJpbfHQFe6uUC/XH0mNLbk/e2icpdaCtT 8/9Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=iZkjOTY5; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id e12-20020aa7d7cc000000b004bf9e2889ebsi14540eds.93.2023.03.01.09.30.50 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Mar 2023 09:30:50 -0800 (PST) Received-SPF: pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=iZkjOTY5; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id F27573858408 for ; Wed, 1 Mar 2023 17:30:48 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org F27573858408 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1677691849; bh=szA5ZYmSOpTgYaBIar02sJmOqiAmrFHi88DFFuTG7J8=; h=To:Cc:Subject:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=iZkjOTY5gVscbm3lbp7p8ejqQN2ofNwgKIOQnmhf7KSnLAXeNfey23Tn40CYt5+Ab g/TjQX/QlrKxgKTpOmNVz6R8dcecP+hP4BayV2EzNRZBJ/qxgQykhNsSDt/kOUyGNG 0rAdJQ3NHG7ifO8Kbfahy4y6juEIqoFDA1FtN360= X-Original-To: binutils@sourceware.org Delivered-To: binutils@sourceware.org Received: from emagii.se (www.emagii.com [185.133.207.17]) by sourceware.org (Postfix) with ESMTPS id D5BF23858D33 for ; Wed, 1 Mar 2023 17:30:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D5BF23858D33 Received: from valinor.ownit.se (84-55-68-216.customers.ownit.se [84.55.68.216]) by emagii.se (Postfix) with ESMTPSA id 5C84512020C; Wed, 1 Mar 2023 18:30:36 +0100 (CET) Received-SPF: pass (emagii.beebytevps.io: connection is authenticated) To: binutils@sourceware.org Cc: nickc@redhat.com, Ulf Samuelsson Subject: [PATCH v7 08/11] DIGEST: ldlang.*: add timestamp Date: Wed, 1 Mar 2023 18:30:19 +0100 Message-Id: <20230301173022.1851188-8-binutils@emagii.com> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 X-PPP-Message-ID: <167769183804.160621.10715380014455166095@localhost.localdomain> X-PPP-Vhost: emagii.com X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_FAIL, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Ulf Samuelsson via Binutils From: Ulf Samuelsson Reply-To: binutils@emagii.com Errors-To: binutils-bounces+ouuuleilei=gmail.com@sourceware.org Sender: "Binutils" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1759177473353082553?= X-GMAIL-MSGID: =?utf-8?q?1759187409402356475?= From: Ulf Samuelsson Signed-off-by: Ulf Samuelsson --- ld/ldlang.c | 8 ++++++++ ld/ldlang.h | 2 ++ 2 files changed, 10 insertions(+) diff --git a/ld/ldlang.c b/ld/ldlang.c index 295de015da9..77917027f83 100644 --- a/ld/ldlang.c +++ b/ld/ldlang.c @@ -20,6 +20,7 @@ #include "sysdep.h" #include +#include #include "bfd.h" #include "libiberty.h" #include "filenames.h" @@ -8520,6 +8521,13 @@ lang_add_string (size_t size, const char *s) free (string); } +/* Store the time of linking in the image */ +void +lang_add_timestamp (void) +{ + lang_add_data (QUAD, exp_intop ((bfd_vma) time (0))); +} + /* Create a new reloc statement. RELOC is the BFD relocation type to generate. HOWTO is the corresponding howto structure (we could look this up, but the caller has already done so). SECTION is the diff --git a/ld/ldlang.h b/ld/ldlang.h index 2300fa5b2a3..ef785ae5cad 100644 --- a/ld/ldlang.h +++ b/ld/ldlang.h @@ -649,6 +649,8 @@ extern void lang_add_data extern bfd_vma charcount(const char *s); extern void lang_add_string (size_t, const char *s); +extern void lang_add_timestamp + (void); extern void lang_add_reloc (bfd_reloc_code_real_type, reloc_howto_type *, asection *, const char *, union etree_union *); From patchwork Wed Mar 1 17:30:20 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Samuelsson X-Patchwork-Id: 62997 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:5915:0:0:0:0:0 with SMTP id v21csp3765544wrd; Wed, 1 Mar 2023 09:32:34 -0800 (PST) X-Google-Smtp-Source: AK7set83GEYAWnvFSr9Xc4rkZhwLG3ZbhOtLByO5UdLk+ps4RYP7wsofFzIR4XgS5N9/SeGTiG6B X-Received: by 2002:a17:906:af14:b0:882:cdd4:14d9 with SMTP id lx20-20020a170906af1400b00882cdd414d9mr6388292ejb.46.1677691953940; Wed, 01 Mar 2023 09:32:33 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1677691953; cv=none; d=google.com; s=arc-20160816; b=mOnmgUzWXZkvYVuqju22vfo14bz7rXz3Wt0nmVteq+1Pt5B6Hw/B6NOBaFOqyrBuRS 6vxjRC6NBngokh3pPKEm9ULjn39hRBXYnqcD2QssYueU2y0300619+0ooum3SYDRZhW5 7baHWlijs3s+PryfiwNZM5X2SW2BsPoaZz0y+7eSNFhiiJ8finTwH3/4dYKy3IvC7RoC mLPj6HcA1OpG6baURIjdm4RNsAUzJRNsYfP2s7V9Us78BadS5arGhNF/yF42TB6k7vsM P5aXmZKuK5A83euvTGrlrmF3vy1XxjKM04ie6ZnMRcppBPJnU34gyd+lK7YrBjGLN1Th k0xA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:dmarc-filter:delivered-to :dkim-signature:dkim-filter; bh=DIyGOTeqPU3a61b6DasrPuKd8uATNHZlUyv0FqV8340=; b=i2qfl8AVG1SxkWZbmIXMd2D1Q4SXOocQFbmfCPlth9jiP+HX0Dkfg5llLlE3MdQU+P 4ycecSDOWrZVIpOVEaGoja3ngTbvvn3JQkYQpy4J7UcOnOHOAaWA47deRR5ARdxyaDPb yH2Ca83MTvu9T4aG9n+gbWtXbGsx/Wbq5uMXzGJyzRbXVVsGgurs8b54CL2aiuVy1jxG /h7hhAh8qyDVwqpaG5XjLGr7kxdS13K2Ct0zHUvT8UdmvhE9tA+TddOcQfs/i6aHk9bn U6N7gu25ZSebwgBW/n39w+Pl+GJMwREmZwjbsDvS19UFHapEx4Guz1imx+nIgbN5U4Ru 8A9g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=oorNo6Xz; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id a7-20020a1709065f8700b009063dd5960asi1767477eju.122.2023.03.01.09.32.33 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Mar 2023 09:32:33 -0800 (PST) Received-SPF: pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=oorNo6Xz; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 724543851142 for ; Wed, 1 Mar 2023 17:31:55 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 724543851142 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1677691915; bh=DIyGOTeqPU3a61b6DasrPuKd8uATNHZlUyv0FqV8340=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=oorNo6XzlarLGn8e9BqIDMXqYo+bepaiHqOKwScNU8nuMWgRi1K5oTAd5MJc4ATQy k8Xk/whRKI0y3q1xC3FFgkKrsp6zlqIFVAIXbkDcQv4QUptNtnriP2u+9niMRjucyJ Z3n6VDLs8HwI8gDUVGj3qaVl6K02nVAXk7VV3IF8= X-Original-To: binutils@sourceware.org Delivered-To: binutils@sourceware.org Received: from emagii.se (www.emagii.com [185.133.207.17]) by sourceware.org (Postfix) with ESMTPS id B28B73858425 for ; Wed, 1 Mar 2023 17:30:46 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org B28B73858425 Received: from valinor.ownit.se (84-55-68-216.customers.ownit.se [84.55.68.216]) by emagii.se (Postfix) with ESMTPSA id B0E5612057F; Wed, 1 Mar 2023 18:30:41 +0100 (CET) Received-SPF: pass (emagii.beebytevps.io: connection is authenticated) To: binutils@sourceware.org Cc: nickc@redhat.com, Ulf Samuelsson Subject: [PATCH v7 09/11] DIGEST: calculation Date: Wed, 1 Mar 2023 18:30:20 +0100 Message-Id: <20230301173022.1851188-9-binutils@emagii.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230301173022.1851188-8-binutils@emagii.com> References: <20230301173022.1851188-8-binutils@emagii.com> MIME-Version: 1.0 X-PPP-Message-ID: <167769184539.160720.15651055367787714790@localhost.localdomain> X-PPP-Vhost: emagii.com X-Spam-Status: No, score=-12.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_ASCII_DIVIDERS, SPF_HELO_FAIL, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Ulf Samuelsson via Binutils From: Ulf Samuelsson Reply-To: binutils@emagii.com Errors-To: binutils-bounces+ouuuleilei=gmail.com@sourceware.org Sender: "Binutils" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1759187518500920223?= X-GMAIL-MSGID: =?utf-8?q?1759187518500920223?= From: Ulf Samuelsson Signed-off-by: Ulf Samuelsson --- ld/ldcrc32.c | 179 +++++++++++ ld/ldcrc64.c | 180 +++++++++++ ld/lddigest.c | 760 ++++++++++++++++++++++++++++++++++++++++++++++ ld/lddigest.h | 172 +++++++++++ ld/lddigest_tab.c | 147 +++++++++ ld/ldreflect.c | 99 ++++++ ld/ldreflect.h | 37 +++ 7 files changed, 1574 insertions(+) create mode 100644 ld/ldcrc32.c create mode 100644 ld/ldcrc64.c create mode 100644 ld/lddigest.c create mode 100755 ld/lddigest.h create mode 100644 ld/lddigest_tab.c create mode 100644 ld/ldreflect.c create mode 100644 ld/ldreflect.h diff --git a/ld/ldcrc32.c b/ld/ldcrc32.c new file mode 100644 index 00000000000..8b7de1d6e72 --- /dev/null +++ b/ld/ldcrc32.c @@ -0,0 +1,179 @@ +/* + * Library: ldlibcrc + * Author: Lammert Bies, Bastian Molkenthin, Ulf Samuelsson + * + * This file is licensed under the MIT License as stated below + * + * Copyright (c) 2016 Lammert Bies + * Copyright (c) 2013 Ulf Samuelsson (ulf@emagii.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#include "sysdep.h" +#include "bfd.h" +#include "lddigest.h" +#include "ldreflect.h" + +#define SHIFT(t) ((sizeof(t)-1)*8) +/* ============ CRC-32 LIBCRC functions ======================================*/ + +/* + * void _init_crc32_tab (uint32_t *crc_tab, uint32_t poly); + * + * For optimal speed, the CRC32 calculation uses a table with pre-calculated + * bit patterns which are used in the XOR operations in the program. + * _init_crc32_tab is copyright (c) 2016 Lammert Bies + */ +static void +_init_crc32_tab (uint32_t * crc_tab, uint32_t poly) +{ + uint32_t crc; + uint32_t shift = SHIFT (uint32_t); + for (uint32_t i = 0; i < 256; i++) + { + crc = i << shift; + for (uint32_t j = 0; j < 8; j++) + { + if ((crc & 0x80000000u) != 0) + { + crc = (crc << 1) ^ poly; + } + else + { + crc = crc << 1; + } + } + crc_tab[i] = crc; + } +} /* _init_crc32__tab */ + +/* + * void _init_crc32_reciprocal_tab (uint32_t *crc_tab, uint32_t poly); + * + * For optimal speed, the CRC32 calculation uses a table with pre-calculated + * bit patterns which are used in the XOR operations in the program. + * _init_crc32_reciprocal_tab is copyright (c) 2021 Bastian Molkenthin + */ +static void +_init_crc32_reciprocal_tab (uint32_t * crc_tab, uint32_t poly) +{ + uint32_t crc; + uint32_t reflected_poly = reflect32 (poly); + for (uint32_t i = 0; i < 256; i++) + { + crc = i; + for (uint32_t j = 0; j < 8; j++) + { + if (crc & 0x00000001U) + { + crc >>= 1; + crc ^= reflected_poly; + } + else + { + crc = crc >> 1; + } + } + crc_tab[i] = crc; + } +} /* _init_crc32_reciprocal_tab */ + +/* + * void init_crc32_tab( void ); + * + * For optimal speed, the CRC32 calculation uses a table with pre-calculated + * bit patterns which are used in the XOR operations in the program. + * The table can be calculated in a normal or a reciprocal version. + * init_crc64_tab is copyright (c) 2023 Ulf Samuelsson + */ +uint32_t * +init_crc32_tab (algorithm_desc_t * dsc) +{ + uint32_t *crc_tab = malloc (256 * sizeof (uint32_t)); + + if (crc_tab == NULL) + return NULL; + + if (dsc->reciprocal) + { + _init_crc32_reciprocal_tab (crc_tab, dsc->poly.d32._0); + } + else + { + _init_crc32_tab (crc_tab, dsc->poly.d32._0); + } + + return crc_tab; +} /* init_crc32_tab */ + +/* + * uint32_t calc_crc32(algorithm_desc_t *dsc, const unsigned char *input_str, size_t num_bytes); + * + * The function calc_crc32() calculates in one pass the common 32 bit CRC value for + * a byte string that is passed to the function together with a parameter + * indicating the length. + * calc_crc32 is + * copyright (c) 2016 Lammert Bies + * copyright (c) 2021 Bastian Molkenthin + * copyright (c) 2023 Ulf Samuelsson + */ +uint32_t +calc_crc32 (algorithm_desc_t * dsc, const unsigned char *input_str, + size_t num_bytes) +{ + uint32_t crc; + const unsigned char *ptr; + uint32_t index; + uint32_t *crc_tab = dsc->crc_tab; + + if ((ptr = input_str) == NULL) + return 0; + + if (crc_tab == NULL) + return 0; + + crc = dsc->initial.d32._0; + + if (dsc->reciprocal) + { + for (uint32_t i = 0; i < num_bytes; i++) + { + index = ((crc >> 0) ^ (uint32_t) * ptr++) & 0x000000FFul; + crc = (crc >> 8) ^ crc_tab[index]; + } + } + else + { + uint32_t shift = SHIFT (uint32_t); + for (uint32_t i = 0; i < num_bytes; i++) + { + const unsigned char c = *ptr++; + uint32_t rc = (uint32_t) (dsc->ireflect ? reflect8 (c) : c); + crc = (crc ^ (rc << shift)); + index = (uint32_t) (crc >> shift); + crc = (crc << 8); + crc = (crc ^ (crc_tab[index])); + } + } + crc = (dsc->oreflect ? reflect32 (crc) : crc); + crc = crc ^ dsc->xor_val.d32._0; + return crc; +} /* calc_crc32 */ diff --git a/ld/ldcrc64.c b/ld/ldcrc64.c new file mode 100644 index 00000000000..c94ff21bdcb --- /dev/null +++ b/ld/ldcrc64.c @@ -0,0 +1,180 @@ +/* + * Library: ldlibcrc + * Author: Lammert Bies, Bastian Molkenthin, Ulf Samuelsson + * + * This file is licensed under the MIT License as stated below + * + * Copyright (c) 2016 Lammert Bies + * Copyright (c) 2021 Bastian Molkenthin + * Copyright (c) 2023 Ulf Samuelsson (ulf@emagii.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#include "sysdep.h" +#include "bfd.h" +#include "lddigest.h" +#include "ldreflect.h" + +#define SHIFT(t) ((sizeof(t)-1)*8) +/* ============ CRC-64 LIBCRC functions ======================================*/ + +/* + * uint64_t *init_crc64_tab(algorithm_desc_t *dsc) ; + * + * For optimal speed, the CRC64 calculation uses a table with pre-calculated + * bit patterns which are used in the XOR operations in the program. + * init_crc64_tab is copyright (c) 2016 Lammert Bies + */ +static void +_init_crc64_tab (uint64_t * crc_tab, uint64_t poly) +{ + uint64_t crc; + uint32_t shift = SHIFT (uint64_t); + for (uint64_t i = 0; i < 256; i++) + { + crc = i << shift; + for (uint64_t j = 0; j < 8; j++) + { + if ((crc & 0x8000000000000000ull) != 0) + { + crc = (crc << 1) ^ poly; + } + else + { + crc = crc << 1; + } + } + crc_tab[i] = crc; + } +} /* _init_crc64_tab */ + +/* + * _init_crc64_reciprocal_tab (uint64_t *crc_tab, uint64_t poly); + * + * For optimal speed, the CRC64 calculation uses a table with pre-calculated + * bit patterns which are used in the XOR operations in the program. + * _init_crc64_reciprocal_tab is copyright (c) 2021 Bastian Molkenthin + */ + +static void +_init_crc64_reciprocal_tab (uint64_t * crc_tab, uint64_t poly) +{ + uint64_t crc; + uint64_t reflected_poly = reflect64 (poly); + for (uint64_t i = 0; i < 256; i++) + { + crc = i; + for (uint64_t j = 0; j < 8; j++) + { + if ((crc & 0x0000000000000001ULL) != 0) + { + crc >>= 1; + crc ^= reflected_poly; + } + else + { + crc >>= 1; + } + } + crc_tab[i] = crc; + } +} /* _init_crc64_reciprocal_tab */ + +/* + * uint64_t *init_crc64_tab(algorithm_desc_t *dsc) ; + * + * For optimal speed, the CRC64 calculation uses a table with pre-calculated + * bit patterns which are used in the XOR operations in the program. + * init_crc64_tab is copyright (c) 2023 Ulf Samuelsson + */ +uint64_t * +init_crc64_tab (algorithm_desc_t * dsc) +{ + uint64_t *crc_tab = malloc (256 * sizeof (uint64_t)); + + if (crc_tab == NULL) + return NULL; + + if (dsc->reciprocal) + { + _init_crc64_reciprocal_tab (crc_tab, dsc->poly.d64); + } + else + { + _init_crc64_tab (crc_tab, dsc->poly.d64); + } + return crc_tab; + +} /* init_crc64_tab */ + +/* + * uint64_t calc_crc64 + * (algorithm_desc_t *dsc, const unsigned char *input_str, size_t num_bytes); + * + * The function calc_crc64() calculates in one pass the 64 bit CRC value + * for a byte string that is passed to the function together with a + * parameter indicating the length. + * calc_crc64 is + * copyright (c) 2016 Lammert Bies + * copyright (c) 2021 Bastian Molkenthin + * copyright (c) 2023 Ulf Samuelsson + */ +uint64_t calc_crc64 + (algorithm_desc_t * dsc, const unsigned char *input_str, size_t num_bytes) +{ + uint64_t crc; + const unsigned char *ptr; + uint64_t *crc_tab = dsc->crc_tab; + uint64_t index; + + if ((ptr = input_str) == NULL) + return 0; + + if (crc_tab == NULL) + return 0; + + + crc = dsc->initial.d64; + if (dsc->reciprocal) + { + for (uint32_t i = 0; i < num_bytes; i++) + { + index = ((crc >> 0) ^ (uint64_t) * ptr++) & 0x00000000000000FFull; + crc = (crc >> 8) ^ crc_tab[index]; + } + } + else + { + uint32_t shift = SHIFT (uint64_t); + for (uint32_t i = 0; i < num_bytes; i++) + { + const unsigned char c = *ptr++; + uint64_t rc = (uint64_t) (dsc->ireflect ? reflect8 (c) : c); + crc = (crc ^ (rc << shift)); + index = (uint32_t) (crc >> shift); + crc = (crc << 8); + crc = (crc ^ (crc_tab[index])); + } + } + crc = (dsc->oreflect ? reflect64 (crc) : crc); + crc = crc ^ dsc->xor_val.d64; + return crc; +} /* calc_crc64 */ diff --git a/ld/lddigest.c b/ld/lddigest.c new file mode 100644 index 00000000000..1c6ddc69a58 --- /dev/null +++ b/ld/lddigest.c @@ -0,0 +1,760 @@ +/* Linker command language support. + Copyright (C) 1991-2023 Ulf Samuelsson + + This file is part of the GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +#define DEBUG_CRC 0 + +#include "sysdep.h" +#include "bfd.h" +#include "safe-ctype.h" +#include "obstack.h" +#include "bfdlink.h" +#include "ctf-api.h" + +#include "ld.h" +#include "ldmain.h" +#include "ldexp.h" +#include "ldlang.h" +#include +#include "ldlex.h" +#include "ldmisc.h" +#include "lddigest.h" + +/* CRC calculation on output section */ +asection *text_section; +unsigned char *text_contents = NULL; + +char *CRC_ADDRESS = NULL; +char *CRC_START = NULL; +char *CRC_END = NULL; +char *CRC_TABLE = NULL; + + + + + +const char *digest_section = ".text"; +const char *digest_label = "___CRC_LABEL__"; +bool digest_big_endian = false; +static bool +big_endian_host (void) +{ + union + { + uint32_t i; + char c[4]; + } e = { 0x01000000 }; + + return e.c[0]; +} + +#if 0 +static bool +swap_endian (void) +{ + if (big_endian_host ()) + { + return !link_info.big_endian; + } + else + { + return link_info.big_endian; + } +} +#endif + +/* ============ CRC-32 public functions ======================================*/ + +void +lang_add_crc32_syndrome (algorithm_desc_t * a) +{ + CRC_ADDRESS = CRC32_ADDRESS; + CRC_START = CRC32_START; + CRC_END = CRC32_END; + CRC_TABLE = CRC32_TABLE; + + lang_add_data (LONG, exp_intop (0)); /* Reserve room for the ECC value */ + a->crc_tab = init_crc32_tab (a); + if (a->crc_tab == NULL) + { + einfo (_("%F%P: can not allocate memory for CRC table: %E\n")); + return; + } +} + +static void +lang_add_crc32_table (bool big_endian) +{ + uint32_t *crc32_table = algorithm.crc_tab; /* Use a precomputed, if it exists */ + bool local_table = false; + if (crc32_table == NULL) + { /* No luck, create a table */ + crc32_table = init_crc32_tab (&algorithm); + if (crc32_table == NULL) + { + einfo (_("%F%P: can not allocate memory for CRC table: %E\n")); + return; + } + local_table = true; + } + for (bfd_vma i = 0; i < 256; i++) + { + uint32_t elem = crc32_table[i]; + if (big_endian) + { + elem = __builtin_bswap32 (elem); + } + lang_add_data (LONG, exp_intop (elem)); + } + if (local_table) + free (crc32_table); +} + +/* ============ CRC-64 public functions ======================================*/ + +void +lang_add_crc64_syndrome (algorithm_desc_t * a) +{ + CRC_ADDRESS = CRC64_ADDRESS; + CRC_START = CRC64_START; + CRC_END = CRC64_END; + CRC_TABLE = CRC64_TABLE; + lang_add_data (QUAD, exp_intop (0)); /* Reserve room for the ECC value */ + a->crc_tab = init_crc64_tab (a); + if (a->crc_tab == NULL) + { + einfo (_("%F%P: can not allocate memory for CRC table: %E\n")); + return; + } +} + +#if (DEBUG_CRC == 1) +static void +print_hash64_table (algorithm_desc_t * a) +{ + uint64_t *crc_tab = a->crc_tab; + uint32_t i; + if (crc_tab == NULL) + { + printf ("%-20ssBad Table\n", a->name); + return; + + } + + i = 0; + printf ("%03d\t", i); + printf ("0x%016lx, ", crc_tab[i + 0]); + printf ("0x%016lx, ", crc_tab[i + 1]); + printf ("0x%016lx, ", crc_tab[i + 2]); + printf ("0x%016lx\n", crc_tab[i + 3]); + printf ("\t...\n"); + i = 252; + printf ("%03d\t", i); + printf ("0x%016lx, ", crc_tab[i + 0]); + printf ("0x%016lx, ", crc_tab[i + 1]); + printf ("0x%016lx, ", crc_tab[i + 2]); + printf ("0x%016lx\n", crc_tab[i + 3]); + printf ("\n"); +} +#else +#define print_hash64_table(x) +#endif + +static void +lang_add_crc64_table (bool big_endian) +{ + bfd_vma *crc64_table = algorithm.crc_tab; /* Use a precomputed, if it exists */ + bool local_table = false; + if (crc64_table == NULL) + { /* No luck, create a table */ + crc64_table = init_crc64_tab (&algorithm); + if (crc64_table == NULL) + { + einfo (_("%F%P: can not allocate memory for CRC table: %E\n")); + return; + } + local_table = true; + } + print_hash64_table (&algorithm); + for (bfd_vma i = 0; i < 256; i++) + { + bfd_vma elem = crc64_table[i]; + if (big_endian) + { + elem = __builtin_bswap64 (elem); + } + if (link_info.big_endian) + { + elem = __builtin_bswap64 (elem); + } + + lang_add_data (QUAD, exp_intop (elem)); + } + if (local_table) + free (crc64_table); +} + +/* ============ DIGEST COMMON functions ======================================*/ + +void +lang_add_digest (bfd_vma size, + bfd_vma poly, + bfd_vma initial, + bfd_vma xor_val, + bfd_vma ireflect, bfd_vma oreflect, bfd_vma reciprocal) +{ + if (algorithm.crc_algo != no_algo) /* We only allow one CRC */ + { + einfo (_("%P:%pS: warning: Only the first CRC polynome is used\n"), + NULL); + return; + } + + algorithm.name = "CUSTOM"; + algorithm.big_endian = digest_big_endian; + if (size == 64) + { + algorithm.crc_algo = crc_algo_64; + algorithm.crc_size = size; + algorithm.poly.d64 = poly; /* Set the polynom */ + algorithm.initial.d64 = initial; /* Set seed */ + algorithm.xor_val.d64 = xor_val; /* final XOR value */ + algorithm.ireflect = ireflect; + algorithm.oreflect = oreflect; + algorithm.crc_tab = NULL; + algorithm.reciprocal = reciprocal; + algorithm.expected.d64 = 0; + + lang_add_crc64_syndrome (&algorithm); + } + else if (size == 32) + { + algorithm.crc_algo = crc_algo_32; + algorithm.crc_size = size; + algorithm.poly.d32._0 = poly; /* Set the polynom */ + algorithm.initial.d32._0 = initial; /* Set seed */ + algorithm.xor_val.d32._0 = xor_val; /* final XOR value */ + algorithm.ireflect = ireflect; + algorithm.oreflect = oreflect; + algorithm.crc_tab = NULL; + algorithm.reciprocal = reciprocal; + algorithm.expected.d32._0 = 0; + lang_add_crc32_syndrome (&algorithm); + } + else + { + einfo (_("%F%P: Illegal Size in DIGEST: %E\n")); + return; + } +} + +const char * +lang_get_label (const char *label, bool *big_endian) +{ + char *newlabel; + const char *p = &label[1]; + char c; + *big_endian = false; /* unless told otherwise */ + if (*label == '\0') + { + return "__CRC_LABEL__"; + } + for (uint32_t i = 1; *p; i++) /* ignore '.' in first character */ + { + c = *p; + if (c == '.') + { + newlabel = strndup (label, i); + p++; + if (strlen (p) == 2) + { + char c0 = *p++; + char c1 = *p; + bool be = ((c0 == 'B') || (c0 == 'b')) & + ((c1 == 'E') || (c1 == 'e')); + if (be) + { + *big_endian = true; + } + } + return newlabel; + } + else + { + p++; + } + } + return label; +} + +bool +lang_set_digest (char *digest) +{ + if (algorithm.crc_algo != no_algo) /* We only allow one CRC */ + { + einfo (_("%P:%pS: warning: Only the first CRC polynome is used\n"), + NULL); + return false; + } + + for (algo_t a = (algo_t) 0; algorithms[a].crc_algo != no_algo; a++) + { +#if (DEBUG_CRC == 1) + printf ("Comparing \"%s\" with \"%s\": ", digest, algorithms[a].name); +#endif + if (!strcmp (digest, algorithms[a].name)) + { +#if (DEBUG_CRC == 1) + printf ("OK\n"); +#endif + memcpy (&algorithm, &algorithms[a], sizeof (algorithm_desc_t)); + algorithm.big_endian = digest_big_endian; + if (algorithm.crc_size == 64) + { + lang_add_crc64_syndrome (&algorithm); + } + else if (algorithm.crc_size == 32) + { + lang_add_crc32_syndrome (&algorithm); + } + + return true; + } +#if (DEBUG_CRC == 1) + else + { + printf ("FAIL\n"); + } +#endif + } + einfo (_("%F%P: Unknown DIGEST: %E\n")); + return false; +} + +void +lang_add_digest_table (bool big_endian) +{ + if (algorithm.crc_algo == crc_algo_32) + { + lang_add_crc32_table (big_endian); + } + else if (algorithm.crc_algo == crc_algo_64) + { + lang_add_crc64_table (big_endian); + } +} + +void +lang_set_digest_section (char *section) +{ + digest_section = section; +} + +/* ============ Access functions for inserting checksum in text section=======*/ +static bool +get_text_section_contents (void) +{ + /* + * Get the '.text' section + * Is there a risk that CRC needs to be calculated on more than .text? + * We do not support that... + */ + text_section = + bfd_get_section_by_name (link_info.output_bfd, digest_section); + if (text_section == NULL) + { + einfo (_("%P:%pS: Cannot retrieve '.text' section for CRC calc\n"), + NULL); + return false; + } + + /* Get the contents of the '.text' area so we can calculate the CRC */ + if (!bfd_malloc_and_get_section (link_info.output_bfd, + text_section->output_section, + (bfd_byte **) & text_contents)) + { + einfo (_("%P:%pS: warning: '.text' section contents unavailable\n" + "CRC generation aborted\n"), NULL); + return false; + } + +#if (DEBUG_CRC == 1) + printf ("%s: [0x%08lx .. 0x%08lx]\n", + text_section->name, + text_section->lma, text_section->lma + text_section->size - 1); +#endif + return true; +} + +/* Set variable in the '.text' area */ +static bool +set_crc32_checksum (uint32_t crc, bfd_vma addr) +{ + uint32_t real_crc = crc; + if (big_endian_host ()) + { + if (algorithm.big_endian) + { + /* We are OK */ + } + else + { + real_crc = __builtin_bswap32 (crc); + } + } + else + { + if (algorithm.big_endian) + { + real_crc = __builtin_bswap32 (crc); + } + else + { + /* We are OK */ + } + } + + return (bfd_set_section_contents (link_info.output_bfd, + text_section->output_section, + &real_crc, addr, sizeof (uint32_t))); +} + +static bool +set_crc64_checksum (uint64_t crc, bfd_vma addr) +{ + uint64_t real_crc = crc; + if (big_endian_host ()) + { + if (algorithm.big_endian) + { + /* We are OK */ + } + else + { + real_crc = __builtin_bswap64 (crc); + } + } + else + { + if (algorithm.big_endian) + { + real_crc = __builtin_bswap64 (crc); + } + else + { + /* We are OK */ + } + } + /* True if OK */ + return (bfd_set_section_contents (link_info.output_bfd, + text_section->output_section, + &real_crc, addr, sizeof (uint64_t))); +} + +static bool +set_crc_checksum (bfd_vma crc, bfd_vma addr, bfd_vma size) +{ + bool status; + if (size == 64) + { + status = set_crc64_checksum (crc, addr); + } + else + { + status = set_crc32_checksum ((uint32_t) crc, addr); + } + if (!status) + { + einfo (_("%P:%pS: warning: updating CRC failed\n" + "CRC generation aborted\n"), NULL); + return false; + } + return true; +} + +static bool +symbol_lookup (char *name, bfd_vma * val) +{ + struct bfd_link_hash_entry *h; + *val = 0ull; + h = bfd_link_hash_lookup (link_info.hash, name, false, false, true); + if (h != NULL) + { + if (((h->type == bfd_link_hash_defined) || + (h->type == bfd_link_hash_defweak)) && + (h->u.def.section->output_section != NULL)) + { + *val = (h->u.def.value + + bfd_section_vma (h->u.def.section->output_section) + + h->u.def.section->output_offset); + return true; + } + } + return false; +} + +/* ============ CRC DEBUG functions ==========================================*/ + +#if (DEBUG_CRC == 1) +static void +debug_hex (char *prompt, unsigned char *section, bfd_vma address, bfd_vma sz) +{ + bfd_vma *vma_section = (bfd_vma *) section; + bfd_vma size = (sz) / sizeof (bfd_vma); + printf ("%s:\n", prompt); + for (bfd_vma i = 0; i < size; i += 8) + { + printf ("0x%08lx: 0x%016lx 0x%016lx 0x%016lx 0x%016lx\n", + address + (i * sizeof (bfd_vma)), + vma_section[i + 0], + vma_section[i + 1], vma_section[i + 2], vma_section[i + 3]); + } +} + +static void +debug_crc_header (char *prompt) +{ + debug_hex (prompt, text_contents, text_section->vma, 64); +} + +static void +debug_crc_update (bfd_vma crc, bfd_vma crc_addr) +{ + printf ("CRC [0x%016lx] update at 0x%08lx succeeded\n", crc, crc_addr); +} + +static void +debug_full_textsection (void) +{ + + /* In order to see the updated content, we have to fetch it again */ + + if (!get_text_section_contents ()) + { + debug_crc_header ("After CRC"); + debug_hex ("Full Section After CRC", + text_contents, text_section->vma, text_section->size); + free (text_contents); + } +} + + +static void +print_crc64_algorithm (algorithm_desc_t * a, const unsigned char *crc_data, + uint64_t crc) +{ + printf ("64:%-16s, data=\"%s\", ", a->name, crc_data); + printf ("poly=0x%016lx i=0x%1x xor=0x%1x .ir=%u .or=%u .rp=%u ", + a->poly.d64, + a->initial.d32._0 & 0xF, + a->xor_val.d32._0 & 0xF, a->ireflect, a->oreflect, a->reciprocal); + printf ("checksum=0x%016lx, expected=0x%016lx\n", crc, a->expected.d64); +} + +#else +#define debug_hex(p,s,a,sz) +#define debug_crc_header(p) +#define debug_crc_update(c, a) +#define debug_full_textsection() +#endif + +/* ============ CRC common functions =========================================*/ +/* + * Multiplexing function for calculating CRC with different algorithms + * 'algorithm.crc_algo' + */ +static bfd_vma +calculate_crc (const unsigned char *input_str, size_t num_bytes) +{ + if (algorithm.crc_algo == crc_algo_64) + { + if (algorithm.crc_tab != NULL) + { + return calc_crc64 (&algorithm, input_str, num_bytes); + } + } + else if (algorithm.crc_algo == crc_algo_32) + { + if (algorithm.crc_tab != NULL) + { + return calc_crc32 (&algorithm, input_str, num_bytes); + } + } + /* This should never happen */ + return 0; +} + +static bool +invalid_crc_parameters (bfd_vma crc_addr, + bfd_vma crc_area_start, bfd_vma crc_area_end) +{ + bool crc_in_section; + /* Get limits of '.text' section */ + bfd_vma text_start = text_section->lma; + bfd_vma text_end = text_section->lma + text_section->size; + + /* All three symbols must be inside the '.text' section */ + crc_in_section = + ((text_start <= crc_addr) && (crc_addr <= text_end)) && + ((text_start <= crc_area_start) && (crc_area_start <= text_end)) && + ((text_start <= crc_area_end) && (crc_area_end <= text_end)); + + if (!crc_in_section) + { + einfo (_("%P:%pS: warning: CRC area outside the '.text' section\n" + "CRC generation aborted\n"), NULL); + /* + * Maybe we should printout the text section start and end + * as well as the boundaries of the CRC check area. + */ + return true; + } + + /* + * CRC checksum must be outside the checked area + * We must check that they do not overlap in the beginning + */ + { + bool crc_valid = false; + if (crc_addr < crc_area_start) + { + if ((crc_addr + (algorithm.crc_size / 8)) <= crc_area_start) + { + crc_valid = true; + } + } + else if (crc_addr >= crc_area_end) + { + crc_valid = true; + } + if (!crc_valid) + { + einfo (_("%P:%pS: warning: CRC located inside checked area\n" + "CRC generation aborted\n"), NULL); + return true; + } + } + return false; +} + +void +lang_generate_crc (void) +{ + bfd_vma crc_addr, crc_area_start, crc_area_end; + bfd_vma crc; + bool can_do_crc; + + /* Return immediately, if CRC is not requested */ + if (algorithm.crc_algo == no_algo) + return; + + if (!get_text_section_contents ()) + { + /* Error messages inside check */ + return; + } + /* + * These symbols must be present, for CRC to be generated + * They should all have been defined in a CRC## statement + * If they are not defined, then there is an internal error. + * Should we consider using symbols which cannot be parsed by the linker? + * I.E. CRC-64 is never an identifier + */ + can_do_crc = symbol_lookup (CRC_ADDRESS, &crc_addr) && + symbol_lookup (CRC_START, &crc_area_start) && + symbol_lookup (CRC_END, &crc_area_end); + + if (!can_do_crc) + { + einfo (_("%P:%pS: Internal Error - __CRC#___ symbols not defined\n" + "CRC generation aborted\n"), NULL); + return; + } + + /* Check that the addresses make sense */ + if (invalid_crc_parameters (crc_addr, crc_area_start, crc_area_end)) + { + /* Error messages inside check */ + return; + } + + /* Calculate and set the CRC */ + { + /* + * The '.text' area does not neccessarily start at 0x00000000, + * so we have to shift the indices. + */ + bfd_vma _crc_addr = crc_addr - text_section->vma; + bfd_vma _crc_area_start = crc_area_start - text_section->vma; + bfd_vma _crc_area_end = crc_area_end - text_section->vma; + + + /* This is the CRC calculation which we worked so hard for */ + debug_crc_header ("Before CRC"); + + print_hash64_table (&algorithm); + +#if (DEBUG_CRC == 1) + crc = calculate_crc ((const unsigned char *) "123456789", 9); +#else + crc = calculate_crc (&text_contents[_crc_area_start], + _crc_area_end - _crc_area_start); +#endif + +#if (DEBUG_CRC == 1) + printf ("size = 0x%08u\n", (uint32_t) (_crc_area_end - _crc_area_start)); + printf ("start = 0x%016lx\n", _crc_area_start); + printf ("end = 0x%016lx\n", _crc_area_end); + printf ("crc = 0x%016lx\n", crc); + + print_crc64_algorithm (&algorithm, &text_contents[_crc_area_start], crc); +#endif + + /* + * The contents of the '.text' section are no longer needed. + * It is a copy of the section contents, and will therefore be stale + * after we updated the section with the CRC checksum. + * Remove it before we set the CRC checksum, to simplify the code logic. + */ + free (text_contents); + if (set_crc_checksum (crc, _crc_addr, algorithm.crc_size)) + { + debug_crc_update (crc, crc_addr); + } + } + + debug_full_textsection (); +} + +/* ============ END CRC common functions =====================================*/ + +void +lang_generate_digest (void) +{ + /* Return immediately, if CRC is not requested */ + if (algorithm.crc_algo == no_algo) + return; + + /* Handle 32/64-bit CRCs */ + if ((algorithm.crc_algo == crc_algo_32) + || (algorithm.crc_algo == crc_algo_64)) + { + lang_generate_crc (); + } +} diff --git a/ld/lddigest.h b/ld/lddigest.h new file mode 100755 index 00000000000..a1f7933ad36 --- /dev/null +++ b/ld/lddigest.h @@ -0,0 +1,172 @@ +/* + * Library: libcrc + * Author: Lammert Bies, Ulf Samuelsson + * + * This file is licensed under the MIT License as stated below + * + * Copyright (c) 2016 Lammert Bies + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#ifndef LDDIGEST_H +#define LDDIGEST_H + +#include +#include +#include +#include "bfd.h" + +#define CRC_POLY_64_ECMA 0x42F0E1EBA9EA3693ull /* Normal */ +#define CRC_POLY_64_ECMA_EXP 0x6C40DF5F0B497347ull /* CRC when testing "123456789" */ +#define CRC_POLY_64_ECMA_R 0xC96C5795D7870F42ull /* Reversed */ + +#define CRC_POLY_64_ISO 0x000000000000001Bull /* Normal */ +#define CRC_POLY_64_ISO_EXP 0xB90956C775A41001ull /* CRC when testing "123456789" */ +#define CRC_POLY_64_ISO_R 0xD800000000000000ull /* Reversed */ + +#define CRC_POLY_64_WE 0x42F0E1EBA9EA3693ull /* Normal */ +#define CRC_POLY_64_WE_EXP 0x62EC59E3F1A4F00Aull /* CRC when testing "123456789" */ + +#define CRC_POLY_64_XZ 0x42F0E1EBA9EA3693ull /* Normal */ +#define CRC_POLY_64_XZ_EXP 0x995DC9BBDF1939FAull /* CRC when testing "123456789" */ + +#define CRC_START_64 0x0000000000000000ull +#define CRC_START_64_ECMA 0x0000000000000000ull +#define CRC_START_64_WE 0xFFFFFFFFFFFFFFFFull +#define CRC_START_64_INV 0xFFFFFFFFFFFFFFFFull +#define CRC_END_64 0x0000000000000000ull +#define CRC_END_64_INV 0xFFFFFFFFFFFFFFFFull + +#define CRC_START_32 0xFFFFFFFFul +#define CRC_END_32 0xFFFFFFFFul + +#define CRC64_ADDRESS "___CRC64___" +#define CRC64_START "___CRC64_START___" +#define CRC64_END "___CRC64_END___" +#define CRC64_TABLE "___CRC64_TABLE___" + +#define CRC_POLY_32 0x04C11DB7ul /* Normal */ +#define CRC_POLY_32_R 0xEDB88320ul /* Reversed */ + +#define CRC_START_32_INV 0xFFFFFFFFul +#define CRC_END_32_INV 0xFFFFFFFFul + +#define CRC32_ADDRESS "___CRC32___" +#define CRC32_START "___CRC32_START___" +#define CRC32_END "___CRC32_END___" +#define CRC32_TABLE "___CRC32_TABLE___" + +typedef enum algorithm +{ + no_algo = 0, + sha_algo_1 = 1, + crc_algo_32 = 4, + crc_algo_64 = 8, + sha_algo_256 = 256, + sha_algo_512 +} algo_t; + +typedef struct +{ + uint8_t _0; + uint8_t _1; + uint8_t _2; + uint8_t _3; + uint8_t _4; + uint8_t _5; + uint8_t _6; + uint8_t _7; +} uint8_ut; + +typedef struct +{ + uint16_t _0; + uint16_t _1; + uint16_t _2; + uint16_t _3; +} uint16_ut; + +typedef struct +{ + uint32_t _0; + uint32_t _1; +} uint32_ut; + +typedef union +{ + uint64_t d64; + uint32_ut d32; + uint16_ut d16; + uint8_ut d8; +} int_t; + +typedef struct +{ + algo_t crc_algo; + uint32_t crc_size; + const char *name; + int_t poly; + int_t initial; + int_t xor_val; + bool ireflect; + bool oreflect; + bool reciprocal; + void *crc_tab; + int_t expected; + bool big_endian; +} algorithm_desc_t; + +extern char *CRC_ADDRESS; +extern char *CRC_START; +extern char *CRC_END; +extern char *CRC_TABLE; +extern const algorithm_desc_t algorithms[]; +extern algorithm_desc_t algorithm; + +extern const char *digest_label; +extern bool digest_big_endian; + +/* CRC-32 */ +extern uint32_t *init_crc32_tab (algorithm_desc_t * dsc); +extern uint32_t calc_crc32 + (algorithm_desc_t * dsc, const unsigned char *input_str, size_t num_bytes); +extern void lang_add_crc32_syndrome (algorithm_desc_t * a); + +/* CR-64 */ +extern bfd_vma *init_crc64_tab (algorithm_desc_t * dsc); +extern bfd_vma calc_crc64 + (algorithm_desc_t * dsc, const unsigned char *input_str, size_t num_bytes); +extern void lang_add_crc64_syndrome (algorithm_desc_t * a); + +extern void lang_add_digest (bfd_vma size, + bfd_vma poly, + bfd_vma initial, + bfd_vma xor_val, + bfd_vma ireflect, + bfd_vma oreflect, bfd_vma reciprocal); +extern bool lang_set_digest (char *digest); +extern void lang_add_digest_table (bool big_endian); +extern const char *lang_get_label (const char *label, bool *big_endian); +extern void lang_generate_crc (void); +extern void lang_generate_digest (void); +extern void lang_set_digest_section (char *section); + +#endif /* LDDIGEST_H */ diff --git a/ld/lddigest_tab.c b/ld/lddigest_tab.c new file mode 100644 index 00000000000..8752a4ed55f --- /dev/null +++ b/ld/lddigest_tab.c @@ -0,0 +1,147 @@ +/* Linker command language support. + Copyright (C) 1991-2023 Ulf Samuelsson + + This file is part of the GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +typedef enum +{ + CRC64_ECMA, + CRC64_WE, + CRC64_XZ, + CRC64_ISO, + CRC64_ISO_R, + CRC32, + MAXALGO +} poly_t; + +#include "sysdep.h" +#include "bfd.h" +#include "safe-ctype.h" +#include "obstack.h" +#include "bfdlink.h" +#include "ctf-api.h" + +#include "ld.h" +#include "ldmain.h" +#include "ldexp.h" +#include "ldlang.h" +#include +#include "ldlex.h" +#include "ldmisc.h" +#include "lddigest.h" + +const algorithm_desc_t algorithms[] = +{ + [CRC64_ECMA] = + { + crc_algo_64, 64, "CRC64-ECMA", + .poly.d64 = CRC_POLY_64_ECMA, + .initial.d64 = CRC_START_64, + .xor_val.d64 = CRC_END_64, + .ireflect = false, + .oreflect = false, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0x6c40df5f0b497347 + }, + [CRC64_WE] = + { + crc_algo_64, 64, "CRC64-WE", + .poly.d64 = CRC_POLY_64_WE, + .initial.d64 = CRC_START_64_INV, + .xor_val.d64 = CRC_END_64_INV, + .ireflect = false, + .oreflect = false, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0x62ec59e3f1a4f00a + }, + [CRC64_XZ] = + { + crc_algo_64, 64, "CRC64-XZ", + .poly.d64 = CRC_POLY_64_XZ, + .initial.d64 = CRC_START_64_INV, + .xor_val.d64 = CRC_END_64_INV, + .ireflect = true, + .oreflect = true, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0x995dc9bbdf1939fa + }, + [CRC64_ISO] = + { + crc_algo_64, 64, "CRC64-GO-ISO", + .poly.d64 = CRC_POLY_64_ISO, + .initial.d64 = CRC_START_64_INV, + .xor_val.d64 = CRC_END_64_INV, + .ireflect = true, + .oreflect = true, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0xb90956c775a41001 + }, + [CRC64_ISO_R] = + { + crc_algo_64, 64, "CRC64-GO-ISO-R", + .poly.d64 = CRC_POLY_64_ISO, + .initial.d64 = CRC_START_64_INV, + .xor_val.d64 = CRC_END_64_INV, + .ireflect = false, + .oreflect = false, + .reciprocal = true, + .crc_tab = NULL, + .expected.d64 = 0xb90956c775a41001 + }, + [CRC32] = + { + crc_algo_32, 32, "CRC32", + .poly.d32._0 = CRC_POLY_32, + .initial.d64 = CRC_START_32_INV, + .xor_val.d32._0 = CRC_END_32_INV, + .ireflect = true, + .oreflect = true, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0xCBF43926 + }, + [MAXALGO] = + { + no_algo, 0, "", + .poly.d64 = 0, + .initial.d64 = 0, + .xor_val.d64 = 0, + .ireflect = false, + .oreflect = false, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0 + } +}; + +algorithm_desc_t algorithm = +{ + no_algo, 0, "", + .poly.d64 = 0, + .initial.d64 = 0, + .xor_val.d64 = 0, + .ireflect = false, + .oreflect = false, + .reciprocal = false, + .crc_tab = NULL, + .expected.d64 = 0 +}; diff --git a/ld/ldreflect.c b/ld/ldreflect.c new file mode 100644 index 00000000000..0601e2a8c1b --- /dev/null +++ b/ld/ldreflect.c @@ -0,0 +1,99 @@ +/* Linker command language support. + Copyright (C) 1991-2023 Ulf Samuelsson + + This file is part of the GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +#include +#include +#include "ldreflect.h" + +uint8_t reflect_tab[256] = { + 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, + 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, + 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, + 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, + 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, + 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, + 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, + 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, + 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, + 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, + 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, + 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, + 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, + 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, + 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, + 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, + 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, + 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, + 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, + 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, + 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, + 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, + 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, + 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, + 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, + 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, + 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, + 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, + 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, + 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, + 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, + 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF +}; + +uint8_t +reflect8 (uint8_t val) +{ + return reflect_tab[val]; +} + +uint16_t +reflect16 (uint16_t val) +{ + uint16_t result; + result = ((uint16_t) reflect_tab[(val >> 0) & 0xFF]) << 8; + result |= ((uint16_t) reflect_tab[(val >> 8) & 0xFF]) << 0; + return result; +} + +uint32_t +reflect32 (uint32_t val) +{ + uint32_t result; + result = ((uint32_t) reflect_tab[(val >> 0) & 0xFF]) << 24; + result |= ((uint32_t) reflect_tab[(val >> 8) & 0xFF]) << 16; + result |= ((uint32_t) reflect_tab[(val >> 16) & 0xFF]) << 8; + result |= ((uint32_t) reflect_tab[(val >> 24) & 0xFF]) << 0; + return result; +} + +uint64_t +reflect64 (uint64_t val) +{ + uint64_t result; + result = ((uint64_t) reflect_tab[(val >> 0) & 0xFF]) << 56; + result |= ((uint64_t) reflect_tab[(val >> 8) & 0xFF]) << 48; + result |= ((uint64_t) reflect_tab[(val >> 16) & 0xFF]) << 40; + result |= ((uint64_t) reflect_tab[(val >> 24) & 0xFF]) << 32; + result |= ((uint64_t) reflect_tab[(val >> 32) & 0xFF]) << 24; + result |= ((uint64_t) reflect_tab[(val >> 40) & 0xFF]) << 16; + result |= ((uint64_t) reflect_tab[(val >> 48) & 0xFF]) << 8; + result |= ((uint64_t) reflect_tab[(val >> 56) & 0xFF]) << 0; + return result; +} diff --git a/ld/ldreflect.h b/ld/ldreflect.h new file mode 100644 index 00000000000..a3f834d0acc --- /dev/null +++ b/ld/ldreflect.h @@ -0,0 +1,37 @@ +/* + * File: reflect.h + * Author: Ulf Samuelsson + * + * This file is licensed under the MIT License as stated below + * + * Copyright (c) 2013 Ulf Samuelsson (ulf@emagii.com) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#ifndef REFLECT_H +#define REFLECT_H + +uint8_t reflect8 (uint8_t val); +uint16_t reflect16 (uint16_t val); +uint32_t reflect32 (uint32_t val); +uint64_t reflect64 (uint64_t val); + +#endif /* REFLECT_H */ From patchwork Wed Mar 1 17:30:21 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Samuelsson X-Patchwork-Id: 62995 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:5915:0:0:0:0:0 with SMTP id v21csp3764549wrd; Wed, 1 Mar 2023 09:31:05 -0800 (PST) X-Google-Smtp-Source: AK7set8tvCVpsO2la5d3xtsB2jCXn1JdUwlgwINi4Sh3EZmneo6b5sHg0LsRvFeVcYwgksdzzy/I X-Received: by 2002:a17:907:a588:b0:8b1:3821:1406 with SMTP id vs8-20020a170907a58800b008b138211406mr8087082ejc.45.1677691865747; Wed, 01 Mar 2023 09:31:05 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1677691865; cv=none; d=google.com; s=arc-20160816; b=SnA/Rzj/P5OKCw8Kl2kbv691Wmvz7ndWiHSw90wnI6qG+0IXdKGd164GgNojr8Yysc apuhSSkkDd1hbGynysE8jOu7tDSZIbfiLSaYmIRW16l9BOCmkFIYTzc7wzfwaxpAUamd MlEBHffKDOjRhIQyT0d+otVOTPCUr+gylKRPWYU2pUXN0sBZwaYuP4Sg8PdzPKVZ9v/w i/LygiOUqJXQn3MLyzQz+hmd1axtQkv2stBkSKDW4HqejqlX7zfhRPM5ZcUH2XcmOFWS nYc+j6+TRa5cMktMAGDqnyOLDNXtugKfoHf1dHzCtK38iuxlhNqlVHyGfsmtJ7wKhHA6 Na7g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:dmarc-filter:delivered-to :dkim-signature:dkim-filter; bh=iyRN3BsloscJ78H0jNyrPMgq8RPEKSr1uyUstNbFsSU=; b=M9jzNrWJIn5W1Qe/k0wFnbAmHbDIVDLdoisTOUs/CRp+CyaX57lqE+G/xBBrr2K2AD t1OlpiDOMKVEmcThtdA/sdDnJNFYxJO5MWQBGBGd3JY5Y/3efNApu8cHMIM2IJd/3/Nh JJemcSFZNxKv+wccFj7VME6GLMeXXLgGTPXvkoEXgQxJaJ/Cb5zOno5pZrLD8q/env9t pwS4PXsVDAbRMS415kS5lbwA8Z0Co50TLbI17GNy6dpysJ8czScGE1aj6/ZnrIuy0ZaR p3Rwn8kgXXCvyr7iPvHDA5vBNNyCIndclGcaiBGfctNVcYfT+WjRAi9baJFywi4FDSLA mdpw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=PTnQeD3N; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id ci24-20020a170906c35800b008b17ed96947si3303527ejb.922.2023.03.01.09.31.05 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Mar 2023 09:31:05 -0800 (PST) Received-SPF: pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=PTnQeD3N; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5EB9E3858430 for ; Wed, 1 Mar 2023 17:31:04 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5EB9E3858430 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1677691864; bh=iyRN3BsloscJ78H0jNyrPMgq8RPEKSr1uyUstNbFsSU=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=PTnQeD3N+iVOio0x8Kf2xe3OYFHbULPS6C3dOMIf3dcS9BBWbXb+9sS3cscM/2H4l BZVda037eX5+xKr7DWrhop5Y3LsB5Q2OlHuliI8mAO4/KsXdlrTdS53VeH9mV1tiqe PHJvTvrgno9h6S1xNwv1qjyv2FOD0MFXLP7TWh70= X-Original-To: binutils@sourceware.org Delivered-To: binutils@sourceware.org Received: from emagii.se (www.emagii.com [185.133.207.17]) by sourceware.org (Postfix) with ESMTPS id 4FD9A3858408 for ; Wed, 1 Mar 2023 17:30:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 4FD9A3858408 Received: from valinor.ownit.se (84-55-68-216.customers.ownit.se [84.55.68.216]) by emagii.se (Postfix) with ESMTPSA id D8ECB12057B; Wed, 1 Mar 2023 18:30:47 +0100 (CET) Received-SPF: pass (emagii.beebytevps.io: connection is authenticated) To: binutils@sourceware.org Cc: nickc@redhat.com, Ulf Samuelsson Subject: [PATCH v7 10/11] DIGEST: Makefile.* Date: Wed, 1 Mar 2023 18:30:21 +0100 Message-Id: <20230301173022.1851188-10-binutils@emagii.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230301173022.1851188-8-binutils@emagii.com> References: <20230301173022.1851188-8-binutils@emagii.com> MIME-Version: 1.0 X-PPP-Message-ID: <167769185201.160822.18032470611900640305@localhost.localdomain> X-PPP-Vhost: emagii.com X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_FAIL, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Ulf Samuelsson via Binutils From: Ulf Samuelsson Reply-To: binutils@emagii.com Errors-To: binutils-bounces+ouuuleilei=gmail.com@sourceware.org Sender: "Binutils" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1759187426103188840?= X-GMAIL-MSGID: =?utf-8?q?1759187426103188840?= From: Ulf Samuelsson The Makefile.in was generated using automake after adding a few files. When adding the ldreflect.* files, the autotools versions were wrong. After upgrading the host OS, autotools were upgraded to 2.71 reinstalling the desired 2.69 still generates a lot of changes. Makefile.ini has therefore been manually edited. Signed-off-by: Ulf Samuelsson --- ld/Makefile.am | 5 +++++ ld/Makefile.in | 13 +++++++++++++ 2 files changed, 18 insertions(+) diff --git a/ld/Makefile.am b/ld/Makefile.am index 760225c5b88..813f19b354a 100644 --- a/ld/Makefile.am +++ b/ld/Makefile.am @@ -479,12 +479,14 @@ CFILES = ldctor.c ldemul.c ldexp.c ldfile.c ldlang.c \ ldmain.c ldmisc.c ldver.c ldwrite.c lexsup.c \ mri.c ldcref.c pe-dll.c pep-dll.c ldlex-wrapper.c \ plugin.c ldbuildid.c ldelf.c ldelfgen.c \ + lddigest.c lddigest_tab.c ldcrc32.c ldcrc64.c ldreflect.c \ pdb.c HFILES = ld.h ldctor.h ldemul.h ldexp.h ldfile.h \ ldlang.h ldlex.h ldmain.h ldmisc.h ldver.h \ ldwrite.h mri.h deffile.h pe-dll.h pep-dll.h \ elf-hints-local.h plugin.h ldbuildid.h ldelf.h ldelfgen.h \ + lddigest.h ldreflect.h \ pdb.h GENERATED_CFILES = ldgram.c ldlex.c deffilep.c @@ -495,6 +497,8 @@ GENERATED_HFILES = ldgram.h ldemul-list.h deffilep.h BUILT_SOURCES = $(GENERATED_HFILES) OFILES = ldgram.@OBJEXT@ ldlex-wrapper.@OBJEXT@ lexsup.@OBJEXT@ ldlang.@OBJEXT@ \ + lddigest.@OBJEXT@ lddigest_tab.@OBJEXT@ \ + ldcrc32.@OBJEXT@ ldcrc64.@OBJEXT@ ldreflect.@OBJEXT@ \ mri.@OBJEXT@ ldctor.@OBJEXT@ ldmain.@OBJEXT@ plugin.@OBJEXT@ \ ldwrite.@OBJEXT@ ldexp.@OBJEXT@ ldemul.@OBJEXT@ ldver.@OBJEXT@ ldmisc.@OBJEXT@ \ ldfile.@OBJEXT@ ldcref.@OBJEXT@ ${EMULATION_OFILES} ${EMUL_EXTRA_OFILES} \ @@ -962,6 +966,7 @@ EXTRA_ld_new_SOURCES = deffilep.y ldlex.l EXTRA_ld_new_SOURCES += ldelf.c ldelfgen.c pdb.c pep-dll.c pe-dll.c ld_new_SOURCES = ldgram.y ldlex-wrapper.c lexsup.c ldlang.c mri.c ldctor.c ldmain.c \ + lddigest.c lddigest_tab.c ldcrc32.c ldcrc64.c ldreflect.c \ ldwrite.c ldexp.c ldemul.c ldver.c ldmisc.c ldfile.c ldcref.c plugin.c \ ldbuildid.c ld_new_DEPENDENCIES = $(EMULATION_OFILES) $(EMUL_EXTRA_OFILES) \ diff --git a/ld/Makefile.in b/ld/Makefile.in index d4dddf2f629..6ec916aa629 100644 --- a/ld/Makefile.in +++ b/ld/Makefile.in @@ -210,6 +210,8 @@ PROGRAMS = $(bin_PROGRAMS) am_ld_new_OBJECTS = ldgram.$(OBJEXT) ldlex-wrapper.$(OBJEXT) \ lexsup.$(OBJEXT) ldlang.$(OBJEXT) mri.$(OBJEXT) \ ldctor.$(OBJEXT) ldmain.$(OBJEXT) ldwrite.$(OBJEXT) \ + lddigest.$(OBJEXT) lddigest_tab.$(OBJEXT) \ + ldcrc32.$(OBJEXT) ldcrc64.$(OBJEXT) ldreflect.$(OBJEXT) \ ldexp.$(OBJEXT) ldemul.$(OBJEXT) ldver.$(OBJEXT) \ ldmisc.$(OBJEXT) ldfile.$(OBJEXT) ldcref.$(OBJEXT) \ plugin.$(OBJEXT) ldbuildid.$(OBJEXT) @@ -533,6 +535,7 @@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ +runstatedir = @runstatedir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ @@ -978,12 +981,14 @@ CFILES = ldctor.c ldemul.c ldexp.c ldfile.c ldlang.c \ ldmain.c ldmisc.c ldver.c ldwrite.c lexsup.c \ mri.c ldcref.c pe-dll.c pep-dll.c ldlex-wrapper.c \ plugin.c ldbuildid.c ldelf.c ldelfgen.c \ + lddigest.c lddigest_tab.c ldcrc32.c ldcrc64.c ldreflect.c \ pdb.c HFILES = ld.h ldctor.h ldemul.h ldexp.h ldfile.h \ ldlang.h ldlex.h ldmain.h ldmisc.h ldver.h \ ldwrite.h mri.h deffile.h pe-dll.h pep-dll.h \ elf-hints-local.h plugin.h ldbuildid.h ldelf.h ldelfgen.h \ + lddigest.h ldreflect.h \ pdb.h GENERATED_CFILES = ldgram.c ldlex.c deffilep.c @@ -993,6 +998,8 @@ GENERATED_HFILES = ldgram.h ldemul-list.h deffilep.h # tracking will not cause them to be built beforehand. BUILT_SOURCES = $(GENERATED_HFILES) OFILES = ldgram.@OBJEXT@ ldlex-wrapper.@OBJEXT@ lexsup.@OBJEXT@ ldlang.@OBJEXT@ \ + lddigest.@OBJEXT@ lddigest_tab.@OBJEXT@ \ + ldcrc32.@OBJEXT@ ldcrc64.@OBJEXT@ ldreflect.@OBJEXT@ \ mri.@OBJEXT@ ldctor.@OBJEXT@ ldmain.@OBJEXT@ plugin.@OBJEXT@ \ ldwrite.@OBJEXT@ ldexp.@OBJEXT@ ldemul.@OBJEXT@ ldver.@OBJEXT@ ldmisc.@OBJEXT@ \ ldfile.@OBJEXT@ ldcref.@OBJEXT@ ${EMULATION_OFILES} ${EMUL_EXTRA_OFILES} \ @@ -1014,6 +1021,7 @@ EXTRA_ld_new_SOURCES = deffilep.y ldlex.l ldelf.c ldelfgen.c pdb.c \ pep-dll.c pe-dll.c $(ALL_EMULATION_SOURCES) \ $(ALL_64_EMULATION_SOURCES) ld_new_SOURCES = ldgram.y ldlex-wrapper.c lexsup.c ldlang.c mri.c ldctor.c ldmain.c \ + lddigest.c lddigest_tab.c ldcrc32.c ldcrc64.c ldreflect.c \ ldwrite.c ldexp.c ldemul.c ldver.c ldmisc.c ldfile.c ldcref.c plugin.c \ ldbuildid.c @@ -1560,8 +1568,12 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ez8001.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ez8002.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldbuildid.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldcrc32.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldcrc64.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldcref.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldctor.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lddigest.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lddigest_tab.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldelf.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldelfgen.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldemul.Po@am__quote@ @@ -1573,6 +1585,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldlex.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldmain.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldmisc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldreflect.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldver.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ldwrite.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lexsup.Po@am__quote@ From patchwork Wed Mar 1 17:30:22 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ulf Samuelsson X-Patchwork-Id: 62996 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:5915:0:0:0:0:0 with SMTP id v21csp3764654wrd; Wed, 1 Mar 2023 09:31:16 -0800 (PST) X-Google-Smtp-Source: AK7set/Rc0JbwiEiO7/PisePKleiNyLJRjBLnBDS45a3fQmI5IqFwhqzmwW80qqYokijkWlfZR6M X-Received: by 2002:a17:907:b15:b0:8aa:bf48:aae1 with SMTP id h21-20020a1709070b1500b008aabf48aae1mr8320548ejl.6.1677691876132; Wed, 01 Mar 2023 09:31:16 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1677691876; cv=none; d=google.com; s=arc-20160816; b=qQEOvcH7IKeHYeFeqAmrOzB9BR521jH0/oSh2Oc2WTAODXnGlgqJsyPxk+RS3HOSZF Aac3RLJN3MUQ4fQ+lEBweyv2YPSQ0tEmF95rPEfUa5PR6210Bbipt66HE72a3F/Xvkg6 MuW4fOFHHMea9Md6+Hl8kkvvAGVx5G9KvHHPzLZPGF1UEPj3jaqjawh36EzPrsz2aR2X k96HiMtrNk6swG3P4RZjyp+jKigvPrnHszw+6Tw60WZyI+BERb5WvT6PvSriHMJ21b64 8LlSd1XdIfSSZW+jBCr1+nLNq5xRQFTcGGnSdiGiSSgGudkEjMZkewgISRGjauKxFtrJ cu2A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:dmarc-filter:delivered-to :dkim-signature:dkim-filter; bh=F+tCKpBXReWbPfToaFOi04plpYzPv6/8y/QyXmOM2BQ=; b=VmjfCf5bMcPvYhJrCO6vuOwYlJ/1iTqosmoMgcp/kFyFE2mUzte/1GLBA0OF/maqpg levkk+Nurg6wkObDX/MWOLQ3ONbhwCFuyMlESmnr2/isQ/XzPSL0T8OT7HK3dsrCG0sZ SWctZMTjzs4jFB9oNNQFisVTPo7yPADDwdLJzuwNapEJmCWIeguz9Mdwrd+rfFxGBJkj 1zZw23T2iNYDwseqlkdsTWRpcbJIgpiYBoXwPuL3y10fdBPJISyO4wH2TQBDC+6ZgFPs WatlcoDpzreU0m0Ckc7Ob37yPPTuSz2pszwwWULyA095BjcSL4BmYE/mS/bIAdd+zkLQ n9JA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=PcpgVeGH; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id u24-20020a17090617d800b008e20382c9bcsi6112706eje.439.2023.03.01.09.31.15 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 01 Mar 2023 09:31:16 -0800 (PST) Received-SPF: pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=PcpgVeGH; spf=pass (google.com: domain of binutils-bounces+ouuuleilei=gmail.com@sourceware.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="binutils-bounces+ouuuleilei=gmail.com@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5218C3857B98 for ; Wed, 1 Mar 2023 17:31:11 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5218C3857B98 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1677691871; bh=F+tCKpBXReWbPfToaFOi04plpYzPv6/8y/QyXmOM2BQ=; h=To:Cc:Subject:Date:In-Reply-To:References:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=PcpgVeGHplz5B7bXgBDhudjGEugggthDfF/CgRnSi8teMpnQkZ4BJWOh45gVm7wQs u4MhiX3oZhVUQpCHV/YzVgTKH5lOHX3fXVYAY2OPvqBD/h5EUBur1awX2SOaA85I6x 9ozRh2kWL86rV3MVWEx4C3UyiIaxIEL/vbMQ5TLw= X-Original-To: binutils@sourceware.org Delivered-To: binutils@sourceware.org Received: from emagii.se (www.emagii.com [185.133.207.17]) by sourceware.org (Postfix) with ESMTPS id 054553858C39 for ; Wed, 1 Mar 2023 17:31:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 054553858C39 Received: from valinor.ownit.se (84-55-68-216.customers.ownit.se [84.55.68.216]) by emagii.se (Postfix) with ESMTPSA id 3A3E0120194; Wed, 1 Mar 2023 18:30:55 +0100 (CET) Received-SPF: pass (emagii.beebytevps.io: connection is authenticated) To: binutils@sourceware.org Cc: nickc@redhat.com, Ulf Samuelsson Subject: [PATCH v7 11/11] Build ldint Date: Wed, 1 Mar 2023 18:30:22 +0100 Message-Id: <20230301173022.1851188-11-binutils@emagii.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230301173022.1851188-8-binutils@emagii.com> References: <20230301173022.1851188-8-binutils@emagii.com> MIME-Version: 1.0 X-PPP-Message-ID: <167769185942.160938.8929784582862969715@localhost.localdomain> X-PPP-Vhost: emagii.com X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_FAIL, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: binutils@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Binutils mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Ulf Samuelsson via Binutils From: Ulf Samuelsson Reply-To: binutils@emagii.com Errors-To: binutils-bounces+ouuuleilei=gmail.com@sourceware.org Sender: "Binutils" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1759187436402500527?= X-GMAIL-MSGID: =?utf-8?q?1759187436402500527?= From: Ulf Samuelsson Signed-off-by: Ulf Samuelsson --- ld/Makefile.am | 16 +++++++++++++-- ld/Makefile.in | 53 ++++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 61 insertions(+), 8 deletions(-) diff --git a/ld/Makefile.am b/ld/Makefile.am index 813f19b354a..00118f8da13 100644 --- a/ld/Makefile.am +++ b/ld/Makefile.am @@ -128,7 +128,7 @@ CXXFLAGS_FOR_TARGET = `echo $(CXXFLAGS) | sed -e 's/-fsanitize=[^ ]*//g'` transform = s/^ld-new$$/$(installed_linker)/;@program_transform_name@ bin_PROGRAMS = ld-new -info_TEXINFOS = ld.texi +info_TEXINFOS = ld.texi ldint.texi ld_TEXINFOS = configdoc.texi noinst_TEXINFOS = ldint.texi man_MANS = ld.1 @@ -1060,7 +1060,19 @@ ld.1: $(srcdir)/ld.texi configdoc.texi (rm -f $@.T$$$$ && exit 1) $(AM_V_at)rm -f ld.pod -MAINTAINERCLEANFILES = configdoc.texi ld.1 +# Build the man page from the texinfo file +# The sed command removes the no-adjust Nroff command so that +# the man output looks standard. +ldint.1: $(srcdir)/ldint.texi configdoc.texi + $(AM_V_GEN)touch $@ + $(AM_V_at)-$(TEXI2POD) $(MANCONF) < $(srcdir)/ldint.texi > ldint.pod + $(AM_V_at)-($(POD2MAN) ldint.pod | \ + sed -e '/^.if n .na/d' > $@.T$$$$ && \ + mv -f $@.T$$$$ $@) || \ + (rm -f $@.T$$$$ && exit 1) + $(AM_V_at)rm -f ldint.pod + +MAINTAINERCLEANFILES = configdoc.texi ld.1 ldint.1 # We want to reconfigure if configure.host or configure.tgt changes. # development.sh is used to determine -Werror default. diff --git a/ld/Makefile.in b/ld/Makefile.in index 6ec916aa629..7bf51bffa54 100644 --- a/ld/Makefile.in +++ b/ld/Makefile.in @@ -305,11 +305,11 @@ am__v_texidevnull_0 = > /dev/null am__v_texidevnull_1 = INFO_DEPS = ld.info am__TEXINFO_TEX_DIR = $(srcdir)/../texinfo -DVIS = ld.dvi -PDFS = ld.pdf -PSS = ld.ps -HTMLS = ld.html -TEXINFOS = ld.texi +DVIS = ld.dvi ldint.dvi +PDFS = ld.pdf ldint.pdf +PSS = ld.ps ldint.ps +HTMLS = ld.html ldint.html +TEXINFOS = ld.texi ldint.texi TEXI2PDF = $(TEXI2DVI) --pdf --batch MAKEINFOHTML = $(MAKEINFO) --html AM_MAKEINFOHTMLFLAGS = $(AM_MAKEINFOFLAGS) @@ -1682,18 +1682,48 @@ ld.info: ld.texi $(ld_TEXINFOS) fi; \ rm -rf $$backupdir; exit $$rc +ldint.info: ld.texi $(ld_TEXINFOS) + $(AM_V_MAKEINFO)restore=: && backupdir="$(am__leading_dot)am$$$$" && \ + rm -rf $$backupdir && mkdir $$backupdir && \ + if ($(MAKEINFO) --version) >/dev/null 2>&1; then \ + for f in $@ $@-[0-9] $@-[0-9][0-9] $(@:.info=).i[0-9] $(@:.info=).i[0-9][0-9]; do \ + if test -f $$f; then mv $$f $$backupdir; restore=mv; else :; fi; \ + done; \ + else :; fi && \ + if $(MAKEINFO) $(AM_MAKEINFOFLAGS) $(MAKEINFOFLAGS) -I $(srcdir) \ + -o $@ `test -f 'ldint.texi' || echo '$(srcdir)/'`ldint.texi; \ + then \ + rc=0; \ + else \ + rc=$$?; \ + $$restore $$backupdir/* `echo "./$@" | sed 's|[^/]*$$||'`; \ + fi; \ + rm -rf $$backupdir; exit $$rc + ld.dvi: ld.texi $(ld_TEXINFOS) $(AM_V_TEXI2DVI)TEXINPUTS="$(am__TEXINFO_TEX_DIR)$(PATH_SEPARATOR)$$TEXINPUTS" \ MAKEINFO='$(MAKEINFO) $(AM_MAKEINFOFLAGS) $(MAKEINFOFLAGS) -I $(srcdir)' \ $(TEXI2DVI) $(AM_V_texinfo) --build-dir=$(@:.dvi=.t2d) -o $@ $(AM_V_texidevnull) \ `test -f 'ld.texi' || echo '$(srcdir)/'`ld.texi -ld.pdf: ld.texi $(ld_TEXINFOS) +ldint.dvi: ldint.texi $(ld_TEXINFOS) + $(AM_V_TEXI2DVI)TEXINPUTS="$(am__TEXINFO_TEX_DIR)$(PATH_SEPARATOR)$$TEXINPUTS" \ + MAKEINFO='$(MAKEINFO) $(AM_MAKEINFOFLAGS) $(MAKEINFOFLAGS) -I $(srcdir)' \ + $(TEXI2DVI) $(AM_V_texinfo) --build-dir=$(@:.dvi=.t2d) -o $@ $(AM_V_texidevnull) \ + `test -f 'ldint.texi' || echo '$(srcdir)/'`ldint.texi + +ld.pdf: ld.texi $(ld_TEXINFOS) $(AM_V_TEXI2PDF)TEXINPUTS="$(am__TEXINFO_TEX_DIR)$(PATH_SEPARATOR)$$TEXINPUTS" \ MAKEINFO='$(MAKEINFO) $(AM_MAKEINFOFLAGS) $(MAKEINFOFLAGS) -I $(srcdir)' \ $(TEXI2PDF) $(AM_V_texinfo) --build-dir=$(@:.pdf=.t2p) -o $@ $(AM_V_texidevnull) \ `test -f 'ld.texi' || echo '$(srcdir)/'`ld.texi +ldint.pdf: ldint.texi $(ld_TEXINFOS) + $(AM_V_TEXI2PDF)TEXINPUTS="$(am__TEXINFO_TEX_DIR)$(PATH_SEPARATOR)$$TEXINPUTS" \ + MAKEINFO='$(MAKEINFO) $(AM_MAKEINFOFLAGS) $(MAKEINFOFLAGS) -I $(srcdir)' \ + $(TEXI2PDF) $(AM_V_texinfo) --build-dir=$(@:.pdf=.t2p) -o $@ $(AM_V_texidevnull) \ + `test -f 'ldint.texi' || echo '$(srcdir)/'`ldint.texi + ld.html: ld.texi $(ld_TEXINFOS) $(AM_V_MAKEINFO)rm -rf $(@:.html=.htp) $(AM_V_at)if $(MAKEINFOHTML) $(AM_MAKEINFOHTMLFLAGS) $(MAKEINFOFLAGS) -I $(srcdir) \ @@ -1703,6 +1733,17 @@ ld.html: ld.texi $(ld_TEXINFOS) else \ rm -rf $(@:.html=.htp); exit 1; \ fi + +ldint.html: ldint.texi $(ld_TEXINFOS) + $(AM_V_MAKEINFO)rm -rf $(@:.html=.htp) + $(AM_V_at)if $(MAKEINFOHTML) $(AM_MAKEINFOHTMLFLAGS) $(MAKEINFOFLAGS) -I $(srcdir) \ + -o $(@:.html=.htp) `test -f 'ldint.texi' || echo '$(srcdir)/'`ldint.texi; \ + then \ + rm -rf $@ && mv $(@:.html=.htp) $@; \ + else \ + rm -rf $(@:.html=.htp); exit 1; \ + fi + .dvi.ps: $(AM_V_DVIPS)TEXINPUTS="$(am__TEXINFO_TEX_DIR)$(PATH_SEPARATOR)$$TEXINPUTS" \ $(DVIPS) $(AM_V_texinfo) -o $@ $<