Development of rust applications in the openwrt router system of MIPS Platform

Target

Use the rust language to develop application software on the MIPs (EL) + openwrt router platform.

Compile rustc

First, compile the source code of the rust compiler and generate the cross compiler rustc that supports the mipsel-Linux platform.

[Plain]View plaincopy

1. ./Configure -- target = mipsel-Linux & make install

Note that during the compilation process, the MIPs (EL) + openwrt platform development kit SDK will be called, specifically, mipsel-Linux-GCC and mipsel-Linux-ar. However, the tool naming format in the SDK is mipsel-openwrt-Linux-uclibc-gcc/AR, which is different from that in the rust compiling script. A simple method is to create a symbolic link file:

[Plain]View plaincopy

1. CD/path/to/openwrt/SDK/toolchain
2. Ln-s mipsel-openwrt-Linux-uclibc-GCC mipsel-Linux-gcc
3. Ln-s mipsel-openwrt-Linux-uclibc-ar mipsel-Linux-ar

Use the rust standard library std

Compile the source file histd. RS:

[CPP]View plaincopy

1. FN main (){
2. Println! ("Hi rust! (Uses std crate )");
3. }

Compile histd:

[Plain]View plaincopy

1. Rustc -- target = mipsel-Linux-C linker = mipsel-Linux-GCC histd. RS

The executable file histd under the target platform will be generated. The file size is 1,389,884 bytes, about 1.32 MB, which is quite large! Vro devices are almost unacceptable.

This is an executable file generated by static compilation without additional Runtime Library dependencies. Strictly speaking, it only depends on libc. So in the target system. Of course, if you do not need to output text to the console, you do not need libc. So.

Use the rust core library (without the standard library STD)

Compile the source file hicore. RS:

[CPP]View plaincopy

1. #! [No_std]
2. #! [Feature (lang_items)]
4. Extern crate libc;
5. Extern crate core;
7. Use libc: puts;
8. Use core: intrinsics: transmute;
10. # [Start]
11. FN start (_ argc: int, _ argv: * const u8)-> int {
12. Let s = "Hi rust! (Uses core CRATE) \ 0 "; // & Str
13. Unsafe {
14. Let (S, _): (* const i8, uint) = transmute (s); // see core: Raw: Slice
15. Puts (s );
16. }
17. Return 0;
18. }
20. # [Lang = "stack_exhausted"] extern FN stack_exhausted (){}
21. # [Lang = "eh_personality"] extern FN eh_personality (){}
23. # [Lang = "begin_unwind"]
24. Extern FN begin_unwind (_ ARGs: & core: FMT: arguments,
25. _ File: & STR,
26. _ Line: uint)->! {
27. Loop {}
28. }

Compile hicore. RS:

[Plain]View plaincopy

1. Rustc -- target = mipsel-Linux-C linker = mipsel-Linux-GCC hicore. RS

The executable file hicore under the target platform will be generated. The file size is only 6556 bytes, which is quite small!

This is an executable file generated by static compilation without additional Runtime Library dependencies. Strictly speaking, it only depends on libc. So in the target system. Of course, if you do not need to output text to the console, you do not need libc. So.

No standard library STD, no core library CORE, pure streaking

Compile the source code hi. RS:

[CPP]View plaincopy

1. #! [No_std]
2. #! [Feature (lang_items)]
3. #! [Feature (intrinsics)]
5. # [LINK (name = "C")]
6. Extern {
7. FN puts (S: * const u8 );
8. }
10. # [Start]
11. FN start (_ argc: int, _ argv: * const u8)-> int {
12. Let s = "Hi rust! \ 0 "; // & Str
13. Unsafe {
14. Let (S, _): (* const u8, uint) = transmute (s); // see core: Raw: Slice
15. Puts (s );
16. }
17. Return 0;
18. }
20. # [Lang = "stack_exhausted"] extern FN stack_exhausted (){}
21. # [Lang = "eh_personality"] extern FN eh_personality (){}
23. Extern "Rust-intrinsic "{
24. FN transmute <t, u> (X: T)-> U;
25. }

Compile hi. RS:

[Plain]View plaincopy

1. Rustc -- target = mipsel-Linux-C linker = mipsel-Linux-GCC hi. RS

The executable file hi under the target platform will be generated. The file size is only 6504 bytes, which is quite small! It is smaller than the hicore that uses the core library core, but the difference is not big.

This is an executable file generated by static compilation without additional Runtime Library dependencies. Strictly speaking, it only depends on libc. So in the target system. Of course, if you do not need to output text to the console, you do not need libc. So.

Comparison of executable file sizes

Histd compiled using the rust standard library STD, hicore compiled using the rust core library CORE, and hicore generated without the standard library or core library compilation, the size of executable files of the three is compared as follows:

[Plain]View plaincopy

1. -Rwxr-XR-x 1 liigo 1389884 20:20 histd
2. -Rwxr-XR-x 1 liigo 6556 September 17 20:19 hicore
3. -Rwxr-XR-x 1 liigo 6504 September 17 20:19 hi

The histd program compiled using the standard library STD is too large and is not suitable for embedded devices. It is eliminated first. The hicore program compiled using the core library CORE is very small and comparable to the hicore program that does not use any library. Since core of the core library is not used, the file size remains unchanged, and core of the core library can bring a lot of coding convenience, it is recommended to use core of the core library in the embedded platform.

The above is the situation of the mipsel-Linux platform. Below as a comparison, let's look at the x86_64-unknown-linux-gnu platform:

[Plain]View plaincopy

1. -Rwxr-XR-x 1 liigo 1004136 20:16 histd
2. -Rwxr-XR-x 1 liigo 8203 September 17 20:16 hicore
3. -Rwxr-XR-x 1 liigo 8159 September 17 20:16 hi

After comparison, it is found that the executable files on the x86_64 platform are slightly larger than those on the mipsel platform, but the gap is not big, and the situation is similar.

Target triples)

Information Source: https://github.com/rust-lang/rust/blob/master/mk/platform.mk

[Plain]View plaincopy

1. X86_64-unknown-linux-gnu
2. I686-unknown-linux-gnu
3. Arm-apple-Ios
4. I386-apple-ios
5. X86_64-apple-darwin
6. I686-apple-darwin
7. Arm-Linux-androideabi
8. Arm-unknown-Linux-gnueabihf
9. Arm-unknown-Linux-gnueabi
10. Mipsel-Linux
11. MIPs-unknown-Linux-GNU
12. I586-mingw32msvc
13. I686-w64-mingw32
14. X86_64-w64-mingw32
15. X86_64-unknown-freebsd
16. X86_64-pc-dragonfly-elf

Usage:

Compile rust itself:./configure -- target = triple1, triple2 & make install

Compile the rust program: rustc -- target = triple-C linker = triple-gcc

If necessary, create a symbolic link file, such as triple-gcc/triple-AR, for the SDK compilation tool of the Cross-compilation platform.

Development of rust applications in the openwrt router system of MIPS Platform