more punctuation

Properly capitalize PathConversion

Normalize MIRI_TEMP before using it

Move `convert_path_separator` to trait and use it in `readlink`

Swap order of assertions for easier debugging

Make helper functions freestanding

Add trailing punctuation

Co-authored-by: Ralf Jung <post@ralfj.de>

Merge `fs` and `fs_libc` tests

Use panicking coversions instead of `as`

Move some helper functions around

Implement `readlink`

Due to the truncating behavior of `readlink`, I was not able to
directly use any of the existing C-cstring helper functions.

Auto merge of #1563 - lzutao:dummy-actions, r=RalfJung

Add a dummy actions template to enable it on CI

I already had a complete template to transition from Travis and Appveyor.
Since actions will not run on repo haven't enabled it before.
I have this dummy template first to enable it on default branch.
We should address a few todo here, merge it and I will send another patch
to complete the migration.

Add a dummy actions template to enable it on CI

Auto merge of #1570 - RalfJung:syscalls, r=RalfJung

check that all syscall arguments are scalars

`@m-ou-se` do you think this check makes sense?

The `abi` of a layout contains everything needed for the calling convention (as far as I know), so this should ensure that all the ignored arguments are passed like integers and do not otherwise mess up argument passing.

The one thing I am not sure about is what happens when more arguments are passed than fit in registers. The `syscall` man page says that all calling conventions support at least 6 arguments, except for "mips/o32" where it says that
```
       [1] The mips/o32 system call convention passes arguments 5 through 8 on the user stack.
```
If we assume that passing these extra arguments to futex is legal even with that calling convention, that would mean that those user stack arguments are just silently ignored as well, which seems plausible to me -- but I know very little about calling conventions.

check that all syscall arguments are scalars

Auto merge of #1569 - RalfJung:rustup, r=RalfJung

bump Rust version and a bit of cleanup

merge parking test into general synchronization test

add backtics back in isolation error message

rustup

Auto merge of #1568 - fusion-engineering-forks:futex, r=RalfJung

Implement futex_wait and futex_wake.

Fixes https://github.com/rust-lang/rust/issues/77406 and fixes #1562.

This makes std's park(), park_timeout(), and unpark() work. That means std::sync::Once is usable again and the test pass again with the latest rustc.

This also makes parking_lot work.

Add FIXME about type of `addr` in futex implementation.

Co-authored-by: Ralf Jung <post@ralfj.de>

Add note about use of force_ptr in futex implementation.

Co-authored-by: Ralf Jung <post@ralfj.de>

Update syscall FIXME to include note about 'wrong' types.

Add test for futex syscall.

Add FIXME note about variadic syscall().

Use read_scalar_at_offset in futex_wait instead of memory.get_raw.

Update expected error messages in tests.

Remove backtics from isolation error.

Otherwise `FUTEX_WAIT with timeout` will look weird.

Only allow FUTEX_WAIT with timeout when isoloation is disabled.

Use correct return type for syscall(SYS_futex).

Add park/park_timeout/unpark test.

Implement timeouts for FUTEX_WAIT.

Use force_ptr in futex implementation.

Add note about arguments in futex implementation.

Co-authored-by: Ralf Jung <post@ralfj.de>

Update note about number of arguments to SYS_futex.

Add comments that document SYS_futex better.

Improve handling of the `addr` argument in SYS_futex.

Check maximum amount of arguments to SYS_futex.

Return correct value from futex_wait.

Only check futex pointer in futex_wait and not in futex_wake.

futex_wake doesn't access the futex itself, so should accept pointers to
memory that's no longer there.

Erase tag from futex pointers.

Move futex syscall to its own file.

Implement futex_wait and futex_wake.

This does not support futex_wait with a timeout yet.

Auto merge of #1566 - RalfJung:backtrace, r=RalfJung

normalize backtrace stderr even more

The test previously failed on rustc CI with this diff:
```
 $DIR/backtrace-api.rs:21:59 (func_c)
 $DIR/backtrace-api.rs:20:53 (func_b)
 $DIR/backtrace-api.rs:19:50 (func_a)
 $DIR/backtrace-api.rs:25:18 (main)
-RUSTLIB/src/rust/library/core/src/ops/function.rs:LL:COL (<fn() as std::ops::FnOnce<()>>::call_once - shim(fn()))
-RUSTLIB/src/rust/library/std/src/sys_common/backtrace.rs:LL:COL (std::sys_common::backtrace::__rust_begin_short_backtrace)
-RUSTLIB/src/rust/library/std/src/rt.rs:LL:COL (std::rt::lang_start::{closure#0})
-RUSTLIB/src/rust/library/core/src/ops/function.rs:LL:COL (std::ops::function::impls::call_once)
-RUSTLIB/src/rust/library/std/src/panicking.rs:LL:COL (std::panicking::r#try::do_call)
-RUSTLIB/src/rust/library/std/src/panicking.rs:LL:COL (std::panicking::r#try)
-RUSTLIB/src/rust/library/std/src/panic.rs:LL:COL (std::panic::catch_unwind)
-RUSTLIB/src/rust/library/std/src/rt.rs:LL:COL (std::rt::lang_start_internal)
-RUSTLIB/src/rust/library/std/src/rt.rs:LL:COL (std::rt::lang_start)
+/checkout/library/core/src/ops/function.rs:227:5 (<fn() as std::ops::FnOnce<()>>::call_once - shim(fn()))
+/checkout/library/std/src/sys_common/backtrace.rs:137:18 (std::sys_common::backtrace::__rust_begin_short_backtrace)
+/checkout/library/std/src/rt.rs:66:18 (std::rt::lang_start::{closure#0})
+/checkout/library/core/src/ops/function.rs:259:13 (std::ops::function::impls::call_once)
+/checkout/library/std/src/panicking.rs:381:40 (std::panicking::r#try::do_call)
+/checkout/library/std/src/panicking.rs:345:19 (std::panicking::r#try)
+/checkout/library/std/src/panic.rs:382:14 (std::panic::catch_unwind)
+/checkout/library/std/src/rt.rs:51:25 (std::rt::lang_start_internal)
+/checkout/library/std/src/rt.rs:65:5 (std::rt::lang_start)
```
Cc `@Aaron1011`

normalize backtrace stderr even more

Auto merge of #1565 - RalfJung:rustup, r=RalfJung

rustup; adjust for rustc_driver changes

rustup; adjust for rustc_driver changes

Auto merge of #1559 - Aaron1011:new-miri-backtrace, r=RalfJung

Add API for capturing backtrace

This PR adds two new Miri-defined extern functions:
`miri_get_backtrace` and `miri_resolve_frame`, which are documented in
the README. Together, they allow obtaining a backtrace for the currently
executing program.

I've added a test showing how these APIs are used. I've also prepared a
companion PR `backtrace-rs`, which will allow
`backtrace::Backtrace::new()` to work automatically under Miri.

Once these two PRs are merged, we will be able to print backtraces from
the normal Rust panic hook (since libstd is now using backtrace-rs).

A few notes:
* Resolving the backtrace frames is *very* slow - you can actually see
  each line being printed out one at a time. Some local testing showed
  that this is not (primrary) caused by resolving a `Span` - it seems
  to be just Miri being slow.
* For the first time, we now interact directly with a user-defined
  struct (instead of just executing the user-provided MIR that
  manipulates the struct). To allow for future changes, I've added
  a 'version' parameter (currently required to be 0). This should allow
  us to change the `MiriFrame` struct should the need ever arise.
* I used the approach suggested by `@oli-obk` - a returned backtrace
  pointer consists of a base function allocation, with the 'offset'
  used to encode the `Span.lo`. This allows losslessly reconstructing
  the location information in `miri_resolve_frame`.
* There are a few quirks on the `backtrace-rs` side:
  * `backtrace-rs` calls `getcwd()` by default to try to simplify
    the filename. This results in an isolation error by default,
    which could be annoying when printing a backtrace from libstd.
  * `backtrace-rs` tries to remove 'internal' frames (everything between
     the call to `Backtrace::new()` and the internal API call made by
     backtrace-rs) by comparing the returned frame pointer value to
     a Rust function pointer. This doesn't work due to the way we
     construct the frame pointers passed to the caller. We could
     attempt to support this kind of comparison, or just add a
    `#[cfg(miri)]` and ignore the frames ourselves.

Normalize out generic arguments in backtrace-api stderr

fix typo

Require #[repr(C)] on MiriFrame

Apply #[inline(never)] to functions that we want in the backtrace

Update README

Make some error messages lowercase

Explain encoding scheme

Move things around

Print non-std frames to stdout in `backtrace-api` test

Use a 'flags' parameter instead of 'version'

Normalize line and column numbers from the sysroot

Add API for capturing backtrace

This PR adds two new Miri-defined extern functions:
`miri_get_backtrace` and `miri_resolve_frame`, which are documented in
the README. Together, they allow obtaining a backtrace for the currently
executing program.

I've added a test showing how these APIs are used. I've also prepared a
companion PR `backtrace-rs`, which will allow
`backtrace::Backtrace::new()` to work automatically under Miri.

Once these two PRs are merged, we will be able to print backtraces from
the normal Rust panic hook (since libstd is now using backtrace-rs).

A few notes:
* Resolving the backtrace frames is *very* slow - you can actually see
  each line being printed out one at a time. Some local testing showed
  that this is not (primrary) caused by resolving a `Span` - it seems
  to be just Miri being slow.
* For the first time, we now interact directly with a user-defined
  struct (instead of just executing the user-provided MIR that
  manipulates the struct). To allow for future changes, I've added
  a 'version' parameter (currently required to be 0). This should allow
  us to change the `MiriFrame` struct should the need ever arise.
* I used the approach suggested by @oli-obk - a returned backtrace
  pointer consists of a base function allocation, with the 'offset'
  used to encode the `Span.lo`. This allows losslessly reconstructing
  the location information in `miri_resolve_frame`.
* There are a few quirks on the `backtrace-rs` side:
  * `backtrace-rs` calls `getcwd()` by default to try to simplify
    the filename. This results in an isolation error by default,
    which could be annoying when printing a backtrace from libstd.
  * `backtrace-rs` tries to remove 'internal' frames (everything between
     the call to `Backtrace::new()` and the internal API call made by
     backtrace-rs) by comparing the returned frame pointer value to
     a Rust function pointer. This doesn't work due to the way we
     construct the frame pointers passed to the caller. We could
     attempt to support this kind of comparison, or just add a
    `#[cfg(miri)]` and ignore the frames ourselves.

Auto merge of #1555 - lzutao:upstream-assume-const, r=RalfJung

Remove assume intrinsic from EvalContextExt

Waiting for https://github.com/rust-lang/rust/pull/76973 merged.

Remove assume intrinsic from EvalContextExt

It has been moved to rustc_mir.

Auto merge of #1561 - RalfJung:rustup, r=RalfJung

rustup; fix tests

rustup; fix tests

Auto merge of #1560 - RalfJung:rustup, r=RalfJung

opt-level 3 is clean again :)

opt-level 3 is clean again :)

Auto merge of #1558 - RalfJung:serde_derive, r=RalfJung

test formerly broken serde_derive dependency

Adds a test for the issue fixed in https://github.com/rust-lang/miri/pull/1557

test formerly broken serde_derive dependency

Auto merge of #1557 - RalfJung:cargo-miri, r=RalfJung

support non-rlib extern files

This came up in https://github.com/hsivonen/encoding_rs/pull/57.

support non-rlib extern files

Auto merge of #1556 - RalfJung:compat, r=RalfJung

also support old 'cargo miri run -- -- args' style

I forgot this in https://github.com/rust-lang/miri/pull/1540. Again this is just temporary, for backwards compatibility.

also support old 'cargo miri run -- -- args' style

Auto merge of #1554 - RalfJung:rustup, r=RalfJung

rustup; support panic=abort on Windows

Fixes https://github.com/rust-lang/miri/issues/1058

rustup; support panic=abort on Windows

Auto merge of #1553 - RalfJung:rustup, r=RalfJung

rustup

Cc `@oli-obk`

rustup

Auto merge of #1552 - RalfJung:rustup, r=RalfJung

rustup; make sure the generator moves even with smarter optimizations

account for mir-opts masking more errors

rustup; make sure the iterator moves even with smarter optimizations

Auto merge of #1551 - RalfJung:readme, r=RalfJung

list two more aliasing problems we found in BTreeMap and VecDeque

list two more aliasing problems we found in BTreeMap and VecDeque

Auto merge of #1549 - RalfJung:panic-abort, r=oli-obk

support panic=abort

This adds support for abort-on-panic (https://github.com/rust-lang/miri/issues/1058). To achieve this, we insert `cargo-miri` as `RUSTC` when building the standard library, and patch the rustc flags in a way similar to what bootstrap does.

However, this is currently not supported on Windows as the Windows code uses inline assembly to cause an abort (?!?). I'll submit a rustc PR with some `cffg(miri)` to make that work. (EDIT: that would be https://github.com/rust-lang/rust/pull/76871)

Cc `@Aaron1011` r? `@oli-obk`

fmt

Co-authored-by: Oli Scherer <github35764891676564198441@oli-obk.de>

support panic=abort

Auto merge of #1548 - RalfJung:update, r=RalfJung

Update dependencies

update for major version bumps

'cargo update' test-cargo-miri

cargo update main crates

Auto merge of #1540 - RalfJung:cargo-miri-redone, r=oli-obk

Redo cargo-miri logic

This rewrite the cargo-miri logic for running the requested crate(s) following what we outlined in https://github.com/rust-lang/miri/issues/739: `cargo miri run/test $FLAGS` (almost) literally invokes `cargo run/test $FLAGS` but with some environment variables set so that we can control what happens:
* `RUSTC_WRAPPER` is set so that we get invoked instead of `rustc`. We use that power to mess with the flags being used for the build (things to be interpreted by Miri use a different sysroot), and when we are detecting a binary crate meant to be run by Miri, we grab the info we care about and put it into a JSON file for later use.
* `CARGO_TARGET_$TARGET_RUNNER` is set so what we get invoked when cargo wants to run a binary. At that point we take that JSON info from before and use it to invoke Miri.

Overall this works great! We get all sorts of cargo magic for free, and do not even need `cargo-metadata` any more. There's one annoying point though, which I have not managed to entirely work around yet: this means we are doing a full build, not just a check-build. Given that our sysroot is MIR-only, I was surprised that this even worked, but still -- this means we are doing more work than we should. So I also added some patching of arguments to make sure `--emit` does not contain `link`, and then more patching was required of the `--extern` flags for the binary because those referenced the `.rlib` files but now only `.rmeta` exists, and that is still not fully working because cargo seems to expect those `.rmeta` files and now triggers a rebuild each time as those files are still missing. My current plan is to make our wrapper create some empty dummy files with the right names, but the amount of hacks we are stacking on top of each other here is getting worrysome.^^ `@ehuss` your input would be welcome on this issue.

Due to re-using cargo more literally, this also changes flag parsing to match `cargo`. So `-Zmiri` flags now have to be passed via an environment variable (Cc https://github.com/rust-lang/miri/issues/1416).

This PR is not ready yet, but the parts that are there I think can be reviewed already. TODO:
* [x] [Fix Windows](https://github.com/rust-lang/miri/pull/1540#issuecomment-688733741).
* [x] Figure out how we can do check-only builds without the rebuild problem above. ~~I am also worried about cases where `build.rs` script might detect check-only builds and then do less work; I think some crates in rustc are doing that and if this is a thing in the wider ecosystem we need to find a way to support this as well.~~ (postponed that until we have a concrete example)
* [x] Currently cargo runs doctests as well, and they are not run in Miri. We should at least figure out a way to not run them at all (resolving https://github.com/rust-lang/miri/issues/584 is left for a future PR).
* [x] For some time, detect the old way of passing `-Zmiri` flags and warn that this will need updating. For some simple situations we can probably make it still support the old way, but I plan to remove those hacks after a bit. This is just to give people and me time to go around and send PRs to all projects that use Miri on CI, and update their use of the flags.
* [x] Add a test for stdin handling (https://github.com/rust-lang/miri/issues/1505). This should work now but we should be sure.
* [x] Add a test for cargo env vars (https://github.com/rust-lang/miri/issues/1515).
* [x] Check if https://github.com/rust-lang/miri/issues/1516 is resolved.
* [x] Check if https://github.com/rust-lang/miri/issues/1001 and https://github.com/rust-lang/miri/issues/1514 are resolved.
* [x] Check if https://github.com/rust-lang/miri/issues/1312 is resolved (not sure if it is wort adding a test).
* [x] Check if https://github.com/rust-lang/miri/issues/1512 is resolved (not sure if it is wort adding a test).

Fixes https://github.com/rust-lang/miri/issues/700.
Fixes https://github.com/rust-lang/miri/issues/739.
Fixes https://github.com/rust-lang/miri/issues/1001.
Fixes https://github.com/rust-lang/miri/issues/1312 (without a test, as we run without cargo's stdin/stdout wrapping now, as the test for stdin confirms).
Fixes https://github.com/rust-lang/miri/issues/1416.
Fixes https://github.com/rust-lang/miri/issues/1505.
Fixes https://github.com/rust-lang/miri/issues/1512 (without a test, as cargo now does all that handling anyway, which various other tests confirm).
Fixes https://github.com/rust-lang/miri/issues/1514.
Fixes https://github.com/rust-lang/miri/issues/1516.

Cc `@alecmocatta` who reported many of the bugs above; would be great if you could help with the tests e.g. by providing some small examples I could try.
r? `@oli-obk`

Auto merge of #1547 - RalfJung:rustup, r=RalfJung

rustup; no need to special-case the guaranteed_eq/ne intrinsics any more

rustup; no need to special-case the guaranteed_eq/ne intrinsics any more

add comment mentioning alternative approach

test-cargo-miri: normalize slashes before comparing paths

make sure tests pass even with RUST_TEST_NOCAPTURE set

make (not yet actually used) doctest actually use the crate, and fix a comment

more consistent error capitalization

cleaner output for cargo-miri-test harness

make sure subcrate tests have the right cwd

test 'cargo miri run' CWD, also for subcrate in a workspace

test propagating env vars from build.rs to binary