Import Dexter to debuginfo-tests

Dexter (Debug Experience Tester) is a test-driver for our debug info
integration tests, reading a set of debug experience expectations and
comparing them with the actual behaviour of a program under a debugger.
More about Dexter can be found in the RFC:

  http://lists.llvm.org/pipermail/llvm-dev/2019-October/135773.html

and the phab review in D68708. Not all the debuginfo tests have been
transformed into Dexter tests, and we look forwards to doing that
incrementally.

This commit mostly aims to flush out buildbots that are running
debuginfo-tests but don't have python 3 installed, possibly
green-dragon and some windows bots.

89 files changed, 7918 insertions, 0 deletions

diff --git a/debuginfo-tests/dexter/dex/__init__.py b/debuginfo-tests/dexter/dex/__init__.py
new file mode 100644
index 00000000000..d2a290b0ee0
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+__version__ = '1.0.0'
diff --git a/debuginfo-tests/dexter/dex/builder/Builder.py b/debuginfo-tests/dexter/dex/builder/Builder.py
new file mode 100644
index 00000000000..a2bab863568
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/Builder.py
@@ -0,0 +1,117 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Deals with the processing execution of shell or batch build scripts."""
+
+import os
+import subprocess
+import unittest
+
+from dex.dextIR import BuilderIR
+from dex.utils import Timer
+from dex.utils.Exceptions import BuildScriptException
+
+
+def _quotify(text):
+    if '"' in text or ' ' not in text:
+        return text
+    return '"{}"'.format(text)
+
+
+def _get_script_environment(source_files, compiler_options,
+                            linker_options, executable_file):
+
+    source_files = [_quotify(f) for f in source_files]
+    object_files = [
+        _quotify('{}.o'.format(os.path.basename(f))) for f in source_files
+    ]
+    source_indexes = ['{:02d}'.format(i + 1) for i in range(len(source_files))]
+
+    env_variables = {}
+    env_variables['SOURCE_INDEXES'] = ' '.join(source_indexes)
+    env_variables['SOURCE_FILES'] = ' '.join(source_files)
+    env_variables['OBJECT_FILES'] = ' '.join(object_files)
+    env_variables['LINKER_OPTIONS'] = linker_options
+
+    for i, _ in enumerate(source_files):
+        index = source_indexes[i]
+        env_variables['SOURCE_FILE_{}'.format(index)] = source_files[i]
+        env_variables['OBJECT_FILE_{}'.format(index)] = object_files[i]
+        env_variables['COMPILER_OPTIONS_{}'.format(index)] = compiler_options[i]
+
+    env_variables['EXECUTABLE_FILE'] = executable_file
+
+    return env_variables
+
+
+def run_external_build_script(context, script_path, source_files,
+                              compiler_options, linker_options,
+                              executable_file):
+    """Build an executable using a builder script.
+
+    The executable is saved to `context.working_directory.path`.
+
+    Returns:
+        ( stdout (str), stderr (str), builder (BuilderIR) )
+    """
+
+    builderIR = BuilderIR(
+        name=context.options.builder,
+        cflags=compiler_options,
+        ldflags=linker_options,
+    )
+    assert len(source_files) == len(compiler_options), (source_files,
+                                                        compiler_options)
+
+    script_environ = _get_script_environment(source_files, compiler_options,
+                                             linker_options, executable_file)
+    env = dict(os.environ)
+    env.update(script_environ)
+    try:
+        with Timer('running build script'):
+            process = subprocess.Popen(
+                [script_path],
+                cwd=context.working_directory.path,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE)
+            out, err = process.communicate()
+            returncode = process.returncode
+        if returncode != 0:
+            raise BuildScriptException(
+                '{}: failed with returncode {}.\nstdout:\n{}\n\nstderr:\n{}\n'.
+                format(script_path, returncode, out, err),
+                script_error=err)
+        return out.decode('utf-8'), err.decode('utf-8'), builderIR
+    except OSError as e:
+        raise BuildScriptException('{}: {}'.format(e.strerror, script_path))
+
+
+class TestBuilder(unittest.TestCase):
+    def test_get_script_environment(self):
+        source_files = ['a.a', 'b.b']
+        compiler_options = ['-option1 value1', '-option2 value2']
+        linker_options = '-optionX valueX'
+        executable_file = 'exe.exe'
+        env = _get_script_environment(source_files, compiler_options,
+                                      linker_options, executable_file)
+
+        assert env['SOURCE_FILES'] == 'a.a b.b'
+        assert env['OBJECT_FILES'] == 'a.a.o b.b.o'
+
+        assert env['SOURCE_INDEXES'] == '01 02'
+        assert env['LINKER_OPTIONS'] == '-optionX valueX'
+
+        assert env['SOURCE_FILE_01'] == 'a.a'
+        assert env['SOURCE_FILE_02'] == 'b.b'
+
+        assert env['OBJECT_FILE_01'] == 'a.a.o'
+        assert env['OBJECT_FILE_02'] == 'b.b.o'
+
+        assert env['EXECUTABLE_FILE'] == 'exe.exe'
+
+        assert env['COMPILER_OPTIONS_01'] == '-option1 value1'
+        assert env['COMPILER_OPTIONS_02'] == '-option2 value2'
diff --git a/debuginfo-tests/dexter/dex/builder/ParserOptions.py b/debuginfo-tests/dexter/dex/builder/ParserOptions.py
new file mode 100644
index 00000000000..b6677aac549
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/ParserOptions.py
@@ -0,0 +1,56 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command line options for subtools that use the builder component."""
+
+import os
+
+from dex.tools import Context
+from dex.utils import is_native_windows
+
+
+def _find_build_scripts():
+    """Finds build scripts in the 'scripts' subdirectory.
+
+    Returns:
+        { script_name (str): directory (str) }
+    """
+    try:
+        return _find_build_scripts.cached
+    except AttributeError:
+        scripts_directory = os.path.join(os.path.dirname(__file__), 'scripts')
+        if is_native_windows():
+            scripts_directory = os.path.join(scripts_directory, 'windows')
+        else:
+            scripts_directory = os.path.join(scripts_directory, 'posix')
+        assert os.path.isdir(scripts_directory), scripts_directory
+        results = {}
+
+        for f in os.listdir(scripts_directory):
+            results[os.path.splitext(f)[0]] = os.path.abspath(
+                os.path.join(scripts_directory, f))
+
+        _find_build_scripts.cached = results
+        return results
+
+
+def add_builder_tool_arguments(parser):
+    parser.add_argument('--binary',
+                        metavar="<file>",
+                        help='provide binary file to override --builder')
+
+    parser.add_argument(
+        '--builder',
+        type=str,
+        choices=sorted(_find_build_scripts().keys()),
+        help='test builder to use')
+    parser.add_argument(
+        '--cflags', type=str, default='', help='compiler flags')
+    parser.add_argument('--ldflags', type=str, default='', help='linker flags')
+
+
+def handle_builder_tool_options(context: Context) -> str:
+    return _find_build_scripts()[context.options.builder]
diff --git a/debuginfo-tests/dexter/dex/builder/__init__.py b/debuginfo-tests/dexter/dex/builder/__init__.py
new file mode 100644
index 00000000000..3bf0ca40f5c
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/__init__.py
@@ -0,0 +1,10 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.builder.Builder import run_external_build_script
+from dex.builder.ParserOptions import add_builder_tool_arguments
+from dex.builder.ParserOptions import handle_builder_tool_options
diff --git a/debuginfo-tests/dexter/dex/builder/scripts/posix/clang-c.sh b/debuginfo-tests/dexter/dex/builder/scripts/posix/clang-c.sh
new file mode 100755
index 00000000000..f69f51cd86a
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/scripts/posix/clang-c.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+
+if test -z "$PATHTOCLANG"; then
+  PATHTOCLANG=clang
+fi
+
+for INDEX in $SOURCE_INDEXES
+do
+  CFLAGS=$(eval echo "\$COMPILER_OPTIONS_$INDEX")
+  SRCFILE=$(eval echo "\$SOURCE_FILE_$INDEX")
+  OBJFILE=$(eval echo "\$OBJECT_FILE_$INDEX")
+  $PATHTOCLANG -std=gnu11 -c $CFLAGS $SRCFILE -o $OBJFILE
+done
+
+$PATHTOCLANG $LINKER_OPTIONS $OBJECT_FILES -o $EXECUTABLE_FILE
diff --git a/debuginfo-tests/dexter/dex/builder/scripts/posix/clang.sh b/debuginfo-tests/dexter/dex/builder/scripts/posix/clang.sh
new file mode 100755
index 00000000000..9cf4cdd65f7
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/scripts/posix/clang.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+
+if test -z "$PATHTOCLANGPP"; then
+  PATHTOCLANGPP=clang++
+fi
+
+for INDEX in $SOURCE_INDEXES
+do
+  CFLAGS=$(eval echo "\$COMPILER_OPTIONS_$INDEX")
+  SRCFILE=$(eval echo "\$SOURCE_FILE_$INDEX")
+  OBJFILE=$(eval echo "\$OBJECT_FILE_$INDEX")
+  $PATHTOCLANGPP -std=gnu++11 -c $CFLAGS $SRCFILE -o $OBJFILE
+done
+
+$PATHTOCLANGPP $LINKER_OPTIONS $OBJECT_FILES -o $EXECUTABLE_FILE
diff --git a/debuginfo-tests/dexter/dex/builder/scripts/windows/clang-cl_vs2015.bat b/debuginfo-tests/dexter/dex/builder/scripts/windows/clang-cl_vs2015.bat
new file mode 100644
index 00000000000..ea0d4414d26
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/scripts/windows/clang-cl_vs2015.bat
@@ -0,0 +1,23 @@
+@echo OFF
+setlocal EnableDelayedExpansion
+
+call "%VS140COMNTOOLS%..\..\VC\bin\amd64\vcvars64.bat"
+
+@echo OFF
+setlocal EnableDelayedExpansion
+
+for %%I in (%SOURCE_INDEXES%) do (
+  %PATHTOCLANGCL% /c !COMPILER_OPTIONS_%%I! !SOURCE_FILE_%%I! /Fo!OBJECT_FILE_%%I!
+  if errorlevel 1 goto :FAIL
+)
+
+%PATHTOCLANGCL% %LINKER_OPTIONS% %OBJECT_FILES% /Fe%EXECUTABLE_FILE%
+if errorlevel 1 goto :FAIL
+goto :END
+
+:FAIL
+echo FAILED
+exit /B 1
+
+:END
+exit /B 0
diff --git a/debuginfo-tests/dexter/dex/builder/scripts/windows/clang.bat b/debuginfo-tests/dexter/dex/builder/scripts/windows/clang.bat
new file mode 100644
index 00000000000..a83e4d4c1bb
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/builder/scripts/windows/clang.bat
@@ -0,0 +1,17 @@
+setlocal EnableDelayedExpansion
+
+for %%I in (%SOURCE_INDEXES%) do (
+  %PATHTOCLANGPP% -fuse-ld=lld -c !COMPILER_OPTIONS_%%I! !SOURCE_FILE_%%I! -o !OBJECT_FILE_%%I!
+  if errorlevel 1 goto :FAIL
+)
+
+%PATHTOCLANGPP% -fuse-ld=lld %LINKER_OPTIONS% %OBJECT_FILES% -o %EXECUTABLE_FILE%
+if errorlevel 1 goto :FAIL
+goto :END
+
+:FAIL
+echo FAILED
+exit /B 1
+
+:END
+exit /B 0
diff --git a/debuginfo-tests/dexter/dex/command/CommandBase.py b/debuginfo-tests/dexter/dex/command/CommandBase.py
new file mode 100644
index 00000000000..49e908623df
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/CommandBase.py
@@ -0,0 +1,54 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Base class for all DExTer commands, where a command is a specific Python
+function that can be embedded into a comment in the source code under test
+which will then be executed by DExTer during debugging.
+"""
+
+import abc
+from typing import List
+
+class CommandBase(object, metaclass=abc.ABCMeta):
+    def __init__(self):
+        self.path = None
+        self.lineno = None
+        self.raw_text = ''
+
+    def get_label_args(self):
+        return list()
+
+    def has_labels(self):
+        return False
+
+    @abc.abstractstaticmethod
+    def get_name():
+        """This abstract method is usually implemented in subclasses as:
+        return __class__.__name__
+        """
+
+    def get_watches(self) -> List[str]:
+        return []
+
+    @abc.abstractmethod
+    def eval(self):
+        """Evaluate the command.
+
+        This will be called when constructing a Heuristic object to determine
+        the debug score.
+
+        Returns:
+            The logic for handling the result of CommandBase.eval() must be
+            defined in Heuristic.__init__() so a consitent return type between
+            commands is not enforced.
+        """
+
+    @staticmethod
+    def get_subcommands() -> dict:
+        """Returns a dictionary of subcommands in the form {name: command} or
+        None if no subcommands are required.
+        """
+        return None
diff --git a/debuginfo-tests/dexter/dex/command/ParseCommand.py b/debuginfo-tests/dexter/dex/command/ParseCommand.py
new file mode 100644
index 00000000000..3b9a2d5766b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/ParseCommand.py
@@ -0,0 +1,421 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Parse a DExTer command. In particular, ensure that only a very limited
+subset of Python is allowed, in order to prevent the possibility of unsafe
+Python code being embedded within DExTer commands.
+"""
+
+import os
+import unittest
+from copy import copy
+
+from collections import defaultdict
+
+from dex.utils.Exceptions import CommandParseError
+
+from dex.command.CommandBase import CommandBase
+from dex.command.commands.DexExpectProgramState import DexExpectProgramState
+from dex.command.commands.DexExpectStepKind import DexExpectStepKind
+from dex.command.commands.DexExpectStepOrder import DexExpectStepOrder
+from dex.command.commands.DexExpectWatchType import DexExpectWatchType
+from dex.command.commands.DexExpectWatchValue import DexExpectWatchValue
+from dex.command.commands.DexLabel import DexLabel
+from dex.command.commands.DexUnreachable import DexUnreachable
+from dex.command.commands.DexWatch import DexWatch
+
+
+def _get_valid_commands():
+    """Return all top level DExTer test commands.
+
+    Returns:
+        { name (str): command (class) }
+    """
+    return {
+      DexExpectProgramState.get_name() : DexExpectProgramState,
+      DexExpectStepKind.get_name() : DexExpectStepKind,
+      DexExpectStepOrder.get_name() : DexExpectStepOrder,
+      DexExpectWatchType.get_name() : DexExpectWatchType,
+      DexExpectWatchValue.get_name() : DexExpectWatchValue,
+      DexLabel.get_name() : DexLabel,
+      DexUnreachable.get_name() : DexUnreachable,
+      DexWatch.get_name() : DexWatch
+    }
+
+
+def _get_command_name(command_raw: str) -> str:
+    """Return command name by splitting up DExTer command contained in
+    command_raw on the first opening paranthesis and further stripping
+    any potential leading or trailing whitespace.
+    """
+    return command_raw.split('(', 1)[0].rstrip()
+
+
+def _merge_subcommands(command_name: str, valid_commands: dict) -> dict:
+    """Merge valid_commands and command_name's subcommands into a new dict.
+
+    Returns:
+        { name (str): command (class) }
+    """
+    subcommands = valid_commands[command_name].get_subcommands()
+    if subcommands:
+        return { **valid_commands, **subcommands }
+    return valid_commands
+
+
+def _build_command(command_type, raw_text: str, path: str, lineno: str) -> CommandBase:
+    """Build a command object from raw text.
+
+    This function will call eval().
+
+    Raises:
+        Any exception that eval() can raise.
+
+    Returns:
+        A dexter command object.
+    """
+    valid_commands = _merge_subcommands(
+        command_type.get_name(), { command_type.get_name(): command_type })
+    # pylint: disable=eval-used
+    command = eval(raw_text, valid_commands)
+    # pylint: enable=eval-used
+    command.raw_text = raw_text
+    command.path = path
+    command.lineno = lineno
+    return command
+
+
+def resolve_labels(command: CommandBase, commands: dict):
+    """Attempt to resolve any labels in command"""
+    dex_labels = commands['DexLabel']
+    command_label_args = command.get_label_args()
+    for command_arg in command_label_args:
+        for dex_label in list(dex_labels.values()):
+            if (os.path.samefile(dex_label.path, command.path) and
+                dex_label.eval() == command_arg):
+                command.resolve_label(dex_label.get_as_pair())
+    # labels for command should be resolved by this point.
+    if command.has_labels():
+        syntax_error = SyntaxError()
+        syntax_error.filename = command.path
+        syntax_error.lineno = command.lineno
+        syntax_error.offset = 0
+        syntax_error.msg = 'Unresolved labels'
+        for label in command.get_label_args():
+            syntax_error.msg += ' \'' + label + '\''
+        raise syntax_error
+
+
+def _search_line_for_cmd_start(line: str, start: int, valid_commands: dict) -> int:
+    """Scan `line` for a string matching any key in `valid_commands`.
+
+    Start searching from `start`.
+    Commands escaped with `\` (E.g. `\DexLabel('a')`) are ignored.
+
+    Returns:
+        int: the index of the first character of the matching string in `line`
+        or -1 if no command is found.
+    """
+    for command in valid_commands:
+        idx = line.find(command, start)
+        if idx != -1:
+            # Ignore escaped '\' commands.
+            if idx > 0 and line[idx - 1] == '\\':
+                continue
+            return idx
+    return -1
+
+
+def _search_line_for_cmd_end(line: str, start: int, paren_balance: int) -> (int, int):
+    """Find the end of a command by looking for balanced parentheses.
+
+    Args:
+        line: String to scan.
+        start: Index into `line` to start looking.
+        paren_balance(int): paren_balance after previous call.
+
+    Note:
+        On the first call `start` should point at the opening parenthesis and
+        `paren_balance` should be set to 0. Subsequent calls should pass in the
+        returned `paren_balance`.
+
+    Returns:
+        ( end,  paren_balance )
+        Where end is 1 + the index of the last char in the command or, if the
+        parentheses are not balanced, the end of the line.
+
+        paren_balance will be 0 when the parentheses are balanced.
+    """
+    for end in range(start, len(line)):
+        ch = line[end]
+        if ch == '(':
+            paren_balance += 1
+        elif ch == ')':
+            paren_balance -=1
+        if paren_balance == 0:
+            break
+    end += 1
+    return (end, paren_balance)
+
+
+class TextPoint():
+    def __init__(self, line, char):
+        self.line = line
+        self.char = char
+
+    def get_lineno(self):
+        return self.line + 1
+
+    def get_column(self):
+        return self.char + 1
+
+
+def format_parse_err(msg: str, path: str, lines: list, point: TextPoint) -> CommandParseError:
+    err = CommandParseError()
+    err.filename = path
+    err.src = lines[point.line].rstrip()
+    err.lineno = point.get_lineno()
+    err.info = msg
+    err.caret = '{}<r>^</>'.format(' ' * (point.char))
+    return err
+
+
+def skip_horizontal_whitespace(line, point):
+    for idx, char in enumerate(line[point.char:]):
+        if char not in ' \t':
+            point.char += idx
+            return
+
+
+def _find_all_commands_in_file(path, file_lines, valid_commands):
+    commands = defaultdict(dict)
+    paren_balance = 0
+    region_start = TextPoint(0, 0)
+    for region_start.line in range(len(file_lines)):
+        line = file_lines[region_start.line]
+        region_start.char = 0
+
+        # Search this line till we find no more commands.
+        while True:
+            # If parens are currently balanced we can look for a new command.
+            if paren_balance == 0:
+                region_start.char = _search_line_for_cmd_start(line, region_start.char, valid_commands)
+                if region_start.char == -1:
+                    break # Read next line.
+
+                command_name = _get_command_name(line[region_start.char:])
+                cmd_point = copy(region_start)
+                cmd_text_list = [command_name]
+
+                region_start.char += len(command_name) # Start searching for parens after cmd.
+                skip_horizontal_whitespace(line, region_start)
+                if region_start.char >= len(line) or line[region_start.char] != '(':
+                    raise format_parse_err(
+                        "Missing open parenthesis", path, file_lines, region_start)
+
+            end, paren_balance = _search_line_for_cmd_end(line, region_start.char, paren_balance)
+            # Add this text blob to the command.
+            cmd_text_list.append(line[region_start.char:end])
+            # Move parse ptr to end of line or parens
+            region_start.char = end
+
+            # If the parens are unbalanced start reading the next line in an attempt
+            # to find the end of the command.
+            if paren_balance != 0:
+                break  # Read next line.
+
+            # Parens are balanced, we have a full command to evaluate.
+            raw_text = "".join(cmd_text_list)
+            try:
+                command = _build_command(
+                    valid_commands[command_name],
+                    raw_text,
+                    path,
+                    cmd_point.get_lineno(),
+                )
+            except SyntaxError as e:
+                # This err should point to the problem line.
+                err_point = copy(cmd_point)
+                # To e the command start is the absolute start, so use as offset.
+                err_point.line += e.lineno - 1 # e.lineno is a position, not index.
+                err_point.char += e.offset - 1 # e.offset is a position, not index.
+                raise format_parse_err(e.msg, path, file_lines, err_point)
+            except TypeError as e:
+                # This err should always point to the end of the command name.
+                err_point = copy(cmd_point)
+                err_point.char += len(command_name)
+                raise format_parse_err(str(e), path, file_lines, err_point)
+            else:
+                resolve_labels(command, commands)
+                assert (path, cmd_point) not in commands[command_name], (
+                    command_name, commands[command_name])
+                commands[command_name][path, cmd_point] = command
+
+    if paren_balance != 0:
+        # This err should always point to the end of the command name.
+        err_point = copy(cmd_point)
+        err_point.char += len(command_name)
+        msg = "Unbalanced parenthesis starting here"
+        raise format_parse_err(msg, path, file_lines, err_point)
+    return dict(commands)
+
+
+
+def find_all_commands(source_files):
+    commands = defaultdict(dict)
+    valid_commands = _get_valid_commands()
+    for source_file in source_files:
+        with open(source_file) as fp:
+            lines = fp.readlines()
+        file_commands = _find_all_commands_in_file(source_file, lines,
+                                                   valid_commands)
+        for command_name in file_commands:
+            commands[command_name].update(file_commands[command_name])
+
+    return dict(commands)
+
+
+class TestParseCommand(unittest.TestCase):
+    class MockCmd(CommandBase):
+        """A mock DExTer command for testing parsing.
+
+        Args:
+            value (str): Unique name for this instance.
+        """
+
+        def __init__(self, *args):
+           self.value = args[0]
+
+        def get_name():
+            return __class__.__name__
+
+        def eval(this):
+            pass
+
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+        self.valid_commands = {
+            TestParseCommand.MockCmd.get_name() : TestParseCommand.MockCmd
+        }
+
+
+    def _find_all_commands_in_lines(self, lines):
+        """Use DExTer parsing methods to find all the mock commands in lines.
+
+        Returns:
+            { cmd_name: { (path, line): command_obj } }
+        """
+        return _find_all_commands_in_file(__file__, lines, self.valid_commands)
+
+
+    def _find_all_mock_values_in_lines(self, lines):
+        """Use DExTer parsing methods to find all mock command values in lines.
+
+        Returns:
+            values (list(str)): MockCmd values found in lines.
+        """
+        cmds = self._find_all_commands_in_lines(lines)
+        mocks = cmds.get(TestParseCommand.MockCmd.get_name(), None)
+        return [v.value for v in mocks.values()] if mocks else []
+
+
+    def test_parse_inline(self):
+        """Commands can be embedded in other text."""
+
+        lines = [
+            'MockCmd("START") Lorem ipsum dolor sit amet, consectetur\n',
+            'adipiscing elit, MockCmd("EMBEDDED") sed doeiusmod tempor,\n',
+            'incididunt ut labore et dolore magna aliqua.\n'
+        ]
+
+        values = self._find_all_mock_values_in_lines(lines)
+
+        self.assertTrue('START' in values)
+        self.assertTrue('EMBEDDED' in values)
+
+
+    def test_parse_multi_line_comment(self):
+        """Multi-line commands can embed comments."""
+
+        lines = [
+            'Lorem ipsum dolor sit amet, consectetur\n',
+            'adipiscing elit, sed doeiusmod tempor,\n',
+            'incididunt ut labore et MockCmd(\n',
+            '    "WITH_COMMENT" # THIS IS A COMMENT\n',
+            ') dolore magna aliqua. Ut enim ad minim\n',
+        ]
+
+        values = self._find_all_mock_values_in_lines(lines)
+
+        self.assertTrue('WITH_COMMENT' in values)
+
+    def test_parse_empty(self):
+        """Empty files are silently ignored."""
+
+        lines = []
+        values = self._find_all_mock_values_in_lines(lines)
+        self.assertTrue(len(values) == 0)
+
+    def test_parse_bad_whitespace(self):
+        """Throw exception when parsing badly formed whitespace."""
+        lines = [
+            'MockCmd\n',
+            '("XFAIL_CMD_LF_PAREN")\n',
+        ]
+
+        with self.assertRaises(CommandParseError):
+            values = self._find_all_mock_values_in_lines(lines)
+
+    def test_parse_good_whitespace(self):
+        """Try to emulate python whitespace rules"""
+
+        lines = [
+            'MockCmd("NONE")\n',
+            'MockCmd    ("SPACE")\n',
+            'MockCmd\t\t("TABS")\n',
+            'MockCmd(    "ARG_SPACE"    )\n',
+            'MockCmd(\t\t"ARG_TABS"\t\t)\n',
+            'MockCmd(\n',
+            '"CMD_PAREN_LF")\n',
+        ]
+
+        values = self._find_all_mock_values_in_lines(lines)
+
+        self.assertTrue('NONE' in values)
+        self.assertTrue('SPACE' in values)
+        self.assertTrue('TABS' in values)
+        self.assertTrue('ARG_SPACE' in values)
+        self.assertTrue('ARG_TABS' in values)
+        self.assertTrue('CMD_PAREN_LF' in values)
+
+
+    def test_parse_share_line(self):
+        """More than one command can appear on one line."""
+
+        lines = [
+            'MockCmd("START") MockCmd("CONSECUTIVE") words '
+                'MockCmd("EMBEDDED") more words\n'
+        ]
+
+        values = self._find_all_mock_values_in_lines(lines)
+
+        self.assertTrue('START' in values)
+        self.assertTrue('CONSECUTIVE' in values)
+        self.assertTrue('EMBEDDED' in values)
+
+
+    def test_parse_escaped(self):
+        """Escaped commands are ignored."""
+
+        lines = [
+            'words \MockCmd("IGNORED") words words words\n'
+        ]
+
+        values = self._find_all_mock_values_in_lines(lines)
+
+        self.assertFalse('IGNORED' in values)
diff --git a/debuginfo-tests/dexter/dex/command/StepValueInfo.py b/debuginfo-tests/dexter/dex/command/StepValueInfo.py
new file mode 100644
index 00000000000..afcb9c5d0c8
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/StepValueInfo.py
@@ -0,0 +1,23 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+
+class StepValueInfo(object):
+    def __init__(self, step_index, watch_info, expected_value):
+        self.step_index = step_index
+        self.watch_info = watch_info
+        self.expected_value = expected_value
+
+    def __str__(self):
+        return '{}:{}: expected value:{}'.format(self.step_index, self.watch_info, self.expected_value)
+
+    def __eq__(self, other):
+        return (self.watch_info.expression == other.watch_info.expression
+                and self.expected_value == other.expected_value)
+
+    def __hash__(self):
+        return hash(self.watch_info.expression, self.expected_value)
diff --git a/debuginfo-tests/dexter/dex/command/__init__.py b/debuginfo-tests/dexter/dex/command/__init__.py
new file mode 100644
index 00000000000..70da546fe5e
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/__init__.py
@@ -0,0 +1,9 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.command.ParseCommand import find_all_commands
+from dex.command.StepValueInfo import StepValueInfo
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexExpectProgramState.py b/debuginfo-tests/dexter/dex/command/commands/DexExpectProgramState.py
new file mode 100644
index 00000000000..78335838a65
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexExpectProgramState.py
@@ -0,0 +1,83 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command for specifying a partial or complete state for the program to enter
+during execution.
+"""
+
+from itertools import chain
+
+from dex.command.CommandBase import CommandBase
+from dex.dextIR import ProgramState, SourceLocation, StackFrame, DextIR
+
+def frame_from_dict(source: dict) -> StackFrame:
+    if 'location' in source:
+        assert isinstance(source['location'], dict)
+        source['location'] = SourceLocation(**source['location'])
+    return StackFrame(**source)
+
+def state_from_dict(source: dict) -> ProgramState:
+    if 'frames' in source:
+        assert isinstance(source['frames'], list)
+        source['frames'] = list(map(frame_from_dict, source['frames']))
+    return ProgramState(**source)
+
+class DexExpectProgramState(CommandBase):
+    """Expect to see a given program `state` a certain numer of `times`.
+
+    DexExpectProgramState(state [,**times])
+
+    See Commands.md for more info.
+    """
+
+    def __init__(self, *args, **kwargs):
+        if len(args) != 1:
+            raise TypeError('expected exactly one unnamed arg')
+
+        self.program_state_text = str(args[0])
+
+        self.expected_program_state = state_from_dict(args[0])
+
+        self.times = kwargs.pop('times', -1)
+        if kwargs:
+            raise TypeError('unexpected named args: {}'.format(
+                ', '.join(kwargs)))
+
+        # Step indices at which the expected program state was encountered.
+        self.encounters = []
+
+        super(DexExpectProgramState, self).__init__()
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def get_watches(self):
+        frame_expects = chain.from_iterable(frame.watches
+            for frame in self.expected_program_state.frames)
+        return set(frame_expects)
+
+    def eval(self, step_collection: DextIR) -> bool:
+        for step in step_collection.steps:
+            if self.expected_program_state.match(step.program_state):
+                self.encounters.append(step.step_index)
+
+        return self.times < 0 < len(self.encounters) or len(self.encounters) == self.times
+
+    def has_labels(self):
+        return len(self.get_label_args()) > 0
+
+    def get_label_args(self):
+        return [frame.location.lineno
+                    for frame in self.expected_program_state.frames
+                        if frame.location and
+                        isinstance(frame.location.lineno, str)]
+
+    def resolve_label(self, label_line__pair):
+        label, line = label_line__pair
+        for frame in self.expected_program_state.frames:
+            if frame.location and frame.location.lineno == label:
+                frame.location.lineno = line
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexExpectStepKind.py b/debuginfo-tests/dexter/dex/command/commands/DexExpectStepKind.py
new file mode 100644
index 00000000000..6370f5d32c7
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexExpectStepKind.py
@@ -0,0 +1,45 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command for specifying an expected number of steps of a particular kind."""
+
+from dex.command.CommandBase import CommandBase
+from dex.dextIR.StepIR import StepKind
+
+
+class DexExpectStepKind(CommandBase):
+    """Expect to see a particular step `kind` a number of `times` while stepping
+    through the program.
+
+    DexExpectStepKind(kind, times)
+
+    See Commands.md for more info.
+    """
+
+    def __init__(self, *args):
+        if len(args) != 2:
+            raise TypeError('expected two args')
+
+        try:
+            step_kind = StepKind[args[0]]
+        except KeyError:
+            raise TypeError('expected arg 0 to be one of {}'.format(
+                [kind for kind, _ in StepKind.__members__.items()]))
+
+        self.name = step_kind
+        self.count = args[1]
+
+        super(DexExpectStepKind, self).__init__()
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def eval(self):
+        # DexExpectStepKind eval() implementation is mixed into
+        # Heuristic.__init__()
+        # [TODO] Fix this ^.
+        pass
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexExpectStepOrder.py b/debuginfo-tests/dexter/dex/command/commands/DexExpectStepOrder.py
new file mode 100644
index 00000000000..4342bc5e80b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexExpectStepOrder.py
@@ -0,0 +1,39 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.command.CommandBase import CommandBase
+from dex.dextIR import ValueIR
+
+class DexExpectStepOrder(CommandBase):
+    """Expect the line every `DexExpectStepOrder` is found on to be stepped on
+    in `order`. Each instance must have a set of unique ascending indicies.
+
+    DexExpectStepOrder(*order)
+
+    See Commands.md for more info.
+    """
+
+    def __init__(self, *args):
+        if not args:
+            raise TypeError('Need at least one order number')
+
+        self.sequence = [int(x) for x in args]
+        super(DexExpectStepOrder, self).__init__()
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def eval(self, debugger):
+        step_info = debugger.get_step_info()
+        loc = step_info.current_location
+        return {'DexExpectStepOrder': ValueIR(expression=str(loc.lineno),
+                      value=str(debugger.step_index), type_name=None,
+                      error_string=None,
+                      could_evaluate=True,
+                      is_optimized_away=True,
+                      is_irretrievable=False)}
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchBase.py b/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchBase.py
new file mode 100644
index 00000000000..e6422d14098
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchBase.py
@@ -0,0 +1,197 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+"""DexExpectWatch base class, holds logic for how to build and process expected
+ watch commands.
+"""
+
+import abc
+import difflib
+import os
+
+from dex.command.CommandBase import CommandBase
+from dex.command.StepValueInfo import StepValueInfo
+
+
+class DexExpectWatchBase(CommandBase):
+    def __init__(self, *args, **kwargs):
+        if len(args) < 2:
+            raise TypeError('expected at least two args')
+
+        self.expression = args[0]
+        self.values = [str(arg) for arg in args[1:]]
+        try:
+            on_line = kwargs.pop('on_line')
+            self._from_line = on_line
+            self._to_line = on_line
+        except KeyError:
+            self._from_line = kwargs.pop('from_line', 1)
+            self._to_line = kwargs.pop('to_line', 999999)
+        self._require_in_order = kwargs.pop('require_in_order', True)
+        if kwargs:
+            raise TypeError('unexpected named args: {}'.format(
+                ', '.join(kwargs)))
+
+        # Number of times that this watch has been encountered.
+        self.times_encountered = 0
+
+        # We'll pop from this set as we encounter values so anything left at
+        # the end can be considered as not having been seen.
+        self._missing_values = set(self.values)
+
+        self.misordered_watches = []
+
+        # List of StepValueInfos for any watch that is encountered as invalid.
+        self.invalid_watches = []
+
+        # List of StepValueInfo any any watch where we couldn't retrieve its
+        # data.
+        self.irretrievable_watches = []
+
+        # List of StepValueInfos for any watch that is encountered as having
+        # been optimized out.
+        self.optimized_out_watches = []
+
+        # List of StepValueInfos for any watch that is encountered that has an
+        # expected value.
+        self.expected_watches = []
+
+        # List of StepValueInfos for any watch that is encountered that has an
+        # unexpected value.
+        self.unexpected_watches = []
+
+        super(DexExpectWatchBase, self).__init__()
+
+
+    def get_watches(self):
+        return [self.expression]
+
+    @property
+    def line_range(self):
+        return list(range(self._from_line, self._to_line + 1))
+
+    @property
+    def missing_values(self):
+        return sorted(list(self._missing_values))
+
+    @property
+    def encountered_values(self):
+        return sorted(list(set(self.values) - self._missing_values))
+
+
+    def resolve_label(self, label_line_pair):
+        # from_line and to_line could have the same label.
+        label, lineno = label_line_pair
+        if self._to_line == label:
+            self._to_line = lineno
+        if self._from_line == label:
+            self._from_line = lineno
+
+    def has_labels(self):
+        return len(self.get_label_args()) > 0
+
+    def get_label_args(self):
+        return [label for label in (self._from_line, self._to_line)
+                      if isinstance(label, str)]
+
+    @abc.abstractmethod
+    def _get_expected_field(self, watch):
+        """Return a field from watch that this ExpectWatch command is checking.
+        """
+
+    def _handle_watch(self, step_info):
+        self.times_encountered += 1
+
+        if not step_info.watch_info.could_evaluate:
+            self.invalid_watches.append(step_info)
+            return
+
+        if step_info.watch_info.is_optimized_away:
+            self.optimized_out_watches.append(step_info)
+            return
+
+        if step_info.watch_info.is_irretrievable:
+            self.irretrievable_watches.append(step_info)
+            return
+
+        if step_info.expected_value not in self.values:
+            self.unexpected_watches.append(step_info)
+            return
+
+        self.expected_watches.append(step_info)
+        try:
+            self._missing_values.remove(step_info.expected_value)
+        except KeyError:
+            pass
+
+    def _check_watch_order(self, actual_watches, expected_values):
+        """Use difflib to figure out whether the values are in the expected order
+        or not.
+        """
+        differences = []
+        actual_values = [w.expected_value for w in actual_watches]
+        value_differences = list(difflib.Differ().compare(actual_values,
+                                                          expected_values))
+
+        missing_value = False
+        index = 0
+        for vd in value_differences:
+            kind = vd[0]
+            if kind == '+':
+                # A value that is encountered in the expected list but not in the
+                # actual list.  We'll keep a note that something is wrong and flag
+                # the next value that matches as misordered.
+                missing_value = True
+            elif kind == ' ':
+                # This value is as expected.  It might still be wrong if we've
+                # previously encountered a value that is in the expected list but
+                #  not the actual list.
+                if missing_value:
+                    missing_value = False
+                    differences.append(actual_watches[index])
+                index += 1
+            elif kind == '-':
+                # A value that is encountered in the actual list but not the
+                #  expected list.
+                differences.append(actual_watches[index])
+                index += 1
+            else:
+                assert False, 'unexpected diff:{}'.format(vd)
+
+        return differences
+
+    def eval(self, step_collection):
+        for step in step_collection.steps:
+            loc = step.current_location
+
+            if (os.path.exists(loc.path) and os.path.exists(self.path) and
+                os.path.samefile(loc.path, self.path) and
+                loc.lineno in self.line_range):
+                try:
+                    watch = step.program_state.frames[0].watches[self.expression]
+                except KeyError:
+                    pass
+                else:
+                    expected_field = self._get_expected_field(watch)
+                    step_info = StepValueInfo(step.step_index, watch, 
+                                              expected_field)
+                    self._handle_watch(step_info)
+
+        if self._require_in_order:
+            # A list of all watches where the value has changed.
+            value_change_watches = []
+            prev_value = None
+            for watch in self.expected_watches:
+                if watch.expected_value != prev_value:
+                    value_change_watches.append(watch)
+                    prev_value = watch.expected_value
+
+            self.misordered_watches = self._check_watch_order(
+                value_change_watches, [
+                    v for v in self.values if v in
+                    [w.expected_value for w in self.expected_watches]
+                ])
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchType.py b/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchType.py
new file mode 100644
index 00000000000..f2336de4828
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchType.py
@@ -0,0 +1,26 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command for specifying an expected set of types for a particular watch."""
+
+
+from dex.command.commands.DexExpectWatchBase import DexExpectWatchBase
+
+class DexExpectWatchType(DexExpectWatchBase):
+    """Expect the expression `expr` to evaluate be evaluated and have each
+    evaluation's type checked against the list of `types`.
+
+    DexExpectWatchType(expr, *types [,**from_line=1][,**to_line=Max]
+                        [,**on_line])
+
+    See Commands.md for more info.
+    """
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def _get_expected_field(self, watch):
+        return watch.type_name
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchValue.py b/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchValue.py
new file mode 100644
index 00000000000..d6da006ee8c
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexExpectWatchValue.py
@@ -0,0 +1,27 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command for specifying an expected set of values for a particular watch."""
+
+
+from dex.command.commands.DexExpectWatchBase import DexExpectWatchBase
+
+class DexExpectWatchValue(DexExpectWatchBase):
+    """Expect the expression `expr` to evaluate to the list of `values`
+    sequentially.
+
+    DexExpectWatchValue(expr, *values [,**from_line=1][,**to_line=Max]
+                        [,**on_line])
+
+    See Commands.md for more info.
+    """
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def _get_expected_field(self, watch):
+        return watch.value
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexLabel.py b/debuginfo-tests/dexter/dex/command/commands/DexLabel.py
new file mode 100644
index 00000000000..8a0325e6634
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexLabel.py
@@ -0,0 +1,31 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command used to give a line in a test a named psuedonym. Every DexLabel has
+   a line number and Label string component.
+"""
+
+from dex.command.CommandBase import CommandBase
+
+
+class DexLabel(CommandBase):
+    def __init__(self, label):
+
+        if not isinstance(label, str):
+            raise TypeError('invalid argument type')
+
+        self._label = label
+        super(DexLabel, self).__init__()
+
+    def get_as_pair(self):
+        return (self._label, self.lineno)
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def eval(self):
+        return self._label
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexUnreachable.py b/debuginfo-tests/dexter/dex/command/commands/DexUnreachable.py
new file mode 100644
index 00000000000..188a5d8180d
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexUnreachable.py
@@ -0,0 +1,38 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+
+from dex.command.CommandBase import CommandBase
+from dex.dextIR import ValueIR
+
+
+class DexUnreachable(CommandBase):
+    """Expect the source line this is found on will never be stepped on to.
+
+    DexUnreachable()
+
+    See Commands.md for more info.
+    """
+
+    def __init(self):
+        super(DexUnreachable, self).__init__()
+        pass
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def eval(self, debugger):
+        # If we're ever called, at all, then we're evaluating a line that has
+        # been marked as unreachable. Which means a failure.
+        vir = ValueIR(expression="Unreachable",
+                      value="True", type_name=None,
+                      error_string=None,
+                      could_evaluate=True,
+                      is_optimized_away=True,
+                      is_irretrievable=False)
+        return {'DexUnreachable' : vir}
diff --git a/debuginfo-tests/dexter/dex/command/commands/DexWatch.py b/debuginfo-tests/dexter/dex/command/commands/DexWatch.py
new file mode 100644
index 00000000000..2dfa3a36fb3
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/command/commands/DexWatch.py
@@ -0,0 +1,39 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Command to instruct the debugger to inspect the value of some set of
+expressions on the current source line.
+"""
+
+from dex.command.CommandBase import CommandBase
+
+
+class DexWatch(CommandBase):
+    """[Deprecated] Evaluate each given `expression` when the debugger steps onto the
+    line this command is found on
+
+    DexWatch(*expressions)
+
+    See Commands.md for more info.
+    """
+
+    def __init__(self, *args):
+        if not args:
+            raise TypeError('expected some arguments')
+
+        for arg in args:
+            if not isinstance(arg, str):
+                raise TypeError('invalid argument type')
+
+        self._args = args
+        super(DexWatch, self).__init__()
+
+    @staticmethod
+    def get_name():
+        return __class__.__name__
+
+    def eval(self, debugger):
+        return {arg: debugger.evaluate_expression(arg) for arg in self._args}
diff --git a/debuginfo-tests/dexter/dex/debugger/DebuggerBase.py b/debuginfo-tests/dexter/dex/debugger/DebuggerBase.py
new file mode 100644
index 00000000000..8013ceb6436
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/DebuggerBase.py
@@ -0,0 +1,227 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Base class for all debugger interface implementations."""
+
+import abc
+from itertools import chain
+import os
+import sys
+import time
+import traceback
+
+from dex.dextIR import DebuggerIR, ValueIR
+from dex.utils.Exceptions import DebuggerException
+from dex.utils.Exceptions import NotYetLoadedDebuggerException
+from dex.utils.ReturnCode import ReturnCode
+
+
+class DebuggerBase(object, metaclass=abc.ABCMeta):
+    def __init__(self, context, step_collection):
+        self.context = context
+        self.steps = step_collection
+        self._interface = None
+        self.has_loaded = False
+        self._loading_error = NotYetLoadedDebuggerException()
+        self.watches = set()
+
+        try:
+            self._interface = self._load_interface()
+            self.has_loaded = True
+            self._loading_error = None
+        except DebuggerException:
+            self._loading_error = sys.exc_info()
+
+        self.step_index = 0
+
+    def __enter__(self):
+        try:
+            self._custom_init()
+            self.clear_breakpoints()
+            self.add_breakpoints()
+        except DebuggerException:
+            self._loading_error = sys.exc_info()
+        return self
+
+    def __exit__(self, *args):
+        self._custom_exit()
+
+    def _custom_init(self):
+        pass
+
+    def _custom_exit(self):
+        pass
+
+    @property
+    def debugger_info(self):
+        return DebuggerIR(name=self.name, version=self.version)
+
+    @property
+    def is_available(self):
+        return self.has_loaded and self.loading_error is None
+
+    @property
+    def loading_error(self):
+        return (str(self._loading_error[1])
+                if self._loading_error is not None else None)
+
+    @property
+    def loading_error_trace(self):
+        if not self._loading_error:
+            return None
+
+        tb = traceback.format_exception(*self._loading_error)
+
+        if self._loading_error[1].orig_exception is not None:
+            orig_exception = traceback.format_exception(
+                *self._loading_error[1].orig_exception)
+
+            if ''.join(orig_exception) not in ''.join(tb):
+                tb.extend(['\n'])
+                tb.extend(orig_exception)
+
+        tb = ''.join(tb).splitlines(True)
+        return tb
+
+    def add_breakpoints(self):
+        for s in self.context.options.source_files:
+            with open(s, 'r') as fp:
+                num_lines = len(fp.readlines())
+            for line in range(1, num_lines + 1):
+                self.add_breakpoint(s, line)
+
+    def _update_step_watches(self, step_info):
+        loc = step_info.current_location
+        watch_cmds = ['DexUnreachable', 'DexExpectStepOrder']
+        towatch = chain.from_iterable(self.steps.commands[x]
+                                      for x in watch_cmds
+                                      if x in self.steps.commands)
+        try:
+            # Iterate over all watches of the types named in watch_cmds
+            for watch in towatch:
+                if (os.path.exists(loc.path)
+                        and os.path.samefile(watch.path, loc.path)
+                        and watch.lineno == loc.lineno):
+                    result = watch.eval(self)
+                    step_info.watches.update(result)
+                    break
+        except KeyError:
+            pass
+
+    def _sanitize_function_name(self, name):  # pylint: disable=no-self-use
+        """If the function name returned by the debugger needs any post-
+        processing to make it fit (for example, if it includes a byte offset),
+        do that here.
+        """
+        return name
+
+    def start(self):
+        self.steps.clear_steps()
+        self.launch()
+
+        for command_obj in chain.from_iterable(self.steps.commands.values()):
+            self.watches.update(command_obj.get_watches())
+
+        max_steps = self.context.options.max_steps
+        for _ in range(max_steps):
+            while self.is_running:
+                pass
+
+            if self.is_finished:
+                break
+
+            self.step_index += 1
+            step_info = self.get_step_info()
+
+            if step_info.current_frame:
+                self._update_step_watches(step_info)
+                self.steps.new_step(self.context, step_info)
+
+            if self.in_source_file(step_info):
+                self.step()
+            else:
+                self.go()
+
+            time.sleep(self.context.options.pause_between_steps)
+        else:
+            raise DebuggerException(
+                'maximum number of steps reached ({})'.format(max_steps))
+
+    def in_source_file(self, step_info):
+        if not step_info.current_frame:
+            return False
+        if not os.path.exists(step_info.current_location.path):
+            return False
+        return any(os.path.samefile(step_info.current_location.path, f) \
+                   for f in self.context.options.source_files)
+
+    @abc.abstractmethod
+    def _load_interface(self):
+        pass
+
+    @classmethod
+    def get_option_name(cls):
+        """Short name that will be used on the command line to specify this
+        debugger.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def get_name(cls):
+        """Full name of this debugger."""
+        raise NotImplementedError()
+
+    @property
+    def name(self):
+        return self.__class__.get_name()
+
+    @property
+    def option_name(self):
+        return self.__class__.get_option_name()
+
+    @abc.abstractproperty
+    def version(self):
+        pass
+
+    @abc.abstractmethod
+    def clear_breakpoints(self):
+        pass
+
+    @abc.abstractmethod
+    def add_breakpoint(self, file_, line):
+        pass
+
+    @abc.abstractmethod
+    def launch(self):
+        pass
+
+    @abc.abstractmethod
+    def step(self):
+        pass
+
+    @abc.abstractmethod
+    def go(self) -> ReturnCode:
+        pass
+
+    @abc.abstractmethod
+    def get_step_info(self):
+        pass
+
+    @abc.abstractproperty
+    def is_running(self):
+        pass
+
+    @abc.abstractproperty
+    def is_finished(self):
+        pass
+
+    @abc.abstractproperty
+    def frames_below_main(self):
+        pass
+
+    @abc.abstractmethod
+    def evaluate_expression(self, expression, frame_idx=0) -> ValueIR:
+        pass
diff --git a/debuginfo-tests/dexter/dex/debugger/Debuggers.py b/debuginfo-tests/dexter/dex/debugger/Debuggers.py
new file mode 100644
index 00000000000..2f246a3fd95
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/Debuggers.py
@@ -0,0 +1,299 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Discover potential/available debugger interfaces."""
+
+from collections import OrderedDict
+import os
+import pickle
+import subprocess
+import sys
+from tempfile import NamedTemporaryFile
+
+from dex.command import find_all_commands
+from dex.dextIR import DextIR
+from dex.utils import get_root_directory, Timer
+from dex.utils.Environment import is_native_windows
+from dex.utils.Exceptions import CommandParseError, DebuggerException
+from dex.utils.Exceptions import ToolArgumentError
+from dex.utils.Warning import warn
+
+from dex.debugger.dbgeng.dbgeng import DbgEng
+from dex.debugger.lldb.LLDB import LLDB
+from dex.debugger.visualstudio.VisualStudio2015 import VisualStudio2015
+from dex.debugger.visualstudio.VisualStudio2017 import VisualStudio2017
+
+
+def _get_potential_debuggers():  # noqa
+    """Return a dict of the supported debuggers.
+    Returns:
+        { name (str): debugger (class) }
+    """
+    return {
+        DbgEng.get_option_name(): DbgEng,
+        LLDB.get_option_name(): LLDB,
+        VisualStudio2015.get_option_name(): VisualStudio2015,
+        VisualStudio2017.get_option_name(): VisualStudio2017
+    }
+
+
+def _warn_meaningless_option(context, option):
+    if context.options.list_debuggers:
+        return
+
+    warn(context,
+         'option <y>"{}"</> is meaningless with this debugger'.format(option),
+         '--debugger={}'.format(context.options.debugger))
+
+
+def add_debugger_tool_base_arguments(parser, defaults):
+    defaults.lldb_executable = 'lldb.exe' if is_native_windows() else 'lldb'
+    parser.add_argument(
+        '--lldb-executable',
+        type=str,
+        metavar='<file>',
+        default=None,
+        display_default=defaults.lldb_executable,
+        help='location of LLDB executable')
+
+
+def add_debugger_tool_arguments(parser, context, defaults):
+    debuggers = Debuggers(context)
+    potential_debuggers = sorted(debuggers.potential_debuggers().keys())
+
+    add_debugger_tool_base_arguments(parser, defaults)
+
+    parser.add_argument(
+        '--debugger',
+        type=str,
+        choices=potential_debuggers,
+        required=True,
+        help='debugger to use')
+    parser.add_argument(
+        '--max-steps',
+        metavar='<int>',
+        type=int,
+        default=1000,
+        help='maximum number of program steps allowed')
+    parser.add_argument(
+        '--pause-between-steps',
+        metavar='<seconds>',
+        type=float,
+        default=0.0,
+        help='number of seconds to pause between steps')
+    defaults.show_debugger = False
+    parser.add_argument(
+        '--show-debugger',
+        action='store_true',
+        default=None,
+        help='show the debugger')
+    defaults.arch = 'x86_64'
+    parser.add_argument(
+        '--arch',
+        type=str,
+        metavar='<architecture>',
+        default=None,
+        display_default=defaults.arch,
+        help='target architecture')
+
+
+def handle_debugger_tool_base_options(context, defaults):  # noqa
+    options = context.options
+
+    if options.lldb_executable is None:
+        options.lldb_executable = defaults.lldb_executable
+    else:
+        if getattr(options, 'debugger', 'lldb') != 'lldb':
+            _warn_meaningless_option(context, '--lldb-executable')
+
+        options.lldb_executable = os.path.abspath(options.lldb_executable)
+        if not os.path.isfile(options.lldb_executable):
+            raise ToolArgumentError('<d>could not find</> <r>"{}"</>'.format(
+                options.lldb_executable))
+
+
+def handle_debugger_tool_options(context, defaults):  # noqa
+    options = context.options
+
+    handle_debugger_tool_base_options(context, defaults)
+
+    if options.arch is None:
+        options.arch = defaults.arch
+    else:
+        if options.debugger != 'lldb':
+            _warn_meaningless_option(context, '--arch')
+
+    if options.show_debugger is None:
+        options.show_debugger = defaults.show_debugger
+    else:
+        if options.debugger == 'lldb':
+            _warn_meaningless_option(context, '--show-debugger')
+
+
+def _get_command_infos(context):
+    commands = find_all_commands(context.options.source_files)
+    command_infos = OrderedDict()
+    for command_type in commands:
+        for command in commands[command_type].values():
+            if command_type not in command_infos:
+                command_infos[command_type] = []
+            command_infos[command_type].append(command)
+    return OrderedDict(command_infos)
+
+
+def empty_debugger_steps(context):
+    return DextIR(
+        executable_path=context.options.executable,
+        source_paths=context.options.source_files,
+        dexter_version=context.version)
+
+
+def get_debugger_steps(context):
+    step_collection = empty_debugger_steps(context)
+
+    with Timer('parsing commands'):
+        try:
+            step_collection.commands = _get_command_infos(context)
+        except CommandParseError as e:
+            msg = 'parser error: <d>{}({}):</> {}\n{}\n{}\n'.format(
+                e.filename, e.lineno, e.info, e.src, e.caret)
+            raise DebuggerException(msg)
+
+    with NamedTemporaryFile(
+            dir=context.working_directory.path, delete=False) as fp:
+        pickle.dump(step_collection, fp, protocol=pickle.HIGHEST_PROTOCOL)
+        steps_path = fp.name
+
+    with NamedTemporaryFile(
+            dir=context.working_directory.path, delete=False, mode='wb') as fp:
+        pickle.dump(context.options, fp, protocol=pickle.HIGHEST_PROTOCOL)
+        options_path = fp.name
+
+    dexter_py = os.path.basename(sys.argv[0])
+    if not os.path.isfile(dexter_py):
+        dexter_py = os.path.join(get_root_directory(), '..', dexter_py)
+    assert os.path.isfile(dexter_py)
+
+    with NamedTemporaryFile(dir=context.working_directory.path) as fp:
+        args = [
+            sys.executable, dexter_py, 'run-debugger-internal-', steps_path,
+            options_path, '--working-directory', context.working_directory.path,
+            '--unittest=off', '--indent-timer-level={}'.format(Timer.indent + 2)
+        ]
+        try:
+            with Timer('running external debugger process'):
+                subprocess.check_call(args)
+        except subprocess.CalledProcessError as e:
+            raise DebuggerException(e)
+
+    with open(steps_path, 'rb') as fp:
+        step_collection = pickle.load(fp)
+
+    return step_collection
+
+
+class Debuggers(object):
+    @classmethod
+    def potential_debuggers(cls):
+        try:
+            return cls._potential_debuggers
+        except AttributeError:
+            cls._potential_debuggers = _get_potential_debuggers()
+            return cls._potential_debuggers
+
+    def __init__(self, context):
+        self.context = context
+
+    def load(self, key, step_collection=None):
+        with Timer('load {}'.format(key)):
+            return Debuggers.potential_debuggers()[key](self.context,
+                                                        step_collection)
+
+    def _populate_debugger_cache(self):
+        debuggers = []
+        for key in sorted(Debuggers.potential_debuggers()):
+            debugger = self.load(key)
+
+            class LoadedDebugger(object):
+                pass
+
+            LoadedDebugger.option_name = key
+            LoadedDebugger.full_name = '[{}]'.format(debugger.name)
+            LoadedDebugger.is_available = debugger.is_available
+
+            if LoadedDebugger.is_available:
+                try:
+                    LoadedDebugger.version = debugger.version.splitlines()
+                except AttributeError:
+                    LoadedDebugger.version = ['']
+            else:
+                try:
+                    LoadedDebugger.error = debugger.loading_error.splitlines()
+                except AttributeError:
+                    LoadedDebugger.error = ['']
+
+                try:
+                    LoadedDebugger.error_trace = debugger.loading_error_trace
+                except AttributeError:
+                    LoadedDebugger.error_trace = None
+
+            debuggers.append(LoadedDebugger)
+        return debuggers
+
+    def list(self):
+        debuggers = self._populate_debugger_cache()
+
+        max_o_len = max(len(d.option_name) for d in debuggers)
+        max_n_len = max(len(d.full_name) for d in debuggers)
+
+        msgs = []
+
+        for d in debuggers:
+            # Option name, right padded with spaces for alignment
+            option_name = (
+                '{{name: <{}}}'.format(max_o_len).format(name=d.option_name))
+
+            # Full name, right padded with spaces for alignment
+            full_name = ('{{name: <{}}}'.format(max_n_len)
+                         .format(name=d.full_name))
+
+            if d.is_available:
+                name = '<b>{} {}</>'.format(option_name, full_name)
+
+                # If the debugger is available, show the first line of the
+                #  version info.
+                available = '<g>YES</>'
+                info = '<b>({})</>'.format(d.version[0])
+            else:
+                name = '<y>{} {}</>'.format(option_name, full_name)
+
+                # If the debugger is not available, show the first line of the
+                # error reason.
+                available = '<r>NO</> '
+                info = '<y>({})</>'.format(d.error[0])
+
+            msg = '{} {} {}'.format(name, available, info)
+
+            if self.context.options.verbose:
+                # If verbose mode and there was more version or error output
+                # than could be displayed in a single line, display the whole
+                # lot slightly indented.
+                verbose_info = None
+                if d.is_available:
+                    if d.version[1:]:
+                        verbose_info = d.version + ['\n']
+                else:
+                    # Some of list elems may contain multiple lines, so make
+                    # sure each elem is a line of its own.
+                    verbose_info = d.error_trace
+
+                if verbose_info:
+                    verbose_info = '\n'.join('        {}'.format(l.rstrip())
+                                             for l in verbose_info) + '\n'
+                    msg = '{}\n\n{}'.format(msg, verbose_info)
+
+            msgs.append(msg)
+        self.context.o.auto('\n{}\n\n'.format('\n'.join(msgs)))
diff --git a/debuginfo-tests/dexter/dex/debugger/__init__.py b/debuginfo-tests/dexter/dex/debugger/__init__.py
new file mode 100644
index 00000000000..3c4fdece479
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.debugger.Debuggers import Debuggers
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/README.md b/debuginfo-tests/dexter/dex/debugger/dbgeng/README.md
new file mode 100644
index 00000000000..f9b864206d3
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/README.md
@@ -0,0 +1,60 @@
+# Debugger Engine backend
+
+This directory contains the Dexter backend for the Windows Debugger Engine
+(DbgEng), which powers tools such as WinDbg and CDB.
+
+## Overview
+
+DbgEng is available as a collection of unregistered COM-"like" objects that
+one accesses by calling DebugCreate in DbgEng.dll. The unregistered nature
+means normal COM tooling can't access them; as a result, this backend uses
+ctypes to describe the COM objects and call their methods.
+
+This is obviously not a huge amount of fun; on the other hand, COM has
+maintained ABI compatible interfaces for decades, and nothing is for free.
+
+The dexter backend follows the same formula as others; it creates a process
+and breaks on "main", then steps through the program, observing states and
+stack frames along the way.
+
+## Implementation details
+
+This backend uses a mixture of both APIs for accessing information, and the
+direct command-string interface to DbgEng for performing some actions. We
+have to use the DbgEng stepping interface, or we would effectively be
+building a new debugger, but certain things (like enabling source-line
+stepping) only seem to be possible from the command interface.
+
+Each segment of debugger responsibility has its own COM object: Client,
+Control, Symbols, SymbolGroups, Breakpoint, SystemObjects. In this python
+wrapper, each COM object gets a python object wrapping it. COM methods
+that are relevant to our interests have a python method that wraps the COM
+one and performs data marshalling. Some additional helper methods are added
+to the python objects to extract data.
+
+The majority of the work occurs in setup.py and probe_process.py. The
+former contains routines to launch a process and attach the debugger to
+it, while the latter extracts as much information as possible from a
+stopped process, returning a list of stack frames with associated variable
+information.
+
+## Sharp edges
+
+For reasons still unclear, using CreateProcessAndAttach never appears to
+allow the debuggee to resume, hence this implementation creates the
+debuggee process manually, attaches, and resumes.
+
+On process startup, we set a breakpoint on main and then continue running
+to it. This has the potential to never complete -- although of course,
+there's no guarantee that the debuggee will ever do anything anyway.
+
+There doesn't appear to be a way to instruct DbgEng to "step into" a
+function call, thus after reaching main, we scan the module for all
+functions with line numbers in the source directory, and put breakpoints
+on them. An alternative implementation would be putting breakpoints on
+every known line number.
+
+Finally, it's unclear whether arbitrary expressions can be evaluated in
+arbitrary stack frames, although this isn't something that Dexter currently
+supports.
+ 
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/__init__.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/__init__.py
new file mode 100644
index 00000000000..3c458f955b7
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/__init__.py
@@ -0,0 +1,19 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from . import dbgeng
+
+import platform
+if platform.system() == 'Windows':
+  from . import breakpoint
+  from . import control
+  from . import probe_process
+  from . import setup
+  from . import symbols
+  from . import symgroup
+  from . import sysobjs
+  from . import utils
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/breakpoint.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/breakpoint.py
new file mode 100644
index 00000000000..c966d8c9c88
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/breakpoint.py
@@ -0,0 +1,88 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from ctypes import *
+from enum import *
+from functools import partial
+
+from .utils import *
+
+class BreakpointTypes(IntEnum):
+  DEBUG_BREAKPOINT_CODE =   0
+  DEBUG_BREAKPOINT_DATA =   1
+  DEBUG_BREAKPOINT_TIME =   2
+  DEBUG_BREAKPOINT_INLINE = 3
+
+class BreakpointFlags(IntFlag):
+  DEBUG_BREAKPOINT_GO_ONLY =    0x00000001
+  DEBUG_BREAKPOINT_DEFERRED =   0x00000002
+  DEBUG_BREAKPOINT_ENABLED =    0x00000004
+  DEBUG_BREAKPOINT_ADDER_ONLY = 0x00000008
+  DEBUG_BREAKPOINT_ONE_SHOT =   0x00000010
+
+DebugBreakpoint2IID = IID(0x1b278d20, 0x79f2, 0x426e, IID_Data4_Type(0xa3, 0xf9, 0xc1, 0xdd, 0xf3, 0x75, 0xd4, 0x8e))
+
+class DebugBreakpoint2(Structure):
+  pass
+
+class DebugBreakpoint2Vtbl(Structure):
+  wrp = partial(WINFUNCTYPE, c_long, POINTER(DebugBreakpoint2))
+  idb_setoffset = wrp(c_ulonglong)
+  idb_setflags = wrp(c_ulong)
+  _fields_ = [
+      ("QueryInterface", c_void_p),
+      ("AddRef", c_void_p),
+      ("Release", c_void_p),
+      ("GetId", c_void_p),
+      ("GetType", c_void_p),
+      ("GetAdder", c_void_p),
+      ("GetFlags", c_void_p),
+      ("AddFlags", c_void_p),
+      ("RemoveFlags", c_void_p),
+      ("SetFlags", idb_setflags),
+      ("GetOffset", c_void_p),
+      ("SetOffset", idb_setoffset),
+      ("GetDataParameters", c_void_p),
+      ("SetDataParameters", c_void_p),
+      ("GetPassCount", c_void_p),
+      ("SetPassCount", c_void_p),
+      ("GetCurrentPassCount", c_void_p),
+      ("GetMatchThreadId", c_void_p),
+      ("SetMatchThreadId", c_void_p),
+      ("GetCommand", c_void_p),
+      ("SetCommand", c_void_p),
+      ("GetOffsetExpression", c_void_p),
+      ("SetOffsetExpression", c_void_p),
+      ("GetParameters", c_void_p),
+      ("GetCommandWide", c_void_p),
+      ("SetCommandWide", c_void_p),
+      ("GetOffsetExpressionWide", c_void_p),
+      ("SetOffsetExpressionWide", c_void_p)
+    ]
+
+DebugBreakpoint2._fields_ = [("lpVtbl", POINTER(DebugBreakpoint2Vtbl))]
+
+class Breakpoint(object):
+  def __init__(self, breakpoint):
+    self.breakpoint = breakpoint.contents
+    self.vt = self.breakpoint.lpVtbl.contents
+
+  def SetFlags(self, flags):
+    res = self.vt.SetFlags(self.breakpoint, flags)
+    aborter(res, "Breakpoint SetFlags")
+
+  def SetOffset(self, offs):
+    res = self.vt.SetOffset(self.breakpoint, offs)
+    aborter(res, "Breakpoint SetOffset")
+
+  def RemoveFlags(self, flags):
+    res = self.vt.RemoveFlags(self.breakpoint, flags)
+    aborter(res, "Breakpoint RemoveFlags")
+
+  def die(self):
+    self.breakpoint = None
+    self.vt = None
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/client.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/client.py
new file mode 100644
index 00000000000..a65e4ded2f3
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/client.py
@@ -0,0 +1,185 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from ctypes import *
+from enum import *
+from functools import partial
+
+from .utils import *
+from . import control
+from . import symbols
+from . import sysobjs
+
+class DebugAttach(IntFlag):
+  DEBUG_ATTACH_DEFAULT =                      0
+  DEBUG_ATTACH_NONINVASIVE =                  1
+  DEBUG_ATTACH_EXISTING =                     2
+  DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND =       4
+  DEBUG_ATTACH_INVASIVE_NO_INITIAL_BREAK =    8
+  DEBUG_ATTACH_INVASIVE_RESUME_PROCESS =   0x10
+  DEBUG_ATTACH_NONINVASIVE_ALLOW_PARTIAL = 0x20
+
+# UUID for DebugClient7 interface.
+DebugClient7IID = IID(0x13586be3, 0x542e, 0x481e, IID_Data4_Type(0xb1, 0xf2, 0x84, 0x97, 0xba, 0x74, 0xf9, 0xa9 ))
+
+class IDebugClient7(Structure):
+  pass
+
+class IDebugClient7Vtbl(Structure):
+  wrp = partial(WINFUNCTYPE, c_long, POINTER(IDebugClient7))
+  idc_queryinterface = wrp(POINTER(IID), POINTER(c_void_p))
+  idc_attachprocess = wrp(c_longlong, c_long, c_long)
+  idc_detachprocesses = wrp()
+  _fields_ = [
+      ("QueryInterface", idc_queryinterface),
+      ("AddRef", c_void_p),
+      ("Release", c_void_p),
+      ("AttachKernel", c_void_p),
+      ("GetKernelConnectionOptions", c_void_p),
+      ("SetKernelConnectionOptions", c_void_p),
+      ("StartProcessServer", c_void_p),
+      ("ConnectProcessServer", c_void_p),
+      ("DisconnectProcessServer", c_void_p),
+      ("GetRunningProcessSystemIds", c_void_p),
+      ("GetRunningProcessSystemIdsByExecutableName", c_void_p),
+      ("GetRunningProcessDescription", c_void_p),
+      ("AttachProcess", idc_attachprocess),
+      ("CreateProcess", c_void_p),
+      ("CreateProcessAndAttach", c_void_p),
+      ("GetProcessOptions", c_void_p),
+      ("AddProcessOptions", c_void_p),
+      ("RemoveProcessOptions", c_void_p),
+      ("SetProcessOptions", c_void_p),
+      ("OpenDumpFile", c_void_p),
+      ("WriteDumpFile", c_void_p),
+      ("ConnectSession", c_void_p),
+      ("StartServer", c_void_p),
+      ("OutputServers", c_void_p),
+      ("TerminateProcesses", c_void_p),
+      ("DetachProcesses", idc_detachprocesses),
+      ("EndSession", c_void_p),
+      ("GetExitCode", c_void_p),
+      ("DispatchCallbacks", c_void_p),
+      ("ExitDispatch", c_void_p),
+      ("CreateClient", c_void_p),
+      ("GetInputCallbacks", c_void_p),
+      ("SetInputCallbacks", c_void_p),
+      ("GetOutputCallbacks", c_void_p),
+      ("SetOutputCallbacks", c_void_p),
+      ("GetOutputMask", c_void_p),
+      ("SetOutputMask", c_void_p),
+      ("GetOtherOutputMask", c_void_p),
+      ("SetOtherOutputMask", c_void_p),
+      ("GetOutputWidth", c_void_p),
+      ("SetOutputWidth", c_void_p),
+      ("GetOutputLinePrefix", c_void_p),
+      ("SetOutputLinePrefix", c_void_p),
+      ("GetIdentity", c_void_p),
+      ("OutputIdentity", c_void_p),
+      ("GetEventCallbacks", c_void_p),
+      ("SetEventCallbacks", c_void_p),
+      ("FlushCallbacks", c_void_p),
+      ("WriteDumpFile2", c_void_p),
+      ("AddDumpInformationFile", c_void_p),
+      ("EndProcessServer", c_void_p),
+      ("WaitForProcessServerEnd", c_void_p),
+      ("IsKernelDebuggerEnabled", c_void_p),
+      ("TerminateCurrentProcess", c_void_p),
+      ("DetachCurrentProcess", c_void_p),
+      ("AbandonCurrentProcess", c_void_p),
+      ("GetRunningProcessSystemIdByExecutableNameWide", c_void_p),
+      ("GetRunningProcessDescriptionWide", c_void_p),
+      ("CreateProcessWide", c_void_p),
+      ("CreateProcessAndAttachWide", c_void_p),
+      ("OpenDumpFileWide", c_void_p),
+      ("WriteDumpFileWide", c_void_p),
+      ("AddDumpInformationFileWide", c_void_p),
+      ("GetNumberDumpFiles", c_void_p),
+      ("GetDumpFile", c_void_p),
+      ("GetDumpFileWide", c_void_p),
+      ("AttachKernelWide", c_void_p),
+      ("GetKernelConnectionOptionsWide", c_void_p),
+      ("SetKernelConnectionOptionsWide", c_void_p),
+      ("StartProcessServerWide", c_void_p),
+      ("ConnectProcessServerWide", c_void_p),
+      ("StartServerWide", c_void_p),
+      ("OutputServerWide", c_void_p),
+      ("GetOutputCallbacksWide", c_void_p),
+      ("SetOutputCallbacksWide", c_void_p),
+      ("GetOutputLinePrefixWide", c_void_p),
+      ("SetOutputLinePrefixWide", c_void_p),
+      ("GetIdentityWide", c_void_p),
+      ("OutputIdentityWide", c_void_p),
+      ("GetEventCallbacksWide", c_void_p),
+      ("SetEventCallbacksWide", c_void_p),
+      ("CreateProcess2", c_void_p),
+      ("CreateProcess2Wide", c_void_p),
+      ("CreateProcessAndAttach2", c_void_p),
+      ("CreateProcessAndAttach2Wide", c_void_p),
+      ("PushOutputLinePrefix", c_void_p),
+      ("PushOutputLinePrefixWide", c_void_p),
+      ("PopOutputLinePrefix", c_void_p),
+      ("GetNumberInputCallbacks", c_void_p),
+      ("GetNumberOutputCallbacks", c_void_p),
+      ("GetNumberEventCallbacks", c_void_p),
+      ("GetQuitLockString", c_void_p),
+      ("SetQuitLockString", c_void_p),
+      ("GetQuitLockStringWide", c_void_p),
+      ("SetQuitLockStringWide", c_void_p),
+      ("SetEventContextCallbacks", c_void_p),
+      ("SetClientContext", c_void_p),
+    ]
+
+IDebugClient7._fields_ = [("lpVtbl", POINTER(IDebugClient7Vtbl))]
+
+class Client(object):
+  def __init__(self):
+    DbgEng = WinDLL("DbgEng")
+    DbgEng.DebugCreate.argtypes = [POINTER(IID), POINTER(POINTER(IDebugClient7))]
+    DbgEng.DebugCreate.restype = c_ulong
+
+    # Call DebugCreate to create a new debug client
+    ptr = POINTER(IDebugClient7)()
+    res = DbgEng.DebugCreate(byref(DebugClient7IID), ptr)
+    aborter(res, "DebugCreate")
+    self.client = ptr.contents
+    self.vt = vt = self.client.lpVtbl.contents
+
+    def QI(iface, ptr):
+      return vt.QueryInterface(self.client, byref(iface), byref(ptr))
+
+    # Query for a control object
+    ptr = c_void_p()
+    res = QI(control.DebugControl7IID, ptr)
+    aborter(res, "QueryInterface control")
+    self.control_ptr = cast(ptr, POINTER(control.IDebugControl7))
+    self.Control = control.Control(self.control_ptr)
+
+    # Query for a SystemObjects object
+    ptr = c_void_p()
+    res = QI(sysobjs.DebugSystemObjects4IID, ptr)
+    aborter(res, "QueryInterface sysobjects")
+    self.sysobjects_ptr = cast(ptr, POINTER(sysobjs.IDebugSystemObjects4))
+    self.SysObjects = sysobjs.SysObjects(self.sysobjects_ptr)
+
+    # Query for a Symbols object
+    ptr = c_void_p()
+    res = QI(symbols.DebugSymbols5IID, ptr)
+    aborter(res, "QueryInterface debugsymbosl5")
+    self.symbols_ptr = cast(ptr, POINTER(symbols.IDebugSymbols5))
+    self.Symbols = symbols.Symbols(self.symbols_ptr)
+
+  def AttachProcess(self, pid):
+    # Zero process-server id means no process-server.
+    res = self.vt.AttachProcess(self.client, 0, pid, DebugAttach.DEBUG_ATTACH_DEFAULT)
+    aborter(res, "AttachProcess")
+    return
+
+  def DetachProcesses(self):
+    res = self.vt.DetachProcesses(self.client)
+    aborter(res, "DetachProcesses")
+    return
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/control.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/control.py
new file mode 100644
index 00000000000..38585c83f70
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/control.py
@@ -0,0 +1,405 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from ctypes import *
+from functools import partial
+
+from .utils import *
+from .breakpoint import *
+
+class DEBUG_STACK_FRAME_EX(Structure):
+  _fields_ = [
+      ("InstructionOffset", c_ulonglong),
+      ("ReturnOffset", c_ulonglong),
+      ("FrameOffset", c_ulonglong),
+      ("StackOffset", c_ulonglong),
+      ("FuncTableEntry", c_ulonglong),
+      ("Params", c_ulonglong * 4),
+      ("Reserved", c_ulonglong * 6),
+      ("Virtual", c_bool),
+      ("FrameNumber", c_ulong),
+      ("InlineFrameContext", c_ulong),
+      ("Reserved1", c_ulong)
+    ]
+PDEBUG_STACK_FRAME_EX = POINTER(DEBUG_STACK_FRAME_EX)
+
+class DEBUG_VALUE_U(Union):
+  _fields_ = [
+      ("I8", c_byte),
+      ("I16", c_short),
+      ("I32", c_int),
+      ("I64", c_long),
+      ("F32", c_float),
+      ("F64", c_double),
+      ("RawBytes", c_ubyte * 24) # Force length to 24b.
+    ]
+
+class DEBUG_VALUE(Structure):
+  _fields_ = [
+      ("U", DEBUG_VALUE_U),
+      ("TailOfRawBytes", c_ulong),
+      ("Type", c_ulong)
+    ]
+PDEBUG_VALUE = POINTER(DEBUG_VALUE)
+
+class DebugValueType(IntEnum):
+  DEBUG_VALUE_INVALID      = 0
+  DEBUG_VALUE_INT8         = 1
+  DEBUG_VALUE_INT16        = 2
+  DEBUG_VALUE_INT32        = 3
+  DEBUG_VALUE_INT64        = 4
+  DEBUG_VALUE_FLOAT32      = 5
+  DEBUG_VALUE_FLOAT64      = 6
+  DEBUG_VALUE_FLOAT80      = 7
+  DEBUG_VALUE_FLOAT82      = 8
+  DEBUG_VALUE_FLOAT128     = 9
+  DEBUG_VALUE_VECTOR64     = 10
+  DEBUG_VALUE_VECTOR128    = 11
+  DEBUG_VALUE_TYPES        = 12
+
+# UUID for DebugControl7 interface.
+DebugControl7IID = IID(0xb86fb3b1, 0x80d4, 0x475b, IID_Data4_Type(0xae, 0xa3, 0xcf, 0x06, 0x53, 0x9c, 0xf6, 0x3a))
+
+class IDebugControl7(Structure):
+  pass
+
+class IDebugControl7Vtbl(Structure):
+  wrp = partial(WINFUNCTYPE, c_long, POINTER(IDebugControl7))
+  idc_getnumbereventfilters = wrp(c_ulong_p, c_ulong_p, c_ulong_p)
+  idc_setexceptionfiltersecondcommand = wrp(c_ulong, c_char_p)
+  idc_waitforevent = wrp(c_long, c_long)
+  idc_execute = wrp(c_long, c_char_p, c_long)
+  idc_setexpressionsyntax = wrp(c_ulong)
+  idc_addbreakpoint2 = wrp(c_ulong, c_ulong, POINTER(POINTER(DebugBreakpoint2)))
+  idc_setexecutionstatus = wrp(c_ulong)
+  idc_getexecutionstatus = wrp(c_ulong_p)
+  idc_getstacktraceex = wrp(c_ulonglong, c_ulonglong, c_ulonglong, PDEBUG_STACK_FRAME_EX, c_ulong, c_ulong_p)
+  idc_evaluate = wrp(c_char_p, c_ulong, PDEBUG_VALUE, c_ulong_p)
+  _fields_ = [
+      ("QueryInterface", c_void_p),
+      ("AddRef", c_void_p),
+      ("Release", c_void_p),
+      ("GetInterrupt", c_void_p),
+      ("SetInterrupt", c_void_p),
+      ("GetInterruptTimeout", c_void_p),
+      ("SetInterruptTimeout", c_void_p),
+      ("GetLogFile", c_void_p),
+      ("OpenLogFile", c_void_p),
+      ("CloseLogFile", c_void_p),
+      ("GetLogMask", c_void_p),
+      ("SetLogMask", c_void_p),
+      ("Input", c_void_p),
+      ("ReturnInput", c_void_p),
+      ("Output", c_void_p),
+      ("OutputVaList", c_void_p),
+      ("ControlledOutput", c_void_p),
+      ("ControlledOutputVaList", c_void_p),
+      ("OutputPrompt", c_void_p),
+      ("OutputPromptVaList", c_void_p),
+      ("GetPromptText", c_void_p),
+      ("OutputCurrentState", c_void_p),
+      ("OutputVersionInformation", c_void_p),
+      ("GetNotifyEventHandle", c_void_p),
+      ("SetNotifyEventHandle", c_void_p),
+      ("Assemble", c_void_p),
+      ("Disassemble", c_void_p),
+      ("GetDisassembleEffectiveOffset", c_void_p),
+      ("OutputDisassembly", c_void_p),
+      ("OutputDisassemblyLines", c_void_p),
+      ("GetNearInstruction", c_void_p),
+      ("GetStackTrace", c_void_p),
+      ("GetReturnOffset", c_void_p),
+      ("OutputStackTrace", c_void_p),
+      ("GetDebuggeeType", c_void_p),
+      ("GetActualProcessorType", c_void_p),
+      ("GetExecutingProcessorType", c_void_p),
+      ("GetNumberPossibleExecutingProcessorTypes", c_void_p),
+      ("GetPossibleExecutingProcessorTypes", c_void_p),
+      ("GetNumberProcessors", c_void_p),
+      ("GetSystemVersion", c_void_p),
+      ("GetPageSize", c_void_p),
+      ("IsPointer64Bit", c_void_p),
+      ("ReadBugCheckData", c_void_p),
+      ("GetNumberSupportedProcessorTypes", c_void_p),
+      ("GetSupportedProcessorTypes", c_void_p),
+      ("GetProcessorTypeNames", c_void_p),
+      ("GetEffectiveProcessorType", c_void_p),
+      ("SetEffectiveProcessorType", c_void_p),
+      ("GetExecutionStatus", idc_getexecutionstatus),
+      ("SetExecutionStatus", idc_setexecutionstatus),
+      ("GetCodeLevel", c_void_p),
+      ("SetCodeLevel", c_void_p),
+      ("GetEngineOptions", c_void_p),
+      ("AddEngineOptions", c_void_p),
+      ("RemoveEngineOptions", c_void_p),
+      ("SetEngineOptions", c_void_p),
+      ("GetSystemErrorControl", c_void_p),
+      ("SetSystemErrorControl", c_void_p),
+      ("GetTextMacro", c_void_p),
+      ("SetTextMacro", c_void_p),
+      ("GetRadix", c_void_p),
+      ("SetRadix", c_void_p),
+      ("Evaluate", idc_evaluate),
+      ("CoerceValue", c_void_p),
+      ("CoerceValues", c_void_p),
+      ("Execute", idc_execute),
+      ("ExecuteCommandFile", c_void_p),
+      ("GetNumberBreakpoints", c_void_p),
+      ("GetBreakpointByIndex", c_void_p),
+      ("GetBreakpointById", c_void_p),
+      ("GetBreakpointParameters", c_void_p),
+      ("AddBreakpoint", c_void_p),
+      ("RemoveBreakpoint", c_void_p),
+      ("AddExtension", c_void_p),
+      ("RemoveExtension", c_void_p),
+      ("GetExtensionByPath", c_void_p),
+      ("CallExtension", c_void_p),
+      ("GetExtensionFunction", c_void_p),
+      ("GetWindbgExtensionApis32", c_void_p),
+      ("GetWindbgExtensionApis64", c_void_p),
+      ("GetNumberEventFilters", idc_getnumbereventfilters),
+      ("GetEventFilterText", c_void_p),
+      ("GetEventFilterCommand", c_void_p),
+      ("SetEventFilterCommand", c_void_p),
+      ("GetSpecificFilterParameters", c_void_p),
+      ("SetSpecificFilterParameters", c_void_p),
+      ("GetSpecificFilterArgument", c_void_p),
+      ("SetSpecificFilterArgument", c_void_p),
+      ("GetExceptionFilterParameters", c_void_p),
+      ("SetExceptionFilterParameters", c_void_p),
+      ("GetExceptionFilterSecondCommand", c_void_p),
+      ("SetExceptionFilterSecondCommand", idc_setexceptionfiltersecondcommand),
+      ("WaitForEvent", idc_waitforevent),
+      ("GetLastEventInformation", c_void_p),
+      ("GetCurrentTimeDate", c_void_p),
+      ("GetCurrentSystemUpTime", c_void_p),
+      ("GetDumpFormatFlags", c_void_p),
+      ("GetNumberTextReplacements", c_void_p),
+      ("GetTextReplacement", c_void_p),
+      ("SetTextReplacement", c_void_p),
+      ("RemoveTextReplacements", c_void_p),
+      ("OutputTextReplacements", c_void_p),
+      ("GetAssemblyOptions", c_void_p),
+      ("AddAssemblyOptions", c_void_p),
+      ("RemoveAssemblyOptions", c_void_p),
+      ("SetAssemblyOptions", c_void_p),
+      ("GetExpressionSyntax", c_void_p),
+      ("SetExpressionSyntax", idc_setexpressionsyntax),
+      ("SetExpressionSyntaxByName", c_void_p),
+      ("GetNumberExpressionSyntaxes", c_void_p),
+      ("GetExpressionSyntaxNames", c_void_p),
+      ("GetNumberEvents", c_void_p),
+      ("GetEventIndexDescription", c_void_p),
+      ("GetCurrentEventIndex", c_void_p),
+      ("SetNextEventIndex", c_void_p),
+      ("GetLogFileWide", c_void_p),
+      ("OpenLogFileWide", c_void_p),
+      ("InputWide", c_void_p),
+      ("ReturnInputWide", c_void_p),
+      ("OutputWide", c_void_p),
+      ("OutputVaListWide", c_void_p),
+      ("ControlledOutputWide", c_void_p),
+      ("ControlledOutputVaListWide", c_void_p),
+      ("OutputPromptWide", c_void_p),
+      ("OutputPromptVaListWide", c_void_p),
+      ("GetPromptTextWide", c_void_p),
+      ("AssembleWide", c_void_p),
+      ("DisassembleWide", c_void_p),
+      ("GetProcessrTypeNamesWide", c_void_p),
+      ("GetTextMacroWide", c_void_p),
+      ("SetTextMacroWide", c_void_p),
+      ("EvaluateWide", c_void_p),
+      ("ExecuteWide", c_void_p),
+      ("ExecuteCommandFileWide", c_void_p),
+      ("GetBreakpointByIndex2", c_void_p),
+      ("GetBreakpointById2", c_void_p),
+      ("AddBreakpoint2", idc_addbreakpoint2),
+      ("RemoveBreakpoint2", c_void_p),
+      ("AddExtensionWide", c_void_p),
+      ("GetExtensionByPathWide", c_void_p),
+      ("CallExtensionWide", c_void_p),
+      ("GetExtensionFunctionWide", c_void_p),
+      ("GetEventFilterTextWide", c_void_p),
+      ("GetEventfilterCommandWide", c_void_p),
+      ("SetEventFilterCommandWide", c_void_p),
+      ("GetSpecificFilterArgumentWide", c_void_p),
+      ("SetSpecificFilterArgumentWide", c_void_p),
+      ("GetExceptionFilterSecondCommandWide", c_void_p),
+      ("SetExceptionFilterSecondCommandWider", c_void_p),
+      ("GetLastEventInformationWide", c_void_p),
+      ("GetTextReplacementWide", c_void_p),
+      ("SetTextReplacementWide", c_void_p),
+      ("SetExpressionSyntaxByNameWide", c_void_p),
+      ("GetExpressionSyntaxNamesWide", c_void_p),
+      ("GetEventIndexDescriptionWide", c_void_p),
+      ("GetLogFile2", c_void_p),
+      ("OpenLogFile2", c_void_p),
+      ("GetLogFile2Wide", c_void_p),
+      ("OpenLogFile2Wide", c_void_p),
+      ("GetSystemVersionValues", c_void_p),
+      ("GetSystemVersionString", c_void_p),
+      ("GetSystemVersionStringWide", c_void_p),
+      ("GetContextStackTrace", c_void_p),
+      ("OutputContextStackTrace", c_void_p),
+      ("GetStoredEventInformation", c_void_p),
+      ("GetManagedStatus", c_void_p),
+      ("GetManagedStatusWide", c_void_p),
+      ("ResetManagedStatus", c_void_p),
+      ("GetStackTraceEx", idc_getstacktraceex),
+      ("OutputStackTraceEx", c_void_p),
+      ("GetContextStackTraceEx", c_void_p),
+      ("OutputContextStackTraceEx", c_void_p),
+      ("GetBreakpointByGuid", c_void_p),
+      ("GetExecutionStatusEx", c_void_p),
+      ("GetSynchronizationStatus", c_void_p),
+      ("GetDebuggeeType2", c_void_p)
+    ]
+
+IDebugControl7._fields_ = [("lpVtbl", POINTER(IDebugControl7Vtbl))]
+
+class DebugStatus(IntEnum):
+  DEBUG_STATUS_NO_CHANGE =            0
+  DEBUG_STATUS_GO =                   1
+  DEBUG_STATUS_GO_HANDLED =           2
+  DEBUG_STATUS_GO_NOT_HANDLED =       3
+  DEBUG_STATUS_STEP_OVER =            4
+  DEBUG_STATUS_STEP_INTO =            5
+  DEBUG_STATUS_BREAK =                6
+  DEBUG_STATUS_NO_DEBUGGEE =          7
+  DEBUG_STATUS_STEP_BRANCH =          8
+  DEBUG_STATUS_IGNORE_EVENT =         9
+  DEBUG_STATUS_RESTART_REQUESTED =   10
+  DEBUG_STATUS_REVERSE_GO =          11
+  DEBUG_STATUS_REVERSE_STEP_BRANCH = 12
+  DEBUG_STATUS_REVERSE_STEP_OVER =   13
+  DEBUG_STATUS_REVERSE_STEP_INTO =   14
+  DEBUG_STATUS_OUT_OF_SYNC =         15
+  DEBUG_STATUS_WAIT_INPUT =          16
+  DEBUG_STATUS_TIMEOUT =             17
+
+class DebugSyntax(IntEnum):
+  DEBUG_EXPR_MASM = 0
+  DEBUG_EXPR_CPLUSPLUS = 1
+
+class Control(object):
+  def __init__(self, control):
+    self.ptr = control
+    self.control = control.contents
+    self.vt = self.control.lpVtbl.contents
+    # Keep a handy ulong for passing into C methods.
+    self.ulong = c_ulong()
+
+  def GetExecutionStatus(self, doprint=False):
+    ret = self.vt.GetExecutionStatus(self.control, byref(self.ulong))
+    aborter(ret, "GetExecutionStatus")
+    status = DebugStatus(self.ulong.value)
+    if doprint:
+      print("Execution status: {}".format(status))
+    return status
+
+  def SetExecutionStatus(self, status):
+    assert isinstance(status, DebugStatus)
+    res = self.vt.SetExecutionStatus(self.control, status.value)
+    aborter(res, "SetExecutionStatus")
+
+  def WaitForEvent(self, timeout=100):
+    # No flags are taken by WaitForEvent, hence 0
+    ret = self.vt.WaitForEvent(self.control, 0, timeout)
+    aborter(ret, "WaitforEvent", ignore=[S_FALSE])
+    return ret
+
+  def GetNumberEventFilters(self):
+    specific_events = c_ulong()
+    specific_exceptions = c_ulong()
+    arbitrary_exceptions = c_ulong()
+    res = self.vt.GetNumberEventFilters(self.control, byref(specific_events),
+                                    byref(specific_exceptions),
+                                    byref(arbitrary_exceptions))
+    aborter(res, "GetNumberEventFilters")
+    return (specific_events.value, specific_exceptions.value,
+            arbitrary_exceptions.value)
+
+  def SetExceptionFilterSecondCommand(self, index, command):
+    buf = create_string_buffer(command.encode('ascii'))
+    res = self.vt.SetExceptionFilterSecondCommand(self.control, index, buf)
+    aborter(res, "SetExceptionFilterSecondCommand")
+    return
+
+  def AddBreakpoint2(self, offset=None, enabled=None):
+    breakpoint = POINTER(DebugBreakpoint2)()
+    res = self.vt.AddBreakpoint2(self.control, BreakpointTypes.DEBUG_BREAKPOINT_CODE, DEBUG_ANY_ID, byref(breakpoint))
+    aborter(res, "Add breakpoint 2")
+    bp = Breakpoint(breakpoint)
+
+    if offset is not None:
+      bp.SetOffset(offset)
+    if enabled is not None and enabled:
+      bp.SetFlags(BreakpointFlags.DEBUG_BREAKPOINT_ENABLED)
+
+    return bp
+
+  def RemoveBreakpoint(self, bp):
+    res = self.vt.RemoveBreakpoint2(self.control, bp.breakpoint)
+    aborter(res, "RemoveBreakpoint2")
+    bp.die()
+
+  def GetStackTraceEx(self):
+    # XXX -- I can't find a way to query for how many stack frames there _are_
+    # in  advance. Guess 128 for now.
+    num_frames_buffer = 128
+
+    frames = (DEBUG_STACK_FRAME_EX * num_frames_buffer)()
+    numframes = c_ulong()
+
+    # First three args are frame/stack/IP offsets -- leave them as zero to
+    # default to the current instruction.
+    res = self.vt.GetStackTraceEx(self.control, 0, 0, 0, frames, num_frames_buffer, byref(numframes))
+    aborter(res, "GetStackTraceEx")
+    return frames, numframes.value
+
+  def Execute(self, command):
+    # First zero is DEBUG_OUTCTL_*, which we leave as a default, second
+    # zero is DEBUG_EXECUTE_* flags, of which we set none.
+    res = self.vt.Execute(self.control, 0, command.encode('ascii'), 0)
+    aborter(res, "Client execute")
+
+  def SetExpressionSyntax(self, cpp=True):
+    if cpp:
+      syntax = DebugSyntax.DEBUG_EXPR_CPLUSPLUS
+    else:
+      syntax = DebugSyntax.DEBUG_EXPR_MASM
+
+    res = self.vt.SetExpressionSyntax(self.control, syntax)
+    aborter(res, "SetExpressionSyntax")
+
+  def Evaluate(self, expr):
+    ptr = DEBUG_VALUE()
+    res = self.vt.Evaluate(self.control, expr.encode("ascii"), DebugValueType.DEBUG_VALUE_INVALID, byref(ptr), None)
+    aborter(res, "Evaluate", ignore=[E_INTERNALEXCEPTION, E_FAIL])
+    if res != 0:
+      return None
+
+    val_type = DebugValueType(ptr.Type)
+
+    # Here's a map from debug value types to fields. Unclear what happens
+    # with unsigned values, as DbgEng doesn't present any unsigned fields.
+
+    extract_map = {
+      DebugValueType.DEBUG_VALUE_INT8    : ("I8", "char"),
+      DebugValueType.DEBUG_VALUE_INT16   : ("I16", "short"),
+      DebugValueType.DEBUG_VALUE_INT32   : ("I32", "int"),
+      DebugValueType.DEBUG_VALUE_INT64   : ("I64", "long"),
+      DebugValueType.DEBUG_VALUE_FLOAT32 : ("F32", "float"),
+      DebugValueType.DEBUG_VALUE_FLOAT64 : ("F64", "double")
+    } # And everything else is invalid.
+
+    if val_type not in extract_map:
+      raise Exception("Unexpected debug value type {} when evalutaing".format(val_type))
+
+    # Also produce a type name...
+
+    return getattr(ptr.U, extract_map[val_type][0]), extract_map[val_type][1]
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/dbgeng.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/dbgeng.py
new file mode 100644
index 00000000000..66d01f03e8f
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/dbgeng.py
@@ -0,0 +1,163 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import sys
+import os
+import platform
+
+from dex.debugger.DebuggerBase import DebuggerBase
+from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR
+from dex.dextIR import ProgramState, StackFrame, SourceLocation
+from dex.utils.Exceptions import DebuggerException, LoadDebuggerException
+from dex.utils.ReturnCode import ReturnCode
+
+if platform.system() == "Windows":
+  # Don't load on linux; _load_interface will croak before any names are used.
+  from . import setup
+  from . import probe_process
+  from . import breakpoint
+
+class DbgEng(DebuggerBase):
+    def __init__(self, context, *args):
+        self.breakpoints = []
+        self.running = False
+        self.finished = False
+        self.step_info = None
+        super(DbgEng, self).__init__(context, *args)
+
+    def _custom_init(self):
+        try:
+          res = setup.setup_everything(self.context.options.executable)
+          self.client, self.hProcess = res
+          self.running = True
+        except Exception as e:
+          raise Exception('Failed to start debuggee: {}'.format(e))
+
+    def _custom_exit(self):
+        setup.cleanup(self.client, self.hProcess)
+
+    def _load_interface(self):
+        arch = platform.architecture()[0]
+        machine = platform.machine()
+        if arch == '32bit' and machine == 'AMD64':
+          # This python process is 32 bits, but is sitting on a 64 bit machine.
+          # Bad things may happen, don't support it.
+          raise LoadDebuggerException('Can\'t run Dexter dbgeng on 32 bit python in a 64 bit environment')
+
+        if platform.system() != 'Windows':
+          raise LoadDebuggerException('DbgEng supports Windows only')
+
+        # Otherwise, everything was imported earlier
+
+    @classmethod
+    def get_name(cls):
+        return 'dbgeng'
+
+    @classmethod
+    def get_option_name(cls):
+        return 'dbgeng'
+
+    @property
+    def frames_below_main(self):
+        return []
+
+    @property
+    def version(self):
+        # I don't believe there's a well defined DbgEng version, outside of the
+        # version of Windows being used.
+        return "1"
+
+    def clear_breakpoints(self):
+        for x in self.breakpoints:
+            x.RemoveFlags(breakpoint.BreakpointFlags.DEBUG_BREAKPOINT_ENABLED)
+            self.client.Control.RemoveBreakpoint(x)
+
+    def add_breakpoint(self, file_, line):
+        # This is something to implement in the future -- as it stands, Dexter
+        # doesn't test for such things as "I can set a breakpoint on this line".
+        # This is only called AFAICT right now to ensure we break on every step.
+        pass
+
+    def launch(self):
+        # We are, by this point, already launched.
+        self.step_info = probe_process.probe_state(self.client)
+
+    def step(self):
+        res = setup.step_once(self.client)
+        if not res:
+          self.finished = True
+        self.step_info = res
+
+    def go(self):
+        # We never go -- we always single step.
+        pass
+
+    def get_step_info(self):
+        frames = self.step_info
+        state_frames = []
+
+        # For now assume the base function is the... function, ignoring
+        # inlining.
+        dex_frames = []
+        for i, x in enumerate(frames):
+          # XXX Might be able to get columns out through
+          # GetSourceEntriesByOffset, not a priority now
+          loc = LocIR(path=x.source_file, lineno=x.line_no, column=0)
+          new_frame = FrameIR(function=x.function_name, is_inlined=False, loc=loc)
+          dex_frames.append(new_frame)
+
+          state_frame = StackFrame(function=new_frame.function,
+                                   is_inlined=new_frame.is_inlined,
+                                   location=SourceLocation(path=x.source_file,
+                                                           lineno=x.line_no,
+                                                           column=0),
+                                   watches={})
+          for expr in map(
+              lambda watch, idx=i: self.evaluate_expression(watch, idx),
+              self.watches):
+              state_frame.watches[expr.expression] = expr
+          state_frames.append(state_frame)
+
+        return StepIR(
+            step_index=self.step_index, frames=dex_frames,
+            stop_reason=StopReason.STEP,
+            program_state=ProgramState(state_frames))
+
+    @property
+    def is_running(self):
+        return False # We're never free-running
+
+    @property
+    def is_finished(self):
+        return self.finished
+
+    def evaluate_expression(self, expression, frame_idx=0):
+        # XXX: cdb insists on using '->' to examine fields of structures,
+        # as it appears to reserve '.' for other purposes.
+        fixed_expr = expression.replace('.', '->')
+
+        orig_scope_idx = self.client.Symbols.GetCurrentScopeFrameIndex()
+        self.client.Symbols.SetScopeFrameByIndex(frame_idx)
+
+        res = self.client.Control.Evaluate(fixed_expr)
+        if res is not None:
+          result, typename = self.client.Control.Evaluate(fixed_expr)
+          could_eval = True
+        else:
+          result, typename = (None, None)
+          could_eval = False
+
+        self.client.Symbols.SetScopeFrameByIndex(orig_scope_idx)
+
+        return ValueIR(
+            expression=expression,
+            value=str(result),
+            type_name=typename,
+            error_string="",
+            could_evaluate=could_eval,
+            is_optimized_away=False,
+            is_irretrievable=not could_eval)
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/probe_process.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/probe_process.py
new file mode 100644
index 00000000000..8bd7f607081
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/probe_process.py
@@ -0,0 +1,80 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import os
+
+from .utils import *
+
+class Frame(object):
+  def __init__(self, frame, idx, Symbols):
+    # Store some base information about the frame
+    self.ip = frame.InstructionOffset
+    self.scope_idx = idx
+    self.virtual = frame.Virtual
+    self.inline_frame_context = frame.InlineFrameContext
+    self.func_tbl_entry = frame.FuncTableEntry
+
+    # Fetch the module/symbol we're in, with displacement. Useful for debugging.
+    self.descr = Symbols.GetNearNameByOffset(self.ip)
+    split = self.descr.split('!')[0]
+    self.module = split[0]
+    self.symbol = split[1]
+
+    # Fetch symbol group for this scope.
+    prevscope = Symbols.GetCurrentScopeFrameIndex()
+    if Symbols.SetScopeFrameByIndex(idx):
+      symgroup = Symbols.GetScopeSymbolGroup2()
+      Symbols.SetScopeFrameByIndex(prevscope)
+      self.symgroup = symgroup
+    else:
+      self.symgroup = None
+
+    # Fetch the name according to the line-table, using inlining context.
+    name = Symbols.GetNameByInlineContext(self.ip, self.inline_frame_context)
+    self.function_name = name.split('!')[-1]
+
+    try:
+      tup = Symbols.GetLineByInlineContext(self.ip, self.inline_frame_context)
+      self.source_file, self.line_no = tup
+    except WinError as e:
+      # Fall back to trying to use a non-inlining-aware line number
+      # XXX - this is not inlining aware
+      sym = Symbols.GetLineByOffset(self.ip)
+      if sym is not None:
+        self.source_file, self.line_no = sym
+      else:
+        self.source_file = None
+        self.line_no = None
+        self.basename = None
+
+    if self.source_file is not None:
+      self.basename = os.path.basename(self.source_file)
+    else:
+      self.basename = None
+
+
+
+  def __str__(self):
+    return '{}:{}({}) {}'.format(self.basename, self.line, self.descr, self.function_name)
+
+def main_on_stack(Symbols, frames):
+  module_name = Symbols.get_exefile_module_name()
+  main_name = "{}!main".format(module_name)
+  for x in frames:
+    if main_name in x.descr: # Could be less hard coded...
+      return True
+  return False
+
+def probe_state(Client):
+  # Fetch the state of the program -- represented by the stack frames.
+  frames, numframes = Client.Control.GetStackTraceEx()
+
+  the_frames = [Frame(frames[x], x, Client.Symbols) for x in range(numframes)]
+  if not main_on_stack(Client.Symbols, the_frames):
+    return None
+
+  return the_frames
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/setup.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/setup.py
new file mode 100644
index 00000000000..30a62f6dd42
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/setup.py
@@ -0,0 +1,185 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from ctypes import *
+
+from . import client
+from . import control
+from . import symbols
+from .probe_process import probe_state
+from .utils import *
+
+class STARTUPINFOA(Structure):
+  _fields_ = [
+      ('cb', c_ulong),
+      ('lpReserved', c_char_p),
+      ('lpDesktop', c_char_p),
+      ('lpTitle', c_char_p),
+      ('dwX', c_ulong),
+      ('dwY', c_ulong),
+      ('dwXSize', c_ulong),
+      ('dwYSize', c_ulong),
+      ('dwXCountChars', c_ulong),
+      ('dwYCountChars', c_ulong),
+      ('dwFillAttribute', c_ulong),
+      ('wShowWindow', c_ushort),
+      ('cbReserved2', c_ushort),
+      ('lpReserved2', c_char_p),
+      ('hStdInput', c_void_p),
+      ('hStdOutput', c_void_p),
+      ('hStdError', c_void_p)
+    ]
+
+class PROCESS_INFORMATION(Structure):
+  _fields_ = [
+      ('hProcess', c_void_p),
+      ('hThread', c_void_p),
+      ('dwProcessId', c_ulong),
+      ('dwThreadId', c_ulong)
+    ]
+
+def fetch_local_function_syms(Symbols, prefix):
+  syms = Symbols.get_all_functions()
+
+  def is_sym_in_src_dir(sym):
+    name, data = sym
+    symdata = Symbols.GetLineByOffset(data.Offset)
+    if symdata is not None:
+      srcfile, line = symdata
+      if prefix in srcfile:
+        return True
+    return False
+   
+  syms = [x for x in syms if is_sym_in_src_dir(x)]
+  return syms
+
+def break_on_all_but_main(Control, Symbols, main_offset):
+  mainfile, _ = Symbols.GetLineByOffset(main_offset)
+  prefix = '\\'.join(mainfile.split('\\')[:-1])
+
+  for name, rec in fetch_local_function_syms(Symbols, prefix):
+    if name == "main":
+      continue
+    bp = Control.AddBreakpoint2(offset=rec.Offset, enabled=True)
+
+  # All breakpoints are currently discarded: we just sys.exit for cleanup
+  return
+
+def process_creator(binfile):
+  Kernel32 = WinDLL("Kernel32")
+
+  # Another flavour of process creation
+  startupinfoa = STARTUPINFOA()
+  startupinfoa.cb = sizeof(STARTUPINFOA)
+  startupinfoa.lpReserved = None
+  startupinfoa.lpDesktop = None
+  startupinfoa.lpTitle = None
+  startupinfoa.dwX = 0
+  startupinfoa.dwY = 0
+  startupinfoa.dwXSize = 0
+  startupinfoa.dwYSize = 0
+  startupinfoa.dwXCountChars = 0
+  startupinfoa.dwYCountChars = 0
+  startupinfoa.dwFillAttribute = 0
+  startupinfoa.dwFlags = 0
+  startupinfoa.wShowWindow = 0
+  startupinfoa.cbReserved2 = 0
+  startupinfoa.lpReserved2 = None
+  startupinfoa.hStdInput = None
+  startupinfoa.hStdOutput = None
+  startupinfoa.hStdError = None
+  processinformation = PROCESS_INFORMATION()
+
+  # 0x4 below specifies CREATE_SUSPENDED.
+  ret = Kernel32.CreateProcessA(binfile.encode("ascii"), None, None, None, False, 0x4, None, None, byref(startupinfoa), byref(processinformation))
+  if ret == 0:
+    raise Exception('CreateProcess running {}'.format(binfile))
+
+  return processinformation.dwProcessId, processinformation.dwThreadId, processinformation.hProcess, processinformation.hThread
+
+def thread_resumer(hProcess, hThread):
+  Kernel32 = WinDLL("Kernel32")
+
+  # For reasons unclear to me, other suspend-references seem to be opened on
+  # the opened thread. Clear them all.
+  while True:
+    ret = Kernel32.ResumeThread(hThread)
+    if ret <= 0:
+      break
+  if ret < 0:
+    Kernel32.TerminateProcess(hProcess, 1)
+    raise Exception("Couldn't resume process after startup")
+
+  return
+
+def setup_everything(binfile):
+  from . import client
+  from . import symbols
+  Client = client.Client()
+
+  created_pid, created_tid, hProcess, hThread = process_creator(binfile)
+
+  # Load lines as well as general symbols
+  sym_opts = Client.Symbols.GetSymbolOptions()
+  sym_opts |= symbols.SymbolOptionFlags.SYMOPT_LOAD_LINES
+  Client.Symbols.SetSymbolOptions(sym_opts)
+
+  Client.AttachProcess(created_pid)
+
+  # Need to enter the debugger engine to let it attach properly
+  Client.Control.WaitForEvent(timeout=1)
+  Client.SysObjects.set_current_thread(created_pid, created_tid)
+  Client.Control.Execute("l+t")
+  Client.Control.SetExpressionSyntax(cpp=True)
+
+  module_name = Client.Symbols.get_exefile_module_name()
+  offset = Client.Symbols.GetOffsetByName("{}!main".format(module_name))
+  breakpoint = Client.Control.AddBreakpoint2(offset=offset, enabled=True)
+  thread_resumer(hProcess, hThread)
+  Client.Control.SetExecutionStatus(control.DebugStatus.DEBUG_STATUS_GO)
+
+  # Problem: there is no guarantee that the client will ever reach main,
+  # something else exciting could happen in that time, the host system may
+  # be very loaded, and similar. Wait for some period, say, five seconds, and
+  # abort afterwards: this is a trade-off between spurious timeouts and
+  # completely hanging in the case of a environmental/programming error.
+  res = Client.Control.WaitForEvent(timeout=5000)
+  if res == S_FALSE:
+    Kernel32.TerminateProcess(hProcess, 1)
+    raise Exception("Debuggee did not reach main function in a timely manner")
+
+  break_on_all_but_main(Client.Control, Client.Symbols, offset)
+
+  # Set the default action on all exceptions to be "quit and detach". If we
+  # don't, dbgeng will merrily spin at the exception site forever.
+  filts = Client.Control.GetNumberEventFilters()
+  for x in range(filts[0], filts[0] + filts[1]):
+    Client.Control.SetExceptionFilterSecondCommand(x, "qd")
+
+  return Client, hProcess
+
+def step_once(client):
+  client.Control.Execute("p")
+  try:
+    client.Control.WaitForEvent()
+  except Exception as e:
+    if client.Control.GetExecutionStatus() == control.DebugStatus.DEBUG_STATUS_NO_DEBUGGEE:
+      return None # Debuggee has gone away, likely due to an exception.
+    raise e
+  # Could assert here that we're in the "break" state
+  client.Control.GetExecutionStatus()
+  return probe_state(client)
+
+def main_loop(client):
+  res = True
+  while res is not None:
+    res = step_once(client)
+
+def cleanup(client, hProcess):
+  res = client.DetachProcesses()
+  Kernel32 = WinDLL("Kernel32")
+  Kernel32.TerminateProcess(hProcess, 1)
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/symbols.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/symbols.py
new file mode 100644
index 00000000000..bc998facb4e
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/symbols.py
@@ -0,0 +1,499 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from collections import namedtuple
+from ctypes import *
+from enum import *
+from functools import reduce, partial
+
+from .symgroup import SymbolGroup, IDebugSymbolGroup2
+from .utils import *
+
+class SymbolOptionFlags(IntFlag):
+  SYMOPT_CASE_INSENSITIVE          = 0x00000001
+  SYMOPT_UNDNAME                   = 0x00000002
+  SYMOPT_DEFERRED_LOADS            = 0x00000004
+  SYMOPT_NO_CPP                    = 0x00000008
+  SYMOPT_LOAD_LINES                = 0x00000010
+  SYMOPT_OMAP_FIND_NEAREST         = 0x00000020
+  SYMOPT_LOAD_ANYTHING             = 0x00000040
+  SYMOPT_IGNORE_CVREC              = 0x00000080
+  SYMOPT_NO_UNQUALIFIED_LOADS      = 0x00000100
+  SYMOPT_FAIL_CRITICAL_ERRORS      = 0x00000200
+  SYMOPT_EXACT_SYMBOLS             = 0x00000400
+  SYMOPT_ALLOW_ABSOLUTE_SYMBOLS    = 0x00000800
+  SYMOPT_IGNORE_NT_SYMPATH         = 0x00001000
+  SYMOPT_INCLUDE_32BIT_MODULES     = 0x00002000
+  SYMOPT_PUBLICS_ONLY              = 0x00004000
+  SYMOPT_NO_PUBLICS                = 0x00008000
+  SYMOPT_AUTO_PUBLICS              = 0x00010000
+  SYMOPT_NO_IMAGE_SEARCH           = 0x00020000
+  SYMOPT_SECURE                    = 0x00040000
+  SYMOPT_NO_PROMPTS                = 0x00080000
+  SYMOPT_DEBUG                     = 0x80000000
+
+class ScopeGroupFlags(IntFlag):
+  DEBUG_SCOPE_GROUP_ARGUMENTS    = 0x00000001
+  DEBUG_SCOPE_GROUP_LOCALS       = 0x00000002
+  DEBUG_SCOPE_GROUP_ALL          = 0x00000003
+  DEBUG_SCOPE_GROUP_BY_DATAMODEL = 0x00000004
+
+class DebugModuleNames(IntEnum):
+  DEBUG_MODNAME_IMAGE        = 0x00000000
+  DEBUG_MODNAME_MODULE       = 0x00000001
+  DEBUG_MODNAME_LOADED_IMAGE = 0x00000002
+  DEBUG_MODNAME_SYMBOL_FILE  = 0x00000003
+  DEBUG_MODNAME_MAPPED_IMAGE = 0x00000004
+
+class DebugModuleFlags(IntFlag):
+  DEBUG_MODULE_LOADED            = 0x00000000
+  DEBUG_MODULE_UNLOADED          = 0x00000001
+  DEBUG_MODULE_USER_MODE         = 0x00000002
+  DEBUG_MODULE_EXE_MODULE        = 0x00000004
+  DEBUG_MODULE_EXPLICIT          = 0x00000008
+  DEBUG_MODULE_SECONDARY         = 0x00000010
+  DEBUG_MODULE_SYNTHETIC         = 0x00000020
+  DEBUG_MODULE_SYM_BAD_CHECKSUM  = 0x00010000
+
+class DEBUG_MODULE_PARAMETERS(Structure):
+  _fields_ = [
+      ("Base", c_ulonglong),
+      ("Size", c_ulong),
+      ("TimeDateStamp", c_ulong),
+      ("Checksum", c_ulong),
+      ("Flags", c_ulong),
+      ("SymbolType", c_ulong),
+      ("ImageNameSize", c_ulong),
+      ("ModuleNameSize", c_ulong),
+      ("LoadedImageNameSize", c_ulong),
+      ("SymbolFileNameSize", c_ulong),
+      ("MappedImageNameSize", c_ulong),
+      ("Reserved", c_ulonglong * 2)
+    ]
+PDEBUG_MODULE_PARAMETERS = POINTER(DEBUG_MODULE_PARAMETERS)
+
+class DEBUG_MODULE_AND_ID(Structure):
+  _fields_ = [
+      ("ModuleBase", c_ulonglong),
+      ("Id", c_ulonglong)
+    ]
+PDEBUG_MODULE_AND_ID = POINTER(DEBUG_MODULE_AND_ID)
+
+class DEBUG_SYMBOL_ENTRY(Structure):
+  _fields_ = [
+      ("ModuleBase", c_ulonglong),
+      ("Offset", c_ulonglong),
+      ("Id", c_ulonglong),
+      ("Arg64", c_ulonglong),
+      ("Size", c_ulong),
+      ("Flags", c_ulong),
+      ("TypeId", c_ulong),
+      ("NameSize", c_ulong),
+      ("Token", c_ulong),
+      ("Tag", c_ulong),
+      ("Arg32", c_ulong),
+      ("Reserved", c_ulong)
+    ]
+PDEBUG_SYMBOL_ENTRY = POINTER(DEBUG_SYMBOL_ENTRY)
+
+# UUID for DebugSymbols5 interface.
+DebugSymbols5IID = IID(0xc65fa83e, 0x1e69, 0x475e, IID_Data4_Type(0x8e, 0x0e, 0xb5, 0xd7, 0x9e, 0x9c, 0xc1, 0x7e))
+
+class IDebugSymbols5(Structure):
+  pass
+
+class IDebugSymbols5Vtbl(Structure):
+  wrp = partial(WINFUNCTYPE, c_long, POINTER(IDebugSymbols5))
+  ids_getsymboloptions = wrp(c_ulong_p)
+  ids_setsymboloptions = wrp(c_ulong)
+  ids_getmoduleparameters = wrp(c_ulong, c_ulong64_p, c_ulong, PDEBUG_MODULE_PARAMETERS)
+  ids_getmodulenamestring = wrp(c_ulong, c_ulong, c_ulonglong, c_char_p, c_ulong, c_ulong_p)
+  ids_getoffsetbyname = wrp(c_char_p, c_ulong64_p)
+  ids_getlinebyoffset = wrp(c_ulonglong, c_ulong_p, c_char_p, c_ulong, c_ulong_p, c_ulong64_p)
+  ids_getsymbolentriesbyname = wrp(c_char_p, c_ulong, PDEBUG_MODULE_AND_ID, c_ulong, c_ulong_p)
+  ids_getsymbolentrystring = wrp(PDEBUG_MODULE_AND_ID, c_ulong, c_char_p, c_ulong, c_ulong_p)
+  ids_getsymbolentryinformation = wrp(PDEBUG_MODULE_AND_ID, PDEBUG_SYMBOL_ENTRY)
+  ids_getcurrentscopeframeindex = wrp(c_ulong_p)
+  ids_getnearnamebyoffset = wrp(c_ulonglong, c_long, c_char_p, c_ulong, c_ulong_p, c_ulong64_p)
+  ids_setscopeframebyindex = wrp(c_ulong)
+  ids_getscopesymbolgroup2 = wrp(c_ulong, POINTER(IDebugSymbolGroup2), POINTER(POINTER(IDebugSymbolGroup2)))
+  ids_getnamebyinlinecontext = wrp(c_ulonglong, c_ulong, c_char_p, c_ulong, c_ulong_p, c_ulong64_p)
+  ids_getlinebyinlinecontext = wrp(c_ulonglong, c_ulong, c_ulong_p, c_char_p, c_ulong, c_ulong_p, c_ulong64_p)
+  _fields_ = [
+      ("QueryInterface", c_void_p),
+      ("AddRef", c_void_p),
+      ("Release", c_void_p),
+      ("GetSymbolOptions", ids_getsymboloptions),
+      ("AddSymbolOptions", c_void_p),
+      ("RemoveSymbolOptions", c_void_p),
+      ("SetSymbolOptions", ids_setsymboloptions),
+      ("GetNameByOffset", c_void_p),
+      ("GetOffsetByName", ids_getoffsetbyname),
+      ("GetNearNameByOffset", ids_getnearnamebyoffset),
+      ("GetLineByOffset", ids_getlinebyoffset),
+      ("GetOffsetByLine", c_void_p),
+      ("GetNumberModules", c_void_p),
+      ("GetModuleByIndex", c_void_p),
+      ("GetModuleByModuleName", c_void_p),
+      ("GetModuleByOffset", c_void_p),
+      ("GetModuleNames", c_void_p),
+      ("GetModuleParameters", ids_getmoduleparameters),
+      ("GetSymbolModule", c_void_p),
+      ("GetTypeName", c_void_p),
+      ("GetTypeId", c_void_p),
+      ("GetTypeSize", c_void_p),
+      ("GetFieldOffset", c_void_p),
+      ("GetSymbolTypeId", c_void_p),
+      ("GetOffsetTypeId", c_void_p),
+      ("ReadTypedDataVirtual", c_void_p),
+      ("WriteTypedDataVirtual", c_void_p),
+      ("OutputTypedDataVirtual", c_void_p),
+      ("ReadTypedDataPhysical", c_void_p),
+      ("WriteTypedDataPhysical", c_void_p),
+      ("OutputTypedDataPhysical", c_void_p),
+      ("GetScope", c_void_p),
+      ("SetScope", c_void_p),
+      ("ResetScope", c_void_p),
+      ("GetScopeSymbolGroup", c_void_p),
+      ("CreateSymbolGroup", c_void_p),
+      ("StartSymbolMatch", c_void_p),
+      ("GetNextSymbolMatch", c_void_p),
+      ("EndSymbolMatch", c_void_p),
+      ("Reload", c_void_p),
+      ("GetSymbolPath", c_void_p),
+      ("SetSymbolPath", c_void_p),
+      ("AppendSymbolPath", c_void_p),
+      ("GetImagePath", c_void_p),
+      ("SetImagePath", c_void_p),
+      ("AppendImagePath", c_void_p),
+      ("GetSourcePath", c_void_p),
+      ("GetSourcePathElement", c_void_p),
+      ("SetSourcePath", c_void_p),
+      ("AppendSourcePath", c_void_p),
+      ("FindSourceFile", c_void_p),
+      ("GetSourceFileLineOffsets", c_void_p),
+      ("GetModuleVersionInformation", c_void_p),
+      ("GetModuleNameString", ids_getmodulenamestring),
+      ("GetConstantName", c_void_p),
+      ("GetFieldName", c_void_p),
+      ("GetTypeOptions", c_void_p),
+      ("AddTypeOptions", c_void_p),
+      ("RemoveTypeOptions", c_void_p),
+      ("SetTypeOptions", c_void_p),
+      ("GetNameByOffsetWide", c_void_p),
+      ("GetOffsetByNameWide", c_void_p),
+      ("GetNearNameByOffsetWide", c_void_p),
+      ("GetLineByOffsetWide", c_void_p),
+      ("GetOffsetByLineWide", c_void_p),
+      ("GetModuleByModuleNameWide", c_void_p),
+      ("GetSymbolModuleWide", c_void_p),
+      ("GetTypeNameWide", c_void_p),
+      ("GetTypeIdWide", c_void_p),
+      ("GetFieldOffsetWide", c_void_p),
+      ("GetSymbolTypeIdWide", c_void_p),
+      ("GetScopeSymbolGroup2", ids_getscopesymbolgroup2),
+      ("CreateSymbolGroup2", c_void_p),
+      ("StartSymbolMatchWide", c_void_p),
+      ("GetNextSymbolMatchWide", c_void_p),
+      ("ReloadWide", c_void_p),
+      ("GetSymbolPathWide", c_void_p),
+      ("SetSymbolPathWide", c_void_p),
+      ("AppendSymbolPathWide", c_void_p),
+      ("GetImagePathWide", c_void_p),
+      ("SetImagePathWide", c_void_p),
+      ("AppendImagePathWide", c_void_p),
+      ("GetSourcePathWide", c_void_p),
+      ("GetSourcePathElementWide", c_void_p),
+      ("SetSourcePathWide", c_void_p),
+      ("AppendSourcePathWide", c_void_p),
+      ("FindSourceFileWide", c_void_p),
+      ("GetSourceFileLineOffsetsWide", c_void_p),
+      ("GetModuleVersionInformationWide", c_void_p),
+      ("GetModuleNameStringWide", c_void_p),
+      ("GetConstantNameWide", c_void_p),
+      ("GetFieldNameWide", c_void_p),
+      ("IsManagedModule", c_void_p),
+      ("GetModuleByModuleName2", c_void_p),
+      ("GetModuleByModuleName2Wide", c_void_p),
+      ("GetModuleByOffset2", c_void_p),
+      ("AddSyntheticModule", c_void_p),
+      ("AddSyntheticModuleWide", c_void_p),
+      ("RemoveSyntheticModule", c_void_p),
+      ("GetCurrentScopeFrameIndex", ids_getcurrentscopeframeindex),
+      ("SetScopeFrameByIndex", ids_setscopeframebyindex),
+      ("SetScopeFromJitDebugInfo", c_void_p),
+      ("SetScopeFromStoredEvent", c_void_p),
+      ("OutputSymbolByOffset", c_void_p),
+      ("GetFunctionEntryByOffset", c_void_p),
+      ("GetFieldTypeAndOffset", c_void_p),
+      ("GetFieldTypeAndOffsetWide", c_void_p),
+      ("AddSyntheticSymbol", c_void_p),
+      ("AddSyntheticSymbolWide", c_void_p),
+      ("RemoveSyntheticSymbol", c_void_p),
+      ("GetSymbolEntriesByOffset", c_void_p),
+      ("GetSymbolEntriesByName", ids_getsymbolentriesbyname),
+      ("GetSymbolEntriesByNameWide", c_void_p),
+      ("GetSymbolEntryByToken", c_void_p),
+      ("GetSymbolEntryInformation", ids_getsymbolentryinformation),
+      ("GetSymbolEntryString", ids_getsymbolentrystring),
+      ("GetSymbolEntryStringWide", c_void_p),
+      ("GetSymbolEntryOffsetRegions", c_void_p),
+      ("GetSymbolEntryBySymbolEntry", c_void_p),
+      ("GetSourceEntriesByOffset", c_void_p),
+      ("GetSourceEntriesByLine", c_void_p),
+      ("GetSourceEntriesByLineWide", c_void_p),
+      ("GetSourceEntryString", c_void_p),
+      ("GetSourceEntryStringWide", c_void_p),
+      ("GetSourceEntryOffsetRegions", c_void_p),
+      ("GetsourceEntryBySourceEntry", c_void_p),
+      ("GetScopeEx", c_void_p),
+      ("SetScopeEx", c_void_p),
+      ("GetNameByInlineContext", ids_getnamebyinlinecontext),
+      ("GetNameByInlineContextWide", c_void_p),
+      ("GetLineByInlineContext", ids_getlinebyinlinecontext),
+      ("GetLineByInlineContextWide", c_void_p),
+      ("OutputSymbolByInlineContext", c_void_p),
+      ("GetCurrentScopeFrameIndexEx", c_void_p),
+      ("SetScopeFrameByIndexEx", c_void_p)
+    ]
+
+IDebugSymbols5._fields_ = [("lpVtbl", POINTER(IDebugSymbols5Vtbl))]
+
+SymbolId = namedtuple("SymbolId", ["ModuleBase", "Id"])
+SymbolEntry = namedtuple("SymbolEntry", ["ModuleBase", "Offset", "Id", "Arg64", "Size", "Flags", "TypeId", "NameSize", "Token", "Tag", "Arg32"])
+DebugModuleParams = namedtuple("DebugModuleParams", ["Base", "Size", "TimeDateStamp", "Checksum", "Flags", "SymbolType", "ImageNameSize", "ModuleNameSize", "LoadedImageNameSize", "SymbolFileNameSize", "MappedImageNameSize"])
+
+class SymTags(IntEnum):
+  Null = 0
+  Exe = 1
+  SymTagFunction = 5
+
+def make_debug_module_params(cdata):
+  fieldvalues = map(lambda y: getattr(cdata, y), DebugModuleParams._fields)
+  return DebugModuleParams(*fieldvalues)
+
+class Symbols(object):
+  def __init__(self, symbols):
+    self.ptr = symbols
+    self.symbols = symbols.contents
+    self.vt = self.symbols.lpVtbl.contents
+    # Keep some handy ulongs for passing into C methods.
+    self.ulong = c_ulong()
+    self.ulong64 = c_ulonglong()
+
+  def GetCurrentScopeFrameIndex(self):
+    res = self.vt.GetCurrentScopeFrameIndex(self.symbols, byref(self.ulong))
+    aborter(res, "GetCurrentScopeFrameIndex")
+    return self.ulong.value
+
+  def SetScopeFrameByIndex(self, idx):
+    res = self.vt.SetScopeFrameByIndex(self.symbols, idx)
+    aborter(res, "SetScopeFrameByIndex", ignore=[E_EINVAL])
+    return res != E_EINVAL
+
+  def GetOffsetByName(self, name):
+    res = self.vt.GetOffsetByName(self.symbols, name.encode("ascii"), byref(self.ulong64))
+    aborter(res, "GetOffsetByName {}".format(name))
+    return self.ulong64.value
+
+  def GetNearNameByOffset(self, addr):
+    ptr = create_string_buffer(256)
+    pulong = c_ulong()
+    disp = c_ulonglong()
+    # Zero arg -> "delta" indicating how many symbols to skip
+    res = self.vt.GetNearNameByOffset(self.symbols, addr, 0, ptr, 255, byref(pulong), byref(disp))
+    if res == E_NOINTERFACE:
+      return "{noname}"
+    aborter(res, "GetNearNameByOffset")
+    ptr[255] = '\0'.encode("ascii")
+    return '{}+{}'.format(string_at(ptr).decode("ascii"), disp.value)
+
+  def GetModuleByModuleName2(self, name):
+    # First zero arg -> module index to search from, second zero arg ->
+    # DEBUG_GETMOD_* flags, none of which we use.
+    res = self.vt.GetModuleByModuleName2(self.symbols, name, 0, 0, None, byref(self.ulong64))
+    aborter(res, "GetModuleByModuleName2")
+    return self.ulong64.value
+
+  def GetScopeSymbolGroup2(self):
+    retptr = POINTER(IDebugSymbolGroup2)()
+    res = self.vt.GetScopeSymbolGroup2(self.symbols, ScopeGroupFlags.DEBUG_SCOPE_GROUP_ALL, None, retptr)
+    aborter(res, "GetScopeSymbolGroup2")
+    return SymbolGroup(retptr)
+
+  def GetSymbolEntryString(self, idx, module):
+    symid = DEBUG_MODULE_AND_ID()
+    symid.ModuleBase = module
+    symid.Id = idx
+    ptr = create_string_buffer(1024)
+    # Zero arg is the string index -- symbols can have multiple names, for now
+    # only support the first one.
+    res = self.vt.GetSymbolEntryString(self.symbols, symid, 0, ptr, 1023, byref(self.ulong))
+    aborter(res, "GetSymbolEntryString")
+    return string_at(ptr).decode("ascii")
+
+  def GetSymbolEntryInformation(self, module, theid):
+    symid = DEBUG_MODULE_AND_ID()
+    symentry = DEBUG_SYMBOL_ENTRY()
+    symid.ModuleBase = module
+    symid.Id = theid
+    res = self.vt.GetSymbolEntryInformation(self.symbols, symid, symentry)
+    aborter(res, "GetSymbolEntryInformation")
+    # Fetch fields into SymbolEntry object
+    fields = map(lambda x: getattr(symentry, x), SymbolEntry._fields)
+    return SymbolEntry(*fields)
+
+  def GetSymbolEntriesByName(self, symstr):
+    # Initial query to find number of symbol entries
+    res = self.vt.GetSymbolEntriesByName(self.symbols, symstr.encode("ascii"), 0, None, 0, byref(self.ulong))
+    aborter(res, "GetSymbolEntriesByName")
+
+    # Build a buffer and query for 'length' entries
+    length = self.ulong.value
+    symrecs = (DEBUG_MODULE_AND_ID * length)()
+    # Zero arg -> flags, of which there are none defined.
+    res = self.vt.GetSymbolEntriesByName(self.symbols, symstr.encode("ascii"), 0, symrecs, length, byref(self.ulong))
+    aborter(res, "GetSymbolEntriesByName")
+
+    # Extract 'length' number of SymbolIds
+    length = self.ulong.value
+    def extract(x):
+      sym = symrecs[x]
+      return SymbolId(sym.ModuleBase, sym.Id)
+    return [extract(x) for x in range(length)]
+
+  def GetSymbolPath(self):
+    # Query for length of buffer to allocate
+    res = self.vt.GetSymbolPath(self.symbols, None, 0, byref(self.ulong))
+    aborter(res, "GetSymbolPath", ignore=[S_FALSE])
+
+    # Fetch 'length' length symbol path string
+    length = self.ulong.value
+    arr = create_string_buffer(length)
+    res = self.vt.GetSymbolPath(self.symbols, arr, length, byref(self.ulong))
+    aborter(res, "GetSymbolPath")
+
+    return string_at(arr).decode("ascii")
+
+  def GetSourcePath(self):
+    # Query for length of buffer to allocate
+    res = self.vt.GetSourcePath(self.symbols, None, 0, byref(self.ulong))
+    aborter(res, "GetSourcePath", ignore=[S_FALSE])
+
+    # Fetch a string of len 'length'
+    length = self.ulong.value
+    arr = create_string_buffer(length)
+    res = self.vt.GetSourcePath(self.symbols, arr, length, byref(self.ulong))
+    aborter(res, "GetSourcePath")
+
+    return string_at(arr).decode("ascii")
+
+  def SetSourcePath(self, string):
+    res = self.vt.SetSourcePath(self.symbols, string.encode("ascii"))
+    aborter(res, "SetSourcePath")
+    return
+
+  def GetModuleParameters(self, base):
+    self.ulong64.value = base
+    params = DEBUG_MODULE_PARAMETERS()
+    # Fetch one module params struct, starting at idx zero
+    res = self.vt.GetModuleParameters(self.symbols, 1, byref(self.ulong64), 0, byref(params))
+    aborter(res, "GetModuleParameters")
+    return make_debug_module_params(params)
+
+  def GetSymbolOptions(self):
+    res = self.vt.GetSymbolOptions(self.symbols, byref(self.ulong))
+    aborter(res, "GetSymbolOptions")
+    return SymbolOptionFlags(self.ulong.value)
+
+  def SetSymbolOptions(self, opts):
+    assert isinstance(opts, SymbolOptionFlags)
+    res = self.vt.SetSymbolOptions(self.symbols, opts.value)
+    aborter(res, "SetSymbolOptions")
+    return
+
+  def GetLineByOffset(self, offs):
+    # Initial query for filename buffer size
+    res = self.vt.GetLineByOffset(self.symbols, offs, None, None, 0, byref(self.ulong), None)
+    if res == E_FAIL:
+      return None # Sometimes we just can't get line numbers, of course
+    aborter(res, "GetLineByOffset", ignore=[S_FALSE])
+
+    # Allocate filename buffer and query for line number too
+    filenamelen = self.ulong.value
+    text = create_string_buffer(filenamelen)
+    line = c_ulong()
+    res = self.vt.GetLineByOffset(self.symbols, offs, byref(line), text, filenamelen, byref(self.ulong), None)
+    aborter(res, "GetLineByOffset")
+
+    return string_at(text).decode("ascii"), line.value
+
+  def GetModuleNameString(self, whichname, base):
+    # Initial query for name string length
+    res = self.vt.GetModuleNameString(self.symbols, whichname, DEBUG_ANY_ID, base, None, 0, byref(self.ulong))
+    aborter(res, "GetModuleNameString", ignore=[S_FALSE])
+
+    module_name_len = self.ulong.value
+    module_name = (c_char * module_name_len)()
+    res = self.vt.GetModuleNameString(self.symbols, whichname, DEBUG_ANY_ID, base, module_name, module_name_len, None)
+    aborter(res, "GetModuleNameString")
+
+    return string_at(module_name).decode("ascii")
+
+  def GetNameByInlineContext(self, pc, ctx):
+    # None args -> ignore output name size and displacement
+    buf = create_string_buffer(256)
+    res = self.vt.GetNameByInlineContext(self.symbols, pc, ctx, buf, 255, None, None)
+    aborter(res, "GetNameByInlineContext")
+    return string_at(buf).decode("ascii")
+
+  def GetLineByInlineContext(self, pc, ctx):
+    # None args -> ignore output filename size and displacement
+    buf = create_string_buffer(256)
+    res = self.vt.GetLineByInlineContext(self.symbols, pc, ctx, byref(self.ulong), buf, 255, None, None)
+    aborter(res, "GetLineByInlineContext")
+    return string_at(buf).decode("ascii"), self.ulong.value
+
+  def get_all_symbols(self):
+    main_module_name = self.get_exefile_module_name()
+    idnumbers = self.GetSymbolEntriesByName("{}!*".format(main_module_name))
+    lst = []
+    for symid in idnumbers:
+      s = self.GetSymbolEntryString(symid.Id, symid.ModuleBase)
+      symentry = self.GetSymbolEntryInformation(symid.ModuleBase, symid.Id)
+      lst.append((s, symentry))
+    return lst
+
+  def get_all_functions(self):
+    syms = self.get_all_symbols()
+    return [x for x in syms if x[1].Tag == SymTags.SymTagFunction]
+
+  def get_all_modules(self):
+    params = DEBUG_MODULE_PARAMETERS()
+    idx = 0
+    res = 0
+    all_modules = []
+    while res != E_EINVAL:
+      res = self.vt.GetModuleParameters(self.symbols, 1, None, idx, byref(params))
+      aborter(res, "GetModuleParameters", ignore=[E_EINVAL])
+      all_modules.append(make_debug_module_params(params))
+      idx += 1
+    return all_modules
+
+  def get_exefile_module(self):
+    all_modules = self.get_all_modules()
+    reduce_func = lambda x, y: y if y.Flags & DebugModuleFlags.DEBUG_MODULE_EXE_MODULE else x
+    main_module = reduce(reduce_func, all_modules, None)
+    if main_module is None:
+      raise Exception("Couldn't find the exefile module")
+    return main_module
+
+  def get_module_name(self, base):
+    return self.GetModuleNameString(DebugModuleNames.DEBUG_MODNAME_MODULE, base)
+
+  def get_exefile_module_name(self):
+    return self.get_module_name(self.get_exefile_module().Base)
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/symgroup.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/symgroup.py
new file mode 100644
index 00000000000..2775af3279b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/symgroup.py
@@ -0,0 +1,98 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from collections import namedtuple
+from ctypes import *
+from functools import partial
+
+from .utils import *
+
+Symbol = namedtuple("Symbol", ["num", "name", "type", "value"])
+
+class IDebugSymbolGroup2(Structure):
+  pass
+
+class IDebugSymbolGroup2Vtbl(Structure):
+  wrp = partial(WINFUNCTYPE, c_long, POINTER(IDebugSymbolGroup2))
+  ids_getnumbersymbols = wrp(c_ulong_p)
+  ids_getsymbolname = wrp(c_ulong, c_char_p, c_ulong, c_ulong_p)
+  ids_getsymboltypename = wrp(c_ulong, c_char_p, c_ulong, c_ulong_p)
+  ids_getsymbolvaluetext = wrp(c_ulong, c_char_p, c_ulong, c_ulong_p)
+  _fields_ = [
+      ("QueryInterface", c_void_p),
+      ("AddRef", c_void_p),
+      ("Release", c_void_p),
+      ("GetNumberSymbols", ids_getnumbersymbols),
+      ("AddSymbol", c_void_p),
+      ("RemoveSymbolByName", c_void_p),
+      ("RemoveSymbolByIndex", c_void_p),
+      ("GetSymbolName", ids_getsymbolname),
+      ("GetSymbolParameters", c_void_p),
+      ("ExpandSymbol", c_void_p),
+      ("OutputSymbols", c_void_p),
+      ("WriteSymbol", c_void_p),
+      ("OutputAsType", c_void_p),
+      ("AddSymbolWide", c_void_p),
+      ("RemoveSymbolByNameWide", c_void_p),
+      ("GetSymbolNameWide", c_void_p),
+      ("WritesymbolWide", c_void_p),
+      ("OutputAsTypeWide", c_void_p),
+      ("GetSymbolTypeName", ids_getsymboltypename),
+      ("GetSymbolTypeNameWide", c_void_p),
+      ("GetSymbolSize", c_void_p),
+      ("GetSymbolOffset", c_void_p),
+      ("GetSymbolRegister", c_void_p),
+      ("GetSymbolValueText", ids_getsymbolvaluetext),
+      ("GetSymbolValueTextWide", c_void_p),
+      ("GetSymbolEntryInformation", c_void_p)
+    ]
+
+IDebugSymbolGroup2._fields_ = [("lpVtbl", POINTER(IDebugSymbolGroup2Vtbl))]
+
+class SymbolGroup(object):
+  def __init__(self, symgroup):
+    self.symgroup = symgroup.contents
+    self.vt = self.symgroup.lpVtbl.contents
+    self.ulong = c_ulong()
+
+  def GetNumberSymbols(self):
+    res = self.vt.GetNumberSymbols(self.symgroup, byref(self.ulong))
+    aborter(res, "GetNumberSymbols")
+    return self.ulong.value
+
+  def GetSymbolName(self, idx):
+    buf = create_string_buffer(256)
+    res = self.vt.GetSymbolName(self.symgroup, idx, buf, 255, byref(self.ulong))
+    aborter(res, "GetSymbolName")
+    thelen = self.ulong.value
+    return string_at(buf).decode("ascii")
+
+  def GetSymbolTypeName(self, idx):
+    buf = create_string_buffer(256)
+    res = self.vt.GetSymbolTypeName(self.symgroup, idx, buf, 255, byref(self.ulong))
+    aborter(res, "GetSymbolTypeName")
+    thelen = self.ulong.value
+    return string_at(buf).decode("ascii")
+
+  def GetSymbolValueText(self, idx, handleserror=False):
+    buf = create_string_buffer(256)
+    res = self.vt.GetSymbolValueText(self.symgroup, idx, buf, 255, byref(self.ulong))
+    if res != 0 and handleserror:
+      return None
+    aborter(res, "GetSymbolTypeName")
+    thelen = self.ulong.value
+    return string_at(buf).decode("ascii")
+
+  def get_symbol(self, idx):
+    name = self.GetSymbolName(idx)
+    thetype = self.GetSymbolTypeName(idx)
+    value = self.GetSymbolValueText(idx)
+    return Symbol(idx, name, thetype, value)
+
+  def get_all_symbols(self):
+    num_syms = self.GetNumberSymbols()
+    return list(map(self.get_symbol, list(range(num_syms))))
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/sysobjs.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/sysobjs.py
new file mode 100644
index 00000000000..0e9844a363b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/sysobjs.py
@@ -0,0 +1,200 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from ctypes import *
+from functools import partial
+
+from .utils import *
+
+# UUID For SystemObjects4 interface.
+DebugSystemObjects4IID = IID(0x489468e6, 0x7d0f, 0x4af5, IID_Data4_Type(0x87, 0xab, 0x25, 0x20, 0x74, 0x54, 0xd5, 0x53))
+
+class IDebugSystemObjects4(Structure):
+  pass
+
+class IDebugSystemObjects4Vtbl(Structure):
+  wrp = partial(WINFUNCTYPE, c_long, POINTER(IDebugSystemObjects4))
+  ids_getnumberprocesses = wrp(POINTER(c_ulong))
+  ids_getprocessidsbyindex = wrp(c_ulong, c_ulong, c_ulong_p, c_ulong_p)
+  ids_setcurrentprocessid = wrp(c_ulong)
+  ids_getnumberthreads = wrp(c_ulong_p)
+  ids_getthreadidsbyindex = wrp(c_ulong, c_ulong, c_ulong_p, c_ulong_p)
+  ids_setcurrentthreadid = wrp(c_ulong)
+  _fields_ = [
+      ("QueryInterface", c_void_p),
+      ("AddRef", c_void_p),
+      ("Release", c_void_p),
+      ("GetEventThread", c_void_p),
+      ("GetEventProcess", c_void_p),
+      ("GetCurrentThreadId", c_void_p),
+      ("SetCurrentThreadId", ids_setcurrentthreadid),
+      ("GetCurrentProcessId", c_void_p),
+      ("SetCurrentProcessId", ids_setcurrentprocessid),
+      ("GetNumberThreads", ids_getnumberthreads),
+      ("GetTotalNumberThreads", c_void_p),
+      ("GetThreadIdsByIndex", ids_getthreadidsbyindex),
+      ("GetThreadIdByProcessor", c_void_p),
+      ("GetCurrentThreadDataOffset", c_void_p),
+      ("GetThreadIdByDataOffset", c_void_p),
+      ("GetCurrentThreadTeb", c_void_p),
+      ("GetThreadIdByTeb", c_void_p),
+      ("GetCurrentThreadSystemId", c_void_p),
+      ("GetThreadIdBySystemId", c_void_p),
+      ("GetCurrentThreadHandle", c_void_p),
+      ("GetThreadIdByHandle", c_void_p),
+      ("GetNumberProcesses", ids_getnumberprocesses),
+      ("GetProcessIdsByIndex", ids_getprocessidsbyindex),
+      ("GetCurrentProcessDataOffset", c_void_p),
+      ("GetProcessIdByDataOffset", c_void_p),
+      ("GetCurrentProcessPeb", c_void_p),
+      ("GetProcessIdByPeb", c_void_p),
+      ("GetCurrentProcessSystemId", c_void_p),
+      ("GetProcessIdBySystemId", c_void_p),
+      ("GetCurrentProcessHandle", c_void_p),
+      ("GetProcessIdByHandle", c_void_p),
+      ("GetCurrentProcessExecutableName", c_void_p),
+      ("GetCurrentProcessUpTime", c_void_p),
+      ("GetImplicitThreadDataOffset", c_void_p),
+      ("SetImplicitThreadDataOffset", c_void_p),
+      ("GetImplicitProcessDataOffset", c_void_p),
+      ("SetImplicitProcessDataOffset", c_void_p),
+      ("GetEventSystem", c_void_p),
+      ("GetCurrentSystemId", c_void_p),
+      ("SetCurrentSystemId", c_void_p),
+      ("GetNumberSystems", c_void_p),
+      ("GetSystemIdsByIndex", c_void_p),
+      ("GetTotalNumberThreadsAndProcesses", c_void_p),
+      ("GetCurrentSystemServer", c_void_p),
+      ("GetSystemByServer", c_void_p),
+      ("GetCurrentSystemServerName", c_void_p),
+      ("GetCurrentProcessExecutableNameWide", c_void_p),
+      ("GetCurrentSystemServerNameWide", c_void_p)
+    ]
+
+IDebugSystemObjects4._fields_ = [("lpVtbl", POINTER(IDebugSystemObjects4Vtbl))]
+
+class SysObjects(object):
+  def __init__(self, sysobjects):
+    self.ptr = sysobjects
+    self.sysobjects = sysobjects.contents
+    self.vt = self.sysobjects.lpVtbl.contents
+    # Keep a handy ulong for passing into C methods.
+    self.ulong = c_ulong()
+
+  def GetNumberSystems(self):
+    res = self.vt.GetNumberSystems(self.sysobjects, byref(self.ulong))
+    aborter(res, "GetNumberSystems")
+    return self.ulong.value
+
+  def GetNumberProcesses(self):
+    res = self.vt.GetNumberProcesses(self.sysobjects, byref(self.ulong))
+    aborter(res, "GetNumberProcesses")
+    return self.ulong.value
+
+  def GetNumberThreads(self):
+    res = self.vt.GetNumberThreads(self.sysobjects, byref(self.ulong))
+    aborter(res, "GetNumberThreads")
+    return self.ulong.value
+
+  def GetTotalNumberThreadsAndProcesses(self):
+    tthreads = c_ulong()
+    tprocs = c_ulong()
+    pulong3 = c_ulong()
+    res = self.vt.GetTotalNumberThreadsAndProcesses(self.sysobjects, byref(tthreads), byref(tprocs), byref(pulong3), byref(pulong3), byref(pulong3))
+    aborter(res, "GettotalNumberThreadsAndProcesses")
+    return tthreads.value, tprocs.value
+
+  def GetCurrentProcessId(self):
+    res = self.vt.GetCurrentProcessId(self.sysobjects, byref(self.ulong))
+    aborter(res, "GetCurrentProcessId")
+    return self.ulong.value
+
+  def SetCurrentProcessId(self, sysid):
+    res = self.vt.SetCurrentProcessId(self.sysobjects, sysid)
+    aborter(res, "SetCurrentProcessId")
+    return
+
+  def GetCurrentThreadId(self):
+    res = self.vt.GetCurrentThreadId(self.sysobjects, byref(self.ulong))
+    aborter(res, "GetCurrentThreadId")
+    return self.ulong.value
+
+  def SetCurrentThreadId(self, sysid):
+    res = self.vt.SetCurrentThreadId(self.sysobjects, sysid)
+    aborter(res, "SetCurrentThreadId")
+    return
+
+  def GetProcessIdsByIndex(self):
+    num_processes = self.GetNumberProcesses()
+    if num_processes == 0:
+      return []
+    engineids = (c_ulong * num_processes)()
+    pids = (c_ulong * num_processes)()
+    for x in range(num_processes):
+      engineids[x] = DEBUG_ANY_ID
+      pids[x] = DEBUG_ANY_ID
+    res = self.vt.GetProcessIdsByIndex(self.sysobjects, 0, num_processes, engineids, pids)
+    aborter(res, "GetProcessIdsByIndex")
+    return list(zip(engineids, pids))
+
+  def GetThreadIdsByIndex(self):
+    num_threads = self.GetNumberThreads()
+    if num_threads == 0:
+      return []
+    engineids = (c_ulong * num_threads)()
+    tids = (c_ulong * num_threads)()
+    for x in range(num_threads):
+      engineids[x] = DEBUG_ANY_ID
+      tids[x] = DEBUG_ANY_ID
+    # Zero -> start index
+    res = self.vt.GetThreadIdsByIndex(self.sysobjects, 0, num_threads, engineids, tids)
+    aborter(res, "GetThreadIdsByIndex")
+    return list(zip(engineids, tids))
+
+  def GetCurThreadHandle(self):
+    pulong64 = c_ulonglong()
+    res = self.vt.GetCurrentThreadHandle(self.sysobjects, byref(pulong64))
+    aborter(res, "GetCurrentThreadHandle")
+    return pulong64.value
+
+  def set_current_thread(self, pid, tid):
+    proc_sys_id = -1
+    for x in self.GetProcessIdsByIndex():
+      sysid, procid = x
+      if procid == pid:
+        proc_sys_id = sysid
+
+    if proc_sys_id == -1:
+      raise Exception("Couldn't find designated PID {}".format(pid))
+
+    self.SetCurrentProcessId(proc_sys_id)
+
+    thread_sys_id = -1
+    for x in self.GetThreadIdsByIndex():
+      sysid, threadid = x
+      if threadid == tid:
+        thread_sys_id = sysid
+
+    if thread_sys_id == -1:
+      raise Exception("Couldn't find designated TID {}".format(tid))
+
+    self.SetCurrentThreadId(thread_sys_id)
+    return
+
+  def print_current_procs_threads(self):
+    procs = []
+    for x in self.GetProcessIdsByIndex():
+      sysid, procid = x
+      procs.append(procid)
+
+    threads = []
+    for x in self.GetThreadIdsByIndex():
+      sysid, threadid = x
+      threads.append(threadid)
+
+    print("Current processes: {}".format(procs))
+    print("Current threads: {}".format(threads))
diff --git a/debuginfo-tests/dexter/dex/debugger/dbgeng/utils.py b/debuginfo-tests/dexter/dex/debugger/dbgeng/utils.py
new file mode 100644
index 00000000000..0c9197aa1c9
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/dbgeng/utils.py
@@ -0,0 +1,47 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from ctypes import *
+
+# Error codes are negative when received by python, but are typically
+# represented by unsigned hex elsewhere. Subtract 2^32 from the unsigned
+# hex to produce negative error codes.
+E_NOINTERFACE = 0x80004002 - 0x100000000
+E_FAIL = 0x80004005 - 0x100000000
+E_EINVAL = 0x80070057 - 0x100000000
+E_INTERNALEXCEPTION = 0x80040205 - 0x100000000
+S_FALSE = 1
+
+# This doesn't fit into any convenient category
+DEBUG_ANY_ID = 0xFFFFFFFF
+
+class WinError(Exception):
+  def __init__(self, msg, hstatus):
+    self.hstatus = hstatus
+    super(WinError, self).__init__(msg)
+
+def aborter(res, msg, ignore=[]):
+  if res != 0 and res not in ignore:
+    # Convert a negative error code to a positive unsigned one, which is
+    # now NTSTATUSes appear in documentation.
+    if res < 0:
+      res += 0x100000000
+    msg = '{:08X} : {}'.format(res, msg)
+    raise WinError(msg, res)
+
+IID_Data4_Type = c_ubyte * 8
+
+class IID(Structure):
+  _fields_ = [
+      ("Data1", c_uint),
+      ("Data2", c_ushort),
+      ("Data3", c_ushort),
+      ("Data4", IID_Data4_Type)
+  ]
+
+c_ulong_p = POINTER(c_ulong)
+c_ulong64_p = POINTER(c_ulonglong)
diff --git a/debuginfo-tests/dexter/dex/debugger/lldb/LLDB.py b/debuginfo-tests/dexter/dex/debugger/lldb/LLDB.py
new file mode 100644
index 00000000000..425d3c2adb1
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/lldb/LLDB.py
@@ -0,0 +1,244 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Interface for communicating with the LLDB debugger via its python interface.
+"""
+
+import imp
+import os
+from subprocess import CalledProcessError, check_output, STDOUT
+import sys
+
+from dex.debugger.DebuggerBase import DebuggerBase
+from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR
+from dex.dextIR import StackFrame, SourceLocation, ProgramState
+from dex.utils.Exceptions import DebuggerException, LoadDebuggerException
+from dex.utils.ReturnCode import ReturnCode
+
+
+class LLDB(DebuggerBase):
+    def __init__(self, context, *args):
+        self.lldb_executable = context.options.lldb_executable
+        self._debugger = None
+        self._target = None
+        self._process = None
+        self._thread = None
+        super(LLDB, self).__init__(context, *args)
+
+    def _custom_init(self):
+        self._debugger = self._interface.SBDebugger.Create()
+        self._debugger.SetAsync(False)
+        self._target = self._debugger.CreateTargetWithFileAndArch(
+            self.context.options.executable, self.context.options.arch)
+        if not self._target:
+            raise LoadDebuggerException(
+                'could not create target for executable "{}" with arch:{}'.
+                format(self.context.options.executable,
+                       self.context.options.arch))
+
+    def _custom_exit(self):
+        if getattr(self, '_process', None):
+            self._process.Kill()
+        if getattr(self, '_debugger', None) and getattr(self, '_target', None):
+            self._debugger.DeleteTarget(self._target)
+
+    def _translate_stop_reason(self, reason):
+        if reason == self._interface.eStopReasonNone:
+            return None
+        if reason == self._interface.eStopReasonBreakpoint:
+            return StopReason.BREAKPOINT
+        if reason == self._interface.eStopReasonPlanComplete:
+            return StopReason.STEP
+        if reason == self._interface.eStopReasonThreadExiting:
+            return StopReason.PROGRAM_EXIT
+        if reason == self._interface.eStopReasonException:
+            return StopReason.ERROR
+        return StopReason.OTHER
+
+    def _load_interface(self):
+        try:
+            args = [self.lldb_executable, '-P']
+            pythonpath = check_output(
+                args, stderr=STDOUT).rstrip().decode('utf-8')
+        except CalledProcessError as e:
+            raise LoadDebuggerException(str(e), sys.exc_info())
+        except OSError as e:
+            raise LoadDebuggerException(
+                '{} ["{}"]'.format(e.strerror, self.lldb_executable),
+                sys.exc_info())
+
+        if not os.path.isdir(pythonpath):
+            raise LoadDebuggerException(
+                'path "{}" does not exist [result of {}]'.format(
+                    pythonpath, args), sys.exc_info())
+
+        try:
+            module_info = imp.find_module('lldb', [pythonpath])
+            return imp.load_module('lldb', *module_info)
+        except ImportError as e:
+            msg = str(e)
+            if msg.endswith('not a valid Win32 application.'):
+                msg = '{} [Are you mixing 32-bit and 64-bit binaries?]'.format(
+                    msg)
+            raise LoadDebuggerException(msg, sys.exc_info())
+
+    @classmethod
+    def get_name(cls):
+        return 'lldb'
+
+    @classmethod
+    def get_option_name(cls):
+        return 'lldb'
+
+    @property
+    def version(self):
+        try:
+            return self._interface.SBDebugger_GetVersionString()
+        except AttributeError:
+            return None
+
+    def clear_breakpoints(self):
+        self._target.DeleteAllBreakpoints()
+
+    def add_breakpoint(self, file_, line):
+        if not self._target.BreakpointCreateByLocation(file_, line):
+            raise LoadDebuggerException(
+                'could not add breakpoint [{}:{}]'.format(file_, line))
+
+    def launch(self):
+        self._process = self._target.LaunchSimple(None, None, os.getcwd())
+        if not self._process or self._process.GetNumThreads() == 0:
+            raise DebuggerException('could not launch process')
+        if self._process.GetNumThreads() != 1:
+            raise DebuggerException('multiple threads not supported')
+        self._thread = self._process.GetThreadAtIndex(0)
+        assert self._thread, (self._process, self._thread)
+
+    def step(self):
+        self._thread.StepInto()
+
+    def go(self) -> ReturnCode:
+        self._process.Continue()
+        return ReturnCode.OK
+
+    def get_step_info(self):
+        frames = []
+        state_frames = []
+
+        for i in range(0, self._thread.GetNumFrames()):
+            sb_frame = self._thread.GetFrameAtIndex(i)
+            sb_line = sb_frame.GetLineEntry()
+            sb_filespec = sb_line.GetFileSpec()
+
+            try:
+                path = os.path.join(sb_filespec.GetDirectory(),
+                                    sb_filespec.GetFilename())
+            except (AttributeError, TypeError):
+                path = None
+
+            function = self._sanitize_function_name(sb_frame.GetFunctionName())
+
+            loc_dict = {
+                'path': path,
+                'lineno': sb_line.GetLine(),
+                'column': sb_line.GetColumn()
+            }
+            loc = LocIR(**loc_dict)
+
+            frame = FrameIR(
+                function=function, is_inlined=sb_frame.IsInlined(), loc=loc)
+
+            if any(
+                    name in (frame.function or '')  # pylint: disable=no-member
+                    for name in self.frames_below_main):
+                break
+
+            frames.append(frame)
+
+            state_frame = StackFrame(function=frame.function,
+                                     is_inlined=frame.is_inlined,
+                                     location=SourceLocation(**loc_dict),
+                                     watches={})
+            for expr in map(
+                lambda watch, idx=i: self.evaluate_expression(watch, idx),
+                self.watches):
+                state_frame.watches[expr.expression] = expr
+            state_frames.append(state_frame)
+
+        if len(frames) == 1 and frames[0].function is None:
+            frames = []
+            state_frames = []
+
+        reason = self._translate_stop_reason(self._thread.GetStopReason())
+
+        return StepIR(
+            step_index=self.step_index, frames=frames, stop_reason=reason,
+            program_state=ProgramState(state_frames))
+
+    @property
+    def is_running(self):
+        # We're not running in async mode so this is always False.
+        return False
+
+    @property
+    def is_finished(self):
+        return not self._thread.GetFrameAtIndex(0)
+
+    @property
+    def frames_below_main(self):
+        return ['__scrt_common_main_seh', '__libc_start_main']
+
+    def evaluate_expression(self, expression, frame_idx=0) -> ValueIR:
+        result = self._thread.GetFrameAtIndex(frame_idx
+            ).EvaluateExpression(expression)
+        error_string = str(result.error)
+
+        value = result.value
+        could_evaluate = not any(s in error_string for s in [
+            "Can't run the expression locally",
+            "use of undeclared identifier",
+            "no member named",
+            "Couldn't lookup symbols",
+            "reference to local variable",
+            "invalid use of 'this' outside of a non-static member function",
+        ])
+
+        is_optimized_away = any(s in error_string for s in [
+            'value may have been optimized out',
+        ])
+
+        is_irretrievable = any(s in error_string for s in [
+            "couldn't get the value of variable",
+            "couldn't read its memory",
+            "couldn't read from memory",
+            "Cannot access memory at address",
+            "invalid address (fault address:",
+        ])
+
+        if could_evaluate and not is_irretrievable and not is_optimized_away:
+            assert error_string == 'success', (error_string, expression, value)
+            # assert result.value is not None, (result.value, expression)
+
+        if error_string == 'success':
+            error_string = None
+
+        # attempt to find expression as a variable, if found, take the variable
+        # obj's type information as it's 'usually' more accurate.
+        var_result = self._thread.GetFrameAtIndex(frame_idx).FindVariable(expression)
+        if str(var_result.error) == 'success':
+            type_name = var_result.type.GetDisplayTypeName()
+        else:
+            type_name = result.type.GetDisplayTypeName()
+
+        return ValueIR(
+            expression=expression,
+            value=value,
+            type_name=type_name,
+            error_string=error_string,
+            could_evaluate=could_evaluate,
+            is_optimized_away=is_optimized_away,
+            is_irretrievable=is_irretrievable,
+        )
diff --git a/debuginfo-tests/dexter/dex/debugger/lldb/__init__.py b/debuginfo-tests/dexter/dex/debugger/lldb/__init__.py
new file mode 100644
index 00000000000..1282f2ddc90
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/lldb/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.debugger.lldb.LLDB import LLDB
diff --git a/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio.py b/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio.py
new file mode 100644
index 00000000000..596dc31ab4a
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio.py
@@ -0,0 +1,224 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Interface for communicating with the Visual Studio debugger via DTE."""
+
+import abc
+import imp
+import os
+import sys
+
+from dex.debugger.DebuggerBase import DebuggerBase
+from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR
+from dex.dextIR import StackFrame, SourceLocation, ProgramState
+from dex.utils.Exceptions import Error, LoadDebuggerException
+from dex.utils.ReturnCode import ReturnCode
+
+
+def _load_com_module():
+    try:
+        module_info = imp.find_module(
+            'ComInterface',
+            [os.path.join(os.path.dirname(__file__), 'windows')])
+        return imp.load_module('ComInterface', *module_info)
+    except ImportError as e:
+        raise LoadDebuggerException(e, sys.exc_info())
+
+
+class VisualStudio(DebuggerBase, metaclass=abc.ABCMeta):  # pylint: disable=abstract-method
+
+    # Constants for results of Debugger.CurrentMode
+    # (https://msdn.microsoft.com/en-us/library/envdte.debugger.currentmode.aspx)
+    dbgDesignMode = 1
+    dbgBreakMode = 2
+    dbgRunMode = 3
+
+    def __init__(self, *args):
+        self.com_module = None
+        self._debugger = None
+        self._solution = None
+        self._fn_step = None
+        self._fn_go = None
+        super(VisualStudio, self).__init__(*args)
+
+    def _custom_init(self):
+        try:
+            self._debugger = self._interface.Debugger
+            self._debugger.HexDisplayMode = False
+
+            self._interface.MainWindow.Visible = (
+                self.context.options.show_debugger)
+
+            self._solution = self._interface.Solution
+            self._solution.Create(self.context.working_directory.path,
+                                  'DexterSolution')
+
+            try:
+                self._solution.AddFromFile(self._project_file)
+            except OSError:
+                raise LoadDebuggerException(
+                    'could not debug the specified executable', sys.exc_info())
+
+            self._fn_step = self._debugger.StepInto
+            self._fn_go = self._debugger.Go
+
+        except AttributeError as e:
+            raise LoadDebuggerException(str(e), sys.exc_info())
+
+    def _custom_exit(self):
+        if self._interface:
+            self._interface.Quit()
+
+    @property
+    def _project_file(self):
+        return self.context.options.executable
+
+    @abc.abstractproperty
+    def _dte_version(self):
+        pass
+
+    @property
+    def _location(self):
+        bp = self._debugger.BreakpointLastHit
+        return {
+            'path': getattr(bp, 'File', None),
+            'lineno': getattr(bp, 'FileLine', None),
+            'column': getattr(bp, 'FileColumn', None)
+        }
+
+    @property
+    def _mode(self):
+        return self._debugger.CurrentMode
+
+    def _load_interface(self):
+        self.com_module = _load_com_module()
+        return self.com_module.DTE(self._dte_version)
+
+    @property
+    def version(self):
+        try:
+            return self._interface.Version
+        except AttributeError:
+            return None
+
+    def clear_breakpoints(self):
+        for bp in self._debugger.Breakpoints:
+            bp.Delete()
+
+    def add_breakpoint(self, file_, line):
+        self._debugger.Breakpoints.Add('', file_, line)
+
+    def launch(self):
+        self.step()
+
+    def step(self):
+        self._fn_step()
+
+    def go(self) -> ReturnCode:
+        self._fn_go()
+        return ReturnCode.OK
+
+    def set_current_stack_frame(self, idx: int = 0):
+        thread = self._debugger.CurrentThread
+        stack_frames = thread.StackFrames
+        try:
+            stack_frame = stack_frames[idx]
+            self._debugger.CurrentStackFrame = stack_frame.raw
+        except IndexError:
+            raise Error('attempted to access stack frame {} out of {}'
+                .format(idx, len(stack_frames)))
+
+    def get_step_info(self):
+        thread = self._debugger.CurrentThread
+        stackframes = thread.StackFrames
+
+        frames = []
+        state_frames = []
+
+
+        for idx, sf in enumerate(stackframes):
+            frame = FrameIR(
+                function=self._sanitize_function_name(sf.FunctionName),
+                is_inlined=sf.FunctionName.startswith('[Inline Frame]'),
+                loc=LocIR(path=None, lineno=None, column=None))
+
+            fname = frame.function or ''  # pylint: disable=no-member
+            if any(name in fname for name in self.frames_below_main):
+                break
+
+
+            state_frame = StackFrame(function=frame.function,
+                                     is_inlined=frame.is_inlined,
+                                     watches={})
+
+            for watch in self.watches:
+                state_frame.watches[watch] = self.evaluate_expression(
+                    watch, idx)
+
+
+            state_frames.append(state_frame)
+            frames.append(frame)
+
+        loc = LocIR(**self._location)
+        if frames:
+            frames[0].loc = loc
+            state_frames[0].location = SourceLocation(**self._location)
+
+        reason = StopReason.BREAKPOINT
+        if loc.path is None:  # pylint: disable=no-member
+            reason = StopReason.STEP
+
+        program_state = ProgramState(frames=state_frames)
+
+        return StepIR(
+            step_index=self.step_index, frames=frames, stop_reason=reason,
+            program_state=program_state)
+
+    @property
+    def is_running(self):
+        return self._mode == VisualStudio.dbgRunMode
+
+    @property
+    def is_finished(self):
+        return self._mode == VisualStudio.dbgDesignMode
+
+    @property
+    def frames_below_main(self):
+        return [
+            '[Inline Frame] invoke_main', '__scrt_common_main_seh',
+            '__tmainCRTStartup', 'mainCRTStartup'
+        ]
+
+    def evaluate_expression(self, expression, frame_idx=0) -> ValueIR:
+        self.set_current_stack_frame(frame_idx)
+        result = self._debugger.GetExpression(expression)
+        self.set_current_stack_frame(0)
+        value = result.Value
+
+        is_optimized_away = any(s in value for s in [
+            'Variable is optimized away and not available',
+            'Value is not available, possibly due to optimization',
+        ])
+
+        is_irretrievable = any(s in value for s in [
+            '???',
+            '<Unable to read memory>',
+        ])
+
+        # an optimized away value is still counted as being able to be
+        # evaluated.
+        could_evaluate = (result.IsValidValue or is_optimized_away
+                          or is_irretrievable)
+
+        return ValueIR(
+            expression=expression,
+            value=value,
+            type_name=result.Type,
+            error_string=None,
+            is_optimized_away=is_optimized_away,
+            could_evaluate=could_evaluate,
+            is_irretrievable=is_irretrievable,
+        )
diff --git a/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio2015.py b/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio2015.py
new file mode 100644
index 00000000000..af6edcd2451
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio2015.py
@@ -0,0 +1,23 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Specializations for the Visual Studio 2015 interface."""
+
+from dex.debugger.visualstudio.VisualStudio import VisualStudio
+
+
+class VisualStudio2015(VisualStudio):
+    @classmethod
+    def get_name(cls):
+        return 'Visual Studio 2015'
+
+    @classmethod
+    def get_option_name(cls):
+        return 'vs2015'
+
+    @property
+    def _dte_version(self):
+        return 'VisualStudio.DTE.14.0'
diff --git a/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio2017.py b/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio2017.py
new file mode 100644
index 00000000000..f2f757546f3
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio2017.py
@@ -0,0 +1,23 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Specializations for the Visual Studio 2017 interface."""
+
+from dex.debugger.visualstudio.VisualStudio import VisualStudio
+
+
+class VisualStudio2017(VisualStudio):
+    @classmethod
+    def get_name(cls):
+        return 'Visual Studio 2017'
+
+    @classmethod
+    def get_option_name(cls):
+        return 'vs2017'
+
+    @property
+    def _dte_version(self):
+        return 'VisualStudio.DTE.15.0'
diff --git a/debuginfo-tests/dexter/dex/debugger/visualstudio/__init__.py b/debuginfo-tests/dexter/dex/debugger/visualstudio/__init__.py
new file mode 100644
index 00000000000..35fefacf22f
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/visualstudio/__init__.py
@@ -0,0 +1,9 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.debugger.visualstudio.VisualStudio2015 import VisualStudio2015
+from dex.debugger.visualstudio.VisualStudio2017 import VisualStudio2017
diff --git a/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/ComInterface.py b/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/ComInterface.py
new file mode 100644
index 00000000000..0bce5b533e7
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/ComInterface.py
@@ -0,0 +1,119 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Communication via the Windows COM interface."""
+
+import inspect
+import time
+import sys
+
+# pylint: disable=import-error
+import win32com.client as com
+import win32api
+# pylint: enable=import-error
+
+from dex.utils.Exceptions import LoadDebuggerException
+
+_com_error = com.pywintypes.com_error  # pylint: disable=no-member
+
+
+def get_file_version(file_):
+    try:
+        info = win32api.GetFileVersionInfo(file_, '\\')
+        ms = info['FileVersionMS']
+        ls = info['FileVersionLS']
+        return '.'.join(
+            str(s) for s in [
+                win32api.HIWORD(ms),
+                win32api.LOWORD(ms),
+                win32api.HIWORD(ls),
+                win32api.LOWORD(ls)
+            ])
+    except com.pywintypes.error:  # pylint: disable=no-member
+        return 'no versioninfo present'
+
+
+def _handle_com_error(e):
+    exc = sys.exc_info()
+    msg = win32api.FormatMessage(e.hresult)
+    try:
+        msg = msg.decode('CP1251')
+    except AttributeError:
+        pass
+    msg = msg.strip()
+    return msg, exc
+
+
+class ComObject(object):
+    """Wrap a raw Windows COM object in a class that implements auto-retry of
+    failed calls.
+    """
+
+    def __init__(self, raw):
+        assert not isinstance(raw, ComObject), raw
+        self.__dict__['raw'] = raw
+
+    def __str__(self):
+        return self._call(self.raw.__str__)
+
+    def __getattr__(self, key):
+        if key in self.__dict__:
+            return self.__dict__[key]
+        return self._call(self.raw.__getattr__, key)
+
+    def __setattr__(self, key, val):
+        if key in self.__dict__:
+            self.__dict__[key] = val
+        self._call(self.raw.__setattr__, key, val)
+
+    def __getitem__(self, key):
+        return self._call(self.raw.__getitem__, key)
+
+    def __setitem__(self, key, val):
+        self._call(self.raw.__setitem__, key, val)
+
+    def __call__(self, *args):
+        return self._call(self.raw, *args)
+
+    @classmethod
+    def _call(cls, fn, *args):
+        """COM calls tend to randomly fail due to thread sync issues.
+        The Microsoft recommended solution is to set up a message filter object
+        to automatically retry failed calls, but this seems prohibitively hard
+        from python, so this is a custom solution to do the same thing.
+        All COM accesses should go through this function.
+        """
+        ex = AssertionError("this should never be raised!")
+
+        assert (inspect.isfunction(fn) or inspect.ismethod(fn)
+                or inspect.isbuiltin(fn)), (fn, type(fn))
+        retries = ([0] * 50) + ([1] * 5)
+        for r in retries:
+            try:
+                try:
+                    result = fn(*args)
+                    if inspect.ismethod(result) or 'win32com' in str(
+                            result.__class__):
+                        result = ComObject(result)
+                    return result
+                except _com_error as e:
+                    msg, _ = _handle_com_error(e)
+                    e = WindowsError(msg)  # pylint: disable=undefined-variable
+                    raise e
+            except (AttributeError, TypeError, OSError) as e:
+                ex = e
+                time.sleep(r)
+        raise ex
+
+
+class DTE(ComObject):
+    def __init__(self, class_string):
+        try:
+            super(DTE, self).__init__(com.DispatchEx(class_string))
+        except _com_error as e:
+            msg, exc = _handle_com_error(e)
+            raise LoadDebuggerException(
+                '{} [{}]'.format(msg, class_string), orig_exception=exc)
diff --git a/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/__init__.py b/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/__init__.py
new file mode 100644
index 00000000000..1194affd891
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/__init__.py
@@ -0,0 +1,6 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
diff --git a/debuginfo-tests/dexter/dex/dextIR/BuilderIR.py b/debuginfo-tests/dexter/dex/dextIR/BuilderIR.py
new file mode 100644
index 00000000000..b94a1fb7e81
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/BuilderIR.py
@@ -0,0 +1,16 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+
+class BuilderIR:
+    """Data class which represents the compiler related options passed to Dexter
+    """
+
+    def __init__(self, name: str, cflags: str, ldflags: str):
+        self.name = name
+        self.cflags = cflags
+        self.ldflags = ldflags
diff --git a/debuginfo-tests/dexter/dex/dextIR/DebuggerIR.py b/debuginfo-tests/dexter/dex/dextIR/DebuggerIR.py
new file mode 100644
index 00000000000..5956db602b4
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/DebuggerIR.py
@@ -0,0 +1,14 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+
+class DebuggerIR:
+    """Data class which represents a debugger."""
+
+    def __init__(self, name: str, version: str):
+        self.name = name
+        self.version = version
diff --git a/debuginfo-tests/dexter/dex/dextIR/DextIR.py b/debuginfo-tests/dexter/dex/dextIR/DextIR.py
new file mode 100644
index 00000000000..7638e8b4ab7
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/DextIR.py
@@ -0,0 +1,129 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+from collections import OrderedDict
+import os
+from typing import List
+
+from dex.dextIR.BuilderIR import BuilderIR
+from dex.dextIR.DebuggerIR import DebuggerIR
+from dex.dextIR.StepIR import StepIR, StepKind
+
+
+def _step_kind_func(context, step):
+    if (step.current_location.path is None or
+        not os.path.exists(step.current_location.path)):
+        return StepKind.FUNC_UNKNOWN
+
+    if any(os.path.samefile(step.current_location.path, f)
+           for f in context.options.source_files):
+        return StepKind.FUNC
+
+    return StepKind.FUNC_EXTERNAL
+
+
+class DextIR:
+    """A full Dexter test report.
+
+    This is composed of all the other *IR classes. They are used together to
+    record Dexter inputs and the resultant debugger steps, providing a single
+    high level access container.
+
+    The Heuristic class works with dexter commands and the generated DextIR to
+    determine the debugging score for a given test.
+
+    Args:
+        commands: { name (str), commands (list[CommandIR])
+    """
+
+    def __init__(self,
+                 dexter_version: str,
+                 executable_path: str,
+                 source_paths: List[str],
+                 builder: BuilderIR = None,
+                 debugger: DebuggerIR = None,
+                 commands: OrderedDict = None):
+        self.dexter_version = dexter_version
+        self.executable_path = executable_path
+        self.source_paths = source_paths
+        self.builder = builder
+        self.debugger = debugger
+        self.commands = commands
+        self.steps: List[StepIR] = []
+
+    def __str__(self):
+        colors = 'rgby'
+        st = '## BEGIN ##\n'
+        color_idx = 0
+        for step in self.steps:
+            if step.step_kind in (StepKind.FUNC, StepKind.FUNC_EXTERNAL,
+                                  StepKind.FUNC_UNKNOWN):
+                color_idx += 1
+
+            color = colors[color_idx % len(colors)]
+            st += '<{}>{}</>\n'.format(color, step)
+        st += '## END ({} step{}) ##\n'.format(
+            self.num_steps, '' if self.num_steps == 1 else 's')
+        return st
+
+    @property
+    def num_steps(self):
+        return len(self.steps)
+
+    def _get_prev_step_in_this_frame(self, step):
+        """Find the most recent step in the same frame as `step`.
+
+        Returns:
+            StepIR or None if there is no previous step in this frame.
+        """
+        return next((s for s in reversed(self.steps)
+            if s.current_function == step.current_function
+            and s.num_frames == step.num_frames), None)
+
+    def _get_new_step_kind(self, context, step):
+        if step.current_function is None:
+            return StepKind.UNKNOWN
+
+        if len(self.steps) == 0:
+            return _step_kind_func(context, step)
+
+        prev_step = self.steps[-1]
+
+        if prev_step.current_function is None:
+            return StepKind.UNKNOWN
+
+        if prev_step.num_frames < step.num_frames:
+            return _step_kind_func(context, step)
+
+        if prev_step.num_frames > step.num_frames:
+            frame_step = self._get_prev_step_in_this_frame(step)
+            prev_step = frame_step if frame_step is not None else prev_step
+
+        # We're in the same func as prev step, check lineo.
+        if prev_step.current_location.lineno > step.current_location.lineno:
+            return StepKind.VERTICAL_BACKWARD
+
+        if prev_step.current_location.lineno < step.current_location.lineno:
+            return StepKind.VERTICAL_FORWARD
+
+        # We're on the same line as prev step, check column.
+        if prev_step.current_location.column > step.current_location.column:
+            return StepKind.HORIZONTAL_BACKWARD
+
+        if prev_step.current_location.column < step.current_location.column:
+            return StepKind.HORIZONTAL_FORWARD
+
+        # This step is in exactly the same location as the prev step.
+        return StepKind.SAME
+
+    def new_step(self, context, step):
+        assert isinstance(step, StepIR), type(step)
+        step.step_kind = self._get_new_step_kind(context, step)
+        self.steps.append(step)
+        return step
+
+    def clear_steps(self):
+        self.steps.clear()
diff --git a/debuginfo-tests/dexter/dex/dextIR/FrameIR.py b/debuginfo-tests/dexter/dex/dextIR/FrameIR.py
new file mode 100644
index 00000000000..a2c0523b47b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/FrameIR.py
@@ -0,0 +1,16 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+from dex.dextIR.LocIR import LocIR
+
+
+class FrameIR:
+    """Data class which represents a frame in the call stack"""
+
+    def __init__(self, function: str, is_inlined: bool, loc: LocIR):
+        self.function = function
+        self.is_inlined = is_inlined
+        self.loc = loc
diff --git a/debuginfo-tests/dexter/dex/dextIR/LocIR.py b/debuginfo-tests/dexter/dex/dextIR/LocIR.py
new file mode 100644
index 00000000000..52a56a8fe80
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/LocIR.py
@@ -0,0 +1,45 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+import os
+
+
+class LocIR:
+    """Data class which represents a source location."""
+
+    def __init__(self, path: str, lineno: int, column: int):
+        if path:
+            path = os.path.normcase(path)
+        self.path = path
+        self.lineno = lineno
+        self.column = column
+
+    def __str__(self):
+        return '{}({}:{})'.format(self.path, self.lineno, self.column)
+
+    def __eq__(self, rhs):
+        return (os.path.exists(self.path) and os.path.exists(rhs.path)
+                and os.path.samefile(self.path, rhs.path)
+                and self.lineno == rhs.lineno
+                and self.column == rhs.column)
+
+    def __lt__(self, rhs):
+        if self.path != rhs.path:
+            return False
+
+        if self.lineno == rhs.lineno:
+            return self.column < rhs.column
+
+        return self.lineno < rhs.lineno
+
+    def __gt__(self, rhs):
+        if self.path != rhs.path:
+            return False
+
+        if self.lineno == rhs.lineno:
+            return self.column > rhs.column
+
+        return self.lineno > rhs.lineno
diff --git a/debuginfo-tests/dexter/dex/dextIR/ProgramState.py b/debuginfo-tests/dexter/dex/dextIR/ProgramState.py
new file mode 100644
index 00000000000..4f05189aed8
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/ProgramState.py
@@ -0,0 +1,117 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Set of data classes for representing the complete debug program state at a
+fixed point in execution.
+"""
+
+import os
+
+from collections import OrderedDict
+from typing import List
+
+class SourceLocation:
+    def __init__(self, path: str = None, lineno: int = None, column: int = None):
+        if path:
+            path = os.path.normcase(path)
+        self.path = path
+        self.lineno = lineno
+        self.column = column
+
+    def __str__(self):
+        return '{}({}:{})'.format(self.path, self.lineno, self.column)
+
+    def match(self, other) -> bool:
+        """Returns true iff all the properties that appear in `self` have the
+        same value in `other`, but not necessarily vice versa.
+        """
+        if not other or not isinstance(other, SourceLocation):
+            return False
+
+        if self.path and (self.path != other.path):
+            return False
+
+        if self.lineno and (self.lineno != other.lineno):
+            return False
+
+        if self.column and (self.column != other.column):
+            return False
+
+        return True
+
+
+class StackFrame:
+    def __init__(self,
+                 function: str = None,
+                 is_inlined: bool = None,
+                 location: SourceLocation = None,
+                 watches: OrderedDict = None):
+        if watches is None:
+            watches = {}
+
+        self.function = function
+        self.is_inlined = is_inlined
+        self.location = location
+        self.watches = watches
+
+    def __str__(self):
+        return '{}{}: {} | {}'.format(
+            self.function,
+            ' (inlined)' if self.is_inlined else '',
+            self.location,
+            {k: str(self.watches[k]) for k in self.watches})
+
+    def match(self, other) -> bool:
+        """Returns true iff all the properties that appear in `self` have the
+        same value in `other`, but not necessarily vice versa.
+        """
+        if not other or not isinstance(other, StackFrame):
+            return False
+
+        if self.location and not self.location.match(other.location):
+            return False
+
+        if self.watches:
+            for name in iter(self.watches):
+                try:
+                    if isinstance(self.watches[name], dict):
+                        for attr in iter(self.watches[name]):
+                            if (getattr(other.watches[name], attr, None) !=
+                                    self.watches[name][attr]):
+                                return False
+                    else:
+                        if other.watches[name].value != self.watches[name]:
+                            return False
+                except KeyError:
+                    return False
+
+        return True
+
+class ProgramState:
+    def __init__(self, frames: List[StackFrame] = None):
+        self.frames = frames
+
+    def __str__(self):
+        return '\n'.join(map(
+            lambda enum: 'Frame {}: {}'.format(enum[0], enum[1]),
+            enumerate(self.frames)))
+
+    def match(self, other) -> bool:
+        """Returns true iff all the properties that appear in `self` have the
+        same value in `other`, but not necessarily vice versa.
+        """
+        if not other or not isinstance(other, ProgramState):
+            return False
+
+        if self.frames:
+            for idx, frame in enumerate(self.frames):
+                try:
+                    if not frame.match(other.frames[idx]):
+                        return False
+                except (IndexError, KeyError):
+                    return False
+
+        return True
diff --git a/debuginfo-tests/dexter/dex/dextIR/StepIR.py b/debuginfo-tests/dexter/dex/dextIR/StepIR.py
new file mode 100644
index 00000000000..8111968efe9
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/StepIR.py
@@ -0,0 +1,103 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Classes which are used to represent debugger steps."""
+
+import json
+
+from collections import OrderedDict
+from typing import List
+from enum import Enum
+from dex.dextIR.FrameIR import FrameIR
+from dex.dextIR.LocIR import LocIR
+from dex.dextIR.ProgramState import ProgramState
+
+
+class StopReason(Enum):
+    BREAKPOINT = 0
+    STEP = 1
+    PROGRAM_EXIT = 2
+    ERROR = 3
+    OTHER = 4
+
+
+class StepKind(Enum):
+    FUNC = 0
+    FUNC_EXTERNAL = 1
+    FUNC_UNKNOWN = 2
+    VERTICAL_FORWARD = 3
+    SAME = 4
+    VERTICAL_BACKWARD = 5
+    UNKNOWN = 6
+    HORIZONTAL_FORWARD = 7
+    HORIZONTAL_BACKWARD = 8
+
+
+class StepIR:
+    """A debugger step.
+
+    Args:
+        watches (OrderedDict): { expression (str), result (ValueIR) }
+    """
+
+    def __init__(self,
+                 step_index: int,
+                 stop_reason: StopReason,
+                 frames: List[FrameIR],
+                 step_kind: StepKind = None,
+                 watches: OrderedDict = None,
+                 program_state: ProgramState = None):
+        self.step_index = step_index
+        self.step_kind = step_kind
+        self.stop_reason = stop_reason
+        self.program_state = program_state
+
+        if frames is None:
+            frames = []
+        self.frames = frames
+
+        if watches is None:
+            watches = {}
+        self.watches = watches
+
+    def __str__(self):
+        try:
+            frame = self.current_frame
+            frame_info = (frame.function, frame.loc.path, frame.loc.lineno,
+                          frame.loc.column)
+        except AttributeError:
+            frame_info = (None, None, None, None)
+
+        step_info = (self.step_index, ) + frame_info + (
+            str(self.stop_reason), str(self.step_kind),
+                                    [w for w in self.watches])
+
+        return '{}{}'.format('.   ' * (self.num_frames - 1),
+                             json.dumps(step_info))
+
+    @property
+    def num_frames(self):
+        return len(self.frames)
+
+    @property
+    def current_frame(self):
+        if not len(self.frames):
+            return None
+        return self.frames[0]
+
+    @property
+    def current_function(self):
+        try:
+            return self.current_frame.function
+        except AttributeError:
+            return None
+
+    @property
+    def current_location(self):
+        try:
+            return self.current_frame.loc
+        except AttributeError:
+            return LocIR(path=None, lineno=None, column=None)
diff --git a/debuginfo-tests/dexter/dex/dextIR/ValueIR.py b/debuginfo-tests/dexter/dex/dextIR/ValueIR.py
new file mode 100644
index 00000000000..9d532acbb21
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/ValueIR.py
@@ -0,0 +1,38 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+
+class ValueIR:
+    """Data class to store the result of an expression evaluation."""
+
+    def __init__(self,
+                 expression: str,
+                 value: str,
+                 type_name: str,
+                 could_evaluate: bool,
+                 error_string: str = None,
+                 is_optimized_away: bool = False,
+                 is_irretrievable: bool = False):
+        self.expression = expression
+        self.value = value
+        self.type_name = type_name
+        self.could_evaluate = could_evaluate
+        self.error_string = error_string
+        self.is_optimized_away = is_optimized_away
+        self.is_irretrievable = is_irretrievable
+
+    def __str__(self):
+        prefix = '"{}": '.format(self.expression)
+        if self.error_string is not None:
+            return prefix + self.error_string
+        if self.value is not None:
+            return prefix + '({}) {}'.format(self.type_name, self.value)
+        return (prefix +
+                'could_evaluate: {}; irretrievable: {}; optimized_away: {};'
+                    .format(self.could_evaluate, self.is_irretrievable,
+                            self.is_optimized_away))
+
diff --git a/debuginfo-tests/dexter/dex/dextIR/__init__.py b/debuginfo-tests/dexter/dex/dextIR/__init__.py
new file mode 100644
index 00000000000..463a2c13716
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/dextIR/__init__.py
@@ -0,0 +1,17 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""dextIR: DExTer Intermediate Representation of DExTer's debugger trace output.
+"""
+
+from dex.dextIR.BuilderIR import BuilderIR
+from dex.dextIR.DextIR import DextIR
+from dex.dextIR.DebuggerIR import DebuggerIR
+from dex.dextIR.FrameIR import FrameIR
+from dex.dextIR.LocIR import LocIR
+from dex.dextIR.StepIR import StepIR, StepKind, StopReason
+from dex.dextIR.ValueIR import ValueIR
+from dex.dextIR.ProgramState import ProgramState, SourceLocation, StackFrame
diff --git a/debuginfo-tests/dexter/dex/heuristic/Heuristic.py b/debuginfo-tests/dexter/dex/heuristic/Heuristic.py
new file mode 100644
index 00000000000..205b767a1ec
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/heuristic/Heuristic.py
@@ -0,0 +1,497 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Calculate a 'score' based on some dextIR.
+Assign penalties based on different commands to decrease the score.
+1.000 would be a perfect score.
+0.000 is the worst theoretical score possible.
+"""
+
+from collections import defaultdict, namedtuple, Counter
+import difflib
+import os
+from itertools import groupby
+from dex.command.StepValueInfo import StepValueInfo
+
+
+PenaltyCommand = namedtuple('PenaltyCommand', ['pen_dict', 'max_penalty'])
+# 'meta' field used in different ways by different things
+PenaltyInstance = namedtuple('PenaltyInstance', ['meta', 'the_penalty'])
+
+
+def add_heuristic_tool_arguments(parser):
+    parser.add_argument(
+        '--penalty-variable-optimized',
+        type=int,
+        default=3,
+        help='set the penalty multiplier for each'
+        ' occurrence of a variable that was optimized'
+        ' away',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-misordered-values',
+        type=int,
+        default=3,
+        help='set the penalty multiplier for each'
+        ' occurrence of a misordered value.',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-irretrievable',
+        type=int,
+        default=4,
+        help='set the penalty multiplier for each'
+        " occurrence of a variable that couldn't"
+        ' be retrieved',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-not-evaluatable',
+        type=int,
+        default=5,
+        help='set the penalty multiplier for each'
+        " occurrence of a variable that couldn't"
+        ' be evaluated',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-missing-values',
+        type=int,
+        default=6,
+        help='set the penalty multiplier for each missing'
+        ' value',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-incorrect-values',
+        type=int,
+        default=7,
+        help='set the penalty multiplier for each'
+        ' occurrence of an unexpected value.',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-unreachable',
+        type=int,
+        default=4,  # XXX XXX XXX selected by random
+        help='set the penalty for each line stepped onto that should'
+        ' have been unreachable.',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-misordered-steps',
+        type=int,
+        default=2,  # XXX XXX XXX selected by random
+        help='set the penalty for differences in the order of steps'
+        ' the program was expected to observe.',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-missing-step',
+        type=int,
+        default=4,  # XXX XXX XXX selected by random
+        help='set the penalty for the program skipping over a step.',
+        metavar='<int>')
+    parser.add_argument(
+        '--penalty-incorrect-program-state',
+        type=int,
+        default=4,  # XXX XXX XXX selected by random
+        help='set the penalty for the program never entering an expected state'
+        ' or entering an unexpected state.',
+        metavar='<int>')
+
+
+class Heuristic(object):
+    def __init__(self, context, steps):
+        self.context = context
+        self.penalties = {}
+
+        worst_penalty = max([
+            self.penalty_variable_optimized, self.penalty_irretrievable,
+            self.penalty_not_evaluatable, self.penalty_incorrect_values,
+            self.penalty_missing_values, self.penalty_unreachable,
+            self.penalty_missing_step, self.penalty_misordered_steps
+        ])
+
+        # Get DexExpectWatchType results.
+        try:
+            for command in steps.commands['DexExpectWatchType']:
+                command.eval(steps)
+                maximum_possible_penalty = min(3, len(
+                    command.values)) * worst_penalty
+                name, p = self._calculate_expect_watch_penalties(
+                    command, maximum_possible_penalty)
+                name = name + ' ExpectType'
+                self.penalties[name] = PenaltyCommand(p,
+                                                      maximum_possible_penalty)
+        except KeyError:
+            pass
+
+        # Get DexExpectWatchValue results.
+        try:
+            for command in steps.commands['DexExpectWatchValue']:
+                command.eval(steps)
+                maximum_possible_penalty = min(3, len(
+                    command.values)) * worst_penalty
+                name, p = self._calculate_expect_watch_penalties(
+                    command, maximum_possible_penalty)
+                name = name + ' ExpectValue'
+                self.penalties[name] = PenaltyCommand(p,
+                                                      maximum_possible_penalty)
+        except KeyError:
+            pass
+
+        try:
+            penalties = defaultdict(list)
+            maximum_possible_penalty_all = 0
+            for expect_state in steps.commands['DexExpectProgramState']:
+                success = expect_state.eval(steps)
+                p = 0 if success else self.penalty_incorrect_program_state
+
+                meta = 'expected {}: {}'.format(
+                    '{} times'.format(expect_state.times)
+                        if expect_state.times >= 0 else 'at least once',
+                    expect_state.program_state_text)
+
+                if success:
+                    meta = '<g>{}</>'.format(meta)
+
+                maximum_possible_penalty = self.penalty_incorrect_program_state
+                maximum_possible_penalty_all += maximum_possible_penalty
+                name = expect_state.program_state_text
+                penalties[meta] = [PenaltyInstance('{} times'.format(
+                    len(expect_state.encounters)), p)]
+            self.penalties['expected program states'] = PenaltyCommand(
+                penalties, maximum_possible_penalty_all)
+        except KeyError:
+            pass
+
+        # Get the total number of each step kind.
+        step_kind_counts = defaultdict(int)
+        for step in getattr(steps, 'steps'):
+            step_kind_counts[step.step_kind] += 1
+
+        # Get DexExpectStepKind results.
+        penalties = defaultdict(list)
+        maximum_possible_penalty_all = 0
+        try:
+            for command in steps.commands['DexExpectStepKind']:
+                command.eval()
+                # Cap the penalty at 2 * expected count or else 1
+                maximum_possible_penalty = max(command.count * 2, 1)
+                p = abs(command.count - step_kind_counts[command.name])
+                actual_penalty = min(p, maximum_possible_penalty)
+                key = ('{}'.format(command.name)
+                       if actual_penalty else '<g>{}</>'.format(command.name))
+                penalties[key] = [PenaltyInstance(p, actual_penalty)]
+                maximum_possible_penalty_all += maximum_possible_penalty
+            self.penalties['step kind differences'] = PenaltyCommand(
+                penalties, maximum_possible_penalty_all)
+        except KeyError:
+            pass
+
+        if 'DexUnreachable' in steps.commands:
+            cmds = steps.commands['DexUnreachable']
+            unreach_count = 0
+
+            # Find steps with unreachable in them
+            ureachs = [
+                s for s in steps.steps if 'DexUnreachable' in s.watches.keys()
+            ]
+
+            # There's no need to match up cmds with the actual watches
+            upen = self.penalty_unreachable
+
+            count = upen * len(ureachs)
+            if count != 0:
+                d = dict()
+                for x in ureachs:
+                    msg = 'line {} reached'.format(x.current_location.lineno)
+                    d[msg] = [PenaltyInstance(upen, upen)]
+            else:
+                d = {
+                    '<g>No unreachable lines seen</>': [PenaltyInstance(0, 0)]
+                }
+            total = PenaltyCommand(d, len(cmds) * upen)
+
+            self.penalties['unreachable lines'] = total
+
+        if 'DexExpectStepOrder' in steps.commands:
+            cmds = steps.commands['DexExpectStepOrder']
+
+            # Form a list of which line/cmd we _should_ have seen
+            cmd_num_lst = [(x, c.lineno) for c in cmds
+                                         for x in c.sequence]
+            # Order them by the sequence number
+            cmd_num_lst.sort(key=lambda t: t[0])
+            # Strip out sequence key
+            cmd_num_lst = [y for x, y in cmd_num_lst]
+
+            # Now do the same, but for the actually observed lines/cmds
+            ss = steps.steps
+            deso = [s for s in ss if 'DexExpectStepOrder' in s.watches.keys()]
+            deso = [s.watches['DexExpectStepOrder'] for s in deso]
+            # We rely on the steps remaining in order here
+            order_list = [int(x.expression) for x in deso]
+
+            # First off, check to see whether or not there are missing items
+            expected = Counter(cmd_num_lst)
+            seen = Counter(order_list)
+
+            unseen_line_dict = dict()
+            skipped_line_dict = dict()
+
+            mispen = self.penalty_missing_step
+            num_missing = 0
+            num_repeats = 0
+            for k, v in expected.items():
+                if k not in seen:
+                    msg = 'Line {} not seen'.format(k)
+                    unseen_line_dict[msg] = [PenaltyInstance(mispen, mispen)]
+                    num_missing += v
+                elif v > seen[k]:
+                    msg = 'Line {} skipped at least once'.format(k)
+                    skipped_line_dict[msg] = [PenaltyInstance(mispen, mispen)]
+                    num_missing += v - seen[k]
+                elif v < seen[k]:
+                    # Don't penalise unexpected extra sightings of a line
+                    # for now
+                    num_repeats = seen[k] - v
+                    pass
+
+            if len(unseen_line_dict) == 0:
+                pi = PenaltyInstance(0, 0)
+                unseen_line_dict['<g>All lines were seen</>'] = [pi]
+
+            if len(skipped_line_dict) == 0:
+                pi = PenaltyInstance(0, 0)
+                skipped_line_dict['<g>No lines were skipped</>'] = [pi]
+
+            total = PenaltyCommand(unseen_line_dict, len(expected) * mispen)
+            self.penalties['Unseen lines'] = total
+            total = PenaltyCommand(skipped_line_dict, len(expected) * mispen)
+            self.penalties['Skipped lines'] = total
+
+            ordpen = self.penalty_misordered_steps
+            cmd_num_lst = [str(x) for x in cmd_num_lst]
+            order_list = [str(x) for x in order_list]
+            lst = list(difflib.Differ().compare(cmd_num_lst, order_list))
+            diff_detail = Counter(l[0] for l in lst)
+
+            assert '?' not in diff_detail
+
+            # Diffs are hard to interpret; there are many algorithms for
+            # condensing them. Ignore all that, and just print out the changed
+            # sequences, it's up to the user to interpret what's going on.
+
+            def filt_lines(s, seg, e, key):
+                lst = [s]
+                for x in seg:
+                    if x[0] == key:
+                        lst.append(int(x[2:]))
+                lst.append(e)
+                return lst
+
+            diff_msgs = dict()
+
+            def reportdiff(start_idx, segment, end_idx):
+                msg = 'Order mismatch, expected linenos {}, saw {}'
+                expected_linenos = filt_lines(start_idx, segment, end_idx, '-')
+                seen_linenos = filt_lines(start_idx, segment, end_idx, '+')
+                msg = msg.format(expected_linenos, seen_linenos)
+                diff_msgs[msg] = [PenaltyInstance(ordpen, ordpen)]
+
+            # Group by changed segments.
+            start_expt_step = 0
+            end_expt_step = 0
+            to_print_lst = []
+            for k, subit in groupby(lst, lambda x: x[0] == ' '):
+                if k:  # Whitespace group
+                    nochanged = [x for x in subit]
+                    end_expt_step = int(nochanged[0][2:])
+                    if len(to_print_lst) > 0:
+                        reportdiff(start_expt_step, to_print_lst,
+                                   end_expt_step)
+                    start_expt_step = int(nochanged[-1][2:])
+                    to_print_lst = []
+                else:  # Diff group, save for printing
+                    to_print_lst = [x for x in subit]
+
+            # If there was a dangling different step, print that too.
+            if len(to_print_lst) > 0:
+                reportdiff(start_expt_step, to_print_lst, '[End]')
+
+            if len(diff_msgs) == 0:
+                diff_msgs['<g>No lines misordered</>'] = [
+                    PenaltyInstance(0, 0)
+                ]
+            total = PenaltyCommand(diff_msgs, len(cmd_num_lst) * ordpen)
+            self.penalties['Misordered lines'] = total
+
+        return
+
+    def _calculate_expect_watch_penalties(self, c, maximum_possible_penalty):
+        penalties = defaultdict(list)
+
+        if c.line_range[0] == c.line_range[-1]:
+            line_range = str(c.line_range[0])
+        else:
+            line_range = '{}-{}'.format(c.line_range[0], c.line_range[-1])
+
+        name = '{}:{} [{}]'.format(
+            os.path.basename(c.path), line_range, c.expression)
+
+        num_actual_watches = len(c.expected_watches) + len(
+            c.unexpected_watches)
+
+        penalty_available = maximum_possible_penalty
+
+        # Only penalize for missing values if we have actually seen a watch
+        # that's returned us an actual value at some point, or if we've not
+        # encountered the value at all.
+        if num_actual_watches or c.times_encountered == 0:
+            for v in c.missing_values:
+                current_penalty = min(penalty_available,
+                                      self.penalty_missing_values)
+                penalty_available -= current_penalty
+                penalties['missing values'].append(
+                    PenaltyInstance(v, current_penalty))
+
+        for v in c.encountered_values:
+            penalties['<g>expected encountered watches</>'].append(
+                PenaltyInstance(v, 0))
+
+        penalty_descriptions = [
+            (self.penalty_not_evaluatable, c.invalid_watches,
+             'could not evaluate'),
+            (self.penalty_variable_optimized, c.optimized_out_watches,
+             'result optimized away'),
+            (self.penalty_misordered_values, c.misordered_watches,
+             'misordered result'),
+            (self.penalty_irretrievable, c.irretrievable_watches,
+             'result could not be retrieved'),
+            (self.penalty_incorrect_values, c.unexpected_watches,
+             'unexpected result'),
+        ]
+
+        for penalty_score, watches, description in penalty_descriptions:
+            # We only penalize the encountered issue for each missing value per
+            # command but we still want to record each one, so set the penalty
+            # to 0 after the threshold is passed.
+            times_to_penalize = len(c.missing_values)
+
+            for w in watches:
+                times_to_penalize -= 1
+                penalty_score = min(penalty_available, penalty_score)
+                penalty_available -= penalty_score
+                penalties[description].append(
+                    PenaltyInstance(w, penalty_score))
+                if not times_to_penalize:
+                    penalty_score = 0
+
+        return name, penalties
+
+    @property
+    def penalty(self):
+        result = 0
+
+        maximum_allowed_penalty = 0
+        for name, pen_cmd in self.penalties.items():
+            maximum_allowed_penalty += pen_cmd.max_penalty
+            value = pen_cmd.pen_dict
+            for category, inst_list in value.items():
+                result += sum(x.the_penalty for x in inst_list)
+        return min(result, maximum_allowed_penalty)
+
+    @property
+    def max_penalty(self):
+        return sum(p_cat.max_penalty for p_cat in self.penalties.values())
+
+    @property
+    def score(self):
+        try:
+            return 1.0 - (self.penalty / float(self.max_penalty))
+        except ZeroDivisionError:
+            return float('nan')
+
+    @property
+    def summary_string(self):
+        score = self.score
+        isnan = score != score  # pylint: disable=comparison-with-itself
+        color = 'g'
+        if score < 0.25 or isnan:
+            color = 'r'
+        elif score < 0.75:
+            color = 'y'
+
+        return '<{}>({:.4f})</>'.format(color, score)
+
+    @property
+    def verbose_output(self):  # noqa
+        string = ''
+        string += ('\n')
+        for command in sorted(self.penalties):
+            pen_cmd = self.penalties[command]
+            maximum_possible_penalty = pen_cmd.max_penalty
+            total_penalty = 0
+            lines = []
+            for category in sorted(pen_cmd.pen_dict):
+                lines.append('    <r>{}</>:\n'.format(category))
+
+                for result, penalty in pen_cmd.pen_dict[category]:
+                    if isinstance(result, StepValueInfo):
+                        text = 'step {}'.format(result.step_index)
+                        if result.expected_value:
+                            text += ' ({})'.format(result.expected_value)
+                    else:
+                        text = str(result)
+                    if penalty:
+                        assert penalty > 0, penalty
+                        total_penalty += penalty
+                        text += ' <r>[-{}]</>'.format(penalty)
+                    lines.append('      {}\n'.format(text))
+
+                lines.append('\n')
+
+            string += ('  <b>{}</> <y>[{}/{}]</>\n'.format(
+                command, total_penalty, maximum_possible_penalty))
+            for line in lines:
+                string += (line)
+        string += ('\n')
+        return string
+
+    @property
+    def penalty_variable_optimized(self):
+        return self.context.options.penalty_variable_optimized
+
+    @property
+    def penalty_irretrievable(self):
+        return self.context.options.penalty_irretrievable
+
+    @property
+    def penalty_not_evaluatable(self):
+        return self.context.options.penalty_not_evaluatable
+
+    @property
+    def penalty_incorrect_values(self):
+        return self.context.options.penalty_incorrect_values
+
+    @property
+    def penalty_missing_values(self):
+        return self.context.options.penalty_missing_values
+
+    @property
+    def penalty_misordered_values(self):
+        return self.context.options.penalty_misordered_values
+
+    @property
+    def penalty_unreachable(self):
+        return self.context.options.penalty_unreachable
+
+    @property
+    def penalty_missing_step(self):
+        return self.context.options.penalty_missing_step
+
+    @property
+    def penalty_misordered_steps(self):
+        return self.context.options.penalty_misordered_steps
+
+    @property
+    def penalty_incorrect_program_state(self):
+        return self.context.options.penalty_incorrect_program_state
diff --git a/debuginfo-tests/dexter/dex/heuristic/__init__.py b/debuginfo-tests/dexter/dex/heuristic/__init__.py
new file mode 100644
index 00000000000..2a143f6c72b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/heuristic/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.heuristic.Heuristic import Heuristic, StepValueInfo
diff --git a/debuginfo-tests/dexter/dex/tools/Main.py b/debuginfo-tests/dexter/dex/tools/Main.py
new file mode 100644
index 00000000000..78fb4f7b724
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/Main.py
@@ -0,0 +1,207 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""This is the main entry point.
+It implements some functionality common to all subtools such as command line
+parsing and running the unit-testing harnesses, before calling the reequested
+subtool.
+"""
+
+import imp
+import os
+import sys
+
+from dex.utils import PrettyOutput, Timer
+from dex.utils import ExtArgParse as argparse
+from dex.utils import get_root_directory
+from dex.utils.Exceptions import Error, ToolArgumentError
+from dex.utils.UnitTests import unit_tests_ok
+from dex.utils.Version import version
+from dex.utils import WorkingDirectory
+from dex.utils.ReturnCode import ReturnCode
+
+
+def _output_bug_report_message(context):
+    """ In the event of a catastrophic failure, print bug report request to the
+        user.
+    """
+    context.o.red(
+        '\n\n'
+        '<g>****************************************</>\n'
+        '<b>****************************************</>\n'
+        '****************************************\n'
+        '**                                    **\n'
+        '** <y>This is a bug in <a>DExTer</>.</>           **\n'
+        '**                                    **\n'
+        '**                  <y>Please report it.</> **\n'
+        '**                                    **\n'
+        '****************************************\n'
+        '<b>****************************************</>\n'
+        '<g>****************************************</>\n'
+        '\n'
+        '<b>system:</>\n'
+        '<d>{}</>\n\n'
+        '<b>version:</>\n'
+        '<d>{}</>\n\n'
+        '<b>args:</>\n'
+        '<d>{}</>\n'
+        '\n'.format(sys.platform, version('DExTer'),
+                    [sys.executable] + sys.argv),
+        stream=PrettyOutput.stderr)
+
+
+def get_tools_directory():
+    """ Returns directory path where DExTer tool imports can be
+        found.
+    """
+    tools_directory = os.path.join(get_root_directory(), 'tools')
+    assert os.path.isdir(tools_directory), tools_directory
+    return tools_directory
+
+
+def get_tool_names():
+    """ Returns a list of expected DExTer Tools
+    """
+    return [
+        'clang-opt-bisect', 'help', 'list-debuggers', 'no-tool-',
+        'run-debugger-internal-', 'test', 'view'
+    ]
+
+
+def _set_auto_highlights(context):
+    """Flag some strings for auto-highlighting.
+    """
+    context.o.auto_reds.extend([
+        r'[Ee]rror\:',
+        r'[Ee]xception\:',
+        r'un(expected|recognized) argument',
+    ])
+    context.o.auto_yellows.extend([
+        r'[Ww]arning\:',
+        r'\(did you mean ',
+        r'During handling of the above exception, another exception',
+    ])
+
+
+def _get_options_and_args(context):
+    """ get the options and arguments from the commandline
+    """
+    parser = argparse.ExtArgumentParser(context, add_help=False)
+    parser.add_argument('tool', default=None, nargs='?')
+    options, args = parser.parse_known_args(sys.argv[1:])
+
+    return options, args
+
+
+def _get_tool_name(options):
+    """ get the name of the dexter tool (if passed) specified on the command
+        line, otherwise return 'no_tool_'.
+    """
+    tool_name = options.tool
+    if tool_name is None:
+        tool_name = 'no_tool_'
+    else:
+        _is_valid_tool_name(tool_name)
+    return tool_name
+
+
+def _is_valid_tool_name(tool_name):
+    """ check tool name matches a tool directory within the dexter tools
+        directory.
+    """
+    valid_tools = get_tool_names()
+    if tool_name not in valid_tools:
+        raise Error('invalid tool "{}" (choose from {})'.format(
+            tool_name,
+            ', '.join([t for t in valid_tools if not t.endswith('-')])))
+
+
+def _import_tool_module(tool_name):
+    """ Imports the python module at the tool directory specificed by
+        tool_name.
+    """
+    # format tool argument to reflect tool directory form.
+    tool_name = tool_name.replace('-', '_')
+
+    tools_directory = get_tools_directory()
+    module_info = imp.find_module(tool_name, [tools_directory])
+
+    return imp.load_module(tool_name, *module_info)
+
+
+def tool_main(context, tool, args):
+    with Timer(tool.name):
+        options, defaults = tool.parse_command_line(args)
+        Timer.display = options.time_report
+        Timer.indent = options.indent_timer_level
+        Timer.fn = context.o.blue
+        context.options = options
+        context.version = version(tool.name)
+
+        if options.version:
+            context.o.green('{}\n'.format(context.version))
+            return ReturnCode.OK
+
+        if (options.unittest != 'off' and not unit_tests_ok(context)):
+            raise Error('<d>unit test failures</>')
+
+        if options.colortest:
+            context.o.colortest()
+            return ReturnCode.OK
+
+        try:
+            tool.handle_base_options(defaults)
+        except ToolArgumentError as e:
+            raise Error(e)
+
+        dir_ = context.options.working_directory
+        with WorkingDirectory(context, dir=dir_) as context.working_directory:
+            return_code = tool.go()
+
+        return return_code
+
+
+class Context(object):
+    """Context encapsulates globally useful objects and data; passed to many
+    Dexter functions.
+    """
+
+    def __init__(self):
+        self.o: PrettyOutput = None
+        self.working_directory: str = None
+        self.options: dict = None
+        self.version: str = None
+        self.root_directory: str = None
+
+
+def main() -> ReturnCode:
+
+    context = Context()
+
+    with PrettyOutput() as context.o:
+        try:
+            context.root_directory = get_root_directory()
+            # Flag some strings for auto-highlighting.
+            _set_auto_highlights(context)
+            options, args = _get_options_and_args(context)
+            # raises 'Error' if command line tool is invalid.
+            tool_name = _get_tool_name(options)
+            module = _import_tool_module(tool_name)
+            return tool_main(context, module.Tool(context), args)
+        except Error as e:
+            context.o.auto(
+                '\nerror: {}\n'.format(str(e)), stream=PrettyOutput.stderr)
+            try:
+                if context.options.error_debug:
+                    raise
+            except AttributeError:
+                pass
+            return ReturnCode._ERROR
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except:  # noqa
+            _output_bug_report_message(context)
+            raise
diff --git a/debuginfo-tests/dexter/dex/tools/TestToolBase.py b/debuginfo-tests/dexter/dex/tools/TestToolBase.py
new file mode 100644
index 00000000000..7e00fc54b19
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/TestToolBase.py
@@ -0,0 +1,148 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Base class for subtools that do build/run tests."""
+
+import abc
+from datetime import datetime
+import os
+import sys
+
+from dex.builder import add_builder_tool_arguments
+from dex.builder import handle_builder_tool_options
+from dex.debugger.Debuggers import add_debugger_tool_arguments
+from dex.debugger.Debuggers import handle_debugger_tool_options
+from dex.heuristic.Heuristic import add_heuristic_tool_arguments
+from dex.tools.ToolBase import ToolBase
+from dex.utils import get_root_directory, warn
+from dex.utils.Exceptions import Error, ToolArgumentError
+from dex.utils.ReturnCode import ReturnCode
+
+
+class TestToolBase(ToolBase):
+    def __init__(self, *args, **kwargs):
+        super(TestToolBase, self).__init__(*args, **kwargs)
+        self.build_script: str = None
+
+    def add_tool_arguments(self, parser, defaults):
+        parser.description = self.__doc__
+        add_builder_tool_arguments(parser)
+        add_debugger_tool_arguments(parser, self.context, defaults)
+        add_heuristic_tool_arguments(parser)
+
+        parser.add_argument(
+            'test_path',
+            type=str,
+            metavar='<test-path>',
+            nargs='?',
+            default=os.path.abspath(
+                os.path.join(get_root_directory(), '..', 'tests')),
+            help='directory containing test(s)')
+
+        parser.add_argument(
+            '--results-directory',
+            type=str,
+            metavar='<directory>',
+            default=os.path.abspath(
+                os.path.join(get_root_directory(), '..', 'results',
+                             datetime.now().strftime('%Y-%m-%d-%H%M-%S'))),
+            help='directory to save results')
+
+    def handle_options(self, defaults):
+        options = self.context.options
+
+        # We accept either or both of --binary and --builder.
+        if not options.binary and not options.builder:
+            raise Error('expected --builder or --binary')
+
+        # --binary overrides --builder
+        if options.binary:
+            if options.builder:
+                warn(self.context, "overriding --builder with --binary\n")
+
+            options.binary = os.path.abspath(options.binary)
+            if not os.path.isfile(options.binary):
+                raise Error('<d>could not find binary file</> <r>"{}"</>'
+                            .format(options.binary))
+        else:
+            try:
+                self.build_script = handle_builder_tool_options(self.context)
+            except ToolArgumentError as e:
+                raise Error(e)
+
+        try:
+            handle_debugger_tool_options(self.context, defaults)
+        except ToolArgumentError as e:
+            raise Error(e)
+
+        options.test_path = os.path.abspath(options.test_path)
+        if not os.path.isfile(options.test_path) and not os.path.isdir(options.test_path):
+            raise Error(
+                '<d>could not find test path</> <r>"{}"</>'.format(
+                    options.test_path))
+
+        options.results_directory = os.path.abspath(options.results_directory)
+        if not os.path.isdir(options.results_directory):
+            try:
+                os.makedirs(options.results_directory, exist_ok=True)
+            except OSError as e:
+                raise Error(
+                    '<d>could not create directory</> <r>"{}"</> <y>({})</>'.
+                    format(options.results_directory, e.strerror))
+
+    def go(self) -> ReturnCode:  # noqa
+        options = self.context.options
+
+        options.executable = os.path.join(
+            self.context.working_directory.path, 'tmp.exe')
+
+        if os.path.isdir(options.test_path):
+
+            subdirs = sorted([
+                r for r, _, f in os.walk(options.test_path)
+                if 'test.cfg' in f
+            ])
+
+            for subdir in subdirs:
+
+                # TODO: read file extensions from the test.cfg file instead so
+                # that this isn't just limited to C and C++.
+                options.source_files = [
+                    os.path.normcase(os.path.join(subdir, f))
+                    for f in os.listdir(subdir) if any(
+                        f.endswith(ext) for ext in ['.c', '.cpp'])
+                ]
+
+                self._run_test(self._get_test_name(subdir))
+        else:
+            options.source_files = [options.test_path]
+            self._run_test(self._get_test_name(options.test_path))
+
+        return self._handle_results()
+
+    @staticmethod
+    def _is_current_directory(test_directory):
+        return test_directory == '.'
+
+    def _get_test_name(self, test_path):
+        """Get the test name from either the test file, or the sub directory
+        path it's stored in.
+        """
+        # test names are distinguished by their relative path from the
+        # specified test path.
+        test_name = os.path.relpath(test_path,
+                                    self.context.options.test_path)
+        if self._is_current_directory(test_name):
+            test_name = os.path.basename(test_path)
+        return test_name
+
+    @abc.abstractmethod
+    def _run_test(self, test_dir):
+        pass
+
+    @abc.abstractmethod
+    def _handle_results(self) -> ReturnCode:
+        pass
diff --git a/debuginfo-tests/dexter/dex/tools/ToolBase.py b/debuginfo-tests/dexter/dex/tools/ToolBase.py
new file mode 100644
index 00000000000..eb6ba94c2de
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/ToolBase.py
@@ -0,0 +1,135 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Base class for all subtools."""
+
+import abc
+import os
+import tempfile
+
+from dex import __version__
+from dex.utils import ExtArgParse
+from dex.utils import PrettyOutput
+from dex.utils.ReturnCode import ReturnCode
+
+
+class ToolBase(object, metaclass=abc.ABCMeta):
+    def __init__(self, context):
+        self.context = context
+        self.parser = None
+
+    @abc.abstractproperty
+    def name(self):
+        pass
+
+    @abc.abstractmethod
+    def add_tool_arguments(self, parser, defaults):
+        pass
+
+    def parse_command_line(self, args):
+        """Define two parsers: pparser and self.parser.
+        pparser deals with args that need to be parsed prior to any of those of
+        self.parser.  For example, any args which may affect the state of
+        argparse error output.
+        """
+
+        class defaults(object):
+            pass
+
+        pparser = ExtArgParse.ExtArgumentParser(
+            self.context, add_help=False, prog=self.name)
+
+        pparser.add_argument(
+            '--no-color-output',
+            action='store_true',
+            default=False,
+            help='do not use colored output on stdout/stderr')
+        pparser.add_argument(
+            '--time-report',
+            action='store_true',
+            default=False,
+            help='display timing statistics')
+
+        self.parser = ExtArgParse.ExtArgumentParser(
+            self.context, parents=[pparser], prog=self.name)
+        self.parser.add_argument(
+            '-v',
+            '--verbose',
+            action='store_true',
+            default=False,
+            help='enable verbose output')
+        self.parser.add_argument(
+            '-V',
+            '--version',
+            action='store_true',
+            default=False,
+            help='display the DExTer version and exit')
+        self.parser.add_argument(
+            '-w',
+            '--no-warnings',
+            action='store_true',
+            default=False,
+            help='suppress warning output')
+        self.parser.add_argument(
+            '--unittest',
+            type=str,
+            choices=['off', 'show-failures', 'show-all'],
+            default='off',
+            help='run the DExTer codebase unit tests')
+
+        suppress = ExtArgParse.SUPPRESS  # pylint: disable=no-member
+        self.parser.add_argument(
+            '--colortest', action='store_true', default=False, help=suppress)
+        self.parser.add_argument(
+            '--error-debug', action='store_true', default=False, help=suppress)
+        defaults.working_directory = os.path.join(tempfile.gettempdir(),
+                                                  'dexter')
+        self.parser.add_argument(
+            '--indent-timer-level', type=int, default=1, help=suppress)
+        self.parser.add_argument(
+            '--working-directory',
+            type=str,
+            metavar='<file>',
+            default=None,
+            display_default=defaults.working_directory,
+            help='location of working directory')
+        self.parser.add_argument(
+            '--save-temps',
+            action='store_true',
+            default=False,
+            help='save temporary files')
+
+        self.add_tool_arguments(self.parser, defaults)
+
+        # If an error is encountered during pparser, show the full usage text
+        # including self.parser options. Strip the preceding 'usage: ' to avoid
+        # having it appear twice.
+        pparser.usage = self.parser.format_usage().lstrip('usage: ')
+
+        options, args = pparser.parse_known_args(args)
+
+        if options.no_color_output:
+            PrettyOutput.stdout.color_enabled = False
+            PrettyOutput.stderr.color_enabled = False
+
+        options = self.parser.parse_args(args, namespace=options)
+        return options, defaults
+
+    def handle_base_options(self, defaults):
+        self.handle_options(defaults)
+
+        options = self.context.options
+
+        if options.working_directory is None:
+            options.working_directory = defaults.working_directory
+
+    @abc.abstractmethod
+    def handle_options(self, defaults):
+        pass
+
+    @abc.abstractmethod
+    def go(self) -> ReturnCode:
+        pass
diff --git a/debuginfo-tests/dexter/dex/tools/__init__.py b/debuginfo-tests/dexter/dex/tools/__init__.py
new file mode 100644
index 00000000000..76d12614b07
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/__init__.py
@@ -0,0 +1,10 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.Main import Context, get_tool_names, get_tools_directory, main, tool_main
+from dex.tools.TestToolBase import TestToolBase
+from dex.tools.ToolBase import ToolBase
diff --git a/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/Tool.py b/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/Tool.py
new file mode 100644
index 00000000000..a2fc2969e96
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/Tool.py
@@ -0,0 +1,286 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Clang opt-bisect tool."""
+
+from collections import defaultdict
+import os
+import csv
+import re
+import pickle
+
+from dex.builder import run_external_build_script
+from dex.debugger.Debuggers import empty_debugger_steps, get_debugger_steps
+from dex.heuristic import Heuristic
+from dex.tools import TestToolBase
+from dex.utils.Exceptions import DebuggerException, Error
+from dex.utils.Exceptions import BuildScriptException, HeuristicException
+from dex.utils.PrettyOutputBase import Stream
+from dex.utils.ReturnCode import ReturnCode
+
+
+class BisectPass(object):
+    def __init__(self, no, description, description_no_loc):
+        self.no = no
+        self.description = description
+        self.description_no_loc = description_no_loc
+
+        self.penalty = 0
+        self.differences = []
+
+
+class Tool(TestToolBase):
+    """Use the LLVM "-opt-bisect-limit=<n>" flag to get information on the
+    contribution of each LLVM pass to the overall DExTer score when using
+    clang.
+
+    Clang is run multiple times, with an increasing value of n, measuring the
+    debugging experience at each value.
+    """
+
+    _re_running_pass = re.compile(
+        r'^BISECT\: running pass \((\d+)\) (.+?)( \(.+\))?$')
+
+    def __init__(self, *args, **kwargs):
+        super(Tool, self).__init__(*args, **kwargs)
+        self._all_bisect_pass_summary = defaultdict(list)
+
+    @property
+    def name(self):
+        return 'DExTer clang opt bisect'
+
+    def _get_bisect_limits(self):
+        options = self.context.options
+
+        max_limit = 999999
+        limits = [max_limit for _ in options.source_files]
+        all_passes = [
+            l for l in self._clang_opt_bisect_build(limits)[1].splitlines()
+            if l.startswith('BISECT: running pass (')
+        ]
+
+        results = []
+        for i, pass_ in enumerate(all_passes[1:]):
+            if pass_.startswith('BISECT: running pass (1)'):
+                results.append(all_passes[i])
+        results.append(all_passes[-1])
+
+        assert len(results) == len(
+            options.source_files), (results, options.source_files)
+
+        limits = [
+            int(Tool._re_running_pass.match(r).group(1)) for r in results
+        ]
+
+        return limits
+
+    def _run_test(self, test_name):  # noqa
+        options = self.context.options
+
+        per_pass_score = []
+        current_bisect_pass_summary = defaultdict(list)
+
+        max_limits = self._get_bisect_limits()
+        overall_limit = sum(max_limits)
+        prev_score = 1.0
+        prev_steps_str = None
+
+        for current_limit in range(overall_limit + 1):
+            # Take the overall limit number and split it across buckets for
+            # each source file.
+            limit_remaining = current_limit
+            file_limits = [0] * len(max_limits)
+            for i, max_limit in enumerate(max_limits):
+                if limit_remaining < max_limit:
+                    file_limits[i] += limit_remaining
+                    break
+                else:
+                    file_limits[i] = max_limit
+                    limit_remaining -= file_limits[i]
+
+            f = [l for l in file_limits if l]
+            current_file_index = len(f) - 1 if f else 0
+
+            _, err, builderIR = self._clang_opt_bisect_build(file_limits)
+            err_lines = err.splitlines()
+            # Find the last line that specified a running pass.
+            for l in err_lines[::-1]:
+                match = Tool._re_running_pass.match(l)
+                if match:
+                    pass_info = match.groups()
+                    break
+            else:
+                pass_info = (0, None, None)
+
+            try:
+                steps = get_debugger_steps(self.context)
+            except DebuggerException:
+                steps = empty_debugger_steps(self.context)
+
+            steps.builder = builderIR
+
+            try:
+                heuristic = Heuristic(self.context, steps)
+            except HeuristicException as e:
+                raise Error(e)
+
+            score_difference = heuristic.score - prev_score
+            prev_score = heuristic.score
+
+            isnan = heuristic.score != heuristic.score
+            if isnan or score_difference < 0:
+                color1 = 'r'
+                color2 = 'r'
+            elif score_difference > 0:
+                color1 = 'g'
+                color2 = 'g'
+            else:
+                color1 = 'y'
+                color2 = 'd'
+
+            summary = '<{}>running pass {}/{} on "{}"'.format(
+                color2, pass_info[0], max_limits[current_file_index],
+                test_name)
+            if len(options.source_files) > 1:
+                summary += ' [{}/{}]'.format(current_limit, overall_limit)
+
+            pass_text = ''.join(p for p in pass_info[1:] if p)
+            summary += ': {} <{}>{:+.4f}</> <{}>{}</></>\n'.format(
+                heuristic.summary_string, color1, score_difference, color2,
+                pass_text)
+
+            self.context.o.auto(summary)
+
+            heuristic_verbose_output = heuristic.verbose_output
+
+            if options.verbose:
+                self.context.o.auto(heuristic_verbose_output)
+
+            steps_str = str(steps)
+            steps_changed = steps_str != prev_steps_str
+            prev_steps_str = steps_str
+
+            # If this is the first pass, or something has changed, write a text
+            # file containing verbose information on the current status.
+            if current_limit == 0 or score_difference or steps_changed:
+                file_name = '-'.join(
+                    str(s) for s in [
+                        'status', test_name, '{{:0>{}}}'.format(
+                            len(str(overall_limit))).format(current_limit),
+                        '{:.4f}'.format(heuristic.score).replace(
+                            '.', '_'), pass_info[1]
+                    ] if s is not None)
+
+                file_name = ''.join(
+                    c for c in file_name
+                    if c.isalnum() or c in '()-_./ ').strip().replace(
+                        ' ', '_').replace('/', '_')
+
+                output_text_path = os.path.join(options.results_directory,
+                                                '{}.txt'.format(file_name))
+                with open(output_text_path, 'w') as fp:
+                    self.context.o.auto(summary + '\n', stream=Stream(fp))
+                    self.context.o.auto(str(steps) + '\n', stream=Stream(fp))
+                    self.context.o.auto(
+                        heuristic_verbose_output + '\n', stream=Stream(fp))
+
+                output_dextIR_path = os.path.join(options.results_directory,
+                                                '{}.dextIR'.format(file_name))
+                with open(output_dextIR_path, 'wb') as fp:
+                    pickle.dump(steps, fp, protocol=pickle.HIGHEST_PROTOCOL)
+
+            per_pass_score.append((test_name, pass_text,
+                                   heuristic.score))
+
+            if pass_info[1]:
+                self._all_bisect_pass_summary[pass_info[1]].append(
+                    score_difference)
+
+                current_bisect_pass_summary[pass_info[1]].append(
+                    score_difference)
+
+        per_pass_score_path = os.path.join(
+            options.results_directory,
+            '{}-per_pass_score.csv'.format(test_name))
+
+        with open(per_pass_score_path, mode='w', newline='') as fp:
+            writer = csv.writer(fp, delimiter=',')
+            writer.writerow(['Source File', 'Pass', 'Score'])
+
+            for path, pass_, score in per_pass_score:
+                writer.writerow([path, pass_, score])
+        self.context.o.blue('wrote "{}"\n'.format(per_pass_score_path))
+
+        pass_summary_path = os.path.join(
+            options.results_directory, '{}-pass-summary.csv'.format(test_name))
+
+        self._write_pass_summary(pass_summary_path,
+                                 current_bisect_pass_summary)
+
+    def _handle_results(self) -> ReturnCode:
+        options = self.context.options
+        pass_summary_path = os.path.join(options.results_directory,
+                                         'overall-pass-summary.csv')
+
+        self._write_pass_summary(pass_summary_path,
+                                 self._all_bisect_pass_summary)
+        return ReturnCode.OK
+
+
+    def _clang_opt_bisect_build(self, opt_bisect_limits):
+        options = self.context.options
+        compiler_options = [
+            '{} -mllvm -opt-bisect-limit={}'.format(options.cflags,
+                                                    opt_bisect_limit)
+            for opt_bisect_limit in opt_bisect_limits
+        ]
+        linker_options = options.ldflags
+
+        try:
+            return run_external_build_script(
+                self.context,
+                source_files=options.source_files,
+                compiler_options=compiler_options,
+                linker_options=linker_options,
+                script_path=self.build_script,
+                executable_file=options.executable)
+        except BuildScriptException as e:
+            raise Error(e)
+
+    def _write_pass_summary(self, path, pass_summary):
+        # Get a list of tuples.
+        pass_summary_list = list(pass_summary.items())
+
+        for i, item in enumerate(pass_summary_list):
+            # Add elems for the sum, min, and max of the values, as well as
+            # 'interestingness' which is whether any of these values are
+            # non-zero.
+            pass_summary_list[i] += (sum(item[1]), min(item[1]), max(item[1]),
+                                     any(item[1]))
+
+            # Split the pass name into the basic name and kind.
+            pass_summary_list[i] += tuple(item[0].rsplit(' on ', 1))
+
+        # Sort the list by the following columns in order of precedence:
+        #   - Is interesting (True first)
+        #   - Sum (smallest first)
+        #   - Number of times pass ran (largest first)
+        #   - Kind (alphabetically)
+        #   - Name (alphabetically)
+        pass_summary_list.sort(
+            key=lambda tup: (not tup[5], tup[2], -len(tup[1]), tup[7], tup[6]))
+
+        with open(path, mode='w', newline='') as fp:
+            writer = csv.writer(fp, delimiter=',')
+            writer.writerow(
+                ['Pass', 'Kind', 'Sum', 'Min', 'Max', 'Interesting'])
+
+            for (_, vals, sum_, min_, max_, interesting, name,
+                 kind) in pass_summary_list:
+                writer.writerow([name, kind, sum_, min_, max_, interesting] +
+                                vals)
+
+        self.context.o.blue('wrote "{}"\n'.format(path))
diff --git a/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/__init__.py b/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/__init__.py
new file mode 100644
index 00000000000..b933e690b23
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/clang_opt_bisect/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.clang_opt_bisect.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/tools/help/Tool.py b/debuginfo-tests/dexter/dex/tools/help/Tool.py
new file mode 100644
index 00000000000..2b35af4b98f
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/help/Tool.py
@@ -0,0 +1,61 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Help tool."""
+
+import imp
+import textwrap
+
+from dex.tools import ToolBase, get_tool_names, get_tools_directory, tool_main
+from dex.utils.ReturnCode import ReturnCode
+
+
+class Tool(ToolBase):
+    """Provides help info on subtools."""
+
+    @property
+    def name(self):
+        return 'DExTer help'
+
+    @property
+    def _visible_tool_names(self):
+        return [t for t in get_tool_names() if not t.endswith('-')]
+
+    def add_tool_arguments(self, parser, defaults):
+        parser.description = Tool.__doc__
+        parser.add_argument(
+            'tool',
+            choices=self._visible_tool_names,
+            nargs='?',
+            help='name of subtool')
+
+    def handle_options(self, defaults):
+        pass
+
+    @property
+    def _default_text(self):
+        s = '\n<b>The following subtools are available:</>\n\n'
+        tools_directory = get_tools_directory()
+        for tool_name in sorted(self._visible_tool_names):
+            internal_name = tool_name.replace('-', '_')
+            module_info = imp.find_module(internal_name, [tools_directory])
+            tool_doc = imp.load_module(internal_name,
+                                       *module_info).Tool.__doc__
+            tool_doc = tool_doc.strip() if tool_doc else ''
+            tool_doc = textwrap.fill(' '.join(tool_doc.split()), 80)
+            s += '<g>{}</>\n{}\n\n'.format(tool_name, tool_doc)
+        return s
+
+    def go(self) -> ReturnCode:
+        if self.context.options.tool is None:
+            self.context.o.auto(self._default_text)
+            return ReturnCode.OK
+
+        tool_name = self.context.options.tool.replace('-', '_')
+        tools_directory = get_tools_directory()
+        module_info = imp.find_module(tool_name, [tools_directory])
+        module = imp.load_module(tool_name, *module_info)
+        return tool_main(self.context, module.Tool(self.context), ['--help'])
diff --git a/debuginfo-tests/dexter/dex/tools/help/__init__.py b/debuginfo-tests/dexter/dex/tools/help/__init__.py
new file mode 100644
index 00000000000..351e8fe48a0
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/help/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.help.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/tools/list_debuggers/Tool.py b/debuginfo-tests/dexter/dex/tools/list_debuggers/Tool.py
new file mode 100644
index 00000000000..5ef5d65464f
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/list_debuggers/Tool.py
@@ -0,0 +1,40 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""List debuggers tool."""
+
+from dex.debugger.Debuggers import add_debugger_tool_base_arguments
+from dex.debugger.Debuggers import handle_debugger_tool_base_options
+from dex.debugger.Debuggers import Debuggers
+from dex.tools import ToolBase
+from dex.utils import Timer
+from dex.utils.Exceptions import DebuggerException, Error
+from dex.utils.ReturnCode import ReturnCode
+
+
+class Tool(ToolBase):
+    """List all of the potential debuggers that DExTer knows about and whether
+    there is currently a valid interface available for them.
+    """
+
+    @property
+    def name(self):
+        return 'DExTer list debuggers'
+
+    def add_tool_arguments(self, parser, defaults):
+        parser.description = Tool.__doc__
+        add_debugger_tool_base_arguments(parser, defaults)
+
+    def handle_options(self, defaults):
+        handle_debugger_tool_base_options(self.context, defaults)
+
+    def go(self) -> ReturnCode:
+        with Timer('list debuggers'):
+            try:
+                Debuggers(self.context).list()
+            except DebuggerException as e:
+                raise Error(e)
+        return ReturnCode.OK
diff --git a/debuginfo-tests/dexter/dex/tools/list_debuggers/__init__.py b/debuginfo-tests/dexter/dex/tools/list_debuggers/__init__.py
new file mode 100644
index 00000000000..95741028be5
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/list_debuggers/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.list_debuggers.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/tools/no_tool_/Tool.py b/debuginfo-tests/dexter/dex/tools/no_tool_/Tool.py
new file mode 100644
index 00000000000..3d73189cd5b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/no_tool_/Tool.py
@@ -0,0 +1,49 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""This is a special subtool that is run when no subtool is specified.
+It just provides a welcome message and simple usage instructions.
+"""
+
+from dex.tools import ToolBase, get_tool_names
+from dex.utils.Exceptions import Error
+from dex.utils.ReturnCode import ReturnCode
+
+
+# This is a special "tool" that is run when no subtool has been specified on
+# the command line. Its only job is to provide useful usage info.
+class Tool(ToolBase):
+    """Welcome to DExTer (Debugging Experience Tester).
+    Please choose a subtool from the list below.  Use 'dexter.py help' for more
+    information.
+    """
+
+    @property
+    def name(self):
+        return 'DExTer'
+
+    def add_tool_arguments(self, parser, defaults):
+        parser.description = Tool.__doc__
+        parser.add_argument(
+            'subtool',
+            choices=[t for t in get_tool_names() if not t.endswith('-')],
+            nargs='?',
+            help='name of subtool')
+        parser.add_argument(
+            'subtool_options',
+            metavar='subtool-options',
+            nargs='*',
+            help='subtool specific options')
+
+    def handle_options(self, defaults):
+        if not self.context.options.subtool:
+            raise Error('<d>no subtool specified</>\n\n{}\n'.format(
+                self.parser.format_help()))
+
+    def go(self) -> ReturnCode:
+        # This fn is never called because not specifying a subtool raises an
+        # exception.
+        return ReturnCode._ERROR
diff --git a/debuginfo-tests/dexter/dex/tools/no_tool_/__init__.py b/debuginfo-tests/dexter/dex/tools/no_tool_/__init__.py
new file mode 100644
index 00000000000..0e355f818aa
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/no_tool_/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.no_tool_.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/Tool.py b/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/Tool.py
new file mode 100644
index 00000000000..494b4e1d0a9
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/Tool.py
@@ -0,0 +1,74 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""This is an internal subtool used to sandbox the communication with a
+debugger into a separate process so that any crashes inside the debugger will
+not bring down the entire DExTer tool.
+"""
+
+import pickle
+
+from dex.debugger import Debuggers
+from dex.tools import ToolBase
+from dex.utils import Timer
+from dex.utils.Exceptions import DebuggerException, Error
+from dex.utils.ReturnCode import ReturnCode
+
+
+class Tool(ToolBase):
+    def __init__(self, *args, **kwargs):
+        super(Tool, self).__init__(*args, **kwargs)
+        self.dextIR = None
+
+    @property
+    def name(self):
+        return 'DExTer run debugger internal'
+
+    def add_tool_arguments(self, parser, defaults):
+        parser.add_argument('dextIR_path', type=str, help='dextIR file')
+        parser.add_argument(
+            'pickled_options', type=str, help='pickled options file')
+
+    def handle_options(self, defaults):
+        with open(self.context.options.dextIR_path, 'rb') as fp:
+            self.dextIR = pickle.load(fp)
+
+        with open(self.context.options.pickled_options, 'rb') as fp:
+            poptions = pickle.load(fp)
+            poptions.working_directory = (
+                self.context.options.working_directory[:])
+            poptions.unittest = self.context.options.unittest
+            poptions.dextIR_path = self.context.options.dextIR_path
+            self.context.options = poptions
+
+        Timer.display = self.context.options.time_report
+
+    def go(self) -> ReturnCode:
+        options = self.context.options
+
+        with Timer('loading debugger'):
+            debugger = Debuggers(self.context).load(options.debugger,
+                                                    self.dextIR)
+            self.dextIR.debugger = debugger.debugger_info
+
+        with Timer('running debugger'):
+            if not debugger.is_available:
+                msg = '<d>could not load {}</> ({})\n'.format(
+                    debugger.name, debugger.loading_error)
+                if options.verbose:
+                    msg = '{}\n    {}'.format(
+                        msg, '    '.join(debugger.loading_error_trace))
+                raise Error(msg)
+
+            with debugger:
+                try:
+                    debugger.start()
+                except DebuggerException as e:
+                    raise Error(e)
+
+        with open(self.context.options.dextIR_path, 'wb') as fp:
+            pickle.dump(self.dextIR, fp)
+        return ReturnCode.OK
diff --git a/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/__init__.py b/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/__init__.py
new file mode 100644
index 00000000000..db3f98bd75b
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/run_debugger_internal_/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.run_debugger_internal_.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/tools/test/Tool.py b/debuginfo-tests/dexter/dex/tools/test/Tool.py
new file mode 100644
index 00000000000..fcd009c5081
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/test/Tool.py
@@ -0,0 +1,244 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Test tool."""
+
+import os
+import csv
+import pickle
+import shutil
+
+from dex.builder import run_external_build_script
+from dex.debugger.Debuggers import get_debugger_steps
+from dex.heuristic import Heuristic
+from dex.tools import TestToolBase
+from dex.utils.Exceptions import DebuggerException
+from dex.utils.Exceptions import BuildScriptException, HeuristicException
+from dex.utils.PrettyOutputBase import Stream
+from dex.utils.ReturnCode import ReturnCode
+from dex.dextIR import BuilderIR
+
+
+class TestCase(object):
+    def __init__(self, context, name, heuristic, error):
+        self.context = context
+        self.name = name
+        self.heuristic = heuristic
+        self.error = error
+
+    @property
+    def penalty(self):
+        try:
+            return self.heuristic.penalty
+        except AttributeError:
+            return float('nan')
+
+    @property
+    def max_penalty(self):
+        try:
+            return self.heuristic.max_penalty
+        except AttributeError:
+            return float('nan')
+
+    @property
+    def score(self):
+        try:
+            return self.heuristic.score
+        except AttributeError:
+            return float('nan')
+
+    def __str__(self):
+        if self.error and self.context.options.verbose:
+            verbose_error = str(self.error)
+        else:
+            verbose_error = ''
+
+        if self.error:
+            script_error = (' : {}'.format(
+                self.error.script_error.splitlines()[0].decode()) if getattr(
+                    self.error, 'script_error', None) else '')
+
+            error = ' [{}{}]'.format(
+                str(self.error).splitlines()[0], script_error)
+        else:
+            error = ''
+
+        try:
+            summary = self.heuristic.summary_string
+        except AttributeError:
+            summary = '<r>nan/nan (nan)</>'
+        return '{}: {}{}\n{}'.format(self.name, summary, error, verbose_error)
+
+
+class Tool(TestToolBase):
+    """Run the specified DExTer test(s) with the specified compiler and linker
+    options and produce a dextIR file as well as printing out the debugging
+    experience score calculated by the DExTer heuristic.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(Tool, self).__init__(*args, **kwargs)
+        self._test_cases = []
+
+    @property
+    def name(self):
+        return 'DExTer test'
+
+    def add_tool_arguments(self, parser, defaults):
+        parser.add_argument('--fail-lt',
+                            type=float,
+                            default=0.0, # By default TEST always succeeds.
+                            help='exit with status FAIL(2) if the test result'
+                                ' is less than this value.',
+                            metavar='<float>')
+        super(Tool, self).add_tool_arguments(parser, defaults)
+
+    def _build_test_case(self):
+        """Build an executable from the test source with the given --builder
+        script and flags (--cflags, --ldflags) in the working directory.
+        Or, if the --binary option has been given, copy the executable provided
+        into the working directory and rename it to match the --builder output.
+        """
+
+        options = self.context.options
+        if options.binary:
+            # Copy user's binary into the tmp working directory
+            shutil.copy(options.binary, options.executable)
+            builderIR = BuilderIR(
+                name='binary',
+                cflags=[options.binary],
+                ldflags='')
+        else:
+            options = self.context.options
+            compiler_options = [options.cflags for _ in options.source_files]
+            linker_options = options.ldflags
+            _, _, builderIR = run_external_build_script(
+                self.context,
+                script_path=self.build_script,
+                source_files=options.source_files,
+                compiler_options=compiler_options,
+                linker_options=linker_options,
+                executable_file=options.executable)
+        return builderIR
+
+    def _get_steps(self, builderIR):
+        """Generate a list of debugger steps from a test case.
+        """
+        steps = get_debugger_steps(self.context)
+        steps.builder = builderIR
+        return steps
+
+    def _get_results_basename(self, test_name):
+        def splitall(x):
+            while len(x) > 0:
+              x, y = os.path.split(x)
+              yield y
+        all_components = reversed([x for x in splitall(test_name)])
+        return '_'.join(all_components)
+
+    def _get_results_path(self, test_name):
+        """Returns the path to the test results directory for the test denoted
+        by test_name.
+        """
+        return os.path.join(self.context.options.results_directory,
+                            self._get_results_basename(test_name))
+
+    def _get_results_text_path(self, test_name):
+        """Returns path results .txt file for test denoted by test_name.
+        """
+        test_results_path = self._get_results_path(test_name)
+        return '{}.txt'.format(test_results_path)
+
+    def _get_results_pickle_path(self, test_name):
+        """Returns path results .dextIR file for test denoted by test_name.
+        """
+        test_results_path = self._get_results_path(test_name)
+        return '{}.dextIR'.format(test_results_path)
+
+    def _record_steps(self, test_name, steps):
+        """Write out the set of steps out to the test's .txt and .json
+        results file.
+        """
+        output_text_path = self._get_results_text_path(test_name)
+        with open(output_text_path, 'w') as fp:
+            self.context.o.auto(str(steps), stream=Stream(fp))
+
+        output_dextIR_path = self._get_results_pickle_path(test_name)
+        with open(output_dextIR_path, 'wb') as fp:
+            pickle.dump(steps, fp, protocol=pickle.HIGHEST_PROTOCOL)
+
+    def _record_score(self, test_name, heuristic):
+        """Write out the test's heuristic score to the results .txt file.
+        """
+        output_text_path = self._get_results_text_path(test_name)
+        with open(output_text_path, 'a') as fp:
+            self.context.o.auto(heuristic.verbose_output, stream=Stream(fp))
+
+    def _record_test_and_display(self, test_case):
+        """Output test case to o stream and record test case internally for
+        handling later.
+        """
+        self.context.o.auto(test_case)
+        self._test_cases.append(test_case)
+
+    def _record_failed_test(self, test_name, exception):
+        """Instantiate a failed test case with failure exception and
+        store internally.
+        """
+        test_case = TestCase(self.context, test_name, None, exception)
+        self._record_test_and_display(test_case)
+
+    def _record_successful_test(self, test_name, steps, heuristic):
+        """Instantiate a successful test run, store test for handling later.
+        Display verbose output for test case if required.
+        """
+        test_case = TestCase(self.context, test_name, heuristic, None)
+        self._record_test_and_display(test_case)
+        if self.context.options.verbose:
+            self.context.o.auto('\n{}\n'.format(steps))
+            self.context.o.auto(heuristic.verbose_output)
+
+    def _run_test(self, test_name):
+        """Attempt to run test files specified in options.source_files. Store
+        result internally in self._test_cases.
+        """
+        try:
+            builderIR = self._build_test_case()
+            steps = self._get_steps(builderIR)
+            self._record_steps(test_name, steps)
+            heuristic_score = Heuristic(self.context, steps)
+            self._record_score(test_name, heuristic_score)
+        except (BuildScriptException, DebuggerException,
+                HeuristicException) as e:
+            self._record_failed_test(test_name, e)
+            return
+
+        self._record_successful_test(test_name, steps, heuristic_score)
+        return
+
+    def _handle_results(self) -> ReturnCode:
+        return_code = ReturnCode.OK
+        options = self.context.options
+
+        if not options.verbose:
+            self.context.o.auto('\n')
+
+        summary_path = os.path.join(options.results_directory, 'summary.csv')
+        with open(summary_path, mode='w', newline='') as fp:
+            writer = csv.writer(fp, delimiter=',')
+            writer.writerow(['Test Case', 'Score', 'Error'])
+
+            for test_case in self._test_cases:
+                if (test_case.score < options.fail_lt or
+                        test_case.error is not None):
+                    return_code = ReturnCode.FAIL
+
+                writer.writerow([
+                    test_case.name, '{:.4f}'.format(test_case.score),
+                    test_case.error
+                ])
+
+        return return_code
diff --git a/debuginfo-tests/dexter/dex/tools/test/__init__.py b/debuginfo-tests/dexter/dex/tools/test/__init__.py
new file mode 100644
index 00000000000..01ead3affe1
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/test/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.test.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/tools/view/Tool.py b/debuginfo-tests/dexter/dex/tools/view/Tool.py
new file mode 100644
index 00000000000..ad7d5300035
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/view/Tool.py
@@ -0,0 +1,59 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""View tool."""
+
+import os
+
+import pickle
+from dex.heuristic import Heuristic
+from dex.heuristic.Heuristic import add_heuristic_tool_arguments
+from dex.tools import ToolBase
+from dex.utils.Exceptions import Error, HeuristicException
+from dex.utils.ReturnCode import ReturnCode
+
+
+class Tool(ToolBase):
+    """Given a dextIR file, display the information in a human-readable form.
+    """
+
+    @property
+    def name(self):
+        return 'DExTer view'
+
+    def add_tool_arguments(self, parser, defaults):
+        add_heuristic_tool_arguments(parser)
+        parser.add_argument(
+            'input_path',
+            metavar='dextIR-file',
+            type=str,
+            default=None,
+            help='dexter dextIR file to view')
+        parser.description = Tool.__doc__
+
+    def handle_options(self, defaults):
+        options = self.context.options
+
+        options.input_path = os.path.abspath(options.input_path)
+        if not os.path.isfile(options.input_path):
+            raise Error('<d>could not find dextIR file</> <r>"{}"</>'.format(
+                options.input_path))
+
+    def go(self) -> ReturnCode:
+        options = self.context.options
+
+        with open(options.input_path, 'rb') as fp:
+            steps = pickle.load(fp)
+
+        try:
+            heuristic = Heuristic(self.context, steps)
+        except HeuristicException as e:
+            raise Error('could not apply heuristic: {}'.format(e))
+
+        self.context.o.auto('{}\n\n{}\n\n{}\n\n'.format(
+            heuristic.summary_string, steps, heuristic.verbose_output))
+
+        return ReturnCode.OK
diff --git a/debuginfo-tests/dexter/dex/tools/view/__init__.py b/debuginfo-tests/dexter/dex/tools/view/__init__.py
new file mode 100644
index 00000000000..1868fca28c2
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/tools/view/__init__.py
@@ -0,0 +1,8 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from dex.tools.view.Tool import Tool
diff --git a/debuginfo-tests/dexter/dex/utils/Environment.py b/debuginfo-tests/dexter/dex/utils/Environment.py
new file mode 100644
index 00000000000..d2df2522440
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/Environment.py
@@ -0,0 +1,22 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Utility functions for querying the current environment."""
+
+import os
+
+
+def is_native_windows():
+    return os.name == 'nt'
+
+
+def has_pywin32():
+    try:
+        import win32com.client  # pylint:disable=unused-variable
+        import win32api  # pylint:disable=unused-variable
+        return True
+    except ImportError:
+        return False
diff --git a/debuginfo-tests/dexter/dex/utils/Exceptions.py b/debuginfo-tests/dexter/dex/utils/Exceptions.py
new file mode 100644
index 00000000000..39c0c2f1695
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/Exceptions.py
@@ -0,0 +1,72 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Provides Dexter-specific exception types."""
+
+
+class Dexception(Exception):
+    """All dexter-specific exceptions derive from this."""
+    pass
+
+
+class Error(Dexception):
+    """Error.  Prints 'error: <message>' without a traceback."""
+    pass
+
+
+class DebuggerException(Dexception):
+    """Any error from using the debugger."""
+
+    def __init__(self, msg, orig_exception=None):
+        super(DebuggerException, self).__init__(msg)
+        self.msg = msg
+        self.orig_exception = orig_exception
+
+    def __str__(self):
+        return str(self.msg)
+
+
+class LoadDebuggerException(DebuggerException):
+    """If specified debugger cannot be loaded."""
+    pass
+
+
+class NotYetLoadedDebuggerException(LoadDebuggerException):
+    """If specified debugger has not yet been attempted to load."""
+
+    def __init__(self):
+        super(NotYetLoadedDebuggerException,
+              self).__init__('not loaded', orig_exception=None)
+
+
+class CommandParseError(Dexception):
+    """If a command instruction cannot be successfully parsed."""
+
+    def __init__(self, *args, **kwargs):
+        super(CommandParseError, self).__init__(*args, **kwargs)
+        self.filename = None
+        self.lineno = None
+        self.info = None
+        self.src = None
+        self.caret = None
+
+
+class ToolArgumentError(Dexception):
+    """If a tool argument is invalid."""
+    pass
+
+
+class BuildScriptException(Dexception):
+    """If there is an error in a build script file."""
+
+    def __init__(self, *args, **kwargs):
+        self.script_error = kwargs.pop('script_error', None)
+        super(BuildScriptException, self).__init__(*args, **kwargs)
+
+
+class HeuristicException(Dexception):
+    """If there was a problem with the heuristic."""
+    pass
diff --git a/debuginfo-tests/dexter/dex/utils/ExtArgParse.py b/debuginfo-tests/dexter/dex/utils/ExtArgParse.py
new file mode 100644
index 00000000000..9fa08fb066e
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/ExtArgParse.py
@@ -0,0 +1,148 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Extended Argument Parser. Extends the argparse module with some extra
+functionality, to hopefully aid user-friendliness.
+"""
+
+import argparse
+import difflib
+import unittest
+
+from dex.utils import PrettyOutput
+from dex.utils.Exceptions import Error
+
+# re-export all of argparse
+for argitem in argparse.__all__:
+    vars()[argitem] = getattr(argparse, argitem)
+
+
+def _did_you_mean(val, possibles):
+    close_matches = difflib.get_close_matches(val, possibles)
+    did_you_mean = ''
+    if close_matches:
+        did_you_mean = 'did you mean {}?'.format(' or '.join(
+            "<y>'{}'</>".format(c) for c in close_matches[:2]))
+    return did_you_mean
+
+
+def _colorize(message):
+    lines = message.splitlines()
+    for i, line in enumerate(lines):
+        lines[i] = lines[i].replace('usage:', '<g>usage:</>')
+        if line.endswith(':'):
+            lines[i] = '<g>{}</>'.format(line)
+    return '\n'.join(lines)
+
+
+class ExtArgumentParser(argparse.ArgumentParser):
+    def error(self, message):
+        """Use the Dexception Error mechanism (including auto-colored output).
+        """
+        raise Error('{}\n\n{}'.format(message, self.format_usage()))
+
+    # pylint: disable=redefined-builtin
+    def _print_message(self, message, file=None):
+        if message:
+            if file and file.name == '<stdout>':
+                file = PrettyOutput.stdout
+            else:
+                file = PrettyOutput.stderr
+
+            self.context.o.auto(message, file)
+
+    # pylint: enable=redefined-builtin
+
+    def format_usage(self):
+        return _colorize(super(ExtArgumentParser, self).format_usage())
+
+    def format_help(self):
+        return _colorize(super(ExtArgumentParser, self).format_help() + '\n\n')
+
+    @property
+    def _valid_visible_options(self):
+        """A list of all non-suppressed command line flags."""
+        return [
+            item for sublist in vars(self)['_actions']
+            for item in sublist.option_strings
+            if sublist.help != argparse.SUPPRESS
+        ]
+
+    def parse_args(self, args=None, namespace=None):
+        """Add 'did you mean' output to errors."""
+        args, argv = self.parse_known_args(args, namespace)
+        if argv:
+            errors = []
+            for arg in argv:
+                if arg in self._valid_visible_options:
+                    error = "unexpected argument: <y>'{}'</>".format(arg)
+                else:
+                    error = "unrecognized argument: <y>'{}'</>".format(arg)
+                    dym = _did_you_mean(arg, self._valid_visible_options)
+                    if dym:
+                        error += '  ({})'.format(dym)
+                errors.append(error)
+            self.error('\n       '.join(errors))
+
+        return args
+
+    def add_argument(self, *args, **kwargs):
+        """Automatically add the default value to help text."""
+        if 'default' in kwargs:
+            default = kwargs['default']
+            if default is None:
+                default = kwargs.pop('display_default', None)
+
+            if (default and isinstance(default, (str, int, float))
+                    and default != argparse.SUPPRESS):
+                assert (
+                    'choices' not in kwargs or default in kwargs['choices']), (
+                        "default value '{}' is not one of allowed choices: {}".
+                        format(default, kwargs['choices']))
+                if 'help' in kwargs and kwargs['help'] != argparse.SUPPRESS:
+                    assert isinstance(kwargs['help'], str), type(kwargs['help'])
+                    kwargs['help'] = ('{} (default:{})'.format(
+                        kwargs['help'], default))
+
+        super(ExtArgumentParser, self).add_argument(*args, **kwargs)
+
+    def __init__(self, context, *args, **kwargs):
+        self.context = context
+        super(ExtArgumentParser, self).__init__(*args, **kwargs)
+
+
+class TestExtArgumentParser(unittest.TestCase):
+    def test_did_you_mean(self):
+        parser = ExtArgumentParser(None)
+        parser.add_argument('--foo')
+        parser.add_argument('--qoo', help=argparse.SUPPRESS)
+        parser.add_argument('jam', nargs='?')
+
+        parser.parse_args(['--foo', '0'])
+
+        expected = (r"^unrecognized argument\: <y>'\-\-doo'</>\s+"
+                    r"\(did you mean <y>'\-\-foo'</>\?\)\n"
+                    r"\s*<g>usage:</>")
+        with self.assertRaisesRegex(Error, expected):
+            parser.parse_args(['--doo'])
+
+        parser.add_argument('--noo')
+
+        expected = (r"^unrecognized argument\: <y>'\-\-doo'</>\s+"
+                    r"\(did you mean <y>'\-\-noo'</> or <y>'\-\-foo'</>\?\)\n"
+                    r"\s*<g>usage:</>")
+        with self.assertRaisesRegex(Error, expected):
+            parser.parse_args(['--doo'])
+
+        expected = (r"^unrecognized argument\: <y>'\-\-bar'</>\n"
+                    r"\s*<g>usage:</>")
+        with self.assertRaisesRegex(Error, expected):
+            parser.parse_args(['--bar'])
+
+        expected = (r"^unexpected argument\: <y>'\-\-foo'</>\n"
+                    r"\s*<g>usage:</>")
+        with self.assertRaisesRegex(Error, expected):
+            parser.parse_args(['--', 'x', '--foo'])
diff --git a/debuginfo-tests/dexter/dex/utils/PrettyOutputBase.py b/debuginfo-tests/dexter/dex/utils/PrettyOutputBase.py
new file mode 100644
index 00000000000..d21db89a6ae
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/PrettyOutputBase.py
@@ -0,0 +1,392 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Provides formatted/colored console output on both Windows and Linux.
+
+Do not use this module directly, but instead use via the appropriate platform-
+specific module.
+"""
+
+import abc
+import re
+import sys
+import threading
+import unittest
+
+from io import StringIO
+
+from dex.utils.Exceptions import Error
+
+
+class _NullLock(object):
+    def __enter__(self):
+        return None
+
+    def __exit__(self, *params):
+        pass
+
+
+_lock = threading.Lock()
+_null_lock = _NullLock()
+
+
+class PreserveAutoColors(object):
+    def __init__(self, pretty_output):
+        self.pretty_output = pretty_output
+        self.orig_values = {}
+        self.properties = [
+            'auto_reds', 'auto_yellows', 'auto_greens', 'auto_blues'
+        ]
+
+    def __enter__(self):
+        for p in self.properties:
+            self.orig_values[p] = getattr(self.pretty_output, p)[:]
+        return self
+
+    def __exit__(self, *args):
+        for p in self.properties:
+            setattr(self.pretty_output, p, self.orig_values[p])
+
+
+class Stream(object):
+    def __init__(self, py_, os_=None):
+        self.py = py_
+        self.os = os_
+        self.orig_color = None
+        self.color_enabled = self.py.isatty()
+
+
+class PrettyOutputBase(object, metaclass=abc.ABCMeta):
+    stdout = Stream(sys.stdout)
+    stderr = Stream(sys.stderr)
+
+    def __init__(self):
+        self.auto_reds = []
+        self.auto_yellows = []
+        self.auto_greens = []
+        self.auto_blues = []
+        self._stack = []
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def _set_valid_stream(self, stream):
+        if stream is None:
+            return self.__class__.stdout
+        return stream
+
+    def _write(self, text, stream):
+        text = str(text)
+
+        # Users can embed color control tags in their output
+        # (e.g. <r>hello</> <y>world</> would write the word 'hello' in red and
+        # 'world' in yellow).
+        # This function parses these tags using a very simple recursive
+        # descent.
+        colors = {
+            'r': self.red,
+            'y': self.yellow,
+            'g': self.green,
+            'b': self.blue,
+            'd': self.default,
+            'a': self.auto,
+        }
+
+        # Find all tags (whether open or close)
+        tags = [
+            t for t in re.finditer('<([{}/])>'.format(''.join(colors)), text)
+        ]
+
+        if not tags:
+            # No tags.  Just write the text to the current stream and return.
+            # 'unmangling' any tags that have been mangled so that they won't
+            # render as colors (for example in error output from this
+            # function).
+            stream = self._set_valid_stream(stream)
+            stream.py.write(text.replace(r'\>', '>'))
+            return
+
+        open_tags = [i for i in tags if i.group(1) != '/']
+        close_tags = [i for i in tags if i.group(1) == '/']
+
+        if (len(open_tags) != len(close_tags)
+                or any(o.start() >= c.start()
+                       for (o, c) in zip(open_tags, close_tags))):
+            raise Error('open/close tag mismatch in "{}"'.format(
+                text.rstrip()).replace('>', r'\>'))
+
+        open_tag = open_tags.pop(0)
+
+        # We know that the tags balance correctly, so figure out where the
+        # corresponding close tag is to the current open tag.
+        tag_nesting = 1
+        close_tag = None
+        for tag in tags[1:]:
+            if tag.group(1) == '/':
+                tag_nesting -= 1
+            else:
+                tag_nesting += 1
+            if tag_nesting == 0:
+                close_tag = tag
+                break
+        else:
+            assert False, text
+
+        # Use the method on the top of the stack for text prior to the open
+        # tag.
+        before = text[:open_tag.start()]
+        if before:
+            self._stack[-1](before, lock=_null_lock, stream=stream)
+
+        # Use the specified color for the tag itself.
+        color = open_tag.group(1)
+        within = text[open_tag.end():close_tag.start()]
+        if within:
+            colors[color](within, lock=_null_lock, stream=stream)
+
+        # Use the method on the top of the stack for text after the close tag.
+        after = text[close_tag.end():]
+        if after:
+            self._stack[-1](after, lock=_null_lock, stream=stream)
+
+    def flush(self, stream):
+        stream = self._set_valid_stream(stream)
+        stream.py.flush()
+
+    def auto(self, text, stream=None, lock=_lock):
+        text = str(text)
+        stream = self._set_valid_stream(stream)
+        lines = text.splitlines(True)
+
+        with lock:
+            for line in lines:
+                # This is just being cute for the sake of cuteness, but why
+                # not?
+                line = line.replace('DExTer', '<r>D<y>E<g>x<b>T</></>e</>r</>')
+
+                # Apply the appropriate color method if the expression matches
+                # any of
+                # the patterns we have set up.
+                for fn, regexs in ((self.red, self.auto_reds),
+                                   (self.yellow, self.auto_yellows),
+                                   (self.green,
+                                    self.auto_greens), (self.blue,
+                                                        self.auto_blues)):
+                    if any(re.search(regex, line) for regex in regexs):
+                        fn(line, stream=stream, lock=_null_lock)
+                        break
+                else:
+                    self.default(line, stream=stream, lock=_null_lock)
+
+    def _call_color_impl(self, fn, impl, text, *args, **kwargs):
+        try:
+            self._stack.append(fn)
+            return impl(text, *args, **kwargs)
+        finally:
+            fn = self._stack.pop()
+
+    @abc.abstractmethod
+    def red_impl(self, text, stream=None, **kwargs):
+        pass
+
+    def red(self, *args, **kwargs):
+        return self._call_color_impl(self.red, self.red_impl, *args, **kwargs)
+
+    @abc.abstractmethod
+    def yellow_impl(self, text, stream=None, **kwargs):
+        pass
+
+    def yellow(self, *args, **kwargs):
+        return self._call_color_impl(self.yellow, self.yellow_impl, *args,
+                                     **kwargs)
+
+    @abc.abstractmethod
+    def green_impl(self, text, stream=None, **kwargs):
+        pass
+
+    def green(self, *args, **kwargs):
+        return self._call_color_impl(self.green, self.green_impl, *args,
+                                     **kwargs)
+
+    @abc.abstractmethod
+    def blue_impl(self, text, stream=None, **kwargs):
+        pass
+
+    def blue(self, *args, **kwargs):
+        return self._call_color_impl(self.blue, self.blue_impl, *args,
+                                     **kwargs)
+
+    @abc.abstractmethod
+    def default_impl(self, text, stream=None, **kwargs):
+        pass
+
+    def default(self, *args, **kwargs):
+        return self._call_color_impl(self.default, self.default_impl, *args,
+                                     **kwargs)
+
+    def colortest(self):
+        from itertools import combinations, permutations
+
+        fns = ((self.red, 'rrr'), (self.yellow, 'yyy'), (self.green, 'ggg'),
+               (self.blue, 'bbb'), (self.default, 'ddd'))
+
+        for l in range(1, len(fns) + 1):
+            for comb in combinations(fns, l):
+                for perm in permutations(comb):
+                    for stream in (None, self.__class__.stderr):
+                        perm[0][0]('stdout '
+                                   if stream is None else 'stderr ', stream)
+                        for fn, string in perm:
+                            fn(string, stream)
+                        self.default('\n', stream)
+
+        tests = [
+            (self.auto, 'default1<r>red2</>default3'),
+            (self.red, 'red1<r>red2</>red3'),
+            (self.blue, 'blue1<r>red2</>blue3'),
+            (self.red, 'red1<y>yellow2</>red3'),
+            (self.auto, 'default1<y>yellow2<r>red3</></>'),
+            (self.auto, 'default1<g>green2<r>red3</></>'),
+            (self.auto, 'default1<g>green2<r>red3</>green4</>default5'),
+            (self.auto, 'default1<g>green2</>default3<g>green4</>default5'),
+            (self.auto, '<r>red1<g>green2</>red3<g>green4</>red5</>'),
+            (self.auto, '<r>red1<y><g>green2</>yellow3</>green4</>default5'),
+            (self.auto, '<r><y><g><b><d>default1</></><r></></></>red2</>'),
+            (self.auto, '<r>red1</>default2<r>red3</><g>green4</>default5'),
+            (self.blue, '<r>red1</>blue2<r><r>red3</><g><g>green</></></>'),
+            (self.blue, '<r>r<r>r<y>y<r><r><r><r>r</></></></></></></>b'),
+        ]
+
+        for fn, text in tests:
+            for stream in (None, self.__class__.stderr):
+                stream_name = 'stdout' if stream is None else 'stderr'
+                fn('{} {}\n'.format(stream_name, text), stream)
+
+
+class TestPrettyOutput(unittest.TestCase):
+    class MockPrettyOutput(PrettyOutputBase):
+        def red_impl(self, text, stream=None, **kwargs):
+            self._write('[R]{}[/R]'.format(text), stream)
+
+        def yellow_impl(self, text, stream=None, **kwargs):
+            self._write('[Y]{}[/Y]'.format(text), stream)
+
+        def green_impl(self, text, stream=None, **kwargs):
+            self._write('[G]{}[/G]'.format(text), stream)
+
+        def blue_impl(self, text, stream=None, **kwargs):
+            self._write('[B]{}[/B]'.format(text), stream)
+
+        def default_impl(self, text, stream=None, **kwargs):
+            self._write('[D]{}[/D]'.format(text), stream)
+
+    def test_red(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.red('hello', stream)
+            self.assertEqual(stream.py.getvalue(), '[R]hello[/R]')
+
+    def test_yellow(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.yellow('hello', stream)
+            self.assertEqual(stream.py.getvalue(), '[Y]hello[/Y]')
+
+    def test_green(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.green('hello', stream)
+            self.assertEqual(stream.py.getvalue(), '[G]hello[/G]')
+
+    def test_blue(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.blue('hello', stream)
+            self.assertEqual(stream.py.getvalue(), '[B]hello[/B]')
+
+    def test_default(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.default('hello', stream)
+            self.assertEqual(stream.py.getvalue(), '[D]hello[/D]')
+
+    def test_auto(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.auto_reds.append('foo')
+            o.auto('bar\n', stream)
+            o.auto('foo\n', stream)
+            o.auto('baz\n', stream)
+            self.assertEqual(stream.py.getvalue(),
+                             '[D]bar\n[/D][R]foo\n[/R][D]baz\n[/D]')
+
+            stream = Stream(StringIO())
+            o.auto('bar\nfoo\nbaz\n', stream)
+            self.assertEqual(stream.py.getvalue(),
+                             '[D]bar\n[/D][R]foo\n[/R][D]baz\n[/D]')
+
+            stream = Stream(StringIO())
+            o.auto('barfoobaz\nbardoobaz\n', stream)
+            self.assertEqual(stream.py.getvalue(),
+                             '[R]barfoobaz\n[/R][D]bardoobaz\n[/D]')
+
+            o.auto_greens.append('doo')
+            stream = Stream(StringIO())
+            o.auto('barfoobaz\nbardoobaz\n', stream)
+            self.assertEqual(stream.py.getvalue(),
+                             '[R]barfoobaz\n[/R][G]bardoobaz\n[/G]')
+
+    def test_PreserveAutoColors(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            o.auto_reds.append('foo')
+            with PreserveAutoColors(o):
+                o.auto_greens.append('bar')
+                stream = Stream(StringIO())
+                o.auto('foo\nbar\nbaz\n', stream)
+                self.assertEqual(stream.py.getvalue(),
+                                 '[R]foo\n[/R][G]bar\n[/G][D]baz\n[/D]')
+
+            stream = Stream(StringIO())
+            o.auto('foo\nbar\nbaz\n', stream)
+            self.assertEqual(stream.py.getvalue(),
+                             '[R]foo\n[/R][D]bar\n[/D][D]baz\n[/D]')
+
+            stream = Stream(StringIO())
+            o.yellow('<a>foo</>bar<a>baz</>', stream)
+            self.assertEqual(
+                stream.py.getvalue(),
+                '[Y][Y][/Y][R]foo[/R][Y][Y]bar[/Y][D]baz[/D][Y][/Y][/Y][/Y]')
+
+    def test_tags(self):
+        with TestPrettyOutput.MockPrettyOutput() as o:
+            stream = Stream(StringIO())
+            o.auto('<r>hi</>', stream)
+            self.assertEqual(stream.py.getvalue(),
+                             '[D][D][/D][R]hi[/R][D][/D][/D]')
+
+            stream = Stream(StringIO())
+            o.auto('<r><y>a</>b</>c', stream)
+            self.assertEqual(
+                stream.py.getvalue(),
+                '[D][D][/D][R][R][/R][Y]a[/Y][R]b[/R][/R][D]c[/D][/D]')
+
+            with self.assertRaisesRegex(Error, 'tag mismatch'):
+                o.auto('<r>hi', stream)
+
+            with self.assertRaisesRegex(Error, 'tag mismatch'):
+                o.auto('hi</>', stream)
+
+            with self.assertRaisesRegex(Error, 'tag mismatch'):
+                o.auto('<r><y>hi</>', stream)
+
+            with self.assertRaisesRegex(Error, 'tag mismatch'):
+                o.auto('<r><y>hi</><r></>', stream)
+
+            with self.assertRaisesRegex(Error, 'tag mismatch'):
+                o.auto('</>hi<r>', stream)
diff --git a/debuginfo-tests/dexter/dex/utils/ReturnCode.py b/debuginfo-tests/dexter/dex/utils/ReturnCode.py
new file mode 100644
index 00000000000..487d225d1b6
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/ReturnCode.py
@@ -0,0 +1,20 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+from enum import Enum
+
+
+class ReturnCode(Enum):
+   """Used to indicate whole program success status."""
+
+   OK = 0
+   _ERROR = 1        # Unhandled exceptions result in exit(1) by default.
+                     # Usage of _ERROR is discouraged:
+                     # If the program cannot run, raise an exception.
+                     # If the program runs successfully but the result is
+                     # "failure" based on the inputs, return FAIL
+   FAIL = 2
diff --git a/debuginfo-tests/dexter/dex/utils/RootDirectory.py b/debuginfo-tests/dexter/dex/utils/RootDirectory.py
new file mode 100644
index 00000000000..57f204c79ac
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/RootDirectory.py
@@ -0,0 +1,15 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Utility functions related to DExTer's directory layout."""
+
+import os
+
+
+def get_root_directory():
+    root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+    assert os.path.basename(root) == 'dex', root
+    return root
diff --git a/debuginfo-tests/dexter/dex/utils/Timer.py b/debuginfo-tests/dexter/dex/utils/Timer.py
new file mode 100644
index 00000000000..63726f1a757
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/Timer.py
@@ -0,0 +1,50 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""RAII-style timer class to be used with a 'with' statement to get wall clock
+time for the contained code.
+"""
+
+import sys
+import time
+
+
+def _indent(indent):
+    return '| ' * indent
+
+
+class Timer(object):
+    fn = sys.stdout.write
+    display = False
+    indent = 0
+
+    def __init__(self, name=None):
+        self.name = name
+        self.start = self.now
+
+    def __enter__(self):
+        Timer.indent += 1
+        if Timer.display and self.name:
+            indent = _indent(Timer.indent - 1) + ' _'
+            Timer.fn('{}\n'.format(_indent(Timer.indent - 1)))
+            Timer.fn('{} start {}\n'.format(indent, self.name))
+        return self
+
+    def __exit__(self, *args):
+        if Timer.display and self.name:
+            indent = _indent(Timer.indent - 1) + '|_'
+            Timer.fn('{} {} time taken: {:0.1f}s\n'.format(
+                indent, self.name, self.elapsed))
+            Timer.fn('{}\n'.format(_indent(Timer.indent - 1)))
+        Timer.indent -= 1
+
+    @property
+    def elapsed(self):
+        return self.now - self.start
+
+    @property
+    def now(self):
+        return time.time()
diff --git a/debuginfo-tests/dexter/dex/utils/UnitTests.py b/debuginfo-tests/dexter/dex/utils/UnitTests.py
new file mode 100644
index 00000000000..5a8a0a6aeb9
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/UnitTests.py
@@ -0,0 +1,62 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Unit test harness."""
+
+from fnmatch import fnmatch
+import os
+import unittest
+
+from io import StringIO
+
+from dex.utils import is_native_windows, has_pywin32
+from dex.utils import PreserveAutoColors, PrettyOutput
+from dex.utils import Timer
+
+
+class DexTestLoader(unittest.TestLoader):
+    def _match_path(self, path, full_path, pattern):
+        """Don't try to import platform-specific modules for the wrong platform
+        during test discovery.
+        """
+        d = os.path.basename(os.path.dirname(full_path))
+        if is_native_windows():
+            if d == 'posix':
+                return False
+            if d == 'windows':
+                return has_pywin32()
+        else:
+            if d == 'windows':
+                return False
+        return fnmatch(path, pattern)
+
+
+def unit_tests_ok(context):
+    unittest.TestCase.maxDiff = None  # remove size limit from diff output.
+
+    with Timer('unit tests'):
+        suite = DexTestLoader().discover(
+            context.root_directory, pattern='*.py')
+        stream = StringIO()
+        result = unittest.TextTestRunner(verbosity=2, stream=stream).run(suite)
+
+        ok = result.wasSuccessful()
+        if not ok or context.options.unittest == 'show-all':
+            with PreserveAutoColors(context.o):
+                context.o.auto_reds.extend(
+                    [r'FAIL(ED|\:)', r'\.\.\.\s(FAIL|ERROR)$'])
+                context.o.auto_greens.extend([r'^OK$', r'\.\.\.\sok$'])
+                context.o.auto_blues.extend([r'^Ran \d+ test'])
+                context.o.default('\n')
+                for line in stream.getvalue().splitlines(True):
+                    context.o.auto(line, stream=PrettyOutput.stderr)
+
+        return ok
+
+
+class TestUnitTests(unittest.TestCase):
+    def test_sanity(self):
+        self.assertEqual(1, 1)
diff --git a/debuginfo-tests/dexter/dex/utils/Version.py b/debuginfo-tests/dexter/dex/utils/Version.py
new file mode 100644
index 00000000000..1a257fa7107
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/Version.py
@@ -0,0 +1,40 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""DExTer version output."""
+
+import os
+from subprocess import CalledProcessError, check_output, STDOUT
+import sys
+
+from dex import __version__
+
+
+def _git_version():
+    dir_ = os.path.dirname(__file__)
+    try:
+        branch = (check_output(
+            ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
+            stderr=STDOUT,
+            cwd=dir_).rstrip().decode('utf-8'))
+        hash_ = check_output(
+            ['git', 'rev-parse', 'HEAD'], stderr=STDOUT,
+            cwd=dir_).rstrip().decode('utf-8')
+        repo = check_output(
+            ['git', 'remote', 'get-url', 'origin'], stderr=STDOUT,
+            cwd=dir_).rstrip().decode('utf-8')
+        return '[{} {}] ({})'.format(branch, hash_, repo)
+    except (OSError, CalledProcessError):
+        pass
+    return None
+
+
+def version(name):
+    lines = []
+    lines.append(' '.join(
+        [s for s in [name, __version__, _git_version()] if s]))
+    lines.append('  using Python {}'.format(sys.version))
+    return '\n'.join(lines)
diff --git a/debuginfo-tests/dexter/dex/utils/Warning.py b/debuginfo-tests/dexter/dex/utils/Warning.py
new file mode 100644
index 00000000000..402861aaed5
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/Warning.py
@@ -0,0 +1,18 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Utility functions for producing command line warnings."""
+
+
+def warn(context, msg, flag=None):
+    if context.options.no_warnings:
+        return
+
+    msg = msg.rstrip()
+    if flag:
+        msg = '{} <y>[{}]</>'.format(msg, flag)
+
+    context.o.auto('warning: <d>{}</>\n'.format(msg))
diff --git a/debuginfo-tests/dexter/dex/utils/WorkingDirectory.py b/debuginfo-tests/dexter/dex/utils/WorkingDirectory.py
new file mode 100644
index 00000000000..e1862f2db72
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/WorkingDirectory.py
@@ -0,0 +1,46 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Create/set a temporary working directory for some operations."""
+
+import os
+import shutil
+import tempfile
+import time
+
+from dex.utils.Exceptions import Error
+
+
+class WorkingDirectory(object):
+    def __init__(self, context, *args, **kwargs):
+        self.context = context
+        self.orig_cwd = os.getcwd()
+
+        dir_ = kwargs.get('dir', None)
+        if dir_ and not os.path.isdir(dir_):
+            os.makedirs(dir_, exist_ok=True)
+        self.path = tempfile.mkdtemp(*args, **kwargs)
+
+    def __enter__(self):
+        os.chdir(self.path)
+        return self
+
+    def __exit__(self, *args):
+        os.chdir(self.orig_cwd)
+        if self.context.options.save_temps:
+            self.context.o.blue('"{}" left in place [--save-temps]\n'.format(
+                self.path))
+            return
+
+        exception = AssertionError('should never be raised')
+        for _ in range(100):
+            try:
+                shutil.rmtree(self.path)
+                return
+            except OSError as e:
+                exception = e
+                time.sleep(0.1)
+        raise Error(exception)
diff --git a/debuginfo-tests/dexter/dex/utils/__init__.py b/debuginfo-tests/dexter/dex/utils/__init__.py
new file mode 100644
index 00000000000..ac08139d568
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/__init__.py
@@ -0,0 +1,21 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Generic non-dexter-specific utility classes and functions."""
+
+import os
+
+from dex.utils.Environment import is_native_windows, has_pywin32
+from dex.utils.PrettyOutputBase import PreserveAutoColors
+from dex.utils.RootDirectory import get_root_directory
+from dex.utils.Timer import Timer
+from dex.utils.Warning import warn
+from dex.utils.WorkingDirectory import WorkingDirectory
+
+if is_native_windows():
+    from dex.utils.windows.PrettyOutput import PrettyOutput
+else:
+    from dex.utils.posix.PrettyOutput import PrettyOutput
diff --git a/debuginfo-tests/dexter/dex/utils/posix/PrettyOutput.py b/debuginfo-tests/dexter/dex/utils/posix/PrettyOutput.py
new file mode 100644
index 00000000000..82cfed5dfd6
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/posix/PrettyOutput.py
@@ -0,0 +1,34 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Provides POSIX implementation of formatted/colored console output."""
+
+from ..PrettyOutputBase import PrettyOutputBase, _lock
+
+
+class PrettyOutput(PrettyOutputBase):
+    def _color(self, text, color, stream, lock=_lock):
+        """Use ANSI escape codes to provide color on Linux."""
+        stream = self._set_valid_stream(stream)
+        with lock:
+            if stream.color_enabled:
+                text = '\033[{}m{}\033[0m'.format(color, text)
+            self._write(text, stream)
+
+    def red_impl(self, text, stream=None, **kwargs):
+        self._color(text, 91, stream, **kwargs)
+
+    def yellow_impl(self, text, stream=None, **kwargs):
+        self._color(text, 93, stream, **kwargs)
+
+    def green_impl(self, text, stream=None, **kwargs):
+        self._color(text, 92, stream, **kwargs)
+
+    def blue_impl(self, text, stream=None, **kwargs):
+        self._color(text, 96, stream, **kwargs)
+
+    def default_impl(self, text, stream=None, **kwargs):
+        self._color(text, 0, stream, **kwargs)
diff --git a/debuginfo-tests/dexter/dex/utils/posix/__init__.py b/debuginfo-tests/dexter/dex/utils/posix/__init__.py
new file mode 100644
index 00000000000..1194affd891
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/posix/__init__.py
@@ -0,0 +1,6 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
diff --git a/debuginfo-tests/dexter/dex/utils/windows/PrettyOutput.py b/debuginfo-tests/dexter/dex/utils/windows/PrettyOutput.py
new file mode 100644
index 00000000000..657406a59ac
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/windows/PrettyOutput.py
@@ -0,0 +1,83 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Provides Windows implementation of formatted/colored console output."""
+
+import sys
+
+import ctypes
+import ctypes.wintypes
+
+from ..PrettyOutputBase import PrettyOutputBase, Stream, _lock, _null_lock
+
+
+class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
+    # pylint: disable=protected-access
+    _fields_ = [('dwSize', ctypes.wintypes._COORD), ('dwCursorPosition',
+                                                     ctypes.wintypes._COORD),
+                ('wAttributes',
+                 ctypes.c_ushort), ('srWindow', ctypes.wintypes._SMALL_RECT),
+                ('dwMaximumWindowSize', ctypes.wintypes._COORD)]
+    # pylint: enable=protected-access
+
+
+class PrettyOutput(PrettyOutputBase):
+
+    stdout = Stream(sys.stdout, ctypes.windll.kernel32.GetStdHandle(-11))
+    stderr = Stream(sys.stderr, ctypes.windll.kernel32.GetStdHandle(-12))
+
+    def __enter__(self):
+        info = _CONSOLE_SCREEN_BUFFER_INFO()
+
+        for s in (PrettyOutput.stdout, PrettyOutput.stderr):
+            ctypes.windll.kernel32.GetConsoleScreenBufferInfo(
+                s.os, ctypes.byref(info))
+            s.orig_color = info.wAttributes
+
+        return self
+
+    def __exit__(self, *args):
+        self._restore_orig_color(PrettyOutput.stdout)
+        self._restore_orig_color(PrettyOutput.stderr)
+
+    def _restore_orig_color(self, stream, lock=_lock):
+        if not stream.color_enabled:
+            return
+
+        with lock:
+            stream = self._set_valid_stream(stream)
+            self.flush(stream)
+            if stream.orig_color:
+                ctypes.windll.kernel32.SetConsoleTextAttribute(
+                    stream.os, stream.orig_color)
+
+    def _color(self, text, color, stream, lock=_lock):
+        stream = self._set_valid_stream(stream)
+        with lock:
+            try:
+                if stream.color_enabled:
+                    ctypes.windll.kernel32.SetConsoleTextAttribute(
+                        stream.os, color)
+                self._write(text, stream)
+            finally:
+                if stream.color_enabled:
+                    self._restore_orig_color(stream, lock=_null_lock)
+
+    def red_impl(self, text, stream=None, **kwargs):
+        self._color(text, 12, stream, **kwargs)
+
+    def yellow_impl(self, text, stream=None, **kwargs):
+        self._color(text, 14, stream, **kwargs)
+
+    def green_impl(self, text, stream=None, **kwargs):
+        self._color(text, 10, stream, **kwargs)
+
+    def blue_impl(self, text, stream=None, **kwargs):
+        self._color(text, 11, stream, **kwargs)
+
+    def default_impl(self, text, stream=None, **kwargs):
+        stream = self._set_valid_stream(stream)
+        self._color(text, stream.orig_color, stream, **kwargs)
diff --git a/debuginfo-tests/dexter/dex/utils/windows/__init__.py b/debuginfo-tests/dexter/dex/utils/windows/__init__.py
new file mode 100644
index 00000000000..1194affd891
--- /dev/null
+++ b/debuginfo-tests/dexter/dex/utils/windows/__init__.py
@@ -0,0 +1,6 @@
+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception