Wrapper complains stable-i686-pc-windows-gnu isn’t installed even though stable-x86_64-pc-windows-msvc is #1333

Comments

Arnavion commented Jan 5, 2018

And, possibly related to #1332:

The text was updated successfully, but these errors were encountered:

Diggsey commented May 30, 2018

This is the expected behaviour if your Default Host is set to i686-pc-windows-gnu

You can see this on the first line of output from rustup show .

You can change your default host with rustup set default-host . However, if your host really is 32-bit, you will not be able to use 64-bit toolchains, even though you can install them.

Arnavion commented May 30, 2018 •

Yes, I did notice that it stopped being a search of installed toolchains and started being determined based on the default-host setting (this change is probably why the readme is also inconsistent, as in #1332 ).

Now I’m not sure why the default-host for Windows is set to i686 when Linux does default to x86_64. I assume because 32-bit Windows is popular enough that you want rustup users to be able to target 32-bit Windows by default even if they themselves are on 64-bit Windows?

Diggsey commented May 30, 2018

The behaviour hasn’t changed here: it’s always been based off the host target, and has never searched installed toolchains.

The readme is likely inconsistent because it was written assuming a 64-bit host, and the way in which the «default host» was selected has changed to now prefer 32-bit. (Although it will remember your previous selection)

I believe the rationale for this change is that both toolchains can target both 32-bit and 64-bit windows via rustup target add , and so it makes most sense to install a 32-bit version of rustc, since that will run anywhere.

Arnavion commented May 30, 2018

and the way in which the «default host» was selected has changed to now prefer 32-bit.

Ah, that would make sense. I guess I misatttributed the original behavior to searching based on the toolchain names. Thanks.

cross compiling and statically linking against Rust libraries

At CSIS we have traditionally written our back-end in Python, together with some C/C++ code for our Incident Response Toolkit.

A few years ago, mainly due to performance reasons, we started rewriting specific back-end services from Python to Rust, with great success. Now, for the sake of ease of development and testing, we are exploring the idea of moving parts of our C/C++ code base to Rust, too.

In order to do so, instead of re-writing everything in one swoop, we decided to try integrating Rust into our existing code base.

Following is a summary of our experiments, and a skeleton for writing a Rust library and calling it from a C/C++ application.

Targets

In order to be able to cross compile code, we need to first make sure that we have the desired targets installed. A list of available targets can be obtained via rustc —print target-list and new ones can be installed via rustup target add .

Installed targets can be shown with rustup show :

Project Setup

Once the targets have been properly setup we need to setup our project. Starting with Cargo.toml :

Now the source code for our library src/lib.rs :

And the code for our application caller.cpp :

If this were a C application, only the extern «C» needed to be removed.

Next we need to indicate our desired target, which is done in .cargo/config , for example:

Linux binaries

In order to statically link Linux binaries the target needs to be set to -linux-musl .

Alternatively we could choose x86_64-unknown-linux-musl for 64 bit binaries.

If we were targeting 64 bit, the -m32 option needed to be removed and the -L flag adjusted accordingly.

Windows Binaries

In order to statically link Windows binaries the target needs to be set to -pc-windows-gnu . In the case of 32 bit binaries special care is needed with regards to the exception handling model. A good summary can be found on the “rust-lang” Github repository and on stack overflow.

Alternatively we could choose x86_64-pc-windows-gnu for 64 bit binaries. If this were the case, the rustflags option could be removed.

If the target was a 64bit environment, x86_64-w64-mingw32-g++ should be used instead and the -L flag adjusted accordingly.

Conclusion

With this post we hope to have provided a simple, working example of how Rust and C/C++ can inter-operate, which can be used as a starting point.

We would like to thank the contributors of the resources linked below.

Resources

This post was a summary of the information found in the following links

CSIS TechBlog

CSIS Security Group software development and security…

error: toolchain ‘nightly-x86_64-pc-windows-msvc’ does not support components #1184

Comments

GrahamBest commented Jun 25, 2017 •

Hey, running
D:\Rust Fixed\testdll>rustup target add i686-pc-windows-msvc
gives me the error
error: toolchain ‘nightly-x86_64-pc-windows-msvc’ does not support components
I have an x64 system. Trying to build a 32 bit DLL. Anyone here have any experience with this?

The text was updated successfully, but these errors were encountered:

Diggsey commented Jun 25, 2017

What is the output of running rustc —version in that directory?

It could be that you have a very very old nightly, from before components were added. If that’s the case, you just need to run rustup update and then try again.

GrahamBest commented Jun 25, 2017

@Diggsey
rustc 1.18.0 (03fc9d622 2017-06-06)

Thats whats outputted. I’lll try rustup update and report my results.

Diggsey commented Jun 25, 2017

@Verideth That’s not right — that version is a stable rust version, but the error you posted previously shows that you’re installing the target for a nightly version of rust.

GrahamBest commented Jun 25, 2017

@Diggsey Yes, I want to use a nightly version of rust. Anyway to fix this?

Diggsey commented Jun 25, 2017

@Verideth Please run these commands in that same directory:

And post the result.

GrahamBest commented Jun 25, 2017 •

GrahamBest commented Jun 25, 2017

Those are my results

Diggsey commented Jun 25, 2017

Uh, you ran where rustup three times 😛 . No matter — the problem is that you’ve installed rust via the installer, and that’s the version of rust that’s on your PATH first, so rustup is not being used.

If you’re using rustup, you don’t need to install rust separately. Remove C:\Program Files\Rust stable GNU 1.18\bin\ from your PATH environment variable, and uninstall it if you don’t need it anymore.

Once you’ve done that, run rustc —version . Previously this would have been very old (hence the error about components) but now that you’ve done a rustup update is should be a recent version, and you should be able to manage targets successfully.

GrahamBest commented Jun 25, 2017

Well @Diggsey I thank you a ton.

It worked somewhat, it changed rustc to nightly. However I’m still having the same problem. I don’t know whats going on! But here take this as a reward 🙂 🥇

I’ll report back if I get it to work

Zbyl commented Oct 6, 2017

I had the same problem.
It worked when I manually installed RLS using Setup instructions from:
https://github.com/rust-lang-nursery/rls

kinnison commented Oct 29, 2019

If you’re encountering similar errors with a modern rustup, please open a fresh issue. I’m closing this one as it hasn’t seen movement in over two years.

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

cross compiling and statically linking against Rust libraries

At CSIS we have traditionally written our back-end in Python, together with some C/C++ code for our Incident Response Toolkit.

A few years ago, mainly due to performance reasons, we started rewriting specific back-end services from Python to Rust, with great success. Now, for the sake of ease of development and testing, we are exploring the idea of moving parts of our C/C++ code base to Rust, too.

In order to do so, instead of re-writing everything in one swoop, we decided to try integrating Rust into our existing code base.

Following is a summary of our experiments, and a skeleton for writing a Rust library and calling it from a C/C++ application.

Targets

In order to be able to cross compile code, we need to first make sure that we have the desired targets installed. A list of available targets can be obtained via rustc —print target-list and new ones can be installed via rustup target add .

Installed targets can be shown with rustup show :

Project Setup

Once the targets have been properly setup we need to setup our project. Starting with Cargo.toml :

Now the source code for our library src/lib.rs :

And the code for our application caller.cpp :

If this were a C application, only the extern «C» needed to be removed.

Next we need to indicate our desired target, which is done in .cargo/config , for example:

Linux binaries

In order to statically link Linux binaries the target needs to be set to -linux-musl .

Alternatively we could choose x86_64-unknown-linux-musl for 64 bit binaries.

If we were targeting 64 bit, the -m32 option needed to be removed and the -L flag adjusted accordingly.

Windows Binaries

In order to statically link Windows binaries the target needs to be set to -pc-windows-gnu . In the case of 32 bit binaries special care is needed with regards to the exception handling model. A good summary can be found on the “rust-lang” Github repository and on stack overflow.

Alternatively we could choose x86_64-pc-windows-gnu for 64 bit binaries. If this were the case, the rustflags option could be removed.

If the target was a 64bit environment, x86_64-w64-mingw32-g++ should be used instead and the -L flag adjusted accordingly.

Conclusion

With this post we hope to have provided a simple, working example of how Rust and C/C++ can inter-operate, which can be used as a starting point.

We would like to thank the contributors of the resources linked below.

Resources

This post was a summary of the information found in the following links

CSIS TechBlog

CSIS Security Group software development and security…

I686 pc windows msvc

The Rust Programming Language

This is the main source code repository for Rust. It contains the compiler, standard library, and documentation.

Note: this README is for users rather than contributors. If you wish to contribute to the compiler, you should read the Getting Started section of the rustc-dev-guide instead.

Installing from Source

The Rust build system uses a Python script called x.py to build the compiler, which manages the bootstrapping process. More information about it can be found by running ./x.py —help or reading the rustc dev guide.

Building on a Unix-like system

Make sure you have installed the dependencies:

• g++ 5.1 or later or clang++ 3.5 or later
• python 3 or 2.7
• GNU make 3.81 or later
• cmake 3.13.4 or later
• ninja
• curl
• git
• ssl which comes in libssl-dev or openssl-devel
• pkg-config if you are compiling on Linux and targeting Linux

Clone the source with git :

Configure the build settings:

The Rust build system uses a file named config.toml in the root of the source tree to determine various configuration settings for the build. Copy the default config.toml.example to config.toml to get started.

If you plan to use x.py install to create an installation, it is recommended that you set the prefix value in the [install] section to a directory.

Create install directory if you are not installing in default directory

Build and install:

When complete, ./x.py install will place several programs into $PREFIX/bin : rustc , the Rust compiler, and rustdoc , the API-documentation tool. This install does not include Cargo, Rust’s package manager. To build and install Cargo, you may run ./x.py install cargo or set the build.extended key in config.toml to true to build and install all tools.

Building on Windows

There are two prominent ABIs in use on Windows: the native (MSVC) ABI used by Visual Studio, and the GNU ABI used by the GCC toolchain. Which version of Rust you need depends largely on what C/C++ libraries you want to interoperate with: for interop with software produced by Visual Studio use the MSVC build of Rust; for interop with GNU software built using the MinGW/MSYS2 toolchain use the GNU build.

MSYS2 can be used to easily build Rust on Windows:

Grab the latest MSYS2 installer and go through the installer.

Run mingw32_shell.bat or mingw64_shell.bat from wherever you installed MSYS2 (i.e. C:\msys64 ), depending on whether you want 32-bit or 64-bit Rust. (As of the latest version of MSYS2 you have to run msys2_shell.cmd -mingw32 or msys2_shell.cmd -mingw64 from the command line instead)

From this terminal, install the required tools:

Navigate to Rust’s source code (or clone it), then build it:

MSVC builds of Rust additionally require an installation of Visual Studio 2017 (or later) so rustc can use its linker. The simplest way is to get the Visual Studio, check the “C++ build tools” and “Windows 10 SDK” workload.

(If you’re installing cmake yourself, be careful that “C++ CMake tools for Windows” doesn’t get included under “Individual components”.)

With these dependencies installed, you can build the compiler in a cmd.exe shell with:

Currently, building Rust only works with some known versions of Visual Studio. If you have a more recent version installed and the build system doesn’t understand, you may need to force rustbuild to use an older version. This can be done by manually calling the appropriate vcvars file before running the bootstrap.

Specifying an ABI

Each specific ABI can also be used from either environment (for example, using the GNU ABI in PowerShell) by using an explicit build triple. The available Windows build triples are:

• GNU ABI (using GCC)
  • i686-pc-windows-gnu
  • x86_64-pc-windows-gnu
• The MSVC ABI
  • i686-pc-windows-msvc
  • x86_64-pc-windows-msvc

The build triple can be specified by either specifying —build= when invoking x.py commands, or by copying the config.toml file (as described in Installing From Source), and modifying the build option under the [build] section.

Configure and Make

While it’s not the recommended build system, this project also provides a configure script and makefile (the latter of which just invokes x.py ).

When using the configure script, the generated config.mk file may override the config.toml file. To go back to the config.toml file, delete the generated config.mk file.

If you’d like to build the documentation, it’s almost the same:

The generated documentation will appear under doc in the build directory for the ABI used. I.e., if the ABI was x86_64-pc-windows-msvc , the directory will be build\x86_64-pc-windows-msvc\doc .

Since the Rust compiler is written in Rust, it must be built by a precompiled «snapshot» version of itself (made in an earlier stage of development). As such, source builds require a connection to the Internet, to fetch snapshots, and an OS that can execute the available snapshot binaries.

Snapshot binaries are currently built and tested on several platforms:

Platform / Architecture	x86	x86_64
Windows (7, 8, 10, . )	✓	✓
Linux (kernel 2.6.32, glibc 2.11 or later)	✓	✓
macOS (10.7 Lion or later)	(*)	✓

(*): Apple dropped support for running 32-bit binaries starting from macOS 10.15 and iOS 11. Due to this decision from Apple, the targets are no longer useful to our users. Please read our blog post for more info.

You may find that other platforms work, but these are our officially supported build environments that are most likely to work.

The Rust community congregates in a few places:

• Stack Overflow — Direct questions about using the language.
• users.rust-lang.org — General discussion and broader questions.
• /r/rust — News and general discussion.

If you are interested in contributing to the Rust project, please take a look at the Getting Started guide in the rustc-dev-guide.

Rust is primarily distributed under the terms of both the MIT license and the Apache License (Version 2.0), with portions covered by various BSD-like licenses.

The Rust programming language is an open source, community project governed by a core team. It is also sponsored by the Mozilla Foundation (“Mozilla”), which owns and protects the Rust and Cargo trademarks and logos (the “Rust Trademarks”).

If you want to use these names or brands, please read the media guide.

Third-party logos may be subject to third-party copyrights and trademarks. See Licenses for details.

About

Empowering everyone to build reliable and efficient software.