commit	542d59bdde5a2129688015e0a7bbfaf65619bc0a	[log] [tgz]
author	Derek Bruening <bruening@google.com>	Thu May 12 18:34:26 2022
committer	GitHub <noreply@github.com>	Thu May 12 18:34:26 2022
tree	8f5868905cb1b868e5c262ebaf1d5b7547ef5d33
parent	5f9179369853a4abed26cfe92f72d7086180528b [diff]

i#5486: Add drmemtrace view tool support for no binaries (#5492)

Adds support for using the drmemtrace view tool on a trace for which
no modules.log, and thus no binary, is available.

Adds a unit test for missing modules.

Adds a short header clarifying the record number and thread id.

Modifies the output of the existing tool as well with a unified "access-type size @ address" format.
The output looks like this for no binaries:
```
----------------------------------------------------------------------
  2923096: T3551529 <marker: tid 3551529 on core 2>
  2923097: T3551529 <marker: timestamp 13296790404166936>
  2923098: T3551529 ifetch 3 byte(s) @ 0x00007f7fe3a61761 non-branch
  2923099: T3551529 ifetch 2 byte(s) @ 0x00007f7fe3a61764 conditional jump
  2923100: T3551529 ifetch 2 byte(s) @ 0x00007f7fe3a61766 conditional jump
  2923101: T3551529 ifetch 2 byte(s) @ 0x00007f7fe3a61769 non-branch
  2923102: T3551529 ifetch 1 byte(s) @ 0x00007f7fe3a6176b non-branch
  2923103: T3551529 read   8 byte(s) @ 0x00007f7fe3962ef0 by PC 0x00007f7fe3a6176b
  2923104: T3551529 ifetch 1 byte(s) @ 0x00007f7fe3a6176c non-branch
  2923105: T3551529 read   8 byte(s) @ 0x00007f7fe3962ef8 by PC 0x00007f7fe3a6176c
  2923106: T3551529 ifetch 2 byte(s) @ 0x00007f7fe3a6176d indirect call
  2923107: T3551529 write  8 byte(s) @ 0x00007f7fe3962ef8 by PC 0x00007f7fe3a6176d
----------------------------------------------------------------------
```

An example with binaries:
```
----------------------------------------------------------------------
       28: T3731918 <marker: tid 3731918 on core 4>
       29: T3731918 <marker: timestamp 13296850393297095>
       30: T3731918 ifetch 3 byte(s) @ 0x00007fbf81bc1050 48 89 e7             mov    %rsp, %rdi
       31: T3731918 ifetch 5 byte(s) @ 0x00007fbf81bc1053 e8 18 0d 00 00       call   $0x00007fbf81bc1d70
       32: T3731918 write  8 byte(s) @ 0x00007ffffe379368 by PC 0x00007fbf81bc1053
       33: T3731918 ifetch 1 byte(s) @ 0x00007fbf81bc1d70 55                   push   %rbp
       34: T3731918 write  8 byte(s) @ 0x00007ffffe379360 by PC 0x00007fbf81bc1d70
       35: T3731918 ifetch 3 byte(s) @ 0x00007fbf81bc1d71 48 89 e5             mov    %rsp, %rbp
       36: T3731918 ifetch 2 byte(s) @ 0x00007fbf81bc1d74 41 57                push   %r15
       37: T3731918 write  8 byte(s) @ 0x00007ffffe379358 by PC 0x00007fbf81bc1d74
       38: T3731918 ifetch 3 byte(s) @ 0x00007fbf81bc1d76 49 89 ff             mov    %rdi, %r15
----------------------------------------------------------------------
```

Fixes #5486

6 files changed

tree: 8f5868905cb1b868e5c262ebaf1d5b7547ef5d33

README.md

DynamoRIO

DynamoRIO logo

About DynamoRIO

DynamoRIO is a runtime code manipulation system that supports code transformations on any part of a program, while it executes. DynamoRIO exports an interface for building dynamic tools for a wide variety of uses: program analysis and understanding, profiling, instrumentation, optimization, translation, etc. Unlike many dynamic tool systems, DynamoRIO is not limited to insertion of callouts/trampolines and allows arbitrary modifications to application instructions via a powerful IA-32/AMD64/ARM/AArch64 instruction manipulation library. DynamoRIO provides efficient, transparent, and comprehensive manipulation of unmodified applications running on stock operating systems (Windows, Linux, or Android) and commodity IA-32, AMD64, ARM, and AArch64 hardware. Mac OSX support is in progress.

Existing DynamoRIO-based tools

DynamoRIO is the basis for some well-known external tools:

The Arm Instruction Emulator (ArmIE)
WinAFL, the Windows fuzzing tool, as an instrumentation and code coverage engine
The fine-grained profiler for ARM DrCCTProf

Tools built on DynamoRIO and available in the release package include:

The memory debugging tool Dr. Memory
The tracing and analysis framework drmemtrace with multiple tools that operate on both online (with multi-process support) and offline instruction and memory address traces:
- The cache simulator drcachesim
- TLB simulation
- Reuse distance
- Reuse time
- Opcode mix
- Function call tracing
The legacy processor emulator drcpusim
The “strace for Windows” tool drstrace
The code coverage tool drcov
The library tracing tool drltrace
The memory address tracing tool memtrace (drmemtrace's offline traces are faster with more surrounding infrastructure, but this is a simpler starting point for customized memory address tracing)
The memory value tracing tool memval
The instruction tracing tool instrace (drmemtrace's offline traces are faster with more surrounding infrastructure, but this is a simpler starting point for customized instruction tracing)
The basic block tracing tool bbbuf
The instruction counting tool inscount
The dynamic fuzz testing tool Dr. Fuzz
The disassembly tool drdisas
And more, including opcode counts, branch instrumentation, etc.: see \ref API_samples.

Building your own custom tools

DynamoRIO‘s powerful API abstracts away the details of the underlying infrastructure and allows the tool builder to concentrate on analyzing or modifying the application’s runtime code stream. API documentation is included in the release package and can also be browsed online. Slides from our past tutorials are also available.

Downloading DynamoRIO

DynamoRIO is available free of charge as a binary package for both Windows and Linux. DynamoRIO's source code is available primarily under a BSD license.

Obtaining Help

Use the discussion list to ask questions.

To report a bug, use the issue tracker.