Author SHA1 Message Date
Ryan Fleury c05ceedfcb fix clang build 2024-06-26 18:12:27 -07:00
Ryan Fleury 5e093a9b4c notes 2024-06-26 17:54:54 -07:00
Ryan Fleury 08bc2b0a79 fix up color config remapping table 2024-06-26 17:48:28 -07:00
Ryan Fleury 4ebc38d9f9 fill theme presets for new theme color codes 2024-06-26 17:39:40 -07:00
Ryan Fleury 5e2c6b5107 setting view categories 2024-06-26 15:47:28 -07:00
Ryan Fleury 7584890edd theme presets in new settings view 2024-06-26 15:16:41 -07:00
Ryan Fleury 4bbf64de7e first pass at new settings view 2024-06-26 15:00:45 -07:00
Ryan Fleury e10bef9d2b fix function breakpoints using hit-count as voff; pass over entity ref buttons in various uis; go-to-location with address values in watch views 2024-06-26 12:05:56 -07:00
Ryan Fleury 1229a50c68 eliminate txti layer 2024-06-26 11:09:58 -07:00
Ryan Fleury 6e2353d302 eliminate margin from output 2024-06-26 11:01:51 -07:00
Ryan Fleury 3d272a598b complete convergence of new disasm view, which uses the core code view path 2024-06-26 10:57:49 -07:00
Ryan Fleury dbdf6e7c02 eliminate old duplicative disasm path; use same code view path 2024-06-26 10:44:24 -07:00
Ryan Fleury 0904de74de eliminate old duplicative code/output views 2024-06-26 10:07:26 -07:00
Ryan Fleury e3077cf6f5 pick-file path for new code view 2024-06-26 10:06:16 -07:00
Ryan Fleury 9ad52d25b5 more progress on top-level interaction-register-based cursor commands, getting more out of unified source view 2024-06-26 10:02:26 -07:00
Ryan Fleury c2ddffd424 set up interaction register push/pops for windows & views; use to implement top-level cursor-breakpoint operations; more convergence with new unified src view path 2024-06-26 09:21:51 -07:00
Ryan Fleury 7d351d03c5 txt: split symbol tokens in language lexers to defaultly do single-char symbols unless in special cases; this resolves weird indirection-size-change code label displays 2024-06-26 07:37:52 -07:00
Ryan Fleury 2e12b1485a some light mode fixes, light mode theme preset re-filled 2024-06-25 17:53:39 -07:00
Ryan Fleury 653eb08d43 set up interaction register stack 2024-06-25 17:21:59 -07:00
Ryan Fleury 9be3c2affc sketch out 'interaction registers'; fix bp hit count tracking 2024-06-25 17:02:43 -07:00
Ryan Fleury 6fa8af5e1a checkpoint on unified code ctx menu & all of its operations 2024-06-25 16:31:31 -07:00
Ryan Fleury 010d5609c6 checkpoint in first pass at new unified code view impl.; start setting up unified top-level code ctx menu 2024-06-25 12:00:50 -07:00
Ryan Fleury d12c5ec2e8 first pass at mutable text layer, which allows debugger-produced/controlled buffers to be fed into text visualization systems; start pulling out code view into single path, which will be used for disassembly/source/output 2024-06-25 11:09:02 -07:00
Ryan Fleury c10ac170a8 config settings, for top-level toggles or simple numeric parameters; use to mask off animations, background blurs, and so on; use to control tab width 2024-06-25 09:09:10 -07:00
Ryan Fleury 7a185f9560 auto-fill ctrl+f query from selection; fix single-cell copy/paste in watch views; tweaks/fixes 2024-06-25 08:04:00 -07:00
Ryan Fleury 0d581694e6 notes; tweaks; fixes 2024-06-24 16:35:23 -07:00
Ryan Fleury b4b8f5f0ab fix some escape-to-cancel & context menu behavior; notes 2024-06-24 16:14:06 -07:00
Ryan Fleury 15d42027e7 adjust memory view for new ui palettes & themes 2024-06-24 15:39:12 -07:00
Ryan Fleury 883aa2d1de fix binding ui interaction with group keys 2024-06-24 15:34:56 -07:00
Ryan Fleury 586b3e3072 fix incorrect margin measurement in output view 2024-06-24 15:32:50 -07:00
Ryan Fleury 2588bbcd12 notes 2024-06-24 15:25:22 -07:00
Ryan Fleury 0a5cc5df6f ui: group key, for menu-bar-style interactions, where you have several distinct boxes, but want one interaction to continuously flow between them 2024-06-24 15:23:56 -07:00
Ryan Fleury ff32449ba2 adjust rich hover info in source/disasm view to be less noisy; require hovering over line number margin, rather than always displaying it for whatever line the mouse is over 2024-06-24 15:14:13 -07:00
Ryan Fleury 614954b7ef checkpoint on palettes, fix source view overlay margin building/drawing 2024-06-24 14:46:16 -07:00
Ryan Fleury 31c671e3f5 more progress on simplifying/condensing new theme colors 2024-06-24 14:08:28 -07:00
Ryan Fleury 6d75d6b63b simplification/consolidation pass over theme colors 2024-06-24 11:59:19 -07:00
Ryan Fleury 4d2b524400 notes, ui pass tweaks 2024-06-23 23:21:18 -07:00
Ryan Fleury 16863b1f5a fix run-list size calculation, accounting for advance vs. end pad 2024-06-22 20:29:38 -07:00
Ryan Fleury f9abb397f3 adjust px offset -> byte offset path for new text measuring fixes 2024-06-22 20:19:24 -07:00
Ryan Fleury db5a7d4be2 adjust title bar 2024-06-22 16:12:53 -07:00
Ryan Fleury 6ac870dac0 improvements in text layout, focus visualization, smooth text rasterization for icons; checkpoint in ui visuals pass 2024-06-22 15:58:40 -07:00
Ryan Fleury 5f23820f9d checkpoint on ui/palettes/visuals pass 2024-06-21 22:06:40 -07:00
Ryan Fleury fc77844452 color scheme -> palette; fix eval/watch views after cleanup; make more progress on new palette system 2024-06-21 09:49:51 -07:00
Ryan Fleury 3b27abd5c7 first pass at new theme color table, scheme-based ui color specification 2024-06-20 15:28:48 -07:00
Ryan Fleury ce1f54a931 notes 2024-06-20 09:06:35 -07:00
Ryan Fleury c60d3aab22 mouse-driven ui path for query completion; show-in-explorer ui for tab ctx menu 2024-06-20 08:02:01 -07:00
Ryan Fleury b76c605eba sort locals by debug info order; still likely not sufficient for all the options, but at least marginally better & introduces the sorting path 2024-06-20 07:35:59 -07:00
Ryan Fleury 6eef8c3e16 rdi_format_parse: prefer line info idxs with file coordinates in line mapping helper 2024-06-19 13:27:34 -07:00
Ryan Fleury b5b5aca691 log win32 demon resume code 2024-06-19 12:07:08 -07:00
Ryan Fleury 435877824a oh NO... never mind... mystery solved... be VERY CAREFUL ABOUT STATE MACHINES! fixes incorrect non-resets of win32 demon 'exception not handled' state, which was buggily leading to DBG_EXCEPTION_NOT_HANDLED being passed to ContinueDebugEvent 2024-06-19 11:56:47 -07:00
Ryan Fleury 3327d73373 notes on memory-execution-exception spoof implementation situation, and toggles to switch to old behavior, for later investigation 2024-06-19 11:32:44 -07:00
Ryan Fleury 376a7c48a5 pass over logging, include a lot of extra info in ctrl thread log; demon abstraction for target-process memory allocation/protection; switch spoofs to being in allocated page, rather than at bogus address 2024-06-19 11:12:21 -07:00
Ryan Fleury f6eec680bc adjust single stepping rule to be robust to non-single-step events; this is still not what the issue is pertaining to the stepping bug... 2024-06-18 17:19:17 -07:00
Ryan Fleury 41fd224956 log ctrl events on user thread; do not use cached register block reading path for ctrl stepping machine, as it must not prematurely update cache for all readers, since runs are not complete 2024-06-18 12:07:46 -07:00
Ryan Fleury c794d896c9 oops - fix logging for trap net 2024-06-18 10:59:35 -07:00
Ryan Fleury 1a8b39ad9d fix builds github workflow for new build names 2024-06-18 10:56:41 -07:00
Ryan Fleury a8891b3ca4 fix rdi_from_dwarf build 2024-06-18 10:55:54 -07:00
Ryan Fleury ada1b8dfe2 log final trap net 2024-06-18 10:51:29 -07:00
Ryan Fleury 9461e79268 adjust build script to warn if valid build target was not specified 2024-06-18 10:46:50 -07:00
Ryan Fleury 4fc5b61676 also disable overly-ambitious cursor centering in memory view 2024-06-18 10:28:49 -07:00
Ryan Fleury 6cc1dfb39a trap net generation logging; log markers 2024-06-18 10:14:54 -07:00
Ryan Fleury d44f098e84 disallow override detection with nil overrides 2024-06-17 13:06:23 -07:00
Ryan Fleury 749821dd27 adjust unwind loop to be robust to noop-unwind-steps that would otherwise result in infinite unwind loops 2024-06-17 12:14:10 -07:00
Ryan Fleury 6ad94978ce correctly adjust dbgi timestamp in ctrl entity store, upon debug info changes 2024-06-17 10:55:17 -07:00
Ryan Fleury bc5d0b1888 fix rich hover reset behavior 2024-06-17 10:18:41 -07:00
Ryan Fleury 3c2c98b08a rdi_make: fix incorrect line table count calculation 2024-06-17 10:08:11 -07:00
Ryan Fleury 31d7be8f8a tweak snap-to-cursor behavior when dragging 2024-06-17 09:42:12 -07:00
Ryan Fleury 0b3e3228d1 rdi_from_pdb: fix incorrect bounds checks on procedure frameproc lookup for local location info 2024-06-17 09:34:27 -07:00
Ryan Fleury 794f212501 dasm address consistency 2024-06-14 14:17:26 -07:00
Ryan Fleury 723c7c5d4d further tightening up of win32 demon run path; take a few fastpaths on x64; speeds up conditional breakpoints 2024-06-14 09:50:33 -07:00
Ryan Fleury fb9824dc24 remove unnecessary ctrl log flushes, which seriously bloated the ctrl thread running path 2024-06-14 07:57:46 -07:00
Ryan Fleury 933b4c90de fix rdi_format_parse and rdi_breakpad_from_pdb build 2024-06-13 17:12:31 -07:00
Ryan Fleury 5349838633 rdi: producer name in top-level-info 2024-06-13 16:55:47 -07:00
Ryan Fleury f655758060 extend tooltips & stringization of callstacks with rich unwind info 2024-06-13 16:48:27 -07:00
Ryan Fleury fa4d0bc262 ctrl: break debug string events apart if needed; enforce size cap on serialized ctrl events 2024-06-13 16:24:54 -07:00
Ryan Fleury 3c39a88abf correctly transform saved relative project paths to absolute project paths on config deserialization 2024-06-13 15:52:11 -07:00
Ryan Fleury fb6689a74d always report debug string events earlier in queue 2024-06-13 15:28:56 -07:00
Ryan Fleury a5e29f65f6 Merge branch 'inline_merge' of https://github.com/EpicGamesExt/raddebugger into inline_merge 2024-06-13 15:20:35 -07:00
Ryan Fleury b6f50cc4be intersect line voff ranges across all overlapping line tables when mapping voffs to line info; fixes inline stepping 2024-06-13 15:18:29 -07:00
Ryan Fleury b47b22bdce correct thread -> src mapping, given inline info 2024-06-13 15:18:29 -07:00
Ryan Fleury 41e99bd2f6 proper inline frame unwind selection & storage & command parameterization 2024-06-13 15:18:29 -07:00
Ryan Fleury 2c7d15de59 pull out 'rich unwind' gathering path, which takes a 'concrete unwind'
and produces a full unwind with debug-info-derived inline frames
2024-06-13 15:18:29 -07:00
Ryan Fleury bf2d5640fa go back to per-inline-site line tables; eliminate call location for inline tables; these can be encoded via parent line tables; wire up parsed line tables to inline site production from symbol conversion phase 2024-06-13 15:18:29 -07:00
Ryan Fleury 1880eca295 do not assume non-empty name map bakes 2024-06-13 15:18:29 -07:00
Ryan Fleury 59a20a5574 fix missing line chunks in inline line table parsing 2024-06-13 15:18:29 -07:00
Ryan Fleury 852ff5f054 oops! 2024-06-13 15:18:29 -07:00
Ryan Fleury ac3d7be4de look up into inline site info in call stack view; display both concrete & inline frames 2024-06-13 15:18:29 -07:00
Ryan Fleury 07b56a920c parse inline site scope ranges in symbol conversion pass 2024-06-13 15:18:29 -07:00
Ryan Fleury 1cc829512f fix disasm cmd/ui discrepancy 2024-06-13 15:18:29 -07:00
Ryan Fleury dafbe32e85 adjust line info lookup apis to be range-based, with a first-and-shallowest-only helper 2024-06-13 15:18:29 -07:00
Ryan Fleury 2419a00b11 fix cases where decorative disasm lines were being confused with non-decorative 2024-06-13 15:18:29 -07:00
Ryan Fleury 6e9b2bd107 extend rdi line info lookups with depth; fix bad panel deref in target view cmds 2024-06-13 15:18:29 -07:00
Ryan Fleury 123232ab32 correctly apply procedure base voffs in inline line info parsing 2024-06-13 15:18:29 -07:00
Ryan Fleury 1dbc37fe1f eliminate per-inline-site line tables; merge inline site line info with unit's line table 2024-06-13 15:18:29 -07:00
Ryan Fleury 4c10967cec merged line table sort experiments 2024-06-13 15:18:29 -07:00
Ryan Fleury e543abd478 rdi_from_pdb: next checkpoint on inline line table parsing/conversion 2024-06-13 15:18:29 -07:00
Ryan Fleury 3b94fa55fb rdi_from_pdb: inline binary annotations parsing 2024-06-13 15:18:29 -07:00
Ryan Fleury 3b6d8cb761 rdi_from_pdb: sketch out unified inlinee parsing/gathering path in units conversion task 2024-06-13 15:18:29 -07:00
Ryan Fleury a73cde2864 codeview c13 inlinee lines info parsing, lookup in inline site parsing path 2024-06-13 15:18:29 -07:00
Ryan Fleury fe12f2fdf9 inline site info extraction 2024-06-13 15:18:29 -07:00
Ryan Fleury c80555c49d rdi_make, rdi_from_pdb, rdi_dump: sketch out the building (no parsing/filling yet), dumping, and baking/serializing of inline sites 2024-06-13 15:18:29 -07:00
Ryan Fleury a3f411ddd4 more progress on rdi parsing library high-level composite helpers; update breakpad_from_pdb to new format/maker changes 2024-06-13 15:18:29 -07:00
Ryan Fleury 084cabad39 pass over high level composite rdi parsing helpers 2024-06-13 15:18:29 -07:00
Ryan Fleury 64d7bae845 rdi_make: eliminate old baking/serializing code 2024-06-13 15:18:29 -07:00
Ryan Fleury 93d5bab41c eliminate base node idx from per-node info; nodes can be stored all relative to their name map's base indices, and this is naturally applied on lookup, no need to bake it in 2024-06-13 15:18:29 -07:00
Ryan Fleury 772bc37504 fix fuzzy search layer for new table extraction code 2024-06-13 15:18:29 -07:00
Ryan Fleury 2ff0abb91e rdi_make, rdi_from_pdb: complete next pass over new serialization/compression interface, including for new top-level-only name map data sections; eliminate determinism issues from string map build (task dispatch was busted) 2024-06-13 15:18:28 -07:00
Ryan Fleury b05cfa4b24 checkpoint on new baking implementation 2024-06-13 15:18:28 -07:00
Ryan Fleury 379885421e rdi make: xfer over per-name-map building path 2024-06-13 15:18:28 -07:00
Ryan Fleury 809a888ce7 rdi make: first pass at new baking paths 2024-06-13 15:18:28 -07:00
Ryan Fleury 9dadd3ed3c sketch out new rdi make baking codepaths 2024-06-13 15:18:28 -07:00
Ryan Fleury d0d1e7d7e6 sketch out artifact types for new rdi baking pass 2024-06-13 15:18:28 -07:00
Ryan Fleury 10ead2f999 rdi: first pass of eliminating remainder of non-top-level sections; simplification/cleanup of rdi parsing layer 2024-06-13 15:18:28 -07:00
Ryan Fleury 550e8a0451 set up inline site info building scaffolding 2024-06-13 15:18:28 -07:00
Ryan Fleury 7495096e05 fix baking of joined line tables 2024-06-13 15:18:28 -07:00
Ryan Fleury 7e85335f3b move per-source-file line maps to top-level sections, and move source line -> voff maps to separate top-level info table 2024-06-13 15:18:28 -07:00
Ryan Fleury 3ad6197b88 eliminate old per-unit line info code 2024-06-13 15:18:28 -07:00
Ryan Fleury 81b45f1a2f do not broadcast unnecessarily in task system kickoff 2024-06-13 15:18:28 -07:00
Ryan Fleury 44868c0e85 rdi, rdi_make, rdi_from_pdb, rdi_dump, df, dasm, etc: extract line tables from per-unit data sections, have top-level line info tables with units referring to line tables, and line tables just referring to sub-ranges of top-level sections; fix off-by-one string index in rdi generation 2024-06-13 15:18:28 -07:00
Ryan Fleury f7ce1b73bc introduce separate rdi table element types for isolated line tables & inline sites 2024-06-13 15:18:28 -07:00
Ryan Fleury a4a0452d0c fix project.4coder 2024-06-13 15:18:28 -07:00
Ryan Fleury 45090de3fb appease clang 2024-06-13 15:18:28 -07:00
Ryan Fleury 6824ffddc0 intersect line voff ranges across all overlapping line tables when mapping voffs to line info; fixes inline stepping 2024-06-13 15:17:12 -07:00
Ryan Fleury dc34cdb59a correct thread -> src mapping, given inline info 2024-06-13 15:04:12 -07:00
Ryan Fleury 98290ff29b proper inline frame unwind selection & storage & command parameterization 2024-06-13 14:58:18 -07:00
Ryan Fleury 5a24649a31 pull out 'rich unwind' gathering path, which takes a 'concrete unwind'
and produces a full unwind with debug-info-derived inline frames
2024-06-13 11:28:38 -07:00
Ryan Fleury 97a96cfdd4 go back to per-inline-site line tables; eliminate call location for inline tables; these can be encoded via parent line tables; wire up parsed line tables to inline site production from symbol conversion phase 2024-06-13 10:41:19 -07:00
Ryan Fleury e25c3044b0 do not assume non-empty name map bakes 2024-06-10 15:59:19 -07:00
Ryan Fleury af80e1bfc8 fix missing line chunks in inline line table parsing 2024-06-10 15:42:50 -07:00
Ryan Fleury 6488e2d5e2 oops! 2024-06-10 15:26:02 -07:00
Ryan Fleury 649932cce0 look up into inline site info in call stack view; display both concrete & inline frames 2024-06-10 15:06:25 -07:00
Ryan Fleury dd5cc89483 parse inline site scope ranges in symbol conversion pass 2024-06-10 14:36:00 -07:00
Ryan Fleury 8a6837c553 fix disasm cmd/ui discrepancy 2024-06-10 13:33:32 -07:00
Ryan Fleury a009473557 adjust line info lookup apis to be range-based, with a first-and-shallowest-only helper 2024-06-10 13:28:08 -07:00
Ryan Fleury c18c02a37e fix cases where decorative disasm lines were being confused with non-decorative 2024-06-10 13:23:32 -07:00
Ryan Fleury c61f820aef extend rdi line info lookups with depth; fix bad panel deref in target view cmds 2024-06-10 12:34:22 -07:00
Ryan Fleury 5c8c1a89e3 correctly apply procedure base voffs in inline line info parsing 2024-06-10 11:35:31 -07:00
Ryan Fleury 61630f4cf9 eliminate per-inline-site line tables; merge inline site line info with unit's line table 2024-06-10 11:26:54 -07:00
Ryan Fleury 21b439e7e5 merged line table sort experiments 2024-06-10 11:12:21 -07:00
Ryan Fleury 4888f90f7f rdi_from_pdb: next checkpoint on inline line table parsing/conversion 2024-06-10 09:45:41 -07:00
Ryan Fleury 6f92fe971a rdi_from_pdb: inline binary annotations parsing 2024-06-10 09:18:05 -07:00
Ryan Fleury cfd2380caa rdi_from_pdb: sketch out unified inlinee parsing/gathering path in units conversion task 2024-06-07 17:22:45 -07:00
Ryan Fleury 07d56ee27c codeview c13 inlinee lines info parsing, lookup in inline site parsing path 2024-06-07 16:40:21 -07:00
Ryan Fleury 334bd3b06f inline site info extraction 2024-06-07 15:22:53 -07:00
Ryan Fleury a14a2f34f5 rdi_make, rdi_from_pdb, rdi_dump: sketch out the building (no parsing/filling yet), dumping, and baking/serializing of inline sites 2024-06-07 14:54:13 -07:00
Ryan Fleury 9dcb5a209a more progress on rdi parsing library high-level composite helpers; update breakpad_from_pdb to new format/maker changes 2024-06-07 13:45:26 -07:00
Ryan Fleury 300b14ffb4 pass over high level composite rdi parsing helpers 2024-06-07 11:45:18 -07:00
Ryan Fleury 8c63478d9b rdi_make: eliminate old baking/serializing code 2024-06-07 11:17:48 -07:00
Ryan Fleury 8f03fb0cc5 eliminate base node idx from per-node info; nodes can be stored all relative to their name map's base indices, and this is naturally applied on lookup, no need to bake it in 2024-06-07 11:17:11 -07:00
Ryan Fleury b48fcea28a fix fuzzy search layer for new table extraction code 2024-06-07 11:07:58 -07:00
Ryan Fleury 431884dce8 rdi_make, rdi_from_pdb: complete next pass over new serialization/compression interface, including for new top-level-only name map data sections; eliminate determinism issues from string map build (task dispatch was busted) 2024-06-07 11:03:00 -07:00
Ryan Fleury d931aed462 checkpoint on new baking implementation 2024-06-06 17:13:44 -07:00
Ryan Fleury 2c4c9e9d75 rdi make: xfer over per-name-map building path 2024-06-06 16:50:02 -07:00
Ryan Fleury 11978904e1 rdi make: first pass at new baking paths 2024-06-06 16:47:33 -07:00
Ryan Fleury 8d99f4859b sketch out new rdi make baking codepaths 2024-06-06 16:06:50 -07:00
Ryan Fleury 6e84c078a8 sketch out artifact types for new rdi baking pass 2024-06-06 15:37:27 -07:00
Ryan Fleury 14034c8bea rdi: first pass of eliminating remainder of non-top-level sections; simplification/cleanup of rdi parsing layer 2024-06-06 14:37:22 -07:00
Ryan Fleury 0a88e08dee Merge branch 'dev' of https://github.com/EpicGamesExt/raddebugger into inline_merge 2024-06-05 18:06:47 -07:00
Ryan Fleury c04a97f991 eval: fix enum type unwrapping; unwrap enum types on array indexing 2024-06-05 18:06:09 -07:00
Ryan Fleury 0b35224cf8 set up inline site info building scaffolding 2024-06-04 17:04:53 -07:00
Ryan Fleury 3f50169fee fix baking of joined line tables 2024-06-04 15:46:51 -07:00
Ryan Fleury ebd5cf9e47 move per-source-file line maps to top-level sections, and move source line -> voff maps to separate top-level info table 2024-06-04 13:33:38 -07:00
Ryan Fleury f7e67a80c9 eliminate old per-unit line info code 2024-06-03 16:45:33 -07:00
Ryan Fleury 063975693d do not broadcast unnecessarily in task system kickoff 2024-06-03 16:25:37 -07:00
Ryan Fleury 44fbbc24ee rdi, rdi_make, rdi_from_pdb, rdi_dump, df, dasm, etc: extract line tables from per-unit data sections, have top-level line info tables with units referring to line tables, and line tables just referring to sub-ranges of top-level sections; fix off-by-one string index in rdi generation 2024-06-03 15:32:14 -07:00
Ryan Fleury fcb839b788 introduce separate rdi table element types for isolated line tables & inline sites 2024-06-02 21:22:01 -07:00
Ryan Fleury 139d00e660 Merge branch 'dev' of https://github.com/EpicGamesExt/raddebugger into inline_merge 2024-06-02 18:24:30 -07:00
Ryan Fleury 41afe1af64 Merge branch 'dev' of https://github.com/EpicGamesExt/raddebugger 2024-06-02 18:23:38 -07:00
Ryan Fleury 3927d333ae remove unnecessary and sometimes unsupported win_noexcept keyword 2024-06-02 18:22:51 -07:00
Ryan Fleury 8438faca06 fix project.4coder 2024-06-01 21:09:44 -07:00
Ryan Fleury 061abb4545 appease clang 2024-06-01 21:09:36 -07:00
Ryan Fleury 011c980646 fix project.4coder 2024-06-01 21:09:10 -07:00
Ryan Fleury 26626c3946 appease clang 2024-06-01 21:09:06 -07:00
Ryan Fleury 281849b4e8 fix project.4coder 2024-06-01 21:06:28 -07:00
Ryan Fleury d3f7bef2b7 appease clang 2024-06-01 21:06:22 -07:00
Ryan Fleury ab5259a3d3 Merge branch 'inline_merge' of https://github.com/EpicGamesExt/raddebugger into inline_merge 2024-06-01 19:25:33 -07:00
Ryan Fleury 57da328c2a d3d11 render backend c++ -> c; raddbg build c++ -> c 2024-06-01 19:24:47 -07:00
Ryan Fleury ebc19ded62 font provider dwrite c++ -> c 2024-06-01 19:24:47 -07:00
Ryan Fleury aff3da8256 move font provider directwrite backend to using martins' auto-generated dwrite c declarations, get it almost off C++ entirely 2024-06-01 19:24:47 -07:00
Ryan Fleury c1764cee07 adjust builds to new rdi library setup 2024-06-01 19:24:46 -07:00
Ryan Fleury cc58703185 reorganize generated & handwritten library (relocatable) rad debug info format files; separate from codebase-local tools for managing or internally including the libraries 2024-06-01 19:24:46 -07:00
Ryan Fleury 6a57555882 lld no_aslr 2024-06-01 19:24:46 -07:00
Ryan Fleury cdf0b67354 clean up metaprogram multiline string line endings; fix rdi_from_pdb build 2024-06-01 19:24:46 -07:00
Ryan Fleury 45f69b6f98 further progress on metacode-driven generation of rdi headers; metaprogram xlist generation; getting rdi_dump up-to-speed 2024-06-01 19:24:46 -07:00
Ryan Fleury 47df50b6dc generation folder output override in metaprogram 2024-06-01 19:24:46 -07:00
Ryan Fleury f50b54cff7 complete metacodification of rdi format info into tables 2024-06-01 19:24:46 -07:00
Ryan Fleury 8492693df2 initial pass of moving rdi definitions to metacode tables 2024-06-01 19:24:45 -07:00
Nikita SmithandRyan Fleury 652a9b5cee codeview: inline binary annot format and decode helpers 2024-06-01 19:23:59 -07:00
Ryan Fleury 7f87f89aa8 rdi_dump: stringize source file's path 2024-06-01 19:22:30 -07:00
Nikita SmithandRyan Fleury 92b3356526 codeview: struct defs for $$INLINEE_LINES 2024-06-01 19:22:30 -07:00
Nikita SmithandRyan Fleury 98486f0795 codeview: new sub-section types 2024-06-01 19:22:29 -07:00
Ryan Fleury 729a5a9392 clean up & merge inline binary annotation decoders 2024-06-01 19:22:29 -07:00
Nikita SmithandRyan Fleury ffa802f583 codeview: inline binary annot format and decode helpers 2024-06-01 19:22:29 -07:00
Ryan Fleury b192e38d12 d3d11 render backend c++ -> c; raddbg build c++ -> c 2024-06-01 19:21:43 -07:00
Ryan Fleury 3c0831ec09 font provider dwrite c++ -> c 2024-06-01 18:21:29 -07:00
Ryan Fleury 02e1b8cf00 move font provider directwrite backend to using martins' auto-generated dwrite c declarations, get it almost off C++ entirely 2024-06-01 18:20:13 -07:00
Ryan Fleury 448baf68a8 adjust builds to new rdi library setup 2024-06-01 12:07:55 -07:00
Ryan Fleury 82c1badcdc reorganize generated & handwritten library (relocatable) rad debug info format files; separate from codebase-local tools for managing or internally including the libraries 2024-06-01 12:05:51 -07:00
Ryan Fleury 01a21af955 lld no_aslr 2024-06-01 11:57:44 -07:00
Ryan Fleury a8b02f9791 clean up metaprogram multiline string line endings; fix rdi_from_pdb build 2024-06-01 11:30:51 -07:00
Ryan Fleury 2c9a6f996d fix zero expression child nodes, commonly produced via partially typed expressions 2024-06-01 10:58:49 -07:00
Ryan Fleury d66bbdc6a7 further progress on metacode-driven generation of rdi headers; metaprogram xlist generation; getting rdi_dump up-to-speed 2024-06-01 10:16:38 -07:00
Ryan Fleury de56231f4a generation folder output override in metaprogram 2024-05-31 17:29:25 -07:00
Ryan Fleury 35c1c463c8 complete metacodification of rdi format info into tables 2024-05-31 17:16:54 -07:00
Ryan Fleury 59e71eb5cc drive iteration in win32 file system api; fix some root-level behaviors of file browser 2024-05-31 12:20:14 -07:00
Ryan Fleury d3adfdeced deduplicate debug string event generation; log ctrl messages 2024-05-31 11:17:59 -07:00
Ryan Fleury ed8731c093 correctly handle copy path in new multicursor-able watch view controls 2024-05-31 10:47:46 -07:00
Ryan Fleury 6d4b4b1526 time-based exit path for demon win32 event consumption loop, to not overly-aggressively-buffer things 2024-05-30 07:10:21 -07:00
Ryan Fleury 9fbcd1ec36 Merge branch 'dev' 2024-05-30 07:06:53 -07:00
Ryan Fleury da54fd1217 majorly improve outputdebugstring performance 2024-05-30 07:06:29 -07:00
Ryan Fleury 34bba95839 import todo notes from awkwardly aggressive user feedback 2024-05-29 21:25:47 -07:00
Ryan Fleury 89fd718a8c Merge branch 'dev' of https://github.com/EpicGamesExt/raddebugger into inline_merge 2024-05-29 12:35:49 -07:00
Ryan Fleury 89c8f84498 more tweaks with new double-margin; do not try to display non-printable ascii characters in watch 2024-05-29 12:25:03 -07:00
Ryan Fleury c426818364 draw line between priority & catchall marging 2024-05-29 11:53:48 -07:00
Ryan Fleury 62fa397e29 split code slice margin into two parts - priority, and catchall. priority for selected thread so it is always necessarily visible, and catchall for other threads, breakpoints, watch pins, etc. also tweak targets view behavior to prioritize selection as the common path, and to make checkboxes less idiosyncratic 2024-05-29 11:51:04 -07:00
Ryan Fleury 0e179f3844 fix clips, occlusion, for ui-tree-wide truncated text tooltips 2024-05-29 10:56:46 -07:00
Ryan Fleury f808e8ae29 adjust force-contain on tooltips; we don't want it for drag/drop, we do for tooltips, so use active interaction as a proxy 2024-05-29 10:43:14 -07:00
Ryan Fleury 8f446d1f9a pass over callstack view to display function type info and properly display richer/weirder C++ symbol names 2024-05-29 10:36:22 -07:00
Ryan Fleury e073ff3218 more notes on the multithreaded access violation stuff! 2024-05-29 08:31:24 -07:00
Ryan Fleury 2512d07c72 correctly roll-back late-hits for int3s 2024-05-29 08:08:44 -07:00
Ryan Fleury f65cf5436e fix code off -> instruction idx lookup - fixes busted instruction pointer drawing in disassembly view 2024-05-29 08:03:06 -07:00
Ryan Fleury 5778e75d66 oops - do not zero unwind cache node after adding it, zero it before adding it 2024-05-28 21:45:14 -07:00
Ryan Fleury 08750c2318 initial pass of moving rdi definitions to metacode tables 2024-05-28 21:31:56 -07:00
Ryan Fleury 9a5a3b9296 Merge remote-tracking branch 'refs/remotes/origin/inline_merge' into inline_merge 2024-05-28 07:41:31 -07:00
Ryan Fleury cab8bdaf38 rdi_dump: stringize source file's path 2024-05-28 07:37:19 -07:00
Nikita SmithandRyan Fleury afb7aba039 codeview: struct defs for $$INLINEE_LINES 2024-05-28 07:37:19 -07:00
Nikita SmithandRyan Fleury 0750570081 codeview: new sub-section types 2024-05-28 07:37:18 -07:00
Ryan Fleury 86a9934016 clean up & merge inline binary annotation decoders 2024-05-28 07:37:18 -07:00
Nikita SmithandRyan Fleury f14686c6fb codeview: inline binary annot format and decode helpers 2024-05-28 07:37:18 -07:00
Ryan Fleury e80008cb7e do not animate disasm load when running 2024-05-28 07:34:10 -07:00
Ryan Fleury 68d3f17ecb do not snap-to-thread on soft-halts 2024-05-28 07:30:54 -07:00
Ryan Fleury e541fce2bc fix non-enumeration of 0 tex2dfmt 2024-05-28 06:13:14 -07:00
Ryan Fleury 6a32c197fa rdi_dump: stringize source file's path 2024-05-28 06:10:43 -07:00
Nikita SmithandRyan Fleury eea3c6b53c codeview: struct defs for $$INLINEE_LINES 2024-05-28 06:10:43 -07:00
Nikita SmithandRyan Fleury d2f9bdeefb codeview: new sub-section types 2024-05-28 06:10:43 -07:00
Ryan Fleury c767f03f32 clean up & merge inline binary annotation decoders 2024-05-28 06:10:43 -07:00
Nikita SmithandRyan Fleury db737941d8 codeview: inline binary annot format and decode helpers 2024-05-28 06:10:43 -07:00
Ryan Fleury 8319850666 fix precision tab alignment issue 2024-05-28 06:10:12 -07:00
Ryan Fleury d04ee598b2 use lower level unwinding path with more generous time allowance, rather than passive cache query, for step-out 2024-05-26 14:35:57 -07:00
Ryan Fleury 15f5894c60 choose debug info key timestamps from debug info path, rather than module timestamp; the module should be allowed to be newer 2024-05-26 13:25:03 -07:00
Ryan Fleury 05c751a61a fix filesystem lister names 2024-05-26 12:47:47 -07:00
Ryan Fleury dd7cce2c3a some progress on the bitmap view rule 2024-05-24 21:20:44 -07:00
Ryan Fleury b1e1752229 oops 2024-05-24 17:19:46 -07:00
Ryan Fleury bddc9c97d9 get rdi_dump off dbgi layer, actually, super bad idea; just dedup decompression code 2024-05-24 17:18:31 -07:00
Ryan Fleury 325474fc49 Merge remote-tracking branch 'refs/remotes/origin/dev' into dev 2024-05-24 16:35:09 -07:00
Ryan Fleury 50d401e4ce formalize tab size in all ui codepaths, per-box; pick 4*columnsize by default in text views 2024-05-24 16:34:42 -07:00
Ryan Fleury 1dbbd351d7 formalize tab size in all ui codepaths, per-box; pick 4*columnsize by default in text views 2024-05-24 16:33:30 -07:00
Casey MuratoriandRyan Fleury 1161c4adbb Added line that got left out when I tried to commit this the first time. 2024-05-24 16:10:40 -07:00
Casey MuratoriandRyan Fleury 320a307e90 Dynamically linked SetThreadDescription to avoid requiring latest SDK/kernel version on Windows 2024-05-24 16:10:40 -07:00
Casey MuratoriandRyan Fleury f835158071 Added call to the build.bat so that rc can be redirected as a batch file 2024-05-24 16:10:40 -07:00
Ryan Fleury f214b7d5f2 eliminate tab picker ui 2024-05-24 15:17:36 -07:00
Ryan Fleury d716159faf feed base column & tab width through all font rendering paths; use temporary constants 2024-05-24 15:12:40 -07:00
Ryan Fleury 5074b7f62e expand f_push_run_from_... to basing its tab-advance logic on what base column it is starting at - currently assume this is 0, basically doing the most naive tab alignment version that will work for leading spaces but for nothing else, and also assume 4-space tab width for now 2024-05-24 14:40:07 -07:00
Martins MozeikoandRyan Fleury fd982d38fc Fixes bad resource usage in rendering
D3D11 is quite strict about how resources are supposed to be used - read/write & CPU access.
This changes Tex2DKind and BufferKind into one uniform ResourceKind (because it's the same thing really).

And it is more strict about usage:
1) Static is not allowed to update, resource is immutable, data provided at creation
2) Dynamic allows CPU to update GPU resource occasionally via UpdateSubresource
3) Stream allows CPU to update GPU resource often via Map/Unmap (currently unused)
2024-05-24 14:04:42 -07:00
Ryan Fleury 7e0611e7f1 recent projects history & opener 2024-05-24 14:03:07 -07:00
Ryan Fleury fd7085b690 do not settle for empty unwinds 2024-05-24 13:37:31 -07:00
Ryan Fleury 5f76fcfb6b filter panel tabs by project, if applicable; move all tab controls & so on to working based on this filtering mechanism 2024-05-24 13:33:47 -07:00
Ryan Fleury 9e778b30b6 begin tracking per-tab project info; fix dasm cache request dequeue incorrect cv broadcast 2024-05-24 12:58:54 -07:00
Ryan Fleury 15a1f81545 profile -> project 2024-05-24 12:35:51 -07:00
Ryan Fleury f7ad44a0d7 fix new-file query completion 2024-05-24 12:16:30 -07:00
Ryan Fleury 9349ac9e72 eliminate weird rollback/re-adjust rules for threads hitting int3s - rollback should only ever happen for temporary traps, e.g. user breakpoints or stepping. the fact that the thread shows *after* the trap later is a visualization issue, not a functionality issue 2024-05-24 08:20:10 -07:00
Ryan Fleury 489ae56223 fix moduleless unwinding and find-threads without debug info 2024-05-23 16:17:31 -07:00
Ryan Fleury 35b97d9c20 process name on stop-reason strings 2024-05-23 15:38:51 -07:00
Ryan Fleury bafc2170ca do not consume passthrough --s in command line parser 2024-05-23 15:21:53 -07:00
Ryan Fleury 6837d8d71a move rdi_dump over to dbgi layer 2024-05-23 15:16:53 -07:00
Ryan Fleury 35c599dea3 raddbgi -> rdi 2024-05-23 15:09:53 -07:00
Ryan Fleury dc5dda3f71 visualize handle basic types 2024-05-23 14:47:42 -07:00
Ryan Fleury fdfee37228 oops - only d3d11 flush on resize 2024-05-23 14:45:32 -07:00
Ryan Fleury ece414c575 prioritize title-bar-client-areas over built-in window borders; expand top bar rect a bit to ensure edge of window coverage 2024-05-23 14:40:23 -07:00
Ryan Fleury f431ac7f80 rewrite ipc communication; do ipc message reception on separate thread, wake up main thread; fix various robustness issues. do not necessarily initialize slower-to-initialize layers in conversion/ipc instances 2024-05-23 14:34:01 -07:00
Ryan Fleury e850f6fc93 c++ module extensions 2024-05-23 12:39:14 -07:00
Ryan Fleury 68a9802357 re-implement keyboard-driven path for opening dedicated view rule tabs 2024-05-23 11:36:51 -07:00
Ryan Fleury 905d04ab0b adjust disasm window limits; too often hitting non-read-only memory 2024-05-23 11:34:23 -07:00
Ryan Fleury bc40d1c0b0 rewrite frontend unwind cache to always preserve stale results until a new unwind successfully completes 2024-05-23 11:16:34 -07:00
Ryan Fleury f26b4c3b06 eliminate path-tree-based keying of debug info on frontend; use dbgi-layer-defined debug info keys, which can be more robust to changes to the same debug info path across time (e.g. during hot reloads 2024-05-23 10:30:23 -07:00
Ryan Fleury 68a92e910a eliminate old dbgi layer 2024-05-23 08:26:16 -07:00
Ryan Fleury 1621dc0637 correct nil rdi top-level-info 2024-05-23 07:54:28 -07:00
Ryan Fleury 21fcfd28a4 appease clang 2024-05-23 07:38:30 -07:00
Ryan Fleury 4a3d439c44 adjust symbol lister to apply to all loaded debug infos, rather than just the selected thread's debug info 2024-05-23 07:34:24 -07:00
Ryan Fleury 30f8e1675e new multi-dbgi-capable fuzzy search layer first pass 2024-05-23 07:01:34 -07:00
Ryan Fleury c17072053b adjust d3d11 resize path 2024-05-22 15:27:39 -07:00
Ryan Fleury a5e2235fc6 fix deadlocks on di_close contending with passive scoped dbgi access 2024-05-22 11:54:27 -07:00
Ryan Fleury 0160d05e8a further tweaks to mule_peb_trample 2024-05-22 11:39:23 -07:00
Ryan Fleury 7a4e939886 fix incorrectly referring to root entity for debug info if missing; fix thread register cache issues; fix new dbgi layer issues 2024-05-22 11:13:08 -07:00
Ryan Fleury b33559b081 tweaks to mule_peb_trample 2024-05-21 12:40:21 -07:00
Ryan Fleury b74db17375 peb trampling mule 2024-05-21 11:29:19 -07:00
Ryan Fleury a019115b95 get ctrl and debug frontend layers onto new pdb-path-based debug info loader layer; sketch out standalone fuzzy search layer, to replace old dbgi searching functionality; shift all debug frontend code from referring to debug info via 'binaries' to referring to debug info via 'dbgis', just file entities at the location of o.g. debug info 2024-05-21 10:08:28 -07:00
Ryan Fleury b9ac104276 begin stitching new dbgi layer usage code into ctrl layer; keep track of per-module preferred pdb paths via event-synchronized ctrl entity tree; still need conversion 2024-05-20 17:15:11 -07:00
Ryan Fleury 6e41bdf11b first pass at loader portion of new dbgi layer replacement; set up ctrl entity for per-module debug info selection path info 2024-05-20 16:28:52 -07:00
Ryan Fleury 49eb834e2b eliminate old unwind code 2024-05-20 12:58:02 -07:00
Ryan Fleury fd6befecc3 get tls address calculation off of binary parsing path; do based on in-process memory 2024-05-20 12:55:20 -07:00
Ryan Fleury 5342fab86b bugfix in new unwinder; applying stack ptr read & unwind when doing epilog unwinds 2024-05-20 11:12:29 -07:00
Ryan Fleury 9919ac59bb move module image info parse / cache management to ctrl thread, directly tie to module lifetime as ctrl thread sees it; reduce load from each unwind 2024-05-20 10:58:45 -07:00
Ryan Fleury 2d1fcd7475 fix some unwanted frontend unwind cache behavior; fix staleness calculation in ctrl process memory cache 2024-05-20 08:23:41 -07:00
Ryan Fleury 393fb9e5f2 eliminate old unwinder usage code; more regression fixing 2024-05-17 15:07:21 -07:00
Ryan Fleury 301cf6b7ac regression fixes, better integration, and tightening up the new unwinder 2024-05-17 14:15:11 -07:00
Ryan Fleury 578a56d231 further progress on new unwinder 2024-05-16 17:12:37 -07:00
Ryan Fleury 33ab26dfb3 begin porting unwinder to ctrl layer, just built purely on in-process memory, and getting completely off of parsed binary image artifacts 2024-05-16 15:39:57 -07:00
Ryan Fleury 8901dd30ec eliminate old pending entity code; do not build missing entity interface if data is actually present (but frontend cache still suggests missing) 2024-05-16 10:35:56 -07:00
Ryan Fleury e1a5d131c8 fix clang... sigh 2024-05-15 15:41:03 -07:00
Ryan Fleury 55c1674ec6 notes 2024-05-15 13:38:38 -07:00
Ryan Fleury 364a2160af correctly register jit debugger exe; collect jit_debug_info into dmn win32; notes 2024-05-15 13:25:20 -07:00
Ryan Fleury 56afe8ca60 watch window reordering 2024-05-15 11:57:46 -07:00
Ryan Fleury 6e039430a5 mouse controls for new watch window editing mechanism 2024-05-15 11:22:05 -07:00
Ryan Fleury f1af166fd4 expand ui events to contain semantic 'controls' info, to eliminate most hardcoded escs/returns/f2s/etc; formalize these things as proper commands; keyboard-driven expansions; other various fixes 2024-05-15 10:53:26 -07:00
Ryan Fleury 03844d81d2 further progress on watch window pass; multi-cursor, multi-selection, autocomplete lister, etc 2024-05-15 09:26:16 -07:00
Ryan Fleury aa73e62240 fix clang 2024-05-14 16:31:34 -07:00
Ryan Fleury 16de33245c first half of first pass at multi-cursor watch window 2024-05-14 16:25:24 -07:00
Ryan Fleury f8b688096a fix crash on tpi-less pdbs 2024-05-14 11:39:18 -07:00
Ryan Fleury 4dd1f6f579 eval watch -> watch; prep for more organized event-driven editing path for watch windows, beginning of multi-selection support 2024-05-14 10:33:03 -07:00
Ryan Fleury 58b8ed8974 floating line-nums/margins in source & disasm views, when horizontally scrolled 2024-05-14 09:07:44 -07:00
Ryan Fleury ac9a908464 automatically support insert-based copy/paste shortcuts 2024-05-14 08:27:59 -07:00
Ryan Fleury 5d459d9b7a skip/chop whitespace on launch parameters 2024-05-14 08:23:28 -07:00
Ryan Fleury 3085482e34 expand base layer logging mechanism with bucketing info; make one bucket for passive log collection, another for user-facing errors; always consume user errors at the top-level and display; use user-error mechanism to communicate bad 32-bit app launches from demon 2024-05-14 08:10:02 -07:00
Ryan Fleury 6c200a59cd bugfixes for new autocompletion system 2024-05-14 07:50:13 -07:00
Ryan Fleury 362bcbcda5 fix clang 2024-05-13 16:28:13 -07:00
Ryan Fleury 897949d33a notes 2024-05-13 16:27:15 -07:00
Ryan Fleury 70479e0399 fix autocompletion query word calculation 2024-05-13 16:26:54 -07:00
Ryan Fleury 90fc289ef0 extend autocompletion lister parameter detection, based on cursor position; feed through view rule parameters; correctly support cursor position with multi-arguments, regardless of which argument the cursor is on 2024-05-13 16:19:32 -07:00
Ryan Fleury 7c0f92ab3d sketch out view rule schemas; use them to determine autocompletion lister flags via partial parse of view rule input & matching to cursor; expand autocompletion lister to support lists of various things used in view rule arguments 2024-05-13 15:45:35 -07:00
Ryan Fleury 036d94fff0 autocompletion lister improvements - completions now can be used for sub-expression parts 2024-05-13 14:24:28 -07:00
Ryan Fleury 37dd5cea2d oops - this was not dead code! 2024-05-13 13:11:34 -07:00
Ryan Fleury 05f2cde2ee fix clang 2024-05-13 13:10:49 -07:00
Ryan Fleury e59d71893b bugfix copying & other accidental event consumption issues with new ui events 2024-05-13 12:57:45 -07:00
Ryan Fleury e41eb9430f finish pass to convert everything over to ui events, eliminate nav actions; intermix os events & ui event production with commands 2024-05-13 11:48:42 -07:00
Ryan Fleury 58192b8356 move all ui/df codepaths onto new ui event consumption, rather than os/nav events in parallel 2024-05-13 10:33:30 -07:00
Ryan Fleury 38e38eaf3b sketch out ui event type, to unify type & stream for text ops, nav actions, and all other user inputs 2024-05-13 07:48:48 -07:00
Ryan Fleury 9f89735b01 preserve jeff notes from emails - put into todo list 2024-05-12 14:11:08 -07:00
Ryan Fleury 4cb0073909 stop non-x64 builds with less cryptic errors 2024-05-10 16:32:01 -07:00
Ryan Fleury 6fb8db4d3d getting started view improvements 2024-05-10 10:15:10 -07:00
Ryan Fleury 123276a1c6 choose compact layout by default with smaller monitor size 2024-05-10 09:59:23 -07:00
Ryan Fleury 6e8753f1e1 formalize more compact panel layout 2024-05-10 09:56:06 -07:00
Ryan Fleury dda0e012bf support getting started view in default panel layout 2024-05-10 09:35:03 -07:00
Ryan Fleury 6660446bdd auto-close panels if final tabs are closed; simplify empty panel view, move 'helper' stuff to dedicated 'getting started' tab 2024-05-10 08:48:42 -07:00
Nikita SmithandRyan Fleury ef175baae4 fix chained unwind info count 2024-05-10 08:47:25 -07:00
Ryan Fleury f45ea18f24 full line bounds check in intermixed dasm 2024-05-01 05:13:17 -07:00
Ryan Fleury 4aeb6d7d03 notes 2024-04-30 11:38:02 -07:00
Ryan Fleury ed0ec4b34d last fixes, improvements, & split operation coverage for new tab drag/drop system 2024-04-30 11:14:24 -07:00
Ryan Fleury 2e971f9e39 do not force contain tooltip if it is above some threshold - otherwise it can occlude important ui 2024-04-30 10:02:50 -07:00
Ryan Fleury d65c263266 new/fixed panel animation 2024-04-30 09:41:57 -07:00
Ryan Fleury cd9437534c remove old animation method for panel pcts; since panels are often rearranged in a hierarchy, having pcts being based on parent rectangle (as opposed to the root rectangle) is unstable and often looks bad 2024-04-30 09:17:00 -07:00
Ryan Fleury 3b2656675e root-level non-split-axis splits; less noisy tab drag/drop ui 2024-04-30 05:39:34 -07:00
Ryan Fleury b4dab84235 always resolve to address mode evaluation when doing a member access 2024-04-29 18:13:50 -07:00
Ryan Fleury 2fc34ffb3d further coverage of split-drop drag/drop sites, for splitting options at non-leaf-panels 2024-04-29 12:17:03 -07:00
Ryan Fleury d419c6e15c formal drop-hot mechanism in ui core; further cleanup/fixes in drop-split combined operation ui 2024-04-29 11:06:18 -07:00
Ryan Fleury 15a2e708a0 hook up new combined move-tab-and-split ui with actual operation; auto-close panels which have their last tab dragged away; etc 2024-04-29 06:15:43 -07:00
Ryan Fleury 5a84fe4949 first half of pass to enable combined, standard split+movetab drag/drop fast-paths; just visualizations, next need the combo mutations 2024-04-28 18:51:57 -07:00
Ryan Fleury 9177299488 improve tab drag/drop 2024-04-28 17:29:41 -07:00
Ryan Fleury b6eb13761f fix breakpad_from_pdb build; robustify to typeless global vars 2024-04-25 11:53:23 -07:00
Ryan Fleury 67eede7513 hot-reloading for dasm_cache, in case of filesystem changes; file stream layer -> expose filesystem-wide generation number, for very coarse-grained generation number to gracefully depend on filesystem changes passively 2024-04-25 09:37:16 -07:00
Ryan Fleury f4ea9e66b0 bugfix on-demand process-dependent breakpoint resolution path & user breakpoint hit logic in stepping machine; more logging 2024-04-25 08:59:00 -07:00
Ryan Fleury 0dbde584bd jump destination symbol name visualization in disassembly 2024-04-23 19:12:58 -07:00
Ryan Fleury 579e3e9637 adjust source code intermixing symbol 2024-04-23 14:01:11 -07:00
Ryan Fleury 425626a275 first pass over mixed-mode disassembly 2024-04-23 13:52:44 -07:00
Ryan Fleury 5b87c2b64a bundle disassembly parameterizations into single dasm params type; extend with exe path & base address, to begin using debug info in the disassembly pass itself 2024-04-23 12:37:53 -07:00
Ryan Fleury 879e649d0e more frontend logging 2024-04-23 10:07:59 -07:00
Ryan Fleury 15e9dec60a fix incorrect entity destruction logging 2024-04-23 10:04:05 -07:00
Ryan Fleury ec13092a35 ui thread logging; more ctrl thread logging 2024-04-23 09:57:17 -07:00
Ryan Fleury 757cd9b9d2 correct createfile params for appending 2024-04-23 08:34:32 -07:00
Ryan Fleury 856c59a949 set up ctrl thread log scopes; ditch ctrl -> user log stuff, just make each log site in control of exporting to a separate file 2024-04-18 15:09:43 -07:00
Ryan Fleury 62d1c6b130 scoped log gathering; communicate ctrl logs -> user via events 2024-04-18 14:48:03 -07:00
Ryan Fleury b995909997 sketch out logging stub, to begin marking up debugger layers with logging - high level stuff still wip 2024-04-17 14:32:09 -07:00
Ryan Fleury a954317500 fix new issues with confirmation popup & top bar 2024-04-17 12:41:49 -07:00
Ryan Fleury b307d3bbed fix top bar issues 2024-04-17 11:50:38 -07:00
Ryan Fleury 8890284f97 zig lexing (syntax highlighting & hover-on-eval) 2024-04-17 11:36:01 -07:00
Ryan Fleury b41e762393 jai syntax highlighting & hover-eval support 2024-04-17 11:12:05 -07:00
Ryan Fleury 72e8ae6e30 actually do redraw on resize - need that win32 window class style.. 2024-04-17 09:58:03 -07:00
Ryan Fleury 9f4aade2e1 stepping fast-paths in top bar 2024-04-17 09:47:36 -07:00
Ryan Fleury 27fef06b6c remove unnecessary window class styles 2024-04-17 09:19:00 -07:00
Ryan Fleury 572fad1f03 first pass at custom window border 2024-04-17 08:46:21 -07:00
Ryan Fleury c31847f785 improve min sampling when applying transforms in ui 2024-04-13 12:18:01 -07:00
Ryan Fleury 9719688bb3 improve query visualization in tabs; don't collapse title before query string 2024-04-13 11:46:55 -07:00
Ryan Fleury a6bed27dff errr, reverse last change 2024-04-10 13:37:32 -07:00
Ryan Fleury b7a14aa41c explicitly show error if decoding line machine code or line info fails 2024-04-10 13:36:52 -07:00
Ryan Fleury 56bc399fd5 initial pass for compression in converter; decompression in debuggerdbgi layer 2024-04-10 09:33:55 -07:00
Ryan Fleury d560f8c734 fix backslash escaping rules in cfg serialization; fix small scrolling (e.g. from trackpad) often being truncated to having no effect; fixed hanging when set-thread-name specifies a non-readable address 2024-04-09 07:37:53 -07:00
Ryan Fleury 36b50981ff fix conditional breakpoints, post demon2/ctrl passes 2024-04-05 11:38:14 -07:00
Ryan Fleury 32114c3215 begin cleanup/naming pass over view rules 2024-04-05 10:17:38 -07:00
Ryan Fleury a8ece647c1 simplify and remove temporary polish from minified bitmap viewer 2024-04-02 15:31:02 -07:00
Ryan Fleury e0879ac569 stub out graph view rule 2024-04-02 15:18:16 -07:00
Ryan Fleury 0eb8216ea0 first pass at dedicated bitmap tab view, & all the machinery of going from watch window w/ view rule -> dedicated ui 2024-04-02 14:33:17 -07:00
Ryan Fleury cd1a0a4cb5 tab query serialization/deserialization; only enable for view rule defined view specs 2024-04-02 10:42:31 -07:00
Ryan Fleury 1b95eacd08 stub out visualizer tab view hooks for bitmap, geo, text, disasm viewers; pass down cfg node trees for open-tab command; visualize query string in tab titles 2024-04-02 10:35:19 -07:00
Ryan Fleury 546c544ae0 eliminate eval-viewer view - instead we can have the gfx view rule spec table optionally define tab view specs itself, and those can be separately registered from the sort of 'base' tab views. then we can map from gfx-view-rule -> dedicated-tab-view-spec 2024-04-02 10:16:53 -07:00
Ryan Fleury 3ea67dd7cf eliminate old disasm layer initialization 2024-04-01 15:09:41 -07:00
Ryan Fleury 52295e5e06 first pass at view rule lookup cache... this might not be the right thing here 2024-04-01 14:48:48 -07:00
Ryan Fleury 63123d69d1 set up auto view rule entities, serialization, & editor ui, for automatically mapping specific types to specific view rules 2024-04-01 14:30:48 -07:00
Ryan Fleury 835eae208a extend eval viz pipeline with split between edit/display expression strings per-block and per-row. this allows reconstruction of the string that would lead to the same eval as a row (even if it is auto-generated by e.g. expanding a root-level row; also allow -- to extend eval expressions with passthrough text, used for view rules 2024-04-01 13:56:07 -07:00
Ryan Fleury cfb34ec560 C++ namespace examples 2024-04-01 11:11:27 -07:00
Ryan Fleury c45b12cfac only export executable name, not full cmdline specified path in converter 2024-04-01 10:25:27 -07:00
Ryan Fleury 7c0ce2ab54 fix incorrect skip-to-end in new pdb -> raddbgi converter member parsing, in some cases (particularly noticeable in C++ structs with vtable members) 2024-03-30 19:44:20 -07:00
Ryan Fleury 693d20ec1a fix incorrect generation of modifier flags, container types, and out-of-order pointer/modifier types in new pdb -> raddbgi converter. fixes many 'nil type' issues, missing this ptr, etc. 2024-03-30 19:29:16 -07:00
Ryan Fleury a6db711f2d quick fix to not omit opl line records in breakpad_from_pdb 2024-03-29 15:53:18 -07:00
Ryan Fleury f2dd1e3c2d further sketching & setting up for escape-hatch-style view rule uis 2024-03-29 14:02:46 -07:00
Ryan Fleury 81c79c0ac2 sketch out parts of 'whole ui' eval viz pipeline build stage; fix copypaste issue with string viz 2024-03-29 12:52:19 -07:00
Ryan Fleury c1b92c1b27 reintroduce support for address/code-bytes toggling in disassembly view; also reintroduce support for toggle-watch-expr and goto-name commands 2024-03-29 11:51:20 -07:00
Ryan Fleury eec124c53b eliminate old text searching thread code 2024-03-29 11:28:45 -07:00
Ryan Fleury 8c5c0be040 ui: further improvements to double/triple dragging detection; df: use double/triple dragging to determine mouse-drag-range. dbl -> use token range, triple -> use line. pick appropriate side of mouse drag range on drag based on side of mark. 2024-03-29 11:17:01 -07:00
Ryan Fleury 2842901f9c ui: extend box->signal path with double-drag, triple-drag info 2024-03-29 10:58:05 -07:00
Ryan Fleury 6eb8e37d4d default to hexadecimal radix in register-mode hover-evaluations 2024-03-29 10:42:14 -07:00
Ryan Fleury 7496f3b8cc dont over-ambitiously respond to exceptions/errors on kill/detach 2024-03-29 10:22:06 -07:00
Ryan Fleury 7c3fabfc39 wchar test in mule_main 2024-03-29 10:13:29 -07:00
Ryan Fleury 4b3941c17f sketch out non-utf8 string visualization in frontend eval paths; simple retry mechanism for large memory reads that may fail across page boundaries in ctrl process memory cache 2024-03-29 10:09:57 -07:00
Ryan Fleury 60030b298b bitfield support in address mode -> value mode evaluation path 2024-03-29 09:51:38 -07:00
Ryan Fleury 60e1f105e4 raddbgi: correctly encode bitfields; type_graph: correctly stringify bitfield types 2024-03-29 09:22:13 -07:00
Ryan Fleury d9675f2565 allow assembly-style dereferences in eval parser; register/register-alias syntax highlighting 2024-03-29 08:52:46 -07:00
Ryan Fleury 7c7b44e940 attempt to auto-resolve numeric evaluations into addresses in frontend eval path 2024-03-29 08:52:45 -07:00
Mohit SethiandRyan Fleury 6c8963cd06 Disable Alt+Enter fullscreen 2024-03-29 08:23:24 -07:00
Ryan Fleury 5aa8aa1c66 fix expandability rules for function pointer types; identifiers -> keywords in disassembly 2024-03-28 19:56:33 -07:00
Ryan Fleury 7f50beae2a notes 2024-03-28 15:40:28 -07:00
Ryan Fleury 3931edb3f1 notes 2024-03-28 15:21:25 -07:00
Ryan Fleury 1904d4ca0d support copy from disasm (finally) 2024-03-28 15:19:25 -07:00
Ryan Fleury 0ead1c034c eliminate old dasm layer, since we're all caught up with dasm_cache 2024-03-28 14:58:25 -07:00
Ryan Fleury 09f74805e0 restore old demon layer linux implementation, to not have to seek back in version control to find it when porting 2024-03-28 14:54:52 -07:00
Ryan Fleury f75ae9eb4a transition disassembly command processing paths to dasm cache 2024-03-28 14:53:38 -07:00
Ryan Fleury 2f5cc748d8 use disasm style parameters in dasm_cache disassembly path 2024-03-28 14:42:56 -07:00
Ryan Fleury 614b9bc537 extend dasm cache with style parameters; switch over primary disassembly ui path to dasm cache 2024-03-28 14:38:35 -07:00
Ryan Fleury bcbb4142cf plug in x64 intel-syntax disassembly 'language' into text analysis cache layer, to use that layer to naturally do parser/highlighter work for disassembly 2024-03-28 12:01:14 -07:00
Ryan Fleury d3570e8147 further progress on disassembly cache; instead of caching the text via the disassembly cache, simply submit into the hash store; this allows the disassembly cache to be composed with other caches, like the text analysis cache. + plug this system into the disassembly view rule, so now we can disassemble arbitrary pointers in the watch window 2024-03-28 11:36:57 -07:00
Ryan Fleury c91cd69536 first pass at new hash-store-based disassembly cache layer; can serve as a general-purpose asynchronous disassembly visualization cache layer, regardless of where that data ultimately comes from - can click into a file, process memory cache, etc. 2024-03-28 10:57:34 -07:00
Ryan Fleury f46691d79a dasm -> dasmi; make room for new dasm_cache layer 2024-03-28 09:45:41 -07:00
Ryan Fleury dbb0c1e0a4 file_stream: solidify retry mechanism; df: multiline controls for text_cache-based info, begin porting over txti-based systems 2024-03-28 09:36:09 -07:00
Ryan Fleury 96ff5efe7c allow delete/rename access on exe/debug handles 2024-03-28 08:54:08 -07:00
Ryan Fleury a14d0f5b18 rewire up target colors with processes/modules/threads; use first module path for correllation rather than entities & id correllation 2024-03-27 15:25:27 -07:00
Ryan Fleury 22185cee5f eliminate stuck-step disabling hack 2024-03-27 14:36:11 -07:00
Ryan Fleury 1da92b8dbc store per-launch entry points in ctrl entity store; use to later correllate PIDs to custom entry points in run path 2024-03-27 14:24:06 -07:00
Ryan Fleury 291bf3875d eliminate launch-and-init path, switch fully to separate 'launch' and 'run' paths; snap to selected thread if no stopper thread on stopped events; 2024-03-27 14:09:29 -07:00
Ryan Fleury ee056aa45d collapse user bp gathering helper, used only once 2024-03-27 12:29:45 -07:00
Ryan Fleury 53163f3610 ctrl: kill launch_and_handshake; begin extending run to be usable for launch-and-init and launch-and-run operations 2024-03-27 12:26:15 -07:00
Ryan Fleury 4899f1871b correctly close module file handles on module unloading in new demon layer 2024-03-27 11:19:24 -07:00
Ryan Fleury d73a3d4196 plug txt-layer-provided tokens into text view rule - both source code & text view rule are now completely powered via the txt visualization layer, rather than the special-purpose txti layer, which is now being retired 2024-03-26 16:47:15 -07:00
Ryan Fleury 4272258f99 txti -> txt; checkpoint #5 2024-03-26 16:38:12 -07:00
Ryan Fleury 8792c2280c txti -> txt; checkpoint #4 2024-03-26 16:26:31 -07:00
Ryan Fleury 88798e4453 txti -> txt; checkpoint #3 2024-03-26 16:04:21 -07:00
Ryan Fleury e80c69cb8f txti -> txt; checkpoint #2 2024-03-26 16:00:43 -07:00
Ryan Fleury 40ed36df3f txti -> txt; checkpoint #1 2024-03-26 15:31:39 -07:00
Ryan Fleury 88b692c840 eliminate fallback cache in text cache layer; we can use the hash store layer to rewind 2024-03-26 12:11:00 -07:00
Ryan Fleury 9dc484858a eliminate geo cache fallback key/hash cache; we can just use the hash store to rewind 2024-03-26 11:59:54 -07:00
Ryan Fleury f7e7aec355 bundle 'get key & stream' operation in process memory cache; eliminate old cache interaction in texture view rule hook 2024-03-26 11:55:15 -07:00
Ryan Fleury 7cf8da0b43 eliminate fallback key/hash pair cache in texture cache layer; we can rely on rewinding purely via the hash store layer 2024-03-26 11:50:44 -07:00
Ryan Fleury 4027338a2f adjust stripe counts 2024-03-26 11:30:47 -07:00
righthandprincessandRyan Fleury 3e911a8c64 Improve disabled overlay
Disabled overlay now respects the theme background color, as well as
the theme inactive overlay color, improving readability across themes.
2024-03-26 11:08:38 -07:00
Ryan Fleury 4bc82db69e deduplicate txti/text_cache language stuff; port over odin lexing 2024-03-26 11:00:37 -07:00
Ryan Fleury ca6e75d466 allow c++14 digit separators in c/c++ lexing 2024-03-26 10:42:46 -07:00
Ryan Fleury 6393766f82 deduplicate txti/txt layer lexing 2024-03-26 10:31:20 -07:00
Ryan Fleury 206d48b363 notes 2024-03-25 15:47:34 -07:00
Ryan Fleury f561abfd63 show stopper-thread exception-info on entity tooltips, when applicable 2024-03-25 15:43:00 -07:00
Ryan Fleury 6d1c0d9f6d louder & more informative exception info viz 2024-03-25 15:37:31 -07:00
Ryan Fleury 55146b547b reading & organization pass over unwinding layer; deduplicate PE info with PE layer, move dwarf info to in-progress dwarf layer 2024-03-25 14:42:54 -07:00
Ryan Fleury 1c3792a3da tighten architecture-specific path for unwinder 2024-03-25 13:34:43 -07:00
Ryan Fleury e5df25b314 use stderr-based fatal crash reporting, rather than windows gui, with programs built as console interfaces rather than guis 2024-03-25 13:24:00 -07:00
Ryan Fleury 23c1ea0e68 ui: if only one view scroll axis is specified on a box, always use scroll info to fill it, regardless of which axis that scroll took place on 2024-03-25 13:02:17 -07:00
Ryan Fleury aa85b2cdbb correctly pass unicode environments to launched child processes; also treat unicode command line arguments correctly 2024-03-25 12:57:00 -07:00
Ryan Fleury e136a67535 demon/win32: correctly report exception repetitions for unhandled exception cases 2024-03-25 11:00:00 -07:00
Ryan Fleury 83ecb4b86a ctrl thread stepping machine: read initial stack-pointer-check-value *before* single-stepping stuck threads, otherwise we can obtain an incorrect stack check value if the single-step causes a call. 2024-03-22 17:27:54 -07:00
Ryan Fleury c26274ac70 disable single-step-stuck-thread behavior when launching-and-initing, such that breakpoints on entry point will not be stepped over 2024-03-22 17:17:08 -07:00
Ryan Fleury 995804cc78 demon2 -> demon; eliminate original demon layer 2024-03-22 16:33:48 -07:00
Ryan Fleury c9df04ca60 merge 2024-03-22 16:31:05 -07:00
Ryan Fleury 71f3d18bf7 notes 2024-03-22 16:30:04 -07:00
Ryan Fleury 928532f386 do not attempt to refresh tls base calculation cache, if targets running 2024-03-22 16:29:50 -07:00
Ryan Fleury 7cd524d39d fix tls base calculation in demon2 2024-03-22 16:19:35 -07:00
Ryan Fleury 2c8c9a497c parameterize ctrl thread registers cache with entity store, rather than relying on implicit demon-api-provided cache 2024-03-22 16:15:20 -07:00
Ryan Fleury c636e1ad2e extend demon2 with explicit separation between blocking ctrl mechanisms & passive access/introspection/writing mechanisms; extend demon2 api with access mechanism 2024-03-22 15:53:04 -07:00
Ryan Fleury 07bbf1b43c organize demon2 by thread api 2024-03-22 15:15:33 -07:00
Ryan Fleury ca01e66ea2 plug in tls root vaddr path 2024-03-22 14:12:40 -07:00
Ryan Fleury 14ac7141e7 double buffer member cache 2024-03-22 13:53:14 -07:00
Ryan Fleury 9de678ec22 disable debug heap by default; get unwindg path off caching layers & use demon reads directly 2024-03-22 13:51:26 -07:00
Ryan Fleury e9129975e3 double buffer locals cache & tls base cache; introduce synchronizing mechanism for run vs. non-run ctrl thread states, to only attempt demon reads/queries during non-running times 2024-03-22 13:32:22 -07:00
Ryan Fleury 3994adae92 double-buffer frontend unwind cache 2024-03-22 11:56:28 -07:00
Ryan Fleury 982f2b6bab extend process memory cache queries with output channel for staleness detection - in some cases this is crucial, in other cases you don't care & want to passively accept stale redsults 2024-03-22 10:33:20 -07:00
Ryan Fleury a694a77eba fix halting, unattached running, and caching generations in demon2 2024-03-21 16:49:34 -07:00
Ryan Fleury 54677e05ec fix incorrect metagen pointer comparisons 2024-03-21 16:21:17 -07:00
Ryan Fleury 236214db25 eliminate unnecessary layers in frontend 2024-03-21 16:13:01 -07:00
Ryan Fleury 2c9ff37b2c sketch out new unwind cache types 2024-03-21 13:53:12 -07:00
Ryan Fleury 1466b27385 tweak registers cache lookup rules, to correctly return stale results on failed reads 2024-03-21 11:48:48 -07:00
Ryan Fleury e0e84c2ee3 further progress on integrating new demon layer 2024-03-21 11:28:47 -07:00
Ryan Fleury c2709d78b8 dont over-ambitiously consider the unwind cache up-to-date if some thread unwinds failed 2024-03-17 12:21:57 -07:00
Ryan Fleury 1269b93588 fix unchecked zero pointers in bake string map joining task, when zero pointers are legal 2024-03-17 12:17:22 -07:00
Ryan Fleury 14d3037aec raddbgi_breakpad_from_pdb: add a few missing null checks for edge cases 2024-03-17 12:17:22 -07:00
Ryan Fleury fbf4cce0e7 make tpi hash parsing gracefully exit on empty input data 2024-03-17 12:17:21 -07:00
Ryan Fleury d3cdb97a4e notes 2024-03-17 12:16:40 -07:00
Ryan Fleury 808d26684e fix unchecked zero pointers in bake string map joining task, when zero pointers are legal 2024-03-15 14:16:30 -07:00
Ryan Fleury 8f0e39024f fix additional demon2 typo 2024-03-14 21:24:12 -07:00
Ryan Fleury aa7c30d85b ctrl: first pass at new thread registers cache; also checkpoint for progress on moving to new demon layer 2024-03-14 21:09:43 -07:00
Ryan Fleury 22e6352056 raddbgi_breakpad_from_pdb: add a few missing null checks for edge cases 2024-03-13 15:25:05 -07:00
Ryan Fleury 2fff68cfcf make tpi hash parsing gracefully exit on empty input data 2024-03-13 15:10:39 -07:00
Ryan Fleury 936c6149e3 remove timeout on thread register cache accessor 2024-03-12 16:35:43 -07:00
Ryan Fleury c417f15912 fix task entry points in breakpad converter 2024-03-12 16:01:30 -07:00
Ryan Fleury ea74f928cd fix process memory cache query mechanism when ring buffer is near capacity 2024-03-12 15:51:26 -07:00
Ryan Fleury 871419de39 bugfixes in new demon layer; adjust retry mechanism in process memory cache query; ui fixes 2024-03-12 15:49:36 -07:00
Ryan Fleury 8639faabdd ctrl entity string allocation & tracking, for thread names & module names; fix process memory cache in edge cases 2024-03-12 14:56:02 -07:00
Ryan Fleury d1e88f781e tweak ctrl entity building to be bucketed per 'entity store' - we can now have multiple 'entity stores', one on the frontend thread, one on the ctrl thread, and keep them in sync at specific points via event lists 2024-03-12 14:20:24 -07:00
Ryan Fleury 4a3cc9bb39 get raddbg building on new demon layer 2024-03-12 13:55:13 -07:00
Ryan Fleury 2749301777 checkpoint - moving ctrl mostly over to demon2; sketching out a few missing cache pieces 2024-03-12 11:41:53 -07:00
Ryan Fleury 90d9f3b7c2 fix task entry points in breakpad converter 2024-03-12 09:05:00 -07:00
Ryan Fleury 49ccf50fd4 first pass at integrating new demon2 layer into debugger, need to change ctrl a bit to adopt some of the things that were previously being left up to demon layers 2024-03-08 12:49:06 -08:00
Ryan Fleury 0d0c599e00 begin process of moving pe unwinding info into pe layer; more demon2 work checkpoint 2024-03-05 16:54:57 -08:00
Ryan Fleury e25364a835 strip out some unnecessary apis from the demon layer, since we'll be doing per-entity caching in ctrl and keep demon as close to a thin abstraction as possible 2024-03-05 14:55:49 -08:00
Ryan Fleury f85718f1e2 fix eval header 2024-03-05 14:48:23 -08:00
Ryan Fleury 4074551a1a hook up demon2 initialization to base layer entry point 2024-03-05 14:27:40 -08:00
Ryan Fleury 0c436f0d5b first pass at demon replacement layer; just trimming out old code & cruft & reading & naming pass 2024-03-05 14:17:41 -08:00
Ryan Fleury 091269b1d8 eliminate synchronous per-thread string map building, just do it as-needed on each thread; 2024-03-04 11:53:12 -08:00
Ryan Fleury 4d6860b3a1 raddbgi_from_pdb/raddbgi_make: kill old synchronous string map code; naming pass 2024-03-04 11:14:54 -08:00
Ryan Fleury 778f4eb08d raddbgi_from_pdb: complete initial parallelization pass over string map building, joining, & sorting 2024-03-04 11:02:48 -08:00
Ryan Fleury 0ad795ba4c eliminate old udt string baking kickoff code 2024-03-01 11:36:03 -08:00
Ryan Fleury ac22e24841 raddbgi_from_pdb: switch string baking to using fixed per-thread maps, rather than per-task maps 2024-03-01 11:21:30 -08:00
Ryan Fleury 2fc0b4eac2 extend task system with thread count, so usage code can easily create per-thread state; pass thread idx into task entry points 2024-03-01 11:08:00 -08:00
Ryan Fleury 7eca2a35cd raddbgi_dump: dump string table 2024-02-29 11:04:53 -08:00
Ryan Fleury 1ea3a14a50 shift to slice-granularity of string map gathering, rather than chunk-granularity - gives a bit more flexibility. set up pdb converter type name gathering tasks for slice subdivision. before going forward with this plan it's imperative that we start sparsely allocating these name maps... 2024-02-28 16:48:25 -08:00
Ryan Fleury a38742d80b adjust string map sorting tasks to be wide, but less granular than per-slot; divide up table into chunks 2024-02-28 16:18:11 -08:00
Ryan Fleury e94b530758 new bake string map gathering/merging passes & async usage in converter 2024-02-28 15:51:17 -08:00
Ryan Fleury 0916c2a3c8 first pass at bake string chunk list, bake string chunk list map, and bake string chunk list sorting paths/datastructures - basic machinery for going wide on the string/name map builds 2024-02-28 13:27:48 -08:00
Ryan Fleury 56690a703f fix padding insertion pass over members gathering 2024-02-27 06:35:11 -08:00
Ryan Fleury bb0ebb5df2 raddbgi prefix on breakpad converter 2024-02-26 17:01:52 -08:00
Ryan Fleury 70d004e5d3 clean up command line arguments & help in converters 2024-02-26 16:49:57 -08:00
Ryan Fleury 3b7a4f3331 clean up pdb -> raddbgi converter parameters; extend conversion parameterization with optional type/udt disabling; use in breakpad converter 2024-02-26 14:11:26 -08:00
Ryan Fleury 1c2c82cc58 breakpad_from_pdb per-function line info writing 2024-02-26 13:34:33 -08:00
Ryan Fleury 03763e3444 raddbgi_from_pdb/raddbgi_make: split top-level units baking from per-unit baking; do per-unit baking wide 2024-02-26 12:15:18 -08:00
Ryan Fleury d9897161c2 first half of first pass at breakpad textual symbol info format exporter 2024-02-26 11:49:19 -08:00
Ryan Fleury 874f40244c eliminate per-executable initialization, just pull that down into the base layer entry point 2024-02-26 10:45:00 -08:00
Ryan Fleury 443c3fb74b get dwarf -> raddbgi converter on new entry point style 2024-02-25 15:03:27 -08:00
Ryan Fleury 8eb0f90f3e move to codebase-defined entry point style, with basic command line argument parsing, capture, thread-ctx, and other boilerplate deduplicated in the base layer's entry point definition 2024-02-25 15:02:05 -08:00
Ryan Fleury dd05eaa21e sketch out some codebase-wide standard thread entry point boilerplate 2024-02-25 14:13:27 -08:00
Ryan Fleury 93ab48ecdf organization/naming/dead-code-elimination pass over base 2024-02-25 14:00:35 -08:00
Ryan Fleury 3ec1edaff1 oops, fix clang 2024-02-25 13:33:27 -08:00
Ryan Fleury d8cf83b4d7 pull out & organize build configuration options, including entry point style, to context cracker 2024-02-25 13:30:15 -08:00
Ryan Fleury c4b8916bcf raddbgi dump - fix bad condition 2024-02-25 09:59:56 -08:00
Ryan Fleury 642acdf474 switch voff -> symbol name path to graceful failure RDI lookups 2024-02-25 09:57:51 -08:00
Ryan Fleury 7c9f127425 cleanup/naming pass over raddbgi_dump, do not require specific named params 2024-02-24 22:03:08 -08:00
Ryan Fleury 93c0e657fd eliminate old test files 2024-02-24 20:08:44 -08:00
Ryan Fleury 10ab27eb43 oops - actually respect operating system file system match flags in dbgi layer 2024-02-24 18:16:59 -08:00
Ryan Fleury 4c76eb73f1 respect operating system file system case sensitivity rules in dbgi layer 2024-02-24 14:04:41 -08:00
Ryan Fleury d9aa49e45c respect wait timeouts in task system join 2024-02-23 12:17:57 -08:00
Ryan Fleury 4da33c0d2c eliminate noop in ui layout pass 2024-02-23 11:21:47 -08:00
Ryan Fleury dd0416f9f9 fix nil expressions mapping to valid expression kinds, thus implying children nodes 2024-02-23 11:18:53 -08:00
Ryan Fleury c1984edadf dont over-eagerly join udt building tassk 2024-02-23 11:13:12 -08:00
Ryan Fleury ac8a7ba988 fix enumerate gathering in new udt building pass 2024-02-23 11:07:09 -08:00
Ryan Fleury 6beb9951e6 adjust default task sizes in raddbgi_from_pdb 2024-02-22 16:54:39 -08:00
Ryan Fleury 5813cb2af8 proper thread names 2024-02-22 16:20:27 -08:00
Ryan Fleury 74d051f383 walk args as dependent types for member function types 2024-02-22 15:51:18 -08:00
Ryan Fleury 7facfb7d08 kill single threaded udt conversion code 2024-02-22 15:50:07 -08:00
Ryan Fleury fe1e0cc2fd move udt info conversion to task threads, divide up itype stream and do it wide 2024-02-22 15:49:46 -08:00
Ryan Fleury bcbd01bf2c eliminate type revisiting task list, just iterate itypes again - in preparation for dividing up the itype stream and doing udt building in parallel 2024-02-22 15:37:50 -08:00
Ryan Fleury 34f500ce27 push unit conversion & src file gathering to background task threads; dont preemptively join initial independent parses until they are necessary 2024-02-22 15:11:13 -08:00
Ryan Fleury 0e352f92df separate per-name-map baking stages from each other, and from top-level name map section build; do them all independently 2024-02-22 14:45:09 -08:00
Ryan Fleury 50f7d53db2 eliminate unnecessary copy in raddbgi string map interner 2024-02-22 14:15:23 -08:00
Ryan Fleury b508489416 clean up old transitionary code 2024-02-22 10:03:26 -08:00
Ryan Fleury d2adf3e067 extend task system with ability to specify per-task arenas, if needed - not necessary in the converter, since it is fire-and-forget, but this will make it more useful for the debugger later 2024-02-22 09:48:19 -08:00
Ryan Fleury a5493d5edb appease the clang gods 2024-02-21 16:48:22 -08:00
Ryan Fleury c7e80ee135 raddbgi_from_pdb: move all top-level baking phases to task system threads. still a lot of improvement to do, these are top-level tasks and there is a lot of work *within* these tasks that is happening serially unnecessarily, but this is a good first step to parallelizing the bake. 2024-02-21 16:27:29 -08:00
Ryan Fleury 6a49672904 raddbgi_from_pdb: idx run baking; raddbg: catch up to new converter interface 2024-02-21 15:23:35 -08:00
Ryan Fleury 2dd4526dd9 raddbgi_from_pdb: path tree & string baking 2024-02-21 15:12:08 -08:00
Ryan Fleury f2cf518231 raddbgi_from_pdb: name map baking, small fixes with new baking strategy 2024-02-21 14:55:50 -08:00
Ryan Fleury 41b1f1c7e3 raddbgi_from_pdb: organize new baking path, which does all independent section list builds separately; do first pass of baked string map building 2024-02-21 14:36:15 -08:00
Ryan Fleury f93b71d8c3 raddbgi_from_pdb: untangle all baking stages - move almost all baking stages to a strictly read-only path of strings, idx runs, and so on. make section layout, given some loose input baking params, completely deterministic & well-defined, such that section list building for each stage of baking can be completely independent 2024-02-21 13:43:56 -08:00
Ryan Fleury 25ef98a98c raddbgi_make: eliminate old bake src files, switch over completely to user-specified src files; enforce nil entries in all tables for all cases 2024-02-21 10:36:22 -08:00
Ryan Fleury 529262d471 begin untangling source file & path tree building in converter/maker/baker; this cannot happen as another implicitly-mutated-context thing that magically happens behing a top-level 'baking' function. instead, this needs to be constructed according to the rules of the user, and passed to baking stages as a batch 2024-02-20 16:32:09 -08:00
Ryan Fleury 7581a6866d raddbgi_from_pdb: overlap link name map building with type info building, since they are independent streams of work 2024-02-20 15:13:22 -08:00
Ryan Fleury 923714c3c9 raddbgi_make: split final blob flattening & encoding from 'baking' phase 2024-02-20 14:07:58 -08:00
Ryan Fleury b8a4aeac39 raddbgi_from_pdb: offload c13 line info parsing to task threads 2024-02-20 13:16:52 -08:00
Ryan Fleury e7ab92e07c raddbgi_from_pdb: move comp unit contributions parsing out to task threads; move per-comp-unit top-level symbol parsing to task threads 2024-02-20 13:09:23 -08:00
Ryan Fleury 53bc258c4a raddbgi_from_pdb: move itype dependency chain building to task threads 2024-02-20 12:58:04 -08:00
Ryan Fleury 7e36c25a31 fix more async fwd map building bugs; move symbol stream conversion to task system 2024-02-20 12:04:57 -08:00
Ryan Fleury 66ef1b3eeb raddbgi_from_pdb: move top-level compilation unit parsing to asynchronous tasks 2024-02-20 11:30:01 -08:00
Ryan Fleury 6b2e4abe81 unify async task kickoff/await mechanism in first pass of 'task system' layer; use in organizing various independent parsing passes of a pdb; also fix busted multithreaded fwd resolution pass 2024-02-20 11:16:54 -08:00
Ryan Fleury 10a0420264 raddbgi_from_pdb: parameterize symbol stream conversion pass with sub-range of symbols; this cannot be applied to unit conversion, since they have cross-sym-record concepts, but it *can* be used for global symbol streams, which are also the most expensive to convert. this majorly speeds up global symbol stream conversion 2024-02-19 16:41:22 -08:00
Ryan Fleury 0b73582b87 raddbgi_from_pdb: multithread initial independent parsing/preparation phases of converter 2024-02-19 15:52:26 -08:00
Ryan Fleury 8369637026 raddbgi_from_pdb: multithread itype forward resolution map building 2024-02-19 15:07:25 -08:00
Ryan Fleury 86ee3cb4b6 raddbgi_from_pdb: multithread per-unit symbol conversion 2024-02-19 14:42:13 -08:00
Ryan Fleury 5cd5503db1 raddbgi_make: adjust baking-phase bucket counts based on estimates from parameters 2024-02-19 12:13:42 -08:00
Ryan Fleury 29c21b43af fix busted vmap section size 2024-02-19 11:52:28 -08:00
Ryan Fleury f7f57a2c7a fix enumerate parsing 2024-02-19 11:18:34 -08:00
Ryan Fleury 694e9d27d6 raddbgi_from_pdb: adjust itype -> type node building strategy; do initial pass of finding dependent itypes from a given itype, since those *must* be built first in order to comply with raddbgi's rule of type nodes only ever referencing earlier type nodes; then do a single itype build pass where you build all itypes by iterating their dependency chains 2024-02-19 11:13:29 -08:00
Ryan Fleury e44128de96 bugfix udt member parsing 2024-02-17 21:26:23 -08:00
Ryan Fleury b93bb5904a more itype generation fixes 2024-02-17 17:14:11 -08:00
Ryan Fleury cfe089de8c eliminate forward reference parsing work in non-forward-reference cases 2024-02-17 12:31:15 -08:00
Ryan Fleury e752eebfc9 fix itype conversion 2024-02-17 10:50:56 -08:00
Ryan Fleury d0fe5b9e04 raddbgi make: export scope voffs section 2024-02-17 10:36:07 -08:00
Ryan Fleury c790ee3de0 fix reversed-order path building 2024-02-17 08:44:55 -08:00
Ryan Fleury 4f9e3bb4f5 clean up / debugging / bugfixes in new converter 2024-02-17 08:41:27 -08:00
Ryan Fleury e9d2cb82b2 eliminate all old raddbgi_make and raddbgi_from_pdb code 2024-02-16 13:46:55 -08:00
Ryan Fleury 5190530417 oops, remember units... 2024-02-16 13:44:42 -08:00
Ryan Fleury 626ad29b91 converge raddbg to new conversion/raddbgi-make layers 2024-02-16 13:39:52 -08:00
Ryan Fleury 178719c479 transfer over idx run baking 2024-02-16 13:35:00 -08:00
Ryan Fleury 9cccabfa21 transfer over string baking 2024-02-16 13:33:45 -08:00
Ryan Fleury 3735e82579 source file baking 2024-02-16 13:31:58 -08:00
Ryan Fleury 75263c5833 path node tree baking 2024-02-16 13:29:26 -08:00
Ryan Fleury c64fba90a1 transfer over name map baking 2024-02-16 13:26:43 -08:00
Ryan Fleury 3fb632c23d raddbgi_make: name maps 2024-02-16 13:11:57 -08:00
Ryan Fleury 7597bccd46 raddbgi from pdb: fix chunk list concats 2024-02-16 12:51:17 -08:00
Ryan Fleury 335f22e00b raddbgi_make & raddbgi_from_pdb: solve multithreaded 'indexing' problem - how do we correllate loose pointer relationships, constructed by various threads, with final indices in the baked file 2024-02-16 11:53:03 -08:00
Ryan Fleury a38241ebe0 raddbgi_make: overrideable profile macros; raddbgi_from_pdb: itype name resolution, link anme resolution 2024-02-16 11:18:48 -08:00
Ryan Fleury 5ae9259253 raddbgi_from_pdb: global variable, thread variable, procedure, scope, local, location info baking 2024-02-16 09:04:15 -08:00
Ryan Fleury 7646487a90 raddbgi_from_pdb: type info baking 2024-02-16 07:28:55 -08:00
Ryan Fleury e8ca548360 transfer over unit vmap baking 2024-02-15 16:11:24 -08:00
Ryan Fleury 5f1ab8fdb4 move over per-source-file line info baking 2024-02-15 15:56:20 -08:00
Ryan Fleury c3c1906d43 first pass over raddbgi make baking phase rewrite/cleanup pass, getting off of old cons API 2024-02-15 15:44:24 -08:00
Ryan Fleury a9c5ec8878 symbol conversion passes in new converter 2024-02-15 12:00:02 -08:00
Ryan Fleury a118ff79cd partial first pass over converter & raddbgi make layer rewrites/optimizations 2024-02-14 13:34:39 -08:00
Ryan Fleury f18e236431 a few more raddbgi, raddbgic -> rdi, rdim notes 2024-02-13 16:06:56 -08:00
Ryan Fleury 816f94ef71 further raddbgi -> rdi naming pass 2024-02-13 15:56:30 -08:00
Ryan Fleury b9f010dff6 raddbgi_ -> rdi_ 2024-02-13 15:52:53 -08:00
Ryan Fleury 30d2dea951 complete raddbgi_cons -> raddbgi_make 2024-02-13 15:38:38 -08:00
Ryan Fleury 87d9d0be05 readme 2024-02-13 15:37:27 -08:00
Ryan Fleury db35e09629 raddbgic -> rdim (rad debug info make) 2024-02-13 15:36:06 -08:00
Ryan Fleury 90dce510cc raddbgi_from_pdb: eliminate unnecessary files 2024-02-13 15:16:42 -08:00
Ryan Fleury fb56951264 collapse raddbgi_convert folder into just being separate from_pdb and from_dwarf layers 2024-02-13 15:12:40 -08:00
Ryan Fleury ecd21d0c1b pdbconv -> p2r 2024-02-13 15:05:46 -08:00
Ryan Fleury 67859f228b fix parse error checks in raddbgi_from_pdb 2024-02-13 14:37:59 -08:00
Ryan Fleury 348034a490 reading/cleanup/organization pass over main symbol conversion pass in raddbgi_from_pdb; automate & table-drive a few pieces via metacode tables 2024-02-13 14:26:01 -08:00
Ryan Fleury 725481fcc7 fix codeview struct 2024-02-13 13:36:15 -08:00
Ryan Fleury 608055e447 metagen: simplify catchall generations; move some codeview enums into metacode; generate enum->string code 2024-02-13 13:27:02 -08:00
Ryan Fleury 66a24a226a adjust contain -> center cursor threshold 2024-02-13 11:42:20 -08:00
Ryan Fleury 9c7fd0a411 metagen: simplify & straighten out table generation further; raddbgi_cons: fix incorrect str8_list_join 2024-02-13 11:38:43 -08:00
Ryan Fleury 348e93162a metagen: simplify & unify error gathering & printing path 2024-02-13 11:26:31 -08:00
Ryan Fleury 1d9dc2b9a9 metagen: simplify data tables 2024-02-13 11:16:45 -08:00
Ryan Fleury 742d2387e2 metagen: simplify metacode structs 2024-02-13 11:00:58 -08:00
Ryan Fleury ea840a71e8 metagen: simplify enum generation; reading/organization pass over raddbgi_from_pdb 2024-02-13 10:55:06 -08:00
Ryan Fleury 4a9e5512f6 fix this_function_name macro 2024-02-13 09:56:46 -08:00
Ryan Fleury ac30c8a84b add codeview/msf/pdb notes to readme 2024-02-13 09:53:52 -08:00
Ryan Fleury 7defce94c7 float codeview, msf, pdb layers up as regular codebase layers, and out of converter-specific code; clangify some builds 2024-02-13 09:51:50 -08:00
Ryan Fleury 017116aee9 formalize codebase's library exports; document in README 2024-02-13 09:27:52 -08:00
Ryan Fleury 8c70b5efc9 raddbgi_cons: get building standalone, without base layer; complete first pass of librarification 2024-02-13 08:58:10 -08:00
Ryan Fleury 4aa2cb655b further progress on raddbgi cons librarification 2024-02-12 21:05:05 -08:00
Ryan Fleury 440dcf21a2 further raddbg_cons librarification 2024-02-12 20:32:20 -08:00
Ryan Fleury 2a85e1d37d raddbgi cons: more overrides work 2024-02-12 19:10:31 -08:00
Ryan Fleury 7022c58018 begin libraryifying raddbgi_cons; switch to raddbgi_format types, or overrideable base-layer-style types; just override & include in codebase-local inclusion sites. next step is to break out this stuff, along with stringization, into a raddbgi helper layer 2024-02-12 16:17:54 -08:00
Ryan Fleury 840e1da5f3 update github workflows to new debug info naming 2024-02-12 15:26:06 -08:00
Ryan Fleury 02825f3b3e move raddbgi stringize into standalone layer 2024-02-12 15:22:41 -08:00
Ryan Fleury cf19b13b78 dump -> raddbgidump 2024-02-12 15:19:20 -08:00
Ryan Fleury ad4003e70d cons -> raddbgic 2024-02-12 15:17:23 -08:00
Ryan Fleury 5c33c410d3 flatten cons api; eliminate private/public distinction 2024-02-12 15:11:20 -08:00
Ryan Fleury d35bdf2128 adjust readme for new debug info naming convention 2024-02-12 15:08:40 -08:00
Ryan Fleury aa2a0948ba raddbg -> raddbgi 2024-02-12 15:03:13 -08:00
Ryan Fleury 4b68967fbe raddbg format stuff -> raddbgi; partial naming/organization over raddbgi_cons 2024-02-12 14:29:24 -08:00
Ryan Fleury cc26a22e40 apply cancel/ok ordering note from jeff 2024-02-12 10:33:04 -08:00
Ryan Fleury 4fde6addc4 raddbg_cons: parameterize bake ctx with bucket sizes; make initial prediction based on symbol count 2024-02-11 13:29:06 -08:00
Ryan Fleury 60b6e2d597 Merge branch 'dev' of https://github.com/EpicGames/raddebugger into dev 2024-02-11 09:23:37 -08:00
Ryan Fleury e5c35a4035 oops! fix wrong type fwd reference condition 2024-02-11 09:23:16 -08:00
Ryan Fleury 47bb3464e1 oops! 2024-02-11 09:23:06 -08:00
Ryan Fleury 2e8afad5f0 adjust conversion visualization; strip out old profiling markup 2024-02-10 19:40:19 -08:00
Ryan Fleury e7897f302f do some more fine tuning of symbol id hash functions used in pdb -> raddbg path; also eliminate unnecessary per-type work 2024-02-10 18:25:47 -08:00
Ryan Fleury c81ee6d9bc extend id -> handle cons APIs with separate hash channel, so usage code completely controls both unique IDs and how they're hashed; second pass at designing better local variable hashing function 2024-02-10 16:21:55 -08:00
Ryan Fleury 801518ea75 improve local map hash 2024-02-09 18:02:44 -08:00
Ryan Fleury ebfddabd0b raddbg cons: extend u64 -> ptr map api with separate channel for hash, which reduces scan space, independently from unique keys which were previously assumed to be a reasonable hash (which they weren't) 2024-02-09 16:59:42 -08:00
Ryan Fleury 6c872566af raddbg_from_pdb: greatly improve speed of line info combining pass; do not linearly scan for line numbers, use line as hash -> slot key and search only slots 2024-02-09 15:31:24 -08:00
Ryan Fleury 44d9b57eb5 track bucket collision counts, include in table diagnostics dump; finish moving pdb->raddbg conversion tables over to dynamic & heuristically chosen table sizes 2024-02-09 14:55:07 -08:00
Ryan Fleury cdb53ebed0 pdb -> raddbg table diagnostic dumping 2024-02-09 12:59:06 -08:00
Ryan Fleury 2d63234c92 eliminate static, absurdly large table sizes in all cases in pdb->raddbg path; markup & diagnostics of table sizes vs. counts, to begin gathering data for table size prediction path 2024-02-09 11:50:04 -08:00
Ryan Fleury 7f357b264c os_gfx_win32: fix preservation of sign info in x/y lparams for mouse events 2024-02-08 17:05:24 -08:00
Ryan Fleury 11dd5fd21a fix dragging interpretation in ui box -> signal path 2024-02-08 15:10:53 -08:00
Ryan Fleury 77337f9e86 use globals, thread-locals, types, procedures in default panel layout 2024-02-08 10:37:08 -08:00
Ryan Fleury 95a6579f89 expand eval machine interpretation error codes; visualize 2024-02-08 10:28:41 -08:00
Ryan Fleury fed0a13aca eliminate leftover events system, since ui codepaths should now consume as many events as possible within a single frame 2024-02-08 10:09:51 -08:00
Ryan Fleury 6e3242848f wm_mousewheel and wm_mousehwheel report mouse coordinates in screen space, not client space; fix to account fo rthat 2024-02-08 10:05:29 -08:00
Ryan Fleury 2967d8be2a fix double assignment to strtable buckets_min in raddbg_pdb 2024-02-08 04:12:29 -08:00
Ryan Fleury 3a811e5e16 middle click -> close tabs 2024-02-07 16:49:05 -08:00
Ryan Fleury 0bced47404 eliminate old ui box -> signal path 2024-02-07 16:47:21 -08:00
Ryan Fleury c637ad6ede rewrite ui box -> signal path for less lossy event processing & correctness; also extend to use all 3 mouse buttons. eliminate ui signal bitfields, just use flags & helper macros everywhere. 2024-02-07 16:46:57 -08:00
Ryan Fleury b9cec99cd4 ui code -> extend 'active' system to all left/middle/right mouse buttons, rather than just min/max (left/right) 2024-02-07 14:20:21 -08:00
axeldaguerreandRyan Fleury fb9e890653 fix utf8 encoding missing one bit shift
For Unicode code point in the highest range, 1 bit shift operation on the 4th byte is missing, giving a wrong encoding
2024-02-07 13:54:58 -08:00
Ryan Fleury 2c73c65878 remove debug 2024-02-07 13:35:34 -08:00
Ryan Fleury 390aab2699 raddbg from pdb: correctly parse several c13 files in single c13 subsection, rather than just assuming a single one 2024-02-07 13:35:14 -08:00
Ryan Fleury ccec64750d fix raddbg_dump build 2024-02-07 12:59:56 -08:00
Ryan Fleury e637f7237c straighten out a few key stability issues in eval watch views; editing expressions will no longer eliminate view rules; stale view rules will no longer find their way into inserted expressions 2024-02-07 10:32:24 -08:00
257 changed files with 66339 additions and 44221 deletions
+6 -4
View File
@@ -21,8 +21,10 @@ jobs:
run: |
call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
call build raddbg msvc debug || exit /b 1
call build raddbg_from_pdb msvc debug || exit /b 1
call build raddbg_from_dwarf msvc debug || exit /b 1
call build rdi_from_pdb msvc debug || exit /b 1
call build rdi_from_dwarf msvc debug || exit /b 1
call build rdi_dump msvc debug || exit /b 1
call build raddbg clang debug || exit /b 1
call build raddbg_from_pdb clang debug || exit /b 1
call build raddbg_from_dwarf clang debug || exit /b 1
call build rdi_from_pdb clang debug || exit /b 1
call build rdi_from_dwarf clang debug || exit /b 1
call build rdi_dump clang debug || exit /b 1
+50 -48
View File
@@ -1,5 +1,11 @@
# The RAD Debugger Project
_**Note:** This README does not document usage instructions and tips for the
debugger itself, and is intended as a technical overview of the project. The
debugger's README, which includes usage instructions and tips, can be found
packaged along with debugger releases, or within the `build` folder after a
local copy has been built._
The RAD Debugger is a native, user-mode, multi-process, graphical debugger. It
currently only supports local-machine Windows x64 debugging with PDBs, with
plans to expand and port in the future. In the future we'll expand to also
@@ -14,23 +20,20 @@ You can download pre-built binaries for the debugger
[here](https://github.com/EpicGames/raddebugger/releases).
The RAD Debugger project aims to simplify the debugger by simplifying and
unifying the underlying debug info format. In that pursuit we've built
the RADDBG debug info format, which is what the debugger parses and uses. To
work with existing toolchains, we convert PDB (and eventually PE/ELF files
with embedded DWARF) into the RADDBG format on-demand. This conversion process
is currently an unoptimized reference version. Nevertheless it's still quite
fast for smaller PDB files (in many cases faster than many other programs
simply deserialize the PDBs). It is much slower for much larger projects at the
moment, but we expect this will vastly improve overtime.
unifying the underlying debug info format. In that pursuit we've built the RAD
Debug Info (RDI) format, which is what the debugger parses and uses. To work
with existing toolchains, we convert PDB (and eventually PE/ELF files with
embedded DWARF) into the RDI format on-demand.
The RADDBG format is currently specified in code, in the files within the
`src/raddbg_format` folder. The other relevant folders for working with the
The RDI format is currently specified in code, in the files within the
`src/lib_rdi_format` folder. The other relevant folders for working with the
format are:
- `raddbg_cons`: The RADDBG construction layer, for constructing RADDBG files.
- `raddbg_convert`: Our implementation of PDB-to-RADDBG (and an in-progress
implementation of a DWARF-to-RADDBG) conversion.
- `raddbg_dump`: Code for textually dumping information from RADDBG files.
- `lib_rdi_make`: The "RAD Debug Info Make" library, for making RDI debug info.
- `rdi_from_pdb`: Our PDB-to-RDI converter. Can be used as a helper codebase
layer, or built as an executable with a command line interface frontend.
- `rdi_from_dwarf`: Our in-progress DWARF-to-RDI converter.
- `rdi_dump`: Our RDI textual dumping utility.
## Development Setup Instructions
@@ -117,18 +120,6 @@ there are still cases where the debugger has not been tested, and so there are
still issues. So, we feel that the top priority is eliminating these issues,
such that the debugging experience is rock solid.
Additionally, the debug info conversion process is not fast (nor wide) enough
to support extremely large projects. This is for two reasons: (a) the
PDB-to-RADDBG converter is an unoptimized reference implementation, and (b) the
debugger learns of new modules (and thus which PDBs to load) in a
serially-dependent way (this is necessarily the case for correct debugging
results). We expect that the conversion process' performance can be massively
improved, and also that some heuristics can be used to begin converting PDBs
to RADDBGs before the debugger knows those PDBs are needed, thus ensuring the
associated RADDBG files are ready instantaneously when the associated modules
are finally loaded by the debugger. Improving this situation is a major part of
this phase, as it will make the debugger much more usable for large projects.
### Local x64 Linux Debugging Phase
The next priority for the project is to take the rock solid x64 Windows
@@ -143,11 +134,10 @@ The major parts of this phase are:
- Porting the `src/demon` layer to implement the Demon local process control
abstraction API.
- Porting the `src/unwind` layer to support x64 ELF unwinding (currently, there
is only an x64 PE unwinding implementation).
- Creating a DWARF-to-RADDBG converter (in the same way that we've built a PDB-
to-RADDBG converter). A partial implementation of this is in
`src/raddbg_convert/dwarf`.
- Implementing an x64 ELF Linux unwinder in the `src/ctrl` layer.
- Creating a DWARF-to-RDI converter (in the same way that we've built a
PDB-to-RDI converter). A partial implementation of this is in
`src/rdi_from_dwarf`.
- Porting the `src/render` layer to implement all of the rendering features the
frontend needs on a Linux-compatible API (the backend used on Windows is D3D11).
- Porting the `src/font_provider` layer to a Linux-compatible font
@@ -206,10 +196,16 @@ Layers depend on other layers, but circular dependencies would break the
separability and isolation utility of layers (in effect, forming one big layer),
so in other words, layers are arranged into a directed acyclic graph.
A few layers are built to be used completely independently from the rest of the
codebase, as libraries in other codebases and projects. As such, these layers do
not depend on any other layers in the codebase. The folders which contain these
layers are prefixed with `lib_`, like `lib_rdi_format`.
A list of the layers in the codebase and their associated namespaces is below:
- `base` (no namespace): Universal, codebase-wide constructs. Strings, math,
memory allocators, helper macros, command-line parsing, and so on. Depends
on no other codebase layers.
- `codeview` (`CV_`): Code for parsing and/or writing the CodeView format.
- `coff` (`COFF_`): Code for parsing and/or writing the COFF (Common Object File
Format) file format.
- `ctrl` (`CTRL_`): The debugger's "control system" layer. Implements
@@ -220,11 +216,11 @@ A list of the layers in the codebase and their associated namespaces is below:
- `dasm` (`DASM_`): An asynchronous disassembly decoder and cache. Users ask for
disassembly for a particular virtual address range in a process, and threads
implemented in this layer decode and cache the disassembly for that range.
- `dbgi` (`DBGI_`): An asynchronous debug info loader and cache. Loads debug
info stored in the RADDBG format. Users ask for debug info for a particular
executable, and on separate threads, this layer loads the associated debug
info file. If necessary, it will launch a separate conversion process to
convert original debug info into the RADDBG format.
- `dbgi` (`DI_`): An asynchronous debug info loader and cache. Loads debug info
stored in the RDI format. Users ask for debug info for a particular path, and
on separate threads, this layer loads the associated debug info file. If
necessary, it will launch a separate conversion process to convert original
debug info into the RDI format.
- `demon` (`DEMON_`): An abstraction layer for local-machine, low-level process
control. The abstraction is used to provide a common interface for process
control on target platforms. Used to implement part of `ctrl`.
@@ -256,6 +252,16 @@ A list of the layers in the codebase and their associated namespaces is below:
for asynchronously preparing data for memory visualization in the debugger.
- `hash_store` (`HS_`): Implements a cache for general data blobs, keyed by a
128-bit hash of the data. Used as a general data store by other layers.
- `lib_raddbg_markup` (`RADDBG_`): Standalone library for marking up user
programs to work with various features in the `raddbg` debugger. Does not
depend on `base`, and can be independently relocated to other codebases.
- `lib_rdi_make` (`RDIM_`): Standalone library for constructing RDI debug info
data. Does not depend on `base`, and can be independently relocated
to other codebases.
- `lib_rdi_format` (`RDI_`): Standalone library which defines the core RDI types
and helper functions for reading and writing the RDI debug info file format.
Does not depend on `base`, and can be independently relocated to other
codebases.
- `metagen` (`MG_`): A metaprogram which is used to generate primarily code and
data tables. Consumes Metadesk files, stored with the extension `.mdesk`, and
generates C code which is then included by hand-written C code. Currently, it
@@ -270,6 +276,7 @@ A list of the layers in the codebase and their associated namespaces is below:
duplicate version of `base` and `os` are included in this layer. They are
updated manually, as needed. This is to ensure the stability of the
metaprogram.
- `msf` (`MSF_`): Code for parsing and/or writing the MSF file format.
- `mule` (no namespace): Test executables for battle testing debugger
functionality.
- `natvis` (no namespace): NatVis files for type visualization of the codebase's
@@ -283,20 +290,17 @@ A list of the layers in the codebase and their associated namespaces is below:
- `os/socket` (`OS_`): An abstraction layer, building on `os/core`, providing
networking operating system features under an abstract API, which is
implemented per-target-operating-system.
- `pdb` (`PDB_`): Code for parsing and/or writing the PDB file format.
- `pe` (`PE_`): Code for parsing and/or writing the PE (Portable Executable)
file format.
- `raddbg` (no namespace): The layer which ties everything together for the main
graphical debugger. Not much "meat", just drives `df`, implements command line
options, and so on.
- `raddbg_cons` (`CONS_`): Implements an API for constructing files of the
RADDBG debug info file format.
- `raddbg_dump` (`DUMP_`): A dumper utility program for dumping textualizations
of RADDBG debug info files.
- `raddbg_format` (`RADDBG_`): Standalone types and helper functions for the
RADDBG debug info file format. Does not depend on `base`.
- `raddbg_markup` (`RADDBG_`): Standalone header file for marking up user
programs to work with various features in the `raddbg` debugger. Does not
depend on `base`.
- `rdi_from_pdb` (`P2R_`): Our implementation of PDB-to-RDI conversion.
- `rdi_from_dwarf` (`D2R_`): Our in-progress implementation of DWARF-to-RDI
conversion.
- `rdi_dump` (no namespace): A dumper utility program for dumping
textualizations of RDI debug info files.
- `regs` (`REGS_`): Types, helper functions, and metadata for registers on
supported architectures. Used in reading/writing registers in `demon`, or in
looking up register metadata.
@@ -315,11 +319,9 @@ A list of the layers in the codebase and their associated namespaces is below:
Used by the debugger to visualize source code files. Users ask for text lines,
tokens, and metadata, and it is prepared on background threads.
- `type_graph` (`TG_`): Code for analyzing and navigating type structures from
RADDBG debug info files, with the additional capability of constructing
RDI debug info files, with the additional capability of constructing
synthetic types *not* found in debug info. Used in `eval` and for various
visualization features.
- `ui` (`UI_`): Machinery for building graphical user interfaces. Provides a
core immediate mode hierarchical user interface data structure building
API, and has helper layers for building some higher-level widgets.
- `unwind` (`UNW_`): Code for generating unwind information from threads, for
supported operating systems and architectures.
+38 -21
View File
@@ -15,7 +15,7 @@ cd /D "%~dp0"
:: `build raddbg clang`
:: `build raddbg release`
:: `build raddbg asan telemetry`
:: `build raddbg_from_pdb`
:: `build rdi_from_pdb`
::
:: For a full list of possible build targets and their build command lines,
:: search for @build_targets in this file.
@@ -34,6 +34,7 @@ if "%release%"=="1" set debug=0 && echo [release mode]
if "%msvc%"=="1" set clang=0 && echo [msvc compile]
if "%clang%"=="1" set msvc=0 && echo [clang compile]
if "%~1"=="" echo [default mode, assuming `raddbg` build] && set raddbg=1
if "%~1"=="release" if "%~2"=="" echo [default mode, assuming `raddbg` build] && set raddbg=1
:: --- Unpack Command Line Build Arguments ------------------------------------
set auto_compile_flags=
@@ -42,26 +43,26 @@ if "%asan%"=="1" set auto_compile_flags=%auto_compile_flags% -fsanitize=add
:: --- Compile/Link Line Definitions ------------------------------------------
set cl_common= /I..\src\ /I..\local\ /nologo /FC /Z7
set clang_common= -I..\src\ -I..\local\ -gcodeview -fdiagnostics-absolute-paths -Wall -Wno-unknown-warning-option -Wno-missing-braces -Wno-unused-function -Wno-writable-strings -Wno-unused-value -Wno-unused-variable -Wno-unused-local-typedef -Wno-deprecated-register -Wno-deprecated-declarations -Wno-unused-but-set-variable -Wno-single-bit-bitfield-constant-conversion -Xclang -flto-visibility-public-std -D_USE_MATH_DEFINES -Dstrdup=_strdup -Dgnu_printf=printf
set cl_debug= call cl /Od %cl_common% %auto_compile_flags%
set cl_release= call cl /O2 /DNDEBUG %cl_common% %auto_compile_flags%
set clang_debug= call clang -g -O0 %clang_common% %auto_compile_flags%
set clang_release= call clang -g -O2 -DNDEBUG %clang_common% %auto_compile_flags%
set clang_common= -I..\src\ -I..\local\ -gcodeview -fdiagnostics-absolute-paths -Wall -Wno-unknown-warning-option -Wno-missing-braces -Wno-unused-function -Wno-writable-strings -Wno-unused-value -Wno-unused-variable -Wno-unused-local-typedef -Wno-deprecated-register -Wno-deprecated-declarations -Wno-unused-but-set-variable -Wno-single-bit-bitfield-constant-conversion -Wno-compare-distinct-pointer-types -Wno-initializer-overrides -Wno-incompatible-pointer-types-discards-qualifiers -Xclang -flto-visibility-public-std -D_USE_MATH_DEFINES -Dstrdup=_strdup -Dgnu_printf=printf
set cl_debug= call cl /Od /Ob1 /DBUILD_DEBUG=1 %cl_common% %auto_compile_flags%
set cl_release= call cl /O2 /DBUILD_DEBUG=0 %cl_common% %auto_compile_flags%
set clang_debug= call clang -g -O0 -DBUILD_DEBUG=1 %clang_common% %auto_compile_flags%
set clang_release= call clang -g -O2 -DBUILD_DEBUG=0 %clang_common% %auto_compile_flags%
set cl_link= /link /MANIFEST:EMBED /INCREMENTAL:NO /natvis:"%~dp0\src\natvis\base.natvis" logo.res
set clang_link= -fuse-ld=lld -Xlinker /MANIFEST:EMBED -Xlinker /natvis:"%~dp0\src\natvis\base.natvis" logo.res
set cl_out= /out:
set clang_out= -o
:: --- Per-Build Settings -----------------------------------------------------
set gfx=-DOS_FEATURE_GRAPHICAL=1
set net=-DOS_FEATURE_SOCKET=1
set link_dll=-DLL
if "%msvc%"=="1" set only_compile=/c
if "%clang%"=="1" set only_compile=-c
if "%msvc%"=="1" set EHsc=/EHsc
if "%clang%"=="1" set EHsc=
if "%msvc%"=="1" set rc=rc.exe
if "%clang%"=="1" set rc=llvm-rc.exe
if "%msvc%"=="1" set no_aslr=/DYNAMICBASE:NO
if "%clang%"=="1" set no_aslr=-Wl,/DYNAMICBASE:NO
if "%msvc%"=="1" set rc=call rc
if "%clang%"=="1" set rc=call llvm-rc
:: --- Choose Compile/Link Lines ----------------------------------------------
if "%msvc%"=="1" set compile_debug=%cl_debug%
@@ -85,7 +86,7 @@ pushd build
popd
:: --- Get Current Git Commit Id ----------------------------------------------
for /f %%i in ('call git describe --always --dirty') do set compile=%compile% -DRADDBG_GIT=\"%%i\"
for /f %%i in ('call git describe --always --dirty') do set compile=%compile% -DBUILD_GIT_HASH=\"%%i\"
:: --- Build & Run Metaprogram ------------------------------------------------
if "%no_meta%"=="1" echo [skipping metagen]
@@ -98,16 +99,25 @@ if not "%no_meta%"=="1" (
:: --- Build Everything (@build_targets) --------------------------------------
pushd build
if "%raddbg%"=="1" %compile% %gfx% ..\src\raddbg\raddbg_main.cpp %compile_link% %out%raddbg.exe || exit /b 1
if "%raddbg_from_pdb%"=="1" %compile% ..\src\raddbg_convert\pdb\raddbg_from_pdb_main.c %compile_link% %out%raddbg_from_pdb.exe || exit /b 1
if "%raddbg_from_dwarf%"=="1" %compile% ..\src\raddbg_convert\dwarf\raddbg_from_dwarf.c %compile_link% %out%raddbg_from_dwarf.exe || exit /b 1
if "%raddbg_dump%"=="1" %compile% ..\src\raddbg_dump\raddbg_dump.c %compile_link% %out%raddbg_dump.exe || exit /b 1
if "%ryan_scratch%"=="1" %compile% ..\src\scratch\ryan_scratch.c %compile_link% %out%ryan_scratch.exe || exit /b 1
if "%cpp_tests%"=="1" %compile% ..\src\scratch\i_hate_c_plus_plus.cpp %compile_link% %out%cpp_tests.exe || exit /b 1
if "%look_at_raddbg%"=="1" %compile% ..\src\scratch\look_at_raddbg.c %compile_link% %out%look_at_raddbg.exe || exit /b 1
if "%mule_main%"=="1" del vc*.pdb mule*.pdb && %compile_release% %only_compile% ..\src\mule\mule_inline.cpp && %compile_release% %only_compile% ..\src\mule\mule_o2.cpp && %compile_debug% %EHsc% ..\src\mule\mule_main.cpp ..\src\mule\mule_c.c mule_inline.obj mule_o2.obj %compile_link% %out%mule_main.exe || exit /b 1
if "%mule_module%"=="1" %compile% ..\src\mule\mule_module.cpp %compile_link% %link_dll% %out%mule_module.dll || exit /b 1
if "%mule_hotload%"=="1" %compile% ..\src\mule\mule_hotload_main.c %compile_link% %out%mule_hotload.exe & %compile% ..\src\mule\mule_hotload_module_main.c %compile_link% %link_dll% %out%mule_hotload_module.dll || exit /b 1
if "%raddbg%"=="1" set didbuild=1 && %compile% ..\src\raddbg\raddbg_main.c %compile_link% %out%raddbg.exe || exit /b 1
if "%rdi_from_pdb%"=="1" set didbuild=1 && %compile% ..\src\rdi_from_pdb\rdi_from_pdb_main.c %compile_link% %out%rdi_from_pdb.exe || exit /b 1
if "%rdi_from_dwarf%"=="1" set didbuild=1 && %compile% ..\src\rdi_from_dwarf\rdi_from_dwarf.c %compile_link% %out%rdi_from_dwarf.exe || exit /b 1
if "%rdi_dump%"=="1" set didbuild=1 && %compile% ..\src\rdi_dump\rdi_dump_main.c %compile_link% %out%rdi_dump.exe || exit /b 1
if "%rdi_breakpad_from_pdb%"=="1" set didbuild=1 && %compile% ..\src\rdi_breakpad_from_pdb\rdi_breakpad_from_pdb_main.c %compile_link% %out%rdi_breakpad_from_pdb.exe || exit /b 1
if "%ryan_scratch%"=="1" set didbuild=1 && %compile% ..\src\scratch\ryan_scratch.c %compile_link% %out%ryan_scratch.exe || exit /b 1
if "%cpp_tests%"=="1" set didbuild=1 && %compile% ..\src\scratch\i_hate_c_plus_plus.cpp %compile_link% %out%cpp_tests.exe || exit /b 1
if "%look_at_raddbg%"=="1" set didbuild=1 && %compile% ..\src\scratch\look_at_raddbg.c %compile_link% %out%look_at_raddbg.exe || exit /b 1
if "%mule_main%"=="1" set didbuild=1 && del vc*.pdb mule*.pdb && %compile_release% %only_compile% ..\src\mule\mule_inline.cpp && %compile_release% %only_compile% ..\src\mule\mule_o2.cpp && %compile_debug% %EHsc% ..\src\mule\mule_main.cpp ..\src\mule\mule_c.c mule_inline.obj mule_o2.obj %compile_link% %no_aslr% %out%mule_main.exe || exit /b 1
if "%mule_module%"=="1" set didbuild=1 && %compile% ..\src\mule\mule_module.cpp %compile_link% %link_dll% %out%mule_module.dll || exit /b 1
if "%mule_hotload%"=="1" set didbuild=1 && %compile% ..\src\mule\mule_hotload_main.c %compile_link% %out%mule_hotload.exe & %compile% ..\src\mule\mule_hotload_module_main.c %compile_link% %link_dll% %out%mule_hotload_module.dll || exit /b 1
if "%mule_peb_trample%"=="1" (
set didbuild=1
if exist mule_peb_trample.exe move mule_peb_trample.exe mule_peb_trample_old_%random%.exe
if exist mule_peb_trample_new.pdb move mule_peb_trample_new.pdb mule_peb_trample_old_%random%.pdb
if exist mule_peb_trample_new.rdi move mule_peb_trample_new.rdi mule_peb_trample_old_%random%.rdi
%compile% ..\src\mule\mule_peb_trample.c %compile_link% %out%mule_peb_trample_new.exe || exit /b 1
move mule_peb_trample_new.exe mule_peb_trample.exe
)
popd
:: --- Unset ------------------------------------------------------------------
@@ -118,3 +128,10 @@ set compile_link=
set out=
set msvc=
set debug=
set release=
:: --- Warn On No Builds ------------------------------------------------------
if "%didbuild%"=="" (
echo [WARNING] no valid build target specified; must use build target names as arguments to this script, like `build raddbg` or `build rdi_from_pdb`.
exit /b 1
)
+36 -6
View File
@@ -47,6 +47,7 @@ commands =
{
.rjf_f1 =
{
//.win = "build rdi_from_pdb rdi_dump && pushd build && rdi_from_pdb --pdb:mule_main.pdb --out:mule_main.rdi && rdi_dump mule_main.rdi > mule_main.dump && popd",
.win = "build raddbg telemetry",
.linux = "",
.out = "*compilation*",
@@ -56,7 +57,7 @@ commands =
},
.rjf_f2 =
{
.win = "build raddbg_from_pdb",
.win = "build rdi_from_pdb rdi_dump && pushd build && rdi_from_pdb --pdb:mule_main.pdb --out:mule_main.rdi && rdi_dump mule_main.rdi > mule_main.dump && popd",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
@@ -65,7 +66,25 @@ commands =
},
.rjf_f3 =
{
.win = "pushd build && raddbg.exe --user:local_dev.raddbg_user --profile:local_dev.raddbg_profile && popd",
.win = "pushd build && raddbg.exe --user:local_dev.raddbg_user --project:local_dev.raddbg_project && popd",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
.save_dirty_files = true,
.cursor_at_end = false,
},
.rjf_f4 =
{
.win = "build rdi_from_pdb release telemetry && pushd build && rdi_from_pdb.exe --pdb:UnrealEditorFortnite.pdb --out:profile.rdi --capture && popd",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
.save_dirty_files = true,
.cursor_at_end = false,
},
.rjf_f5 =
{
.win = "pushd build && rdi_from_pdb.exe --exe:raddbg.exe --pdb:raddbg.pdb --out:raddbg.rdi --capture && popd",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
@@ -90,18 +109,18 @@ commands =
.save_dirty_files = true,
.cursor_at_end = false,
},
.build_raddbg_from_pdb =
.build_rdi_from_pdb =
{
.win = "build raddbg_from_pdb",
.win = "build rdi_from_pdb",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
.save_dirty_files = true,
.cursor_at_end = false,
},
.build_raddbg_dump =
.build_rdi_dump =
{
.win = "build raddbg_dump",
.win = "build rdi_dump",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
@@ -117,6 +136,15 @@ commands =
.save_dirty_files = true,
.cursor_at_end = false,
},
.build_ryan_scratch =
{
.win = "build ryan_scratch",
.linux = "",
.out = "*compilation*",
.footer_panel = true,
.save_dirty_files = true,
.cursor_at_end = false,
},
.run_raddbg =
{
.win = "pushd build && raddbg.exe && popd",
@@ -141,5 +169,7 @@ fkey_command_override =
.F1 = "rjf_f1",
.F2 = "rjf_f2",
.F3 = "rjf_f3",
.F4 = "rjf_f4",
.F5 = "rjf_f5",
},
};
-13
View File
@@ -55,9 +55,6 @@ arena_alloc__sized(U64 init_res, U64 init_cmt)
arena->cmt = cmt;
arena->res = res;
arena->align = 8;
#if ENABLE_DEV
arena->dev = 0;
#endif
arena->grow = 1;
arena->large_pages = large_pages;
}
@@ -209,10 +206,6 @@ arena_pop_to(Arena *arena, U64 big_pos_unclamped)
internal void
arena_absorb(Arena *arena, Arena *sub)
{
#if ENABLE_DEV
arena_annotate_absorb__dev(arena, sub);
#endif
// base adjustment
Arena *current = arena->current;
U64 base_adjust = current->base_pos + current->res;
@@ -233,9 +226,6 @@ internal void *
arena_push(Arena *arena, U64 size)
{
void *memory = arena_push__impl(arena, size);
#if ENABLE_DEV
arena_annotate_push__dev(arena, size, memory);
#endif
return memory;
}
@@ -246,9 +236,6 @@ arena_push_contiguous(Arena *arena, U64 size)
arena->grow = 0;
void *memory = arena_push(arena, size);
arena->grow = restore;
#if ENABLE_DEV
arena_annotate_push__dev(arena, size, memory);
#endif
return memory;
}
+1 -8
View File
@@ -36,7 +36,6 @@ struct Arena
U64 cmt;
U64 res;
U64 align;
struct ArenaDev *dev;
B8 grow;
B8 large_pages;
};
@@ -82,13 +81,7 @@ internal B32 ensure_commit(void **cmt, void *pos, U64 cmt_block_size);
////////////////////////////////
//~ NOTE(allen): Main API Macros
#if !ENABLE_DEV
# define push_array_no_zero(a,T,c) (T*)arena_push((a), sizeof(T)*(c))
#else
# define push_array_no_zero(a,T,c) (tctx_write_this_srcloc(), (T*)arena_push((a), sizeof(T)*(c)))
#endif
#define push_array_no_zero__no_annotation(a,T,c) (T*)arena_push__impl((a), sizeof(T)*(c))
#define push_array_no_zero(a,T,c) (T*)arena_push((a), sizeof(T)*(c))
#define push_array(a,T,c) (T*)MemoryZero(push_array_no_zero(a,T,c), sizeof(T)*(c))
#endif // BASE_ARENA_H
-197
View File
@@ -1,197 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
// NOTE(allen): Dev Arena
#if ENABLE_DEV
internal void
arena_annotate_push__dev(Arena *arena, U64 size, void *ptr){
ArenaDev *dev = arena->dev;
if (dev != 0 && ptr != 0){
//- read location
char *file_name = 0;
U64 line_number = 0;
tctx_read_srcloc(&file_name, &line_number);
tctx_write_srcloc(0, 0);
//- profile
ArenaProf *prof = dev->prof;
if (prof != 0){
// c string -> string
String8 file_name_str = str8_lit("(null)");
if (file_name != 0){
file_name_str = str8_cstring(file_name);
}
// record
arena_prof_inc_counters__dev(dev->arena, prof, file_name_str, line_number, size, 1);
}
}
}
internal void
arena_annotate_absorb__dev(Arena *arena, Arena *sub){
ArenaDev *dev = arena->dev;
ArenaDev *sub_dev = sub->dev;
if (dev != 0 && sub_dev != 0){
//- merge profiles
ArenaProf *prof = dev->prof;
ArenaProf *sub_prof = sub_dev->prof;
if (prof != 0 && sub_prof != 0){
for (ArenaProfNode *sub_node = sub_prof->first;
sub_node != 0;
sub_node = sub_node->next){
arena_prof_inc_counters__dev(dev->arena, prof, sub_node->file_name, sub_node->line,
sub_node->size, sub_node->count);
}
}
}
//- release the sub dev memory
if (sub_dev != 0){
arena_release(sub_dev->arena);
}
}
internal ArenaDev*
arena_equip__dev(Arena *arena){
ArenaDev *result = arena->dev;
if (result == 0){
Arena *dev_arena = arena_alloc();
ArenaDev *dev = (ArenaDev*)arena_push__impl(dev_arena, sizeof(ArenaDev));
MemoryZeroStruct(dev);
dev->arena = dev_arena;
arena->dev = dev;
result = dev;
}
return(result);
}
internal void
arena_equip_profile__dev(Arena *arena){
ArenaDev *dev = arena_equip__dev(arena);
if (dev->prof == 0){
dev->prof = (ArenaProf*)arena_push__impl(dev->arena, sizeof(ArenaProf));
MemoryZeroStruct(dev->prof);
}
}
internal void
arena_print_profile__dev(Arena *arena, Arena *out_arena, String8List *out){
Assert(arena != out_arena);
//- get dev & disable
ArenaDev *dev = arena->dev;
arena->dev = 0;
//- get prof
ArenaProf *prof = (dev != 0)?dev->prof:0;
//- not equipped with prof
if (prof == 0){
str8_list_push(out_arena, out, str8_lit("not equipped with a memory profile\n"));
}
//- print prof
if (prof != 0){
Temp scratch = temp_begin(dev->arena);
//- make flat array
U64 note_count = prof->count;
ArenaProfNode **notes = push_array_no_zero__no_annotation(scratch.arena, ArenaProfNode*, note_count);
{
ArenaProfNode **note_ptr = notes;
for (ArenaProfNode *node = prof->first;
node != 0;
node = node->next, note_ptr += 1){
*note_ptr = node;
}
}
//- file name size
U64 max_file_name_size = 0;
{
ArenaProfNode **note_ptr = notes;
for (U64 i = 0; i < note_count; i += 1, note_ptr += 1){
max_file_name_size = Max(max_file_name_size, (**note_ptr).file_name.size);
}
}
//- sort (> size, < [address])
for (U64 i = 0; i < note_count; i += 1){
ArenaProfNode **i_note = notes + i;
ArenaProfNode **min_note = i_note;
for (U64 j = i + 1; j < note_count; j += 1){
ArenaProfNode **j_note = notes + j;
if ((**j_note).size > (**min_note).size ||
((**j_note).size == (**min_note).size && *j_note < *min_note)){
min_note = j_note;
}
}
if (min_note != i_note){
ArenaProfNode *t = *i_note;
*i_note = *min_note;
*min_note = t;
}
}
//- total size
U64 total_size = 0;
{
ArenaProfNode **note_ptr = notes;
for (U64 i = 0; i < note_count; i += 1, note_ptr += 1){
ArenaProfNode *note = *note_ptr;
total_size += note->size;
}
}
//- print
{
str8_list_pushf(out_arena, out, "memory total: %llu\n", total_size);
ArenaProfNode **note_ptr = notes;
for (U64 i = 0; i < note_count; i += 1, note_ptr += 1){
ArenaProfNode *note = *note_ptr;
String8 location = push_str8f(scratch.arena, "%S:%5llu:",
note->file_name, note->line);
F32 percent = 100.f*((F32)note->size)/total_size;
str8_list_pushf(out_arena, out, "%*.*s %12llu %5.2f%% [%5llu]\n",
max_file_name_size + 7, str8_varg(location),
note->size, percent, note->count);
}
}
temp_end(scratch);
}
//- restore dev
arena->dev = dev;
}
internal void
arena_prof_inc_counters__dev(Arena *dev_arena, ArenaProf *prof, String8 file_name, U64 line,
U64 size, U64 count){
// find existing profile node
ArenaProfNode *prof_node = 0;
for (ArenaProfNode *node = prof->first;
node != 0;
node = node->next){
if (node->line == line && str8_match(file_name, node->file_name, 0)){
prof_node = node;
break;
}
}
// make new histogram node if necessary
if (prof_node == 0){
prof_node = (ArenaProfNode*)arena_push(dev_arena, sizeof(*prof_node));
SLLQueuePush(prof->first, prof->last, prof_node);
prof->count += 1;
prof_node->file_name = file_name;
prof_node->line = line;
}
// record this allocation
prof_node->size += size;
prof_node->count += count;
}
#endif
-47
View File
@@ -1,47 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_ARENA_DEV_H
#define BASE_ARENA_DEV_H
////////////////////////////////
//~ NOTE(allen): Dev Arena Types
typedef struct ArenaDev ArenaDev;
struct ArenaDev
{
Arena *arena;
struct ArenaProf *prof;
};
typedef struct ArenaProf ArenaProf;
struct ArenaProf
{
struct ArenaProfNode *first;
struct ArenaProfNode *last;
U64 count;
};
typedef struct ArenaProfNode ArenaProfNode;
struct ArenaProfNode
{
ArenaProfNode *next;
String8 file_name;
U64 line;
U64 size;
U64 count;
};
////////////////////////////////
//~ NOTE(allen): Dev Arena Functions
#if ENABLE_DEV
internal void arena_annotate_push__dev(Arena *arena, U64 size, void *ptr);
internal void arena_annotate_absorb__dev(Arena *arena, Arena *sub);
internal ArenaDev* arena_equip__dev(Arena *arena);
internal void arena_equip_profile__dev(Arena *arena);
internal void arena_print_profile__dev(Arena *arena, Arena *out_arena, String8List *out);
internal void arena_prof_inc_counters__dev(Arena *dev_arena, ArenaProf *prof, String8 file_name, U64 line, U64 size, U64 count);
#endif
#endif // BASE_ARENA_DEV_H
-103
View File
@@ -1,103 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#if COMPILER_CL || (COMPILER_CLANG && OS_WINDOWS)
internal U64
count_bits_set16(U16 val)
{
return __popcnt16(val);
}
internal U64
count_bits_set32(U32 val)
{
return __popcnt(val);
}
internal U64
count_bits_set64(U64 val)
{
return __popcnt64(val);
}
internal U64
ctz32(U32 mask)
{
unsigned long idx;
_BitScanForward(&idx, mask);
return idx;
}
internal U64
ctz64(U64 mask)
{
unsigned long idx;
_BitScanForward64(&idx, mask);
return idx;
}
internal U64
clz32(U32 mask)
{
unsigned long idx;
_BitScanReverse(&idx, mask);
return 31 - idx;
}
internal U64
clz64(U64 mask)
{
unsigned long idx;
_BitScanReverse64(&idx, mask);
return 63 - idx;
}
#elif COMPILER_CLANG || COMPILER_GCC
internal U64
count_bits_set16(U16 val)
{
NotImplemented;
return 0;
}
internal U64
count_bits_set32(U32 val)
{
NotImplemented;
return 0;
}
internal U64
count_bits_set64(U64 val)
{
NotImplemented;
return 0;
}
internal U64
ctz32(U32 val)
{
NotImplemented;
return 0;
}
internal U64
clz32(U32 val)
{
NotImplemented;
return 0;
}
internal U64
clz64(U64 val)
{
NotImplemented;
return 0;
}
#else
# error "bits not defined for this target"
#endif
-18
View File
@@ -1,18 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_BITS_H
#define BASE_BITS_H
#define ExtractBit(word, idx) (((word) >> (idx)) & 1)
internal U64 count_bits_set16(U16 val);
internal U64 count_bits_set32(U32 val);
internal U64 count_bits_set64(U64 val);
internal U64 ctz32(U32 val);
internal U64 ctz64(U64 val);
internal U64 clz32(U32 val);
internal U64 clz64(U64 val);
#endif // BASE_BITS_H
+4 -1
View File
@@ -82,6 +82,7 @@ internal CmdLine
cmd_line_from_string_list(Arena *arena, String8List command_line)
{
CmdLine parsed = {0};
parsed.exe_name = command_line.first->string;
// NOTE(rjf): Set up config option table.
{
@@ -91,6 +92,7 @@ cmd_line_from_string_list(Arena *arena, String8List command_line)
// NOTE(rjf): Parse command line.
B32 after_passthrough_option = 0;
B32 first_passthrough = 1;
for(String8Node *node = command_line.first->next, *next = 0; node != 0; node = next)
{
next = node->next;
@@ -174,10 +176,11 @@ cmd_line_from_string_list(Arena *arena, String8List command_line)
// NOTE(rjf): Default path, treat as a passthrough config option to be
// handled by tool-specific code.
else if(!str8_match(node->string, str8_lit("--"), 0))
else if(!str8_match(node->string, str8_lit("--"), 0) || !first_passthrough)
{
str8_list_push(arena, &parsed.inputs, node->string);
after_passthrough_option = 1;
first_passthrough = 0;
}
}
+1
View File
@@ -29,6 +29,7 @@ struct CmdLineOptList
typedef struct CmdLine CmdLine;
struct CmdLine
{
String8 exe_name;
CmdLineOptList options;
String8List inputs;
U64 option_table_size;
+118 -15
View File
@@ -4,6 +4,9 @@
#ifndef BASE_CONTEXT_CRACKING_H
#define BASE_CONTEXT_CRACKING_H
////////////////////////////////
//~ rjf: Clang OS/Arch Cracking
#if defined(__clang__)
# define COMPILER_CLANG 1
@@ -15,7 +18,7 @@
# elif defined(__APPLE__) && defined(__MACH__)
# define OS_MAC 1
# else
# error This compiler/platform combo is not supported yet
# error This compiler/OS combo is not supported.
# endif
# if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64)
@@ -27,17 +30,40 @@
# elif defined(__arm__)
# define ARCH_ARM32 1
# else
# error architecture not supported yet
# error Architecture not supported.
# endif
////////////////////////////////
//~ rjf: MSVC OS/Arch Cracking
#elif defined(_MSC_VER)
# define COMPILER_CL 1
# define COMPILER_MSVC 1
# if _MSC_VER >= 1920
# define COMPILER_MSVC_YEAR 2019
# elif _MSC_VER >= 1910
# define COMPILER_MSVC_YEAR 2017
# elif _MSC_VER >= 1900
# define COMPILER_MSVC_YEAR 2015
# elif _MSC_VER >= 1800
# define COMPILER_MSVC_YEAR 2013
# elif _MSC_VER >= 1700
# define COMPILER_MSVC_YEAR 2012
# elif _MSC_VER >= 1600
# define COMPILER_MSVC_YEAR 2010
# elif _MSC_VER >= 1500
# define COMPILER_MSVC_YEAR 2008
# elif _MSC_VER >= 1400
# define COMPILER_MSVC_YEAR 2005
# else
# define COMPILER_MSVC_YEAR 0
# endif
# if defined(_WIN32)
# define OS_WINDOWS 1
# else
# error This compiler/platform combo is not supported yet
# error This compiler/OS combo is not supported.
# endif
# if defined(_M_AMD64)
@@ -49,9 +75,12 @@
# elif defined(_M_ARM)
# define ARCH_ARM32 1
# else
# error architecture not supported yet
# error Architecture not supported.
# endif
////////////////////////////////
//~ rjf: GCC OS/Arch Cracking
#elif defined(__GNUC__) || defined(__GNUG__)
# define COMPILER_GCC 1
@@ -59,7 +88,7 @@
# if defined(__gnu_linux__) || defined(__linux__)
# define OS_LINUX 1
# else
# error This compiler/platform combo is not supported yet
# error This compiler/OS combo is not supported.
# endif
# if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64)
@@ -71,26 +100,96 @@
# elif defined(__arm__)
# define ARCH_ARM32 1
# else
# error architecture not supported yet
# error Architecture not supported.
# endif
#else
# error This compiler is not supported yet
# error Compiler not supported.
#endif
////////////////////////////////
//~ rjf: Arch Cracking
#if defined(ARCH_X64)
# define ARCH_64BIT 1
#elif defined(ARCH_X86)
# define ARCH_32BIT 1
#endif
#if ARCH_ARM32 || ARCH_ARM64 || ARCH_X64 || ARCH_X86
# define ARCH_LITTLE_ENDIAN 1
#else
# error Endianness of this architecture not understood by context cracker.
#endif
////////////////////////////////
//~ rjf: Language Cracking
#if defined(__cplusplus)
# define LANG_CPP 1
#else
# define LANG_C 1
#endif
// zeroify
////////////////////////////////
//~ rjf: Build Option Cracking
#if !defined(BUILD_DEBUG)
# define BUILD_DEBUG 1
#endif
#if !defined(BUILD_SUPPLEMENTARY_UNIT)
# define BUILD_SUPPLEMENTARY_UNIT 0
#endif
#if !defined(BUILD_ENTRY_DEFINING_UNIT)
# define BUILD_ENTRY_DEFINING_UNIT 1
#endif
#if !defined(BUILD_CONSOLE_INTERFACE)
# define BUILD_CONSOLE_INTERFACE 0
#endif
#if !defined(BUILD_VERSION_MAJOR)
# define BUILD_VERSION_MAJOR 0
#endif
#if !defined(BUILD_VERSION_MINOR)
# define BUILD_VERSION_MINOR 0
#endif
#if !defined(BUILD_VERSION_PATCH)
# define BUILD_VERSION_PATCH 0
#endif
#define BUILD_VERSION_STRING_LITERAL Stringify(BUILD_VERSION_MAJOR) "." Stringify(BUILD_VERSION_MINOR) "." Stringify(BUILD_VERSION_PATCH)
#if BUILD_DEBUG
# define BUILD_MODE_STRING_LITERAL_APPEND " [Debug]"
#else
# define BUILD_MODE_STRING_LITERAL_APPEND ""
#endif
#if defined(BUILD_GIT_HASH)
# define BUILD_GIT_HASH_STRING_LITERAL_APPEND " [" BUILD_GIT_HASH "]"
#else
# define BUILD_GIT_HASH_STRING_LITERAL_APPEND ""
#endif
#if !defined(BUILD_TITLE)
# define BUILD_TITLE "Untitled"
#endif
#if !defined(BUILD_RELEASE_PHASE_STRING_LITERAL)
# define BUILD_RELEASE_PHASE_STRING_LITERAL "ALPHA"
#endif
#if !defined(BUILD_ISSUES_LINK_STRING_LITERAL)
# define BUILD_ISSUES_LINK_STRING_LITERAL "https://github.com/EpicGames/raddebugger/issues"
#endif
#define BUILD_TITLE_STRING_LITERAL BUILD_TITLE " (" BUILD_VERSION_STRING_LITERAL " " BUILD_RELEASE_PHASE_STRING_LITERAL ") - " __DATE__ "" BUILD_GIT_HASH_STRING_LITERAL_APPEND BUILD_MODE_STRING_LITERAL_APPEND
////////////////////////////////
//~ rjf: Zero All Undefined Options
#if !defined(ARCH_32BIT)
# define ARCH_32BIT 0
@@ -110,8 +209,8 @@
#if !defined(ARCH_ARM32)
# define ARCH_ARM32 0
#endif
#if !defined(COMPILER_CL)
# define COMPILER_CL 0
#if !defined(COMPILER_MSVC)
# define COMPILER_MSVC 0
#endif
#if !defined(COMPILER_GCC)
# define COMPILER_GCC 0
@@ -135,10 +234,14 @@
# define LANG_C 0
#endif
#if ARCH_ARM32 || ARCH_ARM64 || ARCH_X64 || ARCH_X86
# define ARCH_LITTLE_ENDIAN 1
#else
# error Endianness of this architecture not understood by context cracker
////////////////////////////////
//~ rjf: Unsupported Errors
#if ARCH_X86
# error You tried to build in x86 (32 bit) mode, but currently, only building in x64 (64 bit) mode is supported.
#endif
#if !ARCH_X64
# error You tried to build with an unsupported architecture. Currently, only building in x64 mode is supported.
#endif
#endif // BASE_CONTEXT_CRACKING_H
+111 -3
View File
@@ -2,7 +2,7 @@
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ Safe Casts
//~ rjf: Safe Casts
internal U16
safe_cast_u16(U32 x)
@@ -141,6 +141,106 @@ bswap_u64(U64 x)
return result;
}
#if COMPILER_MSVC || (COMPILER_CLANG && OS_WINDOWS)
internal U64
count_bits_set16(U16 val)
{
return __popcnt16(val);
}
internal U64
count_bits_set32(U32 val)
{
return __popcnt(val);
}
internal U64
count_bits_set64(U64 val)
{
return __popcnt64(val);
}
internal U64
ctz32(U32 mask)
{
unsigned long idx;
_BitScanForward(&idx, mask);
return idx;
}
internal U64
ctz64(U64 mask)
{
unsigned long idx;
_BitScanForward64(&idx, mask);
return idx;
}
internal U64
clz32(U32 mask)
{
unsigned long idx;
_BitScanReverse(&idx, mask);
return 31 - idx;
}
internal U64
clz64(U64 mask)
{
unsigned long idx;
_BitScanReverse64(&idx, mask);
return 63 - idx;
}
#elif COMPILER_CLANG || COMPILER_GCC
internal U64
count_bits_set16(U16 val)
{
NotImplemented;
return 0;
}
internal U64
count_bits_set32(U32 val)
{
NotImplemented;
return 0;
}
internal U64
count_bits_set64(U64 val)
{
NotImplemented;
return 0;
}
internal U64
ctz32(U32 val)
{
NotImplemented;
return 0;
}
internal U64
clz32(U32 val)
{
NotImplemented;
return 0;
}
internal U64
clz64(U64 val)
{
NotImplemented;
return 0;
}
#else
# error "Bit intrinsic functions not defined for this compiler."
#endif
////////////////////////////////
//~ rjf: Enum -> Sign
@@ -287,6 +387,14 @@ txt_rng_union(TxtRng a, TxtRng b)
return result;
}
internal B32
txt_rng_contains(TxtRng r, TxtPt pt)
{
B32 result = ((txt_pt_less_than(r.min, pt) || txt_pt_match(r.min, pt)) &&
txt_pt_less_than(pt, r.max));
return result;
}
////////////////////////////////
//~ rjf: Toolchain/Environment Enum Functions
@@ -344,8 +452,8 @@ architecture_from_context(void){
internal Compiler
compiler_from_context(void){
Compiler compiler = Compiler_Null;
#if COMPILER_CL
compiler = Compiler_cl;
#if COMPILER_MSVC
compiler = Compiler_msvc;
#elif COMPILER_GCC
compiler = Compiler_gcc;
#elif COMPILER_CLANG
+254 -147
View File
@@ -13,17 +13,6 @@
#include <string.h>
#include <stdint.h>
////////////////////////////////
//~ rjf: Build Configuration
#if !defined(ENABLE_DEV)
# define ENABLE_DEV 0
#endif
#if !defined(SUPPLEMENT_UNIT)
# define SUPPLEMENT_UNIT 0
#endif
////////////////////////////////
//~ rjf: Codebase Keywords
@@ -31,7 +20,7 @@
#define global static
#define local_persist static
#if COMPILER_CL || (COMPILER_CLANG && OS_WINDOWS)
#if COMPILER_MSVC || (COMPILER_CLANG && OS_WINDOWS)
# pragma section(".rdata$", read)
# define read_only __declspec(allocate(".rdata$"))
#elif (COMPILER_CLANG && OS_LINUX)
@@ -45,6 +34,80 @@
# define read_only
#endif
#if COMPILER_MSVC
# define thread_static __declspec(thread)
#elif COMPILER_CLANG || COMPILER_GCC
# define thread_static __thread
#endif
////////////////////////////////
//~ rjf: Linkage Keyword Macros
#if OS_WINDOWS
# define shared_function C_LINKAGE __declspec(dllexport)
#else
# define shared_function C_LINKAGE
#endif
#if LANG_CPP
# define C_LINKAGE_BEGIN extern "C"{
# define C_LINKAGE_END }
# define C_LINKAGE extern "C"
#else
# define C_LINKAGE_BEGIN
# define C_LINKAGE_END
# define C_LINKAGE
#endif
////////////////////////////////
//~ rjf: Units
#define KB(n) (((U64)(n)) << 10)
#define MB(n) (((U64)(n)) << 20)
#define GB(n) (((U64)(n)) << 30)
#define TB(n) (((U64)(n)) << 40)
#define Thousand(n) ((n)*1000)
#define Million(n) ((n)*1000000)
#define Billion(n) ((n)*1000000000)
////////////////////////////////
//~ rjf: Branch Predictor Hints
#if defined(__clang__)
# define Expect(expr, val) __builtin_expect((expr), (val))
#else
# define Expect(expr, val) (expr)
#endif
#define Likely(expr) Expect(expr,1)
#define Unlikely(expr) Expect(expr,0)
////////////////////////////////
//~ rjf: Clamps, Mins, Maxes
#define Min(A,B) (((A)<(B))?(A):(B))
#define Max(A,B) (((A)>(B))?(A):(B))
#define ClampTop(A,X) Min(A,X)
#define ClampBot(X,B) Max(X,B)
#define Clamp(A,X,B) (((X)<(A))?(A):((X)>(B))?(B):(X))
////////////////////////////////
//~ rjf: Member Offsets
#define Member(T,m) (((T*)0)->m)
#define OffsetOf(T,m) IntFromPtr(&Member(T,m))
#define MemberFromOffset(T,ptr,off) (T)((((U8 *)ptr)+(off)))
#define CastFromMember(T,m,ptr) (T*)(((U8*)ptr) - OffsetOf(T,m))
////////////////////////////////
//~ rjf: For-Loop Construct Macros
#define DeferLoop(begin, end) for(int _i_ = ((begin), 0); !_i_; _i_ += 1, (end))
#define DeferLoopChecked(begin, end) for(int _i_ = 2 * !(begin); (_i_ == 2 ? ((end), 0) : !_i_); _i_ += 1, (end))
#define EachEnumVal(type, it) type it = (type)0; it < type##_COUNT; it = (type)(it+1)
#define EachNonZeroEnumVal(type, it) type it = (type)1; it < type##_COUNT; it = (type)(it+1)
////////////////////////////////
//~ rjf: Memory Operation Macros
@@ -67,147 +130,127 @@
#define MemoryMatchArray(a,b) MemoryMatch((a),(b),sizeof(a))
#define MemoryRead(T,p,e) ( ((p)+sizeof(T)<=(e))?(*(T*)(p)):(0) )
#define MemoryConsume(T,p,e) \
( ((p)+sizeof(T)<=(e))?((p)+=sizeof(T),*(T*)((p)-sizeof(T))):((p)=(e),0) )
////////////////////////////////
//~ rjf: Units
#define KB(n) (((U64)(n)) << 10)
#define MB(n) (((U64)(n)) << 20)
#define GB(n) (((U64)(n)) << 30)
#define TB(n) (((U64)(n)) << 40)
#define Thousand(n) ((n)*1000)
#define Million(n) ((n)*1000000)
#define Billion(n) ((n)*1000000000)
#define MemoryConsume(T,p,e) ( ((p)+sizeof(T)<=(e))?((p)+=sizeof(T),*(T*)((p)-sizeof(T))):((p)=(e),0) )
////////////////////////////////
//~ rjf: Asserts
#if COMPILER_CL
#if COMPILER_MSVC
# define Trap() __debugbreak()
#elif COMPILER_CLANG || COMPILER_GCC
# define Trap() __builtin_trap()
# else
# error "undefined trap"
#else
# error Unknown trap intrinsic for this compiler.
#endif
#define AssertAlways(x) do{if(!(x)) {Trap();}}while(0)
#if !defined(NDEBUG)
#if BUILD_DEBUG
# define Assert(x) AssertAlways(x)
#else
# define Assert(x) (void)(x)
#endif
#define AssertImplies(a,b) Assert(!(a) || b)
#define AssertIff(a,b) Assert(!!(a) == !!(b))
#define InvalidPath Assert(!"Invalid Path!")
#define NotImplemented Assert(!"Not Implemented!")
#define StaticAssert(C,ID) global U8 Glue(ID,__LINE__)[(C)?1:-1]
#define NoOp ((void)0)
#define StaticAssert(C, ID) global U8 Glue(ID, __LINE__)[(C)?1:-1]
////////////////////////////////
//~ rjf: Branch Predictor Hints
#if defined(__clang__)
# define Expect(expr, val) __builtin_expect((expr), (val))
#else
# define Expect(expr, val) (expr)
#endif
#define Likely(expr) Expect(expr,1)
#define Unlikely(expr) Expect(expr,0)
////////////////////////////////
//~ rjf: Misc. Helper Macros
#define ArrayCount(a) (sizeof(a) / sizeof((a)[0]))
#define Stmnt(S) do{ S }while(0)
#define Stringify_(S) #S
#define Stringify(S) Stringify_(S)
#define Glue_(A,B) A##B
#define Glue(A,B) Glue_(A,B)
#define Min(A,B) ( ((A)<(B))?(A):(B) )
#define Max(A,B) ( ((A)>(B))?(A):(B) )
#define ClampTop(A,X) Min(A,X)
#define ClampBot(X,B) Max(X,B)
#define Clamp(A,X,B) ( ((X)<(A))?(A):((X)>(B))?(B):(X) )
#define PtrClampTop(A,X) ClampTop(A,X)
#define PtrClampBot(X,B) ClampBot(X,B)
#define PtrClamp(A,X,B) Clamp(A,X,B)
#define CeilIntegerDiv(a,b) (((a) + (b) - 1)/(b))
#define Swap(T,a,b) Stmnt( T t__ = a; a = b; b = t__; )
#if ARCH_64BIT
# define IntFromPtr(ptr) ((U64)(ptr))
#elif ARCH_32BIT
# define IntFromPtr(ptr) ((U32)(ptr))
#else
# error missing ptr cast for this architecture
#endif
#define PtrFromInt(i) (void*)((U8*)0 + (i))
#define Member(T,m) (((T*)0)->m)
#define OffsetOf(T,m) IntFromPtr(&Member(T,m))
#define MemberFromOffset(T,ptr,off) (T)((((U8 *)ptr)+(off)))
#define CastFromMember(T,m,ptr) (T*)(((U8*)ptr) - OffsetOf(T,m))
#define Compose64Bit(a,b) ((((U64)a) << 32) | ((U64)b));
#define AlignPow2(x,b) (((x) + (b) - 1)&(~((b) - 1)))
#define AlignDownPow2(x,b) ((x)&(~((b) - 1)))
#define AlignPadPow2(x,b) ((0-(x)) & ((b) - 1))
#define IsPow2(x) ((x)!=0 && ((x)&((x)-1))==0)
#define IsPow2OrZero(x) ((((x) - 1)&(x)) == 0)
#define DeferLoop(begin, end) for(int _i_ = ((begin), 0); !_i_; _i_ += 1, (end))
#define DeferLoopChecked(begin, end) for(int _i_ = 2 * !(begin); (_i_ == 2 ? ((end), 0) : !_i_); _i_ += 1, (end))
#if LANG_CPP
# define zero_struct {}
#else
# define zero_struct {0}
#endif
#if COMPILER_MSVC && COMPILER_MSVC_YEAR < 2015
# define this_function_name "unknown"
#else
# define this_function_name __func__
#endif
#if LANG_CPP
# define C_LINKAGE_BEGIN extern "C"{
# define C_LINKAGE_END }
# define C_LINKAGE extern "C"
#else
# define C_LINKAGE_BEGIN
# define C_LINKAGE_END
# define C_LINKAGE
#endif
#if COMPILER_CL
# define thread_static __declspec(thread)
#elif COMPILER_CLANG || COMPILER_GCC
# define thread_static __thread
#endif
//~ rjf: Atomic Operations
#if OS_WINDOWS
# define shared_function C_LINKAGE __declspec(dllexport)
# include <windows.h>
# include <tmmintrin.h>
# include <wmmintrin.h>
# include <intrin.h>
# if ARCH_X64
# define ins_atomic_u64_eval(x) InterlockedAdd64((volatile __int64 *)(x), 0)
# define ins_atomic_u64_inc_eval(x) InterlockedIncrement64((volatile __int64 *)(x))
# define ins_atomic_u64_dec_eval(x) InterlockedDecrement64((volatile __int64 *)(x))
# define ins_atomic_u64_eval_assign(x,c) InterlockedExchange64((volatile __int64 *)(x),(c))
# define ins_atomic_u64_add_eval(x,c) InterlockedAdd64((volatile __int64 *)(x), c)
# define ins_atomic_u64_eval_cond_assign(x,k,c) InterlockedCompareExchange64((volatile __int64 *)(x),(k),(c))
# define ins_atomic_u32_eval(x,c) InterlockedAdd((volatile LONG *)(x), 0)
# define ins_atomic_u32_eval_assign(x,c) InterlockedExchange((volatile LONG *)(x),(c))
# define ins_atomic_u32_eval_cond_assign(x,k,c) InterlockedCompareExchange((volatile LONG *)(x),(k),(c))
# define ins_atomic_ptr_eval_assign(x,c) (void*)ins_atomic_u64_eval_assign((volatile __int64 *)(x), (__int64)(c))
# else
# error Atomic intrinsics not defined for this operating system / architecture combination.
# endif
#elif OS_LINUX
# if ARCH_X64
# define ins_atomic_u64_inc_eval(x) __sync_fetch_and_add((volatile U64 *)(x), 1)
# else
# error Atomic intrinsics not defined for this operating system / architecture combination.
# endif
#else
# define shared_function C_LINKAGE
# error Atomic intrinsics not defined for this operating system.
#endif
////////////////////////////////
//~ ASAN
//~ rjf: Linked List Building Macros
#if COMPILER_CL
//- rjf: linked list macro helpers
#define CheckNil(nil,p) ((p) == 0 || (p) == nil)
#define SetNil(nil,p) ((p) = nil)
//- rjf: doubly-linked-lists
#define DLLInsert_NPZ(nil,f,l,p,n,next,prev) (CheckNil(nil,f) ? \
((f) = (l) = (n), SetNil(nil,(n)->next), SetNil(nil,(n)->prev)) :\
CheckNil(nil,p) ? \
((n)->next = (f), (f)->prev = (n), (f) = (n), SetNil(nil,(n)->prev)) :\
((p)==(l)) ? \
((l)->next = (n), (n)->prev = (l), (l) = (n), SetNil(nil, (n)->next)) :\
(((!CheckNil(nil,p) && CheckNil(nil,(p)->next)) ? (0) : ((p)->next->prev = (n))), ((n)->next = (p)->next), ((p)->next = (n)), ((n)->prev = (p))))
#define DLLPushBack_NPZ(nil,f,l,n,next,prev) DLLInsert_NPZ(nil,f,l,l,n,next,prev)
#define DLLPushFront_NPZ(nil,f,l,n,next,prev) DLLInsert_NPZ(nil,l,f,f,n,prev,next)
#define DLLRemove_NPZ(nil,f,l,n,next,prev) (((n) == (f) ? (f) = (n)->next : (0)),\
((n) == (l) ? (l) = (l)->prev : (0)),\
(CheckNil(nil,(n)->prev) ? (0) :\
((n)->prev->next = (n)->next)),\
(CheckNil(nil,(n)->next) ? (0) :\
((n)->next->prev = (n)->prev)))
//- rjf: singly-linked, doubly-headed lists (queues)
#define SLLQueuePush_NZ(nil,f,l,n,next) (CheckNil(nil,f)?\
((f)=(l)=(n),SetNil(nil,(n)->next)):\
((l)->next=(n),(l)=(n),SetNil(nil,(n)->next)))
#define SLLQueuePushFront_NZ(nil,f,l,n,next) (CheckNil(nil,f)?\
((f)=(l)=(n),SetNil(nil,(n)->next)):\
((n)->next=(f),(f)=(n)))
#define SLLQueuePop_NZ(nil,f,l,next) ((f)==(l)?\
(SetNil(nil,f),SetNil(nil,l)):\
((f)=(f)->next))
//- rjf: singly-linked, singly-headed lists (stacks)
#define SLLStackPush_N(f,n,next) ((n)->next=(f), (f)=(n))
#define SLLStackPop_N(f,next) ((f)=(f)->next)
//- rjf: doubly-linked-list helpers
#define DLLInsert_NP(f,l,p,n,next,prev) DLLInsert_NPZ(0,f,l,p,n,next,prev)
#define DLLPushBack_NP(f,l,n,next,prev) DLLPushBack_NPZ(0,f,l,n,next,prev)
#define DLLPushFront_NP(f,l,n,next,prev) DLLPushFront_NPZ(0,f,l,n,next,prev)
#define DLLRemove_NP(f,l,n,next,prev) DLLRemove_NPZ(0,f,l,n,next,prev)
#define DLLInsert(f,l,p,n) DLLInsert_NPZ(0,f,l,p,n,next,prev)
#define DLLPushBack(f,l,n) DLLPushBack_NPZ(0,f,l,n,next,prev)
#define DLLPushFront(f,l,n) DLLPushFront_NPZ(0,f,l,n,next,prev)
#define DLLRemove(f,l,n) DLLRemove_NPZ(0,f,l,n,next,prev)
//- rjf: singly-linked, doubly-headed list helpers
#define SLLQueuePush_N(f,l,n,next) SLLQueuePush_NZ(0,f,l,n,next)
#define SLLQueuePushFront_N(f,l,n,next) SLLQueuePushFront_NZ(0,f,l,n,next)
#define SLLQueuePop_N(f,l,next) SLLQueuePop_NZ(0,f,l,next)
#define SLLQueuePush(f,l,n) SLLQueuePush_NZ(0,f,l,n,next)
#define SLLQueuePushFront(f,l,n) SLLQueuePushFront_NZ(0,f,l,n,next)
#define SLLQueuePop(f,l) SLLQueuePop_NZ(0,f,l,next)
//- rjf: singly-linked, singly-headed list helpers
#define SLLStackPush(f,n) SLLStackPush_N(f,n,next)
#define SLLStackPop(f) SLLStackPop_N(f,next)
////////////////////////////////
//~ rjf: Address Sanitizer Markup
#if COMPILER_MSVC
# if defined(__SANITIZE_ADDRESS__)
# define ASAN_ENABLED 1
# define NO_ASAN __declspec(no_sanitize_address)
@@ -222,24 +265,63 @@
# endif
# define NO_ASAN __attribute__((no_sanitize("address")))
#else
# error "NO_ASAN is not defined"
# error "NO_ASAN is not defined for this compiler."
#endif
#if ASAN_ENABLED
#pragma comment(lib, "clang_rt.asan-x86_64.lib")
C_LINKAGE_BEGIN
void __asan_poison_memory_region(void const volatile *addr, size_t size);
void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
C_LINKAGE_END
C_LINKAGE void __asan_poison_memory_region(void const volatile *addr, size_t size);
C_LINKAGE void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
# define AsanPoisonMemoryRegion(addr, size) __asan_poison_memory_region((addr), (size))
# define AsanUnpoisonMemoryRegion(addr, size) __asan_unpoison_memory_region((addr), (size))
#else
# define AsanPoisonMemoryRegion(addr, size) ((void)(addr), (void)(size))
# define AsanUnpoisonMemoryRegion(addr, size) ((void)(addr), (void)(size))
#endif
////////////////////////////////
//~ rjf: Misc. Helper Macros
#define Stringify_(S) #S
#define Stringify(S) Stringify_(S)
#define Glue_(A,B) A##B
#define Glue(A,B) Glue_(A,B)
#define ArrayCount(a) (sizeof(a) / sizeof((a)[0]))
#define CeilIntegerDiv(a,b) (((a) + (b) - 1)/(b))
#define Swap(T,a,b) do{T t__ = a; a = b; b = t__;}while(0)
#if ARCH_64BIT
# define IntFromPtr(ptr) ((U64)(ptr))
#elif ARCH_32BIT
# define IntFromPtr(ptr) ((U32)(ptr))
#else
# error Missing pointer-to-integer cast for this architecture.
#endif
#define PtrFromInt(i) (void*)((U8*)0 + (i))
#define Compose64Bit(a,b) ((((U64)a) << 32) | ((U64)b));
#define AlignPow2(x,b) (((x) + (b) - 1)&(~((b) - 1)))
#define AlignDownPow2(x,b) ((x)&(~((b) - 1)))
#define AlignPadPow2(x,b) ((0-(x)) & ((b) - 1))
#define IsPow2(x) ((x)!=0 && ((x)&((x)-1))==0)
#define IsPow2OrZero(x) ((((x) - 1)&(x)) == 0)
#define ExtractBit(word, idx) (((word) >> (idx)) & 1)
#if LANG_CPP
# define zero_struct {}
#else
# define zero_struct {0}
#endif
#if COMPILER_MSVC && COMPILER_MSVC_YEAR < 2015
# define this_function_name "unknown"
#else
# define this_function_name __func__
#endif
////////////////////////////////
@@ -259,10 +341,7 @@ typedef S32 B32;
typedef S64 B64;
typedef float F32;
typedef double F64;
////////////////////////////////
//~ rjf: Large Base Types
typedef void VoidProc(void);
typedef struct U128 U128;
struct U128
{
@@ -272,8 +351,6 @@ struct U128
////////////////////////////////
//~ rjf: Basic Types & Spaces
typedef void VoidProc(void);
typedef enum Dimension
{
Dimension_X,
@@ -314,6 +391,19 @@ typedef enum Corner
}
Corner;
typedef enum Dir2
{
Dir2_Invalid = -1,
Dir2_Left,
Dir2_Up,
Dir2_Right,
Dir2_Down,
Dir2_COUNT
}
Dir2;
#define axis2_from_dir2(d) (((d) & 1) ? Axis2_Y : Axis2_X)
#define side_from_dir2(d) (((d) < Dir2_Right) ? Side_Min : Side_Max)
////////////////////////////////
//~ rjf: Toolchain/Environment Enums
@@ -341,7 +431,7 @@ Architecture;
typedef enum Compiler
{
Compiler_Null,
Compiler_cl,
Compiler_msvc,
Compiler_gcc,
Compiler_clang,
Compiler_COUNT,
@@ -569,11 +659,13 @@ struct DateTime
U16 min; // [0,59]
U16 hour; // [0,24]
U16 day; // [0,30]
union{
union
{
WeekDay week_day;
U32 wday;
};
union{
union
{
Month month;
U32 mon;
};
@@ -601,7 +693,7 @@ struct FileProperties
};
////////////////////////////////
//~ Safe Casts
//~ rjf: Safe Casts
internal U16 safe_cast_u16(U32 x);
internal U32 safe_cast_u32(U64 x);
@@ -629,6 +721,15 @@ internal U16 bswap_u16(U16 x);
internal U32 bswap_u32(U32 x);
internal U64 bswap_u64(U64 x);
internal U64 count_bits_set16(U16 val);
internal U64 count_bits_set32(U32 val);
internal U64 count_bits_set64(U64 val);
internal U64 ctz32(U32 val);
internal U64 ctz64(U64 val);
internal U64 clz32(U32 val);
internal U64 clz64(U64 val);
////////////////////////////////
//~ rjf: Enum -> Sign
@@ -651,6 +752,7 @@ internal TxtPt txt_pt_max(TxtPt a, TxtPt b);
internal TxtRng txt_rng(TxtPt min, TxtPt max);
internal TxtRng txt_rng_intersect(TxtRng a, TxtRng b);
internal TxtRng txt_rng_union(TxtRng a, TxtRng b);
internal B32 txt_rng_contains(TxtRng r, TxtPt pt);
////////////////////////////////
//~ rjf: Toolchain/Environment Enum Functions
@@ -677,4 +779,9 @@ internal U64 ring_read(U8 *ring_base, U64 ring_size, U64 ring_pos, void *dst_dat
#define ring_write_struct(ring_base, ring_size, ring_pos, ptr) ring_write((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr)))
#define ring_read_struct(ring_base, ring_size, ring_pos, ptr) ring_read((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr)))
#endif // BASE_TYPES_H
////////////////////////////////
//~ rjf: Sorts
#define quick_sort(ptr, count, element_size, cmp_function) qsort((ptr), (count), (element_size), (int (*)(const void *, const void *))(cmp_function))
#endif // BASE_CORE_H
+95
View File
@@ -0,0 +1,95 @@
internal void
main_thread_base_entry_point(void (*entry_point)(CmdLine *cmdline), char **arguments, U64 arguments_count)
{
#if PROFILE_TELEMETRY
local_persist U8 tm_data[MB(64)];
tmLoadLibrary(TM_RELEASE);
tmSetMaxThreadCount(256);
tmInitialize(sizeof(tm_data), (char *)tm_data);
#endif
TCTX tctx;
tctx_init_and_equip(&tctx);
ThreadNameF("[main thread]");
Temp scratch = scratch_begin(0, 0);
String8List command_line_argument_strings = os_string_list_from_argcv(scratch.arena, (int)arguments_count, arguments);
CmdLine cmdline = cmd_line_from_string_list(scratch.arena, command_line_argument_strings);
B32 capture = cmd_line_has_flag(&cmdline, str8_lit("capture"));
if(capture)
{
ProfBeginCapture(arguments[0]);
}
#if defined(OS_CORE_H) && !defined(OS_INIT_MANUAL)
os_init();
#endif
#if defined(TASK_SYSTEM_H) && !defined(TS_INIT_MANUAL)
ts_init();
#endif
#if defined(HASH_STORE_H) && !defined(HS_INIT_MANUAL)
hs_init();
#endif
#if defined(FILE_STREAM_H) && !defined(FS_INIT_MANUAL)
fs_init();
#endif
#if defined(TEXT_CACHE_H) && !defined(TXT_INIT_MANUAL)
txt_init();
#endif
#if defined(MUTABLE_TEXT_H) && !defined(MTX_INIT_MANUAL)
mtx_init();
#endif
#if defined(DASM_CACHE_H) && !defined(DASM_INIT_MANUAL)
dasm_init();
#endif
#if defined(DI_H) && !defined(DI_INIT_MANUAL)
di_init();
#endif
#if defined(FUZZY_SEARCH_H) && !defined(FZY_INIT_MANUAL)
fzy_init();
#endif
#if defined(DEMON_CORE_H) && !defined(DMN_INIT_MANUAL)
dmn_init();
#endif
#if defined(CTRL_CORE_H) && !defined(CTRL_INIT_MANUAL)
ctrl_init();
#endif
#if defined(OS_GRAPHICAL_H) && !defined(OS_GFX_INIT_MANUAL)
os_graphical_init();
#endif
#if defined(FONT_PROVIDER_H) && !defined(FP_INIT_MANUAL)
fp_init();
#endif
#if defined(RENDER_CORE_H) && !defined(R_INIT_MANUAL)
r_init(&cmdline);
#endif
#if defined(TEXTURE_CACHE_H) && !defined(TEX_INIT_MANUAL)
tex_init();
#endif
#if defined(GEO_CACHE_H) && !defined(GEO_INIT_MANUAL)
geo_init();
#endif
#if defined(FONT_CACHE_H) && !defined(F_INIT_MANUAL)
f_init();
#endif
#if defined(DF_CORE_H) && !defined(DF_INIT_MANUAL)
DF_StateDeltaHistory *hist = df_state_delta_history_alloc();
df_core_init(&cmdline, hist);
#endif
#if defined(DF_GFX_H) && !defined(DF_GFX_INIT_MANUAL)
df_gfx_init(update_and_render, df_state_delta_history());
#endif
entry_point(&cmdline);
if(capture)
{
ProfEndCapture();
}
scratch_end(scratch);
tctx_release();
}
internal void
supplement_thread_base_entry_point(void (*entry_point)(void *params), void *params)
{
TCTX tctx;
tctx_init_and_equip(&tctx);
entry_point(params);
tctx_release();
}
+10
View File
@@ -0,0 +1,10 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_ENTRY_POINT_H
#define BASE_ENTRY_POINT_H
internal void main_thread_base_entry_point(void (*entry_point)(CmdLine *cmdline), char **arguments, U64 arguments_count);
internal void supplement_thread_base_entry_point(void (*entry_point)(void *params), void *params);
#endif // BASE_ENTRY_POINT_H
+6 -5
View File
@@ -7,12 +7,13 @@
#undef RADDBG_LAYER_COLOR
#define RADDBG_LAYER_COLOR 0.20f, 0.60f, 0.80f
#include "base_types.c"
#include "base_markup.c"
#include "base_core.c"
#include "base_profile.c"
#include "base_arena.c"
#include "base_math.c"
#include "base_string.c"
#include "base_strings.c"
#include "base_thread_context.c"
#include "base_command_line.c"
#include "base_arena_dev.c"
#include "base_bits.c"
#include "base_markup.c"
#include "base_log.c"
#include "base_entry_point.c"
+7 -7
View File
@@ -8,16 +8,16 @@
//~ rjf: Base Includes
#include "base_context_cracking.h"
#include "base_types.h"
#include "base_markup.h"
#include "base_ins.h"
#include "base_linked_lists.h"
#include "base_core.h"
#include "base_profile.h"
#include "base_arena.h"
#include "base_math.h"
#include "base_string.h"
#include "base_strings.h"
#include "base_thread_context.h"
#include "base_command_line.h"
#include "base_arena_dev.h"
#include "base_bits.h"
#include "base_markup.h"
#include "base_log.h"
#include "base_entry_point.h"
#endif // BASE_INC_H
-52
View File
@@ -1,52 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_INS_H
#define BASE_INS_H
////////////////////////////////
// NOTE(allen): Implementations of Intrinsics
#if OS_WINDOWS
# include <windows.h>
# include <tmmintrin.h>
# include <wmmintrin.h>
# include <intrin.h>
# if ARCH_X64
# define ins_atomic_u64_eval(x) InterlockedAdd((volatile LONG *)(x), 0)
# define ins_atomic_u64_inc_eval(x) InterlockedIncrement64((volatile __int64 *)(x))
# define ins_atomic_u64_dec_eval(x) InterlockedDecrement64((volatile __int64 *)(x))
# define ins_atomic_u64_eval_assign(x,c) InterlockedExchange64((volatile __int64 *)(x),(c))
# define ins_atomic_u64_add_eval(x,c) InterlockedAdd((volatile LONG *)(x), c)
# define ins_atomic_u32_eval_assign(x,c) InterlockedExchange((volatile LONG *)(x),(c))
# define ins_atomic_u32_eval_cond_assign(x,k,c) InterlockedCompareExchange((volatile LONG *)(x),(k),(c))
# define ins_atomic_ptr_eval_assign(x,c) (void*)ins_atomic_u64_eval_assign((volatile __int64 *)(x), (__int64)(c))
# endif
#elif OS_LINUX
# if ARCH_X64
# define ins_atomic_u64_inc_eval(x) __sync_fetch_and_add((volatile U64 *)(x), 1)
# endif
#else
// TODO(allen):
#endif
////////////////////////////////
// NOTE(allen): Intrinsic Checks
#if ARCH_X64
# if !defined(ins_atomic_u64_inc_eval)
# error missing: ins_atomic_u64_inc_eval
# endif
#else
# error the intrinsic set for this arch is not developed
#endif
#endif //BASE_INS_H
-73
View File
@@ -1,73 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_LINKED_LIST_H
#define BASE_LINKED_LIST_H
////////////////////////////////
//~ rjf: Helpers
#define CheckNil(nil,p) ((p) == 0 || (p) == nil)
#define SetNil(nil,p) ((p) = nil)
////////////////////////////////
//~ rjf: Base Macros
//- rjf: Base Doubly-Linked-List Macros
#define DLLInsert_NPZ(nil,f,l,p,n,next,prev) (CheckNil(nil,f) ? \
((f) = (l) = (n), SetNil(nil,(n)->next), SetNil(nil,(n)->prev)) :\
CheckNil(nil,p) ? \
((n)->next = (f), (f)->prev = (n), (f) = (n), SetNil(nil,(n)->prev)) :\
((p)==(l)) ? \
((l)->next = (n), (n)->prev = (l), (l) = (n), SetNil(nil, (n)->next)) :\
(((!CheckNil(nil,p) && CheckNil(nil,(p)->next)) ? (0) : ((p)->next->prev = (n))), ((n)->next = (p)->next), ((p)->next = (n)), ((n)->prev = (p))))
#define DLLPushBack_NPZ(nil,f,l,n,next,prev) DLLInsert_NPZ(nil,f,l,l,n,next,prev)
#define DLLPushFront_NPZ(nil,f,l,n,next,prev) DLLInsert_NPZ(nil,l,f,f,n,prev,next)
#define DLLRemove_NPZ(nil,f,l,n,next,prev) (((n) == (f) ? (f) = (n)->next : (0)),\
((n) == (l) ? (l) = (l)->prev : (0)),\
(CheckNil(nil,(n)->prev) ? (0) :\
((n)->prev->next = (n)->next)),\
(CheckNil(nil,(n)->next) ? (0) :\
((n)->next->prev = (n)->prev)))
//- rjf: Base Singly-Linked-List Queue Macros
#define SLLQueuePush_NZ(nil,f,l,n,next) (CheckNil(nil,f)?\
((f)=(l)=(n),SetNil(nil,(n)->next)):\
((l)->next=(n),(l)=(n),SetNil(nil,(n)->next)))
#define SLLQueuePushFront_NZ(nil,f,l,n,next) (CheckNil(nil,f)?\
((f)=(l)=(n),SetNil(nil,(n)->next)):\
((n)->next=(f),(f)=(n)))
#define SLLQueuePop_NZ(nil,f,l,next) ((f)==(l)?\
(SetNil(nil,f),SetNil(nil,l)):\
((f)=(f)->next))
//- rjf: Base Singly-Linked-List Stack Macros
#define SLLStackPush_N(f,n,next) ((n)->next=(f), (f)=(n))
#define SLLStackPop_N(f,next) ((f)=(f)->next)
////////////////////////////////
//~ rjf: Convenience Wrappers
//- rjf: Doubly-Linked-List Wrappers
#define DLLInsert_NP(f,l,p,n,next,prev) DLLInsert_NPZ(0,f,l,p,n,next,prev)
#define DLLPushBack_NP(f,l,n,next,prev) DLLPushBack_NPZ(0,f,l,n,next,prev)
#define DLLPushFront_NP(f,l,n,next,prev) DLLPushFront_NPZ(0,f,l,n,next,prev)
#define DLLRemove_NP(f,l,n,next,prev) DLLRemove_NPZ(0,f,l,n,next,prev)
#define DLLInsert(f,l,p,n) DLLInsert_NPZ(0,f,l,p,n,next,prev)
#define DLLPushBack(f,l,n) DLLPushBack_NPZ(0,f,l,n,next,prev)
#define DLLPushFront(f,l,n) DLLPushFront_NPZ(0,f,l,n,next,prev)
#define DLLRemove(f,l,n) DLLRemove_NPZ(0,f,l,n,next,prev)
//- rjf: Singly-Linked-List Queue Wrappers
#define SLLQueuePush_N(f,l,n,next) SLLQueuePush_NZ(0,f,l,n,next)
#define SLLQueuePushFront_N(f,l,n,next) SLLQueuePushFront_NZ(0,f,l,n,next)
#define SLLQueuePop_N(f,l,next) SLLQueuePop_NZ(0,f,l,next)
#define SLLQueuePush(f,l,n) SLLQueuePush_NZ(0,f,l,n,next)
#define SLLQueuePushFront(f,l,n) SLLQueuePushFront_NZ(0,f,l,n,next)
#define SLLQueuePop(f,l) SLLQueuePop_NZ(0,f,l,next)
//- rjf: Singly-Linked-List Stack Wrappers
#define SLLStackPush(f,n) SLLStackPush_N(f,n,next)
#define SLLStackPop(f) SLLStackPop_N(f,next)
#endif //BASE_LINKED_LIST_H
+103
View File
@@ -0,0 +1,103 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Globals/Thread-Locals
C_LINKAGE thread_static Log *log_active;
#if !BUILD_SUPPLEMENTARY_UNIT
C_LINKAGE thread_static Log *log_active = 0;
#endif
////////////////////////////////
//~ rjf: Log Creation/Selection
internal Log *
log_alloc(void)
{
Arena *arena = arena_alloc();
Log *log = push_array(arena, Log, 1);
log->arena = arena;
return log;
}
internal void
log_release(Log *log)
{
arena_release(log->arena);
}
internal void
log_select(Log *log)
{
log_active = log;
}
////////////////////////////////
//~ rjf: Log Building/Clearing
internal void
log_msg(LogMsgKind kind, String8 string)
{
if(log_active != 0 && log_active->top_scope != 0)
{
String8 string_copy = push_str8_copy(log_active->arena, string);
str8_list_push(log_active->arena, &log_active->top_scope->strings[kind], string_copy);
}
}
internal void
log_msgf(LogMsgKind kind, char *fmt, ...)
{
if(log_active != 0)
{
Temp scratch = scratch_begin(0, 0);
va_list args;
va_start(args, fmt);
String8 string = push_str8fv(scratch.arena, fmt, args);
log_msg(kind, string);
va_end(args);
scratch_end(scratch);
}
}
////////////////////////////////
//~ rjf: Log Scopes
internal void
log_scope_begin(void)
{
if(log_active != 0)
{
U64 pos = arena_pos(log_active->arena);
LogScope *scope = push_array(log_active->arena, LogScope, 1);
scope->pos = pos;
SLLStackPush(log_active->top_scope, scope);
}
}
internal LogScopeResult
log_scope_end(Arena *arena)
{
LogScopeResult result = {0};
if(log_active != 0)
{
LogScope *scope = log_active->top_scope;
if(scope != 0)
{
SLLStackPop(log_active->top_scope);
if(arena != 0)
{
for(EachEnumVal(LogMsgKind, kind))
{
Temp scratch = scratch_begin(&arena, 1);
String8 result_unindented = str8_list_join(scratch.arena, &scope->strings[kind], 0);
result.strings[kind] = indented_from_string(arena, result_unindented);
scratch_end(scratch);
}
}
arena_pop_to(log_active->arena, scope->pos);
}
}
return result;
}
+65
View File
@@ -0,0 +1,65 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_LOG_H
#define BASE_LOG_H
////////////////////////////////
//~ rjf: Log Types
typedef enum LogMsgKind
{
LogMsgKind_Info,
LogMsgKind_UserError,
LogMsgKind_COUNT
}
LogMsgKind;
typedef struct LogScope LogScope;
struct LogScope
{
LogScope *next;
U64 pos;
String8List strings[LogMsgKind_COUNT];
};
typedef struct LogScopeResult LogScopeResult;
struct LogScopeResult
{
String8 strings[LogMsgKind_COUNT];
};
typedef struct Log Log;
struct Log
{
Arena *arena;
LogScope *top_scope;
};
////////////////////////////////
//~ rjf: Log Creation/Selection
internal Log *log_alloc(void);
internal void log_release(Log *log);
internal void log_select(Log *log);
////////////////////////////////
//~ rjf: Log Building
internal void log_msg(LogMsgKind kind, String8 string);
internal void log_msgf(LogMsgKind kind, char *fmt, ...);
#define log_info(s) log_msg(LogMsgKind_Info, (s))
#define log_infof(fmt, ...) log_msgf(LogMsgKind_Info, (fmt), __VA_ARGS__)
#define log_user_error(s) log_msg(LogMsgKind_UserError, (s))
#define log_user_errorf(fmt, ...) log_msgf(LogMsgKind_UserError, (fmt), __VA_ARGS__)
#define LogInfoNamedBlock(s) DeferLoop(log_infof("%S:\n{\n", (s)), log_infof("}\n"))
#define LogInfoNamedBlockF(fmt, ...) DeferLoop((log_infof(fmt, __VA_ARGS__), log_infof(":\n{\n")), log_infof("}\n"))
////////////////////////////////
//~ rjf: Log Scopes
internal void log_scope_begin(void);
internal LogScopeResult log_scope_end(Arena *arena);
#endif // BASE_LOG_H
+19
View File
@@ -1,2 +1,21 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal void
set_thread_name(String8 string)
{
ProfThreadName("%.*s", str8_varg(string));
os_set_thread_name(string);
}
internal void
set_thread_namef(char *fmt, ...)
{
Temp scratch = scratch_begin(0, 0);
va_list args;
va_start(args, fmt);
String8 string = push_str8fv(scratch.arena, fmt, args);
set_thread_name(string);
va_end(args);
scratch_end(scratch);
}
+4 -71
View File
@@ -4,76 +4,9 @@
#ifndef BASE_MARKUP_H
#define BASE_MARKUP_H
////////////////////////////////
//~ rjf: Zero Settings
#if !defined(PROFILE_TELEMETRY)
# define PROFILE_TELEMETRY 0
#endif
#if !defined(MARKUP_LAYER_COLOR)
# define MARKUP_LAYER_COLOR 1.00f, 0.00f, 1.00f
#endif
////////////////////////////////
//~ rjf: Third Party Includes
#if PROFILE_TELEMETRY
# include "rad_tm.h"
# if OS_WINDOWS
# pragma comment(lib, "rad_tm_win64.lib")
# endif
#endif
////////////////////////////////
//~ rjf: Telemetry Profile Defines
#if PROFILE_TELEMETRY
# define ProfBegin(...) tmEnter(0, 0, __VA_ARGS__)
# define ProfBeginDynamic(...) (TM_API_PTR ? TM_API_PTR->_tmEnterZoneV_Core(0, 0, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0)
# define ProfEnd(...) (TM_API_PTR ? TM_API_PTR->_tmLeaveZone(0) : (void)0)
# define ProfTick(...) tmTick(0)
# define ProfIsCapturing(...) tmRunning()
# define ProfBeginCapture(...) tmOpen(0, __VA_ARGS__, __DATE__, "localhost", TMCT_TCP, TELEMETRY_DEFAULT_PORT, TMOF_INIT_NETWORKING|TMOF_CAPTURE_CONTEXT_SWITCHES, 100)
# define ProfEndCapture(...) tmClose(0)
# define ProfThreadName(...) (TM_API_PTR ? TM_API_PTR->_tmThreadName(0, 0, __VA_ARGS__) : (void)0)
# define ProfMsg(...) (TM_API_PTR ? TM_API_PTR->_tmMessageV_Core(0, TMMF_ICON_NOTE, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0)
# define ProfBeginLockWait(...) tmStartWaitForLock(0, 0, __VA_ARGS__)
# define ProfEndLockWait(...) tmEndWaitForLock(0)
# define ProfLockTake(...) tmAcquiredLock(0, 0, __VA_ARGS__)
# define ProfLockDrop(...) tmReleasedLock(0, __VA_ARGS__)
# define ProfColor(color) tmZoneColorSticky(color)
#endif
////////////////////////////////
//~ rjf: Zeroify Undefined Defines
#if !defined(ProfBegin)
# define ProfBegin(...) (0)
# define ProfBeginDynamic(...) (0)
# define ProfEnd(...) (0)
# define ProfTick(...) (0)
# define ProfIsCapturing(...) (0)
# define ProfBeginCapture(...) (0)
# define ProfEndCapture(...) (0)
# define ProfThreadName(...) (0)
# define ProfMsg(...) (0)
# define ProfBeginLockWait(...) (0)
# define ProfEndLockWait(...) (0)
# define ProfLockTake(...) (0)
# define ProfLockDrop(...) (0)
# define ProfColor(...) (0)
#endif
////////////////////////////////
//~ rjf: Helper Wrappers
#define ProfBeginFunction(...) ProfBegin(this_function_name)
#define ProfScope(...) DeferLoop(ProfBeginDynamic(__VA_ARGS__), ProfEnd())
////////////////////////////////
//~ rjf: General Markup
#define ThreadName(...) (ProfThreadName(__VA_ARGS__))
internal void set_thread_name(String8 string);
internal void set_thread_namef(char *fmt, ...);
#define ThreadNameF(...) (set_thread_namef(__VA_ARGS__))
#define ThreadName(str) (set_thread_name(str))
#endif // BASE_MARKUP_H
+2
View File
@@ -0,0 +1,2 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
+74
View File
@@ -0,0 +1,74 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_PROFILE_H
#define BASE_PROFILE_H
////////////////////////////////
//~ rjf: Zero Settings
#if !defined(PROFILE_TELEMETRY)
# define PROFILE_TELEMETRY 0
#endif
#if !defined(MARKUP_LAYER_COLOR)
# define MARKUP_LAYER_COLOR 1.00f, 0.00f, 1.00f
#endif
////////////////////////////////
//~ rjf: Third Party Includes
#if PROFILE_TELEMETRY
# include "rad_tm.h"
# if OS_WINDOWS
# pragma comment(lib, "rad_tm_win64.lib")
# endif
#endif
////////////////////////////////
//~ rjf: Telemetry Profile Defines
#if PROFILE_TELEMETRY
# define ProfBegin(...) tmEnter(0, 0, __VA_ARGS__)
# define ProfBeginDynamic(...) (TM_API_PTR ? TM_API_PTR->_tmEnterZoneV_Core(0, 0, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0)
# define ProfEnd(...) (TM_API_PTR ? TM_API_PTR->_tmLeaveZone(0) : (void)0)
# define ProfTick(...) tmTick(0)
# define ProfIsCapturing(...) tmRunning()
# define ProfBeginCapture(...) tmOpen(0, __VA_ARGS__, __DATE__, "localhost", TMCT_TCP, TELEMETRY_DEFAULT_PORT, TMOF_INIT_NETWORKING|TMOF_CAPTURE_CONTEXT_SWITCHES, 100)
# define ProfEndCapture(...) tmClose(0)
# define ProfThreadName(...) (TM_API_PTR ? TM_API_PTR->_tmThreadName(0, 0, __VA_ARGS__) : (void)0)
# define ProfMsg(...) (TM_API_PTR ? TM_API_PTR->_tmMessageV_Core(0, TMMF_ICON_NOTE, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0)
# define ProfBeginLockWait(...) tmStartWaitForLock(0, 0, __VA_ARGS__)
# define ProfEndLockWait(...) tmEndWaitForLock(0)
# define ProfLockTake(...) tmAcquiredLock(0, 0, __VA_ARGS__)
# define ProfLockDrop(...) tmReleasedLock(0, __VA_ARGS__)
# define ProfColor(color) tmZoneColorSticky(color)
#endif
////////////////////////////////
//~ rjf: Zeroify Undefined Defines
#if !defined(ProfBegin)
# define ProfBegin(...) (0)
# define ProfBeginDynamic(...) (0)
# define ProfEnd(...) (0)
# define ProfTick(...) (0)
# define ProfIsCapturing(...) (0)
# define ProfBeginCapture(...) (0)
# define ProfEndCapture(...) (0)
# define ProfThreadName(...) (0)
# define ProfMsg(...) (0)
# define ProfBeginLockWait(...) (0)
# define ProfEndLockWait(...) (0)
# define ProfLockTake(...) (0)
# define ProfLockDrop(...) (0)
# define ProfColor(...) (0)
#endif
////////////////////////////////
//~ rjf: Helper Wrappers
#define ProfBeginFunction(...) ProfBegin(this_function_name)
#define ProfScope(...) DeferLoop(ProfBeginDynamic(__VA_ARGS__), ProfEnd())
#endif // BASE_PROFILE_H
@@ -4,7 +4,7 @@
////////////////////////////////
//~ rjf: Third Party Includes
#if !SUPPLEMENT_UNIT
#if !BUILD_SUPPLEMENTARY_UNIT
# define STB_SPRINTF_IMPLEMENTATION
# define STB_SPRINTF_STATIC
# include "third_party/stb/stb_sprintf.h"
@@ -946,11 +946,11 @@ str8_array_from_list(Arena *arena, String8List *list)
{
String8Array array;
array.count = list->node_count;
array.strings = push_array_no_zero(arena, String8, array.count);
array.v = push_array_no_zero(arena, String8, array.count);
U64 idx = 0;
for(String8Node *n = list->first; n != 0; n = n->next, idx += 1)
{
array.strings[idx] = n->string;
array.v[idx] = n->string;
}
return array;
}
@@ -960,7 +960,7 @@ str8_array_reserve(Arena *arena, U64 count)
{
String8Array arr;
arr.count = 0;
arr.strings = push_array(arena, String8, count);
arr.v = push_array(arena, String8, count);
return arr;
}
@@ -1306,7 +1306,7 @@ utf8_encode(U8 *str, U32 codepoint){
inc = 3;
}
else if (codepoint <= 0x10FFFF){
str[0] = (bitmask4 << 3) | ((codepoint >> 18) & bitmask3);
str[0] = (bitmask4 << 4) | ((codepoint >> 18) & bitmask3);
str[1] = bit8 | ((codepoint >> 12) & bitmask6);
str[2] = bit8 | ((codepoint >> 6) & bitmask6);
str[3] = bit8 | ( codepoint & bitmask6);
@@ -1565,6 +1565,102 @@ string_from_elapsed_time(Arena *arena, DateTime dt){
return(result);
}
////////////////////////////////
//~ rjf: Basic Text Indentation
internal String8
indented_from_string(Arena *arena, String8 string)
{
Temp scratch = scratch_begin(&arena, 1);
read_only local_persist U8 indentation_bytes[] = " ";
String8List indented_strings = {0};
S64 depth = 0;
S64 next_depth = 0;
U64 line_begin_off = 0;
for(U64 off = 0; off <= string.size; off += 1)
{
U8 byte = off<string.size ? string.str[off] : 0;
switch(byte)
{
default:{}break;
case '{':case '[':case '(':{next_depth += 1; next_depth = Max(0, next_depth);}break;
case '}':case ']':case ')':{next_depth -= 1; next_depth = Max(0, next_depth); depth = next_depth;}break;
case '\n':
case 0:
{
String8 line = str8_skip_chop_whitespace(str8_substr(string, r1u64(line_begin_off, off)));
if(line.size != 0)
{
str8_list_pushf(scratch.arena, &indented_strings, "%.*s%S\n", (int)depth*2, indentation_bytes, line);
}
line_begin_off = off+1;
depth = next_depth;
}break;
}
}
String8 result = str8_list_join(arena, &indented_strings, 0);
scratch_end(scratch);
return result;
}
////////////////////////////////
//~ rjf: Text Wrapping
internal String8List
wrapped_lines_from_string(Arena *arena, String8 string, U64 first_line_max_width, U64 max_width, U64 wrap_indent)
{
String8List list = {0};
Rng1U64 line_range = r1u64(0, 0);
U64 wrapped_indent_level = 0;
static char *spaces = " ";
for (U64 idx = 0; idx <= string.size; idx += 1){
U8 chr = idx < string.size ? string.str[idx] : 0;
if (chr == '\n'){
Rng1U64 candidate_line_range = line_range;
candidate_line_range.max = idx;
// NOTE(nick): when wrapping is interrupted with \n we emit a string without including \n
// because later tool_fprint_list inserts separator after each node
// except for last node, so don't strip last \n.
if (idx + 1 == string.size){
candidate_line_range.max += 1;
}
String8 substr = str8_substr(string, candidate_line_range);
str8_list_push(arena, &list, substr);
line_range = r1u64(idx+1,idx+1);
}
else
if (char_is_space(chr) || chr == 0){
Rng1U64 candidate_line_range = line_range;
candidate_line_range.max = idx;
String8 substr = str8_substr(string, candidate_line_range);
U64 width_this_line = max_width-wrapped_indent_level;
if (list.node_count == 0){
width_this_line = first_line_max_width;
}
if (substr.size > width_this_line){
String8 line = str8_substr(string, line_range);
if (wrapped_indent_level > 0){
line = push_str8f(arena, "%.*s%S", wrapped_indent_level, spaces, line);
}
str8_list_push(arena, &list, line);
line_range = r1u64(line_range.max+1, candidate_line_range.max);
wrapped_indent_level = ClampTop(64, wrap_indent);
}
else{
line_range = candidate_line_range;
}
}
}
if (line_range.min < string.size && line_range.max > line_range.min){
String8 line = str8_substr(string, line_range);
if (wrapped_indent_level > 0){
line = push_str8f(arena, "%.*s%S", wrapped_indent_level, spaces, line);
}
str8_list_push(arena, &list, line);
}
return list;
}
////////////////////////////////
//~ rjf: String <-> Color
@@ -1,8 +1,8 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef BASE_STRING_H
#define BASE_STRING_H
#ifndef BASE_STRINGS_H
#define BASE_STRINGS_H
////////////////////////////////
//~ rjf: Third Party Includes
@@ -63,7 +63,7 @@ struct String8List
typedef struct String8Array String8Array;
struct String8Array
{
String8 *strings;
String8 *v;
U64 count;
};
@@ -326,6 +326,16 @@ internal String8 push_date_time_string(Arena *arena, DateTime *date_time);
internal String8 push_file_name_date_time_string(Arena *arena, DateTime *date_time);
internal String8 string_from_elapsed_time(Arena *arena, DateTime dt);
////////////////////////////////
//~ rjf: Basic Text Indentation
internal String8 indented_from_string(Arena *arena, String8 string);
////////////////////////////////
//~ rjf: Text Wrapping
internal String8List wrapped_lines_from_string(Arena *arena, String8 string, U64 first_line_max_width, U64 max_width, U64 wrap_indent);
////////////////////////////////
//~ rjf: String <-> Color
@@ -368,4 +378,4 @@ internal U64 str8_deserial_read_block(String8 string, U64 off, U64 size, Stri
#define str8_deserial_read_array(string, off, ptr, count) str8_deserial_read((string), (off), (ptr), sizeof(*(ptr))*(count), sizeof(*(ptr)))
#define str8_deserial_read_struct(string, off, ptr) str8_deserial_read((string), (off), (ptr), sizeof(*(ptr)), sizeof(*(ptr)))
#endif // BASE_STRING_H
#endif // BASE_STRINGS_H
+10 -1
View File
@@ -5,7 +5,7 @@
// NOTE(allen): Thread Context Functions
C_LINKAGE thread_static TCTX* tctx_thread_local;
#if !SUPPLEMENT_UNIT
#if !BUILD_SUPPLEMENTARY_UNIT
C_LINKAGE thread_static TCTX* tctx_thread_local = 0;
#endif
@@ -19,6 +19,15 @@ tctx_init_and_equip(TCTX *tctx){
tctx_thread_local = tctx;
}
internal void
tctx_release(void)
{
for(U64 i = 0; i < ArrayCount(tctx_thread_local->arenas); i += 1)
{
arena_release(tctx_thread_local->arenas[i]);
}
}
internal TCTX*
tctx_get_equipped(void){
return(tctx_thread_local);
+1
View File
@@ -23,6 +23,7 @@ struct TCTX
// NOTE(allen): Thread Context Functions
internal void tctx_init_and_equip(TCTX *tctx);
internal void tctx_release(void);
internal TCTX* tctx_get_equipped(void);
internal Arena* tctx_get_scratch(Arena **conflicts, U64 count);
+638
View File
@@ -0,0 +1,638 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ Generated Code
#include "generated/codeview.meta.c"
////////////////////////////////
//~ CodeView Common Decoding Helper Functions
internal U64
cv_hash_from_string(String8 string)
{
U64 result = 5381;
for(U64 i = 0; i < string.size; i += 1)
{
result = ((result << 5) + result) + string.str[i];
}
return result;
}
internal U64
cv_hash_from_item_id(CV_ItemId item_id)
{
U64 result = cv_hash_from_string(str8_struct(&item_id));
return result;
}
internal CV_NumericParsed
cv_numeric_from_data_range(U8 *first, U8 *opl)
{
CV_NumericParsed result = {0};
if(first + 2 <= opl)
{
U16 x = *(U16*)first;
if(x < 0x8000)
{
result.kind = CV_NumericKind_USHORT;
result.val = first;
result.encoded_size = 2;
}
else
{
U64 val_size = 0;
switch(x)
{
case CV_NumericKind_CHAR: val_size = 1; break;
case CV_NumericKind_SHORT:
case CV_NumericKind_USHORT: val_size = 2; break;
case CV_NumericKind_LONG:
case CV_NumericKind_ULONG: val_size = 4; break;
case CV_NumericKind_FLOAT32: val_size = 4; break;
case CV_NumericKind_FLOAT64: val_size = 8; break;
case CV_NumericKind_FLOAT80: val_size = 10; break;
case CV_NumericKind_FLOAT128: val_size = 16; break;
case CV_NumericKind_QUADWORD:
case CV_NumericKind_UQUADWORD: val_size = 8; break;
case CV_NumericKind_FLOAT48: val_size = 6; break;
case CV_NumericKind_COMPLEX32: val_size = 8; break;
case CV_NumericKind_COMPLEX64: val_size = 16; break;
case CV_NumericKind_COMPLEX80: val_size = 20; break;
case CV_NumericKind_COMPLEX128:val_size = 32; break;
case CV_NumericKind_VARSTRING: val_size = 0; break; // TODO: ???
case CV_NumericKind_OCTWORD:
case CV_NumericKind_UOCTWORD: val_size = 16; break;
case CV_NumericKind_DECIMAL: val_size = 0; break; // TODO: ???
case CV_NumericKind_DATE: val_size = 0; break; // TODO: ???
case CV_NumericKind_UTF8STRING:val_size = 0; break; // TODO: ???
case CV_NumericKind_FLOAT16: val_size = 2; break;
}
if(first + 2 + val_size <= opl)
{
result.kind = x;
result.val = (first + 2);
result.encoded_size = 2 + val_size;
}
}
}
return result;
}
internal B32
cv_numeric_fits_in_u64(CV_NumericParsed *num)
{
B32 result = 0;
switch(num->kind)
{
case CV_NumericKind_USHORT:
case CV_NumericKind_ULONG:
case CV_NumericKind_UQUADWORD:
{
result = 1;
}break;
}
return result;
}
internal B32
cv_numeric_fits_in_s64(CV_NumericParsed *num)
{
B32 result = 0;
switch(num->kind)
{
case CV_NumericKind_CHAR:
case CV_NumericKind_SHORT:
case CV_NumericKind_LONG:
case CV_NumericKind_QUADWORD:
{
result = 1;
}break;
}
return result;
}
internal B32
cv_numeric_fits_in_f64(CV_NumericParsed *num)
{
B32 result = 0;
switch(num->kind)
{
case CV_NumericKind_FLOAT32:
case CV_NumericKind_FLOAT64:
{
result = 1;
}break;
}
return result;
}
internal U64
cv_u64_from_numeric(CV_NumericParsed *num)
{
U64 result = 0;
switch(num->kind)
{
case CV_NumericKind_USHORT: {result = *(U16*)num->val;}break;
case CV_NumericKind_ULONG: {result = *(U32*)num->val;}break;
case CV_NumericKind_UQUADWORD:{result = *(U64*)num->val;}break;
}
return result;
}
internal S64
cv_s64_from_numeric(CV_NumericParsed *num)
{
S64 result = 0;
switch(num->kind)
{
case CV_NumericKind_CHAR: {result = *(S8*)num->val;}break;
case CV_NumericKind_SHORT: {result = *(S16*)num->val;}break;
case CV_NumericKind_LONG: {result = *(S32*)num->val;}break;
case CV_NumericKind_QUADWORD: {result = *(S64*)num->val;}break;
}
return(result);
}
internal F64
cv_f64_from_numeric(CV_NumericParsed *num)
{
F64 result = 0;
switch(num->kind)
{
case CV_NumericKind_FLOAT32:{result = *(F32*)num->val;}break;
case CV_NumericKind_FLOAT64:{result = *(F64*)num->val;}break;
}
return(result);
}
internal U64
cv_decode_inline_annot_u32(String8 data, U64 offset, U32 *out_value)
{
U64 cursor = offset;
// rjf: read header
U8 header = 0;
cursor += str8_deserial_read_struct(data, cursor, &header);
// rjf: decode value
U32 value = 0;
{
// 1 byte
if((header & 0x80) == 0)
{
value = header;
}
// 2 bytes
else if((header & 0xC0) == 0x80 && cursor+2 <= data.size)
{
U8 second_byte;
cursor += str8_deserial_read_struct(data, cursor, &second_byte);
value = ((header & 0x3F) << 8) | second_byte;
}
// 4 bytes
else if((header & 0xE0) == 0xC0 && cursor+3 <= data.size)
{
U8 second_byte, third_byte, fourth_byte;
cursor += str8_deserial_read_struct(data, cursor, &second_byte);
cursor += str8_deserial_read_struct(data, cursor, &third_byte);
cursor += str8_deserial_read_struct(data, cursor, &fourth_byte);
value = (((U32)header & 0x1F) << 24) | ((U32)second_byte << 16) | ((U32)third_byte << 8) | (U32)fourth_byte;
}
// bad encode
else if((header & 0xE0) == 0xE0)
{
value = max_U32;
}
}
// rjf: output results
if(out_value)
{
*out_value = value;
}
U64 read_size = cursor - offset;
return read_size;
}
internal U64
cv_decode_inline_annot_s32(String8 data, U64 offset, S32 *out_value)
{
U32 value;
U64 read_size = cv_decode_inline_annot_u32(data, offset, &value);
if(value & 1)
{
value = -(value >> 1);
}
else
{
value = value >> 1;
}
*out_value = (S32)value;
return read_size;
}
internal S32
cv_inline_annot_signed_from_unsigned_operand(U32 value)
{
if(value & 1)
{
value = -(value >> 1);
}
else
{
value = value >> 1;
}
S32 result = (S32)value;
return result;
}
////////////////////////////////
//~ CodeView Parsing Functions
//- rjf: record range stream parsing
internal CV_RecRangeStream*
cv_rec_range_stream_from_data(Arena *arena, String8 sym_data, U64 sym_align)
{
Assert(1 <= sym_align && IsPow2OrZero(sym_align));
CV_RecRangeStream *result = push_array(arena, CV_RecRangeStream, 1);
U8 *data = sym_data.str;
U64 cursor = 0;
U64 cap = sym_data.size;
for(;cursor + sizeof(CV_RecHeader) <= cap;)
{
// setup a new chunk
arena_push_align(arena, 64);
CV_RecRangeChunk *cur_chunk = push_array_no_zero(arena, CV_RecRangeChunk, 1);
SLLQueuePush(result->first_chunk, result->last_chunk, cur_chunk);
U64 partial_count = 0;
for(;partial_count < CV_REC_RANGE_CHUNK_SIZE && cursor + sizeof(CV_RecHeader) <= cap; partial_count += 1)
{
// compute cap
CV_RecHeader *hdr = (CV_RecHeader*)(data + cursor);
U64 symbol_cap_unclamped = cursor + 2 + hdr->size;
U64 symbol_cap = ClampTop(symbol_cap_unclamped, cap);
// push on range
cur_chunk->ranges[partial_count].off = cursor + 2;
cur_chunk->ranges[partial_count].hdr = *hdr;
// update cursor
U32 next_pos = AlignPow2(symbol_cap, sym_align);
cursor = next_pos;
}
result->total_count += partial_count;
}
return result;
}
internal CV_RecRangeArray
cv_rec_range_array_from_stream(Arena *arena, CV_RecRangeStream *stream)
{
U64 total_count = stream->total_count;
CV_RecRange *ranges = push_array_no_zero(arena, CV_RecRange, total_count);
U64 idx = 0;
for(CV_RecRangeChunk *chunk = stream->first_chunk; chunk != 0; chunk = chunk->next)
{
U64 copy_count_raw = total_count - idx;
U64 copy_count = ClampTop(copy_count_raw, CV_REC_RANGE_CHUNK_SIZE);
MemoryCopy(ranges + idx, chunk->ranges, copy_count*sizeof(CV_RecRange));
idx += copy_count;
}
CV_RecRangeArray result = {0};
result.ranges = ranges;
result.count = total_count;
return result;
}
//- rjf: sym stream parsing
internal CV_SymParsed *
cv_sym_from_data(Arena *arena, String8 sym_data, U64 sym_align)
{
Assert(1 <= sym_align && IsPow2OrZero(sym_align));
ProfBeginFunction();
Temp scratch = scratch_begin(&arena, 1);
//- rjf: gather symbols
CV_RecRangeStream *stream = cv_rec_range_stream_from_data(scratch.arena, sym_data, sym_align);
//- rjf: convert to result, fill basics
CV_SymParsed *result = push_array(arena, CV_SymParsed, 1);
result->data = sym_data;
result->sym_align = sym_align;
result->sym_ranges = cv_rec_range_array_from_stream(arena, stream);
//- rjf: extract top-level-info
{
CV_RecRange *range = result->sym_ranges.ranges;
CV_RecRange *opl = range + result->sym_ranges.count;
for(;range < opl; range += 1)
{
U8 *first = sym_data.str + range->off + 2;
U64 cap = range->hdr.size - 2;
switch(range->hdr.kind)
{
case CV_SymKind_COMPILE:
if(sizeof(CV_SymCompile) <= cap)
{
CV_SymCompile *compile = (CV_SymCompile*)first;
String8 ver_str = str8_cstring_capped((char*)(compile + 1), (char *)(first + cap));
result->info.arch = compile->machine;
result->info.language = CV_CompileFlags_ExtractLanguage(compile->flags);;
result->info.compiler_name = ver_str;
}break;
case CV_SymKind_COMPILE2:
if(sizeof(CV_SymCompile2) <= cap)
{
CV_SymCompile2 *compile2 = (CV_SymCompile2*)first;
String8 ver_str = str8_cstring_capped((char*)(compile2 + 1), (char*)(first + cap));
String8 compiler_name = push_str8f(arena, "%.*s %u.%u.%u",
str8_varg(ver_str),
compile2->ver_major,
compile2->ver_minor,
compile2->ver_build);
result->info.arch = compile2->machine;
result->info.language = CV_Compile2Flags_ExtractLanguage(compile2->flags);;
result->info.compiler_name = compiler_name;
}break;
case CV_SymKind_COMPILE3:
if(sizeof(CV_SymCompile3) <= cap)
{
CV_SymCompile3 *compile3 = (CV_SymCompile3*)first;
String8 ver_str = str8_cstring_capped((char*)(compile3 + 1), (char *)(first + cap));
String8 compiler_name = push_str8f(arena, "%.*s %u.%u.%u",
str8_varg(ver_str),
compile3->ver_major,
compile3->ver_minor,
compile3->ver_build);
result->info.arch = compile3->machine;
result->info.language = CV_Compile3Flags_ExtractLanguage(compile3->flags);;
result->info.compiler_name = compiler_name;
}break;
}
}
}
scratch_end(scratch);
ProfEnd();
return result;
}
//- rjf: leaf stream parsing
internal CV_LeafParsed *
cv_leaf_from_data(Arena *arena, String8 leaf_data, CV_TypeId itype_first)
{
ProfBeginFunction();
Temp scratch = scratch_begin(&arena, 1);
// gather up symbols
CV_RecRangeStream *stream = cv_rec_range_stream_from_data(scratch.arena, leaf_data, 1);
// convert to result
CV_LeafParsed *result = push_array(arena, CV_LeafParsed, 1);
result->data = leaf_data;
result->itype_first = itype_first;
result->itype_opl = itype_first + stream->total_count;
result->leaf_ranges = cv_rec_range_array_from_stream(arena, stream);
scratch_end(scratch);
ProfEnd();
return result;
}
////////////////////////////////
//~ CodeView C13 Parser Functions
internal CV_C13Parsed *
cv_c13_parsed_from_data(Arena *arena, String8 c13_data, PDB_Strtbl *strtbl, PDB_CoffSectionArray *sections)
{
ProfBeginFunction();
//////////////////////////////
//- rjf: gather c13 sub-sections
//
CV_C13SubSectionNode *file_chksms = 0;
CV_C13SubSectionNode *first = 0;
CV_C13SubSectionNode *last = 0;
U64 count = 0;
{
U32 cursor = 0;
for(; cursor + sizeof(CV_C13SubSectionHeader) <= c13_data.size;)
{
// read header
CV_C13SubSectionHeader *hdr = (CV_C13SubSectionHeader*)(c13_data.str + cursor);
// get sub section info
U32 sub_section_off = cursor + sizeof(*hdr);
U32 sub_section_size_raw = hdr->size;
U32 after_sub_section_off_unclamped = sub_section_off + sub_section_size_raw;
U32 after_sub_section_off = ClampTop(after_sub_section_off_unclamped, c13_data.size);
U32 sub_section_size = after_sub_section_off - sub_section_off;
// emit sub section
if(!(hdr->kind & CV_C13SubSectionKind_IgnoreFlag))
{
CV_C13SubSectionNode *node = push_array(arena, CV_C13SubSectionNode, 1);
SLLQueuePush(first, last, node);
count += 1;
node->kind = hdr->kind;
node->off = sub_section_off;
node->size = sub_section_size;
if(hdr->kind == CV_C13SubSectionKind_FileChksms)
{
file_chksms = node;
}
}
// move cursor
cursor = AlignPow2(after_sub_section_off, 4);
}
}
//////////////////////////////
//- rjf: parse each sub-section
//
U64 inlinee_lines_parsed_slots_count = 4096;
CV_C13InlineeLinesParsedNode **inlinee_lines_parsed_slots = push_array(arena, CV_C13InlineeLinesParsedNode *, inlinee_lines_parsed_slots_count);
for(CV_C13SubSectionNode *node = first;
node != 0;
node = node->next)
{
U8 *first = c13_data.str + node->off;
U32 cap = node->size;
switch(node->kind)
{
default:{}break;
//////////////////////////
//- rjf: line info sub-section
//
case CV_C13SubSectionKind_Lines:
if(sizeof(CV_C13SubSecLinesHeader) <= cap)
{
// read header
U32 read_off = 0;
U64 read_off_opl = node->size;
CV_C13SubSecLinesHeader *hdr = (CV_C13SubSecLinesHeader*)(first + read_off);
read_off += sizeof(*hdr);
// extract top level info
U32 sec_idx = hdr->sec;
B32 has_cols = !!(hdr->flags & CV_C13SubSecLinesFlag_HasColumns);
U64 secrel_off = hdr->sec_off;
U64 secrel_opl = secrel_off + hdr->len;
U64 sec_base_off = sections->sections[sec_idx - 1].voff;
// rjf: bad section index -> skip
if(sec_idx < 1 || sections->count < sec_idx)
{
continue;
}
// read files
for(;read_off+sizeof(CV_C13File) <= read_off_opl;)
{
// rjf: grab next file header
CV_C13File *file = (CV_C13File*)(first + read_off);
U32 file_off = file->file_off;
U32 line_count_unclamped = file->num_lines;
U32 block_size = file->block_size;
// file_name from file_off
String8 file_name = {0};
if(file_off + sizeof(CV_C13Checksum) <= file_chksms->size)
{
CV_C13Checksum *checksum = (CV_C13Checksum*)(c13_data.str + file_chksms->off + file_off);
U32 name_off = checksum->name_off;
file_name = pdb_strtbl_string_from_off(strtbl, name_off);
}
// array layouts
U32 line_item_size = sizeof(CV_C13Line);
if (has_cols){
line_item_size += sizeof(CV_C13Column);
}
U32 line_array_off = read_off + sizeof(*file);
U32 line_count_max = (read_off_opl - line_array_off) / line_item_size;
U32 line_count = ClampTop(line_count_unclamped, line_count_max);
U32 col_array_off = line_array_off + line_count*sizeof(CV_C13Line);
// parse lines
U64 *voffs = push_array_no_zero(arena, U64, line_count + 1);
U32 *line_nums = push_array_no_zero(arena, U32, line_count);
{
CV_C13Line *line_ptr = (CV_C13Line*)(first + line_array_off);
CV_C13Line *line_opl = line_ptr + line_count;
// TODO(allen): check order correctness here
U32 i = 0;
for (; line_ptr < line_opl; line_ptr += 1, i += 1){
voffs[i] = line_ptr->off + secrel_off + sec_base_off;
line_nums[i] = CV_C13LineFlags_ExtractLineNumber(line_ptr->flags);
}
voffs[i] = secrel_opl + sec_base_off;
}
// emit parsed lines
CV_C13LinesParsedNode *lines_parsed_node = push_array(arena, CV_C13LinesParsedNode, 1);
CV_C13LinesParsed *lines_parsed = &lines_parsed_node->v;
lines_parsed->sec_idx = sec_idx;
lines_parsed->file_off = file_off;
lines_parsed->secrel_base_off = secrel_off;
lines_parsed->file_name = file_name;
lines_parsed->voffs = voffs;
lines_parsed->line_nums = line_nums;
lines_parsed->line_count = line_count;
SLLQueuePush(node->lines_first, node->lines_last, lines_parsed_node);
// rjf: advance
read_off += sizeof(*file);
read_off += line_item_size*line_count;
}
}break;
//////////////////////////
//- rjf: inlinee line info sub-section
//
case CV_C13SubSectionKind_InlineeLines:
if(sizeof(CV_C13InlineeLinesSig) <= cap)
{
// rjf: read sig
U32 read_off = 0;
U64 read_off_opl = node->size;
CV_C13InlineeLinesSig *sig = (CV_C13InlineeLinesSig *)(first + read_off);
read_off += sizeof(*sig);
// rjf: read source lines
for(;read_off + sizeof(CV_C13InlineeSourceLineHeader) <= read_off_opl;)
{
// rjf: read next header
CV_C13InlineeSourceLineHeader *hdr = (CV_C13InlineeSourceLineHeader *)(first + read_off);
read_off += sizeof(*hdr);
// rjf: file_off -> file_name
String8 file_name = {0};
if(hdr->file_off + sizeof(CV_C13Checksum) <= file_chksms->size)
{
CV_C13Checksum *checksum = (CV_C13Checksum*)(c13_data.str + file_chksms->off + hdr->file_off);
U32 name_off = checksum->name_off;
file_name = pdb_strtbl_string_from_off(strtbl, name_off);
}
// rjf: parse extra files
U32 extra_file_count = 0;
U32 *extra_files = 0;
if(*sig == CV_C13InlineeLinesSig_EXTRA_FILES && read_off+sizeof(U32) <= read_off_opl)
{
U32 *extra_file_count_ptr = (U32 *)(first + read_off);
read_off += sizeof(*extra_file_count_ptr);
U32 max_extra_file_count = (read_off_opl-read_off)/sizeof(U32);
extra_file_count = Min(*extra_file_count_ptr, max_extra_file_count);
extra_files = (U32 *)(first + read_off);
read_off += sizeof(*extra_files)*extra_file_count;
}
// rjf: push node for this inlinee lines parsed into this subsection's list
CV_C13InlineeLinesParsedNode *n = push_array(arena, CV_C13InlineeLinesParsedNode, 1);
SLLQueuePush(node->inlinee_lines_first, node->inlinee_lines_last, n);
n->v.inlinee = hdr->inlinee;
n->v.file_name = file_name;
n->v.first_source_ln = hdr->first_source_ln;
n->v.extra_file_count = extra_file_count;
n->v.extra_files = extra_files;
// rjf: push node into inlinee parse hash table
U64 hash = cv_hash_from_item_id(hdr->inlinee);
U64 slot_idx = hash%inlinee_lines_parsed_slots_count;
SLLStackPush_N(inlinee_lines_parsed_slots[slot_idx], n, hash_next);
}
}break;
}
}
//////////////////////////////
//- rjf: fill output
//
CV_C13Parsed *result = push_array(arena, CV_C13Parsed, 1);
result->data = c13_data;
result->first_sub_section = first;
result->last_sub_section = last;
result->sub_section_count = count;
result->file_chksms_sub_section = file_chksms;
result->inlinee_lines_parsed_slots = inlinee_lines_parsed_slots;
result->inlinee_lines_parsed_slots_count = inlinee_lines_parsed_slots_count;
ProfEnd();
return result;
}
File diff suppressed because it is too large Load Diff
+622
View File
@@ -0,0 +1,622 @@
////////////////////////////////
//~ rjf: CV Numerics
@table(name val)
CV_NumericKindTable:
{
{CHAR 0x8000}
{SHORT 0x8001}
{USHORT 0x8002}
{LONG 0x8003}
{ULONG 0x8004}
{FLOAT32 0x8005}
{FLOAT64 0x8006}
{FLOAT80 0x8007}
{FLOAT128 0x8008}
{QUADWORD 0x8009}
{UQUADWORD 0x800a}
{FLOAT48 0x800b}
{COMPLEX32 0x800c}
{COMPLEX64 0x800d}
{COMPLEX80 0x800e}
{COMPLEX128 0x800f}
{VARSTRING 0x8010}
{OCTWORD 0x8017}
{UOCTWORD 0x8018}
{DECIMAL 0x8019}
{DATE 0x801a}
{UTF8STRING 0x801b}
{FLOAT16 0x801c}
}
@enum(U16) CV_NumericKind:
{
@expand(CV_NumericKindTable a) `$(a.name) = $(a.val)`
}
@enum2string_switch(CV_NumericKind)
cv_string_from_numeric_kind:
{
@expand(CV_NumericKindTable a) `case CV_NumericKind_$(a.name):{result = str8_lit("$(a.name)");}break`;
}
////////////////////////////////
//~ rjf: CV Architectures
@table(name val)
CV_ArchTable:
{
{8080 0x00}
{8086 0x01}
{80286 0x02}
{80386 0x03}
{80486 0x04}
{PENTIUM 0x05}
{PENTIUMII 0x06}
{PENTIUMIII 0x07}
{MIPS 0x10}
{MIPS16 0x11}
{MIPS32 0x12}
{MIPS64 0x13}
{MIPSI 0x14}
{MIPSII 0x15}
{MIPSIII 0x16}
{MIPSIV 0x17}
{MIPSV 0x18}
{M68000 0x20}
{M68010 0x21}
{M68020 0x22}
{M68030 0x23}
{M68040 0x24}
{ALPHA 0x30}
{ALPHA_21164 0x31}
{ALPHA_21164A 0x32}
{ALPHA_21264 0x33}
{ALPHA_21364 0x34}
{PPC601 0x40}
{PPC603 0x41}
{PPC604 0x42}
{PPC620 0x43}
{PPCFP 0x44}
{PPCBE 0x45}
{SH3 0x50}
{SH3E 0x51}
{SH3DSP 0x52}
{SH4 0x53}
{SHMEDIA 0x54}
{ARM3 0x60}
{ARM4 0x61}
{ARM4T 0x62}
{ARM5 0x63}
{ARM5T 0x64}
{ARM6 0x65}
{ARM_XMAC 0x66}
{ARM_WMMX 0x67}
{ARM7 0x68}
{OMNI 0x70}
{IA64_1 0x80}
{IA64_2 0x81}
{CEE 0x90}
{AM33 0xA0}
{M32R 0xB0}
{TRICORE 0xC0}
{X64 0xD0}
{EBC 0xE0}
{THUMB 0xF0}
{ARMNT 0xF4}
{ARM64 0xF6}
{D3D11_SHADER 0x100}
}
@enum(U16) CV_Arch:
{
@expand(CV_ArchTable a) `$(a.name) = $(a.val)`,
`IA64 = CV_Arch_IA64_1`,
`PENTIUMPRO = CV_Arch_PENTIUMII`,
`MIPSR4000 = CV_Arch_MIPS`,
`ALPHA_21064 = CV_Arch_ALPHA`,
`AMD64 = CV_Arch_X64`,
}
@enum2string_switch(CV_Arch)
cv_string_from_arch:
{
@expand(CV_ArchTable a) `case CV_Arch_$(a.name):{result = str8_lit("$(a.name)");}break`;
}
////////////////////////////////
//~ rjf: CV Registers
@table(name val) CV_AllRegTable:
{
{ERR 30000}
{TEB 30001}
{TIMER 30002}
{EFAD1 30003}
{EFAD2 30004}
{EFAD3 30005}
{VFRAME 30006}
{HANDLE 30007}
{PARAMS 30008}
{LOCALS 30009}
{TID 30010}
{ENV 30011}
{CMDLN 30012}
}
@enum(U16) CV_AllReg:
{
@expand(CV_AllRegTable a) `$(a.name) = $(a.val)`
}
////////////////////////////////
//~ rjf: CV Sym Kinds
@table(name header_type_name val) CV_SymKindTable:
{
{COMPILE Compile 0x0001}
{REGISTER_16t - 0x0002}
{CONSTANT_16t - 0x0003}
{UDT_16t - 0x0004}
{SSEARCH StartSearch 0x0005}
{END - 0x0006}
{SKIP - 0x0007}
{CVRESERVE - 0x0008}
{OBJNAME_ST - 0x0009}
{ENDARG - 0x000a}
{COBOLUDT_16t - 0x000b}
{MANYREG_16t - 0x000c}
{RETURN Return 0x000d}
{ENTRYTHIS - 0x000e}
{BPREL16 - 0x0100}
{LDATA16 - 0x0101}
{GDATA16 - 0x0102}
{PUB16 - 0x0103}
{LPROC16 - 0x0104}
{GPROC16 - 0x0105}
{THUNK16 - 0x0106}
{BLOCK16 - 0x0107}
{WITH16 - 0x0108}
{LABEL16 - 0x0109}
{CEXMODEL16 - 0x010a}
{VFTABLE16 - 0x010b}
{REGREL16 - 0x010c}
{BPREL32_16t - 0x0200}
{LDATA32_16t - 0x0201}
{GDATA32_16t - 0x0202}
{PUB32_16t - 0x0203}
{LPROC32_16t - 0x0204}
{GPROC32_16t - 0x0205}
{THUNK32_ST - 0x0206}
{BLOCK32_ST - 0x0207}
{WITH32_ST - 0x0208}
{LABEL32_ST - 0x0209}
{CEXMODEL32 - 0x020a}
{VFTABLE32_16t - 0x020b}
{REGREL32_16t - 0x020c}
{LTHREAD32_16t - 0x020d}
{GTHREAD32_16t - 0x020e}
{SLINK32 SLink32 0x020f}
{LPROCMIPS_16t - 0x0300}
{GPROCMIPS_16t - 0x0301}
{PROCREF_ST - 0x0400}
{DATAREF_ST - 0x0401}
{ALIGN - 0x0402}
{LPROCREF_ST - 0x0403}
{OEM OEM 0x0404}
{TI16_MAX - 0x1000}
{CONSTANT_ST - 0x1002}
{UDT_ST - 0x1003}
{COBOLUDT_ST - 0x1004}
{MANYREG_ST - 0x1005}
{BPREL32_ST - 0x1006}
{LDATA32_ST - 0x1007}
{GDATA32_ST - 0x1008}
{PUB32_ST - 0x1009}
{LPROC32_ST - 0x100a}
{GPROC32_ST - 0x100b}
{VFTABLE32 VPath32 0x100c}
{REGREL32_ST - 0x100d}
{LTHREAD32_ST - 0x100e}
{GTHREAD32_ST - 0x100f}
{LPROCMIPS_ST - 0x1010}
{GPROCMIPS_ST - 0x1011}
{FRAMEPROC Frameproc 0x1012}
{COMPILE2_ST - 0x1013}
{MANYREG2_ST - 0x1014}
{LPROCIA64_ST - 0x1015}
{GPROCIA64_ST - 0x1016}
{LOCALSLOT_ST - 0x1017}
{PARAMSLOT_ST - 0x1018}
{ANNOTATION Annotation 0x1019}
{GMANPROC_ST - 0x101a}
{LMANPROC_ST - 0x101b}
{RESERVED1 - 0x101c}
{RESERVED2 - 0x101d}
{RESERVED3 - 0x101e}
{RESERVED4 - 0x101f}
{LMANDATA_ST - 0x1020}
{GMANDATA_ST - 0x1021}
{MANFRAMEREL_ST - 0x1022}
{MANREGISTER_ST - 0x1023}
{MANSLOT_ST - 0x1024}
{MANMANYREG_ST - 0x1025}
{MANREGREL_ST - 0x1026}
{MANMANYREG2_ST - 0x1027}
{MANTYPREF - 0x1028}
{UNAMESPACE_ST - 0x1029}
{ST_MAX - 0x1100}
{OBJNAME Objname 0x1101}
{THUNK32 Thunk32 0x1102}
{BLOCK32 Block32 0x1103}
{WITH32 - 0x1104}
{LABEL32 Label32 0x1105}
{REGISTER Register 0x1106}
{CONSTANT Constant 0x1107}
{UDT UDT 0x1108}
{COBOLUDT - 0x1109}
{MANYREG Manyreg 0x110a}
{BPREL32 BPRel32 0x110b}
{LDATA32 Data32 0x110c}
{GDATA32 Data32 0x110d}
{PUB32 Pub32 0x110e}
{LPROC32 Proc32 0x110f}
{GPROC32 Proc32 0x1110}
{REGREL32 Regrel32 0x1111}
{LTHREAD32 Thread32 0x1112}
{GTHREAD32 Thread32 0x1113}
{LPROCMIPS - 0x1114}
{GPROCMIPS - 0x1115}
{COMPILE2 Compile2 0x1116}
{MANYREG2 Manyreg2 0x1117}
{LPROCIA64 - 0x1118}
{GPROCIA64 - 0x1119}
{LOCALSLOT Slot 0x111a}
{PARAMSLOT - 0x111b}
{LMANDATA - 0x111c}
{GMANDATA - 0x111d}
{MANFRAMEREL AttrFrameRel 0x111e}
{MANREGISTER AttrReg 0x111f}
{MANSLOT - 0x1120}
{MANMANYREG AttrManyReg 0x1121}
{MANREGREL AttrRegRel 0x1122}
{MANMANYREG2 - 0x1123}
{UNAMESPACE UNamespace 0x1124}
{PROCREF Ref2 0x1125}
{DATAREF Ref2 0x1126}
{LPROCREF Ref2 0x1127}
{ANNOTATIONREF - 0x1128}
{TOKENREF - 0x1129}
{GMANPROC - 0x112a}
{LMANPROC - 0x112b}
{TRAMPOLINE Trampoline 0x112c}
{MANCONSTANT - 0x112d}
{ATTR_FRAMEREL AttrFrameRel 0x112e}
{ATTR_REGISTER AttrReg 0x112f}
{ATTR_REGREL AttrRegRel 0x1130}
{ATTR_MANYREG AttrManyReg 0x1131}
{SEPCODE Sepcode 0x1132}
{DEFRANGE_2005 - 0x1134}
{DEFRANGE2_2005 - 0x1135}
{SECTION Section 0x1136}
{COFFGROUP CoffGroup 0x1137}
{EXPORT Export 0x1138}
{CALLSITEINFO CallSiteInfo 0x1139}
{FRAMECOOKIE FrameCookie 0x113a}
{DISCARDED Discarded 0x113b}
{COMPILE3 Compile3 0x113c}
{ENVBLOCK EnvBlock 0x113d}
{LOCAL Local 0x113e}
{DEFRANGE - 0x113f}
{DEFRANGE_SUBFIELD DefrangeSubfield 0x1140}
{DEFRANGE_REGISTER DefrangeRegister 0x1141}
{DEFRANGE_FRAMEPOINTER_REL DefrangeFramepointerRel 0x1142}
{DEFRANGE_SUBFIELD_REGISTER DefrangeSubfieldRegister 0x1143}
{DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE DefrangeFramepointerRelFullScope 0x1144}
{DEFRANGE_REGISTER_REL DefrangeRegisterRel 0x1145}
{LPROC32_ID - 0x1146}
{GPROC32_ID - 0x1147}
{LPROCMIPS_ID - 0x1148}
{GPROCMIPS_ID - 0x1149}
{LPROCIA64_ID - 0x114a}
{GPROCIA64_ID - 0x114b}
{BUILDINFO BuildInfo 0x114c}
{INLINESITE InlineSite 0x114d}
{INLINESITE_END - 0x114e}
{PROC_ID_END - 0x114f}
{DEFRANGE_HLSL - 0x1150}
{GDATA_HLSL - 0x1151}
{LDATA_HLSL - 0x1152}
{FILESTATIC FileStatic 0x1153}
{LPROC32_DPC - 0x1155}
{LPROC32_DPC_ID - 0x1156}
{DEFRANGE_DPC_PTR_TAG - 0x1157}
{DPC_SYM_TAG_MAP - 0x1158}
{ARMSWITCHTABLE - 0x1159}
{CALLEES FunctionList 0x115a}
{CALLERS FunctionList 0x115b}
{POGODATA PogoInfo 0x115c}
{INLINESITE2 InlineSite2 0x115d}
{HEAPALLOCSITE HeapAllocSite 0x115e}
{MOD_TYPEREF ModTypeRef 0x115f}
{REF_MINIPDB RefMiniPdb 0x1160}
{PDBMAP - 0x1161}
{GDATA_HLSL32 - 0x1162}
{LDATA_HLSL32 - 0x1163}
{GDATA_HLSL32_EX - 0x1164}
{LDATA_HLSL32_EX - 0x1165}
{FASTLINK FastLink 0x1167}
{INLINEES Inlinees 0x1168}
}
@enum(U16) CV_SymKind:
{
@expand(CV_SymKindTable a) `$(a.name) = $(a.val)`
}
@enum2string_switch(CV_SymKind)
cv_string_from_sym_kind:
{
@expand(CV_SymKindTable a) `case CV_SymKind_$(a.name):{result = str8_lit("$(a.name)");}break`;
}
@gen(functions)
{
`internal U64 cv_header_struct_size_from_sym_kind(CV_SymKind v);`;
}
@gen(functions) @c_file
{
`internal U64`;
`cv_header_struct_size_from_sym_kind(CV_SymKind v)`;
`{`;
`U64 result = 0;`;
`switch(v)`;
`{`;
`default:{}break;`;
@expand(CV_SymKindTable a) `$(a.header_type_name != "-" -> "case CV_SymKind_"..a.name..":{result = sizeof(CV_Sym"..a.header_type_name..");}break;")`;
`}`;
`return result;`;
`}`;
}
////////////////////////////////
//~ rjf: CV Basic Types
@table(name val type_name)
CV_BasicTypeTable:
{
{NOTYPE 0x00 "" }
{ABS 0x01 "" }
{SEGMENT 0x02 "" }
{VOID 0x03 "void" }
{CURRENCY 0x04 "" }
{NBASICSTR 0x05 "" }
{FBASICSTR 0x06 "" }
{NOTTRANS 0x07 "" }
{HRESULT 0x08 "HRESULT" }
{CHAR 0x10 "char" }
{SHORT 0x11 "S16" }
{LONG 0x12 "S32" }
{QUAD 0x13 "S64" }
{OCT 0x14 "S128" }
{UCHAR 0x20 "UCHAR" }
{USHORT 0x21 "U16" }
{ULONG 0x22 "U32" }
{UQUAD 0x23 "U64" }
{UOCT 0x24 "U128" }
{BOOL8 0x30 "B8" }
{BOOL16 0x31 "B16" }
{BOOL32 0x32 "B32" }
{BOOL64 0x33 "B64" }
{FLOAT32 0x40 "F32" }
{FLOAT64 0x41 "F64" }
{FLOAT80 0x42 "F80" }
{FLOAT128 0x43 "F128" }
{FLOAT48 0x44 "F48" }
{FLOAT32PP 0x45 "F32PP" }
{FLOAT16 0x46 "F16" }
{COMPLEX32 0x50 "ComplexF32" }
{COMPLEX64 0x51 "ComplexF64" }
{COMPLEX80 0x52 "ComplexF80" }
{COMPLEX128 0x53 "ComplexF128" }
{BIT 0x60 "" }
{PASCHAR 0x61 "" }
{BOOL32FF 0x62 "B32FF" }
{INT8 0x68 "S8" }
{UINT8 0x69 "U8" }
{RCHAR 0x70 "char" }
{WCHAR 0x71 "WCHAR" }
{INT16 0x72 "S16" }
{UINT16 0x73 "U16" }
{INT32 0x74 "S32" }
{UINT32 0x75 "U32" }
{INT64 0x76 "S64" }
{UINT64 0x77 "U64" }
{INT128 0x78 "S128" }
{UINT128 0x79 "U128" }
{CHAR16 0x7a "CHAR16" }
{CHAR32 0x7b "CHAR32" }
{CHAR8 0x7c "char" }
{PTR 0xf0 "PTR" }
}
@enum(U8) CV_BasicType:
{
@expand(CV_BasicTypeTable a) `$(a.name) = $(a.val)`
}
@enum2string_switch(CV_BasicType) cv_string_from_basic_type:
{
@expand(CV_BasicTypeTable a) `case CV_BasicType_$(a.name):{result = str8_lit("$(a.name)");}break`
}
@enum2string_switch(CV_BasicType) cv_type_name_from_basic_type:
{
@expand(CV_BasicTypeTable a) `case CV_BasicType_$(a.name):{result = str8_lit("$(a.type_name)");}break`
}
////////////////////////////////
//~ rjf: CV Leaf Kinds
@table(name header_type_name val)
CV_LeafKindTable:
{
{MODIFIER_16t - 0x0001}
{POINTER_16t - 0x0002}
{ARRAY_16t - 0x0003}
{CLASS_16t - 0x0004}
{STRUCTURE_16t - 0x0005}
{UNION_16t - 0x0006}
{ENUM_16t - 0x0007}
{PROCEDURE_16t - 0x0008}
{MFUNCTION_16t - 0x0009}
{VTSHAPE VTShape 0x000a}
{COBOL0_16t - 0x000b}
{COBOL1 - 0x000c}
{BARRAY_16t - 0x000d}
{LABEL Label 0x000e}
{NULL - 0x000f}
{NOTTRAN - 0x0010}
{DIMARRAY_16t - 0x0011}
{VFTPATH_16t - 0x0012}
{PRECOMP_16t - 0x0013}
{ENDPRECOMP - 0x0014}
{OEM_16t - 0x0015}
{TYPESERVER_ST - 0x0016}
{SKIP_16t - 0x0200}
{ARGLIST_16t - 0x0201}
{DEFARG_16t - 0x0202}
{LIST - 0x0203}
{FIELDLIST_16t - 0x0204}
{DERIVED_16t - 0x0205}
{BITFIELD_16t - 0x0206}
{METHODLIST_16t - 0x0207}
{DIMCONU_16t - 0x0208}
{DIMCONLU_16t - 0x0209}
{DIMVARU_16t - 0x020a}
{DIMVARLU_16t - 0x020b}
{REFSYM - 0x020c}
{BCLASS_16t - 0x0400}
{VBCLASS_16t - 0x0401}
{IVBCLASS_16t - 0x0402}
{ENUMERATE_ST - 0x0403}
{FRIENDFCN_16t - 0x0404}
{INDEX_16t - 0x0405}
{MEMBER_16t - 0x0406}
{STMEMBER_16t - 0x0407}
{METHOD_16t - 0x0408}
{NESTTYPE_16t - 0x0409}
{VFUNCTAB_16t - 0x040a}
{FRIENDCLS_16t - 0x040b}
{ONEMETHOD_16t - 0x040c}
{VFUNCOFF_16t - 0x040d}
{TI16_MAX - 0x1000}
{MODIFIER Modifier 0x1001}
{POINTER Pointer 0x1002}
{ARRAY_ST - 0x1003}
{CLASS_ST - 0x1004}
{STRUCTURE_ST - 0x1005}
{UNION_ST - 0x1006}
{ENUM_ST - 0x1007}
{PROCEDURE Procedure 0x1008}
{MFUNCTION MFunction 0x1009}
{COBOL0 - 0x100a}
{BARRAY - 0x100b}
{DIMARRAY_ST - 0x100c}
{VFTPATH VFPath 0x100d}
{PRECOMP_ST - 0x100e}
{OEM - 0x100f}
{ALIAS_ST - 0x1010}
{OEM2 - 0x1011}
{SKIP Skip 0x1200}
{ARGLIST ArgList 0x1201}
{DEFARG_ST - 0x1202}
{FIELDLIST - 0x1203}
{DERIVED - 0x1204}
{BITFIELD BitField 0x1205}
{METHODLIST MethodListMember 0x1206}
{DIMCONU - 0x1207}
{DIMCONLU - 0x1208}
{DIMVARU - 0x1209}
{DIMVARLU - 0x120a}
{BCLASS BClass 0x1400}
{VBCLASS VBClass 0x1401}
{IVBCLASS - 0x1402}
{FRIENDFCN_ST - 0x1403}
{INDEX Index 0x1404}
{MEMBER_ST - 0x1405}
{STMEMBER_ST - 0x1406}
{METHOD_ST - 0x1407}
{NESTTYPE_ST - 0x1408}
{VFUNCTAB VFuncTab 0x1409}
{FRIENDCLS - 0x140a}
{ONEMETHOD_ST - 0x140b}
{VFUNCOFF VFuncOff 0x140c}
{NESTTYPEEX_ST - 0x140d}
{MEMBERMODIFY_ST - 0x140e}
{MANAGED_ST - 0x140f}
{ST_MAX - 0x1500}
{TYPESERVER TypeServer 0x1501}
{ENUMERATE Enumerate 0x1502}
{ARRAY Array 0x1503}
{CLASS Struct 0x1504}
{STRUCTURE Struct 0x1505}
{UNION Union 0x1506}
{ENUM Enum 0x1507}
{DIMARRAY - 0x1508}
{PRECOMP PreComp 0x1509}
{ALIAS Alias 0x150a}
{DEFARG - 0x150b}
{FRIENDFCN - 0x150c}
{MEMBER Member 0x150d}
{STMEMBER StMember 0x150e}
{METHOD Method 0x150f}
{NESTTYPE NestType 0x1510}
{ONEMETHOD OneMethod 0x1511}
{NESTTYPEEX NestTypeEx 0x1512}
{MEMBERMODIFY - 0x1513}
{MANAGED - 0x1514}
{TYPESERVER2 TypeServer2 0x1515}
{STRIDED_ARRAY - 0x1516}
{HLSL - 0x1517}
{MODIFIER_EX - 0x1518}
{INTERFACE Struct 0x1519}
{BINTERFACE - 0x151a}
{VECTOR - 0x151b}
{MATRIX - 0x151c}
{VFTABLE - 0x151d}
{CLASS2 Struct2 0x1608}
{STRUCT2 Struct2 0x1609}
}
@enum(U16) CV_LeafKind:
{
@expand(CV_LeafKindTable a) `$(a.name) = $(a.val)`;
}
@enum2string_switch(CV_LeafKind)
cv_string_from_leaf_kind:
{
@expand(CV_LeafKindTable a) `case CV_LeafKind_$(a.name):{result = str8_lit("$(a.name)");}break`;
}
@gen(functions)
{
`internal U64 cv_header_struct_size_from_leaf_kind(CV_LeafKind v);`;
}
@gen(functions) @c_file
{
`internal U64`;
`cv_header_struct_size_from_leaf_kind(CV_LeafKind v)`;
`{`;
`U64 result = 0;`;
`switch(v)`;
`{`;
`default:{}break;`;
@expand(CV_LeafKindTable a) `$(a.header_type_name != "-" -> "case CV_LeafKind_"..a.name..":{result = sizeof(CV_Leaf"..a.header_type_name..");}break;")`;
`}`;
`return result;`;
`}`;
}
@@ -4,7 +4,7 @@
////////////////////////////////
//~ CodeView Common Stringize Functions
static void
internal void
cv_stringize_numeric(Arena *arena, String8List *out, CV_NumericParsed *num){
String8 numeric_kind_str = cv_string_from_numeric_kind(num->kind);
str8_list_pushf(arena, out, "(%.*s)", str8_varg(numeric_kind_str));
@@ -23,17 +23,17 @@ cv_stringize_numeric(Arena *arena, String8List *out, CV_NumericParsed *num){
}
}
static void
internal void
cv_stringize_lvar_addr_range(Arena *arena, String8List *out, CV_LvarAddrRange *range){
str8_list_pushf(arena, out, "{off=%x, sec=%u, len=%u}", range->off, range->sec, range->len);
}
static void
internal void
cv_stringize_lvar_addr_gap(Arena *arena, String8List *out, CV_LvarAddrGap *gap){
str8_list_pushf(arena, out, "{off=%x, len=%u}", gap->off, gap->len);
}
static void
internal void
cv_stringize_lvar_addr_gap_list(Arena *arena, String8List *out, void *first, void *opl){
U64 gap_count = ((U8*)first - (U8*)opl)/sizeof(CV_LvarAddrGap);
if (gap_count > 0){
@@ -48,79 +48,19 @@ cv_stringize_lvar_addr_gap_list(Arena *arena, String8List *out, void *first, voi
}
}
static String8
cv_string_from_sym_kind(CV_SymKind kind){
String8 result = str8_lit("UNRECOGNIZED_SYM_KIND");
switch (kind){
#define X(N,c) case CV_SymKind_##N: result = str8_lit(#N); break;
CV_SymKindXList(X)
#undef X
}
return(result);
}
static String8
cv_string_from_basic_type(CV_BasicType basic_type){
String8 result = str8_lit("UNRECOGNIZED_BASIC_TYPE");
switch (basic_type){
#define X(N,c) case CV_BasicType_##N: result = str8_lit(#N); break;
CV_BasicTypeXList(X)
#undef X
}
return(result);
}
static String8
cv_string_from_leaf_kind(CV_LeafKind kind){
String8 result = str8_lit("UNRECOGNIZED_LEAF_KIND");
switch (kind){
#define X(N,c) case CV_LeafKind_##N: result = str8_lit(#N); break;
CV_LeafKindXList(X)
#undef X
#define X(N,c) case CV_LeafIDKind_##N: result = str8_lit(#N); break;
CV_LeafIDKindXList(X)
#undef X
}
return(result);
}
static String8
cv_string_from_numeric_kind(CV_NumericKind kind){
String8 result = str8_lit("UNRECOGNIZED_NUMERIC_KIND");
switch (kind){
case 0: str8_lit("PARSE_ERROR"); break;
#define X(N,c) case CV_NumericKind_##N: result = str8_lit(#N); break;
CV_NumericKindXList(X)
#undef X
}
return(result);
}
static String8
cv_string_from_c13_sub_section_kind(CV_C13_SubSectionKind kind){
internal String8
cv_string_from_c13_sub_section_kind(CV_C13SubSectionKind kind){
String8 result = str8_lit("UNRECOGNIZED_C13_SUB_SECTION_KIND");
switch (kind){
case 0: str8_lit("PARSE_ERROR"); break;
#define X(N,c) case CV_C13_SubSectionKind_##N: result = str8_lit(#N); break;
CV_C13_SubSectionKindXList(X)
#define X(N,c) case CV_C13SubSectionKind_##N: result = str8_lit(#N); break;
CV_C13SubSectionKindXList(X)
#undef X
}
return(result);
}
static String8
cv_string_from_machine(CV_Arch arch){
String8 result = {0};
switch (arch){
#define X(N,c) case CV_Arch_##N: result = str8_lit(#N); break;
CV_ArchXList(X)
#undef X
}
return(result);
}
static String8
internal String8
cv_string_from_reg(CV_Arch arch, CV_Reg reg){
String8 result = {0};
switch (arch){
@@ -147,7 +87,7 @@ cv_string_from_reg(CV_Arch arch, CV_Reg reg){
return(result);
}
static String8
internal String8
cv_string_from_pointer_kind(CV_PointerKind ptr_kind){
String8 result = {0};
switch (ptr_kind){
@@ -169,7 +109,7 @@ cv_string_from_pointer_kind(CV_PointerKind ptr_kind){
return(result);
}
static String8
internal String8
cv_string_from_pointer_mode(CV_PointerMode ptr_mode){
String8 result = {0};
switch (ptr_mode){
@@ -183,7 +123,7 @@ cv_string_from_pointer_mode(CV_PointerMode ptr_mode){
return(result);
}
static String8
internal String8
cv_string_from_hfa_kind(CV_HFAKind hfa_kind){
String8 result = {0};
switch (hfa_kind){
@@ -196,7 +136,7 @@ cv_string_from_hfa_kind(CV_HFAKind hfa_kind){
return(result);
}
static String8
internal String8
cv_string_from_mo_com_udt_kind(CV_MoComUDTKind mo_com_udt_kind){
String8 result = {0};
switch (mo_com_udt_kind){
@@ -212,11 +152,11 @@ cv_string_from_mo_com_udt_kind(CV_MoComUDTKind mo_com_udt_kind){
////////////////////////////////
//~ CodeView Flags Stringize Functions
static char cv_stringize_spaces[] = " ";
global char cv_stringize_spaces[] = " ";
#define SPACES cv_stringize_spaces
static void
internal void
cv_stringize_modifier_flags(Arena *arena, String8List *out,
U32 indent, CV_ModifierFlags flags){
if (flags & CV_ModifierFlag_Const){
@@ -230,7 +170,7 @@ cv_stringize_modifier_flags(Arena *arena, String8List *out,
}
}
static void
internal void
cv_stringize_type_props(Arena *arena, String8List *out,
U32 indent, CV_TypeProps props){
if (props & CV_TypeProp_Packed){
@@ -285,7 +225,7 @@ cv_stringize_type_props(Arena *arena, String8List *out,
}
}
static void
internal void
cv_stringize_pointer_attribs(Arena *arena, String8List *out,
U32 indent, CV_PointerAttribs attribs){
if (attribs & CV_PointerAttrib_IsFlat){
@@ -332,7 +272,7 @@ cv_stringize_pointer_attribs(Arena *arena, String8List *out,
indent, SPACES, size);
}
static void
internal void
cv_stringize_local_flags(Arena *arena, String8List *out,
U32 indent, CV_LocalFlags flags){
if (flags & CV_LocalFlag_Param){
@@ -376,7 +316,7 @@ cv_stringize_local_flags(Arena *arena, String8List *out,
////////////////////////////////
//~ CodeView Sym Stringize Functions
static void
internal void
cv_stringize_sym_parsed(Arena *arena, String8List *out, CV_SymParsed *sym){
CV_StringizeSymParams params = {0};
params.arch = sym->info.arch;
@@ -384,7 +324,7 @@ cv_stringize_sym_parsed(Arena *arena, String8List *out, CV_SymParsed *sym){
cv_stringize_sym_array(arena, out, &sym->sym_ranges, sym->data, &params);
}
static void
internal void
cv_stringize_sym_range(Arena *arena, String8List *out,
CV_RecRange *range, String8 data,
CV_StringizeSymParams *p){
@@ -417,7 +357,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out,
CV_SymCompile *compile = (CV_SymCompile*)first;
// machine
String8 machine = cv_string_from_machine(compile->machine);
String8 machine = cv_string_from_arch(compile->machine);
str8_list_pushf(arena, out, " machine=%.*s\n",
str8_varg(machine));
@@ -742,7 +682,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out,
str8_list_pushf(arena, out, " flags=%x\n", compile2->flags);
// machine
String8 machine = cv_string_from_machine(compile2->machine);
String8 machine = cv_string_from_arch(compile2->machine);
str8_list_pushf(arena, out, " machine=%.*s\n",
str8_varg(machine));
@@ -906,7 +846,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out,
str8_list_pushf(arena, out, " flags=%x\n", compile3->flags);
// machine
String8 machine = cv_string_from_machine(compile3->machine);
String8 machine = cv_string_from_arch(compile3->machine);
str8_list_pushf(arena, out, " machine=%.*s\n",
str8_varg(machine));
@@ -1381,7 +1321,7 @@ cv_stringize_sym_range(Arena *arena, String8List *out,
}
}
static void
internal void
cv_stringize_sym_array(Arena *arena, String8List *out,
CV_RecRangeArray *ranges, String8 data,
CV_StringizeSymParams *p){
@@ -1396,7 +1336,7 @@ cv_stringize_sym_array(Arena *arena, String8List *out,
////////////////////////////////
//~ CodeView Leaf Stringize Functions
static void
internal void
cv_stringize_leaf_parsed(Arena *arena, String8List *out, CV_LeafParsed *leaf){
CV_StringizeLeafParams params = {0};
@@ -1404,7 +1344,7 @@ cv_stringize_leaf_parsed(Arena *arena, String8List *out, CV_LeafParsed *leaf){
leaf->data, &params);
}
static void
internal void
cv_stringize_leaf_range(Arena *arena, String8List *out,
CV_RecRange *range, CV_TypeId itype, String8 data,
CV_StringizeLeafParams *p){
@@ -2312,7 +2252,7 @@ cv_stringize_leaf_range(Arena *arena, String8List *out,
}
}
static void
internal void
cv_stringize_leaf_array(Arena *arena, String8List *out,
CV_RecRangeArray *ranges, CV_TypeId itype_first, String8 data,
CV_StringizeLeafParams *p){
@@ -2328,23 +2268,28 @@ cv_stringize_leaf_array(Arena *arena, String8List *out,
////////////////////////////////
//~ CodeView C13 Stringize Functions
static void
internal void
cv_stringize_c13_parsed(Arena *arena, String8List *out, CV_C13Parsed *c13){
for (CV_C13SubSectionNode *node = c13->first_sub_section;
for(CV_C13SubSectionNode *node = c13->first_sub_section;
node != 0;
node = node->next){
node = node->next)
{
String8 kind_str = cv_string_from_c13_sub_section_kind(node->kind);
str8_list_pushf(arena, out, "C13 Sub Section [%llx] (%.*s):\n",
node->off, str8_varg(kind_str));
switch (node->kind){
case CV_C13_SubSectionKind_Lines:
switch(node->kind)
{
case CV_C13SubSectionKind_Lines:
{
if (node->lines_first == 0)
{
CV_C13LinesParsed *lines = node->lines;
if (lines == 0){
str8_list_push(arena, out, str8_lit(" failed to extract info\n"));
}
else{
else for(CV_C13LinesParsedNode *n = node->lines_first; n != 0; n = n->next)
{
CV_C13LinesParsed *lines = &n->v;
str8_list_pushf(arena, out, " section: %u\n", lines->sec_idx);
str8_list_pushf(arena, out, " file off: %u\n", lines->file_off);
str8_list_pushf(arena, out, " file name: %.*s\n", str8_varg(lines->file_name));
@@ -2364,12 +2309,12 @@ cv_stringize_c13_parsed(Arena *arena, String8List *out, CV_C13Parsed *c13){
}
}break;
case CV_C13_SubSectionKind_FileChksms:
case CV_C13SubSectionKind_FileChksms:
{
str8_list_push(arena, out, str8_lit(" no stringizer path\n"));
}break;
case CV_C13_SubSectionKind_InlineeLines:
case CV_C13SubSectionKind_InlineeLines:
{
str8_list_push(arena, out, str8_lit(" no stringizer path\n"));
}break;
+82
View File
@@ -0,0 +1,82 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef CODEVIEW_STRINGIZE_H
#define CODEVIEW_STRINGIZE_H
////////////////////////////////
//~ CodeView Stringize Helper Types
typedef struct CV_StringizeSymParams{
CV_Arch arch;
} CV_StringizeSymParams;
typedef struct CV_StringizeLeafParams{
U32 dummy;
} CV_StringizeLeafParams;
////////////////////////////////
//~ CodeView Common Stringize Functions
internal void cv_stringize_numeric(Arena *arena, String8List *out, CV_NumericParsed *num);
internal void cv_stringize_lvar_addr_range(Arena *arena, String8List *out,
CV_LvarAddrRange *range);
internal void cv_stringize_lvar_addr_gap(Arena *arena, String8List *out, CV_LvarAddrGap *gap);
internal void cv_stringize_lvar_addr_gap_list(Arena *arena, String8List *out,
void *first, void *opl);
internal String8 cv_string_from_basic_type(CV_BasicType basic_type);
internal String8 cv_string_from_c13_sub_section_kind(CV_C13SubSectionKind kind);
internal String8 cv_string_from_reg(CV_Arch arch, CV_Reg reg);
internal String8 cv_string_from_pointer_kind(CV_PointerKind ptr_kind);
internal String8 cv_string_from_pointer_mode(CV_PointerMode ptr_mode);
internal String8 cv_string_from_hfa_kind(CV_HFAKind hfa_kind);
internal String8 cv_string_from_mo_com_udt_kind(CV_MoComUDTKind mo_com_udt_kind);
////////////////////////////////
//~ CodeView Flags Stringize Functions
internal void cv_stringize_modifier_flags(Arena *arena, String8List *out,
U32 indent, CV_ModifierFlags flags);
internal void cv_stringize_type_props(Arena *arena, String8List *out,
U32 indent, CV_TypeProps props);
internal void cv_stringize_pointer_attribs(Arena *arena, String8List *out,
U32 indent, CV_PointerAttribs attribs);
internal void cv_stringize_local_flags(Arena *arena, String8List *out,
U32 indent, CV_LocalFlags flags);
////////////////////////////////
//~ CodeView Sym Stringize Functions
internal void cv_stringize_sym_parsed(Arena *arena, String8List *out, CV_SymParsed *sym);
internal void cv_stringize_sym_range(Arena *arena, String8List *out,
CV_RecRange *range, String8 data,
CV_StringizeSymParams *p);
internal void cv_stringize_sym_array(Arena *arena, String8List *out,
CV_RecRangeArray *ranges, String8 data,
CV_StringizeSymParams *p);
////////////////////////////////
//~ CodeView Leaf Stringize Functions
internal void cv_stringize_leaf_parsed(Arena *arena, String8List *out, CV_LeafParsed *leaf);
internal void cv_stringize_leaf_range(Arena *arena, String8List *out,
CV_RecRange *range, CV_TypeId itype, String8 data,
CV_StringizeLeafParams *p);
internal void cv_stringize_leaf_array(Arena *arena, String8List *out,
CV_RecRangeArray *ranges, CV_TypeId itype_first,
String8 data,
CV_StringizeLeafParams *p);
////////////////////////////////
//~ CodeView C13 Stringize Functions
internal void cv_stringize_c13_parsed(Arena *arena, String8List *out, CV_C13Parsed *c13);
#endif // CODEVIEW_STRINGIZE_H
+703
View File
@@ -0,0 +1,703 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
internal String8
cv_string_from_numeric_kind(CV_NumericKind v)
{
String8 result = str8_lit("<Unknown CV_NumericKind>");
switch(v)
{
default:{}break;
case CV_NumericKind_CHAR:{result = str8_lit("CHAR");}break;
case CV_NumericKind_SHORT:{result = str8_lit("SHORT");}break;
case CV_NumericKind_USHORT:{result = str8_lit("USHORT");}break;
case CV_NumericKind_LONG:{result = str8_lit("LONG");}break;
case CV_NumericKind_ULONG:{result = str8_lit("ULONG");}break;
case CV_NumericKind_FLOAT32:{result = str8_lit("FLOAT32");}break;
case CV_NumericKind_FLOAT64:{result = str8_lit("FLOAT64");}break;
case CV_NumericKind_FLOAT80:{result = str8_lit("FLOAT80");}break;
case CV_NumericKind_FLOAT128:{result = str8_lit("FLOAT128");}break;
case CV_NumericKind_QUADWORD:{result = str8_lit("QUADWORD");}break;
case CV_NumericKind_UQUADWORD:{result = str8_lit("UQUADWORD");}break;
case CV_NumericKind_FLOAT48:{result = str8_lit("FLOAT48");}break;
case CV_NumericKind_COMPLEX32:{result = str8_lit("COMPLEX32");}break;
case CV_NumericKind_COMPLEX64:{result = str8_lit("COMPLEX64");}break;
case CV_NumericKind_COMPLEX80:{result = str8_lit("COMPLEX80");}break;
case CV_NumericKind_COMPLEX128:{result = str8_lit("COMPLEX128");}break;
case CV_NumericKind_VARSTRING:{result = str8_lit("VARSTRING");}break;
case CV_NumericKind_OCTWORD:{result = str8_lit("OCTWORD");}break;
case CV_NumericKind_UOCTWORD:{result = str8_lit("UOCTWORD");}break;
case CV_NumericKind_DECIMAL:{result = str8_lit("DECIMAL");}break;
case CV_NumericKind_DATE:{result = str8_lit("DATE");}break;
case CV_NumericKind_UTF8STRING:{result = str8_lit("UTF8STRING");}break;
case CV_NumericKind_FLOAT16:{result = str8_lit("FLOAT16");}break;
}
return result;
}
internal String8
cv_string_from_arch(CV_Arch v)
{
String8 result = str8_lit("<Unknown CV_Arch>");
switch(v)
{
default:{}break;
case CV_Arch_8080:{result = str8_lit("8080");}break;
case CV_Arch_8086:{result = str8_lit("8086");}break;
case CV_Arch_80286:{result = str8_lit("80286");}break;
case CV_Arch_80386:{result = str8_lit("80386");}break;
case CV_Arch_80486:{result = str8_lit("80486");}break;
case CV_Arch_PENTIUM:{result = str8_lit("PENTIUM");}break;
case CV_Arch_PENTIUMII:{result = str8_lit("PENTIUMII");}break;
case CV_Arch_PENTIUMIII:{result = str8_lit("PENTIUMIII");}break;
case CV_Arch_MIPS:{result = str8_lit("MIPS");}break;
case CV_Arch_MIPS16:{result = str8_lit("MIPS16");}break;
case CV_Arch_MIPS32:{result = str8_lit("MIPS32");}break;
case CV_Arch_MIPS64:{result = str8_lit("MIPS64");}break;
case CV_Arch_MIPSI:{result = str8_lit("MIPSI");}break;
case CV_Arch_MIPSII:{result = str8_lit("MIPSII");}break;
case CV_Arch_MIPSIII:{result = str8_lit("MIPSIII");}break;
case CV_Arch_MIPSIV:{result = str8_lit("MIPSIV");}break;
case CV_Arch_MIPSV:{result = str8_lit("MIPSV");}break;
case CV_Arch_M68000:{result = str8_lit("M68000");}break;
case CV_Arch_M68010:{result = str8_lit("M68010");}break;
case CV_Arch_M68020:{result = str8_lit("M68020");}break;
case CV_Arch_M68030:{result = str8_lit("M68030");}break;
case CV_Arch_M68040:{result = str8_lit("M68040");}break;
case CV_Arch_ALPHA:{result = str8_lit("ALPHA");}break;
case CV_Arch_ALPHA_21164:{result = str8_lit("ALPHA_21164");}break;
case CV_Arch_ALPHA_21164A:{result = str8_lit("ALPHA_21164A");}break;
case CV_Arch_ALPHA_21264:{result = str8_lit("ALPHA_21264");}break;
case CV_Arch_ALPHA_21364:{result = str8_lit("ALPHA_21364");}break;
case CV_Arch_PPC601:{result = str8_lit("PPC601");}break;
case CV_Arch_PPC603:{result = str8_lit("PPC603");}break;
case CV_Arch_PPC604:{result = str8_lit("PPC604");}break;
case CV_Arch_PPC620:{result = str8_lit("PPC620");}break;
case CV_Arch_PPCFP:{result = str8_lit("PPCFP");}break;
case CV_Arch_PPCBE:{result = str8_lit("PPCBE");}break;
case CV_Arch_SH3:{result = str8_lit("SH3");}break;
case CV_Arch_SH3E:{result = str8_lit("SH3E");}break;
case CV_Arch_SH3DSP:{result = str8_lit("SH3DSP");}break;
case CV_Arch_SH4:{result = str8_lit("SH4");}break;
case CV_Arch_SHMEDIA:{result = str8_lit("SHMEDIA");}break;
case CV_Arch_ARM3:{result = str8_lit("ARM3");}break;
case CV_Arch_ARM4:{result = str8_lit("ARM4");}break;
case CV_Arch_ARM4T:{result = str8_lit("ARM4T");}break;
case CV_Arch_ARM5:{result = str8_lit("ARM5");}break;
case CV_Arch_ARM5T:{result = str8_lit("ARM5T");}break;
case CV_Arch_ARM6:{result = str8_lit("ARM6");}break;
case CV_Arch_ARM_XMAC:{result = str8_lit("ARM_XMAC");}break;
case CV_Arch_ARM_WMMX:{result = str8_lit("ARM_WMMX");}break;
case CV_Arch_ARM7:{result = str8_lit("ARM7");}break;
case CV_Arch_OMNI:{result = str8_lit("OMNI");}break;
case CV_Arch_IA64_1:{result = str8_lit("IA64_1");}break;
case CV_Arch_IA64_2:{result = str8_lit("IA64_2");}break;
case CV_Arch_CEE:{result = str8_lit("CEE");}break;
case CV_Arch_AM33:{result = str8_lit("AM33");}break;
case CV_Arch_M32R:{result = str8_lit("M32R");}break;
case CV_Arch_TRICORE:{result = str8_lit("TRICORE");}break;
case CV_Arch_X64:{result = str8_lit("X64");}break;
case CV_Arch_EBC:{result = str8_lit("EBC");}break;
case CV_Arch_THUMB:{result = str8_lit("THUMB");}break;
case CV_Arch_ARMNT:{result = str8_lit("ARMNT");}break;
case CV_Arch_ARM64:{result = str8_lit("ARM64");}break;
case CV_Arch_D3D11_SHADER:{result = str8_lit("D3D11_SHADER");}break;
}
return result;
}
internal String8
cv_string_from_sym_kind(CV_SymKind v)
{
String8 result = str8_lit("<Unknown CV_SymKind>");
switch(v)
{
default:{}break;
case CV_SymKind_COMPILE:{result = str8_lit("COMPILE");}break;
case CV_SymKind_REGISTER_16t:{result = str8_lit("REGISTER_16t");}break;
case CV_SymKind_CONSTANT_16t:{result = str8_lit("CONSTANT_16t");}break;
case CV_SymKind_UDT_16t:{result = str8_lit("UDT_16t");}break;
case CV_SymKind_SSEARCH:{result = str8_lit("SSEARCH");}break;
case CV_SymKind_END:{result = str8_lit("END");}break;
case CV_SymKind_SKIP:{result = str8_lit("SKIP");}break;
case CV_SymKind_CVRESERVE:{result = str8_lit("CVRESERVE");}break;
case CV_SymKind_OBJNAME_ST:{result = str8_lit("OBJNAME_ST");}break;
case CV_SymKind_ENDARG:{result = str8_lit("ENDARG");}break;
case CV_SymKind_COBOLUDT_16t:{result = str8_lit("COBOLUDT_16t");}break;
case CV_SymKind_MANYREG_16t:{result = str8_lit("MANYREG_16t");}break;
case CV_SymKind_RETURN:{result = str8_lit("RETURN");}break;
case CV_SymKind_ENTRYTHIS:{result = str8_lit("ENTRYTHIS");}break;
case CV_SymKind_BPREL16:{result = str8_lit("BPREL16");}break;
case CV_SymKind_LDATA16:{result = str8_lit("LDATA16");}break;
case CV_SymKind_GDATA16:{result = str8_lit("GDATA16");}break;
case CV_SymKind_PUB16:{result = str8_lit("PUB16");}break;
case CV_SymKind_LPROC16:{result = str8_lit("LPROC16");}break;
case CV_SymKind_GPROC16:{result = str8_lit("GPROC16");}break;
case CV_SymKind_THUNK16:{result = str8_lit("THUNK16");}break;
case CV_SymKind_BLOCK16:{result = str8_lit("BLOCK16");}break;
case CV_SymKind_WITH16:{result = str8_lit("WITH16");}break;
case CV_SymKind_LABEL16:{result = str8_lit("LABEL16");}break;
case CV_SymKind_CEXMODEL16:{result = str8_lit("CEXMODEL16");}break;
case CV_SymKind_VFTABLE16:{result = str8_lit("VFTABLE16");}break;
case CV_SymKind_REGREL16:{result = str8_lit("REGREL16");}break;
case CV_SymKind_BPREL32_16t:{result = str8_lit("BPREL32_16t");}break;
case CV_SymKind_LDATA32_16t:{result = str8_lit("LDATA32_16t");}break;
case CV_SymKind_GDATA32_16t:{result = str8_lit("GDATA32_16t");}break;
case CV_SymKind_PUB32_16t:{result = str8_lit("PUB32_16t");}break;
case CV_SymKind_LPROC32_16t:{result = str8_lit("LPROC32_16t");}break;
case CV_SymKind_GPROC32_16t:{result = str8_lit("GPROC32_16t");}break;
case CV_SymKind_THUNK32_ST:{result = str8_lit("THUNK32_ST");}break;
case CV_SymKind_BLOCK32_ST:{result = str8_lit("BLOCK32_ST");}break;
case CV_SymKind_WITH32_ST:{result = str8_lit("WITH32_ST");}break;
case CV_SymKind_LABEL32_ST:{result = str8_lit("LABEL32_ST");}break;
case CV_SymKind_CEXMODEL32:{result = str8_lit("CEXMODEL32");}break;
case CV_SymKind_VFTABLE32_16t:{result = str8_lit("VFTABLE32_16t");}break;
case CV_SymKind_REGREL32_16t:{result = str8_lit("REGREL32_16t");}break;
case CV_SymKind_LTHREAD32_16t:{result = str8_lit("LTHREAD32_16t");}break;
case CV_SymKind_GTHREAD32_16t:{result = str8_lit("GTHREAD32_16t");}break;
case CV_SymKind_SLINK32:{result = str8_lit("SLINK32");}break;
case CV_SymKind_LPROCMIPS_16t:{result = str8_lit("LPROCMIPS_16t");}break;
case CV_SymKind_GPROCMIPS_16t:{result = str8_lit("GPROCMIPS_16t");}break;
case CV_SymKind_PROCREF_ST:{result = str8_lit("PROCREF_ST");}break;
case CV_SymKind_DATAREF_ST:{result = str8_lit("DATAREF_ST");}break;
case CV_SymKind_ALIGN:{result = str8_lit("ALIGN");}break;
case CV_SymKind_LPROCREF_ST:{result = str8_lit("LPROCREF_ST");}break;
case CV_SymKind_OEM:{result = str8_lit("OEM");}break;
case CV_SymKind_TI16_MAX:{result = str8_lit("TI16_MAX");}break;
case CV_SymKind_CONSTANT_ST:{result = str8_lit("CONSTANT_ST");}break;
case CV_SymKind_UDT_ST:{result = str8_lit("UDT_ST");}break;
case CV_SymKind_COBOLUDT_ST:{result = str8_lit("COBOLUDT_ST");}break;
case CV_SymKind_MANYREG_ST:{result = str8_lit("MANYREG_ST");}break;
case CV_SymKind_BPREL32_ST:{result = str8_lit("BPREL32_ST");}break;
case CV_SymKind_LDATA32_ST:{result = str8_lit("LDATA32_ST");}break;
case CV_SymKind_GDATA32_ST:{result = str8_lit("GDATA32_ST");}break;
case CV_SymKind_PUB32_ST:{result = str8_lit("PUB32_ST");}break;
case CV_SymKind_LPROC32_ST:{result = str8_lit("LPROC32_ST");}break;
case CV_SymKind_GPROC32_ST:{result = str8_lit("GPROC32_ST");}break;
case CV_SymKind_VFTABLE32:{result = str8_lit("VFTABLE32");}break;
case CV_SymKind_REGREL32_ST:{result = str8_lit("REGREL32_ST");}break;
case CV_SymKind_LTHREAD32_ST:{result = str8_lit("LTHREAD32_ST");}break;
case CV_SymKind_GTHREAD32_ST:{result = str8_lit("GTHREAD32_ST");}break;
case CV_SymKind_LPROCMIPS_ST:{result = str8_lit("LPROCMIPS_ST");}break;
case CV_SymKind_GPROCMIPS_ST:{result = str8_lit("GPROCMIPS_ST");}break;
case CV_SymKind_FRAMEPROC:{result = str8_lit("FRAMEPROC");}break;
case CV_SymKind_COMPILE2_ST:{result = str8_lit("COMPILE2_ST");}break;
case CV_SymKind_MANYREG2_ST:{result = str8_lit("MANYREG2_ST");}break;
case CV_SymKind_LPROCIA64_ST:{result = str8_lit("LPROCIA64_ST");}break;
case CV_SymKind_GPROCIA64_ST:{result = str8_lit("GPROCIA64_ST");}break;
case CV_SymKind_LOCALSLOT_ST:{result = str8_lit("LOCALSLOT_ST");}break;
case CV_SymKind_PARAMSLOT_ST:{result = str8_lit("PARAMSLOT_ST");}break;
case CV_SymKind_ANNOTATION:{result = str8_lit("ANNOTATION");}break;
case CV_SymKind_GMANPROC_ST:{result = str8_lit("GMANPROC_ST");}break;
case CV_SymKind_LMANPROC_ST:{result = str8_lit("LMANPROC_ST");}break;
case CV_SymKind_RESERVED1:{result = str8_lit("RESERVED1");}break;
case CV_SymKind_RESERVED2:{result = str8_lit("RESERVED2");}break;
case CV_SymKind_RESERVED3:{result = str8_lit("RESERVED3");}break;
case CV_SymKind_RESERVED4:{result = str8_lit("RESERVED4");}break;
case CV_SymKind_LMANDATA_ST:{result = str8_lit("LMANDATA_ST");}break;
case CV_SymKind_GMANDATA_ST:{result = str8_lit("GMANDATA_ST");}break;
case CV_SymKind_MANFRAMEREL_ST:{result = str8_lit("MANFRAMEREL_ST");}break;
case CV_SymKind_MANREGISTER_ST:{result = str8_lit("MANREGISTER_ST");}break;
case CV_SymKind_MANSLOT_ST:{result = str8_lit("MANSLOT_ST");}break;
case CV_SymKind_MANMANYREG_ST:{result = str8_lit("MANMANYREG_ST");}break;
case CV_SymKind_MANREGREL_ST:{result = str8_lit("MANREGREL_ST");}break;
case CV_SymKind_MANMANYREG2_ST:{result = str8_lit("MANMANYREG2_ST");}break;
case CV_SymKind_MANTYPREF:{result = str8_lit("MANTYPREF");}break;
case CV_SymKind_UNAMESPACE_ST:{result = str8_lit("UNAMESPACE_ST");}break;
case CV_SymKind_ST_MAX:{result = str8_lit("ST_MAX");}break;
case CV_SymKind_OBJNAME:{result = str8_lit("OBJNAME");}break;
case CV_SymKind_THUNK32:{result = str8_lit("THUNK32");}break;
case CV_SymKind_BLOCK32:{result = str8_lit("BLOCK32");}break;
case CV_SymKind_WITH32:{result = str8_lit("WITH32");}break;
case CV_SymKind_LABEL32:{result = str8_lit("LABEL32");}break;
case CV_SymKind_REGISTER:{result = str8_lit("REGISTER");}break;
case CV_SymKind_CONSTANT:{result = str8_lit("CONSTANT");}break;
case CV_SymKind_UDT:{result = str8_lit("UDT");}break;
case CV_SymKind_COBOLUDT:{result = str8_lit("COBOLUDT");}break;
case CV_SymKind_MANYREG:{result = str8_lit("MANYREG");}break;
case CV_SymKind_BPREL32:{result = str8_lit("BPREL32");}break;
case CV_SymKind_LDATA32:{result = str8_lit("LDATA32");}break;
case CV_SymKind_GDATA32:{result = str8_lit("GDATA32");}break;
case CV_SymKind_PUB32:{result = str8_lit("PUB32");}break;
case CV_SymKind_LPROC32:{result = str8_lit("LPROC32");}break;
case CV_SymKind_GPROC32:{result = str8_lit("GPROC32");}break;
case CV_SymKind_REGREL32:{result = str8_lit("REGREL32");}break;
case CV_SymKind_LTHREAD32:{result = str8_lit("LTHREAD32");}break;
case CV_SymKind_GTHREAD32:{result = str8_lit("GTHREAD32");}break;
case CV_SymKind_LPROCMIPS:{result = str8_lit("LPROCMIPS");}break;
case CV_SymKind_GPROCMIPS:{result = str8_lit("GPROCMIPS");}break;
case CV_SymKind_COMPILE2:{result = str8_lit("COMPILE2");}break;
case CV_SymKind_MANYREG2:{result = str8_lit("MANYREG2");}break;
case CV_SymKind_LPROCIA64:{result = str8_lit("LPROCIA64");}break;
case CV_SymKind_GPROCIA64:{result = str8_lit("GPROCIA64");}break;
case CV_SymKind_LOCALSLOT:{result = str8_lit("LOCALSLOT");}break;
case CV_SymKind_PARAMSLOT:{result = str8_lit("PARAMSLOT");}break;
case CV_SymKind_LMANDATA:{result = str8_lit("LMANDATA");}break;
case CV_SymKind_GMANDATA:{result = str8_lit("GMANDATA");}break;
case CV_SymKind_MANFRAMEREL:{result = str8_lit("MANFRAMEREL");}break;
case CV_SymKind_MANREGISTER:{result = str8_lit("MANREGISTER");}break;
case CV_SymKind_MANSLOT:{result = str8_lit("MANSLOT");}break;
case CV_SymKind_MANMANYREG:{result = str8_lit("MANMANYREG");}break;
case CV_SymKind_MANREGREL:{result = str8_lit("MANREGREL");}break;
case CV_SymKind_MANMANYREG2:{result = str8_lit("MANMANYREG2");}break;
case CV_SymKind_UNAMESPACE:{result = str8_lit("UNAMESPACE");}break;
case CV_SymKind_PROCREF:{result = str8_lit("PROCREF");}break;
case CV_SymKind_DATAREF:{result = str8_lit("DATAREF");}break;
case CV_SymKind_LPROCREF:{result = str8_lit("LPROCREF");}break;
case CV_SymKind_ANNOTATIONREF:{result = str8_lit("ANNOTATIONREF");}break;
case CV_SymKind_TOKENREF:{result = str8_lit("TOKENREF");}break;
case CV_SymKind_GMANPROC:{result = str8_lit("GMANPROC");}break;
case CV_SymKind_LMANPROC:{result = str8_lit("LMANPROC");}break;
case CV_SymKind_TRAMPOLINE:{result = str8_lit("TRAMPOLINE");}break;
case CV_SymKind_MANCONSTANT:{result = str8_lit("MANCONSTANT");}break;
case CV_SymKind_ATTR_FRAMEREL:{result = str8_lit("ATTR_FRAMEREL");}break;
case CV_SymKind_ATTR_REGISTER:{result = str8_lit("ATTR_REGISTER");}break;
case CV_SymKind_ATTR_REGREL:{result = str8_lit("ATTR_REGREL");}break;
case CV_SymKind_ATTR_MANYREG:{result = str8_lit("ATTR_MANYREG");}break;
case CV_SymKind_SEPCODE:{result = str8_lit("SEPCODE");}break;
case CV_SymKind_DEFRANGE_2005:{result = str8_lit("DEFRANGE_2005");}break;
case CV_SymKind_DEFRANGE2_2005:{result = str8_lit("DEFRANGE2_2005");}break;
case CV_SymKind_SECTION:{result = str8_lit("SECTION");}break;
case CV_SymKind_COFFGROUP:{result = str8_lit("COFFGROUP");}break;
case CV_SymKind_EXPORT:{result = str8_lit("EXPORT");}break;
case CV_SymKind_CALLSITEINFO:{result = str8_lit("CALLSITEINFO");}break;
case CV_SymKind_FRAMECOOKIE:{result = str8_lit("FRAMECOOKIE");}break;
case CV_SymKind_DISCARDED:{result = str8_lit("DISCARDED");}break;
case CV_SymKind_COMPILE3:{result = str8_lit("COMPILE3");}break;
case CV_SymKind_ENVBLOCK:{result = str8_lit("ENVBLOCK");}break;
case CV_SymKind_LOCAL:{result = str8_lit("LOCAL");}break;
case CV_SymKind_DEFRANGE:{result = str8_lit("DEFRANGE");}break;
case CV_SymKind_DEFRANGE_SUBFIELD:{result = str8_lit("DEFRANGE_SUBFIELD");}break;
case CV_SymKind_DEFRANGE_REGISTER:{result = str8_lit("DEFRANGE_REGISTER");}break;
case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL:{result = str8_lit("DEFRANGE_FRAMEPOINTER_REL");}break;
case CV_SymKind_DEFRANGE_SUBFIELD_REGISTER:{result = str8_lit("DEFRANGE_SUBFIELD_REGISTER");}break;
case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:{result = str8_lit("DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE");}break;
case CV_SymKind_DEFRANGE_REGISTER_REL:{result = str8_lit("DEFRANGE_REGISTER_REL");}break;
case CV_SymKind_LPROC32_ID:{result = str8_lit("LPROC32_ID");}break;
case CV_SymKind_GPROC32_ID:{result = str8_lit("GPROC32_ID");}break;
case CV_SymKind_LPROCMIPS_ID:{result = str8_lit("LPROCMIPS_ID");}break;
case CV_SymKind_GPROCMIPS_ID:{result = str8_lit("GPROCMIPS_ID");}break;
case CV_SymKind_LPROCIA64_ID:{result = str8_lit("LPROCIA64_ID");}break;
case CV_SymKind_GPROCIA64_ID:{result = str8_lit("GPROCIA64_ID");}break;
case CV_SymKind_BUILDINFO:{result = str8_lit("BUILDINFO");}break;
case CV_SymKind_INLINESITE:{result = str8_lit("INLINESITE");}break;
case CV_SymKind_INLINESITE_END:{result = str8_lit("INLINESITE_END");}break;
case CV_SymKind_PROC_ID_END:{result = str8_lit("PROC_ID_END");}break;
case CV_SymKind_DEFRANGE_HLSL:{result = str8_lit("DEFRANGE_HLSL");}break;
case CV_SymKind_GDATA_HLSL:{result = str8_lit("GDATA_HLSL");}break;
case CV_SymKind_LDATA_HLSL:{result = str8_lit("LDATA_HLSL");}break;
case CV_SymKind_FILESTATIC:{result = str8_lit("FILESTATIC");}break;
case CV_SymKind_LPROC32_DPC:{result = str8_lit("LPROC32_DPC");}break;
case CV_SymKind_LPROC32_DPC_ID:{result = str8_lit("LPROC32_DPC_ID");}break;
case CV_SymKind_DEFRANGE_DPC_PTR_TAG:{result = str8_lit("DEFRANGE_DPC_PTR_TAG");}break;
case CV_SymKind_DPC_SYM_TAG_MAP:{result = str8_lit("DPC_SYM_TAG_MAP");}break;
case CV_SymKind_ARMSWITCHTABLE:{result = str8_lit("ARMSWITCHTABLE");}break;
case CV_SymKind_CALLEES:{result = str8_lit("CALLEES");}break;
case CV_SymKind_CALLERS:{result = str8_lit("CALLERS");}break;
case CV_SymKind_POGODATA:{result = str8_lit("POGODATA");}break;
case CV_SymKind_INLINESITE2:{result = str8_lit("INLINESITE2");}break;
case CV_SymKind_HEAPALLOCSITE:{result = str8_lit("HEAPALLOCSITE");}break;
case CV_SymKind_MOD_TYPEREF:{result = str8_lit("MOD_TYPEREF");}break;
case CV_SymKind_REF_MINIPDB:{result = str8_lit("REF_MINIPDB");}break;
case CV_SymKind_PDBMAP:{result = str8_lit("PDBMAP");}break;
case CV_SymKind_GDATA_HLSL32:{result = str8_lit("GDATA_HLSL32");}break;
case CV_SymKind_LDATA_HLSL32:{result = str8_lit("LDATA_HLSL32");}break;
case CV_SymKind_GDATA_HLSL32_EX:{result = str8_lit("GDATA_HLSL32_EX");}break;
case CV_SymKind_LDATA_HLSL32_EX:{result = str8_lit("LDATA_HLSL32_EX");}break;
case CV_SymKind_FASTLINK:{result = str8_lit("FASTLINK");}break;
case CV_SymKind_INLINEES:{result = str8_lit("INLINEES");}break;
}
return result;
}
internal String8
cv_string_from_basic_type(CV_BasicType v)
{
String8 result = str8_lit("<Unknown CV_BasicType>");
switch(v)
{
default:{}break;
case CV_BasicType_NOTYPE:{result = str8_lit("NOTYPE");}break;
case CV_BasicType_ABS:{result = str8_lit("ABS");}break;
case CV_BasicType_SEGMENT:{result = str8_lit("SEGMENT");}break;
case CV_BasicType_VOID:{result = str8_lit("VOID");}break;
case CV_BasicType_CURRENCY:{result = str8_lit("CURRENCY");}break;
case CV_BasicType_NBASICSTR:{result = str8_lit("NBASICSTR");}break;
case CV_BasicType_FBASICSTR:{result = str8_lit("FBASICSTR");}break;
case CV_BasicType_NOTTRANS:{result = str8_lit("NOTTRANS");}break;
case CV_BasicType_HRESULT:{result = str8_lit("HRESULT");}break;
case CV_BasicType_CHAR:{result = str8_lit("CHAR");}break;
case CV_BasicType_SHORT:{result = str8_lit("SHORT");}break;
case CV_BasicType_LONG:{result = str8_lit("LONG");}break;
case CV_BasicType_QUAD:{result = str8_lit("QUAD");}break;
case CV_BasicType_OCT:{result = str8_lit("OCT");}break;
case CV_BasicType_UCHAR:{result = str8_lit("UCHAR");}break;
case CV_BasicType_USHORT:{result = str8_lit("USHORT");}break;
case CV_BasicType_ULONG:{result = str8_lit("ULONG");}break;
case CV_BasicType_UQUAD:{result = str8_lit("UQUAD");}break;
case CV_BasicType_UOCT:{result = str8_lit("UOCT");}break;
case CV_BasicType_BOOL8:{result = str8_lit("BOOL8");}break;
case CV_BasicType_BOOL16:{result = str8_lit("BOOL16");}break;
case CV_BasicType_BOOL32:{result = str8_lit("BOOL32");}break;
case CV_BasicType_BOOL64:{result = str8_lit("BOOL64");}break;
case CV_BasicType_FLOAT32:{result = str8_lit("FLOAT32");}break;
case CV_BasicType_FLOAT64:{result = str8_lit("FLOAT64");}break;
case CV_BasicType_FLOAT80:{result = str8_lit("FLOAT80");}break;
case CV_BasicType_FLOAT128:{result = str8_lit("FLOAT128");}break;
case CV_BasicType_FLOAT48:{result = str8_lit("FLOAT48");}break;
case CV_BasicType_FLOAT32PP:{result = str8_lit("FLOAT32PP");}break;
case CV_BasicType_FLOAT16:{result = str8_lit("FLOAT16");}break;
case CV_BasicType_COMPLEX32:{result = str8_lit("COMPLEX32");}break;
case CV_BasicType_COMPLEX64:{result = str8_lit("COMPLEX64");}break;
case CV_BasicType_COMPLEX80:{result = str8_lit("COMPLEX80");}break;
case CV_BasicType_COMPLEX128:{result = str8_lit("COMPLEX128");}break;
case CV_BasicType_BIT:{result = str8_lit("BIT");}break;
case CV_BasicType_PASCHAR:{result = str8_lit("PASCHAR");}break;
case CV_BasicType_BOOL32FF:{result = str8_lit("BOOL32FF");}break;
case CV_BasicType_INT8:{result = str8_lit("INT8");}break;
case CV_BasicType_UINT8:{result = str8_lit("UINT8");}break;
case CV_BasicType_RCHAR:{result = str8_lit("RCHAR");}break;
case CV_BasicType_WCHAR:{result = str8_lit("WCHAR");}break;
case CV_BasicType_INT16:{result = str8_lit("INT16");}break;
case CV_BasicType_UINT16:{result = str8_lit("UINT16");}break;
case CV_BasicType_INT32:{result = str8_lit("INT32");}break;
case CV_BasicType_UINT32:{result = str8_lit("UINT32");}break;
case CV_BasicType_INT64:{result = str8_lit("INT64");}break;
case CV_BasicType_UINT64:{result = str8_lit("UINT64");}break;
case CV_BasicType_INT128:{result = str8_lit("INT128");}break;
case CV_BasicType_UINT128:{result = str8_lit("UINT128");}break;
case CV_BasicType_CHAR16:{result = str8_lit("CHAR16");}break;
case CV_BasicType_CHAR32:{result = str8_lit("CHAR32");}break;
case CV_BasicType_CHAR8:{result = str8_lit("CHAR8");}break;
case CV_BasicType_PTR:{result = str8_lit("PTR");}break;
}
return result;
}
internal String8
cv_type_name_from_basic_type(CV_BasicType v)
{
String8 result = str8_lit("<Unknown CV_BasicType>");
switch(v)
{
default:{}break;
case CV_BasicType_NOTYPE:{result = str8_lit("");}break;
case CV_BasicType_ABS:{result = str8_lit("");}break;
case CV_BasicType_SEGMENT:{result = str8_lit("");}break;
case CV_BasicType_VOID:{result = str8_lit("void");}break;
case CV_BasicType_CURRENCY:{result = str8_lit("");}break;
case CV_BasicType_NBASICSTR:{result = str8_lit("");}break;
case CV_BasicType_FBASICSTR:{result = str8_lit("");}break;
case CV_BasicType_NOTTRANS:{result = str8_lit("");}break;
case CV_BasicType_HRESULT:{result = str8_lit("HRESULT");}break;
case CV_BasicType_CHAR:{result = str8_lit("char");}break;
case CV_BasicType_SHORT:{result = str8_lit("S16");}break;
case CV_BasicType_LONG:{result = str8_lit("S32");}break;
case CV_BasicType_QUAD:{result = str8_lit("S64");}break;
case CV_BasicType_OCT:{result = str8_lit("S128");}break;
case CV_BasicType_UCHAR:{result = str8_lit("UCHAR");}break;
case CV_BasicType_USHORT:{result = str8_lit("U16");}break;
case CV_BasicType_ULONG:{result = str8_lit("U32");}break;
case CV_BasicType_UQUAD:{result = str8_lit("U64");}break;
case CV_BasicType_UOCT:{result = str8_lit("U128");}break;
case CV_BasicType_BOOL8:{result = str8_lit("B8");}break;
case CV_BasicType_BOOL16:{result = str8_lit("B16");}break;
case CV_BasicType_BOOL32:{result = str8_lit("B32");}break;
case CV_BasicType_BOOL64:{result = str8_lit("B64");}break;
case CV_BasicType_FLOAT32:{result = str8_lit("F32");}break;
case CV_BasicType_FLOAT64:{result = str8_lit("F64");}break;
case CV_BasicType_FLOAT80:{result = str8_lit("F80");}break;
case CV_BasicType_FLOAT128:{result = str8_lit("F128");}break;
case CV_BasicType_FLOAT48:{result = str8_lit("F48");}break;
case CV_BasicType_FLOAT32PP:{result = str8_lit("F32PP");}break;
case CV_BasicType_FLOAT16:{result = str8_lit("F16");}break;
case CV_BasicType_COMPLEX32:{result = str8_lit("ComplexF32");}break;
case CV_BasicType_COMPLEX64:{result = str8_lit("ComplexF64");}break;
case CV_BasicType_COMPLEX80:{result = str8_lit("ComplexF80");}break;
case CV_BasicType_COMPLEX128:{result = str8_lit("ComplexF128");}break;
case CV_BasicType_BIT:{result = str8_lit("");}break;
case CV_BasicType_PASCHAR:{result = str8_lit("");}break;
case CV_BasicType_BOOL32FF:{result = str8_lit("B32FF");}break;
case CV_BasicType_INT8:{result = str8_lit("S8");}break;
case CV_BasicType_UINT8:{result = str8_lit("U8");}break;
case CV_BasicType_RCHAR:{result = str8_lit("char");}break;
case CV_BasicType_WCHAR:{result = str8_lit("WCHAR");}break;
case CV_BasicType_INT16:{result = str8_lit("S16");}break;
case CV_BasicType_UINT16:{result = str8_lit("U16");}break;
case CV_BasicType_INT32:{result = str8_lit("S32");}break;
case CV_BasicType_UINT32:{result = str8_lit("U32");}break;
case CV_BasicType_INT64:{result = str8_lit("S64");}break;
case CV_BasicType_UINT64:{result = str8_lit("U64");}break;
case CV_BasicType_INT128:{result = str8_lit("S128");}break;
case CV_BasicType_UINT128:{result = str8_lit("U128");}break;
case CV_BasicType_CHAR16:{result = str8_lit("CHAR16");}break;
case CV_BasicType_CHAR32:{result = str8_lit("CHAR32");}break;
case CV_BasicType_CHAR8:{result = str8_lit("char");}break;
case CV_BasicType_PTR:{result = str8_lit("PTR");}break;
}
return result;
}
internal String8
cv_string_from_leaf_kind(CV_LeafKind v)
{
String8 result = str8_lit("<Unknown CV_LeafKind>");
switch(v)
{
default:{}break;
case CV_LeafKind_MODIFIER_16t:{result = str8_lit("MODIFIER_16t");}break;
case CV_LeafKind_POINTER_16t:{result = str8_lit("POINTER_16t");}break;
case CV_LeafKind_ARRAY_16t:{result = str8_lit("ARRAY_16t");}break;
case CV_LeafKind_CLASS_16t:{result = str8_lit("CLASS_16t");}break;
case CV_LeafKind_STRUCTURE_16t:{result = str8_lit("STRUCTURE_16t");}break;
case CV_LeafKind_UNION_16t:{result = str8_lit("UNION_16t");}break;
case CV_LeafKind_ENUM_16t:{result = str8_lit("ENUM_16t");}break;
case CV_LeafKind_PROCEDURE_16t:{result = str8_lit("PROCEDURE_16t");}break;
case CV_LeafKind_MFUNCTION_16t:{result = str8_lit("MFUNCTION_16t");}break;
case CV_LeafKind_VTSHAPE:{result = str8_lit("VTSHAPE");}break;
case CV_LeafKind_COBOL0_16t:{result = str8_lit("COBOL0_16t");}break;
case CV_LeafKind_COBOL1:{result = str8_lit("COBOL1");}break;
case CV_LeafKind_BARRAY_16t:{result = str8_lit("BARRAY_16t");}break;
case CV_LeafKind_LABEL:{result = str8_lit("LABEL");}break;
case CV_LeafKind_NULL:{result = str8_lit("NULL");}break;
case CV_LeafKind_NOTTRAN:{result = str8_lit("NOTTRAN");}break;
case CV_LeafKind_DIMARRAY_16t:{result = str8_lit("DIMARRAY_16t");}break;
case CV_LeafKind_VFTPATH_16t:{result = str8_lit("VFTPATH_16t");}break;
case CV_LeafKind_PRECOMP_16t:{result = str8_lit("PRECOMP_16t");}break;
case CV_LeafKind_ENDPRECOMP:{result = str8_lit("ENDPRECOMP");}break;
case CV_LeafKind_OEM_16t:{result = str8_lit("OEM_16t");}break;
case CV_LeafKind_TYPESERVER_ST:{result = str8_lit("TYPESERVER_ST");}break;
case CV_LeafKind_SKIP_16t:{result = str8_lit("SKIP_16t");}break;
case CV_LeafKind_ARGLIST_16t:{result = str8_lit("ARGLIST_16t");}break;
case CV_LeafKind_DEFARG_16t:{result = str8_lit("DEFARG_16t");}break;
case CV_LeafKind_LIST:{result = str8_lit("LIST");}break;
case CV_LeafKind_FIELDLIST_16t:{result = str8_lit("FIELDLIST_16t");}break;
case CV_LeafKind_DERIVED_16t:{result = str8_lit("DERIVED_16t");}break;
case CV_LeafKind_BITFIELD_16t:{result = str8_lit("BITFIELD_16t");}break;
case CV_LeafKind_METHODLIST_16t:{result = str8_lit("METHODLIST_16t");}break;
case CV_LeafKind_DIMCONU_16t:{result = str8_lit("DIMCONU_16t");}break;
case CV_LeafKind_DIMCONLU_16t:{result = str8_lit("DIMCONLU_16t");}break;
case CV_LeafKind_DIMVARU_16t:{result = str8_lit("DIMVARU_16t");}break;
case CV_LeafKind_DIMVARLU_16t:{result = str8_lit("DIMVARLU_16t");}break;
case CV_LeafKind_REFSYM:{result = str8_lit("REFSYM");}break;
case CV_LeafKind_BCLASS_16t:{result = str8_lit("BCLASS_16t");}break;
case CV_LeafKind_VBCLASS_16t:{result = str8_lit("VBCLASS_16t");}break;
case CV_LeafKind_IVBCLASS_16t:{result = str8_lit("IVBCLASS_16t");}break;
case CV_LeafKind_ENUMERATE_ST:{result = str8_lit("ENUMERATE_ST");}break;
case CV_LeafKind_FRIENDFCN_16t:{result = str8_lit("FRIENDFCN_16t");}break;
case CV_LeafKind_INDEX_16t:{result = str8_lit("INDEX_16t");}break;
case CV_LeafKind_MEMBER_16t:{result = str8_lit("MEMBER_16t");}break;
case CV_LeafKind_STMEMBER_16t:{result = str8_lit("STMEMBER_16t");}break;
case CV_LeafKind_METHOD_16t:{result = str8_lit("METHOD_16t");}break;
case CV_LeafKind_NESTTYPE_16t:{result = str8_lit("NESTTYPE_16t");}break;
case CV_LeafKind_VFUNCTAB_16t:{result = str8_lit("VFUNCTAB_16t");}break;
case CV_LeafKind_FRIENDCLS_16t:{result = str8_lit("FRIENDCLS_16t");}break;
case CV_LeafKind_ONEMETHOD_16t:{result = str8_lit("ONEMETHOD_16t");}break;
case CV_LeafKind_VFUNCOFF_16t:{result = str8_lit("VFUNCOFF_16t");}break;
case CV_LeafKind_TI16_MAX:{result = str8_lit("TI16_MAX");}break;
case CV_LeafKind_MODIFIER:{result = str8_lit("MODIFIER");}break;
case CV_LeafKind_POINTER:{result = str8_lit("POINTER");}break;
case CV_LeafKind_ARRAY_ST:{result = str8_lit("ARRAY_ST");}break;
case CV_LeafKind_CLASS_ST:{result = str8_lit("CLASS_ST");}break;
case CV_LeafKind_STRUCTURE_ST:{result = str8_lit("STRUCTURE_ST");}break;
case CV_LeafKind_UNION_ST:{result = str8_lit("UNION_ST");}break;
case CV_LeafKind_ENUM_ST:{result = str8_lit("ENUM_ST");}break;
case CV_LeafKind_PROCEDURE:{result = str8_lit("PROCEDURE");}break;
case CV_LeafKind_MFUNCTION:{result = str8_lit("MFUNCTION");}break;
case CV_LeafKind_COBOL0:{result = str8_lit("COBOL0");}break;
case CV_LeafKind_BARRAY:{result = str8_lit("BARRAY");}break;
case CV_LeafKind_DIMARRAY_ST:{result = str8_lit("DIMARRAY_ST");}break;
case CV_LeafKind_VFTPATH:{result = str8_lit("VFTPATH");}break;
case CV_LeafKind_PRECOMP_ST:{result = str8_lit("PRECOMP_ST");}break;
case CV_LeafKind_OEM:{result = str8_lit("OEM");}break;
case CV_LeafKind_ALIAS_ST:{result = str8_lit("ALIAS_ST");}break;
case CV_LeafKind_OEM2:{result = str8_lit("OEM2");}break;
case CV_LeafKind_SKIP:{result = str8_lit("SKIP");}break;
case CV_LeafKind_ARGLIST:{result = str8_lit("ARGLIST");}break;
case CV_LeafKind_DEFARG_ST:{result = str8_lit("DEFARG_ST");}break;
case CV_LeafKind_FIELDLIST:{result = str8_lit("FIELDLIST");}break;
case CV_LeafKind_DERIVED:{result = str8_lit("DERIVED");}break;
case CV_LeafKind_BITFIELD:{result = str8_lit("BITFIELD");}break;
case CV_LeafKind_METHODLIST:{result = str8_lit("METHODLIST");}break;
case CV_LeafKind_DIMCONU:{result = str8_lit("DIMCONU");}break;
case CV_LeafKind_DIMCONLU:{result = str8_lit("DIMCONLU");}break;
case CV_LeafKind_DIMVARU:{result = str8_lit("DIMVARU");}break;
case CV_LeafKind_DIMVARLU:{result = str8_lit("DIMVARLU");}break;
case CV_LeafKind_BCLASS:{result = str8_lit("BCLASS");}break;
case CV_LeafKind_VBCLASS:{result = str8_lit("VBCLASS");}break;
case CV_LeafKind_IVBCLASS:{result = str8_lit("IVBCLASS");}break;
case CV_LeafKind_FRIENDFCN_ST:{result = str8_lit("FRIENDFCN_ST");}break;
case CV_LeafKind_INDEX:{result = str8_lit("INDEX");}break;
case CV_LeafKind_MEMBER_ST:{result = str8_lit("MEMBER_ST");}break;
case CV_LeafKind_STMEMBER_ST:{result = str8_lit("STMEMBER_ST");}break;
case CV_LeafKind_METHOD_ST:{result = str8_lit("METHOD_ST");}break;
case CV_LeafKind_NESTTYPE_ST:{result = str8_lit("NESTTYPE_ST");}break;
case CV_LeafKind_VFUNCTAB:{result = str8_lit("VFUNCTAB");}break;
case CV_LeafKind_FRIENDCLS:{result = str8_lit("FRIENDCLS");}break;
case CV_LeafKind_ONEMETHOD_ST:{result = str8_lit("ONEMETHOD_ST");}break;
case CV_LeafKind_VFUNCOFF:{result = str8_lit("VFUNCOFF");}break;
case CV_LeafKind_NESTTYPEEX_ST:{result = str8_lit("NESTTYPEEX_ST");}break;
case CV_LeafKind_MEMBERMODIFY_ST:{result = str8_lit("MEMBERMODIFY_ST");}break;
case CV_LeafKind_MANAGED_ST:{result = str8_lit("MANAGED_ST");}break;
case CV_LeafKind_ST_MAX:{result = str8_lit("ST_MAX");}break;
case CV_LeafKind_TYPESERVER:{result = str8_lit("TYPESERVER");}break;
case CV_LeafKind_ENUMERATE:{result = str8_lit("ENUMERATE");}break;
case CV_LeafKind_ARRAY:{result = str8_lit("ARRAY");}break;
case CV_LeafKind_CLASS:{result = str8_lit("CLASS");}break;
case CV_LeafKind_STRUCTURE:{result = str8_lit("STRUCTURE");}break;
case CV_LeafKind_UNION:{result = str8_lit("UNION");}break;
case CV_LeafKind_ENUM:{result = str8_lit("ENUM");}break;
case CV_LeafKind_DIMARRAY:{result = str8_lit("DIMARRAY");}break;
case CV_LeafKind_PRECOMP:{result = str8_lit("PRECOMP");}break;
case CV_LeafKind_ALIAS:{result = str8_lit("ALIAS");}break;
case CV_LeafKind_DEFARG:{result = str8_lit("DEFARG");}break;
case CV_LeafKind_FRIENDFCN:{result = str8_lit("FRIENDFCN");}break;
case CV_LeafKind_MEMBER:{result = str8_lit("MEMBER");}break;
case CV_LeafKind_STMEMBER:{result = str8_lit("STMEMBER");}break;
case CV_LeafKind_METHOD:{result = str8_lit("METHOD");}break;
case CV_LeafKind_NESTTYPE:{result = str8_lit("NESTTYPE");}break;
case CV_LeafKind_ONEMETHOD:{result = str8_lit("ONEMETHOD");}break;
case CV_LeafKind_NESTTYPEEX:{result = str8_lit("NESTTYPEEX");}break;
case CV_LeafKind_MEMBERMODIFY:{result = str8_lit("MEMBERMODIFY");}break;
case CV_LeafKind_MANAGED:{result = str8_lit("MANAGED");}break;
case CV_LeafKind_TYPESERVER2:{result = str8_lit("TYPESERVER2");}break;
case CV_LeafKind_STRIDED_ARRAY:{result = str8_lit("STRIDED_ARRAY");}break;
case CV_LeafKind_HLSL:{result = str8_lit("HLSL");}break;
case CV_LeafKind_MODIFIER_EX:{result = str8_lit("MODIFIER_EX");}break;
case CV_LeafKind_INTERFACE:{result = str8_lit("INTERFACE");}break;
case CV_LeafKind_BINTERFACE:{result = str8_lit("BINTERFACE");}break;
case CV_LeafKind_VECTOR:{result = str8_lit("VECTOR");}break;
case CV_LeafKind_MATRIX:{result = str8_lit("MATRIX");}break;
case CV_LeafKind_VFTABLE:{result = str8_lit("VFTABLE");}break;
case CV_LeafKind_CLASS2:{result = str8_lit("CLASS2");}break;
case CV_LeafKind_STRUCT2:{result = str8_lit("STRUCT2");}break;
}
return result;
}
internal U64
cv_header_struct_size_from_sym_kind(CV_SymKind v)
{
U64 result = 0;
switch(v)
{
default:{}break;
case CV_SymKind_COMPILE:{result = sizeof(CV_SymCompile);}break;
case CV_SymKind_SSEARCH:{result = sizeof(CV_SymStartSearch);}break;
case CV_SymKind_RETURN:{result = sizeof(CV_SymReturn);}break;
case CV_SymKind_SLINK32:{result = sizeof(CV_SymSLink32);}break;
case CV_SymKind_OEM:{result = sizeof(CV_SymOEM);}break;
case CV_SymKind_VFTABLE32:{result = sizeof(CV_SymVPath32);}break;
case CV_SymKind_FRAMEPROC:{result = sizeof(CV_SymFrameproc);}break;
case CV_SymKind_ANNOTATION:{result = sizeof(CV_SymAnnotation);}break;
case CV_SymKind_OBJNAME:{result = sizeof(CV_SymObjname);}break;
case CV_SymKind_THUNK32:{result = sizeof(CV_SymThunk32);}break;
case CV_SymKind_BLOCK32:{result = sizeof(CV_SymBlock32);}break;
case CV_SymKind_LABEL32:{result = sizeof(CV_SymLabel32);}break;
case CV_SymKind_REGISTER:{result = sizeof(CV_SymRegister);}break;
case CV_SymKind_CONSTANT:{result = sizeof(CV_SymConstant);}break;
case CV_SymKind_UDT:{result = sizeof(CV_SymUDT);}break;
case CV_SymKind_MANYREG:{result = sizeof(CV_SymManyreg);}break;
case CV_SymKind_BPREL32:{result = sizeof(CV_SymBPRel32);}break;
case CV_SymKind_LDATA32:{result = sizeof(CV_SymData32);}break;
case CV_SymKind_GDATA32:{result = sizeof(CV_SymData32);}break;
case CV_SymKind_PUB32:{result = sizeof(CV_SymPub32);}break;
case CV_SymKind_LPROC32:{result = sizeof(CV_SymProc32);}break;
case CV_SymKind_GPROC32:{result = sizeof(CV_SymProc32);}break;
case CV_SymKind_REGREL32:{result = sizeof(CV_SymRegrel32);}break;
case CV_SymKind_LTHREAD32:{result = sizeof(CV_SymThread32);}break;
case CV_SymKind_GTHREAD32:{result = sizeof(CV_SymThread32);}break;
case CV_SymKind_COMPILE2:{result = sizeof(CV_SymCompile2);}break;
case CV_SymKind_MANYREG2:{result = sizeof(CV_SymManyreg2);}break;
case CV_SymKind_LOCALSLOT:{result = sizeof(CV_SymSlot);}break;
case CV_SymKind_MANFRAMEREL:{result = sizeof(CV_SymAttrFrameRel);}break;
case CV_SymKind_MANREGISTER:{result = sizeof(CV_SymAttrReg);}break;
case CV_SymKind_MANMANYREG:{result = sizeof(CV_SymAttrManyReg);}break;
case CV_SymKind_MANREGREL:{result = sizeof(CV_SymAttrRegRel);}break;
case CV_SymKind_UNAMESPACE:{result = sizeof(CV_SymUNamespace);}break;
case CV_SymKind_PROCREF:{result = sizeof(CV_SymRef2);}break;
case CV_SymKind_DATAREF:{result = sizeof(CV_SymRef2);}break;
case CV_SymKind_LPROCREF:{result = sizeof(CV_SymRef2);}break;
case CV_SymKind_TRAMPOLINE:{result = sizeof(CV_SymTrampoline);}break;
case CV_SymKind_ATTR_FRAMEREL:{result = sizeof(CV_SymAttrFrameRel);}break;
case CV_SymKind_ATTR_REGISTER:{result = sizeof(CV_SymAttrReg);}break;
case CV_SymKind_ATTR_REGREL:{result = sizeof(CV_SymAttrRegRel);}break;
case CV_SymKind_ATTR_MANYREG:{result = sizeof(CV_SymAttrManyReg);}break;
case CV_SymKind_SEPCODE:{result = sizeof(CV_SymSepcode);}break;
case CV_SymKind_SECTION:{result = sizeof(CV_SymSection);}break;
case CV_SymKind_COFFGROUP:{result = sizeof(CV_SymCoffGroup);}break;
case CV_SymKind_EXPORT:{result = sizeof(CV_SymExport);}break;
case CV_SymKind_CALLSITEINFO:{result = sizeof(CV_SymCallSiteInfo);}break;
case CV_SymKind_FRAMECOOKIE:{result = sizeof(CV_SymFrameCookie);}break;
case CV_SymKind_DISCARDED:{result = sizeof(CV_SymDiscarded);}break;
case CV_SymKind_COMPILE3:{result = sizeof(CV_SymCompile3);}break;
case CV_SymKind_ENVBLOCK:{result = sizeof(CV_SymEnvBlock);}break;
case CV_SymKind_LOCAL:{result = sizeof(CV_SymLocal);}break;
case CV_SymKind_DEFRANGE_SUBFIELD:{result = sizeof(CV_SymDefrangeSubfield);}break;
case CV_SymKind_DEFRANGE_REGISTER:{result = sizeof(CV_SymDefrangeRegister);}break;
case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL:{result = sizeof(CV_SymDefrangeFramepointerRel);}break;
case CV_SymKind_DEFRANGE_SUBFIELD_REGISTER:{result = sizeof(CV_SymDefrangeSubfieldRegister);}break;
case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:{result = sizeof(CV_SymDefrangeFramepointerRelFullScope);}break;
case CV_SymKind_DEFRANGE_REGISTER_REL:{result = sizeof(CV_SymDefrangeRegisterRel);}break;
case CV_SymKind_BUILDINFO:{result = sizeof(CV_SymBuildInfo);}break;
case CV_SymKind_INLINESITE:{result = sizeof(CV_SymInlineSite);}break;
case CV_SymKind_FILESTATIC:{result = sizeof(CV_SymFileStatic);}break;
case CV_SymKind_CALLEES:{result = sizeof(CV_SymFunctionList);}break;
case CV_SymKind_CALLERS:{result = sizeof(CV_SymFunctionList);}break;
case CV_SymKind_POGODATA:{result = sizeof(CV_SymPogoInfo);}break;
case CV_SymKind_INLINESITE2:{result = sizeof(CV_SymInlineSite2);}break;
case CV_SymKind_HEAPALLOCSITE:{result = sizeof(CV_SymHeapAllocSite);}break;
case CV_SymKind_MOD_TYPEREF:{result = sizeof(CV_SymModTypeRef);}break;
case CV_SymKind_REF_MINIPDB:{result = sizeof(CV_SymRefMiniPdb);}break;
case CV_SymKind_FASTLINK:{result = sizeof(CV_SymFastLink);}break;
case CV_SymKind_INLINEES:{result = sizeof(CV_SymInlinees);}break;
}
return result;
}
internal U64
cv_header_struct_size_from_leaf_kind(CV_LeafKind v)
{
U64 result = 0;
switch(v)
{
default:{}break;
case CV_LeafKind_VTSHAPE:{result = sizeof(CV_LeafVTShape);}break;
case CV_LeafKind_LABEL:{result = sizeof(CV_LeafLabel);}break;
case CV_LeafKind_MODIFIER:{result = sizeof(CV_LeafModifier);}break;
case CV_LeafKind_POINTER:{result = sizeof(CV_LeafPointer);}break;
case CV_LeafKind_PROCEDURE:{result = sizeof(CV_LeafProcedure);}break;
case CV_LeafKind_MFUNCTION:{result = sizeof(CV_LeafMFunction);}break;
case CV_LeafKind_VFTPATH:{result = sizeof(CV_LeafVFPath);}break;
case CV_LeafKind_SKIP:{result = sizeof(CV_LeafSkip);}break;
case CV_LeafKind_ARGLIST:{result = sizeof(CV_LeafArgList);}break;
case CV_LeafKind_BITFIELD:{result = sizeof(CV_LeafBitField);}break;
case CV_LeafKind_METHODLIST:{result = sizeof(CV_LeafMethodListMember);}break;
case CV_LeafKind_BCLASS:{result = sizeof(CV_LeafBClass);}break;
case CV_LeafKind_VBCLASS:{result = sizeof(CV_LeafVBClass);}break;
case CV_LeafKind_INDEX:{result = sizeof(CV_LeafIndex);}break;
case CV_LeafKind_VFUNCTAB:{result = sizeof(CV_LeafVFuncTab);}break;
case CV_LeafKind_VFUNCOFF:{result = sizeof(CV_LeafVFuncOff);}break;
case CV_LeafKind_TYPESERVER:{result = sizeof(CV_LeafTypeServer);}break;
case CV_LeafKind_ENUMERATE:{result = sizeof(CV_LeafEnumerate);}break;
case CV_LeafKind_ARRAY:{result = sizeof(CV_LeafArray);}break;
case CV_LeafKind_CLASS:{result = sizeof(CV_LeafStruct);}break;
case CV_LeafKind_STRUCTURE:{result = sizeof(CV_LeafStruct);}break;
case CV_LeafKind_UNION:{result = sizeof(CV_LeafUnion);}break;
case CV_LeafKind_ENUM:{result = sizeof(CV_LeafEnum);}break;
case CV_LeafKind_PRECOMP:{result = sizeof(CV_LeafPreComp);}break;
case CV_LeafKind_ALIAS:{result = sizeof(CV_LeafAlias);}break;
case CV_LeafKind_MEMBER:{result = sizeof(CV_LeafMember);}break;
case CV_LeafKind_STMEMBER:{result = sizeof(CV_LeafStMember);}break;
case CV_LeafKind_METHOD:{result = sizeof(CV_LeafMethod);}break;
case CV_LeafKind_NESTTYPE:{result = sizeof(CV_LeafNestType);}break;
case CV_LeafKind_ONEMETHOD:{result = sizeof(CV_LeafOneMethod);}break;
case CV_LeafKind_NESTTYPEEX:{result = sizeof(CV_LeafNestTypeEx);}break;
case CV_LeafKind_TYPESERVER2:{result = sizeof(CV_LeafTypeServer2);}break;
case CV_LeafKind_INTERFACE:{result = sizeof(CV_LeafStruct);}break;
case CV_LeafKind_CLASS2:{result = sizeof(CV_LeafStruct2);}break;
case CV_LeafKind_STRUCT2:{result = sizeof(CV_LeafStruct2);}break;
}
return result;
}
+520
View File
@@ -0,0 +1,520 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
#ifndef CODEVIEW_META_H
#define CODEVIEW_META_H
typedef U16 CV_NumericKind;
typedef enum CV_NumericKindEnum
{
CV_NumericKind_CHAR = 0x8000,
CV_NumericKind_SHORT = 0x8001,
CV_NumericKind_USHORT = 0x8002,
CV_NumericKind_LONG = 0x8003,
CV_NumericKind_ULONG = 0x8004,
CV_NumericKind_FLOAT32 = 0x8005,
CV_NumericKind_FLOAT64 = 0x8006,
CV_NumericKind_FLOAT80 = 0x8007,
CV_NumericKind_FLOAT128 = 0x8008,
CV_NumericKind_QUADWORD = 0x8009,
CV_NumericKind_UQUADWORD = 0x800a,
CV_NumericKind_FLOAT48 = 0x800b,
CV_NumericKind_COMPLEX32 = 0x800c,
CV_NumericKind_COMPLEX64 = 0x800d,
CV_NumericKind_COMPLEX80 = 0x800e,
CV_NumericKind_COMPLEX128 = 0x800f,
CV_NumericKind_VARSTRING = 0x8010,
CV_NumericKind_OCTWORD = 0x8017,
CV_NumericKind_UOCTWORD = 0x8018,
CV_NumericKind_DECIMAL = 0x8019,
CV_NumericKind_DATE = 0x801a,
CV_NumericKind_UTF8STRING = 0x801b,
CV_NumericKind_FLOAT16 = 0x801c,
} CV_NumericKindEnum;
typedef U16 CV_Arch;
typedef enum CV_ArchEnum
{
CV_Arch_8080 = 0x00,
CV_Arch_8086 = 0x01,
CV_Arch_80286 = 0x02,
CV_Arch_80386 = 0x03,
CV_Arch_80486 = 0x04,
CV_Arch_PENTIUM = 0x05,
CV_Arch_PENTIUMII = 0x06,
CV_Arch_PENTIUMIII = 0x07,
CV_Arch_MIPS = 0x10,
CV_Arch_MIPS16 = 0x11,
CV_Arch_MIPS32 = 0x12,
CV_Arch_MIPS64 = 0x13,
CV_Arch_MIPSI = 0x14,
CV_Arch_MIPSII = 0x15,
CV_Arch_MIPSIII = 0x16,
CV_Arch_MIPSIV = 0x17,
CV_Arch_MIPSV = 0x18,
CV_Arch_M68000 = 0x20,
CV_Arch_M68010 = 0x21,
CV_Arch_M68020 = 0x22,
CV_Arch_M68030 = 0x23,
CV_Arch_M68040 = 0x24,
CV_Arch_ALPHA = 0x30,
CV_Arch_ALPHA_21164 = 0x31,
CV_Arch_ALPHA_21164A = 0x32,
CV_Arch_ALPHA_21264 = 0x33,
CV_Arch_ALPHA_21364 = 0x34,
CV_Arch_PPC601 = 0x40,
CV_Arch_PPC603 = 0x41,
CV_Arch_PPC604 = 0x42,
CV_Arch_PPC620 = 0x43,
CV_Arch_PPCFP = 0x44,
CV_Arch_PPCBE = 0x45,
CV_Arch_SH3 = 0x50,
CV_Arch_SH3E = 0x51,
CV_Arch_SH3DSP = 0x52,
CV_Arch_SH4 = 0x53,
CV_Arch_SHMEDIA = 0x54,
CV_Arch_ARM3 = 0x60,
CV_Arch_ARM4 = 0x61,
CV_Arch_ARM4T = 0x62,
CV_Arch_ARM5 = 0x63,
CV_Arch_ARM5T = 0x64,
CV_Arch_ARM6 = 0x65,
CV_Arch_ARM_XMAC = 0x66,
CV_Arch_ARM_WMMX = 0x67,
CV_Arch_ARM7 = 0x68,
CV_Arch_OMNI = 0x70,
CV_Arch_IA64_1 = 0x80,
CV_Arch_IA64_2 = 0x81,
CV_Arch_CEE = 0x90,
CV_Arch_AM33 = 0xA0,
CV_Arch_M32R = 0xB0,
CV_Arch_TRICORE = 0xC0,
CV_Arch_X64 = 0xD0,
CV_Arch_EBC = 0xE0,
CV_Arch_THUMB = 0xF0,
CV_Arch_ARMNT = 0xF4,
CV_Arch_ARM64 = 0xF6,
CV_Arch_D3D11_SHADER = 0x100,
CV_Arch_IA64 = CV_Arch_IA64_1,
CV_Arch_PENTIUMPRO = CV_Arch_PENTIUMII,
CV_Arch_MIPSR4000 = CV_Arch_MIPS,
CV_Arch_ALPHA_21064 = CV_Arch_ALPHA,
CV_Arch_AMD64 = CV_Arch_X64,
} CV_ArchEnum;
typedef U16 CV_AllReg;
typedef enum CV_AllRegEnum
{
CV_AllReg_ERR = 30000,
CV_AllReg_TEB = 30001,
CV_AllReg_TIMER = 30002,
CV_AllReg_EFAD1 = 30003,
CV_AllReg_EFAD2 = 30004,
CV_AllReg_EFAD3 = 30005,
CV_AllReg_VFRAME = 30006,
CV_AllReg_HANDLE = 30007,
CV_AllReg_PARAMS = 30008,
CV_AllReg_LOCALS = 30009,
CV_AllReg_TID = 30010,
CV_AllReg_ENV = 30011,
CV_AllReg_CMDLN = 30012,
} CV_AllRegEnum;
typedef U16 CV_SymKind;
typedef enum CV_SymKindEnum
{
CV_SymKind_COMPILE = 0x0001,
CV_SymKind_REGISTER_16t = 0x0002,
CV_SymKind_CONSTANT_16t = 0x0003,
CV_SymKind_UDT_16t = 0x0004,
CV_SymKind_SSEARCH = 0x0005,
CV_SymKind_END = 0x0006,
CV_SymKind_SKIP = 0x0007,
CV_SymKind_CVRESERVE = 0x0008,
CV_SymKind_OBJNAME_ST = 0x0009,
CV_SymKind_ENDARG = 0x000a,
CV_SymKind_COBOLUDT_16t = 0x000b,
CV_SymKind_MANYREG_16t = 0x000c,
CV_SymKind_RETURN = 0x000d,
CV_SymKind_ENTRYTHIS = 0x000e,
CV_SymKind_BPREL16 = 0x0100,
CV_SymKind_LDATA16 = 0x0101,
CV_SymKind_GDATA16 = 0x0102,
CV_SymKind_PUB16 = 0x0103,
CV_SymKind_LPROC16 = 0x0104,
CV_SymKind_GPROC16 = 0x0105,
CV_SymKind_THUNK16 = 0x0106,
CV_SymKind_BLOCK16 = 0x0107,
CV_SymKind_WITH16 = 0x0108,
CV_SymKind_LABEL16 = 0x0109,
CV_SymKind_CEXMODEL16 = 0x010a,
CV_SymKind_VFTABLE16 = 0x010b,
CV_SymKind_REGREL16 = 0x010c,
CV_SymKind_BPREL32_16t = 0x0200,
CV_SymKind_LDATA32_16t = 0x0201,
CV_SymKind_GDATA32_16t = 0x0202,
CV_SymKind_PUB32_16t = 0x0203,
CV_SymKind_LPROC32_16t = 0x0204,
CV_SymKind_GPROC32_16t = 0x0205,
CV_SymKind_THUNK32_ST = 0x0206,
CV_SymKind_BLOCK32_ST = 0x0207,
CV_SymKind_WITH32_ST = 0x0208,
CV_SymKind_LABEL32_ST = 0x0209,
CV_SymKind_CEXMODEL32 = 0x020a,
CV_SymKind_VFTABLE32_16t = 0x020b,
CV_SymKind_REGREL32_16t = 0x020c,
CV_SymKind_LTHREAD32_16t = 0x020d,
CV_SymKind_GTHREAD32_16t = 0x020e,
CV_SymKind_SLINK32 = 0x020f,
CV_SymKind_LPROCMIPS_16t = 0x0300,
CV_SymKind_GPROCMIPS_16t = 0x0301,
CV_SymKind_PROCREF_ST = 0x0400,
CV_SymKind_DATAREF_ST = 0x0401,
CV_SymKind_ALIGN = 0x0402,
CV_SymKind_LPROCREF_ST = 0x0403,
CV_SymKind_OEM = 0x0404,
CV_SymKind_TI16_MAX = 0x1000,
CV_SymKind_CONSTANT_ST = 0x1002,
CV_SymKind_UDT_ST = 0x1003,
CV_SymKind_COBOLUDT_ST = 0x1004,
CV_SymKind_MANYREG_ST = 0x1005,
CV_SymKind_BPREL32_ST = 0x1006,
CV_SymKind_LDATA32_ST = 0x1007,
CV_SymKind_GDATA32_ST = 0x1008,
CV_SymKind_PUB32_ST = 0x1009,
CV_SymKind_LPROC32_ST = 0x100a,
CV_SymKind_GPROC32_ST = 0x100b,
CV_SymKind_VFTABLE32 = 0x100c,
CV_SymKind_REGREL32_ST = 0x100d,
CV_SymKind_LTHREAD32_ST = 0x100e,
CV_SymKind_GTHREAD32_ST = 0x100f,
CV_SymKind_LPROCMIPS_ST = 0x1010,
CV_SymKind_GPROCMIPS_ST = 0x1011,
CV_SymKind_FRAMEPROC = 0x1012,
CV_SymKind_COMPILE2_ST = 0x1013,
CV_SymKind_MANYREG2_ST = 0x1014,
CV_SymKind_LPROCIA64_ST = 0x1015,
CV_SymKind_GPROCIA64_ST = 0x1016,
CV_SymKind_LOCALSLOT_ST = 0x1017,
CV_SymKind_PARAMSLOT_ST = 0x1018,
CV_SymKind_ANNOTATION = 0x1019,
CV_SymKind_GMANPROC_ST = 0x101a,
CV_SymKind_LMANPROC_ST = 0x101b,
CV_SymKind_RESERVED1 = 0x101c,
CV_SymKind_RESERVED2 = 0x101d,
CV_SymKind_RESERVED3 = 0x101e,
CV_SymKind_RESERVED4 = 0x101f,
CV_SymKind_LMANDATA_ST = 0x1020,
CV_SymKind_GMANDATA_ST = 0x1021,
CV_SymKind_MANFRAMEREL_ST = 0x1022,
CV_SymKind_MANREGISTER_ST = 0x1023,
CV_SymKind_MANSLOT_ST = 0x1024,
CV_SymKind_MANMANYREG_ST = 0x1025,
CV_SymKind_MANREGREL_ST = 0x1026,
CV_SymKind_MANMANYREG2_ST = 0x1027,
CV_SymKind_MANTYPREF = 0x1028,
CV_SymKind_UNAMESPACE_ST = 0x1029,
CV_SymKind_ST_MAX = 0x1100,
CV_SymKind_OBJNAME = 0x1101,
CV_SymKind_THUNK32 = 0x1102,
CV_SymKind_BLOCK32 = 0x1103,
CV_SymKind_WITH32 = 0x1104,
CV_SymKind_LABEL32 = 0x1105,
CV_SymKind_REGISTER = 0x1106,
CV_SymKind_CONSTANT = 0x1107,
CV_SymKind_UDT = 0x1108,
CV_SymKind_COBOLUDT = 0x1109,
CV_SymKind_MANYREG = 0x110a,
CV_SymKind_BPREL32 = 0x110b,
CV_SymKind_LDATA32 = 0x110c,
CV_SymKind_GDATA32 = 0x110d,
CV_SymKind_PUB32 = 0x110e,
CV_SymKind_LPROC32 = 0x110f,
CV_SymKind_GPROC32 = 0x1110,
CV_SymKind_REGREL32 = 0x1111,
CV_SymKind_LTHREAD32 = 0x1112,
CV_SymKind_GTHREAD32 = 0x1113,
CV_SymKind_LPROCMIPS = 0x1114,
CV_SymKind_GPROCMIPS = 0x1115,
CV_SymKind_COMPILE2 = 0x1116,
CV_SymKind_MANYREG2 = 0x1117,
CV_SymKind_LPROCIA64 = 0x1118,
CV_SymKind_GPROCIA64 = 0x1119,
CV_SymKind_LOCALSLOT = 0x111a,
CV_SymKind_PARAMSLOT = 0x111b,
CV_SymKind_LMANDATA = 0x111c,
CV_SymKind_GMANDATA = 0x111d,
CV_SymKind_MANFRAMEREL = 0x111e,
CV_SymKind_MANREGISTER = 0x111f,
CV_SymKind_MANSLOT = 0x1120,
CV_SymKind_MANMANYREG = 0x1121,
CV_SymKind_MANREGREL = 0x1122,
CV_SymKind_MANMANYREG2 = 0x1123,
CV_SymKind_UNAMESPACE = 0x1124,
CV_SymKind_PROCREF = 0x1125,
CV_SymKind_DATAREF = 0x1126,
CV_SymKind_LPROCREF = 0x1127,
CV_SymKind_ANNOTATIONREF = 0x1128,
CV_SymKind_TOKENREF = 0x1129,
CV_SymKind_GMANPROC = 0x112a,
CV_SymKind_LMANPROC = 0x112b,
CV_SymKind_TRAMPOLINE = 0x112c,
CV_SymKind_MANCONSTANT = 0x112d,
CV_SymKind_ATTR_FRAMEREL = 0x112e,
CV_SymKind_ATTR_REGISTER = 0x112f,
CV_SymKind_ATTR_REGREL = 0x1130,
CV_SymKind_ATTR_MANYREG = 0x1131,
CV_SymKind_SEPCODE = 0x1132,
CV_SymKind_DEFRANGE_2005 = 0x1134,
CV_SymKind_DEFRANGE2_2005 = 0x1135,
CV_SymKind_SECTION = 0x1136,
CV_SymKind_COFFGROUP = 0x1137,
CV_SymKind_EXPORT = 0x1138,
CV_SymKind_CALLSITEINFO = 0x1139,
CV_SymKind_FRAMECOOKIE = 0x113a,
CV_SymKind_DISCARDED = 0x113b,
CV_SymKind_COMPILE3 = 0x113c,
CV_SymKind_ENVBLOCK = 0x113d,
CV_SymKind_LOCAL = 0x113e,
CV_SymKind_DEFRANGE = 0x113f,
CV_SymKind_DEFRANGE_SUBFIELD = 0x1140,
CV_SymKind_DEFRANGE_REGISTER = 0x1141,
CV_SymKind_DEFRANGE_FRAMEPOINTER_REL = 0x1142,
CV_SymKind_DEFRANGE_SUBFIELD_REGISTER = 0x1143,
CV_SymKind_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE = 0x1144,
CV_SymKind_DEFRANGE_REGISTER_REL = 0x1145,
CV_SymKind_LPROC32_ID = 0x1146,
CV_SymKind_GPROC32_ID = 0x1147,
CV_SymKind_LPROCMIPS_ID = 0x1148,
CV_SymKind_GPROCMIPS_ID = 0x1149,
CV_SymKind_LPROCIA64_ID = 0x114a,
CV_SymKind_GPROCIA64_ID = 0x114b,
CV_SymKind_BUILDINFO = 0x114c,
CV_SymKind_INLINESITE = 0x114d,
CV_SymKind_INLINESITE_END = 0x114e,
CV_SymKind_PROC_ID_END = 0x114f,
CV_SymKind_DEFRANGE_HLSL = 0x1150,
CV_SymKind_GDATA_HLSL = 0x1151,
CV_SymKind_LDATA_HLSL = 0x1152,
CV_SymKind_FILESTATIC = 0x1153,
CV_SymKind_LPROC32_DPC = 0x1155,
CV_SymKind_LPROC32_DPC_ID = 0x1156,
CV_SymKind_DEFRANGE_DPC_PTR_TAG = 0x1157,
CV_SymKind_DPC_SYM_TAG_MAP = 0x1158,
CV_SymKind_ARMSWITCHTABLE = 0x1159,
CV_SymKind_CALLEES = 0x115a,
CV_SymKind_CALLERS = 0x115b,
CV_SymKind_POGODATA = 0x115c,
CV_SymKind_INLINESITE2 = 0x115d,
CV_SymKind_HEAPALLOCSITE = 0x115e,
CV_SymKind_MOD_TYPEREF = 0x115f,
CV_SymKind_REF_MINIPDB = 0x1160,
CV_SymKind_PDBMAP = 0x1161,
CV_SymKind_GDATA_HLSL32 = 0x1162,
CV_SymKind_LDATA_HLSL32 = 0x1163,
CV_SymKind_GDATA_HLSL32_EX = 0x1164,
CV_SymKind_LDATA_HLSL32_EX = 0x1165,
CV_SymKind_FASTLINK = 0x1167,
CV_SymKind_INLINEES = 0x1168,
} CV_SymKindEnum;
typedef U8 CV_BasicType;
typedef enum CV_BasicTypeEnum
{
CV_BasicType_NOTYPE = 0x00,
CV_BasicType_ABS = 0x01,
CV_BasicType_SEGMENT = 0x02,
CV_BasicType_VOID = 0x03,
CV_BasicType_CURRENCY = 0x04,
CV_BasicType_NBASICSTR = 0x05,
CV_BasicType_FBASICSTR = 0x06,
CV_BasicType_NOTTRANS = 0x07,
CV_BasicType_HRESULT = 0x08,
CV_BasicType_CHAR = 0x10,
CV_BasicType_SHORT = 0x11,
CV_BasicType_LONG = 0x12,
CV_BasicType_QUAD = 0x13,
CV_BasicType_OCT = 0x14,
CV_BasicType_UCHAR = 0x20,
CV_BasicType_USHORT = 0x21,
CV_BasicType_ULONG = 0x22,
CV_BasicType_UQUAD = 0x23,
CV_BasicType_UOCT = 0x24,
CV_BasicType_BOOL8 = 0x30,
CV_BasicType_BOOL16 = 0x31,
CV_BasicType_BOOL32 = 0x32,
CV_BasicType_BOOL64 = 0x33,
CV_BasicType_FLOAT32 = 0x40,
CV_BasicType_FLOAT64 = 0x41,
CV_BasicType_FLOAT80 = 0x42,
CV_BasicType_FLOAT128 = 0x43,
CV_BasicType_FLOAT48 = 0x44,
CV_BasicType_FLOAT32PP = 0x45,
CV_BasicType_FLOAT16 = 0x46,
CV_BasicType_COMPLEX32 = 0x50,
CV_BasicType_COMPLEX64 = 0x51,
CV_BasicType_COMPLEX80 = 0x52,
CV_BasicType_COMPLEX128 = 0x53,
CV_BasicType_BIT = 0x60,
CV_BasicType_PASCHAR = 0x61,
CV_BasicType_BOOL32FF = 0x62,
CV_BasicType_INT8 = 0x68,
CV_BasicType_UINT8 = 0x69,
CV_BasicType_RCHAR = 0x70,
CV_BasicType_WCHAR = 0x71,
CV_BasicType_INT16 = 0x72,
CV_BasicType_UINT16 = 0x73,
CV_BasicType_INT32 = 0x74,
CV_BasicType_UINT32 = 0x75,
CV_BasicType_INT64 = 0x76,
CV_BasicType_UINT64 = 0x77,
CV_BasicType_INT128 = 0x78,
CV_BasicType_UINT128 = 0x79,
CV_BasicType_CHAR16 = 0x7a,
CV_BasicType_CHAR32 = 0x7b,
CV_BasicType_CHAR8 = 0x7c,
CV_BasicType_PTR = 0xf0,
} CV_BasicTypeEnum;
typedef U16 CV_LeafKind;
typedef enum CV_LeafKindEnum
{
CV_LeafKind_MODIFIER_16t = 0x0001,
CV_LeafKind_POINTER_16t = 0x0002,
CV_LeafKind_ARRAY_16t = 0x0003,
CV_LeafKind_CLASS_16t = 0x0004,
CV_LeafKind_STRUCTURE_16t = 0x0005,
CV_LeafKind_UNION_16t = 0x0006,
CV_LeafKind_ENUM_16t = 0x0007,
CV_LeafKind_PROCEDURE_16t = 0x0008,
CV_LeafKind_MFUNCTION_16t = 0x0009,
CV_LeafKind_VTSHAPE = 0x000a,
CV_LeafKind_COBOL0_16t = 0x000b,
CV_LeafKind_COBOL1 = 0x000c,
CV_LeafKind_BARRAY_16t = 0x000d,
CV_LeafKind_LABEL = 0x000e,
CV_LeafKind_NULL = 0x000f,
CV_LeafKind_NOTTRAN = 0x0010,
CV_LeafKind_DIMARRAY_16t = 0x0011,
CV_LeafKind_VFTPATH_16t = 0x0012,
CV_LeafKind_PRECOMP_16t = 0x0013,
CV_LeafKind_ENDPRECOMP = 0x0014,
CV_LeafKind_OEM_16t = 0x0015,
CV_LeafKind_TYPESERVER_ST = 0x0016,
CV_LeafKind_SKIP_16t = 0x0200,
CV_LeafKind_ARGLIST_16t = 0x0201,
CV_LeafKind_DEFARG_16t = 0x0202,
CV_LeafKind_LIST = 0x0203,
CV_LeafKind_FIELDLIST_16t = 0x0204,
CV_LeafKind_DERIVED_16t = 0x0205,
CV_LeafKind_BITFIELD_16t = 0x0206,
CV_LeafKind_METHODLIST_16t = 0x0207,
CV_LeafKind_DIMCONU_16t = 0x0208,
CV_LeafKind_DIMCONLU_16t = 0x0209,
CV_LeafKind_DIMVARU_16t = 0x020a,
CV_LeafKind_DIMVARLU_16t = 0x020b,
CV_LeafKind_REFSYM = 0x020c,
CV_LeafKind_BCLASS_16t = 0x0400,
CV_LeafKind_VBCLASS_16t = 0x0401,
CV_LeafKind_IVBCLASS_16t = 0x0402,
CV_LeafKind_ENUMERATE_ST = 0x0403,
CV_LeafKind_FRIENDFCN_16t = 0x0404,
CV_LeafKind_INDEX_16t = 0x0405,
CV_LeafKind_MEMBER_16t = 0x0406,
CV_LeafKind_STMEMBER_16t = 0x0407,
CV_LeafKind_METHOD_16t = 0x0408,
CV_LeafKind_NESTTYPE_16t = 0x0409,
CV_LeafKind_VFUNCTAB_16t = 0x040a,
CV_LeafKind_FRIENDCLS_16t = 0x040b,
CV_LeafKind_ONEMETHOD_16t = 0x040c,
CV_LeafKind_VFUNCOFF_16t = 0x040d,
CV_LeafKind_TI16_MAX = 0x1000,
CV_LeafKind_MODIFIER = 0x1001,
CV_LeafKind_POINTER = 0x1002,
CV_LeafKind_ARRAY_ST = 0x1003,
CV_LeafKind_CLASS_ST = 0x1004,
CV_LeafKind_STRUCTURE_ST = 0x1005,
CV_LeafKind_UNION_ST = 0x1006,
CV_LeafKind_ENUM_ST = 0x1007,
CV_LeafKind_PROCEDURE = 0x1008,
CV_LeafKind_MFUNCTION = 0x1009,
CV_LeafKind_COBOL0 = 0x100a,
CV_LeafKind_BARRAY = 0x100b,
CV_LeafKind_DIMARRAY_ST = 0x100c,
CV_LeafKind_VFTPATH = 0x100d,
CV_LeafKind_PRECOMP_ST = 0x100e,
CV_LeafKind_OEM = 0x100f,
CV_LeafKind_ALIAS_ST = 0x1010,
CV_LeafKind_OEM2 = 0x1011,
CV_LeafKind_SKIP = 0x1200,
CV_LeafKind_ARGLIST = 0x1201,
CV_LeafKind_DEFARG_ST = 0x1202,
CV_LeafKind_FIELDLIST = 0x1203,
CV_LeafKind_DERIVED = 0x1204,
CV_LeafKind_BITFIELD = 0x1205,
CV_LeafKind_METHODLIST = 0x1206,
CV_LeafKind_DIMCONU = 0x1207,
CV_LeafKind_DIMCONLU = 0x1208,
CV_LeafKind_DIMVARU = 0x1209,
CV_LeafKind_DIMVARLU = 0x120a,
CV_LeafKind_BCLASS = 0x1400,
CV_LeafKind_VBCLASS = 0x1401,
CV_LeafKind_IVBCLASS = 0x1402,
CV_LeafKind_FRIENDFCN_ST = 0x1403,
CV_LeafKind_INDEX = 0x1404,
CV_LeafKind_MEMBER_ST = 0x1405,
CV_LeafKind_STMEMBER_ST = 0x1406,
CV_LeafKind_METHOD_ST = 0x1407,
CV_LeafKind_NESTTYPE_ST = 0x1408,
CV_LeafKind_VFUNCTAB = 0x1409,
CV_LeafKind_FRIENDCLS = 0x140a,
CV_LeafKind_ONEMETHOD_ST = 0x140b,
CV_LeafKind_VFUNCOFF = 0x140c,
CV_LeafKind_NESTTYPEEX_ST = 0x140d,
CV_LeafKind_MEMBERMODIFY_ST = 0x140e,
CV_LeafKind_MANAGED_ST = 0x140f,
CV_LeafKind_ST_MAX = 0x1500,
CV_LeafKind_TYPESERVER = 0x1501,
CV_LeafKind_ENUMERATE = 0x1502,
CV_LeafKind_ARRAY = 0x1503,
CV_LeafKind_CLASS = 0x1504,
CV_LeafKind_STRUCTURE = 0x1505,
CV_LeafKind_UNION = 0x1506,
CV_LeafKind_ENUM = 0x1507,
CV_LeafKind_DIMARRAY = 0x1508,
CV_LeafKind_PRECOMP = 0x1509,
CV_LeafKind_ALIAS = 0x150a,
CV_LeafKind_DEFARG = 0x150b,
CV_LeafKind_FRIENDFCN = 0x150c,
CV_LeafKind_MEMBER = 0x150d,
CV_LeafKind_STMEMBER = 0x150e,
CV_LeafKind_METHOD = 0x150f,
CV_LeafKind_NESTTYPE = 0x1510,
CV_LeafKind_ONEMETHOD = 0x1511,
CV_LeafKind_NESTTYPEEX = 0x1512,
CV_LeafKind_MEMBERMODIFY = 0x1513,
CV_LeafKind_MANAGED = 0x1514,
CV_LeafKind_TYPESERVER2 = 0x1515,
CV_LeafKind_STRIDED_ARRAY = 0x1516,
CV_LeafKind_HLSL = 0x1517,
CV_LeafKind_MODIFIER_EX = 0x1518,
CV_LeafKind_INTERFACE = 0x1519,
CV_LeafKind_BINTERFACE = 0x151a,
CV_LeafKind_VECTOR = 0x151b,
CV_LeafKind_MATRIX = 0x151c,
CV_LeafKind_VFTABLE = 0x151d,
CV_LeafKind_CLASS2 = 0x1608,
CV_LeafKind_STRUCT2 = 0x1609,
} CV_LeafKindEnum;
internal String8 cv_string_from_numeric_kind(CV_NumericKind v);
internal String8 cv_string_from_arch(CV_Arch v);
internal String8 cv_string_from_sym_kind(CV_SymKind v);
internal String8 cv_string_from_basic_type(CV_BasicType v);
internal String8 cv_type_name_from_basic_type(CV_BasicType v);
internal String8 cv_string_from_leaf_kind(CV_LeafKind v);
internal U64 cv_header_struct_size_from_sym_kind(CV_SymKind v);
internal U64 cv_header_struct_size_from_leaf_kind(CV_LeafKind v);
#endif // CODEVIEW_META_H
+10
View File
@@ -11,6 +11,16 @@ typedef U32 COFF_TimeStamp;
#pragma pack(push,1)
typedef struct COFF_Guid COFF_Guid;
struct COFF_Guid
{
U32 data1;
U16 data2;
U16 data3;
U32 data4;
U32 data5;
};
typedef U16 COFF_Flags;
enum
{
+16 -20
View File
@@ -49,37 +49,33 @@ CTRL_ExceptionCodeKindTable:
////////////////////////////////
//~ rjf: Generators
@table_gen_enum CTRL_ExceptionCodeKind:
@enum CTRL_ExceptionCodeKind:
{
`CTRL_ExceptionCodeKind_Null,`;
@expand(CTRL_ExceptionCodeKindTable a) `CTRL_ExceptionCodeKind_$(a.name),`;
`CTRL_ExceptionCodeKind_COUNT`;
Null,
@expand(CTRL_ExceptionCodeKindTable a) `$(a.name)`,
COUNT,
}
@table_gen_data(type:U32, fallback:0)
ctrl_exception_code_kind_code_table:
@data(U32) ctrl_exception_code_kind_code_table:
{
`0,`;
@expand(CTRL_ExceptionCodeKindTable a) `$(a.code),`;
`0`;
@expand(CTRL_ExceptionCodeKindTable a) `$(a.code)`;
}
@table_gen_data(type:String8, fallback:`{0}`)
ctrl_exception_code_kind_display_string_table:
@data(String8) ctrl_exception_code_kind_display_string_table:
{
`{0},`;
@expand(CTRL_ExceptionCodeKindTable a) `str8_lit_comp("$(a.display_string)"),`;
`{0}`;
@expand(CTRL_ExceptionCodeKindTable a) `str8_lit_comp("$(a.display_string)")`;
}
@table_gen_data(type:String8, fallback:`{0}`)
ctrl_exception_code_kind_lowercase_code_string_table:
@data(String8) ctrl_exception_code_kind_lowercase_code_string_table:
{
`{0},`;
@expand(CTRL_ExceptionCodeKindTable a) `str8_lit_comp("$(a.lower_name)"),`;
`{0}`;
@expand(CTRL_ExceptionCodeKindTable a) `str8_lit_comp("$(a.lower_name)")`;
}
@table_gen_data(type:B8, fallback:0)
ctrl_exception_code_kind_default_enable_table:
@data(B8) ctrl_exception_code_kind_default_enable_table:
{
`0,`;
@expand(CTRL_ExceptionCodeKindTable a) `$(a.default),`;
`0`;
@expand(CTRL_ExceptionCodeKindTable a) `$(a.default)`;
}
+3358 -1468
View File
File diff suppressed because it is too large Load Diff
+352 -111
View File
@@ -10,16 +10,7 @@
typedef U64 CTRL_MsgID;
typedef U64 CTRL_MachineID;
#define CTRL_MachineID_Client (1)
////////////////////////////////
//~ rjf: Handle Type
typedef struct CTRL_Handle CTRL_Handle;
struct CTRL_Handle
{
U64 u64[1];
};
#define CTRL_MachineID_Local (1)
////////////////////////////////
//~ rjf: Machine/Handle Pair Types
@@ -28,7 +19,7 @@ typedef struct CTRL_MachineIDHandlePair CTRL_MachineIDHandlePair;
struct CTRL_MachineIDHandlePair
{
CTRL_MachineID machine_id;
CTRL_Handle handle;
DMN_Handle handle;
};
typedef struct CTRL_MachineIDHandlePairNode CTRL_MachineIDHandlePairNode;
@@ -46,25 +37,117 @@ struct CTRL_MachineIDHandlePairList
U64 count;
};
////////////////////////////////
//~ rjf: Entity Types
typedef enum CTRL_EntityKind
{
CTRL_EntityKind_Null,
CTRL_EntityKind_Root,
CTRL_EntityKind_Machine,
CTRL_EntityKind_Process,
CTRL_EntityKind_Thread,
CTRL_EntityKind_Module,
CTRL_EntityKind_EntryPoint,
CTRL_EntityKind_DebugInfoPath,
CTRL_EntityKind_COUNT
}
CTRL_EntityKind;
typedef struct CTRL_Entity CTRL_Entity;
struct CTRL_Entity
{
CTRL_Entity *first;
CTRL_Entity *last;
CTRL_Entity *next;
CTRL_Entity *prev;
CTRL_Entity *parent;
CTRL_EntityKind kind;
Architecture arch;
CTRL_MachineID machine_id;
DMN_Handle handle;
U64 id;
Rng1U64 vaddr_range;
U64 timestamp;
String8 string;
};
typedef struct CTRL_EntityHashNode CTRL_EntityHashNode;
struct CTRL_EntityHashNode
{
CTRL_EntityHashNode *next;
CTRL_EntityHashNode *prev;
CTRL_Entity *entity;
};
typedef struct CTRL_EntityHashSlot CTRL_EntityHashSlot;
struct CTRL_EntityHashSlot
{
CTRL_EntityHashNode *first;
CTRL_EntityHashNode *last;
};
typedef struct CTRL_EntityStringChunkNode CTRL_EntityStringChunkNode;
struct CTRL_EntityStringChunkNode
{
CTRL_EntityStringChunkNode *next;
U64 size;
};
typedef struct CTRL_EntityStore CTRL_EntityStore;
struct CTRL_EntityStore
{
Arena *arena;
CTRL_Entity *root;
CTRL_Entity *free;
CTRL_EntityHashSlot *hash_slots;
CTRL_EntityHashNode *hash_node_free;
U64 hash_slots_count;
CTRL_EntityStringChunkNode *free_string_chunks[8];
};
////////////////////////////////
//~ rjf: Unwind Types
typedef U32 CTRL_UnwindFlags;
enum
{
CTRL_UnwindFlag_Error = (1<<0),
CTRL_UnwindFlag_Stale = (1<<1),
};
typedef struct CTRL_UnwindStepResult CTRL_UnwindStepResult;
struct CTRL_UnwindStepResult
{
CTRL_UnwindFlags flags;
};
typedef struct CTRL_UnwindFrame CTRL_UnwindFrame;
struct CTRL_UnwindFrame
{
CTRL_UnwindFrame *next;
CTRL_UnwindFrame *prev;
U64 rip;
void *regs;
};
typedef struct CTRL_UnwindFrameNode CTRL_UnwindFrameNode;
struct CTRL_UnwindFrameNode
{
CTRL_UnwindFrameNode *next;
CTRL_UnwindFrameNode *prev;
CTRL_UnwindFrame v;
};
typedef struct CTRL_UnwindFrameArray CTRL_UnwindFrameArray;
struct CTRL_UnwindFrameArray
{
CTRL_UnwindFrame *v;
U64 count;
};
typedef struct CTRL_Unwind CTRL_Unwind;
struct CTRL_Unwind
{
CTRL_UnwindFrame *first;
CTRL_UnwindFrame *last;
U64 count;
B32 error;
CTRL_UnwindFrameArray frames;
CTRL_UnwindFlags flags;
};
////////////////////////////////
@@ -105,8 +188,8 @@ struct CTRL_TrapList
typedef struct CTRL_Spoof CTRL_Spoof;
struct CTRL_Spoof
{
CTRL_Handle process;
CTRL_Handle thread;
DMN_Handle process;
DMN_Handle thread;
U64 vaddr;
U64 new_ip_value;
};
@@ -159,32 +242,39 @@ struct CTRL_UserBreakpointList
typedef enum CTRL_MsgKind
{
CTRL_MsgKind_Null,
CTRL_MsgKind_LaunchAndHandshake,
CTRL_MsgKind_LaunchAndInit,
CTRL_MsgKind_Launch,
CTRL_MsgKind_Attach,
CTRL_MsgKind_Kill,
CTRL_MsgKind_Detach,
CTRL_MsgKind_Run,
CTRL_MsgKind_SingleStep,
CTRL_MsgKind_SetUserEntryPoints,
CTRL_MsgKind_SetModuleDebugInfoPath,
CTRL_MsgKind_COUNT,
}
CTRL_MsgKind;
typedef U32 CTRL_RunFlags;
enum
{
CTRL_RunFlag_StopOnEntryPoint = (1<<0),
};
typedef struct CTRL_Msg CTRL_Msg;
struct CTRL_Msg
{
CTRL_MsgKind kind;
CTRL_RunFlags run_flags;
CTRL_MsgID msg_id;
CTRL_MachineID machine_id;
CTRL_Handle entity;
CTRL_Handle parent;
DMN_Handle entity;
DMN_Handle parent;
U32 entity_id;
U32 exit_code;
B32 env_inherit;
U64 exception_code_filters[(CTRL_ExceptionCodeKind_COUNT+63)/64];
String8 path;
String8List strings;
String8List entry_points;
String8List cmd_line_string_list;
String8List env_string_list;
CTRL_TrapList traps;
@@ -228,6 +318,9 @@ typedef enum CTRL_EventKind
CTRL_EventKind_EndThread,
CTRL_EventKind_EndModule,
//- rjf: debug info changes
CTRL_EventKind_ModuleDebugInfoPathChange,
//- rjf: debug strings
CTRL_EventKind_DebugString,
CTRL_EventKind_ThreadName,
@@ -238,13 +331,6 @@ typedef enum CTRL_EventKind
CTRL_EventKind_MemDecommit,
CTRL_EventKind_MemRelease,
//- rjf: ctrl requests
CTRL_EventKind_LaunchAndHandshakeDone,
CTRL_EventKind_LaunchAndInitDone,
CTRL_EventKind_AttachDone,
CTRL_EventKind_KillDone,
CTRL_EventKind_DetachDone,
CTRL_EventKind_COUNT
}
CTRL_EventKind;
@@ -254,6 +340,7 @@ typedef enum CTRL_EventCause
CTRL_EventCause_Null,
CTRL_EventCause_Error,
CTRL_EventCause_Finished,
CTRL_EventCause_EntryPoint,
CTRL_EventCause_UserBreakpoint,
CTRL_EventCause_InterruptedByTrap,
CTRL_EventCause_InterruptedByException,
@@ -281,8 +368,8 @@ struct CTRL_Event
CTRL_ExceptionKind exception_kind;
CTRL_MsgID msg_id;
CTRL_MachineID machine_id;
CTRL_Handle entity;
CTRL_Handle parent;
DMN_Handle entity;
DMN_Handle parent;
Architecture arch;
U64 u64_code;
U32 entity_id;
@@ -290,6 +377,7 @@ struct CTRL_Event
U64 rip_vaddr;
U64 stack_base;
U64 tls_root;
U64 timestamp;
U32 exception_code;
String8 string;
};
@@ -320,7 +408,8 @@ struct CTRL_ProcessMemoryRangeHashNode
B32 zero_terminated;
Rng1U64 vaddr_range_clamped;
U128 hash;
U64 memgen_idx;
U64 mem_gen;
U64 last_time_requested_us;
B32 is_taken;
};
@@ -338,7 +427,7 @@ struct CTRL_ProcessMemoryCacheNode
CTRL_ProcessMemoryCacheNode *prev;
Arena *arena;
CTRL_MachineID machine_id;
CTRL_Handle process;
DMN_Handle process;
U64 range_hash_slots_count;
CTRL_ProcessMemoryRangeHashSlot *range_hash_slots;
};
@@ -372,6 +461,88 @@ struct CTRL_ProcessMemorySlice
String8 data;
U64 *byte_bad_flags;
U64 *byte_changed_flags;
B32 stale;
B32 any_byte_bad;
B32 any_byte_changed;
};
////////////////////////////////
//~ rjf: Thread Register Cache Types
typedef struct CTRL_ThreadRegCacheNode CTRL_ThreadRegCacheNode;
struct CTRL_ThreadRegCacheNode
{
CTRL_ThreadRegCacheNode *next;
CTRL_ThreadRegCacheNode *prev;
CTRL_MachineID machine_id;
DMN_Handle thread;
U64 block_size;
void *block;
U64 reg_gen;
};
typedef struct CTRL_ThreadRegCacheSlot CTRL_ThreadRegCacheSlot;
struct CTRL_ThreadRegCacheSlot
{
CTRL_ThreadRegCacheNode *first;
CTRL_ThreadRegCacheNode *last;
};
typedef struct CTRL_ThreadRegCacheStripe CTRL_ThreadRegCacheStripe;
struct CTRL_ThreadRegCacheStripe
{
Arena *arena;
OS_Handle rw_mutex;
};
typedef struct CTRL_ThreadRegCache CTRL_ThreadRegCache;
struct CTRL_ThreadRegCache
{
U64 slots_count;
CTRL_ThreadRegCacheSlot *slots;
U64 stripes_count;
CTRL_ThreadRegCacheStripe *stripes;
};
////////////////////////////////
//~ rjf: Module Image Info Cache Types
typedef struct CTRL_ModuleImageInfoCacheNode CTRL_ModuleImageInfoCacheNode;
struct CTRL_ModuleImageInfoCacheNode
{
CTRL_ModuleImageInfoCacheNode *next;
CTRL_ModuleImageInfoCacheNode *prev;
CTRL_MachineID machine_id;
DMN_Handle module;
Arena *arena;
PE_IntelPdata *pdatas;
U64 pdatas_count;
U64 entry_point_voff;
Rng1U64 tls_vaddr_range;
String8 initial_debug_info_path;
};
typedef struct CTRL_ModuleImageInfoCacheSlot CTRL_ModuleImageInfoCacheSlot;
struct CTRL_ModuleImageInfoCacheSlot
{
CTRL_ModuleImageInfoCacheNode *first;
CTRL_ModuleImageInfoCacheNode *last;
};
typedef struct CTRL_ModuleImageInfoCacheStripe CTRL_ModuleImageInfoCacheStripe;
struct CTRL_ModuleImageInfoCacheStripe
{
Arena *arena;
OS_Handle rw_mutex;
};
typedef struct CTRL_ModuleImageInfoCache CTRL_ModuleImageInfoCache;
struct CTRL_ModuleImageInfoCache
{
U64 slots_count;
CTRL_ModuleImageInfoCacheSlot *slots;
U64 stripes_count;
CTRL_ModuleImageInfoCacheStripe *stripes;
};
////////////////////////////////
@@ -388,16 +559,15 @@ struct CTRL_State
{
Arena *arena;
CTRL_WakeupFunctionType *wakeup_hook;
U64 run_idx;
U64 memgen_idx;
U64 reggen_idx;
// rjf: name -> register/alias hash tables for eval
EVAL_String2NumMap arch_string2reg_tables[Architecture_COUNT];
EVAL_String2NumMap arch_string2alias_tables[Architecture_COUNT];
// rjf: process memory cache
// rjf: caches
CTRL_ProcessMemoryCache process_memory_cache;
CTRL_ThreadRegCache thread_reg_cache;
CTRL_ModuleImageInfoCache module_image_info_cache;
// rjf: user -> ctrl msg ring buffer
U64 u2c_ring_size;
@@ -409,6 +579,7 @@ struct CTRL_State
// rjf: ctrl -> user event ring buffer
U64 c2u_ring_size;
U64 c2u_ring_max_string_size;
U8 *c2u_ring_base;
U64 c2u_ring_write_pos;
U64 c2u_ring_read_pos;
@@ -416,11 +587,14 @@ struct CTRL_State
OS_Handle c2u_ring_cv;
// rjf: ctrl thread state
String8 ctrl_thread_log_path;
OS_Handle ctrl_thread;
Arena *demon_event_arena;
DEMON_EventNode *first_demon_event_node;
DEMON_EventNode *last_demon_event_node;
DEMON_EventNode *free_demon_event_node;
Log *ctrl_thread_log;
CTRL_EntityStore *ctrl_thread_entity_store;
Arena *dmn_event_arena;
DMN_EventNode *first_dmn_event_node;
DMN_EventNode *last_dmn_event_node;
DMN_EventNode *free_dmn_event_node;
Arena *user_entry_point_arena;
String8List user_entry_points;
U64 exception_code_filters[(CTRL_ExceptionCodeKind_COUNT+63)/64];
@@ -443,24 +617,28 @@ struct CTRL_State
//~ rjf: Globals
global CTRL_State *ctrl_state = 0;
read_only global CTRL_Entity ctrl_entity_nil =
{
&ctrl_entity_nil,
&ctrl_entity_nil,
&ctrl_entity_nil,
&ctrl_entity_nil,
&ctrl_entity_nil,
};
////////////////////////////////
//~ rjf: Main Layer Initialization
//~ rjf: Logging Markup
internal void ctrl_init(CTRL_WakeupFunctionType *wakeup_hook);
#define CTRL_CtrlThreadLogScope DeferLoop(log_scope_begin(), ctrl_thread__end_and_flush_info_log())
////////////////////////////////
//~ rjf: Basic Type Functions
internal U64 ctrl_hash_from_string(String8 string);
internal CTRL_EventCause ctrl_event_cause_from_demon_event_kind(DEMON_EventKind event_kind);
internal B32 ctrl_handle_match(CTRL_Handle a, CTRL_Handle b);
////////////////////////////////
//~ rjf: Ctrl <-> Demon Handle Translation Functions
internal DEMON_Handle ctrl_demon_handle_from_ctrl(CTRL_Handle h);
internal CTRL_Handle ctrl_handle_from_demon(DEMON_Handle h);
internal U64 ctrl_hash_from_machine_id_handle(CTRL_MachineID machine_id, DMN_Handle handle);
internal CTRL_EventCause ctrl_event_cause_from_dmn_event_kind(DMN_EventKind event_kind);
internal String8 ctrl_string_from_event_kind(CTRL_EventKind kind);
internal String8 ctrl_string_from_msg_kind(CTRL_MsgKind kind);
////////////////////////////////
//~ rjf: Machine/Handle Pair Type Functions
@@ -479,8 +657,6 @@ internal CTRL_TrapList ctrl_trap_list_copy(Arena *arena, CTRL_TrapList *src);
internal void ctrl_user_breakpoint_list_push(Arena *arena, CTRL_UserBreakpointList *list, CTRL_UserBreakpoint *bp);
internal CTRL_UserBreakpointList ctrl_user_breakpoint_list_copy(Arena *arena, CTRL_UserBreakpointList *src);
internal void ctrl_append_resolved_module_user_bp_traps(Arena *arena, DEMON_Handle process, DEMON_Handle module, CTRL_UserBreakpointList *user_bps, DEMON_TrapChunkList *traps_out);
internal void ctrl_append_resolved_process_user_bp_traps(Arena *arena, DEMON_Handle process, CTRL_UserBreakpointList *user_bps, DEMON_TrapChunkList *traps_out);
////////////////////////////////
//~ rjf: Message Type Functions
@@ -503,101 +679,166 @@ internal CTRL_Event *ctrl_event_list_push(Arena *arena, CTRL_EventList *list);
internal void ctrl_event_list_concat_in_place(CTRL_EventList *dst, CTRL_EventList *to_push);
//- rjf: serialization
internal String8 ctrl_serialized_string_from_event(Arena *arena, CTRL_Event *event);
internal String8 ctrl_serialized_string_from_event(Arena *arena, CTRL_Event *event, U64 max);
internal CTRL_Event ctrl_event_from_serialized_string(Arena *arena, String8 string);
////////////////////////////////
//~ rjf: Shared Functions
//~ rjf: Entity Type Functions
//- rjf: run index
internal U64 ctrl_run_idx(void);
internal U64 ctrl_memgen_idx(void);
internal U64 ctrl_reggen_idx(void);
//- rjf: cache creation/destruction
internal CTRL_EntityStore *ctrl_entity_store_alloc(void);
internal void ctrl_entity_store_release(CTRL_EntityStore *store);
//- rjf: halt everything
internal void ctrl_halt(void);
//- rjf: string allocation/deletion
internal U64 ctrl_name_bucket_idx_from_string_size(U64 size);
internal String8 ctrl_entity_string_alloc(CTRL_EntityStore *store, String8 string);
internal void ctrl_entity_string_release(CTRL_EntityStore *store, String8 string);
//- rjf: exe -> dbg path mapping
internal String8 ctrl_inferred_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path);
internal String8 ctrl_forced_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path);
internal String8 ctrl_natural_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path);
internal String8 ctrl_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path);
//- rjf: entity construction/deletion
internal CTRL_Entity *ctrl_entity_alloc(CTRL_EntityStore *store, CTRL_Entity *parent, CTRL_EntityKind kind, Architecture arch, CTRL_MachineID machine_id, DMN_Handle handle, U64 id);
internal void ctrl_entity_release(CTRL_EntityStore *store, CTRL_Entity *entity);
//- rjf: handle -> arch
internal Architecture ctrl_arch_from_handle(CTRL_MachineID machine, CTRL_Handle handle);
//- rjf: entity equipment
internal void ctrl_entity_equip_string(CTRL_EntityStore *store, CTRL_Entity *entity, String8 string);
//- rjf: process memory reading/writing
internal U64 ctrl_process_read(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *dst);
internal B32 ctrl_process_write(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *src);
//- rjf: entity store lookups
internal CTRL_Entity *ctrl_entity_from_machine_id_handle(CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle handle);
internal CTRL_Entity *ctrl_entity_child_from_kind(CTRL_Entity *parent, CTRL_EntityKind kind);
//- rjf: applying events to entity caches
internal void ctrl_entity_store_apply_events(CTRL_EntityStore *store, CTRL_EventList *list);
////////////////////////////////
//~ rjf: Main Layer Initialization
internal void ctrl_init(void);
////////////////////////////////
//~ rjf: Wakeup Callback Registration
internal void ctrl_set_wakeup_hook(CTRL_WakeupFunctionType *wakeup_hook);
////////////////////////////////
//~ rjf: Process Memory Functions
//- rjf: process memory cache interaction
internal U128 ctrl_hash_store_key_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated);
internal U128 ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated, U64 endt_us);
internal U128 ctrl_calc_hash_store_key_from_process_vaddr_range(CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 range, B32 zero_terminated);
internal U128 ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 range, B32 zero_terminated, B32 *out_is_stale, U64 endt_us);
//- rjf: bundled key/stream helper
internal U128 ctrl_hash_store_key_from_process_vaddr_range(CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 range, B32 zero_terminated);
//- rjf: process memory cache reading helpers
internal CTRL_ProcessMemorySlice ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, U64 endt_us);
internal CTRL_ProcessMemorySlice ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us);
internal CTRL_ProcessMemorySlice ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 range, U64 endt_us);
internal CTRL_ProcessMemorySlice ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, DMN_Handle process, U64 vaddr, U64 limit, U64 element_size, U64 endt_us);
internal B32 ctrl_read_cached_process_memory(CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 range, B32 *is_stale_out, void *out, U64 endt_us);
#define ctrl_read_cached_process_memory_struct(machine_id, process, vaddr, is_stale_out, ptr, endt_us) ctrl_read_cached_process_memory((machine_id), (process), r1u64((vaddr), (vaddr)+(sizeof(*(ptr)))), (is_stale_out), (ptr), (endt_us))
//- rjf: register reading/writing
internal void *ctrl_reg_block_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread);
internal B32 ctrl_thread_write_reg_block(CTRL_MachineID machine_id, CTRL_Handle thread, void *block);
internal U64 ctrl_rip_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread);
internal B32 ctrl_thread_write_rip(CTRL_MachineID machine_id, CTRL_Handle thread, U64 rip);
internal U64 ctrl_tls_root_vaddr_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread);
//- rjf: process memory writing
internal B32 ctrl_process_write(CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 range, void *src);
//- rjf: process * vaddr -> module
internal CTRL_Handle ctrl_module_from_process_vaddr(CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr);
////////////////////////////////
//~ rjf: Thread Register Functions
//- rjf: unwinding
internal CTRL_Unwind ctrl_unwind_from_process_thread(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, CTRL_Handle thread);
//- rjf: thread register cache reading
internal void *ctrl_query_cached_reg_block_from_thread(Arena *arena, CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle thread);
internal U64 ctrl_query_cached_tls_root_vaddr_from_thread(CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle thread);
internal U64 ctrl_query_cached_rip_from_thread(CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle thread);
internal U64 ctrl_query_cached_rsp_from_thread(CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle thread);
//- rjf: thread register writing
internal B32 ctrl_thread_write_reg_block(CTRL_MachineID machine_id, DMN_Handle thread, void *block);
////////////////////////////////
//~ rjf: Module Image Info Functions
//- rjf: cache lookups
internal PE_IntelPdata *ctrl_intel_pdata_from_module_voff(Arena *arena, CTRL_MachineID machine_id, DMN_Handle module_handle, U64 voff);
internal U64 ctrl_entry_point_voff_from_module(CTRL_MachineID machine_id, DMN_Handle module_handle);
internal Rng1U64 ctrl_tls_vaddr_range_from_module(CTRL_MachineID machine_id, DMN_Handle module_handle);
internal String8 ctrl_initial_debug_info_path_from_module(Arena *arena, CTRL_MachineID machine_id, DMN_Handle module_handle);
////////////////////////////////
//~ rjf: Unwinding Functions
//- rjf: unwind deep copier
internal CTRL_Unwind ctrl_unwind_deep_copy(Arena *arena, Architecture arch, CTRL_Unwind *src);
//- rjf: [x64]
internal REGS_Reg64 *ctrl_unwind_reg_from_pe_gpr_reg__pe_x64(REGS_RegBlockX64 *regs, PE_UnwindGprRegX64 gpr_reg);
internal CTRL_UnwindStepResult ctrl_unwind_step__pe_x64(CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle process_handle, DMN_Handle module, REGS_RegBlockX64 *regs, U64 endt_us);
//- rjf: abstracted unwind step
internal CTRL_UnwindStepResult ctrl_unwind_step(CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle process_handle, DMN_Handle module, Architecture arch, void *reg_block, U64 endt_us);
//- rjf: abstracted full unwind
internal CTRL_Unwind ctrl_unwind_from_thread(Arena *arena, CTRL_EntityStore *store, CTRL_MachineID machine_id, DMN_Handle thread, U64 endt_us);
////////////////////////////////
//~ rjf: Halting All Attached Processes
internal void ctrl_halt(void);
////////////////////////////////
//~ rjf: Shared Accessor Functions
//- rjf: generation counters
internal U64 ctrl_run_gen(void);
internal U64 ctrl_mem_gen(void);
internal U64 ctrl_reg_gen(void);
//- rjf: name -> register/alias hash tables, for eval
internal EVAL_String2NumMap *ctrl_string2reg_from_arch(Architecture arch);
internal EVAL_String2NumMap *ctrl_string2alias_from_arch(Architecture arch);
////////////////////////////////
//~ rjf: User -> Ctrl Communication
//~ rjf: Control-Thread Functions
//- rjf: user -> control thread communication
internal B32 ctrl_u2c_push_msgs(CTRL_MsgList *msgs, U64 endt_us);
internal CTRL_MsgList ctrl_u2c_pop_msgs(Arena *arena);
////////////////////////////////
//~ rjf: Ctrl -> User Communication
//- rjf: control -> user thread communication
internal void ctrl_c2u_push_events(CTRL_EventList *events);
internal CTRL_EventList ctrl_c2u_pop_events(Arena *arena);
////////////////////////////////
//~ rjf: User -> Memory Stream Communication
internal B32 ctrl_u2ms_enqueue_req(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, U64 endt_us);
internal void ctrl_u2ms_dequeue_req(CTRL_MachineID *out_machine_id, CTRL_Handle *out_process, Rng1U64 *out_vaddr_range, B32 *out_zero_terminated);
////////////////////////////////
//~ rjf: Control-Thread-Only Functions
//- rjf: entry point
internal void ctrl_thread__entry_point(void *p);
//- rjf: breakpoint resolution
internal void ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, CTRL_MachineID machine_id, DMN_Handle process, DMN_Handle module, CTRL_UserBreakpointList *user_bps, DMN_TrapChunkList *traps_out);
internal void ctrl_thread__append_resolved_process_user_bp_traps(Arena *arena, CTRL_MachineID machine_id, DMN_Handle process, CTRL_UserBreakpointList *user_bps, DMN_TrapChunkList *traps_out);
//- rjf: module lifetime open/close work
internal void ctrl_thread__module_open(CTRL_MachineID machine_id, DMN_Handle process, DMN_Handle module, Rng1U64 vaddr_range, String8 path);
internal void ctrl_thread__module_close(CTRL_MachineID machine_id, DMN_Handle module);
//- rjf: attached process running/event gathering
internal DEMON_Event *ctrl_thread__next_demon_event(Arena *arena, CTRL_Msg *msg, DEMON_RunCtrls *run_ctrls, CTRL_Spoof *spoof);
internal DMN_Event *ctrl_thread__next_dmn_event(Arena *arena, DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg, DMN_RunCtrls *run_ctrls, CTRL_Spoof *spoof);
//- rjf: eval helpers
internal B32 ctrl_eval_memory_read(void *u, void *out, U64 addr, U64 size);
//- rjf: log flusher
internal void ctrl_thread__flush_info_log(String8 string);
internal void ctrl_thread__end_and_flush_info_log(void);
//- rjf: msg kind implementations
internal void ctrl_thread__launch_and_handshake(CTRL_Msg *msg);
internal void ctrl_thread__launch_and_init(CTRL_Msg *msg);
internal void ctrl_thread__attach(CTRL_Msg *msg);
internal void ctrl_thread__kill(CTRL_Msg *msg);
internal void ctrl_thread__detach(CTRL_Msg *msg);
internal void ctrl_thread__run(CTRL_Msg *msg);
internal void ctrl_thread__single_step(CTRL_Msg *msg);
internal void ctrl_thread__launch(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg);
internal void ctrl_thread__attach(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg);
internal void ctrl_thread__kill(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg);
internal void ctrl_thread__detach(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg);
internal void ctrl_thread__run(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg);
internal void ctrl_thread__single_step(DMN_CtrlCtx *ctrl_ctx, CTRL_Msg *msg);
////////////////////////////////
//~ rjf: Memory-Stream-Thread-Only Functions
//~ rjf: Memory-Stream Thread Functions
//- rjf: user -> memory stream communication
internal B32 ctrl_u2ms_enqueue_req(CTRL_MachineID machine_id, DMN_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, U64 endt_us);
internal void ctrl_u2ms_dequeue_req(CTRL_MachineID *out_machine_id, DMN_Handle *out_process, Rng1U64 *out_vaddr_range, B32 *out_zero_terminated);
//- rjf: entry point
internal void ctrl_mem_stream_thread__entry_point(void *p);
#endif //CTRL_CORE_H
#endif // CTRL_CORE_H
+1 -1
View File
@@ -74,4 +74,4 @@
#include "ctrl_core.h"
#endif //CTRL_INC_H
#endif // CTRL_INC_H
+171
View File
@@ -3,3 +3,174 @@
//- GENERATED CODE
C_LINKAGE_BEGIN
U32 ctrl_exception_code_kind_code_table[38] =
{
0,
0x40010005,
0x40010008,
0x40080201,
0x40080202,
0x0000071a,
0x80000002,
0xc0000005,
0xc0000006,
0xc0000008,
0xc0000017,
0xc000001d,
0xc0000025,
0xc0000026,
0xc000008c,
0xc000008d,
0xc000008e,
0xc000008f,
0xc0000090,
0xc0000091,
0xc0000092,
0xc0000093,
0xc0000094,
0xc0000095,
0xc0000096,
0xc00000fd,
0xc0000135,
0xc0000138,
0xc0000139,
0xc0000142,
0xc00002b4,
0xc00002b5,
0xc0000420,
0xc06d007e,
0xc06d007f,
0xe073616e,
0xe0736171,
0x0000087a,
};
String8 ctrl_exception_code_kind_display_string_table[38] =
{
{0},
str8_lit_comp("(Win32) Control-C"),
str8_lit_comp("(Win32) Control-Break"),
str8_lit_comp("(Win32) WinRT Originate Error"),
str8_lit_comp("(Win32) WinRT Transform Error"),
str8_lit_comp("(Win32) RPC Call Cancelled"),
str8_lit_comp("(Win32) Data Type Misalignment"),
str8_lit_comp("(Win32) Access Violation"),
str8_lit_comp("(Win32) In Page Error"),
str8_lit_comp("(Win32) Invalid Handle Specified"),
str8_lit_comp("(Win32) Not Enough Quota"),
str8_lit_comp("(Win32) Illegal Instruction"),
str8_lit_comp("(Win32) Cannot Continue From Exception"),
str8_lit_comp("(Win32) Invalid Exception Disposition Returned By Handler"),
str8_lit_comp("(Win32) Array Bounds Exceeded"),
str8_lit_comp("(Win32) Floating-Point Denormal Operand"),
str8_lit_comp("(Win32) Floating-Point Division By Zero"),
str8_lit_comp("(Win32) Floating-Point Inexact Result"),
str8_lit_comp("(Win32) Floating-Point Invalid Operation"),
str8_lit_comp("(Win32) Floating-Point Overflow"),
str8_lit_comp("(Win32) Floating-Point Stack Check"),
str8_lit_comp("(Win32) Floating-Point Underflow"),
str8_lit_comp("(Win32) Integer Division By Zero"),
str8_lit_comp("(Win32) Integer Overflow"),
str8_lit_comp("(Win32) Privileged Instruction"),
str8_lit_comp("(Win32) Stack Overflow"),
str8_lit_comp("(Win32) Unable To Locate DLL"),
str8_lit_comp("(Win32) Ordinal Not Found"),
str8_lit_comp("(Win32) Entry Point Not Found"),
str8_lit_comp("(Win32) DLL Initialization Failed"),
str8_lit_comp("(Win32) Floating Point SSE Multiple Faults"),
str8_lit_comp("(Win32) Floating Point SSE Multiple Traps"),
str8_lit_comp("(Win32) Assertion Failed"),
str8_lit_comp("(Win32) Module Not Found"),
str8_lit_comp("(Win32) Procedure Not Found"),
str8_lit_comp("(Win32) Sanitizer Error Detected"),
str8_lit_comp("(Win32) Sanitizer Raw Access Violation"),
str8_lit_comp("(Win32) DirectX Debug Layer"),
};
String8 ctrl_exception_code_kind_lowercase_code_string_table[38] =
{
{0},
str8_lit_comp("win32_ctrl_c"),
str8_lit_comp("win32_ctrl_break"),
str8_lit_comp("win32_win_rt_originate_error"),
str8_lit_comp("win32_win_rt_transform_error"),
str8_lit_comp("win32_rpc_call_cancelled"),
str8_lit_comp("win32_datatype_misalignment"),
str8_lit_comp("win32_access_violation"),
str8_lit_comp("win32_in_page_error"),
str8_lit_comp("win32_invalid_handle"),
str8_lit_comp("win32_not_enough_quota"),
str8_lit_comp("win32_illegal_instruction"),
str8_lit_comp("win32_cannot_continue_exception"),
str8_lit_comp("win32_invalid_exception_disposition"),
str8_lit_comp("win32_array_bounds_exceeded"),
str8_lit_comp("win32_floating_point_denormal_operand"),
str8_lit_comp("win32_floating_point_division_by_zero"),
str8_lit_comp("win32_floating_point_inexact_result"),
str8_lit_comp("win32_floating_point_invalid_operation"),
str8_lit_comp("win32_floating_point_overflow"),
str8_lit_comp("win32_floating_point_stack_check"),
str8_lit_comp("win32_floating_point_underflow"),
str8_lit_comp("win32_integer_division_by_zero"),
str8_lit_comp("win32_integer_overflow"),
str8_lit_comp("win32_privileged_instruction"),
str8_lit_comp("win32_stack_overflow"),
str8_lit_comp("win32_unable_to_locate_dll"),
str8_lit_comp("win32_ordinal_not_found"),
str8_lit_comp("win32_entry_point_not_found"),
str8_lit_comp("win32_dll_initialization_failed"),
str8_lit_comp("win32_floating_point_sse_multiple_faults"),
str8_lit_comp("win32_floating_point_sse_multiple_traps"),
str8_lit_comp("win32_assertion_failed"),
str8_lit_comp("win32_module_not_found"),
str8_lit_comp("win32_procedure_not_found"),
str8_lit_comp("win32_sanitizer_error_detected"),
str8_lit_comp("win32_sanitizer_raw_access_violation"),
str8_lit_comp("win32_directx_debug_layer"),
};
B8 ctrl_exception_code_kind_default_enable_table[38] =
{
0,
1,
1,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
1,
};
C_LINKAGE_END
+7 -168
View File
@@ -46,176 +46,15 @@ CTRL_ExceptionCodeKind_Win32ProcedureNotFound,
CTRL_ExceptionCodeKind_Win32SanitizerErrorDetected,
CTRL_ExceptionCodeKind_Win32SanitizerRawAccessViolation,
CTRL_ExceptionCodeKind_Win32DirectXDebugLayer,
CTRL_ExceptionCodeKind_COUNT
CTRL_ExceptionCodeKind_COUNT,
} CTRL_ExceptionCodeKind;
U32 ctrl_exception_code_kind_code_table[] =
{
0,
0x40010005,
0x40010008,
0x40080201,
0x40080202,
0x0000071a,
0x80000002,
0xc0000005,
0xc0000006,
0xc0000008,
0xc0000017,
0xc000001d,
0xc0000025,
0xc0000026,
0xc000008c,
0xc000008d,
0xc000008e,
0xc000008f,
0xc0000090,
0xc0000091,
0xc0000092,
0xc0000093,
0xc0000094,
0xc0000095,
0xc0000096,
0xc00000fd,
0xc0000135,
0xc0000138,
0xc0000139,
0xc0000142,
0xc00002b4,
0xc00002b5,
0xc0000420,
0xc06d007e,
0xc06d007f,
0xe073616e,
0xe0736171,
0x0000087a,
};
String8 ctrl_exception_code_kind_display_string_table[] =
{
{0},
str8_lit_comp("(Win32) Control-C"),
str8_lit_comp("(Win32) Control-Break"),
str8_lit_comp("(Win32) WinRT Originate Error"),
str8_lit_comp("(Win32) WinRT Transform Error"),
str8_lit_comp("(Win32) RPC Call Cancelled"),
str8_lit_comp("(Win32) Data Type Misalignment"),
str8_lit_comp("(Win32) Access Violation"),
str8_lit_comp("(Win32) In Page Error"),
str8_lit_comp("(Win32) Invalid Handle Specified"),
str8_lit_comp("(Win32) Not Enough Quota"),
str8_lit_comp("(Win32) Illegal Instruction"),
str8_lit_comp("(Win32) Cannot Continue From Exception"),
str8_lit_comp("(Win32) Invalid Exception Disposition Returned By Handler"),
str8_lit_comp("(Win32) Array Bounds Exceeded"),
str8_lit_comp("(Win32) Floating-Point Denormal Operand"),
str8_lit_comp("(Win32) Floating-Point Division By Zero"),
str8_lit_comp("(Win32) Floating-Point Inexact Result"),
str8_lit_comp("(Win32) Floating-Point Invalid Operation"),
str8_lit_comp("(Win32) Floating-Point Overflow"),
str8_lit_comp("(Win32) Floating-Point Stack Check"),
str8_lit_comp("(Win32) Floating-Point Underflow"),
str8_lit_comp("(Win32) Integer Division By Zero"),
str8_lit_comp("(Win32) Integer Overflow"),
str8_lit_comp("(Win32) Privileged Instruction"),
str8_lit_comp("(Win32) Stack Overflow"),
str8_lit_comp("(Win32) Unable To Locate DLL"),
str8_lit_comp("(Win32) Ordinal Not Found"),
str8_lit_comp("(Win32) Entry Point Not Found"),
str8_lit_comp("(Win32) DLL Initialization Failed"),
str8_lit_comp("(Win32) Floating Point SSE Multiple Faults"),
str8_lit_comp("(Win32) Floating Point SSE Multiple Traps"),
str8_lit_comp("(Win32) Assertion Failed"),
str8_lit_comp("(Win32) Module Not Found"),
str8_lit_comp("(Win32) Procedure Not Found"),
str8_lit_comp("(Win32) Sanitizer Error Detected"),
str8_lit_comp("(Win32) Sanitizer Raw Access Violation"),
str8_lit_comp("(Win32) DirectX Debug Layer"),
};
String8 ctrl_exception_code_kind_lowercase_code_string_table[] =
{
{0},
str8_lit_comp("win32_ctrl_c"),
str8_lit_comp("win32_ctrl_break"),
str8_lit_comp("win32_win_rt_originate_error"),
str8_lit_comp("win32_win_rt_transform_error"),
str8_lit_comp("win32_rpc_call_cancelled"),
str8_lit_comp("win32_datatype_misalignment"),
str8_lit_comp("win32_access_violation"),
str8_lit_comp("win32_in_page_error"),
str8_lit_comp("win32_invalid_handle"),
str8_lit_comp("win32_not_enough_quota"),
str8_lit_comp("win32_illegal_instruction"),
str8_lit_comp("win32_cannot_continue_exception"),
str8_lit_comp("win32_invalid_exception_disposition"),
str8_lit_comp("win32_array_bounds_exceeded"),
str8_lit_comp("win32_floating_point_denormal_operand"),
str8_lit_comp("win32_floating_point_division_by_zero"),
str8_lit_comp("win32_floating_point_inexact_result"),
str8_lit_comp("win32_floating_point_invalid_operation"),
str8_lit_comp("win32_floating_point_overflow"),
str8_lit_comp("win32_floating_point_stack_check"),
str8_lit_comp("win32_floating_point_underflow"),
str8_lit_comp("win32_integer_division_by_zero"),
str8_lit_comp("win32_integer_overflow"),
str8_lit_comp("win32_privileged_instruction"),
str8_lit_comp("win32_stack_overflow"),
str8_lit_comp("win32_unable_to_locate_dll"),
str8_lit_comp("win32_ordinal_not_found"),
str8_lit_comp("win32_entry_point_not_found"),
str8_lit_comp("win32_dll_initialization_failed"),
str8_lit_comp("win32_floating_point_sse_multiple_faults"),
str8_lit_comp("win32_floating_point_sse_multiple_traps"),
str8_lit_comp("win32_assertion_failed"),
str8_lit_comp("win32_module_not_found"),
str8_lit_comp("win32_procedure_not_found"),
str8_lit_comp("win32_sanitizer_error_detected"),
str8_lit_comp("win32_sanitizer_raw_access_violation"),
str8_lit_comp("win32_directx_debug_layer"),
};
B8 ctrl_exception_code_kind_default_enable_table[] =
{
0,
1,
1,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
1,
};
C_LINKAGE_BEGIN
extern U32 ctrl_exception_code_kind_code_table[38];
extern String8 ctrl_exception_code_kind_display_string_table[38];
extern String8 ctrl_exception_code_kind_lowercase_code_string_table[38];
extern B8 ctrl_exception_code_kind_default_enable_table[38];
C_LINKAGE_END
#endif // CTRL_META_H
-540
View File
@@ -1,540 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Main Layer Initialization
internal void
dasm_init(void)
{
Arena *arena = arena_alloc();
dasm_shared = push_array(arena, DASM_Shared, 1);
dasm_shared->arena = arena;
dasm_shared->entity_map.slots_count = 1024;
dasm_shared->entity_map.slots = push_array(arena, DASM_EntitySlot, dasm_shared->entity_map.slots_count);
dasm_shared->entity_map_stripes.count = 64;
dasm_shared->entity_map_stripes.v = push_array(arena, DASM_Stripe, dasm_shared->entity_map_stripes.count);
for(U64 idx = 0; idx < dasm_shared->entity_map_stripes.count; idx += 1)
{
dasm_shared->entity_map_stripes.v[idx].arena = arena_alloc();
dasm_shared->entity_map_stripes.v[idx].rw_mutex = os_rw_mutex_alloc();
dasm_shared->entity_map_stripes.v[idx].cv = os_condition_variable_alloc();
}
dasm_shared->u2d_ring_mutex = os_mutex_alloc();
dasm_shared->u2d_ring_cv = os_condition_variable_alloc();
dasm_shared->u2d_ring_size = KB(64);
dasm_shared->u2d_ring_base = push_array_no_zero(arena, U8, dasm_shared->u2d_ring_size);
dasm_shared->decode_thread_count = Max(1, os_logical_core_count()-1);
dasm_shared->decode_threads = push_array(arena, OS_Handle, dasm_shared->decode_thread_count);
for(U64 idx = 0; idx < dasm_shared->decode_thread_count; idx += 1)
{
dasm_shared->decode_threads[idx] = os_launch_thread(dasm_decode_thread_entry_point, (void *)idx, 0);
}
}
////////////////////////////////
//~ rjf: Basic Helpers
internal U64
dasm_hash_from_string(String8 string)
{
U64 result = 5381;
for(U64 i = 0; i < string.size; i += 1)
{
result = ((result << 5) + result) + string.str[i];
}
return result;
}
////////////////////////////////
//~ rjf: Instruction Type Functions
internal void
dasm_inst_chunk_list_push(Arena *arena, DASM_InstChunkList *list, U64 cap, DASM_Inst *inst)
{
DASM_InstChunkNode *node = list->last;
if(node == 0 || node->count >= node->cap)
{
node = push_array(arena, DASM_InstChunkNode, 1);
node->v = push_array_no_zero(arena, DASM_Inst, cap);
node->cap = cap;
SLLQueuePush(list->first, list->last, node);
list->node_count += 1;
}
MemoryCopyStruct(&node->v[node->count], inst);
node->count += 1;
list->inst_count += 1;
}
internal DASM_InstArray
dasm_inst_array_from_chunk_list(Arena *arena, DASM_InstChunkList *list)
{
DASM_InstArray array = {0};
array.count = list->inst_count;
array.v = push_array_no_zero(arena, DASM_Inst, array.count);
U64 idx = 0;
for(DASM_InstChunkNode *n = list->first; n != 0; n = n->next)
{
MemoryCopy(array.v+idx, n->v, sizeof(DASM_Inst)*n->count);
idx += n->count;
}
return array;
}
internal U64
dasm_inst_array_idx_from_off__linear_scan(DASM_InstArray *array, U64 off)
{
U64 result = 0;
for(U64 idx = 0; idx < array->count; idx += 1)
{
if(array->v[idx].off == off)
{
result = idx;
break;
}
}
return result;
}
internal U64
dasm_inst_array_off_from_idx(DASM_InstArray *array, U64 idx)
{
U64 off = 0;
if(idx < array->count)
{
off = array->v[idx].off;
}
return off;
}
////////////////////////////////
//~ rjf: Disassembly Functions
#include "third_party/udis86/config.h"
#include "third_party/udis86/udis86.h"
#include "third_party/udis86/libudis86/decode.c"
#include "third_party/udis86/libudis86/itab.c"
#include "third_party/udis86/libudis86/syn-att.c"
#include "third_party/udis86/libudis86/syn-intel.c"
#include "third_party/udis86/libudis86/syn.c"
#include "third_party/udis86/libudis86/udis86.c"
internal DASM_InstChunkList
dasm_inst_chunk_list_from_arch_addr_data(Arena *arena, U64 *bytes_processed_counter, Architecture arch, U64 addr, String8 data)
{
DASM_InstChunkList inst_list = {0};
switch(arch)
{
default:{}break;
//- rjf: x86/x64 decoding
case Architecture_x64:
case Architecture_x86:
{
// rjf: grab context
struct ud udc;
ud_init(&udc);
ud_set_mode(&udc, bit_size_from_arch(arch));
ud_set_pc(&udc, addr);
ud_set_input_buffer(&udc, data.str, data.size);
ud_set_vendor(&udc, UD_VENDOR_ANY);
ud_set_syntax(&udc, UD_SYN_INTEL);
// rjf: disassemble
U64 byte_process_start_off = 0;
for(U64 off = 0; off < data.size;)
{
// rjf: disassemble one instruction
U64 size = ud_disassemble(&udc);
if(size == 0)
{
break;
}
// rjf: analyze
struct ud_operand *first_op = (struct ud_operand *)ud_insn_opr(&udc, 0);
U64 rel_voff = (first_op != 0 && first_op->type == UD_OP_JIMM) ? ud_syn_rel_target(&udc, first_op) : 0;
// rjf: push
String8 string = push_str8f(arena, "%s", udc.asm_buf);
DASM_Inst inst = {string, off, rel_voff};
dasm_inst_chunk_list_push(arena, &inst_list, 1024, &inst);
// rjf: increment
off += size;
if(bytes_processed_counter != 0 && (off-byte_process_start_off >= 1000))
{
ins_atomic_u64_add_eval(bytes_processed_counter, (off-byte_process_start_off));
byte_process_start_off = off;
}
}
}break;
}
return inst_list;
}
////////////////////////////////
//~ rjf: Cache Lookups
//- rjf: opening handles & correllation with module
internal DASM_Handle
dasm_handle_from_ctrl_process_range(CTRL_MachineID machine, CTRL_Handle process, Rng1U64 vaddr_range)
{
DASM_Handle result = {0};
if(machine != 0 && process.u64[0] != 0)
{
U64 hash = dasm_hash_from_string(str8_struct(&process));
U64 slot_idx = hash%dasm_shared->entity_map.slots_count;
U64 stripe_idx = slot_idx%dasm_shared->entity_map_stripes.count;
DASM_EntitySlot *slot = &dasm_shared->entity_map.slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->entity_map_stripes.v[stripe_idx];
OS_MutexScopeW(stripe->rw_mutex)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->machine_id == machine &&
ctrl_handle_match(e->process, process) &&
MemoryMatchStruct(&e->vaddr_range, &vaddr_range))
{
entity = e;
break;
}
}
if(entity == 0)
{
entity = push_array(stripe->arena, DASM_Entity, 1);
SLLQueuePush(slot->first, slot->last, entity);
entity->machine_id = machine;
entity->process = process;
entity->vaddr_range= vaddr_range;
entity->id = ins_atomic_u64_inc_eval(&dasm_shared->entity_id_gen);
entity->decode_inst_arena = arena_alloc__sized(MB(256), KB(64));
entity->decode_string_arena = arena_alloc__sized(GB(1), KB(64));
}
result.u64[0] = hash;
result.u64[1] = entity->id;
}
}
return result;
}
//- rjf: asking for top-level info of a handle
internal DASM_BinaryInfo
dasm_binary_info_from_handle(Arena *arena, DASM_Handle handle)
{
DASM_BinaryInfo info = {0};
{
U64 hash = handle.u64[0];
U64 id = handle.u64[1];
U64 slot_idx = hash%dasm_shared->entity_map.slots_count;
U64 stripe_idx = slot_idx%dasm_shared->entity_map_stripes.count;
DASM_EntitySlot *slot = &dasm_shared->entity_map.slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->entity_map_stripes.v[stripe_idx];
OS_MutexScopeR(stripe->rw_mutex)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->id == id)
{
entity = e;
break;
}
}
if(entity != 0)
{
info.machine_id = entity->machine_id;
info.process = entity->process;
info.vaddr_range = entity->vaddr_range;
info.bytes_processed = ins_atomic_u64_eval(&entity->bytes_processed);
info.bytes_to_process = ins_atomic_u64_eval(&entity->bytes_to_process);
}
}
}
return info;
}
//- rjf: asking for decoded instructions
internal DASM_InstArray
dasm_inst_array_from_handle(Arena *arena, DASM_Handle handle, U64 endt_us)
{
DASM_InstArray result = {0};
if(handle.u64[0] != 0 || handle.u64[1] != 0)
{
U64 hash = handle.u64[0];
U64 id = handle.u64[1];
U64 slot_idx = hash%dasm_shared->entity_map.slots_count;
U64 stripe_idx = slot_idx%dasm_shared->entity_map_stripes.count;
DASM_EntitySlot *slot = &dasm_shared->entity_map.slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->entity_map_stripes.v[stripe_idx];
B32 sent = 0;
OS_MutexScopeR(stripe->rw_mutex) for(;;)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->id == id)
{
entity = e;
break;
}
}
U64 last_time_sent_us = 0;
if(entity != 0)
{
U64 bytes_processed = ins_atomic_u64_eval(&entity->bytes_processed);
U64 bytes_to_process = ins_atomic_u64_eval(&entity->bytes_to_process);
last_time_sent_us = ins_atomic_u64_eval(&entity->last_time_sent_us);
if(bytes_processed == bytes_to_process && bytes_processed != 0)
{
result.count = entity->decode_inst_array.count;
result.v = push_array_no_zero(arena, DASM_Inst, result.count);
MemoryCopy(result.v, entity->decode_inst_array.v, sizeof(DASM_Inst)*result.count);
for(U64 idx = 0; idx < result.count; idx += 1)
{
result.v[idx].string = push_str8_copy(arena, result.v[idx].string);
}
break;
}
}
if(!sent && entity != 0 && last_time_sent_us+10000 <= os_now_microseconds())
{
DASM_DecodeRequest req = {handle};
sent = dasm_u2d_enqueue_request(&req, endt_us);
ins_atomic_u64_eval_assign(&entity->last_time_sent_us, os_now_microseconds());
}
if(os_now_microseconds() >= endt_us)
{
break;
}
os_condition_variable_wait_rw_r(stripe->cv, stripe->rw_mutex, endt_us);
}
}
return result;
}
////////////////////////////////
//~ rjf: Decode Threads
internal B32
dasm_u2d_enqueue_request(DASM_DecodeRequest *req, U64 endt_us)
{
B32 result = 0;
OS_MutexScope(dasm_shared->u2d_ring_mutex) for(;;)
{
U64 unconsumed_size = (dasm_shared->u2d_ring_write_pos-dasm_shared->u2d_ring_read_pos);
U64 available_size = (dasm_shared->u2d_ring_size-unconsumed_size);
if(available_size >= sizeof(*req))
{
result = 1;
dasm_shared->u2d_ring_write_pos += ring_write_struct(dasm_shared->u2d_ring_base, dasm_shared->u2d_ring_size, dasm_shared->u2d_ring_write_pos, req);
dasm_shared->u2d_ring_write_pos += 7;
dasm_shared->u2d_ring_write_pos -= dasm_shared->u2d_ring_write_pos%8;
break;
}
if(os_now_microseconds() >= endt_us)
{
break;
}
os_condition_variable_wait(dasm_shared->u2d_ring_cv, dasm_shared->u2d_ring_mutex, endt_us);
}
if(result)
{
os_condition_variable_broadcast(dasm_shared->u2d_ring_cv);
}
return result;
}
internal DASM_DecodeRequest
dasm_u2d_dequeue_request(void)
{
DASM_DecodeRequest req = {0};
OS_MutexScope(dasm_shared->u2d_ring_mutex) for(;;)
{
U64 unconsumed_size = (dasm_shared->u2d_ring_write_pos-dasm_shared->u2d_ring_read_pos);
if(unconsumed_size >= sizeof(DASM_DecodeRequest))
{
dasm_shared->u2d_ring_read_pos += ring_read_struct(dasm_shared->u2d_ring_base, dasm_shared->u2d_ring_size, dasm_shared->u2d_ring_read_pos, &req);
dasm_shared->u2d_ring_read_pos += 7;
dasm_shared->u2d_ring_read_pos -= dasm_shared->u2d_ring_read_pos%8;
break;
}
os_condition_variable_wait(dasm_shared->u2d_ring_cv, dasm_shared->u2d_ring_mutex, max_U64);
}
os_condition_variable_broadcast(dasm_shared->u2d_ring_cv);
return req;
}
internal void
dasm_decode_thread_entry_point(void *p)
{
TCTX tctx_;
tctx_init_and_equip(&tctx_);
for(;;)
{
Temp scratch = scratch_begin(0, 0);
//- rjf: get next request & unpack
DASM_DecodeRequest req = dasm_u2d_dequeue_request();
DASM_Handle handle = req.handle;
U64 hash = handle.u64[0];
U64 id = handle.u64[1];
U64 slot_idx = hash%dasm_shared->entity_map.slots_count;
U64 stripe_idx = slot_idx%dasm_shared->entity_map_stripes.count;
DASM_EntitySlot *slot = &dasm_shared->entity_map.slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->entity_map_stripes.v[stripe_idx];
//- rjf: request -> ctrl info
B32 is_first_to_task = 0;
CTRL_MachineID ctrl_machine_id = 0;
CTRL_Handle ctrl_process = {0};
Rng1U64 vaddr_range = {0};
Architecture arch = Architecture_Null;
U64 *bytes_processed_counter = 0;
OS_MutexScopeR(stripe->rw_mutex)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->id == id)
{
entity = e;
break;
}
}
if(entity != 0)
{
U64 initial_working_count = ins_atomic_u32_eval_cond_assign(&entity->working_count, 1, 0);
if(initial_working_count == 0)
{
is_first_to_task = 1;
ctrl_machine_id = entity->machine_id;
ctrl_process = entity->process;
vaddr_range = entity->vaddr_range;
arch = ctrl_arch_from_handle(ctrl_machine_id, ctrl_process);
bytes_processed_counter = &entity->bytes_processed;
U64 bytes_to_process = dim_1u64(vaddr_range);
ins_atomic_u64_eval_assign(&entity->bytes_processed, 0);
ins_atomic_u64_eval_assign(&entity->bytes_to_process, bytes_to_process);
}
}
}
//- rjf: bad handle or machine id -> bad task
B32 good_task = (is_first_to_task && ctrl_process.u64[0] != 0 && ctrl_machine_id != 0 && arch != Architecture_Null && bytes_processed_counter != 0);
//- rjf: good task -> clear entity's info
if(good_task)
{
OS_MutexScopeW(stripe->rw_mutex)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->id == id)
{
entity = e;
break;
}
}
if(entity != 0)
{
arena_clear(entity->decode_inst_arena);
arena_clear(entity->decode_string_arena);
MemoryZeroStruct(&entity->decode_inst_array);
}
}
}
//- rjf: good task -> read process memory & decode instructions - stop each
// 4k and write into cache, so users can read incremental results
if(good_task)
{
U64 chunk_size = KB(4);
for(U64 off = 0; vaddr_range.min+off < vaddr_range.max; off += chunk_size)
{
Rng1U64 chunk_vaddr_range = r1u64(vaddr_range.min+off, vaddr_range.min+off+chunk_size);
chunk_vaddr_range.min = ClampTop(chunk_vaddr_range.min, vaddr_range.max);
chunk_vaddr_range.max = ClampTop(chunk_vaddr_range.max, vaddr_range.max);
//- rjf: read next chunk & decode
String8 data = {0};
DASM_InstChunkList inst_list = {0};
if(good_task)
{
data.str = push_array_no_zero(scratch.arena, U8, dim_1u64(chunk_vaddr_range));
data.size = ctrl_process_read(ctrl_machine_id, ctrl_process, chunk_vaddr_range, data.str);
if(data.size != 0)
{
inst_list = dasm_inst_chunk_list_from_arch_addr_data(scratch.arena, bytes_processed_counter, arch, chunk_vaddr_range.min, data);
}
}
//- rjf: write into cache
{
OS_MutexScopeW(stripe->rw_mutex)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->id == id)
{
entity = e;
break;
}
}
if(entity != 0)
{
DASM_Inst *new_chunk_base = push_array(entity->decode_inst_arena, DASM_Inst, inst_list.inst_count);
U64 off = 0;
for(DASM_InstChunkNode *node = inst_list.first; node != 0; node = node->next)
{
MemoryCopy(new_chunk_base+off, node->v, sizeof(DASM_Inst)*node->count);
off += node->count;
}
for(U64 idx = 0; idx < inst_list.inst_count; idx += 1)
{
new_chunk_base[idx].string = push_str8_copy(entity->decode_string_arena, new_chunk_base[idx].string);
}
entity->decode_inst_array.count += inst_list.inst_count;
if(entity->decode_inst_array.v == 0)
{
entity->decode_inst_array.v = new_chunk_base;
}
}
}
os_condition_variable_broadcast(stripe->cv);
}
}
}
//- rjf: mark task as complete
if(good_task)
{
OS_MutexScopeR(stripe->rw_mutex)
{
DASM_Entity *entity = 0;
for(DASM_Entity *e = slot->first; e != 0; e = e->next)
{
if(e->id == id)
{
entity = e;
break;
}
}
if(entity != 0)
{
U64 bytes_to_process = ins_atomic_u64_eval(&entity->bytes_to_process);
ins_atomic_u64_eval_assign(&entity->bytes_processed, bytes_to_process);
ins_atomic_u64_eval_assign(&entity->working_count, 0);
}
}
}
scratch_end(scratch);
}
}
-206
View File
@@ -1,206 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DASM_H
#define DASM_H
////////////////////////////////
//~ rjf: Handle Type
typedef struct DASM_Handle DASM_Handle;
struct DASM_Handle
{
U64 u64[2];
};
////////////////////////////////
//~ rjf: Instruction Types
typedef struct DASM_Inst DASM_Inst;
struct DASM_Inst
{
String8 string;
U64 off;
U64 addr;
};
typedef struct DASM_InstChunkNode DASM_InstChunkNode;
struct DASM_InstChunkNode
{
DASM_InstChunkNode *next;
DASM_Inst *v;
U64 cap;
U64 count;
};
typedef struct DASM_InstChunkList DASM_InstChunkList;
struct DASM_InstChunkList
{
DASM_InstChunkNode *first;
DASM_InstChunkNode *last;
U64 node_count;
U64 inst_count;
};
typedef struct DASM_InstArray DASM_InstArray;
struct DASM_InstArray
{
DASM_Inst *v;
U64 count;
};
////////////////////////////////
//~ rjf: Striped Access Types
typedef struct DASM_Stripe DASM_Stripe;
struct DASM_Stripe
{
Arena *arena;
OS_Handle cv;
OS_Handle rw_mutex;
};
typedef struct DASM_StripeTable DASM_StripeTable;
struct DASM_StripeTable
{
U64 count;
DASM_Stripe *v;
};
////////////////////////////////
//~ rjf: Entity Cache Types
typedef struct DASM_Entity DASM_Entity;
struct DASM_Entity
{
DASM_Entity *next;
// rjf: key info
CTRL_MachineID machine_id;
CTRL_Handle process;
Rng1U64 vaddr_range;
U64 id;
// rjf: top-level info
U64 last_time_sent_us;
U64 working_count;
U64 bytes_processed;
U64 bytes_to_process;
// rjf: decoded instruction data
Arena *decode_inst_arena;
Arena *decode_string_arena;
DASM_InstArray decode_inst_array;
};
typedef struct DASM_EntitySlot DASM_EntitySlot;
struct DASM_EntitySlot
{
DASM_Entity *first;
DASM_Entity *last;
};
typedef struct DASM_EntityMap DASM_EntityMap;
struct DASM_EntityMap
{
U64 slots_count;
DASM_EntitySlot *slots;
};
////////////////////////////////
//~ rjf: Introspection Info Types
typedef struct DASM_BinaryInfo DASM_BinaryInfo;
struct DASM_BinaryInfo
{
CTRL_MachineID machine_id;
CTRL_Handle process;
Rng1U64 vaddr_range;
U64 bytes_processed;
U64 bytes_to_process;
};
////////////////////////////////
//~ rjf: Decode Request Types
typedef struct DASM_DecodeRequest DASM_DecodeRequest;
struct DASM_DecodeRequest
{
DASM_Handle handle;
};
////////////////////////////////
//~ rjf: Shared State
typedef struct DASM_Shared DASM_Shared;
struct DASM_Shared
{
Arena *arena;
// rjf: entity table
DASM_EntityMap entity_map;
DASM_StripeTable entity_map_stripes;
U64 entity_id_gen;
// rjf: user -> decode ring
OS_Handle u2d_ring_mutex;
OS_Handle u2d_ring_cv;
U64 u2d_ring_size;
U8 *u2d_ring_base;
U64 u2d_ring_write_pos;
U64 u2d_ring_read_pos;
// rjf: decode threads
U64 decode_thread_count;
OS_Handle *decode_threads;
};
////////////////////////////////
//~ rjf: Globals
global DASM_Shared *dasm_shared = 0;
////////////////////////////////
//~ rjf: Main Layer Initialization
internal void dasm_init(void);
////////////////////////////////
//~ rjf: Basic Helpers
internal U64 dasm_hash_from_string(String8 string);
////////////////////////////////
//~ rjf: Instruction Type Functions
internal void dasm_inst_chunk_list_push(Arena *arena, DASM_InstChunkList *list, U64 cap, DASM_Inst *inst);
internal DASM_InstArray dasm_inst_array_from_chunk_list(Arena *arena, DASM_InstChunkList *list);
internal U64 dasm_inst_array_idx_from_off__linear_scan(DASM_InstArray *array, U64 off);
internal U64 dasm_inst_array_off_from_idx(DASM_InstArray *array, U64 idx);
////////////////////////////////
//~ rjf: Disassembly Functions
internal DASM_InstChunkList dasm_inst_chunk_list_from_arch_addr_data(Arena *arena, U64 *bytes_processed_counter, Architecture arch, U64 addr, String8 data);
////////////////////////////////
//~ rjf: Cache Lookups
//- rjf: opening handles & correllation with module
internal DASM_Handle dasm_handle_from_ctrl_process_range(CTRL_MachineID machine, CTRL_Handle process, Rng1U64 vaddr_range);
//- rjf: asking for top-level info of a handle
internal DASM_BinaryInfo dasm_binary_info_from_handle(Arena *arena, DASM_Handle handle);
//- rjf: asking for decoded instructions
internal DASM_InstArray dasm_inst_array_from_handle(Arena *arena, DASM_Handle handle, U64 endt_us);
////////////////////////////////
//~ rjf: Decode Threads
internal B32 dasm_u2d_enqueue_request(DASM_DecodeRequest *req, U64 endt_us);
internal DASM_DecodeRequest dasm_u2d_dequeue_request(void);
internal void dasm_decode_thread_entry_point(void *p);
#endif //DASM_H
+738
View File
@@ -0,0 +1,738 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Third Party Includes
#include "third_party/udis86/config.h"
#include "third_party/udis86/udis86.h"
#include "third_party/udis86/libudis86/decode.c"
#include "third_party/udis86/libudis86/itab.c"
#include "third_party/udis86/libudis86/syn-att.c"
#include "third_party/udis86/libudis86/syn-intel.c"
#include "third_party/udis86/libudis86/syn.c"
#include "third_party/udis86/libudis86/udis86.c"
////////////////////////////////
//~ rjf: Parameter Type Functions
internal B32
dasm_params_match(DASM_Params *a, DASM_Params *b)
{
B32 result = (a->vaddr == b->vaddr &&
a->arch == b->arch &&
a->style_flags == b->style_flags &&
a->syntax == b->syntax &&
a->base_vaddr == b->base_vaddr &&
di_key_match(&a->dbgi_key, &b->dbgi_key));
return result;
}
////////////////////////////////
//~ rjf: Instruction Type Functions
internal void
dasm_inst_chunk_list_push(Arena *arena, DASM_InstChunkList *list, U64 cap, DASM_Inst *inst)
{
DASM_InstChunkNode *node = list->last;
if(node == 0 || node->count >= node->cap)
{
node = push_array(arena, DASM_InstChunkNode, 1);
node->v = push_array_no_zero(arena, DASM_Inst, cap);
node->cap = cap;
SLLQueuePush(list->first, list->last, node);
list->node_count += 1;
}
MemoryCopyStruct(&node->v[node->count], inst);
node->count += 1;
list->inst_count += 1;
}
internal DASM_InstArray
dasm_inst_array_from_chunk_list(Arena *arena, DASM_InstChunkList *list)
{
DASM_InstArray array = {0};
array.count = list->inst_count;
array.v = push_array_no_zero(arena, DASM_Inst, array.count);
U64 idx = 0;
for(DASM_InstChunkNode *n = list->first; n != 0; n = n->next)
{
MemoryCopy(array.v+idx, n->v, sizeof(DASM_Inst)*n->count);
idx += n->count;
}
return array;
}
internal U64
dasm_inst_array_idx_from_code_off__linear_scan(DASM_InstArray *array, U64 off)
{
U64 result = 0;
for(U64 idx = 0; idx < array->count; idx += 1)
{
U64 next_off = (idx+1 < array->count ? array->v[idx+1].code_off : max_U64);
if(array->v[idx].code_off <= off && off < next_off)
{
result = idx;
if(!(array->v[idx].flags & DASM_InstFlag_Decorative))
{
break;
}
}
}
return result;
}
internal U64
dasm_inst_array_code_off_from_idx(DASM_InstArray *array, U64 idx)
{
U64 off = 0;
if(idx < array->count)
{
off = array->v[idx].code_off;
}
return off;
}
////////////////////////////////
//~ rjf: Main Layer Initialization
internal void
dasm_init(void)
{
Arena *arena = arena_alloc();
dasm_shared = push_array(arena, DASM_Shared, 1);
dasm_shared->arena = arena;
dasm_shared->slots_count = 1024;
dasm_shared->stripes_count = Min(dasm_shared->slots_count, os_logical_core_count());
dasm_shared->slots = push_array(arena, DASM_Slot, dasm_shared->slots_count);
dasm_shared->stripes = push_array(arena, DASM_Stripe, dasm_shared->stripes_count);
for(U64 idx = 0; idx < dasm_shared->stripes_count; idx += 1)
{
dasm_shared->stripes[idx].arena = arena_alloc();
dasm_shared->stripes[idx].rw_mutex = os_rw_mutex_alloc();
dasm_shared->stripes[idx].cv = os_condition_variable_alloc();
}
dasm_shared->u2p_ring_size = KB(64);
dasm_shared->u2p_ring_base = push_array_no_zero(arena, U8, dasm_shared->u2p_ring_size);
dasm_shared->u2p_ring_cv = os_condition_variable_alloc();
dasm_shared->u2p_ring_mutex = os_mutex_alloc();
dasm_shared->parse_thread_count = 1;
dasm_shared->parse_threads = push_array(arena, OS_Handle, dasm_shared->parse_thread_count);
for(U64 idx = 0; idx < dasm_shared->parse_thread_count; idx += 1)
{
dasm_shared->parse_threads[idx] = os_launch_thread(dasm_parse_thread__entry_point, (void *)idx, 0);
}
dasm_shared->evictor_detector_thread = os_launch_thread(dasm_evictor_detector_thread__entry_point, 0, 0);
}
////////////////////////////////
//~ rjf: User Clock
internal void
dasm_user_clock_tick(void)
{
ins_atomic_u64_inc_eval(&dasm_shared->user_clock_idx);
}
internal U64
dasm_user_clock_idx(void)
{
U64 idx = ins_atomic_u64_eval(&dasm_shared->user_clock_idx);
return idx;
}
////////////////////////////////
//~ rjf: Scoped Access
internal DASM_Scope *
dasm_scope_open(void)
{
if(dasm_tctx == 0)
{
Arena *arena = arena_alloc();
dasm_tctx = push_array(arena, DASM_TCTX, 1);
dasm_tctx->arena = arena;
}
U64 base_pos = arena_pos(dasm_tctx->arena);
DASM_Scope *scope = push_array(dasm_tctx->arena, DASM_Scope, 1);
scope->base_pos = base_pos;
return scope;
}
internal void
dasm_scope_close(DASM_Scope *scope)
{
for(DASM_Touch *t = scope->top_touch, *next = 0; t != 0; t = next)
{
next = t->next;
U64 slot_idx = t->hash.u64[1]%dasm_shared->slots_count;
U64 stripe_idx = slot_idx%dasm_shared->stripes_count;
DASM_Slot *slot = &dasm_shared->slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->stripes[stripe_idx];
OS_MutexScopeR(stripe->rw_mutex)
{
for(DASM_Node *n = slot->first; n != 0; n = n->next)
{
if(u128_match(t->hash, n->hash) && dasm_params_match(&t->params, &n->params))
{
ins_atomic_u64_dec_eval(&n->scope_ref_count);
break;
}
}
}
}
arena_pop_to(dasm_tctx->arena, scope->base_pos);
}
internal void
dasm_scope_touch_node__stripe_r_guarded(DASM_Scope *scope, DASM_Node *node)
{
DASM_Touch *touch = push_array(dasm_tctx->arena, DASM_Touch, 1);
ins_atomic_u64_inc_eval(&node->scope_ref_count);
ins_atomic_u64_eval_assign(&node->last_time_touched_us, os_now_microseconds());
ins_atomic_u64_eval_assign(&node->last_user_clock_idx_touched, dasm_user_clock_idx());
touch->hash = node->hash;
MemoryCopyStruct(&touch->params, &node->params);
touch->params.dbgi_key = di_key_copy(dasm_tctx->arena, &touch->params.dbgi_key);
SLLStackPush(scope->top_touch, touch);
}
////////////////////////////////
//~ rjf: Cache Lookups
internal DASM_Info
dasm_info_from_hash_params(DASM_Scope *scope, U128 hash, DASM_Params *params)
{
DASM_Info info = {0};
if(!u128_match(hash, u128_zero()))
{
U64 slot_idx = hash.u64[1]%dasm_shared->slots_count;
U64 stripe_idx = slot_idx%dasm_shared->stripes_count;
DASM_Slot *slot = &dasm_shared->slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->stripes[stripe_idx];
B32 found = 0;
OS_MutexScopeR(stripe->rw_mutex)
{
for(DASM_Node *n = slot->first; n != 0; n = n->next)
{
if(u128_match(hash, n->hash) && dasm_params_match(params, &n->params))
{
MemoryCopyStruct(&info, &n->info);
found = 1;
dasm_scope_touch_node__stripe_r_guarded(scope, n);
break;
}
}
}
B32 node_is_new = 0;
if(!found)
{
OS_MutexScopeW(stripe->rw_mutex)
{
DASM_Node *node = 0;
for(DASM_Node *n = slot->first; n != 0; n = n->next)
{
if(u128_match(hash, n->hash) && dasm_params_match(params, &n->params))
{
node = n;
break;
}
}
if(node == 0)
{
LogInfoNamedBlockF("dasm_new_node")
{
log_infof("hash: [0x%I64x 0x%I64x]\n", hash.u64[0], hash.u64[1]);
log_infof("vaddr: 0x%I64x\n", params->vaddr);
log_infof("arch: %S\n", string_from_architecture(params->arch));
log_infof("style_flags: 0x%x\n", params->style_flags);
log_infof("syntax: %i\n", params->syntax);
log_infof("base_vaddr: 0x%I64x\n", params->base_vaddr);
log_infof("dbgi_key: [%S 0x%I64x]\n", params->dbgi_key.path, params->dbgi_key.min_timestamp);
}
node = stripe->free_node;
if(node)
{
SLLStackPop(stripe->free_node);
}
else
{
node = push_array_no_zero(stripe->arena, DASM_Node, 1);
}
MemoryZeroStruct(node);
DLLPushBack(slot->first, slot->last, node);
node->hash = hash;
MemoryCopyStruct(&node->params, params);
// TODO(rjf): need to make this releasable - currently all exe_paths just leak
node->params.dbgi_key = di_key_copy(stripe->arena, &node->params.dbgi_key);
node_is_new = 1;
}
}
}
if(node_is_new)
{
dasm_u2p_enqueue_req(hash, params, max_U64);
}
}
return info;
}
internal DASM_Info
dasm_info_from_key_params(DASM_Scope *scope, U128 key, DASM_Params *params, U128 *hash_out)
{
DASM_Info result = {0};
for(U64 rewind_idx = 0; rewind_idx < 2; rewind_idx += 1)
{
U128 hash = hs_hash_from_key(key, rewind_idx);
result = dasm_info_from_hash_params(scope, hash, params);
if(result.insts.count != 0)
{
if(hash_out)
{
*hash_out = hash;
}
break;
}
}
return result;
}
////////////////////////////////
//~ rjf: Parse Threads
internal B32
dasm_u2p_enqueue_req(U128 hash, DASM_Params *params, U64 endt_us)
{
B32 good = 0;
OS_MutexScope(dasm_shared->u2p_ring_mutex) for(;;)
{
U64 unconsumed_size = dasm_shared->u2p_ring_write_pos - dasm_shared->u2p_ring_read_pos;
U64 available_size = dasm_shared->u2p_ring_size - unconsumed_size;
if(available_size >= sizeof(hash)+sizeof(U64)+sizeof(Architecture)+sizeof(DASM_StyleFlags)+sizeof(DASM_Syntax)+sizeof(U64)+sizeof(U64)+params->dbgi_key.path.size+sizeof(U64))
{
good = 1;
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &hash);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->vaddr);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->arch);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->style_flags);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->syntax);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->base_vaddr);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->dbgi_key.path.size);
dasm_shared->u2p_ring_write_pos += ring_write(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, params->dbgi_key.path.str, params->dbgi_key.path.size);
dasm_shared->u2p_ring_write_pos += ring_write_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_write_pos, &params->dbgi_key.min_timestamp);
dasm_shared->u2p_ring_write_pos += 7;
dasm_shared->u2p_ring_write_pos -= dasm_shared->u2p_ring_write_pos%8;
break;
}
if(os_now_microseconds() >= endt_us)
{
break;
}
os_condition_variable_wait(dasm_shared->u2p_ring_cv, dasm_shared->u2p_ring_mutex, endt_us);
}
if(good)
{
os_condition_variable_broadcast(dasm_shared->u2p_ring_cv);
}
return good;
}
internal void
dasm_u2p_dequeue_req(Arena *arena, U128 *hash_out, DASM_Params *params_out)
{
OS_MutexScope(dasm_shared->u2p_ring_mutex) for(;;)
{
U64 unconsumed_size = dasm_shared->u2p_ring_write_pos - dasm_shared->u2p_ring_read_pos;
if(unconsumed_size >= sizeof(*hash_out)+sizeof(U64)+sizeof(Architecture)+sizeof(DASM_StyleFlags)+sizeof(DASM_Syntax)+sizeof(U64)+sizeof(U64)+sizeof(U64))
{
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, hash_out);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->vaddr);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->arch);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->style_flags);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->syntax);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->base_vaddr);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->dbgi_key.path.size);
params_out->dbgi_key.path.str = push_array(arena, U8, params_out->dbgi_key.path.size);
dasm_shared->u2p_ring_read_pos += ring_read(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, params_out->dbgi_key.path.str, params_out->dbgi_key.path.size);
dasm_shared->u2p_ring_read_pos += ring_read_struct(dasm_shared->u2p_ring_base, dasm_shared->u2p_ring_size, dasm_shared->u2p_ring_read_pos, &params_out->dbgi_key.min_timestamp);
dasm_shared->u2p_ring_read_pos += 7;
dasm_shared->u2p_ring_read_pos -= dasm_shared->u2p_ring_read_pos%8;
break;
}
os_condition_variable_wait(dasm_shared->u2p_ring_cv, dasm_shared->u2p_ring_mutex, max_U64);
}
os_condition_variable_broadcast(dasm_shared->u2p_ring_cv);
}
internal void
dasm_parse_thread__entry_point(void *p)
{
ThreadNameF("[dasm] parse thread #%I64u", (U64)p);
for(;;)
{
Temp scratch = scratch_begin(0, 0);
//- rjf: get next request
U128 hash = {0};
DASM_Params params = {0};
dasm_u2p_dequeue_req(scratch.arena, &hash, &params);
U64 change_gen = fs_change_gen();
HS_Scope *hs_scope = hs_scope_open();
DI_Scope *di_scope = di_scope_open();
TXT_Scope *txt_scope = txt_scope_open();
//- rjf: unpack hash
U64 slot_idx = hash.u64[1]%dasm_shared->slots_count;
U64 stripe_idx = slot_idx%dasm_shared->stripes_count;
DASM_Slot *slot = &dasm_shared->slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->stripes[stripe_idx];
//- rjf: take task
B32 got_task = 0;
OS_MutexScopeR(stripe->rw_mutex)
{
for(DASM_Node *n = slot->first; n != 0; n = n->next)
{
if(u128_match(n->hash, hash) && dasm_params_match(&n->params, &params))
{
got_task = !ins_atomic_u32_eval_cond_assign(&n->is_working, 1, 0);
break;
}
}
}
//- rjf: get dbg info
RDI_Parsed *rdi = &di_rdi_parsed_nil;
if(got_task && params.dbgi_key.path.size != 0)
{
rdi = di_rdi_from_key(di_scope, &params.dbgi_key, max_U64);
}
//- rjf: hash -> data
String8 data = {0};
if(got_task)
{
data = hs_data_from_hash(hs_scope, hash);
}
//- rjf: data * arch * addr * dbg -> decode artifacts
DASM_InstChunkList inst_list = {0};
String8List inst_strings = {0};
if(got_task)
{
switch(params.arch)
{
default:{}break;
//- rjf: x86/x64 decoding
case Architecture_x64:
case Architecture_x86:
{
// rjf: grab context
struct ud udc;
ud_init(&udc);
ud_set_mode(&udc, bit_size_from_arch(params.arch));
ud_set_pc(&udc, params.vaddr);
ud_set_input_buffer(&udc, data.str, data.size);
ud_set_vendor(&udc, UD_VENDOR_ANY);
ud_set_syntax(&udc, params.syntax == DASM_Syntax_Intel ? UD_SYN_INTEL : UD_SYN_ATT);
// rjf: disassemble
RDI_SourceFile *last_file = &rdi_nil_element_union.source_file;
RDI_Line *last_line = 0;
for(U64 off = 0; off < data.size;)
{
// rjf: disassemble one instruction
U64 size = ud_disassemble(&udc);
if(size == 0)
{
break;
}
// rjf: analyze
struct ud_operand *first_op = (struct ud_operand *)ud_insn_opr(&udc, 0);
U64 rel_voff = (first_op != 0 && first_op->type == UD_OP_JIMM) ? ud_syn_rel_target(&udc, first_op) : 0;
U64 jump_dst_vaddr = rel_voff;
// rjf: push strings derived from voff -> line info
if(params.style_flags & (DASM_StyleFlag_SourceFilesNames|DASM_StyleFlag_SourceLines))
{
if(rdi != &di_rdi_parsed_nil)
{
U64 voff = (params.vaddr+off) - params.base_vaddr;
U32 unit_idx = rdi_vmap_idx_from_section_kind_voff(rdi, RDI_SectionKind_UnitVMap, voff);
RDI_Unit *unit = rdi_element_from_name_idx(rdi, Units, unit_idx);
RDI_LineTable *line_table = rdi_element_from_name_idx(rdi, LineTables, unit->line_table_idx);
RDI_ParsedLineTable unit_line_info = {0};
rdi_parsed_from_line_table(rdi, line_table, &unit_line_info);
U64 line_info_idx = rdi_line_info_idx_from_voff(&unit_line_info, voff);
if(line_info_idx < unit_line_info.count)
{
RDI_Line *line = &unit_line_info.lines[line_info_idx];
RDI_SourceFile *file = rdi_element_from_name_idx(rdi, SourceFiles, line->file_idx);
String8 file_normalized_full_path = {0};
file_normalized_full_path.str = rdi_string_from_idx(rdi, file->normal_full_path_string_idx, &file_normalized_full_path.size);
if(file != last_file)
{
if(params.style_flags & DASM_StyleFlag_SourceFilesNames &&
file->normal_full_path_string_idx != 0 && file_normalized_full_path.size != 0)
{
String8 inst_string = push_str8f(scratch.arena, "> %S", file_normalized_full_path);
DASM_Inst inst = {u32_from_u64_saturate(off), DASM_InstFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count,
inst_strings.total_size + inst_strings.node_count + inst_string.size)};
dasm_inst_chunk_list_push(scratch.arena, &inst_list, 1024, &inst);
str8_list_push(scratch.arena, &inst_strings, inst_string);
}
if(params.style_flags & DASM_StyleFlag_SourceFilesNames && file->normal_full_path_string_idx == 0)
{
String8 inst_string = str8_lit(">");
DASM_Inst inst = {u32_from_u64_saturate(off), DASM_InstFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count,
inst_strings.total_size + inst_strings.node_count + inst_string.size)};
dasm_inst_chunk_list_push(scratch.arena, &inst_list, 1024, &inst);
str8_list_push(scratch.arena, &inst_strings, inst_string);
}
last_file = file;
}
if(line && line != last_line && file->normal_full_path_string_idx != 0 &&
params.style_flags & DASM_StyleFlag_SourceLines &&
file_normalized_full_path.size != 0)
{
FileProperties props = os_properties_from_file_path(file_normalized_full_path);
if(props.modified != 0)
{
// TODO(rjf): need redirection path - this may map to a different path on the local machine,
// need frontend to communicate path remapping info to this layer
U128 key = fs_key_from_path(file_normalized_full_path);
TXT_LangKind lang_kind = txt_lang_kind_from_extension(file_normalized_full_path);
U64 endt_us = max_U64;
U128 hash = {0};
TXT_TextInfo text_info = {0};
for(;os_now_microseconds() <= endt_us;)
{
text_info = txt_text_info_from_key_lang(txt_scope, key, lang_kind, &hash);
if(!u128_match(hash, u128_zero()))
{
break;
}
}
if(0 < line->line_num && line->line_num < text_info.lines_count)
{
String8 data = hs_data_from_hash(hs_scope, hash);
String8 line_text = str8_skip_chop_whitespace(str8_substr(data, text_info.lines_ranges[line->line_num-1]));
if(line_text.size != 0)
{
String8 inst_string = push_str8f(scratch.arena, "> %S", line_text);
DASM_Inst inst = {u32_from_u64_saturate(off), DASM_InstFlag_Decorative, 0, r1u64(inst_strings.total_size + inst_strings.node_count,
inst_strings.total_size + inst_strings.node_count + inst_string.size)};
dasm_inst_chunk_list_push(scratch.arena, &inst_list, 1024, &inst);
str8_list_push(scratch.arena, &inst_strings, inst_string);
}
}
}
last_line = line;
}
}
}
}
// rjf: push
String8 addr_part = {0};
if(params.style_flags & DASM_StyleFlag_Addresses)
{
addr_part = push_str8f(scratch.arena, "%s0x%016I64x ", rdi != &di_rdi_parsed_nil ? " " : "", params.vaddr+off);
}
String8 code_bytes_part = {0};
if(params.style_flags & DASM_StyleFlag_CodeBytes)
{
String8List code_bytes_strings = {0};
str8_list_push(scratch.arena, &code_bytes_strings, str8_lit("{"));
for(U64 byte_idx = 0; byte_idx < size || byte_idx < 16; byte_idx += 1)
{
if(byte_idx < size)
{
str8_list_pushf(scratch.arena, &code_bytes_strings, "%02x%s ", (U32)data.str[off+byte_idx], byte_idx == size-1 ? "}" : "");
}
else if(byte_idx < 8)
{
str8_list_push(scratch.arena, &code_bytes_strings, str8_lit(" "));
}
}
str8_list_push(scratch.arena, &code_bytes_strings, str8_lit(" "));
code_bytes_part = str8_list_join(scratch.arena, &code_bytes_strings, 0);
}
String8 symbol_part = {0};
if(jump_dst_vaddr != 0 && rdi != &di_rdi_parsed_nil && params.style_flags & DASM_StyleFlag_SymbolNames)
{
RDI_U32 scope_idx = rdi_vmap_idx_from_section_kind_voff(rdi, RDI_SectionKind_ScopeVMap, jump_dst_vaddr-params.base_vaddr);
if(scope_idx != 0)
{
RDI_Scope *scope = rdi_element_from_name_idx(rdi, Scopes, scope_idx);
RDI_U32 procedure_idx = scope->proc_idx;
RDI_Procedure *procedure = rdi_element_from_name_idx(rdi, Procedures, procedure_idx);
String8 procedure_name = {0};
procedure_name.str = rdi_string_from_idx(rdi, procedure->name_string_idx, &procedure_name.size);
if(procedure_name.size != 0)
{
symbol_part = push_str8f(scratch.arena, " (%S)", procedure_name);
}
}
}
String8 inst_string = push_str8f(scratch.arena, "%S%S%s%S", addr_part, code_bytes_part, udc.asm_buf, symbol_part);
DASM_Inst inst = {u32_from_u64_saturate(off), 0, rel_voff, r1u64(inst_strings.total_size + inst_strings.node_count,
inst_strings.total_size + inst_strings.node_count + inst_string.size)};
dasm_inst_chunk_list_push(scratch.arena, &inst_list, 1024, &inst);
str8_list_push(scratch.arena, &inst_strings, inst_string);
// rjf: increment
off += size;
}
}break;
}
}
//- rjf: artifacts -> value bundle
Arena *info_arena = 0;
DASM_Info info = {0};
if(got_task)
{
//- rjf: produce joined text
Arena *text_arena = arena_alloc();
StringJoin text_join = {0};
text_join.sep = str8_lit("\n");
String8 text = str8_list_join(text_arena, &inst_strings, &text_join);
//- rjf: produce unique key for this disassembly's text
U128 text_key = {0};
{
U64 hash_data[] =
{
hash.u64[0],
hash.u64[1],
params.vaddr,
(U64)params.arch,
(U64)params.style_flags,
(U64)params.syntax,
(U64)rdi,
0x4d534144,
};
text_key = hs_hash_from_data(str8((U8 *)hash_data, sizeof(hash_data)));
}
//- rjf: submit text data to hash store
U128 text_hash = hs_submit_data(text_key, &text_arena, text);
//- rjf: produce value bundle
info_arena = arena_alloc();
info.text_key = text_key;
info.insts = dasm_inst_array_from_chunk_list(info_arena, &inst_list);
}
//- rjf: commit results to cache
if(got_task) OS_MutexScopeW(stripe->rw_mutex)
{
for(DASM_Node *n = slot->first; n != 0; n = n->next)
{
if(u128_match(n->hash, hash) && dasm_params_match(&n->params, &params))
{
n->info_arena = info_arena;
MemoryCopyStruct(&n->info, &info);
if(rdi != &di_rdi_parsed_nil && params.style_flags & (DASM_StyleFlag_SourceLines|DASM_StyleFlag_SourceFilesNames))
{
n->change_gen = change_gen;
}
else
{
n->change_gen = 0;
}
ins_atomic_u32_eval_assign(&n->is_working, 0);
ins_atomic_u64_inc_eval(&n->load_count);
break;
}
}
}
txt_scope_close(txt_scope);
di_scope_close(di_scope);
hs_scope_close(hs_scope);
scratch_end(scratch);
}
}
////////////////////////////////
//~ rjf: Evictor/Detector Thread
internal void
dasm_evictor_detector_thread__entry_point(void *p)
{
ThreadNameF("[dasm] evictor/detector thread");
for(;;)
{
U64 change_gen = fs_change_gen();
U64 check_time_us = os_now_microseconds();
U64 check_time_user_clocks = dasm_user_clock_idx();
U64 evict_threshold_us = 10*1000000;
U64 retry_threshold_us = 1*1000000;
U64 evict_threshold_user_clocks = 10;
U64 retry_threshold_user_clocks = 10;
for(U64 slot_idx = 0; slot_idx < dasm_shared->slots_count; slot_idx += 1)
{
U64 stripe_idx = slot_idx%dasm_shared->stripes_count;
DASM_Slot *slot = &dasm_shared->slots[slot_idx];
DASM_Stripe *stripe = &dasm_shared->stripes[stripe_idx];
B32 slot_has_work = 0;
OS_MutexScopeR(stripe->rw_mutex)
{
for(DASM_Node *n = slot->first; n != 0; n = n->next)
{
if(n->scope_ref_count == 0 &&
n->last_time_touched_us+evict_threshold_us <= check_time_us &&
n->last_user_clock_idx_touched+evict_threshold_user_clocks <= check_time_user_clocks &&
n->load_count != 0 &&
n->is_working == 0)
{
slot_has_work = 1;
break;
}
if(n->change_gen != 0 && n->change_gen != change_gen &&
n->last_time_requested_us+retry_threshold_us <= check_time_us &&
n->last_user_clock_idx_requested+retry_threshold_user_clocks <= check_time_user_clocks)
{
slot_has_work = 1;
break;
}
}
}
if(slot_has_work) OS_MutexScopeW(stripe->rw_mutex)
{
for(DASM_Node *n = slot->first, *next = 0; n != 0; n = next)
{
next = n->next;
if(n->scope_ref_count == 0 &&
n->last_time_touched_us+evict_threshold_us <= check_time_us &&
n->last_user_clock_idx_touched+evict_threshold_user_clocks <= check_time_user_clocks &&
n->load_count != 0 &&
n->is_working == 0)
{
DLLRemove(slot->first, slot->last, n);
if(n->info_arena != 0)
{
arena_release(n->info_arena);
}
SLLStackPush(stripe->free_node, n);
}
if(n->change_gen != 0 && n->change_gen != change_gen &&
n->last_time_requested_us+retry_threshold_us <= check_time_us &&
n->last_user_clock_idx_requested+retry_threshold_user_clocks <= check_time_user_clocks)
{
if(dasm_u2p_enqueue_req(n->hash, &n->params, max_U64))
{
n->last_time_requested_us = os_now_microseconds();
n->last_user_clock_idx_requested = check_time_user_clocks;
}
}
}
}
}
os_sleep_milliseconds(100);
}
}
+258
View File
@@ -0,0 +1,258 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DASM_CACHE_H
#define DASM_CACHE_H
////////////////////////////////
//~ rjf: Stringification Types
typedef U32 DASM_StyleFlags;
enum
{
DASM_StyleFlag_Addresses = (1<<0),
DASM_StyleFlag_CodeBytes = (1<<1),
DASM_StyleFlag_SourceFilesNames = (1<<2),
DASM_StyleFlag_SourceLines = (1<<3),
DASM_StyleFlag_SymbolNames = (1<<4),
};
typedef enum DASM_Syntax
{
DASM_Syntax_Intel,
DASM_Syntax_ATT,
DASM_Syntax_COUNT
}
DASM_Syntax;
////////////////////////////////
//~ rjf: Disassembling Parameters Bundle
typedef struct DASM_Params DASM_Params;
struct DASM_Params
{
U64 vaddr;
Architecture arch;
DASM_StyleFlags style_flags;
DASM_Syntax syntax;
U64 base_vaddr;
DI_Key dbgi_key;
};
////////////////////////////////
//~ rjf: Instruction Types
typedef U32 DASM_InstFlags;
enum
{
DASM_InstFlag_Decorative = (1<<0),
};
typedef struct DASM_Inst DASM_Inst;
struct DASM_Inst
{
U32 code_off;
DASM_InstFlags flags;
U64 addr;
Rng1U64 text_range;
};
typedef struct DASM_InstChunkNode DASM_InstChunkNode;
struct DASM_InstChunkNode
{
DASM_InstChunkNode *next;
DASM_Inst *v;
U64 cap;
U64 count;
};
typedef struct DASM_InstChunkList DASM_InstChunkList;
struct DASM_InstChunkList
{
DASM_InstChunkNode *first;
DASM_InstChunkNode *last;
U64 node_count;
U64 inst_count;
};
typedef struct DASM_InstArray DASM_InstArray;
struct DASM_InstArray
{
DASM_Inst *v;
U64 count;
};
////////////////////////////////
//~ rjf: Value Bundle Type
typedef struct DASM_Info DASM_Info;
struct DASM_Info
{
U128 text_key;
DASM_InstArray insts;
};
////////////////////////////////
//~ rjf: Cache Types
typedef struct DASM_Node DASM_Node;
struct DASM_Node
{
// rjf: links
DASM_Node *next;
DASM_Node *prev;
// rjf: key
U128 hash;
DASM_Params params;
// rjf: generations
U64 change_gen;
// rjf: value
Arena *info_arena;
DASM_Info info;
// rjf: metadata
B32 is_working;
U64 scope_ref_count;
U64 last_time_touched_us;
U64 last_user_clock_idx_touched;
U64 load_count;
U64 last_time_requested_us;
U64 last_user_clock_idx_requested;
};
typedef struct DASM_Slot DASM_Slot;
struct DASM_Slot
{
DASM_Node *first;
DASM_Node *last;
};
typedef struct DASM_Stripe DASM_Stripe;
struct DASM_Stripe
{
Arena *arena;
OS_Handle rw_mutex;
OS_Handle cv;
DASM_Node *free_node;
};
////////////////////////////////
//~ rjf: Scoped Access Types
typedef struct DASM_Touch DASM_Touch;
struct DASM_Touch
{
DASM_Touch *next;
U128 hash;
DASM_Params params;
};
typedef struct DASM_Scope DASM_Scope;
struct DASM_Scope
{
DASM_Scope *next;
DASM_Touch *top_touch;
U64 base_pos;
};
////////////////////////////////
//~ rjf: Thread Context
typedef struct DASM_TCTX DASM_TCTX;
struct DASM_TCTX
{
Arena *arena;
};
////////////////////////////////
//~ rjf: Shared State
typedef struct DASM_Shared DASM_Shared;
struct DASM_Shared
{
Arena *arena;
// rjf: user clock
U64 user_clock_idx;
// rjf: cache
U64 slots_count;
U64 stripes_count;
DASM_Slot *slots;
DASM_Stripe *stripes;
// rjf: user -> parse thread
U64 u2p_ring_size;
U8 *u2p_ring_base;
U64 u2p_ring_write_pos;
U64 u2p_ring_read_pos;
OS_Handle u2p_ring_cv;
OS_Handle u2p_ring_mutex;
// rjf: parse threads
U64 parse_thread_count;
OS_Handle *parse_threads;
// rjf: evictor/detector thread
OS_Handle evictor_detector_thread;
};
////////////////////////////////
//~ rjf: Globals
thread_static DASM_TCTX *dasm_tctx = 0;
global DASM_Shared *dasm_shared = 0;
////////////////////////////////
//~ rjf: Parameter Type Functions
internal B32 dasm_params_match(DASM_Params *a, DASM_Params *b);
////////////////////////////////
//~ rjf: Instruction Type Functions
internal void dasm_inst_chunk_list_push(Arena *arena, DASM_InstChunkList *list, U64 cap, DASM_Inst *inst);
internal DASM_InstArray dasm_inst_array_from_chunk_list(Arena *arena, DASM_InstChunkList *list);
internal U64 dasm_inst_array_idx_from_code_off__linear_scan(DASM_InstArray *array, U64 off);
internal U64 dasm_inst_array_code_off_from_idx(DASM_InstArray *array, U64 idx);
////////////////////////////////
//~ rjf: Main Layer Initialization
internal void dasm_init(void);
////////////////////////////////
//~ rjf: User Clock
internal void dasm_user_clock_tick(void);
internal U64 dasm_user_clock_idx(void);
////////////////////////////////
//~ rjf: Scoped Access
internal DASM_Scope *dasm_scope_open(void);
internal void dasm_scope_close(DASM_Scope *scope);
internal void dasm_scope_touch_node__stripe_r_guarded(DASM_Scope *scope, DASM_Node *node);
////////////////////////////////
//~ rjf: Cache Lookups
internal DASM_Info dasm_info_from_hash_params(DASM_Scope *scope, U128 hash, DASM_Params *params);
internal DASM_Info dasm_info_from_key_params(DASM_Scope *scope, U128 key, DASM_Params *params, U128 *hash_out);
////////////////////////////////
//~ rjf: Parse Threads
internal B32 dasm_u2p_enqueue_req(U128 hash, DASM_Params *params, U64 endt_us);
internal void dasm_u2p_dequeue_req(Arena *arena, U128 *hash_out, DASM_Params *params_out);
internal void dasm_parse_thread__entry_point(void *p);
////////////////////////////////
//~ rjf: Evictor/Detector Thread
internal void dasm_evictor_detector_thread__entry_point(void *p);
#endif // DASM_CACHE_H
+613 -1071
View File
File diff suppressed because it is too large Load Diff
+168 -344
View File
@@ -1,294 +1,170 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DBGI_H
#define DBGI_H
#ifndef DI_H
#define DI_H
////////////////////////////////
//~ rjf: Info Bundle Types
//~ rjf: Cache Key Type
typedef struct DBGI_Parse DBGI_Parse;
struct DBGI_Parse
typedef struct DI_Key DI_Key;
struct DI_Key
{
U64 gen;
Arena *arena;
void *exe_base;
FileProperties exe_props;
String8 dbg_path;
void *dbg_base;
FileProperties dbg_props;
PE_BinInfo pe;
RADDBG_Parsed rdbg;
String8 path;
U64 min_timestamp;
};
////////////////////////////////
//~ rjf: Exe -> Debug Forced Override Cache Types
typedef struct DBGI_ForceNode DBGI_ForceNode;
struct DBGI_ForceNode
typedef struct DI_KeyNode DI_KeyNode;
struct DI_KeyNode
{
DBGI_ForceNode *next;
String8 exe_path;
U64 dbg_path_cap;
U64 dbg_path_size;
U8 *dbg_path_base;
DI_KeyNode *next;
DI_Key v;
};
typedef struct DBGI_ForceSlot DBGI_ForceSlot;
struct DBGI_ForceSlot
typedef struct DI_KeyList DI_KeyList;
struct DI_KeyList
{
DBGI_ForceNode *first;
DBGI_ForceNode *last;
};
typedef struct DBGI_ForceStripe DBGI_ForceStripe;
struct DBGI_ForceStripe
{
Arena *arena;
OS_Handle rw_mutex;
OS_Handle cv;
};
////////////////////////////////
//~ rjf: Binary Cache State Types
typedef U32 DBGI_BinaryFlags;
enum
{
DBGI_BinaryFlag_ParseInFlight = (1<<0),
};
typedef struct DBGI_Binary DBGI_Binary;
struct DBGI_Binary
{
// rjf: links & metadata
DBGI_Binary *next;
String8 exe_path;
U64 refcount;
U64 scope_touch_count;
U64 last_time_enqueued_for_parse_us;
DBGI_BinaryFlags flags;
U64 gen;
// rjf: exe handles
OS_Handle exe_file;
OS_Handle exe_file_map;
// rjf: debug handles
OS_Handle dbg_file;
OS_Handle dbg_file_map;
// rjf: analysis results
DBGI_Parse parse;
};
typedef struct DBGI_BinarySlot DBGI_BinarySlot;
struct DBGI_BinarySlot
{
DBGI_Binary *first;
DBGI_Binary *last;
};
typedef struct DBGI_BinaryStripe DBGI_BinaryStripe;
struct DBGI_BinaryStripe
{
Arena *arena;
OS_Handle rw_mutex;
OS_Handle cv;
};
////////////////////////////////
//~ rjf: Fuzzy Search Cache Types
typedef enum DBGI_FuzzySearchTarget
{
DBGI_FuzzySearchTarget_Procedures,
DBGI_FuzzySearchTarget_GlobalVariables,
DBGI_FuzzySearchTarget_ThreadVariables,
DBGI_FuzzySearchTarget_UDTs,
DBGI_FuzzySearchTarget_COUNT
}
DBGI_FuzzySearchTarget;
typedef struct DBGI_FuzzySearchItem DBGI_FuzzySearchItem;
struct DBGI_FuzzySearchItem
{
U64 idx;
U64 missed_size;
FuzzyMatchRangeList match_ranges;
};
typedef struct DBGI_FuzzySearchItemChunk DBGI_FuzzySearchItemChunk;
struct DBGI_FuzzySearchItemChunk
{
DBGI_FuzzySearchItemChunk *next;
DBGI_FuzzySearchItem *v;
U64 count;
U64 cap;
};
typedef struct DBGI_FuzzySearchItemChunkList DBGI_FuzzySearchItemChunkList;
struct DBGI_FuzzySearchItemChunkList
{
DBGI_FuzzySearchItemChunk *first;
DBGI_FuzzySearchItemChunk *last;
U64 chunk_count;
U64 total_count;
};
typedef struct DBGI_FuzzySearchItemArray DBGI_FuzzySearchItemArray;
struct DBGI_FuzzySearchItemArray
{
DBGI_FuzzySearchItem *v;
DI_KeyNode *first;
DI_KeyNode *last;
U64 count;
};
typedef struct DBGI_FuzzySearchBucket DBGI_FuzzySearchBucket;
struct DBGI_FuzzySearchBucket
typedef struct DI_KeyArray DI_KeyArray;
struct DI_KeyArray
{
Arena *arena;
String8 exe_path;
String8 query;
DBGI_FuzzySearchTarget target;
};
typedef struct DBGI_FuzzySearchNode DBGI_FuzzySearchNode;
struct DBGI_FuzzySearchNode
{
DBGI_FuzzySearchNode *next;
U128 key;
U64 scope_touch_count;
U64 last_time_submitted_us;
DBGI_FuzzySearchBucket buckets[3];
U64 gen;
U64 submit_gen;
DBGI_FuzzySearchItemArray gen_items;
};
typedef struct DBGI_FuzzySearchSlot DBGI_FuzzySearchSlot;
struct DBGI_FuzzySearchSlot
{
DBGI_FuzzySearchNode *first;
DBGI_FuzzySearchNode *last;
};
typedef struct DBGI_FuzzySearchStripe DBGI_FuzzySearchStripe;
struct DBGI_FuzzySearchStripe
{
Arena *arena;
OS_Handle rw_mutex;
OS_Handle cv;
};
typedef struct DBGI_FuzzySearchThread DBGI_FuzzySearchThread;
struct DBGI_FuzzySearchThread
{
OS_Handle thread;
OS_Handle u2f_ring_mutex;
OS_Handle u2f_ring_cv;
U64 u2f_ring_size;
U8 *u2f_ring_base;
U64 u2f_ring_write_pos;
U64 u2f_ring_read_pos;
};
////////////////////////////////
//~ rjf: Weak Access Scope Types
typedef struct DBGI_TouchedBinary DBGI_TouchedBinary;
struct DBGI_TouchedBinary
{
DBGI_TouchedBinary *next;
DBGI_Binary *binary;
};
typedef struct DBGI_TouchedFuzzySearch DBGI_TouchedFuzzySearch;
struct DBGI_TouchedFuzzySearch
{
DBGI_TouchedFuzzySearch *next;
DBGI_FuzzySearchNode *node;
};
typedef struct DBGI_Scope DBGI_Scope;
struct DBGI_Scope
{
DBGI_Scope *next;
DBGI_TouchedBinary *first_tb;
DBGI_TouchedBinary *last_tb;
DBGI_TouchedFuzzySearch *first_tfs;
DBGI_TouchedFuzzySearch *last_tfs;
};
typedef struct DBGI_ThreadCtx DBGI_ThreadCtx;
struct DBGI_ThreadCtx
{
Arena *arena;
DBGI_Scope *free_scope;
DBGI_TouchedBinary *free_tb;
DBGI_TouchedFuzzySearch *free_tfs;
DI_Key *v;
U64 count;
};
////////////////////////////////
//~ rjf: Event Types
typedef enum DBGI_EventKind
typedef enum DI_EventKind
{
DBGI_EventKind_Null,
DBGI_EventKind_ConversionStarted,
DBGI_EventKind_ConversionEnded,
DBGI_EventKind_ConversionFailureUnsupportedFormat,
DBGI_EventKind_COUNT
DI_EventKind_Null,
DI_EventKind_ConversionStarted,
DI_EventKind_ConversionEnded,
DI_EventKind_ConversionFailureUnsupportedFormat,
DI_EventKind_COUNT
}
DBGI_EventKind;
DI_EventKind;
typedef struct DBGI_Event DBGI_Event;
struct DBGI_Event
typedef struct DI_Event DI_Event;
struct DI_Event
{
DBGI_EventKind kind;
DI_EventKind kind;
String8 string;
};
typedef struct DBGI_EventNode DBGI_EventNode;
struct DBGI_EventNode
typedef struct DI_EventNode DI_EventNode;
struct DI_EventNode
{
DBGI_EventNode *next;
DBGI_Event v;
DI_EventNode *next;
DI_Event v;
};
typedef struct DBGI_EventList DBGI_EventList;
struct DBGI_EventList
typedef struct DI_EventList DI_EventList;
struct DI_EventList
{
DBGI_EventNode *first;
DBGI_EventNode *last;
DI_EventNode *first;
DI_EventNode *last;
U64 count;
};
////////////////////////////////
//~ rjf: Cross-Thread Shared State
//~ rjf: Cache Types
typedef struct DBGI_Shared DBGI_Shared;
struct DBGI_Shared
typedef struct DI_StringChunkNode DI_StringChunkNode;
struct DI_StringChunkNode
{
DI_StringChunkNode *next;
U64 size;
};
typedef struct DI_Node DI_Node;
struct DI_Node
{
// rjf: links
DI_Node *next;
DI_Node *prev;
// rjf: metadata
U64 ref_count;
U64 touch_count;
U64 is_working;
U64 last_time_requested_us;
// rjf: key
DI_Key key;
// rjf: file handles
OS_Handle file;
OS_Handle file_map;
void *file_base;
FileProperties file_props;
// rjf: parse artifacts
Arena *arena;
RDI_Parsed rdi;
B32 parse_done;
};
typedef struct DI_Slot DI_Slot;
struct DI_Slot
{
DI_Node *first;
DI_Node *last;
};
typedef struct DI_Stripe DI_Stripe;
struct DI_Stripe
{
Arena *arena;
DI_Node *free_node;
DI_StringChunkNode *free_string_chunks[8];
OS_Handle rw_mutex;
OS_Handle cv;
};
////////////////////////////////
//~ rjf: Scoped Access Types
typedef struct DI_Touch DI_Touch;
struct DI_Touch
{
DI_Touch *next;
DI_Node *node;
};
typedef struct DI_Scope DI_Scope;
struct DI_Scope
{
DI_Scope *next;
DI_Touch *first_touch;
DI_Touch *last_touch;
};
typedef struct DI_TCTX DI_TCTX;
struct DI_TCTX
{
Arena *arena;
DI_Scope *free_scope;
DI_Touch *free_touch;
};
////////////////////////////////
//~ rjf: Shared State Types
typedef struct DI_Shared DI_Shared;
struct DI_Shared
{
// rjf: arena
Arena *arena;
// rjf: forced override table
U64 force_slots_count;
U64 force_stripes_count;
DBGI_ForceSlot *force_slots;
DBGI_ForceStripe *force_stripes;
// rjf: binary table
U64 binary_slots_count;
U64 binary_stripes_count;
DBGI_BinarySlot *binary_slots;
DBGI_BinaryStripe *binary_stripes;
// rjf: fuzzy search cache table
U64 fuzzy_search_slots_count;
U64 fuzzy_search_stripes_count;
DBGI_FuzzySearchSlot *fuzzy_search_slots;
DBGI_FuzzySearchStripe *fuzzy_search_stripes;
// rjf: node cache
U64 slots_count;
DI_Slot *slots;
U64 stripes_count;
DI_Stripe *stripes;
// rjf: user -> parse ring
OS_Handle u2p_ring_mutex;
@@ -309,123 +185,71 @@ struct DBGI_Shared
// rjf: threads
U64 parse_thread_count;
OS_Handle *parse_threads;
U64 fuzzy_thread_count;
DBGI_FuzzySearchThread *fuzzy_threads;
};
////////////////////////////////
//~ rjf: Globals
global DBGI_Shared *dbgi_shared = 0;
thread_static DBGI_ThreadCtx *dbgi_tctx = 0;
global DBGI_Parse dbgi_parse_nil =
{
0,
0,
0,
{0},
{0},
0,
{0},
{0},
{
0,
0,
0,
0,
{0},
0,
0,
0,
0,
0,
0,
0,
&raddbg_binary_section_nil, 1,
&raddbg_file_path_node_nil, 1,
&raddbg_source_file_nil, 1,
&raddbg_unit_nil, 1,
&raddbg_vmap_entry_nil, 1,
&raddbg_type_node_nil, 1,
&raddbg_udt_nil, 1,
&raddbg_member_nil, 1,
&raddbg_enum_member_nil, 1,
&raddbg_global_variable_nil, 1,
&raddbg_vmap_entry_nil, 1,
&raddbg_thread_variable_nil, 1,
&raddbg_procedure_nil, 1,
&raddbg_scope_nil, 1,
&raddbg_voff_nil, 1,
&raddbg_vmap_entry_nil, 1,
&raddbg_local_nil, 1,
&raddbg_location_block_nil, 1,
0, 0,
0, 0,
},
};
global DI_Shared *di_shared = 0;
thread_static DI_TCTX *di_tctx = 0;
global RDI_Parsed di_rdi_parsed_nil = {0};
////////////////////////////////
//~ rjf: Basic Helpers
internal U64 di_hash_from_string(String8 string, StringMatchFlags match_flags);
internal U64 di_hash_from_key(DI_Key *k);
internal DI_Key di_key_zero(void);
internal B32 di_key_match(DI_Key *a, DI_Key *b);
internal DI_Key di_key_copy(Arena *arena, DI_Key *src);
internal DI_Key di_normalized_key_from_key(Arena *arena, DI_Key *src);
internal void di_key_list_push(Arena *arena, DI_KeyList *list, DI_Key *key);
internal DI_KeyArray di_key_array_from_list(Arena *arena, DI_KeyList *list);
////////////////////////////////
//~ rjf: Main Layer Initialization
internal void dbgi_init(void);
////////////////////////////////
//~ rjf: Thread-Context Idempotent Initialization
internal void dbgi_ensure_tctx_inited(void);
////////////////////////////////
//~ rjf: Helpers
internal U64 dbgi_hash_from_string(String8 string);
internal U64 dbgi_fuzzy_item_num_from_array_element_idx__linear_search(DBGI_FuzzySearchItemArray *array, U64 element_idx);
internal String8 dbgi_fuzzy_item_string_from_rdbg_target_element_idx(RADDBG_Parsed *rdbg, DBGI_FuzzySearchTarget target, U64 element_idx);
////////////////////////////////
//~ rjf: Forced Override Cache Functions
internal void dbgi_force_exe_path_dbg_path(String8 exe_path, String8 dbg_path);
internal String8 dbgi_forced_dbg_path_from_exe_path(Arena *arena, String8 exe_path);
internal void di_init(void);
////////////////////////////////
//~ rjf: Scope Functions
internal DBGI_Scope *dbgi_scope_open(void);
internal void dbgi_scope_close(DBGI_Scope *scope);
internal void dbgi_scope_touch_binary__stripe_mutex_r_guarded(DBGI_Scope *scope, DBGI_Binary *binary);
internal void dbgi_scope_touch_fuzzy_search__stripe_mutex_r_guarded(DBGI_Scope *scope, DBGI_FuzzySearchNode *node);
internal DI_Scope *di_scope_open(void);
internal void di_scope_close(DI_Scope *scope);
internal void di_scope_touch_node__stripe_mutex_r_guarded(DI_Scope *scope, DI_Node *node);
////////////////////////////////
//~ rjf: Binary Cache Functions
//~ rjf: Per-Slot Functions
internal void dbgi_binary_open(String8 exe_path);
internal void dbgi_binary_close(String8 exe_path);
internal DBGI_Parse *dbgi_parse_from_exe_path(DBGI_Scope *scope, String8 exe_path, U64 endt_us);
internal DI_Node *di_node_from_key_slot__stripe_mutex_r_guarded(DI_Slot *slot, DI_Key *key);
////////////////////////////////
//~ rjf: Fuzzy Search Cache Functions
//~ rjf: Per-Stripe Functions
internal DBGI_FuzzySearchItemArray dbgi_fuzzy_search_items_from_key_exe_query(DBGI_Scope *scope, U128 key, String8 exe_path, String8 query, DBGI_FuzzySearchTarget target, U64 endt_us, B32 *stale_out);
internal U64 di_string_bucket_idx_from_string_size(U64 size);
internal String8 di_string_alloc__stripe_mutex_w_guarded(DI_Stripe *stripe, String8 string);
internal void di_string_release__stripe_mutex_w_guarded(DI_Stripe *stripe, String8 string);
////////////////////////////////
//~ rjf: Key Opening/Closing
internal void di_open(DI_Key *key);
internal void di_close(DI_Key *key);
////////////////////////////////
//~ rjf: Cache Lookups
internal RDI_Parsed *di_rdi_from_key(DI_Scope *scope, DI_Key *key, U64 endt_us);
////////////////////////////////
//~ rjf: Parse Threads
internal B32 dbgi_u2p_enqueue_exe_path(String8 exe_path, U64 endt_us);
internal String8 dbgi_u2p_dequeue_exe_path(Arena *arena);
internal B32 di_u2p_enqueue_key(DI_Key *key, U64 endt_us);
internal void di_u2p_dequeue_key(Arena *arena, DI_Key *out_key);
internal void dbgi_p2u_push_event(DBGI_Event *event);
internal DBGI_EventList dbgi_p2u_pop_events(Arena *arena, U64 endt_us);
internal void di_p2u_push_event(DI_Event *event);
internal DI_EventList di_p2u_pop_events(Arena *arena, U64 endt_us);
internal void dbgi_parse_thread_entry_point(void *p);
internal void di_parse_thread__entry_point(void *p);
////////////////////////////////
//~ rjf: Fuzzy Searching Threads
internal B32 dbgi_u2f_enqueue_req(U128 key, U64 endt_us);
internal void dbgi_u2f_dequeue_req(Arena *arena, DBGI_FuzzySearchThread *thread, U128 *key_out);
internal int dbgi_qsort_compare_fuzzy_search_items(DBGI_FuzzySearchItem *a, DBGI_FuzzySearchItem *b);
internal void dbgi_fuzzy_thread__entry_point(void *p);
#endif //DBGI_H
#endif // DI_H
-231
View File
@@ -1,231 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//- allen: Acceleration Layer Functions
//- accel helpers
internal DEMON_AccelModule*
demon_accel_module_alloc(void){
DEMON_AccelModule *result = demon_free_module_accel;
if (result != 0){
SLLStackPop(demon_free_module_accel);
}
else{
result = push_array_no_zero(demon_ent_arena, DEMON_AccelModule, 1);
}
MemoryZeroStruct(result);
return(result);
}
internal void
demon_accel_module_free(DEMON_AccelModule *module){
SLLStackPush(demon_free_module_accel, module);
}
internal DEMON_AccelThread*
demon_accel_thread_alloc(void){
DEMON_AccelThread *result = demon_free_thread_accel;
if (result != 0){
SLLStackPop(demon_free_thread_accel);
}
else{
result = push_array_no_zero(demon_ent_arena, DEMON_AccelThread, 1);
}
MemoryZeroStruct(result);
return(result);
}
internal void
demon_accel_thread_free(DEMON_AccelThread *thread){
SLLStackPush(demon_free_thread_accel, thread);
}
internal DEMON_AccelThread*
demon_accel_from_thread(DEMON_Entity *thread){
DEMON_AccelThread *accel = (DEMON_AccelThread*)thread->accel;
if (accel == 0){
accel = demon_accel_thread_alloc();
thread->accel = accel;
}
return(accel);
}
//- operations on demon objects
internal String8
demon_accel_full_path_from_module(Arena *arena, DEMON_Entity *module){
DEMON_AccelModule *accel = (DEMON_AccelModule*)module->accel;
String8 result = {0};
// first time
if (accel == 0){
result = demon_os_full_path_from_module(arena, module);
// build chain
DEMON_AccelModule *last_accel = 0;
U8 *ptr = result.str;
U8 *opl = result.str + result.size;
for (;ptr < opl;){
U64 size = (U64)(ptr - opl);
U64 clamped_size = ClampTop(result.size, sizeof(Member(DEMON_AccelModule, buf)));
DEMON_AccelModule *node = demon_accel_module_alloc();
SLLQueuePush(accel, last_accel, node);
node->total_size = result.size;
MemoryCopy(node->buf, ptr, clamped_size);
ptr += clamped_size;
}
// store in module
module->accel = accel;
}
// read from accel
else{
U64 size = accel->total_size;
U8 *str = push_array_no_zero(arena, U8, size + 1);
// copy chain contents to buffer
U8 *ptr = str;
for (DEMON_AccelModule *node = accel;
node != 0;
node = node->next){
U64 total_size = node->total_size;
U64 clamped_size = ClampTop(total_size, sizeof(node->buf));
MemoryCopy(ptr, node->buf, clamped_size);
ptr += clamped_size;
}
*ptr = 0;
// fill result
result.str = str;
result.size = size;
}
return(result);
}
internal U64
demon_accel_stack_base_vaddr_from_thread(DEMON_Entity *thread){
// get accel data
DEMON_AccelThread *accel = demon_accel_from_thread(thread);
// fill stack base
if (!accel->has_stack_base){
accel->has_stack_base = 1;
accel->stack_base = demon_os_stack_base_vaddr_from_thread(thread);
}
return(accel->stack_base);
}
internal U64
demon_accel_tls_root_vaddr_from_thread(DEMON_Entity *thread){
// get accel data
DEMON_AccelThread *accel = demon_accel_from_thread(thread);
// fill tls root
if (!accel->has_tls_root){
accel->has_tls_root = 1;
accel->tls_root = demon_os_tls_root_vaddr_from_thread(thread);
}
return(accel->tls_root);
}
internal void*
demon_accel_read_regs(DEMON_Entity *thread){
// get accel data
DEMON_AccelThread *accel = demon_accel_from_thread(thread);
// update reg cache
if (accel->reg_cache_time != demon_time){
accel->reg_cache_time = demon_time;
B32 success = demon_os_read_regs(thread, &accel->regs);
if (!success){
MemoryZeroStruct(&accel->regs);
}
}
return(&accel->regs);
}
internal void
demon_accel_write_regs(DEMON_Entity *thread, void *data){
// get accel data
DEMON_AccelThread *accel = demon_accel_from_thread(thread);
// low level write
B32 success = 0;
U64 data_size = 0;
switch (thread->arch){
case Architecture_x86:
{
data_size = sizeof(REGS_RegBlockX86);
success = demon_os_write_regs_x86(thread, (REGS_RegBlockX86*)data);
}break;
case Architecture_x64:
{
data_size = sizeof(REGS_RegBlockX64);
success = demon_os_write_regs_x64(thread, (REGS_RegBlockX64*)data);
}break;
}
// update cache
if (success){
accel->reg_cache_time = demon_time;
MemoryCopy(&accel->regs, data, data_size);
}
}
internal void
demon_accel_low_level_write_regs(DEMON_Entity *thread){
// NOTE(allen): This is a tricky one. It's just a way to enable some internal
// optimizations. Instead of forcing the user to pass in register data
// to write out and copy to the cache, the "user" is other demon code that
// knows what it's doing. So it grabs the cache memory (through a call to
// `demon_accel_read_regs`) modifies it in place and then calls this.
// So we just have to write the cache contents directly out to OS.
// get accel data
DEMON_AccelThread *accel = demon_accel_from_thread(thread);
switch (thread->arch){
case Architecture_x86:
{
demon_os_write_regs_x86(thread, &accel->regs.x86);
}break;
case Architecture_x64:
{
demon_os_write_regs_x64(thread, &accel->regs.x64);
}break;
}
}
//- entity accel free
internal void
demon_accel_free(DEMON_Entity *entity){
switch (entity->kind){
case DEMON_EntityKind_Module:
{
if (entity->accel != 0){
for (DEMON_AccelModule *node = (DEMON_AccelModule*)entity->accel, *next = 0;
node != 0;
node = next){
next = node->next;
demon_accel_module_free(node);
}
}
}break;
case DEMON_EntityKind_Thread:
{
if (entity->accel != 0){
demon_accel_thread_free((DEMON_AccelThread*)entity->accel);
}
}break;
}
}
-66
View File
@@ -1,66 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DEMON_ACCEL_H
#define DEMON_ACCEL_H
////////////////////////////////
//~ allen: Acceleration Data
typedef struct DEMON_AccelModule DEMON_AccelModule;
struct DEMON_AccelModule
{
DEMON_AccelModule *next;
U64 total_size;
U8 buf[240];
};
typedef union DEMON_AccelThread DEMON_AccelThread;
union DEMON_AccelThread
{
DEMON_AccelThread *next;
struct{
B32 has_stack_base;
B32 has_tls_root;
U64 stack_base;
U64 tls_root;
U64 reg_cache_time;
union{
REGS_RegBlockX64 x64;
REGS_RegBlockX86 x86;
} regs;
};
};
////////////////////////////////
//~ allen: Acceleration Globals
global DEMON_AccelModule *demon_free_module_accel = 0;
global DEMON_AccelThread *demon_free_thread_accel = 0;
////////////////////////////////
//~ allen: Acceleration Layer Functions
//- accel helpers
internal DEMON_AccelModule *demon_accel_module_alloc(void);
internal void demon_accel_module_free(DEMON_AccelModule *module);
internal DEMON_AccelThread *demon_accel_thread_alloc(void);
internal void demon_accel_thread_free(DEMON_AccelThread *thread);
internal DEMON_AccelThread *demon_accel_from_thread(DEMON_Entity *thread);
//- operations on demon objects
internal String8 demon_accel_full_path_from_module(Arena *arena, DEMON_Entity *module);
internal U64 demon_accel_stack_base_vaddr_from_thread(DEMON_Entity *thread);
internal U64 demon_accel_tls_root_vaddr_from_thread(DEMON_Entity *thread);
internal void* demon_accel_read_regs(DEMON_Entity *thread);
internal void demon_accel_write_regs(DEMON_Entity *thread, void *data);
internal void demon_accel_low_level_write_regs(DEMON_Entity *thread);
//- entity accel free
internal void demon_accel_free(DEMON_Entity *entity);
#endif //DEMON_ACCEL_H
-270
View File
@@ -1,270 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
// NOTE(allen): State Safety Helper
internal B32
demon_access_begin(void){
B32 result = 0;
if (demon_primary_thread){
Assert(demon_run_state);
result = 1;
}
else{
os_mutex_take(demon_state_mutex);
if (demon_run_state){
os_mutex_drop(demon_state_mutex);
}
else{
result = 1;
}
}
return(result);
}
internal void
demon_access_end(void){
if (!demon_primary_thread){
os_mutex_drop(demon_state_mutex);
}
}
////////////////////////////////
// NOTE(allen): Entity System
internal void
demon_common_init(void){
// access control mechanism
demon_state_mutex = os_mutex_alloc();
// time
demon_time = 1;
// setup arena
demon_ent_arena = arena_alloc();
// setup map
demon_ent_map = push_array(demon_ent_arena, DEMON_Map, 1);
demon_ent_map->bucket_count = 4093;
demon_ent_map->buckets = push_array(demon_ent_arena, DEMON_MapSlot*, demon_ent_map->bucket_count);
// setup entity memory
U64 reserve_size_unaligned = (DEMON_ENTITY_CAP)*sizeof(DEMON_Entity);
U64 reserve_size = AlignPow2(reserve_size_unaligned, DEMON_ENTITY_CMT_SIZE);
demon_ent_cmt = demon_ent_pos = demon_ent_base = (DEMON_Entity*)os_reserve(reserve_size);
demon_ent_opl = demon_ent_base + (reserve_size/sizeof(DEMON_Entity));
Assert(demon_ent_base != 0);
// setup root
demon_ent_root = demon_ent_alloc();
demon_ent_root->kind = DEMON_EntityKind_Root;
}
internal DEMON_Entity*
demon_ent_alloc(void){
DEMON_Entity *result = demon_ent_free;
if (result != 0){
SLLStackPop(demon_ent_free);
}
else{
if (demon_ent_pos < demon_ent_opl){
if (ensure_commit(&demon_ent_cmt, demon_ent_pos + 1, DEMON_ENTITY_CMT_SIZE)){
result = demon_ent_pos;
demon_ent_pos += 1;
}
}
}
if (result != 0){
U32 gen = result->gen;
MemoryZeroStruct(result);
result->gen = gen;
}
return(result);
}
//- handle <-> entity pointer
internal DEMON_Entity*
demon_ent_ptr_from_handle(DEMON_Handle handle){
Assert(demon_ent_base != 0);
DEMON_Entity *result = 0;
U32 index = (U32)(handle & 0xFFFFFFFF);
U64 count = (U64)(demon_ent_pos - demon_ent_base);
if (0 < index && index < count){
DEMON_Entity *entity = demon_ent_base + index;
U32 gen = (U32)(handle >> 32);
if (gen == entity->gen){
result = entity;
}
}
return(result);
}
internal DEMON_Handle
demon_ent_handle_from_ptr(DEMON_Entity *entity){
Assert(demon_ent_base != 0);
DEMON_Handle result = {0};
if (demon_ent_base < entity && entity < demon_ent_pos){
U32 index = (U32)(entity - demon_ent_base);
U64 gen = entity->gen;
result = (gen << 32) | index;
}
return(result);
}
//- high level entity alloc,init,release
internal DEMON_Entity*
demon_ent_new(DEMON_Entity *parent, DEMON_EntityKind kind, U64 id){
Assert(demon_ent_base != 0);
DEMON_Entity *result = demon_ent_alloc();
if (result != 0){
result->kind = kind;
result->id = id;
result->arch = parent->arch;
result->parent = parent;
DLLPushBack(parent->first, parent->last, result);
demon_ent_map_save(kind, id, result);
}
return(result);
}
internal void
demon_ent_release_single(DEMON_Entity *entity){
switch (entity->kind){
case DEMON_EntityKind_Process: demon_proc_count -= 1; break;
case DEMON_EntityKind_Thread: demon_thread_count -= 1; break;
case DEMON_EntityKind_Module: demon_module_count -= 1; break;
}
demon_accel_free(entity);
demon_os_entity_cleanup(entity);
DEMON_MapRef ref = demon_ent_map_find(entity->kind, entity->id);
demon_ent_map_erase(ref);
entity->gen += 1;
}
internal void
demon_ent_release_children(DEMON_Entity *root){
Assert(demon_ent_base != 0);
if (root->first != 0){
for (DEMON_Entity *node = root->first;
node != 0;
node = node->next){
demon_ent_release_children(node);
demon_ent_release_single(node);
}
root->last->next = demon_ent_free;
demon_ent_free = root->first;
root->first = 0;
root->last = 0;
}
}
internal void
demon_ent_release_root_and_children(DEMON_Entity *root){
Assert(demon_ent_base != 0);
Assert(root->parent != 0);
// release children
demon_ent_release_children(root);
// release root
DEMON_Entity *parent = root->parent;
demon_ent_release_single(root);
DLLRemove(parent->first, parent->last, root);
SLLStackPush(demon_ent_free, root);
}
//- entity map
internal U64
demon_ent_map_hash(U16 kind, U64 id){
U64 result = ((U64)kind << 32) ^ id;
return(result);
}
internal void
demon_ent_map_save(U16 kind, U64 id, DEMON_Entity *entity){
Assert(demon_ent_base != 0);
DEMON_Map *map = demon_ent_map;
// allocate a new slot
DEMON_MapSlot *slot = map->free_slots;
if (slot != 0){
SLLStackPop(map->free_slots);
}
else{
slot = push_array_no_zero(demon_ent_arena, DEMON_MapSlot, 1);
}
// fill slot
slot->kind = kind;
slot->id = id;
slot->entity = entity;
// insert into bucket
U64 hash = demon_ent_map_hash(kind, id);
U64 bucket_index = hash%map->bucket_count;
SLLStackPush(map->buckets[bucket_index], slot);
}
internal DEMON_MapRef
demon_ent_map_find(U16 kind, U64 id){
Assert(demon_ent_base != 0);
DEMON_Map *map = demon_ent_map;
// scan bucket
DEMON_MapRef result = {0};
U64 hash = demon_ent_map_hash(kind, id);
U64 bucket_index = hash%map->bucket_count;
for (DEMON_MapSlot **ptr = &map->buckets[bucket_index], *slot = 0;
*ptr != 0;
ptr = &slot->next){
slot = *ptr;
if (slot->kind == kind && slot->id == id){
result.slot = slot;
result.ptr_to_slot = ptr;
break;
}
}
return(result);
}
internal DEMON_Entity*
demon_ent_map_entity_from_id(U16 kind, U64 id){
DEMON_Entity *result = 0;
DEMON_MapRef ref = demon_ent_map_find(kind, id);
if (ref.slot != 0){
result = ref.slot->entity;
}
return(result);
}
internal void
demon_ent_map_erase(DEMON_MapRef ref){
Assert(demon_ent_base != 0);
DEMON_Map *map = demon_ent_map;
// move slot to free list
if (ref.slot != 0){
*ref.ptr_to_slot = ref.slot->next;
SLLStackPush(map->free_slots, ref.slot);
}
}
////////////////////////////////
// NOTE(allen): Event Helpers
internal DEMON_Event*
demon_push_event(Arena *arena, DEMON_EventList *list, DEMON_EventKind kind){
DEMON_EventNode *n = push_array(arena, DEMON_EventNode, 1);
DEMON_Event *result = &n->v;
SLLQueuePush(list->first, list->last, n);
list->count += 1;
result->kind = kind;
return(result);
}
-150
View File
@@ -1,150 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DEMON_COMMON_H
#define DEMON_COMMON_H
////////////////////////////////
//~ allen: DEMON Entity System
typedef enum DEMON_EntityKind
{
DEMON_EntityKind_NULL,
DEMON_EntityKind_Root,
DEMON_EntityKind_Process,
DEMON_EntityKind_Thread,
DEMON_EntityKind_Module,
DEMON_EntityKind_COUNT
}
DEMON_EntityKind;
typedef struct DEMON_Entity DEMON_Entity;
struct DEMON_Entity
{
// TODO(allen): these could be U32s
DEMON_Entity *next;
DEMON_Entity *prev;
DEMON_Entity *parent;
DEMON_Entity *first;
DEMON_Entity *last;
DEMON_EntityKind kind;
Architecture arch;
U32 gen;
U64 id;
U64 addr_range_dim;
// each OS backend decides how to use `ext` for each entity kind
union{
void *ext;
U64 ext_u64;
};
// the accel layer attaches some extra information to some entities
void *accel;
};
//- id -> entity map
typedef struct DEMON_MapSlot DEMON_MapSlot;
struct DEMON_MapSlot
{
DEMON_MapSlot *next;
U16 kind;
U64 id;
DEMON_Entity *entity;
};
typedef struct DEMON_Map DEMON_Map;
struct DEMON_Map
{
DEMON_MapSlot **buckets;
U64 bucket_count;
DEMON_MapSlot *free_slots;
};
typedef struct DEMON_MapRef DEMON_MapRef;
struct DEMON_MapRef
{
DEMON_MapSlot *slot;
DEMON_MapSlot **ptr_to_slot;
};
//- rjf: entity extrusive list
typedef struct DEMON_EntityNode DEMON_EntityNode;
struct DEMON_EntityNode
{
DEMON_EntityNode *next;
DEMON_Entity *entity;
};
////////////////////////////////
//~ allen: Demon Globals
thread_static B32 demon_primary_thread = 0;
global B32 demon_run_state = 0;
global OS_Handle demon_state_mutex = {0};
global U64 demon_time = 0;
global Arena *demon_ent_arena = 0;
global DEMON_Map *demon_ent_map = 0;
global DEMON_Entity *demon_ent_free = 0;
global DEMON_Entity *demon_ent_root = 0;
global DEMON_Entity *demon_ent_base = 0;
global DEMON_Entity *demon_ent_pos = 0;
global DEMON_Entity *demon_ent_opl = 0;
global void *demon_ent_cmt = 0;
global U64 demon_proc_count = 0;
global U64 demon_thread_count = 0;
global U64 demon_module_count = 0;
#if !defined(DEMON_ENTITY_CMT_SIZE)
# define DEMON_ENTITY_CMT_SIZE KB(64)
#endif
#if !defined(DEMON_ENTITY_CAP)
# define DEMON_ENTITY_CAP 65536
#endif
StaticAssert(IsPow2(DEMON_ENTITY_CMT_SIZE), check_demon_entity_cmt_size);
////////////////////////////////
//~ allen: State Safety Helper
internal B32 demon_access_begin(void);
internal void demon_access_end(void);
////////////////////////////////
//~ allen: Entity System
internal void demon_common_init(void);
internal DEMON_Entity* demon_ent_alloc(void);
//- handle <-> entity pointer
internal DEMON_Entity* demon_ent_ptr_from_handle(DEMON_Handle handle);
internal DEMON_Handle demon_ent_handle_from_ptr(DEMON_Entity *entity);
//- high level entity alloc,init,release
internal DEMON_Entity* demon_ent_new(DEMON_Entity *parent, DEMON_EntityKind kind, U64 id);
internal void demon_ent_release_single(DEMON_Entity *entity);
internal void demon_ent_release_children(DEMON_Entity *root);
internal void demon_ent_release_root_and_children(DEMON_Entity *root);
//- entity map
internal U64 demon_ent_map_hash(U16 kind, U64 id);
internal void demon_ent_map_save(U16 kind, U64 id, DEMON_Entity *entity);
internal DEMON_MapRef demon_ent_map_find(U16 kind, U64 id);
internal DEMON_Entity* demon_ent_map_entity_from_id(U16 kind, U64 id);
internal void demon_ent_map_erase(DEMON_MapRef map_ref);
////////////////////////////////
//~ allen: Event Helpers
internal DEMON_Event* demon_push_event(Arena *arena, DEMON_EventList *list, DEMON_EventKind kind);
#endif //DEMON_COMMON_H
+65 -778
View File
@@ -2,148 +2,39 @@
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Main Layer Initialization
//~ rjf: Generated Code
internal void
demon_init(void){
demon_common_init();
demon_os_init();
}
#include "generated/demon.meta.c"
////////////////////////////////
//~ rjf: Basic Type Functions
//~ rjf: Basic Type Functions (Helpers, Implemented Once)
//- rjf: stringizing
//- rjf: handles
internal String8
demon_string_from_event_kind(DEMON_EventKind kind){
String8 result = str8_lit("unknown");
switch (kind){
default: break;
case DEMON_EventKind_Error: result = str8_lit("Error"); break;
case DEMON_EventKind_HandshakeComplete: result = str8_lit("HandshakeComplete"); break;
case DEMON_EventKind_CreateProcess: result = str8_lit("CreateProcess"); break;
case DEMON_EventKind_ExitProcess: result = str8_lit("ExitProcess"); break;
case DEMON_EventKind_CreateThread: result = str8_lit("CreateThread"); break;
case DEMON_EventKind_ExitThread: result = str8_lit("ExitThread"); break;
case DEMON_EventKind_LoadModule: result = str8_lit("LoadModule"); break;
case DEMON_EventKind_UnloadModule: result = str8_lit("UnloadModule"); break;
case DEMON_EventKind_Breakpoint: result = str8_lit("Breakpoint"); break;
case DEMON_EventKind_Trap: result = str8_lit("Trap"); break;
case DEMON_EventKind_SingleStep: result = str8_lit("SingleStep"); break;
case DEMON_EventKind_Exception: result = str8_lit("Exception"); break;
case DEMON_EventKind_Halt: result = str8_lit("Halt"); break;
case DEMON_EventKind_Memory: result = str8_lit("Memory"); break;
case DEMON_EventKind_DebugString: result = str8_lit("DebugString"); break;
case DEMON_EventKind_SetThreadName: result = str8_lit("SetThreadName"); break;
}
return(result);
internal DMN_Handle
dmn_handle_zero(void)
{
DMN_Handle h = {0};
return h;
}
internal String8
demon_string_from_memory_event_kind(DEMON_MemoryEventKind kind){
String8 result = str8_lit("unknown");
switch (kind){
default: break;
case DEMON_MemoryEventKind_Commit: result = str8_lit("Commit"); break;
case DEMON_MemoryEventKind_Reserve: result = str8_lit("Reserve"); break;
case DEMON_MemoryEventKind_Decommit: result = str8_lit("Decommit"); break;
case DEMON_MemoryEventKind_Release: result = str8_lit("Release"); break;
}
return(result);
}
internal String8
demon_string_from_exception_kind(DEMON_ExceptionKind kind){
String8 result = str8_lit("unknown");
switch (kind){
default: break;
case DEMON_ExceptionKind_MemoryRead: result = str8_lit("MemoryRead"); break;
case DEMON_ExceptionKind_MemoryWrite: result = str8_lit("MemoryWrite"); break;
case DEMON_ExceptionKind_MemoryExecute: result = str8_lit("MemoryExecute"); break;
case DEMON_ExceptionKind_CppThrow: result = str8_lit("CppThrow"); break;
}
return(result);
}
internal void
demon_string_list_from_event(Arena *arena, String8List *out, DEMON_Event *event){
B32 need_exception_info = (event->kind == DEMON_EventKind_Exception ||
event->kind == DEMON_EventKind_Breakpoint ||
event->kind == DEMON_EventKind_Halt ||
event->kind == DEMON_EventKind_SingleStep);
// allen: kind
String8 kind_string = demon_string_from_event_kind(event->kind);
str8_list_pushf(arena, out, "%S: { (%i)", kind_string, event->kind);
// rjf: basics
{
str8_list_pushf(arena, out, " process: (%I64x)", event->process);
str8_list_pushf(arena, out, " thread: (%I64x)", event->thread);
str8_list_pushf(arena, out, " module: (%I64x)", event->module);
str8_list_pushf(arena, out, " address: (%I64x)", event->address, event->address);
str8_list_pushf(arena, out, " size: (0x%I64x, %I64u)", event->size, event->size);
}
// rjf: string
if (event->string.size != 0){
str8_list_pushf(arena, out, " string: \"%S\"", event->string);
}
// rjf: exception info
if (need_exception_info){
str8_list_pushf(arena, out, " code: (0x%x, %i)", event->code, event->code);
str8_list_pushf(arena, out, " flags: (0x%x, %i)", event->flags, event->flags);
str8_list_pushf(arena, out, " signo: (0x%x, %i)", event->signo, event->signo);
str8_list_pushf(arena, out, " sigcode: (0x%x, %i)", event->sigcode, event->sigcode);
}
// rjf: need error info
if (event->kind == DEMON_EventKind_Error){
str8_list_pushf(arena, out, " error_kind: (0x%x, %i)", event->error_kind, event->error_kind);
}
// rjf: memory event kind info
if (event->memory_kind != DEMON_MemoryEventKind_Null){
String8 memory_kind_string = demon_string_from_memory_event_kind(event->memory_kind);
str8_list_pushf(arena, out, " memory_kind: (%S, %i)",
memory_kind_string, event->memory_kind);
}
// rjf: exception kind
if (need_exception_info){
String8 exception_kind_string = demon_string_from_exception_kind(event->exception_kind);
str8_list_pushf(arena, out, " exception_kind: (%S, %i)",
exception_kind_string, event->exception_kind);
}
// rjf: instruction ptr
if (event->instruction_pointer != 0){
str8_list_pushf(arena, out, " instruction_pointer: (%I64x)", event->instruction_pointer);
}
// rjf: stack ptr
if (event->stack_pointer != 0){
str8_list_pushf(arena, out, " stack_pointer: (%I64x)", event->stack_pointer);
}
str8_list_pushf(arena, out, " user_data: (0x%I64x, %I64u)",
event->user_data, event->user_data);
str8_list_pushf(arena, out, "}");
internal B32
dmn_handle_match(DMN_Handle a, DMN_Handle b)
{
return a.u32[0] == b.u32[0] && a.u32[1] == b.u32[1];
}
//- rjf: trap chunk lists
internal void
demon_trap_chunk_list_push(Arena *arena, DEMON_TrapChunkList *list, U64 cap, DEMON_Trap *trap)
dmn_trap_chunk_list_push(Arena *arena, DMN_TrapChunkList *list, U64 cap, DMN_Trap *trap)
{
DEMON_TrapChunkNode *node = list->last;
DMN_TrapChunkNode *node = list->last;
if(node == 0 || node->count >= node->cap)
{
node = push_array(arena, DEMON_TrapChunkNode, 1);
node = push_array(arena, DMN_TrapChunkNode, 1);
node->cap = cap;
node->v = push_array_no_zero(arena, DEMON_Trap, node->cap);
node->v = push_array_no_zero(arena, DMN_Trap, node->cap);
SLLQueuePush(list->first, list->last, node);
list->node_count += 1;
}
@@ -153,7 +44,7 @@ demon_trap_chunk_list_push(Arena *arena, DEMON_TrapChunkList *list, U64 cap, DEM
}
internal void
demon_trap_chunk_list_concat_in_place(DEMON_TrapChunkList *dst, DEMON_TrapChunkList *to_push)
dmn_trap_chunk_list_concat_in_place(DMN_TrapChunkList *dst, DMN_TrapChunkList *to_push)
{
if(dst->last == 0)
{
@@ -170,11 +61,11 @@ demon_trap_chunk_list_concat_in_place(DEMON_TrapChunkList *dst, DEMON_TrapChunkL
}
internal void
demon_trap_chunk_list_concat_shallow_copy(Arena *arena, DEMON_TrapChunkList *dst, DEMON_TrapChunkList *to_push)
dmn_trap_chunk_list_concat_shallow_copy(Arena *arena, DMN_TrapChunkList *dst, DMN_TrapChunkList *to_push)
{
for(DEMON_TrapChunkNode *src_n = to_push->first; src_n != 0; src_n = src_n->next)
for(DMN_TrapChunkNode *src_n = to_push->first; src_n != 0; src_n = src_n->next)
{
DEMON_TrapChunkNode *dst_n = push_array(arena, DEMON_TrapChunkNode, 1);
DMN_TrapChunkNode *dst_n = push_array(arena, DMN_TrapChunkNode, 1);
dst_n->v = src_n->v;
dst_n->cap = src_n->cap;
dst_n->count = src_n->count;
@@ -187,685 +78,81 @@ demon_trap_chunk_list_concat_shallow_copy(Arena *arena, DEMON_TrapChunkList *dst
//- rjf: handle lists
internal void
demon_handle_list_push(Arena *arena, DEMON_HandleList *list, DEMON_Handle handle)
dmn_handle_list_push(Arena *arena, DMN_HandleList *list, DMN_Handle handle)
{
DEMON_HandleNode *node = push_array(arena, DEMON_HandleNode, 1);
DMN_HandleNode *node = push_array(arena, DMN_HandleNode, 1);
SLLQueuePush(list->first, list->last, node);
node->v = handle;
list->count += 1;
}
internal DEMON_HandleArray
demon_handle_array_from_list(Arena *arena, DEMON_HandleList *list)
internal DMN_HandleArray
dmn_handle_array_from_list(Arena *arena, DMN_HandleList *list)
{
DEMON_HandleArray array = {0};
DMN_HandleArray array = {0};
array.count = list->count;
array.handles = push_array_no_zero(arena, DEMON_Handle, array.count);
array.handles = push_array_no_zero(arena, DMN_Handle, array.count);
U64 idx = 0;
for(DEMON_HandleNode *n = list->first; n != 0; n = n->next, idx += 1)
for(DMN_HandleNode *n = list->first; n != 0; n = n->next, idx += 1)
{
array.handles[idx] = n->v;
}
return array;
}
internal DEMON_HandleArray
demon_handle_array_copy(Arena *arena, DEMON_HandleArray *src)
internal DMN_HandleArray
dmn_handle_array_copy(Arena *arena, DMN_HandleArray *src)
{
DEMON_HandleArray dst = {0};
DMN_HandleArray dst = {0};
dst.count = src->count;
dst.handles = push_array_no_zero(arena, DEMON_Handle, dst.count);
MemoryCopy(dst.handles, src->handles, sizeof(DEMON_Handle)*dst.count);
dst.handles = push_array_no_zero(arena, DMN_Handle, dst.count);
MemoryCopy(dst.handles, src->handles, sizeof(DMN_Handle)*dst.count);
return dst;
}
////////////////////////////////
//~ rjf: Primary Thread & Exclusive Mode Controls
//- rjf: event list building
internal void
demon_primary_thread_begin(void){
demon_primary_thread = 1;
}
internal void
demon_exclusive_mode_begin(void){
Assert(demon_primary_thread);
os_mutex_take(demon_state_mutex);
demon_run_state = 1;
os_mutex_drop(demon_state_mutex);
}
internal void
demon_exclusive_mode_end(void){
Assert(demon_primary_thread);
os_mutex_take(demon_state_mutex);
demon_run_state = 0;
os_mutex_drop(demon_state_mutex);
}
////////////////////////////////
//~ rjf: Running/Halting
internal DEMON_EventList
demon_run(Arena *arena, DEMON_RunCtrls *ctrls)
internal DMN_Event *
dmn_event_list_push(Arena *arena, DMN_EventList *list)
{
Assert(demon_primary_thread);
Temp scratch = scratch_begin(&arena, 1);
DMN_EventNode *n = push_array(arena, DMN_EventNode, 1);
SLLQueuePush(list->first, list->last, n);
list->count += 1;
DMN_Event *result = &n->v;
return result;
}
// convert controls to os controls
B32 full_conversion = 1;
DEMON_OS_RunCtrls os_ctrls = {0};
////////////////////////////////
//~ rjf: Thread Reading Helper Functions (Helpers, Implemented Once)
internal U64
dmn_rip_from_thread(DMN_Handle thread)
{
U64 result = 0;
Temp scratch = scratch_begin(0, 0);
{
// convert single_step_thread
if (ctrls->single_step_thread != 0){
DEMON_Entity *sst_entity = demon_ent_ptr_from_handle(ctrls->single_step_thread);
if (sst_entity != 0 &&
sst_entity->kind == DEMON_EntityKind_Thread){
os_ctrls.single_step_thread = sst_entity;
Architecture arch = dmn_arch_from_thread(thread);
U64 reg_block_size = regs_block_size_from_architecture(arch);
void *reg_block = push_array(scratch.arena, U8, reg_block_size);
dmn_thread_read_reg_block(thread, reg_block);
result = regs_rip_from_arch_block(arch, reg_block);
}
else{
full_conversion = 0;
goto finish_conversion;
}
}
// convert exception handling flag
os_ctrls.ignore_previous_exception = ctrls->ignore_previous_exception;
// convert fronzen threads
os_ctrls.run_entities_are_unfrozen = ctrls->run_entities_are_unfrozen;
os_ctrls.run_entities_are_processes = ctrls->run_entities_are_processes;
os_ctrls.run_entity_count = ctrls->run_entity_count;
os_ctrls.run_entities = push_array_no_zero(scratch.arena, DEMON_Entity*, ctrls->run_entity_count);
{
DEMON_EntityKind expected_entity_kind = DEMON_EntityKind_Thread;
if (os_ctrls.run_entities_are_processes){
expected_entity_kind = DEMON_EntityKind_Process;
}
DEMON_Handle *src = ctrls->run_entities;
DEMON_Entity **dst = os_ctrls.run_entities;
for (U64 i = 0; i < ctrls->run_entity_count; i += 1, src += 1, dst += 1){
DEMON_Entity *frozen_thread = demon_ent_ptr_from_handle(*src);
if (frozen_thread != 0 &&
frozen_thread->kind == expected_entity_kind){
*dst = frozen_thread;
}
else{
full_conversion = 0;
goto finish_conversion;
}
}
}
// convert traps
os_ctrls.traps = push_array_no_zero(scratch.arena, DEMON_OS_Trap, ctrls->traps.trap_count);
{
DEMON_OS_Trap *dst = os_ctrls.traps;
for (DEMON_TrapChunkNode *node = ctrls->traps.first;
node != 0;
node = node->next){
DEMON_Trap *src = node->v;
U64 node_trap_count = node->count;
for (U64 i = 0; i < node_trap_count; i += 1, src += 1){
if (src->process != 0){
DEMON_Entity *trap_process = demon_ent_ptr_from_handle(src->process);
if (trap_process != 0 &&
trap_process->kind == DEMON_EntityKind_Process){
dst->process = trap_process;
dst->address = src->address;
dst += 1;
}
else{
full_conversion = 0;
goto finish_conversion;
}
}
}
}
os_ctrls.trap_count = (U64)(dst - os_ctrls.traps);
}
finish_conversion:;
}
// call the OS implementation of run
DEMON_EventList result = {0};
if (full_conversion){
result = demon_os_run(arena, &os_ctrls);
}
else{
DEMON_Event *event = demon_push_event(arena, &result, DEMON_EventKind_Error);
event->error_kind = DEMON_ErrorKind_InvalidHandle;
}
scratch_end(scratch);
return(result);
}
internal void
demon_halt(U64 code, U64 user_data){
demon_os_halt(code, user_data);
return result;
}
internal U64
demon_get_time_counter(void){
return(demon_time);
}
////////////////////////////////
//~ rjf: Target Process Launching/Attaching/Killing/Detaching/Halting
internal U32
demon_launch_process(OS_LaunchOptions *options){
Assert(demon_primary_thread);
U32 result = demon_os_launch_process(options);
return(result);
}
internal B32
demon_attach_process(U32 pid){
Assert(demon_primary_thread);
B32 result = demon_os_attach_process(pid);
return(result);
}
internal B32
demon_kill_process(DEMON_Handle process, U32 exit_code){
Assert(demon_primary_thread);
B32 result = 0;
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
result = demon_os_kill_process(entity, exit_code);
}
return(result);
}
internal B32
demon_detach_process(DEMON_Handle process){
Assert(demon_primary_thread);
B32 result = 0;
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
result = demon_os_detach_process(entity);
}
return(result);
}
////////////////////////////////
//~ rjf: Entity Functions
//- rjf: basics
internal B32
demon_object_exists(DEMON_Handle object){
B32 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(object);
result = (entity != 0);
demon_access_end();
}
return(result);
}
//- rjf: introspection
internal Architecture
demon_arch_from_object(DEMON_Handle object){
Architecture result = Architecture_Null;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(object);
if (entity != 0){
result = (Architecture)entity->arch;
}
demon_access_end();
}
return(result);
}
internal U64
demon_base_vaddr_from_module(DEMON_Handle module){
U64 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(module);
if (entity != 0 && entity->kind == DEMON_EntityKind_Module){
result = entity->id;
}
demon_access_end();
}
return(result);
}
internal Rng1U64
demon_vaddr_range_from_module(DEMON_Handle module)
dmn_rsp_from_thread(DMN_Handle thread)
{
Rng1U64 result = {0};
if(demon_access_begin())
{
DEMON_Entity *entity = demon_ent_ptr_from_handle(module);
if(entity != 0 && entity->kind == DEMON_EntityKind_Module)
{
result = r1u64(entity->id, entity->id+entity->addr_range_dim);
}
demon_access_end();
}
return(result);
}
internal String8
demon_full_path_from_module(Arena *arena, DEMON_Handle module){
String8 result = {0};
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(module);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Module){
result = demon_accel_full_path_from_module(arena, entity);
}
demon_access_end();
}
return(result);
}
internal U64
demon_stack_base_vaddr_from_thread(DEMON_Handle thread){
U64 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(thread);
if (entity != 0 && entity->kind == DEMON_EntityKind_Thread){
result = demon_accel_stack_base_vaddr_from_thread(entity);
}
demon_access_end();
}
return(result);
}
internal U64
demon_tls_root_vaddr_from_thread(DEMON_Handle handle){
U64 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(handle);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Thread){
result = demon_accel_tls_root_vaddr_from_thread(entity);
}
demon_access_end();
}
return(result);
}
internal DEMON_HandleArray
demon_all_processes(Arena *arena){
DEMON_HandleArray result = {0};
if (demon_access_begin()){
DEMON_Handle *handles = push_array_no_zero(arena, DEMON_Handle, demon_proc_count);
DEMON_Handle *handle_opl = handles + demon_proc_count;
DEMON_Handle *handle_ptr = handles;
for (DEMON_Entity *process = demon_ent_root->first;
process != 0 && handle_ptr < handle_opl;
process = process->next){
if (process->kind == DEMON_EntityKind_Process){
*handle_ptr = demon_ent_handle_from_ptr(process);
handle_ptr += 1;
}
}
result.handles = handles;
result.count = (U64)(handle_ptr - handles);
U64 unused_count = demon_proc_count - result.count;
arena_put_back(arena, sizeof(DEMON_Handle)*unused_count);
demon_access_end();
}
return(result);
}
internal DEMON_HandleArray
demon_threads_from_process(Arena *arena, DEMON_Handle process){
DEMON_HandleArray result = {0};
if (demon_access_begin()){
DEMON_Handle *handles = push_array_no_zero(arena, DEMON_Handle, demon_thread_count);
DEMON_Handle *handle_opl = handles + demon_thread_count;
DEMON_Handle *handle_ptr = handles;
DEMON_Entity *process_ptr = demon_ent_ptr_from_handle(process);
if (process_ptr != 0 && process_ptr->kind == DEMON_EntityKind_Process){
for (DEMON_Entity *thread = process_ptr->first;
thread != 0 && handle_ptr < handle_opl;
thread = thread->next){
if (thread->kind == DEMON_EntityKind_Thread){
*handle_ptr = demon_ent_handle_from_ptr(thread);
handle_ptr += 1;
}
}
}
result.handles = handles;
result.count = (U64)(handle_ptr - handles);
U64 unused_count = demon_thread_count - result.count;
arena_put_back(arena, sizeof(DEMON_Handle)*unused_count);
demon_access_end();
}
return(result);
}
internal DEMON_HandleArray
demon_modules_from_process(Arena *arena, DEMON_Handle process){
DEMON_HandleArray result = {0};
if (demon_access_begin()){
DEMON_Handle *handles = push_array_no_zero(arena, DEMON_Handle, demon_module_count);
DEMON_Handle *handle_opl = handles + demon_module_count;
DEMON_Handle *handle_ptr = handles;
DEMON_Entity *process_ptr = demon_ent_ptr_from_handle(process);
if (process_ptr != 0 && process_ptr->kind == DEMON_EntityKind_Process){
for (DEMON_Entity *module = process_ptr->first;
module != 0 && handle_ptr < handle_opl;
module = module->next){
if (module->kind == DEMON_EntityKind_Module){
*handle_ptr = demon_ent_handle_from_ptr(module);
handle_ptr += 1;
}
}
}
result.handles = handles;
result.count = (U64)(handle_ptr - handles);
U64 unused_count = demon_module_count - result.count;
arena_put_back(arena, sizeof(DEMON_Handle)*unused_count);
demon_access_end();
}
return(result);
}
//- rjf: target process memory allocation/protection
internal U64
demon_reserve_memory(DEMON_Handle process, U64 size){
U64 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
result = demon_os_reserve_memory(entity, size);
}
demon_access_end();
}
return(result);
}
internal B32
demon_set_memory_protect_flags(DEMON_Handle process, U64 page_vaddr, U64 size, DEMON_MemoryProtectFlags flags){
B32 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
demon_os_set_memory_protect_flags(entity, page_vaddr, size, flags);
result = 1;
}
demon_access_end();
}
return(result);
}
internal B32
demon_release_memory(DEMON_Handle process, U64 vaddr, U64 size){
B32 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
demon_os_release_memory(entity, vaddr, size);
result = 1;
}
demon_access_end();
}
return(result);
}
//- rjf: target process memory reading/writing
internal U64
demon_read_memory(DEMON_Handle process, void *dst, U64 src_address, U64 size){
U64 bytes_read = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
bytes_read = demon_os_read_memory(entity, dst, src_address, size);
}
demon_access_end();
}
return(bytes_read);
}
internal B32
demon_write_memory(DEMON_Handle process, U64 dst_address, void *src, U64 size){
B32 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(process);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Process){
result = demon_os_write_memory(entity, dst_address, src, size);
}
demon_access_end();
}
return(result);
}
#define READ_BLOCK_SIZE 4096
internal U64
demon_read_memory_amap_aligned(DEMON_Handle process, void *dst, U64 src_address, U64 size){
// Algorithm:
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ^ ^ ^
// MIN MAX SMAX
// [MIN,MAX) - range attempting to read
// [MAX,SMAX) - range not yet proven to be impossible to read
Assert(src_address%READ_BLOCK_SIZE == 0);
Assert(size%READ_BLOCK_SIZE == 0);
U64 read_size = 0;
U64 min = 0;
U64 max = size;
U64 smax = max;
for (;;){
if (max <= min){
break;
}
// attempt to read range
U64 attempt_size = max - min;
B32 success = demon_read_memory(process, (U8*)dst + min, src_address + min, attempt_size);
if (success){
// increase successful read size
read_size += attempt_size;
// adjust range up
min = max;
max = smax;
}
else{
// mark this point as too far
smax = max - READ_BLOCK_SIZE;
// bisect the range for the next read attempt
U64 mid = (min + max)/2;
U64 aligned_mid = AlignDownPow2(mid, READ_BLOCK_SIZE);
max = aligned_mid;
}
}
U64 result = read_size;
return(result);
}
internal U64
demon_read_memory_amap(DEMON_Handle process, void *dst, U64 src_address, U64 size){
U64 read_size = 0;
if (demon_access_begin()){
B32 done = 0;
U64 read_opl = src_address + size;
// pre-aligned part -- [SRC,PRE_OPL)
U64 src_block_opl = AlignPow2(src_address, READ_BLOCK_SIZE);
U64 pre_opl = Min(src_block_opl, read_opl);
if(src_address < pre_opl)
Temp scratch = scratch_begin(0, 0);
{
U64 attempt_size = pre_opl - src_address;
if(!demon_read_memory(process, dst, src_address, attempt_size))
{
done = 1;
Architecture arch = dmn_arch_from_thread(thread);
U64 reg_block_size = regs_block_size_from_architecture(arch);
void *reg_block = push_array(scratch.arena, U8, reg_block_size);
dmn_thread_read_reg_block(thread, reg_block);
result = regs_rsp_from_arch_block(arch, reg_block);
}
else
{
read_size += attempt_size;
}
}
// aligned part -- [PRE_OPL,POST_FIRST)
U64 read_opl_block_base = AlignDownPow2(read_opl, READ_BLOCK_SIZE);
U64 post_first = Max(read_opl_block_base, pre_opl);
if (!done && pre_opl < post_first){
U64 off = pre_opl - src_address;
U64 attempt_size = post_first - pre_opl;
U64 actual_size = demon_read_memory_amap_aligned(process, (U8*)dst + off,
pre_opl, attempt_size);
read_size += actual_size;
if (actual_size < attempt_size){
done = 1;
}
}
// post-aligned part -- [POST_FIRST,READ_OPL)
if (!done && post_first < read_opl){
U64 off = post_first - src_address;
U64 attempt_size = read_opl - post_first;
if (!demon_read_memory(process, (U8*)dst + off, post_first, attempt_size)){
done = 1;
}
else
{
read_size += attempt_size;
}
}
demon_access_end();
}
U64 result = read_size;
return(result);
}
#undef READ_BLOCK_SIZE
//- rjf: thread registers reading/writing
internal void*
demon_read_regs(DEMON_Handle thread){
void *result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(thread);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Thread){
result = demon_accel_read_regs(entity);
}
demon_access_end();
}
return(result);
}
internal B32
demon_write_regs(DEMON_Handle thread, void *data){
B32 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(thread);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Thread){
demon_accel_write_regs(entity, data);
result = 1;
}
demon_access_end();
}
return(result);
}
internal U64
demon_read_ip(DEMON_Handle thread){
U64 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(thread);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Thread){
void *regs = demon_accel_read_regs(entity);
result = regs_rip_from_arch_block((Architecture)entity->arch, regs);
}
demon_access_end();
}
return(result);
}
internal U64
demon_read_sp(DEMON_Handle thread){
U64 result = 0;
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(thread);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Thread){
void *regs = demon_accel_read_regs(entity);
result = regs_rsp_from_arch_block((Architecture)entity->arch, regs);
}
demon_access_end();
}
return(result);
}
internal void
demon_write_ip(DEMON_Handle thread, U64 ip){
if (demon_access_begin()){
DEMON_Entity *entity = demon_ent_ptr_from_handle(thread);
if (entity != 0 &&
entity->kind == DEMON_EntityKind_Thread){
void *regs = demon_accel_read_regs(entity);
regs_arch_block_write_rip((Architecture)entity->arch, regs, ip);
demon_accel_write_regs(entity, regs);
}
demon_access_end();
}
}
////////////////////////////////
//~ rjf: Process Listing
internal void
demon_proc_iter_begin(DEMON_ProcessIter *iter){
demon_os_proc_iter_begin(iter);
}
internal B32
demon_proc_iter_next(Arena *arena, DEMON_ProcessIter *iter, DEMON_ProcessInfo *info_out){
return(demon_os_proc_iter_next(arena, iter, info_out));
}
internal void
demon_proc_iter_end(DEMON_ProcessIter *iter){
demon_os_proc_iter_end(iter);
scratch_end(scratch);
return result;
}
+141 -192
View File
@@ -5,111 +5,70 @@
#define DEMON_CORE_H
////////////////////////////////
//~ allen: Demon Low Level Entities
//~ rjf: Control-Thread-Only Context
//
// An instance of this struct must ONLY be returned by dmn_ctrl_begin, and only
// used by the thread which called it. All APIs which can ONLY run on the
// control thread, which blocks to control & receive events, will take this
// parameter. All other APIs can be called from any thread.
typedef U64 DEMON_Handle;
typedef struct DEMON_HandleNode DEMON_HandleNode;
struct DEMON_HandleNode
typedef struct DMN_CtrlCtx DMN_CtrlCtx;
struct DMN_CtrlCtx
{
DEMON_HandleNode *next;
DEMON_Handle v;
U64 u64[1];
};
typedef struct DEMON_HandleList DEMON_HandleList;
struct DEMON_HandleList
////////////////////////////////
//~ rjf: Handle Types
typedef union DMN_Handle DMN_Handle;
union DMN_Handle
{
DEMON_HandleNode *first;
DEMON_HandleNode *last;
U32 u32[2];
U64 u64[1];
};
typedef struct DMN_HandleNode DMN_HandleNode;
struct DMN_HandleNode
{
DMN_HandleNode *next;
DMN_Handle v;
};
typedef struct DMN_HandleList DMN_HandleList;
struct DMN_HandleList
{
DMN_HandleNode *first;
DMN_HandleNode *last;
U64 count;
};
typedef struct DEMON_HandleArray DEMON_HandleArray;
struct DEMON_HandleArray
typedef struct DMN_HandleArray DMN_HandleArray;
struct DMN_HandleArray
{
DEMON_Handle *handles;
DMN_Handle *handles;
U64 count;
};
////////////////////////////////
//~ rjf: Memory Protection Flags
//~ rjf: Generated Code
typedef U32 DEMON_MemoryProtectFlags;
enum{
DEMON_MemoryProtectFlag_Read = (1<<0),
DEMON_MemoryProtectFlag_Write = (1<<1),
DEMON_MemoryProtectFlag_Execute = (1<<2),
};
#include "generated/demon.meta.h"
////////////////////////////////
//~ allen: Demon Event Types
//~ rjf: Event Types
typedef enum DEMON_EventKind
typedef struct DMN_Event DMN_Event;
struct DMN_Event
{
DEMON_EventKind_Null,
DEMON_EventKind_Error,
DEMON_EventKind_HandshakeComplete,
DEMON_EventKind_CreateProcess,
DEMON_EventKind_ExitProcess,
DEMON_EventKind_CreateThread,
DEMON_EventKind_ExitThread,
DEMON_EventKind_LoadModule,
DEMON_EventKind_UnloadModule,
DEMON_EventKind_Breakpoint,
DEMON_EventKind_Trap,
DEMON_EventKind_SingleStep,
DEMON_EventKind_Exception,
DEMON_EventKind_Halt,
DEMON_EventKind_Memory,
DEMON_EventKind_DebugString,
DEMON_EventKind_SetThreadName,
DEMON_EventKind_COUNT
}
DEMON_EventKind;
typedef enum DEMON_ErrorKind
{
DEMON_ErrorKind_Null,
DEMON_ErrorKind_NotInitialized,
DEMON_ErrorKind_NotAttached,
DEMON_ErrorKind_UnexpectedFailure,
DEMON_ErrorKind_InvalidHandle,
}
DEMON_ErrorKind;
typedef enum DEMON_MemoryEventKind
{
DEMON_MemoryEventKind_Null,
DEMON_MemoryEventKind_Commit,
DEMON_MemoryEventKind_Reserve,
DEMON_MemoryEventKind_Decommit,
DEMON_MemoryEventKind_Release,
DEMON_MemoryEventKind_COUNT
}
DEMON_MemoryEventKind;
typedef enum DEMON_ExceptionKind
{
DEMON_ExceptionKind_Null,
DEMON_ExceptionKind_MemoryRead,
DEMON_ExceptionKind_MemoryWrite,
DEMON_ExceptionKind_MemoryExecute,
DEMON_ExceptionKind_CppThrow,
DEMON_ExceptionKind_COUNT
}
DEMON_ExceptionKind;
typedef struct DEMON_Event DEMON_Event;
struct DEMON_Event
{
// TODO(allen): condense
DEMON_EventKind kind;
DEMON_ErrorKind error_kind;
DEMON_MemoryEventKind memory_kind;
DEMON_ExceptionKind exception_kind;
DEMON_Handle process;
DEMON_Handle thread;
DEMON_Handle module;
DMN_EventKind kind;
DMN_ErrorKind error_kind;
DMN_MemoryEventKind memory_kind;
DMN_ExceptionKind exception_kind;
DMN_Handle process;
DMN_Handle thread;
DMN_Handle module;
Architecture arch;
U64 address;
U64 size;
String8 string;
@@ -123,171 +82,161 @@ struct DEMON_Event
B32 exception_repeated;
};
typedef struct DEMON_EventNode DEMON_EventNode;
struct DEMON_EventNode
typedef struct DMN_EventNode DMN_EventNode;
struct DMN_EventNode
{
DEMON_EventNode *next;
DEMON_Event v;
DMN_EventNode *next;
DMN_Event v;
};
typedef struct DEMON_EventList DEMON_EventList;
struct DEMON_EventList
typedef struct DMN_EventList DMN_EventList;
struct DMN_EventList
{
DEMON_EventNode *first;
DEMON_EventNode *last;
DMN_EventNode *first;
DMN_EventNode *last;
U64 count;
};
////////////////////////////////
//~ allen: Demon Run Control Types
//~ rjf: Run Control Types
typedef struct DEMON_Trap DEMON_Trap;
struct DEMON_Trap
typedef struct DMN_Trap DMN_Trap;
struct DMN_Trap
{
DEMON_Handle process;
U64 address;
DMN_Handle process;
U64 vaddr;
U64 id;
};
typedef struct DEMON_TrapChunkNode DEMON_TrapChunkNode;
struct DEMON_TrapChunkNode
typedef struct DMN_TrapChunkNode DMN_TrapChunkNode;
struct DMN_TrapChunkNode
{
DEMON_TrapChunkNode *next;
DEMON_Trap *v;
DMN_TrapChunkNode *next;
DMN_Trap *v;
U64 cap;
U64 count;
};
typedef struct DEMON_TrapChunkList DEMON_TrapChunkList;
struct DEMON_TrapChunkList
typedef struct DMN_TrapChunkList DMN_TrapChunkList;
struct DMN_TrapChunkList
{
DEMON_TrapChunkNode *first;
DEMON_TrapChunkNode *last;
DMN_TrapChunkNode *first;
DMN_TrapChunkNode *last;
U64 node_count;
U64 trap_count;
};
typedef struct DEMON_RunCtrls DEMON_RunCtrls;
struct DEMON_RunCtrls
typedef struct DMN_RunCtrls DMN_RunCtrls;
struct DMN_RunCtrls
{
DEMON_Handle single_step_thread;
DMN_Handle single_step_thread;
B8 ignore_previous_exception;
B8 run_entities_are_unfrozen;
B8 run_entities_are_processes;
DEMON_Handle *run_entities;
DMN_Handle *run_entities;
U64 run_entity_count;
DEMON_TrapChunkList traps;
DMN_TrapChunkList traps;
};
////////////////////////////////
//~ allen: Demon Process Listing
//~ rjf: System Process Listing Types
typedef struct DEMON_ProcessIter DEMON_ProcessIter;
struct DEMON_ProcessIter
typedef struct DMN_ProcessIter DMN_ProcessIter;
struct DMN_ProcessIter
{
U64 v[2];
};
typedef struct DEMON_ProcessInfo DEMON_ProcessInfo;
struct DEMON_ProcessInfo
typedef struct DMN_ProcessInfo DMN_ProcessInfo;
struct DMN_ProcessInfo
{
String8 name;
U32 pid;
};
////////////////////////////////
//~ rjf: Main Layer Initialization
//~ rjf: Basic Type Functions (Helpers, Implemented Once)
internal void demon_init(void);
////////////////////////////////
//~ rjf: Basic Type Functions
//- rjf: stringizing
internal String8 demon_string_from_event_kind(DEMON_EventKind kind);
internal String8 demon_string_from_memory_event_kind(DEMON_MemoryEventKind kind);
internal String8 demon_string_from_exception_kind(DEMON_ExceptionKind kind);
internal void demon_string_list_from_event(Arena *arena, String8List *out, DEMON_Event *event);
//- rjf: handles
internal DMN_Handle dmn_handle_zero(void);
internal B32 dmn_handle_match(DMN_Handle a, DMN_Handle b);
//- rjf: trap chunk lists
internal void demon_trap_chunk_list_push(Arena *arena, DEMON_TrapChunkList *list, U64 cap, DEMON_Trap *trap);
internal void demon_trap_chunk_list_concat_in_place(DEMON_TrapChunkList *dst, DEMON_TrapChunkList *to_push);
internal void demon_trap_chunk_list_concat_shallow_copy(Arena *arena, DEMON_TrapChunkList *dst, DEMON_TrapChunkList *to_push);
internal void dmn_trap_chunk_list_push(Arena *arena, DMN_TrapChunkList *list, U64 cap, DMN_Trap *trap);
internal void dmn_trap_chunk_list_concat_in_place(DMN_TrapChunkList *dst, DMN_TrapChunkList *to_push);
internal void dmn_trap_chunk_list_concat_shallow_copy(Arena *arena, DMN_TrapChunkList *dst, DMN_TrapChunkList *to_push);
//- rjf: handle lists
internal void demon_handle_list_push(Arena *arena, DEMON_HandleList *list, DEMON_Handle handle);
internal DEMON_HandleArray demon_handle_array_from_list(Arena *arena, DEMON_HandleList *list);
internal DEMON_HandleArray demon_handle_array_copy(Arena *arena, DEMON_HandleArray *src);
internal void dmn_handle_list_push(Arena *arena, DMN_HandleList *list, DMN_Handle handle);
internal DMN_HandleArray dmn_handle_array_from_list(Arena *arena, DMN_HandleList *list);
internal DMN_HandleArray dmn_handle_array_copy(Arena *arena, DMN_HandleArray *src);
//- rjf: event list building
internal DMN_Event *dmn_event_list_push(Arena *arena, DMN_EventList *list);
////////////////////////////////
//~ rjf: Primary Thread & Exclusive Mode Controls
//~ rjf: Thread Reading Helper Functions (Helpers, Implemented Once)
internal void demon_primary_thread_begin(void);
internal void demon_exclusive_mode_begin(void);
internal void demon_exclusive_mode_end(void);
internal U64 dmn_rip_from_thread(DMN_Handle thread);
internal U64 dmn_rsp_from_thread(DMN_Handle thread);
////////////////////////////////
//~ rjf: Running/Halting
//~ rjf: @dmn_os_hooks Main Layer Initialization (Implemented Per-OS)
internal DEMON_EventList demon_run(Arena *arena, DEMON_RunCtrls *ctrls);
internal void demon_halt(U64 code, U64 user_data);
internal U64 demon_get_time_counter(void);
internal void dmn_init(void);
////////////////////////////////
//~ rjf: Target Process Launching/Attaching/Killing/Detaching/Halting
//~ rjf: @dmn_os_hooks Blocking Control Thread Operations (Implemented Per-OS)
internal U32 demon_launch_process(OS_LaunchOptions *options);
internal B32 demon_attach_process(U32 pid);
internal B32 demon_kill_process(DEMON_Handle process, U32 exit_code);
internal B32 demon_detach_process(DEMON_Handle process);
internal DMN_CtrlCtx *dmn_ctrl_begin(void);
internal void dmn_ctrl_exclusive_access_begin(void);
internal void dmn_ctrl_exclusive_access_end(void);
#define DMN_CtrlExclusiveAccessScope DeferLoop(dmn_ctrl_exclusive_access_begin(), dmn_ctrl_exclusive_access_end())
internal U32 dmn_ctrl_launch(DMN_CtrlCtx *ctx, OS_LaunchOptions *options);
internal B32 dmn_ctrl_attach(DMN_CtrlCtx *ctx, U32 pid);
internal B32 dmn_ctrl_kill(DMN_CtrlCtx *ctx, DMN_Handle process, U32 exit_code);
internal B32 dmn_ctrl_detach(DMN_CtrlCtx *ctx, DMN_Handle process);
internal DMN_EventList dmn_ctrl_run(Arena *arena, DMN_CtrlCtx *ctx, DMN_RunCtrls *ctrls);
////////////////////////////////
//~ rjf: Entity Functions
//~ rjf: @dmn_os_hooks Halting (Implemented Per-OS)
//- rjf: basics
internal B32 demon_object_exists(DEMON_Handle object);
//- rjf: introspection
internal Architecture demon_arch_from_object(DEMON_Handle object);
internal U64 demon_base_vaddr_from_module(DEMON_Handle module);
internal Rng1U64 demon_vaddr_range_from_module(DEMON_Handle module);
internal String8 demon_full_path_from_module(Arena *arena, DEMON_Handle module);
internal U64 demon_stack_base_vaddr_from_thread(DEMON_Handle thread);
internal U64 demon_tls_root_vaddr_from_thread(DEMON_Handle thread);
internal DEMON_HandleArray demon_all_processes(Arena *arena);
internal DEMON_HandleArray demon_threads_from_process(Arena *arena, DEMON_Handle process);
internal DEMON_HandleArray demon_modules_from_process(Arena *arena, DEMON_Handle process);
//- rjf: target process memory allocation/protection
internal U64 demon_reserve_memory(DEMON_Handle process, U64 size);
internal B32 demon_set_memory_protect_flags(DEMON_Handle process, U64 page_vaddr, U64 size, DEMON_MemoryProtectFlags flags);
internal B32 demon_release_memory(DEMON_Handle process, U64 vaddr, U64 size);
//- rjf: target process memory reading/writing
internal U64 demon_read_memory(DEMON_Handle process, void *dst, U64 src_address, U64 size);
internal B32 demon_write_memory(DEMON_Handle process, U64 dst_address, void *src, U64 size);
internal U64 demon_read_memory_amap_aligned(DEMON_Handle process, void *dst, U64 src_address, U64 size);
internal U64 demon_read_memory_amap(DEMON_Handle process, void *dst, U64 src_address, U64 size);
//- rjf: thread registers reading/writing
// IMPORTANT(allen): This API is _trusting_ you. You should never modify the data pointed
// at by that void pointer! It is pointing to the internal cache of the registers, so it
// will become invalid after a call to demon_write_regs, or demon_run. Use it to read
// what you need and be done ASAP and we can avoid an extra copy baked into the API.
internal void *demon_read_regs(DEMON_Handle thread);
internal B32 demon_write_regs(DEMON_Handle thread, void *data);
// TODO(allen): These might be a bad idea when we try to extend to ARM
// They make sense for x86/x64 abstraction, which often needs identical
// code paths except for these parts. Revisit this when ARM is integrated.
internal U64 demon_read_ip(DEMON_Handle thread);
internal U64 demon_read_sp(DEMON_Handle thread);
internal void demon_write_ip(DEMON_Handle thread, U64 ip);
internal void dmn_halt(U64 code, U64 user_data);
////////////////////////////////
//~ rjf: Process Listing
//~ rjf: @dmn_os_hooks Introspection Functions (Implemented Per-OS)
internal void demon_proc_iter_begin(DEMON_ProcessIter *iter);
internal B32 demon_proc_iter_next(Arena *arena, DEMON_ProcessIter *iter, DEMON_ProcessInfo *info_out);
internal void demon_proc_iter_end(DEMON_ProcessIter *iter);
//- rjf: run/memory/register counters
internal U64 dmn_run_gen(void);
internal U64 dmn_mem_gen(void);
internal U64 dmn_reg_gen(void);
#endif //DEMON_CORE_H
//- rjf: non-blocking-control-thread access barriers
internal B32 dmn_access_open(void);
internal void dmn_access_close(void);
#define DMN_AccessScope DeferLoopChecked(dmn_access_open(), dmn_access_close())
//- rjf: processes
internal U64 dmn_process_memory_reserve(DMN_Handle process, U64 vaddr, U64 size);
internal void dmn_process_memory_commit(DMN_Handle process, U64 vaddr, U64 size);
internal void dmn_process_memory_decommit(DMN_Handle process, U64 vaddr, U64 size);
internal void dmn_process_memory_release(DMN_Handle process, U64 vaddr, U64 size);
internal void dmn_process_memory_protect(DMN_Handle process, U64 vaddr, U64 size, OS_AccessFlags flags);
internal U64 dmn_process_read(DMN_Handle process, Rng1U64 range, void *dst);
internal B32 dmn_process_write(DMN_Handle process, Rng1U64 range, void *src);
#define dmn_process_read_struct(process, vaddr, ptr) dmn_process_read((process), r1u64((vaddr), (vaddr)+(sizeof(*ptr))), ptr)
#define dmn_process_write_struct(process, vaddr, ptr) dmn_process_write((process), r1u64((vaddr), (vaddr)+(sizeof(*ptr))), ptr)
//- rjf: threads
internal Architecture dmn_arch_from_thread(DMN_Handle handle);
internal U64 dmn_stack_base_vaddr_from_thread(DMN_Handle handle);
internal U64 dmn_tls_root_vaddr_from_thread(DMN_Handle handle);
internal B32 dmn_thread_read_reg_block(DMN_Handle handle, void *reg_block);
internal B32 dmn_thread_write_reg_block(DMN_Handle handle, void *reg_block);
//- rjf: system process listing
internal void dmn_process_iter_begin(DMN_ProcessIter *iter);
internal B32 dmn_process_iter_next(Arena *arena, DMN_ProcessIter *iter, DMN_ProcessInfo *info_out);
internal void dmn_process_iter_end(DMN_ProcessIter *iter);
#endif // DEMON_CORE_H
+90
View File
@@ -0,0 +1,90 @@
////////////////////////////////
//~ rjf: Event Kind Tables
@table(name)
DMN_EventKindTable:
{
{Null}
{Error}
{HandshakeComplete}
{CreateProcess}
{ExitProcess}
{CreateThread}
{ExitThread}
{LoadModule}
{UnloadModule}
{Breakpoint}
{Trap}
{SingleStep}
{Exception}
{Halt}
{Memory}
{DebugString}
{SetThreadName}
}
@table(name)
DMN_ErrorKindTable:
{
{Null}
{NotAttached}
{UnexpectedFailure}
{InvalidHandle}
}
@table(name)
DMN_MemoryEventKindTable:
{
{Null}
{Commit}
{Reserve}
{Decommit}
{Release}
}
@table(name)
DMN_ExceptionKindTable:
{
{Null}
{MemoryRead}
{MemoryWrite}
{MemoryExecute}
{CppThrow}
}
////////////////////////////////
//~ rjf: Generators
@enum DMN_EventKind:
{
@expand(DMN_EventKindTable a) `$(a.name)`,
COUNT
}
@data(String8) dmn_event_kind_string_table:
{
@expand(DMN_EventKindTable a) `str8_lit_comp("$(a.name)")`
}
@enum DMN_ErrorKind:
{
@expand(DMN_ErrorKindTable a) `$(a.name)`,
COUNT
}
@enum DMN_MemoryEventKind:
{
@expand(DMN_MemoryEventKindTable a) `$(a.name)`,
COUNT
}
@enum DMN_ExceptionKind:
{
@expand(DMN_ExceptionKindTable a) `$(a.name)`,
COUNT
}
@data(String8) dmn_exception_kind_string_table:
{
@expand(DMN_ExceptionKindTable a) `str8_lit_comp("$(a.name)")`
}
+2 -7
View File
@@ -2,14 +2,9 @@
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "demon_core.c"
#include "demon_common.c"
#include "demon_accel.c"
#include "demon_os.c"
#if OS_WINDOWS
# include "win32/demon_os_win32.c"
#elif OS_LINUX
# include "linux/demon_os_linux.c"
# include "win32/demon_core_win32.c"
#else
# error No Demon Implementation for This OS
# error Demon layer backend not defined for this operating system.
#endif
+3 -8
View File
@@ -5,16 +5,11 @@
#define DEMON_INC_H
#include "demon_core.h"
#include "demon_common.h"
#include "demon_accel.h"
#include "demon_os.h"
#if OS_WINDOWS
# include "win32/demon_os_win32.h"
#elif OS_LINUX
# include "linux/demon_os_linux.h"
# include "win32/demon_core_win32.h"
#else
# error No Demon Implementation for This OS
# error Demon layer backend not defined for this operating system.
#endif
#endif //DEMON_INC_H
#endif // DEMON_INC_H
-28
View File
@@ -1,28 +0,0 @@
////////////////////////////////
//~ rjf: Helpers
internal B32
demon_os_read_regs(DEMON_Entity *thread, void *dst)
{
B32 result = 0;
switch(thread->arch)
{
default:{}break;
case Architecture_x86:{result = demon_os_read_regs_x86(thread, (REGS_RegBlockX86 *)dst);}break;
case Architecture_x64:{result = demon_os_read_regs_x64(thread, (REGS_RegBlockX64 *)dst);}break;
}
return result;
}
internal B32
demon_os_write_regs(DEMON_Entity *thread, void *src)
{
B32 result = 0;
switch(thread->arch)
{
default:{}break;
case Architecture_x86:{result = demon_os_write_regs_x86(thread, (REGS_RegBlockX86 *)src);}break;
case Architecture_x64:{result = demon_os_write_regs_x64(thread, (REGS_RegBlockX64 *)src);}break;
}
return result;
}
-98
View File
@@ -1,98 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DEMON_OS_H
#define DEMON_OS_H
// NOTE(allen):
// These are the functions that the OS backends actually implement.
// Demon objects go through a handle validation layer but it is a lot more
// convenient in the OS backends to implement these versions which take the
// already validated DEMON_Entity*. These are also more convenient to call from
// the backend layer, which lets us avoid converting back and forth between
// handles and pointers a lot.
////////////////////////////////
//~ NOTE(allen): Demon OS Run Control Types
typedef struct DEMON_OS_Trap DEMON_OS_Trap;
struct DEMON_OS_Trap
{
DEMON_Entity *process;
U64 address;
};
typedef struct DEMON_OS_RunCtrls DEMON_OS_RunCtrls;
struct DEMON_OS_RunCtrls
{
DEMON_Entity *single_step_thread;
B8 ignore_previous_exception;
B8 run_entities_are_unfrozen;
B8 run_entities_are_processes;
DEMON_Entity **run_entities;
U64 run_entity_count;
DEMON_OS_Trap *traps;
U64 trap_count;
};
////////////////////////////////
//~ rjf: Helpers
internal B32 demon_os_read_regs(DEMON_Entity *thread, void *dst);
internal B32 demon_os_write_regs(DEMON_Entity *thread, void *src);
////////////////////////////////
//~ rjf: @demon_os_hooks Main Layer Initialization
internal void demon_os_init(void);
////////////////////////////////
//~ rjf: @demon_os_hooks Running/Halting
internal DEMON_EventList demon_os_run(Arena *arena, DEMON_OS_RunCtrls *controls);
internal void demon_os_halt(U64 code, U64 user_data);
////////////////////////////////
//~ rjf: @demon_os_hooks Target Process Launching/Attaching/Killing/Detaching/Halting
internal U32 demon_os_launch_process(OS_LaunchOptions *options);
internal B32 demon_os_attach_process(U32 pid);
internal B32 demon_os_kill_process(DEMON_Entity *process, U32 exit_code);
internal B32 demon_os_detach_process(DEMON_Entity *process);
////////////////////////////////
//~ rjf: @demon_os_hooks Entity Functions
//- rjf: cleanup
internal void demon_os_entity_cleanup(DEMON_Entity *entity);
//- rjf: introspection
internal String8 demon_os_full_path_from_module(Arena *arena, DEMON_Entity *module);
internal U64 demon_os_stack_base_vaddr_from_thread(DEMON_Entity *thread);
internal U64 demon_os_tls_root_vaddr_from_thread(DEMON_Entity *thread);
//- rjf: target process memory allocation/protection
internal U64 demon_os_reserve_memory(DEMON_Entity *process, U64 size);
internal void demon_os_set_memory_protect_flags(DEMON_Entity *process, U64 page_vaddr, U64 size, DEMON_MemoryProtectFlags flags);
internal void demon_os_release_memory(DEMON_Entity *process, U64 vaddr, U64 size);
//- rjf: target process memory reading/writing
internal U64 demon_os_read_memory(DEMON_Entity *process, void *dst, U64 src_address, U64 size);
internal B32 demon_os_write_memory(DEMON_Entity *process, U64 dst_address, void *src, U64 size);
#define demon_os_read_struct(p,dst,src) demon_os_read_memory((p), (dst), (src), sizeof(*(dst)))
#define demon_os_write_struct(p,dst,src) demon_os_write_memory((p), (dst), (src), sizeof(*(src)))
//- rjf: thread registers reading/writing
internal B32 demon_os_read_regs_x86(DEMON_Entity *thread, REGS_RegBlockX86 *dst);
internal B32 demon_os_write_regs_x86(DEMON_Entity *thread, REGS_RegBlockX86 *src);
internal B32 demon_os_read_regs_x64(DEMON_Entity *thread, REGS_RegBlockX64 *dst);
internal B32 demon_os_write_regs_x64(DEMON_Entity *thread, REGS_RegBlockX64 *src);
////////////////////////////////
//~ rjf: @demon_os_hooks Process Listing
internal void demon_os_proc_iter_begin(DEMON_ProcessIter *iter);
internal B32 demon_os_proc_iter_next(Arena *arena, DEMON_ProcessIter *iter, DEMON_ProcessInfo *info_out);
internal void demon_os_proc_iter_end(DEMON_ProcessIter *iter);
#endif //DEMON_OS_H
+38
View File
@@ -0,0 +1,38 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
C_LINKAGE_BEGIN
String8 dmn_event_kind_string_table[17] =
{
str8_lit_comp("Null"),
str8_lit_comp("Error"),
str8_lit_comp("HandshakeComplete"),
str8_lit_comp("CreateProcess"),
str8_lit_comp("ExitProcess"),
str8_lit_comp("CreateThread"),
str8_lit_comp("ExitThread"),
str8_lit_comp("LoadModule"),
str8_lit_comp("UnloadModule"),
str8_lit_comp("Breakpoint"),
str8_lit_comp("Trap"),
str8_lit_comp("SingleStep"),
str8_lit_comp("Exception"),
str8_lit_comp("Halt"),
str8_lit_comp("Memory"),
str8_lit_comp("DebugString"),
str8_lit_comp("SetThreadName"),
};
String8 dmn_exception_kind_string_table[5] =
{
str8_lit_comp("Null"),
str8_lit_comp("MemoryRead"),
str8_lit_comp("MemoryWrite"),
str8_lit_comp("MemoryExecute"),
str8_lit_comp("CppThrow"),
};
C_LINKAGE_END
+66
View File
@@ -0,0 +1,66 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
//- GENERATED CODE
#ifndef DEMON_META_H
#define DEMON_META_H
typedef enum DMN_EventKind
{
DMN_EventKind_Null,
DMN_EventKind_Error,
DMN_EventKind_HandshakeComplete,
DMN_EventKind_CreateProcess,
DMN_EventKind_ExitProcess,
DMN_EventKind_CreateThread,
DMN_EventKind_ExitThread,
DMN_EventKind_LoadModule,
DMN_EventKind_UnloadModule,
DMN_EventKind_Breakpoint,
DMN_EventKind_Trap,
DMN_EventKind_SingleStep,
DMN_EventKind_Exception,
DMN_EventKind_Halt,
DMN_EventKind_Memory,
DMN_EventKind_DebugString,
DMN_EventKind_SetThreadName,
DMN_EventKind_COUNT,
} DMN_EventKind;
typedef enum DMN_ErrorKind
{
DMN_ErrorKind_Null,
DMN_ErrorKind_NotAttached,
DMN_ErrorKind_UnexpectedFailure,
DMN_ErrorKind_InvalidHandle,
DMN_ErrorKind_COUNT,
} DMN_ErrorKind;
typedef enum DMN_MemoryEventKind
{
DMN_MemoryEventKind_Null,
DMN_MemoryEventKind_Commit,
DMN_MemoryEventKind_Reserve,
DMN_MemoryEventKind_Decommit,
DMN_MemoryEventKind_Release,
DMN_MemoryEventKind_COUNT,
} DMN_MemoryEventKind;
typedef enum DMN_ExceptionKind
{
DMN_ExceptionKind_Null,
DMN_ExceptionKind_MemoryRead,
DMN_ExceptionKind_MemoryWrite,
DMN_ExceptionKind_MemoryExecute,
DMN_ExceptionKind_CppThrow,
DMN_ExceptionKind_COUNT,
} DMN_ExceptionKind;
C_LINKAGE_BEGIN
extern String8 dmn_event_kind_string_table[17];
extern String8 dmn_exception_kind_string_table[5];
C_LINKAGE_END
#endif // DEMON_META_H
-65
View File
@@ -1,65 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
// exe //
#include "base/base_inc.h"
#include "os/os_inc.h"
#include "demon/demon_inc.h"
#include "syms_helpers/syms_internal_overrides.h"
#include "syms/syms_inc.h"
#include "syms_helpers/syms_helpers.h"
#include "base/base_inc.c"
#include "os/os_inc.c"
#include "demon/demon_inc.c"
#include "syms_helpers/syms_internal_overrides.c"
#include "syms/syms_inc.c"
#include "syms_helpers/syms_helpers.c"
int
main(int argument_count, char **arguments)
{
os_init(argument_count, arguments);
Arena *arena = arena_alloc();
demon_init();
//- rjf: find PID of mule_loop.exe
String8 attach_process_name = str8_lit("mule_loop.exe");
U32 pid = 0;
{
DEMON_ProcessIter it = {0};
demon_proc_iter_begin(&it);
for(DEMON_ProcessInfo info = {0}; demon_proc_iter_next(arena, &it, &info);)
{
if(str8_match(info.name, attach_process_name, 0))
{
pid = info.pid;
break;
}
}
demon_proc_iter_end(&it);
}
//- rjf: attach
B32 attach_good = demon_attach_process(pid);
//- rjf: get events
DEMON_RunCtrls ctrls = {0};
DEMON_EventList events = demon_run(arena, ctrls);
for(DEMON_Event *event = events.first; event != 0; event = event->next)
{
int x = 0;
}
#if 0
//- rjf: try to break in the loop
DEMON_RunCtrls ctrls = {0};
DEMON_Trap trap = {0};
{
U64 loop_bp = 0x0000000140001074;
ctrls.trap_count = 1;
ctrls.traps = &trap;
}
#endif
}
-166
View File
@@ -1,166 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "base/base_inc.h"
#include "os/os_inc.h"
#include "demon/demon_inc.h"
#include "syms_helpers/syms_internal_overrides.h"
#include "syms/syms_inc.h"
#include "syms_helpers/syms_helpers.h"
#include "base/base_inc.c"
#include "os/os_inc.c"
#include "demon/demon_inc.c"
#include "syms_helpers/syms_internal_overrides.c"
#include "syms/syms_inc.c"
#include "syms_helpers/syms_helpers.c"
internal SYMS_String8
file_load_func_for_syms(void *user, SYMS_Arena *arena, SYMS_String8 file_name){
String8 data = os_read_file(arena, str8_from_syms(file_name));
SYMS_String8 result = syms_from_str8(data);
return(result);
}
int
main(int argument_count, char **arguments)
{
os_init(argument_count, arguments);
Temp scratch = scratch_begin(0, 0);
// setup
demon_init();
// parse arguments
String8 executable_file_name = {0};
U64 bp_address = 0;
{
String8List command_line_arguments = os_get_command_line_arguments();
CmdLine cmd_line = cmd_line_from_string_list(scratch.arena, command_line_arguments);
if (cmd_line.inputs.first != 0){
executable_file_name = cmd_line.inputs.first->string;
}
String8 bp_string = cmd_line_string(cmd_line, str8_lit("bp"));
try_u64_from_str8_c_rules(bp_string, &bp_address);
}
// check parameters
if (bp_address == 0 || executable_file_name.size == 0){
printf("bad parameters\n");
exit(0);
}
// demon launch
OS_LaunchOptions launch_opts = {0};
str8_list_push(scratch.arena, &launch_opts.cmd_line, executable_file_name);
launch_opts.path = os_get_path(scratch.arena, OS_SystemPath_Current);
U32 process_id = demon_launch_process(&launch_opts);
if (process_id == 0){
printf("could not launch: '%.*s'\n", str8_varg(executable_file_name));
exit(0);
}
// demon loop
{
DEMON_Handle process = 0;
DEMON_Handle thread = 0;
B32 hit_bp = false;
U64 single_step_counter = 0;
U64 counter = 0;
for (;;){
Temp temp = temp_begin(scratch.arena);
DEMON_RunCtrls run_controls = {0};
DEMON_Trap traps[1];
if (!hit_bp){
if (process != 0){
run_controls.trap_count = 1;
run_controls.traps = traps;
run_controls.traps[0].process = process;
run_controls.traps[0].address = bp_address;
}
}
else{
run_controls.single_step_thread = thread;
}
DEMON_EventList events = demon_run(temp.arena, run_controls);
for (DEMON_Event *event = events.first;
event != 0;
event = event->next, counter += 1){
// update tracking state
switch (event->kind){
case DEMON_EventKind_CreateProcess:
{
process = event->process;
}break;
case DEMON_EventKind_ExitProcess:
{
if (event->process == process){
process = 0;
}
}break;
case DEMON_EventKind_CreateThread:
{
thread = event->thread;
}break;
case DEMON_EventKind_Breakpoint:
{
hit_bp = true;
}break;
case DEMON_EventKind_SingleStep:
{
single_step_counter += 1;
SYMS_RegX64 regs1 = {0};
demon_read_x64_regs(thread, &regs1);
demon_write_x64_regs(thread, &regs1);
SYMS_RegX64 regs2 = {0};
demon_read_x64_regs(thread, &regs2);
if (!MemoryMatchStruct(&regs1, &regs2)){
printf("mismatch at single_step_counter=%llu\n", single_step_counter);
}
if (single_step_counter == 1000){
goto end_loop;
}
}break;
case DEMON_EventKind_NotAttached:
{
fprintf(stderr, "not attached - exiting\n");
goto end_loop;
}break;
case DEMON_EventKind_NotInitialized:
case DEMON_EventKind_UnexpectedFailure:
{
fprintf(stderr, "unexpected error - exiting\n");
goto end_loop;
}break;
}
}
goto end_it;
end_loop:
temp_end(temp);
goto loop_exit;
end_it:;
}
loop_exit:;
}
printf("[done]\n");
scratch_end(scratch);
}
-250
View File
@@ -1,250 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include "base/base_inc.h"
#include "os/os_inc.h"
#include "demon/demon_inc.h"
#include "syms_helpers/syms_internal_overrides.h"
#include "syms/syms_inc.h"
#include "syms_helpers/syms_helpers.h"
#include "base/base_inc.c"
#include "os/os_inc.c"
#include "demon/demon_inc.c"
#include "syms_helpers/syms_internal_overrides.c"
#include "syms/syms_inc.c"
#include "syms_helpers/syms_helpers.c"
internal SYMS_String8
file_load_func_for_syms(void *user, SYMS_Arena *arena, SYMS_String8 file_name){
String8 data = os_read_file(arena, str8_from_syms(file_name));
SYMS_String8 result = syms_from_str8(data);
return(result);
}
int
main(int argument_count, char **arguments)
{
os_init(argument_count, arguments);
demon_init();
String8Node node[2];
#define TARGET_EXE "C:\\devel\\projects\\debugger\\build\\mule_unwind_20210511_clang11_lldlink.exe"
OS_LaunchOptions options = {0};
#if OS_WINDOWS
str8_list_push(&options.cmd_line, &node[0], str8_lit(TARGET_EXE));
options.path = str8_lit("C:\\devel\\projects\\debugger\\build\\");
#else
str8_list_push(&options.cmd_line, &node[0], str8_lit("/home/allenw/projects_copy/debugger/build/mule_main"));
options.path = str8_lit("/home/allenw/projects_copy/debugger/build/");
#endif
U32 process_id = demon_launch_process(&options);
if (process_id == 0){
printf("Could not launch process\n");
exit(1);
}
#if OS_WINDOWS
U64 bp_addr = 0x140001134;
#else
U64 bp_addr = 0x400918;
#endif
DEMON_Handle process = 0;
DEMON_Handle thread = 0;
DEMON_Handle module = 0;
U64 module_base = 0;
SYMS_Group *group = 0;
B32 hit_bp = false;
U64 counter = 0;
for (;;){
DEMON_RunCtrls run_controls = {0};
DEMON_Trap trap_memory[2];
DEMON_Trap *trap_ptr = trap_memory;
if (process != 0 && !hit_bp){
trap_ptr->process = process;
trap_ptr->address = bp_addr;
trap_ptr += 1;
}
run_controls.traps = trap_memory;
run_controls.trap_count = (U64)(trap_ptr - trap_memory);
Temp scratch = scratch_begin(0, 0);
DEMON_EventList events = demon_run(scratch.arena, run_controls);
for (DEMON_Event *event = events.first;
event != 0;
event = event->next){
printf("STEP[%05llx] -- ", counter);
counter += 1;
switch (event->kind){
case DEMON_EventKind_NotInitialized:
{
printf("Not Initialized\n");
exit(1);
}break;
case DEMON_EventKind_NotAttached:
{
printf("Not Attached\n");
exit(1);
}break;
case DEMON_EventKind_UnexpectedFailure:
{
printf("Unexpected Failure\n");
exit(1);
}break;
case DEMON_EventKind_CreateProcess:
{
printf("Create Process\n");
if (process == 0){
process = event->process;
}
}break;
case DEMON_EventKind_CreateThread:
{
printf("Create Thread\n");
if (thread == 0){
thread = event->thread;
}
}break;
case DEMON_EventKind_LoadModule:
{
Temp temp = temp_begin(scratch.arena);
String8 file_name = demon_full_path_from_module(scratch.arena, event->module);
printf("Load Module: %.*s\n", str8_varg(file_name));
if (module == 0 && str8_match(file_name, str8_lit(TARGET_EXE), 0)){
module = event->module;
module_base = event->address;
// setup syms group
group = syms_group_alloc();
SYMS_FileLoadCtx ctx = {0};
ctx.file_load_func = file_load_func_for_syms;
SYMS_String8List file_names = {0};
syms_string_list_push(group->arena, &file_names, syms_from_str8(file_name));
SYMS_FileInfOptions opts = {0};
SYMS_FileInfResult inf_result = syms_file_inf_infer_from_file_list(group->arena, ctx, file_names, &opts);
syms_group_init(group, &inf_result.data_parsed);
}
temp_end(temp);
}break;
case DEMON_EventKind_ExitProcess:
{
printf("Exit Process\n");
exit(0);
}break;
case DEMON_EventKind_ExitThread:
{
printf("Exit Thread\n");
}break;
case DEMON_EventKind_UnloadModule:
{
printf("Unload Module\n");
}break;
case DEMON_EventKind_Breakpoint:
{
Architecture arch = demon_arch_from_object(event->process);
U64 ip = event->instruction_pointer;
printf("Breakpoint: %llx\n", ip);
hit_bp = true;
//- unwind
// setup bin
SYMS_String8 bin_data = group->bin_data;
SYMS_BinAccel *generic_bin = group->bin;
SYMS_PeBinAccel *pe_bin = 0;
if (generic_bin->format == SYMS_FileFormat_PE){
pe_bin = (SYMS_PeBinAccel*)generic_bin;
}
if (pe_bin != 0){
// read regs
SYMS_RegX64 regs = {0};
demon_read_x64_regs(event->thread, &regs);
// read stack
SYMS_U64 sp = regs.rsp.u64;
SYMS_U64 sp_rounded_down = sp&~(KB(4) - 1);
SYMS_String8 stack_memory = {0};
stack_memory.size = KB(8);
stack_memory.str = push_array_no_zero(scratch.arena, U8, stack_memory.size);
SYMS_U64 stack_memory_addr = sp_rounded_down;
stack_memory.size = demon_read_memory_amap(event->process, stack_memory.str,
stack_memory_addr, stack_memory.size);
// unwind loop
U64 counter = 1;
for (;; counter += 1){
printf("%02llu: ip=%llx; sp=%llx\n", counter, regs.rip.u64, regs.rsp.u64);
SYMS_MemoryView memview = syms_memory_view_make(stack_memory, stack_memory_addr);
SYMS_UnwindResult unwind_result = syms_unwind_pe_x64(bin_data, pe_bin, module_base, &memview, &regs);
if (unwind_result.dead){
break;
}
}
}
}break;
case DEMON_EventKind_Trap:
{
Architecture arch = demon_arch_from_object(event->process);
U64 ip = event->instruction_pointer;
printf("Trap: %llx\n", ip);
}break;
case DEMON_EventKind_SingleStep:
{
printf("Single Step: %llx\n", event->instruction_pointer);
}break;
case DEMON_EventKind_Exception:
{
printf("Exception: %llx\n", event->instruction_pointer);
}break;
case DEMON_EventKind_Halt:
{
printf("Halt\n");
}break;
case DEMON_EventKind_Memory:
{
printf("Memory\n");
}break;
default:
{
printf("Unhandled Event\n");
exit(1);
}break;
}
}
scratch_end(scratch);
}
printf("Done\n");
}
-935
View File
@@ -1,935 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
// NOTE(rjf): (18 October 2021) Notes on Win32 process halting via
// DebugBreakProcess:
//
// Calling DebugBreakProcess seems to cause a few events to come back:
// 1. Thread Creation Event
// 2. Breakpoint Event (with the thread matching that of #1)
// 3. Thread Exiting Event (matching #1)
//
// Having done this experiment on a single-threaded program (mule_loop.exe),
// I can only infer that what is happening here is that when DebugBreakProcess
// is called, it first injects a thread into the target process that runs
// code with an int3. This is very similar to the old approach that Demon
// took.
//
// It's going to be difficult to distinguish between these CreateThreads and
// ExitThreads from others (not caused by halting), even though we can match
// the hit breakpoint to the associated thread.
//
// What could be possible (in order to distinguish the hit breakpoint as a
// halt event, instead of an arbitrary breakpoint) is looking at the breakpoint
// address. This injected thread has a breakpoint that's different from the
// initial breakpoint that the kernel automatically hits when a process is
// first being debugged.
//
// With DebugBreakProcess:
// - first breakpoint that is hit: 0x7ff8ad9806b0 in kernel code
// - last breakpoint that is hit: 0x7ff8ad950860 in kernel code (halt)
//
// Without DebugBreakProcess:
// - first breakpoint that is hit: 0x7ff8ad9806b0
//
// NOTE(rjf): (18 October 2021) Notes on suspending processes via
// NtSuspendProcess:
//
// NtSuspendProcess is an undocumented API that is exported by ntdll. It is
// fairly simple but could be unstable. To call it, the main trick is that
// you need a handle with certain privileges (PROCESS_SUSPEND_RESUME), so
// you can't just take any handle and use it.
//
// To use it, we can manually load it from ntdll, grab an elevated handle
// for a given process HANDLE, and then call it. We can resume, then, with
// NtResumeProcess.
//
// Other than this, our options seem to more-or-less lie in individually
// suspending all of the threads in the process-to-be-halted.
#include <windows.h>
#include "base/base_inc.h"
#include "os/os_inc.h"
#include "syms_helpers/syms_internal_overrides.h"
#include "syms/syms_inc.h"
#include "syms_helpers/syms_helpers.h"
#include "base/base_inc.c"
#include "os/os_inc.c"
#include "syms_helpers/syms_internal_overrides.c"
#include "syms/syms_inc.c"
#include "syms_helpers/syms_helpers.c"
typedef LONG NtSuspendProcessFunction(HANDLE ProcessHandle);
global NtSuspendProcessFunction *NtSuspendProcess = 0;
////////////////////////////////
// NOTE(allen): Win32 Demon Exceptions
#define DEMON_W32_EXCEPTION_BREAKPOINT 0x80000003u
#define DEMON_W32_EXCEPTION_SINGLE_STEP 0x80000004u
#define DEMON_W32_EXCEPTION_LONG_JUMP 0x80000026u
#define DEMON_W32_EXCEPTION_ACCESS_VIOLATION 0xC0000005u
#define DEMON_W32_EXCEPTION_ARRAY_BOUNDS_EXCEEDED 0xC000008Cu
#define DEMON_W32_EXCEPTION_DATA_TYPE_MISALIGNMENT 0x80000002u
#define DEMON_W32_EXCEPTION_GUARD_PAGE_VIOLATION 0x80000001u
#define DEMON_W32_EXCEPTION_FLT_DENORMAL_OPERAND 0xC000008Du
#define DEMON_W32_EXCEPTION_FLT_DEVIDE_BY_ZERO 0xC000008Eu
#define DEMON_W32_EXCEPTION_FLT_INEXACT_RESULT 0xC000008Fu
#define DEMON_W32_EXCEPTION_FLT_INVALID_OPERATION 0xC0000090u
#define DEMON_W32_EXCEPTION_FLT_OVERFLOW 0xC0000091u
#define DEMON_W32_EXCEPTION_FLT_STACK_CHECK 0xC0000092u
#define DEMON_W32_EXCEPTION_FLT_UNDERFLOW 0xC0000093u
#define DEMON_W32_EXCEPTION_INT_DIVIDE_BY_ZERO 0xC0000094u
#define DEMON_W32_EXCEPTION_INT_OVERFLOW 0xC0000095u
#define DEMON_W32_EXCEPTION_PRIVILEGED_INSTRUCTION 0xC0000096u
#define DEMON_W32_EXCEPTION_ILLEGAL_INSTRUCTION 0xC000001Du
#define DEMON_W32_EXCEPTION_IN_PAGE_ERROR 0xC0000006u
#define DEMON_W32_EXCEPTION_INVALID_DISPOSITION 0xC0000026u
#define DEMON_W32_EXCEPTION_NONCONTINUABLE 0xC0000025u
#define DEMON_W32_EXCEPTION_STACK_OVERFLOW 0xC00000FDu
#define DEMON_W32_EXCEPTION_INVALID_HANDLE 0xC0000008u
#define DEMON_W32_EXCEPTION_UNWIND_CONSOLIDATE 0x80000029u
#define DEMON_W32_EXCEPTION_DLL_NOT_FOUND 0xC0000135u
#define DEMON_W32_EXCEPTION_ORDINAL_NOT_FOUND 0xC0000138u
#define DEMON_W32_EXCEPTION_ENTRY_POINT_NOT_FOUND 0xC0000139u
#define DEMON_W32_EXCEPTION_DLL_INIT_FAILED 0xC0000142u
#define DEMON_W32_EXCEPTION_CONTROL_C_EXIT 0xC000013Au
#define DEMON_W32_EXCEPTION_FLT_MULTIPLE_FAULTS 0xC00002B4u
#define DEMON_W32_EXCEPTION_FLT_MULTIPLE_TRAPS 0xC00002B5u
#define DEMON_W32_EXCEPTION_NAT_CONSUMPTION 0xC00002C9u
#define DEMON_W32_EXCEPTION_HEAP_CORRUPTION 0xC0000374u
#define DEMON_W32_EXCEPTION_STACK_BUFFER_OVERRUN 0xC0000409u
#define DEMON_W32_EXCEPTION_INVALID_CRUNTIME_PARAM 0xC0000417u
#define DEMON_W32_EXCEPTION_ASSERT_FAILURE 0xC0000420u
#define DEMON_W32_EXCEPTION_NO_MEMORY 0xC0000017u
#define DEMON_W32_EXCEPTION_THROW 0xE06D7363u
////////////////////////////////
// NOTE(allen): Win32 Demon Register API Codes
#define DEMON_W32_CTX_X86 0x00010000
#define DEMON_W32_CTX_X64 0x00100000
#define DEMON_W32_CTX_INTEL_CONTROL 0x0001
#define DEMON_W32_CTX_INTEL_INTEGER 0x0002
#define DEMON_W32_CTX_INTEL_SEGMENTS 0x0004
#define DEMON_W32_CTX_INTEL_FLOATS 0x0008
#define DEMON_W32_CTX_INTEL_DEBUG 0x0010
#define DEMON_W32_CTX_INTEL_EXTENDED 0x0020
#define DEMON_W32_CTX_INTEL_XSTATE 0x0040
#define DEMON_W32_CTX_X86_ALL (DEMON_W32_CTX_X86 | \
DEMON_W32_CTX_INTEL_CONTROL | DEMON_W32_CTX_INTEL_INTEGER | \
DEMON_W32_CTX_INTEL_SEGMENTS | DEMON_W32_CTX_INTEL_DEBUG | \
DEMON_W32_CTX_INTEL_EXTENDED)
#define DEMON_W32_CTX_X64_ALL (DEMON_W32_CTX_X64 | \
DEMON_W32_CTX_INTEL_CONTROL | DEMON_W32_CTX_INTEL_INTEGER | \
DEMON_W32_CTX_INTEL_SEGMENTS | DEMON_W32_CTX_INTEL_FLOATS | \
DEMON_W32_CTX_INTEL_DEBUG)
struct TEST_DebugEvent
{
String8 name;
U64 process_id;
U64 thread_id;
HANDLE process;
HANDLE thread;
U64 addr;
DEBUG_EVENT evt;
};
struct TEST_Trap
{
HANDLE process;
U64 address;
};
internal U16
test_w32_real_tag_word_from_xsave(XSAVE_FORMAT *fxsave)
{
U16 result = 0;
U32 top = (fxsave->StatusWord >> 11) & 7;
for (U32 fpr = 0; fpr < 8; fpr += 1){
U32 tag = 3;
if (fxsave->TagWord & (1 << fpr)){
U32 st = (fpr - top)&7;
SYMS_Reg80 *fp = (SYMS_Reg80*)&fxsave->FloatRegisters[st*16];
U16 exponent = fp->sign1_exp15 & bitmask15;
U64 integer_part = fp->int1_frac63 >> 63;
U64 fraction_part = fp->int1_frac63 & bitmask63;
// tag: 0 - normal; 1 - zero; 2 - special
tag = 2;
if (exponent == 0){
if (integer_part == 0 && fraction_part == 0){
tag = 1;
}
}
else if (exponent != bitmask15 && integer_part != 0){
tag = 0;
}
}
result |= tag << (2 * fpr);
}
return(result);
}
internal U16
test_w32_xsave_tag_word_from_real_tag_word(U16 ftw)
{
U16 compact = 0;
for (U32 fpr = 0; fpr < 8; fpr++){
U32 tag = (ftw >> (fpr * 2)) & 3;
if (tag != 3){
compact |= (1 << fpr);
}
}
return(compact);
}
internal B32
test_w32_read_x64_regs(HANDLE thread, SYMS_RegX64 *dst)
{
Temp scratch = scratch_begin(0, 0);
// NOTE(allen): Check available features
U32 feature_mask = GetEnabledXStateFeatures();
B32 avx_enabled = !!(feature_mask & XSTATE_MASK_AVX);
// NOTE(allen): Setup the context
CONTEXT *ctx = 0;
U32 ctx_flags = DEMON_W32_CTX_X64_ALL;
if (avx_enabled){
ctx_flags |= DEMON_W32_CTX_INTEL_XSTATE;
}
DWORD size = 0;
InitializeContext(0, ctx_flags, 0, &size);
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER){
void *ctx_memory = push_array(scratch.arena, U8, size);
if (!InitializeContext(ctx_memory, ctx_flags, &ctx, &size)){
ctx = 0;
}
}
B32 avx_available = false;
if (ctx != 0){
// NOTE(allen): Finish Context Setup
if (avx_enabled){
SetXStateFeaturesMask(ctx, XSTATE_MASK_AVX);
}
// NOTE(allen): Determine what features are available on this particular ctx
// TODO(allen): Experiment carefully with this nonsense.
// Does avx_enabled = avx_available in all circumstances or not?
DWORD64 xstate_flags = 0;
if (GetXStateFeaturesMask(ctx, &xstate_flags)){
if (xstate_flags & XSTATE_MASK_AVX){
avx_available = true;
}
}
}
// get thread context
HANDLE thread_handle = thread;
if (!GetThreadContext(thread_handle, ctx)){
ctx = 0;
}
B32 result = false;
if (ctx != 0){
result = true;
// NOTE(allen): Convert CONTEXT -> SYMS_RegX64
dst->rax.u64 = ctx->Rax;
dst->rcx.u64 = ctx->Rcx;
dst->rdx.u64 = ctx->Rdx;
dst->rbx.u64 = ctx->Rbx;
dst->rsp.u64 = ctx->Rsp;
dst->rbp.u64 = ctx->Rbp;
dst->rsi.u64 = ctx->Rsi;
dst->rdi.u64 = ctx->Rdi;
dst->r8.u64 = ctx->R8;
dst->r9.u64 = ctx->R9;
dst->r10.u64 = ctx->R10;
dst->r11.u64 = ctx->R11;
dst->r12.u64 = ctx->R12;
dst->r13.u64 = ctx->R13;
dst->r14.u64 = ctx->R14;
dst->r15.u64 = ctx->R15;
dst->rip.u64 = ctx->Rip;
dst->cs.u16 = ctx->SegCs;
dst->ds.u16 = ctx->SegDs;
dst->es.u16 = ctx->SegEs;
dst->fs.u16 = ctx->SegFs;
dst->gs.u16 = ctx->SegGs;
dst->ss.u16 = ctx->SegSs;
dst->dr0.u32 = ctx->Dr0;
dst->dr1.u32 = ctx->Dr1;
dst->dr2.u32 = ctx->Dr2;
dst->dr3.u32 = ctx->Dr3;
dst->dr6.u32 = ctx->Dr6;
dst->dr7.u32 = ctx->Dr7;
// NOTE(allen): This bit is "supposed to always be 1" I guess.
// TODO(allen): Not sure what this is all about but I haven't investigated it yet.
// This might be totally not necessary or something.
dst->rflags.u64 = ctx->EFlags | 0x2;
XSAVE_FORMAT *xsave = &ctx->FltSave;
dst->fcw.u16 = xsave->ControlWord;
dst->fsw.u16 = xsave->StatusWord;
dst->ftw.u16 = test_w32_real_tag_word_from_xsave(xsave);
dst->fop.u16 = xsave->ErrorOpcode;
dst->fcs.u16 = xsave->ErrorSelector;
dst->fds.u16 = xsave->DataSelector;
dst->fip.u32 = xsave->ErrorOffset;
dst->fdp.u32 = xsave->DataOffset;
dst->mxcsr.u32 = xsave->MxCsr;
dst->mxcsr_mask.u32 = xsave->MxCsr_Mask;
M128A *float_s = xsave->FloatRegisters;
SYMS_Reg80 *float_d = &dst->fpr0;
for (U32 n = 0; n < 8; n += 1, float_s += 1, float_d += 1){
MemoryCopy(float_d, float_s, sizeof(*float_d));
}
if (!avx_available){
M128A *xmm_s = xsave->XmmRegisters;
SYMS_Reg256 *xmm_d = &dst->ymm0;
for (U32 n = 0; n < 16; n += 1, xmm_s += 1, xmm_d += 1){
MemoryCopy(xmm_d, xmm_s, sizeof(*xmm_s));
}
}
if (avx_available){
DWORD part0_length = 0;
M128A *part0 = (M128A*)LocateXStateFeature(ctx, XSTATE_LEGACY_SSE, &part0_length);
DWORD part1_length = 0;
M128A *part1 = (M128A*)LocateXStateFeature(ctx, XSTATE_AVX, &part1_length);
Assert(part0_length == part1_length);
DWORD count = part0_length/sizeof(part0[0]);
count = ClampTop(count, 16);
SYMS_Reg256 *ymm_d = &dst->ymm0;
for (DWORD i = 0;
i < count;
i += 1, part0 += 1, part1 += 1, ymm_d += 1){
// TODO(allen): Are we writing these out in the right order? Seems weird right?
ymm_d->u64[3] = part0->Low;
ymm_d->u64[2] = part0->High;
ymm_d->u64[1] = part1->Low;
ymm_d->u64[0] = part1->High;
}
}
}
scratch_end(scratch);
return(result);
}
internal B32
test_w32_write_x64_regs(HANDLE thread, SYMS_RegX64 *src)
{
Temp scratch = scratch_begin(0, 0);
// NOTE(allen): Check available features
U32 feature_mask = GetEnabledXStateFeatures();
B32 avx_enabled = !!(feature_mask & XSTATE_MASK_AVX);
// NOTE(allen): Setup the context
CONTEXT *ctx = 0;
U32 ctx_flags = DEMON_W32_CTX_X64_ALL;
if (avx_enabled){
ctx_flags |= DEMON_W32_CTX_INTEL_XSTATE;
}
DWORD size = 0;
InitializeContext(0, ctx_flags, 0, &size);
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER){
void *ctx_memory = push_array(scratch.arena, U8, size);
if (!InitializeContext(ctx_memory, ctx_flags, &ctx, &size)){
ctx = 0;
}
}
B32 avx_available = false;
if (ctx != 0){
// NOTE(allen): Finish Context Setup
if (avx_enabled){
SetXStateFeaturesMask(ctx, XSTATE_MASK_AVX);
}
// NOTE(allen): Determine what features are available on this particular ctx
// TODO(allen): Experiment carefully with this nonsense.
// Does avx_enabled = avx_available in all circumstances or not?
DWORD64 xstate_flags = 0;
if (GetXStateFeaturesMask(ctx, &xstate_flags)){
if (xstate_flags & XSTATE_MASK_AVX){
avx_available = true;
}
}
}
B32 result = false;
if (ctx != 0){
// NOTE(allen): Convert SYMS_RegX64 -> CONTEXT
ctx->ContextFlags = ctx_flags;
ctx->MxCsr = src->mxcsr.u32 & src->mxcsr_mask.u32;
ctx->Rax = src->rax.u64;
ctx->Rcx = src->rcx.u64;
ctx->Rdx = src->rdx.u64;
ctx->Rbx = src->rbx.u64;
ctx->Rsp = src->rsp.u64;
ctx->Rbp = src->rbp.u64;
ctx->Rsi = src->rsi.u64;
ctx->Rdi = src->rdi.u64;
ctx->R8 = src->r8.u64;
ctx->R9 = src->r9.u64;
ctx->R10 = src->r10.u64;
ctx->R11 = src->r11.u64;
ctx->R12 = src->r12.u64;
ctx->R13 = src->r13.u64;
ctx->R14 = src->r14.u64;
ctx->R15 = src->r15.u64;
ctx->Rip = src->rip.u64;
ctx->SegCs = src->cs.u16;
ctx->SegDs = src->ds.u16;
ctx->SegEs = src->es.u16;
ctx->SegFs = src->fs.u16;
ctx->SegGs = src->gs.u16;
ctx->SegSs = src->ss.u16;
ctx->Dr0 = src->dr0.u32;
ctx->Dr1 = src->dr1.u32;
ctx->Dr2 = src->dr2.u32;
ctx->Dr3 = src->dr3.u32;
ctx->Dr6 = src->dr6.u32;
ctx->Dr7 = src->dr7.u32;
ctx->EFlags = src->rflags.u64;
XSAVE_FORMAT *fxsave = &ctx->FltSave;
fxsave->ControlWord = src->fcw.u16;
fxsave->StatusWord = src->fsw.u16;
fxsave->TagWord = test_w32_xsave_tag_word_from_real_tag_word(src->ftw.u16);
fxsave->ErrorOpcode = src->fop.u16;
fxsave->ErrorSelector = src->fcs.u16;
fxsave->DataSelector = src->fds.u16;
fxsave->ErrorOffset = src->fip.u32;
fxsave->DataOffset = src->fdp.u32;
M128A *float_d = fxsave->FloatRegisters;
SYMS_Reg80 *float_s = &src->fpr0;
for (U32 n = 0;
n < 8;
n += 1, float_s += 1, float_d += 1){
MemoryCopy(float_d, float_s, 10);
}
if (!avx_available){
M128A *xmm_d = fxsave->XmmRegisters;
SYMS_Reg256 *xmm_s = &src->ymm0;
for (U32 n = 0;
n < 8;
n += 1, xmm_d += 1, xmm_s += 1){
MemoryCopy(xmm_d, xmm_s, sizeof(*xmm_d));
}
}
if (avx_available){
DWORD part0_length = 0;
M128A *part0 = (M128A*)LocateXStateFeature(ctx, XSTATE_LEGACY_SSE, &part0_length);
DWORD part1_length = 0;
M128A *part1 = (M128A*)LocateXStateFeature(ctx, XSTATE_AVX, &part1_length);
Assert(part0_length == part1_length);
DWORD count = part0_length/sizeof(part0[0]);
count = ClampTop(count, 16);
SYMS_Reg256 *ymm_d = &src->ymm0;
for (DWORD i = 0;
i < count;
i += 1, part0 += 1, part1 += 1, ymm_d += 1){
// TODO(allen): Are we writing these out in the right order? Seems weird right?
part0->Low = ymm_d->u64[3];
part0->High = ymm_d->u64[2];
part1->Low = ymm_d->u64[1];
part1->High = ymm_d->u64[0];
}
}
//- set thread context
HANDLE thread_handle = thread;
if (SetThreadContext(thread_handle, ctx)){
result = true;
}
}
scratch_end(scratch);
return(result);
}
internal B32
test_w32_read_memory(HANDLE process_handle, void *dst, U64 src_address, U64 size)
{
B32 result = true;
U8 *ptr = (U8*)dst;
U8 *opl = ptr + size;
U64 cursor = src_address;
for (;ptr < opl;){
SIZE_T to_read = (SIZE_T)(opl - ptr);
SIZE_T actual_read = 0;
if (!ReadProcessMemory(process_handle, (LPCVOID)cursor, ptr, to_read, &actual_read)){
result = false;
break;
}
ptr += actual_read;
cursor += actual_read;
}
return(result);
}
internal B32
test_w32_write_memory(HANDLE process_handle, U64 dst_address, void *src, U64 size)
{
B32 result = true;
U8 *ptr = (U8*)src;
U8 *opl = ptr + size;
U64 cursor = dst_address;
for (;ptr < opl;){
SIZE_T to_write = (SIZE_T)(opl - ptr);
SIZE_T actual_write = 0;
if (!WriteProcessMemory(process_handle, (LPVOID)cursor, ptr, to_write, &actual_write)){
result = false;
break;
}
ptr += actual_write;
cursor += actual_write;
}
return(result);
}
internal B32
test_launch_process(OS_LaunchOptions *options)
{
B32 result = false;
Temp scratch = scratch_begin(0, 0);
StringJoin join_params = {0};
join_params.pre = str8_lit("\"");
join_params.sep = str8_lit("\" \"");
join_params.post = str8_lit("\"");
String8 cmd = str8_list_join(scratch.arena, &options->cmd_line, &join_params);
StringJoin join_params2 = {0};
join_params2.sep = str8_lit("\0");
join_params2.post = str8_lit("\0");
String8 env = str8_list_join(scratch.arena, &options->env, &join_params2);
String16 cmd16 = str16_from_8(scratch.arena, cmd);
String16 dir16 = str16_from_8(scratch.arena, options->path);
String16 env16 = str16_from_8(scratch.arena, env);
DWORD access_flags = PROCESS_QUERY_INFORMATION | DEBUG_PROCESS | PROCESS_VM_READ | PROCESS_VM_WRITE;
STARTUPINFOW startup_info = {sizeof(startup_info)};
PROCESS_INFORMATION process_info = {0};
if (CreateProcessW(0, (WCHAR*)cmd16.str, 0, 0, 0, access_flags, (WCHAR*)env16.str, (WCHAR*)dir16.str,
&startup_info, &process_info))
{
CloseHandle(process_info.hProcess);
CloseHandle(process_info.hThread);
result = true;
}
scratch_end(scratch);
return(result);
}
global HANDLE g_process_1 = 0;
global DWORD g_process_id_1 = 0;
global U64 g_process_injection_addr_1 = 0;
global HANDLE g_process_2 = 0;
global DWORD g_process_id_2 = 0;
internal B32
test_w32_inject_thread(HANDLE process, U64 start_address)
{
B32 result = false;
LPTHREAD_START_ROUTINE start = (LPTHREAD_START_ROUTINE)start_address;
HANDLE thread = CreateRemoteThread(process, 0, 0, start, 0, 0, 0);
if(thread != 0)
{
CloseHandle(thread);
result = true;
}
return result;
}
internal void
test_halt(void)
{
test_w32_inject_thread(g_process_1, g_process_injection_addr_1);
}
internal TEST_DebugEvent
test_run_process(HANDLE step_thread, HANDLE suspend_thread, U64 traps_count, TEST_Trap *traps)
{
Temp scratch = scratch_begin(0, 0);
TEST_DebugEvent result = {0};
//- rjf: freeze thread
if(suspend_thread)
{
DWORD result = SuspendThread(suspend_thread);
DWORD error = GetLastError();
int x = 0;
}
//- rjf: write traps
U8 *trap_swap_bytes = push_array_no_zero(scratch.arena, U8, traps_count);
{
TEST_Trap *trap = traps;
for(U64 i = 0; i < traps_count; i += 1, trap += 1)
{
if(test_w32_read_memory(trap->process, trap_swap_bytes + i, trap->address, 1))
{
U8 int3 = 0xCC;
test_w32_write_memory(trap->process, trap->address, &int3, 1);
}
else
{
trap_swap_bytes[i] = 0xCC;
}
}
}
//- rjf: set single step bit
if(step_thread != 0)
{
SYMS_RegX64 regs = {0};
test_w32_read_x64_regs(step_thread, &regs);
regs.rflags.u64 |= 0x100;
test_w32_write_x64_regs(step_thread, &regs);
}
//- rjf: continue
local_persist B32 need_resume = 0;
local_persist DWORD resume_pid = 0;
local_persist DWORD resume_tid = 0;
if(need_resume)
{
need_resume = 0;
ContinueDebugEvent(resume_pid, resume_tid, DBG_CONTINUE);
}
//- rjf: get event
DEBUG_EVENT evt = {0};
if(WaitForDebugEvent(&evt, INFINITE))
{
need_resume = 1;
resume_pid = evt.dwProcessId;
resume_tid = evt.dwThreadId;
result.evt = evt;
switch(evt.dwDebugEventCode)
{
default:break;
case CREATE_PROCESS_DEBUG_EVENT:
{
result.name = str8_lit("create process");
result.process_id = evt.dwProcessId;
result.process = evt.u.CreateProcessInfo.hProcess;
result.thread_id = evt.dwThreadId;
result.thread = evt.u.CreateProcessInfo.hThread;
if(g_process_1 == 0)
{
g_process_1 = result.process;
g_process_id_1 = result.process_id;
// injection memory
{
U8 injection_code[64];
injection_code[0] = 0xCC;
injection_code[1] = 0xC3;
for (U64 i = 2; i < 64; i += 1){
injection_code[i] = 0xCC;
}
U64 injection_size = 64;
U64 injection_address = (U64)VirtualAllocEx(g_process_1, 0, injection_size, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE);
test_w32_write_memory(g_process_1, injection_address, injection_code, sizeof(injection_code));
g_process_injection_addr_1 = injection_address;
}
}
else
{
g_process_2 = result.process;
g_process_id_2 = result.process_id;
}
}break;
case EXIT_PROCESS_DEBUG_EVENT:
{
result.name = str8_lit("exit process");
result.process_id = evt.dwProcessId;
}break;
case CREATE_THREAD_DEBUG_EVENT:
{
result.name = str8_lit("create thread");
result.thread_id = evt.dwThreadId;
result.thread = evt.u.CreateThread.hThread;
}break;
case EXIT_THREAD_DEBUG_EVENT:
{
result.name = str8_lit("exit thread");
result.thread_id = evt.dwThreadId;
}break;
case LOAD_DLL_DEBUG_EVENT:
{
result.name = str8_lit("load dll");
}break;
case UNLOAD_DLL_DEBUG_EVENT:
{
result.name = str8_lit("unload dll");
}break;
case EXCEPTION_DEBUG_EVENT:
{
result.name = str8_lit("exception");
EXCEPTION_DEBUG_INFO *edi = &evt.u.Exception;
EXCEPTION_RECORD *exception = &edi->ExceptionRecord;
switch(exception->ExceptionCode)
{
case DEMON_W32_EXCEPTION_BREAKPOINT:
{
result.name = str8_lit("breakpoint");
result.addr = (U64)exception->ExceptionAddress;
}break;
case DEMON_W32_EXCEPTION_SINGLE_STEP:
{
result.name = str8_lit("single_step");
}break;
case DEMON_W32_EXCEPTION_THROW:
{
result.name = str8_lit("exception throw");
}break;
case DEMON_W32_EXCEPTION_ACCESS_VIOLATION:
case DEMON_W32_EXCEPTION_IN_PAGE_ERROR:
{
result.name = str8_lit("exception access violation");
}break;
default:
{
}break;
}
}break;
case OUTPUT_DEBUG_STRING_EVENT:
{
Temp scratch = scratch_begin(0, 0);
result.name = str8_lit("output debug string");
U64 string_address = (U64)evt.u.DebugString.lpDebugStringData;
U64 string_size = (U64)evt.u.DebugString.nDebugStringLength;
// TODO(allen): is the string in UTF-8 or UTF-16?
U8 *buffer = push_array_no_zero(scratch.arena, U8, string_size + 1);
test_w32_read_memory(g_process_id_1 == evt.dwProcessId ? g_process_1 : g_process_2, buffer, string_address, string_size);
buffer[string_size] = 0;
printf("%s\n", buffer);
scratch_end(scratch);
}break;
case RIP_EVENT:
{
result.name = str8_lit("rip event");
}break;
}
}
//- rjf: set single step bit
if(step_thread != 0)
{
SYMS_RegX64 regs = {0};
test_w32_read_x64_regs(step_thread, &regs);
regs.rflags.u64 &= ~0x100;
test_w32_write_x64_regs(step_thread, &regs);
}
//- rjf: unset traps
{
TEST_Trap *trap = traps;
for(U64 i = 0; i < traps_count; i += 1, trap += 1)
{
U8 og_byte = trap_swap_bytes[i];
if(og_byte != 0xCC)
{
test_w32_write_memory(trap->process, trap->address, &og_byte, 1);
}
}
}
//- rjf: resume thread
if(suspend_thread)
{
ResumeThread(suspend_thread);
}
scratch_end(scratch);
return result;
}
internal DWORD
test_halter_thread(void *params)
{
HANDLE original_process_handle = params;
Sleep(1500);
test_halt();
#if 0
DWORD process_id = GetProcessId(original_process_handle);
HANDLE elevated_process_handle = OpenProcess(PROCESS_SUSPEND_RESUME, 0, process_id);
LONG result = NtSuspendProcess(elevated_process_handle);
CloseHandle(elevated_process_handle);
DebugBreakProcess(process);
#endif
return 0;
}
int
main(int argument_count, char **arguments)
{
os_init(argument_count, arguments);
Arena *arena = arena_alloc();
NtSuspendProcess = (NtSuspendProcessFunction *)GetProcAddress(GetModuleHandle("ntdll"), "NtSuspendProcess");
// rjf: launch
{
OS_LaunchOptions opts = {0};
opts.path = os_get_path(arena, OS_SystemPath_Current);
str8_list_push(arena, &opts.cmd_line, str8_lit("R:\\projects\\debugger\\build\\mule_loop.exe"));
B32 launch_good = test_launch_process(&opts);
int x = 0;
}
// rjf: get process/thread handles
HANDLE process = 0;
HANDLE thread1 = 0;
U64 thread1_id = 0;
{
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, 0, 0);
if(evt.process)
{
process = evt.process;
}
if(evt.thread)
{
thread1 = evt.thread;
thread1_id = evt.thread_id;
}
if(process != 0 && thread1 != 0)
{
break;
}
}
}
// rjf: get first breakpoint
{
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, 0, 0);
if(evt.evt.dwDebugEventCode == EXCEPTION_DEBUG_EVENT)
{
break;
}
}
}
// rjf: launch halter thread
DWORD halter_id = 0;
{
CreateThread(0, 0, test_halter_thread, process, 0, &halter_id);
}
// rjf: run + wait for event
for(;;)
{
TEST_DebugEvent evt = test_run_process(0, 0, 0, 0);
int x = 0;
}
#if 0
//- rjf: run until 2nd thread starts up
HANDLE thread2 = 0;
U64 thread2_id = 0;
{
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, 0, 0/*ArrayCount(traps), traps*/);
if(evt.thread)
{
thread2 = evt.thread;
thread2_id = evt.thread_id;
break;
}
}
}
//- rjf: wait for first output string
{
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, 0, 0);
if(evt.evt.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT)
{
break;
}
}
}
//- rjf: wait for bps
{
// U64 thread1_stop_vaddr = 0x0000000140001119;
// U64 thread2_stop_vaddr = 0x00000001400010C8;
// TEST_Trap traps[] =
{
// {process, thread1_stop_vaddr},
//{process, thread2_stop_vaddr},
};
TEST_DebugEvent evt = {0};
//for(;;)
{
evt = test_run_process(0, thread2, 0, 0/*ArrayCount(traps), traps*/);
int x = 0;
}
for(;;) {}
}
#endif
}
-874
View File
@@ -1,874 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#include <windows.h>
#include "base/base_inc.h"
#include "os/os_inc.h"
#include "syms_helpers/syms_internal_overrides.h"
#include "syms/syms_inc.h"
#include "syms_helpers/syms_helpers.h"
#include "base/base_inc.c"
#include "os/os_inc.c"
#include "syms_helpers/syms_internal_overrides.c"
#include "syms/syms_inc.c"
#include "syms_helpers/syms_helpers.c"
////////////////////////////////
// NOTE(allen): Win32 Demon Exceptions
#define DEMON_W32_EXCEPTION_BREAKPOINT 0x80000003u
#define DEMON_W32_EXCEPTION_SINGLE_STEP 0x80000004u
#define DEMON_W32_EXCEPTION_LONG_JUMP 0x80000026u
#define DEMON_W32_EXCEPTION_ACCESS_VIOLATION 0xC0000005u
#define DEMON_W32_EXCEPTION_ARRAY_BOUNDS_EXCEEDED 0xC000008Cu
#define DEMON_W32_EXCEPTION_DATA_TYPE_MISALIGNMENT 0x80000002u
#define DEMON_W32_EXCEPTION_GUARD_PAGE_VIOLATION 0x80000001u
#define DEMON_W32_EXCEPTION_FLT_DENORMAL_OPERAND 0xC000008Du
#define DEMON_W32_EXCEPTION_FLT_DEVIDE_BY_ZERO 0xC000008Eu
#define DEMON_W32_EXCEPTION_FLT_INEXACT_RESULT 0xC000008Fu
#define DEMON_W32_EXCEPTION_FLT_INVALID_OPERATION 0xC0000090u
#define DEMON_W32_EXCEPTION_FLT_OVERFLOW 0xC0000091u
#define DEMON_W32_EXCEPTION_FLT_STACK_CHECK 0xC0000092u
#define DEMON_W32_EXCEPTION_FLT_UNDERFLOW 0xC0000093u
#define DEMON_W32_EXCEPTION_INT_DIVIDE_BY_ZERO 0xC0000094u
#define DEMON_W32_EXCEPTION_INT_OVERFLOW 0xC0000095u
#define DEMON_W32_EXCEPTION_PRIVILEGED_INSTRUCTION 0xC0000096u
#define DEMON_W32_EXCEPTION_ILLEGAL_INSTRUCTION 0xC000001Du
#define DEMON_W32_EXCEPTION_IN_PAGE_ERROR 0xC0000006u
#define DEMON_W32_EXCEPTION_INVALID_DISPOSITION 0xC0000026u
#define DEMON_W32_EXCEPTION_NONCONTINUABLE 0xC0000025u
#define DEMON_W32_EXCEPTION_STACK_OVERFLOW 0xC00000FDu
#define DEMON_W32_EXCEPTION_INVALID_HANDLE 0xC0000008u
#define DEMON_W32_EXCEPTION_UNWIND_CONSOLIDATE 0x80000029u
#define DEMON_W32_EXCEPTION_DLL_NOT_FOUND 0xC0000135u
#define DEMON_W32_EXCEPTION_ORDINAL_NOT_FOUND 0xC0000138u
#define DEMON_W32_EXCEPTION_ENTRY_POINT_NOT_FOUND 0xC0000139u
#define DEMON_W32_EXCEPTION_DLL_INIT_FAILED 0xC0000142u
#define DEMON_W32_EXCEPTION_CONTROL_C_EXIT 0xC000013Au
#define DEMON_W32_EXCEPTION_FLT_MULTIPLE_FAULTS 0xC00002B4u
#define DEMON_W32_EXCEPTION_FLT_MULTIPLE_TRAPS 0xC00002B5u
#define DEMON_W32_EXCEPTION_NAT_CONSUMPTION 0xC00002C9u
#define DEMON_W32_EXCEPTION_HEAP_CORRUPTION 0xC0000374u
#define DEMON_W32_EXCEPTION_STACK_BUFFER_OVERRUN 0xC0000409u
#define DEMON_W32_EXCEPTION_INVALID_CRUNTIME_PARAM 0xC0000417u
#define DEMON_W32_EXCEPTION_ASSERT_FAILURE 0xC0000420u
#define DEMON_W32_EXCEPTION_NO_MEMORY 0xC0000017u
#define DEMON_W32_EXCEPTION_THROW 0xE06D7363u
////////////////////////////////
// NOTE(allen): Win32 Demon Register API Codes
#define DEMON_W32_CTX_X86 0x00010000
#define DEMON_W32_CTX_X64 0x00100000
#define DEMON_W32_CTX_INTEL_CONTROL 0x0001
#define DEMON_W32_CTX_INTEL_INTEGER 0x0002
#define DEMON_W32_CTX_INTEL_SEGMENTS 0x0004
#define DEMON_W32_CTX_INTEL_FLOATS 0x0008
#define DEMON_W32_CTX_INTEL_DEBUG 0x0010
#define DEMON_W32_CTX_INTEL_EXTENDED 0x0020
#define DEMON_W32_CTX_INTEL_XSTATE 0x0040
#define DEMON_W32_CTX_X86_ALL (DEMON_W32_CTX_X86 | \
DEMON_W32_CTX_INTEL_CONTROL | DEMON_W32_CTX_INTEL_INTEGER | \
DEMON_W32_CTX_INTEL_SEGMENTS | DEMON_W32_CTX_INTEL_DEBUG | \
DEMON_W32_CTX_INTEL_EXTENDED)
#define DEMON_W32_CTX_X64_ALL (DEMON_W32_CTX_X64 | \
DEMON_W32_CTX_INTEL_CONTROL | DEMON_W32_CTX_INTEL_INTEGER | \
DEMON_W32_CTX_INTEL_SEGMENTS | DEMON_W32_CTX_INTEL_FLOATS | \
DEMON_W32_CTX_INTEL_DEBUG)
struct TEST_DebugEvent
{
String8 name;
U64 process_id;
U64 thread_id;
HANDLE process;
HANDLE thread;
U64 addr;
DEBUG_EVENT evt;
};
struct TEST_Trap
{
HANDLE process;
U64 address;
};
internal U16
test_w32_real_tag_word_from_xsave(XSAVE_FORMAT *fxsave)
{
U16 result = 0;
U32 top = (fxsave->StatusWord >> 11) & 7;
for (U32 fpr = 0; fpr < 8; fpr += 1){
U32 tag = 3;
if (fxsave->TagWord & (1 << fpr)){
U32 st = (fpr - top)&7;
SYMS_Reg80 *fp = (SYMS_Reg80*)&fxsave->FloatRegisters[st*16];
U16 exponent = fp->sign1_exp15 & bitmask15;
U64 integer_part = fp->int1_frac63 >> 63;
U64 fraction_part = fp->int1_frac63 & bitmask63;
// tag: 0 - normal; 1 - zero; 2 - special
tag = 2;
if (exponent == 0){
if (integer_part == 0 && fraction_part == 0){
tag = 1;
}
}
else if (exponent != bitmask15 && integer_part != 0){
tag = 0;
}
}
result |= tag << (2 * fpr);
}
return(result);
}
internal U16
test_w32_xsave_tag_word_from_real_tag_word(U16 ftw)
{
U16 compact = 0;
for (U32 fpr = 0; fpr < 8; fpr++){
U32 tag = (ftw >> (fpr * 2)) & 3;
if (tag != 3){
compact |= (1 << fpr);
}
}
return(compact);
}
internal B32
test_w32_read_x64_regs(HANDLE thread, SYMS_RegX64 *dst)
{
Temp scratch = scratch_begin(0, 0);
// NOTE(allen): Check available features
U32 feature_mask = GetEnabledXStateFeatures();
B32 avx_enabled = !!(feature_mask & XSTATE_MASK_AVX);
// NOTE(allen): Setup the context
CONTEXT *ctx = 0;
U32 ctx_flags = DEMON_W32_CTX_X64_ALL;
if (avx_enabled){
ctx_flags |= DEMON_W32_CTX_INTEL_XSTATE;
}
DWORD size = 0;
InitializeContext(0, ctx_flags, 0, &size);
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER){
void *ctx_memory = push_array(scratch.arena, U8, size);
if (!InitializeContext(ctx_memory, ctx_flags, &ctx, &size)){
ctx = 0;
}
}
B32 avx_available = false;
if (ctx != 0){
// NOTE(allen): Finish Context Setup
if (avx_enabled){
SetXStateFeaturesMask(ctx, XSTATE_MASK_AVX);
}
// NOTE(allen): Determine what features are available on this particular ctx
// TODO(allen): Experiment carefully with this nonsense.
// Does avx_enabled = avx_available in all circumstances or not?
DWORD64 xstate_flags = 0;
if (GetXStateFeaturesMask(ctx, &xstate_flags)){
if (xstate_flags & XSTATE_MASK_AVX){
avx_available = true;
}
}
}
// get thread context
HANDLE thread_handle = thread;
if (!GetThreadContext(thread_handle, ctx)){
ctx = 0;
}
B32 result = false;
if (ctx != 0){
result = true;
// NOTE(allen): Convert CONTEXT -> SYMS_RegX64
dst->rax.u64 = ctx->Rax;
dst->rcx.u64 = ctx->Rcx;
dst->rdx.u64 = ctx->Rdx;
dst->rbx.u64 = ctx->Rbx;
dst->rsp.u64 = ctx->Rsp;
dst->rbp.u64 = ctx->Rbp;
dst->rsi.u64 = ctx->Rsi;
dst->rdi.u64 = ctx->Rdi;
dst->r8.u64 = ctx->R8;
dst->r9.u64 = ctx->R9;
dst->r10.u64 = ctx->R10;
dst->r11.u64 = ctx->R11;
dst->r12.u64 = ctx->R12;
dst->r13.u64 = ctx->R13;
dst->r14.u64 = ctx->R14;
dst->r15.u64 = ctx->R15;
dst->rip.u64 = ctx->Rip;
dst->cs.u16 = ctx->SegCs;
dst->ds.u16 = ctx->SegDs;
dst->es.u16 = ctx->SegEs;
dst->fs.u16 = ctx->SegFs;
dst->gs.u16 = ctx->SegGs;
dst->ss.u16 = ctx->SegSs;
dst->dr0.u32 = ctx->Dr0;
dst->dr1.u32 = ctx->Dr1;
dst->dr2.u32 = ctx->Dr2;
dst->dr3.u32 = ctx->Dr3;
dst->dr6.u32 = ctx->Dr6;
dst->dr7.u32 = ctx->Dr7;
// NOTE(allen): This bit is "supposed to always be 1" I guess.
// TODO(allen): Not sure what this is all about but I haven't investigated it yet.
// This might be totally not necessary or something.
dst->rflags.u64 = ctx->EFlags | 0x2;
XSAVE_FORMAT *xsave = &ctx->FltSave;
dst->fcw.u16 = xsave->ControlWord;
dst->fsw.u16 = xsave->StatusWord;
dst->ftw.u16 = test_w32_real_tag_word_from_xsave(xsave);
dst->fop.u16 = xsave->ErrorOpcode;
dst->fcs.u16 = xsave->ErrorSelector;
dst->fds.u16 = xsave->DataSelector;
dst->fip.u32 = xsave->ErrorOffset;
dst->fdp.u32 = xsave->DataOffset;
dst->mxcsr.u32 = xsave->MxCsr;
dst->mxcsr_mask.u32 = xsave->MxCsr_Mask;
M128A *float_s = xsave->FloatRegisters;
SYMS_Reg80 *float_d = &dst->fpr0;
for (U32 n = 0; n < 8; n += 1, float_s += 1, float_d += 1){
MemoryCopy(float_d, float_s, sizeof(*float_d));
}
if (!avx_available){
M128A *xmm_s = xsave->XmmRegisters;
SYMS_Reg256 *xmm_d = &dst->ymm0;
for (U32 n = 0; n < 16; n += 1, xmm_s += 1, xmm_d += 1){
MemoryCopy(xmm_d, xmm_s, sizeof(*xmm_s));
}
}
if (avx_available){
DWORD part0_length = 0;
M128A *part0 = (M128A*)LocateXStateFeature(ctx, XSTATE_LEGACY_SSE, &part0_length);
DWORD part1_length = 0;
M128A *part1 = (M128A*)LocateXStateFeature(ctx, XSTATE_AVX, &part1_length);
Assert(part0_length == part1_length);
DWORD count = part0_length/sizeof(part0[0]);
count = ClampTop(count, 16);
SYMS_Reg256 *ymm_d = &dst->ymm0;
for (DWORD i = 0;
i < count;
i += 1, part0 += 1, part1 += 1, ymm_d += 1){
// TODO(allen): Are we writing these out in the right order? Seems weird right?
ymm_d->u64[3] = part0->Low;
ymm_d->u64[2] = part0->High;
ymm_d->u64[1] = part1->Low;
ymm_d->u64[0] = part1->High;
}
}
}
scratch_end(scratch);
return(result);
}
internal B32
test_w32_write_x64_regs(HANDLE thread, SYMS_RegX64 *src)
{
Temp scratch = scratch_begin(0, 0);
// NOTE(allen): Check available features
U32 feature_mask = GetEnabledXStateFeatures();
B32 avx_enabled = !!(feature_mask & XSTATE_MASK_AVX);
// NOTE(allen): Setup the context
CONTEXT *ctx = 0;
U32 ctx_flags = DEMON_W32_CTX_X64_ALL;
if (avx_enabled){
ctx_flags |= DEMON_W32_CTX_INTEL_XSTATE;
}
DWORD size = 0;
InitializeContext(0, ctx_flags, 0, &size);
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER){
void *ctx_memory = push_array(scratch.arena, U8, size);
if (!InitializeContext(ctx_memory, ctx_flags, &ctx, &size)){
ctx = 0;
}
}
B32 avx_available = false;
if (ctx != 0){
// NOTE(allen): Finish Context Setup
if (avx_enabled){
SetXStateFeaturesMask(ctx, XSTATE_MASK_AVX);
}
// NOTE(allen): Determine what features are available on this particular ctx
// TODO(allen): Experiment carefully with this nonsense.
// Does avx_enabled = avx_available in all circumstances or not?
DWORD64 xstate_flags = 0;
if (GetXStateFeaturesMask(ctx, &xstate_flags)){
if (xstate_flags & XSTATE_MASK_AVX){
avx_available = true;
}
}
}
B32 result = false;
if (ctx != 0){
// NOTE(allen): Convert SYMS_RegX64 -> CONTEXT
ctx->ContextFlags = ctx_flags;
ctx->MxCsr = src->mxcsr.u32 & src->mxcsr_mask.u32;
ctx->Rax = src->rax.u64;
ctx->Rcx = src->rcx.u64;
ctx->Rdx = src->rdx.u64;
ctx->Rbx = src->rbx.u64;
ctx->Rsp = src->rsp.u64;
ctx->Rbp = src->rbp.u64;
ctx->Rsi = src->rsi.u64;
ctx->Rdi = src->rdi.u64;
ctx->R8 = src->r8.u64;
ctx->R9 = src->r9.u64;
ctx->R10 = src->r10.u64;
ctx->R11 = src->r11.u64;
ctx->R12 = src->r12.u64;
ctx->R13 = src->r13.u64;
ctx->R14 = src->r14.u64;
ctx->R15 = src->r15.u64;
ctx->Rip = src->rip.u64;
ctx->SegCs = src->cs.u16;
ctx->SegDs = src->ds.u16;
ctx->SegEs = src->es.u16;
ctx->SegFs = src->fs.u16;
ctx->SegGs = src->gs.u16;
ctx->SegSs = src->ss.u16;
ctx->Dr0 = src->dr0.u32;
ctx->Dr1 = src->dr1.u32;
ctx->Dr2 = src->dr2.u32;
ctx->Dr3 = src->dr3.u32;
ctx->Dr6 = src->dr6.u32;
ctx->Dr7 = src->dr7.u32;
ctx->EFlags = src->rflags.u64;
XSAVE_FORMAT *fxsave = &ctx->FltSave;
fxsave->ControlWord = src->fcw.u16;
fxsave->StatusWord = src->fsw.u16;
fxsave->TagWord = test_w32_xsave_tag_word_from_real_tag_word(src->ftw.u16);
fxsave->ErrorOpcode = src->fop.u16;
fxsave->ErrorSelector = src->fcs.u16;
fxsave->DataSelector = src->fds.u16;
fxsave->ErrorOffset = src->fip.u32;
fxsave->DataOffset = src->fdp.u32;
M128A *float_d = fxsave->FloatRegisters;
SYMS_Reg80 *float_s = &src->fpr0;
for (U32 n = 0;
n < 8;
n += 1, float_s += 1, float_d += 1){
MemoryCopy(float_d, float_s, 10);
}
if (!avx_available){
M128A *xmm_d = fxsave->XmmRegisters;
SYMS_Reg256 *xmm_s = &src->ymm0;
for (U32 n = 0;
n < 8;
n += 1, xmm_d += 1, xmm_s += 1){
MemoryCopy(xmm_d, xmm_s, sizeof(*xmm_d));
}
}
if (avx_available){
DWORD part0_length = 0;
M128A *part0 = (M128A*)LocateXStateFeature(ctx, XSTATE_LEGACY_SSE, &part0_length);
DWORD part1_length = 0;
M128A *part1 = (M128A*)LocateXStateFeature(ctx, XSTATE_AVX, &part1_length);
Assert(part0_length == part1_length);
DWORD count = part0_length/sizeof(part0[0]);
count = ClampTop(count, 16);
SYMS_Reg256 *ymm_d = &src->ymm0;
for (DWORD i = 0;
i < count;
i += 1, part0 += 1, part1 += 1, ymm_d += 1){
// TODO(allen): Are we writing these out in the right order? Seems weird right?
part0->Low = ymm_d->u64[3];
part0->High = ymm_d->u64[2];
part1->Low = ymm_d->u64[1];
part1->High = ymm_d->u64[0];
}
}
//- set thread context
HANDLE thread_handle = thread;
if (SetThreadContext(thread_handle, ctx)){
result = true;
}
}
scratch_end(scratch);
return(result);
}
internal B32
test_w32_read_memory(HANDLE process_handle, void *dst, U64 src_address, U64 size)
{
B32 result = true;
U8 *ptr = (U8*)dst;
U8 *opl = ptr + size;
U64 cursor = src_address;
for (;ptr < opl;){
SIZE_T to_read = (SIZE_T)(opl - ptr);
SIZE_T actual_read = 0;
if (!ReadProcessMemory(process_handle, (LPCVOID)cursor, ptr, to_read, &actual_read)){
result = false;
break;
}
ptr += actual_read;
cursor += actual_read;
}
return(result);
}
internal B32
test_w32_write_memory(HANDLE process_handle, U64 dst_address, void *src, U64 size)
{
B32 result = true;
U8 *ptr = (U8*)src;
U8 *opl = ptr + size;
U64 cursor = dst_address;
for (;ptr < opl;){
SIZE_T to_write = (SIZE_T)(opl - ptr);
SIZE_T actual_write = 0;
if (!WriteProcessMemory(process_handle, (LPVOID)cursor, ptr, to_write, &actual_write)){
result = false;
break;
}
ptr += actual_write;
cursor += actual_write;
}
return(result);
}
internal B32
test_launch_process(OS_LaunchOptions *options)
{
B32 result = false;
Temp scratch = scratch_begin(0, 0);
StringJoin join_params = {0};
join_params.pre = str8_lit("\"");
join_params.sep = str8_lit("\" \"");
join_params.post = str8_lit("\"");
String8 cmd = str8_list_join(scratch.arena, &options->cmd_line, &join_params);
StringJoin join_params2 = {0};
join_params2.sep = str8_lit("\0");
join_params2.post = str8_lit("\0");
String8 env = str8_list_join(scratch.arena, &options->env, &join_params2);
String16 cmd16 = str16_from_8(scratch.arena, cmd);
String16 dir16 = str16_from_8(scratch.arena, options->path);
String16 env16 = str16_from_8(scratch.arena, env);
DWORD access_flags = PROCESS_QUERY_INFORMATION | DEBUG_PROCESS | PROCESS_VM_READ | PROCESS_VM_WRITE;
STARTUPINFOW startup_info = {sizeof(startup_info)};
PROCESS_INFORMATION process_info = {0};
if (CreateProcessW(0, (WCHAR*)cmd16.str, 0, 0, 0, access_flags, (WCHAR*)env16.str, (WCHAR*)dir16.str,
&startup_info, &process_info))
{
CloseHandle(process_info.hProcess);
CloseHandle(process_info.hThread);
result = true;
}
scratch_end(scratch);
return(result);
}
global HANDLE g_process = 0;
global DWORD g_process_id = 0;
global HANDLE g_thread1 = 0;
global DWORD g_thread1_id = 0;
global HANDLE g_thread2 = 0;
global DWORD g_thread2_id = 0;
internal TEST_DebugEvent
test_run_process(HANDLE step_thread, HANDLE suspend_thread, U64 traps_count, TEST_Trap *traps)
{
Temp scratch = scratch_begin(0, 0);
TEST_DebugEvent result = {0};
//- rjf: freeze thread
if(suspend_thread)
{
DWORD result = SuspendThread(suspend_thread);
DWORD error = GetLastError();
int x = 0;
}
//- rjf: write traps
U8 *trap_swap_bytes = push_array_no_zero(scratch.arena, U8, traps_count);
{
TEST_Trap *trap = traps;
for(U64 i = 0; i < traps_count; i += 1, trap += 1)
{
if(test_w32_read_memory(trap->process, trap_swap_bytes + i, trap->address, 1))
{
U8 int3 = 0xCC;
test_w32_write_memory(trap->process, trap->address, &int3, 1);
}
else
{
trap_swap_bytes[i] = 0xCC;
}
}
}
//- rjf: set single step bit
if(step_thread != 0)
{
SYMS_RegX64 regs = {0};
test_w32_read_x64_regs(step_thread, &regs);
regs.rflags.u64 |= 0x100;
test_w32_write_x64_regs(step_thread, &regs);
}
//- rjf: continue
local_persist B32 need_resume = 0;
local_persist DWORD resume_pid = 0;
local_persist DWORD resume_tid = 0;
if(need_resume)
{
need_resume = 0;
ContinueDebugEvent(resume_pid, resume_tid, DBG_CONTINUE);
}
//- rjf: get event
DEBUG_EVENT evt = {0};
if(WaitForDebugEvent(&evt, INFINITE))
{
need_resume = 1;
resume_pid = evt.dwProcessId;
resume_tid = evt.dwThreadId;
result.evt = evt;
switch(evt.dwDebugEventCode)
{
default:break;
case CREATE_PROCESS_DEBUG_EVENT:
{
result.name = str8_lit("create process");
result.process_id = evt.dwProcessId;
result.process = evt.u.CreateProcessInfo.hProcess;
result.thread_id = evt.dwThreadId;
result.thread = evt.u.CreateProcessInfo.hThread;
if(g_process == 0)
{
g_process = result.process;
g_process_id = result.process_id;
}
if(g_thread1 == 0)
{
g_thread1 = result.thread;
g_thread1_id = result.thread_id;
}
}break;
case EXIT_PROCESS_DEBUG_EVENT:
{
result.name = str8_lit("exit process");
result.process_id = evt.dwProcessId;
}break;
case CREATE_THREAD_DEBUG_EVENT:
{
result.name = str8_lit("create thread");
result.thread_id = evt.dwThreadId;
result.thread = evt.u.CreateThread.hThread;
g_thread2 = result.thread;
g_thread2_id = result.thread_id;
}break;
case EXIT_THREAD_DEBUG_EVENT:
{
result.name = str8_lit("exit thread");
result.thread_id = evt.dwThreadId;
}break;
case LOAD_DLL_DEBUG_EVENT:
{
result.name = str8_lit("load dll");
}break;
case UNLOAD_DLL_DEBUG_EVENT:
{
result.name = str8_lit("unload dll");
}break;
case EXCEPTION_DEBUG_EVENT:
{
result.name = str8_lit("exception");
EXCEPTION_DEBUG_INFO *edi = &evt.u.Exception;
EXCEPTION_RECORD *exception = &edi->ExceptionRecord;
switch(exception->ExceptionCode)
{
case DEMON_W32_EXCEPTION_BREAKPOINT:
{
result.name = str8_lit("breakpoint");
result.addr = (U64)exception->ExceptionAddress;
local_persist B32 did_first_bp = 0;
if(did_first_bp != 0)
{
HANDLE thread = evt.dwThreadId == g_thread1_id ? g_thread1 : g_thread2;
SYMS_RegX64 regs = {0};
test_w32_read_x64_regs(thread, &regs);
regs.rip.u64 = result.addr;
test_w32_write_x64_regs(thread, &regs);
}
did_first_bp = 1;
}break;
case DEMON_W32_EXCEPTION_SINGLE_STEP:
{
result.name = str8_lit("single_step");
}break;
case DEMON_W32_EXCEPTION_THROW:
{
result.name = str8_lit("exception throw");
}break;
case DEMON_W32_EXCEPTION_ACCESS_VIOLATION:
case DEMON_W32_EXCEPTION_IN_PAGE_ERROR:
{
result.name = str8_lit("exception access violation");
}break;
default:
{
}break;
}
}break;
case OUTPUT_DEBUG_STRING_EVENT:
{
Temp scratch = scratch_begin(0, 0);
result.name = str8_lit("output debug string");
U64 string_address = (U64)evt.u.DebugString.lpDebugStringData;
U64 string_size = (U64)evt.u.DebugString.nDebugStringLength;
// TODO(allen): is the string in UTF-8 or UTF-16?
U8 *buffer = push_array_no_zero(scratch.arena, U8, string_size + 1);
test_w32_read_memory(g_process, buffer, string_address, string_size);
buffer[string_size] = 0;
printf("%s\n", buffer);
scratch_end(scratch);
}break;
case RIP_EVENT:
{
result.name = str8_lit("rip event");
}break;
}
}
//- rjf: set single step bit
if(step_thread != 0)
{
SYMS_RegX64 regs = {0};
test_w32_read_x64_regs(step_thread, &regs);
regs.rflags.u64 &= ~0x100;
test_w32_write_x64_regs(step_thread, &regs);
}
//- rjf: unset traps
{
TEST_Trap *trap = traps;
for(U64 i = 0; i < traps_count; i += 1, trap += 1)
{
U8 og_byte = trap_swap_bytes[i];
if(og_byte != 0xCC)
{
test_w32_write_memory(trap->process, trap->address, &og_byte, 1);
}
}
}
//- rjf: check for more events
for(int i = 0; i < 100; i += 1)
{
DEBUG_EVENT evt = {0};
if(WaitForDebugEvent(&evt, 0))
{
int x = 0;
}
}
//- rjf: resume thread
if(suspend_thread)
{
ResumeThread(suspend_thread);
}
scratch_end(scratch);
return result;
}
int
main(int argument_count, char **arguments)
{
os_init(argument_count, arguments);
Arena *arena = arena_alloc();
U64 before_loop_stop_vaddr = 0x0000000140001089;
U64 inner_loop_stop_vaddr = 0x0000000140001098;
// rjf: launch
{
OS_LaunchOptions opts = {0};
opts.path = os_get_path(arena, OS_SystemPath_Current);
str8_list_push(arena, &opts.cmd_line, str8_lit("R:\\projects\\debugger\\build\\mule_loop_threads_win32.exe"));
B32 launch_good = test_launch_process(&opts);
int x = 0;
}
// rjf: get process/thread handles
HANDLE process = 0;
HANDLE thread1 = 0;
U64 thread1_id = 0;
{
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, 0, 0);
if(evt.process)
{
process = evt.process;
}
if(evt.thread)
{
thread1 = evt.thread;
thread1_id = evt.thread_id;
}
if(process != 0 && thread1 != 0)
{
break;
}
}
}
// rjf: get first breakpoint
{
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, 0, 0);
if(evt.evt.dwDebugEventCode == EXCEPTION_DEBUG_EVENT)
{
break;
}
}
}
//- rjf: run until 2nd thread starts up
HANDLE thread2 = 0;
U64 thread2_id = 0;
{
TEST_Trap traps[] =
{
{process, before_loop_stop_vaddr},
};
int trap_count = 0; //ArrayCount(traps);
for(TEST_DebugEvent evt = {0};;)
{
evt = test_run_process(0, 0, trap_count, traps);
if(str8_match(evt.name, str8_lit("breakpoint"), 0))
{
trap_count = 0;
}
if(evt.thread)
{
thread2 = evt.thread;
thread2_id = evt.thread_id;
break;
}
}
}
//- rjf: wait for bps
{
Temp scratch = scratch_begin(0, 0);
TEST_Trap traps[] =
{
{process, 0x0000000140001098},
{process, 0x00000001400010fb},
{process, 0x00000001400010bc},
{process, 0x00000001400010d7},
};
for(int i = 0;; i += 1)
{
TEST_DebugEvent evt = test_run_process(0, 0, 1, &traps[i % ArrayCount(traps)]);
// rjf: check regs
{
U64 rip = 0;
SYMS_RegX64 *regs = push_array(scratch.arena, SYMS_RegX64, 1);
if(evt.evt.dwThreadId == g_thread1_id && test_w32_read_x64_regs(thread1, regs))
{
rip = regs->rip.u64;
}
if(evt.evt.dwThreadId == g_thread2_id && test_w32_read_x64_regs(thread2, regs))
{
rip = regs->rip.u64;
}
for(int i = 0; i < ArrayCount(traps); i += 1)
{
if(traps[i].address == rip)
{
printf("WRONG BP! 0x%I64x\n", rip);
break;
}
}
}
if(str8_match(evt.name, str8_lit("breakpoint"), 0))
{
HANDLE step = 0;
HANDLE suspend = 0;
step = evt.evt.dwThreadId == thread2_id ? thread2 : thread1;
suspend = step == thread2 ? thread1 : thread2;
evt = test_run_process(step, suspend, 0, 0);
}
}
scratch_end(scratch);
}
return 0;
}
File diff suppressed because it is too large Load Diff
+286
View File
@@ -0,0 +1,286 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DEMON_CORE_WIN32_H
#define DEMON_CORE_WIN32_H
////////////////////////////////
//~ rjf: Windows Includes
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <psapi.h>
#include <tlhelp32.h>
////////////////////////////////
//~ rjf: Win32 Exception Codes
#define DMN_W32_EXCEPTION_BREAKPOINT 0x80000003u
#define DMN_W32_EXCEPTION_SINGLE_STEP 0x80000004u
#define DMN_W32_EXCEPTION_LONG_JUMP 0x80000026u
#define DMN_W32_EXCEPTION_ACCESS_VIOLATION 0xC0000005u
#define DMN_W32_EXCEPTION_ARRAY_BOUNDS_EXCEEDED 0xC000008Cu
#define DMN_W32_EXCEPTION_DATA_TYPE_MISALIGNMENT 0x80000002u
#define DMN_W32_EXCEPTION_GUARD_PAGE_VIOLATION 0x80000001u
#define DMN_W32_EXCEPTION_FLT_DENORMAL_OPERAND 0xC000008Du
#define DMN_W32_EXCEPTION_FLT_DEVIDE_BY_ZERO 0xC000008Eu
#define DMN_W32_EXCEPTION_FLT_INEXACT_RESULT 0xC000008Fu
#define DMN_W32_EXCEPTION_FLT_INVALID_OPERATION 0xC0000090u
#define DMN_W32_EXCEPTION_FLT_OVERFLOW 0xC0000091u
#define DMN_W32_EXCEPTION_FLT_STACK_CHECK 0xC0000092u
#define DMN_W32_EXCEPTION_FLT_UNDERFLOW 0xC0000093u
#define DMN_W32_EXCEPTION_INT_DIVIDE_BY_ZERO 0xC0000094u
#define DMN_W32_EXCEPTION_INT_OVERFLOW 0xC0000095u
#define DMN_W32_EXCEPTION_PRIVILEGED_INSTRUCTION 0xC0000096u
#define DMN_W32_EXCEPTION_ILLEGAL_INSTRUCTION 0xC000001Du
#define DMN_W32_EXCEPTION_IN_PAGE_ERROR 0xC0000006u
#define DMN_W32_EXCEPTION_INVALID_DISPOSITION 0xC0000026u
#define DMN_W32_EXCEPTION_NONCONTINUABLE 0xC0000025u
#define DMN_W32_EXCEPTION_STACK_OVERFLOW 0xC00000FDu
#define DMN_W32_EXCEPTION_INVALID_HANDLE 0xC0000008u
#define DMN_W32_EXCEPTION_UNWIND_CONSOLIDATE 0x80000029u
#define DMN_W32_EXCEPTION_DLL_NOT_FOUND 0xC0000135u
#define DMN_W32_EXCEPTION_ORDINAL_NOT_FOUND 0xC0000138u
#define DMN_W32_EXCEPTION_ENTRY_POINT_NOT_FOUND 0xC0000139u
#define DMN_W32_EXCEPTION_DLL_INIT_FAILED 0xC0000142u
#define DMN_W32_EXCEPTION_CONTROL_C_EXIT 0xC000013Au
#define DMN_W32_EXCEPTION_FLT_MULTIPLE_FAULTS 0xC00002B4u
#define DMN_W32_EXCEPTION_FLT_MULTIPLE_TRAPS 0xC00002B5u
#define DMN_W32_EXCEPTION_NAT_CONSUMPTION 0xC00002C9u
#define DMN_W32_EXCEPTION_HEAP_CORRUPTION 0xC0000374u
#define DMN_W32_EXCEPTION_STACK_BUFFER_OVERRUN 0xC0000409u
#define DMN_W32_EXCEPTION_INVALID_CRUNTIME_PARAM 0xC0000417u
#define DMN_W32_EXCEPTION_ASSERT_FAILURE 0xC0000420u
#define DMN_W32_EXCEPTION_NO_MEMORY 0xC0000017u
#define DMN_W32_EXCEPTION_THROW 0xE06D7363u
#define DMN_W32_EXCEPTION_SET_THREAD_NAME 0x406d1388u
#define DMN_w32_EXCEPTION_CLRDBG_NOTIFICATION 0x04242420u
#define DMN_w32_EXCEPTION_CLR 0xE0434352u
////////////////////////////////
//~ rjf: Win32 Register Codes
#define DMN_W32_CTX_X86 0x00010000
#define DMN_W32_CTX_X64 0x00100000
#define DMN_W32_CTX_INTEL_CONTROL 0x0001 // segss, rsp, segcs, rip, and rflags
#define DMN_W32_CTX_INTEL_INTEGER 0x0002 // rax, rcx, rdx, rbx, rbp, rsi, rdi, and r8-r15
#define DMN_W32_CTX_INTEL_SEGMENTS 0x0004 // segds, seges, segfs, and seggs
#define DMN_W32_CTX_INTEL_FLOATS 0x0008 // xmm0-xmm15
#define DMN_W32_CTX_INTEL_DEBUG 0x0010 // dr0-dr3 and dr6-dr7
#define DMN_W32_CTX_INTEL_EXTENDED 0x0020
#define DMN_W32_CTX_INTEL_XSTATE 0x0040
#define DMN_W32_CTX_X86_ALL (DMN_W32_CTX_X86 | \
DMN_W32_CTX_INTEL_CONTROL | DMN_W32_CTX_INTEL_INTEGER | \
DMN_W32_CTX_INTEL_SEGMENTS | DMN_W32_CTX_INTEL_DEBUG | \
DMN_W32_CTX_INTEL_EXTENDED)
#define DMN_W32_CTX_X64_ALL (DMN_W32_CTX_X64 | \
DMN_W32_CTX_INTEL_CONTROL | DMN_W32_CTX_INTEL_INTEGER | \
DMN_W32_CTX_INTEL_SEGMENTS | DMN_W32_CTX_INTEL_FLOATS | \
DMN_W32_CTX_INTEL_DEBUG)
////////////////////////////////
//~ rjf: Per-Entity State
typedef enum DMN_W32_EntityKind
{
DMN_W32_EntityKind_Null,
DMN_W32_EntityKind_Root,
DMN_W32_EntityKind_Process,
DMN_W32_EntityKind_Thread,
DMN_W32_EntityKind_Module,
DMN_W32_EntityKind_COUNT
}
DMN_W32_EntityKind;
typedef struct DMN_W32_Entity DMN_W32_Entity;
struct DMN_W32_Entity
{
DMN_W32_Entity *first;
DMN_W32_Entity *last;
DMN_W32_Entity *next;
DMN_W32_Entity *prev;
DMN_W32_Entity *parent;
DMN_W32_EntityKind kind;
U32 gen;
U64 id;
HANDLE handle;
Architecture arch;
union
{
struct
{
U64 injection_address;
B32 did_first_bp;
}
proc;
struct
{
U64 thread_local_base;
U64 last_name_hash;
U64 name_gather_time_us;
}
thread;
struct
{
Rng1U64 vaddr_range;
U64 address_of_name_pointer;
B32 is_main;
B32 name_is_unicode;
}
module;
};
};
typedef struct DMN_W32_EntityNode DMN_W32_EntityNode;
struct DMN_W32_EntityNode
{
DMN_W32_EntityNode *next;
DMN_W32_Entity *v;
};
typedef struct DMN_W32_EntityIDHashNode DMN_W32_EntityIDHashNode;
struct DMN_W32_EntityIDHashNode
{
DMN_W32_EntityIDHashNode *next;
DMN_W32_EntityIDHashNode *prev;
U64 id;
DMN_W32_Entity *entity;
};
typedef struct DMN_W32_EntityIDHashSlot DMN_W32_EntityIDHashSlot;
struct DMN_W32_EntityIDHashSlot
{
DMN_W32_EntityIDHashNode *first;
DMN_W32_EntityIDHashNode *last;
};
////////////////////////////////
//~ rjf: Injection Types
typedef struct DMN_W32_InjectedBreak DMN_W32_InjectedBreak;
struct DMN_W32_InjectedBreak
{
U64 code;
U64 user_data;
};
#define DMN_W32_INJECTED_CODE_SIZE 32
////////////////////////////////
//~ rjf: Image Info Types
typedef struct DMN_W32_ImageInfo DMN_W32_ImageInfo;
struct DMN_W32_ImageInfo
{
Architecture arch;
U32 size;
};
////////////////////////////////
//~ rjf: Dynamically-Loaded Win32 Function Types
typedef HRESULT DMN_W32_GetThreadDescriptionFunctionType(HANDLE hThread, WCHAR **ppszThreadDescription);
////////////////////////////////
//~ rjf: Shared State Bundle
typedef struct DMN_W32_Shared DMN_W32_Shared;
struct DMN_W32_Shared
{
// rjf: top-level info
Arena *arena;
String8List env_strings;
// rjf: access locking mechanism
OS_Handle access_mutex;
B32 access_run_state;
// rjf: run/mem/reg gens
U64 run_gen;
U64 mem_gen;
U64 reg_gen;
// rjf: detaching info
Arena *detach_arena;
DMN_HandleList detach_processes;
// rjf: entity state
Arena *entities_arena;
DMN_W32_Entity *entities_base;
DMN_W32_Entity *entities_first_free;
U64 entities_count;
DMN_W32_EntityIDHashSlot *entities_id_hash_slots;
U64 entities_id_hash_slots_count;
DMN_W32_EntityIDHashNode *entities_id_hash_node_free;
// rjf: launch state
B32 new_process_pending;
// rjf: run results
B32 resume_needed;
U32 resume_pid;
U32 resume_tid;
B32 exception_not_handled;
// rjf: halting info
DMN_Handle halter_process;
U32 halter_tid;
};
////////////////////////////////
//~ rjf: Globals
global DMN_W32_Shared *dmn_w32_shared = 0;
global DMN_W32_Entity dmn_w32_entity_nil = {&dmn_w32_entity_nil, &dmn_w32_entity_nil, &dmn_w32_entity_nil, &dmn_w32_entity_nil, &dmn_w32_entity_nil};
global DMN_W32_GetThreadDescriptionFunctionType *dmn_w32_GetThreadDescription = 0;
thread_static B32 dmn_w32_ctrl_thread = 0;
////////////////////////////////
//~ rjf: Basic Helpers
internal U64 dmn_w32_hash_from_string(String8 string);
internal U64 dmn_w32_hash_from_id(U64 id);
////////////////////////////////
//~ rjf: Entity Helpers
//- rjf: entity <-> handle
internal DMN_Handle dmn_w32_handle_from_entity(DMN_W32_Entity *entity);
internal DMN_W32_Entity *dmn_w32_entity_from_handle(DMN_Handle handle);
//- rjf: entity allocation/deallocation
internal DMN_W32_Entity *dmn_w32_entity_alloc(DMN_W32_Entity *parent, DMN_W32_EntityKind kind, U64 id);
internal void dmn_w32_entity_release(DMN_W32_Entity *entity);
//- rjf: kind*id -> entity
internal DMN_W32_Entity *dmn_w32_entity_from_kind_id(DMN_W32_EntityKind kind, U64 id);
////////////////////////////////
//~ rjf: Module Info Extraction
internal String8 dmn_w32_full_path_from_module(Arena *arena, DMN_W32_Entity *module);
////////////////////////////////
//~ rjf: Win32-Level Process/Thread Reads/Writes
//- rjf: processes
internal U64 dmn_w32_process_read(HANDLE process, Rng1U64 range, void *dst);
internal B32 dmn_w32_process_write(HANDLE process, Rng1U64 range, void *src);
internal String8 dmn_w32_read_memory_str(Arena *arena, HANDLE process_handle, U64 address);
internal String16 dmn_w32_read_memory_str16(Arena *arena, HANDLE process_handle, U64 address);
#define dmn_w32_process_read_struct(process, vaddr, ptr) dmn_w32_process_read((process), r1u64((vaddr), (vaddr)+(sizeof(*ptr))), ptr)
#define dmn_w32_process_write_struct(process, vaddr, ptr) dmn_w32_process_write((process), r1u64((vaddr), (vaddr)+(sizeof(*ptr))), ptr)
internal DMN_W32_ImageInfo dmn_w32_image_info_from_process_base_vaddr(HANDLE process, U64 base_vaddr);
//- rjf: threads
internal U16 dmn_w32_real_tag_word_from_xsave(XSAVE_FORMAT *fxsave);
internal U16 dmn_w32_xsave_tag_word_from_real_tag_word(U16 ftw);
internal B32 dmn_w32_thread_read_reg_block(Architecture arch, HANDLE thread, void *reg_block);
internal B32 dmn_w32_thread_write_reg_block(Architecture arch, HANDLE thread, void *reg_block);
//- rjf: remote thread injection
internal DWORD dmn_w32_inject_thread(HANDLE process, U64 start_address);
#endif // DEMON_CORE_WIN32_H
File diff suppressed because it is too large Load Diff
-385
View File
@@ -1,385 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DEMON_OS_WIN32_H
#define DEMON_OS_WIN32_H
////////////////////////////////
//~ NOTE(allen): Win32 Demon Headers Negotation
// windows headers
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <psapi.h>
#include <tlhelp32.h>
////////////////////////////////
//~ NOTE(allen): Win32 Demon Types
//- entities
// Demon Win32 Entity Extensions
// Process: ext points to independently allocated DEMON_W32_Ext
// Thread : ext points to independently allocated DEMON_W32_Ext
// Module : ext set to HANDLE
typedef union DEMON_W32_Ext DEMON_W32_Ext;
union DEMON_W32_Ext
{
DEMON_W32_Ext *next;
struct{
HANDLE handle;
U64 injection_address;
B32 did_first_bp;
} proc;
struct{
HANDLE handle;
U64 thread_local_base;
U64 last_name_hash;
U64 name_gather_time_us;
B32 last_run_reported_trap;
U64 last_run_reported_trap_pre_rip;
U64 last_run_reported_trap_post_rip;
} thread;
struct{
HANDLE handle;
U64 address_of_name_pointer;
B32 is_main;
B32 name_is_unicode;
} module;
};
//- helpers
typedef struct DEMON_W32_InjectedBreak DEMON_W32_InjectedBreak;
struct DEMON_W32_InjectedBreak
{
U64 code;
U64 user_data;
};
#define DEMON_W32_INJECTED_CODE_SIZE 32
typedef struct DEMON_W32_ImageInfo DEMON_W32_ImageInfo;
struct DEMON_W32_ImageInfo
{
Architecture arch;
U32 size;
};
typedef struct DEMON_W32_EntityNode DEMON_W32_EntityNode;
struct DEMON_W32_EntityNode
{
DEMON_W32_EntityNode *next;
DEMON_Entity *entity;
};
typedef HRESULT GetThreadDescriptionFunctionType(HANDLE hThread, WCHAR **ppszThreadDescription);
////////////////////////////////
//~ NOTE(allen): Win32 Demon Exceptions
#define DEMON_W32_EXCEPTION_BREAKPOINT 0x80000003u
#define DEMON_W32_EXCEPTION_SINGLE_STEP 0x80000004u
#define DEMON_W32_EXCEPTION_LONG_JUMP 0x80000026u
#define DEMON_W32_EXCEPTION_ACCESS_VIOLATION 0xC0000005u
#define DEMON_W32_EXCEPTION_ARRAY_BOUNDS_EXCEEDED 0xC000008Cu
#define DEMON_W32_EXCEPTION_DATA_TYPE_MISALIGNMENT 0x80000002u
#define DEMON_W32_EXCEPTION_GUARD_PAGE_VIOLATION 0x80000001u
#define DEMON_W32_EXCEPTION_FLT_DENORMAL_OPERAND 0xC000008Du
#define DEMON_W32_EXCEPTION_FLT_DEVIDE_BY_ZERO 0xC000008Eu
#define DEMON_W32_EXCEPTION_FLT_INEXACT_RESULT 0xC000008Fu
#define DEMON_W32_EXCEPTION_FLT_INVALID_OPERATION 0xC0000090u
#define DEMON_W32_EXCEPTION_FLT_OVERFLOW 0xC0000091u
#define DEMON_W32_EXCEPTION_FLT_STACK_CHECK 0xC0000092u
#define DEMON_W32_EXCEPTION_FLT_UNDERFLOW 0xC0000093u
#define DEMON_W32_EXCEPTION_INT_DIVIDE_BY_ZERO 0xC0000094u
#define DEMON_W32_EXCEPTION_INT_OVERFLOW 0xC0000095u
#define DEMON_W32_EXCEPTION_PRIVILEGED_INSTRUCTION 0xC0000096u
#define DEMON_W32_EXCEPTION_ILLEGAL_INSTRUCTION 0xC000001Du
#define DEMON_W32_EXCEPTION_IN_PAGE_ERROR 0xC0000006u
#define DEMON_W32_EXCEPTION_INVALID_DISPOSITION 0xC0000026u
#define DEMON_W32_EXCEPTION_NONCONTINUABLE 0xC0000025u
#define DEMON_W32_EXCEPTION_STACK_OVERFLOW 0xC00000FDu
#define DEMON_W32_EXCEPTION_INVALID_HANDLE 0xC0000008u
#define DEMON_W32_EXCEPTION_UNWIND_CONSOLIDATE 0x80000029u
#define DEMON_W32_EXCEPTION_DLL_NOT_FOUND 0xC0000135u
#define DEMON_W32_EXCEPTION_ORDINAL_NOT_FOUND 0xC0000138u
#define DEMON_W32_EXCEPTION_ENTRY_POINT_NOT_FOUND 0xC0000139u
#define DEMON_W32_EXCEPTION_DLL_INIT_FAILED 0xC0000142u
#define DEMON_W32_EXCEPTION_CONTROL_C_EXIT 0xC000013Au
#define DEMON_W32_EXCEPTION_FLT_MULTIPLE_FAULTS 0xC00002B4u
#define DEMON_W32_EXCEPTION_FLT_MULTIPLE_TRAPS 0xC00002B5u
#define DEMON_W32_EXCEPTION_NAT_CONSUMPTION 0xC00002C9u
#define DEMON_W32_EXCEPTION_HEAP_CORRUPTION 0xC0000374u
#define DEMON_W32_EXCEPTION_STACK_BUFFER_OVERRUN 0xC0000409u
#define DEMON_W32_EXCEPTION_INVALID_CRUNTIME_PARAM 0xC0000417u
#define DEMON_W32_EXCEPTION_ASSERT_FAILURE 0xC0000420u
#define DEMON_W32_EXCEPTION_NO_MEMORY 0xC0000017u
#define DEMON_W32_EXCEPTION_THROW 0xE06D7363u
#define DEMON_W32_EXCEPTION_SET_THREAD_NAME 0x406d1388u
////////////////////////////////
//~ NOTE(allen): Win32 Demon Register API Codes
#define DEMON_W32_CTX_X86 0x00010000
#define DEMON_W32_CTX_X64 0x00100000
#define DEMON_W32_CTX_INTEL_CONTROL 0x0001
#define DEMON_W32_CTX_INTEL_INTEGER 0x0002
#define DEMON_W32_CTX_INTEL_SEGMENTS 0x0004
#define DEMON_W32_CTX_INTEL_FLOATS 0x0008
#define DEMON_W32_CTX_INTEL_DEBUG 0x0010
#define DEMON_W32_CTX_INTEL_EXTENDED 0x0020
#define DEMON_W32_CTX_INTEL_XSTATE 0x0040
#define DEMON_W32_CTX_X86_ALL (DEMON_W32_CTX_X86 | \
DEMON_W32_CTX_INTEL_CONTROL | DEMON_W32_CTX_INTEL_INTEGER | \
DEMON_W32_CTX_INTEL_SEGMENTS | DEMON_W32_CTX_INTEL_DEBUG | \
DEMON_W32_CTX_INTEL_EXTENDED)
#define DEMON_W32_CTX_X64_ALL (DEMON_W32_CTX_X64 | \
DEMON_W32_CTX_INTEL_CONTROL | DEMON_W32_CTX_INTEL_INTEGER | \
DEMON_W32_CTX_INTEL_SEGMENTS | DEMON_W32_CTX_INTEL_FLOATS | \
DEMON_W32_CTX_INTEL_DEBUG)
////////////////////////////////
//~ rjf: DOS Header Types
// this is the "MZ" as a 16-bit short
#define DEMON_DOS_MAGIC 0x5a4d
#pragma pack(push,1)
typedef struct DEMON_DosHeader DEMON_DosHeader;
struct DEMON_DosHeader
{
U16 magic;
U16 last_page_size;
U16 page_count;
U16 reloc_count;
U16 paragraph_header_size;
U16 min_paragraph;
U16 max_paragraph;
U16 init_ss;
U16 init_sp;
U16 checksum;
U16 init_ip;
U16 init_cs;
U16 reloc_table_file_off;
U16 overlay_number;
U16 reserved[4];
U16 oem_id;
U16 oem_info;
U16 reserved2[10];
U32 coff_file_offset;
};
#pragma pack(pop)
////////////////////////////////
//~ rjf: Coff Header Types
#define DEMON_PE_MAGIC 0x00004550u
typedef U16 DEMON_CoffMachineType;
enum{
DEMON_CoffMachineType_UNKNOWN = 0x0,
DEMON_CoffMachineType_X86 = 0x14c,
DEMON_CoffMachineType_X64 = 0x8664,
DEMON_CoffMachineType_ARM33 = 0x1d3,
DEMON_CoffMachineType_ARM = 0x1c0,
DEMON_CoffMachineType_ARM64 = 0xaa64,
DEMON_CoffMachineType_ARMNT = 0x1c4,
DEMON_CoffMachineType_EBC = 0xebc,
DEMON_CoffMachineType_IA64 = 0x200,
DEMON_CoffMachineType_M32R = 0x9041,
DEMON_CoffMachineType_MIPS16 = 0x266,
DEMON_CoffMachineType_MIPSFPU = 0x366,
DEMON_CoffMachineType_MIPSFPU16 = 0x466,
DEMON_CoffMachineType_POWERPC = 0x1f0,
DEMON_CoffMachineType_POWERPCFP = 0x1f1,
DEMON_CoffMachineType_R4000 = 0x166,
DEMON_CoffMachineType_RISCV32 = 0x5032,
DEMON_CoffMachineType_RISCV64 = 0x5064,
DEMON_CoffMachineType_RISCV128 = 0x5128,
DEMON_CoffMachineType_SH3 = 0x1a2,
DEMON_CoffMachineType_SH3DSP = 0x1a3,
DEMON_CoffMachineType_SH4 = 0x1a6,
DEMON_CoffMachineType_SH5 = 0x1a8,
DEMON_CoffMachineType_THUMB = 0x1c2,
DEMON_CoffMachineType_WCEMIPSV2 = 0x169,
DEMON_CoffMachineType_COUNT = 25
};
typedef U16 DEMON_CoffFlags;
enum{
DEMON_CoffFlag_RELOC_STRIPPED = (1 << 0),
DEMON_CoffFlag_EXECUTABLE_IMAGE = (1 << 1),
DEMON_CoffFlag_LINE_NUMS_STRIPPED = (1 << 2),
DEMON_CoffFlag_SYM_STRIPPED = (1 << 3),
DEMON_CoffFlag_RESERVED_0 = (1 << 4),
DEMON_CoffFlag_LARGE_ADDRESS_AWARE = (1 << 5),
DEMON_CoffFlag_RESERVED_1 = (1 << 6),
DEMON_CoffFlag_RESERVED_2 = (1 << 7),
DEMON_CoffFlag_32BIT_MACHINE = (1 << 8),
DEMON_CoffFlag_DEBUG_STRIPPED = (1 << 9),
DEMON_CoffFlag_REMOVABLE_RUN_FROM_SWAP = (1 << 10),
DEMON_CoffFlag_NET_RUN_FROM_SWAP = (1 << 11),
DEMON_CoffFlag_SYSTEM = (1 << 12),
DEMON_CoffFlag_DLL = (1 << 13),
DEMON_CoffFlag_UP_SYSTEM_ONLY = (1 << 14),
DEMON_CoffFlag_BYTES_RESERVED_HI = (1 << 15),
};
#pragma pack(push,1)
typedef struct DEMON_CoffHeader DEMON_CoffHeader;
struct DEMON_CoffHeader
{
DEMON_CoffMachineType machine;
U16 section_count;
U32 time_date_stamp;
// TODO: rename to "unix_timestamp"
U32 pointer_to_symbol_table;
U32 number_of_symbols;
// TODO: rename to "symbol_count"
U16 size_of_optional_header;
// TODO: rename to "optional_header_size"
DEMON_CoffFlags flags;
};
#pragma pack(pop)
////////////////////////////////
//~ rjf: PE Header Types
#pragma pack(push, 1)
typedef U16 DEMON_PeWindowsSubsystem;
enum{
DEMON_PeWindowsSubsystem_UNKNOWN = 0,
DEMON_PeWindowsSubsystem_NATIVE = 1,
DEMON_PeWindowsSubsystem_WINDOWS_GUI = 2,
DEMON_PeWindowsSubsystem_WINDOWS_CUI = 3,
DEMON_PeWindowsSubsystem_OS2_CUI = 5,
DEMON_PeWindowsSubsystem_POSIX_CUI = 7,
DEMON_PeWindowsSubsystem_NATIVE_WINDOWS = 8,
DEMON_PeWindowsSubsystem_WINDOWS_CE_GUI = 9,
DEMON_PeWindowsSubsystem_EFI_APPLICATION = 10,
DEMON_PeWindowsSubsystem_EFI_BOOT_SERVICE_DRIVER = 11,
DEMON_PeWindowsSubsystem_EFI_RUNTIME_DRIVER = 12,
DEMON_PeWindowsSubsystem_EFI_ROM = 13,
DEMON_PeWindowsSubsystem_XBOX = 14,
DEMON_PeWindowsSubsystem_WINDOWS_BOOT_APPLICATION = 16,
DEMON_PeWindowsSubsystem_COUNT = 14
};
typedef U16 DEMON_DllCharacteristics;
enum{
DEMON_DllCharacteristic_HIGH_ENTROPY_VA = (1 << 5),
DEMON_DllCharacteristic_DYNAMIC_BASE = (1 << 6),
DEMON_DllCharacteristic_FORCE_INTEGRITY = (1 << 7),
DEMON_DllCharacteristic_NX_COMPAT = (1 << 8),
DEMON_DllCharacteristic_NO_ISOLATION = (1 << 9),
DEMON_DllCharacteristic_NO_SEH = (1 << 10),
DEMON_DllCharacteristic_NO_BIND = (1 << 11),
DEMON_DllCharacteristic_APPCONTAINER = (1 << 12),
DEMON_DllCharacteristic_WDM_DRIVER = (1 << 13),
DEMON_DllCharacteristic_GUARD_CF = (1 << 14),
DEMON_DllCharacteristic_TERMINAL_SERVER_AWARE = (1 << 15),
};
typedef struct DEMON_PeOptionalHeader32 DEMON_PeOptionalHeader32;
struct DEMON_PeOptionalHeader32
{
U16 magic;
U8 major_linker_version;
U8 minor_linker_version;
U32 sizeof_code;
U32 sizeof_inited_data;
U32 sizeof_uninited_data;
U32 entry_point_va;
U32 code_base;
U32 data_base;
U32 image_base;
U32 section_alignment;
U32 file_alignment;
U16 major_os_ver;
U16 minor_os_ver;
U16 major_img_ver;
U16 minor_img_ver;
U16 major_subsystem_ver;
U16 minor_subsystem_ver;
U32 win32_version_value;
U32 sizeof_image;
U32 sizeof_headers;
U32 check_sum;
DEMON_PeWindowsSubsystem subsystem;
DEMON_DllCharacteristics dll_characteristics;
U32 sizeof_stack_reserve;
U32 sizeof_stack_commit;
U32 sizeof_heap_reserve;
U32 sizeof_heap_commit;
U32 loader_flags;
U32 data_dir_count;
};
typedef struct DEMON_PeOptionalHeader32Plus DEMON_PeOptionalHeader32Plus;
struct DEMON_PeOptionalHeader32Plus
{
U16 magic;
U8 major_linker_version;
U8 minor_linker_version;
U32 sizeof_code;
U32 sizeof_inited_data;
U32 sizeof_uninited_data;
U32 entry_point_va;
U32 code_base;
U64 image_base;
U32 section_alignment;
U32 file_alignment;
U16 major_os_ver;
U16 minor_os_ver;
U16 major_img_ver;
U16 minor_img_ver;
U16 major_subsystem_ver;
U16 minor_subsystem_ver;
U32 win32_version_value;
U32 sizeof_image;
U32 sizeof_headers;
U32 check_sum;
DEMON_PeWindowsSubsystem subsystem;
DEMON_DllCharacteristics dll_characteristics;
U64 sizeof_stack_reserve;
U64 sizeof_stack_commit;
U64 sizeof_heap_reserve;
U64 sizeof_heap_commit;
U32 loader_flags;
U32 data_dir_count;
};
#pragma pack(pop)
////////////////////////////////
//~ rjf: Helpers
internal U64 demon_w32_hash_from_string(String8 string);
internal DEMON_W32_Ext* demon_w32_ext_alloc(void);
internal DEMON_W32_Ext* demon_w32_ext(DEMON_Entity *entity);
internal U64 demon_w32_read_memory(HANDLE process_handle, void *dst, U64 src_address, U64 size);
internal B32 demon_w32_write_memory(HANDLE process_handle, U64 dst_address, void *src, U64 size);
internal String8 demon_w32_read_memory_str(Arena *arena, HANDLE process_handle, U64 address);
internal String16 demon_w32_read_memory_str16(Arena *arena, HANDLE process_handle, U64 address);
#define demon_w32_read_struct(h,dst,src) demon_w32_read_memory((h), (dst), (src), sizeof(*(dst)))
internal DEMON_W32_ImageInfo demon_w32_image_info_from_base(HANDLE process_handle, U64 base);
internal DWORD demon_w32_inject_thread(DEMON_Entity *process, U64 start_address);
internal U16 demon_w32_real_tag_word_from_xsave(XSAVE_FORMAT *fxsave);
internal U16 demon_w32_xsave_tag_word_from_real_tag_word(U16 ftw);
internal DWORD demon_w32_win32_from_memory_protect_flags(DEMON_MemoryProtectFlags flags);
////////////////////////////////
//~ rjf: Experiments
internal void demon_w32_peak_at_tls(DEMON_Handle handle);
#endif //DEMON_OS_WIN32_H
+1579 -857
View File
File diff suppressed because it is too large Load Diff
+244 -106
View File
@@ -77,6 +77,7 @@ struct DF_CtrlCtx
{
DF_Handle thread;
U64 unwind_count;
U64 inline_unwind_count;
};
////////////////////////////////
@@ -87,8 +88,8 @@ enum
{
DF_EntityKindFlag_LeafMutationUserConfig = (1<<0),
DF_EntityKindFlag_TreeMutationUserConfig = (1<<1),
DF_EntityKindFlag_LeafMutationProfileConfig= (1<<2),
DF_EntityKindFlag_TreeMutationProfileConfig= (1<<3),
DF_EntityKindFlag_LeafMutationProjectConfig= (1<<2),
DF_EntityKindFlag_TreeMutationProjectConfig= (1<<3),
DF_EntityKindFlag_LeafMutationSoftHalt = (1<<4),
DF_EntityKindFlag_TreeMutationSoftHalt = (1<<5),
DF_EntityKindFlag_LeafMutationDebugInfoMap = (1<<6),
@@ -222,7 +223,7 @@ typedef struct DF_CtrlFlowPointNode DF_CtrlFlowPointNode;
struct DF_CtrlFlowPointNode
{
DF_CtrlFlowPointNode *next;
DF_CtrlFlowPoint point;
DF_CtrlFlowPoint v;
};
typedef struct DF_CtrlFlowPointList DF_CtrlFlowPointList;
@@ -265,10 +266,15 @@ struct DF_Eval
////////////////////////////////
//~ rjf: View Rule Hook Types
#define DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_SIG(name) DF_Eval name(Arena *arena, DBGI_Scope *dbgi_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_Eval eval, struct DF_CfgVal *val)
typedef struct DF_CfgNode DF_CfgNode;
typedef struct DF_CfgVal DF_CfgVal;
typedef struct DF_CfgTable DF_CfgTable;
typedef struct DF_EvalView DF_EvalView;
typedef struct DF_EvalVizBlockList DF_EvalVizBlockList;
#define DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_SIG(name) DF_Eval name(Arena *arena, DI_Scope *di_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_Eval eval, DF_CfgVal *val)
#define DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME(name) df_core_view_rule_eval_resolution__##name
#define DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_DEF(name) internal DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_SIG(DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME(name))
#define DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_SIG(name) void name(Arena *arena, DBGI_Scope *dbgi_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, struct DF_EvalView *eval_view, DF_Eval eval, struct DF_CfgTable *cfg_table, DF_ExpandKey parent_key, DF_ExpandKey key, S32 depth, struct DF_CfgNode *cfg, struct DF_EvalVizBlockList *out)
#define DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_SIG(name) void name(Arena *arena, DI_Scope *di_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_EvalView *eval_view, DF_Eval eval, String8 string, DF_CfgTable *cfg_table, DF_ExpandKey parent_key, DF_ExpandKey key, S32 depth, DF_CfgNode *cfg, struct DF_EvalVizBlockList *out)
#define DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(name) df_core_view_rule_viz_block_prod__##name
#define DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(name) internal DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_SIG(DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(name))
typedef DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_SIG(DF_CoreViewRuleEvalResolutionHookFunctionType);
@@ -354,6 +360,7 @@ struct DF_CoreViewRuleSpecInfo
{
String8 string;
String8 display_string;
String8 schema;
String8 description;
DF_CoreViewRuleSpecInfoFlags flags;
DF_CoreViewRuleEvalResolutionHookFunctionType *eval_resolution;
@@ -377,8 +384,6 @@ struct DF_CoreViewRuleSpec
////////////////////////////////
//~ rjf: Entity Types
typedef U32 DF_EntitySubKind;
typedef U32 DF_EntityFlags;
enum
{
@@ -426,10 +431,10 @@ struct DF_Entity
// rjf: metadata
DF_EntityKind kind;
DF_EntitySubKind subkind;
DF_EntityFlags flags;
DF_EntityID id;
U64 generation;
U64 alloc_time_us;
B32 deleted;
F32 alive_t;
@@ -446,7 +451,7 @@ struct DF_Entity
// rjf: ctrl entity equipment
CTRL_MachineID ctrl_machine_id;
CTRL_Handle ctrl_handle;
DMN_Handle ctrl_handle;
Architecture arch;
U32 ctrl_id;
U64 stack_base;
@@ -510,21 +515,85 @@ struct DF_EntityFuzzyItemArray
};
////////////////////////////////
//~ rjf: Text Slices (output type from data which can be used to produce readable text)
//~ rjf: Rich (Including Inline) Unwind Types
//- rjf: text slice construction flags
typedef U32 DF_TextSliceFlags;
enum
typedef struct DF_UnwindFrame DF_UnwindFrame;
struct DF_UnwindFrame
{
DF_TextSliceFlag_CodeBytes = (1<<0),
DF_TextSliceFlag_Addresses = (1<<1),
DF_TextSliceFlag_Tokens = (1<<2),
DF_TextSliceFlag_Src2Dasm = (1<<3),
DF_TextSliceFlag_Dasm2Src = (1<<4),
DF_TextSliceFlag_VirtualOff= (1<<5),
void *regs;
RDI_Parsed *rdi;
RDI_Procedure *procedure;
RDI_InlineSite *inline_site;
U64 base_unwind_idx;
U64 inline_unwind_idx;
};
typedef struct DF_UnwindFrameNode DF_UnwindFrameNode;
struct DF_UnwindFrameNode
{
DF_UnwindFrameNode *next;
DF_UnwindFrame v;
};
typedef struct DF_UnwindFrameList DF_UnwindFrameList;
struct DF_UnwindFrameList
{
DF_UnwindFrameNode *first;
DF_UnwindFrameNode *last;
U64 count;
};
typedef struct DF_UnwindFrameArray DF_UnwindFrameArray;
struct DF_UnwindFrameArray
{
DF_UnwindFrame *v;
U64 count;
};
typedef struct DF_Unwind DF_Unwind;
struct DF_Unwind
{
DF_UnwindFrameArray frames;
};
////////////////////////////////
//~ rjf: Line Info Types
typedef struct DF_Line DF_Line;
struct DF_Line
{
DF_Handle file;
TxtPt pt;
Rng1U64 voff_range;
DI_Key dbgi_key;
};
typedef struct DF_LineNode DF_LineNode;
struct DF_LineNode
{
DF_LineNode *next;
DF_Line v;
};
typedef struct DF_LineList DF_LineList;
struct DF_LineList
{
DF_LineNode *first;
DF_LineNode *last;
U64 count;
};
typedef struct DF_LineListArray DF_LineListArray;
struct DF_LineListArray
{
DF_LineList *v;
U64 count;
DI_KeyList dbgi_keys;
};
////////////////////////////////
//~ rjf: Source <-> Disasm Types
//- rjf: debug info for mapping src -> disasm
typedef struct DF_TextLineSrc2DasmInfo DF_TextLineSrc2DasmInfo;
@@ -532,7 +601,7 @@ struct DF_TextLineSrc2DasmInfo
{
Rng1U64 voff_range;
S64 remap_line;
DF_Entity *binary;
DI_Key dbgi_key;
};
typedef struct DF_TextLineSrc2DasmInfoNode DF_TextLineSrc2DasmInfoNode;
@@ -554,7 +623,7 @@ typedef struct DF_TextLineSrc2DasmInfoListArray DF_TextLineSrc2DasmInfoListArray
struct DF_TextLineSrc2DasmInfoListArray
{
DF_TextLineSrc2DasmInfoList *v;
DF_EntityList binaries;
DI_KeyList dbgi_keys;
U64 count;
};
@@ -563,7 +632,7 @@ struct DF_TextLineSrc2DasmInfoListArray
typedef struct DF_TextLineDasm2SrcInfo DF_TextLineDasm2SrcInfo;
struct DF_TextLineDasm2SrcInfo
{
DF_Entity *binary;
DI_Key dbgi_key;
DF_Entity *file;
TxtPt pt;
Rng1U64 voff_range;
@@ -584,6 +653,38 @@ struct DF_TextLineDasm2SrcInfoList
U64 count;
};
////////////////////////////////
//~ rjf: Interaction Context Register Types
typedef struct DF_InteractRegs DF_InteractRegs;
struct DF_InteractRegs
{
DF_Handle module;
DF_Handle process;
DF_Handle thread;
U64 unwind_count;
U64 inline_unwind_count;
DF_Handle window;
DF_Handle panel;
DF_Handle view;
DF_Handle file;
TxtPt cursor;
TxtPt mark;
U128 text_key;
TXT_LangKind lang_kind;
Rng1U64 vaddr_range;
Rng1U64 voff_range;
DF_LineList lines;
DI_Key dbgi_key;
};
typedef struct DF_InteractRegsNode DF_InteractRegsNode;
struct DF_InteractRegsNode
{
DF_InteractRegsNode *next;
DF_InteractRegs v;
};
////////////////////////////////
//~ rjf: Evaluation Visualization Types
@@ -719,8 +820,8 @@ struct DF_EvalVizBlock
// rjf: info about ranges that this block spans
Rng1U64 visual_idx_range;
Rng1U64 semantic_idx_range;
DBGI_FuzzySearchTarget dbgi_target;
DBGI_FuzzySearchItemArray backing_search_items;
FZY_Target fzy_target;
FZY_ItemArray fzy_backing_items;
// rjf: visualization config extensions
DF_CfgTable cfg_table;
@@ -786,7 +887,8 @@ struct DF_EvalVizRow
DF_Eval eval;
// rjf: basic visualization contents
String8 expr;
String8 display_expr;
String8 edit_expr;
String8 display_value;
String8 edit_value;
TG_KeyList inherited_type_key_chain;
@@ -931,30 +1033,58 @@ struct DF_EntityListCache
DF_EntityList list;
};
//- rjf: per-run unwind cache
//- rjf: auto view rules hash table cache
typedef struct DF_RunUnwindCacheNode DF_RunUnwindCacheNode;
struct DF_RunUnwindCacheNode
typedef struct DF_AutoViewRuleNode DF_AutoViewRuleNode;
struct DF_AutoViewRuleNode
{
DF_RunUnwindCacheNode *hash_next;
DF_Handle thread;
CTRL_Unwind unwind;
U64 tls_base_vaddr;
DF_AutoViewRuleNode *next;
String8 type;
String8 view_rule;
};
typedef struct DF_RunUnwindCacheSlot DF_RunUnwindCacheSlot;
struct DF_RunUnwindCacheSlot
typedef struct DF_AutoViewRuleSlot DF_AutoViewRuleSlot;
struct DF_AutoViewRuleSlot
{
DF_RunUnwindCacheNode *first;
DF_RunUnwindCacheNode *last;
DF_AutoViewRuleNode *first;
DF_AutoViewRuleNode *last;
};
typedef struct DF_RunUnwindCache DF_RunUnwindCache;
struct DF_RunUnwindCache
typedef struct DF_AutoViewRuleMapCache DF_AutoViewRuleMapCache;
struct DF_AutoViewRuleMapCache
{
Arena *arena;
U64 table_size;
DF_RunUnwindCacheSlot *table;
U64 slots_count;
DF_AutoViewRuleSlot *slots;
};
//- rjf: per-thread unwind cache
typedef struct DF_UnwindCacheNode DF_UnwindCacheNode;
struct DF_UnwindCacheNode
{
DF_UnwindCacheNode *next;
DF_UnwindCacheNode *prev;
U64 reggen;
U64 memgen;
Arena *arena;
DF_Handle thread;
CTRL_Unwind unwind;
};
typedef struct DF_UnwindCacheSlot DF_UnwindCacheSlot;
struct DF_UnwindCacheSlot
{
DF_UnwindCacheNode *first;
DF_UnwindCacheNode *last;
};
typedef struct DF_UnwindCache DF_UnwindCache;
struct DF_UnwindCache
{
U64 slots_count;
DF_UnwindCacheSlot *slots;
DF_UnwindCacheNode *free_node;
};
//- rjf: per-run tls-base-vaddr cache
@@ -990,7 +1120,7 @@ typedef struct DF_RunLocalsCacheNode DF_RunLocalsCacheNode;
struct DF_RunLocalsCacheNode
{
DF_RunLocalsCacheNode *hash_next;
DF_Handle binary;
DI_Key dbgi_key;
U64 voff;
EVAL_String2NumMap *locals_map;
};
@@ -1104,10 +1234,18 @@ struct DF_State
F32 dt;
F32 seconds_til_autosave;
// rjf: interaction registers
Arena *frame_arenas[2];
DF_InteractRegsNode base_interact_regs;
DF_InteractRegsNode *top_interact_regs;
// rjf: top-level command batch
Arena *root_cmd_arena;
DF_CmdList root_cmds;
// rjf: output log key
U128 output_log_key;
// rjf: history cache
DF_StateDeltaHistory *hist;
@@ -1129,20 +1267,20 @@ struct DF_State
// rjf: entity query caches
U64 kind_alloc_gens[DF_EntityKind_COUNT];
DF_EntityListCache kind_caches[DF_EntityKind_COUNT];
DF_EntityListCache dbg_info_cache;
DF_EntityListCache bin_file_cache;
DF_AutoViewRuleMapCache auto_view_rule_cache;
// rjf: per-run caches
U64 unwind_cache_reggen_idx;
U64 unwind_cache_memgen_idx;
DF_RunUnwindCache unwind_cache;
DF_UnwindCache unwind_cache;
U64 tls_base_cache_reggen_idx;
U64 tls_base_cache_memgen_idx;
DF_RunTLSBaseCache tls_base_cache;
DF_RunTLSBaseCache tls_base_caches[2];
U64 tls_base_cache_gen;
U64 locals_cache_reggen_idx;
DF_RunLocalsCache locals_cache;
DF_RunLocalsCache locals_caches[2];
U64 locals_cache_gen;
U64 member_cache_reggen_idx;
DF_RunLocalsCache member_cache;
DF_RunLocalsCache member_caches[2];
U64 member_cache_gen;
// rjf: eval view cache
DF_EvalViewCache eval_view_cache;
@@ -1168,6 +1306,7 @@ struct DF_State
DF_RunKind ctrl_last_run_kind;
U64 ctrl_last_run_frame_idx;
DF_Handle ctrl_last_run_thread;
CTRL_RunFlags ctrl_last_run_flags;
CTRL_TrapList ctrl_last_run_traps;
U64 ctrl_run_gen;
B32 ctrl_is_running;
@@ -1175,9 +1314,9 @@ struct DF_State
Arena *ctrl_msg_arena;
CTRL_MsgList ctrl_msgs;
U64 ctrl_exception_code_filters[(CTRL_ExceptionCodeKind_COUNT+63)/64];
B32 ctrl_solo_stepping_mode;
// rjf: control thread ctrl -> user reading state
CTRL_EntityStore *ctrl_entity_store;
Arena *ctrl_stop_arena;
CTRL_Event ctrl_last_stop_event;
@@ -1249,8 +1388,7 @@ read_only global DF_Entity df_g_nil_entity =
0,
// rjf: name equipment
0,
zero_struct,
{0},
0,
// rjf: timestamp
@@ -1299,7 +1437,6 @@ internal B32 df_expand_key_match(DF_ExpandKey a, DF_ExpandKey b);
//- rjf: table
internal void df_expand_tree_table_init(Arena *arena, DF_ExpandTreeTable *table, U64 slot_count);
internal void df_expand_tree_table_animate(DF_ExpandTreeTable *table, F32 dt);
internal DF_ExpandNode *df_expand_node_from_key(DF_ExpandTreeTable *table, DF_ExpandKey key);
internal B32 df_expand_key_is_set(DF_ExpandTreeTable *table, DF_ExpandKey key);
internal void df_expand_set_expansion(Arena *arena, DF_ExpandTreeTable *table, DF_ExpandKey parent_key, DF_ExpandKey key, B32 expanded);
@@ -1325,6 +1462,11 @@ internal String8 df_string_from_cfg_node_key(DF_CfgNode *node, String8 key, Stri
internal DF_Inst df_single_inst_from_machine_code__x64(Arena *arena, U64 start_voff, String8 string);
internal DF_Inst df_single_inst_from_machine_code(Arena *arena, Architecture arch, U64 start_voff, String8 string);
////////////////////////////////
//~ rjf: Debug Info Extraction Type Pure Functions
internal DF_LineList df_line_list_copy(Arena *arena, DF_LineList *list);
////////////////////////////////
//~ rjf: Control Flow Analysis Pure Functions
@@ -1393,12 +1535,6 @@ internal DF_EntityArray df_entity_array_from_list(Arena *arena, DF_EntityList *l
internal DF_EntityFuzzyItemArray df_entity_fuzzy_item_array_from_entity_list_needle(Arena *arena, DF_EntityList *list, String8 needle);
internal DF_EntityFuzzyItemArray df_entity_fuzzy_item_array_from_entity_array_needle(Arena *arena, DF_EntityArray *array, String8 needle);
//- rjf: entity -> text info
internal TXTI_Handle df_txti_handle_from_entity(DF_Entity *entity);
//- rjf: entity -> disasm info
internal DASM_Handle df_dasm_handle_from_process_vaddr(DF_Entity *process, U64 vaddr);
//- rjf: full path building, from file/folder entities
internal String8 df_full_path_from_entity(Arena *arena, DF_Entity *entity);
@@ -1442,10 +1578,11 @@ internal void df_entity_equip_color_rgba(DF_Entity *entity, Vec4F32 rgba);
internal void df_entity_equip_color_hsva(DF_Entity *entity, Vec4F32 hsva);
internal void df_entity_equip_death_timer(DF_Entity *entity, F32 seconds_til_death);
internal void df_entity_equip_cfg_src(DF_Entity *entity, DF_CfgSrc cfg_src);
internal void df_entity_equip_timestamp(DF_Entity *entity, U64 timestamp);
//- rjf: control layer correllation equipment
internal void df_entity_equip_ctrl_machine_id(DF_Entity *entity, CTRL_MachineID machine_id);
internal void df_entity_equip_ctrl_handle(DF_Entity *entity, CTRL_Handle handle);
internal void df_entity_equip_ctrl_handle(DF_Entity *entity, DMN_Handle handle);
internal void df_entity_equip_arch(DF_Entity *entity, Architecture arch);
internal void df_entity_equip_ctrl_id(DF_Entity *entity, U32 id);
internal void df_entity_equip_stack_base(DF_Entity *entity, U64 stack_base);
@@ -1466,7 +1603,7 @@ internal DF_Entity *df_entity_root(void);
internal DF_EntityList df_push_entity_list_with_kind(Arena *arena, DF_EntityKind kind);
internal DF_Entity *df_entity_from_id(DF_EntityID id);
internal DF_Entity *df_machine_entity_from_machine_id(CTRL_MachineID machine_id);
internal DF_Entity *df_entity_from_ctrl_handle(CTRL_MachineID machine_id, CTRL_Handle handle);
internal DF_Entity *df_entity_from_ctrl_handle(CTRL_MachineID machine_id, DMN_Handle handle);
internal DF_Entity *df_entity_from_ctrl_id(CTRL_MachineID machine_id, U32 id);
internal DF_Entity *df_entity_from_name_and_kind(String8 string, DF_EntityKind kind);
internal DF_Entity *df_entity_from_u64_and_kind(U64 u64, DF_EntityKind kind);
@@ -1490,11 +1627,6 @@ internal DF_CmdSpecList df_push_cmd_spec_list(Arena *arena);
internal void df_register_core_view_rule_specs(DF_CoreViewRuleSpecInfoArray specs);
internal DF_CoreViewRuleSpec *df_core_view_rule_spec_from_string(String8 string);
////////////////////////////////
//~ rjf: Debug Info Mapping
internal String8 df_debug_info_path_from_module(Arena *arena, DF_Entity *module);
////////////////////////////////
//~ rjf: Stepping "Trap Net" Builders
@@ -1505,9 +1637,9 @@ internal CTRL_TrapList df_trap_net_from_thread__step_into_line(Arena *arena, DF_
////////////////////////////////
//~ rjf: Modules & Debug Info Mappings
//- rjf: module <=> binary file
internal DF_Entity *df_binary_file_from_module(DF_Entity *module);
internal DF_EntityList df_modules_from_binary_file(Arena *arena, DF_Entity *binary_info);
//- rjf: module <=> debug info keys
internal DI_Key df_dbgi_key_from_module(DF_Entity *module);
internal DF_EntityList df_modules_from_dbgi_key(Arena *arena, DI_Key *dbgi_key);
//- rjf: voff <=> vaddr
internal U64 df_base_vaddr_from_module(DF_Entity *module);
@@ -1519,39 +1651,37 @@ internal Rng1U64 df_vaddr_range_from_voff_range(DF_Entity *module, Rng1U64 voff_
////////////////////////////////
//~ rjf: Debug Info Lookups
//- rjf: binary file -> dbgi parse
internal DBGI_Parse *df_dbgi_parse_from_binary_file(DBGI_Scope *scope, DF_Entity *binary);
//- rjf: voff|vaddr -> symbol lookups
internal String8 df_symbol_name_from_binary_voff(Arena *arena, DF_Entity *binary, U64 voff);
internal String8 df_symbol_name_from_dbgi_key_voff(Arena *arena, DI_Key *dbgi_key, U64 voff);
internal String8 df_symbol_name_from_process_vaddr(Arena *arena, DF_Entity *process, U64 vaddr);
//- rjf: symbol -> voff lookups
internal U64 df_voff_from_dbgi_key_symbol_name(DI_Key *dbgi_key, String8 symbol_name);
internal U64 df_type_num_from_dbgi_key_name(DI_Key *dbgi_key, String8 name);
//- rjf: voff -> line info
internal DF_LineList df_lines_from_dbgi_key_voff(Arena *arena, DI_Key *dbgi_key, U64 voff);
//- rjf: file:line -> line info
internal DF_LineListArray df_lines_array_from_file_line_range(Arena *arena, DF_Entity *file, Rng1S64 line_num_range);
internal DF_LineList df_lines_from_file_line_num(Arena *arena, DF_Entity *file, S64 line_num);
//- rjf: src -> voff lookups
internal DF_TextLineSrc2DasmInfoListArray df_text_line_src2dasm_info_list_array_from_src_line_range(Arena *arena, DF_Entity *file, Rng1S64 line_num_range);
//- rjf: voff -> src lookups
internal DF_TextLineDasm2SrcInfo df_text_line_dasm2src_info_from_binary_voff(DF_Entity *binary, U64 voff);
internal DF_TextLineDasm2SrcInfoList df_text_line_dasm2src_info_from_voff(Arena *arena, U64 voff);
//- rjf: symbol -> voff lookups
internal U64 df_voff_from_binary_symbol_name(DF_Entity *binary, String8 symbol_name);
internal U64 df_type_num_from_binary_name(DF_Entity *binary, String8 name);
////////////////////////////////
//~ rjf: Process/Thread Info Lookups
//~ rjf: Process/Thread/Module Info Lookups
//- rjf: thread info extraction helpers
internal DF_Entity *df_module_from_process_vaddr(DF_Entity *process, U64 vaddr);
internal DF_Entity *df_module_from_thread(DF_Entity *thread);
internal U64 df_tls_base_vaddr_from_process_root_rip(DF_Entity *process, U64 root_vaddr, U64 rip_vaddr);
internal Architecture df_architecture_from_entity(DF_Entity *entity);
internal CTRL_Unwind df_push_unwind_from_thread(Arena *arena, DF_Entity *thread);
internal U64 df_rip_from_thread(DF_Entity *thread);
internal U64 df_rip_from_thread_unwind(DF_Entity *thread, U64 unwind_count);
internal EVAL_String2NumMap *df_push_locals_map_from_binary_voff(Arena *arena, DBGI_Scope *scope, DF_Entity *binary, U64 voff);
internal EVAL_String2NumMap *df_push_member_map_from_binary_voff(Arena *arena, DBGI_Scope *scope, DF_Entity *binary, U64 voff);
internal EVAL_String2NumMap *df_push_locals_map_from_dbgi_key_voff(Arena *arena, DI_Scope *scope, DI_Key *dbgi_key, U64 voff);
internal EVAL_String2NumMap *df_push_member_map_from_dbgi_key_voff(Arena *arena, DI_Scope *scope, DI_Key *dbgi_key, U64 voff);
internal B32 df_set_thread_rip(DF_Entity *thread, U64 vaddr);
internal DF_Entity *df_module_from_thread_candidates(DF_Entity *thread, DF_EntityList *candidates);
internal DF_Unwind df_unwind_from_ctrl_unwind(Arena *arena, DI_Scope *di_scope, DF_Entity *process, CTRL_Unwind *base_unwind);
internal DF_UnwindFrame *df_frame_from_unwind_idxs(DF_Unwind *unwind, U64 base_unwind_idx, U64 inline_unwind_idx);
////////////////////////////////
//~ rjf: Entity -> Log Entities
@@ -1565,7 +1695,7 @@ internal DF_Entity *df_log_from_entity(DF_Entity *entity);
internal void df_push_ctrl_msg(CTRL_Msg *msg);
//- rjf: control thread running
internal void df_ctrl_run(DF_RunKind run, DF_Entity *run_thread, CTRL_TrapList *run_traps);
internal void df_ctrl_run(DF_RunKind run, DF_Entity *run_thread, CTRL_RunFlags flags, CTRL_TrapList *run_traps);
//- rjf: stopped info from the control thread
internal CTRL_Event df_ctrl_last_stop_event(void);
@@ -1574,12 +1704,12 @@ internal CTRL_Event df_ctrl_last_stop_event(void);
//~ rjf: Evaluation
internal B32 df_eval_memory_read(void *u, void *out, U64 addr, U64 size);
internal EVAL_ParseCtx df_eval_parse_ctx_from_process_vaddr(DBGI_Scope *scope, DF_Entity *process, U64 vaddr);
internal EVAL_ParseCtx df_eval_parse_ctx_from_src_loc(DBGI_Scope *scope, DF_Entity *file, TxtPt pt);
internal DF_Eval df_eval_from_string(Arena *arena, DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, String8 string);
internal DF_Eval df_value_mode_eval_from_eval(TG_Graph *graph, RADDBG_Parsed *rdbg, DF_CtrlCtx *ctrl_ctx, DF_Eval eval);
internal DF_Eval df_dynamically_typed_eval_from_eval(TG_Graph *graph, RADDBG_Parsed *rdbg, DF_CtrlCtx *ctrl_ctx, DF_Eval eval);
internal DF_Eval df_eval_from_eval_cfg_table(Arena *arena, DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_Eval eval, DF_CfgTable *cfg);
internal EVAL_ParseCtx df_eval_parse_ctx_from_process_vaddr(DI_Scope *scope, DF_Entity *process, U64 vaddr);
internal EVAL_ParseCtx df_eval_parse_ctx_from_src_loc(DI_Scope *scope, DF_Entity *file, TxtPt pt);
internal DF_Eval df_eval_from_string(Arena *arena, DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, String8 string);
internal DF_Eval df_value_mode_eval_from_eval(TG_Graph *graph, RDI_Parsed *rdi, DF_CtrlCtx *ctrl_ctx, DF_Eval eval);
internal DF_Eval df_dynamically_typed_eval_from_eval(TG_Graph *graph, RDI_Parsed *rdi, DF_CtrlCtx *ctrl_ctx, DF_Eval eval);
internal DF_Eval df_eval_from_eval_cfg_table(Arena *arena, DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_Eval eval, DF_CfgTable *cfg);
////////////////////////////////
//~ rjf: Evaluation Views
@@ -1602,14 +1732,14 @@ internal String8 df_eval_view_rule_from_key(DF_EvalView *eval_view, DF_ExpandKey
//- rjf: evaluation value string builder helpers
internal String8 df_string_from_ascii_value(Arena *arena, U8 val);
internal String8 df_string_from_simple_typed_eval(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, DF_EvalVizStringFlags flags, U32 radix, DF_Eval eval);
internal String8 df_string_from_simple_typed_eval(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, DF_EvalVizStringFlags flags, U32 radix, DF_Eval eval);
//- rjf: writing values back to child processes
internal B32 df_commit_eval_value(TG_Graph *graph, RADDBG_Parsed *rdbg, DF_CtrlCtx *ctrl_ctx, DF_Eval dst_eval, DF_Eval src_eval);
internal B32 df_commit_eval_value(TG_Graph *graph, RDI_Parsed *rdi, DF_CtrlCtx *ctrl_ctx, DF_Eval dst_eval, DF_Eval src_eval);
//- rjf: type helpers
internal TG_MemberArray df_filtered_data_members_from_members_cfg_table(Arena *arena, TG_MemberArray members, DF_CfgTable *cfg);
internal DF_EvalLinkBaseChunkList df_eval_link_base_chunk_list_from_eval(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, TG_Key link_member_type_key, U64 link_member_off, DF_CtrlCtx *ctrl_ctx, DF_Eval eval, U64 cap);
internal DF_EvalLinkBaseChunkList df_eval_link_base_chunk_list_from_eval(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, TG_Key link_member_type_key, U64 link_member_off, DF_CtrlCtx *ctrl_ctx, DF_Eval eval, U64 cap);
internal DF_EvalLinkBase df_eval_link_base_from_chunk_list_index(DF_EvalLinkBaseChunkList *list, U64 idx);
internal DF_EvalLinkBaseArray df_eval_link_base_array_from_chunk_list(Arena *arena, DF_EvalLinkBaseChunkList *chunks);
@@ -1617,8 +1747,8 @@ internal DF_EvalLinkBaseArray df_eval_link_base_array_from_chunk_list(Arena *are
internal DF_EvalVizBlock *df_eval_viz_block_begin(Arena *arena, DF_EvalVizBlockKind kind, DF_ExpandKey parent_key, DF_ExpandKey key, S32 depth);
internal DF_EvalVizBlock *df_eval_viz_block_split_and_continue(Arena *arena, DF_EvalVizBlockList *list, DF_EvalVizBlock *split_block, U64 split_idx);
internal void df_eval_viz_block_end(DF_EvalVizBlockList *list, DF_EvalVizBlock *block);
internal void df_append_viz_blocks_for_parent__rec(Arena *arena, DBGI_Scope *scope, DF_EvalView *view, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_ExpandKey parent_key, DF_ExpandKey key, String8 string, DF_Eval eval, TG_Member *opt_member, DF_CfgTable *cfg_table, S32 depth, DF_EvalVizBlockList *list_out);
internal DF_EvalVizBlockList df_eval_viz_block_list_from_eval_view_expr_num(Arena *arena, DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_EvalView *eval_view, String8 expr, U64 num);
internal void df_append_viz_blocks_for_parent__rec(Arena *arena, DI_Scope *scope, DF_EvalView *view, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_ExpandKey parent_key, DF_ExpandKey key, String8 string, DF_Eval eval, TG_Member *opt_member, DF_CfgTable *cfg_table, S32 depth, DF_EvalVizBlockList *list_out);
internal DF_EvalVizBlockList df_eval_viz_block_list_from_eval_view_expr_keys(Arena *arena, DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_EvalView *eval_view, String8 expr, DF_ExpandKey parent_key, DF_ExpandKey key);
internal void df_eval_viz_block_list_concat__in_place(DF_EvalVizBlockList *dst, DF_EvalVizBlockList *to_push);
//- rjf: viz block list <-> table coordinates
@@ -1632,11 +1762,17 @@ internal DF_EvalVizRow *df_eval_viz_row_list_push_new(Arena *arena, EVAL_ParseCt
////////////////////////////////
//~ rjf: Main State Accessors/Mutators
//- rjf: frame metadata
//- rjf: frame data
internal F32 df_dt(void);
internal U64 df_frame_index(void);
internal Arena *df_frame_arena(void);
internal F64 df_time_in_seconds(void);
//- rjf: interaction registers
internal DF_InteractRegs *df_interact_regs(void);
internal DF_InteractRegs *df_push_interact_regs(void);
internal DF_InteractRegs *df_pop_interact_regs(void);
//- rjf: undo/redo history
internal DF_StateDeltaHistory *df_state_delta_history(void);
@@ -1671,7 +1807,9 @@ internal String8 df_info_summary_from_string(Architecture arch, String8 string);
//- rjf: entity kind cache
internal DF_EntityList df_query_cached_entity_list_with_kind(DF_EntityKind kind);
internal DF_EntityList df_push_active_binary_list(Arena *arena);
//- rjf: active entity based queries
internal DI_KeyList df_push_active_dbgi_key_list(Arena *arena);
internal DF_EntityList df_push_active_target_list(Arena *arena);
//- rjf: per-run caches
@@ -1679,8 +1817,8 @@ internal CTRL_Unwind df_query_cached_unwind_from_thread(DF_Entity *thread);
internal U64 df_query_cached_rip_from_thread(DF_Entity *thread);
internal U64 df_query_cached_rip_from_thread_unwind(DF_Entity *thread, U64 unwind_count);
internal U64 df_query_cached_tls_base_vaddr_from_process_root_rip(DF_Entity *process, U64 root_vaddr, U64 rip_vaddr);
internal EVAL_String2NumMap *df_query_cached_locals_map_from_binary_voff(DF_Entity *binary, U64 voff);
internal EVAL_String2NumMap *df_query_cached_member_map_from_binary_voff(DF_Entity *binary, U64 voff);
internal EVAL_String2NumMap *df_query_cached_locals_map_from_dbgi_key_voff(DI_Key *dbgi_key, U64 voff);
internal EVAL_String2NumMap *df_query_cached_member_map_from_dbgi_key_voff(DI_Key *dbgi_key, U64 voff);
//- rjf: top-level command dispatch
internal void df_push_cmd__root(DF_CmdParams *params, DF_CmdSpec *spec);
@@ -1688,7 +1826,7 @@ internal void df_push_cmd__root(DF_CmdParams *params, DF_CmdSpec *spec);
////////////////////////////////
//~ rjf: Main Layer Top-Level Calls
internal void df_core_init(String8 user_path, String8 profile_path, DF_StateDeltaHistory *hist);
internal void df_core_init(CmdLine *cmdln, DF_StateDeltaHistory *hist);
internal DF_CmdList df_core_gather_root_cmds(Arena *arena);
internal void df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt);
internal void df_core_end_frame(void);
+146 -164
View File
@@ -8,7 +8,7 @@
DF_CfgSrcTable:
{
{"user" User OpenUser WriteUserData ApplyUserData }
{"profile" Profile OpenProfile WriteProfileData ApplyProfileData }
{"project" Project OpenProject WriteProjectData ApplyProjectData }
{"command_line" CommandLine Null Null Null }
{"transient" Transient Null Null Null }
}
@@ -16,14 +16,6 @@ DF_CfgSrcTable:
////////////////////////////////
//~ rjf: Entity Kind Tables
@table(name)
DF_NameKindTable:
{
{Null}
{EntityName}
{EntityKindName}
}
@table(name name_lower op_delete op_freeze op_edit op_rename op_enable op_cond op_dup lf_mut_user_cfg tr_mut_user_cfg lf_mut_prof_cfg tr_mut_prof_cfg lf_mut_halt lf_mut_dbg tr_mut_halt tr_mut_dbg name_is_code user_lifetime name_label icon_kind display_string)
DF_EntityKindTable:
{
@@ -34,13 +26,9 @@ DF_EntityKindTable:
//- rjf: filesystem modeling
{File file 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" FileOutline "File" }
{OverrideFileLink override_file_link 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 "Label" FileOutline "Override File Link" }
{PendingFileChange pending_file_change 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" FileOutline "Pending File Change" }
//- rjf: diagnostics log
{DiagLog diag_log 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" FileOutline "Diagnostics Log" }
//- rjf: text attachments
{FlashMarker flash_marker 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Null "Flash Marker" }
//- rjf: auto view rules
{AutoViewRule auto_view_rule 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 "Label" Binoculars "Auto View Rule" }
//- rjf: watch pins
{WatchPin watch_pin 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 "Expression" Pin "Watch Pin" }
@@ -56,17 +44,19 @@ DF_EntityKindTable:
{ExecutionPath execution_path 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 "Execution Path" Null "Execution Path" }
{EntryPointName entry_point_name 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 "Symbol Name" Null "Entry Point Name" }
//- rjf: recent projects
{RecentProject recent_project 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 "Path" Briefcase "Recent Project" }
//- rjf: src -> dst mapping
{Source source 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Path" Null "Source" }
{Dest dest 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Path" Null "Destination" }
//- rjf: control system entities
{CtrlRequest ctrl_request 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Null "Control Request" }
{Process process 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Threads "Process" }
{Thread thread 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Thread "Thread" }
{Module module 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Module "Module" }
{DebugInfoOverride debug_info_override 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 "Label" Null "Debug Info Override" }
{PendingThreadName pending_thread_name 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Threads "Pending Thread Name" }
{DebugInfoPath debug_info_path 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Module "Debug Info Path" }
//- rjf: parser task entities
{ConversionTask conversion_task 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 "Label" Null "Conversion Task" }
@@ -82,24 +72,29 @@ DF_EntityKindTable:
@table(name, name_lower, c_type)
DF_CmdParamSlotTable:
{
{Window, window, `DF_Handle`}
{Panel, panel, `DF_Handle`}
{DestPanel, dest_panel, `DF_Handle`}
{PrevView, prev_view, `DF_Handle`}
{View, view, `DF_Handle`}
{Entity, entity, `DF_Handle`}
{EntityList, entity_list, `DF_HandleList`}
{String, string, `String8`}
{FilePath, file_path, `String8`}
{TextPoint, text_point, `TxtPt`}
{CmdSpec, cmd_spec, `struct DF_CmdSpec *`}
{ViewSpec, view_spec, `struct DF_ViewSpec *`}
{VirtualAddr, vaddr, `U64`}
{VirtualOff, voff, `U64`}
{Index, index, `U64`}
{ID, id, `U64`}
{PreferDisassembly, prefer_dasm, `B32`}
{ForceConfirm, force_confirm,`B32`}
{Window window `DF_Handle`}
{Panel panel `DF_Handle`}
{DestPanel dest_panel `DF_Handle`}
{PrevView prev_view `DF_Handle`}
{View view `DF_Handle`}
{Entity entity `DF_Handle`}
{EntityList entity_list `DF_HandleList`}
{String string `String8`}
{FilePath file_path `String8`}
{TextPoint text_point `TxtPt`}
{CmdSpec cmd_spec `struct DF_CmdSpec *`}
{ViewSpec view_spec `struct DF_ViewSpec *`}
{CfgNode cfg_node `struct DF_CfgNode *`}
{OSEvent os_event `struct OS_Event *`}
{VirtualAddr vaddr `U64`}
{VirtualOff voff `U64`}
{Index index `U64`}
{ID id `U64`}
{PreferDisassembly prefer_dasm `B32`}
{ForceConfirm force_confirm `B32`}
{Dir2 dir2 `Dir2`}
{BaseUnwindIndex base_unwind_index `U64`}
{InlineUnwindIndex inline_unwind_index `U64`}
}
@table(name lister_omit q_slot q_ent_kind q_allow_files q_allow_folders q_keep_oi q_select_oi q_is_code q_required canonical_icon string display_name desc search_tags )
@@ -118,6 +113,9 @@ DF_CoreCmdTable:// | | |
//- rjf: notifications
{Error 1 Null Nil 0 0 0 0 0 0 Null "error" "Error" "Notifies of an error." "" }
//- rjf: os event passthrough
{OSEvent 1 Null Nil 0 0 0 0 0 0 Null "os_event" "OS Event" "" "" }
//- rjf: low-level target control operations
{LaunchAndRun 0 EntityList Target 0 0 0 0 0 1 Play "launch_and_run" "Launch and Run" "Starts debugging a new instance of a target, then runs." "launch,start,run,target" }
{LaunchAndInit 0 EntityList Target 0 0 0 0 0 1 PlayStepForward "launch_and_init" "Launch and Initialize" "Starts debugging a new instance of a target, then stops at the program's entry point." "launch,start,entry,point" }
@@ -144,18 +142,14 @@ DF_CoreCmdTable:// | | |
{RunToCursor 0 Null Nil 0 0 0 0 0 0 Play "run_to_cursor" "Run To Cursor" "Runs the selected thread to the current cursor." "" }
{SetNextStatement 0 Null Nil 0 0 0 0 0 0 RightArrow "set_next_statement" "Set Next Statement" "Sets the selected thread's instruction pointer to the cursor's position." "" }
//- rjf: solo stepping mode
{EnableSoloSteppingMode 0 Null Nil 0 0 0 0 0 0 Thread "enable_solo_stepping_mode" "Enable Solo Stepping Mode" "Enables 'solo stepping mode', which suspends all non-selected threads before stepping." "solo,stepping,mode,suspend" }
{DisableSoloSteppingMode 0 Null Nil 0 0 0 0 0 0 Thread "disable_solo_stepping_mode" "Disable Solo Stepping Mode" "Disables 'solo stepping mode', which suspends all non-selected threads before stepping." "solo,stepping,mode,suspend" }
//- rjf: debug control context management operations
{SelectThread 0 Entity Thread 0 0 0 0 0 1 Null "select_thread" "Select Thread" "Selects a thread." "" }
{SelectThreadWindow 0 Entity Thread 0 0 0 0 0 1 Null "select_thread_window" "Select Thread On Window" "Selects a thread for the active window, overriding the global selected thread." "" }
{SelectThreadView 0 Entity Thread 0 0 0 0 0 1 Null "select_thread_view" "Select Thread On View" "Selects a thread for the active view, overriding the global and per-window selected threads." "" }
{SelectUnwind 1 Null Nil 0 0 0 0 0 0 Null "select_unwind" "Select Unwind" "Selects an unwind frame number for the selected thread." "" }
{UpOneFrame 0 Null Nil 0 0 0 0 0 0 UpArrow "up_one_frame" "Up One Frame" "Selects the callstack frame above the currently selected." "" }
{DownOneFrame 0 Null Nil 0 0 0 0 0 0 DownArrow "down_one_frame" "Down One Frame" "Selects the callstack frame below the currently selected." "" }
{FreezeThread 0 Entity Thread 0 0 0 0 0 1 Locked "freeze_thread" "Freeze Thread" "Freezes the passed thread." "" }
{UpOneFrame 0 Null Nil 0 0 0 0 0 0 UpArrow "up_one_frame" "Up One Frame" "Selects the call stack frame above the currently selected." "" }
{DownOneFrame 0 Null Nil 0 0 0 0 0 0 DownArrow "down_one_frame" "Down One Frame" "Selects the call stack frame below the currently selected." "callstack,unwind" }
{FreezeThread 0 Entity Thread 0 0 0 0 0 1 Locked "freeze_thread" "Freeze Thread" "Freezes the passed thread." "callstack,unwind" }
{ThawThread 0 Entity Thread 0 0 0 0 0 1 Unlocked "thaw_thread" "Thaw Thread" "Thaws the passed thread." "" }
{FreezeProcess 0 Entity Process 0 0 0 0 0 1 Locked "freeze_process" "Freeze Process" "Freezes the passed process." "" }
{ThawProcess 0 Entity Process 0 0 0 0 0 1 Unlocked "thaw_process" "Thaw Process" "Thaws the passed process." "" }
@@ -181,8 +175,12 @@ DF_CoreCmdTable:// | | |
//- rjf: panel splitting
{ResetToDefaultPanels 0 Null Nil 0 0 0 0 0 0 Window "reset_to_default_panels" "Reset To Default Panel Layout" "Resets the window to the default panel layout." "panel" }
{NewPanelRight 0 Null Nil 0 0 0 0 0 0 XSplit "new_panel_right" "Split Panel Vertically" "Creates a new panel to the right of the active panel." "panel" }
{NewPanelDown 0 Null Nil 0 0 0 0 0 0 YSplit "new_panel_down" "Split Panel Horizontally" "Creates a new panel at the bottom of the active panel." "panel" }
{ResetToCompactPanels 0 Null Nil 0 0 0 0 0 0 Window "reset_to_compact_panels" "Reset To Compact Panel Layout" "Resets the window to the compact panel layout." "panel" }
{NewPanelLeft 0 Null Nil 0 0 0 0 0 0 XSplit "new_panel_left" "Split Panel Left" "Creates a new panel to the left of the active panel." "panel" }
{NewPanelUp 0 Null Nil 0 0 0 0 0 0 YSplit "new_panel_up" "Split Panel Up" "Creates a new panel at the top of the active panel." "panel" }
{NewPanelRight 0 Null Nil 0 0 0 0 0 0 XSplit "new_panel_right" "Split Panel Right" "Creates a new panel to the right of the active panel." "panel" }
{NewPanelDown 0 Null Nil 0 0 0 0 0 0 YSplit "new_panel_down" "Split Panel Down" "Creates a new panel at the bottom of the active panel." "panel" }
{SplitPanel 1 Null Nil 0 0 0 0 0 0 Null "split_panel" "Split Panel" "Creates a new panel in a given direction, and moves a tab to it, if specified." "" }
//- rjf: panel rotation
{RotatePanelColumns 0 Null Nil 0 0 0 0 0 0 Null "rotate_panel_columns" "Rotate Panel Columns" "Rotates all panels at the closest column level of the panel hierarchy." "" }
@@ -221,27 +219,39 @@ DF_CoreCmdTable:// | | |
//- rjf: files
{SetCurrentPath 1 Null Nil 0 0 0 0 0 0 FileOutline "set_current_path" "Set Current Path" "Sets the debugger's current path, which is used as a starting point when browsing for files." "" }
{Open 0 FilePath Nil 1 0 0 0 0 1 FileOutline "open" "Open" "Opens a file." "code,source,file" }
{Reload 0 Entity File 0 0 0 0 0 1 FileOutline "reload" "Reload" "Reloads a loaded file." "code,source,file,reload" }
{ReloadActive 0 Null Nil 0 0 0 0 0 0 FileOutline "reload_active" "Reload Active File" "Reloads the active file." "code,source,file,reload" }
{Switch 0 Entity File 0 0 0 0 0 1 FileOutline "switch" "Switch" "Switches to a loaded file." "code,source,file" }
{SwitchToPartnerFile 0 Null Nil 0 0 0 0 0 0 FileOutline "switch_to_partner_file" "Switch To Partner File" "Switches to the focused file's partner; or from header to implementation or vice versa." "code,source,file" }
//- rjf: source <-> disasm
{GoToDisassembly 0 Null Nil 0 0 0 0 0 0 Glasses "go_to_disassembly" "Go To Disassembly" "Goes to the disassembly, if any, for a given source code line." "code,source,disassembly,disasm" }
{GoToSource 0 Null Nil 0 0 0 0 0 0 FileOutline "go_to_source" "Go To Source" "Goes to the source code, if any, for a given disassembly line." "code,source,disassembly,disasm" }
//- rjf: override file links
{SetFileOverrideLinkSrc 1 Null Nil 0 0 0 0 0 0 Null "set_file_override_link_src" "Set File Override Link Source" "Sets the source path for an override file link." "" }
{SetFileOverrideLinkDst 1 Null Nil 0 0 0 0 0 0 Null "set_file_override_link_dst" "Set File Override Link Destination" "Sets the destination path for an override file link." "" }
{SetFileReplacementPath 1 Null Nil 0 0 0 0 0 0 Null "set_file_replacement_path" "Set File Replacement Path" "Sets the path which should be used as the replacement for the passed file." "" }
//- rjf: auto view rules
{SetAutoViewRuleType 1 Null Nil 0 0 0 0 0 0 Null "set_auto_view_rule_type" "Set Auto View Rule Type" "Sets the type for an auto view rule." "" }
{SetAutoViewRuleViewRule 1 Null Nil 0 0 0 0 0 0 Null "set_auto_view_rule_view_rule""Set Auto View Rule View Rule" "Sets the view rule string for an auto view rule." "" }
//- rjf: setting config paths
{OpenUser 0 FilePath Nil 1 0 0 0 0 1 Person "open_user" "Open User" "Opens a user file path, immediately loading it, and begins autosaving to it." "load,user,profile,layout" }
{OpenProfile 0 FilePath Nil 1 0 0 0 0 1 Briefcase "open_profile" "Open Profile" "Opens a profile file path, immediately loading it, and begins autosaving to it." "profile,project,session" }
{OpenUser 0 FilePath Nil 1 0 0 0 0 1 Person "open_user" "Open User" "Opens a user file path, immediately loading it, and begins autosaving to it." "load,user,project,layout" }
{OpenProject 0 FilePath Nil 1 0 0 0 0 1 Briefcase "open_project" "Open Project" "Opens a project file path, immediately loading it, and begins autosaving to it." "project,project,session" }
{OpenRecentProject 0 Entity RecentProject 0 0 0 0 0 1 Briefcase "open_recent_project" "Open Recent Project" "Opens a recently used project file." "project,project,session" }
//- rjf: loading/applying stateful config changes
{ApplyUserData 1 Null Nil 0 0 0 0 0 0 Null "apply_user_data" "Apply User Data" "Applies user data from the active user file." "" }
{ApplyProfileData 1 Null Nil 0 0 0 0 0 0 Null "apply_profile_data" "Apply Profile Data" "Applies profile data from the active profile file." "" }
{ApplyProjectData 1 Null Nil 0 0 0 0 0 0 Null "apply_project_data" "Apply Project Data" "Applies project data from the active project file." "" }
//- rjf: writing config changes
{WriteUserData 1 Null Nil 0 0 0 0 0 0 Null "write_user_data" "Write User Data" "Writes user data to the active user file." "" }
{WriteProfileData 1 Null Nil 0 0 0 0 0 0 Null "write_profile_data" "Write Profile Data" "Writes profile data to the active profile file." "" }
{WriteProjectData 1 Null Nil 0 0 0 0 0 0 Null "write_project_data" "Write Project Data" "Writes project data to the active project file." "" }
//- rjf: meta controls
{Edit 0 Null Nil 0 0 0 0 0 0 Pencil "edit" "Edit" "Edits the current selection." "" }
{Accept 0 Null Nil 0 0 0 0 0 0 CheckFilled "accept" "Accept" "Accepts current changes, or answers prompts in the affirmative." "" }
{Cancel 0 Null Nil 0 0 0 0 0 0 X "cancel" "Cancel" "Rejects current changes, exits temporary menus, or answers prompts in the negative." "" }
//- rjf: directional movement & text controls
{MoveLeft 0 Null Nil 0 0 0 0 0 0 Null "move_left" "Move Left" "Moves the cursor or selection left." "" }
@@ -268,6 +278,8 @@ DF_CoreCmdTable:// | | |
{MoveDownPageSelect 0 Null Nil 0 0 0 0 0 0 Null "move_down_page_select" "Move Down Page Select" "Moves the cursor or selection down one page, while selecting." "" }
{MoveUpWholeSelect 0 Null Nil 0 0 0 0 0 0 Null "move_up_whole_select" "Move Up Whole Select" "Moves the cursor or selection to the beginning of the relevant content, while selecting." "" }
{MoveDownWholeSelect 0 Null Nil 0 0 0 0 0 0 Null "move_down_whole_select" "Move Down Whole Select" "Moves the cursor or selection to the end of the relevant content, while selecting." "" }
{MoveUpReorder 0 Null Nil 0 0 0 0 0 0 Null "move_up_reorder" "Move Up Reorder" "Moves the cursor or selection up, while swapping the currently selected element with that upward." "" }
{MoveDownReorder 0 Null Nil 0 0 0 0 0 0 Null "move_down_reorder" "Move Down Reorder" "Moves the cursor or selection down, while swapping the currently selected element with that downward." "" }
{MoveHome 0 Null Nil 0 0 0 0 0 0 Null "move_home" "Move Home" "Moves the cursor to the beginning of the line." "" }
{MoveEnd 0 Null Nil 0 0 0 0 0 0 Null "move_end" "Move End" "Moves the cursor to the end of the line." "" }
{MoveHomeSelect 0 Null Nil 0 0 0 0 0 0 Null "move_home_select" "Move Home Select" "Moves the cursor to the beginning of the line, while selecting." "" }
@@ -322,7 +334,7 @@ DF_CoreCmdTable:// | | |
{DuplicateEntity 1 Null Nil 0 0 0 0 0 0 Null "duplicate_entity" "Duplicate Entity" "Duplicates an entity." "" }
//- rjf: breakpoints
{TextBreakpoint 1 Null Nil 0 0 0 0 0 0 CircleFilled "text_breakpoint" "Text Breakpoint" "Places or removes a breakpoint on the specified line of source code." "" }
{TextBreakpoint 1 FilePath Nil 0 0 0 0 0 0 CircleFilled "text_breakpoint" "Text Breakpoint" "Places or removes a breakpoint on the specified line of source code." "" }
{AddressBreakpoint 0 VirtualAddr Nil 0 0 0 0 1 1 CircleFilled "address_breakpoint" "Address Breakpoint" "Places or removes a breakpoint on the specified address." "" }
{FunctionBreakpoint 0 String Nil 0 0 0 0 1 1 CircleFilled "function_breakpoint" "Function Breakpoint" "Places or removes a breakpoint on the first address(es) of the specified function." "" }
{ToggleBreakpointAtCursor 0 Null Nil 0 0 0 0 0 0 CircleFilled "toggle_breakpoint_cursor" "Toggle Breakpoint At Cursor" "Places or removes a breakpoint on the line on which the active cursor sits." "" }
@@ -360,12 +372,14 @@ DF_CoreCmdTable:// | | |
{ClearFilter 0 Null Nil 0 0 0 0 0 0 Find "clear_filter" "Clear Filter" "Clears the filter applied to the active view." "sort,search,filter,find,clear" }
//- rjf: view drivers
{GettingStarted 0 Null Nil 0 0 0 0 0 0 QuestionMark "getting_started" "Getting Started" "Opens the menu for information on getting started." "tutorial,help" }
{Commands 1 Null Nil 0 0 0 0 0 0 List "commands" "Commands" "Opens the list of all commands." "" }
{Target 1 Null Nil 0 0 0 0 0 0 Target "target" "Target" "Opens the editor for a target." "" }
{Targets 0 Null Nil 0 0 0 0 0 0 Target "targets" "Targets" "Opens the list of all targets." "" }
{FilePathMap 0 Null Nil 0 0 0 0 0 0 FileOutline "file_path_map" "File Path Map" "Opens the file path mapping editor." "" }
{AutoViewRules 0 Null Nil 0 0 0 0 0 0 Binoculars "auto_view_rules" "Auto View Rules" "Opens the auto view rule editor." "" }
{Scheduler 0 Null Nil 0 0 0 0 0 0 Scheduler "scheduler" "Scheduler" "Opens the scheduler view, for process and thread controls." "threads,processes,targets" }
{CallStack 0 Null Nil 0 0 0 0 0 0 Thread "call_stack" "Call Stack" "Opens the call stack view." "callstack,thread" }
{CallStack 0 Null Nil 0 0 0 0 0 0 Thread "call_stack" "Call Stack" "Opens the call stack view." "callstack,thread,unwind" }
{Modules 0 Null Nil 0 0 0 0 0 0 Module "modules" "Modules" "Opens the modules view." "" }
{PendingEntity 1 Null Nil 0 0 0 0 0 0 FileOutline "pending_entity" "Pending Entity" "Opens a view which waits for the passed entity to be completely loaded, then replaces itself with a new view." "" }
{Code 1 Null Nil 0 0 0 0 0 0 FileOutline "code" "Code" "Opens the code view for an already-loaded file." "" }
@@ -382,7 +396,7 @@ DF_CoreCmdTable:// | | |
{Breakpoints 0 Null Nil 0 0 0 0 0 0 CircleFilled "breakpoints" "Breakpoints" "Opens the breakpoints view." "" }
{WatchPins 0 Null Nil 0 0 0 0 0 0 Pin "watch_pins" "Watch Pins" "Opens the watch pins view." "" }
{ExceptionFilters 0 Null Nil 0 0 0 0 0 0 Gear "exception_filters" "Exception Filters" "Opens the exception filters view." "exceptions,filters" }
{Theme 0 Null Nil 0 0 0 0 0 0 Palette "theme" "Theme" "Opens the theme view." "theme,color,scheme,palette" }
{Settings 0 Null Nil 0 0 0 0 0 0 Gear "settings" "Settings" "Opens the settings view." "theme,color,scheme,options" }
{PickFile 1 FilePath Nil 1 0 0 0 0 1 FileOutline "pick_file" "Pick File" "Opens the file browser to pick a file." "" }
{PickFolder 1 FilePath Nil 0 1 0 0 0 1 FolderOpenFilled "pick_folder" "Pick Folder" "Opens the file browser to pick a folder." "" }
{PickFileOrFolder 1 FilePath Nil 1 1 0 0 0 1 FileOutline "pick_file_or_folder" "Pick File/Folder" "Opens the file browser to pick a file or folder." "" }
@@ -393,6 +407,7 @@ DF_CoreCmdTable:// | | |
//- rjf: developer commands
{ToggleDevMenu 0 Null Nil 0 0 0 0 0 0 Null "toggle_dev_menu" "Toggle Developer Menu" "Opens and closes the developer menu." "" }
{LogMarker 0 Null Nil 0 0 0 0 0 0 Null "log_marker" "Log Marker" "Logs a marker in the application log, to denote specific points in time within the log." "" }
}
////////////////////////////////
@@ -463,6 +478,11 @@ DF_CoreCmdTable:// | | |
// rows, this stage offers the ability to build a ui
// stretching over all of the rows.
//
// tab ui build, "tu" -> when a view rule also wants to implement ui for a
// dedicated tab, it can supply hooks for that as well
// in which case an eval/view-rule can be opened in a
// fully fledged, dedicated ui
//
// A few other bits are included for various ways in which a view rule may be
// applied throughout the eval visualization pipeline. A list follows:
//
@@ -482,25 +502,26 @@ DF_CoreCmdTable:// | | |
// For any view rules in this layer which also have graphical features, they
// are specified in both tables under the same name.
@table(name name_lower string ih ex er vb display_name docs description)
@table(name name_lower string ih ex er vb display_name docs schema description)
DF_CoreViewRuleTable:
{
{Null null "" - - - - "" - "" }
{Array array "array" - - x - "Array" x "Specifies that a pointer points to N elements, rather than only 1." }
{List list "list" - - - x "List" x "Specifies that some struct, union, or class forms the top of a linked list, and the member which points at the following element in the list." }
{ByteSwap bswap "bswap" x - x - "Byte Swap" x "Specifies that all integer primitives should be byte-swapped, such that their endianness is reversed." }
{BaseDec base_dec "dec" x - - - "Decimal Base (Base 10)" x "Specifies that all integral evaluations should appear in base-10 form." }
{BaseBin base_bin "bin" x - - - "Binary Base (Base 2)" x "Specifies that all integral evaluations should appear in base-2 form." }
{BaseOct base_oct "oct" x - - - "Octal Base (Base 8)" x "Specifies that all integral evaluations should appear in base-8 form." }
{BaseHex base_hex "hex" x - - - "Hexadecimal Base (Base 16)" x "Specifies that all integral evaluations should appear in base-16 form." }
{Only only "only" x - - x "Only Specified Members" x "Specifies that only the specified members should appear in struct, union, or class evaluations." }
{Omit omit "omit" x - - x "Omit Specified Members" x "Omits a list of member names from appearing in struct, union, or class evaluations." }
{NoAddr no_addr "no_addr" x - - - "Disable Address Values" x "Displays only what pointers point to, if possible, without the pointer's address value." }
{RGBA rgba "rgba" - x - x "Color (RGBA)" x "Displays as a color, interpreting the data as encoding R, G, B, and A values." }
{Text text "text" - x - x "Text" x "Displays as text." }
{Disasm disasm "disasm" - x - x "Disassembly" x "Displays as disassembled instructions, interpreting the data as raw machine code." }
{Bitmap bitmap "bitmap" - x - x "Bitmap" x "Displays as a bitmap, interpreting the data as raw pixel data." }
{Geo geo "geo" - x - x "Geometry" x "Displays as geometry, interpreting the data as vertex data." }
{Null null "" - - - - "" - "" "" }
{Array array "array" - - x - "Array" x "x:{expr}" "Specifies that a pointer points to N elements, rather than only 1." }
{List list "list" - - - x "List" x "x:{member}" "Specifies that some struct, union, or class forms the top of a linked list, and the member which points at the following element in the list." }
{ByteSwap bswap "bswap" x - x - "Byte Swap" x "" "Specifies that all integer primitives should be byte-swapped, such that their endianness is reversed." }
{BaseDec base_dec "dec" x - - - "Decimal Base (Base 10)" x "" "Specifies that all integral evaluations should appear in base-10 form." }
{BaseBin base_bin "bin" x - - - "Binary Base (Base 2)" x "" "Specifies that all integral evaluations should appear in base-2 form." }
{BaseOct base_oct "oct" x - - - "Octal Base (Base 8)" x "" "Specifies that all integral evaluations should appear in base-8 form." }
{BaseHex base_hex "hex" x - - - "Hexadecimal Base (Base 16)" x "" "Specifies that all integral evaluations should appear in base-16 form." }
{Only only "only" x - - x "Only Specified Members" x "x:{member}" "Specifies that only the specified members should appear in struct, union, or class evaluations." }
{Omit omit "omit" x - - x "Omit Specified Members" x "x:{member}" "Omits a list of member names from appearing in struct, union, or class evaluations." }
{NoAddr no_addr "no_addr" x - - - "Disable Address Values" x "" "Displays only what pointers point to, if possible, without the pointer's address value." }
{RGBA rgba "rgba" - x - x "Color (RGBA)" x "" "Displays as a color, interpreting the data as encoding R, G, B, and A values." }
{Text text "text" - x - x "Text" x "x:{'lang':lang, 'size':expr}" "Displays as text." }
{Disasm disasm "disasm" - x - x "Disassembly" x "x:{'arch':arch, 'size':expr}" "Displays as disassembled instructions, interpreting the data as raw machine code." }
{Graph graph "graph" - x - x "Graph" x "" "Displays as a pointer graph, visualizing nodes and edges formed by pointers directly." }
{Bitmap bitmap "bitmap" - x - x "Bitmap" x "x:{'w':expr, 'h':expr, 'fmt':tex2dformat}" "Displays as a bitmap, interpreting the data as raw pixel data." }
{Geo geo "geo" - x - x "Geometry" x "x:{'count':expr, 'vertices_base':expr, 'vertices_size':expr}" "Displays as geometry, interpreting the data as vertex data." }
}
////////////////////////////////
@@ -1688,179 +1709,140 @@ DF_DevToggleTable:
//- rjf: enums
@table_gen_enum
DF_CfgSrc:
@enum DF_CfgSrc:
{
@expand(DF_CfgSrcTable a) `DF_CfgSrc_$(a.name),`;
`DF_CfgSrc_COUNT`;
@expand(DF_CfgSrcTable a) `$(a.name)`,
COUNT,
}
@table_gen_enum
DF_EntityKind:
@enum DF_EntityKind:
{
@expand(DF_EntityKindTable a) `DF_EntityKind_$(a.name),`;
`DF_EntityKind_COUNT`;
@expand(DF_EntityKindTable a) `$(a.name)`,
COUNT,
}
@table_gen_enum
DF_NameKind:
@enum DF_CoreCmdKind:
{
@expand(DF_NameKindTable, a) `DF_NameKind_$(a.name),`;
`DF_NameKind_COUNT`;
@expand(DF_CoreCmdTable, a) `$(a.name)`,
COUNT,
}
@table_gen_enum
DF_CoreCmdKind:
@enum DF_IconKind:
{
@expand(DF_CoreCmdTable, a)
`DF_CoreCmdKind_$(a.name),`,
`DF_CoreCmdKind_COUNT`,
@expand(DF_IconTable a) `$(a.name)`,
COUNT,
}
@table_gen_enum
DF_IconKind:
@enum DF_CoreViewRuleKind:
{
@expand(DF_IconTable a)
`DF_IconKind_$(a.name),`;
`DF_IconKind_COUNT`;
}
@table_gen_enum
DF_CoreViewRuleKind:
{
@expand(DF_CoreViewRuleTable a) `DF_CoreViewRuleKind_$(a.name),`;
`DF_CoreViewRuleKind_COUNT`;
@expand(DF_CoreViewRuleTable a) `$(a.name)`,
COUNT,
}
//- rjf: command params
@table_gen_enum
DF_CmdParamSlot:
@enum DF_CmdParamSlot:
{
`DF_CmdParamSlot_Null,`;
@expand(DF_CmdParamSlotTable a)
`DF_CmdParamSlot_$(a.name),`;
`DF_CmdParamSlot_COUNT`;
Null,
@expand(DF_CmdParamSlotTable a) `$(a.name)`,
COUNT,
}
@table_gen
@struct DF_CmdParams:
{
`typedef struct DF_CmdParams DF_CmdParams;`;
`struct DF_CmdParams`;
`{`;
`U64 slot_props[(DF_CmdParamSlot_COUNT + 63) / 64];`;
@expand(DF_CmdParamSlotTable a)
`$(a.c_type) $(a.name_lower);`;
`};`;
`U64 slot_props[(DF_CmdParamSlot_COUNT + 63) / 64]`;
@expand(DF_CmdParamSlotTable a) `$(a.c_type) $(a.name_lower)`;
}
@table_gen_data(type:Rng1U64, fallback:0)
df_g_cmd_param_slot_range_table:
@data(Rng1U64) df_g_cmd_param_slot_range_table:
{
`{0},`
@expand(DF_CmdParamSlotTable a)
`{OffsetOf(DF_CmdParams, $(a.name_lower)), OffsetOf(DF_CmdParams, $(a.name_lower)) + sizeof($(a.c_type))},`
`{0}`,
@expand(DF_CmdParamSlotTable a) `{OffsetOf(DF_CmdParams, $(a.name_lower)), OffsetOf(DF_CmdParams, $(a.name_lower)) + sizeof($(a.c_type))}`,
}
//- rjf: entity kind tables
@table_gen_data(type: DF_IconKind, fallback: `DF_IconKind_Null`)
df_g_entity_kind_icon_kind_table:
@data(DF_IconKind) df_g_entity_kind_icon_kind_table:
{
@expand(DF_EntityKindTable a) `DF_IconKind_$(a.icon_kind),`;
@expand(DF_EntityKindTable a) `DF_IconKind_$(a.icon_kind)`,
}
@table_gen_data(type: String8, fallback: `{0}`)
df_g_entity_kind_display_string_table:
@data(String8) df_g_entity_kind_display_string_table:
{
@expand(DF_EntityKindTable a) `str8_lit_comp("$(a.display_string)"),`;
@expand(DF_EntityKindTable a) `str8_lit_comp("$(a.display_string)")`,
}
@table_gen_data(type: String8, fallback: `{0}`)
df_g_entity_kind_name_label_table:
@data(String8) df_g_entity_kind_name_label_table:
{
@expand(DF_EntityKindTable a) `str8_lit_comp("$(a.name_label)"),`;
@expand(DF_EntityKindTable a) `str8_lit_comp("$(a.name_label)")`,
}
@table_gen_data(type:DF_EntityKindFlags, fallback: `0`)
df_g_entity_kind_flags_table:
@data(DF_EntityKindFlags) df_g_entity_kind_flags_table:
{
@expand(DF_EntityKindTable a) `($(a.lf_mut_user_cfg)*DF_EntityKindFlag_LeafMutationUserConfig | $(a.lf_mut_prof_cfg)*DF_EntityKindFlag_LeafMutationProfileConfig | $(a.lf_mut_halt)*DF_EntityKindFlag_LeafMutationSoftHalt | $(a.lf_mut_dbg)*DF_EntityKindFlag_LeafMutationDebugInfoMap | $(a.tr_mut_user_cfg)*DF_EntityKindFlag_TreeMutationUserConfig | $(a.tr_mut_prof_cfg)*DF_EntityKindFlag_TreeMutationProfileConfig | $(a.tr_mut_halt)*DF_EntityKindFlag_TreeMutationSoftHalt | $(a.tr_mut_dbg)*DF_EntityKindFlag_TreeMutationDebugInfoMap | $(a.name_is_code)*DF_EntityKindFlag_NameIsCode | $(a.user_lifetime)*DF_EntityKindFlag_UserDefinedLifetime),`;
@expand(DF_EntityKindTable a) `($(a.lf_mut_user_cfg)*DF_EntityKindFlag_LeafMutationUserConfig | $(a.lf_mut_prof_cfg)*DF_EntityKindFlag_LeafMutationProjectConfig | $(a.lf_mut_halt)*DF_EntityKindFlag_LeafMutationSoftHalt | $(a.lf_mut_dbg)*DF_EntityKindFlag_LeafMutationDebugInfoMap | $(a.tr_mut_user_cfg)*DF_EntityKindFlag_TreeMutationUserConfig | $(a.tr_mut_prof_cfg)*DF_EntityKindFlag_TreeMutationProjectConfig | $(a.tr_mut_halt)*DF_EntityKindFlag_TreeMutationSoftHalt | $(a.tr_mut_dbg)*DF_EntityKindFlag_TreeMutationDebugInfoMap | $(a.name_is_code)*DF_EntityKindFlag_NameIsCode | $(a.user_lifetime)*DF_EntityKindFlag_UserDefinedLifetime)`,
}
@table_gen_data(type: DF_EntityOpFlags, fallback: `0`)
df_g_entity_kind_op_flags_table:
@data(DF_EntityOpFlags) df_g_entity_kind_op_flags_table:
{
@expand(DF_EntityKindTable a) `($(a.op_delete)*DF_EntityOpFlag_Delete) | ($(a.op_freeze)*DF_EntityOpFlag_Freeze) | ($(a.op_edit)*DF_EntityOpFlag_Edit) | ($(a.op_rename)*DF_EntityOpFlag_Rename) | ($(a.op_enable)*DF_EntityOpFlag_Enable) | ($(a.op_cond)*DF_EntityOpFlag_Condition) | ($(a.op_dup)*DF_EntityOpFlag_Duplicate),`;
@expand(DF_EntityKindTable a) `($(a.op_delete)*DF_EntityOpFlag_Delete) | ($(a.op_freeze)*DF_EntityOpFlag_Freeze) | ($(a.op_edit)*DF_EntityOpFlag_Edit) | ($(a.op_rename)*DF_EntityOpFlag_Rename) | ($(a.op_enable)*DF_EntityOpFlag_Enable) | ($(a.op_cond)*DF_EntityOpFlag_Condition) | ($(a.op_dup)*DF_EntityOpFlag_Duplicate)`,
}
//- rjf: config source tables
@table_gen_data(type: String8, fallback: DF_CoreCmdKind_Null)
df_g_cfg_src_string_table:
@data(String8) df_g_cfg_src_string_table:
{
@expand(DF_CfgSrcTable a) `str8_lit_comp("$(a.string)"),`;
@expand(DF_CfgSrcTable a) `str8_lit_comp("$(a.string)")`,
}
@table_gen_data(type: DF_CoreCmdKind, fallback: DF_CoreCmdKind_Null)
df_g_cfg_src_load_cmd_kind_table:
@data(DF_CoreCmdKind) df_g_cfg_src_load_cmd_kind_table:
{
@expand(DF_CfgSrcTable a) `DF_CoreCmdKind_$(a.load_cmd),`;
@expand(DF_CfgSrcTable a) `DF_CoreCmdKind_$(a.load_cmd)`,
}
@table_gen_data(type: DF_CoreCmdKind, fallback: DF_CoreCmdKind_Null)
df_g_cfg_src_write_cmd_kind_table:
@data(DF_CoreCmdKind) df_g_cfg_src_write_cmd_kind_table:
{
@expand(DF_CfgSrcTable a) `DF_CoreCmdKind_$(a.write_cmd),`;
@expand(DF_CfgSrcTable a) `DF_CoreCmdKind_$(a.write_cmd)`,
}
@table_gen_data(type: DF_CoreCmdKind, fallback: DF_CoreCmdKind_Null)
df_g_cfg_src_apply_cmd_kind_table:
@data(DF_CoreCmdKind) df_g_cfg_src_apply_cmd_kind_table:
{
@expand(DF_CfgSrcTable a) `DF_CoreCmdKind_$(a.apply_cmd),`;
@expand(DF_CfgSrcTable a) `DF_CoreCmdKind_$(a.apply_cmd)`;
}
//- rjf: core view rule function prototypes
@table_gen
@gen
{
``;
@expand(DF_CoreViewRuleTable a)
`$(a.er == "x" -> "DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_CoreViewRuleTable a)
`$(a.vb == "x" -> "DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_CoreViewRuleTable a) `$(a.er == "x" -> "DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_CoreViewRuleTable a) `$(a.vb == "x" -> "DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(" .. a.name_lower .. ");")`;
}
//- rjf: core command kind tables
@table_gen_data(type: DF_CmdSpecInfo, fallback: `{0}`) @c_file
df_g_core_cmd_kind_spec_info_table:
@data(DF_CmdSpecInfo) @c_file df_g_core_cmd_kind_spec_info_table:
{
@expand(DF_CoreCmdTable, a)
```{ str8_lit_comp("$(a.string)"), str8_lit_comp("$(a.desc)"), str8_lit_comp("$(a.search_tags)"), str8_lit_comp("$(a.display_name)"), (DF_CmdSpecFlag_OmitFromLists*$(a.lister_omit)), {DF_CmdParamSlot_$(a.q_slot), DF_EntityKind_$(a.q_ent_kind), (DF_CmdQueryFlag_AllowFiles*$(a.q_allow_files))|(DF_CmdQueryFlag_AllowFolders*$(a.q_allow_folders))|(DF_CmdQueryFlag_CodeInput*$(a.q_is_code))|(DF_CmdQueryFlag_KeepOldInput*$(a.q_keep_oi))|(DF_CmdQueryFlag_SelectOldInput*$(a.q_select_oi))|(DF_CmdQueryFlag_Required*$(a.q_required))}, DF_IconKind_$(a.canonical_icon)},```;
```{ str8_lit_comp("$(a.string)"), str8_lit_comp("$(a.desc)"), str8_lit_comp("$(a.search_tags)"), str8_lit_comp("$(a.display_name)"), (DF_CmdSpecFlag_OmitFromLists*$(a.lister_omit)), {DF_CmdParamSlot_$(a.q_slot), DF_EntityKind_$(a.q_ent_kind), (DF_CmdQueryFlag_AllowFiles*$(a.q_allow_files))|(DF_CmdQueryFlag_AllowFolders*$(a.q_allow_folders))|(DF_CmdQueryFlag_CodeInput*$(a.q_is_code))|(DF_CmdQueryFlag_KeepOldInput*$(a.q_keep_oi))|(DF_CmdQueryFlag_SelectOldInput*$(a.q_select_oi))|(DF_CmdQueryFlag_Required*$(a.q_required))}, DF_IconKind_$(a.canonical_icon)}```;
}
//- rjf: core view rule tables
@table_gen_data(type: DF_CoreViewRuleSpecInfo, fallback: `{0}`) @c_file
df_g_core_view_rule_spec_info_table:
@data(DF_CoreViewRuleSpecInfo) @c_file df_g_core_view_rule_spec_info_table:
{
@expand(DF_CoreViewRuleTable a)
```{str8_lit_comp("$(a.string)"), str8_lit_comp("$(a.display_name)"), str8_lit_comp("$(a.description)"), (DF_CoreViewRuleSpecInfoFlag_Inherited*$(a.ih == "x"))|(DF_CoreViewRuleSpecInfoFlag_Expandable*$(a.ex == "x"))|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*$(a.er == "x"))|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*$(a.vb == "x")), $(a.er == "x" -> "DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME("..a.name_lower..")") $(a.er != "x" -> 0), $(a.vb == "x" -> "DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME("..a.name_lower..")") $(a.vb != "x" -> 0), },```;
```{str8_lit_comp("$(a.string)"), str8_lit_comp("$(a.display_name)"), str8_lit_comp("$(a.schema)"), str8_lit_comp("$(a.description)"), (DF_CoreViewRuleSpecInfoFlag_Inherited*$(a.ih == "x"))|(DF_CoreViewRuleSpecInfoFlag_Expandable*$(a.ex == "x"))|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*$(a.er == "x"))|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*$(a.vb == "x")), $(a.er == "x" -> "DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME("..a.name_lower..")") $(a.er != "x" -> 0), $(a.vb == "x" -> "DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME("..a.name_lower..")") $(a.vb != "x" -> 0), }```;
}
//- rjf: icon kinds
@table_gen_data(type: String8, fallback: `{0}`)
df_g_icon_kind_text_table:
@data(String8) df_g_icon_kind_text_table:
{
@expand(DF_IconTable a)
`str8_lit_comp("$(a.text)"),`;
@expand(DF_IconTable a) `str8_lit_comp("$(a.text)")`;
}
//- rjf: instruction metadata table
@table_gen
@gen
{
``;
`struct{String8 mnemonic; String8 summary;} df_g_inst_table_x64[] =`;
@@ -1872,12 +1854,12 @@ df_g_icon_kind_text_table:
//- rjf: developer toggles
@table_gen
@gen
{
@expand(DF_DevToggleTable a) `global B32 DEV_$(a.name) = 0;`
}
@table_gen
@gen
{
`struct {B32 *value_ptr; String8 name;} DEV_toggle_table[] =`;
`{`;
+330 -34
View File
@@ -3,12 +3,219 @@
//- GENERATED CODE
DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
C_LINKAGE_BEGIN
Rng1U64 df_g_cmd_param_slot_range_table[24] =
{
{0},
{OffsetOf(DF_CmdParams, window), OffsetOf(DF_CmdParams, window) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, panel), OffsetOf(DF_CmdParams, panel) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, dest_panel), OffsetOf(DF_CmdParams, dest_panel) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, prev_view), OffsetOf(DF_CmdParams, prev_view) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, view), OffsetOf(DF_CmdParams, view) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, entity), OffsetOf(DF_CmdParams, entity) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, entity_list), OffsetOf(DF_CmdParams, entity_list) + sizeof(DF_HandleList)},
{OffsetOf(DF_CmdParams, string), OffsetOf(DF_CmdParams, string) + sizeof(String8)},
{OffsetOf(DF_CmdParams, file_path), OffsetOf(DF_CmdParams, file_path) + sizeof(String8)},
{OffsetOf(DF_CmdParams, text_point), OffsetOf(DF_CmdParams, text_point) + sizeof(TxtPt)},
{OffsetOf(DF_CmdParams, cmd_spec), OffsetOf(DF_CmdParams, cmd_spec) + sizeof(struct DF_CmdSpec *)},
{OffsetOf(DF_CmdParams, view_spec), OffsetOf(DF_CmdParams, view_spec) + sizeof(struct DF_ViewSpec *)},
{OffsetOf(DF_CmdParams, cfg_node), OffsetOf(DF_CmdParams, cfg_node) + sizeof(struct DF_CfgNode *)},
{OffsetOf(DF_CmdParams, os_event), OffsetOf(DF_CmdParams, os_event) + sizeof(struct OS_Event *)},
{OffsetOf(DF_CmdParams, vaddr), OffsetOf(DF_CmdParams, vaddr) + sizeof(U64)},
{OffsetOf(DF_CmdParams, voff), OffsetOf(DF_CmdParams, voff) + sizeof(U64)},
{OffsetOf(DF_CmdParams, index), OffsetOf(DF_CmdParams, index) + sizeof(U64)},
{OffsetOf(DF_CmdParams, id), OffsetOf(DF_CmdParams, id) + sizeof(U64)},
{OffsetOf(DF_CmdParams, prefer_dasm), OffsetOf(DF_CmdParams, prefer_dasm) + sizeof(B32)},
{OffsetOf(DF_CmdParams, force_confirm), OffsetOf(DF_CmdParams, force_confirm) + sizeof(B32)},
{OffsetOf(DF_CmdParams, dir2), OffsetOf(DF_CmdParams, dir2) + sizeof(Dir2)},
{OffsetOf(DF_CmdParams, base_unwind_index), OffsetOf(DF_CmdParams, base_unwind_index) + sizeof(U64)},
{OffsetOf(DF_CmdParams, inline_unwind_index), OffsetOf(DF_CmdParams, inline_unwind_index) + sizeof(U64)},
};
DF_IconKind df_g_entity_kind_icon_kind_table[25] =
{
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Machine,
DF_IconKind_FileOutline,
DF_IconKind_FileOutline,
DF_IconKind_Binoculars,
DF_IconKind_Pin,
DF_IconKind_CircleFilled,
DF_IconKind_CircleFilled,
DF_IconKind_Target,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Briefcase,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Threads,
DF_IconKind_Thread,
DF_IconKind_Module,
DF_IconKind_Threads,
DF_IconKind_Module,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
};
String8 df_g_entity_kind_display_string_table[25] =
{
str8_lit_comp("Nil"),
str8_lit_comp("Root"),
str8_lit_comp("Machine"),
str8_lit_comp("File"),
str8_lit_comp("Override File Link"),
str8_lit_comp("Auto View Rule"),
str8_lit_comp("Watch Pin"),
str8_lit_comp("Breakpoint"),
str8_lit_comp("Condition"),
str8_lit_comp("Target"),
str8_lit_comp("Executable"),
str8_lit_comp("Arguments"),
str8_lit_comp("Execution Path"),
str8_lit_comp("Entry Point Name"),
str8_lit_comp("Recent Project"),
str8_lit_comp("Source"),
str8_lit_comp("Destination"),
str8_lit_comp("Process"),
str8_lit_comp("Thread"),
str8_lit_comp("Module"),
str8_lit_comp("Pending Thread Name"),
str8_lit_comp("Debug Info Path"),
str8_lit_comp("Conversion Task"),
str8_lit_comp("Conversion Failure"),
str8_lit_comp("EndedProcess"),
};
String8 df_g_entity_kind_name_label_table[25] =
{
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Expression"),
str8_lit_comp("Label"),
str8_lit_comp("Expression"),
str8_lit_comp("Label"),
str8_lit_comp("Executable"),
str8_lit_comp("Arguments"),
str8_lit_comp("Execution Path"),
str8_lit_comp("Symbol Name"),
str8_lit_comp("Path"),
str8_lit_comp("Path"),
str8_lit_comp("Path"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
};
DF_EntityKindFlags df_g_entity_kind_flags_table[25] =
{
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(1*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 1*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 1*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 1*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProjectConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(1*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 1*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProjectConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProjectConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
};
DF_EntityOpFlags df_g_entity_kind_op_flags_table[25] =
{
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (1*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (1*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (1*DF_EntityOpFlag_Enable) | (1*DF_EntityOpFlag_Condition) | (1*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (1*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (1*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (1*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (1*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (1*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
};
String8 df_g_cfg_src_string_table[4] =
{
str8_lit_comp("user"),
str8_lit_comp("project"),
str8_lit_comp("command_line"),
str8_lit_comp("transient"),
};
DF_CoreCmdKind df_g_cfg_src_load_cmd_kind_table[4] =
{
DF_CoreCmdKind_OpenUser,
DF_CoreCmdKind_OpenProject,
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Null,
};
DF_CoreCmdKind df_g_cfg_src_write_cmd_kind_table[4] =
{
DF_CoreCmdKind_WriteUserData,
DF_CoreCmdKind_WriteProjectData,
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Null,
};
DF_CoreCmdKind df_g_cfg_src_apply_cmd_kind_table[4] =
{
DF_CoreCmdKind_ApplyUserData,
DF_CoreCmdKind_ApplyProjectData,
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Null,
};
DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[220] =
{
{ str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("exit"), str8_lit_comp("Exits the debugger."), str8_lit_comp("quit,close,abort"), str8_lit_comp("Exit"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_X},
{ str8_lit_comp("run_command"), str8_lit_comp("Runs a command from the command palette."), str8_lit_comp("help,cmd"), str8_lit_comp("Run Command"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_CmdSpec, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("error"), str8_lit_comp("Notifies of an error."), str8_lit_comp(""), str8_lit_comp("Error"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("os_event"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("OS Event"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("launch_and_run"), str8_lit_comp("Starts debugging a new instance of a target, then runs."), str8_lit_comp("launch,start,run,target"), str8_lit_comp("Launch and Run"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_EntityList, DF_EntityKind_Target, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Play},
{ str8_lit_comp("launch_and_init"), str8_lit_comp("Starts debugging a new instance of a target, then stops at the program's entry point."), str8_lit_comp("launch,start,entry,point"), str8_lit_comp("Launch and Initialize"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_EntityList, DF_EntityKind_Target, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_PlayStepForward},
{ str8_lit_comp("kill"), str8_lit_comp("Kills the specified existing debugged process(es)."), str8_lit_comp("stop,kill"), str8_lit_comp("Kill"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_EntityList, DF_EntityKind_Process, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Stop},
@@ -31,15 +238,13 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("step_over"), str8_lit_comp("Steps once, always over function calls, for either line or instructions."), str8_lit_comp(""), str8_lit_comp("Step Over"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_StepOver},
{ str8_lit_comp("run_to_cursor"), str8_lit_comp("Runs the selected thread to the current cursor."), str8_lit_comp(""), str8_lit_comp("Run To Cursor"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Play},
{ str8_lit_comp("set_next_statement"), str8_lit_comp("Sets the selected thread's instruction pointer to the cursor's position."), str8_lit_comp(""), str8_lit_comp("Set Next Statement"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_RightArrow},
{ str8_lit_comp("enable_solo_stepping_mode"), str8_lit_comp("Enables 'solo stepping mode', which suspends all non-selected threads before stepping."), str8_lit_comp("solo,stepping,mode,suspend"), str8_lit_comp("Enable Solo Stepping Mode"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Thread},
{ str8_lit_comp("disable_solo_stepping_mode"), str8_lit_comp("Disables 'solo stepping mode', which suspends all non-selected threads before stepping."), str8_lit_comp("solo,stepping,mode,suspend"), str8_lit_comp("Disable Solo Stepping Mode"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Thread},
{ str8_lit_comp("select_thread"), str8_lit_comp("Selects a thread."), str8_lit_comp(""), str8_lit_comp("Select Thread"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Thread, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Null},
{ str8_lit_comp("select_thread_window"), str8_lit_comp("Selects a thread for the active window, overriding the global selected thread."), str8_lit_comp(""), str8_lit_comp("Select Thread On Window"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Thread, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Null},
{ str8_lit_comp("select_thread_view"), str8_lit_comp("Selects a thread for the active view, overriding the global and per-window selected threads."), str8_lit_comp(""), str8_lit_comp("Select Thread On View"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Thread, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Null},
{ str8_lit_comp("select_unwind"), str8_lit_comp("Selects an unwind frame number for the selected thread."), str8_lit_comp(""), str8_lit_comp("Select Unwind"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("up_one_frame"), str8_lit_comp("Selects the callstack frame above the currently selected."), str8_lit_comp(""), str8_lit_comp("Up One Frame"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_UpArrow},
{ str8_lit_comp("down_one_frame"), str8_lit_comp("Selects the callstack frame below the currently selected."), str8_lit_comp(""), str8_lit_comp("Down One Frame"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_DownArrow},
{ str8_lit_comp("freeze_thread"), str8_lit_comp("Freezes the passed thread."), str8_lit_comp(""), str8_lit_comp("Freeze Thread"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Thread, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Locked},
{ str8_lit_comp("up_one_frame"), str8_lit_comp("Selects the call stack frame above the currently selected."), str8_lit_comp(""), str8_lit_comp("Up One Frame"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_UpArrow},
{ str8_lit_comp("down_one_frame"), str8_lit_comp("Selects the call stack frame below the currently selected."), str8_lit_comp("callstack,unwind"), str8_lit_comp("Down One Frame"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_DownArrow},
{ str8_lit_comp("freeze_thread"), str8_lit_comp("Freezes the passed thread."), str8_lit_comp("callstack,unwind"), str8_lit_comp("Freeze Thread"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Thread, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Locked},
{ str8_lit_comp("thaw_thread"), str8_lit_comp("Thaws the passed thread."), str8_lit_comp(""), str8_lit_comp("Thaw Thread"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Thread, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Unlocked},
{ str8_lit_comp("freeze_process"), str8_lit_comp("Freezes the passed process."), str8_lit_comp(""), str8_lit_comp("Freeze Process"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Process, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Locked},
{ str8_lit_comp("thaw_process"), str8_lit_comp("Thaws the passed process."), str8_lit_comp(""), str8_lit_comp("Thaw Process"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_Process, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Unlocked},
@@ -57,8 +262,12 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("confirm_accept"), str8_lit_comp("Accepts the active confirmation prompt."), str8_lit_comp(""), str8_lit_comp("Confirm Accept"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("confirm_cancel"), str8_lit_comp("Cancels the active confirmation prompt."), str8_lit_comp(""), str8_lit_comp("Confirm Cancel"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("reset_to_default_panels"), str8_lit_comp("Resets the window to the default panel layout."), str8_lit_comp("panel"), str8_lit_comp("Reset To Default Panel Layout"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Window},
{ str8_lit_comp("new_panel_right"), str8_lit_comp("Creates a new panel to the right of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Vertically"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_XSplit},
{ str8_lit_comp("new_panel_down"), str8_lit_comp("Creates a new panel at the bottom of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Horizontally"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_YSplit},
{ str8_lit_comp("reset_to_compact_panels"), str8_lit_comp("Resets the window to the compact panel layout."), str8_lit_comp("panel"), str8_lit_comp("Reset To Compact Panel Layout"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Window},
{ str8_lit_comp("new_panel_left"), str8_lit_comp("Creates a new panel to the left of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Left"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_XSplit},
{ str8_lit_comp("new_panel_up"), str8_lit_comp("Creates a new panel at the top of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Up"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_YSplit},
{ str8_lit_comp("new_panel_right"), str8_lit_comp("Creates a new panel to the right of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Right"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_XSplit},
{ str8_lit_comp("new_panel_down"), str8_lit_comp("Creates a new panel at the bottom of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Down"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_YSplit},
{ str8_lit_comp("split_panel"), str8_lit_comp("Creates a new panel in a given direction, and moves a tab to it, if specified."), str8_lit_comp(""), str8_lit_comp("Split Panel"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("rotate_panel_columns"), str8_lit_comp("Rotates all panels at the closest column level of the panel hierarchy."), str8_lit_comp(""), str8_lit_comp("Rotate Panel Columns"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("next_panel"), str8_lit_comp("Cycles the active panel forward."), str8_lit_comp(""), str8_lit_comp("Focus Next Panel"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_RightArrow},
{ str8_lit_comp("prev_panel"), str8_lit_comp("Cycles the active panel backwards."), str8_lit_comp(""), str8_lit_comp("Focus Previous Panel"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_LeftArrow},
@@ -83,19 +292,25 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("tab_bar_bottom"), str8_lit_comp("Anchors a panel's tab bar to the bottom of the panel."), str8_lit_comp(""), str8_lit_comp("Anchor Tab Bar To Bottom"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_DownArrow},
{ str8_lit_comp("set_current_path"), str8_lit_comp("Sets the debugger's current path, which is used as a starting point when browsing for files."), str8_lit_comp(""), str8_lit_comp("Set Current Path"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
{ str8_lit_comp("open"), str8_lit_comp("Opens a file."), str8_lit_comp("code,source,file"), str8_lit_comp("Open"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_FileOutline},
{ str8_lit_comp("reload"), str8_lit_comp("Reloads a loaded file."), str8_lit_comp("code,source,file,reload"), str8_lit_comp("Reload"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_File, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_FileOutline},
{ str8_lit_comp("reload_active"), str8_lit_comp("Reloads the active file."), str8_lit_comp("code,source,file,reload"), str8_lit_comp("Reload Active File"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
{ str8_lit_comp("switch"), str8_lit_comp("Switches to a loaded file."), str8_lit_comp("code,source,file"), str8_lit_comp("Switch"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_File, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_FileOutline},
{ str8_lit_comp("switch_to_partner_file"), str8_lit_comp("Switches to the focused file's partner; or from header to implementation or vice versa."), str8_lit_comp("code,source,file"), str8_lit_comp("Switch To Partner File"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
{ str8_lit_comp("go_to_disassembly"), str8_lit_comp("Goes to the disassembly, if any, for a given source code line."), str8_lit_comp("code,source,disassembly,disasm"), str8_lit_comp("Go To Disassembly"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Glasses},
{ str8_lit_comp("go_to_source"), str8_lit_comp("Goes to the source code, if any, for a given disassembly line."), str8_lit_comp("code,source,disassembly,disasm"), str8_lit_comp("Go To Source"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
{ str8_lit_comp("set_file_override_link_src"), str8_lit_comp("Sets the source path for an override file link."), str8_lit_comp(""), str8_lit_comp("Set File Override Link Source"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("set_file_override_link_dst"), str8_lit_comp("Sets the destination path for an override file link."), str8_lit_comp(""), str8_lit_comp("Set File Override Link Destination"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("set_file_replacement_path"), str8_lit_comp("Sets the path which should be used as the replacement for the passed file."), str8_lit_comp(""), str8_lit_comp("Set File Replacement Path"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("open_user"), str8_lit_comp("Opens a user file path, immediately loading it, and begins autosaving to it."), str8_lit_comp("load,user,profile,layout"), str8_lit_comp("Open User"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Person},
{ str8_lit_comp("open_profile"), str8_lit_comp("Opens a profile file path, immediately loading it, and begins autosaving to it."), str8_lit_comp("profile,project,session"), str8_lit_comp("Open Profile"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Briefcase},
{ str8_lit_comp("set_auto_view_rule_type"), str8_lit_comp("Sets the type for an auto view rule."), str8_lit_comp(""), str8_lit_comp("Set Auto View Rule Type"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("set_auto_view_rule_view_rule"), str8_lit_comp("Sets the view rule string for an auto view rule."), str8_lit_comp(""), str8_lit_comp("Set Auto View Rule View Rule"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("open_user"), str8_lit_comp("Opens a user file path, immediately loading it, and begins autosaving to it."), str8_lit_comp("load,user,project,layout"), str8_lit_comp("Open User"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Person},
{ str8_lit_comp("open_project"), str8_lit_comp("Opens a project file path, immediately loading it, and begins autosaving to it."), str8_lit_comp("project,project,session"), str8_lit_comp("Open Project"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Briefcase},
{ str8_lit_comp("open_recent_project"), str8_lit_comp("Opens a recently used project file."), str8_lit_comp("project,project,session"), str8_lit_comp("Open Recent Project"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Entity, DF_EntityKind_RecentProject, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_Briefcase},
{ str8_lit_comp("apply_user_data"), str8_lit_comp("Applies user data from the active user file."), str8_lit_comp(""), str8_lit_comp("Apply User Data"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("apply_profile_data"), str8_lit_comp("Applies profile data from the active profile file."), str8_lit_comp(""), str8_lit_comp("Apply Profile Data"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("apply_project_data"), str8_lit_comp("Applies project data from the active project file."), str8_lit_comp(""), str8_lit_comp("Apply Project Data"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("write_user_data"), str8_lit_comp("Writes user data to the active user file."), str8_lit_comp(""), str8_lit_comp("Write User Data"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("write_profile_data"), str8_lit_comp("Writes profile data to the active profile file."), str8_lit_comp(""), str8_lit_comp("Write Profile Data"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("write_project_data"), str8_lit_comp("Writes project data to the active project file."), str8_lit_comp(""), str8_lit_comp("Write Project Data"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("edit"), str8_lit_comp("Edits the current selection."), str8_lit_comp(""), str8_lit_comp("Edit"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Pencil},
{ str8_lit_comp("accept"), str8_lit_comp("Accepts current changes, or answers prompts in the affirmative."), str8_lit_comp(""), str8_lit_comp("Accept"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_CheckFilled},
{ str8_lit_comp("cancel"), str8_lit_comp("Rejects current changes, exits temporary menus, or answers prompts in the negative."), str8_lit_comp(""), str8_lit_comp("Cancel"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_X},
{ str8_lit_comp("move_left"), str8_lit_comp("Moves the cursor or selection left."), str8_lit_comp(""), str8_lit_comp("Move Left"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_right"), str8_lit_comp("Moves the cursor or selection right."), str8_lit_comp(""), str8_lit_comp("Move Right"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_up"), str8_lit_comp("Moves the cursor or selection up."), str8_lit_comp(""), str8_lit_comp("Move Up"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
@@ -120,6 +335,8 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("move_down_page_select"), str8_lit_comp("Moves the cursor or selection down one page, while selecting."), str8_lit_comp(""), str8_lit_comp("Move Down Page Select"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_up_whole_select"), str8_lit_comp("Moves the cursor or selection to the beginning of the relevant content, while selecting."), str8_lit_comp(""), str8_lit_comp("Move Up Whole Select"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_down_whole_select"), str8_lit_comp("Moves the cursor or selection to the end of the relevant content, while selecting."), str8_lit_comp(""), str8_lit_comp("Move Down Whole Select"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_up_reorder"), str8_lit_comp("Moves the cursor or selection up, while swapping the currently selected element with that upward."), str8_lit_comp(""), str8_lit_comp("Move Up Reorder"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_down_reorder"), str8_lit_comp("Moves the cursor or selection down, while swapping the currently selected element with that downward."), str8_lit_comp(""), str8_lit_comp("Move Down Reorder"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_home"), str8_lit_comp("Moves the cursor to the beginning of the line."), str8_lit_comp(""), str8_lit_comp("Move Home"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_end"), str8_lit_comp("Moves the cursor to the end of the line."), str8_lit_comp(""), str8_lit_comp("Move End"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("move_home_select"), str8_lit_comp("Moves the cursor to the beginning of the line, while selecting."), str8_lit_comp(""), str8_lit_comp("Move Home Select"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
@@ -158,7 +375,7 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("name_entity"), str8_lit_comp("Equips an entity with a name."), str8_lit_comp(""), str8_lit_comp("Name Entity"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("edit_entity"), str8_lit_comp("Opens the editor for an entity."), str8_lit_comp(""), str8_lit_comp("Edit Entity"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("duplicate_entity"), str8_lit_comp("Duplicates an entity."), str8_lit_comp(""), str8_lit_comp("Duplicate Entity"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("text_breakpoint"), str8_lit_comp("Places or removes a breakpoint on the specified line of source code."), str8_lit_comp(""), str8_lit_comp("Text Breakpoint"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_CircleFilled},
{ str8_lit_comp("text_breakpoint"), str8_lit_comp("Places or removes a breakpoint on the specified line of source code."), str8_lit_comp(""), str8_lit_comp("Text Breakpoint"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_CircleFilled},
{ str8_lit_comp("address_breakpoint"), str8_lit_comp("Places or removes a breakpoint on the specified address."), str8_lit_comp(""), str8_lit_comp("Address Breakpoint"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_VirtualAddr, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*1)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_CircleFilled},
{ str8_lit_comp("function_breakpoint"), str8_lit_comp("Places or removes a breakpoint on the first address(es) of the specified function."), str8_lit_comp(""), str8_lit_comp("Function Breakpoint"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_String, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*1)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_CircleFilled},
{ str8_lit_comp("toggle_breakpoint_cursor"), str8_lit_comp("Places or removes a breakpoint on the line on which the active cursor sits."), str8_lit_comp(""), str8_lit_comp("Toggle Breakpoint At Cursor"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_CircleFilled},
@@ -182,12 +399,14 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("filter"), str8_lit_comp("Begins filtering the active view."), str8_lit_comp("sort,search,filter,find"), str8_lit_comp("Filter"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Find},
{ str8_lit_comp("apply_filter"), str8_lit_comp("Applies the typed filter to the active view."), str8_lit_comp("sort,search,filter,find,apply"), str8_lit_comp("Apply Filter"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Find},
{ str8_lit_comp("clear_filter"), str8_lit_comp("Clears the filter applied to the active view."), str8_lit_comp("sort,search,filter,find,clear"), str8_lit_comp("Clear Filter"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Find},
{ str8_lit_comp("getting_started"), str8_lit_comp("Opens the menu for information on getting started."), str8_lit_comp("tutorial,help"), str8_lit_comp("Getting Started"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_QuestionMark},
{ str8_lit_comp("commands"), str8_lit_comp("Opens the list of all commands."), str8_lit_comp(""), str8_lit_comp("Commands"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_List},
{ str8_lit_comp("target"), str8_lit_comp("Opens the editor for a target."), str8_lit_comp(""), str8_lit_comp("Target"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Target},
{ str8_lit_comp("targets"), str8_lit_comp("Opens the list of all targets."), str8_lit_comp(""), str8_lit_comp("Targets"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Target},
{ str8_lit_comp("file_path_map"), str8_lit_comp("Opens the file path mapping editor."), str8_lit_comp(""), str8_lit_comp("File Path Map"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
{ str8_lit_comp("auto_view_rules"), str8_lit_comp("Opens the auto view rule editor."), str8_lit_comp(""), str8_lit_comp("Auto View Rules"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Binoculars},
{ str8_lit_comp("scheduler"), str8_lit_comp("Opens the scheduler view, for process and thread controls."), str8_lit_comp("threads,processes,targets"), str8_lit_comp("Scheduler"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Scheduler},
{ str8_lit_comp("call_stack"), str8_lit_comp("Opens the call stack view."), str8_lit_comp("callstack,thread"), str8_lit_comp("Call Stack"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Thread},
{ str8_lit_comp("call_stack"), str8_lit_comp("Opens the call stack view."), str8_lit_comp("callstack,thread,unwind"), str8_lit_comp("Call Stack"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Thread},
{ str8_lit_comp("modules"), str8_lit_comp("Opens the modules view."), str8_lit_comp(""), str8_lit_comp("Modules"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Module},
{ str8_lit_comp("pending_entity"), str8_lit_comp("Opens a view which waits for the passed entity to be completely loaded, then replaces itself with a new view."), str8_lit_comp(""), str8_lit_comp("Pending Entity"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
{ str8_lit_comp("code"), str8_lit_comp("Opens the code view for an already-loaded file."), str8_lit_comp(""), str8_lit_comp("Code"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_FileOutline},
@@ -204,32 +423,109 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
{ str8_lit_comp("breakpoints"), str8_lit_comp("Opens the breakpoints view."), str8_lit_comp(""), str8_lit_comp("Breakpoints"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_CircleFilled},
{ str8_lit_comp("watch_pins"), str8_lit_comp("Opens the watch pins view."), str8_lit_comp(""), str8_lit_comp("Watch Pins"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Pin},
{ str8_lit_comp("exception_filters"), str8_lit_comp("Opens the exception filters view."), str8_lit_comp("exceptions,filters"), str8_lit_comp("Exception Filters"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Gear},
{ str8_lit_comp("theme"), str8_lit_comp("Opens the theme view."), str8_lit_comp("theme,color,scheme,palette"), str8_lit_comp("Theme"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Palette},
{ str8_lit_comp("settings"), str8_lit_comp("Opens the settings view."), str8_lit_comp("theme,color,scheme,options"), str8_lit_comp("Settings"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Gear},
{ str8_lit_comp("pick_file"), str8_lit_comp("Opens the file browser to pick a file."), str8_lit_comp(""), str8_lit_comp("Pick File"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_FileOutline},
{ str8_lit_comp("pick_folder"), str8_lit_comp("Opens the file browser to pick a folder."), str8_lit_comp(""), str8_lit_comp("Pick Folder"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*1)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_FolderOpenFilled},
{ str8_lit_comp("pick_file_or_folder"), str8_lit_comp("Opens the file browser to pick a file or folder."), str8_lit_comp(""), str8_lit_comp("Pick File/Folder"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_FilePath, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*1)|(DF_CmdQueryFlag_AllowFolders*1)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*1)}, DF_IconKind_FileOutline},
{ str8_lit_comp("complete_query"), str8_lit_comp("Completes a query."), str8_lit_comp(""), str8_lit_comp("Complete Query"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("cancel_query"), str8_lit_comp("Cancels a query."), str8_lit_comp(""), str8_lit_comp("Cancel Query"), (DF_CmdSpecFlag_OmitFromLists*1), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("toggle_dev_menu"), str8_lit_comp("Opens and closes the developer menu."), str8_lit_comp(""), str8_lit_comp("Toggle Developer Menu"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
{ str8_lit_comp("log_marker"), str8_lit_comp("Logs a marker in the application log, to denote specific points in time within the log."), str8_lit_comp(""), str8_lit_comp("Log Marker"), (DF_CmdSpecFlag_OmitFromLists*0), {DF_CmdParamSlot_Null, DF_EntityKind_Nil, (DF_CmdQueryFlag_AllowFiles*0)|(DF_CmdQueryFlag_AllowFolders*0)|(DF_CmdQueryFlag_CodeInput*0)|(DF_CmdQueryFlag_KeepOldInput*0)|(DF_CmdQueryFlag_SelectOldInput*0)|(DF_CmdQueryFlag_Required*0)}, DF_IconKind_Null},
};
DF_CoreViewRuleSpecInfo df_g_core_view_rule_spec_info_table[] =
DF_CoreViewRuleSpecInfo df_g_core_view_rule_spec_info_table[17] =
{
{str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("array"), str8_lit_comp("Array"), str8_lit_comp("Specifies that a pointer points to N elements, rather than only 1."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*1)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME(array) , 0, },
{str8_lit_comp("list"), str8_lit_comp("List"), str8_lit_comp("Specifies that some struct, union, or class forms the top of a linked list, and the member which points at the following element in the list."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(list) , },
{str8_lit_comp("bswap"), str8_lit_comp("Byte Swap"), str8_lit_comp("Specifies that all integer primitives should be byte-swapped, such that their endianness is reversed."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*1)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME(bswap) , 0, },
{str8_lit_comp("dec"), str8_lit_comp("Decimal Base (Base 10)"), str8_lit_comp("Specifies that all integral evaluations should appear in base-10 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("bin"), str8_lit_comp("Binary Base (Base 2)"), str8_lit_comp("Specifies that all integral evaluations should appear in base-2 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("oct"), str8_lit_comp("Octal Base (Base 8)"), str8_lit_comp("Specifies that all integral evaluations should appear in base-8 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("hex"), str8_lit_comp("Hexadecimal Base (Base 16)"), str8_lit_comp("Specifies that all integral evaluations should appear in base-16 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("only"), str8_lit_comp("Only Specified Members"), str8_lit_comp("Specifies that only the specified members should appear in struct, union, or class evaluations."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(only) , },
{str8_lit_comp("omit"), str8_lit_comp("Omit Specified Members"), str8_lit_comp("Omits a list of member names from appearing in struct, union, or class evaluations."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(omit) , },
{str8_lit_comp("no_addr"), str8_lit_comp("Disable Address Values"), str8_lit_comp("Displays only what pointers point to, if possible, without the pointer's address value."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("rgba"), str8_lit_comp("Color (RGBA)"), str8_lit_comp("Displays as a color, interpreting the data as encoding R, G, B, and A values."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(rgba) , },
{str8_lit_comp("text"), str8_lit_comp("Text"), str8_lit_comp("Displays as text."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(text) , },
{str8_lit_comp("disasm"), str8_lit_comp("Disassembly"), str8_lit_comp("Displays as disassembled instructions, interpreting the data as raw machine code."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(disasm) , },
{str8_lit_comp("bitmap"), str8_lit_comp("Bitmap"), str8_lit_comp("Displays as a bitmap, interpreting the data as raw pixel data."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(bitmap) , },
{str8_lit_comp("geo"), str8_lit_comp("Geometry"), str8_lit_comp("Displays as geometry, interpreting the data as vertex data."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(geo) , },
{str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("array"), str8_lit_comp("Array"), str8_lit_comp("x:{expr}"), str8_lit_comp("Specifies that a pointer points to N elements, rather than only 1."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*1)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME(array) , 0, },
{str8_lit_comp("list"), str8_lit_comp("List"), str8_lit_comp("x:{member}"), str8_lit_comp("Specifies that some struct, union, or class forms the top of a linked list, and the member which points at the following element in the list."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(list) , },
{str8_lit_comp("bswap"), str8_lit_comp("Byte Swap"), str8_lit_comp(""), str8_lit_comp("Specifies that all integer primitives should be byte-swapped, such that their endianness is reversed."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*1)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_NAME(bswap) , 0, },
{str8_lit_comp("dec"), str8_lit_comp("Decimal Base (Base 10)"), str8_lit_comp(""), str8_lit_comp("Specifies that all integral evaluations should appear in base-10 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("bin"), str8_lit_comp("Binary Base (Base 2)"), str8_lit_comp(""), str8_lit_comp("Specifies that all integral evaluations should appear in base-2 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("oct"), str8_lit_comp("Octal Base (Base 8)"), str8_lit_comp(""), str8_lit_comp("Specifies that all integral evaluations should appear in base-8 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("hex"), str8_lit_comp("Hexadecimal Base (Base 16)"), str8_lit_comp(""), str8_lit_comp("Specifies that all integral evaluations should appear in base-16 form."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("only"), str8_lit_comp("Only Specified Members"), str8_lit_comp("x:{member}"), str8_lit_comp("Specifies that only the specified members should appear in struct, union, or class evaluations."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(only) , },
{str8_lit_comp("omit"), str8_lit_comp("Omit Specified Members"), str8_lit_comp("x:{member}"), str8_lit_comp("Omits a list of member names from appearing in struct, union, or class evaluations."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(omit) , },
{str8_lit_comp("no_addr"), str8_lit_comp("Disable Address Values"), str8_lit_comp(""), str8_lit_comp("Displays only what pointers point to, if possible, without the pointer's address value."), (DF_CoreViewRuleSpecInfoFlag_Inherited*1)|(DF_CoreViewRuleSpecInfoFlag_Expandable*0)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*0), 0, 0, },
{str8_lit_comp("rgba"), str8_lit_comp("Color (RGBA)"), str8_lit_comp(""), str8_lit_comp("Displays as a color, interpreting the data as encoding R, G, B, and A values."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(rgba) , },
{str8_lit_comp("text"), str8_lit_comp("Text"), str8_lit_comp("x:{'lang':lang, 'size':expr}"), str8_lit_comp("Displays as text."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(text) , },
{str8_lit_comp("disasm"), str8_lit_comp("Disassembly"), str8_lit_comp("x:{'arch':arch, 'size':expr}"), str8_lit_comp("Displays as disassembled instructions, interpreting the data as raw machine code."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(disasm) , },
{str8_lit_comp("graph"), str8_lit_comp("Graph"), str8_lit_comp(""), str8_lit_comp("Displays as a pointer graph, visualizing nodes and edges formed by pointers directly."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(graph) , },
{str8_lit_comp("bitmap"), str8_lit_comp("Bitmap"), str8_lit_comp("x:{'w':expr, 'h':expr, 'fmt':tex2dformat}"), str8_lit_comp("Displays as a bitmap, interpreting the data as raw pixel data."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(bitmap) , },
{str8_lit_comp("geo"), str8_lit_comp("Geometry"), str8_lit_comp("x:{'count':expr, 'vertices_base':expr, 'vertices_size':expr}"), str8_lit_comp("Displays as geometry, interpreting the data as vertex data."), (DF_CoreViewRuleSpecInfoFlag_Inherited*0)|(DF_CoreViewRuleSpecInfoFlag_Expandable*1)|(DF_CoreViewRuleSpecInfoFlag_EvalResolution*0)|(DF_CoreViewRuleSpecInfoFlag_VizBlockProd*1), 0, DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_NAME(geo) , },
};
String8 df_g_icon_kind_text_table[69] =
{
str8_lit_comp(""),
str8_lit_comp("b"),
str8_lit_comp("c"),
str8_lit_comp("B"),
str8_lit_comp("C"),
str8_lit_comp("f"),
str8_lit_comp("F"),
str8_lit_comp("g"),
str8_lit_comp("h"),
str8_lit_comp("r"),
str8_lit_comp("s"),
str8_lit_comp("i"),
str8_lit_comp("w"),
str8_lit_comp("W"),
str8_lit_comp("k"),
str8_lit_comp("K"),
str8_lit_comp("L"),
str8_lit_comp("R"),
str8_lit_comp("U"),
str8_lit_comp("D"),
str8_lit_comp("G"),
str8_lit_comp("P"),
str8_lit_comp("3"),
str8_lit_comp("p"),
str8_lit_comp("O"),
str8_lit_comp("o"),
str8_lit_comp("!"),
str8_lit_comp("1"),
str8_lit_comp("<"),
str8_lit_comp(">"),
str8_lit_comp("^"),
str8_lit_comp("v"),
str8_lit_comp("9"),
str8_lit_comp("0"),
str8_lit_comp("7"),
str8_lit_comp("8"),
str8_lit_comp("+"),
str8_lit_comp("-"),
str8_lit_comp("'"),
str8_lit_comp("\""),
str8_lit_comp("M"),
str8_lit_comp("."),
str8_lit_comp("x"),
str8_lit_comp("q"),
str8_lit_comp("j"),
str8_lit_comp("u"),
str8_lit_comp("m"),
str8_lit_comp("n"),
str8_lit_comp("l"),
str8_lit_comp("a"),
str8_lit_comp("z"),
str8_lit_comp("y"),
str8_lit_comp("X"),
str8_lit_comp("Y"),
str8_lit_comp("S"),
str8_lit_comp("T"),
str8_lit_comp("Z"),
str8_lit_comp("d"),
str8_lit_comp("N"),
str8_lit_comp("E"),
str8_lit_comp("H"),
str8_lit_comp("e"),
str8_lit_comp("I"),
str8_lit_comp("J"),
str8_lit_comp("A"),
str8_lit_comp("?"),
str8_lit_comp("4"),
str8_lit_comp("5"),
str8_lit_comp("c"),
};
C_LINKAGE_END
+57 -310
View File
@@ -9,10 +9,10 @@
typedef enum DF_CfgSrc
{
DF_CfgSrc_User,
DF_CfgSrc_Profile,
DF_CfgSrc_Project,
DF_CfgSrc_CommandLine,
DF_CfgSrc_Transient,
DF_CfgSrc_COUNT
DF_CfgSrc_COUNT,
} DF_CfgSrc;
typedef enum DF_EntityKind
@@ -22,9 +22,7 @@ DF_EntityKind_Root,
DF_EntityKind_Machine,
DF_EntityKind_File,
DF_EntityKind_OverrideFileLink,
DF_EntityKind_PendingFileChange,
DF_EntityKind_DiagLog,
DF_EntityKind_FlashMarker,
DF_EntityKind_AutoViewRule,
DF_EntityKind_WatchPin,
DF_EntityKind_Breakpoint,
DF_EntityKind_Condition,
@@ -33,34 +31,27 @@ DF_EntityKind_Executable,
DF_EntityKind_Arguments,
DF_EntityKind_ExecutionPath,
DF_EntityKind_EntryPointName,
DF_EntityKind_RecentProject,
DF_EntityKind_Source,
DF_EntityKind_Dest,
DF_EntityKind_CtrlRequest,
DF_EntityKind_Process,
DF_EntityKind_Thread,
DF_EntityKind_Module,
DF_EntityKind_DebugInfoOverride,
DF_EntityKind_PendingThreadName,
DF_EntityKind_DebugInfoPath,
DF_EntityKind_ConversionTask,
DF_EntityKind_ConversionFail,
DF_EntityKind_EndedProcess,
DF_EntityKind_COUNT
DF_EntityKind_COUNT,
} DF_EntityKind;
typedef enum DF_NameKind
{
DF_NameKind_Null,
DF_NameKind_EntityName,
DF_NameKind_EntityKindName,
DF_NameKind_COUNT
} DF_NameKind;
typedef enum DF_CoreCmdKind
{
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Exit,
DF_CoreCmdKind_RunCommand,
DF_CoreCmdKind_Error,
DF_CoreCmdKind_OSEvent,
DF_CoreCmdKind_LaunchAndRun,
DF_CoreCmdKind_LaunchAndInit,
DF_CoreCmdKind_Kill,
@@ -83,8 +74,6 @@ DF_CoreCmdKind_StepInto,
DF_CoreCmdKind_StepOver,
DF_CoreCmdKind_RunToCursor,
DF_CoreCmdKind_SetNextStatement,
DF_CoreCmdKind_EnableSoloSteppingMode,
DF_CoreCmdKind_DisableSoloSteppingMode,
DF_CoreCmdKind_SelectThread,
DF_CoreCmdKind_SelectThreadWindow,
DF_CoreCmdKind_SelectThreadView,
@@ -109,8 +98,12 @@ DF_CoreCmdKind_ToggleFullscreen,
DF_CoreCmdKind_ConfirmAccept,
DF_CoreCmdKind_ConfirmCancel,
DF_CoreCmdKind_ResetToDefaultPanels,
DF_CoreCmdKind_ResetToCompactPanels,
DF_CoreCmdKind_NewPanelLeft,
DF_CoreCmdKind_NewPanelUp,
DF_CoreCmdKind_NewPanelRight,
DF_CoreCmdKind_NewPanelDown,
DF_CoreCmdKind_SplitPanel,
DF_CoreCmdKind_RotatePanelColumns,
DF_CoreCmdKind_NextPanel,
DF_CoreCmdKind_PrevPanel,
@@ -135,19 +128,25 @@ DF_CoreCmdKind_TabBarTop,
DF_CoreCmdKind_TabBarBottom,
DF_CoreCmdKind_SetCurrentPath,
DF_CoreCmdKind_Open,
DF_CoreCmdKind_Reload,
DF_CoreCmdKind_ReloadActive,
DF_CoreCmdKind_Switch,
DF_CoreCmdKind_SwitchToPartnerFile,
DF_CoreCmdKind_GoToDisassembly,
DF_CoreCmdKind_GoToSource,
DF_CoreCmdKind_SetFileOverrideLinkSrc,
DF_CoreCmdKind_SetFileOverrideLinkDst,
DF_CoreCmdKind_SetFileReplacementPath,
DF_CoreCmdKind_SetAutoViewRuleType,
DF_CoreCmdKind_SetAutoViewRuleViewRule,
DF_CoreCmdKind_OpenUser,
DF_CoreCmdKind_OpenProfile,
DF_CoreCmdKind_OpenProject,
DF_CoreCmdKind_OpenRecentProject,
DF_CoreCmdKind_ApplyUserData,
DF_CoreCmdKind_ApplyProfileData,
DF_CoreCmdKind_ApplyProjectData,
DF_CoreCmdKind_WriteUserData,
DF_CoreCmdKind_WriteProfileData,
DF_CoreCmdKind_WriteProjectData,
DF_CoreCmdKind_Edit,
DF_CoreCmdKind_Accept,
DF_CoreCmdKind_Cancel,
DF_CoreCmdKind_MoveLeft,
DF_CoreCmdKind_MoveRight,
DF_CoreCmdKind_MoveUp,
@@ -172,6 +171,8 @@ DF_CoreCmdKind_MoveUpPageSelect,
DF_CoreCmdKind_MoveDownPageSelect,
DF_CoreCmdKind_MoveUpWholeSelect,
DF_CoreCmdKind_MoveDownWholeSelect,
DF_CoreCmdKind_MoveUpReorder,
DF_CoreCmdKind_MoveDownReorder,
DF_CoreCmdKind_MoveHome,
DF_CoreCmdKind_MoveEnd,
DF_CoreCmdKind_MoveHomeSelect,
@@ -234,10 +235,12 @@ DF_CoreCmdKind_FindCodeLocation,
DF_CoreCmdKind_Filter,
DF_CoreCmdKind_ApplyFilter,
DF_CoreCmdKind_ClearFilter,
DF_CoreCmdKind_GettingStarted,
DF_CoreCmdKind_Commands,
DF_CoreCmdKind_Target,
DF_CoreCmdKind_Targets,
DF_CoreCmdKind_FilePathMap,
DF_CoreCmdKind_AutoViewRules,
DF_CoreCmdKind_Scheduler,
DF_CoreCmdKind_CallStack,
DF_CoreCmdKind_Modules,
@@ -256,14 +259,15 @@ DF_CoreCmdKind_Disassembly,
DF_CoreCmdKind_Breakpoints,
DF_CoreCmdKind_WatchPins,
DF_CoreCmdKind_ExceptionFilters,
DF_CoreCmdKind_Theme,
DF_CoreCmdKind_Settings,
DF_CoreCmdKind_PickFile,
DF_CoreCmdKind_PickFolder,
DF_CoreCmdKind_PickFileOrFolder,
DF_CoreCmdKind_CompleteQuery,
DF_CoreCmdKind_CancelQuery,
DF_CoreCmdKind_ToggleDevMenu,
DF_CoreCmdKind_COUNT
DF_CoreCmdKind_LogMarker,
DF_CoreCmdKind_COUNT,
} DF_CoreCmdKind;
typedef enum DF_IconKind
@@ -337,7 +341,7 @@ DF_IconKind_QuestionMark,
DF_IconKind_Person,
DF_IconKind_Briefcase,
DF_IconKind_Dot,
DF_IconKind_COUNT
DF_IconKind_COUNT,
} DF_IconKind;
typedef enum DF_CoreViewRuleKind
@@ -356,9 +360,10 @@ DF_CoreViewRuleKind_NoAddr,
DF_CoreViewRuleKind_RGBA,
DF_CoreViewRuleKind_Text,
DF_CoreViewRuleKind_Disasm,
DF_CoreViewRuleKind_Graph,
DF_CoreViewRuleKind_Bitmap,
DF_CoreViewRuleKind_Geo,
DF_CoreViewRuleKind_COUNT
DF_CoreViewRuleKind_COUNT,
} DF_CoreViewRuleKind;
typedef enum DF_CmdParamSlot
@@ -376,13 +381,18 @@ DF_CmdParamSlot_FilePath,
DF_CmdParamSlot_TextPoint,
DF_CmdParamSlot_CmdSpec,
DF_CmdParamSlot_ViewSpec,
DF_CmdParamSlot_CfgNode,
DF_CmdParamSlot_OSEvent,
DF_CmdParamSlot_VirtualAddr,
DF_CmdParamSlot_VirtualOff,
DF_CmdParamSlot_Index,
DF_CmdParamSlot_ID,
DF_CmdParamSlot_PreferDisassembly,
DF_CmdParamSlot_ForceConfirm,
DF_CmdParamSlot_COUNT
DF_CmdParamSlot_Dir2,
DF_CmdParamSlot_BaseUnwindIndex,
DF_CmdParamSlot_InlineUnwindIndex,
DF_CmdParamSlot_COUNT,
} DF_CmdParamSlot;
typedef struct DF_CmdParams DF_CmdParams;
@@ -401,12 +411,17 @@ String8 file_path;
TxtPt text_point;
struct DF_CmdSpec * cmd_spec;
struct DF_ViewSpec * view_spec;
struct DF_CfgNode * cfg_node;
struct OS_Event * os_event;
U64 vaddr;
U64 voff;
U64 index;
U64 id;
B32 prefer_dasm;
B32 force_confirm;
Dir2 dir2;
U64 base_unwind_index;
U64 inline_unwind_index;
};
DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_DEF(array);
@@ -417,6 +432,7 @@ DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(omit);
DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(rgba);
DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(text);
DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(disasm);
DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(graph);
DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(bitmap);
DF_CORE_VIEW_RULE_VIZ_BLOCK_PROD_FUNCTION_DEF(geo);
@@ -1515,288 +1531,19 @@ struct {B32 *value_ptr; String8 name;} DEV_toggle_table[] =
{&DEV_scratch_mouse_draw, str8_lit_comp("scratch_mouse_draw")},
{&DEV_updating_indicator, str8_lit_comp("updating_indicator")},
};
Rng1U64 df_g_cmd_param_slot_range_table[] =
{
{0},
{OffsetOf(DF_CmdParams, window), OffsetOf(DF_CmdParams, window) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, panel), OffsetOf(DF_CmdParams, panel) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, dest_panel), OffsetOf(DF_CmdParams, dest_panel) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, prev_view), OffsetOf(DF_CmdParams, prev_view) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, view), OffsetOf(DF_CmdParams, view) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, entity), OffsetOf(DF_CmdParams, entity) + sizeof(DF_Handle)},
{OffsetOf(DF_CmdParams, entity_list), OffsetOf(DF_CmdParams, entity_list) + sizeof(DF_HandleList)},
{OffsetOf(DF_CmdParams, string), OffsetOf(DF_CmdParams, string) + sizeof(String8)},
{OffsetOf(DF_CmdParams, file_path), OffsetOf(DF_CmdParams, file_path) + sizeof(String8)},
{OffsetOf(DF_CmdParams, text_point), OffsetOf(DF_CmdParams, text_point) + sizeof(TxtPt)},
{OffsetOf(DF_CmdParams, cmd_spec), OffsetOf(DF_CmdParams, cmd_spec) + sizeof(struct DF_CmdSpec *)},
{OffsetOf(DF_CmdParams, view_spec), OffsetOf(DF_CmdParams, view_spec) + sizeof(struct DF_ViewSpec *)},
{OffsetOf(DF_CmdParams, vaddr), OffsetOf(DF_CmdParams, vaddr) + sizeof(U64)},
{OffsetOf(DF_CmdParams, voff), OffsetOf(DF_CmdParams, voff) + sizeof(U64)},
{OffsetOf(DF_CmdParams, index), OffsetOf(DF_CmdParams, index) + sizeof(U64)},
{OffsetOf(DF_CmdParams, id), OffsetOf(DF_CmdParams, id) + sizeof(U64)},
{OffsetOf(DF_CmdParams, prefer_dasm), OffsetOf(DF_CmdParams, prefer_dasm) + sizeof(B32)},
{OffsetOf(DF_CmdParams, force_confirm), OffsetOf(DF_CmdParams, force_confirm) + sizeof(B32)},
};
DF_IconKind df_g_entity_kind_icon_kind_table[] =
{
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Machine,
DF_IconKind_FileOutline,
DF_IconKind_FileOutline,
DF_IconKind_FileOutline,
DF_IconKind_FileOutline,
DF_IconKind_Null,
DF_IconKind_Pin,
DF_IconKind_CircleFilled,
DF_IconKind_CircleFilled,
DF_IconKind_Target,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Threads,
DF_IconKind_Thread,
DF_IconKind_Module,
DF_IconKind_Null,
DF_IconKind_Threads,
DF_IconKind_Null,
DF_IconKind_Null,
DF_IconKind_Null,
};
String8 df_g_entity_kind_display_string_table[] =
{
str8_lit_comp("Nil"),
str8_lit_comp("Root"),
str8_lit_comp("Machine"),
str8_lit_comp("File"),
str8_lit_comp("Override File Link"),
str8_lit_comp("Pending File Change"),
str8_lit_comp("Diagnostics Log"),
str8_lit_comp("Flash Marker"),
str8_lit_comp("Watch Pin"),
str8_lit_comp("Breakpoint"),
str8_lit_comp("Condition"),
str8_lit_comp("Target"),
str8_lit_comp("Executable"),
str8_lit_comp("Arguments"),
str8_lit_comp("Execution Path"),
str8_lit_comp("Entry Point Name"),
str8_lit_comp("Source"),
str8_lit_comp("Destination"),
str8_lit_comp("Control Request"),
str8_lit_comp("Process"),
str8_lit_comp("Thread"),
str8_lit_comp("Module"),
str8_lit_comp("Debug Info Override"),
str8_lit_comp("Pending Thread Name"),
str8_lit_comp("Conversion Task"),
str8_lit_comp("Conversion Failure"),
str8_lit_comp("EndedProcess"),
};
String8 df_g_entity_kind_name_label_table[] =
{
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Expression"),
str8_lit_comp("Label"),
str8_lit_comp("Expression"),
str8_lit_comp("Label"),
str8_lit_comp("Executable"),
str8_lit_comp("Arguments"),
str8_lit_comp("Execution Path"),
str8_lit_comp("Symbol Name"),
str8_lit_comp("Path"),
str8_lit_comp("Path"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
str8_lit_comp("Label"),
};
DF_EntityKindFlags df_g_entity_kind_flags_table[] =
{
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(1*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 1*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 1*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 1*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 1*DF_EntityKindFlag_LeafMutationProfileConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 1*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 1*DF_EntityKindFlag_LeafMutationSoftHalt | 1*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 1*DF_EntityKindFlag_TreeMutationSoftHalt | 1*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
(0*DF_EntityKindFlag_LeafMutationUserConfig | 0*DF_EntityKindFlag_LeafMutationProfileConfig | 0*DF_EntityKindFlag_LeafMutationSoftHalt | 0*DF_EntityKindFlag_LeafMutationDebugInfoMap | 0*DF_EntityKindFlag_TreeMutationUserConfig | 0*DF_EntityKindFlag_TreeMutationProfileConfig | 0*DF_EntityKindFlag_TreeMutationSoftHalt | 0*DF_EntityKindFlag_TreeMutationDebugInfoMap | 0*DF_EntityKindFlag_NameIsCode | 0*DF_EntityKindFlag_UserDefinedLifetime),
};
DF_EntityOpFlags df_g_entity_kind_op_flags_table[] =
{
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (1*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (1*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (1*DF_EntityOpFlag_Enable) | (1*DF_EntityOpFlag_Condition) | (1*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (1*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (1*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (1*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (1*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (1*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (0*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(0*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
(1*DF_EntityOpFlag_Delete) | (0*DF_EntityOpFlag_Freeze) | (0*DF_EntityOpFlag_Edit) | (1*DF_EntityOpFlag_Rename) | (0*DF_EntityOpFlag_Enable) | (0*DF_EntityOpFlag_Condition) | (0*DF_EntityOpFlag_Duplicate),
};
String8 df_g_cfg_src_string_table[] =
{
str8_lit_comp("user"),
str8_lit_comp("profile"),
str8_lit_comp("command_line"),
str8_lit_comp("transient"),
};
DF_CoreCmdKind df_g_cfg_src_load_cmd_kind_table[] =
{
DF_CoreCmdKind_OpenUser,
DF_CoreCmdKind_OpenProfile,
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Null,
};
DF_CoreCmdKind df_g_cfg_src_write_cmd_kind_table[] =
{
DF_CoreCmdKind_WriteUserData,
DF_CoreCmdKind_WriteProfileData,
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Null,
};
DF_CoreCmdKind df_g_cfg_src_apply_cmd_kind_table[] =
{
DF_CoreCmdKind_ApplyUserData,
DF_CoreCmdKind_ApplyProfileData,
DF_CoreCmdKind_Null,
DF_CoreCmdKind_Null,
};
String8 df_g_icon_kind_text_table[] =
{
str8_lit_comp(""),
str8_lit_comp("b"),
str8_lit_comp("c"),
str8_lit_comp("B"),
str8_lit_comp("C"),
str8_lit_comp("f"),
str8_lit_comp("F"),
str8_lit_comp("g"),
str8_lit_comp("h"),
str8_lit_comp("r"),
str8_lit_comp("s"),
str8_lit_comp("i"),
str8_lit_comp("w"),
str8_lit_comp("W"),
str8_lit_comp("k"),
str8_lit_comp("K"),
str8_lit_comp("L"),
str8_lit_comp("R"),
str8_lit_comp("U"),
str8_lit_comp("D"),
str8_lit_comp("G"),
str8_lit_comp("P"),
str8_lit_comp("3"),
str8_lit_comp("p"),
str8_lit_comp("O"),
str8_lit_comp("o"),
str8_lit_comp("!"),
str8_lit_comp("1"),
str8_lit_comp("<"),
str8_lit_comp(">"),
str8_lit_comp("^"),
str8_lit_comp("v"),
str8_lit_comp("9"),
str8_lit_comp("0"),
str8_lit_comp("7"),
str8_lit_comp("8"),
str8_lit_comp("+"),
str8_lit_comp("-"),
str8_lit_comp("'"),
str8_lit_comp("\""),
str8_lit_comp("M"),
str8_lit_comp("."),
str8_lit_comp("x"),
str8_lit_comp("q"),
str8_lit_comp("j"),
str8_lit_comp("u"),
str8_lit_comp("m"),
str8_lit_comp("n"),
str8_lit_comp("l"),
str8_lit_comp("a"),
str8_lit_comp("z"),
str8_lit_comp("y"),
str8_lit_comp("X"),
str8_lit_comp("Y"),
str8_lit_comp("S"),
str8_lit_comp("T"),
str8_lit_comp("Z"),
str8_lit_comp("d"),
str8_lit_comp("N"),
str8_lit_comp("E"),
str8_lit_comp("H"),
str8_lit_comp("e"),
str8_lit_comp("I"),
str8_lit_comp("J"),
str8_lit_comp("A"),
str8_lit_comp("?"),
str8_lit_comp("4"),
str8_lit_comp("5"),
str8_lit_comp("c"),
};
C_LINKAGE_BEGIN
extern Rng1U64 df_g_cmd_param_slot_range_table[24];
extern DF_IconKind df_g_entity_kind_icon_kind_table[25];
extern String8 df_g_entity_kind_display_string_table[25];
extern String8 df_g_entity_kind_name_label_table[25];
extern DF_EntityKindFlags df_g_entity_kind_flags_table[25];
extern DF_EntityOpFlags df_g_entity_kind_op_flags_table[25];
extern String8 df_g_cfg_src_string_table[4];
extern DF_CoreCmdKind df_g_cfg_src_load_cmd_kind_table[4];
extern DF_CoreCmdKind df_g_cfg_src_write_cmd_kind_table[4];
extern DF_CoreCmdKind df_g_cfg_src_apply_cmd_kind_table[4];
extern String8 df_g_icon_kind_text_table[69];
C_LINKAGE_END
#endif // DF_CORE_META_H
+1 -1
View File
@@ -4,4 +4,4 @@
#include "df/core/df_core.c"
#include "df/gfx/df_gfx.c"
#include "df/gfx/df_views.c"
#include "df/gfx/df_view_rule_hooks.c"
#include "df/gfx/df_view_rules.c"
+1 -1
View File
@@ -7,6 +7,6 @@
#include "df/core/df_core.h"
#include "df/gfx/df_gfx.h"
#include "df/gfx/df_views.h"
#include "df/gfx/df_view_rule_hooks.h"
#include "df/gfx/df_view_rules.h"
#endif // DEBUG_FRONTEND_INC_H
+4309 -2072
View File
File diff suppressed because it is too large Load Diff
+170 -128
View File
@@ -47,71 +47,6 @@ struct DF_StringBindingPair
DF_Binding binding;
};
////////////////////////////////
//~ rjf: Text Searching Types
typedef struct DF_TextSearchMatch DF_TextSearchMatch;
struct DF_TextSearchMatch
{
TxtPt pt;
};
typedef struct DF_TextSearchMatchChunkNode DF_TextSearchMatchChunkNode;
struct DF_TextSearchMatchChunkNode
{
DF_TextSearchMatchChunkNode *next;
DF_TextSearchMatch *v;
U64 count;
U64 cap;
};
typedef struct DF_TextSearchMatchChunkList DF_TextSearchMatchChunkList;
struct DF_TextSearchMatchChunkList
{
DF_TextSearchMatchChunkNode *first;
DF_TextSearchMatchChunkNode *last;
U64 node_count;
U64 total_count;
};
typedef struct DF_TextSearchMatchArray DF_TextSearchMatchArray;
struct DF_TextSearchMatchArray
{
DF_TextSearchMatch *v;
U64 count;
};
typedef struct DF_TextSearchCacheNode DF_TextSearchCacheNode;
struct DF_TextSearchCacheNode
{
// rjf: links
DF_TextSearchCacheNode *next;
DF_TextSearchCacheNode *prev;
// rjf: allocation
Arena *arena;
// rjf: search parameters
U128 hash;
String8 needle;
DF_TextSliceFlags flags;
TxtPt start_pt;
// rjf: search results
B32 good;
DF_TextSearchMatchChunkList search_matches;
// rjf: last time touched
U64 last_time_touched_us;
};
typedef struct DF_TextSearchCacheSlot DF_TextSearchCacheSlot;
struct DF_TextSearchCacheSlot
{
DF_TextSearchCacheNode *first;
DF_TextSearchCacheNode *last;
};
////////////////////////////////
//~ rjf: Key Map Types
@@ -131,14 +66,24 @@ struct DF_KeyMapSlot
DF_KeyMapNode *last;
};
////////////////////////////////
//~ rjf: Setting Types
typedef struct DF_SettingVal DF_SettingVal;
struct DF_SettingVal
{
B32 set;
S32 s32;
};
////////////////////////////////
//~ rjf: View Functions
struct DF_View;
struct DF_Panel;
struct DF_Window;
typedef struct DF_View DF_View;
typedef struct DF_Panel DF_Panel;
typedef struct DF_Window DF_Window;
#define DF_VIEW_SETUP_FUNCTION_SIG(name) void name(struct DF_View *view, DF_CfgNode *cfg_root)
#define DF_VIEW_SETUP_FUNCTION_SIG(name) void name(DF_Window *ws, struct DF_View *view, DF_CfgNode *cfg_root)
#define DF_VIEW_SETUP_FUNCTION_NAME(name) df_view_setup_##name
#define DF_VIEW_SETUP_FUNCTION_DEF(name) internal DF_VIEW_SETUP_FUNCTION_SIG(DF_VIEW_SETUP_FUNCTION_NAME(name))
typedef DF_VIEW_SETUP_FUNCTION_SIG(DF_ViewSetupFunctionType);
@@ -165,13 +110,23 @@ typedef U32 DF_ViewSpecFlags;
enum
{
DF_ViewSpecFlag_ParameterizedByEntity = (1<<0),
DF_ViewSpecFlag_CanSerialize = (1<<1),
DF_ViewSpecFlag_CanSerializeEntityPath = (1<<2),
DF_ViewSpecFlag_CanFilter = (1<<3),
DF_ViewSpecFlag_FilterIsCode = (1<<4),
DF_ViewSpecFlag_TypingAutomaticallyFilters = (1<<5),
DF_ViewSpecFlag_ProjectSpecific = (1<<1),
DF_ViewSpecFlag_CanSerialize = (1<<2),
DF_ViewSpecFlag_CanSerializeEntityPath = (1<<3),
DF_ViewSpecFlag_CanSerializeQuery = (1<<4),
DF_ViewSpecFlag_CanFilter = (1<<5),
DF_ViewSpecFlag_FilterIsCode = (1<<6),
DF_ViewSpecFlag_TypingAutomaticallyFilters = (1<<7),
};
typedef enum DF_NameKind
{
DF_NameKind_Null,
DF_NameKind_EntityName,
DF_NameKind_COUNT
}
DF_NameKind;
typedef struct DF_ViewSpecInfo DF_ViewSpecInfo;
struct DF_ViewSpecInfo
{
@@ -242,11 +197,10 @@ struct DF_View
U64 loading_progress_v;
U64 loading_progress_v_target;
// rjf: update flash animation state
F32 flash_t;
// rjf: view state
UI_ScrollPt2 scroll_pos;
TxtPt cursor;
TxtPt mark;
// rjf: ctrl context overrides
DF_CtrlCtx ctrl_ctx_overrides;
@@ -260,6 +214,7 @@ struct DF_View
// rjf: view kind info
DF_ViewSpec *spec;
DF_Handle entity;
DF_Handle project;
// rjf: filter mode
B32 is_filtering;
@@ -291,15 +246,15 @@ struct DF_Panel
// rjf: split data
Axis2 split_axis;
Vec2F32 off_pct_of_parent;
Vec2F32 off_pct_of_parent_target;
Vec2F32 size_pct_of_parent;
Vec2F32 size_pct_of_parent_target;
F32 pct_of_parent;
// rjf: animated rectangle data
Rng2F32 animated_rect_pct;
// rjf: tab params
Side tab_side;
// rjf: stable view stacks (tabs)
// rjf: stable views (tabs)
DF_View *first_tab_view;
DF_View *last_tab_view;
U64 tab_view_count;
@@ -336,6 +291,19 @@ struct DF_DragDropPayload
TxtPt text_point;
};
////////////////////////////////
//~ rjf: Rich Hover Types
typedef struct DF_RichHoverInfo DF_RichHoverInfo;
struct DF_RichHoverInfo
{
DF_Handle process;
Rng1U64 vaddr_range;
DF_Handle module;
Rng1U64 voff_range;
DI_Key dbgi_key;
};
////////////////////////////////
//~ rjf: View Rule Spec Types
@@ -356,11 +324,11 @@ enum
#define DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_NAME(name) df_gfx_view_rule_line_stringize__##name
#define DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_DEF(name) internal DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_SIG(DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_NAME(name))
#define DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_SIG(name) void name(DF_ExpandKey key, DF_Eval eval, DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, struct DF_CfgNode *cfg)
#define DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_SIG(name) void name(DF_ExpandKey key, DF_Eval eval, DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, struct DF_CfgNode *cfg)
#define DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_NAME(name) df_gfx_view_rule_row_ui__##name
#define DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_DEF(name) DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_SIG(DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_NAME(name))
#define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_SIG(name) void name(struct DF_Window *ws, DF_ExpandKey key, DF_Eval eval, DBGI_Scope *dbgi_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, struct DF_CfgNode *cfg, Vec2F32 dim)
#define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_SIG(name) void name(struct DF_Window *ws, DF_ExpandKey key, DF_Eval eval, String8 string, DI_Scope *di_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, struct DF_CfgNode *cfg, Vec2F32 dim)
#define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_NAME(name) df_gfx_view_rule_block_ui__##name
#define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_DEF(name) DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_SIG(DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_NAME(name))
@@ -378,6 +346,7 @@ struct DF_GfxViewRuleSpecInfo
DF_GfxViewRuleLineStringizeHookFunctionType *line_stringize;
DF_GfxViewRuleRowUIFunctionType *row_ui;
DF_GfxViewRuleBlockUIFunctionType *block_ui;
String8 tab_view_spec_name;
};
typedef struct DF_GfxViewRuleSpecInfoArray DF_GfxViewRuleSpecInfoArray;
@@ -417,6 +386,24 @@ typedef enum DF_FontSlot
}
DF_FontSlot;
typedef enum DF_PaletteCode
{
DF_PaletteCode_Base,
DF_PaletteCode_MenuBar,
DF_PaletteCode_Floating,
DF_PaletteCode_ImplicitButton,
DF_PaletteCode_PlainButton,
DF_PaletteCode_PositivePopButton,
DF_PaletteCode_NegativePopButton,
DF_PaletteCode_NeutralPopButton,
DF_PaletteCode_ScrollBarButton,
DF_PaletteCode_Tab,
DF_PaletteCode_TabInactive,
DF_PaletteCode_DropSiteOverlay,
DF_PaletteCode_COUNT
}
DF_PaletteCode;
////////////////////////////////
//~ rjf: UI Helper & Widget Types
@@ -441,8 +428,10 @@ enum
typedef U32 DF_CodeSliceFlags;
enum
{
DF_CodeSliceFlag_Margin = (1<<0),
DF_CodeSliceFlag_LineNums = (1<<1),
DF_CodeSliceFlag_Clickable = (1<<0),
DF_CodeSliceFlag_PriorityMargin = (1<<1),
DF_CodeSliceFlag_CatchallMargin = (1<<2),
DF_CodeSliceFlag_LineNums = (1<<3),
};
typedef struct DF_CodeSliceParams DF_CodeSliceParams;
@@ -453,23 +442,25 @@ struct DF_CodeSliceParams
Rng1S64 line_num_range;
String8 *line_text;
Rng1U64 *line_ranges;
TXTI_TokenArray *line_tokens;
TXT_TokenArray *line_tokens;
DF_EntityList *line_bps;
DF_EntityList *line_ips;
DF_EntityList *line_pins;
DF_TextLineDasm2SrcInfoList *line_dasm2src;
DF_TextLineSrc2DasmInfoList *line_src2dasm;
DF_EntityList relevant_binaries;
U64 *line_vaddrs;
DF_LineList *line_infos;
DI_KeyList relevant_dbgi_keys;
// rjf: visual parameters
F_Tag font;
F32 font_size;
F32 tab_size;
String8 search_query;
F32 line_height_px;
F32 margin_width_px;
F32 priority_margin_width_px;
F32 catchall_margin_width_px;
F32 line_num_width_px;
F32 line_text_max_width_px;
DF_EntityList flash_ranges;
F32 margin_float_off_px;
};
typedef struct DF_CodeSliceSignal DF_CodeSliceSignal;
@@ -499,6 +490,11 @@ enum
DF_AutoCompListerFlag_Locals = (1<<0),
DF_AutoCompListerFlag_Registers = (1<<1),
DF_AutoCompListerFlag_ViewRules = (1<<2),
DF_AutoCompListerFlag_ViewRuleParams= (1<<3),
DF_AutoCompListerFlag_Members = (1<<4),
DF_AutoCompListerFlag_Languages = (1<<5),
DF_AutoCompListerFlag_Architectures = (1<<6),
DF_AutoCompListerFlag_Tex2DFormats = (1<<7),
};
typedef struct DF_AutoCompListerItem DF_AutoCompListerItem;
@@ -534,6 +530,13 @@ struct DF_AutoCompListerItemArray
U64 count;
};
typedef struct DF_AutoCompListerParams DF_AutoCompListerParams;
struct DF_AutoCompListerParams
{
DF_AutoCompListerFlags flags;
String8List strings;
};
////////////////////////////////
//~ rjf: Per-Window State
@@ -554,34 +557,51 @@ struct DF_Window
UI_State *ui;
F32 code_font_size_delta;
F32 main_font_size_delta;
B32 window_temporarily_focused_ipc;
// rjf: view state delta history
DF_StateDeltaHistory *view_state_hist;
// rjf: context menu info
// rjf: dev interface state
B32 dev_menu_is_open;
// rjf: menu bar state
B32 menu_bar_focused;
B32 menu_bar_focused_on_press;
B32 menu_bar_key_held;
B32 menu_bar_focus_press_started;
UI_Key drop_completion_ctx_menu_key;
DF_Handle drop_completion_entity;
DF_Handle drop_completion_panel;
// rjf: code context menu state
Arena *code_ctx_menu_arena;
UI_Key code_ctx_menu_key;
DF_Handle code_ctx_menu_file;
U128 code_ctx_menu_text_key;
TXT_LangKind code_ctx_menu_lang_kind;
TxtRng code_ctx_menu_range;
U64 code_ctx_menu_vaddr;
DF_LineList code_ctx_menu_lines;
// rjf: entity context menu state
UI_Key entity_ctx_menu_key;
DF_Handle entity_ctx_menu_entity;
U8 entity_ctx_menu_input_buffer[1024];
U64 entity_ctx_menu_input_size;
TxtPt entity_ctx_menu_input_cursor;
TxtPt entity_ctx_menu_input_mark;
// rjf: tab context menu state
UI_Key tab_ctx_menu_key;
DF_Handle tab_ctx_menu_view;
// rjf: autocomplete lister state
U64 autocomp_last_frame_idx;
B32 autocomp_force_closed;
B32 autocomp_query_dirty;
UI_Key autocomp_root_key;
DF_CtrlCtx autocomp_ctrl_ctx;
DF_AutoCompListerFlags autocomp_lister_flags;
Arena *autocomp_lister_params_arena;
DF_AutoCompListerParams autocomp_lister_params;
U64 autocomp_cursor_off;
U8 autocomp_lister_query_buffer[1024];
U64 autocomp_lister_query_size;
F32 autocomp_open_t;
@@ -606,6 +626,7 @@ struct DF_Window
Vec2F32 hover_eval_spawn_pos;
String8 hover_eval_string;
// rjf: hover eval timer
U64 hover_eval_first_frame_idx;
U64 hover_eval_last_frame_idx;
@@ -751,10 +772,11 @@ struct DF_GfxState
// rjf: drag/drop state machine
DF_DragDropState drag_drop_state;
// rjf: hover line info correllation state
DF_Handle hover_line_binary;
U64 hover_line_voff;
B32 hover_line_set_this_frame;
// rjf: rich hover info
Arena *rich_hover_info_next_arena;
Arena *rich_hover_info_current_arena;
DF_RichHoverInfo rich_hover_info_next;
DF_RichHoverInfo rich_hover_info_current;
// rjf: running theme state
DF_Theme cfg_theme_target;
@@ -763,7 +785,14 @@ struct DF_GfxState
Arena *cfg_code_font_path_arena;
String8 cfg_main_font_path;
String8 cfg_code_font_path;
F_Tag cfg_font_tags[DF_FontSlot_COUNT];
F_Tag cfg_font_tags[DF_FontSlot_COUNT]; // derivative from font paths
UI_Palette cfg_palettes[DF_PaletteCode_COUNT]; // derivative from theme
// rjf: settings
DF_SettingVal cfg_setting_vals[DF_CfgSrc_COUNT][DF_SettingCode_COUNT];
// rjf: icon texture
R_Handle icon_texture;
};
////////////////////////////////
@@ -799,7 +828,8 @@ read_only global DF_View df_g_nil_view =
0,
0,
0,
0,
{0},
{0},
{0},
{0},
0,
@@ -822,6 +852,8 @@ read_only global DF_Panel df_g_nil_panel =
global DF_GfxState *df_gfx_state = 0;
global DF_DragDropPayload df_g_drag_drop_payload = {0};
global DF_Handle df_g_last_drag_drop_panel = {0};
global DF_Handle df_g_last_drag_drop_prev_tab = {0};
////////////////////////////////
//~ rjf: Basic Helpers
@@ -832,6 +864,7 @@ internal DF_PathQuery df_path_query_from_string(String8 string);
//~ rjf: View Type Functions
internal B32 df_view_is_nil(DF_View *view);
internal B32 df_view_is_project_filtered(DF_View *view);
internal DF_Handle df_handle_from_view(DF_View *view);
internal DF_View *df_view_from_handle(DF_Handle handle);
@@ -862,12 +895,13 @@ internal DF_PanelRec df_panel_rec_df(DF_Panel *panel, U64 sib_off, U64 child_off
#define df_panel_rec_df_post(panel) df_panel_rec_df(panel, OffsetOf(DF_Panel, prev), OffsetOf(DF_Panel, last))
//- rjf: panel -> rect calculations
internal Rng2F32 df_rect_from_panel_child(Rng2F32 parent_rect, DF_Panel *parent, DF_Panel *panel);
internal Rng2F32 df_rect_from_panel(Rng2F32 root_rect, DF_Panel *root, DF_Panel *panel);
internal Rng2F32 df_target_rect_from_panel_child(Rng2F32 parent_rect, DF_Panel *parent, DF_Panel *panel);
internal Rng2F32 df_target_rect_from_panel(Rng2F32 root_rect, DF_Panel *root, DF_Panel *panel);
//- rjf: view ownership insertion/removal
internal void df_panel_insert_tab_view(DF_Panel *panel, DF_View *prev_view, DF_View *view);
internal void df_panel_remove_tab_view(DF_Panel *panel, DF_View *view);
internal DF_View *df_selected_tab_from_panel(DF_Panel *panel);
//- rjf: icons & display strings
internal String8 df_display_string_from_view(Arena *arena, DF_CtrlCtx ctrl_ctx, DF_View *view);
@@ -904,9 +938,8 @@ internal B32 df_drag_drop(DF_DragDropPayload *out_payload);
internal void df_drag_kill(void);
internal void df_queue_drag_drop(void);
internal void df_set_hovered_line_info(DF_Entity *binary, U64 voff);
internal DF_Entity *df_get_hovered_line_info_binary(void);
internal U64 df_get_hovered_line_info_voff(void);
internal void df_set_rich_hover_info(DF_RichHoverInfo *info);
internal DF_RichHoverInfo df_get_rich_hover_info(void);
////////////////////////////////
//~ rjf: View Spec State Functions
@@ -921,13 +954,14 @@ internal DF_ViewSpec *df_view_spec_from_cmd_param_slot_spec(DF_CmdParamSlot slot
internal void df_register_gfx_view_rule_specs(DF_GfxViewRuleSpecInfoArray specs);
internal DF_GfxViewRuleSpec *df_gfx_view_rule_spec_from_string(String8 string);
internal DF_ViewSpec *df_tab_view_spec_from_gfx_view_rule_spec(DF_GfxViewRuleSpec *spec);
////////////////////////////////
//~ rjf: View State Functions
internal DF_View *df_view_alloc(void);
internal void df_view_release(DF_View *view);
internal void df_view_equip_spec(DF_View *view, DF_ViewSpec *spec, DF_Entity *entity, String8 default_query, DF_CfgNode *cfg_root);
internal void df_view_equip_spec(DF_Window *window, DF_View *view, DF_ViewSpec *spec, DF_Entity *entity, String8 default_query, DF_CfgNode *cfg_root);
internal void df_view_equip_loading_info(DF_View *view, B32 is_loading, U64 progress_v, U64 progress_target);
internal void df_view_clear_user_state(DF_View *view);
internal void *df_view_get_or_push_user_state(DF_View *view, U64 size);
@@ -955,14 +989,14 @@ internal DF_Window *df_window_open(Vec2F32 size, OS_Handle preferred_monitor, DF
internal DF_Window *df_window_from_os_handle(OS_Handle os);
internal void df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, DF_CmdList *cmds);
internal void df_window_update_and_render(Arena *arena, DF_Window *ws, DF_CmdList *cmds);
////////////////////////////////
//~ rjf: Eval Viz
internal String8 df_eval_escaped_from_raw_string(Arena *arena, String8 raw);
internal String8List df_single_line_eval_value_strings_from_eval(Arena *arena, DF_EvalVizStringFlags flags, TG_Graph *graph, RADDBG_Parsed *rdbg, DF_CtrlCtx *ctrl_ctx, U32 default_radix, F_Tag font, F32 font_size, F32 max_size, S32 depth, DF_Eval eval, TG_Member *opt_member, DF_CfgTable *cfg_table);
internal DF_EvalVizWindowedRowList df_eval_viz_windowed_row_list_from_viz_block_list(Arena *arena, DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_EvalView *eval_view, U32 default_radix, F_Tag font, F32 font_size, Rng1S64 visible_range, DF_EvalVizBlockList *blocks);
internal String8List df_single_line_eval_value_strings_from_eval(Arena *arena, DF_EvalVizStringFlags flags, TG_Graph *graph, RDI_Parsed *rdi, DF_CtrlCtx *ctrl_ctx, U32 default_radix, F_Tag font, F32 font_size, F32 max_size, S32 depth, DF_Eval eval, TG_Member *opt_member, DF_CfgTable *cfg_table);
internal DF_EvalVizWindowedRowList df_eval_viz_windowed_row_list_from_viz_block_list(Arena *arena, DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_EvalView *eval_view, U32 default_radix, F_Tag font, F32 font_size, Rng1S64 visible_range, DF_EvalVizBlockList *blocks);
////////////////////////////////
//~ rjf: Hover Eval
@@ -977,7 +1011,9 @@ internal DF_AutoCompListerItemArray df_autocomp_lister_item_array_from_chunk_lis
internal int df_autocomp_lister_item_qsort_compare(DF_AutoCompListerItem *a, DF_AutoCompListerItem *b);
internal void df_autocomp_lister_item_array_sort__in_place(DF_AutoCompListerItemArray *array);
internal void df_set_autocomp_lister_query(DF_Window *ws, UI_Key root_key, DF_CtrlCtx ctrl_ctx, DF_AutoCompListerFlags flags, String8 query);
internal String8 df_autocomp_query_word_from_input_string_off(String8 input, U64 cursor_off);
internal DF_AutoCompListerParams df_view_rule_autocomp_lister_params_from_input_cursor(Arena *arena, String8 string, U64 cursor_off);
internal void df_set_autocomp_lister_query(DF_Window *ws, UI_Key root_key, DF_CtrlCtx ctrl_ctx, DF_AutoCompListerParams *params, String8 input, U64 cursor_off);
////////////////////////////////
//~ rjf: Search Strings
@@ -985,17 +1021,6 @@ internal void df_set_autocomp_lister_query(DF_Window *ws, UI_Key root_key, DF_Ct
internal void df_set_search_string(String8 string);
internal String8 df_push_search_string(Arena *arena);
////////////////////////////////
//~ rjf: Text Searching
internal void df_text_search_match_chunk_list_push(Arena *arena, DF_TextSearchMatchChunkList *list, U64 cap, DF_TextSearchMatch *match);
internal DF_TextSearchMatchArray df_text_search_match_array_from_chunk_list(Arena *arena, DF_TextSearchMatchChunkList *chunks);
internal U64 df_text_search_little_hash_from_hash(U128 hash);
internal void df_text_search_thread_entry_point(void *p);
internal int df_text_search_match_array_qsort_compare(TxtPt *a, TxtPt *b);
internal void df_text_search_match_array_sort_in_place(DF_TextSearchMatchArray *array);
internal DF_TextSearchMatch df_text_search_match_array_find_nearest__linear_scan(DF_TextSearchMatchArray *array, TxtPt pt, Side side);
////////////////////////////////
//~ rjf: Colors, Fonts, Config
@@ -1010,15 +1035,33 @@ internal DF_CmdSpecList df_cmd_spec_list_from_event_flags(Arena *arena, OS_Event
//- rjf: colors
internal Vec4F32 df_rgba_from_theme_color(DF_ThemeColor color);
internal DF_ThemeColor df_theme_color_from_txti_token_kind(TXTI_TokenKind kind);
internal DF_ThemeColor df_theme_color_from_txt_token_kind(TXT_TokenKind kind);
//- rjf: code -> palette
internal UI_Palette *df_palette_from_code(DF_PaletteCode code);
//- rjf: fonts/sizes
internal F_Tag df_font_from_slot(DF_FontSlot slot);
internal F32 df_font_size_from_slot(DF_Window *ws, DF_FontSlot slot);
//- rjf: settings
internal DF_SettingVal df_setting_val_from_code(DF_SettingCode code);
//- rjf: config serialization
internal int df_qsort_compare__cfg_string_bindings(DF_StringBindingPair *a, DF_StringBindingPair *b);
internal String8List df_cfg_strings_from_gfx(Arena *arena, String8 root_path, DF_CfgSrc source);
////////////////////////////////
//~ rjf: Process Control Info Stringification
internal String8 df_string_from_exception_code(U32 code);
internal String8 df_stop_explanation_string_icon_from_ctrl_event(Arena *arena, CTRL_Event *event, DF_IconKind *icon_out);
////////////////////////////////
//~ rjf: UI Building Helpers
#define DF_Palette(code) UI_Palette(df_palette_from_code(code))
////////////////////////////////
//~ rjf: UI Widgets: Fancy Buttons
@@ -1029,7 +1072,7 @@ internal void df_cmd_list_menu_buttons(DF_Window *ws, U64 count, DF_CoreCmdKind
internal UI_Signal df_icon_button(DF_IconKind kind, FuzzyMatchRangeList *matches, String8 string);
internal UI_Signal df_icon_buttonf(DF_IconKind kind, FuzzyMatchRangeList *matches, char *fmt, ...);
internal void df_entity_tooltips(DF_Entity *entity);
internal void df_entity_desc_button(DF_Window *ws, DF_Entity *entity, FuzzyMatchRangeList *name_matches, String8 fuzzy_query);
internal UI_Signal df_entity_desc_button(DF_Window *ws, DF_Entity *entity, FuzzyMatchRangeList *name_matches, String8 fuzzy_query, B32 is_implicit);
internal void df_entity_src_loc_button(DF_Window *ws, DF_Entity *entity, TxtPt point);
////////////////////////////////
@@ -1040,8 +1083,7 @@ internal UI_BOX_CUSTOM_DRAW(df_bp_box_draw_extensions);
internal DF_CodeSliceSignal df_code_slice(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *preferred_column, String8 string);
internal DF_CodeSliceSignal df_code_slicef(DF_Window *ws, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_CodeSliceParams *params, TxtPt *cursor, TxtPt *mark, S64 *preferred_column, char *fmt, ...);
internal B32 df_do_txti_controls(TXTI_Handle handle, U64 line_count_per_page, TxtPt *cursor, TxtPt *mark, S64 *preferred_column);
internal B32 df_do_dasm_controls(DASM_Handle handle, U64 line_count_per_page, TxtPt *cursor, TxtPt *mark, S64 *preferred_column);
internal B32 df_do_txt_controls(TXT_TextInfo *info, String8 data, U64 line_count_per_page, TxtPt *cursor, TxtPt *mark, S64 *preferred_column);
////////////////////////////////
//~ rjf: UI Widgets: Fancy Labels
+347 -353
View File
@@ -8,6 +8,7 @@
@embed_file df_g_default_main_font_bytes: "../data/Roboto-Regular.ttf"
@embed_file df_g_default_code_font_bytes: "../data/liberation-mono.ttf"
//@embed_file df_g_default_code_font_bytes: "../data/Inconsolata-Regular.ttf"
@embed_file df_g_icon_file_bytes: "../data/logo.ico"
////////////////////////////////
//~ rjf: Default Bindings
@@ -86,8 +87,13 @@ DF_DefaultBindingTable:
{ "switch_to_partner_file" O 0 0 alt }
//- rjf: setting config paths
{ "load_user" O ctrl shift alt }
{ "load_profile" O ctrl 0 alt }
{ "open_user" O ctrl shift alt }
{ "open_project" O ctrl 0 alt }
//- rjf: meta controls
{ "edit" F2 0 0 0 }
{ "accept" Return 0 0 0 }
{ "cancel" Esc 0 0 0 }
//- rjf: directional movement & text controls
{ "move_left" Left 0 0 0 }
@@ -114,6 +120,8 @@ DF_DefaultBindingTable:
{ "move_down_page_select" PageDown 0 shift 0 }
{ "move_up_whole_select" Home ctrl shift 0 }
{ "move_down_whole_select" End ctrl shift 0 }
{ "move_up_reorder" Up 0 0 alt }
{ "move_down_reorder" Down 0 0 alt }
{ "move_home" Home 0 0 0 }
{ "move_end" End 0 0 0 }
{ "move_home_select" Home 0 shift 0 }
@@ -124,8 +132,10 @@ DF_DefaultBindingTable:
{ "backspace_single" Backspace 0 0 0 }
{ "backspace_chunk" Backspace ctrl 0 0 }
{ "copy" C ctrl 0 0 }
{ "copy" Insert ctrl 0 0 }
{ "cut" X ctrl 0 0 }
{ "paste" V ctrl 0 0 }
{ "paste" Insert 0 shift 0 }
{ "insert_text" Null 0 0 0 }
//- rjf: code navigation
@@ -161,6 +171,14 @@ DF_DefaultBindingTable:
//- rjf: command lister
{ "run_command" F1 0 0 0 }
//- rjf: developer commands
{ "log_marker" M ctrl shift alt }
}
@data(DF_StringBindingPair) df_g_default_binding_table:
{
@expand(DF_DefaultBindingTable a) ```{str8_lit_comp("$(a.name)"), {OS_Key_$(a.key), 0 $(a.ctrl != 0 -> `|OS_EventFlag_Ctrl`) $(a.shift != 0 -> `|OS_EventFlag_Shift`) $(a.alt != 0 -> `|OS_EventFlag_Alt`)}}```;
}
////////////////////////////////
@@ -172,43 +190,76 @@ DF_BindingVersionRemapTable:
{"commands" "run_command"}
{"load_user" "open_user"}
{"load_profile" "open_profile"}
{"load_project" "open_project"}
{"open_profile" "open_project"}
}
@data(String8) df_g_binding_version_remap_old_name_table:
{
@expand(DF_BindingVersionRemapTable a) `str8_lit_comp("$(a.old_name)")`
}
@data(String8) df_g_binding_version_remap_new_name_table:
{
@expand(DF_BindingVersionRemapTable a) `str8_lit_comp("$(a.new_name)")`
}
////////////////////////////////
//~ rjf: Gfx Layer View Kinds
@table(name, name_lower, display_string, name_kind, icon, parameterized_by_entity, can_serialize, can_serialize_entity_path, can_filter, filter_is_code, typing_automatically_filters, inc_in_docs, docs_desc)
@table(name, name_lower, display_string, name_kind, icon, parameterized_by_entity, project_specific, can_serialize, can_serialize_entity_path, can_filter, filter_is_code, typing_automatically_filters, inc_in_docs, docs_desc)
DF_GfxViewTable:
{
{ Null "null" "" Null Null 0 0 0 0 0 0 0 "" }
{ Empty "empty" "" Null Null 0 0 0 0 0 0 0 "" }
{ Commands "commands" "Commands" Null List 0 0 0 0 0 0 0 "" }
{ FileSystem "file_system" "File System" Null FileOutline 0 0 0 0 0 0 0 "" }
{ SystemProcesses "system_processes" "System Processes" Null Null 0 0 0 0 0 0 0 "" }
{ EntityLister "entity_lister" "Entity List" EntityKindName Null 0 0 0 0 0 0 0 "" }
{ SymbolLister "symbol_lister" "Symbols" Null Null 0 0 0 0 0 0 0 "" }
{ Target "target" "Target" EntityName Target 1 0 0 0 0 0 0 "" }
{ Targets "targets" "Targets" Null Target 0 1 0 1 0 1 1 "Displays a list of all targets, as well as controls for enabling, disabling, launching, editing, or deleting each target. For more information on targets, read the `Targets` section." }
{ FilePathMap "file_path_map" "File Path Map" Null FileOutline 0 1 0 0 0 0 1 "Displays a table of *path maps*. Each path map is a pair of file or folder paths, one being a 'source' path, and one being a 'destination' path. These pairs are used by the debugger when automatically searching for specific files - for instance, when attempting to snap to a source code location specified by debug info. If debug info refers to a path on the machine on which a target executable was originally built, but that path is not valid on the debugger machine, but some alternative path exists, then path maps may be used to redirect the debugger from the debug info's specified paths to the associated appropriate debugger machine file paths." }
{ Scheduler "scheduler" "Scheduler" Null Scheduler 0 1 0 1 1 1 1 "Displays all processes and threads to which the debugger is currently attached, and contains controls for selecting and freezing threads." }
{ CallStack "call_stack" "Call Stack" Null Thread 0 1 0 0 0 0 1 "Displays the call stack of the currently selected thread. Each frame in the call stack contains the associated module, function name, and return address. Allows selection of a particular call stack frame other than the top." }
{ Modules "modules" "Modules" Null Module 0 1 0 1 0 1 1 "Displays a table of all modules currently loaded by any process to which the debugger is attached. This table displays each module's name, virtual address range in the containing process' address space, and which debug info file is being used by the debugger for the associated module." }
{ PendingEntity "pending_entity" "Pending Entity" EntityName FileOutline 1 0 0 0 0 0 0 "" }
{ Code "code" "Code" EntityName FileOutline 1 1 1 0 0 0 0 "" }
{ Disassembly "disassembly" "Disassembly" Null Glasses 0 1 0 0 0 0 1 "Displays disassembled instructions in a textual form from the selected thread's containing process virtual address space." }
{ Watch "watch" "Watch" Null Binoculars 0 1 0 1 1 1 1 "The familiar 'watch window' debugger interface. Allows the inputting of a number of expressions. Each expression in the table is evaluated within the context of the selected thread's selected call stack frame. If applicable (depending on visualization rules and the expression's type), these expressions may be hierarchically expanded, which displays children as more rows in the table. The values of these expressions may also be edited, and if possible, can be used to write to registers or memory in attached processes. Also contains a new *view rule* column, not found in other major debuggers, which allows per-row specification of various visualization rules. These view rules may be used to visualize and inspect the evaluation of expressions in a variety of ways. To learn more, read the 'View Rules' section." }
{ Locals "locals" "Locals" Null Binoculars 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with local variables found within the selected call stack frame of the selected thread, according to the associated debug info. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Registers "registers" "Registers" Null Binoculars 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all register names according to the selected thread's architecture. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Globals "globals" "Globals" Null Binoculars 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all global variables within the selected thread's module. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ ThreadLocals "thread_locals" "Thread Locals" Null Binoculars 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all thread local variables within the selected thread's module. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Types "types" "Types" Null Binoculars 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all types within the selected thread's module. View rules can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Procedures "procedures" "Procedures" Null Binoculars 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all procedures within the selected thread's module. View rules can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Output "output" "Output" Null List 0 1 0 0 0 0 1 "Displays textual output from the selected thread's containing process." }
{ Memory "memory" "Memory" Null Grid 0 1 1 0 0 0 1 "A familiar hex-editor-like interface for viewing memory of attached processes." }
{ Breakpoints "breakpoints" "Breakpoints" Null CircleFilled 0 1 0 1 0 1 1 "Displays a table of all breakpoints, containing information about each breakpoint's name, location, and hit count. Also contains per-breakpoint controls for enabling, deleting, or editing each breakpoint. For more information on breakpoints and their features, read the 'Breakpoints' section." }
{ WatchPins "watch_pins" "Watch Pins" Null Pin 0 1 0 1 1 1 1 "Displays a table of all watch pins (watched expressions, like those found in `Watch`, but instead of being within a table, being pinned to some source code location, like breakpoints). This table contains each pin's name, location, and controls for editing or deleting each pin." }
{ ExceptionFilters "exception_filters" "Exception Filters" Null Gear 0 1 0 1 0 1 1 "An interface which controls whether or not the debugger will halt attached processes upon encountering specific exception codes for the first time." }
{ Theme "theme" "Theme" Null Palette 0 1 0 0 0 0 1 "An interface for modifying the colors used in the debugger's UI. Allows selecting a theme preset, loading a theme from a file, and modifying individual colors within a theme." }
{ Null "null" "" Null Null 0 0 0 0 0 0 0 0 "" }
{ Empty "empty" "" Null Null 0 0 0 0 0 0 0 0 "" }
{ GettingStarted "getting_started" "Getting Started" Null QuestionMark 0 0 1 0 0 0 0 0 "" }
{ Commands "commands" "Commands" Null List 0 0 0 0 0 0 0 0 "" }
{ FileSystem "file_system" "File System" Null FileOutline 0 0 0 0 0 0 0 0 "" }
{ SystemProcesses "system_processes" "System Processes" Null Null 0 0 0 0 0 0 0 0 "" }
{ EntityLister "entity_lister" "Entity List" Null Null 0 0 0 0 0 0 0 0 "" }
{ SymbolLister "symbol_lister" "Symbols" Null Null 0 0 0 0 0 0 0 0 "" }
{ Target "target" "Target" EntityName Target 1 0 0 0 0 0 0 0 "" }
{ Targets "targets" "Targets" Null Target 0 0 1 0 1 0 1 1 "Displays a list of all targets, as well as controls for enabling, disabling, launching, editing, or deleting each target. For more information on targets, read the `Targets` section." }
{ FilePathMap "file_path_map" "File Path Map" Null FileOutline 0 0 1 0 0 0 0 1 "Displays a table of *path maps*. Each path map is a pair of file or folder paths, one being a 'source' path, and one being a 'destination' path. These pairs are used by the debugger when automatically searching for specific files - for instance, when attempting to snap to a source code location specified by debug info. If debug info refers to a path on the machine on which a target executable was originally built, but that path is not valid on the debugger machine, but some alternative path exists, then path maps may be used to redirect the debugger from the debug info's specified paths to the associated appropriate debugger machine file paths." }
{ AutoViewRules "auto_view_rules" "Auto View Rules" Null Binoculars 0 0 1 0 0 0 0 1 "Displays a table of *auto view rules*. Each *auto view rule* is a pair, with one element being a type, and the other being a view rule, which should be automatically applied to expressions of that type, when possible." }
{ Scheduler "scheduler" "Scheduler" Null Scheduler 0 0 1 0 1 1 1 1 "Displays all processes and threads to which the debugger is currently attached, and contains controls for selecting and freezing threads." }
{ CallStack "call_stack" "Call Stack" Null Thread 0 0 1 0 0 0 0 1 "Displays the call stack of the currently selected thread. Each frame in the call stack contains the associated module, function name, and return address. Allows selection of a particular call stack frame other than the top." }
{ Modules "modules" "Modules" Null Module 0 0 1 0 1 0 1 1 "Displays a table of all modules currently loaded by any process to which the debugger is attached. This table displays each module's name, virtual address range in the containing process' address space, and which debug info file is being used by the debugger for the associated module." }
{ PendingEntity "pending_entity" "Pending Entity" EntityName FileOutline 1 0 0 0 0 0 0 0 "" }
{ Code "code" "Code" EntityName FileOutline 1 1 1 1 0 0 0 0 "" }
{ Disassembly "disassembly" "Disassembly" Null Glasses 0 0 1 0 0 0 0 1 "Displays disassembled instructions in a textual form from the selected thread's containing process virtual address space." }
{ Watch "watch" "Watch" Null Binoculars 0 0 1 0 1 1 1 1 "The familiar 'watch window' debugger interface. Allows the inputting of a number of expressions. Each expression in the table is evaluated within the context of the selected thread's selected call stack frame. If applicable (depending on visualization rules and the expression's type), these expressions may be hierarchically expanded, which displays children as more rows in the table. The values of these expressions may also be edited, and if possible, can be used to write to registers or memory in attached processes. Also contains a new *view rule* column, not found in other major debuggers, which allows per-row specification of various visualization rules. These view rules may be used to visualize and inspect the evaluation of expressions in a variety of ways. To learn more, read the 'View Rules' section." }
{ Locals "locals" "Locals" Null Binoculars 0 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with local variables found within the selected call stack frame of the selected thread, according to the associated debug info. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Registers "registers" "Registers" Null Binoculars 0 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all register names according to the selected thread's architecture. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Globals "globals" "Globals" Null Binoculars 0 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all global variables within the selected thread's module. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ ThreadLocals "thread_locals" "Thread Locals" Null Binoculars 0 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all thread local variables within the selected thread's module. View rules and evaluation values can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Types "types" "Types" Null Binoculars 0 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all types within the selected thread's module. View rules can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Procedures "procedures" "Procedures" Null Binoculars 0 0 1 0 1 1 1 1 "Nearly identical to `Watch`, but automatically filled with all procedures within the selected thread's module. View rules can be edited, like in `Watch`, but unlike `Watch`, expressions cannot be edited or added to the table." }
{ Output "output" "Output" Null List 0 0 1 0 0 0 0 1 "Displays textual output from the selected thread's containing process." }
{ Memory "memory" "Memory" Null Grid 0 0 1 0 0 0 0 1 "A familiar hex-editor-like interface for viewing memory of attached processes." }
{ Breakpoints "breakpoints" "Breakpoints" Null CircleFilled 0 0 1 0 1 0 1 1 "Displays a table of all breakpoints, containing information about each breakpoint's name, location, and hit count. Also contains per-breakpoint controls for enabling, deleting, or editing each breakpoint. For more information on breakpoints and their features, read the 'Breakpoints' section." }
{ WatchPins "watch_pins" "Watch Pins" Null Pin 0 0 1 0 1 1 1 1 "Displays a table of all watch pins (watched expressions, like those found in `Watch`, but instead of being within a table, being pinned to some source code location, like breakpoints). This table contains each pin's name, location, and controls for editing or deleting each pin." }
{ ExceptionFilters "exception_filters" "Exception Filters" Null Gear 0 0 1 0 1 0 1 1 "An interface which controls whether or not the debugger will halt attached processes upon encountering specific exception codes for the first time." }
{ Settings "settings" "Settings" Null Gear 0 0 1 0 1 0 1 1 "An interface to modify general settings for the debugger's appearance and behavior." }
}
@enum DF_GfxViewKind:
{
@expand(DF_GfxViewTable a) `$(a.name)`,
COUNT,
}
@gen
{
@expand(DF_GfxViewTable a) `DF_VIEW_SETUP_FUNCTION_DEF($(a.name));`;
@expand(DF_GfxViewTable a) `DF_VIEW_STRING_FROM_STATE_FUNCTION_DEF($(a.name));`;
@expand(DF_GfxViewTable a) `DF_VIEW_CMD_FUNCTION_DEF($(a.name));`;
@expand(DF_GfxViewTable a) `DF_VIEW_UI_FUNCTION_DEF($(a.name));`;
}
@data(DF_ViewSpecInfo) df_g_gfx_view_kind_spec_info_table:
{
@expand(DF_GfxViewTable a) ```{(0|$(a.parameterized_by_entity)*DF_ViewSpecFlag_ParameterizedByEntity|$(a.project_specific)*DF_ViewSpecFlag_ProjectSpecific|$(a.can_serialize)*DF_ViewSpecFlag_CanSerialize|$(a.can_serialize_entity_path)*DF_ViewSpecFlag_CanSerializeEntityPath|$(a.can_filter)*DF_ViewSpecFlag_CanFilter|$(a.filter_is_code)*DF_ViewSpecFlag_FilterIsCode|$(a.typing_automatically_filters)*DF_ViewSpecFlag_TypingAutomaticallyFilters), str8_lit_comp("$(a.name_lower)"), str8_lit_comp("$(a.display_string)"), DF_NameKind_$(a.name_kind), DF_IconKind_$(a.icon), DF_VIEW_SETUP_FUNCTION_NAME($(a.name)), DF_VIEW_STRING_FROM_STATE_FUNCTION_NAME($(a.name)), DF_VIEW_CMD_FUNCTION_NAME($(a.name)), DF_VIEW_UI_FUNCTION_NAME($(a.name))}```;
}
////////////////////////////////
@@ -226,102 +277,80 @@ DF_CmdParamSlot2ViewSpecMap:
{String "symbol_lister" "function_breakpoint" }
}
@data(DF_CmdParamSlot) df_g_cmd_param_slot_2_view_spec_src_map:
{
@expand(DF_CmdParamSlot2ViewSpecMap a) `DF_CmdParamSlot_$(a.slot)`
}
@data(String8) df_g_cmd_param_slot_2_view_spec_dst_map:
{
@expand(DF_CmdParamSlot2ViewSpecMap a) `str8_lit_comp("$(a.view_spec)")`
}
@data(String8) df_g_cmd_param_slot_2_view_spec_cmd_map:
{
@expand(DF_CmdParamSlot2ViewSpecMap a) `str8_lit_comp("$(a.opt_cmd_spec)")`
}
////////////////////////////////
//~ rjf: Built-In Graphical View Rule Extensions
//
// NOTE(rjf): see @view_rule_info
@table(string vr ls ru bu)
@table(string vr ls ru bu tu tab_display_string)
DF_GfxViewRuleTable:
{
{"array" - - - -}
{"list" x - - -}
{"dec" - x - -}
{"bin" - x - -}
{"oct" - x - -}
{"hex" - x - -}
{"only" x x - -}
{"omit" x x - -}
{"no_addr" - x - -}
{"rgba" - - x x}
{"text" - - - x}
{"disasm" - - - x}
{"bitmap" - - x x}
{"geo" - - x x}
{"array" - - - - - "" }
{"list" x - - - - "" }
{"dec" - x - - - "" }
{"bin" - x - - - "" }
{"oct" - x - - - "" }
{"hex" - x - - - "" }
{"only" x x - - - "" }
{"omit" x x - - - "" }
{"no_addr" - x - - - "" }
{"rgba" - - x x - "" }
{"text" - - - x x "Text" }
{"disasm" - - - x x "Disassembly" }
{"bitmap" - - x x x "Bitmap" }
{"geo" - - x x x "Geometry" }
}
////////////////////////////////
//~ rjf: Theme Color Codes
@table(name display_name name_lower)
DF_ThemeTable:
@gen
{
{Null "Null" null }
{PlainText "Plain Text" plain_text }
{PlainBackground "Plain Background" plain_background }
{PlainBorder "Plain Border" plain_border }
{PlainOverlay "Plain Overlay" plain_overlay }
{CodeDefault "Code (Default)" code_default }
{CodeFunction "Code (Function)" code_function }
{CodeType "Code (Type)" code_type }
{CodeLocal "Code (Local)" code_local }
{CodeKeyword "Code (Keyword)" code_keyword }
{CodeSymbol "Code (Symbol)" code_symbol }
{CodeNumeric "Code (Numeric)" code_numeric }
{CodeString "Code (String)" code_string }
{CodeMeta "Code (Meta)" code_meta }
{CodeComment "Code (Comment)" code_comment }
{LineInfo0 "Line Info (0)" line_info_0 }
{LineInfo1 "Line Info (1)" line_info_1 }
{LineInfo2 "Line Info (2)" line_info_2 }
{LineInfo3 "Line Info (3)" line_info_3 }
{AltText "Alt Text" alt_text }
{AltBackground "Alt Background" alt_background }
{AltBorder "Alt Border" alt_border }
{AltOverlay "Alt Overlay" alt_overlay }
{TabInactive "Inactive Tab" tab_inactive }
{TabActive "Active Tab" tab_active }
{EntityBackground "Entity Background" entity_background }
{QueryBar "Query Bar" query_bar }
{WeakText "Weak Text" weak_text }
{TextSelection "Text Selection" text_selection }
{Cursor "Cursor" cursor }
{Highlight0 "Highlight (0)" highlight_0 }
{Highlight1 "Highlight (1)" highlight_1 }
{SuccessText "Success Text" success_text }
{SuccessBackground "Success Background" success_background }
{SuccessBorder "Success Border" success_border }
{FailureText "Failure Text" failure_text }
{FailureBackground "Failure Background" failure_background }
{FailureBorder "Failure Border" failure_border }
{ActionText "Action Text" action_text }
{ActionBackground "Action Background" action_background }
{ActionBorder "Action Border" action_border }
{DropSiteOverlay "Drop Site Overlay" drop_site_overlay }
{Thread0 "Thread (0)" thread_0 }
{Thread1 "Thread (1)" thread_1 }
{Thread2 "Thread (2)" thread_2 }
{Thread3 "Thread (3)" thread_3 }
{Thread4 "Thread (4)" thread_4 }
{Thread5 "Thread (5)" thread_5 }
{Thread6 "Thread (6)" thread_6 }
{Thread7 "Thread (7)" thread_7 }
{ThreadUnwound "Thread (Unwound)" thread_unwound }
{InactivePanelOverlay "Inactive Panel Overlay" inactive_panel_overlay }
{DropShadow "Drop Shadow" drop_shadow }
``;
@expand(DF_GfxViewRuleTable a)
`$(a.vr == "x" -> "DF_GFX_VIEW_RULE_VIZ_ROW_PROD_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.ls == "x" -> "DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.ru == "x" -> "DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.bu == "x" -> "DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.tu == "x" -> "DF_VIEW_SETUP_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.tu == "x" -> "DF_VIEW_STRING_FROM_STATE_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.tu == "x" -> "DF_VIEW_CMD_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.tu == "x" -> "DF_VIEW_UI_FUNCTION_DEF(" .. a.name_lower .. ");")`;
}
////////////////////////////////
//~ rjf: Theme Color Version Remap Table
@table(old_name new_name)
DF_ThemeColorVersionRemapTable:
@data(DF_ViewSpecInfo) @c_file df_g_gfx_view_rule_tab_view_spec_info_table:
{
@expand(DF_GfxViewRuleTable a)
```$(a.tu == "x" -> '{ DF_ViewSpecFlag_CanSerialize|DF_ViewSpecFlag_CanSerializeQuery, str8_lit_comp("' .. a.string .. '_view_rule"), str8_lit_comp("' .. a.tab_display_string .. '"), DF_NameKind_Null, DF_IconKind_Binoculars, ' .. 'DF_VIEW_SETUP_FUNCTION_NAME(' .. a.string .. '), DF_VIEW_STRING_FROM_STATE_FUNCTION_NAME(' .. a.string .. '), DF_VIEW_CMD_FUNCTION_NAME(' .. a.string .. '), DF_VIEW_UI_FUNCTION_NAME(' .. a.string .. ') }')```;
}
@data(DF_GfxViewRuleSpecInfo) @c_file df_g_gfx_view_rule_spec_info_table:
{
@expand(DF_GfxViewRuleTable a)
```{ str8_lit_comp("$(a.string)"), (DF_GfxViewRuleSpecInfoFlag_VizRowProd*$(a.vr == "x"))|(DF_GfxViewRuleSpecInfoFlag_LineStringize*$(a.ls == "x"))|(DF_GfxViewRuleSpecInfoFlag_RowUI*$(a.ru == "x"))|(DF_GfxViewRuleSpecInfoFlag_BlockUI*$(a.bu == "x")), $(a.vr == "x" -> "DF_GFX_VIEW_RULE_VIZ_ROW_PROD_FUNCTION_NAME("..a.name_lower..")") $(a.vr != "x" -> 0), $(a.ls == "x" -> "DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_NAME("..a.name_lower..")") $(a.ls != "x" -> 0), $(a.ru == "x" -> "DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_NAME("..a.name_lower..")") $(a.ru != "x" -> 0), $(a.bu == "x" -> "DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_NAME("..a.name_lower..")") $(a.bu != "x" -> 0), str8_lit_comp("$(a.tu == 'x' -> a.string..'_view_rule')") }```;
}
////////////////////////////////
//~ rjf: Theme Presets
//~ rjf: Theme Tables
@table(name_upper name_lower display_string)
DF_ThemePresetTable:
@@ -337,263 +366,228 @@ DF_ThemePresetTable:
{ FarManager far_manager "Far Manager" }
}
@table(name default_dark default_light vs_dark vs_light solarized_dark solarized_light handmade_hero four_coder far_manager)
DF_ThemePresetColorTable:
@table(name display_name name_lower default_dark default_light vs_dark vs_light solarized_dark solarized_light handmade_hero four_coder far_manager desc)
DF_ThemeColorTable:
{
(null 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff )
(plain_text 0xe5e5e5ff 0x383838ff 0xe5e5e5ff 0x1e1e1eff 0xe5e5e5ff 0x1e1e1eff 0xa08563ff 0x90b080ff 0x00ffffff )
(plain_background 0x3333337f 0xedededfe 0x1e1e1eff 0xffffffff 0x002b36ff 0xfcf6e2ff 0x0c0c0cff 0x0c0c0cff 0x000082ff )
(plain_border 0xffffff19 0x0000001d 0xffffff19 0xcccedb1d 0xffffff19 0xcccedb1d 0xffffff19 0x181818a0 0xffffff19 )
(plain_overlay 0xffffff33 0x00000033 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 )
(code_default 0xe5e5e5ff 0x282828ff 0xd4d4d4ff 0x000000ff 0x839496ff 0x74878cff 0xa08563ff 0x90b080ff 0x00ffffff )
(code_function 0x7fcc99ff 0x2a7a45ff 0xdcdcaaff 0x74531fff 0x1c7dd1ff 0xc39d36ff 0xcc5735ff 0x7fcc99ff 0x49b2ffff )
(code_type 0x66b2e5ff 0x2c688fff 0x4ec9b0ff 0x2b91afff 0x1c7dd1ff 0x66b2e5ff 0xd8a51dff 0x66b2e5ff 0x49b2ffff )
(code_local 0xfe9548ff 0xfe9548ff 0xfe9548ff 0xfe9548ff 0xfe9548ff 0xfe9548ff 0xfe9548ff 0xfe9548ff 0xfe9548ff )
(code_keyword 0xf7bf5eff 0xa47729ff 0x569cd6ff 0x0000ffff 0x63980fff 0xc39d36ff 0xac7b0bff 0xd08f20ff 0xff0000ff )
(code_symbol 0x994c32ff 0x6c2d18ff 0xb4b4b4ff 0x000000ff 0x839496ff 0x2e5256ff 0x994c32ff 0x994c32ff 0xffffffff )
(code_numeric 0x4ce54cff 0x2c7d2cff 0xb5cea8ff 0x000000ff 0xcb4b20ff 0x657b83ff 0x6b8e23ff 0x50ff30ff 0x2cff50ff )
(code_string 0xe5cc66ff 0xcc5a0fff 0xd69d85ff 0xc11515ff 0x2aa198ff 0x5ab4a9ff 0x6b8e23ff 0x50ff30ff 0xe5cc66ff )
(code_meta 0xe54c4cff 0x8a0c0cff 0x9b9b9bff 0x808080ff 0xe54c4cff 0xe54c4cff 0xdab98fff 0x50ff30ff 0xffff00ff )
(code_comment 0x7f7f7fff 0x7f7f7fff 0x6a9955ff 0x008000ff 0x7f7f7fff 0xadafb2ff 0x686868ff 0x2090f0ff 0x7f7f7fff )
(line_info_0 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f )
(line_info_1 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f )
(line_info_2 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f )
(line_info_3 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f )
(alt_text 0xe5e5e5ff 0x535353ff 0xf1f1f1ff 0x535353ff 0xe5e5e5ff 0x535353ff 0xa08563ff 0x90b080ff 0x000000ff )
(alt_background 0x42474c7f 0xfefefebc 0x1b1b1cff 0xfefefebc 0x002b36ff 0xfcf6e2ff 0x0c0c0cff 0x0c0c0cff 0x008184ff )
(alt_border 0xffffff19 0xffffff19 0x333337ff 0xffffff19 0xffffff19 0xffffff19 0xffffff19 0xffffff19 0xffffff19 )
(alt_overlay 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 )
(tab_inactive 0x42474c7f 0x42474c7f 0x42474c7f 0x42474c7f 0x42474c7f 0x42474c7f 0x42474c7f 0x42474c7f 0x42474c7f )
(tab_active 0xa87a4c99 0xc7a27dff 0x007accff 0x007accff 0x28515eff 0xa87a4c99 0xa87a4c99 0xa87a4c99 0xa87a4c99 )
(entity_background 0x4293cc99 0x4293cc99 0x4293cc99 0x4293cc99 0x4293cc99 0x4293cc99 0x4293cc99 0x4293cc99 0x4293cc99 )
(query_bar 0x8e2d4ccc 0xd76489cc 0x8e2d4ccc 0x8e2d4ccc 0x8e2d4ccc 0x8e2d4ccc 0x8e2d4ccc 0x8e2d4ccc 0x8e2d4ccc )
(weak_text 0xffffff7f 0x0000007f 0xffffff7f 0x0000007f 0xffffff7f 0x0000007f 0xa08563af 0x90b080af 0xffffff7f )
(text_selection 0x99ccff4c 0x7d98b34c 0x99ccff4c 0x7d98b34c 0x99ccff4c 0x7d98b34c 0x99ccff4c 0x99ccff4c 0x99ccff4c )
(cursor 0x66e566e5 0x101010ff 0x66e566e5 0x101010ff 0x66e566e5 0x101010ff 0x66e566e5 0x66e566e5 0x66e566e5 )
(highlight_0 0xb27219ff 0xb272189b 0xb27219ff 0xb27219ff 0xb27219ff 0xb27219ff 0xb27219ff 0xb27219ff 0xb27219ff )
(highlight_1 0x327f19ff 0x327f19ff 0x327f19ff 0x327f19ff 0x327f19ff 0x327f19ff 0x327f19ff 0x327f19ff 0x327f19ff )
(success_text 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff )
(success_background 0x32b219ff 0x75db61ff 0x32b219ff 0x32b219ff 0x32b219ff 0x32b219ff 0x32b219ff 0x32b219ff 0x32b219ff )
(success_border 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 )
(failure_text 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff 0xe5e5e5ff )
(failure_background 0xb23219ff 0xf27961ff 0xb23219ff 0xb23219ff 0xb23219ff 0xb23219ff 0xb23219ff 0xb23219ff 0xb23219ff )
(failure_border 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 )
(action_text 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff )
(action_background 0x327fb2ff 0x327fb2ff 0x327fb2ff 0x327fb2ff 0x327fb2ff 0x327fb2ff 0x327fb2ff 0x327fb2ff 0x327fb2ff )
(action_border 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 0xffffff33 )
(drop_site_overlay 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c )
(thread_0 0xffcb7fff 0xad7c34ff 0xffcb7fff 0xad7c34ff 0xffcb7fff 0xad7c34ff 0xffcb7fff 0xffcb7fff 0xffcb7fff )
(thread_1 0xb2ff65ff 0x639b2aff 0xb2ff65ff 0x639b2aff 0xb2ff65ff 0x639b2aff 0xb2ff65ff 0xb2ff65ff 0xb2ff65ff )
(thread_2 0xff99e5ff 0xa94c91ff 0xff99e5ff 0xa94c91ff 0xff99e5ff 0xa94c91ff 0xff99e5ff 0xff99e5ff 0xff99e5ff )
(thread_3 0x6598ffff 0x305398ff 0x6598ffff 0x305398ff 0x6598ffff 0x305398ff 0x6598ffff 0x6598ffff 0x6598ffff )
(thread_4 0x65ffcbff 0x339574ff 0x65ffcbff 0x339574ff 0x65ffcbff 0x339574ff 0x65ffcbff 0x65ffcbff 0x65ffcbff )
(thread_5 0xff9819ff 0xbf7416ff 0xff9819ff 0xbf7416ff 0xff9819ff 0xbf7416ff 0xff9819ff 0xff9819ff 0xff9819ff )
(thread_6 0x9932ffff 0x57238bff 0x9932ffff 0x57238bff 0x9932ffff 0x57238bff 0x9932ffff 0x9932ffff 0x9932ffff )
(thread_7 0x65ff4cff 0x2a7e1cff 0x65ff4cff 0x2a7e1cff 0x65ff4cff 0x2a7e1cff 0x65ff4cff 0x65ff4cff 0x65ff4cff )
(thread_unwound 0xb2ccd8ff 0x236481ff 0xb2ccd8ff 0x236481ff 0xb2ccd8ff 0x236481ff 0xb2ccd8ff 0xb2ccd8ff 0xb2ccd8ff )
(inactive_panel_overlay 0x0000003f 0x0000000d 0x0000003f 0x0000000d 0x0000003f 0x0000000d 0x0000003f 0x0000003f 0x0000003f )
(drop_shadow 0x0000007f 0x0000003b 0x0000007f 0x0000003b 0x0000007f 0x0000003b 0x0000007f 0x0000007f 0x0000007f )
{Null "Null" null 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff 0xff00ffff ""}
//- rjf: global ui colors
{Text "Text" text 0xe5e5e5ff 0x4c4c4cff 0xe5e5e5ff 0x000000ff 0x999999ff 0x333333ff 0xa08462ff 0x90b080ff 0x00fefeff ""}
{TextPositive "Text (Positive)" text_positive 0x4dc221ff 0x4d9e2eff 0x4dc221ff 0x4dc221ff 0x4dc221ff 0x4dc221ff 0x4dc221ff 0x4dc221ff 0x4dc221ff ""}
{TextNegative "Text (Negative)" text_negative 0xc56452ff 0xbd371eff 0xc56452ff 0xc46451ff 0xc56452ff 0xc56452ff 0xc56452ff 0xc56452ff 0xc56452ff ""}
{TextNeutral "Text (Neutral)" text_neutral 0x307eb2ff 0x0064a7ff 0x307eb2ff 0x307eb2ff 0x307eb2ff 0x307eb2ff 0x307eb2ff 0x307eb2ff 0x307eb2ff ""}
{TextWeak "Text (Weak)" text_weak 0xa4a4a4fe 0x4c4c4cff 0xa4a4a4fe 0x0000007f 0x9999998a 0x818181ff 0x6e512eff 0x566e4bff 0x00a9a9ff ""}
{Cursor "Cursor" cursor 0x8aff00ff 0x699830ff 0x8aff00ff 0x000000ff 0x8aff00ff 0x586e75ff 0x8aff00ff 0x8aff00ff 0x8aff00ff ""}
{CursorInactive "Cursor (Inactive)" cursor_inactive 0xb23217ff 0xb23217ff 0xb23217ff 0xb23217ff 0xb23217ff 0xb23217ff 0xb23217ff 0xb23217ff 0xb23217ff ""}
{Focus "Focus" focus 0xfda200ff 0x9c5900ff 0xfda200ff 0x002affff 0xfda200ff 0x92743dff 0xfda200ff 0xfda200ff 0x00fefeff ""}
{Hover "Hover" hover 0xffffffff 0xffffffff 0xffffffff 0x000000ff 0xffffffff 0x747474ff 0xffffffff 0xffffffff 0xffffffff ""}
{DropShadow "Drop Shadow" drop_shadow 0x0000007f 0x0000004c 0x0000007f 0xa3a3a37e 0x0000007f 0xc9bfa394 0x0000007f 0x0000007f 0x0000007f ""}
{DisabledOverlay "Disabled Overlay" disabled_overlay 0x0000003f 0xa6a6a63f 0x0000003f 0x0000003f 0x0000003f 0xe4dac090 0x0000003f 0x0000003f 0x0000003f ""}
{DropSiteOverlay "Drop Site Overlay" drop_site_overlay 0xffffff0c 0x4848480c 0xffffff0c 0x0000000c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c 0xffffff0c ""}
{InactivePanelOverlay "Inactive Panel Overlay" inactive_panel_overlay 0x0000003f 0xa4a4a43f 0x0000003f 0xfefefe53 0x0000003f 0x0000001c 0x0000003f 0x0000003f 0x0000003f ""}
{SelectionOverlay "Selection Overlay" selection_overlay 0x99ccff4c 0x003d7a48 0x99ccff4c 0x3d74ab4b 0x99ccff4c 0x678cb24c 0x99ccff4c 0x99ccff4c 0x99ccff4c ""}
{HighlightOverlay "Highlight Overlay" highlight_overlay 0xffffff1e 0xffffff1e 0xffffff1e 0x0000001e 0xffffff1e 0xffffff1e 0xffffff1e 0xffffff1e 0xffffff1e ""}
{HighlightOverlayError "Error Highlight Overlay" error_highlight_overlay 0x5f12005f 0xff30005f 0x5f12005f 0x5f12005f 0x5f12005f 0x5f12005f 0x5f12005f 0x5f12005f 0x5f12005f ""}
//- rjf: base ui container colors
{BaseBackground "Base Background" base_background 0x1b1b1bfe 0xccccccfe 0x1b1b1bfe 0xfefefefe 0x002a35fe 0xfcf5e2fe 0x0c0c0cfe 0x0c0c0cfe 0x000081fe ""}
{BaseBackgroundAlt "Base Background (Alternate)" base_background_alt 0x2b2b2bfe 0x2b2b2bfe 0x1b1b1bfe 0xe7e7e7fe 0x2b2b2bfe 0x2b2b2bfe 0x2b2b2bfe 0x2b2b2bfe 0x2b2b2bfe ""}
{BaseBorder "Base Border" base_border 0x3f3f3ffe 0xa4a4a4fe 0x3f3f3ffe 0xb6b6b6ff 0xfefefe3a 0xbebaabfe 0x423525fe 0x3f3f3ffe 0x0000fffe ""}
//- rjf: menu bar ui container colors
{MenuBarBackground "Menu Bar Background" menu_bar_background 0x3e4c577f 0xeaeaea7f 0x1b1b1bfd 0xffffff7f 0x00202bff 0xeee8d5ff 0x0c0c0cfe 0x0c0c0cfe 0x007d7dff ""}
{MenuBarBackgroundAlt "Menu Bar Background (Alternate)" menu_bar_background_alt 0x3e4c577f 0x3e4c577f 0x1b1b1bfd 0xffffff7f 0x3e4c577f 0x3e4c577f 0x3e4c577f 0x3e4c577f 0x007d7dff ""}
{MenuBarBorder "Menu Bar Border" menu_bar_border 0xffffff19 0xa4a4a4fe 0x3f3f3ffe 0xb6b6b6ff 0xffffff19 0xbebaabfe 0xffffff19 0xffffff19 0xfefefe00 ""}
//- rjf: floating ui container colors
{FloatingBackground "Floating Background" floating_background 0x33333333 0xccccccc0 0x33333333 0xfefefec7 0x007fa14e 0xffffff7c 0x0c0c0c32 0x0c0c0c3e 0x007c7c55 ""}
{FloatingBackgroundAlt "Floating Background (Alternate)" floating_background_alt 0x33333333 0x33333333 0x33333333 0x33333333 0x33333333 0x33333333 0x33333333 0x33333333 0x33333333 ""}
{FloatingBorder "Floating Border" floating_border 0x3f3f3ffd 0xa4a4a4fe 0x3f3f3ffd 0xb6b6b6ff 0xfdfdfd3a 0xbebaabfe 0x423425fe 0x3f3f3ffd 0x00ffff55 ""}
//- rjf: ui element colors
{ImplicitButtonBackground "Implicit Button Background" implicit_button_background 0x00000000 0x00000000 0x00000000 0x00000000 0x00000000 0x00000000 0x00000000 0x00000000 0x00000000 ""}
{ImplicitButtonBorder "Implicit Button Border" implicit_button_border 0x00000000 0x00000000 0x00000000 0x00000000 0x00000000 0xbdb9aa00 0x00000000 0x00000000 0x00000000 ""}
{PlainButtonBackground "Plain Button Background" plain_button_background 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe 0x1b1b1bfe ""}
{PlainButtonBorder "Plain Button Border" plain_button_border 0x3f3f3ffe 0x3f3f3ffe 0x3f3f3ffe 0xb6b6b6ff 0xfefefe3a 0xbebaabfe 0x3f3f3ffe 0x3f3f3ffe 0x3f3f3ffe ""}
{PositivePopButtonBackground "Positive Pop Button Background" positive_pop_button_background 0x2c5b36ff 0x65f534ff 0x2c5b36ff 0x84ce93ff 0x2c5b36ff 0xb6ddbeff 0x132e19ff 0x152f1bff 0x2c5b36ff ""}
{PositivePopButtonBorder "Positive Pop Button Border" positive_pop_button_border 0x3f3f3ffd 0x3f3f3ffd 0x3f3f3ffd 0xb6b6b6ff 0xfefefe3a 0xbebaabfe 0x3f3f3ffd 0x3f3f3ffd 0x3f3f3ffd ""}
{NegativePopButtonBackground "Negative Pop Button Background" negative_pop_button_background 0x803425ff 0xff694cff 0x803425ff 0xbd3e24ff 0x803425ff 0xf8b0a1ff 0x803425ff 0x43150cff 0x803425ff ""}
{NegativePopButtonBorder "Negative Pop Button Border" negative_pop_button_border 0x3f3f3ffd 0x3f3f3ffd 0x3f3f3ffd 0xb6b6b6ff 0xfefefe3a 0xbebaabfe 0x3f3f3ffd 0x3f3f3ffd 0x3f3f3ffd ""}
{NeutralPopButtonBackground "Neutral Pop Button Background" neutral_pop_button_background 0x355b6eff 0xa6becaff 0x355b6eff 0x6e9db5ff 0x355b6eff 0xb2d3e3ff 0x15445cff 0x1b323eff 0x933100ff ""}
{NeutralPopButtonBorder "Neutral Pop Button Border" neutral_pop_button_border 0x3f3f3ffd 0xa6a6a6fd 0x3f3f3ffd 0xb6b6b6ff 0xfefefe3a 0xbebaabfe 0x3f3f3ffd 0x3f3f3ffd 0x3f3f3ffd ""}
{ScrollBarButtonBackground "Scroll Bar Button Background" scroll_bar_button_background 0x2b2b2bfe 0xa9a9a9fe 0x2b2b2bfe 0xe8e8e8fe 0x005e77fe 0xe3dbc7fe 0x1f1f27fe 0x212721fe 0x007d7dff ""}
{ScrollBarButtonBorder "Scroll Bar Button Border" scroll_bar_button_border 0x3f3f3ffe 0xc0c0c0fe 0x3f3f3ffe 0xb6b6b6ff 0xfefefe3a 0xbebaabfe 0xfefefe4d 0x3f3f3ffe 0x3f3f3ffe ""}
{TabBackground "Tab Background" tab_background 0x6f5135fe 0xa98b6fff 0x0079ccff 0xfffffffe 0x005e77fe 0xfdf6e3ff 0x1f1f27fe 0x212721fe 0x007d7dff ""}
{TabBorder "Tab Border" tab_border 0xfefefe4d 0xffffff4d 0xfefefe4d 0xb6b6b6ff 0xfefefe4d 0xbebaabfe 0xfefefe4d 0xfefefe4d 0xfefefe4d ""}
{TabBackgroundInactive "Tab Background (Inactive)" tab_background_inactive 0x3e4c577f 0x8282827f 0xfefefe14 0xcdd4dc7f 0x3e4c577f 0xd4cfc0fe 0x131315ee 0x3a3a3a7f 0x3e4c577f ""}
{TabBorderInactive "Tab Border (Inactive)" tab_border_inactive 0xffffff19 0xffffff19 0xffffff00 0xb6b6b6ff 0xffffff19 0xbebaabfe 0xffffff19 0x00000019 0xfefefe19 ""}
//- rjf: code colors
{CodeDefault "Code (Default)" code_default 0xcbcbcbff 0x4d4d4dff 0xcbcbcbff 0x000000ff 0xcbcbcbff 0x657b83ff 0xa08462ff 0x90b080ff 0x00fefeff ""}
{CodeSymbol "Code (Symbol)" code_symbol 0x42a2cffe 0x205670fe 0xdcdcaaff 0x000000ff 0xcb4a15ff 0xcb4a15ff 0xcc5634ff 0x42a2cffe 0x65b1ffff ""}
{CodeType "Code (Type)" code_type 0xfec746ff 0x996b00ff 0x4ec9afff 0xa33700ff 0xcb4a15ff 0xcb4a15ff 0xd8a51bff 0xfd7c52ff 0xfec746ff ""}
{CodeLocal "Code (Local)" code_local 0x98bc80ff 0x446a2bff 0x9cdbfeff 0x007666ff 0x98bc80ff 0x258ad2ff 0xc04047ff 0x98bc80ff 0x00ff00ff ""}
{CodeRegister "Code (Register)" code_register 0xb7afd5ff 0x4c35a1ff 0xb7afd5ff 0xb7afd5ff 0xb7afd5ff 0x373345ff 0xb7afd5ff 0xb7afd5ff 0xb7afd5ff ""}
{CodeKeyword "Code (Keyword)" code_keyword 0xb38d4cff 0x573700ff 0x569cd6ff 0x0000ffff 0x849803ff 0x586e75ff 0xac7a09ff 0xd08f1eff 0x00ffffff ""}
{CodeDelimiterOperator "Code (Delimiters/Operators)" code_delimiter_operator 0x767676ff 0x767676ff 0x767676ff 0x767676ff 0x767676ff 0x767676ff 0xa08462ff 0x90b080ff 0xffffffff ""}
{CodeNumeric "Code (Numeric)" code_numeric 0x98abb1ff 0x3f6e7dff 0xb5cea8ff 0x088658ff 0xd33582ff 0xd33482ef 0x698e21ff 0x4fff2eff 0x00ff00ff ""}
{CodeNumericAltDigitGroup "Code (Numeric, Alt. Digit Group)" code_numeric_alt_digit_group 0x738287ff 0x1f4450ff 0x729360ff 0x0c3828ff 0x902559ff 0x8e2659ff 0x3a4e11ff 0x3ccd21ff 0x738287ff ""}
{CodeString "Code (String)" code_string 0x98abb1ff 0x3c606bff 0xd59b85ff 0xa31414ff 0x1f9d91ff 0x29a198ff 0x6a8e22ff 0x4fff2eff 0x98abb1ff ""}
{CodeMeta "Code (Meta)" code_meta 0xd96759ff 0xad3627ff 0xd59c85ff 0x0000ffff 0x839802ff 0xd96759ff 0xdab98fff 0xa0b8a0ff 0xff0000ff ""}
{CodeComment "Code (Comment)" code_comment 0x717171ff 0x4b4b4bff 0x57a54aff 0x008000ff 0x556a6fff 0x93a1a1ff 0x686868ff 0x1e8fefff 0xffffffff ""}
{CodeLineNumbers "Code Line Numbers" code_line_numbers 0x7f7f7fff 0x4b4b4bff 0x2a91afff 0x227893ff 0x566c73ff 0x227893ef 0xa08462ff 0x7e7e7ffe 0x007d7dff ""}
{CodeLineNumbersSelected "Code Line Numbers (Selected)" code_line_numbers_selected 0xbebebeff 0x000000ff 0x9ddaecff 0x123d4bfe 0xa2aaacff 0x111e22ef 0xc8b399ff 0xbebebeff 0x00fefeff ""}
//- rjf: debugging colors
{LineInfoBackground0 "Line Info Background 0" line_info_background_0 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f ""}
{LineInfoBackground1 "Line Info Background 1" line_info_background_1 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f ""}
{LineInfoBackground2 "Line Info Background 2" line_info_background_2 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f ""}
{LineInfoBackground3 "Line Info Background 3" line_info_background_3 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f ""}
{LineInfoBackground4 "Line Info Background 4" line_info_background_4 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f 0x99503d3f ""}
{LineInfoBackground5 "Line Info Background 5" line_info_background_5 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f 0xfe82493f ""}
{LineInfoBackground6 "Line Info Background 6" line_info_background_6 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f 0xffba173f ""}
{LineInfoBackground7 "Line Info Background 7" line_info_background_7 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f 0xcefd693f ""}
{Thread0 "Thread 0" thread_0 0xffcb7fff 0x945800ff 0xffcb7fff 0x945800ff 0xffcb7fff 0x945800ff 0xffcb7fff 0xffcb7fff 0xffcb7fff ""}
{Thread1 "Thread 1" thread_1 0xb2ff65ff 0x3f5b23ff 0xb2ff65ff 0x3f5b23ff 0xb2ff65ff 0x3f5b23ff 0xb2ff65ff 0xb2ff65ff 0xb2ff65ff ""}
{Thread2 "Thread 2" thread_2 0xff99e5ff 0x642a55ff 0xff99e5ff 0x642a55ff 0xff99e5ff 0x642a55ff 0xff99e5ff 0xff99e5ff 0xff99e5ff ""}
{Thread3 "Thread 3" thread_3 0x6598ffff 0x30456fff 0x6598ffff 0x30456fff 0x6598ffff 0x30456fff 0x6598ffff 0x6598ffff 0x6598ffff ""}
{Thread4 "Thread 4" thread_4 0x65ffcbff 0x264f41ff 0x65ffcbff 0x264f41ff 0x65ffcbff 0x264f41ff 0x65ffcbff 0x65ffcbff 0x65ffcbff ""}
{Thread5 "Thread 5" thread_5 0xff9819ff 0x736a5fff 0xff9819ff 0x736a5fff 0xff9819ff 0x736a5fff 0xff9819ff 0xff9819ff 0xff9819ff ""}
{Thread6 "Thread 6" thread_6 0x9932ffff 0x472f5eff 0x9932ffff 0x472f5eff 0x9932ffff 0x472f5eff 0x9932ffff 0x9932ffff 0x9932ffff ""}
{Thread7 "Thread 7" thread_7 0x65ff4cff 0x405d3bff 0x65ff4cff 0x405d3bff 0x65ff4cff 0x405d3bff 0x65ff4cff 0x65ff4cff 0x65ff4cff ""}
{ThreadUnwound "Thread (Unwound)" thread_unwound 0xb2ccd8ff 0x49606aff 0xb2ccd8ff 0x49606aff 0xb2ccd8ff 0x49606aff 0xb2ccd8ff 0xb2ccd8ff 0xb2ccd8ff ""}
{ThreadError "Thread (Error)" thread_error 0xb23219ff 0xb23219ff 0xb23219ff 0xb23219ff 0xb23219ff 0xb23218ff 0xb23219ff 0xb23219ff 0xb23219ff ""}
{Breakpoint "Breakpoint" breakpoint 0xa72911ff 0xff2800ff 0xa72911ff 0xa72911ff 0xa72911ff 0xff684bff 0xa72911ff 0xa72911ff 0xff2800ff ""}
}
@table(old_name new_name)
DF_ThemeColorVersionRemapTable:
{
{plain_text text}
{plain_background base_background}
{plain_border base_border}
{plain_overlay drop_site_overlay}
{code_function code_symbol}
{code_symbol code_delimiter_operator}
{code_numeric code_numeric_alt_digit_group}
{line_info_0 line_info_background_0}
{line_info_1 line_info_background_1}
{line_info_2 line_info_background_2}
{line_info_3 line_info_background_3}
{alt_background menu_bar_background}
{alt_border menu_bar_border}
{tab_inactive tab_background_inactive}
{tab_active tab_background}
{weak_text text_weak}
{text_selection selection}
{cursor cursor}
{highlight_0 focus}
{success_background positive_pop_button_background}
{failure_background negative_pop_button_background}
{action_background neutral_pop_button_background}
}
@enum DF_ThemeColor:
{
@expand(DF_ThemeColorTable a) `$(a.name)`,
COUNT,
}
@enum DF_ThemePreset:
{
@expand(DF_ThemePresetTable a) `$(a.name)`,
COUNT,
}
@data(String8) df_g_theme_preset_display_string_table:
{
@expand(DF_ThemePresetTable a) `str8_lit_comp("$(a.display_string)")`,
}
@data(String8) df_g_theme_preset_code_string_table:
{
@expand(DF_ThemePresetTable a) `str8_lit_comp("$(a.name_lower)")`,
}
@data(String8) df_g_theme_color_version_remap_old_name_table:
{
@expand(DF_ThemeColorVersionRemapTable a) `str8_lit_comp("$(a.old_name)")`
}
@data(String8) df_g_theme_color_version_remap_new_name_table:
{
@expand(DF_ThemeColorVersionRemapTable a) `str8_lit_comp("$(a.new_name)")`
}
@data(Vec4F32) df_g_theme_preset_colors__default_dark: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.default_dark))`}
@data(Vec4F32) df_g_theme_preset_colors__default_light: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.default_light))`}
@data(Vec4F32) df_g_theme_preset_colors__vs_dark: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.vs_dark))`}
@data(Vec4F32) df_g_theme_preset_colors__vs_light: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.vs_light))`}
@data(Vec4F32) df_g_theme_preset_colors__solarized_dark: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.solarized_dark))`,}
@data(Vec4F32) df_g_theme_preset_colors__solarized_light:{@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.solarized_light))`,}
@data(Vec4F32) df_g_theme_preset_colors__handmade_hero: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.handmade_hero))`,}
@data(Vec4F32) df_g_theme_preset_colors__four_coder: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.four_coder))`,}
@data(Vec4F32) df_g_theme_preset_colors__far_manager: {@expand(DF_ThemeColorTable a) `rgba_from_u32_lit_comp($(a.far_manager))`;}
@data(`Vec4F32*`) df_g_theme_preset_colors_table:
{
@expand(DF_ThemePresetTable a) `df_g_theme_preset_colors__$(a.name_lower)`,
}
@data(String8) df_g_theme_color_display_string_table:
{
@expand(DF_ThemeColorTable a) `str8_lit_comp("$(a.display_name)")`
}
@data(String8) df_g_theme_color_cfg_string_table:
{
@expand(DF_ThemeColorTable a) `str8_lit_comp("$(a.name_lower)")`
}
////////////////////////////////
//~ rjf: Generators
//~ rjf: Settings
//- rjf: enums
@table_gen_enum
DF_GfxViewKind:
@table(name name_lower display_string default_s32 s32_min s32_max)
DF_SettingTable:
{
@expand(DF_GfxViewTable a)
`DF_GfxViewKind_$(a.name),`
`DF_GfxViewKind_COUNT`;
{HoverAnimations hover_animations "Hover Animations" 1 0 1 }
{PressAnimations press_animations "Press Animations" 1 0 1 }
{FocusAnimations focus_animations "Focus Animations" 1 0 1 }
{TooltipAnimations tooltip_animations "Tooltip Animations" 1 0 1 }
{MenuAnimations menu_animations "Menu Animations" 1 0 1 }
{ScrollingAnimations scrolling_animations "Scrolling Animations" 1 0 1 }
{BackgroundBlur background_blur "Background Blur" 1 0 1 }
{ThreadLines thread_lines "Thread Lines" 1 0 1 }
{BreakpointLines breakpoint_lines "Breakpoint Lines" 1 0 1 }
{ThreadGlow thread_glow "Thread Glow" 1 0 1 }
{BreakpointGlow breakpoint_glow "Breakpoint Glow" 1 0 1 }
{OpaqueBackgrounds opaque_backgrounds "Opaque Backgrounds" 0 0 1 }
{TabWidth tab_width "Tab Width" 4 1 32 }
}
@table_gen_enum
DF_ThemeColor:
@enum DF_SettingCode:
{
@expand(DF_ThemeTable, a)
`DF_ThemeColor_$(a.name),`;
`DF_ThemeColor_COUNT`;
@expand(DF_SettingTable a) `$(a.name)`,
COUNT
}
@table_gen_enum
DF_ThemePreset:
@data(String8) df_g_setting_code_display_string_table:
{
@expand(DF_ThemePresetTable a)
`DF_ThemePreset_$(a.name),`;
`DF_ThemePreset_COUNT`;
@expand(DF_SettingTable a) `str8_lit_comp("$(a.display_string)")`
}
//- rjf: theme preset color tables
@table_gen_data(type: String8, fallback: `{0}`)
df_g_theme_preset_display_string_table:
@data(String8) df_g_setting_code_lower_string_table:
{
@expand(DF_ThemePresetTable a) `str8_lit_comp("$(a.display_string)"),`;
@expand(DF_SettingTable a) `str8_lit_comp("$(a.name_lower)")`
}
@table_gen_data(type: String8, fallback: `{0}`)
df_g_theme_preset_code_string_table:
@data(DF_SettingVal) df_g_setting_code_default_val_table:
{
@expand(DF_ThemePresetTable a) `str8_lit_comp("$(a.name_lower)"),`;
@expand(DF_SettingTable a) `{1, $(a.default_s32)}`
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__default_dark:
@data(Rng1S32) df_g_setting_code_s32_range_table:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.default_dark)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__default_light:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.default_light)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__vs_dark:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.vs_dark)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__vs_light:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.vs_light)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__solarized_dark:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.solarized_dark)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__solarized_light:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.solarized_light)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__handmade_hero:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.handmade_hero)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__four_coder:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.four_coder)),`;
}
@table_gen_data(type: Vec4F32, fallback: `{1, 0, 1, 1}`)
df_g_theme_preset_colors__far_manager:
{
@expand(DF_ThemePresetColorTable a) `rgba_from_u32_lit_comp($(a.far_manager)),`;
}
@table_gen_data(type: `Vec4F32 *`, fallback: `0`)
df_g_theme_preset_colors_table:
{
@expand(DF_ThemePresetTable a) `df_g_theme_preset_colors__$(a.name_lower),`;
}
//- rjf: cmd param slot -> view spec tables
@table_gen_data(type: DF_CmdParamSlot, fallback:`DF_CmdParamSlot_Null`)
df_g_cmd_param_slot_2_view_spec_src_map:
{
@expand(DF_CmdParamSlot2ViewSpecMap a) `DF_CmdParamSlot_$(a.slot),`
}
@table_gen_data(type: String8, fallback:`{0}`)
df_g_cmd_param_slot_2_view_spec_dst_map:
{
@expand(DF_CmdParamSlot2ViewSpecMap a) `str8_lit_comp("$(a.view_spec)"),`
}
@table_gen_data(type: String8, fallback:`{0}`)
df_g_cmd_param_slot_2_view_spec_cmd_map:
{
@expand(DF_CmdParamSlot2ViewSpecMap a) `str8_lit_comp("$(a.opt_cmd_spec)"),`
}
//- rjf: default bindings table
@table_gen_data(type: DF_StringBindingPair, fallback: `{0}`)
df_g_default_binding_table:
{
@expand(DF_DefaultBindingTable a) ```{str8_lit_comp("$(a.name)"), {OS_Key_$(a.key), 0 $(a.ctrl != 0 -> `|OS_EventFlag_Ctrl`) $(a.shift != 0 -> `|OS_EventFlag_Shift`) $(a.alt != 0 -> `|OS_EventFlag_Alt`)}},```;
}
//- rjf: binding version remap tables
@table_gen_data(type: String8, fallback: `{0}`)
df_g_binding_version_remap_old_name_table:
{
@expand(DF_BindingVersionRemapTable a) `str8_lit_comp("$(a.old_name)"),`
}
@table_gen_data(type: String8, fallback: `{0}`)
df_g_binding_version_remap_new_name_table:
{
@expand(DF_BindingVersionRemapTable a) `str8_lit_comp("$(a.new_name)"),`
}
//- rjf: view hook forward declares
@table_gen
{
@expand(DF_GfxViewTable a) `DF_VIEW_SETUP_FUNCTION_DEF($(a.name));`;
@expand(DF_GfxViewTable a) `DF_VIEW_STRING_FROM_STATE_FUNCTION_DEF($(a.name));`;
@expand(DF_GfxViewTable a) `DF_VIEW_CMD_FUNCTION_DEF($(a.name));`;
@expand(DF_GfxViewTable a) `DF_VIEW_UI_FUNCTION_DEF($(a.name));`;
}
//- rjf: gfx view rule function forward declares
@table_gen
{
``;
@expand(DF_GfxViewRuleTable a)
`$(a.vr == "x" -> "DF_GFX_VIEW_RULE_VIZ_ROW_PROD_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.ls == "x" -> "DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.ru == "x" -> "DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_DEF(" .. a.name_lower .. ");")`;
@expand(DF_GfxViewRuleTable a)
`$(a.bu == "x" -> "DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_DEF(" .. a.name_lower .. ");")`;
}
//- rjf: gfx view rule tables
@table_gen_data(type: DF_GfxViewRuleSpecInfo, fallback: `{0}`) @c_file
df_g_gfx_view_rule_spec_info_table:
{
@expand(DF_GfxViewRuleTable a)
```{ str8_lit_comp("$(a.string)"), (DF_GfxViewRuleSpecInfoFlag_VizRowProd*$(a.vr == "x"))|(DF_GfxViewRuleSpecInfoFlag_LineStringize*$(a.ls == "x"))|(DF_GfxViewRuleSpecInfoFlag_RowUI*$(a.ru == "x"))|(DF_GfxViewRuleSpecInfoFlag_BlockUI*$(a.bu == "x")), $(a.vr == "x" -> "DF_GFX_VIEW_RULE_VIZ_ROW_PROD_FUNCTION_NAME("..a.name_lower..")") $(a.vr != "x" -> 0), $(a.ls == "x" -> "DF_GFX_VIEW_RULE_LINE_STRINGIZE_FUNCTION_NAME("..a.name_lower..")") $(a.ls != "x" -> 0), $(a.ru == "x" -> "DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_NAME("..a.name_lower..")") $(a.ru != "x" -> 0), $(a.bu == "x" -> "DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_NAME("..a.name_lower..")") $(a.bu != "x" -> 0), },```;
}
//- rjf: default view spec info table
@table_gen_data(type: DF_ViewSpecInfo, fallback: `{0}`)
df_g_gfx_view_kind_spec_info_table:
{
@expand(DF_GfxViewTable a) ```{(0|$(a.parameterized_by_entity)*DF_ViewSpecFlag_ParameterizedByEntity|$(a.can_serialize)*DF_ViewSpecFlag_CanSerialize|$(a.can_serialize_entity_path)*DF_ViewSpecFlag_CanSerializeEntityPath|$(a.can_filter)*DF_ViewSpecFlag_CanFilter|$(a.filter_is_code)*DF_ViewSpecFlag_FilterIsCode|$(a.typing_automatically_filters)*DF_ViewSpecFlag_TypingAutomaticallyFilters), str8_lit_comp("$(a.name_lower)"), str8_lit_comp("$(a.display_string)"), DF_NameKind_$(a.name_kind), DF_IconKind_$(a.icon), DF_VIEW_SETUP_FUNCTION_NAME($(a.name)), DF_VIEW_STRING_FROM_STATE_FUNCTION_NAME($(a.name)), DF_VIEW_CMD_FUNCTION_NAME($(a.name)), DF_VIEW_UI_FUNCTION_NAME($(a.name))},```;
}
//- rjf: theme color tables
@table_gen_data(type: String8, fallback: `str8_lit_comp("")`)
df_g_theme_color_display_string_table:
{
@expand(DF_ThemeTable a) `str8_lit_comp("$(a.display_name)"),`;
}
@table_gen_data(type: String8, fallback: `str8_lit_comp("")`)
df_g_theme_color_cfg_string_table:
{
@expand(DF_ThemeTable a) `str8_lit_comp("$(a.name_lower)"),`;
@expand(DF_SettingTable a) `{$(a.s32_min), $(a.s32_max)}`
}
////////////////////////////////
@@ -654,7 +648,7 @@ raddbg_readme:
{
@p "`--help` Displays a help menu which documents the possible command line options.";
@p "`--user:<path>` Specifies a path to the user file which the debugger should use instead of the default. The default user file is stored at `%appdata%/raddbg/default.raddbg_user`. For more information on user files, read the 'User & Profile Files' section.";
@p "`--profile:<path>` Specifies a path to the profile file which the debugger should use instead of the default. The default profile file is stored at `%appdata%/raddbg/default.raddbg_profile`. For more information on profile files, read the 'User & Profile Files' section.";
@p "`--project:<path>` Specifies a path to the project file which the debugger should use instead of the default. The default project file is stored at `%appdata%/raddbg/default.raddbg_project`. For more information on project files, read the 'User & Project Files' section.";
@p "`--auto_run` Specifies that the debugger should immediately run its selected targets upon launching.";
@p "`--auto_step` Specifies that the debugger should immediately step into its selected targets upon launching.";
//@p "`--ipc` Specifies that the launched debugger instance is for communicating a command to another instance of the debugger. In this mode, any non-argument command line contents will be used to express a command. For more information on commands, read the 'Commands' section. For more information on driving another debugger instance with this argument, read the 'Driving Another Debugger Instance' section."
@@ -693,7 +687,7 @@ raddbg_readme:
@subtitle "Targets";
@p "A *target* is one executable and configuration for launching that executable, including command line arguments and working directory (the directory from which the executable is launched). Each target may also have a custom label (replaces the executable path when visualizing the target), and the name of a custom entry point function (when the default entry points - `main`, `WinMain`, etc. - are not desired when stepping into the program upon launch). The debugger can have several targets at once. Each target can also be enabled or disabled. Some operations work on all enabled targets - for instance, the `Run` or `Kill All` commands (standardly bound as F5 or Shift + F5). Enabling and disabling targets allows one to filter which targets are currently being worked with.";
@p "To add a target, you can run the `Add Target` command. A target is also created automatically from command line arguments - the rules for how this happens can be found in the `Command-Line Usage` section.";
@p "Targets created through command line usage are temporary, meaning they are not persistently saved across runs of the debugger. To change this, you can right click the command-line-created target in the `Targets` view, and click `Save To Profile`. After doing so, the target will be restored across runs, and will no longer need to be specified on the command-line.";
@p "Targets created through command line usage are temporary, meaning they are not persistently saved across runs of the debugger. To change this, you can right click the command-line-created target in the `Targets` view, and click `Save To Project`. After doing so, the target will be restored across runs, and will no longer need to be specified on the command-line.";
@subtitle "View Rules";
@p "*View Rules* are used to transform the way that evaluations in the debugger are visualized. An evaluation is produced by taking an expression string - for instance, the name of a variable - and using debug info and information from an attached process' live runtime (memory, registers, and so on) to interpret it.";
@@ -712,11 +706,11 @@ raddbg_readme:
@p "Each breakpoint has a hit count. Every time a breakpoint causes execution to stop, this counter is increased.";
@p "Processor breakpoints are not currently supported, but planned to be in the future.";
@subtitle "User & Profile Files";
@p "Applicable state controlling the debugger's appearance, behavior, targets, breakpoints, and other configurations is saved and reloaded across runs of the debugger through both *user files* and *profile files*. These files are auto-saved. These files are written in a textual format which can be hand-edited as necessary, but they're also continuously re-read and re-written by the debugger. By default, the debugger uses `%appdata%/raddbg/default.raddbg_user` for its user file path, and `%appdata%/raddbg/default.raddbg_profile` for its profile file path. These paths can be overridden on the command line (see the 'Command-Line Usage' section).";
@subtitle "User & Project Files";
@p "Applicable state controlling the debugger's appearance, behavior, targets, breakpoints, and other configurations is saved and reloaded across runs of the debugger through both *user files* and *project files*. These files are auto-saved. These files are written in a textual format which can be hand-edited as necessary, but they're also continuously re-read and re-written by the debugger. By default, the debugger uses `%appdata%/raddbg/default.raddbg_user` for its user file path, and `%appdata%/raddbg/default.raddbg_project` for its project file path. These paths can be overridden on the command line (see the 'Command-Line Usage' section).";
@p "The *user file* defaultly stores file path maps, windows (including their preferred monitor, placement, and size), each window's panel layout and tabs, keybindings, theme colors, and fonts.";
@p "The *profile file* defaultly stores targets, breakpoints, watch pins, and exception code filters.";
@p "Because both can be hand-edited, however, if you want to store something normally stored in a user file in a profile file, or vice versa, this can be done by hand transferring the textual data from one file to another. There is no path in the debugger's UI to support this transfer, currently, although this is planned.";
@p "The *project file* defaultly stores targets, breakpoints, watch pins, and exception code filters.";
@p "Because both can be hand-edited, however, if you want to store something normally stored in a user file in a project file, or vice versa, this can be done by hand transferring the textual data from one file to another. There is no path in the debugger's UI to support this transfer, currently, although this is planned.";
//@subtitle "Driving Another Debugger Instance";
//@p "When the debugger is launched with the `--ipc` command-line argument, it does not launch another instance of the graphical debugger. Instead, it launches, sends a string encoding a command to a running instance of the graphical debugger, and then terminates. The set of commands which can be sent are identical to those which can be run from the debugger's UI itself, but these commands must be encoded textually (through the other command-line arguments). These commands are described in the 'Commands' section.";
-41
View File
@@ -1,41 +0,0 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DF_VIEW_RULE_HOOKS_H
#define DF_VIEW_RULE_HOOKS_H
////////////////////////////////
//~ rjf: Helper Types
typedef struct DF_BitmapTopologyInfo DF_BitmapTopologyInfo;
struct DF_BitmapTopologyInfo
{
U64 width;
U64 height;
R_Tex2DFormat fmt;
};
typedef struct DF_GeoTopologyInfo DF_GeoTopologyInfo;
struct DF_GeoTopologyInfo
{
U64 index_count;
Rng1U64 vertices_vaddr_range;
};
typedef struct DF_TxtTopologyInfo DF_TxtTopologyInfo;
struct DF_TxtTopologyInfo
{
TXT_LangKind lang;
U64 size_cap;
};
////////////////////////////////
//~ rjf: Helpers
internal Vec4F32 df_view_rule_hooks__rgba_from_eval(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed *raddbg, DF_Entity *process);
internal void df_view_rule_hooks__eval_commit_rgba(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed *raddbg, DF_CtrlCtx *ctrl_ctx, Vec4F32 rgba);
internal DF_BitmapTopologyInfo df_view_rule_hooks__bitmap_topology_info_from_cfg(DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
internal DF_GeoTopologyInfo df_view_rule_hooks__geo_topology_info_from_cfg(DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
internal DF_TxtTopologyInfo df_view_rule_hooks__txt_topology_info_from_cfg(DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
#endif //DF_VIEW_RULE_HOOKS_H
File diff suppressed because it is too large Load Diff
+144
View File
@@ -0,0 +1,144 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
#ifndef DF_VIEW_RULES_H
#define DF_VIEW_RULES_H
////////////////////////////////
//~ rjf: "rgba"
typedef struct DF_VR_RGBAState DF_VR_RGBAState;
struct DF_VR_RGBAState
{
Vec4F32 hsva;
U64 memgen_idx;
};
internal Vec4F32 df_vr_rgba_from_eval(DF_Eval eval, TG_Graph *graph, RDI_Parsed *raddbg, DF_Entity *process);
internal void df_vr_eval_commit_rgba(DF_Eval eval, TG_Graph *graph, RDI_Parsed *raddbg, DF_CtrlCtx *ctrl_ctx, Vec4F32 rgba);
////////////////////////////////
//~ rjf: "text"
typedef struct DF_TxtTopologyInfo DF_TxtTopologyInfo;
struct DF_TxtTopologyInfo
{
TXT_LangKind lang;
U64 size_cap;
};
typedef struct DF_VR_TextState DF_VR_TextState;
struct DF_VR_TextState
{
B32 initialized;
TxtPt cursor;
TxtPt mark;
S64 preferred_column;
U64 last_open_frame_idx;
F32 loaded_t;
};
internal DF_TxtTopologyInfo df_vr_txt_topology_info_from_cfg(DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
////////////////////////////////
//~ rjf: "disasm"
typedef struct DF_DisasmTopologyInfo DF_DisasmTopologyInfo;
struct DF_DisasmTopologyInfo
{
Architecture arch;
U64 size_cap;
};
typedef struct DF_VR_DisasmState DF_VR_DisasmState;
struct DF_VR_DisasmState
{
B32 initialized;
TxtPt cursor;
TxtPt mark;
S64 preferred_column;
U64 last_open_frame_idx;
F32 loaded_t;
};
internal DF_DisasmTopologyInfo df_vr_disasm_topology_info_from_cfg(DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
////////////////////////////////
//~ rjf: "bitmap"
typedef struct DF_BitmapTopologyInfo DF_BitmapTopologyInfo;
struct DF_BitmapTopologyInfo
{
U64 width;
U64 height;
R_Tex2DFormat fmt;
};
typedef struct DF_BitmapViewState DF_BitmapViewState;
struct DF_BitmapViewState
{
Vec2F32 view_center_pos;
F32 zoom;
DF_BitmapTopologyInfo top;
};
typedef struct DF_VR_BitmapState DF_VR_BitmapState;
struct DF_VR_BitmapState
{
U64 last_open_frame_idx;
F32 loaded_t;
};
typedef struct DF_VR_BitmapBoxDrawData DF_VR_BitmapBoxDrawData;
struct DF_VR_BitmapBoxDrawData
{
Rng2F32 src;
R_Handle texture;
F32 loaded_t;
B32 hovered;
Vec2S32 mouse_px;
F32 ui_per_bmp_px;
};
internal Vec2F32 df_bitmap_view_state__screen_from_canvas_pos(DF_BitmapViewState *bvs, Rng2F32 rect, Vec2F32 cvs);
internal Rng2F32 df_bitmap_view_state__screen_from_canvas_rect(DF_BitmapViewState *bvs, Rng2F32 rect, Rng2F32 cvs);
internal Vec2F32 df_bitmap_view_state__canvas_from_screen_pos(DF_BitmapViewState *bvs, Rng2F32 rect, Vec2F32 scr);
internal Rng2F32 df_bitmap_view_state__canvas_from_screen_rect(DF_BitmapViewState *bvs, Rng2F32 rect, Rng2F32 scr);
internal DF_BitmapTopologyInfo df_vr_bitmap_topology_info_from_cfg(DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
////////////////////////////////
//~ rjf: "geo"
typedef struct DF_GeoTopologyInfo DF_GeoTopologyInfo;
struct DF_GeoTopologyInfo
{
U64 index_count;
Rng1U64 vertices_vaddr_range;
};
typedef struct DF_VR_GeoState DF_VR_GeoState;
struct DF_VR_GeoState
{
B32 initialized;
U64 last_open_frame_idx;
F32 loaded_t;
F32 pitch;
F32 pitch_target;
F32 yaw;
F32 yaw_target;
F32 zoom;
F32 zoom_target;
};
typedef struct DF_VR_GeoBoxDrawData DF_VR_GeoBoxDrawData;
struct DF_VR_GeoBoxDrawData
{
DF_ExpandKey key;
R_Handle vertex_buffer;
R_Handle index_buffer;
F32 loaded_t;
};
internal DF_GeoTopologyInfo df_vr_geo_topology_info_from_cfg(DI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_CfgNode *cfg);
#endif // DF_VIEW_RULES_H
+3531 -3313
View File
File diff suppressed because it is too large Load Diff
+158 -60
View File
@@ -101,7 +101,6 @@ struct DF_PendingEntityViewState
{
Arena *deferred_cmd_arena;
DF_CmdList deferred_cmds;
DF_Handle pick_file_override_target;
Arena *complete_cfg_arena;
DF_CfgNode *complete_cfg_root;
};
@@ -144,7 +143,7 @@ struct DF_EntityListerItemArray
typedef struct DF_ProcessInfo DF_ProcessInfo;
struct DF_ProcessInfo
{
DEMON_ProcessInfo info;
DMN_ProcessInfo info;
B32 is_attached;
FuzzyMatchRangeList attached_match_ranges;
FuzzyMatchRangeList name_match_ranges;
@@ -230,6 +229,23 @@ struct DF_FilePathMapViewState
F32 dst_column_pct;
};
////////////////////////////////
//~ rjf: AutoViewRules @view_types
typedef struct DF_AutoViewRulesViewState DF_AutoViewRulesViewState;
struct DF_AutoViewRulesViewState
{
B32 initialized;
Vec2S64 cursor;
TxtPt input_cursor;
TxtPt input_mark;
U8 input_buffer[1024];
U64 input_size;
B32 input_editing;
F32 src_column_pct;
F32 dst_column_pct;
};
////////////////////////////////
//~ rjf: Modules @view_types
@@ -264,55 +280,70 @@ struct DF_EvalRoot
U8 *expr_buffer;
};
typedef enum DF_EvalWatchViewColumnKind
typedef enum DF_WatchViewColumnKind
{
DF_EvalWatchViewColumnKind_Expr,
DF_EvalWatchViewColumnKind_Value,
DF_EvalWatchViewColumnKind_Type,
DF_EvalWatchViewColumnKind_ViewRule,
DF_EvalWatchViewColumnKind_COUNT
DF_WatchViewColumnKind_Expr,
DF_WatchViewColumnKind_Value,
DF_WatchViewColumnKind_Type,
DF_WatchViewColumnKind_ViewRule,
DF_WatchViewColumnKind_COUNT
}
DF_EvalWatchViewColumnKind;
DF_WatchViewColumnKind;
typedef enum DF_EvalWatchViewFillKind
typedef enum DF_WatchViewFillKind
{
DF_EvalWatchViewFillKind_Mutable,
DF_EvalWatchViewFillKind_Registers,
DF_EvalWatchViewFillKind_Locals,
DF_EvalWatchViewFillKind_Globals,
DF_EvalWatchViewFillKind_ThreadLocals,
DF_EvalWatchViewFillKind_Types,
DF_EvalWatchViewFillKind_Procedures,
DF_EvalWatchViewFillKind_COUNT
DF_WatchViewFillKind_Mutable,
DF_WatchViewFillKind_Registers,
DF_WatchViewFillKind_Locals,
DF_WatchViewFillKind_Globals,
DF_WatchViewFillKind_ThreadLocals,
DF_WatchViewFillKind_Types,
DF_WatchViewFillKind_Procedures,
DF_WatchViewFillKind_COUNT
}
DF_EvalWatchViewFillKind;
DF_WatchViewFillKind;
typedef struct DF_EvalWatchViewPoint DF_EvalWatchViewPoint;
struct DF_EvalWatchViewPoint
typedef struct DF_WatchViewPoint DF_WatchViewPoint;
struct DF_WatchViewPoint
{
DF_EvalWatchViewColumnKind column_kind;
DF_WatchViewColumnKind column_kind;
DF_ExpandKey parent_key;
DF_ExpandKey key;
};
typedef struct DF_EvalWatchViewState DF_EvalWatchViewState;
struct DF_EvalWatchViewState
typedef struct DF_WatchViewTextEditState DF_WatchViewTextEditState;
struct DF_WatchViewTextEditState
{
DF_WatchViewTextEditState *pt_hash_next;
DF_WatchViewPoint pt;
TxtPt cursor;
TxtPt mark;
U8 input_buffer[1024];
U64 input_size;
U8 initial_buffer[1024];
U64 initial_size;
};
typedef struct DF_WatchViewState DF_WatchViewState;
struct DF_WatchViewState
{
B32 initialized;
// rjf: fill kind (way that the contents of the watch view are computed)
DF_EvalWatchViewFillKind fill_kind;
DF_WatchViewFillKind fill_kind;
// rjf; table cursor state
DF_EvalWatchViewPoint cursor;
DF_EvalWatchViewPoint mark;
DF_WatchViewPoint cursor;
DF_WatchViewPoint mark;
DF_WatchViewPoint next_cursor;
DF_WatchViewPoint next_mark;
// rjf: text input state
TxtPt input_cursor;
TxtPt input_mark;
U8 input_buffer[1024];
U64 input_size;
B32 input_editing;
Arena *text_edit_arena;
U64 text_edit_state_slots_count;
DF_WatchViewTextEditState dummy_text_edit_state;
DF_WatchViewTextEditState **text_edit_state_slots;
B32 text_editing;
// rjf: table column width state
F32 expr_column_pct;
@@ -328,18 +359,30 @@ struct DF_EvalWatchViewState
};
////////////////////////////////
//~ rjf: Code @view_types
//~ rjf: Code, Output @view_types
typedef U32 DF_CodeViewFlags;
enum
{
DF_CodeViewFlag_StickToBottom = (1<<0),
};
typedef U32 DF_CodeViewBuildFlags;
enum
{
DF_CodeViewBuildFlag_Margins = (1<<0),
DF_CodeViewBuildFlag_All = 0xffffffff,
};
typedef struct DF_CodeViewState DF_CodeViewState;
struct DF_CodeViewState
{
// rjf: stable state
B32 initialized;
TxtPt cursor;
TxtPt mark;
S64 preferred_column;
B32 drifted_for_search;
DF_Handle pick_file_override_target;
DF_CodeViewFlags flags;
// rjf: per-frame command info
S64 goto_line_num;
@@ -356,23 +399,12 @@ struct DF_CodeViewState
typedef struct DF_DisasmViewState DF_DisasmViewState;
struct DF_DisasmViewState
{
// rjf: stable state
B32 initialized;
DF_Handle process;
U64 base_vaddr;
TxtPt cursor;
TxtPt mark;
S64 preferred_column;
B32 drifted_for_search;
// rjf: per-frame command info
S64 goto_line_num;
DASM_StyleFlags style_flags;
U64 goto_vaddr;
B32 center_cursor;
B32 contain_cursor;
Arena *find_text_arena;
String8 find_text_fwd;
String8 find_text_bwd;
DF_CodeViewState cv;
};
////////////////////////////////
@@ -402,6 +434,56 @@ struct DF_MemoryViewState
B32 contain_cursor;
};
////////////////////////////////
//~ rjf: Settings @view_types
typedef enum DF_SettingsItemKind
{
DF_SettingsItemKind_CategoryHeader,
DF_SettingsItemKind_Setting,
DF_SettingsItemKind_ThemeColor,
DF_SettingsItemKind_ThemePreset,
DF_SettingsItemKind_COUNT
}
DF_SettingsItemKind;
typedef struct DF_SettingsItem DF_SettingsItem;
struct DF_SettingsItem
{
DF_SettingsItemKind kind;
String8 kind_string;
String8 string;
FuzzyMatchRangeList kind_string_matches;
FuzzyMatchRangeList string_matches;
DF_IconKind icon_kind;
DF_SettingCode code;
DF_ThemeColor color;
DF_ThemePreset preset;
DF_SettingsItemKind category;
};
typedef struct DF_SettingsItemNode DF_SettingsItemNode;
struct DF_SettingsItemNode
{
DF_SettingsItemNode *next;
DF_SettingsItem v;
};
typedef struct DF_SettingsItemList DF_SettingsItemList;
struct DF_SettingsItemList
{
DF_SettingsItemNode *first;
DF_SettingsItemNode *last;
U64 count;
};
typedef struct DF_SettingsItemArray DF_SettingsItemArray;
struct DF_SettingsItemArray
{
DF_SettingsItem *v;
U64 count;
};
////////////////////////////////
//~ rjf: Quick Sort Comparisons
@@ -413,6 +495,7 @@ internal int df_qsort_compare_file_info__size(DF_FileInfo *a, DF_FileInfo *b);
internal int df_qsort_compare_process_info(DF_ProcessInfo *a, DF_ProcessInfo *b);
internal int df_qsort_compare_cmd_lister__strength(DF_CmdListerItem *a, DF_CmdListerItem *b);
internal int df_qsort_compare_entity_lister__strength(DF_EntityListerItem *a, DF_EntityListerItem *b);
internal int df_qsort_compare_settings_item(DF_SettingsItem *a, DF_SettingsItem *b);
////////////////////////////////
//~ rjf: Command Lister
@@ -436,30 +519,45 @@ internal DF_EntityListerItemArray df_entity_lister_item_array_from_list(Arena *a
internal void df_entity_lister_item_array_sort_by_strength__in_place(DF_EntityListerItemArray array);
////////////////////////////////
//~ rjf: Disassembly View
//~ rjf: Code Views
internal TXTI_TokenArray df_txti_token_array_from_dasm_arch_string(Arena *arena, Architecture arch, String8 string);
internal void df_code_view_init(DF_CodeViewState *cv, DF_View *view);
internal void df_code_view_cmds(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_CodeViewState *cv, DF_CmdList *cmds, String8 text_data, TXT_TextInfo *text_info, DASM_InstArray *dasm_insts, Rng1U64 dasm_vaddr_range, DI_Key dasm_dbgi_key);
internal void df_code_view_build(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_CodeViewState *cv, DF_CodeViewBuildFlags flags, Rng2F32 rect, String8 text_data, TXT_TextInfo *text_info, DASM_InstArray *dasm_insts, Rng1U64 dasm_vaddr_range, DI_Key dasm_dbgi_key);
////////////////////////////////
//~ rjf: Eval/Watch Views
//~ rjf: Watch Views
//- rjf: eval watch view instance -> eval view key
internal DF_EvalViewKey df_eval_view_key_from_eval_watch_view(DF_EvalWatchViewState *ewv);
internal DF_EvalViewKey df_eval_view_key_from_eval_watch_view(DF_WatchViewState *ewv);
//- rjf: root allocation/deallocation/mutation
internal DF_EvalRoot * df_eval_root_alloc(DF_View *view, DF_EvalWatchViewState *ews);
internal void df_eval_root_release(DF_EvalWatchViewState *ews, DF_EvalRoot *root);
internal DF_EvalRoot * df_eval_root_alloc(DF_View *view, DF_WatchViewState *ews);
internal void df_eval_root_release(DF_WatchViewState *ews, DF_EvalRoot *root);
internal void df_eval_root_equip_string(DF_EvalRoot *root, String8 string);
internal DF_EvalRoot * df_eval_root_from_string(DF_EvalWatchViewState *ews, String8 string);
internal DF_EvalRoot * df_eval_root_from_expand_key(DF_EvalWatchViewState *ews, DF_EvalView *eval_view, DF_ExpandKey expand_key);
internal DF_EvalRoot * df_eval_root_from_string(DF_WatchViewState *ews, String8 string);
internal DF_EvalRoot * df_eval_root_from_expand_key(DF_WatchViewState *ews, DF_EvalView *eval_view, DF_ExpandKey expand_key);
internal String8 df_string_from_eval_root(DF_EvalRoot *root);
internal DF_ExpandKey df_parent_expand_key_from_eval_root(DF_EvalRoot *root);
internal DF_ExpandKey df_expand_key_from_eval_root(DF_EvalRoot *root);
//- rjf: watch view points <-> table coordinates
internal B32 df_watch_view_point_match(DF_WatchViewPoint a, DF_WatchViewPoint b);
internal DF_WatchViewPoint df_watch_view_point_from_tbl(DF_EvalVizBlockList *blocks, Vec2S64 tbl);
internal Vec2S64 df_tbl_from_watch_view_point(DF_EvalVizBlockList *blocks, DF_WatchViewPoint pt);
//- rjf: table coordinates -> strings
internal String8 df_string_from_eval_viz_row_column_kind(Arena *arena, DF_EvalView *ev, TG_Graph *graph, RDI_Parsed *rdi, DF_EvalVizRow *row, DF_WatchViewColumnKind col_kind, B32 editable);
//- rjf: table coordinates -> text edit state
internal DF_WatchViewTextEditState *df_watch_view_text_edit_state_from_pt(DF_WatchViewState *wv, DF_WatchViewPoint pt);
//- rjf: windowed watch tree visualization
internal DF_EvalVizBlockList df_eval_viz_block_list_from_watch_view_state(Arena *arena, DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_View *view, DF_EvalWatchViewState *ews);
internal DF_EvalVizBlockList df_eval_viz_block_list_from_watch_view_state(Arena *arena, DI_Scope *di_scope, FZY_Scope *fzy_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, EVAL_String2ExprMap *macro_map, DF_View *view, DF_WatchViewState *ews);
//- rjf: eval/watch views main hooks
internal void df_eval_watch_view_init(DF_EvalWatchViewState *ewv, DF_View *view, DF_EvalWatchViewFillKind fill_kind);
internal void df_eval_watch_view_cmds(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_EvalWatchViewState *ewv, DF_CmdList *cmds);
internal void df_eval_watch_view_build(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_EvalWatchViewState *ewv, B32 modifiable, U32 default_radix, Rng2F32 rect);
internal void df_watch_view_init(DF_WatchViewState *ewv, DF_View *view, DF_WatchViewFillKind fill_kind);
internal void df_watch_view_cmds(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_WatchViewState *ewv, DF_CmdList *cmds);
internal void df_watch_view_build(DF_Window *ws, DF_Panel *panel, DF_View *view, DF_WatchViewState *ewv, B32 modifiable, U32 default_radix, Rng2F32 rect);
#endif // DEBUG_FRONTEND_VIEWS_H
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+48 -14
View File
@@ -54,6 +54,23 @@ d_fancy_string_list_push(Arena *arena, D_FancyStringList *list, D_FancyString *s
list->total_size += str->string.size;
}
internal void
d_fancy_string_list_concat_in_place(D_FancyStringList *dst, D_FancyStringList *to_push)
{
if(dst->last != 0 && to_push->first != 0)
{
dst->last->next = to_push->first;
dst->last = to_push->last;
dst->node_count += to_push->node_count;
dst->total_size += to_push->total_size;
}
else if(to_push->first != 0)
{
MemoryCopyStruct(dst, to_push);
}
MemoryZeroStruct(to_push);
}
internal String8
d_string_from_fancy_string_list(Arena *arena, D_FancyStringList *list)
{
@@ -70,14 +87,15 @@ d_string_from_fancy_string_list(Arena *arena, D_FancyStringList *list)
}
internal D_FancyRunList
d_fancy_run_list_from_fancy_string_list(Arena *arena, D_FancyStringList *strs)
d_fancy_run_list_from_fancy_string_list(Arena *arena, F32 tab_size_px, F_RunFlags flags, D_FancyStringList *strs)
{
ProfBeginFunction();
D_FancyRunList run_list = {0};
F32 base_align_px = 0;
for(D_FancyStringNode *n = strs->first; n != 0; n = n->next)
{
D_FancyRunNode *dst_n = push_array(arena, D_FancyRunNode, 1);
dst_n->v.run = f_push_run_from_string(arena, n->v.font, n->v.size, 0, n->v.string);
dst_n->v.run = f_push_run_from_string(arena, n->v.font, n->v.size, base_align_px, tab_size_px, flags, n->v.string);
dst_n->v.color = n->v.color;
dst_n->v.underline_thickness = n->v.underline_thickness;
dst_n->v.strikethrough_thickness = n->v.strikethrough_thickness;
@@ -85,6 +103,12 @@ d_fancy_run_list_from_fancy_string_list(Arena *arena, D_FancyStringList *strs)
run_list.node_count += 1;
run_list.dim.x += dst_n->v.run.dim.x;
run_list.dim.y = Max(run_list.dim.y, dst_n->v.run.dim.y);
base_align_px += dst_n->v.run.dim.x;
if(n->next != 0)
{
run_list.dim.x -= dst_n->v.run.end_pad;
base_align_px -= dst_n->v.run.end_pad;
}
}
ProfEnd();
return run_list;
@@ -288,6 +312,7 @@ d_blur(Rng2F32 rect, F32 blur_size, F32 corner_radius)
R_Pass *pass = r_pass_from_kind(arena, &bucket->passes, R_PassKind_Blur);
R_PassParams_Blur *params = pass->params_blur;
params->rect = rect;
params->clip = d_top_clip();
params->blur_size = blur_size;
params->corner_radii[Corner_00] = corner_radius;
params->corner_radii[Corner_01] = corner_radius;
@@ -450,9 +475,15 @@ d_truncated_fancy_run_list(Vec2F32 p, D_FancyRunList *list, F32 max_x, F_Run tra
for(D_FancyRunNode *n = list->first; n != 0; n = n->next)
{
D_FancyRun *fr = &n->v;
Rng1F32 pixel_range = {0};
{
pixel_range.min = 100000;
pixel_range.max = 0;
}
F_Piece *piece_first = fr->run.pieces.v;
F_Piece *piece_opl = piece_first + fr->run.pieces.count;
F32 pre_advance = advance;
F32 last_piece_end_pad = 0;
last_color = fr->color;
for(F_Piece *piece = piece_first;
piece < piece_opl;
@@ -480,14 +511,17 @@ d_truncated_fancy_run_list(Vec2F32 p, D_FancyRunList *list, F32 max_x, F_Run tra
//d_rect(dst, v4f32(1, 0, 0, 1), 0, 1.f, 0.f);
}
advance += piece->advance;
last_piece_end_pad = ((F32)piece->offset.x+(F32)dim_2s16(piece->subrect).x) - piece->advance;
pixel_range.min = Min(pre_advance, pixel_range.min);
pixel_range.max = Max(advance, pixel_range.max);
}
if(fr->underline_thickness > 0)
{
d_rect(r2f32p(p.x+pre_advance,
d_rect(r2f32p(p.x + pixel_range.min + 1.f,
p.y+fr->run.descent+fr->run.descent/8,
p.x+advance + (advance-pre_advance)/8,
p.x + pixel_range.max + last_piece_end_pad/2,
p.y+fr->run.descent+fr->run.descent/8+fr->underline_thickness),
fr->color, 0, 0, 1.f);
fr->color, 0, 0, 0.8f);
}
if(fr->strikethrough_thickness > 0)
{
@@ -703,44 +737,44 @@ d_truncated_text_run(Vec2F32 p, Vec4F32 color, F32 max_x, F_Run text_run, F_Run
}
internal void
d_text(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, String8 string)
d_text(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, String8 string)
{
Temp scratch = scratch_begin(0, 0);
F_Run run = f_push_run_from_string(scratch.arena, font, size, 0, string);
F_Run run = f_push_run_from_string(scratch.arena, font, size, base_align_px, tab_size_px, flags, string);
d_text_run(p, color, run);
scratch_end(scratch);
}
internal void
d_textf(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, char *fmt, ...)
d_textf(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, char *fmt, ...)
{
Temp scratch = scratch_begin(0, 0);
va_list args;
va_start(args, fmt);
String8 string = push_str8fv(scratch.arena, fmt, args);
va_end(args);
d_text(font, size, p, color, string);
d_text(font, size, base_align_px, tab_size_px, flags, p, color, string);
scratch_end(scratch);
}
internal void
d_truncated_text(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, F32 max_x, String8 string)
d_truncated_text(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, F32 max_x, String8 string)
{
Temp scratch = scratch_begin(0, 0);
F_Run run = f_push_run_from_string(scratch.arena, font, size, 0, string);
F_Run ellipses_run = f_push_run_from_string(scratch.arena, font, size, 0, str8_lit("..."));
F_Run run = f_push_run_from_string(scratch.arena, font, size, base_align_px, tab_size_px, flags, string);
F_Run ellipses_run = f_push_run_from_string(scratch.arena, font, size, base_align_px, tab_size_px, 0, str8_lit("..."));
d_truncated_text_run(p, color, max_x, run, ellipses_run);
scratch_end(scratch);
}
internal void
d_truncated_textf(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, F32 max_x, char *fmt, ...)
d_truncated_textf(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, F32 max_x, char *fmt, ...)
{
Temp scratch = scratch_begin(0, 0);
va_list args;
va_start(args, fmt);
String8 string = push_str8f(scratch.arena, fmt, args);
d_truncated_text(font, size, p, color, max_x, string);
d_truncated_text(font, size, base_align_px, tab_size_px, flags, p, color, max_x, string);
va_end(args);
scratch_end(scratch);
}
+6 -5
View File
@@ -109,8 +109,9 @@ internal U64 d_hash_from_string(String8 string);
//~ rjf: Fancy String Type Functions
internal void d_fancy_string_list_push(Arena *arena, D_FancyStringList *list, D_FancyString *str);
internal void d_fancy_string_list_concat_in_place(D_FancyStringList *dst, D_FancyStringList *to_push);
internal String8 d_string_from_fancy_string_list(Arena *arena, D_FancyStringList *list);
internal D_FancyRunList d_fancy_run_list_from_fancy_string_list(Arena *arena, D_FancyStringList *strs);
internal D_FancyRunList d_fancy_run_list_from_fancy_string_list(Arena *arena, F32 tab_size_px, F_RunFlags flags, D_FancyStringList *strs);
internal D_FancyRunList d_fancy_run_list_copy(Arena *arena, D_FancyRunList *src);
////////////////////////////////
@@ -186,9 +187,9 @@ internal void d_truncated_fancy_run_list(Vec2F32 p, D_FancyRunList *list, F32 ma
internal void d_truncated_fancy_run_fuzzy_matches(Vec2F32 p, D_FancyRunList *list, F32 max_x, FuzzyMatchRangeList *ranges, Vec4F32 color);
internal void d_text_run(Vec2F32 p, Vec4F32 color, F_Run run);
internal void d_truncated_text_run(Vec2F32 p, Vec4F32 color, F32 max_x, F_Run text_run, F_Run trailer_run);
internal void d_text(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, String8 string);
internal void d_textf(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, char *fmt, ...);
internal void d_truncated_text(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, F32 max_x, String8 string);
internal void d_truncated_textf(F_Tag font, F32 size, Vec2F32 p, Vec4F32 color, F32 max_x, char *fmt, ...);
internal void d_text(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, String8 string);
internal void d_textf(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, char *fmt, ...);
internal void d_truncated_text(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, F32 max_x, String8 string);
internal void d_truncated_textf(F_Tag font, F32 size, F32 base_align_px, F32 tab_size_px, F_RunFlags flags, Vec2F32 p, Vec4F32 color, F32 max_x, char *fmt, ...);
#endif // DRAW_H
+7 -7
View File
@@ -10,31 +10,31 @@ D_StackTable:
{Transparency transparency F32 `0` }
}
@table_gen
@gen
{
@expand(D_StackTable a) `typedef struct D_$(a.name)Node D_$(a.name)Node; struct D_$(a.name)Node {D_$(a.name)Node *next; $(a.type) v;};`;
}
@table_gen
@gen
{
`#define D_BucketStackDecls struct{\\`;
@expand(D_StackTable a) `D_$(a.name)Node *top_$(a.name_lower);\\`;
`}`;
}
@table_gen
@gen
{
@expand(D_StackTable a) `read_only global D_$(a.name)Node d_nil_$(a.name_lower) = {0, $(a.default_init)};`;
}
@table_gen
@gen
{
`#define D_BucketStackInits(b) do{\\`;
@expand(D_StackTable a) `(b)->top_$(a.name_lower) = &d_nil_$(a.name_lower);\\`;
`}while(0)`;
}
@table_gen
@gen
{
`#if 0`;
@expand(D_StackTable a) `internal $(a.type) $(=>35) d_push_$(a.name_lower)($(a.type) v);`;
@@ -43,14 +43,14 @@ D_StackTable:
`#endif`;
}
@table_gen @c_file
@gen @c_file
{
@expand(D_StackTable a) `internal $(a.type) $(=>35) d_push_$(a.name_lower)($(a.type) v) {D_StackPushImpl($(a.name), $(a.name_lower), $(a.type), v);}`;
@expand(D_StackTable a) `internal $(a.type) $(=>35) d_pop_$(a.name_lower)(void) {D_StackPopImpl($(a.name), $(a.name_lower), $(a.type));}`;
@expand(D_StackTable a) `internal $(a.type) $(=>35) d_top_$(a.name_lower)(void) {D_StackTopImpl($(a.name), $(a.name_lower), $(a.type));}`;
}
@table_gen
@gen
{
`#if 0`;
@expand(D_StackTable a) `#define D_$(a.name)Scope(v) $(=>35) DeferLoop(d_push_$(a.name_lower)(v), d_pop_$(a.name_lower)())`;
-1
View File
@@ -46,5 +46,4 @@ internal F32 d_top_transparency(void);
#define D_ClipScope(v) DeferLoop(d_push_clip(v), d_pop_clip())
#define D_TransparencyScope(v) DeferLoop(d_push_transparency(v), d_pop_transparency())
#endif
#endif // DRAW_META_H
+38 -16
View File
@@ -6,6 +6,8 @@
// op_string - string for quick display of the operator
EVAL_ExprKindTable:
{
{ Nil 0 "" }
{ ArrayIndex 2 "[]" }
{ MemberAccess 2 "." }
{ Deref 1 "*" }
@@ -54,31 +56,51 @@ EVAL_ExprKindTable:
{ LeafIdent 0 "leaf_ident" }
}
@table_gen
@table(name display_string)
EVAL_ResultCodeTable:
{
`typedef U32 EVAL_ExprKind;`;
`enum`;
`{`;
@expand(EVAL_ExprKindTable a) `EVAL_ExprKind_$(a.name),`;
`EVAL_ExprKind_COUNT`;
`};`;
``;
{ Good "" }
{ DivideByZero "Cannot divide by zero." }
{ BadOp "Invalid operation." }
{ BadOpTypes "Invalid operation types." }
{ BadMemRead "Failed memory read." }
{ BadRegRead "Failed register read." }
{ BadFrameBase "Invalid frame base address." }
{ BadModuleBase "Invalid module base address." }
{ BadTLSBase "Invalid thread-local storage base address." }
{ InsufficientStackSpace "Insufficient evaluation machine stack space." }
{ MalformedBytecode "Malformed bytecode." }
}
@table_gen_data(type:U8, fallback:0)
eval_expr_kind_child_counts:
@enum(U32) EVAL_ExprKind:
{
@expand(EVAL_ExprKindTable a) `$(a.num_children),`;
@expand(EVAL_ExprKindTable a) `$(a.name)`,
COUNT,
}
@table_gen_data(type:String8, fallback:`{0}`)
@enum EVAL_ResultCode:
{
@expand(EVAL_ResultCodeTable a) `$(a.name)`,
COUNT,
}
@data(U8) eval_expr_kind_child_counts:
{
@expand(EVAL_ExprKindTable a) `$(a.num_children)`
}
@data(String8)
eval_expr_kind_strings:
{
@expand(EVAL_ExprKindTable a) `str8_lit_comp("$(a.name)"),`;
@expand(EVAL_ExprKindTable a) `str8_lit_comp("$(a.name)")`
}
@table_gen_data(type:String8, fallback:`{0}`)
eval_expr_op_strings:
@data(String8) eval_result_code_display_strings:
{
@expand(EVAL_ExprKindTable a) `str8_lit_comp("$(a.op_string)"),`;
@expand(EVAL_ResultCodeTable a) `str8_lit_comp("$(a.display_string)")`
}
@data(String8) eval_expr_op_strings:
{
@expand(EVAL_ExprKindTable a) `str8_lit_comp("$(a.op_string)")`
}
+218 -211
View File
File diff suppressed because it is too large Load Diff
+17 -17
View File
@@ -9,7 +9,7 @@
internal String8 eval_bytecode_from_oplist(Arena *arena, EVAL_OpList *list);
internal void eval_oplist_push_op(Arena *arena, EVAL_OpList *list, RADDBG_EvalOp op, U64 p);
internal void eval_oplist_push_op(Arena *arena, EVAL_OpList *list, RDI_EvalOp op, U64 p);
internal void eval_oplist_push_uconst(Arena *arena, EVAL_OpList *list, U64 x);
internal void eval_oplist_push_sconst(Arena *arena, EVAL_OpList *list, S64 x);
@@ -20,7 +20,7 @@ internal void eval_oplist_concat_in_place(EVAL_OpList *left_dst, EVAL_OpList *ri
////////////////////////////////
//~ allen: EVAL Expression Info Functions
internal RADDBG_EvalOp eval_opcode_from_expr_kind(EVAL_ExprKind kind);
internal RDI_EvalOp eval_opcode_from_expr_kind(EVAL_ExprKind kind);
internal B32 eval_expr_kind_is_comparison(EVAL_ExprKind kind);
////////////////////////////////
@@ -40,13 +40,13 @@ internal EVAL_Expr* eval_expr_leaf_type(Arena *arena, void *location, TG_Key typ
////////////////////////////////
//~ allen: EVAL Type Information Transformers
internal RADDBG_EvalTypeGroup eval_type_group_from_kind(TG_Kind kind);
internal RDI_EvalTypeGroup eval_type_group_from_kind(TG_Kind kind);
internal TG_Key eval_type_unwrap_enum(TG_Graph *graph, RADDBG_Parsed *rdbg, TG_Key key);
internal TG_Key eval_type_promote(TG_Graph *graph, RADDBG_Parsed *rdbg, TG_Key key);
internal TG_Key eval_type_coerce(TG_Graph *graph, RADDBG_Parsed *rdbg, TG_Key l, TG_Key r);
internal TG_Key eval_type_unwrap_enum(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key eval_type_promote(TG_Graph *graph, RDI_Parsed *rdi, TG_Key key);
internal TG_Key eval_type_coerce(TG_Graph *graph, RDI_Parsed *rdi, TG_Key l, TG_Key r);
internal B32 eval_type_match(TG_Graph *graph, RADDBG_Parsed *rdbg, TG_Key l, TG_Key r);
internal B32 eval_type_match(TG_Graph *graph, RDI_Parsed *rdi, TG_Key l, TG_Key r);
internal B32 eval_kind_is_integer(TG_Kind kind);
internal B32 eval_kind_is_signed(TG_Kind kind);
@@ -56,27 +56,27 @@ internal B32 eval_kind_is_basic_or_enum(TG_Kind kind);
//~ allen: EVAL IR-Tree Constructors
internal EVAL_IRTree* eval_irtree_const_u(Arena *arena, U64 v);
internal EVAL_IRTree* eval_irtree_unary_op(Arena *arena, RADDBG_EvalOp op, RADDBG_EvalTypeGroup group, EVAL_IRTree *c);
internal EVAL_IRTree* eval_irtree_binary_op(Arena *arena, RADDBG_EvalOp op, RADDBG_EvalTypeGroup group, EVAL_IRTree *l, EVAL_IRTree *r);
internal EVAL_IRTree* eval_irtree_binary_op_u(Arena *arena, RADDBG_EvalOp op, EVAL_IRTree *l, EVAL_IRTree *r);
internal EVAL_IRTree* eval_irtree_unary_op(Arena *arena, RDI_EvalOp op, RDI_EvalTypeGroup group, EVAL_IRTree *c);
internal EVAL_IRTree* eval_irtree_binary_op(Arena *arena, RDI_EvalOp op, RDI_EvalTypeGroup group, EVAL_IRTree *l, EVAL_IRTree *r);
internal EVAL_IRTree* eval_irtree_binary_op_u(Arena *arena, RDI_EvalOp op, EVAL_IRTree *l, EVAL_IRTree *r);
internal EVAL_IRTree* eval_irtree_conditional(Arena *arena, EVAL_IRTree *c, EVAL_IRTree *l, EVAL_IRTree *r);
internal EVAL_IRTree* eval_irtree_bytecode_no_copy(Arena *arena, String8 bytecode);
////////////////////////////////
//~ allen: EVAL IR-Tree High Level Helpers
internal EVAL_IRTree* eval_irtree_mem_read_type(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, EVAL_IRTree *c, TG_Key type_key);
internal EVAL_IRTree* eval_irtree_convert_lo(Arena *arena, EVAL_IRTree *c, RADDBG_EvalTypeGroup out, RADDBG_EvalTypeGroup in);
internal EVAL_IRTree* eval_irtree_trunc(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, EVAL_IRTree *c, TG_Key type_key);
internal EVAL_IRTree* eval_irtree_convert_hi(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, EVAL_IRTree *c, TG_Key out, TG_Key in);
internal EVAL_IRTree* eval_irtree_resolve_to_value(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, EVAL_EvalMode from_mode, EVAL_IRTree *tree, TG_Key type_key);
internal EVAL_IRTree* eval_irtree_mem_read_type(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_IRTree *c, TG_Key type_key);
internal EVAL_IRTree* eval_irtree_convert_lo(Arena *arena, EVAL_IRTree *c, RDI_EvalTypeGroup out, RDI_EvalTypeGroup in);
internal EVAL_IRTree* eval_irtree_trunc(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_IRTree *c, TG_Key type_key);
internal EVAL_IRTree* eval_irtree_convert_hi(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_IRTree *c, TG_Key out, TG_Key in);
internal EVAL_IRTree* eval_irtree_resolve_to_value(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_EvalMode from_mode, EVAL_IRTree *tree, TG_Key type_key);
////////////////////////////////
//~ allen: EVAL Compiler Phases
internal void eval_push_leaf_ident_exprs_from_expr__in_place(Arena *arena, EVAL_String2ExprMap *map, EVAL_Expr *expr, EVAL_ErrorList *eout);
internal TG_Key eval_type_from_type_expr(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, EVAL_Expr *expr, EVAL_ErrorList *eout);
internal EVAL_IRTreeAndType eval_irtree_and_type_from_expr(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg, EVAL_String2ExprMap *leaf_ident_expr_map, EVAL_Expr *expr, EVAL_ErrorList *eout);
internal TG_Key eval_type_from_type_expr(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_Expr *expr, EVAL_ErrorList *eout);
internal EVAL_IRTreeAndType eval_irtree_and_type_from_expr(Arena *arena, TG_Graph *graph, RDI_Parsed *rdi, EVAL_String2ExprMap *leaf_ident_expr_map, EVAL_Expr *expr, EVAL_ErrorList *eout);
internal void eval_oplist_from_irtree(Arena *arena, EVAL_IRTree *tree, EVAL_OpList *out);
#endif //EVAL_COMPILER_H
+41
View File
@@ -1,6 +1,11 @@
// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Generated Code
#include "generated/eval.meta.c"
////////////////////////////////
//~ rjf: Basic Functions
@@ -88,6 +93,7 @@ eval_string2num_map_insert(Arena *arena, EVAL_String2NumMap *map, String8 string
SLLQueuePush_N(map->first, map->last, node, order_next);
node->string = push_str8_copy(arena, string);
node->num = num;
map->node_count += 1;
}
}
@@ -116,6 +122,41 @@ eval_num_from_string(EVAL_String2NumMap *map, String8 string)
return num;
}
internal EVAL_String2NumMapNodeArray
eval_string2num_map_node_array_from_map(Arena *arena, EVAL_String2NumMap *map)
{
EVAL_String2NumMapNodeArray result = {0};
result.count = map->node_count;
result.v = push_array(arena, EVAL_String2NumMapNode *, result.count);
U64 idx = 0;
for(EVAL_String2NumMapNode *n = map->first; n != 0; n = n->order_next, idx += 1)
{
result.v[idx] = n;
}
return result;
}
internal int
eval_string2num_map_node_qsort_compare__num_ascending(EVAL_String2NumMapNode **a, EVAL_String2NumMapNode **b)
{
int result = 0;
if(a[0]->num < b[0]->num)
{
result = -1;
}
else if(a[0]->num > b[0]->num)
{
result = +1;
}
return result;
}
internal void
eval_string2num_map_node_array_sort__in_place(EVAL_String2NumMapNodeArray *array)
{
quick_sort(array->v, array->count, sizeof(array->v[0]), eval_string2num_map_node_qsort_compare__num_ascending);
}
//- rjf: string -> expr
internal EVAL_String2ExprMap
+16 -4
View File
@@ -13,6 +13,7 @@ typedef enum EVAL_ErrorKind
EVAL_ErrorKind_MalformedInput,
EVAL_ErrorKind_MissingInfo,
EVAL_ErrorKind_ResolutionFailure,
EVAL_ErrorKind_InterpretationError,
EVAL_ErrorKind_COUNT
}
EVAL_ErrorKind;
@@ -40,7 +41,7 @@ struct EVAL_ErrorList
enum
{
EVAL_IRExtKind_Bytecode = RADDBG_EvalOp_COUNT,
EVAL_IRExtKind_Bytecode = RDI_EvalOp_COUNT,
EVAL_IRExtKind_COUNT
};
@@ -48,7 +49,7 @@ typedef struct EVAL_Op EVAL_Op;
struct EVAL_Op
{
EVAL_Op *next;
RADDBG_EvalOp opcode;
RDI_EvalOp opcode;
union
{
U64 p;
@@ -114,7 +115,7 @@ struct EVAL_Expr
typedef struct EVAL_IRTree EVAL_IRTree;
struct EVAL_IRTree{
RADDBG_EvalOp op;
RDI_EvalOp op;
EVAL_IRTree *children[3];
union{
U64 p;
@@ -143,6 +144,13 @@ struct EVAL_String2NumMapNode
U64 num;
};
typedef struct EVAL_String2NumMapNodeArray EVAL_String2NumMapNodeArray;
struct EVAL_String2NumMapNodeArray
{
EVAL_String2NumMapNode **v;
U64 count;
};
typedef struct EVAL_String2NumMapSlot EVAL_String2NumMapSlot;
struct EVAL_String2NumMapSlot
{
@@ -154,6 +162,7 @@ typedef struct EVAL_String2NumMap EVAL_String2NumMap;
struct EVAL_String2NumMap
{
U64 slots_count;
U64 node_count;
EVAL_String2NumMapSlot *slots;
EVAL_String2NumMapNode *first;
EVAL_String2NumMapNode *last;
@@ -209,10 +218,13 @@ internal void eval_error_list_concat_in_place(EVAL_ErrorList *dst, EVAL_ErrorLis
internal EVAL_String2NumMap eval_string2num_map_make(Arena *arena, U64 slot_count);
internal void eval_string2num_map_insert(Arena *arena, EVAL_String2NumMap *map, String8 string, U64 num);
internal U64 eval_num_from_string(EVAL_String2NumMap *map, String8 string);
internal EVAL_String2NumMapNodeArray eval_string2num_map_node_array_from_map(Arena *arena, EVAL_String2NumMap *map);
internal int eval_string2num_map_node_qsort_compare__num_ascending(EVAL_String2NumMapNode **a, EVAL_String2NumMapNode **b);
internal void eval_string2num_map_node_array_sort__in_place(EVAL_String2NumMapNodeArray *array);
//- rjf: string -> expr
internal EVAL_String2ExprMap eval_string2expr_map_make(Arena *arena, U64 slot_count);
internal void eval_string2expr_map_insert(Arena *arena, EVAL_String2NumMap *map, String8 string, EVAL_Expr *expr);
internal void eval_string2expr_map_insert(Arena *arena, EVAL_String2ExprMap *map, String8 string, EVAL_Expr *expr);
internal void eval_string2expr_map_inc_poison(EVAL_String2ExprMap *map, String8 string);
internal void eval_string2expr_map_dec_poison(EVAL_String2ExprMap *map, String8 string);
internal EVAL_Expr *eval_expr_from_string(EVAL_String2ExprMap *map, String8 string);
+157 -141
View File
@@ -5,7 +5,8 @@
//~ allen: Eval Machine Functions
internal EVAL_Result
eval_interpret(EVAL_Machine *machine, String8 bytecode){
eval_interpret(EVAL_Machine *machine, String8 bytecode)
{
ProfBeginFunction();
EVAL_Result result = {0};
@@ -21,21 +22,21 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
for (;ptr < opl;){
// consume opcode
RADDBG_EvalOp op = (RADDBG_EvalOp)*ptr;
if (op >= RADDBG_EvalOp_COUNT){
result.bad_eval = 1;
RDI_EvalOp op = (RDI_EvalOp)*ptr;
if (op >= RDI_EvalOp_COUNT){
result.code = EVAL_ResultCode_BadOp;
goto done;
}
U8 ctrlbits = raddbg_eval_opcode_ctrlbits[op];
U8 ctrlbits = rdi_eval_op_ctrlbits_table[op];
ptr += 1;
// decode
U64 imm = 0;
{
U32 decode_size = RADDBG_DECODEN_FROM_CTRLBITS(ctrlbits);
U32 decode_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits);
U8 *next_ptr = ptr + decode_size;
if (next_ptr > opl){
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOp;
goto done;
}
// TODO(allen): to improve this:
@@ -53,9 +54,9 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
// pop
EVAL_Slot *svals = 0;
{
U32 pop_count = RADDBG_POPN_FROM_CTRLBITS(ctrlbits);
U32 pop_count = RDI_POPN_FROM_CTRLBITS(ctrlbits);
if (pop_count > stack_count){
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOp;
goto done;
}
if (pop_count <= stack_count){
@@ -67,29 +68,29 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
// interpret
EVAL_Slot nval = {0};
switch (op){
case RADDBG_EvalOp_Stop:
case RDI_EvalOp_Stop:
{
goto done;
}break;
case RADDBG_EvalOp_Noop:
case RDI_EvalOp_Noop:
{
// do nothing
}break;
case RADDBG_EvalOp_Cond:
case RDI_EvalOp_Cond:
{
if (svals[0].u64){
ptr += imm;
}
}break;
case RADDBG_EvalOp_Skip:
case RDI_EvalOp_Skip:
{
ptr += imm;
}break;
case RADDBG_EvalOp_MemRead:
case RDI_EvalOp_MemRead:
{
U64 addr = svals[0].u64;
U64 size = imm;
@@ -99,17 +100,17 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
good_read = 1;
}
if (!good_read){
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadMemRead;
goto done;
}
}break;
case RADDBG_EvalOp_RegRead:
case RDI_EvalOp_RegRead:
{
U8 raddbg_reg_code = (imm&0x0000FF)>>0;
U8 rdi_reg_code = (imm&0x0000FF)>>0;
U8 byte_size = (imm&0x00FF00)>>8;
U8 byte_off = (imm&0xFF0000)>>16;
REGS_RegCode base_reg_code = regs_reg_code_from_arch_raddbg_code(machine->arch, raddbg_reg_code);
REGS_RegCode base_reg_code = regs_reg_code_from_arch_rdi_code(machine->arch, rdi_reg_code);
REGS_Rng rng = regs_reg_code_rng_table_from_architecture(machine->arch)[base_reg_code];
U64 off = (U64)rng.byte_off + byte_off;
U64 size = (U64)byte_size;
@@ -117,12 +118,12 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
MemoryCopy(&nval, (U8*)machine->reg_data + off, size);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadRegRead;
goto done;
}
}break;
case RADDBG_EvalOp_RegReadDyn:
case RDI_EvalOp_RegReadDyn:
{
U64 off = svals[0].u64;
U64 size = bit_size_from_arch(machine->arch)/8;
@@ -130,61 +131,61 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
MemoryCopy(&nval, (U8*)machine->reg_data + off, size);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadRegRead;
goto done;
}
}break;
case RADDBG_EvalOp_FrameOff:
case RDI_EvalOp_FrameOff:
{
if (machine->frame_base != 0){
nval.u64 = *machine->frame_base + imm;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadFrameBase;
goto done;
}
}break;
case RADDBG_EvalOp_ModuleOff:
case RDI_EvalOp_ModuleOff:
{
if (machine->module_base != 0){
nval.u64 = *machine->module_base + imm;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadModuleBase;
goto done;
}
}break;
case RADDBG_EvalOp_TLSOff:
case RDI_EvalOp_TLSOff:
{
if (machine->tls_base != 0){
nval.u64 = *machine->tls_base + imm;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadTLSBase;
goto done;
}
}break;
case RADDBG_EvalOp_ConstU8:
case RADDBG_EvalOp_ConstU16:
case RADDBG_EvalOp_ConstU32:
case RADDBG_EvalOp_ConstU64:
case RDI_EvalOp_ConstU8:
case RDI_EvalOp_ConstU16:
case RDI_EvalOp_ConstU32:
case RDI_EvalOp_ConstU64:
{
nval.u64 = imm;
}break;
case RADDBG_EvalOp_Abs:
case RDI_EvalOp_Abs:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.f32 = svals[0].f32;
if (svals[0].f32 < 0){
nval.f32 = -svals[0].f32;
}
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.f64 = svals[0].f64;
if (svals[0].f64 < 0){
nval.f64 = -svals[0].f64;
@@ -198,12 +199,12 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Neg:
case RDI_EvalOp_Neg:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.f32 = -svals[0].f32;
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.f64 = -svals[0].f64;
}
else{
@@ -211,12 +212,12 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Add:
case RDI_EvalOp_Add:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.f32 = svals[0].f32 + svals[1].f32;
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.f64 = svals[0].f64 + svals[1].f64;
}
else{
@@ -224,12 +225,12 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Sub:
case RDI_EvalOp_Sub:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.f32 = svals[0].f32 - svals[1].f32;
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.f64 = svals[0].f64 - svals[1].f64;
}
else{
@@ -237,12 +238,12 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Mul:
case RDI_EvalOp_Mul:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.f32 = svals[0].f32*svals[1].f32;
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.f64 = svals[0].f64*svals[1].f64;
}
else{
@@ -250,245 +251,260 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Div:
case RDI_EvalOp_Div:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
if (svals[1].f32 != 0.f){
nval.f32 = svals[0].f32/svals[1].f32;
}
else
{
result.code = EVAL_ResultCode_DivideByZero;
goto done;
}
else if (imm == RADDBG_EvalTypeGroup_F64){
}
else if (imm == RDI_EvalTypeGroup_F64){
if (svals[1].f64 != 0.){
nval.f64 = svals[0].f64/svals[1].f64;
}
else
{
result.code = EVAL_ResultCode_DivideByZero;
goto done;
}
else if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
}
else if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
if (svals[1].u64 != 0){
nval.u64 = svals[0].u64/svals[1].u64;
}
else
{
result.code = EVAL_ResultCode_DivideByZero;
goto done;
}
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_Mod:
case RDI_EvalOp_Mod:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
if (svals[1].u64 != 0){
nval.u64 = svals[0].u64%svals[1].u64;
}
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_LShift:
case RDI_EvalOp_LShift:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = svals[0].u64 << svals[1].u64;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_RShift:
case RDI_EvalOp_RShift:
{
if (imm == RADDBG_EvalTypeGroup_U){
if (imm == RDI_EvalTypeGroup_U){
nval.u64 = svals[0].u64 >> svals[1].u64;
}
else if (imm == RADDBG_EvalTypeGroup_S){
else if (imm == RDI_EvalTypeGroup_S){
nval.u64 = svals[0].s64 >> svals[1].u64;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_BitAnd:
case RDI_EvalOp_BitAnd:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = svals[0].u64&svals[1].u64;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_BitOr:
case RDI_EvalOp_BitOr:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = svals[0].u64|svals[1].u64;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_BitXor:
case RDI_EvalOp_BitXor:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = svals[0].u64^svals[1].u64;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_BitNot:
case RDI_EvalOp_BitNot:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = ~svals[0].u64;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_LogAnd:
case RDI_EvalOp_LogAnd:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = (svals[0].u64 && svals[1].u64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_LogOr:
case RDI_EvalOp_LogOr:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = (svals[0].u64 || svals[1].u64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_LogNot:
case RDI_EvalOp_LogNot:
{
if (imm == RADDBG_EvalTypeGroup_U ||
imm == RADDBG_EvalTypeGroup_S){
if (imm == RDI_EvalTypeGroup_U ||
imm == RDI_EvalTypeGroup_S){
nval.u64 = (!svals[0].u64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_EqEq:
case RDI_EvalOp_EqEq:
{
nval.u64 = (svals[0].u64 == svals[1].u64);
}break;
case RADDBG_EvalOp_NtEq:
case RDI_EvalOp_NtEq:
{
nval.u64 = (svals[0].u64 != svals[1].u64);
}break;
case RADDBG_EvalOp_LsEq:
case RDI_EvalOp_LsEq:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.u64 = (svals[0].f32 <= svals[1].f32);
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.u64 = (svals[0].f64 <= svals[1].f64);
}
else if (imm == RADDBG_EvalTypeGroup_U){
else if (imm == RDI_EvalTypeGroup_U){
nval.u64 = (svals[0].u64 <= svals[1].u64);
}
else if (imm == RADDBG_EvalTypeGroup_S){
else if (imm == RDI_EvalTypeGroup_S){
nval.u64 = (svals[0].s64 <= svals[1].s64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_GrEq:
case RDI_EvalOp_GrEq:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.u64 = (svals[0].f32 >= svals[1].f32);
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.u64 = (svals[0].f64 >= svals[1].f64);
}
else if (imm == RADDBG_EvalTypeGroup_U){
else if (imm == RDI_EvalTypeGroup_U){
nval.u64 = (svals[0].u64 >= svals[1].u64);
}
else if (imm == RADDBG_EvalTypeGroup_S){
else if (imm == RDI_EvalTypeGroup_S){
nval.u64 = (svals[0].s64 >= svals[1].s64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_Less:
case RDI_EvalOp_Less:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.u64 = (svals[0].f32 < svals[1].f32);
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.u64 = (svals[0].f64 < svals[1].f64);
}
else if (imm == RADDBG_EvalTypeGroup_U){
else if (imm == RDI_EvalTypeGroup_U){
nval.u64 = (svals[0].u64 < svals[1].u64);
}
else if (imm == RADDBG_EvalTypeGroup_S){
else if (imm == RDI_EvalTypeGroup_S){
nval.u64 = (svals[0].s64 < svals[1].s64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_Grtr:
case RDI_EvalOp_Grtr:
{
if (imm == RADDBG_EvalTypeGroup_F32){
if (imm == RDI_EvalTypeGroup_F32){
nval.u64 = (svals[0].f32 > svals[1].f32);
}
else if (imm == RADDBG_EvalTypeGroup_F64){
else if (imm == RDI_EvalTypeGroup_F64){
nval.u64 = (svals[0].f64 > svals[1].f64);
}
else if (imm == RADDBG_EvalTypeGroup_U){
else if (imm == RDI_EvalTypeGroup_U){
nval.u64 = (svals[0].u64 > svals[1].u64);
}
else if (imm == RADDBG_EvalTypeGroup_S){
else if (imm == RDI_EvalTypeGroup_S){
nval.u64 = (svals[0].s64 > svals[1].s64);
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOpTypes;
goto done;
}
}break;
case RADDBG_EvalOp_Trunc:
case RDI_EvalOp_Trunc:
{
if (0 < imm){
U64 mask = 0;
@@ -499,7 +515,7 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_TruncSigned:
case RDI_EvalOp_TruncSigned:
{
if (0 < imm){
U64 mask = 0;
@@ -514,52 +530,52 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Convert:
case RDI_EvalOp_Convert:
{
U32 in = imm&0xFF;
U32 out = (imm >> 8)&0xFF;
if (in != out){
switch (in + out*RADDBG_EvalTypeGroup_COUNT){
case RADDBG_EvalTypeGroup_F32 + RADDBG_EvalTypeGroup_U*RADDBG_EvalTypeGroup_COUNT:
switch (in + out*RDI_EvalTypeGroup_COUNT){
case RDI_EvalTypeGroup_F32 + RDI_EvalTypeGroup_U*RDI_EvalTypeGroup_COUNT:
{
nval.u64 = (U64)svals[0].f32;
}break;
case RADDBG_EvalTypeGroup_F64 + RADDBG_EvalTypeGroup_U*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_F64 + RDI_EvalTypeGroup_U*RDI_EvalTypeGroup_COUNT:
{
nval.u64 = (U64)svals[0].f64;
}break;
case RADDBG_EvalTypeGroup_F32 + RADDBG_EvalTypeGroup_S*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_F32 + RDI_EvalTypeGroup_S*RDI_EvalTypeGroup_COUNT:
{
nval.s64 = (S64)svals[0].f32;
}break;
case RADDBG_EvalTypeGroup_F64 + RADDBG_EvalTypeGroup_S*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_F64 + RDI_EvalTypeGroup_S*RDI_EvalTypeGroup_COUNT:
{
nval.s64 = (S64)svals[0].f64;
}break;
case RADDBG_EvalTypeGroup_U + RADDBG_EvalTypeGroup_F32*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_U + RDI_EvalTypeGroup_F32*RDI_EvalTypeGroup_COUNT:
{
nval.f32 = (F32)svals[0].u64;
}break;
case RADDBG_EvalTypeGroup_S + RADDBG_EvalTypeGroup_F32*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_S + RDI_EvalTypeGroup_F32*RDI_EvalTypeGroup_COUNT:
{
nval.f32 = (F32)svals[0].s64;
}break;
case RADDBG_EvalTypeGroup_F64 + RADDBG_EvalTypeGroup_F32*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_F64 + RDI_EvalTypeGroup_F32*RDI_EvalTypeGroup_COUNT:
{
nval.f32 = (F32)svals[0].f64;
}break;
case RADDBG_EvalTypeGroup_U + RADDBG_EvalTypeGroup_F64*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_U + RDI_EvalTypeGroup_F64*RDI_EvalTypeGroup_COUNT:
{
nval.f64 = (F64)svals[0].u64;
}break;
case RADDBG_EvalTypeGroup_S + RADDBG_EvalTypeGroup_F64*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_S + RDI_EvalTypeGroup_F64*RDI_EvalTypeGroup_COUNT:
{
nval.f64 = (F64)svals[0].s64;
}break;
case RADDBG_EvalTypeGroup_F32 + RADDBG_EvalTypeGroup_F64*RADDBG_EvalTypeGroup_COUNT:
case RDI_EvalTypeGroup_F32 + RDI_EvalTypeGroup_F64*RDI_EvalTypeGroup_COUNT:
{
nval.f64 = (F64)svals[0].f32;
}break;
@@ -567,23 +583,23 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}break;
case RADDBG_EvalOp_Pick:
case RDI_EvalOp_Pick:
{
if (stack_count > imm){
nval = stack[stack_count - imm - 1];
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOp;
goto done;
}
}break;
case RADDBG_EvalOp_Pop:
case RDI_EvalOp_Pop:
{
// do nothing - the pop is handled by the control bits
}break;
case RADDBG_EvalOp_Insert:
case RDI_EvalOp_Insert:
{
if (stack_count > imm){
if (imm > 0){
@@ -595,7 +611,7 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
}
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_BadOp;
goto done;
}
}break;
@@ -603,14 +619,14 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
// push
{
U64 push_count = RADDBG_PUSHN_FROM_CTRLBITS(ctrlbits);
U64 push_count = RDI_PUSHN_FROM_CTRLBITS(ctrlbits);
if (push_count == 1){
if (stack_count < stack_cap){
stack[stack_count] = nval;
stack_count += 1;
}
else{
result.bad_eval = 1;
result.code = EVAL_ResultCode_InsufficientStackSpace;
goto done;
}
}
@@ -622,8 +638,8 @@ eval_interpret(EVAL_Machine *machine, String8 bytecode){
if (stack_count == 1){
result.value = stack[0];
}
else{
result.bad_eval = 1;
else if(result.code == EVAL_ResultCode_Good){
result.code = EVAL_ResultCode_MalformedBytecode;
}
scratch_end(scratch);

Some files were not shown because too many files have changed in this diff Show More