BUILD.bazel

load("//:bazel/flex.bzl", "genlex")
load("//:bazel/bison.bzl", "genyacc")

package(
    default_visibility = ["//visibility:public"],
    licenses = ["notice"],
)

filegroup(
    name = "p4include",
    srcs = glob(["p4include/*.p4"]),
)

genrule(
    name = "sed_config_h",
    srcs = ["cmake/config.h.cmake"],
    outs = ["config.h"],
    cmd = " | ".join([
        "sed 's|cmakedefine|define|g' < $(SRCS)",
        "sed 's|define HAVE_LIBGC 1|undef HAVE_LIBGC|g' > $(OUTS)",
    ]),
    visibility = ["//visibility:private"],
)

cc_library(
    name = "config_h",
    hdrs = ["config.h"],
    include_prefix = ".",
)

cc_library(
    name = "lib",
    srcs = glob(["lib/*.cpp"]),
    hdrs = glob(["lib/*.h"]),
    deps = [
        ":config_h",
        "@boost//:format",
        "@boost//:multiprecision",
        "@com_google_googletest//:gtest",
    ],
)

genyacc(
    name = "p4_parser_yacc",
    src = "frontends/parsers/p4/p4parser.ypp",
    extra_outs = ["frontends/parsers/p4/stack.hh"],
    header_out = "frontends/parsers/p4/p4parser.hpp",
    source_out = "frontends/parsers/p4/p4parser.cc",
    visibility = ["//visibility:private"],
)

genyacc(
    name = "v1_parser_yacc",
    src = "frontends/parsers/v1/v1parser.ypp",
    extra_outs = ["frontends/parsers/v1/stack.hh"],
    header_out = "frontends/parsers/v1/v1parser.hpp",
    source_out = "frontends/parsers/v1/v1parser.cc",
    visibility = ["//visibility:private"],
)

genrule(
    name = "p4lexer_lex",
    srcs = ["frontends/parsers/p4/p4lexer.ll"],
    outs = ["frontends/parsers/p4/p4lexer.lex"],
    cmd = "sed '/%option outfile=\"lex.yy.c\"/d' $(SRCS) > $(OUTS)",
    visibility = ["//visibility:private"],
)

genlex(
    name = "p4lexer",
    src = "frontends/parsers/p4/p4lexer.lex",
    out = "frontends/parsers/p4/p4lexer.cc",
    prefix = "yy",
    visibility = ["//visibility:private"],
)

genrule(
    name = "v1lexer_lex",
    srcs = ["frontends/parsers/v1/v1lexer.ll"],
    outs = ["frontends/parsers/v1/v1lexer.lex"],
    cmd = "sed '/%option outfile=\"lex.yy.c\"/d' $(SRCS) > $(OUTS)",
    visibility = ["//visibility:private"],
)

genlex(
    name = "v1lexer",
    src = "frontends/parsers/v1/v1lexer.lex",
    out = "frontends/parsers/v1/v1lexer.cc",
    prefix = "yy",
    visibility = ["//visibility:private"],
)

# The ir-generator tool uses a parser built by these genlex and genyacc rules.
genlex(
    name = "ir_generator_lex",
    src = "tools/ir-generator/ir-generator-lex.l",
    out = "tools/ir-generator/ir-generator-lex.c",
    prefix = "yy",
    visibility = ["//visibility:private"],
)

genyacc(
    name = "ir_generator_yacc",
    src = "tools/ir-generator/ir-generator.ypp",
    header_out = "tools/ir-generator/ir-generator-yacc.hh",
    source_out = "tools/ir-generator/ir-generator-yacc.cc",
    visibility = ["//visibility:private"],
)

# This cc_library contains the ir-generator tool sources, including the
# ir-generator parser source from the lex/yacc output. The srcs attribute
# excludes generator.cpp since it is part of the cc_binary.
cc_library(
    name = "ir_generator_lib",
    srcs = glob(
        include = ["tools/ir-generator/*.cpp"],
        exclude = ["tools/ir-generator/generator.cpp"],
    ) + [
        "tools/ir-generator/ir-generator-yacc.cc",
    ],
    hdrs = glob(["tools/ir-generator/*.h"]),
    textual_hdrs = [
        ":ir_generator_lex",
        ":ir_generator_yacc",
    ],
    deps = [
        ":lib",
    ],
    visibility = ["//visibility:private"],
)

# The next rule builds the ir-generator tool binary.
cc_binary(
    name = "ir_generator",
    srcs = ["tools/ir-generator/generator.cpp"],
    linkopts = ["-lgmp"],
    deps = [
        ":ir_generator_lib",
        ":lib",
    ],
)

filegroup(
    name = "ir_extra_defs",
    srcs = [
        "frontends/p4-14/ir-v1.def",
        "backends/bmv2/bmv2.def",
        # p4c extensions may set this target to a `filegroup` containing
        # additional .def files.
        "@com_github_p4lang_p4c_extension//:ir_extensions",
    ],
)

genrule(
    name = "ir_generated_files",
    srcs = glob(["ir/*.def"]) + [":ir_extra_defs"],
    outs = [
        "ir/gen-tree-macro.h",
        "ir/ir-generated.cpp",
        "ir/ir-generated.h",
    ],
    cmd = """
        $(location :ir_generator) \
            -t $(RULEDIR)/ir/gen-tree-macro.h \
            -i $(RULEDIR)/ir/ir-generated.cpp \
            -o $(RULEDIR)/ir/ir-generated.h \
            $(location ir/base.def) \
            $(location ir/type.def) \
            $(location ir/expression.def) \
            $(location ir/ir.def) \
            $(location ir/v1.def) \
            $(locations :ir_extra_defs)
    """,
    tools = [":ir_generator"],
    visibility = ["//visibility:private"],
)

# It would be better to build these modules separately, but they have cyclic
# dependencies.
cc_library(
    name = "ir_frontend_midend_control_plane",
    srcs = glob([
        "ir/**/*.cpp",
        "frontends/**/*.cpp",
        "midend/**/*.cpp",
        "control-plane/**/*.cpp",
    ]) + [
        "frontends/parsers/p4/p4parser.cc",
        "frontends/parsers/v1/v1parser.cc",
        "frontends/parsers/p4/p4lexer.cc",
        "frontends/parsers/v1/v1lexer.cc",
        "ir/ir-generated.cpp",
    ],
    textual_hdrs = glob([
        "ir/**/*.h",
        "frontends/**/*.h",
        "frontends/**/*.hpp",
        "midend/**/*.h",
        "control-plane/**/*.h",
    ]) + [
        ":p4_parser_yacc",
        ":v1_parser_yacc",
        ":p4lexer",
        ":v1lexer",
        ":ir_generated_files",
    ],
    deps = [
        ":config_h",
        ":lib",
        "@boost//:algorithm",
        "@boost//:functional",
        "@boost//:iostreams",
        "@com_github_p4lang_p4runtime//:p4info_cc_proto",
        "@com_github_p4lang_p4runtime//:p4runtime_cc_proto",
        "@com_github_p4lang_p4runtime//:p4types_cc_proto",
        "@com_google_protobuf//:protobuf",
    ],
    copts = [
        # Where p4c should look for p4include at runtime.
        ("-DCONFIG_PKGDATADIR=\\\"external/%s\\\"" % repository_name()),
        # This will work only if the binary is executed by Bazel. For a general
        # solution, we would need to make p4c aware of Bazel, specifically:
        # https://github.com/bazelbuild/bazel/blob/master/tools/cpp/runfiles/runfiles_src.h
    ],
)

cc_library(
    name = "p4c_bmv2_common_lib",
    srcs = glob(["backends/bmv2/common/*.cpp"]),
    hdrs = glob(["backends/bmv2/common/*.h"]),
    deps = [
        ":ir_frontend_midend_control_plane",
        ":lib",
    ],
)

cc_library(
    name = "p4c_bmv2_simple_lib",
    srcs = glob(
        ["backends/bmv2/simple_switch/*.cpp"],
        exclude = ["backends/bmv2/simple_switch/main.cpp"],
    ),
    hdrs = glob(["backends/bmv2/simple_switch/*.h"]),
    deps = [
        ":p4c_bmv2_common_lib",
        ":ir_frontend_midend_control_plane",
        ":lib",
    ],
)

genrule(
    name = "p4c_bmv2_version",
    srcs = ["backends/bmv2/simple_switch/version.h.cmake"],
    outs = ["backends/bmv2/simple_switch/version.h"],
    cmd = "sed 's|@P4C_VERSION@|0.0.0.0|g' $(SRCS) > $(OUTS)",
    visibility = ["//visibility:private"],
)

cc_binary(
    name = "p4c_bmv2",
    srcs = [
        "backends/bmv2/simple_switch/main.cpp",
        "backends/bmv2/simple_switch/version.h",
    ],
    linkopts = [
        "-lgmp",
        "-lgmpxx",
    ],
    deps = [
        ":p4c_bmv2_common_lib",
        ":p4c_bmv2_simple_lib",
        ":ir_frontend_midend_control_plane",
        ":lib",
    ],
    data = [":p4include"],
)

# This builds the p4test backend.

cc_binary(
    name = "p4c_backend_p4test",
    srcs = [
        "backends/p4test/p4test.cpp",
    ],
    linkopts = [
        "-lgmp",
        "-lgmpxx",
    ],
    deps = [
        ":ir_frontend_midend_control_plane",
        ":lib",
        ":p4c_backend_p4test_lib",
    ],
)

genrule(
    name = "p4c_p4test_version",
    srcs = ["backends/p4test/version.h.cmake"],
    outs = ["backends/p4test/version.h"],
    cmd = "sed 's|@P4C_VERSION@|0.0.0.0|g' $(SRCS) > $(OUTS)",
    visibility = ["//visibility:private"],
)

cc_library(
    name = "p4c_backend_p4test_lib",
    srcs = [
        "backends/p4test/midend.cpp",
    ],
    hdrs = [
        "backends/p4test/midend.h",
        "backends/p4test/version.h",
    ],
    deps = [
        ":ir_frontend_midend_control_plane",
        ":lib",
    ],
)

# These rules build the graphs backend
cc_binary(
    name = "p4c_graphs",
    srcs = [
        "backends/graphs/p4c-graphs.cpp",
    ],
    data = [":p4include"],
    linkopts = [
        "-lgmp",
        "-lgmpxx",
    ],
    deps = [
        ":config_h",
        ":ir_frontend_midend_control_plane",
        ":lib",
        ":p4c_backend_graphs_lib",
    ],
)

genrule(
    name = "p4c_graphs_version",
    srcs = ["backends/graphs/version.h.cmake"],
    outs = ["backends/graphs/version.h"],
    cmd = "sed 's|@P4C_VERSION@|0.0.0.0|g' $(SRCS) > $(OUTS)",
    visibility = ["//visibility:private"],
)

cc_library(
    name = "p4c_backend_graphs_lib",
    srcs = [
        "backends/graphs/controls.cpp",
        "backends/graphs/graphs.cpp",
        "backends/graphs/p4c-graphs.cpp",
        "backends/graphs/parsers.cpp",
    ],
    hdrs = [
        "backends/graphs/controls.h",
        "backends/graphs/graphs.h",
        "backends/graphs/parsers.h",
        "backends/graphs/version.h",
    ],
    defines = [
        # Disable ADL for boost, otherwise the method resolution for
        # `ordered_map` and `graph` clash on method `boost::get`
        "BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP",
    ],
    deps = [
        ":config_h",
        ":ir_frontend_midend_control_plane",
        ":lib",
        "@boost//:graph",
    ],
)