# Copyright 2022 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging
import os
import re
import subprocess

_CHROME_SRC = os.path.join(os.path.dirname(__file__), os.pardir, os.pardir)
_LLVM_OBJDUMP_PATH = os.path.join(
    _CHROME_SRC,
    'third_party',
    'llvm-build',
    'Release+Asserts',
    'bin',
    'llvm-objdump',
)

# Function lines look like:
#   000177b0 <android::IBinder::~IBinder()+0x2c>:
# We pull out the address and function first. Then we check for an optional
# offset. This is tricky due to functions that look like "operator+(..)+0x2c"
_FUNC = re.compile(r"(^[a-f0-9]*) <(.*)>:$")
_OFFSET = re.compile(r"(.*)\+0x([a-f0-9]*)")

# A disassembly line looks like:
#   177b2:  b510        push  {r4, lr}
_ASM = re.compile(r"(^[ a-f0-9]*):[ a-f0-0]*.*$")


def _StripPC(addr, cpu_arch):
    """Strips the Thumb bit from a program counter address when appropriate.

    Args:
      addr: the program counter address
      cpu_arch: Target CPU architecture.

    Returns:
      The stripped program counter address.
    """
    if cpu_arch == "arm":
        return addr & ~1
    return addr


class ObjdumpInformation(object):
    def __init__(self, address, library, symbol, offset):
        self.address = address
        self.library = library
        self.symbol = symbol
        self.offset = offset


class LLVMObjdumper(object):
    def __init__(self):
        """Creates an instance of LLVMObjdumper that interacts with
        llvm-objdump.
        """
        self._llvm_objdump_parameters = [
            '--disassemble',
            '--demangle',
            '--section=.text',
        ]

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

    @staticmethod
    def GetSymbolDataFromObjdumpOutput(objdump_out, address, cpu_arch):
        stripped_target_address = _StripPC(address, cpu_arch)
        for line in objdump_out.split(os.linesep):
            components = _FUNC.match(line)
            if components:
                # This is a new function, so record the current function and its
                # address.
                current_symbol_addr = int(components.group(1), 16)
                current_symbol = components.group(2)

                # Does it have an optional offset like: "foo(..)+0x2c"?
                components = _OFFSET.match(current_symbol)
                if components:
                    current_symbol = components.group(1)
                    offset = components.group(2)
                    if offset:
                        current_symbol_addr -= int(offset, 16)

            # Is it a disassembly line like:
            # "177b2:  b510        push  {r4, lr}"?
            components = _ASM.match(line)
            if components:
                addr = components.group(1)
                i_addr = int(addr, 16)
                if i_addr == stripped_target_address:
                    return (
                        current_symbol,
                        stripped_target_address - current_symbol_addr,
                    )

        return (None, None)

    def GetSymbolInformation(self, lib, address, cpu_arch):
        """Returns the corresponding function names and line numbers.

        Args:
          lib: library to search for info.
          address: address to look for info.
          cpu_arch: architecture where the dump was taken

        Returns:
          An ObjdumpInformation object
        """
        if not os.path.isfile(_LLVM_OBJDUMP_PATH):
            logging.error(
                'Cannot find llvm-objdump. path=%s', _LLVM_OBJDUMP_PATH
            )
            return None

        stripped_address = _StripPC(address, cpu_arch)

        full_arguments = [_LLVM_OBJDUMP_PATH] + self._llvm_objdump_parameters
        full_arguments.append('--start-address=' + str(stripped_address))
        full_arguments.append('--stop-address=' + str(stripped_address + 8))
        full_arguments.append(lib)

        objdump_process = subprocess.Popen(
            full_arguments,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            universal_newlines=True,
        )

        stdout, stderr = objdump_process.communicate()
        objdump_process_return_code = objdump_process.poll()

        if objdump_process_return_code != 0:
            logging.error(
                'Invocation of llvm-objdump failed!'
                + ' tool-command-line=\'{}\', return-code={}, std-error=\'{}\''.format(
                    ' '.join(full_arguments),
                    objdump_process_return_code,
                    stderr,
                )
            )
            return None

        symbol, offset = LLVMObjdumper.GetSymbolDataFromObjdumpOutput(
            stdout, address, cpu_arch
        )

        return ObjdumpInformation(
            address=address, library=lib, symbol=symbol, offset=offset
        )