Mehdi Akiki
Rust Failure Atlas / failure families

FFI and targets

The host, target, linker, ABI, or libc changes the result.

This page lists all 127 records in this family. 126 of them have a failing and a repaired fixture, and 32 are keyed to a compiler error code. Use the Atlas search to filter by mechanism, first check, or evidence.

Below the application layer

These cases in this family depend on the linker, a native toolchain, the target, a Cargo profile, the test harness, or the runtime. They are also featured on the Atlas front page.

Complete symptom directory

Case identifiers and anchors are stable. Records whose page is not published yet are listed without a link. Records marked “no fixture yet” link to an article and have no executable fixture.

  1. RFA-023 — An FFI struct has `repr(C)` but values are still corrupted across the boundary.No fixture yet
  2. RFA-031 — Reading a `repr(packed)` field by value compiles, but printing or borrowing it fails with E0793.
  3. RFA-039 — A Rust function which appeared in a no-LTO symbol table disappears under LTO, and a foreign host reports that its expected entry point is undefined.
  4. RFA-041 — A native dependency compiles successfully during cross-compilation but produces code for the build host instead of the Rust target.
  5. RFA-044 — A Rust enum passed through C works until a new variant is added or another compiler chooses a different representation.
  6. RFA-045 — A panic reaches an extern boundary and the process aborts or enters behavior the caller cannot safely recover from.
  7. RFA-046 — Memory allocated by Rust or a native library corrupts the heap when the other side releases it.
  8. RFA-094 — Taking a reference to a field of `#[repr(packed)]` produces E0793 even inside unsafe code.
  9. RFA-095 — Reading a Rust union field fails E0133 because the compiler cannot know which field currently contains valid data.
  10. RFA-096 — Calling an `unsafe extern "C" fn` from ordinary Rust code produces E0133.
  11. RFA-097 — A C-variadic declaration using the Rust ABI fails E0045 because that calling convention does not support variadic arguments.
  12. RFA-116 — Calling a function annotated with an extra CPU target feature produces E0133 at an ordinary call site.
  13. RFA-117 — A struct using both packed and align representation modifiers fails E0587 with conflicting hints.
  14. RFA-118 — A repr(transparent) wrapper with two stored numeric fields fails E0690 because both fields contribute non-zero size.
  15. RFA-124 — A const assertion expects a repr(C) u8-plus-u32 structure to use five bytes, but target alignment makes it eight.
  16. RFA-125 — An unsafe extern function declaration type-checks, but final linking fails with an undefined native symbol.
  17. RFA-165 — CStr::from_bytes_with_nul rejects a byte slice containing a valid early NUL terminator because additional bytes follow that terminator.
  18. RFA-171 — Path::join with an absolute candidate discards the intended base on Unix, producing /etc/passwd instead of a path beneath the application directory.
  19. RFA-173 — Command::output returns Ok(Output) for a child that exits with status 7, while application code interpreted Ok as command success.
  20. RFA-177 — BufRead::read_line preserves old String contents and appends the next line, producing prefix:hello instead of replacing the buffer.
  21. RFA-178 — Read::read_exact returns UnexpectedEof after changing part of the destination buffer that application code expected to remain untouched.
  22. RFA-179 — Opening an existing file with File::create reduces its length to zero before the application writes replacement data.
  23. RFA-180 — Path::exists returns false for a path whose existence cannot be determined because resolving a self-referential symlink fails.
  24. RFA-186 — Two consecutive BufRead::fill_buf calls return the same unread bytes although application code expected the second call to advance the stream.
  25. RFA-194 — Path::starts_with returns false for /srv/application-cache against /srv/application although the raw text begins with that string.
  26. RFA-195 — Reading two bytes through a File returned by try_clone begins at byte three rather than at the start of the file.
  27. RFA-196 — OpenOptions configured with truncate and create still refuses an existing file and leaves its original bytes unchanged.
  28. RFA-199 — Path::parent returns Some containing an empty path for config.toml instead of returning None for the one-component relative path.
  29. RFA-200 — Splitting a newline-terminated string with str::lines produces no final empty item, so a record count is one smaller than expected.
  30. RFA-202 — After File::set_len shrinks a file, stream_position still reports the old end and the cursor is now beyond the new file length.
  31. RFA-203 — A write through an append-mode File lands at the end even after the handle was successfully seeked to byte zero.
  32. RFA-211 — str::match_indices finds the first aba in ababa but does not report the equally valid overlapping match beginning at byte two.
  33. RFA-212 — BufWriter::get_ref returns an empty underlying Vec immediately after write_all accepted three bytes into the writer.
  34. RFA-213 — A Drop implementation that writes a cleanup marker runs when main returns but never runs when the child calls process::exit.
  35. RFA-215 — Uppercasing one Rust char produces two output chars, breaking code that reserved or validated exactly one scalar value per input scalar.
  36. RFA-216 — str::trim removes ideographic spaces surrounding a token although the parser intended to strip only ASCII protocol whitespace.
  37. RFA-217 — Path::extension returns None for .env and only gz for archive.tar.gz, contradicting a parser that treated every suffix after the first dot as an extension.
  38. RFA-219 — fs::copy succeeds when the destination already exists and replaces its old bytes instead of returning AlreadyExists.
  39. RFA-221 — Splitting a two-character string with an empty pattern returns four fields instead of two.
  40. RFA-222 — A character passes is_numeric but to_digit(10) returns None during parsing.
  41. RFA-224 — Writing one byte at cursor position five over a two-byte Vec creates three zero bytes before the new byte.
  42. RFA-229 — Calling elapsed on a SystemTime one hour in the future returns SystemTimeError instead of a negative or zero duration.
  43. RFA-232 — Parsing the text TRUE as bool returns ParseBoolError although a human reads it as true.
  44. RFA-237 — The mapped address ::ffff:127.0.0.1 returns false from Ipv6Addr::is_loopback even though its embedded IPv4 address is loopback.
  45. RFA-238 — A String reserved for two units grows when two non-ASCII characters are pushed into it.
  46. RFA-239 — String::from_utf8_lossy returns Cow::Borrowed for valid bytes although caller code expected an owned String.
  47. RFA-240 — str::get returns None for byte offset 1 in a non-empty string even though the offset is below len.
  48. RFA-242 — char::from_u32 returns None for 0xD800 even though the number is below char::MAX and occurs in UTF-16 data.
  49. RFA-247 — starts_with returns true for banana with the char slice ['a', 'b'], although banana does not begin with the sequence ab.
  50. RFA-251 — str::splitn with n equal to zero returns an empty iterator instead of one unsplit copy of the original string.
  51. RFA-256 — char::encode_utf8 panics when encoding an accented scalar into a one-byte destination buffer.
  52. RFA-262 — Parsing the two-byte ASCII string ab as char returns an error, while one multibyte scalar such as accented e succeeds.
  53. RFA-263 — Stripping prefix aa from aaaa returns aa instead of removing every repeated copy and returning an empty string.
  54. RFA-267 — Reading from a Cursor positioned beyond its buffer returns zero bytes and leaves the position beyond the end.
  55. RFA-268 — Path::components normalizes an internal current-directory marker but still yields ParentDir for a parent marker.
  56. RFA-271 — char::from_digit returns Option for an invalid digit value but panics when the caller supplies a radix greater than 36.
  57. RFA-272 — u32::from_str_radix panics for radix one even though malformed digits and overflow are returned through ParseIntError.
  58. RFA-275 — Truncating a Cursor's backing Vec through get_mut changes its length from three to one but leaves the independent cursor position at three.
  59. RFA-276 — OpenOptions with read and create enabled fails with InvalidInput because create does not implicitly grant write or append access.
  60. RFA-277 — After three bytes are read through take(4), the next three-byte read returns only one byte and following reads report EOF.
  61. RFA-278 — Popping accented e from a Rust String shortens len by two because pop removes one char while String::len reports UTF-8 bytes.
  62. RFA-279 — After set_extension removes gz from archive.tar.gz, Path::extension returns tar because the earlier dotted suffix becomes the new final extension.
  63. RFA-280 — Read::chain permanently switches to its second reader after the first reader returns Ok(0), even if that reader would produce data on a later call.
  64. RFA-281 — write_all through Cursor<&mut [u8]> writes the fitting prefix, then returns WriteZero when the cursor reaches the fixed slice boundary.
  65. RFA-282 — split_inclusive on a string ending with its separator attaches that separator to the preceding item and does not return a final empty item.
  66. RFA-289 — Parsing ::1:8080 as SocketAddrV6 fails even though its intended IPv6 host and port are individually valid.
  67. RFA-290 — BufRead::skip_until on abc| returns four, although code treated the count as the three-byte payload length before the delimiter.
  68. RFA-298 — A child launched with Command::output reads immediate EOF from stdin instead of inheriting input from its parent.
  69. RFA-299 — str::lines splits CRLF but keeps a lone carriage return inside the surrounding line instead of treating it as a boundary.
  70. RFA-305 — Metadata queried for a symbolic link reports a regular file type because the query describes the link destination.
  71. RFA-306 — A second logical process request built from the same Command retains the argument configured for the first request.
  72. RFA-316 — Clearing the portable readonly flag on a Unix file changes mode 0444 to 0666 instead of restoring only owner write permission.
  73. RFA-317 — DirEntry metadata identifies a symbolic link while fs::metadata on the same entry path identifies its regular-file destination.
  74. RFA-318 — BufWriter::into_inner delivers its buffered bytes but a wrapped probe records no call to the underlying flush method.
  75. RFA-319 — A child aborts and produces an unsuccessful ExitStatus, but code returns None rather than a shell-style integer exit code.
  76. RFA-326 — A valid Unix operating-system string cannot be borrowed as str because one of its bytes is not valid UTF-8.
  77. RFA-330 — After one logical byte is consumed and BufReader is unwrapped, the returned inner reader is already at end of input.
  78. RFA-331 — A direct write through BufWriter::get_mut appears before older output still held in the wrapper's pending buffer.
  79. RFA-337 — UTF-8 validation reports a valid prefix but no invalid-sequence length when a chunk ends partway through a possible scalar value.
  80. RFA-338 — CString::new rejects bytes containing zero instead of treating the first zero as a terminator and silently ignoring the suffix.
  81. RFA-340 — BufReader reports logical position one, yet the seekable reader returned by into_inner exposes position six after read-ahead.
  82. RFA-345 — A file opens and its bytes are readable, but fs::read_to_string fails when one stored byte is not valid UTF-8.
  83. RFA-346 — Reading a Unix symlink through an absolute path returns target.txt rather than the absolute target path.
  84. RFA-347 — decode_utf16 yields an error for an unpaired surrogate and then continues to yield later valid characters.
  85. RFA-352 — Calling char::escape_debug on printable non-ASCII text keeps the Unicode scalar visible instead of producing a hexadecimal escape.
  86. RFA-354 — After three bytes are read through a five-byte Take adapter, set_limit(5) permits five more bytes rather than only two.
  87. RFA-355 — BufReader::buffer returns an empty slice immediately after construction even though the underlying reader contains bytes.
  88. RFA-361 — String::split_off(1) panics on éclair because byte one lies inside the two-byte UTF-8 encoding of é.
  89. RFA-365 — After Child::wait returns, child.stdin is None because Rust took and closed the piped handle before blocking for process exit.
  90. RFA-366 — Collecting env::vars panics after the process environment contains a Unix byte sequence that is not valid Unicode.
  91. RFA-367 — After String::from_utf8 rejects one invalid byte, FromUtf8Error still exposes and can return the complete owned input vector.
  92. RFA-374 — Adding repr(C) to an empty Rust enum produces E0084 instead of creating a C-compatible uninhabited type.
  93. RFA-379 — env::join_paths returns JoinPathsError when one Unix path contains a colon instead of escaping the colon.
  94. RFA-389 — OsString::into_string returns Err with the original owned value when Unix bytes are not valid UTF-8.
  95. RFA-401 — A packed outer structure fails with E0588 because one nested field type declares repr(align(8)).
  96. RFA-402 — An enum mixing an explicit discriminant with a data-carrying variant fails E0732 until an integer representation is specified.
  97. RFA-407 — Seeking a BufWriter causes the wrapped writer to receive its buffered write before it receives the seek operation.
  98. RFA-408 — BufRead::read_until leaves an existing prefix in the destination and appends bytes through and including the delimiter.
  99. RFA-414 — BufRead::split over a,b, yields a and b without commas and without a final empty field.
  100. RFA-415 — LineWriter keeps an unterminated abc buffered but sends abc plus newline to its inner writer as soon as the newline arrives.
  101. RFA-416 — BufReader::seek to its current logical position empties two unread bytes from the internal buffer, yet the next read still returns the correct byte.
  102. RFA-514 — Destructuring a tuple in an extern C function declaration fails with E0130 because foreign declarations accept parameter names and types, not Rust body patterns.
  103. RFA-558 — Annotating Header with repr(network) fails with E0539 because network is not a representation hint understood by rustc.
  104. RFA-561 — Annotating Status with repr(u16, u32) fails with E0566 because one enum cannot promise two incompatible discriminant representations simultaneously.
  105. RFA-569 — Annotating CacheLine with repr(align(24)) fails with E0589 because explicit alignment must be a supported power of two.
  106. RFA-571 — Transmuting a named function directly to fn() fails with E0591 because its function-item type is zero-sized and is not the function-pointer value.
  107. RFA-585 — Passing f32 through printf's variadic arguments fails with E0617 because the C variadic ABI expects the promoted double representation.
  108. RFA-592 — Combining repr(packed) with repr(packed(2)) fails with E0634 because one type cannot promise two packing constraints.
  109. RFA-594 — Casting zero to *const _ fails with E0641 because no context tells rustc what kind of pointee the raw pointer addresses.
  110. RFA-598 — An export_name containing an embedded NUL fails with E0648 because object-file and linker symbol naming cannot preserve that requested identity.
  111. RFA-603 — A transparent Measurement containing f32 and unconstrained U fails with E0690 because U could be a second non-zero-sized field.
  112. RFA-604 — Annotating RequestId with repr(transparent, C) fails with E0692 because transparent delegation and C struct layout are incompatible representation contracts.
  113. RFA-605 — Writing repr(align = 16) fails with E0539 because the alignment hint requires nested-list syntax align(16).
  114. RFA-609 — Declaring extern service fails with E0703 because service is a domain label, not a calling convention recognised by rustc.
  115. RFA-618 — Applying repr(transparent) to Status with Ready and Failed fails with E0731 because representation cannot delegate through two alternatives.
  116. RFA-619 — Combining an explicit Empty = 0 discriminant with Data(u8) fails with E0732 until the enum declares an integer representation.
  117. RFA-622 — Applying track_caller to an extern C function fails with E0737 because the implicit caller-location argument belongs to the Rust ABI.
  118. RFA-623 — Putting String directly in a union fails with E0740 because Rust cannot know which overlapping field needs destruction.
  119. RFA-637 — Constructing a union with both integer and float fields fails with E0784 because all fields overlap and one expression must select exactly one interpretation to initialise.
  120. RFA-639 — Formatting a u32 field from a packed header fails with E0793 even though the source contains no visible ampersand.
  121. RFA-676 — CString::new returns NulError for bytes containing zero before the end instead of preserving the complete Rust byte sequence.
  122. RFA-677 — The extension of archive.tar.gz is gz rather than tar.gz, so a compound-format check does not match.
  123. RFA-695 — A no_std executable with an entry symbol still fails because no #[panic_handler] function exists in its dependency graph.
  124. RFA-696 — Vec is unavailable in a no_std library even though slices, Option, and other core types still compile.
  125. RFA-706 — An extern C function returning core::ffi::c_void triggers c_void_returns even though the intent was to model a C function returning void.
  126. RFA-707 — A no_mangle function named memset is rejected even though the Rust function itself is syntactically valid and has an extern C ABI.
  127. RFA-720 — An exported extern C function named strlen is rejected under deny(suspicious_runtime_symbol_definitions) because it accepts *mut f32 instead of *const c_char.