File size: 4,477 Bytes
e93c9cc | 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 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | # Dynamic trace for the loading-tip cycle function
The static RE pass narrowed the candidate function to a small set of
VMAs in `0x141174xxx` (loading-screen construction) and a few call
targets. To confirm which one is the per-frame tip cycler, we use
hardware breakpoints to observe the running `eu4.exe`.
## Why
Manual RE of a 38 MB binary without symbols is slow. The cycle
function is *not* the `0x141174F50` setup function (which runs only
once). The per-frame update is somewhere else, calling the same
`findChildByName` / `setText` virtuals, but with a Timer. Hardware
breakpoints on the candidates and a hit counter tell us which one
fires most often during the loading screen.
## Tool
`bin/trace_tip_cycle.exe` (built with `x86_64-w64-mingw32-gcc`,
MinGW-w64 GCC 15.2.0). It:
1. Finds the `eu4.exe` PID.
2. Opens the main thread.
3. Sets `DR0`–`DR3` hardware-execute breakpoints on the first 4
candidate VMAs.
4. Calls `DebugActiveProcess` to attach as a debugger.
5. Loops on `WaitForDebugEvent`, logs every `EXCEPTION_SINGLE_STEP`
whose `ExceptionAddress` matches a candidate, and re-arms all 4
breakpoints (Windows clears them on exception).
6. Exits after 10000 hits or 5 minutes, whichever comes first.
The hit log is written to `trace_log.txt` next to the .exe.
## Candidates currently traced
| VMA | Source |
|----------------|------------------------------------------------------------------------|
| `0x141174F50` | `load_screen_setup` (static RE confirmed, runs once) |
| `0x141174840` | `status_updater` (spinner — confirmed fires every frame) |
| `0x141175110` | `status_lookup` (helper, may or may not be per-frame) |
| `0x14117AD80` | call target — likely the GUI `addChild` path |
| (12 more) | See `src/trace_tip_cycle.cpp` for the full list |
Only the first 4 fit in the 4 HW debug registers. If the cycle
function is one of the others, expand the candidate list and
re-build.
## How to run
1. **Launch EU4** through Steam. (Or directly:
`"C:\Program Files (x86)\Steam\steamapps\common\Europa Universalis IV\eu4.exe"`.)
2. **Trigger a loading screen** — start a new campaign, or load a save.
The loading screen must be on-screen for the tip cycler to run.
3. In a second shell, run the tracer:
```bash
cd tools/loading_tip_patcher
./bin/trace_tip_cycle.exe
```
4. **Wait 30–120 s** for the loading to finish and the tracer to
record enough hits.
5. Open `trace_log.txt`. The VMA with the highest hit count is the
per-frame tip cycle function. Compare with the candidate list
to identify the exact symbol we should patch.
## Expected output (illustrative)
```
[trace] target PID 12345, main thread TID 12350
[trace] HW breakpoints set on first 4 candidates
[trace] Waiting for exceptions. Run the loading screen NOW.
[hit] #1 vma=0x141174840 count=1 prev_rip=0x141174812 +dt=12us
[hit] #1 vma=0x141174840 count=2 prev_rip=0x141174812 +dt=16543us
[hit] #1 vma=0x141174840 count=3 prev_rip=0x141174812 +dt=16601us
[hit] #0 vma=0x141174f50 count=1 prev_rip=0x141174e9f +dt=8us
[hit] #1 vma=0x141174840 count=4 prev_rip=0x141174812 +dt=16572us
...
```
The expected pattern: `0x141174840` (status updater / spinner)
fires ~30 times per second while the loading screen is up. If a
*new* VMA fires every few seconds (~8 s interval), that is the
tip cycle function.
## After the trace
1. Identify the new VMA from the log.
2. Add it to the static-RE notes in `RE_notes.md`.
3. Add a `candidates[]` entry in `src/trace_tip_cycle.cpp` and
`src/main.cpp` (with a TODO marker for the actual byte-pattern
patch).
4. Re-run with the new candidate list if necessary.
## Caveats
- `DebugActiveProcess` will **freeze** the target until the trace
loop is running. If you set the breakpoint and then close the
tracer, the target will be left in a frozen state. Kill `eu4.exe`
with Task Manager to recover.
- x64 Windows only allows **4** HW execute breakpoints. The 5th and
later candidates in the list will not fire. If the cycle function
isn't in the first 4, you must narrow the list and re-run.
- The tracer is **not** stealthy — Paradox's anti-cheat (if it
runs in `eu4.exe`) will likely detect `DebugActiveProcess` on
the same process. Don't use this on an ironman / multiplayer
session.
|