https-github-com-bit
diff --git a/‎src/cmd/compile/internal/ssa/cse.go‎
Lines changed: 10 additions & 1 deletion b/‎src/cmd/compile/internal/ssa/cse.go‎
Lines changed: 10 additions & 1 deletion
diff --git a/‎src/cmd/compile/internal/ssa/flagalloc.go‎
Lines changed: 9 additions & 0 deletions b/‎src/cmd/compile/internal/ssa/flagalloc.go‎
Lines changed: 9 additions & 0 deletions
diff --git a/‎src/cmd/compile/internal/ssa/gen/AMD64.rules‎
Lines changed: 1 addition & 1 deletion b/‎src/cmd/compile/internal/ssa/gen/AMD64.rules‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/cmd/compile/internal/ssa/gen/AMD64Ops.go‎
Lines changed: 1 addition & 1 deletion b/‎src/cmd/compile/internal/ssa/gen/AMD64Ops.go‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/cmd/compile/internal/ssa/opGen.go‎
Lines changed: 1 addition & 1 deletion b/‎src/cmd/compile/internal/ssa/opGen.go‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/cmd/compile/internal/ssa/rewriteAMD64.go‎
Lines changed: 5 additions & 5 deletions b/‎src/cmd/compile/internal/ssa/rewriteAMD64.go‎
Lines changed: 5 additions & 5 deletions
@@ -153,7 +153,6 @@ func cse(f *Func) {
 					i++
 				}
 			}
-			// TODO(khr): if value is a control value, do we need to keep it block-local?
 		}
 	}
 
@@ -166,6 +165,16 @@ func cse(f *Func) {
 				}
 			}
 		}
+		if v := b.Control; v != nil {
+			if x := rewrite[v.ID]; x != nil {
+				if v.Op == OpNilCheck {
+					// nilcheck pass will remove the nil checks and log
+					// them appropriately, so don't mess with them here.
+					continue
+				}
+				b.Control = x
+			}
+		}
 	}
 }
 
 
@@ -21,6 +21,15 @@ func flagalloc(f *Func) {
 		// Walk blocks backwards.  Poor-man's postorder traversal.
 		for i := len(f.Blocks) - 1; i >= 0; i-- {
 			b := f.Blocks[i]
+			if len(b.Preds) > 1 {
+				// Don't use any flags register at the start
+				// of a merge block.  This causes problems
+				// in regalloc because some of the rematerialization
+				// instructions used on incoming merge edges clobber
+				// the flags register.
+				// TODO: only for architectures where this matters?
+				continue
+			}
 			// Walk values backwards to figure out what flag
 			// value we want in the flag register at the start
 			// of the block.
 
@@ -370,7 +370,7 @@
 (If (SETGF  cmp) yes no) -> (UGT  cmp yes no)
 (If (SETGEF cmp) yes no) -> (UGE  cmp yes no)
 (If (SETEQF cmp) yes no) -> (EQF  cmp yes no)
-(If (SETNEF cmp) yes no) -> (EQF  cmp yes no)
+(If (SETNEF cmp) yes no) -> (NEF  cmp yes no)
 
 (If cond yes no) -> (NE (TESTB cond cond) yes no)
 
 
@@ -433,7 +433,7 @@ func init() {
 			name: "DUFFCOPY",
 			reg: regInfo{
 				inputs:   []regMask{buildReg("DI"), buildReg("SI")},
-				clobbers: buildReg("DI SI X0"), // uses X0 as a temporary
+				clobbers: buildReg("DI SI X0 FLAGS"), // uses X0 as a temporary
 			},
 		},
 
 
@@ -3177,7 +3177,7 @@ var opcodeTable = [...]opInfo{
 				{0, 128}, // .DI
 				{1, 64},  // .SI
 			},
-			clobbers: 65728, // .SI .DI .X0
+			clobbers: 8590000320, // .SI .DI .X0 .FLAGS
 		},
 	},
 	{
 
@@ -14213,23 +14213,23 @@ func rewriteBlockAMD64(b *Block) bool {
 		;
 		// match: (If (SETNEF cmp) yes no)
 		// cond:
-		// result: (EQF  cmp yes no)
+		// result: (NEF  cmp yes no)
 		{
 			v := b.Control
 			if v.Op != OpAMD64SETNEF {
-				goto endfe25939ca97349543bc2d2ce4f97ba41
+				goto endaa989df10b5bbc5fdf8f7f0b81767e86
 			}
 			cmp := v.Args[0]
 			yes := b.Succs[0]
 			no := b.Succs[1]
-			b.Kind = BlockAMD64EQF
+			b.Kind = BlockAMD64NEF
 			b.Control = cmp
 			b.Succs[0] = yes
 			b.Succs[1] = no
 			return true
 		}
-		goto endfe25939ca97349543bc2d2ce4f97ba41
-	endfe25939ca97349543bc2d2ce4f97ba41:
+		goto endaa989df10b5bbc5fdf8f7f0b81767e86
+	endaa989df10b5bbc5fdf8f7f0b81767e86:
 		;
 		// match: (If cond yes no)
 		// cond:
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,6 @@ func cse(f *Func) {`
`153`	`153`	`i++`
`154`	`154`	`}`
`155`	`155`	`}`
`156`		`- // TODO(khr): if value is a control value, do we need to keep it block-local?`
`157`	`156`	`}`
`158`	`157`	`}`
`159`	`158`
`@@ -166,6 +165,16 @@ func cse(f *Func) {`
`166`	`165`	`}`
`167`	`166`	`}`
`168`	`167`	`}`
	`168`	`+ if v := b.Control; v != nil {`
	`169`	`+ if x := rewrite[v.ID]; x != nil {`
	`170`	`+ if v.Op == OpNilCheck {`
	`171`	`+ // nilcheck pass will remove the nil checks and log`
	`172`	`+ // them appropriately, so don't mess with them here.`
	`173`	`+ continue`
	`174`	`+ }`
	`175`	`+ b.Control = x`
	`176`	`+ }`
	`177`	`+ }`
`169`	`178`	`}`
`170`	`179`	`}`
`171`	`180`
Original file line number	Diff line number	Diff line change
`@@ -3177,7 +3177,7 @@ var opcodeTable = [...]opInfo{`
`3177`	`3177`	`{0, 128}, // .DI`
`3178`	`3178`	`{1, 64}, // .SI`
`3179`	`3179`	`},`
`3180`		`- clobbers: 65728, // .SI .DI .X0`
	`3180`	`+ clobbers: 8590000320, // .SI .DI .X0 .FLAGS`
`3181`	`3181`	`},`
`3182`	`3182`	`},`
`3183`	`3183`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14213,23 +14213,23 @@ func rewriteBlockAMD64(b *Block) bool {`
`14213`	`14213`	`;`
`14214`	`14214`	`// match: (If (SETNEF cmp) yes no)`
`14215`	`14215`	`// cond:`
`14216`		`- // result: (EQF cmp yes no)`
	`14216`	`+ // result: (NEF cmp yes no)`
`14217`	`14217`	`{`
`14218`	`14218`	`v := b.Control`
`14219`	`14219`	`if v.Op != OpAMD64SETNEF {`
`14220`		`- goto endfe25939ca97349543bc2d2ce4f97ba41`
	`14220`	`+ goto endaa989df10b5bbc5fdf8f7f0b81767e86`
`14221`	`14221`	`}`
`14222`	`14222`	`cmp := v.Args[0]`
`14223`	`14223`	`yes := b.Succs[0]`
`14224`	`14224`	`no := b.Succs[1]`
`14225`		`- b.Kind = BlockAMD64EQF`
	`14225`	`+ b.Kind = BlockAMD64NEF`
`14226`	`14226`	`b.Control = cmp`
`14227`	`14227`	`b.Succs[0] = yes`
`14228`	`14228`	`b.Succs[1] = no`
`14229`	`14229`	`return true`
`14230`	`14230`	`}`
`14231`		`- goto endfe25939ca97349543bc2d2ce4f97ba41`
`14232`		`- endfe25939ca97349543bc2d2ce4f97ba41:`
	`14231`	`+ goto endaa989df10b5bbc5fdf8f7f0b81767e86`
	`14232`	`+ endaa989df10b5bbc5fdf8f7f0b81767e86:`
`14233`	`14233`	`;`
`14234`	`14234`	`// match: (If cond yes no)`
`14235`	`14235`	`// cond:`