diff --git a/llvm/utils/release/bump-version.py b/llvm/utils/release/bump-version.py
new file mode 100755
--- /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 different 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)