conditional register breakpoint

[Rock'n Roll]

How is this conditional register breakpoint really works?
fo <num> <reg> <oper> <val> [<mask> <val2>] Conditional register breakpoint.
reg=Dx,Ax,PC,USP,ISP,VBR,SR. oper:!=,==,<,>,>=,<=,-,!- (-=val to val2 range).

>fo 0 A0==$21000
Breakpoint added.
>fl
0: A0 == 00021000 [ffffffff 00000000]
>

LEA.L $00021000,A0
ok, that works.

but how is the function of the two 32Bit values in the square brackets?

Is it in a range? Or can I also break the program with a masked bit like:

>fo 0 d0==$00000004 $00000004
Breakpoint added.
>fl
0: D0 == 00000004 [00000004 00000000]

or
>fo 0 d0==$00000004 $00000004 $00000004
Breakpoint added.
>fl
0: D0 == 00000004 [00000004 00000004]

for move.w #$0004,d0
00c25956 303c 0004                move.w #$0004,d0
Next PC: 00c2595a
>t	
Cycles: 4 Chip, 8 CPU. (V=210 H=66 -> V=210 H=70)
  D0 00000004   D1 00000000   D2 00000000   D3 00000000

But in no case a Breakpoint 0 triggered.

>fd
All breakpoints removed.
>fo 0 d0==$00000004
Breakpoint added.
>fl
0: D0 == 00000004 [ffffffff 00000004]

The value in the brackets are not reset with >fd

[Rock'n Roll]

I made a mistake. A breakpoint 0 triggered isn't shown with singlesteps.

I believe the formula for "fo <num> <reg> <oper> <val> [<mask> <val2>]" is:

f0 0 (reg.l & mask.l) == val2.l
eg.

fo 0 d0==$8000 $ff00 $8000
>fl
0: D0 == 00008000 [0000ff00 00008000]

or
>fo 0 d0==$11008000 $ff00 $8000
>fl
0: D0 == 11008000 [0000ff00 00008000]

it's the same and results in: fo 0 d0.l==$xxxx80xx

move.l #$11008000,d0 ; Breakpoint 0 triggered.
move.l #$00008000,d0 ; Breakpoint 0 triggered.
move.l #$00004010,d0 ; no breakpoint
move.l #$0000F011,d0 ; Breakpoint 0 triggered.

(I made only short tests.)

[Rock'n Roll]

I checked again the fo-command and the result is, that the parameter 'val2' has no function.
I only checked with '=='.

1. if (reg & mask) == val1		; ok
>fo 0 d0==$8
Breakpoint added.
>fl				
0: D0 == 00000008 [ffffffff 00000000]	; Breakpoint only for certain value

2. if (reg & mask) == val1		; ok
>fo 0 d0==$13700 $000fff00 $00000000
Breakpoint added.
>fl
0: D0 == 00013700 [000fff00 00000000]	; Breakpoint for value on specific bits

>fo 0 d0==$13700 $0 $0			; ok
Breakpoint added.
>fl
0: D0 == 00013700 [00000000 00000000]	; Breakpoint every time

3.
>fo 0 d0==$13700 $ffffffff $10	
Breakpoint added.
>fl
0: D0 == 00013700 [ffffffff 00000010]	; I can not see any influence of the second parameter 'val2'

I suggest to look into this and maybe change to:
if (((reg & mask) >= (val1-val2)) && ((reg & mask) <= (val1+val2)))
or
if (((reg & mask) >= (val1)) && ((reg & mask) <= (val1+val2)))

Then the parameter 'val2' would specify a range.
The possible operations seems to be to much: oper: !=,==,<,>,>=,<=,-,!-
Maybe better would be only '==' or the oposite '!=' for inside or outside a range or value.

[Toni Wilen]

val2 is used in "range" tests (in-range "-": val1 <= x <= val2 and not-in-range "!-": x <= val1 OR x >= val2)

[Rock'n Roll]

ok, but for me it doesn't work. I need a short example, how to use it.
(but if I not unterstand this, it's also ok.)

I have a series with different move's and one with move.l #$808,d0

I want a break if "in-range":
800 <= x <= 810 with val1 = 800 and val2 = 810
>fo 0 d0<=$800 $ffffffff $810

>fd
All breakpoints removed.
>fo 0 d0<=$800 $ffffffff $810
Breakpoint added.
>fl
0: D0 <= 00000800 [ffffffff 00000810]

>g
Breakpoint 0 triggered.
Cycles: 6 Chip, 12 CPU. (V=105 H=50 -> V=105 H=56)
VPOS: 105 ($069) HPOS: 056 ($038) COP: $0002388c
  D0 00000000   D1 00000000   D2 00000000   D3 00000000

or

>fd
All breakpoints removed.
>fo 0 d0<=$800 $ffffff00 $810
Breakpoint added.
>g
Breakpoint 0 triggered.
Cycles: 6 Chip, 12 CPU. (V=105 H=56 -> V=105 H=62)
VPOS: 105 ($069) HPOS: 062 ($03e) COP: $0002388c
  D0 00000000   D1 00000000   D2 00000000   D3 00000000