PyNerva 0.0.5__py3-none-any.whl

nervapy/x86_64/__main__.py

@@ -0,0 +1,407 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from __future__ import absolute_import
+
+import argparse
+import sys
+
+import six
+
+from nervapy import *
+from nervapy.x86_64 import *
+
+parser = argparse.ArgumentParser(
+    description="PeachPy: Portable Efficient Assembly Code-generation in High-level Python"
+)
+parser.add_argument(
+    "-g", dest="debug_level", type=int, default=0, help="Debug information level"
+)
+parser.add_argument(
+    "-S",
+    dest="generate_assembly",
+    action="store_true",
+    help="Generate assembly listing on output",
+)
+parser.add_argument(
+    "-MMD",
+    dest="generate_dependencies_makefile",
+    action="store_true",
+    help="Generate Makefile describing the dependencies",
+)
+parser.add_argument(
+    "-MF",
+    dest="dependencies_makefile_path",
+    help="Path to output Makefile with dependencies",
+)
+parser.add_argument(
+    "-I",
+    dest="include",
+    action="append",
+    default=list(),
+    help="Add directory to module search path",
+)
+parser.add_argument(
+    "-fdump-rtl", dest="rtl_dump", help="Path to output file for RTL dump"
+)
+parser.add_argument(
+    "-emit-json-metadata",
+    dest="json_metadata_file",
+    help="Path to output file for JSON metadata",
+)
+parser.add_argument(
+    "-emit-c-header", dest="c_header_file", help="Path to output file for C/C++ header"
+)
+parser.add_argument(
+    "-fname-mangling", dest="name_mangling", help="Mangling of function names"
+)
+
+
+abi_map = {
+    "ms": (nervapy.x86_64.abi.microsoft_x64_abi, ["masm", "nasm"], ["ms-coff"]),
+    "sysv": (
+        nervapy.x86_64.abi.system_v_x86_64_abi,
+        ["gas", "nasm"],
+        ["elf", "mach-o"],
+    ),
+    "x32": (nervapy.x86_64.abi.linux_x32_abi, ["gas"], ["elf"]),
+    "nacl": (nervapy.x86_64.abi.native_client_x86_64_abi, ["gas"], ["elf"]),
+    "gosyso": (
+        nervapy.x86_64.abi.gosyso_amd64_abi,
+        ["gas"],
+        ["elf", "mach-o", "ms-coff"],
+    ),
+    "goasm": (nervapy.x86_64.abi.goasm_amd64_abi, ["go"], []),
+    "gosyso-p32": (
+        nervapy.x86_64.abi.gosyso_amd64p32_abi,
+        ["gas"],
+        ["elf", "mach-o", "ms-coff"],
+    ),
+    "goasm-p32": (nervapy.x86_64.abi.goasm_amd64p32_abi, ["go"], []),
+}
+parser.add_argument(
+    "-mabi",
+    dest="abi",
+    default="native",
+    choices=(
+        "native",
+        "ms",
+        "sysv",
+        "x32",
+        "nacl",
+        "gosyso",
+        "gosyso-p32",
+        "goasm",
+        "goasm-p32",
+    ),
+    help="Generate code for specified ABI",
+)
+
+cpu_map = {
+    "default": nervapy.x86_64.uarch.default,
+    "prescott": nervapy.x86_64.uarch.prescott,
+    "conroe": nervapy.x86_64.uarch.conroe,
+    "penryn": nervapy.x86_64.uarch.penryn,
+    "nehalem": nervapy.x86_64.uarch.nehalem,
+    "sandybridge": nervapy.x86_64.uarch.sandy_bridge,
+    "ivybridge": nervapy.x86_64.uarch.ivy_bridge,
+    "haswell": nervapy.x86_64.uarch.haswell,
+    "broadwell": nervapy.x86_64.uarch.broadwell,
+    "skylake": nervapy.x86_64.uarch.skylake,
+    "skylake-xeon": nervapy.x86_64.uarch.skylake_xeon,
+    "cannonlake": nervapy.x86_64.uarch.cannonlake,
+    "k8": nervapy.x86_64.uarch.k8,
+    "k10": nervapy.x86_64.uarch.k10,
+    "bulldozer": nervapy.x86_64.uarch.bulldozer,
+    "piledriver": nervapy.x86_64.uarch.piledriver,
+    "steamroller": nervapy.x86_64.uarch.steamroller,
+    "excavator": nervapy.x86_64.uarch.excavator,
+    "zen": nervapy.x86_64.uarch.zen,
+    "bonnell": nervapy.x86_64.uarch.bonnell,
+    "saltwell": nervapy.x86_64.uarch.saltwell,
+    "silvermont": nervapy.x86_64.uarch.silvermont,
+    "airmont": nervapy.x86_64.uarch.airmont,
+    "goldmont": nervapy.x86_64.uarch.goldmont,
+    "bobcat": nervapy.x86_64.uarch.bobcat,
+    "jaguar": nervapy.x86_64.uarch.jaguar,
+    "knightslanding": nervapy.x86_64.uarch.knights_landing,
+}
+parser.add_argument(
+    "-mcpu",
+    dest="cpu",
+    default="default",
+    choices=(
+        "default",
+        "prescott",
+        "conroe",
+        "penryn",
+        "nehalem",
+        "sandybridge",
+        "ivybridge",
+        "haswell",
+        "broadwell",
+        "skylake",
+        "skylake-xeon",
+        "cannonlake",
+        "k8",
+        "k10",
+        "bulldozer",
+        "piledriver",
+        "steamroller",
+        "excavator",
+        "zen",
+        "bonnell",
+        "saltwell",
+        "silvermont",
+        "airmont",
+        "goldmont",
+        "bobcat",
+        "jaguar",
+        "knightslanding",
+    ),
+    help="Target specified microarchitecture",
+)
+
+parser.add_argument(
+    "-mimage-format",
+    dest="image_format",
+    default="native",
+    choices=("native", "elf", "mach-o", "ms-coff"),
+    help="Target binary image format",
+)
+parser.add_argument(
+    "-massembly-format",
+    dest="assembly_format",
+    choices=("golang", "nasm", "gas", "masm"),
+    help="Target assembly format",
+)
+
+parser.add_argument(
+    "-fpackage",
+    dest="package",
+    default="",
+    help="Use specified Go package name in generated Plan 9 assembly listings",
+)
+avx_group = parser.add_mutually_exclusive_group()
+avx_group.add_argument(
+    "-mavx", dest="avx", action="store_true", help="Enable AVX extension"
+)
+avx_group.add_argument(
+    "-mno-avx", dest="avx", action="store_false", help="Disable AVX extension"
+)
+xop_group = parser.add_mutually_exclusive_group()
+xop_group.add_argument(
+    "-mxop", dest="xop", action="store_true", help="Enable XOP extension"
+)
+xop_group.add_argument(
+    "-mno-xop", dest="xop", action="store_false", help="Disable XOP extension"
+)
+fma4_group = parser.add_mutually_exclusive_group()
+fma4_group.add_argument(
+    "-mfma4", dest="fma4", action="store_true", help="Enable FMA4 extension"
+)
+fma4_group.add_argument(
+    "-mno-fma4", dest="fma4", action="store_false", help="Disable FMA4 extension"
+)
+fma3_group = parser.add_mutually_exclusive_group()
+fma3_group.add_argument(
+    "-mfma3", dest="fma3", action="store_true", help="Enable FMA3 extension"
+)
+fma3_group.add_argument(
+    "-mno-fma3", dest="fma3", action="store_false", help="Disable FMA3 extension"
+)
+f16c_group = parser.add_mutually_exclusive_group()
+f16c_group.add_argument(
+    "-mf16c", dest="f16c", action="store_true", help="Enable F16C extension"
+)
+f16c_group.add_argument(
+    "-mno-f16c", dest="f16c", action="store_false", help="Disable F16C extension"
+)
+avx2_group = parser.add_mutually_exclusive_group()
+avx2_group.add_argument(
+    "-mavx2", dest="avx2", action="store_true", help="Enable AVX2 extension"
+)
+avx2_group.add_argument(
+    "-mno-avx2", dest="avx2", action="store_false", help="Disable AVX2 extension"
+)
+parser.add_argument(
+    "-o",
+    dest="output",
+    required=True,
+    help="Output file name (ELF/Mach-O/COFF image or Go assembly source)",
+)
+parser.add_argument(
+    "input", nargs=1, help="Input file name (must be a PeachPy Python script)"
+)
+
+
+def guess_assembly_format_from_abi(abi):
+    _, supported_assembly_formats, _ = abi_map[abi]
+    return supported_assembly_formats[0]
+
+
+def check_abi_assembly_format_combination(abi, assembly_format):
+    _, supported_assembly_formats, _ = abi_map[abi]
+    if assembly_format not in supported_assembly_formats:
+        raise ValueError(
+            "Assembly format %s is not supported for %s" % (assembly_format, str(abi))
+        )
+
+
+def check_abi_image_format_combination(image_format, abi):
+    _, _, supported_image_formats = abi_map[abi]
+    if image_format not in supported_image_formats:
+        raise ValueError(
+            "Image format %s is not supported for %s" % (image_format, str(abi))
+        )
+
+
+def detect_native_image_format():
+    import platform
+
+    osname = platform.system()
+    if osname == "Darwin":
+        return "mach-o"
+    elif osname in ["Linux", "NaCl", "FreeBSD"]:
+        return "elf"
+    elif osname == "Windows":
+        return "ms-coff"
+
+
+def add_module_files(module_files, module, roots):
+    """Recursively adds Python source files for module and its submodules inside the roots directories"""
+    if not hasattr(module, "__file__"):
+        return
+
+    module_file = module.__file__
+    if module_file is None:
+        return
+
+    import os
+
+    if not any(module_file.startswith(root + os.sep) for root in roots):
+        # The file is not inside any of the monitored roots
+        # This is typical for system modules
+        return
+
+    if module_file.endswith(".pyc") or module_file.endswith(".pyo"):
+        module_source_file = module_file[:-4] + ".py"
+        if os.path.isfile(module_source_file):
+            module_file = module_source_file
+
+    if module_file in module_files:
+        # This module was already added under a different name
+        return
+    module_files.add(module_file)
+
+    from types import ModuleType
+
+    for variable_name in dir(module):
+        if variable_name.startswith("__"):
+            continue
+
+        variable = getattr(module, variable_name)
+        if isinstance(variable, ModuleType):
+            add_module_files(module_files, variable, roots)
+
+
+def execute_script(writers, source_filename):
+    if writers:
+        writer = writers.pop()
+        with writer:
+            execute_script(writers, source_filename)
+    else:
+        with open(source_filename) as input_file:
+            code = compile(input_file.read(), source_filename, "exec")
+            exec(code, globals())
+
+
+def main():
+    options = parser.parse_args()
+    import nervapy.x86_64.options
+
+    nervapy.x86_64.options.debug_level = options.debug_level
+    if options.abi == "native":
+        abi = nervapy.x86_64.abi.detect(system_abi=True)
+        if abi is None:
+            raise ValueError("Could not auto-detect ABI: specify it with -mabi option")
+        # Set options.abi to the corresponding string value because it is used later on
+        options.abi = {abi: name for name, (abi, _, _) in six.iteritems(abi_map)}[abi]
+    else:
+        abi, _, _ = abi_map[options.abi]
+    nervapy.x86_64.options.abi = abi
+    nervapy.x86_64.options.target = cpu_map[options.cpu]
+    nervapy.x86_64.options.package = options.package
+    nervapy.x86_64.options.generate_assembly = options.generate_assembly
+    if options.name_mangling:
+        nervapy.x86_64.options.name_mangling = options.name_mangling
+
+    from nervapy.writer import (AssemblyWriter, CHeaderWriter, ELFWriter,
+                                JSONMetadataWriter, MachOWriter, MSCOFFWriter)
+
+    writers = []
+    if nervapy.x86_64.options.generate_assembly:
+        assembly_format = options.assembly_format
+        if assembly_format is None:
+            assembly_format = guess_assembly_format_from_abi(options.abi)
+        else:
+            check_abi_assembly_format_combination(options.abi, assembly_format)
+        writers.append(
+            AssemblyWriter(options.output, assembly_format, options.input[0])
+        )
+    else:
+        image_format = options.image_format
+        if image_format == "native":
+            image_format = detect_native_image_format()
+            if image_format is None:
+                raise ValueError(
+                    "Could not auto-detect image format: specify it with -mimage-format option"
+                )
+        check_abi_image_format_combination(image_format, options.abi)
+        if image_format == "elf":
+            writers.append(ELFWriter(options.output, abi, options.input[0]))
+        elif image_format == "mach-o":
+            writers.append(MachOWriter(options.output, abi))
+        elif image_format == "ms-coff":
+            writers.append(MSCOFFWriter(options.output, abi, options.input[0]))
+        else:
+            raise ValueError("Image format %s is not supported" % image_format)
+    dependencies_makefile_path = options.output + ".d"
+    if options.dependencies_makefile_path:
+        dependencies_makefile_path = options.dependencies_makefile_path
+    if options.rtl_dump:
+        nervapy.x86_64.options.rtl_dump_file = open(options.rtl_dump, "w")
+    if options.c_header_file:
+        writers.append(CHeaderWriter(options.c_header_file, options.input[0]))
+    if options.json_metadata_file:
+        writers.append(JSONMetadataWriter(options.json_metadata_file))
+
+    # PeachPy sources can import other modules or files from the same directory
+    import os
+
+    include_directories = [
+        os.path.abspath(include_dir) for include_dir in options.include
+    ]
+    include_directories.insert(0, os.path.abspath(os.path.dirname(options.input[0])))
+    sys.path.extend(include_directories)
+
+    # We would like to avoid situations where source file has changed, but Python uses its old precompiled version
+    sys.dont_write_bytecode = True
+
+    execute_script(writers, options.input[0])
+
+    if options.generate_dependencies_makefile:
+        module_files = set()
+        for module in sys.modules.values():
+            add_module_files(module_files, module, include_directories)
+
+        dependencies = list(sorted(module_files))
+        dependencies.insert(0, options.input[0])
+        with open(dependencies_makefile_path, "w") as dependencies_makefile:
+            dependencies_makefile.write(
+                options.output + ": \\\n  " + " \\\n  ".join(dependencies) + "\n"
+            )
+
+
+if __name__ == "__main__":
+    main()