[llvm] 12ba7f2 - [Release] Add bump-version script.
Tobias Hieta via llvm-commits
llvm-commits at lists.llvm.org
Tue Sep 27 23:41:38 PDT 2022
Author: Tobias Hieta
Date: 2022-09-28T08:41:29+02:00
New Revision: 12ba7f27b88ec554f569ccd8f719747562132b1c
URL: https://github.com/llvm/llvm-project/commit/12ba7f27b88ec554f569ccd8f719747562132b1c
DIFF: https://github.com/llvm/llvm-project/commit/12ba7f27b88ec554f569ccd8f719747562132b1c.diff
LOG: [Release] Add bump-version script.
There are many files that needs to be updated when you
bump the version of LLVM. This script tries to automate
that in order to make the release managers job easier.
Reviewed By: kwk, hans, ldionne
Differential Revision: https://reviews.llvm.org/D133923
Added:
llvm/utils/release/bump-version.py
Modified:
Removed:
################################################################################
diff --git a/llvm/utils/release/bump-version.py b/llvm/utils/release/bump-version.py
new file mode 100755
index 000000000000..9d30c4ba8f37
--- /dev/null
+++ b/llvm/utils/release/bump-version.py
@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+
+# This script bumps the version of LLVM in *all* the
diff erent places where
+# it needs to be defined. Which is quite a few.
+
+import sys
+import argparse
+import packaging.version
+from pathlib import Path
+import re
+from typing import Optional
+
+
+class Processor:
+ def process_line(self, line: str) -> str:
+ raise NotImplementedError()
+
+ def process_file(self, fpath: Path, version: packaging.version.Version) -> None:
+ self.version = version
+ self.major, self.minor, self.patch, self.suffix = (
+ version.major,
+ version.minor,
+ version.micro,
+ version.pre,
+ )
+ data = fpath.read_text()
+ new_data = []
+
+ for line in data.splitlines(True):
+ nline = self.process_line(line)
+
+ # Print the failing line just to inform the user.
+ if nline != line:
+ print(f"{fpath.name}: {line.strip()} -> {nline.strip()}")
+
+ new_data.append(nline)
+
+ fpath.write_text("".join(new_data), newline="\n")
+
+ # Return a string from the version class
+ # optionally include the suffix (-rcX)
+ def version_str(
+ self,
+ version: Optional[packaging.version.Version] = None,
+ include_suffix: bool = True,
+ ) -> str:
+ if version is None:
+ version = self.version
+
+ ver = f"{version.major}.{version.minor}.{version.micro}"
+ if include_suffix and version.pre:
+ ver += f"-{version.pre[0]}{version.pre[1]}"
+ return ver
+
+
+# llvm/CMakeLists.txt
+class CMakeProcessor(Processor):
+ def process_line(self, line: str) -> str:
+ nline = line
+
+ # LLVM_VERSION_SUFFIX should be set to -rcX or be blank if we are
+ # building a final version.
+ if "set(LLVM_VERSION_SUFFIX" in line:
+ if self.suffix:
+ nline = re.sub(
+ r"set\(LLVM_VERSION_SUFFIX(.*)\)",
+ f"set(LLVM_VERSION_SUFFIX -{self.suffix[0]}{self.suffix[1]})",
+ line,
+ )
+ else:
+ nline = re.sub(r"set\(LLVM_VERSION_SUFFIX(.*)\)", f"set(LLVM_VERSION_SUFFIX)", line)
+
+ # Check the rest of the LLVM_VERSION_ lines.
+ elif "set(LLVM_VERSION_" in line:
+ for c, cver in (
+ ("MAJOR", self.major),
+ ("MINOR", self.minor),
+ ("PATCH", self.patch),
+ ):
+ nline = re.sub(
+ fr"set\(LLVM_VERSION_{c} (\d+)",
+ fr"set(LLVM_VERSION_{c} {cver}",
+ line,
+ )
+ if nline != line:
+ break
+
+ return nline
+
+
+# Process the many bazel files.
+class BazelProcessor(Processor):
+ def process_line(self, line: str) -> str:
+ # This matches the CLANG_VERSION line of clang/Config/config.h
+ nline = line
+ if "CLANG_VERSION " in line:
+ nline = re.sub(
+ r"#define CLANG_VERSION (.*)'",
+ f"#define CLANG_VERSION {self.version_str(include_suffix=False)}'",
+ line,
+ )
+ # Match version strings of LLVM, Clang and LLD overlay headers
+ elif "LLVM_VERSION_STRING" in line or "CLANG_VERSION_STRING" in line or "LLD_VERSION_STRING" in line:
+ nline = re.sub(
+ r"#define (LLVM|CLANG|LLD)_VERSION_STRING ([\\\"]+)[0-9\.rcgit-]+([\\\"]+)",
+ rf"#define \g<1>_VERSION_STRING \g<2>{self.version_str()}\g<3>",
+ line,
+ )
+ # Match the split out MAJOR/MINOR/PATCH versions of LLVM and Clang overlay headers
+ # in LLVM the define is called _PATCH and in clang it's called _PATCHLEVEL
+ elif "LLVM_VERSION_" in line or "CLANG_VERSION_" in line:
+ for c, cver in (
+ ("(MAJOR)", self.major),
+ ("(MINOR)", self.minor),
+ ("(PATCH|PATCHLEVEL)", self.patch),
+ ):
+ nline = re.sub(
+ fr"(LLVM|CLANG)_VERSION_{c} \d+",
+ rf"\g<1>_VERSION_\g<2> {cver}",
+ line,
+ )
+ if nline != line:
+ break
+ # Match the BACKEND_PACKAGE_STRING in clang/config.h
+ elif "BACKEND_PACKAGE_STRING" in line:
+ nline = re.sub(
+ r'#define BACKEND_PACKAGE_STRING "LLVM ([0-9\.rcgit-]+)"',
+ f'#define BACKEND_PACKAGE_STRING "LLVM {self.version_str()}"',
+ line,
+ )
+
+ return nline
+
+
+# GN build system
+class GNIProcessor(Processor):
+ def process_line(self, line: str) -> str:
+ if "llvm_version_" in line:
+ for c, cver in (
+ ("major", self.major),
+ ("minor", self.minor),
+ ("patch", self.patch),
+ ):
+ nline = re.sub(fr"llvm_version_{c} = \d+", f"llvm_version_{c} = {cver}", line)
+ if nline != line:
+ return nline
+
+ return line
+
+
+# LIT python file, a simple tuple
+class LitProcessor(Processor):
+ def process_line(self, line: str) -> str:
+ if "__versioninfo__" in line:
+ nline = re.sub(
+ fr"__versioninfo__(.*)\((\d+), (\d+), (\d+)\)",
+ f"__versioninfo__\\1({self.major}, {self.minor}, {self.patch})",
+ line,
+ )
+ return nline
+ return line
+
+
+# Handle libc++ config header
+class LibCXXProcessor(Processor):
+ def process_line(self, line: str) -> str:
+ # match #define _LIBCPP_VERSION 160000 in a relaxed way
+ match = re.match(r".*\s_LIBCPP_VERSION\s+(\d{6})$", line)
+ if match:
+ verstr = f"{str(self.major).zfill(2)}{str(self.minor).zfill(2)}{str(self.patch).zfill(2)}"
+
+ nline = re.sub(
+ fr"_LIBCPP_VERSION (\d+)",
+ f"_LIBCPP_VERSION {verstr}",
+ line,
+ )
+ return nline
+ return line
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(
+ usage="Call this script with a version and it will bump the version for you"
+ )
+ parser.add_argument("version", help="Version to bump to, e.g. 15.0.1", default=None)
+ parser.add_argument("--rc", default=None, type=int, help="RC version")
+ parser.add_argument(
+ "-s",
+ "--source-root",
+ default=None,
+ help="LLVM source root (/path/llvm-project). Defaults to the llvm-project the script is located in.",
+ )
+
+ args = parser.parse_args()
+
+ verstr = args.version
+ if args.rc:
+ verstr += f"-rc{args.rc}"
+
+ # parse the version string with distutils.
+ # note that -rc will end up as version.pre here
+ # since it's a prerelease
+ version = packaging.version.parse(verstr)
+
+ # Find llvm-project root
+ source_root = Path(__file__).resolve().parents[3]
+
+ if args.source_root:
+ source_root = Path(args.source_root).resolve()
+
+ files_to_update = (
+ # Main CMakeLists.
+ (source_root / "llvm" / "CMakeLists.txt", CMakeProcessor()),
+ # Lit configuration
+ (
+ "llvm/utils/lit/lit/__init__.py",
+ LitProcessor(),
+ ),
+ # GN build system
+ (
+ "llvm/utils/gn/secondary/llvm/version.gni",
+ GNIProcessor(),
+ ),
+ # Bazel build system
+ (
+ "utils/bazel/llvm-project-overlay/llvm/include/llvm/Config/llvm-config.h",
+ BazelProcessor(),
+ ),
+ (
+ "utils/bazel/llvm-project-overlay/clang/BUILD.bazel",
+ BazelProcessor(),
+ ),
+ (
+ "utils/bazel/llvm-project-overlay/clang/include/clang/Config/config.h",
+ BazelProcessor(),
+ ),
+ (
+ "utils/bazel/llvm-project-overlay/lld/BUILD.bazel",
+ BazelProcessor(),
+ ),
+ (
+ "libcxx/include/__config",
+ LibCXXProcessor(),
+ ),
+ )
+
+ for f, processor in files_to_update:
+ processor.process_file(source_root / Path(f), version)
More information about the llvm-commits
mailing list