Full Code of rr-debugger/rr for AI

gitextract__6i1v_s1/

├── .android/
│   ├── Dockerfile
│   ├── README.md
│   └── build.sh
├── .buildkite/
│   ├── .gitignore
│   ├── CTestCostData.txt
│   ├── Manifest.toml
│   ├── Project.toml
│   ├── capture_tmpdir.jl
│   └── pipeline.yml
├── .clang-format
├── .github/
│   └── workflows/
│       ├── android-build.yml
│       ├── build-and-test-main.yml
│       └── build-and-test.yml
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── Vagrantfile
├── configure
├── include/
│   └── rr/
│       └── rr.h
├── release-process/
│   ├── README.md
│   ├── distro-configs/
│   │   ├── centos9.json
│   │   ├── debian11.json
│   │   ├── debian12.json
│   │   ├── ubuntu20-lts.json
│   │   ├── ubuntu22-lts.json
│   │   ├── ubuntu24-lts.json
│   │   └── ubuntu24.10.json
│   ├── prepare-release.py
│   ├── rr-testing-cloud-formation.json
│   ├── rr-testing.sh
│   ├── test-data/
│   │   ├── rr-test-doc.odt
│   │   └── test.html
│   └── test-system.py
├── rr.spec
├── scripts/
│   ├── checkpoint-visualizer.html
│   ├── github-actions-CTestCostData.txt
│   ├── github-actions-build.sh
│   ├── github-actions-test.sh
│   ├── reformat.sh
│   ├── rr-collect-symbols.py
│   ├── rr-gdb-script-host.py
│   ├── rr_completion
│   ├── rr_completion.zsh
│   ├── signal-rr-recording.sh
│   ├── update-gh-pages.sh
│   ├── zen_workaround.py
│   └── zen_workaround.service
├── snap/
│   └── snapcraft.yaml
├── src/
│   ├── AddressSpace.cc
│   ├── AddressSpace.h
│   ├── AutoRemoteSyscalls.cc
│   ├── AutoRemoteSyscalls.h
│   ├── BpfMapMonitor.h
│   ├── BreakpointCondition.h
│   ├── BuildidCommand.cc
│   ├── CPUFeaturesCommand.cc
│   ├── CPUIDBugDetector.cc
│   ├── CPUIDBugDetector.h
│   ├── CPUs.cc
│   ├── CPUs.h
│   ├── Command.cc
│   ├── Command.h
│   ├── CompressedReader.cc
│   ├── CompressedReader.h
│   ├── CompressedWriter.cc
│   ├── CompressedWriter.h
│   ├── ContextSwitchEvent.cc
│   ├── ContextSwitchEvent.h
│   ├── DebuggerExtensionCommand.cc
│   ├── DebuggerExtensionCommand.h
│   ├── DebuggerExtensionCommandHandler.cc
│   ├── DebuggerExtensionCommandHandler.h
│   ├── DiversionSession.cc
│   ├── DiversionSession.h
│   ├── DumpCommand.cc
│   ├── DumpCommand.h
│   ├── Dwarf.cc
│   ├── Dwarf.h
│   ├── ElfReader.cc
│   ├── ElfReader.h
│   ├── EmuFs.cc
│   ├── EmuFs.h
│   ├── Event.cc
│   ├── Event.h
│   ├── ExportImportCheckpoints.cc
│   ├── ExportImportCheckpoints.h
│   ├── ExtraRegisters.cc
│   ├── ExtraRegisters.h
│   ├── FdTable.cc
│   ├── FdTable.h
│   ├── FileMonitor.cc
│   ├── FileMonitor.h
│   ├── FileNameCommand.cc
│   ├── Flags.cc
│   ├── Flags.h
│   ├── GdbInitCommand.cc
│   ├── GdbServer.cc
│   ├── GdbServer.h
│   ├── GdbServerConnection.cc
│   ├── GdbServerConnection.h
│   ├── GdbServerExpression.cc
│   ├── GdbServerExpression.h
│   ├── GdbServerRegister.h
│   ├── HasTaskSet.cc
│   ├── HasTaskSet.h
│   ├── HelpCommand.cc
│   ├── LldbInitCommand.cc
│   ├── LsCommand.cc
│   ├── MagicSaveDataMonitor.cc
│   ├── MagicSaveDataMonitor.h
│   ├── MemoryRange.h
│   ├── MmappedFileMonitor.cc
│   ├── MmappedFileMonitor.h
│   ├── MonitoredSharedMemory.cc
│   ├── MonitoredSharedMemory.h
│   ├── Monkeypatcher.cc
│   ├── Monkeypatcher.h
│   ├── MvCommand.cc
│   ├── NonvirtualPerfCounterMonitor.h
│   ├── ODirectFileMonitor.h
│   ├── PackCommand.cc
│   ├── PerfCounterBuffers.cc
│   ├── PerfCounterBuffers.h
│   ├── PerfCounters.cc
│   ├── PerfCounters.h
│   ├── PerfCounters_aarch64.h
│   ├── PerfCounters_x86.h
│   ├── PidFdMonitor.cc
│   ├── PidFdMonitor.h
│   ├── PreserveFileMonitor.h
│   ├── ProcFdDirMonitor.cc
│   ├── ProcFdDirMonitor.h
│   ├── ProcMemMonitor.cc
│   ├── ProcMemMonitor.h
│   ├── ProcStatMonitor.cc
│   ├── ProcStatMonitor.h
│   ├── ProcessorTraceDecoder.cc
│   ├── ProcessorTraceDecoder.h
│   ├── PsCommand.cc
│   ├── RRPageMonitor.h
│   ├── RecordCommand.cc
│   ├── RecordCommand.h
│   ├── RecordSession.cc
│   ├── RecordSession.h
│   ├── RecordTask.cc
│   ├── RecordTask.h
│   ├── Registers.cc
│   ├── Registers.h
│   ├── ReplayCommand.cc
│   ├── ReplayCommand.h
│   ├── ReplaySession.cc
│   ├── ReplaySession.h
│   ├── ReplayTask.cc
│   ├── ReplayTask.h
│   ├── ReplayTimeline.cc
│   ├── ReplayTimeline.h
│   ├── RerunCommand.cc
│   ├── ReturnAddressList.cc
│   ├── ReturnAddressList.h
│   ├── RmCommand.cc
│   ├── Scheduler.cc
│   ├── Scheduler.h
│   ├── ScopedFd.h
│   ├── SeccompFilterRewriter.cc
│   ├── SeccompFilterRewriter.h
│   ├── Session.cc
│   ├── Session.h
│   ├── SourcesCommand.cc
│   ├── StdioMonitor.cc
│   ├── StdioMonitor.h
│   ├── StringVectorToCharArray.h
│   ├── SysCpuMonitor.cc
│   ├── SysCpuMonitor.h
│   ├── TargetDescription.cc
│   ├── TargetDescription.h
│   ├── Task.cc
│   ├── Task.h
│   ├── TaskishUid.h
│   ├── ThreadDb.cc
│   ├── ThreadDb.h
│   ├── ThreadGroup.cc
│   ├── ThreadGroup.h
│   ├── Ticks.h
│   ├── TraceField.cc
│   ├── TraceField.h
│   ├── TraceFrame.cc
│   ├── TraceFrame.h
│   ├── TraceInfoCommand.cc
│   ├── TraceStream.cc
│   ├── TraceStream.h
│   ├── TraceTaskEvent.h
│   ├── TraceeAttentionSet.cc
│   ├── TraceeAttentionSet.h
│   ├── VirtualPerfCounterMonitor.cc
│   ├── VirtualPerfCounterMonitor.h
│   ├── WaitManager.cc
│   ├── WaitManager.h
│   ├── WaitStatus.cc
│   ├── WaitStatus.h
│   ├── assembly_templates.py
│   ├── audit/
│   │   ├── rtld-audit.c
│   │   ├── rtld-audit.h
│   │   ├── stap-note-iter.c
│   │   └── stap-note-iter.h
│   ├── bpf/
│   │   └── async_event_filter.c
│   ├── chaos-test/
│   │   ├── chaos-test.sh
│   │   ├── chaosutil.h
│   │   ├── core_count.c
│   │   ├── futex_wakeup.c
│   │   ├── getaffinity_core_count.c
│   │   ├── harness.py
│   │   ├── mmap_adjacent.c
│   │   ├── mmap_bits.c
│   │   ├── pipe_wakeup.c
│   │   ├── startup.c
│   │   ├── starvation_multithreaded.c
│   │   └── starvation_singlethreaded.c
│   ├── core.h
│   ├── counters-test/
│   │   ├── README.md
│   │   └── counters.cc
│   ├── cpp_supplement.h
│   ├── exec_stub.c
│   ├── extra_version_string.h.in
│   ├── fast_forward.cc
│   ├── fast_forward.h
│   ├── ftrace/
│   │   └── ftrace_helper.c
│   ├── ftrace.cc
│   ├── ftrace.h
│   ├── generate_syscalls.py
│   ├── git_revision.h.in
│   ├── kernel_abi.cc
│   ├── kernel_abi.h
│   ├── kernel_metadata.cc
│   ├── kernel_metadata.h
│   ├── kernel_supplement.h
│   ├── launch_debugger.cc
│   ├── launch_debugger.h
│   ├── log.cc
│   ├── log.h
│   ├── main.cc
│   ├── main.h
│   ├── perf-test/
│   │   ├── many-threads-wake.c
│   │   ├── many-threads-wake.md
│   │   ├── many-threads.c
│   │   ├── many-threads.md
│   │   ├── unbuffered-syscalls.c
│   │   └── unbuffered-syscalls.md
│   ├── preload/
│   │   ├── overrides.c
│   │   ├── preload_interface.h
│   │   ├── raw_syscall.S
│   │   ├── rr_page.S
│   │   ├── rr_page.ld.in
│   │   ├── rr_page_instructions.S
│   │   ├── rr_vdso.S
│   │   ├── rrcalls.h
│   │   ├── syscall_hook.S
│   │   ├── syscallbuf.c
│   │   ├── syscallbuf.h
│   │   └── tweak_librrpage.py
│   ├── processor_trace_check.cc
│   ├── processor_trace_check.h
│   ├── record_signal.cc
│   ├── record_signal.h
│   ├── record_syscall.cc
│   ├── record_syscall.h
│   ├── remote_code_ptr.cc
│   ├── remote_code_ptr.h
│   ├── remote_ptr.h
│   ├── replay_syscall.cc
│   ├── replay_syscall.h
│   ├── rr_trace.capnp
│   ├── seccomp-bpf.h
│   ├── syscalls.py
│   ├── test/
│   │   ├── 64bit_child.c
│   │   ├── _llseek.c
│   │   ├── abort.c
│   │   ├── abort_nonmain.c
│   │   ├── abort_nonmain.run
│   │   ├── accept.c
│   │   ├── acct.c
│   │   ├── adjtimex.c
│   │   ├── aio.c
│   │   ├── alarm.c
│   │   ├── alarm2.c
│   │   ├── alsa_ioctl.c
│   │   ├── alternate_thread_diversion.c
│   │   ├── alternate_thread_diversion.py
│   │   ├── alternate_thread_diversion.run
│   │   ├── args.c
│   │   ├── args.run
│   │   ├── arm/
│   │   │   ├── arch_timer.c
│   │   │   ├── arch_timer.run
│   │   │   ├── brk_nonzero.c
│   │   │   ├── diversion_arch_timer.py
│   │   │   ├── tagged_addr_ctrl.c
│   │   │   ├── util.h
│   │   │   └── util.sh
│   │   ├── async_kill_with_syscallbuf.c
│   │   ├── async_kill_with_syscallbuf.run
│   │   ├── async_kill_with_syscallbuf2.c
│   │   ├── async_kill_with_syscallbuf2.run
│   │   ├── async_kill_with_threads.c
│   │   ├── async_kill_with_threads.run
│   │   ├── async_kill_with_threads_main_running.c
│   │   ├── async_kill_with_threads_main_running.run
│   │   ├── async_kill_with_threads_thread_running.c
│   │   ├── async_kill_with_threads_thread_running.run
│   │   ├── async_segv.c
│   │   ├── async_segv.run
│   │   ├── async_segv_ignored.c
│   │   ├── async_signal_syscalls.c
│   │   ├── async_signal_syscalls.run
│   │   ├── async_signal_syscalls2.c
│   │   ├── async_signal_syscalls2.run
│   │   ├── async_signal_syscalls_100.run
│   │   ├── async_signal_syscalls_1000.run
│   │   ├── async_signal_syscalls_siginfo.c
│   │   ├── async_signal_syscalls_siginfo.run
│   │   ├── async_usr1.c
│   │   ├── async_usr1.run
│   │   ├── at_threadexit.c
│   │   ├── bad_breakpoint.run
│   │   ├── bad_good_break.py
│   │   ├── bad_ip.c
│   │   ├── bad_syscall.c
│   │   ├── barrier.c
│   │   ├── basic_test.run
│   │   ├── big_buffers.c
│   │   ├── big_select.c
│   │   ├── blacklist.c
│   │   ├── blacklist.run
│   │   ├── block.c
│   │   ├── block_clone_checkpoint.c
│   │   ├── block_clone_checkpoint.py
│   │   ├── block_clone_checkpoint.run
│   │   ├── block_clone_interrupted.c
│   │   ├── block_clone_interrupted.run
│   │   ├── block_clone_syscallbuf_overflow.c
│   │   ├── block_clone_syscallbuf_overflow.run
│   │   ├── block_intr_sigchld.c
│   │   ├── block_intr_sigchld.run
│   │   ├── block_open.c
│   │   ├── blocked_bad_ip.c
│   │   ├── blocked_bad_ip.py
│   │   ├── blocked_bad_ip.run
│   │   ├── blocked_sigill.c
│   │   ├── blocked_sigill.run
│   │   ├── bpf.c
│   │   ├── bpf_map.c
│   │   ├── bpf_prog_map.c
│   │   ├── bpf_query.c
│   │   ├── break_block.py
│   │   ├── break_block.run
│   │   ├── break_clock.py
│   │   ├── break_clock.run
│   │   ├── break_clone.py
│   │   ├── break_clone.run
│   │   ├── break_exec.run
│   │   ├── break_int3.py
│   │   ├── break_int3.run
│   │   ├── break_mmap_private.py
│   │   ├── break_mmap_private.run
│   │   ├── break_msg.run
│   │   ├── break_sigreturn.run
│   │   ├── break_sync_signal.run
│   │   ├── break_thread.run
│   │   ├── break_time_slice.py
│   │   ├── break_time_slice.run
│   │   ├── breakpoint.c
│   │   ├── breakpoint.py
│   │   ├── breakpoint.run
│   │   ├── breakpoint_conditions.c
│   │   ├── breakpoint_conditions.py
│   │   ├── breakpoint_conditions.run
│   │   ├── breakpoint_consistent.py
│   │   ├── breakpoint_consistent.run
│   │   ├── breakpoint_overlap.c
│   │   ├── breakpoint_overlap.py
│   │   ├── breakpoint_overlap.run
│   │   ├── breakpoint_print.py
│   │   ├── breakpoint_print.run
│   │   ├── breakpoint_print_command.py
│   │   ├── breakpoint_print_command.run
│   │   ├── brk.c
│   │   ├── brk2.c
│   │   ├── call_exit.py
│   │   ├── call_exit.run
│   │   ├── call_function.c
│   │   ├── call_function.py
│   │   ├── call_function.run
│   │   ├── call_gettid.c
│   │   ├── call_gettid.py
│   │   ├── call_gettid.run
│   │   ├── capget.c
│   │   ├── chaos_oom.c
│   │   ├── chaos_oom.run
│   │   ├── check_lost_interrupts.c
│   │   ├── check_lost_interrupts.run
│   │   ├── check_patched_pthread.py
│   │   ├── check_patched_pthread.run
│   │   ├── check_session_leaks.c
│   │   ├── check_session_leaks.py
│   │   ├── check_session_leaks.run
│   │   ├── check_syscall_perf_interval.py
│   │   ├── checkpoint_async_signal_syscalls_1000.run
│   │   ├── checkpoint_dying_threads.c
│   │   ├── checkpoint_dying_threads.py
│   │   ├── checkpoint_dying_threads.run
│   │   ├── checkpoint_invalid.py
│   │   ├── checkpoint_invalid.run
│   │   ├── checkpoint_mixed_mode.c
│   │   ├── checkpoint_mixed_mode.py
│   │   ├── checkpoint_mixed_mode.run
│   │   ├── checkpoint_mmap_shared.run
│   │   ├── checkpoint_prctl_name.run
│   │   ├── checkpoint_simple.run
│   │   ├── checksum_block_open.run
│   │   ├── checksum_sanity.c
│   │   ├── checksum_sanity.run
│   │   ├── checksum_sanity_noclone.run
│   │   ├── chew_cpu.c
│   │   ├── chmod.c
│   │   ├── chown.c
│   │   ├── clock.c
│   │   ├── clock_adjtime.c
│   │   ├── clock_nanosleep.c
│   │   ├── clock_time64.c
│   │   ├── clone.c
│   │   ├── clone_bad_stack.c
│   │   ├── clone_bad_tls.c
│   │   ├── clone_cleartid_coredump.c
│   │   ├── clone_fail.c
│   │   ├── clone_file_range.c
│   │   ├── clone_file_range.run
│   │   ├── clone_immediate_exit.c
│   │   ├── clone_interruption.c
│   │   ├── clone_interruption.py
│   │   ├── clone_interruption.run
│   │   ├── clone_interruption_finder.py
│   │   ├── clone_newflags.c
│   │   ├── clone_parent.c
│   │   ├── clone_share_vm.c
│   │   ├── clone_share_vm.py
│   │   ├── clone_share_vm.run
│   │   ├── clone_syscallbuf_cleanup_blocked.c
│   │   ├── clone_syscallbuf_cleanup_blocked.run
│   │   ├── clone_syscallbuf_cleanup_cpu.c
│   │   ├── clone_syscallbuf_cleanup_cpu.run
│   │   ├── clone_untraced.c
│   │   ├── clone_vfork.c
│   │   ├── clone_vfork.run
│   │   ├── clone_vfork_pidfd.c
│   │   ├── cloned_sigmask.c
│   │   ├── close_range.c
│   │   ├── comm.py
│   │   ├── comm.run
│   │   ├── concurrent_signals.c
│   │   ├── concurrent_signals.run
│   │   ├── conditional_breakpoint_calls.c
│   │   ├── conditional_breakpoint_calls.py
│   │   ├── conditional_breakpoint_calls.run
│   │   ├── conditional_breakpoint_offload.c
│   │   ├── conditional_breakpoint_offload.py
│   │   ├── conditional_breakpoint_offload.run
│   │   ├── condvar_stress.c
│   │   ├── condvar_stress.run
│   │   ├── constructor.c
│   │   ├── cont_race.c
│   │   ├── cont_race.run
│   │   ├── cont_signal.py
│   │   ├── cont_signal.run
│   │   ├── context_switch_after_patch.c
│   │   ├── context_switch_after_patch.run
│   │   ├── copy_all.py
│   │   ├── copy_all.run
│   │   ├── copy_file_range.c
│   │   ├── crash.c
│   │   ├── crash.run
│   │   ├── crash_in_function.c
│   │   ├── crash_in_function.py
│   │   ├── crash_in_function.run
│   │   ├── creat_address_not_truncated.c
│   │   ├── cwd_inaccessible.c
│   │   ├── daemon.c
│   │   ├── daemon_read.c
│   │   ├── daemon_read.run
│   │   ├── dconf_mock.c
│   │   ├── dconf_mock.run
│   │   ├── dead_thread_target.py
│   │   ├── dead_thread_target.run
│   │   ├── deliver_async_signal_during_syscalls.run
│   │   ├── desched_blocking_poll.c
│   │   ├── desched_sigkill.c
│   │   ├── desched_ticks.py
│   │   ├── desched_ticks.run
│   │   ├── detach_huge_mmap.c
│   │   ├── detach_sigkill.c
│   │   ├── detach_sigkill_exit.c
│   │   ├── detach_state.c
│   │   ├── detach_terminal.c
│   │   ├── detach_terminal.run
│   │   ├── detach_threads.c
│   │   ├── deterministic_sigsys.c
│   │   ├── dev_tty.c
│   │   ├── dev_tty.run
│   │   ├── dev_zero.c
│   │   ├── direct.c
│   │   ├── diversion_sigtrap.c
│   │   ├── diversion_sigtrap.py
│   │   ├── diversion_sigtrap.run
│   │   ├── diversion_syscall.c
│   │   ├── diversion_syscall.py
│   │   ├── diversion_syscall.run
│   │   ├── dlchecksum.c
│   │   ├── dlopen.c
│   │   ├── dlopen.py
│   │   ├── dlopen.run
│   │   ├── doublesegv.c
│   │   ├── dup.c
│   │   ├── early_error.c
│   │   ├── early_error.run
│   │   ├── elapsed_time.c
│   │   ├── elapsed_time.py
│   │   ├── elapsed_time.run
│   │   ├── env_newline.run
│   │   ├── epoll_create.c
│   │   ├── epoll_create1.c
│   │   ├── epoll_edge.c
│   │   ├── epoll_many.c
│   │   ├── epoll_pwait2.c
│   │   ├── epoll_pwait_eintr_sigmask.c
│   │   ├── eventfd.c
│   │   ├── exclusion_region.c
│   │   ├── exclusion_region.run
│   │   ├── exec_deleted.run
│   │   ├── exec_failed.c
│   │   ├── exec_failed.py
│   │   ├── exec_failed.run
│   │   ├── exec_flags.c
│   │   ├── exec_from_main_thread.c
│   │   ├── exec_from_other_thread.c
│   │   ├── exec_many.c
│   │   ├── exec_many.run
│   │   ├── exec_no_env.c
│   │   ├── exec_self.c
│   │   ├── exec_shared_as.c
│   │   ├── exec_shared_as.run
│   │   ├── exec_stop.py
│   │   ├── exec_stop.run
│   │   ├── exec_stopsig.c
│   │   ├── execp.run
│   │   ├── execve_failed.run
│   │   ├── execve_loop.c
│   │   ├── execve_loop.run
│   │   ├── execveat.c
│   │   ├── exit_codes.c
│   │   ├── exit_codes.run
│   │   ├── exit_fast.c
│   │   ├── exit_group.c
│   │   ├── exit_group.run
│   │   ├── exit_race.c
│   │   ├── exit_race.run
│   │   ├── exit_status.c
│   │   ├── exit_status.run
│   │   ├── exit_with_syscallbuf_signal.c
│   │   ├── expect_in_atomic_printf.py
│   │   ├── expect_in_exit.py
│   │   ├── explicit_checkpoint_clone.py
│   │   ├── explicit_checkpoint_clone.run
│   │   ├── fadvise.c
│   │   ├── fanotify.c
│   │   ├── fatal_init_signal.c
│   │   ├── fatal_sigsegv_thread.c
│   │   ├── fcntl_dupfd.c
│   │   ├── fcntl_lease.c
│   │   ├── fcntl_misc.c
│   │   ├── fcntl_notify.c
│   │   ├── fcntl_owner_ex.c
│   │   ├── fcntl_rw_hints.c
│   │   ├── fcntl_seals.c
│   │   ├── fcntl_sig.c
│   │   ├── fd_cleanup.c
│   │   ├── fd_leak.run
│   │   ├── fd_limit.c
│   │   ├── fd_limit.run
│   │   ├── fd_tracking_across_threads.c
│   │   ├── fds_clean.c
│   │   ├── fexecve.c
│   │   ├── fexecve_memfd.c
│   │   ├── file_name_newline.run
│   │   ├── final_sigkill.py
│   │   ├── final_sigkill.run
│   │   ├── first_instruction.py
│   │   ├── first_instruction.run
│   │   ├── flock.c
│   │   ├── flock2.c
│   │   ├── flock_ofd.c
│   │   ├── fork_brk.c
│   │   ├── fork_child_crash.c
│   │   ├── fork_exec_info_thr.run
│   │   ├── fork_many.c
│   │   ├── fork_stress.c
│   │   ├── fork_stress.run
│   │   ├── fork_syscalls.c
│   │   ├── fork_syscalls.run
│   │   ├── fsmount.c
│   │   ├── fstatat.c
│   │   ├── function_calls.c
│   │   ├── function_calls.py
│   │   ├── function_calls.run
│   │   ├── futex_exit_race.c
│   │   ├── futex_exit_race_sigsegv.c
│   │   ├── futex_invalid_op.c
│   │   ├── futex_pi.c
│   │   ├── futex_priorities.c
│   │   ├── futex_requeue.c
│   │   ├── futex_restart_clone.c
│   │   ├── futex_restart_race.c
│   │   ├── gcrypt_rdrand.c
│   │   ├── gdb_bogus_breakpoint.c
│   │   ├── gdb_bogus_breakpoint.py
│   │   ├── gdb_bogus_breakpoint.run
│   │   ├── gdb_qpasssignals.c
│   │   ├── gdb_qpasssignals.py
│   │   ├── gdb_qpasssignals.run
│   │   ├── generic_break.py
│   │   ├── get_thread_list.py
│   │   ├── get_thread_list.run
│   │   ├── getcpu.c
│   │   ├── getcwd.c
│   │   ├── getcwd.run
│   │   ├── getgroups.c
│   │   ├── getpwnam.c
│   │   ├── getrandom.c
│   │   ├── getsid.c
│   │   ├── gettimeofday.c
│   │   ├── goto_event.c
│   │   ├── goto_event.py
│   │   ├── goto_event.run
│   │   ├── grandchild_threads.c
│   │   ├── grandchild_threads_main_running.c
│   │   ├── grandchild_threads_parent_alive.c
│   │   ├── grandchild_threads_thread_running.c
│   │   ├── group_stop_thundering_herd.c
│   │   ├── hardlink_mmapped_files.run
│   │   ├── hbreak.py
│   │   ├── hbreak.run
│   │   ├── hello.c
│   │   ├── hello.run
│   │   ├── history.c
│   │   ├── history.py
│   │   ├── history.run
│   │   ├── hooks.c
│   │   ├── hooks.run
│   │   ├── ignore_nested.c
│   │   ├── ignore_nested.run
│   │   ├── ignored_async_usr1.c
│   │   ├── ignored_async_usr1.run
│   │   ├── ignored_sigsegv.c
│   │   ├── ignored_sigsegv.run
│   │   ├── immediate_restart.c
│   │   ├── immediate_restart.py
│   │   ├── immediate_restart.run
│   │   ├── inotify.c
│   │   ├── int3.c
│   │   ├── interrupt.c
│   │   ├── interrupt.py
│   │   ├── interrupt.run
│   │   ├── intr_futex_wait_restart.c
│   │   ├── intr_poll.c
│   │   ├── intr_ppoll.c
│   │   ├── intr_pselect.c
│   │   ├── intr_ptrace_decline.c
│   │   ├── intr_ptrace_decline.run
│   │   ├── intr_read_no_restart.c
│   │   ├── intr_read_restart.c
│   │   ├── intr_sleep.c
│   │   ├── intr_sleep_no_restart.c
│   │   ├── invalid_exec.c
│   │   ├── invalid_fcntl.c
│   │   ├── invalid_interpreter.c
│   │   ├── invalid_interpreter.py
│   │   ├── invalid_interpreter.run
│   │   ├── invalid_ioctl.c
│   │   ├── invalid_jump.c
│   │   ├── invalid_jump.py
│   │   ├── invalid_jump.run
│   │   ├── io.c
│   │   ├── io_uring.c
│   │   ├── ioctl.c
│   │   ├── ioctl_blk.c
│   │   ├── ioctl_br.c
│   │   ├── ioctl_fb.c
│   │   ├── ioctl_fs.c
│   │   ├── ioctl_hidraw.c
│   │   ├── ioctl_pty.c
│   │   ├── ioctl_sg.c
│   │   ├── ioctl_tty.c
│   │   ├── ioctl_ttyS.c
│   │   ├── ioctl_vt.c
│   │   ├── ioprio.c
│   │   ├── jit_proc_mem.c
│   │   ├── jit_proc_mem.py
│   │   ├── jit_proc_mem.run
│   │   ├── join_threads.c
│   │   ├── joystick.c
│   │   ├── kcmp.c
│   │   ├── keyctl.c
│   │   ├── kill_newborn.c
│   │   ├── kill_ptracee.c
│   │   ├── landlock.c
│   │   ├── large_file.run
│   │   ├── large_hole.c
│   │   ├── large_write_deadlock.c
│   │   ├── legacy_ugid.c
│   │   ├── link.c
│   │   ├── link.run
│   │   ├── madvise.c
│   │   ├── madvise_dontfork.c
│   │   ├── madvise_dontfork.py
│   │   ├── madvise_dontfork.run
│   │   ├── madvise_dontneed_private.c
│   │   ├── madvise_fracture_flags.c
│   │   ├── madvise_fracture_flags.run
│   │   ├── madvise_free.c
│   │   ├── madvise_misc.c
│   │   ├── madvise_remove.c
│   │   ├── madvise_wipeonfork.c
│   │   ├── main_thread_exit.c
│   │   ├── main_thread_exit.py
│   │   ├── main_thread_exit.run
│   │   ├── many_yields.c
│   │   ├── many_yields.run
│   │   ├── map_fixed.c
│   │   ├── map_shared_syscall.c
│   │   ├── membarrier.c
│   │   ├── memfd_create.c
│   │   ├── memfd_create_dotnet_huge_mapping.c
│   │   ├── memfd_create_efault.c
│   │   ├── memfd_create_shared.c
│   │   ├── memfd_create_shared_huge.c
│   │   ├── mincore.c
│   │   ├── mknod.c
│   │   ├── mlock.c
│   │   ├── mlock_madvise.c
│   │   ├── mmap_adjacent_to_rr_usage.c
│   │   ├── mmap_fd_reuse_checkpoint.c
│   │   ├── mmap_fd_reuse_checkpoint.py
│   │   ├── mmap_fd_reuse_checkpoint.run
│   │   ├── mmap_huge.c
│   │   ├── mmap_private.c
│   │   ├── mmap_private_grow_under_map.c
│   │   ├── mmap_recycle.c
│   │   ├── mmap_replace_most_mappings.c
│   │   ├── mmap_replace_most_mappings.py
│   │   ├── mmap_replace_most_mappings.run
│   │   ├── mmap_ro.c
│   │   ├── mmap_self_maps_shared.c
│   │   ├── mmap_shared.c
│   │   ├── mmap_shared_dev_zero.c
│   │   ├── mmap_shared_extern.c
│   │   ├── mmap_shared_extern.run
│   │   ├── mmap_shared_grow.c
│   │   ├── mmap_shared_grow_under_map.c
│   │   ├── mmap_shared_multiple.c
│   │   ├── mmap_shared_prot.c
│   │   ├── mmap_shared_prot.py
│   │   ├── mmap_shared_prot.run
│   │   ├── mmap_shared_subpage.c
│   │   ├── mmap_shared_write.c
│   │   ├── mmap_shared_write_exec_race.c
│   │   ├── mmap_shared_write_exec_race.run
│   │   ├── mmap_shared_write_fork.c
│   │   ├── mmap_short_file.c
│   │   ├── mmap_tmpfs.c
│   │   ├── mmap_tmpfs.run
│   │   ├── mmap_write.c
│   │   ├── mmap_write.run
│   │   ├── mmap_write_complex.c
│   │   ├── mmap_write_private.c
│   │   ├── mmap_write_private.run
│   │   ├── mmap_zero_size_fd.c
│   │   ├── mount_ns_exec.c
│   │   ├── mount_ns_exec2.c
│   │   ├── mount_ns_execveat.c
│   │   ├── mprotect.c
│   │   ├── mprotect_checkpoint.c
│   │   ├── mprotect_checkpoint.py
│   │   ├── mprotect_checkpoint.run
│   │   ├── mprotect_growsdown.c
│   │   ├── mprotect_growsdown.run
│   │   ├── mprotect_heterogenous.c
│   │   ├── mprotect_none.c
│   │   ├── mprotect_stack.c
│   │   ├── mprotect_step.py
│   │   ├── mprotect_step.run
│   │   ├── mprotect_syscallbuf_overflow.c
│   │   ├── mprotect_syscallbuf_overflow.run
│   │   ├── mq.c
│   │   ├── mremap.c
│   │   ├── mremap_after_coalesce.c
│   │   ├── mremap_dontunmap.c
│   │   ├── mremap_grow.c
│   │   ├── mremap_grow_shared.c
│   │   ├── mremap_non_page_size.c
│   │   ├── mremap_overwrite.c
│   │   ├── mremap_private_grow_under_map.c
│   │   ├── mremap_shrink.c
│   │   ├── msg.c
│   │   ├── msg_trunc.c
│   │   ├── msync.c
│   │   ├── mtio.c
│   │   ├── multiple_pending_signals.c
│   │   ├── multiple_pending_signals_sequential.c
│   │   ├── munmap_discontinuous.c
│   │   ├── munmap_segv.c
│   │   ├── mutex_pi_stress.c
│   │   ├── mutex_pi_stress.run
│   │   ├── nanosleep.c
│   │   ├── nested_detach.run
│   │   ├── nested_detach_kill.run
│   │   ├── nested_detach_kill_stuck.c
│   │   ├── nested_detach_kill_stuck.run
│   │   ├── nested_detach_stop.run
│   │   ├── nested_detach_wait.c
│   │   ├── nested_detach_wait.run
│   │   ├── nested_release.run
│   │   ├── nested_release_exit_code.run
│   │   ├── nested_release_signal.c
│   │   ├── nested_release_signal.run
│   │   ├── netfilter.c
│   │   ├── netfilter_ipv6.c
│   │   ├── netlink_mmap_disable.c
│   │   ├── no_mask_timeslice.c
│   │   ├── nscd.c
│   │   ├── nsutils.h
│   │   ├── numa.c
│   │   ├── open_tree.c
│   │   ├── openat2.c
│   │   ├── openat_null.c
│   │   ├── orphan_process.c
│   │   ├── overflow_branch_counter.c
│   │   ├── overflow_branch_counter.run
│   │   ├── pack.c
│   │   ├── pack.run
│   │   ├── pack_dir.run
│   │   ├── packet_mmap_disable.c
│   │   ├── parent_no_break_child_bkpt.py
│   │   ├── parent_no_break_child_bkpt.run
│   │   ├── parent_no_stop_child_crash.py
│   │   ├── parent_no_stop_child_crash.run
│   │   ├── patch_page_end.c
│   │   ├── patch_page_end.run
│   │   ├── pause.c
│   │   ├── perf_event.c
│   │   ├── perf_event_ioctl.c
│   │   ├── perf_event_mmap.c
│   │   ├── personality.c
│   │   ├── personality_chaos.run
│   │   ├── pid_ns_kill_child.c
│   │   ├── pid_ns_kill_child_threads.c
│   │   ├── pid_ns_kill_child_zombie.c
│   │   ├── pid_ns_kill_threads.c
│   │   ├── pid_ns_kill_threads_exit_wait.c
│   │   ├── pid_ns_reap.c
│   │   ├── pid_ns_segv.c
│   │   ├── pid_ns_shutdown.c
│   │   ├── pidfd.c
│   │   ├── pidfd_getfd.c
│   │   ├── pivot_root.c
│   │   ├── poll_sig_race.c
│   │   ├── post_exec_fpu_regs.py
│   │   ├── post_exec_fpu_regs.run
│   │   ├── ppoll.c
│   │   ├── ppoll_deliver.c
│   │   ├── prctl.c
│   │   ├── prctl_anon_vma_name.c
│   │   ├── prctl_auxv.c
│   │   ├── prctl_caps.c
│   │   ├── prctl_deathsig.c
│   │   ├── prctl_mdwe.c
│   │   ├── prctl_name.c
│   │   ├── prctl_short_name.c
│   │   ├── prctl_speculation_ctrl.c
│   │   ├── prctl_tsc.c
│   │   ├── prctl_tsc.run
│   │   ├── prctl_tsc_supported.c
│   │   ├── priority.c
│   │   ├── priority.run
│   │   ├── privileged_net_ioctl.c
│   │   ├── proc_fds.c
│   │   ├── proc_maps.py
│   │   ├── proc_maps.run
│   │   ├── proc_mem.c
│   │   ├── protect_rr_fds.c
│   │   ├── prw.c
│   │   ├── pthread_condvar_locking.c
│   │   ├── pthread_mutex_timedlock.c
│   │   ├── pthread_pi_mutex.c
│   │   ├── pthread_rwlocks.c
│   │   ├── ptrace_attach_null_status.c
│   │   ├── ptrace_attach_running.c
│   │   ├── ptrace_attach_sleeping.c
│   │   ├── ptrace_attach_stopped.c
│   │   ├── ptrace_attach_syscall.c
│   │   ├── ptrace_attach_thread_running.c
│   │   ├── ptrace_breakpoint.c
│   │   ├── ptrace_change_patched_syscall.c
│   │   ├── ptrace_exec.c
│   │   ├── ptrace_group_stop.c
│   │   ├── ptrace_kill_grandtracee.c
│   │   ├── ptrace_remote_unmap.c
│   │   ├── ptrace_remote_unmap.py
│   │   ├── ptrace_remote_unmap.run
│   │   ├── ptrace_seize.c
│   │   ├── ptrace_sigchld.c
│   │   ├── ptrace_sigchld_blocked.c
│   │   ├── ptrace_signals.c
│   │   ├── ptrace_singlestep.c
│   │   ├── ptrace_syscall.c
│   │   ├── ptrace_syscall_clone_untraced.c
│   │   ├── ptrace_sysemu_syscall.c
│   │   ├── ptrace_trace_clone.c
│   │   ├── ptrace_trace_exit.c
│   │   ├── ptrace_traceme.c
│   │   ├── ptrace_traceme_thread.c
│   │   ├── ptrace_util.h
│   │   ├── ptrace_waiter_thread.c
│   │   ├── ptracer_death.c
│   │   ├── ptracer_death_multithread.c
│   │   ├── ptracer_death_multithread_peer.c
│   │   ├── quotactl.c
│   │   ├── read_bad_mem.py
│   │   ├── read_bad_mem.run
│   │   ├── read_big_struct.c
│   │   ├── read_big_struct.py
│   │   ├── read_big_struct.run
│   │   ├── read_large.c
│   │   ├── read_nothing.c
│   │   ├── read_oversize.c
│   │   ├── readdir.c
│   │   ├── readlink.c
│   │   ├── readlinkat.c
│   │   ├── readv.c
│   │   ├── record_replay.run
│   │   ├── record_replay_subject.c
│   │   ├── recvfrom.c
│   │   ├── redzone_integrity.c
│   │   ├── remove_latest_trace.c
│   │   ├── remove_latest_trace.run
│   │   ├── remove_watchpoint.py
│   │   ├── remove_watchpoint.run
│   │   ├── rename.c
│   │   ├── replay_overlarge_event_number.run
│   │   ├── replay_serve_files.py
│   │   ├── replay_serve_files.run
│   │   ├── restart_abnormal_exit.c
│   │   ├── restart_abnormal_exit.py
│   │   ├── restart_abnormal_exit.run
│   │   ├── restart_breakpoint.py
│   │   ├── restart_diversion.py
│   │   ├── restart_diversion.run
│   │   ├── restart_finish.py
│   │   ├── restart_invalid_checkpoint.py
│   │   ├── restart_invalid_checkpoint.run
│   │   ├── restart_unstable.py
│   │   ├── restart_unstable.run
│   │   ├── reverse_alarm.py
│   │   ├── reverse_alarm.run
│   │   ├── reverse_continue_breakpoint.c
│   │   ├── reverse_continue_breakpoint.py
│   │   ├── reverse_continue_breakpoint.run
│   │   ├── reverse_continue_exec_subprocess.py
│   │   ├── reverse_continue_exec_subprocess.run
│   │   ├── reverse_continue_fork_subprocess.py
│   │   ├── reverse_continue_fork_subprocess.run
│   │   ├── reverse_continue_int3.py
│   │   ├── reverse_continue_int3.run
│   │   ├── reverse_continue_multiprocess.c
│   │   ├── reverse_continue_multiprocess.py
│   │   ├── reverse_continue_multiprocess.run
│   │   ├── reverse_continue_process_signal.c
│   │   ├── reverse_continue_process_signal.py
│   │   ├── reverse_continue_process_signal.run
│   │   ├── reverse_continue_start.py
│   │   ├── reverse_continue_start.run
│   │   ├── reverse_finish.py
│   │   ├── reverse_finish.run
│   │   ├── reverse_many_breakpoints.c
│   │   ├── reverse_many_breakpoints.py
│   │   ├── reverse_many_breakpoints.run
│   │   ├── reverse_step_breakpoint.py
│   │   ├── reverse_step_breakpoint.run
│   │   ├── reverse_step_long.c
│   │   ├── reverse_step_long.py
│   │   ├── reverse_step_long.run
│   │   ├── reverse_step_signal.py
│   │   ├── reverse_step_signal.run
│   │   ├── reverse_step_threads.c
│   │   ├── reverse_step_threads.py
│   │   ├── reverse_step_threads.run
│   │   ├── reverse_step_threads2.py
│   │   ├── reverse_step_threads2.run
│   │   ├── reverse_step_threads_break.c
│   │   ├── reverse_step_threads_break.py
│   │   ├── reverse_step_threads_break.run
│   │   ├── reverse_watchpoint.py
│   │   ├── reverse_watchpoint.run
│   │   ├── reverse_watchpoint_syscall.py
│   │   ├── reverse_watchpoint_syscall.run
│   │   ├── rlimit.c
│   │   ├── robust_futex.c
│   │   ├── rr_ps.c
│   │   ├── rr_ps.run
│   │   ├── rr_ps_ns.c
│   │   ├── rr_ps_ns.run
│   │   ├── rseq.c
│   │   ├── rseq.py
│   │   ├── rseq.run
│   │   ├── rseq_cpu_id_reset.c
│   │   ├── rseq_cpu_id_reset_longrunning.c
│   │   ├── rseq_cpu_id_reset_longrunning.py
│   │   ├── rseq_cpu_id_reset_longrunning.run
│   │   ├── rseq_syscallbuf.c
│   │   ├── rseq_syscallbuf.run
│   │   ├── run_end.py
│   │   ├── run_end.run
│   │   ├── run_in_function.py
│   │   ├── run_in_function.run
│   │   ├── rusage.c
│   │   ├── samask.c
│   │   ├── sanity.py
│   │   ├── sanity.run
│   │   ├── save_data_fd.c
│   │   ├── sched_attr.c
│   │   ├── sched_setaffinity.c
│   │   ├── sched_setparam.c
│   │   ├── sched_yield.c
│   │   ├── sched_yield_to_lower_priority.c
│   │   ├── scm_rights.c
│   │   ├── scratch_read.c
│   │   ├── search.c
│   │   ├── search.py
│   │   ├── search.run
│   │   ├── seccomp.c
│   │   ├── seccomp_blocks_rr.c
│   │   ├── seccomp_blocks_rr.run
│   │   ├── seccomp_clone_fail.c
│   │   ├── seccomp_cloning.c
│   │   ├── seccomp_desched.c
│   │   ├── seccomp_kill_exit.c
│   │   ├── seccomp_madvise.c
│   │   ├── seccomp_null.c
│   │   ├── seccomp_open.c
│   │   ├── seccomp_open.run
│   │   ├── seccomp_signals.c
│   │   ├── seccomp_signals.run
│   │   ├── seccomp_sigsys_args.c
│   │   ├── seccomp_sigsys_sigtrap.c
│   │   ├── seccomp_sigsys_syscallbuf.c
│   │   ├── seccomp_tsync.c
│   │   ├── seccomp_veto_exec.c
│   │   ├── seekticks.py
│   │   ├── seekticks.run
│   │   ├── seekticks_threads.c
│   │   ├── seekticks_threads.py
│   │   ├── seekticks_threads.run
│   │   ├── segfault.c
│   │   ├── segfault.run
│   │   ├── self_shebang.c
│   │   ├── self_sigint.c
│   │   ├── sem.c
│   │   ├── send_block.c
│   │   ├── sendfile.c
│   │   ├── set_ptracer.c
│   │   ├── set_tid_address.c
│   │   ├── setgid.c
│   │   ├── setgroups.c
│   │   ├── setitimer.c
│   │   ├── setsid.c
│   │   ├── setuid.c
│   │   ├── setuid.run
│   │   ├── shared_exec.c
│   │   ├── shared_map.c
│   │   ├── shared_map.run
│   │   ├── shared_monitor.c
│   │   ├── shared_offset.c
│   │   ├── shared_persistent_file.c
│   │   ├── shared_persistent_file.py
│   │   ├── shared_persistent_file.run
│   │   ├── shared_write.c
│   │   ├── shm.c
│   │   ├── shm_checkpoint.py
│   │   ├── shm_checkpoint.run
│   │   ├── shm_unmap.c
│   │   ├── sigaction_old.c
│   │   ├── sigaltstack.c
│   │   ├── sigchld_interrupt_signal.c
│   │   ├── sigcont.c
│   │   ├── sigcont_threaded.c
│   │   ├── sigframe_grow_stack.c
│   │   ├── sighandler_bad_rsp_sigsegv.c
│   │   ├── sighandler_fork.c
│   │   ├── sighandler_mask.c
│   │   ├── sigill.c
│   │   ├── siginfo.py
│   │   ├── siginfo.run
│   │   ├── signal_checkpoint.py
│   │   ├── signal_checkpoint.run
│   │   ├── signal_deferred.c
│   │   ├── signal_during_preload_init.c
│   │   ├── signal_frame.c
│   │   ├── signal_numbers.c
│   │   ├── signal_numbers.py
│   │   ├── signal_numbers.run
│   │   ├── signal_stop.py
│   │   ├── signal_stop.run
│   │   ├── signal_unstoppable.c
│   │   ├── signalfd.c
│   │   ├── sigprocmask.c
│   │   ├── sigprocmask_ensure_delivery.c
│   │   ├── sigprocmask_evil.c
│   │   ├── sigprocmask_exec.c
│   │   ├── sigprocmask_in_syscallbuf_sighandler.c
│   │   ├── sigprocmask_race.c
│   │   ├── sigprocmask_race.run
│   │   ├── sigprocmask_rr_sigs.c
│   │   ├── sigprocmask_rr_sigs_nondefault.c
│   │   ├── sigprocmask_rr_sigs_nondefault.run
│   │   ├── sigprocmask_syscallbuf.c
│   │   ├── sigprof.c
│   │   ├── sigpwr.c
│   │   ├── sigqueueinfo.c
│   │   ├── sigreturn_reg.c
│   │   ├── sigreturnmask.c
│   │   ├── sigrt.c
│   │   ├── sigstop.c
│   │   ├── sigstop2.c
│   │   ├── sigsuspend.c
│   │   ├── sigtrap.c
│   │   ├── sigtrap_process_group.c
│   │   ├── simple.c
│   │   ├── simple.run
│   │   ├── simple_script.run
│   │   ├── simple_script.sh
│   │   ├── simple_script_debug.py
│   │   ├── simple_script_debug.run
│   │   ├── simple_threads_stress.c
│   │   ├── simple_winch.py
│   │   ├── simple_winch.run
│   │   ├── sioc.c
│   │   ├── small_holes.c
│   │   ├── sock_name_null.c
│   │   ├── sock_names_opts.c
│   │   ├── spinlock_priorities.c
│   │   ├── splice.c
│   │   ├── stack_growth.c
│   │   ├── stack_growth.py
│   │   ├── stack_growth.run
│   │   ├── stack_growth_after_syscallbuf.c
│   │   ├── stack_growth_syscallbuf.c
│   │   ├── stack_growth_with_guard.c
│   │   ├── stack_invalid.c
│   │   ├── stack_overflow.c
│   │   ├── stack_overflow_altstack.c
│   │   ├── stack_overflow_debug.py
│   │   ├── stack_overflow_debug.run
│   │   ├── stack_overflow_with_guard.c
│   │   ├── statfs.c
│   │   ├── statx.c
│   │   ├── std_random.cc
│   │   ├── stdout_child.c
│   │   ├── stdout_cloexec.c
│   │   ├── stdout_dup.c
│   │   ├── stdout_redirect.c
│   │   ├── step1.py
│   │   ├── step1.run
│   │   ├── step_into_lib.c
│   │   ├── step_into_lib.py
│   │   ├── step_into_lib.run
│   │   ├── step_signal.py
│   │   ├── step_signal.run
│   │   ├── step_thread.c
│   │   ├── step_thread.py
│   │   ├── step_thread.run
│   │   ├── stray_time_slice_signal.c
│   │   ├── stray_time_slice_signal.run
│   │   ├── strict_priorities.c
│   │   ├── strict_priorities.run
│   │   ├── subprocess_exit_ends_session.py
│   │   ├── subprocess_exit_ends_session.run
│   │   ├── switch_processes.py
│   │   ├── switch_processes.run
│   │   ├── switch_read.c
│   │   ├── symlink.c
│   │   ├── sync.c
│   │   ├── sync_file_range.c
│   │   ├── syscall_bp.c
│   │   ├── syscall_in_writable_mem.c
│   │   ├── syscallbuf_fd_disabling.c
│   │   ├── syscallbuf_fd_disabling.run
│   │   ├── syscallbuf_signal_blocking.c
│   │   ├── syscallbuf_signal_blocking_read.c
│   │   ├── syscallbuf_signal_blocking_read.run
│   │   ├── syscallbuf_signal_reset.c
│   │   ├── syscallbuf_sigstop.c
│   │   ├── syscallbuf_timeslice.c
│   │   ├── syscallbuf_timeslice2.c
│   │   ├── syscallbuf_timeslice2_250.run
│   │   ├── syscallbuf_timeslice_250.run
│   │   ├── sysconf.c
│   │   ├── sysconf_conf.c
│   │   ├── sysconf_onln.c
│   │   ├── sysconf_onln.run
│   │   ├── sysctl.c
│   │   ├── sysemu_singlestep.c
│   │   ├── sysinfo.c
│   │   ├── syslog.c
│   │   ├── target_fork.c
│   │   ├── target_fork.run
│   │   ├── target_process.c
│   │   ├── target_process.run
│   │   ├── tcp_sockets.c
│   │   ├── tcp_sockets.run
│   │   ├── term_nonmain.c
│   │   ├── term_nonmain.run
│   │   ├── term_rr.c
│   │   ├── term_rr.py
│   │   ├── term_rr.run
│   │   ├── term_rr_ok.c
│   │   ├── term_rr_ok.run
│   │   ├── term_trace_cpu.run
│   │   ├── term_trace_reset.c
│   │   ├── term_trace_reset.run
│   │   ├── term_trace_syscall.c
│   │   ├── term_trace_syscall.run
│   │   ├── test_lib.c
│   │   ├── test_setup.gdb
│   │   ├── test_setup.lldb
│   │   ├── tgkill.c
│   │   ├── thread_exit_signal.c
│   │   ├── thread_exit_signal.run
│   │   ├── thread_open_race.c
│   │   ├── thread_open_race.run
│   │   ├── thread_stress.c
│   │   ├── thread_stress.run
│   │   ├── thread_yield.c
│   │   ├── threaded_syscall_spam.c
│   │   ├── threaded_syscall_spam.run
│   │   ├── threads.c
│   │   ├── threads.run
│   │   ├── tick0.c
│   │   ├── tick0.py
│   │   ├── tick0.run
│   │   ├── tick0_less.run
│   │   ├── timer.c
│   │   ├── timerfd.c
│   │   ├── times.c
│   │   ├── tls.c
│   │   ├── tls.py
│   │   ├── tls.run
│   │   ├── trace_events.run
│   │   ├── trace_version.run
│   │   ├── tracee_unmap_vdso.c
│   │   ├── tracee_unmap_vdso.run
│   │   ├── traceinfo.run
│   │   ├── transient_fault_replay_all.run
│   │   ├── truncate_temp.c
│   │   ├── tty.run
│   │   ├── tty_tostop.c
│   │   ├── ttyname.c
│   │   ├── ttyname.run
│   │   ├── tun.c
│   │   ├── two_signals_with_mask.c
│   │   ├── ulimit_low.c
│   │   ├── uname.c
│   │   ├── unexpected_exit.c
│   │   ├── unexpected_exit_execve.c
│   │   ├── unexpected_exit_execve_twice.c
│   │   ├── unexpected_exit_pid_ns.c
│   │   ├── unexpected_stack_growth.c
│   │   ├── unexpected_stack_growth.py
│   │   ├── unexpected_stack_growth.run
│   │   ├── unicode.c
│   │   ├── unicode.py
│   │   ├── unicode.run
│   │   ├── unjoined_thread.c
│   │   ├── unmap_vdso.run
│   │   ├── unshare.c
│   │   ├── unwind_on_signal.py
│   │   ├── unwind_on_signal.run
│   │   ├── unwind_rr_page.cc
│   │   ├── usb.c
│   │   ├── user_ignore_sig.c
│   │   ├── user_ignore_sig.run
│   │   ├── userfaultfd.c
│   │   ├── util.h
│   │   ├── util.py
│   │   ├── util.sh
│   │   ├── util_internal.h
│   │   ├── util_syscall.h
│   │   ├── utimes.c
│   │   ├── v4l_dmabuf.c
│   │   ├── vdso_clock_gettime_stack.c
│   │   ├── vdso_clock_gettime_stack.run
│   │   ├── vdso_gettimeofday_stack.c
│   │   ├── vdso_gettimeofday_stack.run
│   │   ├── vdso_parts.c
│   │   ├── vdso_stack.py
│   │   ├── vdso_symbols.c
│   │   ├── vdso_time_stack.c
│   │   ├── vdso_time_stack.run
│   │   ├── vfork.c
│   │   ├── vfork.run
│   │   ├── vfork_break_parent.py
│   │   ├── vfork_break_parent.run
│   │   ├── vfork_done.c
│   │   ├── vfork_done_clone.run
│   │   ├── vfork_exec.run
│   │   ├── vfork_flush.c
│   │   ├── vfork_read_clone_stress.c
│   │   ├── vfork_read_clone_stress.py
│   │   ├── vfork_read_clone_stress.run
│   │   ├── vfork_setopts.c
│   │   ├── vfork_shared.c
│   │   ├── video_capture.c
│   │   ├── vm_readv_writev.c
│   │   ├── vsyscall.c
│   │   ├── vsyscall_reverse_next.c
│   │   ├── vsyscall_reverse_next.py
│   │   ├── vsyscall_reverse_next.run
│   │   ├── vsyscall_singlestep.run
│   │   ├── vsyscall_timeslice.c
│   │   ├── wait.c
│   │   ├── wait_for_all.c
│   │   ├── wait_for_all.run
│   │   ├── wait_sigstop.c
│   │   ├── watch_code.py
│   │   ├── watch_code.run
│   │   ├── watchpoint.c
│   │   ├── watchpoint.py
│   │   ├── watchpoint.run
│   │   ├── watchpoint_at_sched.c
│   │   ├── watchpoint_at_sched.py
│   │   ├── watchpoint_at_sched.run
│   │   ├── watchpoint_before_signal.c
│   │   ├── watchpoint_before_signal.py
│   │   ├── watchpoint_before_signal.run
│   │   ├── watchpoint_cond.py
│   │   ├── watchpoint_cond.run
│   │   ├── watchpoint_no_progress.c
│   │   ├── watchpoint_no_progress.py
│   │   ├── watchpoint_no_progress.run
│   │   ├── watchpoint_size_change.c
│   │   ├── watchpoint_size_change.py
│   │   ├── watchpoint_size_change.run
│   │   ├── watchpoint_step.py
│   │   ├── watchpoint_step.run
│   │   ├── watchpoint_syscall.c
│   │   ├── watchpoint_syscall.py
│   │   ├── watchpoint_syscall.run
│   │   ├── watchpoint_unaligned.c
│   │   ├── watchpoint_unaligned.py
│   │   ├── watchpoint_unaligned.run
│   │   ├── watchpoint_unaligned2.c
│   │   ├── watchpoint_unaligned2.py
│   │   ├── watchpoint_unaligned2.run
│   │   ├── when.py
│   │   ├── when.run
│   │   ├── when_threads.c
│   │   ├── when_threads.py
│   │   ├── when_threads.run
│   │   ├── write_race.c
│   │   ├── writev.c
│   │   ├── x86/
│   │   │   ├── arch_prctl_x86.c
│   │   │   ├── arch_prctl_xstate.c
│   │   │   ├── blocked_sigsegv.c
│   │   │   ├── blocked_sigsegv.run
│   │   │   ├── break_rdtsc.run
│   │   │   ├── chew_cpu_cpuid.c
│   │   │   ├── cpuid.c
│   │   │   ├── cpuid.run
│   │   │   ├── cpuid_loop.S
│   │   │   ├── cpuid_same_state.c
│   │   │   ├── cpuid_singlestep.c
│   │   │   ├── cpuid_singlestep.py
│   │   │   ├── cpuid_singlestep.run
│   │   │   ├── cross_arch.c
│   │   │   ├── deferred_patch.c
│   │   │   ├── diversion_rdtsc.c
│   │   │   ├── diversion_rdtsc.py
│   │   │   ├── diversion_rdtsc.run
│   │   │   ├── explicit_checkpoints.c
│   │   │   ├── explicit_checkpoints.py
│   │   │   ├── explicit_checkpoints.run
│   │   │   ├── fault_in_code_page.c
│   │   │   ├── fxregs.c
│   │   │   ├── fxregs.py
│   │   │   ├── fxregs.run
│   │   │   ├── gdb_avx512.c
│   │   │   ├── gdb_avx512.py
│   │   │   ├── gdb_avx512.run
│   │   │   ├── hle.c
│   │   │   ├── hlt.c
│   │   │   ├── int3_ok.c
│   │   │   ├── int3_ok.run
│   │   │   ├── ioperm.c
│   │   │   ├── iopl.c
│   │   │   ├── la57.c
│   │   │   ├── lsl.c
│   │   │   ├── modify_ldt.c
│   │   │   ├── morestack_unwind.c
│   │   │   ├── morestack_unwind.py
│   │   │   ├── morestack_unwind.run
│   │   │   ├── old_fork.c
│   │   │   ├── patch_40_80_f6_81.c
│   │   │   ├── patch_40_80_f6_81.run
│   │   │   ├── patch_pc_rel.c
│   │   │   ├── patch_pc_rel.run
│   │   │   ├── patch_syscall_restart.c
│   │   │   ├── pkeys.c
│   │   │   ├── ptrace.c
│   │   │   ├── ptrace_debug_regs.c
│   │   │   ├── ptrace_exec32.c
│   │   │   ├── ptrace_sysemu.c
│   │   │   ├── ptrace_tls.c
│   │   │   ├── rdtsc.c
│   │   │   ├── rdtsc_flags.c
│   │   │   ├── rdtsc_interfering.c
│   │   │   ├── rdtsc_interfering.run
│   │   │   ├── rdtsc_loop.c
│   │   │   ├── rdtsc_loop.run
│   │   │   ├── rdtsc_loop2.c
│   │   │   ├── rdtsc_loop2.run
│   │   │   ├── set_thread_area.c
│   │   │   ├── signal_xmm_state.c
│   │   │   ├── sigreturn.c
│   │   │   ├── sigreturn_checksum.run
│   │   │   ├── singlestep_pushf.c
│   │   │   ├── singlestep_pushf.py
│   │   │   ├── singlestep_pushf.run
│   │   │   ├── step_rdtsc.py
│   │   │   ├── step_rdtsc.run
│   │   │   ├── string_instructions.c
│   │   │   ├── string_instructions.py
│   │   │   ├── string_instructions.run
│   │   │   ├── string_instructions_async_signals.c
│   │   │   ├── string_instructions_async_signals.run
│   │   │   ├── string_instructions_async_signals_shared.c
│   │   │   ├── string_instructions_async_signals_shared.run
│   │   │   ├── string_instructions_break.py
│   │   │   ├── string_instructions_break.run
│   │   │   ├── string_instructions_multiwatch.c
│   │   │   ├── string_instructions_multiwatch.py
│   │   │   ├── string_instructions_multiwatch.run
│   │   │   ├── string_instructions_replay.c
│   │   │   ├── string_instructions_replay.run
│   │   │   ├── string_instructions_replay_quirk.py
│   │   │   ├── string_instructions_replay_quirk.run
│   │   │   ├── string_instructions_singlestep_fastforward.c
│   │   │   ├── string_instructions_singlestep_fastforward.run
│   │   │   ├── string_instructions_watch.c
│   │   │   ├── string_instructions_watch.py
│   │   │   ├── string_instructions_watch.run
│   │   │   ├── syscallbuf_branch_check.c
│   │   │   ├── syscallbuf_branch_check.run
│   │   │   ├── syscallbuf_rdtsc_page.c
│   │   │   ├── syscallbuf_rdtsc_page.run
│   │   │   ├── sysfs.c
│   │   │   ├── util.h
│   │   │   ├── util.sh
│   │   │   ├── watchpoint_error.c
│   │   │   ├── watchpoint_error.py
│   │   │   ├── watchpoint_error.run
│   │   │   └── x87env.c
│   │   ├── xattr.c
│   │   └── zero_length_read.c
│   ├── test-monitor/
│   │   └── test-monitor.cc
│   ├── util.cc
│   └── util.h
└── third-party/
    ├── blake2/
    │   ├── README
    │   ├── blake2-impl.h
    │   ├── blake2.h
    │   ├── neon/
    │   │   ├── blake2b-load-neon.h
    │   │   ├── blake2b-neon.c
    │   │   ├── blake2b-round.h
    │   │   └── blake2b.c
    │   └── sse/
    │       ├── blake2-config.h
    │       ├── blake2b-load-sse2.h
    │       ├── blake2b-load-sse41.h
    │       ├── blake2b-round.h
    │       └── blake2b.c
    ├── brotli/
    │   ├── README.md
    │   ├── common/
    │   │   ├── constants.c
    │   │   ├── constants.h
    │   │   ├── context.c
    │   │   ├── context.h
    │   │   ├── dictionary.bin.br
    │   │   ├── dictionary.c
    │   │   ├── dictionary.h
    │   │   ├── platform.c
    │   │   ├── platform.h
    │   │   ├── shared_dictionary.c
    │   │   ├── shared_dictionary_internal.h
    │   │   ├── transform.c
    │   │   ├── transform.h
    │   │   └── version.h
    │   ├── dec/
    │   │   ├── bit_reader.c
    │   │   ├── bit_reader.h
    │   │   ├── decode.c
    │   │   ├── huffman.c
    │   │   ├── huffman.h
    │   │   ├── prefix.h
    │   │   ├── state.c
    │   │   └── state.h
    │   ├── enc/
    │   │   ├── backward_references.c
    │   │   ├── backward_references.h
    │   │   ├── backward_references_hq.c
    │   │   ├── backward_references_hq.h
    │   │   ├── backward_references_inc.h
    │   │   ├── bit_cost.c
    │   │   ├── bit_cost.h
    │   │   ├── bit_cost_inc.h
    │   │   ├── block_encoder_inc.h
    │   │   ├── block_splitter.c
    │   │   ├── block_splitter.h
    │   │   ├── block_splitter_inc.h
    │   │   ├── brotli_bit_stream.c
    │   │   ├── brotli_bit_stream.h
    │   │   ├── cluster.c
    │   │   ├── cluster.h
    │   │   ├── cluster_inc.h
    │   │   ├── command.c
    │   │   ├── command.h
    │   │   ├── compound_dictionary.c
    │   │   ├── compound_dictionary.h
    │   │   ├── compress_fragment.c
    │   │   ├── compress_fragment.h
    │   │   ├── compress_fragment_two_pass.c
    │   │   ├── compress_fragment_two_pass.h
    │   │   ├── dictionary_hash.c
    │   │   ├── dictionary_hash.h
    │   │   ├── encode.c
    │   │   ├── encoder_dict.c
    │   │   ├── encoder_dict.h
    │   │   ├── entropy_encode.c
    │   │   ├── entropy_encode.h
    │   │   ├── entropy_encode_static.h
    │   │   ├── fast_log.c
    │   │   ├── fast_log.h
    │   │   ├── find_match_length.h
    │   │   ├── hash.h
    │   │   ├── hash_composite_inc.h
    │   │   ├── hash_forgetful_chain_inc.h
    │   │   ├── hash_longest_match64_inc.h
    │   │   ├── hash_longest_match_inc.h
    │   │   ├── hash_longest_match_quickly_inc.h
    │   │   ├── hash_rolling_inc.h
    │   │   ├── hash_to_binary_tree_inc.h
    │   │   ├── histogram.c
    │   │   ├── histogram.h
    │   │   ├── histogram_inc.h
    │   │   ├── literal_cost.c
    │   │   ├── literal_cost.h
    │   │   ├── memory.c
    │   │   ├── memory.h
    │   │   ├── metablock.c
    │   │   ├── metablock.h
    │   │   ├── metablock_inc.h
    │   │   ├── params.h
    │   │   ├── prefix.h
    │   │   ├── quality.h
    │   │   ├── ringbuffer.h
    │   │   ├── state.h
    │   │   ├── static_dict.c
    │   │   ├── static_dict.h
    │   │   ├── static_dict_lut.h
    │   │   ├── utf8_util.c
    │   │   ├── utf8_util.h
    │   │   └── write_bits.h
    │   └── include/
    │       └── brotli/
    │           ├── decode.h
    │           ├── encode.h
    │           ├── port.h
    │           ├── shared_dictionary.h
    │           └── types.h
    ├── gdb/
    │   ├── 32bit-avx.xml
    │   ├── 32bit-avx512.xml
    │   ├── 32bit-core.xml
    │   ├── 32bit-linux.xml
    │   ├── 32bit-pkeys.xml
    │   ├── 32bit-sse.xml
    │   ├── 64bit-avx.xml
    │   ├── 64bit-avx512.xml
    │   ├── 64bit-core.xml
    │   ├── 64bit-linux.xml
    │   ├── 64bit-pkeys.xml
    │   ├── 64bit-seg.xml
    │   ├── 64bit-sse.xml
    │   ├── README
    │   ├── aarch64-core.xml
    │   ├── aarch64-fpu.xml
    │   └── aarch64-pauth.xml
    ├── proc-service/
    │   ├── README
    │   └── proc_service.h
    └── zen-pmu-workaround/
        ├── README
        └── zen_workaround.c

SYMBOL INDEX (4505 symbols across 1011 files)

FILE: release-process/prepare-release.py
  function check_call (line 40) | def check_call(args):
  function update_cmake (line 44) | def update_cmake(name, num):
  function prepare_branch (line 49) | def prepare_branch():
  function prepare_dirs (line 64) | def prepare_dirs():
  function output_file_name (line 68) | def output_file_name(distro_name, arch):
  function has_line_starting (line 71) | def has_line_starting(output_file, prefix):
  function start_vm (line 78) | def start_vm(cmd, output_file):
  function run_tests (line 94) | def run_tests():

FILE: release-process/test-system.py
  class Ec2Vm (line 25) | class Ec2Vm:
    method __init__ (line 26) | def __init__(self, machine_type, architecture, distro_config, keypair_...
    method wait_for_ssh (line 76) | def wait_for_ssh(self):
    method ssh (line 94) | def ssh(self, cmd, input):
    method scp_from (line 106) | def scp_from(self, options, src, dst):
    method ssh_command (line 112) | def ssh_command(self):
    method ssh_options (line 115) | def ssh_options(self):
    method ssh_dest (line 124) | def ssh_dest(self):
    method terminate (line 127) | def terminate(self):
  function get_config_lines (line 139) | def get_config_lines(config_key):
  function get_config_lines_arch (line 149) | def get_config_lines_arch(config_key):
  function config_script_function (line 152) | def config_script_function(config_key):

FILE: scripts/rr-collect-symbols.py
  function build_id_for (line 52) | def build_id_for(file):
  function find_altref (line 64) | def find_altref(file):
  function find_altref_for_trace_file (line 75) | def find_altref_for_trace_file(trace_file, altref):
  function mkdir_p (line 87) | def mkdir_p(path):
  function copy_file (line 97) | def copy_file(src, dst):
  function create_link (line 107) | def create_link(src, dst):
  function collect_trace_build_ids (line 115) | def collect_trace_build_ids():
  function collect_archive (line 134) | def collect_archive(url):
  function collect_filesystem (line 170) | def collect_filesystem(path):

FILE: scripts/rr-gdb-script-host.py
  function strip_prefix (line 11) | def strip_prefix(s: str, needle: str) -> Optional[str]:
  function print_wrapper (line 17) | def print_wrapper(*args, **kwargs):
  class DebuggerExtensionCommand (line 27) | class DebuggerExtensionCommand:
    method __init__ (line 28) | def __init__(self, *args, **kwargs):
  class GdbScriptHost (line 31) | class GdbScriptHost:
    method __init__ (line 41) | def __init__(self, *args, **kwargs):
    method show (line 44) | def show(self, cmd: str) -> Optional[str]:
    method set (line 53) | def set(self, cmd: str) -> str:
    method execute_script (line 63) | def execute_script(self, script: str):
    method new_objfile (line 67) | def new_objfile(self, f: str):
  class GdbApiObject (line 73) | class GdbApiObject(object):
    method __init__ (line 74) | def __init__(self, *args, **kwargs):
    method __getattr__ (line 77) | def __getattr__(self, attr):
  class GdbProgspace (line 80) | class GdbProgspace(GdbApiObject):
    method __init__ (line 83) | def __init__(self, *args, **kwargs):
  class GdbNewObjfile (line 87) | class GdbNewObjfile(GdbApiObject):
    method __init__ (line 89) | def __init__(self, *args, **kwargs):
  class GdbNewObjfileEvent (line 93) | class GdbNewObjfileEvent(GdbApiObject):
    method __init__ (line 96) | def __init__(self, *args, **kwargs):
  class GdbNewObjfileEvents (line 100) | class GdbNewObjfileEvents(GdbApiObject):
    method connect (line 101) | def connect(self, c: GdbNewObjfileEventCallback):
  class GdbApiEvents (line 105) | class GdbApiEvents(GdbApiObject):
    method new_objfile (line 109) | def new_objfile(self) -> GdbNewObjfileEvents:
  class GdbApiRoot (line 115) | class GdbApiRoot(GdbApiObject):
    method execute (line 119) | def execute(self, command: str, from_tty: bool = False, to_string: boo...
    method lookup_global_symbol (line 154) | def lookup_global_symbol(self, s: str) -> Optional[object]:
    method current_progspace (line 159) | def current_progspace(self) -> GdbProgspace:
    method events (line 166) | def events(self) -> GdbApiEvents:
    method COMMAND_USER (line 173) | def COMMAND_USER(self) -> int:
    method Command (line 177) | def Command(self) -> Type[DebuggerExtensionCommand]:

FILE: scripts/zen_workaround.py
  function is_secure_boot_enabled (line 27) | def is_secure_boot_enabled():
  function read_msr (line 55) | def read_msr(cpu):

FILE: src/AddressSpace.cc
  type rr (line 28) | namespace rr {
    function thread_group_in_exec (line 61) | static bool thread_group_in_exec(Task* t) {
    function KernelMapping (line 184) | static KernelMapping read_kernel_mapping(pid_t tid, remote_ptr<void> a...
    function KernelMapping (line 200) | KernelMapping AddressSpace::read_kernel_mapping(Task* t,
    function KernelMapping (line 205) | KernelMapping AddressSpace::read_local_kernel_mapping(uint8_t* addr) {
    type stat (line 223) | struct stat
    function clone_stat (line 234) | static unique_ptr<struct stat> clone_stat(
    function find_offset_of_syscall_instruction_in (line 277) | static uint32_t find_offset_of_syscall_instruction_in(SupportedArch arch,
    function remote_code_ptr (line 291) | remote_code_ptr AddressSpace::find_syscall_instruction_in_vdso(Task* t) {
    function string (line 308) | static string rr_page_file_name(SupportedArch arch, const char** fname...
    type stat (line 363) | struct stat
    function rr_page_syscall_stub_size (line 451) | static int rr_page_syscall_stub_size(SupportedArch arch) {
    function rr_page_syscall_instruction_end (line 470) | static int rr_page_syscall_instruction_end(SupportedArch arch) {
    function remote_code_ptr (line 489) | static remote_code_ptr entry_ip_from_index(SupportedArch arch, size_t ...
    function remote_code_ptr (line 493) | static remote_code_ptr exit_ip_from_index(SupportedArch arch, size_t i) {
    function remote_code_ptr (line 498) | remote_code_ptr AddressSpace::rr_page_syscall_exit_point(Traced traced,
    function remote_code_ptr (line 511) | remote_code_ptr AddressSpace::rr_page_syscall_entry_point(Traced traced,
    function SupportedArch (line 707) | SupportedArch AddressSpace::arch() const {
    function BreakpointType (line 711) | BreakpointType AddressSpace::get_breakpoint_type_for_retired_insn(
    function BreakpointType (line 717) | BreakpointType AddressSpace::get_breakpoint_type_at_addr(remote_code_p...
    function remove_range (line 776) | static void remove_range(set<MemoryRange>& ranges, const MemoryRange& ...
    function add_range (line 809) | static void add_range(set<MemoryRange>& ranges, const MemoryRange& ran...
    function KernelMapping (line 816) | KernelMapping AddressSpace::map(Task* t, remote_ptr<void> addr,
    function MemoryRange (line 1191) | static MemoryRange range_for_watchpoint(remote_ptr<void> addr,
    function DR_WATCHPOINT (line 1285) | static int DR_WATCHPOINT(int n) { return 1 << n; }
    function watchpoint_triggered (line 1287) | static bool watchpoint_triggered(uintptr_t debug_status,
    function string (line 1575) | static string strip_deleted(const string& s) {
    function string (line 1584) | string KernelMapping::fsname_strip_deleted() const {
    type HandleHeap (line 1588) | enum HandleHeap { TREAT_HEAP_AS_ANONYMOUS, RESPECT_HEAP }
    function normalized_file_names_equal (line 1590) | static bool normalized_file_names_equal(const KernelMapping& km1,
    function is_adjacent_mapping (line 1618) | static bool is_adjacent_mapping(const KernelMapping& mleft,
    function try_merge_adjacent (line 1648) | static bool try_merge_adjacent(KernelMapping* left_m,
    function dev_t (line 1660) | static dev_t normalized_device_number(const KernelMapping& m) {
    function assert_segments_match (line 1672) | static void assert_segments_match(Task* t, const KernelMapping& input_m,
    function KernelMapping (line 1763) | KernelMapping AddressSpace::vdso() const {
    function fake_syscall (line 1822) | static void __attribute__((noinline, used)) fake_syscall() {
    function try_split_unaligned_range (line 1941) | static bool try_split_unaligned_range(MemoryRange& range, size_t bytes,
    function split_range (line 1951) | static vector<MemoryRange> split_range(const MemoryRange& range) {
    function configure_watch_registers (line 1965) | static void configure_watch_registers(vector<WatchConfig>& regs,
    function assert_coalescable (line 2077) | static inline void assert_coalescable(Task* t,
    function is_coalescable (line 2088) | static bool is_coalescable(const AddressSpace::Mapping& mleft,
    type stat (line 2223) | struct stat
    function could_be_stack (line 2238) | static bool could_be_stack(const KernelMapping& km) {
    function dev_t (line 2250) | static dev_t check_device(const KernelMapping& km) {
    function MemoryRange (line 2305) | static MemoryRange adjust_range_for_stack_growth(const KernelMapping& ...
    function MemoryRange (line 2322) | static MemoryRange overlaps_excluded_range(const RecordSession& sessio...
    function is_all_memory_excluded (line 2331) | static bool is_all_memory_excluded(const RecordSession& session) {
    function MemoryRange (line 2343) | static MemoryRange choose_global_exclusion_range(const RecordSession* ...
    function MemoryRange (line 2366) | MemoryRange AddressSpace::get_global_exclusion_range(const RecordSessi...

FILE: src/AddressSpace.h
  function namespace (line 32) | namespace rr {
  function KernelMapping (line 100) | KernelMapping extend(remote_ptr<void> end) const {
  function KernelMapping (line 105) | KernelMapping set_range(remote_ptr<void> start, remote_ptr<void> end) co...
  function KernelMapping (line 109) | KernelMapping subrange(remote_ptr<void> start, remote_ptr<void> end) con...
  function KernelMapping (line 115) | KernelMapping set_prot(int prot) const {
  function KernelMapping (line 119) | KernelMapping set_fsname(const std::string& name) const {
  function fake_stat (line 161) | struct stat fake_stat() const {
  type MappingComparator (line 202) | struct MappingComparator {
  type BreakpointType (line 208) | enum BreakpointType {
  type WatchType (line 217) | enum WatchType {
  type ArmWatchType (line 225) | enum ArmWatchType {
  type ArmPrivLevel (line 232) | enum ArmPrivLevel {
  type DebugStatus (line 236) | enum DebugStatus {
  type WatchConfig (line 245) | struct WatchConfig {
  function class (line 265) | class AddressSpace : public HasTaskSet {
  function class (line 1265) | class KernelMapIterator {
  function at_end (line 1279) | bool at_end() { return !maps_file; }

FILE: src/AutoRemoteSyscalls.cc
  type rr (line 28) | namespace rr {
    type socketcall_args (line 35) | struct socketcall_args {
    function is_SIGTRAP_default_and_unblocked (line 79) | static bool is_SIGTRAP_default_and_unblocked(Task* t) {
    function is_usable_area (line 216) | static bool is_usable_area(const KernelMapping& km) {
    function ignore_signal (line 358) | static bool ignore_signal(Task* t) {
    function SupportedArch (line 504) | SupportedArch AutoRemoteSyscalls::arch() const { return t->arch(); }
    function write_socketcall_args (line 507) | static void write_socketcall_args(Task* t, remote_ptr<void> remote_mem,
    type fd_message (line 517) | struct fd_message {
      method init (line 526) | void init(remote_ptr<fd_message<Arch>> base) {
      method fd_message (line 536) | fd_message(remote_ptr<fd_message<Arch>> base) {
      method fd_message (line 539) | fd_message() {
      method remote_this (line 542) | remote_ptr<fd_message<Arch>> remote_this() {
      method remote_msg (line 545) | remote_ptr<typename Arch::msghdr> remote_msg() {
      method remote_sc_args (line 548) | remote_ptr<socketcall_args<Arch>> remote_sc_args() {
      method remote_cmsgdata (line 551) | remote_ptr<int> remote_cmsgdata() {
    function child_sendmsg (line 558) | static long child_sendmsg(AutoRemoteSyscalls& remote, int child_sock, ...
    function child_recvmsg (line 593) | static long child_recvmsg(AutoRemoteSyscalls& remote, int child_sock) {
    function maybe_receive_fds (line 662) | static vector<ScopedFd> maybe_receive_fds(ScopedFd& sock, bool blockin...
    function sendmsg_socket (line 696) | static void sendmsg_socket(ScopedFd& sock, int fd_to_send)
    function Task (line 712) | static Task* thread_group_leader_for_fds(Task* t) {
    function ScopedFd (line 721) | ScopedFd AutoRemoteSyscalls::retrieve_fd_arch(int fd) {
    function ScopedFd (line 762) | ScopedFd AutoRemoteSyscalls::retrieve_fd(int fd) {
    type stat (line 922) | struct stat

FILE: src/AutoRemoteSyscalls.h
  function namespace (line 14) | namespace rr {

FILE: src/BpfMapMonitor.h
  function namespace (line 8) | namespace rr {

FILE: src/BreakpointCondition.h
  function namespace (line 6) | namespace rr {

FILE: src/BuildidCommand.cc
  type rr (line 12) | namespace rr {
    class BuildidCommand (line 14) | class BuildidCommand : public Command {
      method BuildidCommand (line 19) | BuildidCommand(const char* name, const char* help) : Command(name, h...

FILE: src/CPUFeaturesCommand.cc
  type rr (line 10) | namespace rr {
    class CPUFeaturesCommand (line 12) | class CPUFeaturesCommand : public Command {
      method CPUFeaturesCommand (line 17) | CPUFeaturesCommand(const char* name, const char* help) : Command(nam...

FILE: src/CPUIDBugDetector.cc
  type rr (line 12) | namespace rr {
    function rcb_counts_ok (line 29) | static bool rcb_counts_ok(ReplayTask* t, uint64_t prev, uint64_t curre...

FILE: src/CPUIDBugDetector.h
  function namespace (line 8) | namespace rr {

FILE: src/CPUs.cc
  type rr (line 18) | namespace rr {
    function hybrid_cpu_arch_parse_cpus (line 20) | static bool hybrid_cpu_arch_parse_cpus(const filesystem::path& dir,
    function hybrid_cpu_arch_parse_type (line 63) | static bool hybrid_cpu_arch_parse_type(const filesystem::path& dir,
    function hybrid_cpu_arch_groups (line 88) | static vector<CPUGroup> hybrid_cpu_arch_groups() {
    function CPUs (line 119) | const CPUs& CPUs::get() {

FILE: src/CPUs.h
  function namespace (line 11) | namespace rr {

FILE: src/Command.cc
  type rr (line 18) | namespace rr {
    function Command (line 40) | Command* Command::command_for_name(const std::string& name) {
    function consume_args (line 83) | static bool consume_args(std::vector<std::string>& args, size_t count) {
    function assign_param (line 88) | static void assign_param(ParsedOption* opt, const char* s) {

FILE: src/Command.h
  function namespace (line 17) | namespace rr {

FILE: src/CompressedReader.cc
  type rr (line 19) | namespace rr {
    function read_all (line 50) | static bool read_all(const ScopedFd& fd, size_t size, void* data,
    function do_decompress (line 60) | static bool do_decompress(std::vector<uint8_t>& compressed,

FILE: src/CompressedReader.h
  function namespace (line 15) | namespace rr {

FILE: src/CompressedWriter.cc
  type rr (line 19) | namespace rr {

FILE: src/CompressedWriter.h
  function namespace (line 15) | namespace rr {

FILE: src/ContextSwitchEvent.cc
  type rr (line 21) | namespace rr {
    function sigio_handler (line 25) | static void sigio_handler(int, siginfo_t*, void*) {
    function can_use_switch_records (line 29) | static bool can_use_switch_records() {
    function ContextSwitchEventStrategy (line 114) | static ContextSwitchEventStrategy init_strategy() {
    function ContextSwitchEventStrategy (line 142) | ContextSwitchEventStrategy ContextSwitchEvent::strategy() {

FILE: src/ContextSwitchEvent.h
  function namespace (line 14) | namespace rr {

FILE: src/DebuggerExtensionCommand.cc
  type rr (line 10) | namespace rr {
    function string (line 118) | string invoke_checkpoint(GdbServer& gdb_server, Task*,
    function string (line 144) | string invoke_delete_checkpoint(GdbServer& gdb_server, Task*,
    function string (line 173) | string invoke_info_checkpoints(GdbServer& gdb_server, Task*,

FILE: src/DebuggerExtensionCommand.h
  function namespace (line 13) | namespace rr {

FILE: src/DebuggerExtensionCommandHandler.cc
  type rr (line 12) | namespace rr {
    function print_python_string_array (line 18) | static void print_python_string_array(ostream& out, const std::vector<...
    function gdb_macro_binding (line 29) | static void gdb_macro_binding(ostream& out, const DebuggerExtensionCom...
    function string (line 63) | string DebuggerExtensionCommandHandler::gdb_macros() {
    function lldb_macro_binding (line 194) | static void lldb_macro_binding(ostream& def_stream, ostream& call_stream,
    function DebuggerExtensionCommand (line 275) | DebuggerExtensionCommand* DebuggerExtensionCommandHandler::command_for...
    function string (line 296) | static string hex_escape(const string& str) {
    function string (line 312) | static string hex_unescape(const string& str) {
    function string (line 332) | string DebuggerExtensionCommandHandler::process_command(GdbServer& gdb...

FILE: src/DebuggerExtensionCommandHandler.h
  function namespace (line 10) | namespace rr {

FILE: src/DiversionSession.cc
  type rr (line 15) | namespace rr {
    function finish_emulated_syscall_with_ret (line 30) | static void finish_emulated_syscall_with_ret(Task* t, long ret) {
    function execute_syscall (line 42) | static void execute_syscall(Task* t) {
    function process_syscall_arch (line 60) | static void process_syscall_arch(Task* t, int syscallno) {
    function maybe_handle_task_exit (line 160) | static bool maybe_handle_task_exit(Task* t, TaskContext* context,

FILE: src/DiversionSession.h
  function namespace (line 9) | namespace rr {

FILE: src/DumpCommand.cc
  type rr (line 26) | namespace rr {
    class DumpCommand (line 28) | class DumpCommand : public Command {
      method DumpCommand (line 33) | DumpCommand(const char* name, const char* help) : Command(name, help...
    function parse_dump_arg (line 54) | static bool parse_dump_arg(vector<string>& args, DumpFlags& flags) {
    function dump_syscallbuf_data (line 108) | static void dump_syscallbuf_data(TraceReader& trace, FILE* out,
    function print_socket_addr (line 170) | static void print_socket_addr(FILE* out, const struct NativeArch::sock...
    function dump_socket_addrs (line 198) | static void dump_socket_addrs(FILE* out, const TraceFrame& frame) {
    function dump_task_event (line 213) | static void dump_task_event(FILE* out, const TraceTaskEvent& event) {
    function dump_events_matching (line 248) | static void dump_events_matching(TraceReader& trace, const DumpFlags& ...
    function dump_statistics (line 373) | static void dump_statistics(const TraceReader& trace, FILE* out) {
    function dump (line 381) | void dump(const string& trace_dir, const DumpFlags& flags,

FILE: src/Dwarf.cc
  type rr (line 11) | namespace rr {
    type Dwarf32 (line 13) | struct Dwarf32 {
      type CompilationUnitPreamble (line 16) | struct CompilationUnitPreamble {
    type Dwarf64 (line 20) | struct Dwarf64 {
      type CompilationUnitPreamble (line 23) | struct __attribute__((packed)) CompilationUnitPreamble {
    type Dwarf4CompilationUnitHeader (line 29) | struct  __attribute__((packed)) Dwarf4CompilationUnitHeader {
      method install_dwo_id (line 36) | void install_dwo_id(DwarfCompilationUnit* unit) const {
    type Dwarf5CompilationUnitHeader (line 41) | struct  __attribute__((packed)) Dwarf5CompilationUnitHeader {
      method install_dwo_id (line 49) | void install_dwo_id(DwarfCompilationUnit* unit) const {
    type Dwarf5SkeletonSplitCompilationUnitHeader (line 54) | struct  __attribute__((packed)) Dwarf5SkeletonSplitCompilationUnitHead...
      method install_dwo_id (line 63) | void install_dwo_id(DwarfCompilationUnit* unit) const {
    type Dwarf2LineNumberTableHeader (line 68) | struct  __attribute__((packed)) Dwarf2LineNumberTableHeader {
    type Dwarf4LineNumberTableHeader (line 86) | struct  __attribute__((packed)) Dwarf4LineNumberTableHeader {
    type Dwarf5LineNumberTableHeader (line 105) | struct  __attribute__((packed)) Dwarf5LineNumberTableHeader {
    function DwarfSpan (line 146) | DwarfSpan DwarfSpan::read_leb_ref(bool* ok) {
    function DwarfAbbrev (line 172) | DwarfAbbrev* DwarfAbbrevSet::lookup(uint64_t code) {
    function DwarfAbbrevSet (line 210) | DwarfAbbrevSet& DwarfAbbrevs::lookup(uint64_t offset) {
    function form_size (line 243) | static size_t form_size(DWForm form, size_t address_size, size_t dwarf...
    function DwarfSpan (line 297) | DwarfSpan DwarfDIE::find_attribute(DWAttr attr, DWForm* form, bool* ok...
    function decode_unsigned_literal (line 313) | static uint64_t decode_unsigned_literal(DwarfSpan span, bool* ok) {
    function decode_section_ptr (line 328) | static int64_t decode_section_ptr(DwarfSpan span, DWForm form, bool* o...
    function decode_unsigned (line 350) | static uint64_t decode_unsigned(DwarfSpan span, DWForm form, bool* ok) {
    function DwarfCompilationUnit (line 445) | DwarfCompilationUnit DwarfCompilationUnit::next(DwarfSpan* debug_info,...
    function read_dwarf2_directories (line 552) | static bool read_dwarf2_directories(DwarfSpan span, std::vector<const ...
    type FileEntryFormat (line 608) | struct FileEntryFormat {

FILE: src/Dwarf.h
  function namespace (line 14) | namespace rr {
  type DwarfSourceFile (line 213) | struct DwarfSourceFile {
  function class (line 218) | class DwarfLineNumberTable {

FILE: src/ElfReader.cc
  type rr (line 19) | namespace rr {
    class ElfReaderImplBase (line 21) | class ElfReaderImplBase {
      method ElfReaderImplBase (line 23) | ElfReaderImplBase(ElfReader& r) : r(r), ok_(false) {}
      method ok (line 34) | bool ok() { return ok_; }
    class ElfReaderImpl (line 42) | class ElfReaderImpl : public ElfReaderImplBase {
    function elf_reader_impl_arch (line 69) | unique_ptr<ElfReaderImplBase> elf_reader_impl_arch(ElfReader& r) {
    function elf_reader_impl (line 73) | unique_ptr<ElfReaderImplBase> elf_reader_impl(ElfReader& r,
    function SectionOffsets (line 167) | SectionOffsets ElfReaderImpl<Arch>::find_section_file_offsets(
    function SymbolTable (line 261) | SymbolTable ElfReaderImpl<Arch>::read_symbols(const char* symtab,
    function DynamicSection (line 320) | DynamicSection ElfReaderImpl<Arch>::read_dynamic() {
    function null_terminated (line 376) | static bool null_terminated(const char* p, size_t size, string& out) {
    function Debuglink (line 386) | Debuglink ElfReaderImpl<Arch>::read_debuglink() {
    function Debugaltlink (line 417) | Debugaltlink ElfReaderImpl<Arch>::read_debugaltlink() {
    function string (line 445) | string ElfReaderImpl<Arch>::read_buildid() {
    function string (line 499) | string ElfReaderImpl<Arch>::read_interp() {
    function ElfReaderImplBase (line 541) | ElfReaderImplBase& ElfReader::impl() {
      method ElfReaderImplBase (line 23) | ElfReaderImplBase(ElfReader& r) : r(r), ok_(false) {}
      method ok (line 34) | bool ok() { return ok_; }
    function SymbolTable (line 548) | SymbolTable ElfReader::read_symbols(const char* symtab, const char* st...
    function DynamicSection (line 552) | DynamicSection ElfReader::read_dynamic() { return impl().read_dynamic(...
    function Debuglink (line 554) | Debuglink ElfReader::read_debuglink() { return impl().read_debuglink(); }
    function Debugaltlink (line 556) | Debugaltlink ElfReader::read_debugaltlink() { return impl().read_debug...
    function SectionOffsets (line 558) | SectionOffsets ElfReader::find_section_file_offsets(const char* name) {
    function DwarfSpan (line 562) | DwarfSpan ElfReader::dwarf_section(const char* name, bool known_to_be_...
    function string (line 572) | string ElfReader::read_buildid() { return impl().read_buildid(); }
    function string (line 573) | string ElfReader::read_interp() { return impl().read_interp(); }
    type stat (line 582) | struct stat
    function ScopedFd (line 601) | ScopedFd ElfFileReader::open_debug_file(const std::string& elf_file_na...
    function SupportedArch (line 643) | SupportedArch ElfFileReader::identify_arch(ScopedFd& fd) {

FILE: src/ElfReader.h
  function namespace (line 15) | namespace rr {
  function class (line 129) | class ElfFileReader : public ElfReader {

FILE: src/EmuFs.cc
  type rr (line 29) | namespace rr {
    function string (line 101) | string EmuFile::proc_path() const {
    function make_temp_name (line 119) | std::string make_temp_name(const string& orig_path, dev_t orig_device,

FILE: src/EmuFs.h
  function namespace (line 13) | namespace rr {
  function class (line 78) | class EmuFile {
  function class (line 149) | class EmuFs {

FILE: src/Event.cc
  type rr (line 17) | namespace rr {
    function Event (line 72) | Event& Event::operator=(const Event& o) {
    function string (line 156) | string Event::str() const {

FILE: src/Event.h
  type syscallbuf_record (line 21) | struct syscallbuf_record
  function namespace (line 23) | namespace rr {
  type PatchSyscallEvent (line 113) | struct PatchSyscallEvent {
  type SchedEvent (line 132) | struct SchedEvent {
  function set_arch (line 141) | struct SyscallbufFlushEvent {
  type syscall_interruption_t (line 289) | struct syscall_interruption_t {
  function Desched (line 299) | struct Event {
  function PatchSyscallEvent (line 325) | const PatchSyscallEvent& PatchSyscall() const {
  function SchedEvent (line 334) | const SchedEvent& Sched() const {
  function SyscallbufFlushEvent (line 343) | const SyscallbufFlushEvent& SyscallbufFlush() const {
  function SignalEvent (line 352) | const SignalEvent& Signal() const {
  function SyscallEvent (line 361) | const SyscallEvent& Syscall() const {
  function Event (line 399) | static Event noop() { return Event(EV_NOOP); }
  function Event (line 400) | static Event trace_termination() { return Event(EV_TRACE_TERMINATION); }
  function Event (line 401) | static Event instruction_trap() { return Event(EV_INSTRUCTION_TRAP); }
  function Event (line 402) | static Event patch_syscall() {
  function Event (line 409) | static Event sched() {
  function Event (line 414) | static Event seccomp_trap() { return Event(EV_SECCOMP_TRAP); }
  function Event (line 415) | static Event syscallbuf_abort_commit() {
  function Event (line 418) | static Event syscallbuf_reset() { return Event(EV_SYSCALLBUF_RESET); }
  function Event (line 419) | static Event grow_map() { return Event(EV_GROW_MAP); }
  function Event (line 420) | static Event exit() { return Event(EV_EXIT); }
  function Event (line 421) | static Event sentinel() { return Event(EV_SENTINEL); }

FILE: src/ExportImportCheckpoints.cc
  type rr (line 24) | namespace rr {
    function parse_export_checkpoints (line 26) | bool parse_export_checkpoints(const string& arg, FrameTime& export_che...
    function ScopedFd (line 55) | ScopedFd bind_export_checkpoints_socket(int count, const string& socke...
    function send_all (line 84) | static void send_all(ScopedFd& sock, const void* vbuf, size_t count) {
    function recv_all (line 96) | static void recv_all(ScopedFd& sock, void* vbuf, size_t count) {
    function setup_child_fds (line 108) | static void setup_child_fds(vector<int> fds, CommandForCheckpoint& com...
    function set_title (line 125) | static void set_title(const vector<string>& args) {
    function CommandForCheckpoint (line 147) | CommandForCheckpoint export_checkpoints(ReplaySession::shr_ptr session...
    function notify_normal_exit (line 272) | void notify_normal_exit(ScopedFd& exit_notification_fd) {
    function invoke_checkpoint_command (line 279) | int invoke_checkpoint_command(const string& socket_file_name,

FILE: src/ExportImportCheckpoints.h
  function namespace (line 11) | namespace rr {

FILE: src/ExtraRegisters.cc
  type rr (line 15) | namespace rr {
    type RegData (line 50) | struct RegData {
      method RegData (line 55) | RegData(int offset = -1, int size = 0)
    function reg_in_range (line 59) | static bool reg_in_range(GdbServerRegister regno, GdbServerRegister lo...
    type RegisterDescriptor (line 81) | struct RegisterDescriptor {
      method register_offset (line 96) | int register_offset(GdbServerRegister reg) const noexcept {
      method describes_register (line 103) | bool describes_register(GdbServerRegister gdb_register) const {
    function reg_is_avx2_or_512 (line 139) | static bool reg_is_avx2_or_512(GdbServerRegister reg, RegData& out) no...
    function RegData (line 158) | static RegData xsave_register_data(SupportedArch arch, GdbServerRegist...
      method RegData (line 55) | RegData(int offset = -1, int size = 0)
    function get_full_value (line 463) | static size_t get_full_value(const ExtraRegisters& r, GdbServerRegiste...
    function string (line 478) | static string reg_to_string(const ExtraRegisters& r, GdbServerRegister...
    function print_reg (line 494) | static void print_reg(const ExtraRegisters& r, GdbServerRegister low, ...
    function print_regs (line 500) | static void print_regs(const ExtraRegisters& r, GdbServerRegister low,...
    function convert_fxsave_to_x86_fpregs (line 539) | static X86Arch::user_fpregs_struct convert_fxsave_to_x86_fpregs(
    function convert_x86_fpregs_to_fxsave (line 561) | static void convert_x86_fpregs_to_fxsave(const X86Arch::user_fpregs_st...
    function to_vector (line 578) | static vector<uint8_t> to_vector(const T& v) {
    function features_used (line 585) | static uint32_t features_used(const uint8_t* data) {
    function memcpy_fpr_regs_arch (line 592) | bool memcpy_fpr_regs_arch(std::vector<uint8_t>& dest, const uint8_t* src,
    function set_word (line 829) | static void set_word(SupportedArch arch, vector<uint8_t>& v, GdbServer...
    function compare_regs (line 884) | static void compare_regs(const ExtraRegisters& reg1,

FILE: src/ExtraRegisters.h
  function namespace (line 15) | namespace rr {

FILE: src/FdTable.cc
  type rr (line 21) | namespace rr {
    function Switchable (line 114) | Switchable FdTable::will_write(Task* t, int fd) {
    function FileMonitor (line 155) | FileMonitor* FdTable::get_monitor(int fd) {
    function syscallbuf_fd_classes (line 163) | static syscallbuf_fd_classes join_fd_classes_over_tasks(AddressSpace* ...
    function is_fd_open (line 264) | static bool is_fd_open(Task* t, int fd) {

FILE: src/FdTable.h
  function namespace (line 13) | namespace rr {

FILE: src/FileMonitor.cc
  type rr (line 16) | namespace rr {
    function is_implicit_offset_syscall_arch (line 20) | static bool is_implicit_offset_syscall_arch(int syscallno) {
    function is_write_syscall_arch (line 26) | static bool is_write_syscall_arch(int syscallno) {
    function is_implicit_offset_syscall (line 31) | static bool is_implicit_offset_syscall(SupportedArch arch, int syscall...
    function retrieve_offset_arch (line 36) | static int64_t retrieve_offset_arch(Task* t, int syscallno,
    function retrieve_offset (line 69) | static int64_t retrieve_offset(Task* t, int syscallno, const Registers...
    function file_monitor_type_name (line 94) | std::string file_monitor_type_name(FileMonitor::Type t) {

FILE: src/FileMonitor.h
  function namespace (line 17) | namespace rr {

FILE: src/FileNameCommand.cc
  type rr (line 14) | namespace rr {
    class FileNameCommand (line 16) | class FileNameCommand : public Command {
      method FileNameCommand (line 21) | FileNameCommand(const char* name, const char* help) : Command(name, ...
    function print_original_file_name (line 32) | static void print_original_file_name(const string& trace_dir,

FILE: src/Flags.cc
  type rr (line 5) | namespace rr {
    function Flags (line 7) | Flags& Flags::get_for_init() { return singleton; }

FILE: src/Flags.h
  function namespace (line 14) | namespace rr {

FILE: src/GdbInitCommand.cc
  type rr (line 10) | namespace rr {
    class GdbInitCommand (line 12) | class GdbInitCommand : public Command {
      method GdbInitCommand (line 17) | GdbInitCommand(const char* name, const char* help) : Command(name, h...

FILE: src/GdbServer.cc
  type rr (line 41) | namespace rr {
    function ExtendedTaskId (line 61) | static ExtendedTaskId extended_task_id(Task* t) {
    function get_reg (line 98) | static size_t get_reg(const Registers& regs, const ExtraRegisters& ext...
    function set_reg (line 107) | static bool set_reg(Task* target, const GdbServerRegisterValue& reg) {
    function GdbServerRegisterValue (line 133) | GdbServerRegisterValue GdbServer::get_reg(const Registers& regs,
    function matches_threadid (line 143) | static bool matches_threadid(const ExtendedTaskId& tid,
    function matches_threadid (line 149) | static bool matches_threadid(Task* t, const GdbThreadId& target) {
    function WatchType (line 153) | static WatchType watchpoint_type(GdbRequestType req) {
    function maybe_singlestep_for_event (line 177) | static void maybe_singlestep_for_event(Task* t, GdbRequest* req) {
    class GdbBreakpointCondition (line 206) | class GdbBreakpointCondition : public BreakpointCondition {
      method GdbBreakpointCondition (line 208) | GdbBreakpointCondition(const vector<vector<uint8_t>>& bytecodes) {
      method evaluate (line 213) | virtual bool evaluate(ReplayTask* t) const override {
    function breakpoint_condition (line 228) | static unique_ptr<BreakpointCondition> breakpoint_condition(
    function search_memory (line 237) | static bool search_memory(Task* t, const MemoryRange& where,
    function is_in_patch_stubs (line 268) | static bool is_in_patch_stubs(Task* t, remote_code_ptr ip) {
    function thread_info (line 294) | static vector<GdbServerConnection::ThreadInfo> thread_info(const Sessi...
    function any_action_targets_match (line 850) | static bool any_action_targets_match(const ExtendedTaskId& thread,
    function Task (line 857) | static Task* find_first_task_matching_target(
    function is_last_thread_exit (line 978) | static bool is_last_thread_exit(const BreakStatus& break_status) {
    function Task (line 984) | static Task* is_in_exec(ReplayTimeline* timeline) {
    function RunCommand (line 1087) | static RunCommand compute_run_command_from_actions(Task* t,
    type AllowedTasks (line 1107) | struct AllowedTasks {
    function RunCommand (line 1111) | static RunCommand compute_run_command_for_reverse_exec(
    function GdbRequest (line 1147) | GdbRequest GdbServer::divert(ReplaySession& replay) {
    function GdbRequest (line 1237) | GdbRequest GdbServer::process_debugger_requests(ReportState state) {
    function ReplayTask (line 1391) | ReplayTask* GdbServer::require_timeline_current_task() {
    function target_event_reached (line 1553) | static bool target_event_reached(const ReplayTimeline& timeline,
    function at_target (line 1564) | static bool at_target(ReplayTimeline& timeline,
    function FrameTime (line 1666) | static FrameTime compute_time_from_ticks(ReplayTimeline& timeline, Tic...
    function ScopedFd (line 1875) | static ScopedFd generate_fake_proc_maps(Task* t) {
    function is_ld_mapping (line 1944) | static bool is_ld_mapping(string map_name) {
    function is_likely_interp (line 1952) | static bool is_likely_interp(string fsname) {
    function base_addr_from_rendezvous (line 1961) | static remote_ptr<void> base_addr_from_rendezvous(Task* t, string fname)
    function remove_trailing_guard_pages (line 2102) | static void remove_trailing_guard_pages(ReplaySession::MemoryRanges& r...
    function coalesce_free_memory (line 2173) | static void coalesce_free_memory(ReplaySession::MemoryRanges& ranges,

FILE: src/GdbServer.h
  function namespace (line 23) | namespace rr {
  type DebuggerMemRegion (line 303) | struct DebuggerMemRegion {
  type DebuggerMem (line 307) | struct DebuggerMem {
  type SavedRegisters (line 317) | struct SavedRegisters {

FILE: src/GdbServerConnection.cc
  type rr (line 39) | namespace rr {
    function request_needs_immediate_response (line 51) | static bool request_needs_immediate_response(const GdbRequest* req) {
    function get_cpu_features (line 80) | static uint32_t get_cpu_features(SupportedArch arch) {
    function poll_socket (line 140) | static bool poll_socket(const ScopedFd& sock_fd, short events, int tim...
    function poll_incoming (line 153) | static bool poll_incoming(const ScopedFd& sock_fd, int timeoutMs) {
    function poll_outgoing (line 157) | static void poll_outgoing(const ScopedFd& sock_fd, int timeoutMs) {
    function string (line 271) | static string string_to_hex(const string& s) {
    function parser_assert (line 303) | static void parser_assert(bool cond) {
    function string (line 311) | static string decode_ascii_encoded_hex_str(const char* encoded) {
    function read_hex_data (line 412) | static void read_hex_data(const char* payload, const char* payload_end,
    function read_binary_data (line 426) | static void read_binary_data(const uint8_t* payload, const uint8_t* pa...
    function GdbThreadId (line 444) | static GdbThreadId parse_threadid(const char* str, char** endptr) {
    function string (line 494) | static string read_target_desc(const char* file_name) {
    function print_reg_value (line 615) | static size_t print_reg_value(const GdbServerRegisterValue& reg, char*...
    function read_reg_value (line 636) | static void read_reg_value(char** strp, GdbServerRegisterValue* reg) {
    function gdb_open_flags_to_system_flags (line 1066) | static int gdb_open_flags_to_system_flags(int64_t flags) {
    function string (line 1317) | static string to_string(const vector<uint8_t>& bytes, size_t max_len) {
    function GdbRequest (line 1607) | GdbRequest GdbServerConnection::get_request() {
    function to_gdb_signum (line 1680) | static int to_gdb_signum(int sig) {
    function string (line 1857) | string GdbServerConnection::format_thread_id(ExtendedTaskId thread) {

FILE: src/GdbServerConnection.h
  function namespace (line 25) | namespace rr {
  type ExtendedTaskId (line 63) | struct ExtendedTaskId {
  type GdbServerRegisterValue (line 85) | struct GdbServerRegisterValue {
  type GdbRequestType (line 99) | enum GdbRequestType {
  type GdbRestartType (line 195) | enum GdbRestartType {
  type GdbActionType (line 202) | enum GdbActionType { ACTION_CONTINUE, ACTION_STEP }
  type GdbContAction (line 204) | struct GdbContAction {
  type GdbRequest (line 218) | struct GdbRequest {
  type Mem (line 267) | struct Mem {
  type Watch (line 274) | struct Watch {
  type Restart (line 280) | struct Restart {
  type Cont (line 285) | struct Cont {
  type RRCmd (line 289) | struct RRCmd {
  type Tls (line 294) | struct Tls {
  type Symbol (line 298) | struct Symbol {
  type FileSetfs (line 303) | struct FileSetfs {
  type FileOpen (line 306) | struct FileOpen {
  type FilePread (line 312) | struct FilePread {
  type FileClose (line 317) | struct FileClose {
  type MemAlloc (line 320) | struct MemAlloc {
  type MemFree (line 324) | struct MemFree {
  type RestoreRegisterState (line 327) | struct RestoreRegisterState {
  function Mem (line 335) | const Mem& mem() const {
  function Watch (line 343) | const Watch& watch() const {
  function GdbServerRegisterValue (line 351) | const GdbServerRegisterValue& reg() const {
  function Restart (line 359) | const Restart& restart() const {
  function Cont (line 367) | const Cont& cont() const {
  function RRCmd (line 375) | const RRCmd& rr_cmd() const {
  function Tls (line 383) | const Tls& tls() const {
  function Symbol (line 391) | const Symbol& sym() const {
  function FileSetfs (line 399) | const FileSetfs& file_setfs() const {
  function FileOpen (line 407) | const FileOpen& file_open() const {
  function FilePread (line 415) | const FilePread& file_pread() const {
  function FileClose (line 423) | const FileClose& file_close() const {
  function MemAlloc (line 431) | const MemAlloc& mem_alloc() const {
  function MemFree (line 439) | const MemFree& mem_free() const {
  function RestoreRegisterState (line 447) | const RestoreRegisterState& restore_register_state() const {
  function class (line 463) | class GdbServerConnection {

FILE: src/GdbServerExpression.cc
  type rr (line 11) | namespace rr {
    type Opcode (line 17) | enum Opcode {
    type ExpressionState (line 71) | struct ExpressionState {
      method ExpressionState (line 74) | ExpressionState(const vector<uint8_t>& bytecode)
      method set_error (line 77) | void set_error() { error = true; }
      method Value (line 81) | Value pop() {
      type BinaryOperands (line 90) | struct BinaryOperands {
        method BinaryOperands (line 91) | BinaryOperands(int64_t a = 0, int64_t b = 0) : a(a), b(b) {}
      method BinaryOperands (line 95) | BinaryOperands pop_a_b() {
        method BinaryOperands (line 91) | BinaryOperands(int64_t a = 0, int64_t b = 0) : a(a), b(b) {}
      method nonzero (line 99) | int64_t nonzero(int64_t v) {
      method pop_a (line 106) | int64_t pop_a() { return pop().i; }
      method push (line 107) | void push(int64_t i) { stack.push_back(Value(i)); }
      method T (line 108) | T fetch() {
      method load (line 120) | void load(Task* t) {
      method pick (line 134) | void pick(size_t offset) {
      method step (line 142) | void step(ReplayTask* t) {
    function count_variants (line 306) | static int count_variants(int bits) {
    function T (line 321) | static T fetch(const uint8_t* data, size_t size, size_t pc) {

FILE: src/GdbServerExpression.h
  function namespace (line 11) | namespace rr {

FILE: src/GdbServerRegister.h
  function namespace (line 6) | namespace rr {

FILE: src/HasTaskSet.cc
  type rr (line 8) | namespace rr {
    function Task (line 20) | Task* HasTaskSet::first_running_task() const {
    function Task (line 29) | Task* HasTaskSet::find_other_thread_group(Task* t) const {

FILE: src/HasTaskSet.h
  function namespace (line 8) | namespace rr {

FILE: src/HelpCommand.cc
  type rr (line 8) | namespace rr {
    class HelpCommand (line 10) | class HelpCommand : public Command {
      method HelpCommand (line 15) | HelpCommand(const char* name, const char* help) : Command(name, help...

FILE: src/LldbInitCommand.cc
  type rr (line 10) | namespace rr {
    class LldbInitCommand (line 12) | class LldbInitCommand : public Command {
      method LldbInitCommand (line 17) | LldbInitCommand(const char* name, const char* help) : Command(name, ...

FILE: src/LsCommand.cc
  type rr (line 20) | namespace rr {
    class LsCommand (line 22) | class LsCommand : public Command {
      method LsCommand (line 27) | LsCommand(const char* name, const char* help) : Command(name, help) {}
    type LsFlags (line 39) | struct LsFlags {
      method LsFlags (line 43) | LsFlags() : reverse(false), full_listing(false), sort_by_time(false) {}
    function parse_ls_arg (line 46) | static bool parse_ls_arg(vector<string>& args, LsFlags& flags) {
    type TraceInfo (line 76) | struct TraceInfo {
      type timespec (line 78) | struct timespec
      method TraceInfo (line 81) | TraceInfo(string in_name) : name(in_name) {}
    function compare_by_name (line 84) | static bool compare_by_name(const TraceInfo& at, const TraceInfo& bt) {
    function get_folder_size (line 90) | static bool get_folder_size(string dir_name, string& size_str) {
    function string (line 134) | static string get_exec_path(TraceReader& reader) {
    function ls (line 151) | static int ls(const string& traces_dir, const LsFlags& flags, FILE* ou...

FILE: src/MagicSaveDataMonitor.cc
  type rr (line 17) | namespace rr {
    function string (line 19) | static string dump_path_data(Task* t, FrameTime global_time, const cha...
    function notify_save_data_error (line 28) | static void notify_save_data_error(ReplayTask* t, remote_ptr<void> addr,

FILE: src/MagicSaveDataMonitor.h
  function namespace (line 8) | namespace rr {

FILE: src/MemoryRange.h
  function namespace (line 10) | namespace rr {

FILE: src/MmappedFileMonitor.cc
  type rr (line 12) | namespace rr {

FILE: src/MmappedFileMonitor.h
  function namespace (line 11) | namespace rr {

FILE: src/MonitoredSharedMemory.cc
  type rr (line 16) | namespace rr {

FILE: src/MonitoredSharedMemory.h
  function namespace (line 10) | namespace rr {

FILE: src/Monkeypatcher.cc
  type rr (line 26) | namespace rr {
    function write_and_record_bytes (line 30) | static void write_and_record_bytes(RecordTask* t, remote_ptr<void> chi...
    function write_and_record_bytes (line 39) | static void write_and_record_bytes(RecordTask* t, remote_ptr<void> chi...
    function write_and_record_mem (line 45) | static void write_and_record_mem(RecordTask* t, remote_ptr<T> child_addr,
    function setup_library_path_arch (line 72) | static void setup_library_path_arch(RecordTask* t, const char* env_var,
    function setup_preload_library_path (line 125) | static void setup_preload_library_path(RecordTask* t) {
    function setup_audit_library_path (line 132) | static void setup_audit_library_path(RecordTask* t) {
    type syscall_patch_hook (line 143) | struct syscall_patch_hook
    function allocate_extended_jump_x86ish (line 217) | static remote_ptr<uint8_t> allocate_extended_jump_x86ish(
    function encode_immediate_aarch64 (line 285) | static void encode_immediate_aarch64(std::vector<uint32_t> &buff,
    function encode_extended_jump_aarch64 (line 329) | static uint32_t encode_extended_jump_aarch64(std::vector<uint32_t> &buff,
    function allocate_extended_jump_aarch64 (line 367) | static remote_ptr<uint8_t> allocate_extended_jump_aarch64(
    function remote_code_ptr (line 478) | remote_code_ptr Monkeypatcher::get_jump_stub_exit_breakpoint(remote_co...
    function hook_can_ignore_interfering_branches (line 496) | static bool hook_can_ignore_interfering_branches(const syscall_patch_h...
    function patch_syscall_with_hook_x86ish (line 527) | static bool patch_syscall_with_hook_x86ish(Monkeypatcher& patcher,
    function patch_syscall_with_hook (line 702) | static bool patch_syscall_with_hook(Monkeypatcher& patcher, RecordTask...
    function unpatch_extended_jumps (line 782) | static void unpatch_extended_jumps(Monkeypatcher& patcher,
    function string (line 896) | static string bytes_to_string(uint8_t* bytes, size_t size) {
    function safe_for_syscall_patching (line 907) | static bool safe_for_syscall_patching(remote_code_ptr start,
    function jump_patch_size (line 969) | static uint64_t jump_patch_size(SupportedArch arch)
    function patch_matches (line 981) | static bool patch_matches(const syscall_patch_hook& hook, const uint8_...
    function syscall_patch_hook (line 989) | const syscall_patch_hook* Monkeypatcher::find_syscall_hook(RecordTask* t,
    function resolve_address (line 1498) | static remote_ptr<void> resolve_address(ElfReader& reader, uintptr_t e...
    function set_and_record_bytes (line 1533) | static void set_and_record_bytes(RecordTask* t, ElfReader& reader,
    function is_aarch64_bti (line 1629) | static bool is_aarch64_bti(uint32_t instruction) {
    function is_aarch64_adrp (line 1639) | static bool is_aarch64_adrp(uint32_t instruction, remote_ptr<void> pc,...
    function is_aarch64_ldrb (line 1650) | static bool is_aarch64_ldrb(uint32_t instruction, uint32_t* offset) {
    function file_may_need_instrumentation (line 1701) | static bool file_may_need_instrumentation(const AddressSpace::Mapping&...

FILE: src/Monkeypatcher.h
  function namespace (line 15) | namespace rr {

FILE: src/MvCommand.cc
  type rr (line 15) | namespace rr {
    class MvCommand (line 17) | class MvCommand : public Command {
      method MvCommand (line 22) | MvCommand(const char* name, const char* help) : Command(name, help) {}
    function mv (line 29) | static int mv(const string& from, const string& to, FILE* out) {

FILE: src/NonvirtualPerfCounterMonitor.h
  function namespace (line 8) | namespace rr {

FILE: src/ODirectFileMonitor.h
  function namespace (line 9) | namespace rr {

FILE: src/PackCommand.cc
  type rr (line 35) | namespace rr {
    class PackCommand (line 43) | class PackCommand : public Command {
      method PackCommand (line 48) | PackCommand(const char* name, const char* help) : Command(name, help...
    type PackFlags (line 71) | struct PackFlags {
      method PackFlags (line 77) | PackFlags()
    type FileHash (line 81) | struct FileHash {
    function FileHash (line 91) | static FileHash allocate_unique_file_hash() {
    type FsExtentsHash (line 100) | struct FsExtentsHash {
    type PackDir (line 108) | struct PackDir {
      method PackDir (line 111) | PackDir(string dir) : dir(dir) {}
    function name_comparator (line 114) | static bool name_comparator(const TraceReader::MappedData& d1,
    function names_equal (line 119) | static bool names_equal(const TraceReader::MappedData& d1,
    function decreasing_size_comparator (line 124) | static bool decreasing_size_comparator(const TraceReader::MappedData* d1,
    function is_hardlink (line 129) | static bool is_hardlink(const string& file_name) {
    function gather_files (line 175) | static vector<TraceReader::MappedData> gather_files(const string& trac...
    function get_file_extents_hash (line 207) | static bool get_file_extents_hash(const string& file_name, FsExtentsHa...
    function gather_file_info (line 318) | static map<string, FileHash> gather_file_info(const string& trace_dir) {
    function is_in_trace_dir (line 409) | static bool is_in_trace_dir(const string& file_name, const string& tra...
    function string (line 428) | static string copy_into_trace(const string& file_name, const string& t...
    function string (line 486) | static string symlink_into_trace(const string& file_name,
    function compute_canonical_symlink_map (line 516) | static map<string, string> compute_canonical_symlink_map(
    function compute_canonical_mmapped_files (line 546) | static map<string, string> compute_canonical_mmapped_files(
    function rewrite_mmaps (line 601) | static void rewrite_mmaps(const map<string, string>& file_map,
    function delete_unnecessary_files (line 649) | static void delete_unnecessary_files(const map<string, string>& file_map,
    function pack (line 682) | static int pack(const vector<string>& trace_dirs, const PackFlags& fla...
    function parse_pack_arg (line 719) | static bool parse_pack_arg(vector<string>& args, PackFlags& flags) {

FILE: src/PerfCounterBuffers.cc
  type rr (line 12) | namespace rr {
    type perf_event_mmap_page (line 43) | struct perf_event_mmap_page
    type perf_event_header (line 85) | struct perf_event_header
    type perf_event_header (line 86) | struct perf_event_header
    type perf_event_header (line 96) | struct perf_event_header

FILE: src/PerfCounterBuffers.h
  function namespace (line 14) | namespace rr {

FILE: src/PerfCounters.cc
  type rr (line 43) | namespace rr {
    type perf_event_attrs (line 51) | struct perf_event_attrs {
    type CpuMicroarch (line 96) | enum CpuMicroarch {
    type PmuConfig (line 187) | struct PmuConfig {
    function string (line 310) | static string lowercase(const string& s) {
    function get_pmu_index (line 319) | static int get_pmu_index(BindCPU cpu_binding) {
    function init_perf_event_attr (line 343) | static void init_perf_event_attr(struct perf_event_attr* attr,
    function read_counter (line 358) | static int64_t read_counter(ScopedFd& fd) {
    function ScopedFd (line 366) | static ScopedFd start_counter(pid_t tid, int group_fd,
    function check_for_ioc_period_bug (line 439) | static uint32_t check_for_ioc_period_bug(perf_event_attrs &perf_attr) {
    function do_branches (line 470) | static void do_branches() {
    type CPUInfo (line 481) | struct CPUInfo {
    function check_working_counters (line 498) | static void check_working_counters(perf_event_attrs &perf_attr, int pm...
    function check_for_bugs (line 546) | static uint32_t check_for_bugs(perf_event_attrs &perf_attr, int pmu_in...
    function get_cpus_info (line 556) | static vector<CPUInfo> get_cpus_info() {
    function get_pmu_microarchs (line 577) | static std::vector<PmuConfig> get_pmu_microarchs() {
    function init_attributes (line 609) | static void init_attributes() {
    function check_pmu (line 688) | static void check_pmu(int pmu_index) {
    function TicksSemantics (line 740) | TicksSemantics PerfCounters::default_ticks_semantics() {
    function make_counter_async (line 779) | static void make_counter_async(ScopedFd& fd, int signal) {
    function infallible_perf_event_reset_if_open (line 786) | static void infallible_perf_event_reset_if_open(ScopedFd& fd) {
    function infallible_perf_event_enable_if_open (line 794) | static void infallible_perf_event_enable_if_open(ScopedFd& fd) {
    function infallible_perf_event_disable_if_open (line 802) | static void infallible_perf_event_disable_if_open(ScopedFd& fd) {
    function pt_event_type (line 810) | static uint32_t pt_event_type() {
    type PTCopyThreadState (line 832) | struct PTCopyThreadState {
      method PTCopyThreadState (line 836) | PTCopyThreadState() {
      method start_copying (line 842) | void start_copying(PerfCounters::PTState* state) {
      method stop_copying (line 847) | void stop_copying(PerfCounters::PTState* state) {
      method thread_run (line 858) | void thread_run() {
    type perf_event_attr (line 897) | struct perf_event_attr
    type perf_event_header (line 916) | struct perf_event_header
    function PTData (line 948) | PTData PerfCounters::extract_intel_pt_data() {
    type perf_event_attr (line 982) | struct perf_event_attr
    type perf_event_attr (line 983) | struct perf_event_attr
    type f_owner_ex (line 1001) | struct f_owner_ex
    function Ticks (line 1070) | Ticks PerfCounters::stop(Task* t, Error* error) {
    function Ticks (line 1100) | Ticks PerfCounters::ticks_for_unconditional_indirect_branch(Task*) {
    function Ticks (line 1105) | Ticks PerfCounters::ticks_for_unconditional_direct_branch(Task*) {
    function Ticks (line 1110) | Ticks PerfCounters::ticks_for_direct_call(Task*) {
    function Ticks (line 1115) | Ticks PerfCounters::read_ticks(Task* t, Error* error) {
    class BpfAccelerator (line 1209) | class BpfAccelerator {
      method skips (line 1215) | uint64_t skips() const {
      method BpfAccelerator (line 1220) | BpfAccelerator(struct bpf_object* bpf_obj, int bpf_prog_fd,
      type perf_event_attr (line 1234) | struct perf_event_attr
      type bpf_object (line 1235) | struct bpf_object
    type bpf_object (line 1255) | struct bpf_object
    type bpf_program (line 1270) | struct bpf_program
    type user_regs_struct (line 1281) | struct user_regs_struct
    function ScopedFd (line 1324) | ScopedFd BpfAccelerator::create_counter(pid_t tid) {
    type user_regs_struct (line 1351) | struct user_regs_struct

FILE: src/PerfCounters.h
  function namespace (line 24) | namespace rr {

FILE: src/PerfCounters_aarch64.h
  type CPUID (line 4) | struct CPUID {
  function operator (line 18) | bool operator!=(const CPUID &other) const
  function CpuMicroarch (line 34) | static CpuMicroarch compute_cpu_microarch(const CPUID &cpuid) {
  function set_cpuid (line 113) | static void set_cpuid(std::vector<CPUID> &cpuids, unsigned long cpuidx, ...
  function get_cpuinfo_sysfs (line 129) | static inline void get_cpuinfo_sysfs(std::vector<CPUID> &res)
  function try_read_procfs_line (line 172) | bool try_read_procfs_line(const std::string &line,
  function get_cpuinfo_procfs (line 214) | static inline void get_cpuinfo_procfs(std::vector<CPUID> &res)
  function vector (line 259) | static vector<CPUInfo> compute_cpus_info() {
  function pmu_index (line 409) | int pmu_index) {

FILE: src/PerfCounters_x86.h
  function CpuMicroarch (line 28) | static CpuMicroarch compute_cpu_microarch() {
  function vector (line 188) | static vector<CPUInfo> compute_cpus_info() {
  function check_for_kvm_in_txcp_bug (line 260) | static void check_for_kvm_in_txcp_bug(const perf_event_attrs &perf_attr) {
  function check_for_xen_pmi_bug (line 281) | static void check_for_xen_pmi_bug(const perf_event_attrs &perf_attr) {
  function check_for_zen_speclockmap (line 426) | static void check_for_zen_speclockmap() {
  function check_for_freeze_on_smi (line 460) | static void check_for_freeze_on_smi() {
  function check_for_arch_bugs (line 497) | static void check_for_arch_bugs(perf_event_attrs &perf_attr) {
  function post_init_pmu_uarchs (line 511) | static void post_init_pmu_uarchs(std::vector<PmuConfig> &) {
  function always_recreate_counters (line 515) | static bool always_recreate_counters(const perf_event_attrs &perf_attr) {
  function arch_check_restricted_counter (line 522) | static void arch_check_restricted_counter() {
  type perf_event_attr (line 537) | struct perf_event_attr

FILE: src/PidFdMonitor.cc
  type rr (line 7) | namespace rr {
    function PidFdMonitor (line 9) | PidFdMonitor*

FILE: src/PidFdMonitor.h
  type perf_event_attr (line 10) | struct perf_event_attr
  function namespace (line 12) | namespace rr {

FILE: src/PreserveFileMonitor.h
  function namespace (line 8) | namespace rr {

FILE: src/ProcFdDirMonitor.cc
  type rr (line 15) | namespace rr {
    function filter_dirent_structs (line 31) | static int filter_dirent_structs(RecordTask* t, uint8_t* buf, size_t s...
    function filter_dirents_arch (line 61) | static void filter_dirents_arch(RecordTask* t) {
    function filter_dirents (line 113) | static void filter_dirents(RecordTask* t) {

FILE: src/ProcFdDirMonitor.h
  function namespace (line 9) | namespace rr {

FILE: src/ProcMemMonitor.cc
  type rr (line 15) | namespace rr {

FILE: src/ProcMemMonitor.h
  function namespace (line 9) | namespace rr {

FILE: src/ProcStatMonitor.cc
  type rr (line 19) | namespace rr {
    function filter_proc_stat (line 22) | static void filter_proc_stat(string& data, const cpu_set_t& active) {

FILE: src/ProcStatMonitor.h
  function namespace (line 8) | namespace rr {

FILE: src/ProcessorTraceDecoder.cc
  type rr (line 18) | namespace rr {
    function string (line 20) | static string pt_err(int status) {
    function read_mem_callback (line 32) | int read_mem_callback(uint8_t *buffer, size_t size,
    function string (line 153) | string ProcessorTraceDecoder::internal_error_context_string() {

FILE: src/ProcessorTraceDecoder.h
  type pt_insn_decoder (line 14) | struct pt_insn_decoder
  function namespace (line 16) | namespace rr {

FILE: src/PsCommand.cc
  type rr (line 13) | namespace rr {
    class PsCommand (line 15) | class PsCommand : public Command {
      method PsCommand (line 20) | PsCommand(const char* name, const char* help) : Command(name, help) {}
    function print_exec_cmd_line (line 27) | static void print_exec_cmd_line(const TraceTaskEvent& event, FILE* out) {
    function update_tid_to_pid_map (line 36) | static void update_tid_to_pid_map(map<pid_t, pid_t>& tid_to_pid,
    function count_tids_for_pid (line 51) | static int count_tids_for_pid(const std::map<pid_t, pid_t> tid_to_pid,
    function find_cmd_line (line 62) | static ssize_t find_cmd_line(pid_t pid, const vector<TraceTaskEvent>& ...
    function string (line 80) | string find_exit_code(pid_t pid, const vector<TraceTaskEvent>& events,
    function ps (line 103) | static int ps(const string& trace_dir, FILE* out) {

FILE: src/RRPageMonitor.h
  function namespace (line 9) | namespace rr {

FILE: src/RecordCommand.cc
  type rr (line 28) | namespace rr {
    type RecordFlags (line 114) | struct RecordFlags {
      method RecordFlags (line 202) | RecordFlags()
    function parse_signal_name (line 230) | static void parse_signal_name(ParsedOption& opt) {
    function parse_feature_bits (line 249) | static vector<uint32_t> parse_feature_bits(ParsedOption& opt) {
    function parse_record_arg (line 264) | static bool parse_record_arg(vector<string>& args, RecordFlags& flags) {
    function handle_SIGTERM (line 564) | static void handle_SIGTERM(__attribute__((unused)) int sig) {
    function handle_SIGSEGV (line 589) | static void handle_SIGSEGV(__attribute__((unused)) int sig) {
    function install_signal_handlers (line 594) | static void install_signal_handlers(void) {
    function setup_session_from_flags (line 614) | static void setup_session_from_flags(RecordSession& session,
    function force_close_record_session (line 644) | void force_close_record_session() {
    function copy_preload_sources_to_trace (line 650) | static void copy_preload_sources_to_trace(const string& trace_dir) {
    function save_rr_git_revision (line 681) | static void save_rr_git_revision(const string& trace_dir) {
    function WaitStatus (line 704) | static WaitStatus record(const vector<string>& args, const RecordFlags...
    function exec_child (line 784) | static void exec_child(vector<string>& args) {
    function reset_uid_sudo (line 802) | static void reset_uid_sudo() {
    function ScopedFd (line 836) | static ScopedFd open_controlling_terminal_if_foreground_process_group_...
    function detach_teleport (line 849) | static void detach_teleport() {
    type sigaction (line 881) | struct sigaction
    type sigaction (line 882) | struct sigaction

FILE: src/RecordCommand.h
  function namespace (line 8) | namespace rr {

FILE: src/RecordSession.cc
  type rr (line 34) | namespace rr {
    function mask_low_bit (line 45) | static remote_ptr<T> mask_low_bit(remote_ptr<T> p) {
    function record_robust_futex_change (line 50) | static void record_robust_futex_change(
    function record_robust_futex_changes_arch (line 83) | static void record_robust_futex_changes_arch(RecordTask* t) {
    function record_robust_futex_changes (line 112) | static void record_robust_futex_changes(RecordTask* t) {
    function looks_like_syscall_entry (line 116) | static bool looks_like_syscall_entry(RecordTask* t) {
    function handle_ptrace_exit_event (line 153) | static bool handle_ptrace_exit_event(RecordTask* t) {
    function note_entering_syscall (line 308) | static void note_entering_syscall(RecordTask* t) {
    function is_in_vsyscall (line 340) | static bool is_in_vsyscall(remote_code_ptr ip)
    function is_in_vsyscall (line 348) | static bool is_in_vsyscall(remote_code_ptr)
    function seccomp_trap_done (line 494) | static void seccomp_trap_done(RecordTask* t) {
    function debug_exec_state (line 814) | static void debug_exec_state(const char* msg, RecordTask* t) {
    function is_ptrace_any_singlestep_arch (line 819) | static bool is_ptrace_any_singlestep_arch(int command) {
    function is_ptrace_any_singlestep (line 824) | static bool is_ptrace_any_singlestep(SupportedArch arch, int command)
    function advance_to_disarm_desched_syscall (line 941) | static void advance_to_disarm_desched_syscall(RecordTask* t) {
    function retry_syscall_patch (line 1020) | static void retry_syscall_patch(RecordTask* t, remote_code_ptr orig_sy...
    function syscall_not_restarted (line 1033) | static void syscall_not_restarted(RecordTask* t) {
    function maybe_restart_syscall (line 1056) | static bool maybe_restart_syscall(RecordTask* t) {
    function maybe_discard_syscall_interruption (line 1079) | static void maybe_discard_syscall_interruption(RecordTask* t, intptr_t...
    function copy_syscall_arg_regs (line 1107) | static void copy_syscall_arg_regs(Registers* to, const Registers& from) {
    function maybe_trigger_emulated_ptrace_syscall_exit_stop (line 1116) | static void maybe_trigger_emulated_ptrace_syscall_exit_stop(RecordTask...
    function save_interrupted_syscall_ret_in_syscallbuf (line 1127) | static void save_interrupted_syscall_ret_in_syscallbuf(RecordTask* t,
    function is_in_privileged_syscall (line 1138) | static bool is_in_privileged_syscall(RecordTask* t) {
    function RecordTask (line 1421) | RecordTask* RecordSession::revive_task_for_exec(pid_t rec_tid) {
    function setup_sigframe_siginfo_arch (line 1460) | static void setup_sigframe_siginfo_arch(RecordTask* t,
    function setup_sigframe_siginfo (line 1484) | static void setup_sigframe_siginfo(RecordTask* t, const siginfo_t& sig...
    function preinject_signal (line 1491) | static bool preinject_signal(RecordTask* t) {
    function maybe_grow_stack_for_sigframe (line 1536) | static void maybe_grow_stack_for_sigframe(RecordTask* t) {
    function inject_handled_signal (line 1582) | static bool inject_handled_signal(RecordTask* t) {
    function is_ptrace_any_sysemu_arch (line 2017) | static bool is_ptrace_any_sysemu_arch(int command) {
    function is_ptrace_any_sysemu (line 2023) | static bool is_ptrace_any_sysemu(SupportedArch arch, int command)
    function inject_ld_helper_library (line 2213) | static void inject_ld_helper_library(vector<string>& env,
    function strip_outer_ld_preload (line 2244) | void strip_outer_ld_preload(vector<string>& env) {
    type ExeInfo (line 2287) | struct ExeInfo {
      method ExeInfo (line 2288) | ExeInfo() : arch(NativeArch::arch()) {}
      method setup_asan_memory_ranges (line 2296) | void setup_asan_memory_ranges() {
      method setup_tsan_memory_ranges (line 2304) | void setup_tsan_memory_ranges() {
      method check_sanitizer_arch (line 2313) | bool check_sanitizer_arch() {
    function ExeInfo (line 2326) | static ExeInfo read_exe_info(const string& exe_file) {
      method ExeInfo (line 2288) | ExeInfo() : arch(NativeArch::arch()) {}
      method setup_asan_memory_ranges (line 2296) | void setup_asan_memory_ranges() {
      method setup_tsan_memory_ranges (line 2304) | void setup_tsan_memory_ranges() {
      method check_sanitizer_arch (line 2313) | bool check_sanitizer_arch() {
    function string (line 2361) | static string lookup_by_path(const string& name) {
    type stat (line 2436) | struct stat
    function Task (line 2801) | Task* RecordSession::new_task(pid_t tid, pid_t, uint32_t serial,
    function RecordTask (line 2811) | RecordTask* RecordSession::find_task(pid_t rec_tid) const {
    function RecordTask (line 2815) | RecordTask* RecordSession::find_task(const TaskUid& tuid) const {
    function RecordTask (line 2819) | RecordTask* RecordSession::find_detached_proxy_task(pid_t proxy_tid) c...

FILE: src/RecordSession.h
  function namespace (line 16) | namespace rr {

FILE: src/RecordTask.cc
  type rr (line 28) | namespace rr {
    type Sighandler (line 35) | struct Sighandler {
      method Sighandler (line 36) | Sighandler() : resethand(false), takes_siginfo(false) {}
      method init_arch (line 39) | void init_arch(const typename Arch::kernel_sigaction& ksa) {
      method reset_arch (line 47) | void reset_arch() {
      method SignalDisposition (line 54) | SignalDisposition disposition() const {
      method remote_code_ptr (line 67) | remote_code_ptr get_user_handler() const {
    function reset_handler (line 80) | static void reset_handler(Sighandler* handler, SupportedArch arch) {
    type Sighandlers (line 84) | struct Sighandlers {
      method shr_ptr (line 87) | shr_ptr clone() const {
      method Sighandler (line 98) | Sighandler& get(int sig) {
      method Sighandler (line 102) | const Sighandler& get(int sig) const {
      method init_from_current_process (line 107) | void init_from_current_process() {
      method reset_user_handlers (line 134) | void reset_user_handlers(SupportedArch arch) {
      method assert_valid (line 146) | void assert_valid(int sig) const {
      method shr_ptr (line 150) | static shr_ptr create() { return shr_ptr(new Sighandlers()); }
      method Sighandlers (line 155) | Sighandlers() {}
    function RecordSession (line 309) | RecordSession& RecordTask::session() const {
    function TraceWriter (line 313) | TraceWriter& RecordTask::trace_writer() const {
    function Task (line 317) | Task* RecordTask::clone(CloneReason reason, int flags, remote_ptr<void...
    function do_preload_init_arch (line 397) | static void do_preload_init_arch(RecordTask* t) {
    function do_preload_init (line 450) | static void do_preload_init(RecordTask* t) {
    function find_free_file_descriptor (line 463) | static int find_free_file_descriptor(RecordTask* t) {
    function is_synthetic_SIGCHLD (line 994) | static bool is_synthetic_SIGCHLD(const siginfo_t& si) {
    function siginfo_t (line 1097) | siginfo_t& RecordTask::get_saved_ptrace_siginfo() {
    function siginfo_t (line 1112) | siginfo_t RecordTask::take_ptrace_signal_siginfo(int sig) {
    function pid_t (line 1127) | static pid_t get_ppid(pid_t pid) {
    function remote_code_ptr (line 1221) | remote_code_ptr RecordTask::get_signal_user_handler(int sig) const {
    function is_unstoppable_signal (line 1233) | static bool is_unstoppable_signal(int sig) {
    function SignalDisposition (line 1276) | SignalDisposition RecordTask::sig_disposition(int sig) const {
    function SignalResolvedDisposition (line 1280) | SignalResolvedDisposition RecordTask::sig_resolved_disposition(
    function sig_set_t (line 1318) | sig_set_t RecordTask::read_sigmask_from_process() {
    function sig_set_t (line 1347) | sig_set_t RecordTask::get_sigmask() {
    function read_ptr_arch (line 1630) | static uint64_t read_ptr_arch(Task* t, remote_ptr<void> p, bool* ok) {
    function read_ptr (line 1634) | static uint64_t read_ptr(Task* t, remote_ptr<void> p, bool* ok) {
    type syscallbuf_record (line 1705) | struct syscallbuf_record
    function maybe_handle_set_robust_list_arch (line 1888) | static void maybe_handle_set_robust_list_arch(RecordTask* t) {
    function maybe_handle_set_robust_list (line 1906) | static void maybe_handle_set_robust_list(RecordTask* t) {
    function maybe_handle_rseq_arch (line 1911) | static void maybe_handle_rseq_arch(RecordTask* t) {
    function maybe_handle_rseq (line 1929) | static void maybe_handle_rseq(RecordTask* t) {
    type syscallbuf_hdr (line 1947) | struct syscallbuf_hdr
    function pid_t (line 2148) | pid_t RecordTask::get_parent_pid() const { return get_ppid(tid); }
    function read_pid_ns (line 2186) | static uint64_t read_pid_ns(const RecordTask* t) {
    function maybe_restore_original_syscall_registers_arch (line 2259) | static void maybe_restore_original_syscall_registers_arch(RecordTask* t,
    type rlimit (line 2329) | struct rlimit
    type rlimit64 (line 2332) | struct rlimit64

FILE: src/RecordTask.h
  function namespace (line 11) | namespace rr {
  function push_event (line 457) | void push_event(const Event& ev) { pending_events.push_back(ev); }
  function pop_noop (line 460) | void pop_noop() { pop_event(EV_NOOP); }
  function pop_desched (line 461) | void pop_desched() { pop_event(EV_DESCHED); }
  function pop_seccomp_trap (line 462) | void pop_seccomp_trap() { pop_event(EV_SECCOMP_TRAP); }
  function pop_signal_delivery (line 463) | void pop_signal_delivery() { pop_event(EV_SIGNAL_DELIVERY); }
  function pop_signal_handler (line 464) | void pop_signal_handler() { pop_event(EV_SIGNAL_HANDLER); }
  function pop_syscall (line 465) | void pop_syscall() { pop_event(EV_SYSCALL); }
  function pop_syscall_interruption (line 466) | void pop_syscall_interruption() { pop_event(EV_SYSCALL_INTERRUPTION); }
  function virtual (line 467) | virtual void log_pending_events() const override;
  function Event (line 475) | Event *prev_ev() {
  type FlushSyscallbuf (line 509) | enum FlushSyscallbuf {
  type AllowSyscallbufReset (line 516) | enum AllowSyscallbufReset {
  function pid_t (line 541) | pid_t get_parent_pid() const;
  function waiting_for_pid_namespace_tasks_to_exit (line 610) | bool waiting_for_pid_namespace_tasks_to_exit() const;

FILE: src/Registers.cc
  type rr (line 17) | namespace rr {
    type RegisterValue (line 19) | struct RegisterValue {
      method RegisterValue (line 31) | constexpr RegisterValue()
      method RegisterValue (line 34) | RegisterValue(const char* name_, size_t offset_, size_t nbytes_)
      method RegisterValue (line 39) | RegisterValue(const char* name_, size_t offset_, size_t nbytes_,
      method mask_for_nbytes (line 60) | static uint64_t mask_for_nbytes(size_t nbytes) {
    type RegisterTable (line 70) | struct RegisterTable : std::array<RegisterValue, N> {
      method RegisterTable (line 71) | RegisterTable(std::initializer_list<RegisterInit> list) {
    type RegisterInfo (line 78) | struct RegisterInfo
    type RegisterInfo<rr::X86Arch> (line 80) | struct RegisterInfo<rr::X86Arch> {
      method ignore_undefined_register (line 81) | static bool ignore_undefined_register(GdbServerRegister regno) {
    type RegisterInfo<rr::X64Arch> (line 89) | struct RegisterInfo<rr::X64Arch> {
      method ignore_undefined_register (line 90) | static bool ignore_undefined_register(GdbServerRegister regno) {
    type RegisterInfo<rr::ARM64Arch> (line 98) | struct RegisterInfo<rr::ARM64Arch> {
      method ignore_undefined_register (line 99) | static bool ignore_undefined_register(GdbServerRegister) {
    type RegisterPrinting (line 198) | struct RegisterPrinting
    type RegisterPrinting<4> (line 200) | struct RegisterPrinting<4> {
    type RegisterPrinting<8> (line 205) | struct RegisterPrinting<8> {
    function print_single_register (line 211) | void print_single_register(FILE* f, const char* name, const void* regi...
    function convert_x86 (line 496) | void convert_x86(X86Arch::user_regs_struct& x86,
    function to_x86_narrow (line 517) | void to_x86_narrow(int32_t& r32, uint64_t& r64) { r32 = r64; }
    function from_x86_narrow (line 518) | void from_x86_narrow(int32_t& r32, uint64_t& r64) { r64 = (uint32_t)r3...
    function from_x86_narrow_signed (line 519) | void from_x86_narrow_signed(int32_t& r32, uint64_t& r64) { r64 = (int6...
    type X64Arch::user_regs_struct (line 543) | struct X64Arch::user_regs_struct
    function iovec (line 557) | iovec Registers::get_ptrace_iovec() {
    function ostream (line 699) | ostream& operator<<(ostream& stream, const Registers& r) {

FILE: src/Registers.h
  type iovec (line 19) | struct iovec
  function namespace (line 21) | namespace rr {

FILE: src/ReplayCommand.cc
  type rr (line 26) | namespace rr {
    type ReplayFlags (line 84) | struct ReplayFlags {
      method ReplayFlags (line 147) | ReplayFlags()
    function parse_replay_arg (line 165) | static bool parse_replay_arg(vector<string>& args, ReplayFlags& flags) {
    function find_pid_for_command (line 304) | static int find_pid_for_command(const string& trace_dir,
    function pid_exists (line 328) | static bool pid_exists(const string& trace_dir, pid_t pid) {
    function pid_execs (line 342) | static bool pid_execs(const string& trace_dir, pid_t pid) {
    function session_flags (line 362) | static ReplaySession::Flags session_flags(const ReplayFlags& flags, bo...
    function to_microseconds (line 373) | static uint64_t to_microseconds(const struct timeval& tv) {
    function serve_replay_no_debugger (line 377) | static void serve_replay_no_debugger(const string& trace_dir,
    function handle_SIGINT_in_parent (line 470) | static void handle_SIGINT_in_parent(int sig) {
    function handle_SIGINT_in_child (line 477) | static void handle_SIGINT_in_child(int sig) {
    function DebuggerType (line 482) | static DebuggerType identify_debugger(const string& debugger_name) {
    function replay (line 491) | static int replay(const string& trace_dir, const ReplayFlags& flags) {

FILE: src/ReplayCommand.h
  function namespace (line 8) | namespace rr {

FILE: src/ReplaySession.cc
  type rr (line 32) | namespace rr {
    function debug_memory (line 34) | static void debug_memory(ReplayTask* t) {
    function split_at_address (line 47) | static void split_at_address(ReplaySession::MemoryRanges& ranges,
    function tracee_xsave_enabled (line 142) | static bool tracee_xsave_enabled(const TraceReader& trace_in) {
    function check_xsave_compatibility (line 148) | static void check_xsave_compatibility(const TraceReader& trace_in) {
    function can_checkpoint_at (line 355) | static bool can_checkpoint_at(const Event& ev) {
    function Task (line 403) | Task* ReplaySession::new_task(pid_t tid, pid_t rec_tid, uint32_t serial,
    function BindCPU (line 432) | BindCPU ReplaySession::cpu_binding() const {
    function compute_ticks_request (line 495) | static bool compute_ticks_request(
    function perform_interrupted_syscall (line 518) | static void perform_interrupted_syscall(ReplayTask* t) {
    function Completion (line 574) | Completion ReplaySession::cont_syscall_boundary(
    function emulate_syscall_entry (line 654) | static void emulate_syscall_entry(ReplayTask* t, const TraceFrame& frame,
    function Completion (line 669) | Completion ReplaySession::enter_syscall(ReplayTask* t,
    function Completion (line 748) | Completion ReplaySession::exit_syscall(ReplayTask* t) {
    function do_replay_assist (line 776) | static bool do_replay_assist(Task* t) {
    function Completion (line 812) | Completion ReplaySession::continue_or_step(ReplayTask* t,
    function guard_overshoot (line 863) | static void guard_overshoot(ReplayTask* t, const Registers& target_regs,
    function guard_unexpected_signal (line 889) | static void guard_unexpected_signal(ReplayTask* t) {
    function is_same_execution_point (line 906) | static bool is_same_execution_point(ReplayTask* t, const Registers& re...
    function Completion (line 963) | Completion ReplaySession::emulate_async_signal(
    function is_fatal_default_action (line 1228) | static bool is_fatal_default_action(int sig) {
    function Completion (line 1237) | Completion ReplaySession::emulate_signal_delivery(ReplayTask* oldtask) {
    function treat_signal_event_as_deterministic (line 1283) | static bool treat_signal_event_as_deterministic(const SignalEvent& ev) {
    function Completion (line 1300) | Completion ReplaySession::emulate_deterministic_signal(
    type syscallbuf_hdr (line 1368) | struct syscallbuf_hdr
    function string (line 1389) | static string mprotect_record_string(const mprotect_record& record) {
    function apply_mprotect_records (line 1399) | static uint32_t apply_mprotect_records(ReplayTask* t,
    function write_breakpoint_value (line 1441) | static void write_breakpoint_value(ReplayTask *t, uint64_t breakpoint_...
    function maybe_handle_rseq_arch (line 1454) | static void maybe_handle_rseq_arch(ReplayTask* t) {
    function maybe_handle_rseq (line 1467) | static void maybe_handle_rseq(ReplayTask* t) {
    function Completion (line 1477) | Completion ReplaySession::flush_syscallbuf(ReplayTask* t,
    function Completion (line 1582) | Completion ReplaySession::patch_ip(ReplayTask* t, const StepConstraint...
    function Completion (line 1648) | Completion ReplaySession::patch_next_syscall(
    function has_deterministic_ticks (line 1667) | static bool has_deterministic_ticks(const Event& ev,
    function Completion (line 1690) | Completion ReplaySession::advance_to_ticks_target(
    function Completion (line 1709) | Completion ReplaySession::try_one_trace_step(
    function end_task (line 1776) | static void end_task(ReplayTask* t) {
    function Completion (line 1806) | Completion ReplaySession::exit_task(ReplayTask* t) {
    function ReplayTask (line 1815) | ReplayTask* ReplaySession::revive_task_for_exec() {
    function ReplayTask (line 1855) | ReplayTask* ReplaySession::setup_replay_one_trace_frame(ReplayTask* t) {
    function ReplayResult (line 2021) | ReplayResult ReplaySession::replay_step(const StepConstraints& constra...
    function ReplayTask (line 2185) | ReplayTask* ReplaySession::find_task(pid_t rec_tid) const {
    function ReplayTask (line 2189) | ReplayTask* ReplaySession::find_task(const TaskUid& tuid) const {

FILE: src/ReplaySession.h
  type syscallbuf_hdr (line 19) | struct syscallbuf_hdr
  type ReplayFlushBufferedSyscallState (line 30) | struct ReplayFlushBufferedSyscallState {
  type ReplayTraceStepType (line 41) | enum ReplayTraceStepType {
  type ReplayTraceStep (line 83) | struct ReplayTraceStep {
  type ReplayStatus (line 106) | enum ReplayStatus {
  type ReplayResult (line 116) | struct ReplayResult {
  function class (line 137) | class ReplayStepKey {
  function ReplayTask (line 218) | ReplayTask* current_task() {
  type Flags (line 243) | struct Flags {
  function ReplaySession (line 297) | ReplaySession* as_replay() override { return this; }
  function SupportedArch (line 300) | SupportedArch arch() { return trace_in.arch(); }
  type std (line 315) | typedef std::set<MemoryRange, MappingComparator> MemoryRanges;
  type PerfTradeoff (line 316) | enum PerfTradeoff {
  function virtual (line 336) | virtual TraceStream* trace_stream() override { return &trace_in; }
  function virtual (line 338) | virtual BindCPU cpu_binding() const override;
  function virtual (line 342) | virtual int tracee_output_fd(int dflt) override {
  function notify_detected_transient_error (line 373) | void notify_detected_transient_error() { detected_transient_error_ = tru...
  function set_suppress_stdio_before_event (line 375) | void set_suppress_stdio_before_event(FrameTime event) { suppress_stdio_b...

FILE: src/ReplayTask.cc
  type rr (line 13) | namespace rr {
    function ReplaySession (line 23) | ReplaySession& ReplayTask::session() const {
    function TraceReader (line 27) | TraceReader& ReplayTask::trace_reader() const {
    function TraceFrame (line 134) | const TraceFrame& ReplayTask::current_trace_frame() const {
    function FrameTime (line 138) | FrameTime ReplayTask::current_frame_time() const {
    function write_data_with_holes (line 143) | static size_t write_data_with_holes(ReplayTask* t,
    function ExtraRegisters (line 219) | const ExtraRegisters& ReplayTask::extra_regs() {

FILE: src/ReplayTask.h
  function namespace (line 9) | namespace rr {

FILE: src/ReplayTimeline.cc
  type rr (line 14) | namespace rr {
    function ostream (line 37) | ostream& operator<<(ostream& s, const ReplayTimeline::MarkKey& o) {
    function ostream (line 42) | ostream& operator<<(ostream& s, const ReplayTimeline::InternalMark& o) {
    function ostream (line 46) | ostream& operator<<(ostream& s, const ReplayTimeline::Mark& o) {
    function ostream (line 53) | ostream& operator<<(ostream& s, const ReplayTimeline::ProtoMark& o) {
    function equal_regs (line 96) | static bool equal_regs(const Registers& r1, const Registers& r2) {
    function ReplayResult (line 454) | ReplayResult ReplayTimeline::replay_step_to_mark(
    function ReplayResult (line 801) | ReplayResult ReplayTimeline::singlestep_with_breakpoints_disabled() {
    function ReplayTask (line 926) | static ReplayTask* to_replay_task(const BreakStatus& status) {
    function arch_watch_fires_before_instr (line 930) | static bool arch_watch_fires_before_instr(SupportedArch arch) {
    function ReplayResult (line 943) | ReplayResult ReplayTimeline::reverse_continue(
    function ReplayResult (line 1175) | ReplayResult ReplayTimeline::reverse_singlestep(
    function ReplayResult (line 1463) | ReplayResult ReplayTimeline::replay_step_forward(RunCommand command) {
    function ReplayResult (line 1498) | ReplayResult ReplayTimeline::reverse_singlestep(
    function inter_checkpoint_interval (line 1569) | static ReplayTimeline::Progress inter_checkpoint_interval(
    function next_interval_length (line 1576) | static ReplayTimeline::Progress next_interval_length(

FILE: src/ReplayTimeline.h
  function namespace (line 19) | namespace rr {
  function operator (line 290) | bool operator<=(const MarkKey& other) const { return !(other < *this); }
  function operator (line 291) | bool operator>(const MarkKey& other) const { return other < *this; }
  function operator (line 292) | bool operator>=(const MarkKey& other) const { return !(*this < other); }
  function operator (line 293) | bool operator==(const MarkKey& other) const {
  function operator (line 297) | bool operator!=(const MarkKey& other) const { return !(*this == other); }
  function key (line 316) | ProtoMark(const MarkKey& key) : key(key) {}
  type InternalMark (line 330) | struct InternalMark {
  function MarkKey (line 380) | static MarkKey session_mark_key(ReplaySession& session) {
  type ForceProgress (line 394) | enum ForceProgress { FORCE_PROGRESS, DONT_FORCE_PROGRESS }
  type ReplayStepToMarkStrategy (line 399) | struct ReplayStepToMarkStrategy {

FILE: src/RerunCommand.cc
  type rr (line 23) | namespace rr {
    class RerunCommand (line 31) | class RerunCommand : public Command {
      method RerunCommand (line 36) | RerunCommand(const char* name, const char* help) : Command(name, hel...
    type RerunFlags (line 75) | struct RerunFlags {
      method RerunFlags (line 88) | RerunFlags()
    function parse_rerun_arg (line 97) | static bool parse_rerun_arg(vector<string>& args, RerunFlags& flags) {
    function treat_event_completion_as_singlestep_complete (line 170) | static bool treat_event_completion_as_singlestep_complete(const Event&...
    function ignore_singlestep_for_event (line 187) | static bool ignore_singlestep_for_event(const Event& ev) {
    function run_diversion_function (line 200) | static void run_diversion_function(ReplaySession& replay, Task* task,
    function session_flags (line 236) | static ReplaySession::Flags session_flags(const RerunFlags& flags) {
    function rerun (line 244) | static int rerun(const string& trace_dir, const RerunFlags& flags, Com...

FILE: src/ReturnAddressList.cc
  type rr (line 7) | namespace rr {
    function read_bytes_no_breakpoints (line 9) | static bool read_bytes_no_breakpoints(Task* t, remote_ptr<void> p, ssi...
    function return_addresses_x86ish (line 20) | static void return_addresses_x86ish(ReturnAddressList* result, Task* t) {
    function compute_return_addresses (line 71) | static void compute_return_addresses(ReturnAddressList* result, Task* ...

FILE: src/ReturnAddressList.h
  function namespace (line 10) | namespace rr {

FILE: src/RmCommand.cc
  type rr (line 15) | namespace rr {
    class RmCommand (line 17) | class RmCommand : public Command {
      method RmCommand (line 22) | RmCommand(const char* name, const char* help) : Command(name, help) {}
    type RmFlags (line 31) | struct RmFlags {
      method RmFlags (line 33) | RmFlags() : force(false) {}
    function parse_rm_arg (line 36) | static bool parse_rm_arg(vector<string>& args, RmFlags& flags) {
    function _rm_cb (line 58) | static int _rm_cb(const char* path, const struct stat*, int, struct FT...
    function remove_all (line 66) | static bool remove_all(const string& path) {
    function rm (line 75) | static int rm(const string& trace, const RmFlags& flags, FILE* out) {

FILE: src/Scheduler.cc
  type rr (line 32) | namespace rr {
    function random_frac (line 185) | static double random_frac() { return double(random() % INT32_MAX) / IN...
    function treat_syscall_as_nonblocking (line 203) | static bool treat_syscall_as_nonblocking(int syscallno, SupportedArch ...
    class WaitAggregator (line 209) | class WaitAggregator {
      method WaitAggregator (line 211) | explicit WaitAggregator(int num_waits_before_polling_stops) :
    function RecordTask (line 423) | RecordTask* Scheduler::find_next_runnable_task(WaitAggregator& wait_ag...
    function WaitResultCode (line 579) | static WaitResultCode wait_any(pid_t& tid, WaitStatus& status, double ...
    function RecordTask (line 609) | static RecordTask* find_waited_task(RecordSession& session, pid_t tid,...
    function round_robin_scheduling_enabled (line 1112) | static bool round_robin_scheduling_enabled() {
    function RecordTask (line 1143) | RecordTask* Scheduler::get_round_robin_task() {

FILE: src/Scheduler.h
  function set_max_ticks (line 92) | void set_max_ticks(Ticks max_ticks) {
  function Ticks (line 96) | Ticks max_ticks() { return max_ticks_; }
  function set_always_switch (line 97) | void set_always_switch(bool always_switch) {
  type Rescheduled (line 114) | struct Rescheduled {
  function RecordTask (line 142) | RecordTask* current() const { return current_; }
  function set_current (line 143) | void set_current(RecordTask* t) { current_ = t; }
  function expire_timeslice (line 147) | void expire_timeslice() { current_timeslice_end_ = 0; }
  type CompareByScheduleOrder (line 192) | struct CompareByScheduleOrder {

FILE: src/ScopedFd.h
  function namespace (line 16) | namespace rr {

FILE: src/SeccompFilterRewriter.cc
  type rr (line 21) | namespace rr {
    function set_syscall_result (line 23) | static void set_syscall_result(RecordTask* t, long ret) {
    function pass_through_seccomp_filter (line 29) | static void pass_through_seccomp_filter(RecordTask* t) {
    function install_patched_seccomp_filter_arch (line 41) | static void install_patched_seccomp_filter_arch(

FILE: src/SeccompFilterRewriter.h
  function namespace (line 31) | namespace rr {

FILE: src/Session.cc
  type rr (line 32) | namespace rr {
    type Session::CloneCompletion (line 34) | struct Session::CloneCompletion {
      type AddressSpaceClone (line 35) | struct AddressSpaceClone {
    function Task (line 156) | Task* Session::new_task(pid_t tid, pid_t rec_tid, uint32_t serial,
    function Task (line 169) | Task* Session::clone(Task* p, int flags, remote_ptr<void> stack,
    function Task (line 179) | Task* Session::find_task(pid_t rec_tid) const {
    function Task (line 185) | Task* Session::find_task(const TaskUid& tuid) const {
    function ThreadGroup (line 190) | ThreadGroup* Session::find_thread_group(const ThreadGroupUid& tguid) c...
    function ThreadGroup (line 199) | ThreadGroup* Session::find_thread_group(pid_t pid) const {
    function AddressSpace (line 209) | AddressSpace* Session::find_address_space(const AddressSpaceUid& vmuid...
    function ScopedFd (line 255) | ScopedFd Session::create_spawn_task_error_pipe() {
    function string (line 264) | string Session::read_spawned_task_error() const {
    function BreakStatus (line 274) | BreakStatus Session::diagnose_debugger_trap(Task* t, RunCommand run_co...
    function remap_shared_mmap (line 391) | static void remap_shared_mmap(AutoRemoteSyscalls& remote, EmuFs& emu_fs,
    function KernelMapping (line 449) | KernelMapping Session::create_shared_mmap(
    function capture_syscallbuf (line 662) | static vector<uint8_t> capture_syscallbuf(const AddressSpace::Mapping& m,
    function BindCPU (line 758) | BindCPU Session::cpu_binding() const {

FILE: src/Session.h
  function namespace (line 21) | namespace rr {
  function Task (line 143) | Task* task() const { return task_context.task; }
  type RunCommand (line 145) | enum RunCommand {
  function is_singlestep (line 156) | inline bool is_singlestep(RunCommand command) {
  function class (line 170) | class Session {

FILE: src/SourcesCommand.cc
  type rr (line 29) | namespace rr {
    class SourcesCommand (line 57) | class SourcesCommand : public Command {
      method SourcesCommand (line 62) | SourcesCommand(const char* name, const char* help) : Command(name, h...
    class ExplicitSourcesCommand (line 80) | class ExplicitSourcesCommand : public Command {
      method ExplicitSourcesCommand (line 85) | ExplicitSourcesCommand(const char* name, const char* help) : Command...
    type SourcesFlags (line 102) | struct SourcesFlags {
    function dir_name (line 107) | static void dir_name(string& s) {
    function is_absolute (line 118) | static bool is_absolute(const string& s) {
    function prepend_path (line 122) | static void prepend_path(const char* prefix, string& s) {
    type DirExistsCache (line 134) | struct DirExistsCache {
      method dir_exists (line 136) | bool dir_exists(const string& dir) {
    type DebugDirs (line 147) | struct DebugDirs {
    class DebugDirManager (line 156) | class DebugDirManager {
      method DebugDirs (line 161) | DebugDirs initial_directories() {
      method DebugDirManager (line 188) | DebugDirManager(const DebugDirManager&) = delete;
      method DebugDirManager (line 189) | DebugDirManager& operator=(const DebugDirManager&) = delete;
    function DebugDirs (line 282) | DebugDirs DebugDirManager::process_one_binary(const string& binary_pat...
    function DebugDirs (line 300) | DebugDirs DebugDirManager::read_result() {
    function resolve_file_name (line 364) | static bool resolve_file_name(const char* original_file_name,
    type DwoInfo (line 416) | struct DwoInfo {
    type OutputCompDirSubstitution (line 426) | struct OutputCompDirSubstitution {
    function process_compilation_units (line 431) | static bool process_compilation_units(ElfFileReader& reader,
    type ExternalDebugInfo (line 579) | struct ExternalDebugInfo {
    function find_auxiliary_file (line 600) | static unique_ptr<ElfFileReader>
    function find_auxiliary_file_by_buildid (line 704) | static unique_ptr<ElfFileReader>
    function process_auxiliary_file (line 748) | static bool process_auxiliary_file(ElfFileReader& trace_file_reader,
    function try_debuglink_file (line 803) | static bool try_debuglink_file(ElfFileReader& trace_file_reader,
    type Symlink (line 876) | struct Symlink {
    function has_subdir (line 881) | static bool has_subdir(string& base, const char* suffix) {
    function assert_absolute (line 888) | static void assert_absolute(const string& path) {
    function check_vcs_root (line 894) | static void check_vcs_root(string& path, set<string>* vcs_dirs) {
    function string (line 912) | static string resolve_symlinks(const string& path,
    function build_symlink_map (line 1031) | static void build_symlink_map(const set<string>& file_names,
    function starts_with (line 1050) | static bool starts_with(const string& s, const string& prefix) {
    function sources (line 1055) | static int sources(const iterable& binary_file_names,
    function parse_sources_option (line 1289) | static bool parse_sources_option(vector<string>& args, SourcesFlags& f...
    type stat (line 1405) | struct stat

FILE: src/StdioMonitor.cc
  type rr (line 12) | namespace rr {
    function Switchable (line 14) | Switchable StdioMonitor::will_write(Task* t) {

FILE: src/StdioMonitor.h
  function namespace (line 8) | namespace rr {

FILE: src/StringVectorToCharArray.h
  function namespace (line 9) | namespace rr {

FILE: src/SysCpuMonitor.cc
  type rr (line 14) | namespace rr {
    function string (line 19) | static string make_cpu_online_data(RecordTask* t) {

FILE: src/SysCpuMonitor.h
  function namespace (line 9) | namespace rr {

FILE: src/TargetDescription.cc
  type rr (line 10) | namespace rr {
    class FeatureStream (line 12) | class FeatureStream {
      method string (line 14) | string result() { return stream.str(); }
    function FeatureStream (line 25) | FeatureStream& operator<<(FeatureStream& stream, Any any) {
      method string (line 14) | string result() { return stream.str(); }
    function FeatureStream (line 31) | FeatureStream& operator<<(FeatureStream& stream, rr::SupportedArch arc...
      method string (line 14) | string result() { return stream.str(); }
    function FeatureStream (line 52) | FeatureStream& operator<<(FeatureStream& stream, TargetFeature feature) {
      method string (line 14) | string result() { return stream.str(); }
    function string (line 130) | string TargetDescription::to_xml() const {

FILE: src/TargetDescription.h
  function TargetFeature (line 14) | enum class TargetFeature : uint32_t {

FILE: src/Task.cc
  type rr (line 64) | namespace rr {
    function ReplayTask (line 113) | ReplayTask* Task::as_replay() {
    function WaitStatus (line 203) | WaitStatus Task::kill() {
    function string (line 310) | string Task::name() const {
    type stat (line 384) | struct stat
    type stat (line 387) | struct stat
    type stat (line 393) | struct stat
    type stat (line 396) | struct stat
    function ScopedFd (line 402) | ScopedFd Task::open_fd(int fd, int flags) {
    function string (line 408) | string Task::file_name_of_fd(int fd) {
    function pid_t (line 421) | pid_t Task::get_ptrace_eventmsg_pid() {
    function siginfo_t (line 429) | const siginfo_t& Task::get_siginfo() {
    type syscallbuf_hdr (line 462) | struct syscallbuf_hdr
    function ptrace_get_regs_set (line 531) | static vector<uint8_t> ptrace_get_regs_set(Task* t, const Registers& r...
    function process_shmdt (line 539) | static void process_shmdt(Task* t, remote_ptr<void> addr) {
    function ptrace_syscall_exit_legacy_arch (line 546) | static void ptrace_syscall_exit_legacy_arch(Task* t, Task* tracee, con...
  function is_long_mode_segment (line 1058) | static bool is_long_mode_segment(uint32_t segment) {
  function string (line 1108) | static string prname_from_exe_image(const string& e) {
  function string (line 1152) | string Task::read_c_str(remote_ptr<char> child_addr, bool *ok) {
  function Registers (line 1176) | const Registers& Task::regs() const {
  function ExtraRegisters (line 1184) | const ExtraRegisters* Task::extra_regs_fallible() {
  function dr_user_word_offset (line 1241) | static ssize_t dr_user_word_offset(size_t i) {
  type iovec (line 1286) | struct iovec
  type iovec (line 1293) | struct iovec
  type iovec (line 1303) | struct iovec
  type iovec (line 1325) | struct iovec
  function is_singlestep_resume (line 1360) | static bool is_singlestep_resume(ResumeRequest request) {
  function TrapReasons (line 1364) | TrapReasons Task::compute_trap_reasons() {
  function setup_preload_thread_locals_arch (line 1472) | static void setup_preload_thread_locals_arch(Task* t) {
  function cpu_has_KNL_string_singlestep_bug (line 1517) | static bool cpu_has_KNL_string_singlestep_bug() {
  function cpu_has_KNL_string_singlestep_bug (line 1523) | static bool cpu_has_KNL_string_singlestep_bug() {
  function single_step_coalesce_cutoff (line 1533) | static int single_step_coalesce_cutoff() { return 16; }
  type iovec (line 1743) | struct iovec
  type iovec (line 1765) | struct iovec
  type iovec (line 1796) | struct iovec
  type WatchBytesX86 (line 1810) | enum WatchBytesX86 {
  function WatchBytesX86 (line 1816) | static WatchBytesX86 num_bytes_to_dr_len(size_t num_bytes) {
  type DebugControl (line 1832) | struct DebugControl {
    method enable (line 1853) | void enable(size_t index, WatchBytesX86 size, WatchType type) {
  function set_x86_debug_regs (line 1881) | static bool set_x86_debug_regs(Task *t, const Task::HardwareWatchpoints&...
  function query_max_bp_wp (line 1931) | static void query_max_bp_wp(Task* t, ssize_t* max_bp, ssize_t* max_wp) {
  function set_debug_regs_internal (line 2011) | static bool set_debug_regs_internal(Task* t, const Task::HardwareWatchpo...
  function set_thread_area (line 2028) | static void set_thread_area(std::vector<X86Arch::user_desc>& thread_areas_,
  function pid_t (line 2066) | pid_t Task::tgid() const { return tg->tgid; }
  function pid_t (line 2068) | pid_t Task::real_tgid() const {
  function string (line 2073) | const string& Task::trace_dir() const {
  function FrameTime (line 2079) | FrameTime Task::trace_time() const {
  function is_signal_triggered_by_ptrace_interrupt (line 2084) | static bool is_signal_triggered_by_ptrace_interrupt(int group_stop_sig) {
  function handle_alarm_signal (line 2098) | static void handle_alarm_signal(__attribute__((unused)) int sig) {}
  type iovec (line 2233) | struct iovec
  type iovec (line 2238) | struct iovec
  function FrameTime (line 2244) | static FrameTime simulate_error_at_event() {
  function simulate_transient_error (line 2252) | static bool simulate_transient_error(Task* t) {
  function ignore_signal_for_detached_proxy (line 2264) | static bool ignore_signal_for_detached_proxy(int sig) {
  type iovec (line 2393) | struct iovec
  function set_tls_from_clone_arch (line 2516) | static void set_tls_from_clone_arch(Task* t, remote_ptr<void> tls) {
  function set_tls_from_clone (line 2522) | static void set_tls_from_clone(Task* t, remote_ptr<void> tls) {
  function setup_preload_thread_locals_from_clone_arch (line 2527) | static void setup_preload_thread_locals_from_clone_arch(Task* t, Task* o...
  function Task (line 2551) | Task* Task::clone(CloneReason reason, int flags, remote_ptr<void> stack,
  function Task (line 2712) | Task* Task::os_fork_into(Session* session, FdTable::shr_ptr new_fds) {
  function Task (line 2735) | Task* Task::os_clone_into(const CapturedState& state,
  function copy_tls_arch (line 2764) | static void copy_tls_arch(const Task::CapturedState& state,
  function copy_tls (line 2779) | static void copy_tls(const Task::CapturedState& state,
  function fdinfo_field (line 2784) | static int64_t fdinfo_field(Task* t, int fd, const char* field, bool mus...
  function pid_t (line 2821) | pid_t Task::pid_of_pidfd(int fd) {
  type syscallbuf_record (line 2917) | struct syscallbuf_record
  type syscallbuf_record (line 2919) | struct syscallbuf_record
  type syscallbuf_record (line 2923) | struct syscallbuf_record
  function ScopedFd (line 2994) | ScopedFd& Task::pagemap_fd() {
  function KernelMapping (line 3006) | KernelMapping Task::init_syscall_buffer(AutoRemoteSyscalls& remote,
  function safe_pwrite64 (line 3199) | static ssize_t safe_pwrite64(Task* t, const void* buf, ssize_t buf_size,
  function TraceStream (line 3387) | const TraceStream* Task::trace_stream() const {
  function SupportedArch (line 3412) | SupportedArch Task::detect_syscall_arch() {
  function do_preload_init_arch (line 3447) | static void do_preload_init_arch(Task* t) {
  function do_preload_init (line 3461) | static void do_preload_init(Task* t) {
  function perform_remote_clone_arch (line 3473) | static long perform_remote_clone_arch(
  function perform_remote_clone (line 3486) | static long perform_remote_clone(AutoRemoteSyscalls& remote,
  function Task (line 3494) | Task* Task::os_clone(CloneReason reason, Session* session,
  function setup_fd_table (line 3515) | static void setup_fd_table(Task* t, FdTable& fds, int tracee_socket_fd_n...
  function spawned_child_fatal_error (line 3522) | static void spawned_child_fatal_error(const ScopedFd& err_fd,
  function disable_tsc (line 3539) | static void disable_tsc(const ScopedFd& err_fd) {
  function set_up_process_arch (line 3553) | void set_up_process_arch(SupportedArch arch, const ScopedFd& err_fd) {
  function set_up_process (line 3562) | static void set_up_process(Session& session, const ScopedFd& err_fd,
  function create_seccomp_filter (line 3658) | static SeccompFilter<struct sock_filter> create_seccomp_filter() {
  function set_up_seccomp_filter (line 3678) | static void set_up_seccomp_filter(const struct sock_fprog& prog, const S...
  function run_initial_child (line 3689) | static void run_initial_child(Session& session, const ScopedFd& error_fd,
  function Task (line 3759) | Task* Task::spawn(Session& session, ScopedFd& error_fd,
  function file_was_deleted (line 3897) | static bool file_was_deleted(string s) {
  function create_mapping (line 3903) | static void create_mapping(Task *t, AutoRemoteSyscalls &remote, const Ke...
  function apply_mm_map (line 3924) | static void apply_mm_map(AutoRemoteSyscalls& remote, const NativeArch::p...
  function copy_mem_mapping (line 3976) | static void copy_mem_mapping(Task* from, Task* to, const KernelMapping& ...
  function copy_mem_mapping_just_used (line 3995) | static bool copy_mem_mapping_just_used(Task* from, Task* to, const Kerne...
  function mremap_move (line 4051) | static void mremap_move(AutoRemoteSyscalls& remote, remote_ptr<void> src,
  type VMappings (line 4065) | struct VMappings {
  function move_vdso_and_vvar_mappings (line 4078) | static void move_vdso_and_vvar_mappings(AutoRemoteSyscalls& remote,
  type rlimit64 (line 4277) | struct rlimit64
  function __ptrace_cont (line 4302) | static bool __ptrace_cont(Task* t, ResumeRequest resume_how,
  function setup_exec_args_arch (line 4355) | static void setup_exec_args_arch(Task* t, const std::string& filename,
  function setup_exec_args (line 4373) | static void setup_exec_args(Task* t, const std::string& filename,

FILE: src/Task.h
  type syscallbuf_hdr (line 28) | struct syscallbuf_hdr
  type syscallbuf_record (line 29) | struct syscallbuf_record
  function namespace (line 31) | namespace rr {
  type WriteFlags (line 762) | enum WriteFlags {
  function usable_scratch_size (line 968) | size_t usable_scratch_size() {
  type CapturedState (line 982) | struct CapturedState {
  function set_in_diversion (line 1021) | void set_in_diversion(bool in_diversion) {
  function os_exec_stub (line 1085) | void os_exec_stub(SupportedArch arch) {
  type CloneReason (line 1156) | enum CloneReason {
  function virtual (line 1183) | virtual void post_wait_clone(Task*, int) {}

FILE: src/TaskishUid.h
  function namespace (line 9) | namespace rr {
  function namespace (line 81) | namespace std {

FILE: src/ThreadDb.cc
  function ps_err_e (line 27) | ps_err_e ps_pglobal_lookup(struct ps_prochandle* h, const char*,
  function ps_err_e (line 39) | ps_err_e ps_pdread(struct ps_prochandle* h, psaddr_t addr, void* buffer,
  function ps_err_e (line 58) | ps_err_e ps_pdwrite(struct ps_prochandle*, psaddr_t, const void*, size_t) {
  function ps_err_e (line 63) | ps_err_e ps_lgetregs(struct ps_prochandle* h, lwpid_t rec_tid,
  function ps_err_e (line 77) | ps_err_e ps_lsetregs(struct ps_prochandle*, lwpid_t, const prgregset_t) {
  function ps_err_e (line 82) | ps_err_e ps_lgetfpregs(struct ps_prochandle*, lwpid_t, prfpregset_t*) {
  function ps_err_e (line 87) | ps_err_e ps_lsetfpregs(struct ps_prochandle*, lwpid_t, const prfpregset_...
  function pid_t (line 92) | pid_t ps_getpid(struct ps_prochandle* h) {
  function ps_err_e (line 100) | ps_err_e ps_get_thread_area(const struct ps_prochandle* h, lwpid_t rec_tid,

FILE: src/ThreadDb.h
  function namespace (line 15) | namespace rr {
  type ps_prochandle (line 23) | struct ps_prochandle {
  function namespace (line 29) | namespace rr {

FILE: src/ThreadGroup.cc
  type rr (line 10) | namespace rr {

FILE: src/ThreadGroup.h
  function namespace (line 17) | namespace rr {

FILE: src/Ticks.h
  function namespace (line 8) | namespace rr {

FILE: src/TraceField.cc
  type rr (line 8) | namespace rr {
    function print_hex (line 12) | void print_hex(uint8_t* value, size_t size, FILE* out) {
    function print_value (line 22) | void print_value(const char* name, void* value, size_t size,
    function seg_reg (line 92) | uint64_t seg_reg(const Registers& regs, uint8_t index) {
    function find_gp_reg (line 112) | int find_gp_reg(const string& reg) {
    function find_seg_reg (line 121) | int find_seg_reg(const string& reg) {
    function print_trace_fields (line 132) | void print_trace_fields(ReplayTask* t, FrameTime event, uint64_t instr...
    function parse_trace_fields (line 312) | bool parse_trace_fields(const string& value, vector<TraceField>* out) {

FILE: src/TraceField.h
  function namespace (line 11) | namespace rr {

FILE: src/TraceFrame.cc
  type rr (line 10) | namespace rr {

FILE: src/TraceFrame.h
  function namespace (line 16) | namespace rr {

FILE: src/TraceInfoCommand.cc
  type rr (line 27) | namespace rr {
    class TraceInfoCommand (line 29) | class TraceInfoCommand : public Command {
      method TraceInfoCommand (line 34) | TraceInfoCommand(const char* name, const char* help) : Command(name,...
    function dump_trace_info (line 44) | static int dump_trace_info(const string& trace_dir, FILE* out) {

FILE: src/TraceStream.cc
  type rr (line 46) | namespace rr {
    type SubstreamData (line 58) | struct SubstreamData {
    function SubstreamData (line 71) | static const SubstreamData& substream(TraceStream::Substream s) {
    function dir_exists (line 87) | static bool dir_exists(const string& dir) {
    function string (line 92) | static string default_rr_trace_dir() {
    function string (line 127) | string trace_save_dir() {
    function string (line 132) | string latest_trace_symlink() {
    function string (line 136) | string resolve_trace_name(const string& trace_name)
    class CompressedWriterOutputStream (line 159) | class CompressedWriterOutputStream : public kj::OutputStream {
      method CompressedWriterOutputStream (line 161) | CompressedWriterOutputStream(CompressedWriter& writer) : writer(writ...
      method write (line 164) | virtual void write(const void* buffer, size_t size) {
    type IOException (line 172) | struct IOException {}
    class CompressedReaderInputStream (line 174) | class CompressedReaderInputStream : public kj::BufferedInputStream {
      method CompressedReaderInputStream (line 176) | CompressedReaderInputStream(CompressedReader& reader) : reader(reade...
      method tryRead (line 179) | virtual size_t tryRead(void* buffer, size_t, size_t maxBytes) {
      method skip (line 185) | virtual void skip(size_t bytes) {
      method tryGetReadBuffer (line 188) | virtual kj::ArrayPtr<const capnp::byte> tryGetReadBuffer() {
    function string (line 207) | string TraceStream::file_data_clone_file_name(const TaskUid& tuid) {
    function string (line 213) | string TraceStream::path(Substream s) {
    function str_to_data (line 237) | static kj::ArrayPtr<const capnp::byte> str_to_data(const string& str) {
    function string (line 242) | static string data_to_str(const kj::ArrayPtr<const capnp::byte>& data) {
    function to_trace_arch (line 252) | static trace::Arch to_trace_arch(SupportedArch arch) {
    function to_tristate (line 266) | static trace::CpuTriState to_tristate(bool value) {
    function SupportedArch (line 270) | static SupportedArch from_trace_arch(trace::Arch arch) {
    function to_trace_disposition (line 284) | static trace::SignalDisposition to_trace_disposition(
    function SignalResolvedDisposition (line 299) | static SignalResolvedDisposition from_trace_disposition(
    function to_trace_syscall_state (line 314) | static trace::SyscallState to_trace_syscall_state(SyscallState state) {
    function SyscallState (line 328) | static SyscallState from_trace_syscall_state(trace::SyscallState state) {
    function to_trace_signal (line 342) | static void to_trace_signal(trace::Signal::Builder signal, const Event...
    function Event (line 352) | static Event from_trace_signal(EventType type, trace::Signal::Reader s...
    function to_trace_ticks_semantics (line 367) | static trace::TicksSemantics to_trace_ticks_semantics(TicksSemantics s...
    function TicksSemantics (line 379) | static TicksSemantics from_trace_ticks_semantics(trace::TicksSemantics...
    function pid_t (line 391) | static pid_t i32_to_tid(int tid) {
    function check_fd (line 398) | static int check_fd(int fd) {
    function TraceFrame (line 558) | TraceFrame TraceReader::read_frame(FrameTime skip_before) {
    function TraceTaskEvent (line 812) | TraceTaskEvent TraceReader::read_task_event(FrameTime* time) {
    function string (line 870) | static string base_file_name(const string& file_name) {
    function starts_with (line 951) | static bool starts_with(const string& s, const string& with) {
    type stat (line 957) | struct stat
    type stat (line 1054) | struct stat
    function KernelMapping (line 1133) | KernelMapping TraceReader::read_mapped_region(MappedData* data, bool* ...
    function string (line 1324) | static string make_trace_dir(const string& exe_path, const string& out...
    type utsname (line 1505) | struct utsname
    function TraceFrame (line 1555) | TraceFrame TraceReader::peek_frame() {

FILE: src/TraceStream.h
  function namespace (line 24) | namespace rr {

FILE: src/TraceTaskEvent.h
  function namespace (line 16) | namespace rr {

FILE: src/TraceeAttentionSet.cc
  type rr (line 14) | namespace rr {
    type signalfd_siginfo (line 30) | struct signalfd_siginfo

FILE: src/TraceeAttentionSet.h
  function namespace (line 11) | namespace rr {

FILE: src/VirtualPerfCounterMonitor.cc
  type rr (line 15) | namespace rr {
    type perf_event_attr (line 22) | struct perf_event_attr
    type perf_event_attr (line 27) | struct perf_event_attr
    type f_owner_ex (line 76) | struct f_owner_ex
    function VirtualPerfCounterMonitor (line 161) | VirtualPerfCounterMonitor*

FILE: src/VirtualPerfCounterMonitor.h
  type perf_event_attr (line 9) | struct perf_event_attr
  function namespace (line 11) | namespace rr {

FILE: src/WaitManager.cc
  type rr (line 18) | namespace rr {
    class WaitState (line 20) | class WaitState {
    function pid_t (line 41) | pid_t WaitState::do_wait(pid_t tid, bool consume, int type, double blo...
    function WaitResult (line 104) | WaitResult WaitState::wait(const WaitOptions& options, int type) {
    function WaitState (line 189) | static WaitState& wait_state() {
    function WaitResult (line 194) | WaitResult WaitManager::wait_stop(const WaitOptions& options) {
    function WaitResult (line 198) | WaitResult WaitManager::wait_exit(const WaitOptions& options) {
    function WaitResult (line 214) | WaitResult WaitManager::wait_stop_or_exit(const WaitOptions& options) {

FILE: src/WaitManager.h
  function namespace (line 10) | namespace rr {

FILE: src/WaitStatus.cc
  type rr (line 16) | namespace rr {
    function WaitStatus (line 122) | WaitStatus WaitStatus::for_exit_code(int code) {
    function WaitStatus (line 127) | WaitStatus WaitStatus::for_fatal_sig(int sig) {
    function WaitStatus (line 132) | WaitStatus WaitStatus::for_stop_sig(int sig) {
    function WaitStatus (line 137) | WaitStatus WaitStatus::for_group_sig(int sig, RecordTask* t) {
    function WaitStatus (line 146) | WaitStatus WaitStatus::for_syscall(RecordTask* t) {
    function WaitStatus (line 154) | WaitStatus WaitStatus::for_ptrace_event(int ptrace_event) {
    function ostream (line 200) | ostream& operator<<(ostream& stream, WaitStatus status) {

FILE: src/WaitStatus.h
  type Type (line 22) | enum Type {

FILE: src/assembly_templates.py
  class RawBytes (line 4) | class RawBytes(object):
    method __init__ (line 6) | def __init__(self, *bytes):
    method __len__ (line 9) | def __len__(self):
  class Field (line 12) | class Field(object):
    method __init__ (line 14) | def __init__(self, name, byte_length):
    method __len__ (line 18) | def __len__(self):
    method c_type (line 21) | def c_type(self):
  class ShiftField (line 25) | class ShiftField(object):
    method __init__ (line 27) | def __init__(self, parent, shift, name, byte_length):
    method __len__ (line 33) | def __len__(self):
    method c_type (line 36) | def c_type(self):
    method patch_c_type (line 40) | def patch_c_type(self):
  class AssemblyTemplate (line 44) | class AssemblyTemplate(object):
    method __init__ (line 49) | def __init__(self, *chunks):
    method fields (line 68) | def fields(self):
    method bytes (line 71) | def bytes(self):
  function byte_array_name (line 219) | def byte_array_name(name):
  function generate_match_method (line 222) | def generate_match_method(byte_array, template):
  function generate_substitute_chunk (line 248) | def generate_substitute_chunk(s, chunk, byte_array, offset):
  function generate_substitute_method (line 265) | def generate_substitute_method(byte_array, template):
  function generate_field_end_methods (line 280) | def generate_field_end_methods(byte_array, template):
  function generate_size_member (line 289) | def generate_size_member(byte_array):
  function generate (line 294) | def generate(f):

FILE: src/audit/rtld-audit.c
  type SemaphoreAddrRange (line 38) | typedef struct {
  function la_version (line 50) | unsigned la_version(unsigned version) {
  function semaphore_addr_range_init (line 55) | static void semaphore_addr_range_init(SemaphoreAddrRange* range) {
  function semaphore_addr_range_init_single (line 60) | static void semaphore_addr_range_init_single(SemaphoreAddrRange* range,
  function semaphore_addr_range_is_valid (line 66) | static bool semaphore_addr_range_is_valid(const SemaphoreAddrRange* rang...
  function semaphore_addr_range_contains (line 70) | static bool semaphore_addr_range_contains(const SemaphoreAddrRange* range,
  function semaphore_addr_range_contiguous (line 75) | static bool semaphore_addr_range_contiguous(const SemaphoreAddrRange* ra...
  function semaphore_addr_range_expand (line 80) | static void semaphore_addr_range_expand(SemaphoreAddrRange* range,
  function semaphore_addr_range_submit (line 90) | static void semaphore_addr_range_submit(const SemaphoreAddrRange* range,
  function semaphore_addr_range_handle_add (line 105) | static void semaphore_addr_range_handle_add(SemaphoreAddrRange* range,
  function la_objopen (line 118) | unsigned la_objopen(struct link_map* map,
  function la_objclose (line 164) | unsigned la_objclose(uintptr_t* cookie) {

FILE: src/audit/stap-note-iter.c
  function stap_note_iter_unmap (line 57) | static void stap_note_iter_unmap(StapNoteIter* self __attribute__((unuse...
  function stap_note_iter_init (line 65) | void stap_note_iter_init(StapNoteIter* self, const struct link_map* map) {
  function stap_note_iter_next (line 132) | bool stap_note_iter_next(StapNoteIter* self, ElfStapNote* out_note) {
  function stap_note_iter_release (line 217) | void stap_note_iter_release(StapNoteIter* self) {

FILE: src/audit/stap-note-iter.h
  type ElfStapNote (line 8) | typedef struct {
  type StapNoteIter (line 17) | typedef struct {
  type link_map (line 27) | struct link_map

FILE: src/bpf/async_event_filter.c
  type pt_regs (line 8) | struct pt_regs
  function match_registers (line 27) | int match_registers(struct bpf_perf_event_data* event) {

FILE: src/chaos-test/chaosutil.h
  function atomic_printf (line 27) | __attribute__((format(printf, 1, 2))) inline static int atomic_printf(
  function check_cond (line 39) | inline static int check_cond(int cond) {
  function atomic_puts (line 51) | inline static int atomic_puts(const char* str) {
  function caught_test_failure (line 61) | __attribute__((format(printf, 1, 2))) inline static void caught_test_fai...
  function now_double (line 78) | inline static double now_double(void) {
  function get_page_size (line 84) | inline static long get_page_size(void) { return sysconf(_SC_PAGE_SIZE); }

FILE: src/chaos-test/core_count.c
  function main (line 8) | int main(__attribute__((unused)) int argc, char** argv) {

FILE: src/chaos-test/futex_wakeup.c
  function main (line 15) | int main(void) {

FILE: src/chaos-test/getaffinity_core_count.c
  function main (line 8) | int main(__attribute__((unused)) int argc, char** argv) {

FILE: src/chaos-test/harness.py
  function run (line 22) | def run(rr_params):
  function safe_exit (line 45) | def safe_exit(code):

FILE: src/chaos-test/mmap_adjacent.c
  function main (line 8) | int main(__attribute__((unused)) int argc, char** argv) {

FILE: src/chaos-test/mmap_bits.c
  function main (line 9) | int main(__attribute__((unused)) int argc, char** argv) {

FILE: src/chaos-test/pipe_wakeup.c
  function main (line 18) | int main(__attribute__((unused)) int argc,

FILE: src/chaos-test/startup.c
  type timespec (line 9) | struct timespec
  function main (line 17) | int main(void) {

FILE: src/chaos-test/starvation_multithreaded.c
  type timespec (line 46) | struct timespec
  function main (line 53) | int main(__attribute__((unused)) int argc, char** argv) {

FILE: src/chaos-test/starvation_singlethreaded.c
  function main (line 13) | int main(__attribute__((unused)) int argc, char** argv) {

FILE: src/core.h
  function namespace (line 38) | namespace rr {

FILE: src/counters-test/counters.cc
  function die (line 32) | static void die(const char* msg) {
  type CpuMicroarch (line 45) | enum CpuMicroarch {
  type PmuConfig (line 117) | struct PmuConfig {
  function CPUIDData (line 251) | CPUIDData cpuid(uint32_t code, uint32_t subrequest) {
  function CpuMicroarch (line 268) | static CpuMicroarch compute_cpu_microarch(void) {
  function compute_cpu_microarchs (line 394) | static std::vector<CpuMicroarch> compute_cpu_microarchs() {
  type CPUID (line 404) | struct CPUID {
  function CpuMicroarch (line 428) | static CpuMicroarch compute_cpu_microarch(const CPUID &cpuid) {
  function set_cpuid (line 489) | static void set_cpuid(std::vector<CPUID> &cpuids, unsigned long cpuidx, ...
  function get_cpuinfo_sysfs (line 505) | static inline void get_cpuinfo_sysfs(std::vector<CPUID> &res)
  function try_read_procfs_line (line 548) | static inline bool try_read_procfs_line(const std::string &line,
  function get_cpuinfo_procfs (line 590) | static inline void get_cpuinfo_procfs(std::vector<CPUID> &res)
  function compute_cpu_microarchs (line 635) | static std::vector<CpuMicroarch> compute_cpu_microarchs() {
  function child_wait (line 678) | static void child_wait(void) {
  function test_ticks_basic (line 721) | void test_ticks_basic(void) {
  function test_ticks_syscalls (line 733) | void test_ticks_syscalls(void) {
  function sighandler (line 763) | void sighandler(int sig) {
  function test_interrupts (line 767) | void test_interrupts(void) {
  function do_child (line 778) | static int do_child(void) {
  function check_ticks (line 791) | static void check_ticks(Ticks got, Ticks expected) {
  function reset_counter_period (line 798) | static void reset_counter_period(int counter_fd, uint64_t period) {
  function Ticks (line 807) | static Ticks reset_counting(pid_t child, int counter_fd, uint64_t period) {
  function main (line 820) | int main(int argc, char** argv) {

FILE: src/exec_stub.c
  function _start (line 3) | void _start(void) {}

FILE: src/fast_forward.cc
  type rr (line 10) | namespace rr {
    type InstructionBuf (line 12) | struct InstructionBuf {
    function InstructionBuf (line 18) | static InstructionBuf read_instruction(Task* t, remote_code_ptr ip) {
    type DecodedInstruction (line 26) | struct DecodedInstruction {
    function decode_x86_string_instruction (line 39) | static bool decode_x86_string_instruction(const InstructionBuf& code,
    function mem_intersect (line 117) | static bool mem_intersect(remote_ptr<void> a1, int s1, remote_ptr<void...
    function bound_iterations_for_watchpoint (line 124) | static void bound_iterations_for_watchpoint(Task* t, remote_ptr<void> ...
    function FastForwardStatus (line 164) | FastForwardStatus fast_forward_through_instruction(Task* t, ResumeRequ...
    function is_ignorable_prefix (line 358) | static bool is_ignorable_prefix(Task* t, uint8_t byte) {
    function is_rep_prefix (line 379) | static bool is_rep_prefix(uint8_t byte) { return byte == 0xF2 || byte ...
    function is_string_instruction (line 381) | static bool is_string_instruction(uint8_t byte) {
    function fallible_read_byte (line 399) | static int fallible_read_byte(Task* t, remote_ptr<uint8_t> ip) {
    function is_x86_string_instruction_at (line 408) | bool is_x86_string_instruction_at(Task* t, remote_code_ptr ip) {
    function is_string_instruction_before (line 427) | static bool is_string_instruction_before(Task* t, remote_code_ptr ip) {
    function maybe_at_or_after_x86_string_instruction (line 447) | bool maybe_at_or_after_x86_string_instruction(Task* t) {
    function at_x86_string_instruction (line 456) | bool at_x86_string_instruction(Task* t) {

FILE: src/fast_forward.h
  function namespace (line 10) | namespace rr {
  function is_x86_string_instruction_at (line 66) | inline bool is_x86_string_instruction_at(Task*, remote_code_ptr) {

FILE: src/ftrace.cc
  type rr (line 21) | namespace rr {
    type ftrace (line 22) | namespace ftrace {
      function open_socket (line 30) | static void open_socket() {
      function write_control_message (line 52) | static void write_control_message(const string& s) {
      function wait_for_reply (line 59) | static void wait_for_reply() {
      function receive_marker_fd (line 66) | static void receive_marker_fd() {
      function start_function_graph (line 92) | void start_function_graph(const Session& session, const TraceStream&...
      function write (line 118) | void write(const string& str) {
      function stop (line 137) | void stop() {

FILE: src/ftrace.h
  function namespace (line 12) | namespace rr {

FILE: src/ftrace/ftrace_helper.c
  function check_cond (line 66) | inline static int check_cond(int cond) {
  function drop_sig (line 73) | static void drop_sig(__attribute__((unused)) int sig) {}
  function chdir_to_tracing (line 102) | static void chdir_to_tracing(void) {
  function copy_file_data (line 123) | static void copy_file_data(int final_fd, int in_fd) {
  function copy_trace_file (line 135) | static void copy_trace_file(int final_fd, const char* name, int size_len) {
  function copy_trace_file_with_name (line 156) | static void copy_trace_file_with_name(int final_fd, const char* name,
  function iterate_events (line 169) | static int iterate_events(int final_fd, const char* dir, int write) {
  function file_offset (line 192) | static uint64_t file_offset(int fd) {
  function page_size (line 198) | size_t page_size(void) {
  function pad_output_to_page_size (line 206) | static uint64_t pad_output_to_page_size(int fd) {
  function write_final_output (line 215) | static void write_final_output(void) {
  function open_control_fd (line 271) | static void open_control_fd(const char* path) {
  function write_file (line 295) | static void write_file(const char* file, const char* value) {
  function stop_tracing (line 304) | static void stop_tracing(void) {
  function read_control_line (line 324) | static void read_control_line(char out[MAX_LINE_SIZE]) {
  function ack_control_message (line 354) | static void ack_control_message(void) { check(1 == write(control_fd, "K"...
  function send_marker_fd (line 356) | static void send_marker_fd(void) {
  function process_control_session (line 382) | static void process_control_session(void) {
  function main (line 431) | int main(int argc, const char** argv) {

FILE: src/generate_syscalls.py
  function arch_syscall_number (line 10) | def arch_syscall_number(arch, syscall):
  function write_syscall_enum (line 16) | def write_syscall_enum(f, arch):
  function write_syscall_enum_for_tests (line 31) | def write_syscall_enum_for_tests(f, arch):
  function write_syscallname_arch (line 45) | def write_syscallname_arch(f):
  function write_syscall_record_cases (line 65) | def write_syscall_record_cases(f):
  function write_syscall_helper_functions (line 130) | def write_syscall_helper_functions(f):
  function write_check_syscall_numbers (line 140) | def write_check_syscall_numbers(f):
  function main (line 162) | def main(argv):

FILE: src/kernel_abi.cc
  type rr (line 68) | namespace rr {
    function to_audit_arch (line 112) | int to_audit_arch(SupportedArch arch) {
    function get_syscall_instruction_arch (line 133) | bool get_syscall_instruction_arch(Task* t, remote_code_ptr ptr,
    function is_at_syscall_instruction (line 199) | bool is_at_syscall_instruction(Task* t, remote_code_ptr ptr, bool* ok) {
    function syscall_instruction (line 204) | vector<uint8_t> syscall_instruction(SupportedArch arch) {
    function instruction_length (line 218) | static ssize_t instruction_length(SupportedArch arch) {
    function syscall_instruction_length (line 231) | ssize_t syscall_instruction_length(SupportedArch arch) {
    function bkpt_instruction_length (line 241) | ssize_t bkpt_instruction_length(SupportedArch arch) {
    function movrm_instruction_length (line 255) | ssize_t movrm_instruction_length(SupportedArch arch) {
    function vsyscall_entry_length (line 266) | ssize_t vsyscall_entry_length(SupportedArch arch) {
    function assign_sigval (line 277) | static void assign_sigval(typename Arch::sigval_t& to,
    function set_arch_siginfo_arch (line 288) | static void set_arch_siginfo_arch(const siginfo_t& src, void* dest,
    function set_arch_siginfo (line 362) | void set_arch_siginfo(const siginfo_t& siginfo, SupportedArch a, void*...
    function sigaction_sigset_size_arch (line 367) | static size_t sigaction_sigset_size_arch() {
    function sigaction_sigset_size (line 371) | size_t sigaction_sigset_size(SupportedArch arch) {
    function user_regs_struct_size_arch (line 375) | static size_t user_regs_struct_size_arch() {
    function user_fpregs_struct_size_arch (line 383) | static size_t user_fpregs_struct_size_arch() {
    function virtual_address_size_arch (line 391) | static uint8_t virtual_address_size_arch(remote_ptr<void> ptr) {
    function default_virtual_address_size_arch (line 399) | static uint8_t default_virtual_address_size_arch() {
  type rr (line 98) | namespace rr {
    function to_audit_arch (line 112) | int to_audit_arch(SupportedArch arch) {
    function get_syscall_instruction_arch (line 133) | bool get_syscall_instruction_arch(Task* t, remote_code_ptr ptr,
    function is_at_syscall_instruction (line 199) | bool is_at_syscall_instruction(Task* t, remote_code_ptr ptr, bool* ok) {
    function syscall_instruction (line 204) | vector<uint8_t> syscall_instruction(SupportedArch arch) {
    function instruction_length (line 218) | static ssize_t instruction_length(SupportedArch arch) {
    function syscall_instruction_length (line 231) | ssize_t syscall_instruction_length(SupportedArch arch) {
    function bkpt_instruction_length (line 241) | ssize_t bkpt_instruction_length(SupportedArch arch) {
    function movrm_instruction_length (line 255) | ssize_t movrm_instruction_length(SupportedArch arch) {
    function vsyscall_entry_length (line 266) | ssize_t vsyscall_entry_length(SupportedArch arch) {
    function assign_sigval (line 277) | static void assign_sigval(typename Arch::sigval_t& to,
    function set_arch_siginfo_arch (line 288) | static void set_arch_siginfo_arch(const siginfo_t& src, void* dest,
    function set_arch_siginfo (line 362) | void set_arch_siginfo(const siginfo_t& siginfo, SupportedArch a, void*...
    function sigaction_sigset_size_arch (line 367) | static size_t sigaction_sigset_size_arch() {
    function sigaction_sigset_size (line 371) | size_t sigaction_sigset_size(SupportedArch arch) {
    function user_regs_struct_size_arch (line 375) | static size_t user_regs_struct_size_arch() {
    function user_fpregs_struct_size_arch (line 383) | static size_t user_fpregs_struct_size_arch() {
    function virtual_address_size_arch (line 391) | static uint8_t virtual_address_size_arch(remote_ptr<void> ptr) {
    function default_virtual_address_size_arch (line 399) | static uint8_t default_virtual_address_size_arch() {

FILE: src/kernel_abi.h
  function namespace (line 16) | namespace rr {
  type KernelConstants (line 71) | struct KernelConstants {
  type FcntlConstants (line 156) | struct FcntlConstants {
  type ELFCLASS (line 197) | enum ELFCLASS { CLASSNONE = 0, CLASS32 = 1, CLASS64 = 2 }
  type ELFENDIAN (line 198) | enum ELFENDIAN { DATA2LSB = 1 }
  type EM (line 199) | enum EM {
  type WordSize32Defs (line 205) | struct WordSize32Defs {
  type ElfPhdr (line 249) | typedef struct {
  type ElfShdr (line 260) | typedef struct {
  type ElfChdr (line 273) | typedef struct {
  type ElfSym (line 278) | typedef struct {
  type ElfDyn (line 287) | typedef struct {
  type ElfNhdr (line 292) | typedef struct {
  type ElfRel (line 298) | typedef struct {
  type ElfRela (line 303) | typedef struct {
  function clz_ptr (line 310) | static uint8_t clz_ptr(remote_ptr<void> ptr) {
  type WordSize64Defs (line 315) | struct WordSize64Defs {
  type ElfPhdr (line 359) | typedef struct {
  type ElfShdr (line 370) | typedef struct {
  type ElfChdr (line 383) | typedef struct {
  type ElfSym (line 389) | typedef struct {
  type ElfDyn (line 398) | typedef struct {
  type ElfNhdr (line 403) | typedef struct {
  type ElfRel (line 409) | typedef struct {
  type ElfRela (line 414) | typedef struct {
  function clz_ptr (line 421) | static uint8_t clz_ptr(remote_ptr<void> ptr) {
  function is_x86ish (line 436) | static bool is_x86ish() {
  type typename (line 440) | typedef typename wordsize::syscall_slong_t syscall_slong_t;
  type typename (line 441) | typedef typename wordsize::syscall_ulong_t syscall_ulong_t;
  type typename (line 442) | typedef typename wordsize::signed_int signed_int;
  type typename (line 443) | typedef typename wordsize::unsigned_int unsigned_int;
  type typename (line 444) | typedef typename wordsize::signed_short signed_short;
  type typename (line 445) | typedef typename wordsize::unsigned_short unsigned_short;
  type typename (line 446) | typedef typename wordsize::signed_long signed_long;
  type typename (line 447) | typedef typename wordsize::unsigned_long unsigned_long;
  type typename (line 448) | typedef typename wordsize::unsigned_word unsigned_word;
  type typename (line 449) | typedef typename wordsize::size_t size_t;
  type typename (line 450) | typedef typename wordsize::ssize_t ssize_t;
  type typename (line 451) | typedef typename wordsize::sigchld_clock_t sigchld_clock_t;
  type typename (line 452) | typedef typename wordsize::__statfs_word __statfs_word;
  type syscall_slong_t (line 454) | typedef syscall_slong_t time_t;
  type syscall_slong_t (line 455) | typedef syscall_slong_t off_t;
  type syscall_slong_t (line 456) | typedef syscall_slong_t blkcnt_t;
  type syscall_slong_t (line 457) | typedef syscall_slong_t blksize_t;
  type syscall_ulong_t (line 458) | typedef syscall_ulong_t rlim_t;
  type syscall_ulong_t (line 459) | typedef syscall_ulong_t fsblkcnt_t;
  type syscall_ulong_t (line 460) | typedef syscall_ulong_t fsfilcnt_t;
  type syscall_ulong_t (line 461) | typedef syscall_ulong_t ino_t;
  type syscall_ulong_t (line 462) | typedef syscall_ulong_t nlink_t;
  type off64_t (line 464) | typedef int64_t off64_t;
  type loff_t (line 465) | typedef int64_t loff_t;
  type rlim64_t (line 466) | typedef uint64_t rlim64_t;
  type ino64_t (line 467) | typedef uint64_t ino64_t;
  type blkcnt64_t (line 468) | typedef int64_t blkcnt64_t;
  type syscall_slong_t (line 470) | typedef syscall_slong_t clock_t;
  type signed_int (line 471) | typedef signed_int __kernel_key_t;
  type signed_int (line 472) | typedef signed_int __kernel_uid32_t;
  type signed_int (line 473) | typedef signed_int __kernel_gid32_t;
  type unsigned_int (line 474) | typedef unsigned_int __kernel_mode_t;
  type unsigned_long (line 475) | typedef unsigned_long __kernel_ulong_t;
  type signed_long (line 476) | typedef signed_long __kernel_long_t;
  type __kernel_long_t (line 477) | typedef __kernel_long_t __kernel_time_t;
  type __kernel_long_t (line 478) | typedef __kernel_long_t __kernel_suseconds_t;
  type signed_int (line 479) | typedef signed_int __kernel_pid_t;
  type __kernel_loff_t (line 480) | typedef int64_t __kernel_loff_t;
  type __u32 (line 482) | typedef uint32_t __u32;
  type __u64 (line 483) | typedef uint64_t __u64;
  type __u64 (line 484) | typedef __u64 aligned_u64 __attribute((aligned(8)));
  type T (line 520) | typedef T Referent;
  type T (line 539) | typedef T Referent;
  type sockaddr (line 562) | struct sockaddr {
  type sockaddr_storage (line 568) | struct sockaddr_storage {
  type sockaddr_un (line 573) | struct sockaddr_un {
  type timeval (line 579) | struct timeval {
  type timespec (line 585) | struct timespec {
  type pollfd (line 591) | struct pollfd {
  type iovec (line 598) | struct iovec {
  type msghdr (line 604) | struct msghdr {
  type cmsghdr (line 619) | struct cmsghdr {
  type mmsghdr (line 626) | struct mmsghdr {
  type epoll_event (line 643) | struct epoll_event {
  type rusage (line 657) | struct rusage {
  type siginfo_t (line 677) | struct siginfo_t {
  type cc_t (line 730) | typedef unsigned char cc_t;
  type unsigned_int (line 731) | typedef unsigned_int speed_t;
  type unsigned_int (line 732) | typedef unsigned_int tcflag_t;
  type termios (line 734) | struct termios {
  type termio (line 747) | struct termio {
  type seccomp_notif_sizes (line 756) | struct seccomp_notif_sizes {
  type serial_struct (line 764) | struct serial_struct {
  type serial_icounter_struct (line 786) | struct serial_icounter_struct {
  type winsize (line 802) | struct winsize {
  type ipc64_perm (line 810) | struct ipc64_perm {
  type msqid64_ds (line 825) | struct msqid64_ds {
  type msginfo (line 846) | struct msginfo {
  type shmid64_ds (line 859) | struct __attribute__((packed)) shmid64_ds {
  type shminfo64 (line 873) | struct shminfo64 {
  type shm_info (line 886) | struct shm_info {
  type seminfo (line 897) | struct seminfo {
  type CloneParameterOrdering (line 914) | enum CloneParameterOrdering {
  type CloneTLSType (line 925) | enum CloneTLSType {
  type user_desc (line 932) | struct user_desc {
  type __user_cap_header_struct (line 946) | struct __user_cap_header_struct {
  type __user_cap_data_struct (line 952) | struct __user_cap_data_struct {
  type dqblk (line 962) | struct dqblk {
  type dqinfo (line 975) | struct dqinfo {
  type ifmap (line 983) | struct ifmap {
  type if_settings (line 993) | struct if_settings {
  type ifreq (line 1008) | struct ifreq {
  type ifconf (line 1030) | struct ifconf {
  type iw_param (line 1040) | struct iw_param {
  type iw_point (line 1048) | struct iw_point {
  type iw_freq (line 1055) | struct iw_freq {
  type iw_quality (line 1063) | struct iw_quality {
  type iwreq (line 1093) | struct iwreq {
  type _flock (line 1101) | struct _flock {
  type flock64 (line 1112) | struct flock64 {
  type f_owner_ex (line 1123) | struct f_owner_ex {
  type accept_args (line 1132) | struct accept_args {
  type accept4_args (line 1139) | struct accept4_args {
  type getsockname_args (line 1147) | struct getsockname_args {
  type getsockopt_args (line 1154) | struct getsockopt_args {
  type setsockopt_args (line 1163) | struct setsockopt_args {
  type connect_args (line 1171) | struct connect_args {
  type recv_args (line 1177) | struct recv_args {
  type recvfrom_args (line 1185) | struct recvfrom_args {
  type recvmsg_args (line 1194) | struct recvmsg_args {
  type recvmmsg_args (line 1201) | struct recvmmsg_args {
  type sendmsg_args (line 1210) | struct sendmsg_args {
  type sendmmsg_args (line 1217) | struct sendmmsg_args {
  type socketpair_args (line 1225) | struct socketpair_args {
  type MmapCallingSemantics (line 1236) | enum MmapCallingSemantics {
  type mmap_args (line 1242) | struct mmap_args {
  type SelectCallingSemantics (line 1260) | enum SelectCallingSemantics {
  type fd_set (line 1266) | struct fd_set {
  type select_args (line 1270) | struct select_args {
  type ipc_kludge_args (line 1283) | struct ipc_kludge_args {
  type __sysctl_args (line 1288) | struct __sysctl_args {
  type kernel_sigset_t (line 1302) | typedef struct {
  type pselect6_arg6 (line 1306) | typedef struct {
  type kernel_sigaction (line 1311) | struct kernel_sigaction {
  type tms (line 1317) | struct tms {
  type rlimit (line 1325) | struct rlimit {
  type rlimit64 (line 1332) | struct rlimit64 {
  type timezone (line 1338) | struct timezone {
  type statfs_t (line 1344) | struct statfs_t {
  type statfs64_t (line 1364) | struct __attribute__((packed)) statfs64_t {
  type itimerval (line 1382) | struct itimerval {
  type itimerspec (line 1388) | struct itimerspec {
  type stack_t (line 1394) | typedef struct sigaltstack {
  type sysinfo_t (line 1402) | struct sysinfo_t {
  type utsname (line 1422) | struct utsname {
  type sched_param (line 1432) | struct sched_param {
  function cmsg_align (line 1438) | static constexpr size_t cmsg_align(size_t len) {
  function cmsg_space (line 1441) | static constexpr size_t cmsg_space(size_t len) {
  function cmsg_len (line 1444) | static size_t cmsg_len(size_t len) {
  type v4l2_timecode (line 1448) | struct v4l2_timecode {
  type v4l2_buffer (line 1459) | struct v4l2_buffer {
  type sock_filter (line 1482) | struct sock_filter {
  type sock_fprog (line 1490) | struct sock_fprog {
  type robust_list (line 1497) | struct robust_list {
  type robust_list_head (line 1502) | struct robust_list_head {
  type snd_ctl_card_info (line 1509) | struct snd_ctl_card_info {
  type usbdevfs_iso_packet_desc (line 1522) | struct usbdevfs_iso_packet_desc {
  type usbdevfs_urb (line 1529) | struct usbdevfs_urb {
  type usbdevfs_ioctl (line 1549) | struct usbdevfs_ioctl {
  type usbdevfs_ctrltransfer (line 1556) | struct usbdevfs_ctrltransfer {
  type dirent (line 1567) | struct dirent {
  type dirent64 (line 1577) | struct dirent64 {
  type mq_attr (line 1586) | struct mq_attr {
  type xt_counters (line 1595) | struct xt_counters {
  type ipt_replace (line 1600) | struct ipt_replace {
  type ip6t_replace (line 1615) | struct ip6t_replace {
  type cap_header (line 1630) | struct cap_header {
  type cap_data (line 1635) | struct cap_data {
  type hci_dev_req (line 1641) | struct hci_dev_req {
  type hci_dev_list_req (line 1646) | struct hci_dev_list_req {
  type bdaddr_t (line 1651) | typedef struct { uint8_t b[6]; } __attribute__((__packed__)) bdaddr_t;
  type hci_dev_stats (line 1653) | struct hci_dev_stats {
  type hci_dev_info (line 1666) | struct hci_dev_info {
  type rseq_t (line 1689) | struct rseq_t {
  type rseq_cs (line 1696) | struct rseq_cs {
  type ifbond (line 1704) | typedef struct ifbond {
  type timex (line 1711) | typedef struct timex {
  type statx_timestamp (line 1748) | typedef struct statx_timestamp {
  type statx (line 1756) | typedef struct statx_struct {
  type sg_io_hdr (line 1782) | struct sg_io_hdr {
  type file_handle (line 1883) | struct file_handle {
  type link_map (line 1890) | struct link_map {
  type r_debug (line 1899) | struct r_debug {
  type prctl_mm_map (line 1905) | struct prctl_mm_map {
  type fiemap_extent (line 1923) | struct fiemap_extent {
  type fiemap (line 1932) | struct fiemap {
  type vt_stat (line 1943) | struct vt_stat {
  type fb_fix_screeninfo (line 1950) | struct fb_fix_screeninfo {
  type fb_bitfield (line 1969) | struct fb_bitfield {
  type fb_var_screeninfo (line 1975) | struct fb_var_screeninfo {
  type cdrom_tochdr (line 2008) | struct cdrom_tochdr {
  type cdrom_msf0 (line 2014) | struct cdrom_msf0 {
  type cdrom_msf0 (line 2020) | struct cdrom_msf0
  type cdrom_tocentry (line 2023) | struct cdrom_tocentry {
  type mtd_read_req_ecc_stats (line 2033) | struct mtd_read_req_ecc_stats {
  type mtd_read_req (line 2039) | struct mtd_read_req {
  type ptrace_syscall_info (line 2051) | struct ptrace_syscall_info {
  type X64Arch (line 2074) | struct X64Arch
  type X64Arch (line 2075) | typedef X64Arch Arch64;
  type legacy_uid_t (line 2089) | typedef uint32_t legacy_uid_t;
  type legacy_gid_t (line 2090) | typedef uint32_t legacy_gid_t;
  type user_regs_struct (line 2109) | struct user_regs_struct {
  type sigcontext (line 2145) | struct sigcontext {
  type user_fpregs_struct (line 2177) | struct user_fpregs_struct {
  type user (line 2193) | struct user {
  type stat_t (line 2221) | struct stat_t {
  function stat_t (line 2240) | struct stat64_t : public stat_t {}
  type semid64_ds (line 2243) | struct semid64_ds {
  type ethtool_rx_flow_spec (line 2255) | struct ethtool_rx_flow_spec {
  type ethtool_rxnfc (line 2266) | struct ethtool_rxnfc {
  type X86Arch (line 2285) | struct X86Arch
  type X64Arch (line 2286) | typedef X64Arch Arch64;
  type legacy_uid_t (line 2307) | typedef uint16_t legacy_uid_t;
  type legacy_gid_t (line 2308) | typedef uint16_t legacy_gid_t;
  type user_regs_struct (line 2327) | struct user_regs_struct {
  type user_fpregs_struct (line 2348) | struct user_fpregs_struct {
  type user_fpxregs_struct (line 2361) | struct user_fpxregs_struct {
  type sigcontext (line 2381) | struct sigcontext {
  type user (line 2407) | struct user {
  type stat_t (line 2426) | struct stat_t {
  type stat64_t (line 2448) | struct __attribute__((packed)) stat64_t {
  type semid64_ds (line 2468) | struct semid64_ds {
  type ethtool_rx_flow_spec (line 2480) | struct __attribute__((packed)) ethtool_rx_flow_spec {
  type ethtool_rxnfc (line 2491) | struct __attribute__((packed)) ethtool_rxnfc {
  type legacy_uid_t (line 2510) | typedef uint32_t legacy_uid_t;
  type legacy_gid_t (line 2511) | typedef uint32_t legacy_gid_t;
  type stat_t (line 2514) | struct stat_t {
  type semid64_ds (line 2533) | struct semid64_ds {
  function stat_t (line 2542) | struct stat64_t : public stat_t {}
  type ARM64Arch (line 2545) | struct ARM64Arch
  type ARM64Arch (line 2546) | typedef ARM64Arch Arch64;
  type user_pt_regs (line 2566) | struct user_pt_regs {
  type user_regs_struct (line 2572) | typedef struct user_pt_regs user_regs_struct;
  type __uint128_t (line 2575) | typedef struct {
  type user_fpsimd_state (line 2579) | struct user_fpsimd_state {
  type user_fpregs_struct (line 2585) | typedef struct user_fpsimd_state user_fpregs_struct;
  type hw_breakpoint_ctrl (line 2587) | struct hw_breakpoint_ctrl {
  type hw_bp (line 2596) | struct hw_bp {
  type user_hwdebug_state (line 2602) | struct user_hwdebug_state {
  type sigcontext (line 2609) | struct __attribute((aligned(16))) sigcontext {
  type ucontext (line 2617) | struct ucontext {
  type rt_sigframe (line 2627) | struct rt_sigframe {
  type ethtool_rx_flow_spec (line 2635) | struct ethtool_rx_flow_spec {
  type ethtool_rxnfc (line 2646) | struct ethtool_rxnfc {
  type user_pac_address_keys (line 2664) | struct user_pac_address_keys {
  type user_pac_generic_keys (line 2671) | struct user_pac_generic_keys {
  type X86Arch (line 2751) | typedef X86Arch NativeArch;
  type X64Arch (line 2753) | typedef X64Arch NativeArch;
  type ARM64Arch (line 2755) | typedef ARM64Arch NativeArch;

FILE: src/kernel_metadata.cc
  type rr (line 20) | namespace rr {
    function string (line 32) | string arch_name(SupportedArch arch) {
    function string (line 44) | string ptrace_event_name(int event) {
    function string (line 77) | string ptrace_req_name(int request) {
    function string (line 125) | string signal_name(int sig) {
    function is_sigreturn (line 179) | bool is_sigreturn(int syscallno, SupportedArch arch) {
    function string (line 323) | string errno_name(int err) {
    function string (line 333) | string sicode_name(int code, int sig) {
    function shm_flags_to_mmap_prot (line 420) | int shm_flags_to_mmap_prot(int flags) {
    function string (line 425) | string xsave_feature_string(uint64_t xsave_features) {
    function is_coredumping_signal (line 466) | bool is_coredumping_signal(int signo) {
    function convert_to_native_siginfo_arch (line 487) | NativeArch::siginfo_t convert_to_native_siginfo_arch(const void* data,
    function convert_to_native_siginfo (line 562) | NativeArch::siginfo_t convert_to_native_siginfo(SupportedArch arch,
    function string (line 567) | string rlimit_resource_name(int resource) {
    function string (line 592) | string prot_flags_string(int prot) {
    function addr_bits (line 611) | int addr_bits(SupportedArch arch) {
    function usable_address_space_end (line 630) | remote_ptr<void> usable_address_space_end(SupportedArch arch) {

FILE: src/kernel_metadata.h
  function namespace (line 14) | namespace rr {

FILE: src/kernel_supplement.h
  function namespace (line 22) | namespace rr {
  type rr (line 630) | enum rr

FILE: src/launch_debugger.cc
  type rr (line 26) | namespace rr {
    function string (line 31) | static string gdb_rr_macros(const string* file_to_delete) {
    function string (line 125) | static const string& lldb_python_rr_macros(
    function push_default_gdb_options (line 147) | static void push_default_gdb_options(vector<string>& vec, bool serve_f...
    function push_gdb_target_remote_cmd (line 177) | static void push_gdb_target_remote_cmd(vector<string>& vec, int socket...
    function push_lldb_target_remote_cmd (line 198) | static void push_lldb_target_remote_cmd(vector<string>& vec, int socke...
    function debugger_launch_command (line 217) | vector<string> debugger_launch_command(Task* t, int socket_domain,
    function string (line 243) | string to_shell_string(const vector<string>& args) {
    function needs_target (line 251) | static bool needs_target(const string& option) {
    function launch_debugger (line 259) | void launch_debugger(ScopedFd& params_pipe_fd,
    function emergency_debug (line 346) | void emergency_debug(Task* t) {
    function string (line 397) | string gdb_init_script() { return gdb_rr_macros(nullptr); }
    function string (line 399) | string lldb_init_script() { return lldb_python_rr_macros(nullptr, null...

FILE: src/launch_debugger.h
  function DebuggerType (line 18) | enum class DebuggerType {

FILE: src/log.cc
  function ostream (line 31) | ostream& operator<<(ostream& stream, const siginfo_t& siginfo) {
  type rr (line 66) | namespace rr {
    type LogModule (line 68) | struct LogModule {
    function LogLevel (line 73) | static LogLevel to_log_level(const string& str) {
    function simple_to_lower (line 94) | static char simple_to_lower(char ch) {
    function string (line 102) | static string simple_to_lower(const string& s) {
    function flush_log_file (line 144) | static void flush_log_file() { log_file->flush(); }
    function apply_log_spec (line 148) | void apply_log_spec(const char *spec) {
    function apply_log_spec_from_env (line 188) | void apply_log_spec_from_env() {
    function init_log_globals (line 199) | static void init_log_globals() {
    function LogLevel (line 241) | static LogLevel get_log_level(const string& name) {
    function string (line 251) | static string file_to_name(const char* file) {
    function LogModule (line 268) | LogModule& get_log_module(const char* file) {
    function set_all_logging (line 282) | void set_all_logging(LogLevel level) {
    function set_logging (line 288) | void set_logging(const char* name, LogLevel level) {
    function ostream (line 308) | ostream& log_stream() {
    function flush_log_stream (line 313) | static void flush_log_stream() {
    function flush_log_buffer (line 337) | void flush_log_buffer(unique_ptr<deque<char>> &this_log_buffer) {
    function flush_log_buffer (line 348) | void flush_log_buffer() {
    function write_prefix (line 353) | static void write_prefix(T& stream, LogLevel level, const char* file, ...
    function is_logging_enabled (line 367) | bool is_logging_enabled(LogLevel level, const char* file) {
    function dump_stack_and_abort (line 407) | static void dump_stack_and_abort() {
    function dump_last_events (line 466) | static void dump_last_events(const TraceStream& trace) {
    function start_emergency_debug (line 481) | static void start_emergency_debug(Task* t) {
    function ostream (line 546) | ostream& operator<<(ostream& stream, const vector<uint8_t>& bytes) {

FILE: src/log.h
  function namespace (line 19) | namespace rr {

FILE: src/main.cc
  type rr (line 25) | namespace rr {
    function assert_prerequisites (line 31) | void assert_prerequisites(bool use_syscall_buffer) {
    function print_version (line 52) | void print_version(FILE* out) { fprintf(out, "rr version %s %s\n", RR_...
    function print_global_options (line 54) | void print_global_options(FILE* out) {
    function list_commands (line 98) | void list_commands(FILE* out) {
    function print_usage (line 102) | void print_usage(FILE* out) {
    function init_random (line 117) | static void init_random() {
    function parse_global_option (line 125) | bool parse_global_option(std::vector<std::string>& args) {
    function saved_argv0_space (line 228) | size_t saved_argv0_space() {
  function main (line 236) | int main(int argc, char* argv[]) {

FILE: src/main.h
  function namespace (line 9) | namespace rr {

FILE: src/perf-test/many-threads-wake.c
  function main (line 19) | int main(void) {

FILE: src/perf-test/many-threads.c
  function main (line 22) | int main(void) {

FILE: src/perf-test/unbuffered-syscalls.c
  function main (line 3) | int main(void) {

FILE: src/preload/overrides.c
  type timespec (line 43) | struct timespec
  function init_override (line 46) | static void __attribute__((constructor)) init_override(void) {
  function fix_mutex_kind (line 54) | static void fix_mutex_kind(pthread_mutex_t* mutex) {
  function pthread_mutex_init (line 78) | int pthread_mutex_init(pthread_mutex_t* mutex,
  function pthread_mutex_lock (line 130) | int pthread_mutex_lock(pthread_mutex_t* mutex) {
  function pthread_mutex_timedlock (line 142) | int pthread_mutex_timedlock(pthread_mutex_t* mutex,
  function pthread_mutex_trylock (line 154) | int pthread_mutex_trylock(pthread_mutex_t* mutex) {
  function XShmQueryExtension (line 180) | int XShmQueryExtension(__attribute__((unused)) void* dpy) { return 0; }
  function delayed_syscall (line 201) | void delayed_syscall(struct syscall_info* info) {
  type preload_thread_locals (line 216) | struct preload_thread_locals
  function spurious_desched_syscall (line 222) | void spurious_desched_syscall(struct syscall_info* info) {
  function sched_yield (line 239) | int sched_yield(void) {
  function uid_t (line 271) | uid_t geteuid(void) {
  function libstdcpp_not_found (line 279) | static void libstdcpp_not_found(void) {
  function _ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE (line 289) | void _ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_...
  function _ZNSt13random_device7_M_initERKSs (line 313) | void _ZNSt13random_device7_M_initERKSs(void* this,

FILE: src/preload/preload_interface.h
  function streq (line 23) | static inline int streq(const char* s1, const char* s2) {
  function rrstrlen (line 36) | static inline size_t rrstrlen(const char* s) {
  function streq (line 46) | static inline int streq(const char* s1, const char* s2) {
  function rrstrlen (line 49) | static inline size_t rrstrlen(const char* s) { return strlen(s); }
  function strprefix (line 56) | static inline int strprefix(const char* s1, const char* s2) {
  type syscall_patch_hook (line 213) | struct syscall_patch_hook {
  type mprotect_record (line 231) | struct mprotect_record {
  type ContextSwitchEventStrategy (line 238) | enum ContextSwitchEventStrategy {
  type preload_globals (line 253) | struct preload_globals {
  function TEMPLATE_ARCH (line 318) | TEMPLATE_ARCH
  function TEMPLATE_ARCH (line 324) | TEMPLATE_ARCH
  function TEMPLATE_ARCH (line 330) | TEMPLATE_ARCH
  function TEMPLATE_ARCH (line 346) | TEMPLATE_ARCH
  type preload_thread_locals (line 457) | struct preload_thread_locals
  type syscallbuf_fd_classes (line 462) | enum syscallbuf_fd_classes {
  function TEMPLATE_ARCH (line 485) | TEMPLATE_ARCH
  function TEMPLATE_ARCH (line 527) | TEMPLATE_ARCH
  type syscallbuf_record (line 546) | struct syscallbuf_record {
  type syscallbuf_hdr (line 584) | struct syscallbuf_hdr {
  type syscallbuf_hdr (line 638) | struct syscallbuf_hdr
  type syscallbuf_locked_why (line 646) | enum syscallbuf_locked_why {
  function stored_record_size (line 658) | inline static long stored_record_size(size_t length) {
  function is_blacklisted_filename (line 674) | inline static int is_blacklisted_filename(const char* filename) {
  function is_blacklisted_memfd (line 686) | inline static int is_blacklisted_memfd(const char* name) {
  function is_blacklisted_socket (line 690) | inline static int is_blacklisted_socket(const char* filename) {
  function is_gcrypt_deny_file (line 697) | inline static int is_gcrypt_deny_file(const char* filename) {
  function is_terminal (line 701) | inline static int is_terminal(const char* filename) {
  function is_proc_mem_file (line 705) | inline static int is_proc_mem_file(const char* filename) {
  function is_proc_fd_dir (line 712) | inline static int is_proc_fd_dir(const char* filename) {
  function is_sys_cpu_online_file (line 726) | inline static int is_sys_cpu_online_file(const char* filename) {
  function is_proc_stat_file (line 730) | inline static int is_proc_stat_file(const char* filename) {
  function is_rr_page_lib (line 734) | inline static int is_rr_page_lib(const char* filename) {
  function allow_buffered_open (line 746) | inline static int allow_buffered_open(const char* filename) {

FILE: src/preload/syscallbuf.c
  type btrfs_ioctl_clone_range_args (line 94) | struct btrfs_ioctl_clone_range_args {
  type rr_rseq (line 127) | struct rr_rseq {
  type rr_iovlen_t (line 143) | typedef size_t rr_iovlen_t;
  type rr_iovlen_t (line 145) | typedef int rr_iovlen_t;
  function _traced_init_syscall (line 148) | static long _traced_init_syscall(int syscallno, long a0, long a1, long a2,
  type rr_f_owner_ex (line 166) | struct rr_f_owner_ex {
  type rr_flock64 (line 174) | struct rr_flock64 {
  type kernel_sigset_t (line 186) | typedef uint64_t kernel_sigset_t;
  type preload_thread_locals (line 195) | struct preload_thread_locals
  type preload_thread_locals (line 196) | struct preload_thread_locals
  type syscallbuf_hdr (line 202) | struct syscallbuf_hdr
  type syscallbuf_hdr (line 203) | struct syscallbuf_hdr
  type syscallbuf_record (line 211) | struct syscallbuf_record
  type syscallbuf_hdr (line 212) | struct syscallbuf_hdr
  type syscallbuf_record (line 214) | struct syscallbuf_record
  function local_memcpy (line 237) | static void local_memcpy(void* dest, const void* source, int n) {
  function local_memset (line 287) | static void local_memset(void* dest, uint8_t c, int n) {
  function local_random (line 326) | static int64_t local_random(void) {
  function privileged_traced_syscall (line 349) | static int privileged_traced_syscall(int syscallno, long a0, long a1, lo...
  function traced_raw_syscall (line 371) | static long traced_raw_syscall(struct syscall_info* call) {
  function privileged_traced_raw_syscall (line 391) | static long privileged_traced_raw_syscall(const struct syscall_info* cal...
  function privileged_traced_fcntl (line 405) | static int privileged_traced_fcntl(int fd, int cmd, ...) {
  function pid_t (line 416) | static pid_t privileged_traced_getpid(void) {
  function pid_t (line 420) | static pid_t privileged_traced_gettid(void) {
  function privileged_traced_perf_event_open (line 424) | static int privileged_traced_perf_event_open(struct perf_event_attr* attr,
  function privileged_traced_raise (line 431) | static __attribute__((noreturn)) void privileged_traced_raise(int sig) {
  function privileged_traced_write (line 436) | static ssize_t privileged_traced_write(int fd, const void* buf, size_t c...
  function logmsg (line 440) | static void logmsg(const char* msg) {
  function untraced_syscall_full (line 475) | static long untraced_syscall_full(int syscallno, long a0, long a1, long a2,
  function untraced_replay_assist_syscall_base (line 549) | static long __attribute__((unused))
  function privileged_untraced_close (line 626) | static int privileged_untraced_close(int fd) {
  function privileged_untraced_fcntl (line 630) | static int privileged_untraced_fcntl(int fd, int cmd, ...) {
  function rrcall_init_buffers (line 656) | static void rrcall_init_buffers(struct rrcall_init_buffers_params* args) {
  function open_desched_event_counter (line 664) | static int open_desched_event_counter(pid_t tid) {
  function init_thread (line 727) | static void init_thread(void) {
  type syscall_info (line 773) | struct syscall_info
  type rrcall_init_preload_params (line 781) | struct rrcall_init_preload_params
  type syscall_patch_hook (line 792) | struct syscall_patch_hook
  type syscall_patch_hook (line 1082) | struct syscall_patch_hook
  type preload_thread_locals (line 1087) | struct preload_thread_locals
  type syscallbuf_record (line 1218) | struct syscallbuf_record
  function fd_class (line 1221) | static enum syscallbuf_fd_classes fd_class(int fd) {
  function is_bufferable_fd (line 1231) | static int is_bufferable_fd(int fd) {
  function arm_desched_event (line 1255) | static void arm_desched_event(void) {
  function disarm_desched_event (line 1268) | static void disarm_desched_event(void) {
  function fd_write_blocks (line 1286) | static int fd_write_blocks(int fd) {
  function start_commit_buffered_syscall (line 1303) | static int start_commit_buffered_syscall(int syscallno, void* record_end,
  function force_tick (line 1388) | static void force_tick(void) {
  function do_breakpoint (line 1400) | static void __attribute__((noinline)) do_breakpoint(size_t value)
  function commit_raw_syscall (line 1449) | static long commit_raw_syscall(int syscallno, void* record_end, long ret) {
  function memcpy_input_parameter (line 1561) | static void memcpy_input_parameter(void* buf, void* src, int size) {
  function rdtsc_recording_only (line 1622) | static void rdtsc_recording_only(uint32_t buf[2]) {
  function copy_futex_int (line 1644) | static void copy_futex_int(uint32_t* buf, uint32_t* real) {
  function force_traced_syscall_for_chaos_mode (line 1678) | static int force_traced_syscall_for_chaos_mode(void) {
  function sys_generic_nonblocking (line 1706) | static long sys_generic_nonblocking(struct syscall_info* call) {
  function sys_generic_nonblocking_fd (line 1722) | static long sys_generic_nonblocking_fd(struct syscall_info* call) {
  function privileged_sys_generic_nonblocking_fd (line 1739) | static long privileged_sys_generic_nonblocking_fd(const struct syscall_i...
  function sys_clock_gettime (line 1752) | static long sys_clock_gettime(struct syscall_info* call) {
  type kernel_timespec (line 1781) | struct kernel_timespec {
  function sys_clock_gettime64 (line 1786) | static long sys_clock_gettime64(struct syscall_info* call) {
  type syscall_info (line 1815) | struct syscall_info
  function sys_creat (line 1816) | static long sys_creat(struct syscall_info* call) {
  function sys_fcntl64_no_outparams (line 1829) | static int sys_fcntl64_no_outparams(struct syscall_info* call) {
  function sys_fcntl64_own_ex (line 1849) | static int sys_fcntl64_own_ex(struct syscall_info* call) {
  function sys_fcntl64_setlk64 (line 1879) | static int sys_fcntl64_setlk64(struct syscall_info* call) {
  function sys_fcntl64_setlkw64 (line 1913) | static int sys_fcntl64_setlkw64(struct syscall_info* call) {
  type syscall_info (line 1938) | struct syscall_info
  function sys_fcntl (line 1941) | static long sys_fcntl(struct syscall_info* call)
  function ret_buf_len (line 1990) | static long ret_buf_len(long ret, size_t len) {
  function sys_flistxattr (line 2000) | static long sys_flistxattr(struct syscall_info* call) {
  function sys_safe_nonblocking_ioctl (line 2025) | static long sys_safe_nonblocking_ioctl(struct syscall_info* call) {
  function sys_ioctl_fionread (line 2039) | static long sys_ioctl_fionread(struct syscall_info* call) {
  function sys_ioctl (line 2062) | static long sys_ioctl(struct syscall_info* call) {
  function sys_futex (line 2075) | static long sys_futex(struct syscall_info* call) {
  function sys_getrandom (line 2161) | static long sys_getrandom(struct syscall_info* call) {
  function sys_generic_getdents (line 2186) | static long sys_generic_getdents(struct syscall_info* call) {
  function sys_getdents (line 2209) | static long sys_getdents(struct syscall_info* call) {
  function sys_getdents64 (line 2214) | static long sys_getdents64(struct syscall_info* call) {
  function sys_gettimeofday (line 2218) | static long sys_gettimeofday(struct syscall_info* call) {
  function sys_generic_getxattr (line 2260) | static long sys_generic_getxattr(struct syscall_info* call) {
  function sys_getxattr (line 2283) | static long sys_getxattr(struct syscall_info* call) {
  function sys_lgetxattr (line 2287) | static long sys_lgetxattr(struct syscall_info* call) {
  function sys_fgetxattr (line 2291) | static long sys_fgetxattr(struct syscall_info* call) {
  function sys_generic_listxattr (line 2314) | static long sys_generic_listxattr(struct syscall_info* call) {
  function sys_listxattr (line 2336) | static long sys_listxattr(struct syscall_info* call) {
  function sys_llistxattr (line 2340) | static long sys_llistxattr(struct syscall_info* call) {
  function sys__llseek (line 2345) | static long sys__llseek(struct syscall_info* call) {
  function sys_madvise (line 2379) | static long sys_madvise(struct syscall_info* call) {
  function sys_mprotect (line 2442) | static long sys_mprotect(struct syscall_info* call) {
  function supported_open (line 2479) | static int supported_open(const char* file_name, int flags) {
  type syscall_info (line 2505) | struct syscall_info
  type check_open_state (line 2507) | struct check_open_state {
  function check_file_open_ok (line 2512) | static int check_file_open_ok(struct syscall_info* call, int ret, struct...
  function capture_check_open_state (line 2549) | static struct check_open_state capture_check_open_state(void) {
  function sys_open (line 2557) | static long sys_open(struct syscall_info* call) {
  function sys_openat (line 2588) | static long sys_openat(struct syscall_info* call) {
  function sys_openat2 (line 2620) | static long sys_openat2(struct syscall_info* call) {
  function __before_poll_syscall_breakpoint (line 2660) | __attribute__((visibility("protected"))) void __before_poll_syscall_brea...
  function sys_poll (line 2665) | static long sys_poll(struct syscall_info* call) {
  function sys_ppoll (line 2720) | static long sys_ppoll(struct syscall_info* call) {
  function sys_epoll_wait (line 2784) | static long sys_epoll_wait(struct syscall_info* call) {
  type timespec64 (line 2851) | struct timespec64 {
  function sys_epoll_pwait2 (line 2857) | static long sys_epoll_pwait2(struct syscall_info* call) {
  function sys_read (line 2923) | static long sys_read(struct syscall_info* call) {
  function sys_pread64 (line 3045) | static long sys_pread64(struct syscall_info* call) {
  function sys_readlink (line 3075) | static long sys_readlink(struct syscall_info* call) {
  function sys_readlinkat (line 3101) | static long sys_readlinkat(struct syscall_info* call, int privileged) {
  function sys_socketcall_recv (line 3135) | static long sys_socketcall_recv(struct syscall_info* call) {
  function sys_socketcall (line 3173) | static long sys_socketcall(struct syscall_info* call) {
  function sys_recvfrom (line 3184) | static long sys_recvfrom(struct syscall_info* call) {
  function msg_received_file_descriptors (line 3252) | static int msg_received_file_descriptors(struct msghdr* msg) {
  function sys_recvmsg (line 3262) | static long sys_recvmsg(struct syscall_info* call) {
  function sys_sendmsg (line 3373) | static long sys_sendmsg(struct syscall_info* call) {
  function sys_sendto (line 3400) | static long sys_sendto(struct syscall_info* call) {
  function sys_setsockopt (line 3431) | static long sys_setsockopt(struct syscall_info* call) {
  function sys_getsockopt (line 3471) | static long sys_getsockopt(struct syscall_info* call) {
  function sys_getsockname (line 3523) | static long sys_getsockname(struct syscall_info* call) {
  function sys_socketpair (line 3567) | static long sys_socketpair(struct syscall_info* call) {
  function sys_uname (line 3593) | static long sys_uname(struct syscall_info* call) {
  function sys_time (line 3618) | static long sys_time(struct syscall_info* call) {
  type stat64_t (line 3640) | typedef struct stat64 stat64_t;
  type stat64_t (line 3642) | typedef struct stat stat64_t;
  function sys_xstat64 (line 3644) | static long sys_xstat64(struct syscall_info* call) {
  function sys_statx (line 3674) | static long sys_statx(struct syscall_info* call) {
  function sys_fstatat (line 3699) | static long sys_fstatat(struct syscall_info* call) {
  function sys_quotactl (line 3726) | static long sys_quotactl(struct syscall_info* call) {
  function sys_statfs (line 3755) | static long sys_statfs(struct syscall_info* call) {
  function sys_write (line 3783) | static long sys_write(struct syscall_info* call) {
  function sys_pwrite64 (line 3812) | static long sys_pwrite64(struct syscall_info* call) {
  function sys_writev (line 3841) | static long sys_writev(struct syscall_info* call) {
  function sys_prctl (line 3866) | static long sys_prctl(struct syscall_info* call) {
  function sys_set_robust_list (line 3891) | static long sys_set_robust_list(struct syscall_info* call) {
  function sys_rseq (line 3918) | static long sys_rseq(struct syscall_info* call) {
  function sys_ptrace (line 3952) | static long sys_ptrace(struct syscall_info* call) {
  function sys_getrusage (line 4000) | static long sys_getrusage(struct syscall_info* call) {
  function sys_rt_sigprocmask (line 4025) | static long sys_rt_sigprocmask(struct syscall_info* call) {
  function sys_sigaltstack (line 4101) | static long sys_sigaltstack(struct syscall_info* call) {
  function sys_rrcall_rdtsc (line 4128) | static long sys_rrcall_rdtsc(struct syscall_info* call) {
  function syscall_hook_internal (line 4156) | static long syscall_hook_internal(struct syscall_info* call) {
  function do_delay (line 4358) | static void do_delay(void) {
  function syscall_hook (line 4371) | RR_HIDDEN long syscall_hook(struct syscall_info* call) {

FILE: src/preload/syscallbuf.h
  type timespec (line 6) | struct timespec

FILE: src/preload/tweak_librrpage.py
  function read_byte (line 21) | def read_byte(f):
  function read_uint64 (line 24) | def read_uint64(f):
  function write_uint64 (line 27) | def write_uint64(f, v):
  function read_uint32 (line 30) | def read_uint32(f):
  function write_uint32 (line 33) | def write_uint32(f, v):
  function read_uint16 (line 36) | def read_uint16(f):
  function seek_nth_section_sh_offset (line 39) | def seek_nth_section_sh_offset(f, shtable, e_shentsize, n, offset):
  function read_uptr (line 42) | def read_uptr(is64, f):
  function write_uptr (line 48) | def write_uptr(is64, f, v):

FILE: src/processor_trace_check.cc
  type rr (line 18) | namespace rr {
    function get_next_instruction (line 20) | static bool get_next_instruction(ReplayTask* t, ProcessorTraceDecoder&...
    function string (line 36) | static string intel_pt_context(ReplayTask* t, const vector<uint8_t>& r...
    function flatten_vector (line 82) | static vector<uint8_t> flatten_vector(const vector<vector<uint8_t>>& d...
    function check_intel_pt_internal (line 99) | static bool check_intel_pt_internal(ReplayTask* t,
    function check_intel_pt_if_enabled (line 176) | void check_intel_pt_if_enabled(ReplayTask* t) {
    function emergency_check_intel_pt (line 204) | void emergency_check_intel_pt(ReplayTask* t, ostream& stream) {

FILE: src/processor_trace_check.h
  function namespace (line 8) | namespace rr {

FILE: src/record_signal.cc
  type rr (line 32) | namespace rr {
    function restore_sighandler_if_not_default (line 34) | static void restore_sighandler_if_not_default(RecordTask* t, int sig) {
    function restore_signal_state (line 51) | static void restore_signal_state(RecordTask* t, int sig,
    function try_handle_trapped_instruction (line 78) | static bool try_handle_trapped_instruction(RecordTask* t, siginfo_t* s...
    function try_grow_map (line 165) | static bool try_grow_map(RecordTask* t, siginfo_t* si) {
    function disarm_desched_event (line 178) | void disarm_desched_event(RecordTask* t) {
    function arm_desched_event (line 185) | void arm_desched_event(RecordTask* t) {
    function desched_event_armed (line 192) | bool desched_event_armed(RecordTask *t) {
    function remote_code_ptr (line 207) | static remote_code_ptr get_stub_scratch_1_arch(RecordTask* t) {
    function remote_code_ptr (line 214) | static remote_code_ptr get_stub_scratch_1(RecordTask* t) {
    function get_stub_scratch_2_arch (line 219) | static void get_stub_scratch_2_arch(RecordTask* t, void *buff, size_t ...
    function get_stub_scratch_2 (line 226) | static void get_stub_scratch_2(RecordTask* t, void *buff, size_t sz) {
    function handle_syscallbuf_breakpoint (line 239) | bool handle_syscallbuf_breakpoint(RecordTask* t) {
    function handle_desched_event (line 343) | static void handle_desched_event(RecordTask* t) {
    function is_safe_to_deliver_signal (line 589) | static bool is_safe_to_deliver_signal(RecordTask* t, siginfo_t* si) {
    function SignalHandled (line 670) | SignalHandled handle_signal(RecordTask* t, siginfo_t* si,

FILE: src/record_signal.h
  function namespace (line 10) | namespace rr {

FILE: src/record_syscall.cc
  type termios2 (line 121) | struct termios2 {
  type rr (line 133) | namespace rr {
    type semid64_ds (line 137) | struct semid64_ds
    type seminfo (line 139) | struct seminfo
    function _shmctl (line 145) | static int _shmctl(int shmid, int cmd, shmid64_ds* buf) {
    function _semctl (line 161) | static int _semctl(int semid, int semnum, int cmd, _semun un_arg) {
    type ArgMode (line 181) | enum ArgMode {
    type ParamSize (line 204) | struct ParamSize {
      method ParamSize (line 205) | ParamSize() : incoming_size(size_t(-1)), from_syscall_multiplier(0) {}
      method ParamSize (line 208) | ParamSize(size_t incoming_size)
      method ParamSize (line 217) | static ParamSize from_initialized_mem(RecordTask* t, remote_ptr<T> p) {
      method ParamSize (line 228) | static ParamSize from_mem(remote_ptr<T> p) {
      method ParamSize (line 239) | static ParamSize from_syscall_result() {
      method ParamSize (line 246) | static ParamSize from_syscall_result(size_t incoming_size, uint32_t ...
      method ParamSize (line 255) | ParamSize limit_size(size_t max) const {
      method is_same_source (line 269) | bool is_same_source(const ParamSize& other) const {
    type TaskSyscallState (line 371) | struct TaskSyscallState : TaskSyscallStateBase {
      method TaskSyscallState (line 372) | static TaskSyscallState& get(RecordTask* t) {
      method TaskSyscallState (line 377) | static TaskSyscallState* maybe_get(RecordTask* t) {
      method init (line 382) | void init(RecordTask* t) {
      method reg_parameter (line 398) | remote_ptr<T> reg_parameter(int arg, ArgMode mode = OUT,
      method mem_ptr_parameter (line 422) | remote_ptr<T> mem_ptr_parameter(remote_ptr<void> addr_of_buf_ptr,
      method mem_ptr_parameter_inferred (line 438) | remote_ptr<typename Ptr::Referent> mem_ptr_parameter_inferred(
      method after_syscall_action (line 461) | void after_syscall_action(AfterSyscallAction action) {
      method emulate_result (line 465) | void emulate_result(uint64_t result) {
      type WriteBack (line 492) | enum WriteBack { WRITE_BACK, NO_WRITE_BACK }
      type MemoryParam (line 512) | struct MemoryParam {
        method MemoryParam (line 513) | MemoryParam() : ptr_in_reg(0) {}
      method TaskSyscallState (line 575) | TaskSyscallState()
    function set_remote_ptr_arch (line 585) | static void set_remote_ptr_arch(RecordTask* t, remote_ptr<void> addr,
    function set_remote_ptr (line 591) | static void set_remote_ptr(RecordTask* t, remote_ptr<void> addr,
    function get_remote_ptr_arch (line 597) | static remote_ptr<void> get_remote_ptr_arch(RecordTask* t,
    function get_remote_ptr (line 604) | static remote_ptr<void> get_remote_ptr(RecordTask* t, remote_ptr<void>...
    function align_scratch (line 608) | static void align_scratch(remote_ptr<void>* scratch, uintptr_t amount ...
    function Switchable (line 682) | Switchable TaskSyscallState::done_preparing_internal(Switchable sw) {
    function Switchable (line 753) | Switchable TaskSyscallState::done_preparing(Switchable sw) {
    function prepare_recvmsg (line 941) | static void prepare_recvmsg(RecordTask* t, TaskSyscallState& syscall_s...
    function prepare_recvmmsg (line 967) | static void prepare_recvmmsg(RecordTask* t, TaskSyscallState& syscall_...
    function block_sock_opt (line 977) | static bool block_sock_opt(int level, int optname,
    function Switchable (line 1001) | static Switchable prepare_setsockopt(RecordTask* t,
    function Switchable (line 1035) | static Switchable maybe_blacklist_connect(RecordTask* t,
    function Switchable (line 1055) | static Switchable prepare_socketcall(RecordTask* t,
    function Switchable (line 1256) | static Switchable prepare_msgctl(TaskSyscallState& syscall_state, int ...
    function Switchable (line 1280) | static Switchable prepare_shmctl(TaskSyscallState& syscall_state, int ...
    type SemctlDereference (line 1309) | enum SemctlDereference { DEREFERENCE, USE_DIRECTLY }
    function Switchable (line 1312) | static Switchable prepare_semctl(RecordTask* t, TaskSyscallState& sysc...
    function record_v4l2_buffer_change (line 1381) | static void record_v4l2_buffer_change(RecordTask* t, int fd, uint64_t ...
    function record_v4l2_buffer_contents (line 1393) | static void record_v4l2_buffer_contents(RecordTask* t) {
    function record_usbdevfs_reaped_urb (line 1408) | static void record_usbdevfs_reaped_urb(RecordTask* t) {
    function record_page_below_stack_ptr (line 1436) | static void record_page_below_stack_ptr(RecordTask* t) {
    function get_ethtool_gstrings_arch (line 1449) | void get_ethtool_gstrings_arch(RecordTask* t) {
    function get_ethtool_gstrings (line 1508) | static void get_ethtool_gstrings(RecordTask* t) {
    function prepare_ethtool_ioctl (line 1512) | void prepare_ethtool_ioctl(RecordTask* t, TaskSyscallState& syscall_st...
    function Switchable (line 1644) | static Switchable prepare_ioctl(RecordTask* t,
    function BpfMapMonitor (line 2241) | static BpfMapMonitor* bpf_map_monitor(RecordTask* t,
    function Switchable (line 2253) | static Switchable prepare_bpf(RecordTask* t,
    function maybe_emulate_wait (line 2364) | static bool maybe_emulate_wait(RecordTask* t, TaskSyscallState& syscal...
    function maybe_pause_instead_of_waiting (line 2398) | static void maybe_pause_instead_of_waiting(RecordTask* t) {
    function RecordTask (line 2430) | static RecordTask* verify_ptrace_target(RecordTask* tracer,
    function prepare_ptrace_cont (line 2453) | static void prepare_ptrace_cont(RecordTask* tracee, int sig, int comma...
    function widen_buffer_unsigned (line 2478) | static uint64_t widen_buffer_unsigned(const void* buf, size_t size) {
    function widen_buffer_signed (line 2494) | static int64_t widen_buffer_signed(const void* buf, size_t size) {
    function path_inode_number (line 2510) | static uint64_t path_inode_number(const char* path) {
    function is_same_namespace (line 2517) | static bool is_same_namespace(const char* name, pid_t tid1, pid_t tid2) {
    function ptrace_get_reg_set (line 2526) | static void ptrace_get_reg_set(RecordTask* t, TaskSyscallState& syscal...
    function ptrace_verify_set_reg_set (line 2539) | static void ptrace_verify_set_reg_set(RecordTask* t, size_t min_size,
    function verify_ptrace_options (line 2549) | static bool verify_ptrace_options(RecordTask* t,
    function check_ptracer_compatible (line 2564) | static void check_ptracer_compatible(RecordTask* tracer, RecordTask* t...
    function RecordTask (line 2571) | static RecordTask* prepare_ptrace_attach(RecordTask* tracer, pid_t att...
    function RecordTask (line 2596) | static RecordTask* prepare_ptrace_traceme(RecordTask* tracee,
    function ptrace_attach_to_already_stopped_task (line 2624) | static void ptrace_attach_to_already_stopped_task(RecordTask* t) {
    function prepare_ptrace_legacy (line 2643) | static void prepare_ptrace_legacy(RecordTask* t,
  function non_negative_command (line 2799) | static int non_negative_command(int command) { return command < 0 ? INT3...
  function Switchable (line 2802) | static Switchable prepare_ptrace(RecordTask* t,
  function check_signals_while_exiting (line 3316) | static void check_signals_while_exiting(RecordTask* t) {
  function send_signal_during_init_buffers (line 3330) | static bool send_signal_during_init_buffers() {
  function prepare_exit (line 3342) | static void prepare_exit(RecordTask* t) {
  function prepare_mmap_register_params (line 3404) | static void prepare_mmap_register_params(RecordTask* t) {
  type ScratchAddrType (line 3458) | enum ScratchAddrType { FIXED_ADDRESS, DYNAMIC_ADDRESS }
  function init_scratch_memory (line 3464) | static void init_scratch_memory(RecordTask* t,
  function ptrace_option_for_event (line 3509) | static int ptrace_option_for_event(int ptrace_event) {
  function Switchable (line 3524) | static Switchable prepare_clone(RecordTask* t, TaskSyscallState& syscall...
  function protect_rr_sigs (line 3673) | static bool protect_rr_sigs(RecordTask* t, remote_ptr<void> p, void* sav...
  function protect_rr_sigs_sa_mask_arch (line 3695) | static bool protect_rr_sigs_sa_mask_arch(RecordTask* t, remote_ptr<void> p,
  function protect_rr_sigs_sa_mask (line 3722) | static bool protect_rr_sigs_sa_mask(RecordTask* t, remote_ptr<void> p,
  function record_ranges (line 3727) | static void record_ranges(RecordTask* t,
  function pid_t (line 3740) | static pid_t do_detach_teleport(RecordTask *t)
  function Switchable (line 3793) | static Switchable did_emulate_read(int syscallno, RecordTask* t,
  function ParamSize (line 3816) | static ParamSize select_param_size(intptr_t nfds, SupportedArch arch) {
  function Switchable (line 3827) | static Switchable rec_prepare_syscall_arch(RecordTask* t,
  function Switchable (line 5565) | static Switchable rec_prepare_syscall_internal(
  function Switchable (line 5575) | Switchable rec_prepare_syscall(RecordTask* t) {
  function rec_abort_prepared_syscall (line 5584) | void rec_abort_prepared_syscall(RecordTask* t) {
  function rec_return_normally_from_wait (line 5593) | bool rec_return_normally_from_wait(RecordTask* t) {
  function aarch64_kernel_bug_workaround (line 5607) | static void aarch64_kernel_bug_workaround(RecordTask *t,
  function rec_prepare_restart_syscall_arch (line 5623) | static void rec_prepare_restart_syscall_arch(RecordTask* t,
  function rec_prepare_restart_syscall_internal (line 5667) | static void rec_prepare_restart_syscall_internal(
  function rec_prepare_restart_syscall (line 5673) | void rec_prepare_restart_syscall(RecordTask* t) {
  function is_privileged_executable (line 5687) | static bool is_privileged_executable(RecordTask* t, const string& path) {
  function in_same_mount_namespace_as (line 5710) | static bool in_same_mount_namespace_as(RecordTask* t) {
  function check_privileged_exe (line 5719) | static void check_privileged_exe(RecordTask* t) {
  function word_at (line 5755) | static uint64_t word_at(uint8_t* buf, size_t wsize) {
  function get_exe_entry_interp_base (line 5765) | static pair<remote_ptr<void>, remote_ptr<void>> get_exe_entry_interp_bas...
  function string (line 5786) | static string try_make_process_file_name(RecordTask* t,
  type PageState (line 5817) | enum class PageState {
  function find_pages (line 5823) | static vector<MemoryRange> find_pages(RecordTask* t, MemoryRange range, ...
  function process_execve (line 5861) | static void process_execve(RecordTask* t, TaskSyscallState& syscall_stat...
  function is_writable (line 6063) | static bool is_writable(RecordTask* t, int fd) {
  function monitor_fd_for_mapping (line 6070) | static bool monitor_fd_for_mapping(RecordTask* mapped_t, int mapped_fd, ...
  function os_has_broken_zfs (line 6131) | static bool os_has_broken_zfs() {
  function may_have_zfs_seek_bug (line 6162) | static bool may_have_zfs_seek_bug(ScopedFd& fd) {
  function find_holes (line 6184) | static vector<WriteHole> find_holes(RecordTask* t, int desc, uint64_t of...
  function check_outside_mappings (line 6226) | static void check_outside_mappings(const KernelMapping& tracee_km, const...
  function process_mmap (line 6271) | static void process_mmap(RecordTask* t, size_t length, int prot, int flags,
  function process_mremap (line 6412) | static void process_mremap(RecordTask* t, remote_ptr<void> old_addr,
  function process_shmat (line 6460) | static void process_shmat(RecordTask* t, int shmid, int shm_flags,
  function maybe_process_new_socket (line 6495) | static void maybe_process_new_socket(RecordTask* t, int fd) {
  function string (line 6510) | static string extra_expected_errno_info(RecordTask* t,
  function is_rr_fd_terminal (line 6597) | static bool is_rr_fd_terminal(int fd, const string& pathname) {
  function is_rr_terminal (line 6606) | static bool is_rr_terminal(const string& pathname) {
  function dev_tty_fd (line 6620) | static int dev_tty_fd() {
  function record_iovec_output (line 6629) | static void record_iovec_output(RecordTask* t, RecordTask* dest,
  function all_tasks_exited (line 6640) | static bool all_tasks_exited(AddressSpace* vm) {
  function is_mapped_shared (line 6649) | static bool is_mapped_shared(RecordTask* t, const struct stat& st) {
  function string (line 6669) | static string handle_opened_file(RecordTask* t, int fd, int flags) {
  function check_scm_rights_fd (line 6732) | static void check_scm_rights_fd(RecordTask* t, typename Arch::msghdr& ms...
  function fake_gcrypt_file (line 6759) | static void fake_gcrypt_file(RecordTask* t, Registers* r) {
  function record_madvise (line 6793) | static void record_madvise(RecordTask* t) {
  function rec_process_syscall_arch (line 6839) | static void rec_process_syscall_arch(RecordTask* t,
  function rec_did_sigreturn (line 7465) | void rec_did_sigreturn(RecordTask *t) {
  function rec_process_syscall (line 7471) | void rec_process_syscall(RecordTask* t) {

FILE: src/record_syscall.h
  function namespace (line 8) | namespace rr {

FILE: src/remote_code_ptr.cc
  type rr (line 7) | namespace rr {
    function ostream (line 9) | ostream& operator<<(ostream& stream, remote_code_ptr p) {

FILE: src/remote_code_ptr.h
  function namespace (line 9) | namespace rr {
  function namespace (line 115) | namespace std {

FILE: src/remote_ptr.h
  function namespace (line 10) | namespace rr {
  function T (line 92) | T* dummy() { return nullptr; }
  function T (line 93) | const T* dummy() const { return nullptr; }
  function referent_size (line 95) | size_t referent_size() { return sizeof(T); }
  function arith_size (line 99) | static size_t arith_size() { return pointer_arithmetic_size<T>(); }

FILE: src/replay_syscall.cc
  type rr (line 62) | namespace rr {
    function init_scratch_memory (line 74) | static void init_scratch_memory(ReplayTask* t, const KernelMapping& km,
    function maybe_noop_restore_syscallbuf_scratch (line 112) | static void maybe_noop_restore_syscallbuf_scratch(ReplayTask* t) {
    function TraceTaskEvent (line 121) | static TraceTaskEvent read_task_trace_event(ReplayTask* t,
    function syscall_shares_vm (line 138) | static bool syscall_shares_vm(Registers r)
    function prepare_clone (line 153) | static void prepare_clone(ReplayTask* t) {
    function restore_mapped_region (line 318) | static void restore_mapped_region(ReplayTask* t, AutoRemoteSyscalls& r...
    function process_execve (line 360) | static void process_execve(ReplayTask* t, const TraceFrame& trace_frame,
    function process_brk (line 504) | static void process_brk(ReplayTask* t) {
    function finish_anonymous_mmap (line 526) | static void finish_anonymous_mmap(ReplayTask* t, AutoRemoteSyscalls& r...
    function write_mapped_data (line 557) | static void write_mapped_data(ReplayTask* t,
    function finish_private_mmap (line 599) | static void finish_private_mmap(ReplayTask* t, AutoRemoteSyscalls& rem...
    function finish_shared_mmap (line 622) | static void finish_shared_mmap(ReplayTask* t, AutoRemoteSyscalls& remote,
    function process_mmap (line 681) | static void process_mmap(ReplayTask* t, const TraceFrame& trace_frame,
    function process_mremap (line 773) | static void process_mremap(ReplayTask* t, const TraceFrame& trace_frame,
    function process_grow_map (line 870) | void process_grow_map(ReplayTask* t) {
    function process_shmat (line 878) | static void process_shmat(ReplayTask* t, const TraceFrame& trace_frame,
    function process_shmdt (line 902) | static void process_shmdt(ReplayTask* t, const TraceFrame& trace_frame,
    function process_madvise (line 917) | static bool process_madvise(ReplayTask* t, const TraceFrame& trace_frame,
    function process_init_buffers (line 958) | static void process_init_buffers(ReplayTask* t, ReplayTraceStep* step) {
    function non_negative_syscall (line 968) | static int non_negative_syscall(int sys) { return sys < 0 ? INT32_MAX ...
    function rep_after_enter_syscall_arch (line 971) | static void rep_after_enter_syscall_arch(ReplayTask* t) {
    function rep_prepare_run_to_syscall (line 1043) | void rep_prepare_run_to_syscall(ReplayTask* t, ReplayTraceStep* step) {
    function handle_opened_files (line 1068) | static void handle_opened_files(ReplayTask* t, int flags) {
    function rep_process_syscall_arch (line 1098) | static void rep_process_syscall_arch(ReplayTask* t, ReplayTraceStep* s...
    function rep_process_syscall (line 1406) | void rep_process_syscall(ReplayTask* t, ReplayTraceStep* step) {

FILE: src/replay_syscall.h
  function namespace (line 8) | namespace rr {

FILE: src/seccomp-bpf.h
  type seccomp_data (line 57) | struct seccomp_data {
  function namespace (line 65) | namespace rr {

FILE: src/syscalls.py
  class BaseSyscall (line 1) | class BaseSyscall(object):
    method __init__ (line 10) | def __init__(self, all=None, x86=None, x64=None, generic=None, **kwargs):
  class RestartSyscall (line 21) | class RestartSyscall(BaseSyscall):
    method __init__ (line 23) | def __init__(self, **kwargs):
  class UnsupportedSyscall (line 26) | class UnsupportedSyscall(BaseSyscall):
    method __init__ (line 33) | def __init__(self, **kwargs):
  class InvalidSyscall (line 36) | class InvalidSyscall(UnsupportedSyscall):
    method __init__ (line 43) | def __init__(self, **kwargs):
  class RegularSyscall (line 46) | class RegularSyscall(BaseSyscall):
    method __init__ (line 59) | def __init__(self, **kwargs):
  class EmulatedSyscall (line 67) | class EmulatedSyscall(RegularSyscall):
    method __init__ (line 70) | def __init__(self, **kwargs):
  class IrregularEmulatedSyscall (line 73) | class IrregularEmulatedSyscall(BaseSyscall):
    method __init__ (line 76) | def __init__(self, **kwargs):
  function _syscalls (line 1820) | def _syscalls():
  function all (line 1825) | def all():
  function for_arch (line 1828) | def for_arch(arch):

FILE: src/test-monitor/test-monitor.cc
  function print_usage (line 22) | static void print_usage(FILE* out) {
  function sighandler (line 43) | static void sighandler(__attribute__((unused)) int sig, siginfo_t* si,
  type ProcessInfo (line 48) | struct ProcessInfo {
    method ProcessInfo (line 49) | ProcessInfo() : is_traced(false) {}
  type ProcessMap (line 55) | struct ProcessMap {
  type dirent (line 68) | struct dirent
  function dump_proc_for_process (line 115) | static void dump_proc_for_process(pid_t child, const char* suffix, FILE*...
  function dump_popen_cmdline (line 131) | static void dump_popen_cmdline(const char* cmdline, FILE* out) {
  function dump_gdb_stacktrace (line 183) | static void dump_gdb_stacktrace(pid_t child, FILE* out) {
  function force_trace_closure (line 191) | static void force_trace_closure(pid_t child, FILE* out) {
  function dump_emergency_debugger (line 205) | static void dump_emergency_debugger(char* gdb_cmd, FILE* out) {
  function get_child_threads (line 227) | static vector<pid_t> get_child_threads(pid_t pid) {
  function dump_subtree (line 251) | static void dump_subtree(ProcessMap& child_processes,
  function dump_state_and_kill (line 281) | static void dump_state_and_kill(pid_t child, const char* out_file_name) {
  function main (line 346) | int main(int argc, char* argv[]) {

FILE: src/test/64bit_child.c
  function callback (line 5) | void callback(uint64_t env, char *name, __attribute__((unused)) map_prop...
  function skip_if_rr_32_bit_under_kernel_64_bit (line 17) | static void skip_if_rr_32_bit_under_kernel_64_bit(void) {
  function main (line 35) | int main(void) {

FILE: src/test/_llseek.c
  function main (line 5) | int main(__attribute__((unused)) int argc, char* argv[]) {

FILE: src/test/abort.c
  function main (line 5) | int main(void) {

FILE: src/test/abort_nonmain.c
  function main (line 12) | int main(void) {

FILE: src/test/accept.c
  function client (line 5) | static void client(const struct sockaddr_un* addr) {
  function server (line 27) | static void server(int use_accept4, int pass_addr) {
  function main (line 71) | int main(void) {

FILE: src/test/acct.c
  function main (line 5) | int main(void) {

FILE: src/test/adjtimex.c
  function main (line 7) | int main(void) {

FILE: src/test/aio.c
  function main (line 5) | int main(void) {

FILE: src/test/alarm.c
  function breakpoint (line 5) | static void breakpoint(void) {}
  function catcher (line 9) | void catcher(__attribute__((unused)) int signum,
  function main (line 15) | int main(void) {

FILE: src/test/alarm2.c
  function catcher (line 5) | void catcher(__attribute__((unused)) int signum,
  function main (line 12) | int main(void) {

FILE: src/test/alsa_ioctl.c
  function main (line 9) | int main(void) {

FILE: src/test/alternate_thread_diversion.c
  function get_value (line 5) | __attribute__((used)) static int get_value(void) { return value; }
  function break_here (line 7) | __attribute__((noinline)) static void break_here(void) { __asm__(""); }
  function main (line 18) | int main(void) {

FILE: src/test/args.c
  function main (line 5) | int main(int argc, char* argv[]) {

FILE: src/test/arm/arch_timer.c
  function cntfrq (line 14) | long cntfrq(void) {
  function cntvct (line 20) | long cntvct(void) {
  function cntvctss (line 26) | long cntvctss(void) {
  function arch_timer_nops (line 39) | void arch_timer_nops(void) {
  function diversion_check (line 47) | void diversion_check(void) {
  function breakpoint (line 55) | void breakpoint(void) {}
  function main (line 57) | int main(void) {

FILE: src/test/arm/brk_nonzero.c
  function breakpoint (line 5) | static void breakpoint(void) {
  function handle_sigtrap (line 9) | static void handle_sigtrap(__attribute__((unused)) int sig) {
  function main (line 14) | int main(void) {

FILE: src/test/arm/tagged_addr_ctrl.c
  function main (line 7) | int main(void) {

FILE: src/test/async_kill_with_syscallbuf.c
  function main (line 5) | int main(void) {

FILE: src/test/async_kill_with_syscallbuf2.c
  function main (line 5) | int main(void) {

FILE: src/test/async_kill_with_threads.c
  function main (line 11) | int main(void) {

FILE: src/test/async_kill_with_threads_main_running.c
  function main (line 10) | int main(void) {

FILE: src/test/async_kill_with_threads_thread_running.c
  function main (line 13) | int main(void) {

FILE: src/test/async_segv.c
  function handle_segv (line 5) | static void handle_segv(int sig) {
  function main (line 11) | int main(void) {

FILE: src/test/async_segv_ignored.c
  function main (line 5) | int main(void) {

FILE: src/test/async_signal_syscalls.c
  function handle_usr1 (line 7) | static void handle_usr1(int sig) {
  function main (line 20) | int main(int argc, char* argv[]) {

FILE: src/test/async_signal_syscalls2.c
  function handle_signal (line 14) | static void handle_signal(int sig) {
  type timespec (line 33) | struct timespec
  function main (line 67) | int main(void) {

FILE: src/test/async_signal_syscalls_siginfo.c
  function handle_usr1 (line 10) | static void handle_usr1(int sig, siginfo_t* si,
  function main (line 34) | int main(int argc, char* argv[]) {

FILE: src/test/async_usr1.c
  function handle_usr1 (line 7) | static void handle_usr1(int sig) {
  function breakpoint (line 13) | static void breakpoint(void) {
  function main (line 18) | int main(void) {

FILE: src/test/at_threadexit.c
  function thread_exit (line 8) | static void thread_exit(__attribute__((unused)) void* data) {
  function main (line 18) | int main(void) {

FILE: src/test/bad_ip.c
  function sighandler (line 5) | static void sighandler(int sig, siginfo_t* si,
  function main (line 13) | int main(void) {

FILE: src/test/bad_syscall.c
  function main (line 5) | int main(void) {

FILE: src/test/barrier.c
  function breakpoint (line 5) | static void breakpoint(void) {
  function hit_barrier (line 10) | static void hit_barrier(void) {
  function joined_threads (line 15) | static void joined_threads(void) {
  function set_thread_name (line 20) | static void set_thread_name(int id) {
  type thread_data (line 26) | struct thread_data {
  type thread_data (line 32) | struct thread_data
  function main (line 47) | int main(void) {

FILE: src/test/big_buffers.c
  function main (line 8) | int main(void) {

FILE: src/test/big_select.c
  function main (line 7) | int main(void) {

FILE: src/test/blacklist.c
  function main (line 7) | int main(void) {

FILE: src/test/block.c
  type sendmmsg_arg (line 8) | struct sendmmsg_arg {
  type recvmmsg_arg (line 15) | struct recvmmsg_arg {
  type select_arg (line 23) | struct select_arg {
  function breakpoint (line 31) | static void breakpoint(void) {
  type timeval (line 45) | struct timeval
  type sockaddr_un (line 79) | struct sockaddr_un
  type sockaddr (line 83) | struct sockaddr
  type mmsghdr (line 92) | struct mmsghdr
  type iovec (line 93) | struct iovec
  type recvmmsg_arg (line 97) | struct recvmmsg_arg
  type cmsghdr (line 107) | struct cmsghdr
  type cmsghdr (line 107) | struct cmsghdr
  type stat (line 128) | struct stat
  type msghdr (line 165) | struct msghdr
  type iovec (line 166) | struct iovec
  type pollfd (line 188) | struct pollfd
  type pollfd (line 202) | struct pollfd
  type timeval (line 217) | struct timeval
  type timeval (line 218) | struct timeval
  type select_arg (line 221) | struct select_arg
  type timeval (line 254) | struct timeval
  type timeval (line 255) | struct timeval
  type epoll_event (line 276) | struct epoll_event
  type iovec (line 300) | struct iovec
  function read_all_chunks (line 347) | static void read_all_chunks(int sock, char* buf, ssize_t num_sockbuf_bytes,
  function main (line 376) | int main(void) {

FILE: src/test/block_clone_checkpoint.c
  function breakpoint (line 7) | static void breakpoint(void) { event_syscall(); }
  function main (line 9) | int main(void) {

FILE: src/test/block_clone_interrupted.c
  function main (line 9) | int main(void) {

FILE: src/test/block_clone_syscallbuf_overflow.c
  function main (line 9) | int main(void) {

FILE: src/test/block_intr_sigchld.c
  function child_proc (line 13) | static void child_proc(void) { exit(MAGIC_EXIT_CODE); }
  function main (line 33) | int main(void) {

FILE: src/test/block_open.c
  function try_open (line 5) | static int try_open(int flags) { return open("fifo", flags); }
  function try_openat (line 7) | static int try_openat(int flags) { return openat(AT_FDCWD, "fifo", flags...
  function do_test (line 9) | static void do_test(int (*func)(int)) {
  function main (line 33) | int main(void) {

FILE: src/test/blocked_bad_ip.c
  function fault_handler (line 5) | static void fault_handler(__attribute__((unused)) int sig,
  function main (line 27) | int main(void) {

FILE: src/test/blocked_sigill.c
  function fault_handler (line 5) | static void fault_handler(__attribute__((unused)) int sig,
  function main (line 25) | int main(void) {

FILE: src/test/bpf.c
  function bpf (line 6) | int bpf(int cmd, union bpf_attr *attr, unsigned int size)
  function main (line 11) | int main(void) {

FILE: src/test/bpf_map.c
  function bpf (line 6) | int bpf(int cmd, union bpf_attr *attr, unsigned int size)
  function main (line 11) | int main(void) {

FILE: src/test/bpf_prog_map.c
  function bpf (line 13) | int bpf(int cmd, union bpf_attr *attr, unsigned int size) {
  type bpf_insn (line 17) | struct bpf_insn
  function main (line 24) | int main(void) {

FILE: src/test/bpf_query.c
  function bpf (line 15) | int bpf(int cmd, union bpf_attr *attr, unsigned int size) {
  type bpf_insn (line 19) | struct bpf_insn
  function main (line 26) | int main(void) {

FILE: src/test/breakpoint.c
  function C (line 5) | static void C(void) { atomic_puts("in C"); }
  function B (line 13) | static void B(void)
  function A (line 19) | static void A(void)
  function main (line 25) | int main(void) {

FILE: src/test/breakpoint_conditions.c
  function breakpointA (line 5) | static void breakpointA(__attribute__((unused)) int v4) {
  function breakpointB (line 10) | static void breakpointB(__attribute__((unused)) int v4) {
  function main (line 24) | int main(void) {

FILE: src/test/breakpoint_conditions.py
  function test_cond (line 3) | def test_cond(c):

FILE: src/test/breakpoint_overlap.c
  function main (line 42) | int main(__attribute__((unused)) int argc, char* argv[]) {

FILE: src/test/brk.c
  function main (line 5) | int main(void) {

FILE: src/test/brk2.c
  function main (line 5) | int main(void) {

FILE: src/test/call_function.c
  function breakpoint (line 7) | static void breakpoint(void) {
  function mutate_var (line 12) | void mutat

[
  {
    "path": ".android/Dockerfile",
    "chars": 737,
    "preview": "FROM ubuntu:latest\n\nARG ndk_version=r27c\n\nRUN apt-get update && apt-get install -y \\\n    build-essential \\\n    curl \\\n  "
  },
  {
    "path": ".android/README.md",
    "chars": 663,
    "preview": "# Building for Android\n\nTo build for Android (from the root of the rr source tree):\n\n```\ndocker build .android -t rr-and"
  },
  {
    "path": ".android/build.sh",
    "chars": 918,
    "preview": "#!/usr/bin/env bash\nset -e\nset -x\n\nDEVICE_CMAKE_DEFS=\"-DCMAKE_TOOLCHAIN_FILE=/ndk/build/cmake/android.toolchain.cmake -D"
  },
  {
    "path": ".buildkite/.gitignore",
    "chars": 20,
    "preview": "test.yml\ntest-*.yml\n"
  },
  {
    "path": ".buildkite/CTestCostData.txt",
    "chars": 99932,
    "preview": "check_environment 2 0.0177417\n64bit_child 2 0.388554\n64bit_child-no-syscallbuf 2 0.343397\n_llseek 2 0.178732\n_llseek-no-"
  },
  {
    "path": ".buildkite/Manifest.toml",
    "chars": 3766,
    "preview": "# This file is machine-generated - editing it directly is not advised\n\njulia_version = \"1.7.2\"\nmanifest_format = \"2.0\"\n\n"
  },
  {
    "path": ".buildkite/Project.toml",
    "chars": 53,
    "preview": "[deps]\nYAML = \"ddb6d928-2868-570f-bddf-ab3f9cf99eb6\"\n"
  },
  {
    "path": ".buildkite/capture_tmpdir.jl",
    "chars": 4713,
    "preview": "import Dates\nimport Pkg\nimport Tar\n\nfunction my_exit(process::Base.Process)\n    wait(process)\n\n    @info(\n        \"\",\n  "
  },
  {
    "path": ".buildkite/pipeline.yml",
    "chars": 720,
    "preview": "steps:\n  - label: \"Launch jobs\"\n    plugins:\n      - JuliaCI/julia#v1:\n          persist_depot_dirs: packages,artifacts,"
  },
  {
    "path": ".clang-format",
    "chars": 1390,
    "preview": "# BasedOnStyle:  Mozilla\nAccessModifierOffset: -2\nConstructorInitializerIndentWidth: 4\nAlignEscapedNewlinesLeft: false\nA"
  },
  {
    "path": ".github/workflows/android-build.yml",
    "chars": 657,
    "preview": "name: Android Build\n\non: [push, pull_request]\n\njobs:\n  android-build:\n    name: Android Build\n    runs-on: ubuntu-latest"
  },
  {
    "path": ".github/workflows/build-and-test-main.yml",
    "chars": 1656,
    "preview": "name: Build and test\n\non: [push, pull_request]\n\njobs:\n  setup:\n    name: Setup runners\n    runs-on: ubuntu-latest\n    if"
  },
  {
    "path": ".github/workflows/build-and-test.yml",
    "chars": 805,
    "preview": "name: Build and test on runner\n\non:\n  workflow_call:\n    inputs:\n      label:\n        required: true\n        type: strin"
  },
  {
    "path": ".gitignore",
    "chars": 742,
    "preview": "*~\n.cache\n.cproject\nCMakeCache.txt\nCMakeFiles/\ncmake_install.cmake\nCPackConfig.cmake\nCPackSourceConfig.cmake\n_CPack_Pack"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 69962,
    "preview": "# *-* Mode: cmake; *-*\n\ncmake_minimum_required(VERSION 3.12)\nproject(rr C CXX ASM)\n\n# Require c++17 as minimum\nif(NOT DE"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 691,
    "preview": "# Community Participation Guidelines\n\nThis repository is governed by Mozilla's code of conduct and etiquette guidelines."
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 3761,
    "preview": "## Submission Checklist\n\nPlease make sure you go through this list before submitting a patch.  The rules aren't hard and"
  },
  {
    "path": "LICENSE",
    "chars": 22309,
    "preview": "Copyright (c) 2013 Mozilla Foundation\nCopyright 2015 VMware, Inc\nCopyright 2015 Google Inc.\n\nContributors: Albert Noll <"
  },
  {
    "path": "README.md",
    "chars": 1942,
    "preview": "# Overview\n\n[![Build and test status](https://github.com/rr-debugger/rr/actions/workflows/build-and-test-main.yml/badge."
  },
  {
    "path": "Vagrantfile",
    "chars": 1249,
    "preview": "# -*- mode: ruby -*-\n# vi: set ft=ruby :\n# Author: David Manouchehri\n\nVagrant.configure(\"2\") do |config|\n\tconfig.vm.box "
  },
  {
    "path": "configure",
    "chars": 88,
    "preview": "#!/usr/bin/env bash\n\n# Helper to make |./configure && make| do what you expect.\ncmake .\n"
  },
  {
    "path": "include/rr/rr.h",
    "chars": 1339,
    "preview": "/* -*- Mode: C; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_H_\n#define RR_H_\n\n/**\n * rr t"
  },
  {
    "path": "release-process/README.md",
    "chars": 4079,
    "preview": "# Setting up AWS-based rr release testing\n\n* Create an AWS account.\n* Switch to the `us-east-2` (Ohio) region. The AMI I"
  },
  {
    "path": "release-process/distro-configs/centos9.json",
    "chars": 922,
    "preview": "{\n  \"name\": \"CentOS Stream 9\",\n  \"ami_owner\": \"125523088429\",\n  \"ami_name_pattern\": \"CentOS Stream 9 *\",\n  \"user\": \"ec2-"
  },
  {
    "path": "release-process/distro-configs/debian11.json",
    "chars": 844,
    "preview": "{\n  \"name\": \"Debian 11\",\n  \"ami_owner\": \"136693071363\",\n  \"ami_name_pattern\": \"debian-11-*\",\n  \"user\": \"admin\",\n  \"setup"
  },
  {
    "path": "release-process/distro-configs/debian12.json",
    "chars": 887,
    "preview": "{\n  \"name\": \"Debian 12\",\n  \"ami_owner\": \"136693071363\",\n  \"ami_name_pattern\": \"debian-12-*\",\n  \"user\": \"admin\",\n  \"archs"
  },
  {
    "path": "release-process/distro-configs/ubuntu20-lts.json",
    "chars": 827,
    "preview": "{\n  \"name\": \"Ubuntu 20.04 LTS\",\n  \"ami_owner\": \"099720109477\",\n  \"ami_name_pattern\": \"ubuntu/images/hvm-ssd/ubuntu-focal"
  },
  {
    "path": "release-process/distro-configs/ubuntu22-lts.json",
    "chars": 922,
    "preview": "{\n  \"name\": \"Ubuntu 22.04 LTS\",\n  \"ami_owner\": \"099720109477\",\n  \"ami_name_pattern\": \"ubuntu/images/hvm-ssd/ubuntu-jammy"
  },
  {
    "path": "release-process/distro-configs/ubuntu24-lts.json",
    "chars": 744,
    "preview": "{\n  \"name\": \"Ubuntu 24.04 LTS\",\n  \"ami_owner\": \"099720109477\",\n  \"ami_name_pattern\": \"ubuntu/images/hvm-ssd-gp3/ubuntu-n"
  },
  {
    "path": "release-process/distro-configs/ubuntu24.10.json",
    "chars": 734,
    "preview": "{\n  \"name\": \"Ubuntu 24.10\",\n  \"ami_owner\": \"099720109477\",\n  \"ami_name_pattern\": \"ubuntu/images/hvm-ssd-gp3/ubuntu-oracu"
  },
  {
    "path": "release-process/prepare-release.py",
    "chars": 5452,
    "preview": "#!/usr/bin/python3\n\nimport argparse\nimport glob\nimport json\nimport os\nimport re\nimport subprocess\nimport sys\nimport time"
  },
  {
    "path": "release-process/rr-testing-cloud-formation.json",
    "chars": 452,
    "preview": "{\n  \"AWSTemplateFormatVersion\" : \"2010-09-09\",\n  \"Resources\": {\n    \"SecurityGroup\": {\n      \"Type\": \"AWS::EC2::Security"
  },
  {
    "path": "release-process/rr-testing.sh",
    "chars": 3572,
    "preview": "# Bash script to build rr and run tests.\n#\n# Requires variables and functions to be set. See test-system.py.\n# $git_revi"
  },
  {
    "path": "release-process/test-data/test.html",
    "chars": 92,
    "preview": "<!DOCTYPE HTML>\n<html>\n<body>\n<p>Hello!\n<script>\ndocument.title = \"rr Test Page\";\n</script>\n"
  },
  {
    "path": "release-process/test-system.py",
    "chars": 8862,
    "preview": "#!/usr/bin/python3\n\nimport argparse\nimport boto3\nfrom datetime import datetime\nimport json\nimport pathlib\nimport subproc"
  },
  {
    "path": "rr.spec",
    "chars": 1375,
    "preview": "Buildroot: @CPACK_BINARY_DIR@/_CPack_Packages/@CPACK_SYSTEM_NAME@/RPM/@CPACK_PACKAGE_FILE_NAME@\nSummary:        Lightwei"
  },
  {
    "path": "scripts/checkpoint-visualizer.html",
    "chars": 2775,
    "preview": "<!DOCTYPE HTML>\n<html>\n<body>\n<canvas width=\"1000\" height=\"50\" id=\"c\" style=\"border:1px solid black\"></canvas>\n<table st"
  },
  {
    "path": "scripts/github-actions-CTestCostData.txt",
    "chars": 105542,
    "preview": "check_environment 3 0.0164291\n64bit_child 3 0.337334\n64bit_child-no-syscallbuf 3 0.302363\n_llseek 3 0.157875\n_llseek-no-"
  },
  {
    "path": "scripts/github-actions-build.sh",
    "chars": 546,
    "preview": "#!/bin/bash\n\nset +x # echo commands\nset -e # default to exiting on error\"\n\nuname -a\n\nEXTRA_PACKAGES=\nMACHINE_TYPE=`uname"
  },
  {
    "path": "scripts/github-actions-test.sh",
    "chars": 1060,
    "preview": "#!/bin/bash\n\nset +x # echo commands\n\n# Enable perf events for rr\necho 0 | sudo tee /proc/sys/kernel/perf_event_paranoid "
  },
  {
    "path": "scripts/reformat.sh",
    "chars": 81,
    "preview": "#!/bin/sh\n\nfind src -regex '.*\\.\\(c\\|h\\|cc\\)$'|xargs clang-format -style=file -i\n"
  },
  {
    "path": "scripts/rr-collect-symbols.py",
    "chars": 7480,
    "preview": "#!/usr/bin/env python3\n\nimport errno\nimport glob\nimport os\nimport re\nimport shutil\nimport subprocess\nimport sys\nimport t"
  },
  {
    "path": "scripts/rr-gdb-script-host.py",
    "chars": 7087,
    "preview": "#!/usr/bin/env python3\n\"\"\" rr-gdb-script-host.py <user-gdb-script> <primary binary name>\"\"\"\n# Performs a limited emulati"
  },
  {
    "path": "scripts/rr_completion",
    "chars": 873,
    "preview": "# vi:syntax=sh\n#\n# completion script for rr commands (to be sourced)\n\n_rr_subcmd_completion() {\n    local cmd=$1\n    loc"
  },
  {
    "path": "scripts/rr_completion.zsh",
    "chars": 1274,
    "preview": "#compdef rr\n\n_rr() {\n  # allow overridding rr with another command (e.g. if multiple versions are installed)\n  zstyle -s"
  },
  {
    "path": "scripts/signal-rr-recording.sh",
    "chars": 562,
    "preview": "#!/usr/bin/env bash\n\nsignal=$1\nif [[ \"$signal\" == \"\" ]]; then\n    echo \"Usage: $0 <signal>\" >&2\n    echo \"Sends <signal>"
  },
  {
    "path": "scripts/update-gh-pages.sh",
    "chars": 742,
    "preview": "#!/usr/bin/env bash\n\nfunction fatal { why=$1;\n    echo \"[FATAL]\" $why >&2\n    exit 1\n}\n\nrev=HEAD\nif [[ $1 != \"\" ]]; then"
  },
  {
    "path": "scripts/zen_workaround.py",
    "chars": 5547,
    "preview": "#!/usr/bin/env python3\n\nimport argparse\nimport os\nimport struct\nimport sys\n\nimport array\nfrom os.path import join\nfrom f"
  },
  {
    "path": "scripts/zen_workaround.service",
    "chars": 1150,
    "preview": "# systemd service for AMD Zen `rr` workaround\n# See https://github.com/rr-debugger/rr/wiki/Zen for more details\n# To ins"
  },
  {
    "path": "snap/snapcraft.yaml",
    "chars": 1981,
    "preview": "name: rr\nbase: core20 # the base snap is the execution environment for this snap\nversion: git\nsummary: low-overhead reco"
  },
  {
    "path": "src/AddressSpace.cc",
    "chars": 90940,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"AddressSpace.h\"\n\n#include <l"
  },
  {
    "path": "src/AddressSpace.h",
    "chars": 45420,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_ADDRESS_SPACE_H_\n#define RR"
  },
  {
    "path": "src/AutoRemoteSyscalls.cc",
    "chars": 36309,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"AutoRemoteSyscalls.h\"\n\n#incl"
  },
  {
    "path": "src/AutoRemoteSyscalls.h",
    "chars": 11558,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_AUTO_REMOTE_SYSCALLS_H_\n#de"
  },
  {
    "path": "src/BpfMapMonitor.h",
    "chars": 697,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_BPF_MAP_MONITOR_H_\n#define "
  },
  {
    "path": "src/BreakpointCondition.h",
    "chars": 370,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_BREAKPOINT_CONDITION_H_\n#de"
  },
  {
    "path": "src/BuildidCommand.cc",
    "chars": 1214,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <iostream>\n\n#include \"log.h\"\n"
  },
  {
    "path": "src/CPUFeaturesCommand.cc",
    "chars": 1483,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"GdbServ"
  },
  {
    "path": "src/CPUIDBugDetector.cc",
    "chars": 2566,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CPUIDBugDetector.h\"\n#include"
  },
  {
    "path": "src/CPUIDBugDetector.h",
    "chars": 1363,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_CPUID_BUG_DETECTOR_H_\n#defi"
  },
  {
    "path": "src/CPUs.cc",
    "chars": 4337,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CPUs.h\"\n\n#include <sched.h>\n"
  },
  {
    "path": "src/CPUs.h",
    "chars": 1552,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_CPUS_H_\n#define RR_CPUS_H_\n"
  },
  {
    "path": "src/Command.cc",
    "chars": 5017,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#define _BSD_SOURCE\n\n#include \"Command"
  },
  {
    "path": "src/Command.h",
    "chars": 2016,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_COMMAND_H_\n#define RR_COMMA"
  },
  {
    "path": "src/CompressedReader.cc",
    "chars": 5611,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CompressedReader.h\"\n\n#includ"
  },
  {
    "path": "src/CompressedReader.h",
    "chars": 2297,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_COMPRESSED_READER_H_\n#defin"
  },
  {
    "path": "src/CompressedWriter.cc",
    "chars": 8329,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CompressedWriter.h\"\n\n#includ"
  },
  {
    "path": "src/CompressedWriter.h",
    "chars": 2793,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_COMPRESSED_WRITER_H_\n#defin"
  },
  {
    "path": "src/ContextSwitchEvent.cc",
    "chars": 4522,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ContextSwitchEvent.h\"\n\n#incl"
  },
  {
    "path": "src/ContextSwitchEvent.h",
    "chars": 2832,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_CONTEXT_SWITCH_EVENT_H_\n#de"
  },
  {
    "path": "src/DebuggerExtensionCommand.cc",
    "chars": 7247,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DebuggerExtensionCommand.h\"\n"
  },
  {
    "path": "src/DebuggerExtensionCommand.h",
    "chars": 2368,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DEBUGGER_EXTENSION_COMMAND_"
  },
  {
    "path": "src/DebuggerExtensionCommandHandler.cc",
    "chars": 11150,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DebuggerExtensionCommandHand"
  },
  {
    "path": "src/DebuggerExtensionCommandHandler.h",
    "chars": 1698,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DEBUGGER_EXTENSION_COMMAND_"
  },
  {
    "path": "src/DiversionSession.cc",
    "chars": 10108,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DiversionSession.h\"\n\n#includ"
  },
  {
    "path": "src/DiversionSession.h",
    "chars": 2323,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DIVERSION_SESSION_H_\n#defin"
  },
  {
    "path": "src/DumpCommand.cc",
    "chars": 14143,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DumpCommand.h\"\n\n#include <ar"
  },
  {
    "path": "src/DumpCommand.h",
    "chars": 935,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DUMP_COMMAND_H_\n#define RR_"
  },
  {
    "path": "src/Dwarf.cc",
    "chars": 22485,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Dwarf.h\"\n\n#include <string.h"
  },
  {
    "path": "src/Dwarf.h",
    "chars": 6452,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DWARF_H_\n#define RR_DWARF_H"
  },
  {
    "path": "src/ElfReader.cc",
    "chars": 20017,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ElfReader.h\"\n\n#include <elf."
  },
  {
    "path": "src/ElfReader.h",
    "chars": 3691,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_ELF_READER_H_\n#define RR_EL"
  },
  {
    "path": "src/EmuFs.cc",
    "chars": 6305,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"EmuFs.h\"\n\n#include <syscall."
  },
  {
    "path": "src/EmuFs.h",
    "chars": 5808,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EMUFS_H_\n#define RR_EMUFS_H"
  },
  {
    "path": "src/Event.cc",
    "chars": 6058,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Event.h\"\n\n#include <syscall."
  },
  {
    "path": "src/Event.h",
    "chars": 15133,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EVENT_H_\n#define RR_EVENT_H"
  },
  {
    "path": "src/ExportImportCheckpoints.cc",
    "chars": 11419,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ExportImportCheckpoints.h\"\n\n"
  },
  {
    "path": "src/ExportImportCheckpoints.h",
    "chars": 1911,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EXPORT_IMPORT_CHECKPOINTS_H"
  },
  {
    "path": "src/ExtraRegisters.cc",
    "chars": 32547,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ExtraRegisters.h\"\n\n#include "
  },
  {
    "path": "src/ExtraRegisters.h",
    "chars": 5690,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EXTRA_REGISTERS_H_\n#define "
  },
  {
    "path": "src/FdTable.cc",
    "chars": 7562,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"FdTable.h\"\n\n#include <limits"
  },
  {
    "path": "src/FdTable.h",
    "chars": 3703,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_FD_TABLE_H_\n#define RR_FD_T"
  },
  {
    "path": "src/FileMonitor.cc",
    "chars": 3390,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"FileMonitor.h\"\n\n#include <li"
  },
  {
    "path": "src/FileMonitor.h",
    "chars": 3751,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_FILE_MONITOR_H_\n#define RR_"
  },
  {
    "path": "src/FileNameCommand.cc",
    "chars": 2223,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <unordered_set>\n\n#include \"Ad"
  },
  {
    "path": "src/Flags.cc",
    "chars": 213,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Flags.h\"\n\nnamespace rr {\n\nFl"
  },
  {
    "path": "src/Flags.h",
    "chars": 2665,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_FLAGS_H_\n#define RR_FLAGS_H"
  },
  {
    "path": "src/GdbInitCommand.cc",
    "chars": 679,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"GdbServ"
  },
  {
    "path": "src/GdbServer.cc",
    "chars": 84396,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"GdbServer.h\"\n\n#include <elf."
  },
  {
    "path": "src/GdbServer.h",
    "chars": 13386,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_SERVER_H_\n#define RR_GD"
  },
  {
    "path": "src/GdbServerConnection.cc",
    "chars": 65026,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#define REVERSE_EXECUTION\n\n/**\n * Much"
  },
  {
    "path": "src/GdbServerConnection.h",
    "chars": 25505,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_CONNECTION_H_\n#define R"
  },
  {
    "path": "src/GdbServerExpression.cc",
    "chars": 11525,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"GdbServerExpression.h\"\n\n#inc"
  },
  {
    "path": "src/GdbServerExpression.h",
    "chars": 1183,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_EXPRESSION_H_\n#define R"
  },
  {
    "path": "src/GdbServerRegister.h",
    "chars": 5550,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_SERVER_REGISTER_H_\n#def"
  },
  {
    "path": "src/HasTaskSet.cc",
    "chars": 810,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"HasTaskSet.h\"\n\n#include \"Tas"
  },
  {
    "path": "src/HasTaskSet.h",
    "chars": 760,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_HASTASKSET_H_\n#define RR_HA"
  },
  {
    "path": "src/HelpCommand.cc",
    "chars": 883,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"main.h\""
  },
  {
    "path": "src/LldbInitCommand.cc",
    "chars": 852,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"GdbServ"
  },
  {
    "path": "src/LsCommand.cc",
    "chars": 7168,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <assert.h>\n#include <dirent.h"
  },
  {
    "path": "src/MagicSaveDataMonitor.cc",
    "chars": 2764,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"MagicSaveDataMonitor.h\"\n\n#in"
  },
  {
    "path": "src/MagicSaveDataMonitor.h",
    "chars": 602,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MAGIC_SAVE_DATA_MONITOR_H_\n"
  },
  {
    "path": "src/MemoryRange.h",
    "chars": 2449,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MEMORY_RANGE_H_\n#define RR_"
  },
  {
    "path": "src/MmappedFileMonitor.cc",
    "chars": 3468,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"MmappedFileMonitor.h\"\n\n#incl"
  },
  {
    "path": "src/MmappedFileMonitor.h",
    "chars": 1205,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MMAPPED_FILE_MONITOR_H_\n#de"
  },
  {
    "path": "src/MonitoredSharedMemory.cc",
    "chars": 2804,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"MonitoredSharedMemory.h\"\n\n#i"
  },
  {
    "path": "src/MonitoredSharedMemory.h",
    "chars": 1838,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MONITORED_SHARED_MEMORY_H_\n"
  },
  {
    "path": "src/Monkeypatcher.cc",
    "chars": 73031,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Monkeypatcher.h\"\n\n#include <"
  },
  {
    "path": "src/Monkeypatcher.h",
    "chars": 7218,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MONKEYPATCHER_H_\n#define RR"
  },
  {
    "path": "src/MvCommand.cc",
    "chars": 2937,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <stdio.h>\n#include <sysexits."
  },
  {
    "path": "src/NonvirtualPerfCounterMonitor.h",
    "chars": 579,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_NONVIRTUAL_PERF_COUNTER_MON"
  },
  {
    "path": "src/ODirectFileMonitor.h",
    "chars": 584,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_ODIRECT_MONITOR_H_\n#define "
  },
  {
    "path": "src/PackCommand.cc",
    "chars": 24959,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <dirent.h>\n#include <limits.h"
  },
  {
    "path": "src/PerfCounterBuffers.cc",
    "chars": 4127,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"PerfCounterBuffers.h\"\n\n#incl"
  },
  {
    "path": "src/PerfCounterBuffers.h",
    "chars": 2038,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PERF_COUNTER_BUFFERS_H_\n#de"
  },
  {
    "path": "src/PerfCounters.cc",
    "chars": 47056,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"PerfCounters.h\"\n\n#include <d"
  },
  {
    "path": "src/PerfCounters.h",
    "chars": 7073,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PERF_COUNTERS_H_\n#define RR"
  },
  {
    "path": "src/PerfCounters_aarch64.h",
    "chars": 11863,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n// This file is included from PerfCount"
  },
  {
    "path": "src/PerfCounters_x86.h",
    "chars": 19192,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n// This file is included from PerfCount"
  },
  {
    "path": "src/PidFdMonitor.cc",
    "chars": 584,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"PidFdMonitor.h\"\n\n#include \"S"
  },
  {
    "path": "src/PidFdMonitor.h",
    "chars": 724,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PID_FD_MONITOR_H_\n#define R"
  },
  {
    "path": "src/PreserveFileMonitor.h",
    "chars": 874,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PRESERVE_FILE_MONITOR_H_\n#d"
  },
  {
    "path": "src/ProcFdDirMonitor.cc",
    "chars": 3588,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ProcFdDirMonitor.h\"\n\n#includ"
  },
  {
    "path": "src/ProcFdDirMonitor.h",
    "chars": 740,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROC_FD_DIR_MONITOR_H_\n#def"
  },
  {
    "path": "src/ProcMemMonitor.cc",
    "chars": 1888,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ProcMemMonitor.h\"\n\n#include "
  },
  {
    "path": "src/ProcMemMonitor.h",
    "chars": 1118,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROC_MEM_MONITOR_H_\n#define"
  },
  {
    "path": "src/ProcStatMonitor.cc",
    "chars": 1998,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <sys/stat.h>\n#include <unistd"
  },
  {
    "path": "src/ProcStatMonitor.h",
    "chars": 925,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROC_STAT_MONITOR_H_\n#defin"
  },
  {
    "path": "src/ProcessorTraceDecoder.cc",
    "chars": 6435,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <intel-pt.h>\n\n#include <ostre"
  },
  {
    "path": "src/ProcessorTraceDecoder.h",
    "chars": 2208,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROCESSOR_TRACE_DECODER_H_\n"
  },
  {
    "path": "src/PsCommand.cc",
    "chars": 4992,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <map>\n\n#include \"Command.h\"\n#"
  },
  {
    "path": "src/RRPageMonitor.h",
    "chars": 741,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RR_PAGE_MONITOR_H_\n#define "
  },
  {
    "path": "src/RecordCommand.cc",
    "chars": 32276,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"RecordCommand.h\"\n\n#include <"
  },
  {
    "path": "src/RecordCommand.h",
    "chars": 554,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RECORD_COMMAND_H_\n#define R"
  },
  {
    "path": "src/RecordSession.cc",
    "chars": 111501,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"RecordSession.h\"\n\n#include <"
  },
  {
    "path": "src/RecordSession.h",
    "chars": 10137,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RECORD_SESSION_H_\n#define R"
  },
  {
    "path": "src/RecordTask.cc",
    "chars": 81691,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"RecordTask.h\"\n\n#include <dir"
  },
  {
    "path": "src/RecordTask.h",
    "chars": 30605,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RECORD_TASK_H_\n#define RR_R"
  },
  {
    "path": "src/Registers.cc",
    "chars": 25529,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Registers.h\"\n\n#include <arra"
  },
  {
    "path": "src/Registers.h",
    "chars": 22415,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REGISTERS_H_\n#define RR_REG"
  },
  {
    "path": "src/ReplayCommand.cc",
    "chars": 23927,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ReplayCommand.h\"\n\n#include <"
  },
  {
    "path": "src/ReplayCommand.h",
    "chars": 518,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REPLAY_COMMAND_H_\n#define R"
  },
  {
    "path": "src/ReplaySession.cc",
    "chars": 87493,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#define USE_BREAKPOINT_TARGET 1\n\n#incl"
  },
  {
    "path": "src/ReplaySession.h",
    "chars": 15485,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REPLAY_SESSION_H_\n#define R"
  },
  {
    "path": "src/ReplayTask.cc",
    "chars": 8374,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ReplayTask.h\"\n\n#include \"Aut"
  },
  {
    "path": "src/ReplayTask.h",
    "chars": 3361,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REPLAY_TASK_H_\n#define RR_R"
  },
  {
    "path": "src/ReplayTimeline.cc",
    "chars": 63837,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ReplayTimeline.h\"\n\n#include "
  },
  {
    "path": "src/ReplayTimeline.h",
    "chars": 20847,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REPLAY_TIMELINE_H_\n#define "
  },
  {
    "path": "src/RerunCommand.cc",
    "chars": 14946,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <sys/time.h>\n#include <sys/wa"
  },
  {
    "path": "src/ReturnAddressList.cc",
    "chars": 2839,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ReturnAddressList.h\"\n\n#inclu"
  },
  {
    "path": "src/ReturnAddressList.h",
    "chars": 1396,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RETURNADDRESSLIST_H_\n#defin"
  },
  {
    "path": "src/RmCommand.cc",
    "chars": 3461,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <ftw.h>\n#include <stdio.h>\n\n#"
  },
  {
    "path": "src/Scheduler.cc",
    "chars": 43469,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n//#define MONITOR_UNSWITCHABLE_WAITS\n\n"
  },
  {
    "path": "src/Scheduler.h",
    "chars": 11011,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REC_SCHED_H_\n#define RR_REC"
  },
  {
    "path": "src/ScopedFd.h",
    "chars": 1651,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_SCOPED_FD_H_\n#define RR_SCO"
  },
  {
    "path": "src/SeccompFilterRewriter.cc",
    "chars": 4777,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"SeccompFilterRewriter.h\"\n\n#i"
  },
  {
    "path": "src/SeccompFilterRewriter.h",
    "chars": 2806,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_SECCOMP_FILTER_REWRITER_H_\n"
  },
  {
    "path": "src/Session.cc",
    "chars": 28980,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Session.h\"\n\n#include <linux/"
  },
  {
    "path": "src/Session.h",
    "chars": 17034,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_SESSION_H_\n#define RR_SESSI"
  },
  {
    "path": "src/SourcesCommand.cc",
    "chars": 50802,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <dirent.h>\n#include <spawn.h>"
  },
  {
    "path": "src/StdioMonitor.cc",
    "chars": 941,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"StdioMonitor.h\"\n\n#include \"F"
  },
  {
    "path": "src/StdioMonitor.h",
    "chars": 1655,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_STDIO_MONITOR_H_\n#define RR"
  },
  {
    "path": "src/StringVectorToCharArray.h",
    "chars": 651,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_STRING_VECTOR_TO_CHAR_ARRAY"
  },
  {
    "path": "src/SysCpuMonitor.cc",
    "chars": 1396,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <sstream>\n\n#include \"SysCpuMo"
  },
  {
    "path": "src/SysCpuMonitor.h",
    "chars": 782,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_SYS_CPU_MONITOR_H_\n#define "
  },
  {
    "path": "src/TargetDescription.cc",
    "chars": 3727,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"TargetDescription.h\"\n\n#inclu"
  },
  {
    "path": "src/TargetDescription.h",
    "chars": 614,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TARGET_DESCRIPTION_H_\n#defi"
  },
  {
    "path": "src/Task.cc",
    "chars": 166763,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include <errno.h>\n#include <limits.h>"
  },
  {
    "path": "src/Task.h",
    "chars": 50137,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TASK_H_\n#define RR_TASK_H_\n"
  },
  {
    "path": "src/TaskishUid.h",
    "chars": 2509,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TASKISH_UID_H_\n#define RR_T"
  },
  {
    "path": "src/ThreadDb.cc",
    "chars": 8342,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ThreadDb.h\"\n#include \"GdbSer"
  },
  {
    "path": "src/ThreadDb.h",
    "chars": 3532,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_THREADDB_H_\n#define RR_THRE"
  },
  {
    "path": "src/ThreadGroup.cc",
    "chars": 1595,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ThreadGroup.h\"\n\n#include \"Re"
  },
  {
    "path": "src/ThreadGroup.h",
    "chars": 2340,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TASKGROUP_H_\n#define RR_TAS"
  },
  {
    "path": "src/Ticks.h",
    "chars": 228,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TICKS_H_\n#define RR_TICKS_H"
  },
  {
    "path": "src/TraceField.cc",
    "chars": 12590,
    "preview": "#include <string>\n\n#include \"ReplayTask.h\"\n#include \"TraceField.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nnamespace {\n\nv"
  },
  {
    "path": "src/TraceField.h",
    "chars": 1469,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TRACE_FIELD_H_\n#define RR_T"
  },
  {
    "path": "src/TraceFrame.cc",
    "chars": 1479,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"TraceFrame.h\"\n\n#include <int"
  },
  {
    "path": "src/TraceFrame.h",
    "chars": 2291,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TRACE_FRAME_H_\n#define RR_T"
  },
  {
    "path": "src/TraceInfoCommand.cc",
    "chars": 5367,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DumpCommand.h\"\n\n#include <in"
  },
  {
    "path": "src/TraceStream.cc",
    "chars": 61514,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef _GNU_SOURCE\n// For utsname::do"
  },
  {
    "path": "src/TraceStream.h",
    "chars": 18881,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TRACE_STREAM_H_\n#define RR_"
  },
  {
    "path": "src/TraceTaskEvent.h",
    "chars": 3802,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TRACE_TASK_EVENT_H_\n#define"
  },
  {
    "path": "src/TraceeAttentionSet.cc",
    "chars": 2258,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"TraceeAttentionSet.h\"\n\n#incl"
  },
  {
    "path": "src/TraceeAttentionSet.h",
    "chars": 1034,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_TRACEE_ATTENTION_SET_H_\n#de"
  },
  {
    "path": "src/VirtualPerfCounterMonitor.cc",
    "chars": 5064,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"VirtualPerfCounterMonitor.h\""
  },
  {
    "path": "src/VirtualPerfCounterMonitor.h",
    "chars": 1928,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_VIRTUAL_PERF_COUNTER_MONITO"
  },
  {
    "path": "src/WaitManager.cc",
    "chars": 6942,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"WaitManager.h\"\n\n#include <er"
  },
  {
    "path": "src/WaitManager.h",
    "chars": 3390,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_WAIT_MANAGER_H_\n#define RR_"
  },
  {
    "path": "src/WaitStatus.cc",
    "chars": 5669,
    "preview": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"WaitStatus.h\"\n\n#include <sys"
  }
]

// ... and 1409 more files (download for full content)