-
Notifications
You must be signed in to change notification settings - Fork 19
/
debugger.go
82 lines (67 loc) · 2.66 KB
/
debugger.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
// This file is part of Gopher2600.
//
// Gopher2600 is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Gopher2600 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Gopher2600. If not, see <https://www.gnu.org/licenses/>.
package lazyvalues
import (
"sync/atomic"
"github.com/jetsetilly/gopher2600/debugger"
"github.com/jetsetilly/gopher2600/debugger/govern"
"github.com/jetsetilly/gopher2600/disassembly"
)
// LazyDebugger lazily accesses Debugger information.
type LazyDebugger struct {
val *LazyValues
quantum atomic.Value // debugger.QuantumMode
liveDisasmEntry atomic.Value // disassembly.Entry
breakpoints atomic.Value // debugger.BreakpointsQuery
hasChanged atomic.Value // bool
state atomic.Value // govern.State
Quantum debugger.Quantum
LiveDisasmEntry disassembly.Entry
Breakpoints debugger.LazyBreakpointsQuery
HasChanged bool
// the govern.State below is taken at the same time as the reset of the
// lazy values. this value should be used in preference to the live
// govern.State() value (which is safe to obtain outside of the lazy
// system) when synchronisation is important
State govern.State
}
func newLazyDebugger(val *LazyValues) *LazyDebugger {
lz := &LazyDebugger{val: val}
lz.hasChanged.Store(false)
return lz
}
func (lz *LazyDebugger) push() {
lz.quantum.Store(lz.val.dbg.LazyGetQuantum())
lz.liveDisasmEntry.Store(lz.val.dbg.LazyGetLiveDisasmEntry())
lz.breakpoints.Store(lz.val.dbg.LazyQueryBreakpoints())
// because the push() and update() pair don't interlock exactly, the
// hasChanged field must be latched. unlatching is performed in the
// update() function
if !lz.hasChanged.Load().(bool) {
lz.hasChanged.Store(lz.val.dbg.LazyHasChanged())
}
lz.state.Store(lz.val.dbg.State())
}
func (lz *LazyDebugger) update() {
lz.Quantum, _ = lz.quantum.Load().(debugger.Quantum)
if lz.liveDisasmEntry.Load() != nil {
lz.LiveDisasmEntry = lz.liveDisasmEntry.Load().(disassembly.Entry)
}
lz.Breakpoints, _ = lz.breakpoints.Load().(debugger.LazyBreakpointsQuery)
// load current hasChanged value and unlatch (see push() function)
lz.HasChanged = lz.hasChanged.Load().(bool)
lz.hasChanged.Store(false)
lz.State, _ = lz.state.Load().(govern.State)
}