Can you explain why the comparison is not necessary? It looks perfectly fine, but I'm jet-lagged so my mind is not very sharp right now.

The resulting flag doesn't get used, and it gets overwritten by the CMPQ at 00018.

Ah, I missed that there are three comparisons, not two. It's actually subtle, a copy is introduced during flagalloc pass. The original is dead, but never removed.

  pass flagalloc begin
  pass flagalloc end [3125 ns]
inrange <nil>
  b1:
    v1 = InitMem <mem>
    v7 = Arg <int> {n}
    v8 = Arg <int> {lo}
    v10 = Arg <int> {hi}
    v12 = CMPQ <flags> v7 v10 DEAD
    v15 = CMPQ <flags> v7 v8
    GE v15 -> b4 b6
  b4: <- b1
    v14 = CMPQ <flags> v7 v10
    LT v14 -> b2 b7
  b2: <- b4
    v16 = VarDef <mem> {i} v1
    v3 = SB <uintptr>
    v17 = MOVQstoreconst <mem> {i} [val=1,off=0] v3 v16
    Plain -> b3
  b3: <- b5 b2
    v18 = Phi <mem> v1 v17
    Ret v18
  b7: <- b4
    Plain -> b5
  b5: <- b6 b7
    Plain -> b3
  b6: <- b1
    Plain -> b5

I wonder if the comparison should have been moved during the tighten pass. v11 has a single use, so it should be defined in b4 instead of b1, right? I'm not suggesting it's bug, just that it's not aggressive enough.

  pass tighten begin
  pass tighten end [11807 ns]
inrange <nil>
  b1:
    v1 = InitMem <mem>
    v7 = Arg <int> {n}
    v8 = Arg <int> {lo}
    v9 = Geq64 <bool> v7 v8
    v10 = Arg <int> {hi}
    v11 = Less64 <bool> v7 v10
    If v9 -> b4 b3
  b2: <- b4
    v16 = VarDef <mem> {i} v1
    v13 = Const64 <int> [1]
    v3 = SB <uintptr>
    v14 = Addr <*int> {i} v3
    v17 = Store <mem> [8] v14 v13 v16
    Plain -> b3
  b3: <- b1 b4 b2
    v18 = Phi <mem> v1 v1 v17
    Ret v18
  b4: <- b1
    If v11 -> b2 b3

Yeah. Tighten won't move any values that depend on two values, for fear of increasing the number of live values that must be spilled and loaded. However, v11 depends on args, which never need to get spilled, so at worst this will (in general) introduce extra loads. There are other kinds of args (constants, what else?) that probably also should not get counted when making this decision.

Fixing tighten to ignore args and rematerializeable values sounds good (for 1.8).

Ok. Added to my queue. I don't think it'll fix all instances of this problem, but I will find out. :)

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