From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7ACCDC432C0 for ; Wed, 20 Nov 2019 17:24:20 +0000 (UTC) Received: from dpdk.org (dpdk.org [92.243.14.124]) by mail.kernel.org (Postfix) with ESMTP id 207B220895 for ; Wed, 20 Nov 2019 17:24:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 207B220895 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=dev-bounces@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 8E0F82C2B; Wed, 20 Nov 2019 18:24:19 +0100 (CET) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by dpdk.org (Postfix) with ESMTP id 32FFC2B87 for ; Wed, 20 Nov 2019 18:24:17 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 20 Nov 2019 09:24:16 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.69,222,1571727600"; d="scan'208";a="200794038" Received: from silpixa00399498.ir.intel.com (HELO silpixa00399498.ger.corp.intel.com) ([10.237.223.151]) by orsmga008.jf.intel.com with ESMTP; 20 Nov 2019 09:24:14 -0800 From: Anatoly Burakov To: dev@dpdk.org Cc: Pawel Modrak , john.mcnamara@intel.com, ray.kinsella@intel.com, bruce.richardson@intel.com, thomas@monjalon.net, david.marchand@redhat.com Date: Wed, 20 Nov 2019 17:23:31 +0000 Message-Id: <623a108a040152d3fce713d8b09d0b0157ddc67e.1574270323.git.anatoly.burakov@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [dpdk-dev] [PATCH v8 04/12] buildtools: add script for updating symbols abi version X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Pawel Modrak Add a script that automatically merges all stable ABI's under one ABI section with the new version, while leaving experimental section exactly as it is. Signed-off-by: Pawel Modrak Signed-off-by: Anatoly Burakov Acked-by: Bruce Richardson --- Notes: v7: - Do not remove stable ABI if it was empty v6: - Split map file generation function in two - Do not print stable ABI if it wasn't present v3: - Add comments to regex patterns v2: - Reworked script to be pep8-compliant and more reliable buildtools/update_version_map_abi.py | 175 +++++++++++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100755 buildtools/update_version_map_abi.py diff --git a/buildtools/update_version_map_abi.py b/buildtools/update_version_map_abi.py new file mode 100755 index 0000000000..87fed54653 --- /dev/null +++ b/buildtools/update_version_map_abi.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2019 Intel Corporation + +""" +A Python program that updates and merges all available stable ABI versions into +one ABI version, while leaving experimental ABI exactly as it is. The intended +ABI version is supplied via command-line parameter. This script is to be called +from the buildtools/update_abi.sh utility. +""" + +from __future__ import print_function +import argparse +import sys +import re + + +def __parse_map_file(f_in): + # match function name, followed by semicolon, followed by EOL, optionally + # with whitespace inbetween each item + func_line_regex = re.compile(r"\s*" + r"(?P[a-zA-Z_0-9]+)" + r"\s*" + r";" + r"\s*" + r"$") + # match section name, followed by opening bracked, followed by EOL, + # optionally with whitespace inbetween each item + section_begin_regex = re.compile(r"\s*" + r"(?P[a-zA-Z0-9_\.]+)" + r"\s*" + r"{" + r"\s*" + r"$") + # match closing bracket, optionally followed by section name (for when we + # inherit from another ABI version), followed by semicolon, followed by + # EOL, optionally with whitespace inbetween each item + section_end_regex = re.compile(r"\s*" + r"}" + r"\s*" + r"(?P[a-zA-Z0-9_\.]+)?" + r"\s*" + r";" + r"\s*" + r"$") + + # for stable ABI, we don't care about which version introduced which + # function, we just flatten the list. there are dupes in certain files, so + # use a set instead of a list + stable_lines = set() + # copy experimental section as is + experimental_lines = [] + in_experimental = False + has_stable = False + + # gather all functions + for line in f_in: + # clean up the line + line = line.strip('\n').strip() + + # is this an end of section? + match = section_end_regex.match(line) + if match: + # whatever section this was, it's not active any more + in_experimental = False + continue + + # if we're in the middle of experimental section, we need to copy + # the section verbatim, so just add the line + if in_experimental: + experimental_lines += [line] + continue + + # skip empty lines + if not line: + continue + + # is this a beginning of a new section? + match = section_begin_regex.match(line) + if match: + cur_section = match.group("version") + # is it experimental? + in_experimental = cur_section == "EXPERIMENTAL" + if not in_experimental: + has_stable = True + continue + + # is this a function? + match = func_line_regex.match(line) + if match: + stable_lines.add(match.group("func")) + + return has_stable, stable_lines, experimental_lines + + +def __generate_stable_abi(f_out, abi_version, lines): + # print ABI version header + print("DPDK_{} {{".format(abi_version), file=f_out) + + # print global section if it exists + if lines: + print("\tglobal:", file=f_out) + # blank line + print(file=f_out) + + # print all stable lines, alphabetically sorted + for line in sorted(lines): + print("\t{};".format(line), file=f_out) + + # another blank line + print(file=f_out) + + # print local section + print("\tlocal: *;", file=f_out) + + # end stable version + print("};", file=f_out) + + +def __generate_experimental_abi(f_out, lines): + # start experimental section + print("EXPERIMENTAL {", file=f_out) + + # print all experimental lines as they were + for line in lines: + # don't print empty whitespace + if not line: + print("", file=f_out) + else: + print("\t{}".format(line), file=f_out) + + # end section + print("};", file=f_out) + + +def __main(): + arg_parser = argparse.ArgumentParser( + description='Merge versions in linker version script.') + + arg_parser.add_argument("map_file", type=str, + help='path to linker version script file ' + '(pattern: *version.map)') + arg_parser.add_argument("abi_version", type=str, + help='target ABI version (pattern: MAJOR.MINOR)') + + parsed = arg_parser.parse_args() + + if not parsed.map_file.endswith('version.map'): + print("Invalid input file: {}".format(parsed.map_file), + file=sys.stderr) + arg_parser.print_help() + sys.exit(1) + + if not re.match(r"\d{1,2}\.\d{1,2}", parsed.abi_version): + print("Invalid ABI version: {}".format(parsed.abi_version), + file=sys.stderr) + arg_parser.print_help() + sys.exit(1) + + with open(parsed.map_file) as f_in: + has_stable, stable_lines, experimental_lines = __parse_map_file(f_in) + + with open(parsed.map_file, 'w') as f_out: + need_newline = has_stable and experimental_lines + if has_stable: + __generate_stable_abi(f_out, parsed.abi_version, stable_lines) + if need_newline: + # separate sections with a newline + print(file=f_out) + if experimental_lines: + __generate_experimental_abi(f_out, experimental_lines) + + +if __name__ == "__main__": + __main() -- 2.17.1