rust/tests/ui/issues/issue-3656.rs

// run-pass
#![allow(dead_code)]
#![allow(improper_ctypes)]
// Issue #3656
// Incorrect struct size computation in the FFI, because of not taking
// the alignment of elements into account.

// pretty-expanded FIXME #23616
// ignore-wasm32-bare no libc to test with
#![feature(rustc_private)]

extern crate libc;
use libc::{c_uint, c_void};

pub struct KEYGEN {
    hash_algorithm: [c_uint; 2],
    count: u32,
    salt: *const c_void,
    salt_size: u32,
}

extern "C" {
    // Bogus signature, just need to test if it compiles.
    pub fn malloc(data: KEYGEN);
}

pub fn main() {}
Add `// run-pass` annotations to all the tests under `ui/run-pass/`. (I may have accidentally added it to some auxilliary crates as well; my emacs-macro-based methodology was pretty crude.) 2018-08-30 12:18:55 +00:00			`// run-pass`
Add `#![allow(..)]` as necessary to get re-migrated run-pass tests compiling with clean stderr again. Most were added mechanically. 2018-09-25 21:51:35 +00:00			`#![allow(dead_code)]`
Add `#[allow(improper_ctypes)]` to slew of cases that need e.g. `repr(C)`. See also rust-lang/rust#53858. 2018-08-31 13:51:35 +00:00			`#![allow(improper_ctypes)]`
rustc: fix size computation of structs for the FFI It didn't take alignment into account. Fixes #3656. 2012-10-10 20:40:17 +00:00			`// Issue #3656`
			`// Incorrect struct size computation in the FFI, because of not taking`
			`// the alignment of elements into account.`

rustdoc: Replace no-pretty-expanded with pretty-expanded Now that features must be declared expanded source often does not compile. This adds 'pretty-expanded' to a bunch of test cases that still work. 2015-03-22 20:13:15 +00:00			`// pretty-expanded FIXME #23616`
std: Add a new wasm32-unknown-unknown target This commit adds a new target to the compiler: wasm32-unknown-unknown. This target is a reimagining of what it looks like to generate WebAssembly code from Rust. Instead of using Emscripten which can bring with it a weighty runtime this instead is a target which uses only the LLVM backend for WebAssembly and a "custom linker" for now which will hopefully one day be direct calls to lld. Notable features of this target include: * There is zero runtime footprint. The target assumes nothing exists other than the wasm32 instruction set. * There is zero toolchain footprint beyond adding the target. No custom linker is needed, rustc contains everything. * Very small wasm modules can be generated directly from Rust code using this target. * Most of the standard library is stubbed out to return an error, but anything related to allocation works (aka `HashMap`, `Vec`, etc). * Naturally, any `#[no_std]` crate should be 100% compatible with this new target. This target is currently somewhat janky due to how linking works. The "linking" is currently unconditional whole program LTO (aka LLVM is being used as a linker). Naturally that means compiling programs is pretty slow! Eventually though this target should have a linker. This target is also intended to be quite experimental. I'm hoping that this can act as a catalyst for further experimentation in Rust with WebAssembly. Breaking changes are very likely to land to this target, so it's not recommended to rely on it in any critical capacity yet. We'll let you know when it's "production ready". --- Currently testing-wise this target is looking pretty good but isn't complete. I've got almost the entire `run-pass` test suite working with this target (lots of tests ignored, but many passing as well). The `core` test suite is still getting LLVM bugs fixed to get that working and will take some time. Relatively simple programs all seem to work though! --- It's worth nothing that you may not immediately see the "smallest possible wasm module" for the input you feed to rustc. For various reasons it's very difficult to get rid of the final "bloat" in vanilla rustc (again, a real linker should fix all this). For now what you'll have to do is: cargo install --git https://github.com/alexcrichton/wasm-gc wasm-gc foo.wasm bar.wasm And then `bar.wasm` should be the smallest we can get it! --- In any case for now I'd love feedback on this, particularly on the various integration points if you've got better ideas of how to approach them! 2017-10-23 03:01:00 +00:00			`// ignore-wasm32-bare no libc to test with`
std: Depend directly on crates.io crates Ever since we added a Cargo-based build system for the compiler the standard library has always been a little special, it's never been able to depend on crates.io crates for runtime dependencies. This has been a result of various limitations, namely that Cargo doesn't understand that crates from crates.io depend on libcore, so Cargo tries to build crates before libcore is finished. I had an idea this afternoon, however, which lifts the strategy from #52919 to directly depend on crates.io crates from the standard library. After all is said and done this removes a whopping three submodules that we need to manage! The basic idea here is that for any crate `std` depends on it adds an optional dependency on an empty crate on crates.io, in this case named `rustc-std-workspace-core`. This crate is overridden via `[patch]` in this repository to point to a local crate we write, and that has a `path` dependency on libcore. Note that all `no_std` crates also depend on `compiler_builtins`, but if we're not using submodules we can publish `compiler_builtins` to crates.io and all crates can depend on it anyway! The basic strategy then looks like: * The standard library (or some transitive dep) decides to depend on a crate `foo`. * The standard library adds ```toml [dependencies] foo = { version = "0.1", features = ['rustc-dep-of-std'] } ``` * The crate `foo` has an optional dependency on `rustc-std-workspace-core` * The crate `foo` has an optional dependency on `compiler_builtins` * The crate `foo` has a feature `rustc-dep-of-std` which activates these crates and any other necessary infrastructure in the crate. A sample commit for `dlmalloc` [turns out to be quite simple][commit]. After that all `no_std` crates should largely build "as is" and still be publishable on crates.io! Notably they should be able to continue to use stable Rust if necessary, since the `rename-dependency` feature of Cargo is soon stabilizing. As a proof of concept, this commit removes the `dlmalloc`, `libcompiler_builtins`, and `libc` submodules from this repository. Long thorns in our side these are now gone for good and we can directly depend on crates.io! It's hoped that in the long term we can bring in other crates as necessary, but for now this is largely intended to simply make it easier to manage these crates and remove submodules. This should be a transparent non-breaking change for all users, but one possible stickler is that this almost for sure breaks out-of-tree `std`-building tools like `xargo` and `cargo-xbuild`. I think it should be relatively easy to get them working, however, as all that's needed is an entry in the `[patch]` section used to build the standard library. Hopefully we can work with these tools to solve this problem! [commit]: https://github.com/alexcrichton/dlmalloc-rs/commit/28ee12db813a3b650a7c25d1c36d2c17dcb88ae3 2018-11-20 05:52:50 +00:00			`#![feature(rustc_private)]`
Require feature attributes, and add them where necessary 2015-03-06 02:33:58 +00:00
Fix fallout from std::libc separation 2014-02-26 17:58:41 +00:00			`extern crate libc;`
Fix test of issue 3656 2019-06-01 13:37:54 +00:00			`use libc::{c_uint, c_void};`
rustc: fix size computation of structs for the FFI It didn't take alignment into account. Fixes #3656. 2012-10-10 20:40:17 +00:00
librustc: Forbid private types in public APIs. This breaks code like: struct Foo { ... } pub fn make_foo() -> Foo { ... } Change this code to: pub struct Foo { // note `pub` ... } pub fn make_foo() -> Foo { ... } The `visible_private_types` lint has been removed, since it is now an error to attempt to expose a private type in a public API. In its place a `#[feature(visible_private_types)]` gate has been added. Closes #16463. RFC #48. [breaking-change] 2014-09-19 19:30:07 +00:00			`pub struct KEYGEN {`
Allow use of `[_ ; n]` syntax for fixed length and repeating arrays. This does NOT break any existing programs because the `[_, ..n]` syntax is also supported. 2014-12-20 02:20:51 +00:00			`hash_algorithm: [c_uint; 2],`
Fix test of issue 3656 2019-06-01 13:37:54 +00:00			`count: u32,`
Rename all raw pointers as necessary 2014-06-25 19:47:34 +00:00			`salt: *const c_void,`
Fix test of issue 3656 2019-06-01 13:37:54 +00:00			`salt_size: u32,`
rustc: fix size computation of structs for the FFI It didn't take alignment into account. Fixes #3656. 2012-10-10 20:40:17 +00:00			`}`

Update tests for extern block linting 2020-09-01 21:12:52 +00:00			`extern "C" {`
rustc: fix size computation of structs for the FFI It didn't take alignment into account. Fixes #3656. 2012-10-10 20:40:17 +00:00			`// Bogus signature, just need to test if it compiles.`
test: Fix tests. 2013-05-08 04:33:31 +00:00			`pub fn malloc(data: KEYGEN);`
rustc: fix size computation of structs for the FFI It didn't take alignment into account. Fixes #3656. 2012-10-10 20:40:17 +00:00			`}`

Update tests for extern block linting 2020-09-01 21:12:52 +00:00			`pub fn main() {}`