generate_version_script.py

#!/usr/bin/env python3

# Generates a version script for an architecture so that it can be incorporated
# into gcc_s.ver.

fromcollectionsimportdefaultdict
fromitertoolsimportchain
importargparse, subprocess, sys, os


defsplit_suffix(symbol):
"""
 Splits a symbol such as `__gttf2@GCC_3.0` into a triple representing its
 function name (__gttf2), version name (GCC_3.0), and version number (300).

 The version number acts as a priority. Since earlier versions are more
 accessible and are likely to be used more, the lower the number is, the higher
 its priortiy. A symbol that has a '@@' instead of '@' has been designated by
 the linker as the default symbol, and is awarded a priority of -1.
 """
if"@"notinsymbol:
returnNone
data= [iforiinfilter(lambdas: s, symbol.split("@"))]
_, version=data[-1].split("_")
version=version.replace(".", "")
priority=-1if"@@"insymbolelseint(version+"0"* (3-len(version)))
returndata[0], data[1], priority


definvert_mapping(symbol_map):
"""Transforms a map from Key->Value to Value->Key."""
store=defaultdict(list)
forsymbol, (version, _) insymbol_map.items():
store[version].append(symbol)
result= []
fork, vinstore.items():
v.sort()
result.append((k, v))
result.sort(key=lambdax: x[0])
returnresult


defintersection(llvm, gcc):
"""
 Finds the intersection between the symbols extracted from compiler-rt.a/libunwind.a
 and libgcc_s.so.1.
 """
common_symbols= {}
foriingcc:
suffix_triple=split_suffix(i)
ifnotsuffix_triple:
continue

symbol, version_name, version_number=suffix_triple
ifsymbolinllvm:
ifsymbolnotincommon_symbols:
common_symbols[symbol] = (version_name, version_number)
continue
ifversion_number<common_symbols[symbol][1]:
common_symbols[symbol] = (version_name, version_number)
returninvert_mapping(common_symbols)


deffind_function_names(path):
"""
 Runs readelf on a binary and reduces to only defined functions. Equivalent to
 `llvm-readelf --wide ${path} | grep 'FUNC' | grep -v 'UND' | awk '{print $8}'`.
 """
result=subprocess.run(args=["llvm-readelf", "-su", path], capture_output=True)

ifresult.returncode!=0:
print(result.stderr.decode("utf-8"), file=sys.stderr)
sys.exit(1)

stdout=result.stdout.decode("utf-8")
stdout=filter(lambdax: "FUNC"inxand"UND"notinx, stdout.split("\n"))
stdout=chain(map(lambdax: filter(None, x), (i.split(" ") foriinstdout)))

return [list(i)[7] foriinstdout]


defto_file(versioned_symbols):
path=f"{os.path.dirname(os.path.realpath(__file__))}/new-gcc_s-symbols"
withopen(path, "w") asf:
f.write(
"Do not check this version script in: you should instead work "
"out which symbols are missing in `lib/gcc_s.ver` and then "
"integrate them into `lib/gcc_s.ver`. For more information, "
"please see `doc/LLVMLibgcc.rst`.\n"
 )
forversion, symbolsinversioned_symbols:
f.write(f"{version} {{\n")
foriinsymbols:
f.write(f" {i};\n")
f.write("};\n\n")


defread_args():
parser=argparse.ArgumentParser()
parser.add_argument(
"--compiler_rt",
type=str,
help="Path to `libclang_rt.builtins-${ARCH}.a`.",
required=True,
 )
parser.add_argument(
"--libunwind", type=str, help="Path to `libunwind.a`.", required=True
 )
parser.add_argument(
"--libgcc_s",
type=str,
help="Path to `libgcc_s.so.1`. Note that unlike the other two arguments, this is a dynamic library.",
required=True,
 )
returnparser.parse_args()


defmain():
args=read_args()
llvm=find_function_names(args.compiler_rt) +find_function_names(args.libunwind)
gcc=find_function_names(args.libgcc_s)
versioned_symbols=intersection(llvm, gcc)
# TODO(cjdb): work out a way to integrate new symbols in with the existing
# ones
to_file(versioned_symbols)


if__name__=="__main__":
main()