CL https://golang.org/cl/39295 mentions this issue.

Let me be ignorant and ask whether turning floating point multiplication into addition is indeed a performance win. One requires touching an exponent; the other requires touching every bit and normalizing.

For amd64, the Agner Fog tables say that turning an fmul into an fadd might be a small improvement. On Haswell, for example, both are 1 micro-op, but fadd has a 3-cycle result latency, whereas fmul has a 5-cycle result latency. However, these instructions use different ports, so code with interleaved fmul and fadd ops that gets turned into just a series of fadd ops will not execute as quickly.

Conversely, on arm64, there may not be a win. Both FADD and FMUL have a 5-cycle result latency on the Cortex A57 (provided that denormals are flushed to zero).

Division, on the other hand, appears to be consistently more expensive (dozens of cycles of result latency... up to 64 on the A57).

x*2 -> x+x is almost certainly a win.
+ requires futzing with an exponent, * requires a carry-save adder chain of some sort. But that's neither here nor there, in the end we just accept the cycle latency the hardware gives us. The processors I've checked have + faster than or equal to *. In addition, with this rewrite we no longer have to materialize the constant 2.

x*-2 -> -(x+x) is less clear. I could be convinced either way.

name       old time/op  new time/op  delta
Mul2-8      626ns ± 0%   382ns ± 1%  -38.96%  (p=0.000 n=8+10)
MulNeg2-8   635ns ± 1%   759ns ± 1%  +19.57%  (p=0.000 n=9+10)

At least on amd64, *2 is a win. I'll remove the *-2 code from the CL.

Thanks for checking.