The lk-sys crate provides low-level bindings to LK functions and types.
This runs bindgen in build.rs, and includes the generated output in the
main library. In addition, there are a small number of instances that
need to be in this file, as these must be in the same crate as the
definitions.

Signed-off-by: David Brown <david.brown@linaro.org>

The lk crate provides the basic Rust-friendly interfaces to LK. At this
point, the following are available:

  - init: Interface to LK's init mechanism
  - log: Provides an implementation of the 'log' crate that calls fputs
    in lk.
  - lkonce: A run-once primitive, similar to std::sync::Once, but with
    provision for using zero-initialized memory, with the initialization
    being called through the lk init mechanism.
  - macros: A few useful macros around `container_of`.

Signed-off-by: David Brown <david.brown@linaro.org>

Instead of just always enabling Rust, only enable if it is specifically
requested via the `USE_RUST` variable.

Signed-off-by: David Brown <david.brown@linaro.org>

This is a Rust reimplementation of the PL011 UART driver.  This will be
used in any build that requests the pl011 driver and has rust support.

Signed-off-by: David Brown <david.brown@linaro.org>

llvm-objdump prints a non-suppressible warning for any source files
mentioned in objects that aren't present. As we are using the
pre-compiled Rust core/alloc libraries, which have a hard-coded path
`rustc/<hash>/...` for these source files, and it is up to the user
whether the source package is present (and to make a symlink so they can
be found), just capture and filter out these messages.  This should only
be filtering out the specific message.

Signed-off-by: David Brown <david.brown@linaro.org>

As LK contains a directory called `target/` we can't ignore this at the
top level. Ignore this directory and Cargo.lock only within the rust
directory.  Currently all crates live here, so this should keep target
from showing up to git.  The real target directory will be under the
build-* directory, which is already ignored.

Signed-off-by: David Brown <david.brown@linaro.org>

When referencing other crates from the `rust_support/Cargo.toml` file,
use the `BUILDROOT` instead of a large relative path. This makes the
process not depend on where the build directory is.

Signed-off-by: David Brown <david.brown@linaro.org>

Remove a redundant MODULE_OBJECT assignment, and add this module to the
MODULES list.

Signed-off-by: David Brown <david.brown@linaro.org>

Signed-off-by: David Brown <david.brown@linaro.org>

Update all of the new Rust source files with an MIT header (from other
parts of LK). Add the license declaration line to the various Cargo.toml
files.

Signed-off-by: David Brown <david.brown@linaro.org>

Instead of depending on a pre-defined target tuple, with a pre-build
core and allow, capture our configuration with a custom LLVM target JSON
file. To do this, we need to build core and alloc, which currently
requires a nightly compiler.

The advantage here is that core and alloc will be build with the exact
configuration we define here, including any specific command line
arguments.

Signed-off-by: David Brown <david.brown@linaro.org>

Ensure that the generated aarch64 rust code does not make use of
floating point registers, pass this option in vai RUSTCFLAGS variable.
This will need more general support to add other architectures.

Signed-off-by: David Brown <david.brown@linaro.org>

As the builds now require the nightly compiler, install that before
trying to build with CI.

Signed-off-by: David Brown <david.brown@linaro.org>

Base this json file off of aarch64-unknown-none-softfloat, to properly
disable use of HW floating point registers in the kernel.

This avoids needing to explicitly pass and option to avoid using Neon.

Note that at the time of this commit, building core with this
configuration generates a warning, due to some explicitly neon code in
core.  Presumably, this will be fixed in core at least before the
compiler starts considering this to be an error.

Signed-off-by: David Brown <davidb@davidb.org>

Cleanly separate enablement of Rust support from a `USE_RUST` that can
be used when invoking make, and `HAVE_RUST` that is defined internally
when rust support is enabled. This allows targets to decide for
themselves if Rust support is needed, or if it is optional.

The definitive decision about rust support will be determined if a
platform makefile includes `lib/rust_support/rules.mk` to include Rust
support in the build. It can optional do this based on a use-defined
`USE_RUST` flag.

Signed-off-by: David Brown <davidb@davidb.org>

The variable RUST_CRATES contains a list of paths (from the build root)
to crates to add. For each crate: generate a call to
`cratename::must_link()` to force the crate to be linked in, allowing lk
init blocks to be included.

This makes the pl011 crate a module, so the crate will be included when
the module is included.

Signed-off-by: David Brown <davidb@davidb.org>

This creates an very basic rust hello world app. The app declaration is
done through unsafe C, but this is sufficient to demonstrate building
and linking a rust app into LK.

Signed-off-by: David Brown <davidb@davidb.org>

Create a framework for defining LK applications in Rust, simplifying app
creation and management.  The `LkApp` trait can be applied to a type,
with the `lkapp!` macro then generating the boilerplate needed to
integrate the app with LK.

Signed-off-by: David Brown <davidb@davidb.org>

An anchor function reference is needed to make sure the linker includes
things from the rust .a files. Previously was defined in qemu-virt-arm64
but since rust is a general feature, move it into top/main.c

-Separate the two pl011 drivers so they do not need to be aware of each
other:
  - make sure the platform selects the right one
  - have the rust one make a copy of the header for C code to interact
    with
- Make the top level rust modules (app/rust_hello, rust/dev-pl011) use
  the LK module.mk which can now deal with empty modules. This cleans up
  the deps a little bit and uses existing machinery to add include
  paths.
- Move the logic to select rust modules into the qemu-virt-arm64 project
  and have it conditionally include a new virtual project file that
  encapsulates rust deps. Will need to refacto this a bit later as more
  platform/projects make use of rust, but at least moves it up to the
  project level instead of down in a single platform.