binary_translation/intrinsics/Android.bp

// Copyright (C) 2018 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

package {
    default_applicable_licenses: ["Android-Apache-2.0"],
}

python_binary_host {
    name: "gen_intrinsics",
    main: "gen_intrinsics.py",
    srcs: ["gen_intrinsics.py"],
    libs: ["asm_defs_lib"],
}

python_library_host {
    name: "gen_intrinsics_lib",
    srcs: ["gen_intrinsics.py"],
}

python_test_host {
    name: "gen_intrinsics_tests",
    main: "gen_intrinsics_test.py",
    srcs: [
        "gen_intrinsics_test.py",
        "gen_intrinsics.py",
    ],
    libs: ["asm_defs_lib"],
    test_suites: ["device-tests"],
    test_options: {
        unit_test: true,
    },
}

filegroup {
    name: "libberberis_intrinsics_gen_inputs_riscv64_to_all",
    srcs: ["riscv64_to_all/intrinsic_def.json"],
}

genrule {
    name: "libberberis_text_assembler_gen_headers_riscv64",
    out: [
        "gen_text_assembler_common_riscv-inl.h",
        "gen_text_assembler_riscv64-inl.h",
    ],
    srcs: [":libberberis_assembler_gen_inputs_riscv64"],
    tools: ["gen_asm"],
    cmd: "$(location gen_asm) --text-assembler $(out) $(in)",
}

genrule {
    name: "libberberis_text_assembler_gen_headers_x86_32",
    out: [
        "gen_text_assembler_common_x86-inl.h",
        "gen_text_assembler_x86_32-inl.h",
    ],
    srcs: [":libberberis_assembler_gen_inputs_x86_32"],
    tools: ["gen_asm"],
    cmd: "$(location gen_asm) --text-assembler $(out) $(in)",
}

genrule {
    name: "libberberis_text_assembler_gen_headers_x86_64",
    out: [
        "gen_text_assembler_common_x86-inl.h",
        "gen_text_assembler_x86_64-inl.h",
    ],
    srcs: [":libberberis_assembler_gen_inputs_x86_64"],
    tools: ["gen_asm"],
    cmd: "$(location gen_asm) --text-assembler $(out) $(in)",
}

filegroup {
    name: "libberberis_machine_ir_intrinsic_binding_riscv64_to_x86_64",
    srcs: ["riscv64_to_x86_64/machine_ir_intrinsic_binding.json"],
}

filegroup {
    name: "libberberis_macro_assembler_gen_inputs_riscv64_to_x86_64",
    srcs: ["riscv64_to_x86_64/macro_def.json"],
}

filegroup {
    name: "dummy_gen_text_asm_intrinsics_srcs",
    srcs: ["dummy_gen_text_asm_intrinsics.cc"],
}

filegroup {
    name: "gen_text_asm_intrinsics_srcs",
    srcs: ["gen_text_asm_intrinsics.cc"],
}

genrule {
    name: "libberberis_intrinsics_gen_inline_headers_riscv64_to_x86_64",
    out: ["berberis/intrinsics/intrinsics.h"],
    srcs: [],
    tools: ["gen_riscv64_to_x86_64_intrinsics"],
    cmd: "$(location gen_riscv64_to_x86_64_intrinsics) $(out)",
}

genrule {
    name: "libberberis_macro_assembler_gen_intrinsics_headers_riscv64_to_x86_64",
    out: ["text_asm_intrinsics_process_bindings-inl.h"],
    srcs: [
        ":libberberis_intrinsics_gen_inputs_riscv64_to_all",
        ":libberberis_machine_ir_intrinsic_binding_riscv64_to_x86_64",
        ":libberberis_macro_assembler_gen_inputs_riscv64_to_x86_64",
        ":libberberis_assembler_gen_inputs_x86_64",
    ],
    tools: ["gen_intrinsics"],
    cmd: "$(location gen_intrinsics) --text_asm_intrinsics_bindings $(out) $(in)",
}

genrule {
    name: "libberberis_intrinsics_gen_public_headers_riscv64_to_x86_64",
    out: [
        "berberis/intrinsics/intrinsics-inl.h",
        "berberis/intrinsics/intrinsics_process_bindings-inl.h",
        "berberis/intrinsics/interpreter_intrinsics_hooks-inl.h",
        "berberis/intrinsics/translator_intrinsics_hooks-inl.h",
        "berberis/intrinsics/mock_semantics_listener_intrinsics_hooks-inl.h",
    ],
    srcs: [
        ":libberberis_intrinsics_gen_inputs_riscv64_to_all",
        ":libberberis_machine_ir_intrinsic_binding_riscv64_to_x86_64",
        ":libberberis_macro_assembler_gen_inputs_riscv64_to_x86_64",
        ":libberberis_assembler_gen_inputs_x86_64",
    ],
    tools: ["gen_intrinsics"],
    cmd: "$(location gen_intrinsics) --public_headers $(out) $(in)",
}

genrule {
    name: "libberberis_macro_assembler_gen_headers_riscv64_to_x86_64",
    out: ["berberis/intrinsics/macro_assembler_interface-inl.h"],
    srcs: [":libberberis_macro_assembler_gen_inputs_riscv64_to_x86_64"],
    tools: ["gen_asm"],
    cmd: "$(location gen_asm) --binary-assembler $(out) $(in)",
}

genrule {
    name: "libberberis_intrinsics_gen_public_headers_riscv64_to_arm64",
    out: [
        "berberis/intrinsics/intrinsics-inl.h",
        "berberis/intrinsics/interpreter_intrinsics_hooks-inl.h",
    ],
    srcs: [
        ":libberberis_intrinsics_gen_inputs_riscv64_to_all",
    ],
    tools: ["gen_intrinsics"],
    cmd: "$(location gen_intrinsics) arm64 --public_headers $(out) $(in)",
}

// Note: the following two genrules and this host binary are working together.
//
// gen_riscv64_to_x86_64_intrinsics is C++ program, generated by python script,
// which does not accept any inputs and produces berberis/intrinsics/intrinsics.h
//
// Other modules are not supposed to use gen_riscv64_to_x86_64_intrinsics, they should only
// depend on libberberis_intrinsics_gen_asm_impl_headers_riscv64_to_x86_64
//
// So with 64-bit RISC V headers we have two-step operation:
//
//   gen_intrinsics
//   -> text_asm_intrinsics_process_bindings-inl.h
//      -> gen_riscv64_to_x86_64_intrinsics
//         -> libberberis_intrinsics_gen_asm_impl_headers_riscv64_to_x86_64
//
// Compare to single-step generation of common headers:
//
//   gen_intrinsics
//   -> libberberis_intrinsics_gen_public_headers_riscv64_to_x86_64

cc_binary_host {
    name: "gen_riscv64_to_x86_64_intrinsics",
    defaults: ["gen_text_asm_intrinsics_defaults"],
    local_include_dirs: ["riscv64_to_x86_64"],
    target: {
        linux: {
            generated_headers: [
                "libberberis_intrinsics_gen_public_headers_riscv64_to_x86_64",
                "libberberis_macro_assembler_gen_intrinsics_headers_riscv64_to_x86_64",
                "libberberis_text_assembler_gen_headers_x86_64",
            ],
            header_libs: ["libberberis_macro_assembler_headers_riscv64_to_x86_64"],
            static_libs: ["libberberis_macro_assembler_riscv64_to_x86_64"],
        },
    },
}

cc_defaults {
    name: "gen_text_asm_intrinsics_defaults",
    // Note: build system would pick the build OS variant.
    // Usually that's 64-bit version thus we can only support 64bit version here.
    // Currently none of Android builds that we care about used 32bit version of host tools.
    defaults: ["berberis_defaults_64"],
    host_supported: true,
    header_libs: ["libberberis_intrinsics_headers"],
    // Note: since this tool is used in genrule, it has to be buildable and
    // available on all platforms unconditionally.
    //
    // Since we don't support MacOS build for the rest of berberis we are providing
    // a "dummy" version on non-linux platform: it would always generate empty header.
    //
    // That version does not need any internal headers, libraries or sources,
    // thus we use conditional dependencies only on linux platform here.
    target: {
        darwin: {
            enabled: true,
            srcs: [":dummy_gen_text_asm_intrinsics_srcs"],
        },
        linux: {
            // We are only ever executing that binary once, it's faster to build it without
            // optimizations and spend half-second more running it, than spend tens of seconds
            // optimizing the code to save that half-second.
            cflags: ["-O0"],
            srcs: [":gen_text_asm_intrinsics_srcs"],
            header_libs: [
                "libberberis_assembler_headers", // Immediates.
                "libberberis_base_headers",
                "libberberis_runtime_primitives_headers",
            ],
            shared_libs: ["liblog"],
        },
    },
    // Targets using these defaults must provide the following guest-specific fields on linux:
    // generated_header: [
    //     "libberberis_intrinsics_gen_public_headers_<guest>_to_<host>",
    //     "libberberis_text_assembler_gen_headers_<guest>_to_<host>",
    // ],
    // header_libs: [ "libberberis_macro_assembler_headers_<guest>_to_<host>" ],
    // static_libs: [ "libberberis_macro_assembler_<guest>_to_<host>" ],
}

cc_library_headers {
    name: "libberberis_intrinsics_riscv64_headers",
    defaults: ["berberis_all_hosts_defaults"],
    host_supported: true,
    header_libs: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
        "libberberis_runtime_primitives_headers", // for platform.h
    ],
    export_header_lib_headers: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
        "libberberis_runtime_primitives_headers", // for platform.h
    ],
    export_include_dirs: [
        "riscv64_to_all/include",
    ],
    arch: {
        arm64: {
            generated_headers: ["libberberis_intrinsics_gen_public_headers_riscv64_to_arm64"],
            export_generated_headers: ["libberberis_intrinsics_gen_public_headers_riscv64_to_arm64"],
            export_include_dirs: [
                "riscv64_to_arm64/include",
            ],
        },
        x86_64: {
            generated_headers: [
                "libberberis_intrinsics_gen_inline_headers_riscv64_to_x86_64",
                "libberberis_intrinsics_gen_public_headers_riscv64_to_x86_64",
            ],
            export_generated_headers: [
                "libberberis_intrinsics_gen_inline_headers_riscv64_to_x86_64",
                "libberberis_intrinsics_gen_public_headers_riscv64_to_x86_64",
            ],
            export_include_dirs: [
                "riscv64_to_x86_64/include",
            ],
        },
    },
}

cc_library_headers {
    name: "libberberis_intrinsics_headers",
    defaults: ["berberis_all_hosts_defaults"],
    host_supported: true,
    native_bridge_supported: true,
    export_include_dirs: ["include"],
    header_libs: ["libberberis_base_headers"],
    export_header_lib_headers: ["libberberis_base_headers"],
    arch: {
        x86: {
            export_include_dirs: [
                "all_to_x86_32_or_x86_64/include",
            ],
        },
        x86_64: {
            export_include_dirs: [
                "all_to_x86_32_or_x86_64/include",
            ],
        },
        riscv64: {
            export_include_dirs: [
                "all_to_riscv64/include",
            ],
        },
    },
}

cc_library_static {
    name: "libberberis_intrinsics",
    defaults: ["berberis_defaults"],
    host_supported: true,
    header_libs: ["libberberis_intrinsics_riscv64_headers"],
    static_libs: ["libberberis_base"],
    export_header_lib_headers: ["libberberis_intrinsics_riscv64_headers"],
}

cc_library_headers {
    name: "libberberis_macro_assembler_headers_all_to_riscv64",
    defaults: ["berberis_defaults_64"],
    host_supported: true,
    export_include_dirs: [
        "all_to_riscv64/include",
        "include",
    ],
    header_libs: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
    ],
    export_header_lib_headers: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
    ],
}

cc_library_headers {
    name: "libberberis_macro_assembler_headers_all_to_x86_64",
    defaults: ["berberis_defaults_64"],
    host_supported: true,
    export_include_dirs: [
        "all_to_x86_32_or_x86_64/include",
        "include",
    ],
    header_libs: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
    ],
    export_header_lib_headers: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
    ],
}

cc_library_headers {
    name: "libberberis_macro_assembler_headers_riscv64_to_x86_64",
    defaults: ["berberis_defaults_64"],
    host_supported: true,
    export_include_dirs: [
        "riscv64_to_all/include",
        "riscv64_to_x86_64/include",
        "include",
    ],
    header_libs: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
        "libberberis_macro_assembler_headers_all_to_x86_64",
    ],
    export_header_lib_headers: [
        "libberberis_base_headers",
        "libberberis_intrinsics_headers",
    ],
    generated_headers: ["libberberis_macro_assembler_gen_headers_riscv64_to_x86_64"],
    export_generated_headers: ["libberberis_macro_assembler_gen_headers_riscv64_to_x86_64"],
}

cc_library_static {
    name: "libberberis_macro_assembler_riscv64_to_x86_64",
    defaults: ["berberis_defaults_64"],
    host_supported: true,
    srcs: ["riscv64_to_x86_64/macro_assembler.cc"],
    header_libs: ["libberberis_macro_assembler_headers_riscv64_to_x86_64"],
}

cc_library_static {
    name: "libberberis_intrinsics_riscv64",
    defaults: ["berberis_all_hosts_defaults_64"],
    host_supported: true,
    srcs: [
        "riscv64_to_all/intrinsics.cc",
        "riscv64_to_all/vector_intrinsics.cc",
    ],
    header_libs: [
        "libberberis_base_headers",
        "libberberis_intrinsics_riscv64_headers",
    ],
    export_header_lib_headers: [
        "libberberis_base_headers",
        "libberberis_intrinsics_riscv64_headers",
    ],
}

cc_test_library {
    name: "libberberis_intrinsics_unit_tests",
    defaults: ["berberis_defaults"],
    host_supported: true,
    srcs: ["simd_register_test.cc"],
    arch: {
        x86: {
            srcs: [
                "all_to_x86_32_or_x86_64/intrinsics_float_test.cc",
            ],
        },
        x86_64: {
            cflags: ["-mssse3"],
            srcs: [
                "all_to_x86_32_or_x86_64/intrinsics_float_test.cc",
                "all_to_x86_64/tuple_test.cc",
                // Note that these two tests technically should work on any platform that supports
                // risv64 to something translation, but currently that's only x86-64.
                "riscv64_to_all/intrinsics_test.cc",
                "riscv64_to_all/vector_intrinsics_test.cc",
            ],
        },
    },
    static_libs: [
        "libberberis_base",
        "libberberis_intrinsics",
    ],
    shared: {
        enabled: false,
    },
}