小编Luk*_*odt的帖子

我需要重定向生成的子进程的输出。这是我尝试过但不起作用的方法：

Command::new(cmd)
    .args(&["--testnet",
            "--fast",
            format!("&>> {}", log_path).as_str()])
    .stdin(Stdio::piped())
    .stdout(Stdio::inherit())
    .spawn()

我有一个简单的.rs文件，想使用进行编译rustc。我总是听说在发布模式下进行编译有多么重要，因为否则我的Rust程序会很慢。

但是，如果我使用经常引用的--release标志，则它不起作用。如果旗帜甚至不存在，每个人都在谈论什么？

$ rustc --release foo.rs
error: Unrecognized option: 'release'.

我正在尝试使用 WebAssembly 运行一个用 Rust 编写的 hello world 程序，但是当我尝试加载该程序时收到一条错误消息。

按照我发现的一些教程，我能够让它运行，问题是他们使用 Emscripten 创建 JavaScript 和 HTML 来加载代码，但是这个 JavaScript 和 HTML 包含大量的样板文件和其他东西。我有点迷路了，而是想尝试获得一个非常简单的例子，我正在加载自己。

我运行以下命令来编译 hello.wasm

echo 'fn main() { println!("Hello, Emscripten!"); }' > hello.rs
rustc --target=wasm32-unknown-emscripten hello.rs

为了加载 hello.wasm，我从 Mozilla WebAssembly 文档中获取示例并尝试运行它。

var importObject = {
  imports: {
    imported_func: function(arg) {
      console.log(arg);
    }
  }
};

fetch('hello.wasm').then(response =>
  response.arrayBuffer()
).then(bytes =>
  WebAssembly.instantiate(bytes, importObject)
).then(results => {
  // Do something with the compiled results!
});

WebAssembly.instantiate 崩溃：

var importObject = {
  imports: {
    imported_func: function(arg) { …

我目前正在玩LLVM,我正在尝试编写一些优化器来熟悉opt和clang.我写了一个test.c文件,如下所示:

int foo(int aa, int bb, int cc){
    int sum = aa + bb;
    return sum/cc;
}

我编译了源代码并生成了2个.ll文件,一个未经优化,一个用mem2reg优化器传递:

clang -emit-llvm -O0 -c test.c -o test.bc
llvm-dis test.bc
opt -mem2reg -S test.ll -o test-mem2reg.ll

两个.ll文件都给了我以下输出:

ModuleID = 'test.bc'
source_filename = "test.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

; Function Attrs: noinline nounwind optnone uwtable
define i32 @foo(i32 %aa, i32 %bb, i32 %cc) #0 {
entry:
  %aa.addr = alloca i32, align 4
  %bb.addr = alloca i32, align 4
  %cc.addr = …

我有这种类型:

struct Wrap<T>(Vec<T>);

我想实现std::ops::Index并返回对特征对象的引用.这是我的第一次尝试(游乐场):

use std::ops::Index;
use std::fmt::Display;


impl<T> Index<usize> for Wrap<T>
where
    T: Display
{
    type Output = Display;
    fn index(&self, index: usize) -> &Self::Output {
        &self.0[index]
    }
}

这不起作用并导致此错误:

error[E0310]: the parameter type `T` may not live long enough
  --> src/main.rs:13:9
   |
7  | impl<T> Index<usize> for Wrap<T>
   |      - help: consider adding an explicit lifetime bound `T: 'static`...
...
13 |         &self.0[index]
   |         ^^^^^^^^^^^^^^
   |
note: ...so that the type `T` will meet …

我在llvm clang Apple LLVM 8.0.0版(clang-800.0.42.1)上反汇编代码:

int main() {
    float a=0.151234;
    float b=0.2;
    float c=a+b;
    printf("%f", c);
}

我编译时没有-O规范,但我也试过-O0(给出相同)和-O2(实际上计算值并存储它预先计算)

产生的反汇编如下(我删除了不相关的部分)

->  0x100000f30 <+0>:  pushq  %rbp
    0x100000f31 <+1>:  movq   %rsp, %rbp
    0x100000f34 <+4>:  subq   $0x10, %rsp
    0x100000f38 <+8>:  leaq   0x6d(%rip), %rdi       
    0x100000f3f <+15>: movss  0x5d(%rip), %xmm0           
    0x100000f47 <+23>: movss  0x59(%rip), %xmm1        
    0x100000f4f <+31>: movss  %xmm1, -0x4(%rbp)  
    0x100000f54 <+36>: movss  %xmm0, -0x8(%rbp)
    0x100000f59 <+41>: movss  -0x4(%rbp), %xmm0         
    0x100000f5e <+46>: addss  -0x8(%rbp), %xmm0
    0x100000f63 <+51>: movss  %xmm0, -0xc(%rbp)
    ...

显然它正在做以下事情:

1. 将两个浮点数加载到寄存器xmm0和xmm1上
2. 把它们放在堆栈中
3. 从堆栈加载一个值(不是之前的xmm0)到xmm0
4. 执行添加. …

我有一个标识符列表,我想为该列表中的每对标识符调用一个宏.例如,如果我有a,b并且c,我想生成这个:

println!("{} <-> {}", a, a);
println!("{} <-> {}", a, b);
println!("{} <-> {}", a, c);
println!("{} <-> {}", b, a);
println!("{} <-> {}", b, b);
println!("{} <-> {}", b, c);
println!("{} <-> {}", c, a);
println!("{} <-> {}", c, b);
println!("{} <-> {}", c, c);

当然,这是一个虚拟的例子.在我的真实代码中,标识符是类型,我想生成impl块或类似的东西.

我的目标是仅列出每个标识符一次.在我的实际代码中,我有大约12个标识符,并且不想手动写下所有12²= 144对.所以我认为宏可能会帮助我.我知道它可以通过所有强大的过程宏来解决,但我希望它也可以使用声明式宏(macro_rules!).

我尝试了我认为直观的处理方法(两个嵌套的"循环")(Playground):

macro_rules! print_all_pairs {
    ($($x:ident)*) => {
        $(
            $(
                println!("{} <-> {}", $x, $x);  // `$x, $x` feels awkward... …

Consider this example:

fn main() {
    let v: Vec<i32> = vec![1, 2, 3, 4, 5];
    let b: i32 = (&v[2]) * 4.0;
    println!("product of third value with 4 is {}", b);
}

This fails as expected as float can't be multiplied with &i32.

error[E0277]: cannot multiply `{float}` to `&i32`
 --> src\main.rs:3:23
  |
3 |   let b: i32 = (&v[2]) * 4.0;
  |                        ^ no implementation for `&i32 * {float}`
  |
  = help: the trait `std::ops::Mul<{float}>` is not implemented for …

我已经开始解决 Rust 中的 Project Euler 问题，并遇到了#3，其中最简单的快速方法是实现埃拉托色尼筛法。

在此过程中，我的算法创建了一个迭代器，然后过滤掉非素数并将其分配回原始向量，但我收到了Vec<u32>无法从 构建的错误Iterator<Item=&u32>。

代码：

fn eratosthenes_sieve(limit: u32) -> Vec<u32> {
    let mut primes: Vec<u32> = Vec::new();
    let mut range: Vec<u32> = (2..=limit).collect();
    let mut length = range.len();

    loop {
        let p = range[0];
        primes.push(p);

        range = range.iter().filter(|&n| *n % p != 0).collect();

        if length == range.len() {
            break;
        }
        length = range.len();
    }

    primes
}

错误：

fn eratosthenes_sieve(limit: u32) -> Vec<u32> {
    let mut primes: Vec<u32> = …

过程宏存在于它们自己的 crate 中，这些 crate 是为开发机器编译的（以便在编译使用它们的 crate 时可以执行它们）。过程宏包中的任何条件编译指令将相应地基于其编译环境，而不是调用包的编译环境。

当然，此类宏可以扩展为包含条件编译指令的标记，然后将在调用包的编译\xe2\x80\x94的上下文中对这些指令进行评估，但是，这并不总是可能或理想的。

如果希望扩展令牌本身成为调用包的编译环境的某个函数，则需要宏在其运行时确定该环境（当然是调用包的编译） -时间）。显然是该模块的完美用例std::env。

然而，rustc 不设置任何环境变量；而货物套装数量有限。特别是，一些关键信息（如目标架构/操作系统等）根本不存在。

我很欣赏调用包中的构建脚本可以为宏设置环境变量然后读取，但这给调用包作者带来了令人不满意的负担。

有没有什么方法可以让 proc 宏作者获得有关调用包的编译环境的运行时信息（我最感兴趣的目标体系结构和操作系统）？