blob: 000d985af594ac83d304801831ad5d9ecdb8c2e2 [file] [log] [blame]
"""Rules to build Kelvin SW objects"""
load("@rules_cc//cc:find_cc_toolchain.bzl", "find_cc_toolchain")
KELVIN_PLATFORM = "//platforms/riscv32:kelvin"
def _kelvin_transition_impl(_settings, _attr):
return {"//command_line_option:platforms": KELVIN_PLATFORM}
kelvin_transition = transition(
implementation = _kelvin_transition_impl,
inputs = [],
outputs = ["//command_line_option:platforms"],
)
def kelvin_rule(**kwargs):
"""Kelvin-specific transition rule.
A wrapper over rule() for creating rules that trigger
the transition to the kelvin platform config.
Args:
**kwargs: params forwarded to the implementation.
Returns:
Kelvin transition rule.
"""
attrs = kwargs.pop("attrs", {})
if "platform" not in attrs:
attrs["platform"] = attr.string(default = KELVIN_PLATFORM)
attrs["_allowlist_function_transition"] = attr.label(
default = "@bazel_tools//tools/allowlists/function_transition_allowlist",
)
return rule(
cfg = kelvin_transition,
attrs = attrs,
**kwargs
)
def _kelvin_binary_impl(ctx):
"""Implements compilation for kelvin executables.
This rule compiles and links provided input into an executable
suitable for use on the Kelvin core. Generates both an ELF
and a BIN.
Args:
ctx: context for the rules.
srcs: Input source files.
deps: Target libraries that the binary depends upon.
hdrs: Header files that are local to the binary.
copts: Flags to pass along to the compiler.
defines: Preprocessor definitions.
linkopts: Flags to pass along to the linker.
Output:
OutputGroupsInfo to allow definition of filegroups
containing the output ELF and BIN.
"""
cc_toolchain = find_cc_toolchain(ctx).cc
feature_configuration = cc_common.configure_features(
ctx = ctx,
cc_toolchain = cc_toolchain,
requested_features = ctx.features,
unsupported_features = ctx.disabled_features,
)
compilation_contexts = []
linking_contexts = []
for dep in ctx.attr.deps:
if CcInfo in dep:
compilation_contexts.append(dep[CcInfo].compilation_context)
linking_contexts.append(dep[CcInfo].linking_context)
(_compilation_context, compilation_outputs) = cc_common.compile(
actions = ctx.actions,
cc_toolchain = cc_toolchain,
feature_configuration = feature_configuration,
name = ctx.label.name,
srcs = ctx.files.srcs,
compilation_contexts = compilation_contexts,
private_hdrs = ctx.files.hdrs,
user_compile_flags = ctx.attr.copts,
defines = ctx.attr.defines,
)
linking_outputs = cc_common.link(
name = "{}.elf".format(ctx.label.name),
actions = ctx.actions,
feature_configuration = feature_configuration,
cc_toolchain = cc_toolchain,
compilation_outputs = compilation_outputs,
linking_contexts = linking_contexts,
user_link_flags = ctx.attr.linkopts + [
"-Wl,-T,{}".format(ctx.file.linker_script.path),
"-Wl,--no-warn-rwx-segments",
],
additional_inputs = depset([ctx.file.linker_script] + ctx.files.linker_script_includes),
output_type = "executable",
)
binary = ctx.actions.declare_file(
"{}.bin".format(
ctx.attr.name,
),
)
ctx.actions.run(
outputs = [binary],
inputs = [linking_outputs.executable] + cc_toolchain.all_files.to_list(),
arguments = [
"-g",
"-O",
"binary",
linking_outputs.executable.path,
binary.path,
],
executable = cc_toolchain.objcopy_executable,
)
return [
DefaultInfo(
files = depset([linking_outputs.executable, binary]),
),
OutputGroupInfo(
all_files = depset([linking_outputs.executable, binary]),
elf_file = depset([linking_outputs.executable]),
bin_file = depset([binary]),
),
]
kelvin_binary_impl = kelvin_rule(
implementation = _kelvin_binary_impl,
attrs = {
"srcs": attr.label_list(allow_files = True),
"deps": attr.label_list(allow_empty = True, providers = [CcInfo]),
"hdrs": attr.label_list(allow_files = [".h"], allow_empty = True),
"copts": attr.string_list(),
"defines": attr.string_list(),
"linkopts": attr.string_list(),
"linker_script": attr.label(allow_single_file = True),
"linker_script_includes": attr.label_list(default = [], allow_files = True),
"_cc_toolchain": attr.label(default = Label("@bazel_tools//tools/cpp:current_cc_toolchain")),
},
fragments = ["cpp"],
toolchains = ["@rules_cc//cc:toolchain_type"],
)
def kelvin_binary(
name,
srcs,
is_riscv_test = False,
tags = [],
**kwargs):
"""A helper macro for generating binary artifacts for the kelvin core.
This macro uses the kelvin toolchain, kelvin-specific starting asm,
and kelvin linker script to build kelvin binaries.
Args:
name: The name of this rule.
srcs: The c source files.
is_riscv_test: A bool flag to decide if a custom _start asm is included.
It is used by riscv-tests.
**kwargs: Additional arguments forward to cc_binary.
Emits rules:
filegroup named: <name>.bin
Containing the binary output for the target.
filegroup named: <name>.elf
Containing all elf output for the target.
"""
srcs.append("//crt:kelvin_gloss.cc")
if not is_riscv_test:
srcs += [
"//crt:crt.S",
"//crt:kelvin_start.S",
]
kelvin_binary_impl(
name = name,
srcs = srcs,
linker_script = "//crt:kelvin.ld",
tags = tags,
**kwargs
)
# Need to create the following filegroups to make the output discoverable.
native.filegroup(
name = "{}.bin".format(name),
srcs = [name],
output_group = "bin_file",
tags = tags,
)
native.filegroup(
name = "{}.elf".format(name),
srcs = [name],
output_group = "elf_file",
tags = tags,
)
def kelvin_test(
name,
hw_test_size = "medium",
hw_test_tags = [],
iss_test_size = "small",
iss_test_tags = [],
**kwargs):
"""A sh_test wrapper for kelvin binaries
A wrapper to build kelvin_binary and test it against build_tools/*test_runner.sh
on both ISS and HW SystemC simulations.
Args:
name: The name of this rule.
hw_test_size: Tests size for SystemC test, default to medium.
hw_test_tags: Test tags passed to System test.
iss_test_size: ISS test size. Default to small.
iss_test_tags: Test tags passed to ISS test.
**kwargs: Agruments that will be forwarded to kelvin_binary
"""
kelvin_elf = "{}_elf".format(name)
kelvin_binary(
name = kelvin_elf,
**kwargs
)
iss_test = "{}_iss".format(name)
native.sh_test(
name = iss_test,
size = iss_test_size,
srcs = [
"//build_tools:test_runner.sh",
],
args = [
"$(location %s.elf)" % kelvin_elf,
],
data = [
"{}.elf".format(kelvin_elf),
],
tags = ["iss"] + iss_test_tags,
)
hw_test = "{}_hw".format(name)
native.sh_test(
name = hw_test,
size = hw_test_size,
srcs = ["//build_tools:core_sim_test_runner.sh"],
args = [
"$(location %s.bin)" % kelvin_elf,
],
data = [
"{}.bin".format(kelvin_elf),
],
tags = ["systemc"] + hw_test_tags,
)
native.test_suite(
name = name,
tests = [
iss_test,
hw_test,
],
)
# From @tflite-micro//tensorflow/lite/micro/build_def.bzl, and paths
# modified to point to the external repo.
def generate_cc_arrays(name, src, out, visibility = None, tags = []):
native.genrule(
name = name,
srcs = [
src,
],
outs = [
out,
],
tags = tags,
cmd = "$(location @tflite-micro//tensorflow/lite/micro/tools:generate_cc_arrays) $@ $<",
tools = ["@tflite-micro//tensorflow/lite/micro/tools:generate_cc_arrays"],
visibility = visibility,
)