# ===----------------------------------------------------------------------===##
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#
# ===----------------------------------------------------------------------===##

from pprint import pformat
import ast
import re
import shutil
import subprocess
import sys


def read_syms_from_list(slist):
    """
    Read a list of symbols from a list of strings.
    Each string is one symbol.
    """
    return [ast.literal_eval(l) for l in slist]


def read_syms_from_file(filename):
    """
    Read a list of symbols in from a file.
    """
    with open(filename, "r") as f:
        data = f.read()
    return read_syms_from_list(data.splitlines())


def read_exclusions(filename):
    with open(filename, "r") as f:
        data = f.read()
    lines = [l.strip() for l in data.splitlines() if l.strip()]
    lines = [l for l in lines if not l.startswith("#")]
    return lines


def write_syms(sym_list, out=None, names_only=False, filter=None):
    """
    Write a list of symbols to the file named by out.
    """
    out_str = ""
    out_list = sym_list
    out_list.sort(key=lambda x: x["name"])
    if filter is not None:
        out_list = filter(out_list)
    if names_only:
        out_list = [sym["name"] for sym in out_list]
    for sym in out_list:
        # Use pformat for consistent ordering of keys.
        out_str += pformat(sym, width=100000) + "\n"
    if out is None:
        sys.stdout.write(out_str)
    else:
        with open(out, "w") as f:
            f.write(out_str)


_cppfilt_exe = shutil.which("c++filt")


def demangle_symbol(symbol):
    if _cppfilt_exe is None:
        return symbol
    result = subprocess.run([_cppfilt_exe], input=symbol.encode(), capture_output=True)
    if result.returncode != 0:
        return symbol
    return result.stdout.decode()


def is_elf(filename):
    with open(filename, "rb") as f:
        magic_bytes = f.read(4)
    return magic_bytes == b"\x7fELF"


def is_mach_o(filename):
    with open(filename, "rb") as f:
        magic_bytes = f.read(4)
    return magic_bytes in [
        b"\xfe\xed\xfa\xce",  # MH_MAGIC
        b"\xce\xfa\xed\xfe",  # MH_CIGAM
        b"\xfe\xed\xfa\xcf",  # MH_MAGIC_64
        b"\xcf\xfa\xed\xfe",  # MH_CIGAM_64
        b"\xca\xfe\xba\xbe",  # FAT_MAGIC
        b"\xbe\xba\xfe\xca",  # FAT_CIGAM
    ]


def is_xcoff_or_big_ar(filename):
    with open(filename, "rb") as f:
        magic_bytes = f.read(7)
    return (
        magic_bytes[:4] in [b"\x01DF", b"\x01F7"]  # XCOFF32  # XCOFF64
        or magic_bytes == b"<bigaf>"
    )


def is_library_file(filename):
    if sys.platform == "darwin":
        return is_mach_o(filename)
    elif sys.platform.startswith("aix"):
        return is_xcoff_or_big_ar(filename)
    else:
        return is_elf(filename)


def extract_or_load(filename):
    import libcxx.sym_check.extract

    if is_library_file(filename):
        return libcxx.sym_check.extract.extract_symbols(filename)
    return read_syms_from_file(filename)


def adjust_mangled_name(name):
    if not name.startswith("__Z"):
        return name
    return name[1:]


new_delete_std_symbols = ["_Znam", "_Znwm", "_ZdaPv", "_ZdaPvm", "_ZdlPv", "_ZdlPvm"]

cxxabi_symbols = [
    "___dynamic_cast",
    "___gxx_personality_v0",
    "_ZTIDi",
    "_ZTIDn",
    "_ZTIDs",
    "_ZTIPDi",
    "_ZTIPDn",
    "_ZTIPDs",
    "_ZTIPKDi",
    "_ZTIPKDn",
    "_ZTIPKDs",
    "_ZTIPKa",
    "_ZTIPKb",
    "_ZTIPKc",
    "_ZTIPKd",
    "_ZTIPKe",
    "_ZTIPKf",
    "_ZTIPKh",
    "_ZTIPKi",
    "_ZTIPKj",
    "_ZTIPKl",
    "_ZTIPKm",
    "_ZTIPKs",
    "_ZTIPKt",
    "_ZTIPKv",
    "_ZTIPKw",
    "_ZTIPKx",
    "_ZTIPKy",
    "_ZTIPa",
    "_ZTIPb",
    "_ZTIPc",
    "_ZTIPd",
    "_ZTIPe",
    "_ZTIPf",
    "_ZTIPh",
    "_ZTIPi",
    "_ZTIPj",
    "_ZTIPl",
    "_ZTIPm",
    "_ZTIPs",
    "_ZTIPt",
    "_ZTIPv",
    "_ZTIPw",
    "_ZTIPx",
    "_ZTIPy",
    "_ZTIa",
    "_ZTIb",
    "_ZTIc",
    "_ZTId",
    "_ZTIe",
    "_ZTIf",
    "_ZTIh",
    "_ZTIi",
    "_ZTIj",
    "_ZTIl",
    "_ZTIm",
    "_ZTIs",
    "_ZTIt",
    "_ZTIv",
    "_ZTIw",
    "_ZTIx",
    "_ZTIy",
    "_ZTSDi",
    "_ZTSDn",
    "_ZTSDs",
    "_ZTSPDi",
    "_ZTSPDn",
    "_ZTSPDs",
    "_ZTSPKDi",
    "_ZTSPKDn",
    "_ZTSPKDs",
    "_ZTSPKa",
    "_ZTSPKb",
    "_ZTSPKc",
    "_ZTSPKd",
    "_ZTSPKe",
    "_ZTSPKf",
    "_ZTSPKh",
    "_ZTSPKi",
    "_ZTSPKj",
    "_ZTSPKl",
    "_ZTSPKm",
    "_ZTSPKs",
    "_ZTSPKt",
    "_ZTSPKv",
    "_ZTSPKw",
    "_ZTSPKx",
    "_ZTSPKy",
    "_ZTSPa",
    "_ZTSPb",
    "_ZTSPc",
    "_ZTSPd",
    "_ZTSPe",
    "_ZTSPf",
    "_ZTSPh",
    "_ZTSPi",
    "_ZTSPj",
    "_ZTSPl",
    "_ZTSPm",
    "_ZTSPs",
    "_ZTSPt",
    "_ZTSPv",
    "_ZTSPw",
    "_ZTSPx",
    "_ZTSPy",
    "_ZTSa",
    "_ZTSb",
    "_ZTSc",
    "_ZTSd",
    "_ZTSe",
    "_ZTSf",
    "_ZTSh",
    "_ZTSi",
    "_ZTSj",
    "_ZTSl",
    "_ZTSm",
    "_ZTSs",
    "_ZTSt",
    "_ZTSv",
    "_ZTSw",
    "_ZTSx",
    "_ZTSy",
]


def is_stdlib_symbol_name(name, sym):
    name = adjust_mangled_name(name)
    if re.search("@GLIBC|@GCC", name):
        # Only when symbol is defined do we consider it ours
        return sym["is_defined"]
    if re.search("(St[0-9])|(__cxa)|(__cxxabi)", name):
        return True
    if name in new_delete_std_symbols:
        return True
    if name in cxxabi_symbols:
        return True
    if name.startswith("_Z"):
        return True
    return False


def filter_stdlib_symbols(syms):
    stdlib_symbols = []
    other_symbols = []
    for s in syms:
        canon_name = adjust_mangled_name(s["name"])
        if not is_stdlib_symbol_name(canon_name, s):
            other_symbols += [s]
        else:
            stdlib_symbols += [s]
    return stdlib_symbols, other_symbols