reviewer comments

Author: arayikhalatyan

compiler/rustc_target/src/spec/targets/riscv32im_unknown_openvm_elf.rs

@@ -22,11 +22,9 @@ pub(crate) fn target() -> Target {
             linker: Some("rust-lld".into()),
             cpu: "generic-rv32".into(),
 
-            // Some crates (*cough* crossbeam) assume you have 64 bit
-            // atomics if the target name is not in a hardcoded list.
-            // Since OpenVM is singlethreaded and all operations are
-            // atomic, I guess we can just say we support 64-bit
-            // atomics.
+            // We set atomic_width to 64 for compatibility with crates such as crossbeam,
+            // but this should never be triggered since compilation should always lower
+            // atomics and be single-threaded.
             max_atomic_width: Some(64),
             atomic_cas: true,
 

library/std/src/sys/env/openvm.rs

@@ -23,10 +23,6 @@ pub fn getenv(varname: &OsStr) -> Option<OsString> {
     debug_assert_eq!(nbytes, nbytes2);
 
     // Convert to OsString.
-    //
-    // FIXME: We can probably get rid of the extra copy here if we
-    // reimplement "os_str" instead of just using the generic unix
-    // "os_str".
     let u8s: &[u8] = unsafe { crate::slice::from_raw_parts(words.cast() as *const u8, nbytes) };
     Some(OsString::from_inner(os_str::Buf { inner: u8s.to_vec() }))
 }

library/std/src/sys/pal/openvm/abi.rs

@@ -1,9 +1,8 @@
 //! ABI definitions for symbols exported by OpenVM.
 
-// Included here so we don't have to depend on OpenVM
-
+// We provide the ABI so that the OpenVM-specific implementations can be provided
+// by linking the openvm crate without introducing the crate as a dependency here
 #![allow(dead_code)]
-pub const DIGEST_WORDS: usize = 8;
 
 /// Standard IO file descriptors for use with sys_read and sys_write.
 pub mod fileno {
@@ -16,11 +15,9 @@ pub mod fileno {
 unsafe extern "C" {
     // Wrappers around syscalls provided by OpenVM:
     pub fn sys_halt();
-    pub fn sys_output(output_id: u32, output_value: u32);
     pub fn sys_rand(recv_buf: *mut u32, words: usize);
     pub fn sys_panic(msg_ptr: *const u8, len: usize) -> !;
     pub fn sys_log(msg_ptr: *const u8, len: usize);
-    pub fn sys_cycle_count() -> usize;
     pub fn sys_read(fd: u32, recv_buf: *mut u8, nrequested: usize) -> usize;
     pub fn sys_write(fd: u32, write_buf: *const u8, nbytes: usize);
     pub fn sys_getenv(

library/std/src/sys/random/openvm.rs

@@ -9,7 +9,7 @@ pub fn fill_bytes(bytes: &mut [u8]) {
     }
 
     let mut buf = [0u32; 2];
-    let len = (pre.len() + post.len() + size_of::<u32>() - 1) / size_of::<u32>();
+    let len = (pre.len() + post.len()).div_ceil(size_of::<u32>());
     if len != 0 {
         unsafe { abi::sys_rand(buf.as_mut_ptr(), len) };
     }

src/doc/rustc/src/platform-support/riscv32im-unknown-openvm-elf.md

@@ -20,12 +20,12 @@ We provide a cargo extension called [cargo-openvm] that provides tools for cross
 ## Requirements
 
 The target supports cross-compilation from any host and does not support host tools. It supports `alloc` with a
-default allocator. Partial support for the Rust `std` library is provided using custom RISC-V instructions and requires the `openvm` crate with the `"std"` feature enabled. Further details and limitations of `std` support are documented [here](https://docs.openvm.dev/book/writing-apps/writing-a-program#rust-std-library-support). 
+default allocator. Partial support for the Rust `std` library is provided using custom RISC-V instructions and requires the `openvm` crate with the `"std"` feature enabled. Further details and limitations of `std` support are documented [here](https://docs.openvm.dev/book/writing-apps/writing-a-program#rust-std-library-support).
 
 The target's execution environment is single-threaded, non-preemptive, and does not support
 privileged instructions. At present, unaligned accesses are not supported and will result in execution traps. The binaries expect no operating system and can be thought
 of as running on bare-metal. The target does not use `#[target_feature(...)]` or
-`-C target-feature=` values. 
+`-C target-feature=` values.
 
 Binaries are expected to be ELF.