assure accurate timer selection in runtime.WakeG

Author: abarisani

src/runtime/sys_tamago_amd64.s

@@ -186,21 +186,21 @@ testing:
 //
 //   * AX: G pointer
 TEXT runtime·WakeG(SB),NOSPLIT|NOFRAME,$0-0
-	MOVQ	(g_timer)(AX), AX
-	CMPQ	AX, $0
+	MOVQ	(g_timer)(AX), DX
+	CMPQ	DX, $0
 	JE	done
 
 	// g->timer.when = 1
 	MOVQ	$(1 << 32), BX
-	MOVQ	BX, (timer_when)(AX)
+	MOVQ	BX, (timer_when)(DX)
 
 	// g->timer.astate &= timerModified
 	// g->timer.state  &= timerModified
-	MOVQ	(timer_astate)(AX), CX
+	MOVQ	(timer_astate)(DX), CX
 	ORQ	$const_timerModified<<8|const_timerModified, CX
-	MOVQ	CX, (timer_astate)(AX)
+	MOVQ	CX, (timer_astate)(DX)
 
-	MOVQ	(timer_ts)(AX), AX
+	MOVQ	(timer_ts)(DX), AX
 	CMPQ	AX, $0
 	JE	done
 
@@ -215,8 +215,8 @@ TEXT runtime·WakeG(SB),NOSPLIT|NOFRAME,$0-0
 
 	// offset to last element
 	SUBQ	$1, CX
-	MOVQ	$(timerWhen__size), DX
-	IMULQ	DX, CX
+	MOVQ	$(timerWhen__size), BX
+	IMULQ	BX, CX
 
 	MOVQ	(timers_heap)(AX), AX
 	CMPQ	AX, $0
@@ -232,13 +232,12 @@ prev:
 	JE	done
 
 check:
-	// find longest timer as *timers.adjust() might be pending
-	MOVQ	(timerWhen_when)(AX), BX
-	MOVQ	$((1 << 63) - 1), CX // math.MaxInt64
-	CMPQ	CX, BX
+	// find heap entry matching g.timer
+	MOVQ	(timerWhen_timer)(AX), BX
+	CMPQ	BX, DX
 	JNE	prev
 
-	// g->timer.ts.heap[off] = 1
+	// g->timer.ts.heap[off].when = 1
 	MOVQ	$(1 << 32), BX
 	MOVQ	BX, (timerWhen_when)(AX)
 

src/runtime/sys_tamago_arm.s

@@ -145,23 +145,23 @@ TEXT runtime·GetG(SB),NOSPLIT,$0-8
 //
 //   * R0: G pointer
 TEXT runtime·WakeG(SB),NOSPLIT|NOFRAME,$0-0
-	MOVW	(g_timer)(R0), R0
-	CMP	$0, R0
+	MOVW	(g_timer)(R0), R3
+	CMP	$0, R3
 	B.EQ	done
 
 	// g->timer.when = 1
 	MOVW	$1, R1
-	MOVW	R1, (timer_when+0)(R0)
+	MOVW	R1, (timer_when+0)(R3)
 	MOVW	$0, R1
-	MOVW	R1, (timer_when+4)(R0)
+	MOVW	R1, (timer_when+4)(R3)
 
 	// g->timer.astate &= timerModified
 	// g->timer.state  &= timerModified
-	MOVW	(timer_astate)(R0), R2
+	MOVW	(timer_astate)(R3), R2
 	ORR	$const_timerModified<<8|const_timerModified, R2, R2
-	MOVW	R2, (timer_astate)(R0)
+	MOVW	R2, (timer_astate)(R3)
 
-	MOVW	(timer_ts)(R0), R0
+	MOVW	(timer_ts)(R3), R0
 	CMP	$0, R0
 	B.EQ	done
 
@@ -178,8 +178,8 @@ TEXT runtime·WakeG(SB),NOSPLIT|NOFRAME,$0-0
 
 	// offset to last element
 	SUB	$1, R2, R2
-	MOVW	$(timerWhen__size), R3
-	MUL	R3, R2, R2
+	MOVW	$(timerWhen__size), R1
+	MUL	R1, R2, R2
 
 	MOVW	(timers_heap)(R0), R0
 	CMP	$0, R0
@@ -195,13 +195,9 @@ prev:
 	B.EQ	done
 
 check:
-	// find longest timer as *timers.adjust() might be pending
-	MOVW	(timerWhen_when+0)(R0), R1
-	CMP	$0xffffffff, R1 // LS word of math.MaxInt64
-	B.NE	prev
-
-	MOVW	(timerWhen_when+4)(R0), R1
-	CMP	$0x7fffffff, R1 // MS word of math.MaxInt64
+	// find heap entry matching g.timer
+	MOVW	(timerWhen_timer)(R0), R1
+	CMP	R3, R1
 	B.NE	prev
 
 	// g->timer.ts.heap[off] = 1

src/runtime/sys_tamago_riscv64.s

@@ -68,20 +68,20 @@ TEXT runtime·GetG(SB),NOSPLIT,$0-16
 //
 //   * T0: G pointer
 TEXT runtime·WakeG(SB),NOSPLIT|NOFRAME,$0-0
-	MOV	(g_timer)(T0), T0
-	BEQ	T0, ZERO, done
+	MOV	(g_timer)(T0), T3
+	BEQ	T3, ZERO, done
 
 	// g->timer.when = 1
 	MOV	$(1 << 32), T1
-	MOV	T1, (timer_when)(T0)
+	MOV	T1, (timer_when)(T3)
 
 	// g->timer.astate &= timerModified
 	// g->timer.state  &= timerModified
-	MOV	(timer_astate)(T0), T2
+	MOV	(timer_astate)(T3), T2
 	OR	$const_timerModified<<8|const_timerModified, T2, T2
-	MOV	T2, (timer_astate)(T0)
+	MOV	T2, (timer_astate)(T3)
 
-	MOV	(timer_ts)(T0), T0
+	MOV	(timer_ts)(T3), T0
 	BEQ	T0, ZERO, done
 
 	// g->timer.ts.minWhenModified = 1
@@ -94,8 +94,8 @@ TEXT runtime·WakeG(SB),NOSPLIT|NOFRAME,$0-0
 
 	// offset to last element
 	SUB	$1, T2, T2
-	MOV	$(timerWhen__size), T3
-	MUL	T3, T2, T2
+	MOV	$(timerWhen__size), T1
+	MUL	T1, T2, T2
 
 	MOV	(timers_heap)(T0), T0
 	BEQ	T0, ZERO, done
@@ -109,10 +109,9 @@ prev:
 	BEQ	T0, ZERO, done
 
 check:
-	// find longest timer as *timers.adjust() might be pending
-	MOV	(timerWhen_when)(T0), T1
-	MOV	$((1 << 63) - 1), T2 // math.MaxInt64
-	BNE	T2, T1, prev
+	// find heap entry matching g.timer
+	MOV	(timerWhen_timer)(T0), T1
+	BNE	T3, T1, prev
 
 	// g->timer.ts.heap[off] = 1
 	MOV	$(1 << 32), T1