#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import abc
import enum
import re
import sys
import traceback
from dataclasses import dataclass
from typing import ClassVar, List, Optional, Tuple, Type


class DebuggerValue(abc.ABC):
    """
    Represents a value from the debugger. This could represent the value
    of a variable, register, or expression.
    """

    @staticmethod
    @abc.abstractmethod
    def nullptr() -> "DebuggerValue":
        """
        Returns a nullptr value.
        """
        pass

    @staticmethod
    @abc.abstractmethod
    def parse_and_eval(expr: str) -> "DebuggerValue":
        """
        Executes `expr` in the debugger and returns the value.
        """
        pass

    @staticmethod
    @abc.abstractmethod
    def execute(expr: str) -> str:
        """
        Executes `expr` and returns the debugger output.
        """
        pass

    @staticmethod
    @abc.abstractmethod
    def get_current_pthread_addr() -> "DebuggerValue":
        """
        Returns a pointer to the current pthread. Returns nullptr if not found
        """
        pass

    @staticmethod
    @abc.abstractmethod
    def get_register(register: str) -> "DebuggerValue":
        """
        Returns the value in the provided register.
        """
        pass

    @abc.abstractmethod
    def get_field(self, n: int) -> "DebuggerValue":
        """
        This assumes the value is a pointer to a struct that consists entirely
        of pointers. Returns the n-th pointer in the struct.
        """
        pass

    @abc.abstractmethod
    def is_nullptr(self) -> bool:
        """
        Returns True if the value is nullptr or 0.
        """
        pass

    @abc.abstractmethod
    def int_value(self) -> int:
        """
        Returns the int value of the debugger value
        """
        pass

    @abc.abstractmethod
    def to_hex(self) -> str:
        """
        Returns the value in hex padded with leading zeroes.
        """
        pass

    @abc.abstractmethod
    def get_file_name_and_line(self) -> Optional[Tuple[str, int]]:
        """
        Returns the file name and line number of the value.
        Assumes the value is a pointer to an instruction.
        Returns None if the name could not be found.
        """
        pass

    @abc.abstractmethod
    def get_func_name(self) -> Optional[str]:
        """
        Returns the function name of the value. Returns None if the name could
        not be found
        """
        pass


"""
These are the memory representations of the types folly uses for tracking
async stacks. See folly/tracing/AsyncStack.h

// Pointed to by thread local storage
struct AsyncStackRootHolder {
  AsyncStackRoot* value;
};

struct AsyncStackRoot {
  AsyncStackFrame* topFrame;
  AsyncStackRoot* nextRoot;
  void* stackFramePtr;
  void* returnAddress;
};

struct AsyncStackFrame {
  AsyncStackFrame* parentFrame;
  void* instructionPointer;
  AsyncStackRoot* stackRoot;
};

// Memory representation of how the compiler generates stack frames
struct StackFrame {
  StackFrame* stackFrame;
  void* returnAddress;
};
"""

# Key used in pthread thread local storage to hold a pointer to
# AsyncStackRootHolder
ASYNC_STACK_ROOT_TLS_KEY = "folly_async_stack_root_tls_key"


@dataclass
class AsyncStackRootHolder:
    value: DebuggerValue

    @staticmethod
    def from_addr(addr: DebuggerValue) -> "AsyncStackRootHolder":
        return AsyncStackRootHolder(
            value=addr.get_field(0),
        )


@dataclass
class AsyncStackRoot:
    top_frame: DebuggerValue
    next_root: DebuggerValue
    stack_frame_ptr: DebuggerValue
    stack_root: DebuggerValue

    @staticmethod
    def from_addr(addr: DebuggerValue) -> "AsyncStackRoot":
        return AsyncStackRoot(
            top_frame=addr.get_field(0),
            next_root=addr.get_field(1),
            stack_frame_ptr=addr.get_field(2),
            stack_root=addr.get_field(3),
        )


@dataclass
class AsyncStackFrame:
    parent_frame: DebuggerValue
    instruction_pointer: DebuggerValue
    stack_root: DebuggerValue

    @staticmethod
    def from_addr(addr: DebuggerValue) -> "AsyncStackFrame":
        return AsyncStackFrame(
            parent_frame=addr.get_field(0),
            instruction_pointer=addr.get_field(1),
            stack_root=addr.get_field(2),
        )


@dataclass
class StackFrame:
    stack_frame: DebuggerValue
    return_address: DebuggerValue

    @staticmethod
    def from_addr(addr: DebuggerValue) -> "StackFrame":
        return StackFrame(
            stack_frame=addr.get_field(0),
            return_address=addr.get_field(1),
        )


def get_async_stack_root_addr(
    debugger_value_class: Type[DebuggerValue],
) -> DebuggerValue:
    """
    Returns a pointer to the top-most async stack root, or a nullptr if none
    exists.
    """
    pthread_addr = debugger_value_class.get_current_pthread_addr()
    if pthread_addr.is_nullptr():
        return debugger_value_class.nullptr()

    # Check if the tls key is initialized
    tls_key = debugger_value_class.parse_and_eval(
        f"(uint64_t){ASYNC_STACK_ROOT_TLS_KEY}"
    )
    if (tls_key.int_value() % (2**32)) == ((2**32) - 1):
        return debugger_value_class.nullptr()

    # get the stack root pointer from thread-local storage
    try:
        # Note: "struct pthread" is the implementation type for "pthread_t".
        # Its symbol information may not be available, depending if pthread
        # debug symbols are available.
        async_stack_root_holder_addr = debugger_value_class.parse_and_eval(
            f"((struct pthread*){pthread_addr.to_hex()})->specific"
            f"[(int){tls_key.to_hex()}/32]"
            f"[(int){tls_key.to_hex()}%32]"
            ".data"
        )
        if async_stack_root_holder_addr.is_nullptr():
            raise Exception("struct pthread info not found")
    except Exception:
        # If "struct pthread" isn't defined, use the precalculated offset.
        # Note: The offset is specific to linux x86_64.
        specific_offset = 1296
        specific_addr = debugger_value_class.parse_and_eval(
            f"{pthread_addr.to_hex()}+{specific_offset}"
        )
        specific_second_level_addr = specific_addr.get_field(tls_key.int_value() // 32)
        # pthread_key_data is equivalent to uintptr_t[2]
        # We want the N-th pthread_key_data, and the second pointer inside
        # pthread_key_data. So we want the uintptr_t at the 2 * N + 1 position
        async_stack_root_holder_addr = specific_second_level_addr.get_field(
            (2 * (tls_key.int_value() % 32)) + 1
        )

    if async_stack_root_holder_addr.is_nullptr():
        return debugger_value_class.nullptr()
    async_stack_root_holder = AsyncStackRootHolder.from_addr(
        async_stack_root_holder_addr
    )
    return async_stack_root_holder.value


def print_async_stack_addrs(addrs: List[DebuggerValue]) -> None:
    if len(addrs) == 0:
        print("No async operation detected")
        return
    num_digits = len(str(len(addrs)))
    for (i, addr) in enumerate(addrs):
        func_name = addr.get_func_name()
        if func_name is None:
            func_name = "???"
        file_name_line_pair = addr.get_file_name_and_line()
        if file_name_line_pair is None:
            file_name = "???"
            line = 0
        else:
            file_name, line = file_name_line_pair
        print(
            f"#{str(i).ljust(num_digits, ' ')}"
            f" {addr.to_hex()} in {func_name} () at {file_name}:{line}"
        )


def get_async_stack_addrs_from_initial_frame(
    async_stack_frame_addr: DebuggerValue,
) -> List[DebuggerValue]:
    """
    Gets the list of async stack frames rooted at the current frame
    """
    addrs: List[DebuggerValue] = []
    while not async_stack_frame_addr.is_nullptr():
        async_stack_frame = AsyncStackFrame.from_addr(async_stack_frame_addr)
        addrs.append(async_stack_frame.instruction_pointer)
        async_stack_frame_addr = async_stack_frame.parent_frame
    return addrs


def walk_normal_stack(
    normal_stack_frame_addr: DebuggerValue,
    normal_stack_frame_stop_addr: DebuggerValue,
) -> List[DebuggerValue]:
    """
    Returns the list of return addresses in the normal stack.
    Does not include stop_addr
    """
    addrs: List[DebuggerValue] = []
    while not normal_stack_frame_addr.is_nullptr():
        normal_stack_frame = StackFrame.from_addr(normal_stack_frame_addr)
        if (
            not normal_stack_frame_stop_addr.is_nullptr()
            and normal_stack_frame.stack_frame == normal_stack_frame_stop_addr
        ):
            # Reached end of normal stack, transition to the async stack
            # Do not include the return address in the stack trace that points
            # to the frame that registered the AsyncStackRoot.
            break
        addrs.append(normal_stack_frame.return_address)
        normal_stack_frame_addr = normal_stack_frame.stack_frame
    return addrs


@dataclass
class WalkAsyncStackResult:
    addrs: List[DebuggerValue]
    # Normal stack frame to start the next normal stack walk
    normal_stack_frame_addr: DebuggerValue
    normal_stack_frame_stop_addr: DebuggerValue
    # Async stack frame to start the next async stack walk after the next
    # normal stack walk
    async_stack_frame_addr: DebuggerValue


def walk_async_stack(
    debugger_value_class: Type[DebuggerValue],
    async_stack_frame_addr: DebuggerValue,
) -> WalkAsyncStackResult:
    """
    Walks the async stack and returns the next normal stack and async stack
    addresses to walk.
    """
    addrs: List[DebuggerValue] = []
    normal_stack_frame_addr = debugger_value_class.nullptr()
    normal_stack_frame_stop_addr = debugger_value_class.nullptr()
    async_stack_frame_next_addr = debugger_value_class.nullptr()
    while not async_stack_frame_addr.is_nullptr():
        async_stack_frame = AsyncStackFrame.from_addr(async_stack_frame_addr)
        addrs.append(async_stack_frame.instruction_pointer)

        if async_stack_frame.parent_frame.is_nullptr():
            # Reached end of async stack
            # Check if there is an AsyncStackRoot and if so, whether there
            # is an associated stack frame that indicates the normal stack
            # frame we should continue walking at.
            async_stack_root_addr = async_stack_frame.stack_root
            if async_stack_root_addr.is_nullptr():
                # This is a detached async stack. We are done
                break
            async_stack_root = AsyncStackRoot.from_addr(async_stack_root_addr)
            normal_stack_frame_addr = async_stack_root.stack_frame_ptr
            if normal_stack_frame_addr.is_nullptr():
                # No associated normal stack frame for this async stack root.
                # This means we should treat this as a top-level/detached
                # stack and not try to walk any further.
                break
            # Skip to the parent stack frame pointer
            normal_stack_frame = StackFrame.from_addr(normal_stack_frame_addr)
            normal_stack_frame_addr = normal_stack_frame.stack_frame

            # Check if there is a higher-level AsyncStackRoot that defines
            # the stop point we should stop walking normal stack frames at.
            # If there is no higher stack root then we will walk to the
            # top of the normal stack (normalStackFrameStop == nullptr).
            # Otherwise we record the frame pointer that we should stop
            # at and walk normal stack frames until we hit that frame.
            # Also get the async stack frame where the next async stack walk
            # should begin after the next normal stack walk finishes.
            async_stack_root_addr = async_stack_root.next_root
            if not async_stack_root_addr.is_nullptr():
                async_stack_root = AsyncStackRoot.from_addr(async_stack_root_addr)
                normal_stack_frame_stop_addr = async_stack_root.stack_frame_ptr
                async_stack_frame_next_addr = async_stack_root.top_frame

        async_stack_frame_addr = async_stack_frame.parent_frame

    return WalkAsyncStackResult(
        addrs=addrs,
        normal_stack_frame_addr=normal_stack_frame_addr,
        normal_stack_frame_stop_addr=normal_stack_frame_stop_addr,
        async_stack_frame_addr=async_stack_frame_next_addr,
    )


def get_async_stack_addrs(
    debugger_value_class: Type[DebuggerValue],
) -> List[DebuggerValue]:
    """
    Gets the async stack trace, including normal stack frames with async
    stack frames.

    See C++ implementation in `getAsyncStackTraceSafe` in
    folly/experimental/symbolizer/StackTrace.cpp
    """
    async_stack_root_addr = get_async_stack_root_addr(debugger_value_class)

    # If we have no async stack root, this should return no frames.
    # If we do have a stack root, also include the current return address.
    if async_stack_root_addr.is_nullptr():
        return []

    # Start the stack trace from the top
    debugger_value_class.execute("f 0")

    # Start by walking the normal stack until we get to the frame right before
    # the frame that holds the async root.
    async_stack_root = AsyncStackRoot.from_addr(async_stack_root_addr)
    normal_stack_frame_addr = debugger_value_class.get_register("rbp")
    normal_stack_frame_stop_addr = async_stack_root.stack_frame_ptr
    addrs: List[DebuggerValue] = []
    addrs.append(debugger_value_class.get_register("pc"))
    async_stack_frame_addr = async_stack_root.top_frame

    while (
        not normal_stack_frame_addr.is_nullptr()
        or not async_stack_frame_addr.is_nullptr()
    ):
        addrs += walk_normal_stack(
            normal_stack_frame_addr, normal_stack_frame_stop_addr
        )
        walk_async_stack_result = walk_async_stack(
            debugger_value_class, async_stack_frame_addr
        )
        addrs += walk_async_stack_result.addrs
        normal_stack_frame_addr = walk_async_stack_result.normal_stack_frame_addr
        normal_stack_frame_stop_addr = (
            walk_async_stack_result.normal_stack_frame_stop_addr
        )
        async_stack_frame_addr = walk_async_stack_result.async_stack_frame_addr
    return addrs


def print_async_stack_root_addrs(addrs: List[DebuggerValue]) -> None:
    if len(addrs) == 0:
        print("No async stack roots detected")
        return
    num_digits = len(str(len(addrs)))
    for (i, addr) in enumerate(addrs):
        async_stack_root = AsyncStackRoot.from_addr(addr)
        if not async_stack_root.stack_frame_ptr.is_nullptr():
            stack_frame = StackFrame.from_addr(async_stack_root.stack_frame_ptr)
            func_name = stack_frame.return_address.get_func_name()
            if func_name is None:
                func_name = "???"
            file_name_line_pair = stack_frame.return_address.get_file_name_and_line()
            if file_name_line_pair is not None:
                file_name, line = file_name_line_pair
            else:
                file_name = "???"
                line = 0
        else:
            func_name = "???"
            file_name = "???"
            line = 0
        print(
            f"#{str(i).ljust(num_digits, ' ')}"
            f" async stack root {addr.to_hex()}"
            f" located in normal stack frame {async_stack_root.stack_frame_ptr.to_hex()}"
            f" in {func_name} () at {file_name}:{line}"
        )


def get_async_stack_root_addrs(
    debugger_value_class: Type[DebuggerValue],
) -> List[DebuggerValue]:
    """
    Gets all the async stack roots that exist for the current thread.
    """
    addrs: List[DebuggerValue] = []
    async_stack_root_addr = get_async_stack_root_addr(debugger_value_class)
    while not async_stack_root_addr.is_nullptr():
        addrs.append(async_stack_root_addr)
        async_stack_root = AsyncStackRoot.from_addr(async_stack_root_addr)
        async_stack_root_addr = async_stack_root.next_root
    return addrs


def backtrace_command(
    debugger_value_class: Type[DebuggerValue],
    stack_root: Optional[str],
) -> None:
    try:
        addrs: List[DebuggerValue] = []
        if stack_root:
            async_stack_root_addr = debugger_value_class.parse_and_eval(stack_root)
            if not async_stack_root_addr.is_nullptr():
                async_stack_root = AsyncStackRoot.from_addr(async_stack_root_addr)
                addrs = get_async_stack_addrs_from_initial_frame(
                    async_stack_root.top_frame
                )
        else:
            addrs = get_async_stack_addrs(debugger_value_class)
        print_async_stack_addrs(addrs)
    except Exception:
        print("Error collecting async stack trace:")
        traceback.print_exception(*sys.exc_info())


def async_stack_roots_command(debugger_value_class: Type[DebuggerValue]) -> None:
    addrs = get_async_stack_root_addrs(debugger_value_class)
    print_async_stack_root_addrs(addrs)


def co_bt_info() -> str:
    return """Command: co_bt [async_stack_root_addr]

Prints async stack trace for the current thread.
If an async stack root address is provided,
prints the async stack starting from this root.
"""


def co_async_stack_root_info() -> str:
    return """Command: co_async_stack_roots

Prints all async stack roots.
"""


class DebuggerType(enum.Enum):
    GDB = 0
    LLDB = 1


debugger_type: Optional[DebuggerType] = None
if debugger_type is None:  # noqa: C901
    try:
        import gdb

        class GdbValue(DebuggerValue):
            """
            GDB implementation of a debugger value
            """

            value: gdb.Value

            def __init__(self, value: gdb.Value) -> None:
                self.value = value

            @staticmethod
            def nullptr() -> DebuggerValue:
                return GdbValue.parse_and_eval("0x0")

            @staticmethod
            def parse_and_eval(expr: str) -> DebuggerValue:
                return GdbValue(gdb.parse_and_eval(expr))

            @staticmethod
            def execute(expr: str) -> str:
                return gdb.execute(expr, from_tty=False, to_string=True)

            @staticmethod
            def get_current_pthread_addr() -> DebuggerValue:
                try:
                    # On Linux x86_64, the pthread struct pointer is stored
                    # in the fs_base virtual register. Try to read it from
                    # this register first.
                    fs_base = GdbValue.get_register("fs_base")
                    if not fs_base.is_nullptr():
                        return fs_base
                except Exception:
                    pass
                regex = re.compile(r"\[Current thread is.*\(Thread (.*) \(LWP .*\)\)")
                output = GdbValue.execute("thread").split("\n")[0]
                groups = regex.match(output)
                return (
                    GdbValue.parse_and_eval(groups.group(1))
                    if groups
                    else GdbValue.nullptr()
                )

            @staticmethod
            def get_register(register: str) -> DebuggerValue:
                return GdbValue.parse_and_eval(f"${register}")

            def get_field(self, n: int) -> DebuggerValue:
                return GdbValue.parse_and_eval(f"((uintptr_t*){self.value})[{n}]")

            def is_nullptr(self) -> bool:
                return int(self.value) == 0

            def int_value(self) -> int:
                return int(self.value)

            def to_hex(self) -> str:
                return f"{int(self.value):#0{18}x}"

            def get_file_name_and_line(self) -> Optional[Tuple[str, int]]:
                regex = re.compile(r"Line (\d+) of (.*) starts at.*")
                output = GdbValue.execute(f"info line *{self.to_hex()}",).split(
                    "\n"
                )[0]
                groups = regex.match(output)
                return (
                    (groups.group(2).strip('"'), int(groups.group(1)))
                    if groups
                    else None
                )

            def get_func_name(self) -> Optional[str]:
                regex = re.compile(r"(.*) \+ \d+ in section.* of .*")
                output = GdbValue.execute(f"info symbol {self.to_hex()}",).split(
                    "\n"
                )[0]
                groups = regex.match(output)
                return groups.group(1) if groups else None

        class GdbCoroBacktraceCommand(gdb.Command):
            def __init__(self):
                print(co_bt_info())
                super(GdbCoroBacktraceCommand, self).__init__("co_bt", gdb.COMMAND_USER)

            def invoke(self, arg: str, from_tty: bool):
                backtrace_command(GdbValue, arg)

        class GdbCoroAsyncStackRootsCommand(gdb.Command):
            def __init__(self):
                print(co_async_stack_root_info())
                super(GdbCoroAsyncStackRootsCommand, self).__init__(
                    "co_async_stack_roots", gdb.COMMAND_USER
                )

            def invoke(self, arg: str, from_tty: bool):
                async_stack_roots_command(GdbValue)

        debugger_type = DebuggerType.GDB
    except Exception:
        pass

if debugger_type is None:  # noqa: C901
    try:
        import lldb

        class LldbValue(DebuggerValue):
            """
            LLDB implementation of a debugger value
            """

            exe_ctx: ClassVar[Optional[lldb.SBExecutionContext]] = None
            next_name_num: ClassVar[int] = 0
            value: lldb.SBValue

            def __init__(self, value: lldb.SBValue) -> None:
                self.value = value

            @staticmethod
            def nullptr() -> DebuggerValue:
                return LldbValue.parse_and_eval("nullptr")

            @staticmethod
            def parse_and_eval(expr: str) -> DebuggerValue:
                value = LldbValue(
                    LldbValue.exe_ctx.GetTarget().CreateValueFromExpression(
                        f"{LldbValue.next_name_num}", expr
                    )
                )
                LldbValue.next_name_num += 1
                return value

            @staticmethod
            def execute(expr: str) -> str:
                return_obj = lldb.SBCommandReturnObject()
                LldbValue.exe_ctx.GetTarget().GetDebugger().GetCommandInterpreter().HandleCommand(
                    expr, LldbValue.exe_ctx, return_obj, False
                )
                if return_obj.Succeeded():
                    return return_obj.GetOutput()
                return return_obj.GetError()

            @staticmethod
            def get_current_pthread_addr() -> DebuggerValue:
                try:
                    # On Linux x86_64, the pthread struct pointer is stored
                    # in the fs_base virtual register.
                    # LLDB upstream currently does not provide support for
                    # the lldb fs_base virtual register, see:
                    # https://discourse.llvm.org/t/how-to-get-pthread-pointer-from-lldb/70542
                    # Internally, we have a patch to add support for fs_base on
                    # Linux x86_64 that we will upstream soon.
                    # In this case, try to use the fs_base register if it
                    # exists, otherwise fall back to other ways:
                    fs_base = LldbValue.get_register("fs_base")
                    if not fs_base.is_nullptr():
                        return fs_base
                except Exception:
                    pass

                # If we are a live process, try to call this helper to get
                # the pthread struct pointer. Note that this may not work
                # on core dumps or optimized builds.
                result = LldbValue.exe_ctx.GetFrame().EvaluateExpression(
                    "(struct pthread*)pthread_self()"
                )
                if result.GetError().Success():
                    return LldbValue(result)
                return LldbValue.nullptr()

            @staticmethod
            def get_register(register: str) -> DebuggerValue:
                return LldbValue(LldbValue.exe_ctx.GetFrame().FindRegister(register))

            def get_field(self, n: int) -> DebuggerValue:
                # Linux x86_64 size of a pointer
                ptr_size = 8
                ptr_type = (
                    LldbValue.exe_ctx.GetTarget()
                    .FindFirstType("uintptr_t")
                    .GetPointerType()
                )
                address = lldb.SBAddress(
                    self.int_value() + ptr_size * n,
                    LldbValue.exe_ctx.GetTarget(),
                )
                value = LldbValue(
                    LldbValue.exe_ctx.GetTarget().CreateValueFromAddress(
                        f"{LldbValue.next_name_num}", address, ptr_type
                    )
                )
                LldbValue.next_name_num += 1
                return value

            def is_nullptr(self) -> bool:
                return int(self.value.value, 0) == 0

            def int_value(self) -> int:
                return int(self.value.value, 0)

            def to_hex(self) -> str:
                return f"{int(self.value.value, 0):#0{18}x}"

            # Type must be in quotes because it breaks parsing
            # with conditional imports
            def _get_symbol_context(self) -> "lldb.SBSymbolContext":
                address = lldb.SBAddress(
                    self.int_value(), LldbValue.exe_ctx.GetTarget()
                )
                return LldbValue.exe_ctx.GetTarget().ResolveSymbolContextForAddress(
                    address, lldb.eSymbolContextEverything
                )

            def get_file_name_and_line(self) -> Optional[Tuple[str, int]]:
                symbol_context = self._get_symbol_context()
                line_entry = symbol_context.GetLineEntry()
                path = line_entry.GetFileSpec().fullpath
                if path:
                    return (path, line_entry.GetLine())
                return None

            def get_func_name(self) -> Optional[str]:
                symbol_context = self._get_symbol_context()
                if symbol_context.GetFunction().IsValid():
                    return symbol_context.GetFunction().GetDisplayName()
                return symbol_context.GetSymbol().GetDisplayName()

        class LldbCoroBacktraceCommand:
            program: ClassVar[str] = "co_bt"

            def __init__(self, debugger, internal_dict):
                pass

            @classmethod
            def register_lldb_command(cls, debugger, module_name):
                command = (
                    f"command script add -c {module_name}.{cls.__name__} {cls.program}"
                )
                debugger.HandleCommand(command)

            def get_short_help(self):
                return co_bt_info()

            def get_long_help(self):
                return co_bt_info()

            def __call__(self, debugger, command, exe_ctx, result):
                LldbValue.exe_ctx = exe_ctx
                backtrace_command(LldbValue, command)

        class LldbCoroAsyncStackRootsCommand:
            program = "co_async_stack_roots"

            def __init__(self, debugger, internal_dict):
                pass

            @classmethod
            def register_lldb_command(cls, debugger, module_name):
                command = (
                    f"command script add -c {module_name}.{cls.__name__} {cls.program}"
                )
                debugger.HandleCommand(command)

            def get_short_help(self):
                return co_async_stack_root_info()

            def get_long_help(self):
                return co_async_stack_root_info()

            def __call__(self, debugger, command, exe_ctx, result):
                LldbValue.exe_ctx = exe_ctx
                async_stack_roots_command(LldbValue)

        debugger_type = DebuggerType.LLDB
    except Exception:
        pass


def info():
    return f"""Pretty printers for folly::coro. Available commands:
{co_bt_info()}

{co_async_stack_root_info()}
"""


def load(debugger=None) -> None:
    """
    This debugger script is meant to work with both lldb and gdb. Use
    conditional imports, as one will not be defined when we use the other.
    """
    if debugger_type == DebuggerType.GDB:
        GdbCoroBacktraceCommand()
        GdbCoroAsyncStackRootsCommand()
    elif debugger_type == DebuggerType.LLDB:
        LldbCoroBacktraceCommand.register_lldb_command(debugger, __name__)
        LldbCoroAsyncStackRootsCommand.register_lldb_command(debugger, __name__)
    else:
        pass


def __lldb_init_module(debugger, internal_dict) -> None:
    """
    This function will be invoked automatically by lldb when we run:

    command script import <path>

    debugger will be of type lldb.SBDebugger
    """
    load(debugger)


if __name__ == "__main__":
    load()
