#!/usr/bin/env python
#
# ESP32 core dump Utility

from __future__ import print_function
from __future__ import unicode_literals
from __future__ import division
from hashlib import sha256
import sys
try:
    from builtins import zip
    from builtins import str
    from builtins import range
    from past.utils import old_div
    from builtins import object
except ImportError:
    print('Import has failed probably because of the missing "future" package. Please install all the packages for '
          'interpreter {} from the $IDF_PATH/requirements.txt file.'.format(sys.executable))
    sys.exit(1)
import os
import argparse
import subprocess
import tempfile
import struct
import errno
import base64
import binascii
import logging
import re

idf_path = os.getenv('IDF_PATH')
if idf_path:
    sys.path.insert(0, os.path.join(idf_path, 'components', 'esptool_py', 'esptool'))

try:
    import esptool

except ImportError:
    print("esptool is not found! Set proper $IDF_PATH in environment.")
    sys.exit(2)

__version__ = "0.4-dev"

if os.name == 'nt':
    CLOSE_FDS = False
else:
    CLOSE_FDS = True

INVALID_CAUSE_VALUE = 0xFFFF

# Exception cause dictionary to get translation of exccause register
# From 4.4.1.5 table 4-64 Exception Causes of Xtensa
# Instruction Set Architecture (ISA) Reference Manual
xtensa_exception_cause_dict = {
    0: ("IllegalInstructionCause", "Illegal instruction"),
    1: ("SyscallCause", "SYSCALL instruction"),
    2: ("InstructionFetchErrorCause", "Processor internal physical address or data error during instruction fetch. (See EXCVADDR for more information)"),
    3: ("LoadStoreErrorCause", "Processor internal physical address or data error during load or store. (See EXCVADDR for more information)"),
    4: ("Level1InterruptCause", "Level-1 interrupt as indicated by set level-1 bits in the INTERRUPT register"),
    5: ("AllocaCause", "MOVSP instruction, if caller`s registers are not in the register file"),
    6: ("IntegerDivideByZeroCause", "QUOS: QUOU, REMS: or REMU divisor operand is zero"),
    8: ("PrivilegedCause", "Attempt to execute a privileged operation when CRING ? 0"),
    9: ("LoadStoreAlignmentCause", "Load or store to an unaligned address. (See EXCVADDR for more information)"),
    12: ("InstrPIFDataErrorCause", "PIF data error during instruction fetch. (See EXCVADDR for more information)"),
    13: ("LoadStorePIFDataErrorCause", "Synchronous PIF data error during LoadStore access. (See EXCVADDR for more information)"),
    14: ("InstrPIFAddrErrorCause", "PIF address error during instruction fetch. (See EXCVADDR for more information)"),
    15: ("LoadStorePIFAddrErrorCause", "Synchronous PIF address error during LoadStore access. (See EXCVADDR for more information)"),
    16: ("InstTLBMissCause", "Error during Instruction TLB refill. (See EXCVADDR for more information)"),
    17: ("InstTLBMultiHitCause", "Multiple instruction TLB entries matched. (See EXCVADDR for more information)"),
    18: ("InstFetchPrivilegeCause", "An instruction fetch referenced a virtual address at a ring level less than CRING. (See EXCVADDR for more information)"),
    20: ("InstFetchProhibitedCause", "An instruction fetch referenced a page mapped with an attribute that does not permit instruction fetch (EXCVADDR)."),
    24: ("LoadStoreTLBMissCause", "Error during TLB refill for a load or store. (See EXCVADDR for more information)"),
    25: ("LoadStoreTLBMultiHitCause", "Multiple TLB entries matched for a load or store. (See EXCVADDR for more information)"),
    26: ("LoadStorePrivilegeCause", "A load or store referenced a virtual address at a ring level less than CRING. (See EXCVADDR for more information)"),
    28: ("LoadProhibitedCause", "A load referenced a page mapped with an attribute that does not permit loads. (See EXCVADDR for more information)"),
    29: ("StoreProhibitedCause", "A store referenced a page mapped with an attribute that does not permit stores [Region Protection Option or MMU Option]."),
    32: ("Coprocessor0Disabled", "Coprocessor 0 instruction when cp0 disabled"),
    33: ("Coprocessor1Disabled", "Coprocessor 1 instruction when cp1 disabled"),
    34: ("Coprocessor2Disabled", "Coprocessor 2 instruction when cp2 disabled"),
    35: ("Coprocessor3Disabled", "Coprocessor 3 instruction when cp3 disabled"),
    36: ("Coprocessor4Disabled", "Coprocessor 4 instruction when cp4 disabled"),
    37: ("Coprocessor5Disabled", "Coprocessor 5 instruction when cp5 disabled"),
    38: ("Coprocessor6Disabled", "Coprocessor 6 instruction when cp6 disabled"),
    39: ("Coprocessor7Disabled", "Coprocessor 7 instruction when cp7 disabled"),
    INVALID_CAUSE_VALUE: ("InvalidCauseRegister", "Invalid EXCCAUSE register value or current task is broken and was skipped")}


class ESPCoreDumpError(RuntimeError):
    """Core dump runtime error class
    """
    def __init__(self, message):
        """Constructor for core dump error
        """
        super(ESPCoreDumpError, self).__init__(message)


class BinStruct(object):
    """Binary structure representation

       Subclasses must specify actual structure layout using 'fields' and 'format' members.
       For example, the following subclass represents structure with two fields:
       f1 of size 2 bytes and 4 bytes f2. Little endian.
        class SomeStruct(BinStruct):
            fields = ("f1",
                      "f2")
            format = "<HL"

        Then subclass can be used to initialize fields of underlaying structure and convert it to binary representation:
        f = open('some_struct.bin', 'wb')
        s = SomeStruct()
        s.f1 = 1
        s.f2 = 10
        f.write(s.dump())
        f.close()
    """

    def __init__(self, buf=None):
        """Base constructor for binary structure objects
        """
        if buf is None:
            buf = b'\0' * self.sizeof()
        fields = struct.unpack(self.__class__.format, buf[:self.sizeof()])
        self.__dict__.update(zip(self.__class__.fields, fields))

    def sizeof(self):
        """Returns the size of the structure represented by specific subclass
        """
        return struct.calcsize(self.__class__.format)

    def dump(self):
        """Returns binary representation of structure
        """
        keys = self.__class__.fields
        return struct.pack(self.__class__.format, *(self.__dict__[k] for k in keys))


class Elf32FileHeader(BinStruct):
    """ELF32 file header
    """
    fields = ("e_ident",
              "e_type",
              "e_machine",
              "e_version",
              "e_entry",
              "e_phoff",
              "e_shoff",
              "e_flags",
              "e_ehsize",
              "e_phentsize",
              "e_phnum",
              "e_shentsize",
              "e_shnum",
              "e_shstrndx")
    format = "<16sHHLLLLLHHHHHH"

    def __init__(self, buf=None):
        """Constructor for ELF32 file header structure
        """
        super(Elf32FileHeader, self).__init__(buf)
        if buf is None:
            # Fill in sane ELF header for LSB32
            self.e_ident = b"\x7fELF\1\1\1\0\0\0\0\0\0\0\0\0"
            self.e_version = ESPCoreDumpElfFile.EV_CURRENT
            self.e_ehsize = self.sizeof()


class Elf32ProgramHeader(BinStruct):
    """ELF32 program header
    """
    fields = ("p_type",
              "p_offset",
              "p_vaddr",
              "p_paddr",
              "p_filesz",
              "p_memsz",
              "p_flags",
              "p_align")
    format = "<LLLLLLLL"


class Elf32NoteDesc(object):
    """ELF32 note descriptor
    """
    def __init__(self, name, type, desc):
        """Constructor for ELF32 note descriptor
        """
        self.name = name
        self.type = type
        self.desc = desc

    def dump(self):
        """Returns binary representation of ELF32 note descriptor
        """
        nm_buf = bytearray(self.name, encoding='ascii') + b'\0'
        hdr = struct.pack("<LLL", len(nm_buf), len(self.desc), self.type)
        # pad for 4 byte alignment
        name = nm_buf + ((4 - len(nm_buf)) % 4) * b'\0'
        desc = self.desc + ((4 - len(self.desc)) % 4) * b'\0'
        return hdr + name + desc

    def read(self, data):
        """Reads ELF32 note descriptor
        """
        hdr_sz = struct.calcsize("<LLL")
        nm_len,desc_len,self.type = struct.unpack("<LLL", data[:hdr_sz])
        nm_len_a = nm_len + ((4 - nm_len) % 4)
        self.name = struct.unpack("<%ds" % (nm_len - 1), data[hdr_sz:hdr_sz + nm_len - 1])[0].decode('ascii')
        self.desc = data[hdr_sz + nm_len_a:hdr_sz + nm_len_a + desc_len]
        desc_len_a = desc_len + ((4 - desc_len) % 4)
        return hdr_sz + nm_len_a + desc_len_a


class XtensaPrStatus(BinStruct):
    """Xtensa program status structure"""
    fields = ("si_signo", "si_code", "si_errno",
              "pr_cursig",
              "pr_pad0",
              "pr_sigpend",
              "pr_sighold",
              "pr_pid",
              "pr_ppid",
              "pr_pgrp",
              "pr_sid",
              "pr_utime",
              "pr_stime",
              "pr_cutime",
              "pr_cstime")
    format = "<3LHHLLLLLLQQQQ"


class EspCoreDumpTaskStatus(BinStruct):
    """Core dump status structure"""
    # task status flags for note
    TASK_STATUS_CORRECT = 0x00
    TASK_STATUS_TCB_CORRUPTED = 0x01
    TASK_STATUS_STACK_CORRUPTED = 0x02
    fields = ("index",
              "flags",
              "tcb_addr",
              "stack_start",
              "stack_len",
              "name")
    format = "<LLLLL16s"


class ESPCoreDumpSegment(esptool.ImageSegment):
    """ Wrapper class for a program segment in core ELF file, has a segment
        type and flags as well as the common properties of an ImageSegment.
    """
    # segment flags
    PF_X = 0x1  # Execute
    PF_W = 0x2  # Write
    PF_R = 0x4  # Read

    def __init__(self, addr, data, type, flags):
        """Constructor for program segment
        """
        super(ESPCoreDumpSegment, self).__init__(addr, data)
        self.flags = flags
        self.type = type

    def __repr__(self):
        """Returns string representation of program segment
        """
        return "%s %s %s" % (self.type, self.attr_str(), super(ESPCoreDumpSegment, self).__repr__())

    def attr_str(self):
        """Returns string representation of program segment attributes
        """
        str = ''
        if self.flags & self.PF_R:
            str += 'R'
        else:
            str += ' '
        if self.flags & self.PF_W:
            str += 'W'
        else:
            str += ' '
        if self.flags & self.PF_X:
            str += 'X'
        else:
            str += ' '
        return str


class ESPCoreDumpSection(esptool.ELFSection):
    """ Wrapper class for a section in core ELF file, has a section
        flags as well as the common properties of an esptool.ELFSection.
    """
    # section flags
    SHF_WRITE       = 0x1
    SHF_ALLOC       = 0x2
    SHF_EXECINSTR   = 0x4

    def __init__(self, name, addr, data, flags):
        """Constructor for section
        """
        super(ESPCoreDumpSection, self).__init__(name, addr, data)
        self.flags = flags

    def __repr__(self):
        """Returns string representation of section
        """
        return "%s %s" % (super(ESPCoreDumpSection, self).__repr__(), self.attr_str())

    def attr_str(self):
        """Returns string representation of section attributes
        """
        str = "R"
        if self.flags & self.SHF_WRITE:
            str += 'W'
        else:
            str += ' '
        if self.flags & self.SHF_EXECINSTR:
            str += 'X'
        else:
            str += ' '
        if self.flags & self.SHF_ALLOC:
            str += 'A'
        else:
            str += ' '
        return str


class ESPCoreDumpElfFile(esptool.ELFFile):
    """ Wrapper class for core dump ELF file
    """
    # extra regs IDs used in EXTRA_INFO note
    REG_EXCCAUSE_IDX    = 0
    REG_EXCVADDR_IDX    = 1
    REG_EPS2_IDX        = 2
    REG_EPS3_IDX        = 3
    REG_EPS4_IDX        = 4
    REG_EPS5_IDX        = 5
    REG_EPS6_IDX        = 6
    REG_EPS7_IDX        = 7
    REG_EPC1_IDX        = 8
    REG_EPC2_IDX        = 9
    REG_EPC3_IDX        = 10
    REG_EPC4_IDX        = 11
    REG_EPC5_IDX        = 12
    REG_EPC6_IDX        = 13
    REG_EPC7_IDX        = 14
    # ELF file type
    ET_NONE             = 0x0  # No file type
    ET_REL              = 0x1  # Relocatable file
    ET_EXEC             = 0x2  # Executable file
    ET_DYN              = 0x3  # Shared object file
    ET_CORE             = 0x4  # Core file
    # ELF file version
    EV_NONE             = 0x0
    EV_CURRENT          = 0x1
    # ELF file machine type
    EM_NONE             = 0x0
    EM_XTENSA           = 0x5E
    # section types
    SEC_TYPE_PROGBITS   = 0x01
    SEC_TYPE_STRTAB     = 0x03
    # special section index
    SHN_UNDEF           = 0x0
    # program segment types
    PT_NULL             = 0x0
    PT_LOAD             = 0x1
    PT_DYNAMIC          = 0x2
    PT_INTERP           = 0x3
    PT_NOTE             = 0x4
    PT_SHLIB            = 0x5
    PT_PHDR             = 0x6

    def __init__(self, name=None):
        """Constructor for core dump ELF file
        """
        if name:
            super(ESPCoreDumpElfFile, self).__init__(name)
        else:
            self.sections = []
            self.program_segments = []
            self.aux_segments = []
            self.e_type = self.ET_NONE
            self.e_machine = self.EM_NONE

    def _read_elf_file(self, f):
        """Reads core dump from ELF file
        """
        # read the ELF file header
        LEN_FILE_HEADER = 0x34
        try:
            header = f.read(LEN_FILE_HEADER)
            (ident,type,machine,_version,
             self.entrypoint,phoff,shoff,_flags,
             _ehsize, phentsize,phnum,_shentsize,
             shnum,shstrndx) = struct.unpack("<16sHHLLLLLHHHHHH", header)
        except struct.error as e:
            raise ESPCoreDumpError("Failed to read a valid ELF header from %s: %s" % (f.name, e))

        if bytearray([ident[0]]) != b'\x7f' or ident[1:4] != b'ELF':
            raise ESPCoreDumpError("%s has invalid ELF magic header" % f.name)
        if machine != self.EM_XTENSA:
            raise ESPCoreDumpError("%s does not appear to be an Xtensa ELF file. e_machine=%04x" % (f.name, machine))
        self.e_type = type
        self.e_machine = machine
        self.sections = []
        self.program_segments = []
        self.aux_segments = []
        if shnum > 0:
            self._read_sections(f, shoff, shstrndx)
        if phnum > 0:
            self._read_program_segments(f, phoff, phentsize, phnum)

    def _read_sections(self, f, section_header_offs, shstrndx):
        """Reads core dump sections from ELF file
        """
        f.seek(section_header_offs)
        section_header = f.read()
        LEN_SEC_HEADER = 0x28
        if len(section_header) == 0:
            raise ESPCoreDumpError("No section header found at offset %04x in ELF file." % section_header_offs)
        if len(section_header) % LEN_SEC_HEADER != 0:
            logging.warning('Unexpected ELF section header length %04x is not mod-%02x' % (len(section_header),LEN_SEC_HEADER))

        # walk through the section header and extract all sections
        section_header_offsets = range(0, len(section_header), LEN_SEC_HEADER)

        def read_section_header(offs):
            name_offs,sec_type,flags,lma,sec_offs,size = struct.unpack_from("<LLLLLL", section_header[offs:])
            return (name_offs, sec_type, flags, lma, size, sec_offs)
        all_sections = [read_section_header(offs) for offs in section_header_offsets]
        prog_sections = [s for s in all_sections if s[1] == esptool.ELFFile.SEC_TYPE_PROGBITS]

        # search for the string table section
        if not shstrndx * LEN_SEC_HEADER in section_header_offsets:
            raise ESPCoreDumpError("ELF file has no STRTAB section at shstrndx %d" % shstrndx)
        _,sec_type,_,_,sec_size,sec_offs = read_section_header(shstrndx * LEN_SEC_HEADER)
        if sec_type != esptool.ELFFile.SEC_TYPE_STRTAB:
            logging.warning('ELF file has incorrect STRTAB section type 0x%02x' % sec_type)
        f.seek(sec_offs)
        string_table = f.read(sec_size)

        # build the real list of ELFSections by reading the actual section names from the
        # string table section, and actual data for each section from the ELF file itself
        def lookup_string(offs):
            raw = string_table[offs:]
            return raw[:raw.index(b'\x00')]

        def read_data(offs,size):
            f.seek(offs)
            return f.read(size)

        prog_sections = [ESPCoreDumpSection(lookup_string(n_offs), lma, read_data(offs, size), flags)
                         for (n_offs, _type, flags, lma, size, offs) in prog_sections if lma != 0]
        self.sections = prog_sections

    def _read_program_segments(self, f, seg_table_offs, entsz, num):
        """Reads core dump program segments from ELF file
        """
        f.seek(seg_table_offs)
        seg_table = f.read(entsz * num)
        LEN_SEG_HEADER = 0x20
        if len(seg_table) == 0:
            raise ESPCoreDumpError("No program header table found at offset %04x in ELF file." % seg_table_offs)
        if len(seg_table) % LEN_SEG_HEADER != 0:
            logging.warning('Unexpected ELF program header table length %04x is not mod-%02x' % (len(seg_table),LEN_SEG_HEADER))
        # walk through the program segment table and extract all segments
        seg_table_offs = range(0, len(seg_table), LEN_SEG_HEADER)

        def read_program_header(offs):
            type,offset,vaddr,_paddr,filesz,_memsz,flags,_align = struct.unpack_from("<LLLLLLLL", seg_table[offs:])
            return (type,offset,vaddr,filesz,flags)
        prog_segments = [read_program_header(offs) for offs in seg_table_offs]

        # build the real list of ImageSegment by reading actual data for each segment from the ELF file itself
        def read_data(offs,size):
            f.seek(offs)
            return f.read(size)

        # read loadable segments
        self.program_segments = [ESPCoreDumpSegment(vaddr, read_data(offset, filesz), type, flags)
                                 for (type, offset, vaddr, filesz,flags) in prog_segments if vaddr != 0]
        self.aux_segments = [ESPCoreDumpSegment(vaddr, read_data(offset, filesz), type, flags)
                             for (type, offset, vaddr, filesz, flags) in prog_segments if type == ESPCoreDumpElfFile.PT_NOTE and vaddr == 0]

    def add_program_segment(self, addr, data, type, flags):
        """Adds new program segment
        """
        # TODO: currently merging with existing segments is not supported
        data_sz = len(data)
        # check for overlapping and merge if needed
        if addr != 0 and data_sz != 0:
            for ps in self.program_segments:
                seg_len = len(ps.data)
                if addr >= ps.addr and addr < (ps.addr + seg_len):
                    raise ESPCoreDumpError("Can not add overlapping region [%x..%x] to ELF file. Conflict with existing [%x..%x]." %
                                           (addr, addr + data_sz - 1, ps.addr, ps.addr + seg_len - 1))
                if (addr + data_sz) > ps.addr and (addr + data_sz) <= (ps.addr + seg_len):
                    raise ESPCoreDumpError("Can not add overlapping region [%x..%x] to ELF file. Conflict with existing [%x..%x]." %
                                           (addr, addr + data_sz - 1, ps.addr, ps.addr + seg_len - 1))
        # append
        self.program_segments.append(ESPCoreDumpSegment(addr, data, type, flags))

    def add_aux_segment(self, data, type, flags):
        """Adds new note segment
        """
        self.aux_segments.append(ESPCoreDumpSegment(0, data, type, flags))

    def write_program_headers(self, f, off, segs):
        for seg in segs:
            phdr = Elf32ProgramHeader()
            phdr.p_type = seg.type
            phdr.p_offset = off
            phdr.p_vaddr = seg.addr
            phdr.p_paddr = phdr.p_vaddr  # TODO
            phdr.p_filesz = len(seg.data)
            phdr.p_memsz = phdr.p_filesz  # TODO
            phdr.p_flags = seg.flags
            phdr.p_align = 0  # TODO
            f.write(phdr.dump())
            off += phdr.p_filesz
        return off

    def dump(self, f):
        """Write core dump contents to file
        """
        # TODO: currently dumps only program segments.
        # dumping sections is not supported yet
        # write ELF header
        ehdr = Elf32FileHeader()
        ehdr.e_type = self.e_type
        ehdr.e_machine = self.e_machine
        ehdr.e_entry = 0
        ehdr.e_phoff = ehdr.sizeof()
        ehdr.e_shoff = 0
        ehdr.e_flags = 0
        ehdr.e_phentsize = Elf32ProgramHeader().sizeof()
        ehdr.e_phnum = len(self.program_segments) + len(self.aux_segments)
        ehdr.e_shentsize = 0
        ehdr.e_shnum = 0
        ehdr.e_shstrndx = self.SHN_UNDEF
        f.write(ehdr.dump())
        # write program header table
        cur_off = ehdr.e_ehsize + ehdr.e_phnum * ehdr.e_phentsize
        cur_off = self.write_program_headers(f, cur_off, self.program_segments)
        cur_off = self.write_program_headers(f, cur_off, self.aux_segments)
        # write program segments
        for segment in self.program_segments:
            f.write(segment.data)
        # write aux program segments
        for segment in self.aux_segments:
            f.write(segment.data)


class ESPCoreDumpLoaderError(ESPCoreDumpError):
    """Core dump loader error class
    """
    def __init__(self, message):
        """Constructor for core dump loader error
        """
        super(ESPCoreDumpLoaderError, self).__init__(message)


class ESPCoreDumpVersion(object):
    """Core dump version class
    """
    # This class contains all version-dependent params
    ESP_CORE_DUMP_CHIP_ESP32 = 0
    ESP_CORE_DUMP_CHIP_ESP32S2 = 2

    def __init__(self, version=None):
        """Constructor for core dump version
        """
        super(ESPCoreDumpVersion, self).__init__()
        if version is None:
            self.version = 0
        else:
            self.set_version(version)

    @staticmethod
    def make_dump_ver(maj, min):
        return (((maj & 0xFF) << 8) | ((min & 0xFF) << 0))

    def set_version(self, version):
        self.version = version

    @property
    def chip_ver(self):
        return ((self.version & 0xFFFF0000) >> 16)

    @property
    def dump_ver(self):
        return (self.version & 0x0000FFFF)

    @property
    def major(self):
        return ((self.version & 0x0000FF00) >> 8)

    @property
    def minor(self):
        return (self.version & 0x000000FF)


class ESPCoreDumpLoader(ESPCoreDumpVersion):
    """Core dump loader base class
    """
    # "legacy" stands for core dumps v0.1 (before IDF v4.1)
    ESP_COREDUMP_VERSION_BIN_V1 = ESPCoreDumpVersion.make_dump_ver(0, 1)
    ESP_COREDUMP_VERSION_BIN_V2 = ESPCoreDumpVersion.make_dump_ver(0, 2)
    ESP_COREDUMP_VERSION_ELF_CRC32 = ESPCoreDumpVersion.make_dump_ver(1, 0)
    ESP_COREDUMP_VERSION_ELF_SHA256 = ESPCoreDumpVersion.make_dump_ver(1, 1)
    ESP_CORE_DUMP_INFO_TYPE = 8266
    ESP_CORE_DUMP_TASK_INFO_TYPE = 678
    ESP_CORE_DUMP_EXTRA_INFO_TYPE = 677
    ESP_COREDUMP_CURR_TASK_MARKER = 0xdeadbeef
    ESP_COREDUMP_BIN_V1_HDR_FMT = '<4L'
    ESP_COREDUMP_BIN_V1_HDR_SZ = struct.calcsize(ESP_COREDUMP_BIN_V1_HDR_FMT)
    ESP_COREDUMP_HDR_FMT = '<5L'
    ESP_COREDUMP_HDR_SZ = struct.calcsize(ESP_COREDUMP_HDR_FMT)
    ESP_COREDUMP_TSK_HDR_FMT = '<3L'
    ESP_COREDUMP_TSK_HDR_SZ = struct.calcsize(ESP_COREDUMP_TSK_HDR_FMT)
    ESP_COREDUMP_MEM_SEG_HDR_FMT = '<2L'
    ESP_COREDUMP_MEM_SEG_HDR_SZ = struct.calcsize(ESP_COREDUMP_MEM_SEG_HDR_FMT)
    ESP_COREDUMP_NOTE_HDR_FMT = '<3L'
    ESP_COREDUMP_NOTE_HDR_SZ = struct.calcsize(ESP_COREDUMP_NOTE_HDR_FMT)
    ESP_COREDUMP_CRC_FMT = '<L'
    ESP_COREDUMP_CRC_SZ = struct.calcsize(ESP_COREDUMP_CRC_FMT)
    ESP_COREDUMP_SHA256_FMT = '32c'
    ESP_COREDUMP_SHA256_SZ = struct.calcsize(ESP_COREDUMP_SHA256_FMT)
    ESP_COREDUMP_FAKE_STACK_START = 0x20000000
    ESP_COREDUMP_FAKE_STACK_LIMIT = 0x30000000
    ESP_COREDUMP_LOG_HDR_FMT = '<2L'
    ESP_COREDUMP_LOG_HDR_SZ = struct.calcsize(ESP_COREDUMP_LOG_HDR_FMT)

    # XT_SOL_EXIT = 0
    XT_SOL_PC = 1
    XT_SOL_PS = 2
    # XT_SOL_NEXT = 3
    XT_SOL_AR_START = 4
    XT_SOL_AR_NUM = 4
    # XT_SOL_FRMSZ = 8

    XT_STK_EXIT = 0
    XT_STK_PC = 1
    XT_STK_PS = 2
    XT_STK_AR_START = 3
    XT_STK_AR_NUM = 16
    XT_STK_SAR = 19
    XT_STK_EXCCAUSE = 20
    XT_STK_EXCVADDR = 21
    XT_STK_LBEG = 22
    XT_STK_LEND = 23
    XT_STK_LCOUNT = 24
    XT_STK_FRMSZ = 25

    def __init__(self):
        """Base constructor for core dump loader
        """
        super(ESPCoreDumpLoader, self).__init__()
        self.fcore = None
        self.hdr = {}

    @staticmethod
    def get_registers_from_stack(data, grows_down):
        """Returns list of registers (in GDB format) from xtensa stack frame
        """
        # from "gdb/xtensa-tdep.h"
        # typedef struct
        # {
        # 0    xtensa_elf_greg_t pc;
        # 1    xtensa_elf_greg_t ps;
        # 2    xtensa_elf_greg_t lbeg;
        # 3    xtensa_elf_greg_t lend;
        # 4    xtensa_elf_greg_t lcount;
        # 5    xtensa_elf_greg_t sar;
        # 6    xtensa_elf_greg_t windowstart;
        # 7    xtensa_elf_greg_t windowbase;
        # 8..63 xtensa_elf_greg_t reserved[8+48];
        # 64   xtensa_elf_greg_t ar[64];
        # } xtensa_elf_gregset_t;
        REG_PC_IDX = 0
        REG_PS_IDX = 1
        REG_LB_IDX = 2
        REG_LE_IDX = 3
        REG_LC_IDX = 4
        REG_SAR_IDX = 5
        # REG_WS_IDX = 6
        # REG_WB_IDX = 7
        REG_AR_START_IDX = 64
        # REG_AR_NUM = 64
        # FIXME: acc to xtensa_elf_gregset_t number of regs must be 128,
        # but gdb complanis when it less then 129
        REG_NUM = 129

        extra_regs = {ESPCoreDumpElfFile.REG_EPS2_IDX: 0, ESPCoreDumpElfFile.REG_EPS3_IDX: 0,
                      ESPCoreDumpElfFile.REG_EPS4_IDX: 0, ESPCoreDumpElfFile.REG_EPS5_IDX: 0,
                      ESPCoreDumpElfFile.REG_EPS6_IDX: 0, ESPCoreDumpElfFile.REG_EPS7_IDX: 0,
                      ESPCoreDumpElfFile.REG_EPC1_IDX: 0, ESPCoreDumpElfFile.REG_EPC2_IDX: 0,
                      ESPCoreDumpElfFile.REG_EPC3_IDX: 0, ESPCoreDumpElfFile.REG_EPC4_IDX: 0,
                      ESPCoreDumpElfFile.REG_EPC5_IDX: 0, ESPCoreDumpElfFile.REG_EPC6_IDX: 0,
                      ESPCoreDumpElfFile.REG_EPC7_IDX: 0}
        regs = [0] * REG_NUM
        # TODO: support for growing up stacks
        if not grows_down:
            raise ESPCoreDumpLoaderError("Growing up stacks are not supported for now!")
        ex_struct = "<%dL" % ESPCoreDumpLoader.XT_STK_FRMSZ
        if len(data) < struct.calcsize(ex_struct):
            raise ESPCoreDumpLoaderError("Too small stack to keep frame: %d bytes!" % len(data))

        stack = struct.unpack(ex_struct, data[:struct.calcsize(ex_struct)])
        # Stack frame type indicator is always the first item
        rc = stack[ESPCoreDumpLoader.XT_STK_EXIT]
        if rc != 0:
            regs[REG_PC_IDX] = stack[ESPCoreDumpLoader.XT_STK_PC]
            regs[REG_PS_IDX] = stack[ESPCoreDumpLoader.XT_STK_PS]
            for i in range(ESPCoreDumpLoader.XT_STK_AR_NUM):
                regs[REG_AR_START_IDX + i] = stack[ESPCoreDumpLoader.XT_STK_AR_START + i]
            regs[REG_SAR_IDX] = stack[ESPCoreDumpLoader.XT_STK_SAR]
            regs[REG_LB_IDX] = stack[ESPCoreDumpLoader.XT_STK_LBEG]
            regs[REG_LE_IDX] = stack[ESPCoreDumpLoader.XT_STK_LEND]
            regs[REG_LC_IDX] = stack[ESPCoreDumpLoader.XT_STK_LCOUNT]
            # FIXME: crashed and some running tasks (e.g. prvIdleTask) have EXCM bit set
            # and GDB can not unwind callstack properly (it implies not windowed call0)
            if regs[REG_PS_IDX] & (1 << 5):
                regs[REG_PS_IDX] &= ~(1 << 4)
            if stack[ESPCoreDumpLoader.XT_STK_EXCCAUSE] in xtensa_exception_cause_dict:
                extra_regs[ESPCoreDumpElfFile.REG_EXCCAUSE_IDX] = stack[ESPCoreDumpLoader.XT_STK_EXCCAUSE]
            else:
                extra_regs[ESPCoreDumpElfFile.REG_EXCCAUSE_IDX] = INVALID_CAUSE_VALUE
            extra_regs[ESPCoreDumpElfFile.REG_EXCVADDR_IDX] = stack[ESPCoreDumpLoader.XT_STK_EXCVADDR]
        else:
            regs[REG_PC_IDX] = stack[ESPCoreDumpLoader.XT_SOL_PC]
            regs[REG_PS_IDX] = stack[ESPCoreDumpLoader.XT_SOL_PS]
            for i in range(ESPCoreDumpLoader.XT_SOL_AR_NUM):
                regs[REG_AR_START_IDX + i] = stack[ESPCoreDumpLoader.XT_SOL_AR_START + i]
            # nxt = stack[XT_SOL_NEXT]
        return regs,extra_regs

    def tcb_is_sane(self, tcb_addr, tcb_size):
        """Check tcb address if it is correct
        """
        return not (tcb_addr < 0x3F800000 or (tcb_addr + tcb_size) > 0x40000000)

    @staticmethod
    def stack_is_sane(sp):
        """Check stack address if it is correct
        """
        return ((sp >= 0x3F800000 and sp < 0x40000000) or
                (sp >= ESPCoreDumpLoader.ESP_COREDUMP_FAKE_STACK_START and
                sp < ESPCoreDumpLoader.ESP_COREDUMP_FAKE_STACK_LIMIT))

    @staticmethod
    def pc_is_sane(pc):
        """Check PC if it is correct
        """
        return not(pc < 0x40000000)

    @staticmethod
    def correct_pc(pc):
        """Corrects PC
        """
        if pc & 0xC0000000:
            pc = (pc & 0x3FFFFFFF) | 0x40000000
        return pc

    def addr_is_fake(self, addr):
        """Check if address is in fake area
        """
        return ((addr < 0x3f3fffff and addr >= 0x20000000) or addr >= 0x80000000)

    def remove_tmp_file(self, fname):
        """Silently removes temporary file
        """
        try:
            os.remove(fname)
        except OSError as e:
            if e.errno != errno.ENOENT:
                logging.warning("Failed to remove temp file '%s' (%d)!" % (fname, e.errno))

    def cleanup(self):
        """Cleans up loader resources
        """
        if self.fcore:
            self.fcore.close()
            if self.fcore_name:
                self.remove_tmp_file(self.fcore_name)

    def _extract_elf_corefile(self, core_fname=None, off=0, exe_name=None):
        """ Reads the ELF formatted core dump image and parse it
        """
        core_off = off
        self.set_version(self.hdr['ver'])
        if self.dump_ver == self.ESP_COREDUMP_VERSION_ELF_CRC32:
            checksum_len = self.ESP_COREDUMP_CRC_SZ
        elif self.dump_ver == self.ESP_COREDUMP_VERSION_ELF_SHA256:
            checksum_len = self.ESP_COREDUMP_SHA256_SZ
        else:
            raise ESPCoreDumpLoaderError("Core dump version '%d' is not supported!" % self.dump_ver)
        core_elf = ESPCoreDumpElfFile()
        data = self.read_data(core_off, self.hdr['tot_len'] - checksum_len - self.ESP_COREDUMP_HDR_SZ)
        with open(core_fname, 'w+b') as fce:
            try:
                fce.write(data)
                fce.flush()
                fce.seek(0)
                core_elf._read_elf_file(fce)
                if exe_name:
                    exe_elf = ESPCoreDumpElfFile(exe_name)
                # Read note segments from core file which are belong to tasks (TCB or stack)
                for ns in core_elf.aux_segments:
                    if ns.type != ESPCoreDumpElfFile.PT_NOTE:
                        continue
                    note_read = 0
                    while note_read < len(ns.data):
                        note = Elf32NoteDesc("", 0, None)
                        note_read += note.read(ns.data[note_read:])
                        # Check for version info note
                        if 'ESP_CORE_DUMP_INFO' == note.name and note.type == self.ESP_CORE_DUMP_INFO_TYPE and exe_name:
                            app_sha256 = binascii.hexlify(exe_elf.sha256())
                            n_ver_len = struct.calcsize("<L")
                            n_sha256_len = self.ESP_COREDUMP_SHA256_SZ * 2  # SHA256 as hex string
                            n_ver,coredump_sha256 = struct.unpack("<L%ds" % (n_sha256_len), note.desc[:n_ver_len + n_sha256_len])
                            if coredump_sha256 != app_sha256 or ESPCoreDumpVersion(n_ver).dump_ver != self.dump_ver:
                                raise ESPCoreDumpError("Invalid application image for coredump: app_SHA256(%s) != coredump_SHA256(%s)." %
                                                       (app_sha256, coredump_sha256))
            except ESPCoreDumpError as e:
                logging.warning("Failed to extract ELF core dump image into file %s. (Reason: %s)" % (core_fname, e))
        return core_fname, None

    def _extract_bin_corefile(self, core_fname=None, rom_elf=None, off=0):
        """Creates core dump ELF file
        """
        core_off = off
        with open(core_fname, 'w+b') as fce:
            tcbsz_aligned = self.hdr['tcbsz']
            if tcbsz_aligned % 4:
                tcbsz_aligned = 4 * (old_div(tcbsz_aligned,4) + 1)
            core_elf = ESPCoreDumpElfFile()
            notes = b''
            core_dump_info_notes = b''
            task_info_notes = b''
            task_status = EspCoreDumpTaskStatus()
            for i in range(self.hdr['task_num']):
                task_status.index = i
                task_status.flags = EspCoreDumpTaskStatus.TASK_STATUS_CORRECT
                task_regs = None
                extra_regs = None
                data = self.read_data(core_off, self.ESP_COREDUMP_TSK_HDR_SZ)
                tcb_addr,stack_top,stack_end = struct.unpack_from(self.ESP_COREDUMP_TSK_HDR_FMT, data)
                stack_len = stack_end - stack_top
                stack_base = stack_top
                stack_len_aligned = stack_len
                if stack_len_aligned % 4:
                    stack_len_aligned = 4 * (old_div(stack_len_aligned,4) + 1)

                core_off += self.ESP_COREDUMP_TSK_HDR_SZ
                logging.debug("Read TCB %d bytes @ 0x%x" % (tcbsz_aligned, tcb_addr))
                data = self.read_data(core_off, tcbsz_aligned)
                task_status.tcb_addr = tcb_addr
                try:
                    if self.tcb_is_sane(tcb_addr, tcbsz_aligned):
                        if self.hdr['tcbsz'] != tcbsz_aligned:
                            core_elf.add_program_segment(tcb_addr, data[:self.hdr['tcbsz'] - tcbsz_aligned],
                                                         ESPCoreDumpElfFile.PT_LOAD, ESPCoreDumpSegment.PF_R | ESPCoreDumpSegment.PF_W)
                        else:
                            core_elf.add_program_segment(tcb_addr, data, ESPCoreDumpElfFile.PT_LOAD, ESPCoreDumpSegment.PF_R | ESPCoreDumpSegment.PF_W)
                    elif tcb_addr and self.addr_is_fake(tcb_addr):
                        task_status.flags |= EspCoreDumpTaskStatus.TASK_STATUS_TCB_CORRUPTED
                except ESPCoreDumpError as e:
                    logging.warning("Skip TCB %d bytes @ 0x%x. (Reason: %s)" % (tcbsz_aligned, tcb_addr, e))

                core_off += tcbsz_aligned
                task_status.stack_start = stack_base
                task_status.stack_len = stack_len_aligned
                if self.stack_is_sane(stack_base):
                    logging.debug("Read stack %d bytes @ 0x%x" % (stack_len_aligned, stack_base))
                    data = self.read_data(core_off, stack_len_aligned)
                    if stack_len != stack_len_aligned:
                        data = data[:stack_len - stack_len_aligned]
                    try:
                        core_elf.add_program_segment(stack_base, data, ESPCoreDumpElfFile.PT_LOAD, ESPCoreDumpSegment.PF_R | ESPCoreDumpSegment.PF_W)
                    except ESPCoreDumpError as e:
                        logging.warning("Skip task's (%x) stack %d bytes @ 0x%x. (Reason: %s)" % (tcb_addr, stack_len_aligned, stack_base, e))
                    core_off += stack_len_aligned
                    try:
                        logging.debug("Stack start_end: 0x%x @ 0x%x" % (stack_top, stack_end))
                        task_regs,extra_regs = self.get_registers_from_stack(data, stack_end > stack_top)
                    except Exception as e:
                        logging.error(e)
                        return None, None
                else:
                    task_status.flags |= EspCoreDumpTaskStatus.TASK_STATUS_STACK_CORRUPTED
                    logging.warning("Skip task's (%x) stack %d bytes @ 0x%x. (Reason: invalid address)" % (tcb_addr, stack_len_aligned, stack_base))

                task_info_notes += Elf32NoteDesc("TASK_INFO", self.ESP_CORE_DUMP_TASK_INFO_TYPE, task_status.dump()).dump()
                if task_regs:
                    prstatus = XtensaPrStatus()
                    prstatus.pr_cursig = 0  # TODO: set sig only for current/failed task
                    prstatus.pr_pid = tcb_addr
                    note = Elf32NoteDesc("CORE", 1, prstatus.dump() + struct.pack("<%dL" % len(task_regs), *task_regs)).dump()
                    notes += note
                if extra_regs and ESPCoreDumpElfFile.REG_EXCCAUSE_IDX in extra_regs and len(core_dump_info_notes) == 0:
                    # actually there will be only one such note - for crashed task
                    core_dump_info_notes += Elf32NoteDesc("ESP_CORE_DUMP_INFO", self.ESP_CORE_DUMP_INFO_TYPE, struct.pack("<L", self.hdr['ver'])).dump()
                    exc_regs = []
                    for reg_id in sorted(extra_regs.keys()):
                        exc_regs.extend([reg_id, extra_regs[reg_id]])
                    core_dump_info_notes += Elf32NoteDesc("EXTRA_INFO", self.ESP_CORE_DUMP_EXTRA_INFO_TYPE,
                                                          struct.pack("<%dL" % (1 + len(exc_regs)), tcb_addr, *exc_regs)).dump()
            self.set_version(self.hdr['ver'])
            if self.dump_ver == self.ESP_COREDUMP_VERSION_BIN_V2:
                for i in range(self.hdr['segs_num']):
                    data = self.read_data(core_off, self.ESP_COREDUMP_MEM_SEG_HDR_SZ)
                    core_off += self.ESP_COREDUMP_MEM_SEG_HDR_SZ
                    mem_start,mem_sz = struct.unpack_from(self.ESP_COREDUMP_MEM_SEG_HDR_FMT, data)
                    logging.debug("Read memory segment %d bytes @ 0x%x" % (mem_sz, mem_start))
                    data = self.read_data(core_off, stack_len_aligned)
                    core_elf.add_program_segment(mem_start, data, ESPCoreDumpElfFile.PT_LOAD, ESPCoreDumpSegment.PF_R | ESPCoreDumpSegment.PF_W)
                    core_off += mem_sz
            # add notes
            try:
                core_elf.add_aux_segment(notes, ESPCoreDumpElfFile.PT_NOTE, 0)
            except ESPCoreDumpError as e:
                logging.warning("Skip NOTES segment %d bytes @ 0x%x. (Reason: %s)" % (len(notes), 0, e))
            # add core dump info notes
            try:
                core_elf.add_aux_segment(core_dump_info_notes, ESPCoreDumpElfFile.PT_NOTE, 0)
            except ESPCoreDumpError as e:
                logging.warning("Skip core dump info NOTES segment %d bytes @ 0x%x. (Reason: %s)" % (len(core_dump_info_notes), 0, e))
            try:
                core_elf.add_aux_segment(task_info_notes, ESPCoreDumpElfFile.PT_NOTE, 0)
            except ESPCoreDumpError as e:
                logging.warning("Skip failed tasks info NOTES segment %d bytes @ 0x%x. (Reason: %s)" % (len(task_info_notes), 0, e))
            # add ROM text sections
            if rom_elf:
                for ps in rom_elf.program_segments:
                    if (ps.flags & ESPCoreDumpSegment.PF_X) == 0:
                        continue
                    try:
                        core_elf.add_program_segment(ps.addr, ps.data, ESPCoreDumpElfFile.PT_LOAD, ps.flags)
                    except ESPCoreDumpError as e:
                        logging.warning("Skip ROM segment %d bytes @ 0x%x. (Reason: %s)" % (len(ps.data), ps.addr, e))
            # dump core ELF
            core_elf.e_type = ESPCoreDumpElfFile.ET_CORE
            core_elf.e_machine = ESPCoreDumpElfFile.EM_XTENSA
            core_elf.dump(fce)
        if self.dump_ver == self.ESP_COREDUMP_VERSION_BIN_V2:
            try:
                log_hdr = self.read_data(core_off, self.ESP_COREDUMP_LOG_HDR_SZ)
                core_off += self.ESP_COREDUMP_LOG_HDR_SZ
                log_start, log_len = struct.unpack_from(self.ESP_COREDUMP_LOG_HDR_FMT, log_hdr)
                log_dat = self.read_data(core_off, log_len)
            except:
                log_dat = None
        else:
            log_dat = None
        return core_fname, log_dat

    def create_corefile(self, core_fname=None, exe_name=None, rom_elf=None, off=0):
        """Creates core dump ELF file
        """
        data = self.read_data(off, self.ESP_COREDUMP_HDR_SZ)
        vals = struct.unpack_from(self.ESP_COREDUMP_HDR_FMT, data)
        self.hdr = dict(zip(('tot_len', 'ver', 'task_num', 'tcbsz', 'segs_num'), vals))
        if not core_fname:
            fce = tempfile.NamedTemporaryFile(mode='w+b', delete=False)
            core_fname = fce.name
        self.set_version(self.hdr['ver'])
        if self.chip_ver == ESPCoreDumpVersion.ESP_CORE_DUMP_CHIP_ESP32S2 or self.chip_ver == ESPCoreDumpVersion.ESP_CORE_DUMP_CHIP_ESP32:
            if self.dump_ver == self.ESP_COREDUMP_VERSION_ELF_CRC32 or self.dump_ver == self.ESP_COREDUMP_VERSION_ELF_SHA256:
                return self._extract_elf_corefile(core_fname, off + self.ESP_COREDUMP_HDR_SZ, exe_name)
            elif self.dump_ver == self.ESP_COREDUMP_VERSION_BIN_V2:
                return self._extract_bin_corefile(core_fname, rom_elf, off + self.ESP_COREDUMP_HDR_SZ)
            elif self.dump_ver == self.ESP_COREDUMP_VERSION_BIN_V1:
                return self._extract_bin_corefile(core_fname, rom_elf, off + self.ESP_COREDUMP_BIN_V1_HDR_SZ)
            raise ESPCoreDumpLoaderError("Core dump version '0x%x' is not supported!" % (self.dump_ver))
        else:
            raise ESPCoreDumpLoaderError("Core dump chip '0x%x' is not supported!" % (self.chip_ver))

    def read_data(self, off, sz):
        """Reads data from raw core dump got from flash or UART
        """
        self.fcore.seek(off)
        data = self.fcore.read(sz)
        return data


class ESPCoreDumpFileLoader(ESPCoreDumpLoader):
    """Core dump file loader class
    """
    def __init__(self, path, b64=False):
        """Constructor for core dump file loader
        """
        super(ESPCoreDumpFileLoader, self).__init__()
        self.fcore = self._load_coredump(path, b64)

    def _load_coredump(self, path, b64):
        """Loads core dump from (raw binary or base64-encoded) file
        """
        logging.debug("Load core dump from '%s'", path)
        self.fcore_name = None
        if b64:
            fhnd,self.fcore_name = tempfile.mkstemp()
            fcore = os.fdopen(fhnd, 'wb')
            fb64 = open(path, 'rb')
            try:
                while True:
                    line = fb64.readline()
                    if len(line) == 0:
                        break
                    data = base64.standard_b64decode(line.rstrip(b'\r\n'))
                    fcore.write(data)
                fcore.close()
                fcore = open(self.fcore_name, 'rb')
            except Exception as e:
                if self.fcore_name:
                    self.remove_tmp_file(self.fcore_name)
                    raise e
            finally:
                fb64.close()
        else:
            fcore = open(path, 'rb')
        return fcore


class ESPCoreDumpFlashLoader(ESPCoreDumpLoader):
    """Core dump flash loader class
    """
    ESP_COREDUMP_FLASH_LEN_FMT    = '<L'
    ESP_COREDUMP_FLASH_LEN_SZ     = struct.calcsize(ESP_COREDUMP_FLASH_LEN_FMT)
    ESP_COREDUMP_PART_TABLE_OFF   = 0x8000

    def __init__(self, off, tool_path=None, chip='esp32', port=None, baud=None):
        """Constructor for core dump flash loader
        """
        super(ESPCoreDumpFlashLoader, self).__init__()
        self.port = port
        self.baud = baud
        self.chip = chip
        self.dump_sz = 0
        self.fcore = self._load_coredump(off)

    def get_tool_path(self, use_esptool=None):
        """Get tool path
        """
        if use_esptool:
            tool_path = os.path.join(idf_path, 'components', 'esptool_py', 'esptool') + os.path.sep
        else:
            tool_path = os.path.join(idf_path, 'components', 'partition_table') + os.path.sep
        return tool_path

    def get_core_dump_partition_info(self, part_off=None, tool_path=None):
        """Get core dump partition info using parttool
        """
        logging.info("Retrieving core dump partition offset and size...")
        if not tool_path:
            tool_path = self.get_tool_path(use_esptool=False)
        if not part_off:
            part_off = self.ESP_COREDUMP_PART_TABLE_OFF
        size = None
        offset = None
        try:
            tool_args = [sys.executable, tool_path + 'parttool.py', "-q", "--partition-table-offset", str(part_off)]
            if self.port:
                tool_args.extend(['--port', self.port])
            invoke_args = tool_args + ["--partition-type", "data", "--partition-subtype", "coredump", "get_partition_info", "--info", "offset", "size"]
            (offset_str, size_str) = subprocess.check_output(invoke_args).strip().split(b" ")
            size = int(size_str, 16)
            offset = int(offset_str, 16)
            logging.info("Core dump partition offset=%d, size=%d", offset, size)
        except subprocess.CalledProcessError as e:
            logging.error("parttool get partition info failed with err %d" % e.returncode)
            logging.debug("Command ran: '%s'" % e.cmd)
            logging.debug("Command out:")
            logging.debug(e.output)
            logging.error("Check if the coredump partition exists in partition table.")
            raise e
        return (offset, size)

    def invoke_parttool(self, tool_path=None):
        """Loads core dump from flash using parttool
        """
        part_tool_args = [sys.executable, tool_path + 'parttool.py']
        if self.port:
            part_tool_args.extend(['--port', self.port])
        part_tool_args.extend(['--partition-type', 'data', '--partition-subtype', 'coredump', 'read_partition', '--output'])
        self.fcore_name = None
        f = tempfile.NamedTemporaryFile(mode='w+b', delete=False)
        try:
            part_tool_args.append(f.name)
            self.fcore_name = f.name
            # read core dump partition
            et_out = subprocess.check_output(part_tool_args)
            if len(et_out):
                logging.info(et_out.decode('utf-8'))
            self.dump_sz = self._read_core_dump_length(f)
            f.seek(self.dump_sz)
            # cut free space of the partition
            f.truncate()
            f.seek(0)
        except subprocess.CalledProcessError as e:
            logging.error("parttool script execution failed with err %d" % e.returncode)
            logging.debug("Command ran: '%s'" % e.cmd)
            logging.debug("Command out:")
            logging.debug(e.output)
            if self.fcore_name:
                f.close()
                self.remove_tmp_file(self.fcore_name)
            raise e

        return f

    def invoke_esptool(self, tool_path=None, off=None):
        """Loads core dump from flash using elftool
        """
        tool_args = [sys.executable, tool_path + 'esptool.py', '-c', self.chip]
        if self.port:
            tool_args.extend(['-p', self.port])
        if self.baud:
            tool_args.extend(['-b', str(self.baud)])
        f = tempfile.NamedTemporaryFile(mode='w+b', delete=False)
        self.fcore_name = None
        try:
            (part_offset, part_size) = self.get_core_dump_partition_info(tool_path='')
            if not off:
                off = part_offset  # set default offset if not specified
                logging.warning("The core dump image offset is not specified. Use partition offset: %d.", part_offset)
            if part_offset != off:
                logging.warning("Predefined image offset: %d does not match core dump partition offset: %d", off, part_offset)
            tool_args.extend(['read_flash', str(off), str(self.ESP_COREDUMP_FLASH_LEN_SZ)])
            tool_args.append(f.name)
            self.fcore_name = f.name
            # read core dump length
            et_out = subprocess.check_output(tool_args)
            if len(et_out):
                logging.info(et_out.decode('utf-8'))
            self.dump_sz = self._read_core_dump_length(f)
            if self.dump_sz == 0 or self.dump_sz > part_size:
                logging.error("Incorrect size of core dump image: %d, use partition size instead: %d", self.dump_sz, part_size)
                self.dump_sz = part_size
            # set actual size of core dump image and read it from flash
            tool_args[-2] = str(self.dump_sz)
            et_out = subprocess.check_output(tool_args)
            if len(et_out):
                logging.info(et_out.decode('utf-8'))
        except subprocess.CalledProcessError as e:
            logging.error("esptool script execution failed with err %d" % e.returncode)
            logging.debug("Command ran: '%s'" % e.cmd)
            logging.debug("Command out:")
            logging.debug(e.output)
            if self.fcore_name:
                f.close()
                self.remove_tmp_file(self.fcore_name)
            raise e
        return f

    def _load_coredump(self, off=None):
        """Loads core dump from flash using parttool or elftool (if offset is set)
        """
        tool_path = None
        try:
            if off:
                tool_path = ''
                logging.info("Invoke esptool to read image.")
                f = self.invoke_esptool(tool_path=tool_path, off=off)
            else:
                tool_path = ''
                logging.info("Invoke parttool to read image.")
                f = self.invoke_parttool(tool_path=tool_path)
        except subprocess.CalledProcessError as e:
            if len(e.output):
                logging.info(e.output)
            logging.warning("System path is not set. Try to use predefined path.")
            if off:
                tool_path = self.get_tool_path(use_esptool=True)
                f = self.invoke_esptool(tool_path=tool_path, off=off)
            else:
                tool_path = self.get_tool_path(use_esptool=False)
                f = self.invoke_parttool(tool_path=tool_path)
        return f

    def _read_core_dump_length(self, f):
        """Reads core dump length
        """
        data = f.read(self.ESP_COREDUMP_FLASH_LEN_SZ)
        tot_len, = struct.unpack_from(self.ESP_COREDUMP_FLASH_LEN_FMT, data)
        return tot_len

    def create_corefile(self, core_fname=None, exe_name=None, rom_elf=None):
        """Checks flash coredump data integrity and creates ELF file
        """
        data = self.read_data(0, self.ESP_COREDUMP_HDR_SZ)
        self.checksum_len = 0
        _,coredump_ver_data,_,_,_ = struct.unpack_from(self.ESP_COREDUMP_HDR_FMT, data)
        self.set_version(coredump_ver_data)
        if self.chip_ver != ESPCoreDumpVersion.ESP_CORE_DUMP_CHIP_ESP32S2 and self.chip_ver != ESPCoreDumpVersion.ESP_CORE_DUMP_CHIP_ESP32:
            raise ESPCoreDumpLoaderError("Invalid core dump chip version: '%s', should be <= '0x%x'" % (self.chip_ver, self.ESP_CORE_DUMP_CHIP_ESP32S2))
        if self.dump_ver == self.ESP_COREDUMP_VERSION_ELF_CRC32 or self.dump_ver == self.ESP_COREDUMP_VERSION_BIN_V1 \
                or self.dump_ver == self.ESP_COREDUMP_VERSION_BIN_V2:
            logging.debug("Dump size = %d, crc off = 0x%x", self.dump_sz, self.dump_sz - self.ESP_COREDUMP_CRC_SZ)
            data = self.read_data(self.dump_sz - self.ESP_COREDUMP_CRC_SZ, self.ESP_COREDUMP_CRC_SZ)
            dump_crc, = struct.unpack_from(self.ESP_COREDUMP_CRC_FMT, data)
            data = self.read_data(0, self.dump_sz - self.ESP_COREDUMP_CRC_SZ)
            data_crc = binascii.crc32(data) & 0xffffffff
            if dump_crc != data_crc:
                raise ESPCoreDumpLoaderError("Invalid core dump CRC %x, should be %x" % (data_crc, dump_crc))
        elif self.dump_ver == self.ESP_COREDUMP_VERSION_ELF_SHA256:
            dump_sha256 = self.read_data(self.dump_sz - self.ESP_COREDUMP_SHA256_SZ, self.ESP_COREDUMP_SHA256_SZ)
            data = self.read_data(0, self.dump_sz - self.ESP_COREDUMP_SHA256_SZ)
            data_sha256 = sha256(data)
            data_sha256_str = data_sha256.hexdigest()
            dump_sha256_str = binascii.hexlify(dump_sha256).decode('ascii')
            if dump_sha256_str != data_sha256_str:
                raise ESPCoreDumpLoaderError("Invalid core dump SHA256 '%s', should be '%s'" % (dump_sha256_str, data_sha256_str))
        return super(ESPCoreDumpFlashLoader, self).create_corefile(core_fname, exe_name)


class GDBMIOutRecordHandler(object):
    """GDB/MI output record handler base class
    """
    TAG = ''

    def __init__(self, f, verbose=False):
        """Base constructor for GDB/MI output record handler
        """
        self.verbose = verbose

    def execute(self, ln):
        """Base method to execute GDB/MI output record handler function
        """
        if self.verbose:
            logging.debug("%s.execute: [[%s]]" % (self.__class__.__name__, ln))


class GDBMIOutStreamHandler(GDBMIOutRecordHandler):
    """GDB/MI output stream handler class
    """
    def __init__(self, f, verbose=False):
        """Constructor for GDB/MI output stream handler
        """
        super(GDBMIOutStreamHandler, self).__init__(None, verbose)
        self.func = f

    def execute(self, ln):
        """Executes GDB/MI output stream handler function
        """
        GDBMIOutRecordHandler.execute(self, ln)
        if self.func:
            # remove TAG / quotes and replace c-string \n with actual NL
            self.func(ln[1:].strip('"').replace('\\n', '\n').replace('\\t', '\t'))


class GDBMIResultHandler(GDBMIOutRecordHandler):
    """GDB/MI result handler class
    """
    TAG = '^'
    RC_DONE = 'done'
    RC_RUNNING = 'running'
    RC_CONNECTED = 'connected'
    RC_ERROR = 'error'
    RC_EXIT = 'exit'

    def __init__(self, verbose=False):
        """Constructor for GDB/MI result handler
        """
        super(GDBMIResultHandler, self).__init__(None, verbose)
        self.result_class = ''
        self.result_str = ''

    def _parse_rc(self, ln, rc):
        """Parses result code
        """
        rc_str = "{0}{1}".format(self.TAG, rc)
        if not ln.startswith(rc_str):
            return False
        self.result_class = rc
        if len(ln) > len(rc_str):
            self.result_str = ln[len(rc_str):]
            if self.result_str.startswith(','):
                self.result_str = self.result_str[1:]
            else:
                logging.error("Invalid result format: '%s'" % ln)
        else:
            self.result_str = ''
        return True

    def execute(self, ln):
        """Executes GDB/MI result handler function
        """
        GDBMIOutRecordHandler.execute(self, ln)
        if self._parse_rc(ln, self.RC_DONE):
            return
        if self._parse_rc(ln, self.RC_RUNNING):
            return
        if self._parse_rc(ln, self.RC_CONNECTED):
            return
        if self._parse_rc(ln, self.RC_ERROR):
            return
        if self._parse_rc(ln, self.RC_EXIT):
            return
        logging.error("Unknown GDB/MI result: '%s'" % ln)


class GDBMIThreadListIdsHandler(GDBMIResultHandler):
    """GDB/MI thread-list-ids handler class
    """
    def __init__(self, verbose=False):
        """Constructor for GDB/MI result handler
        """
        super(GDBMIThreadListIdsHandler, self).__init__(verbose)
        self.threads = []
        self.current_thread = ''

    def execute(self, ln):
        """Executes GDB/MI thread-list-ids handler function
        """
        GDBMIResultHandler.execute(self, ln)
        if self.result_class != self.RC_DONE:
            return
        # simple parsing method
        result = re.search(r'thread-ids\s*=\s*\{([^\{\}]*)\}', self.result_str)
        if result:
            for tid in re.finditer(r'thread-id="(\d+)"', result.group(1)):
                self.threads.append(tid.group(1))
        result = re.search(r'current-thread-id="(\d+)"', self.result_str)
        if result:
            self.current_thread = result.group(1)


class GDBMIThreadSelectHandler(GDBMIResultHandler):
    """GDB/MI thread-select handler class
    """
    def execute(self, ln):
        """Executes GDB/MI thread-select handler function
        """
        GDBMIResultHandler.execute(self, ln)
        if self.result_class != self.RC_DONE:
            return


class GDBMIThreadInfoHandler(GDBMIResultHandler):
    """GDB/MI thread-info handler class
    """
    def __init__(self, verbose=False):
        """Constructor for GDB/MI result handler
        """
        super(GDBMIThreadInfoHandler, self).__init__(verbose)
        self.current = False
        self.id = ''
        self.target_id = ''
        self.details = ''
        self.name = ''
        self.frame = ''
        self.state = ''
        self.core = ''

    def execute(self, ln):
        """Executes GDB/MI thread-info  handler function
        """
        GDBMIResultHandler.execute(self, ln)
        if self.result_class != self.RC_DONE:
            return
        # simple parsing method
        result = re.search(r'id="(\d+)"', self.result_str)
        if result:
            self.id = result.group(1)
        result = re.search(r'current="\*"', self.result_str)
        if result:
            self.current = True
        result = re.search(r'target-id="([^"]+)"', self.result_str)
        if result:
            self.target_id = result.group(1)


class GDBMIDataEvalHandler(GDBMIResultHandler):
    """GDB/MI data-evaluate-expression handler class
    """
    def __init__(self, verbose=False):
        """Constructor for GDB/MI result handler
        """
        super(GDBMIDataEvalHandler, self).__init__(verbose)
        self.value = ''

    def execute(self, ln):
        """Executes GDB/MI data-evaluate-expression handler function
        """
        GDBMIResultHandler.execute(self, ln)
        if self.result_class != self.RC_DONE:
            return
        # simple parsing method
        if self.verbose:
            logging.debug("GDBMIDataEvalHandler: result '%s'", self.result_str)
        res_str = self.result_str.replace(r'\"', '\'')
        m = re.search(r'(frame=\{.+\},)?value="(?P<val>.+)"$', res_str)
        if m:
            if self.verbose:
                logging.debug("GDBMIDataEvalHandler: found value = '%s'", m.group('val'))
            self.value = m.group('val')


class GDBMIDataReadMemoryHandler(GDBMIResultHandler):
    """GDB/MI data-read-memory handler class
    """
    def __init__(self, verbose=False):
        """Constructor for GDB/MI result handler
        """
        super(GDBMIDataReadMemoryHandler, self).__init__(verbose)
        self.addr = ''
        self.nr_bytes = ''
        self.total_bytes = ''
        self.next_row = ''
        self.prev_row = ''
        self.next_page = ''
        self.prev_page = ''
        # list of {'addr': xxx, 'data': [xxx]}
        self.memory = []

    def execute(self, ln):
        """Executes GDB/MI data-read-memory handler function
        """
        GDBMIResultHandler.execute(self, ln)
        if self.result_class != self.RC_DONE:
            return
        # simple parsing method
        result = re.search(r'addr="(0x[0-9a-fA-F]+)"', self.result_str)
        if result:
            self.addr = result.group(1)
        result = re.search(r'nr-bytes="(\d+)"', self.result_str)
        if result:
            self.nr_bytes = result.group(1)
        result = re.search(r'total-bytes="(\d+)"', self.result_str)
        if result:
            self.total_bytes = result.group(1)
        result = re.search(r'next-row="(0x[0-9a-fA-F]+)"', self.result_str)
        if result:
            self.next_row = result.group(1)
        result = re.search(r'prev-row="(0x[0-9a-fA-F]+)"', self.result_str)
        if result:
            self.prev_row = result.group(1)
        result = re.search(r'next-page="(0x[0-9a-fA-F]+)"', self.result_str)
        if result:
            self.next_page = result.group(1)
        result = re.search(r'prev-page="(0x[0-9a-fA-F]+)"', self.result_str)
        if result:
            self.prev_page = result.group(1)
        result = re.search(r'memory=\[\{(.*)\}\]', self.result_str)
        if result:
            mem_str = '{%s}' % result.group(1)
            pos = 0
            r = re.compile(r'addr="(?P<addr>0x[0-9a-fA-F]+)",\s*data=\[(?P<data>[^\[\]]*)\]')
            while True:
                result = r.search(mem_str, pos=pos)
                if not result:
                    break
                # make list and dequote values
                row_data = [x[1:-1] for x in result.group('data').split(",")]
                self.memory.append({'addr': result.group('addr'), 'data': row_data})
                pos = result.end('data') + 1


class GDBMIStreamConsoleHandler(GDBMIOutStreamHandler):
    """GDB/MI console stream handler class
    """
    TAG = '~'


def load_aux_elf(elf_path):
    """ Loads auxilary ELF file and composes GDB command to read its symbols
    """
    elf = None
    sym_cmd = ''
    if os.path.exists(elf_path):
        elf = ESPCoreDumpElfFile(elf_path)
        for s in elf.sections:
            if s.name == '.text':
                sym_cmd = 'add-symbol-file %s 0x%x' % (elf_path, s.addr)
    return (elf, sym_cmd)


def dbg_corefile(args):
    """ Command to load core dump from file or flash and run GDB debug session with it
    """
    global CLOSE_FDS
    loader = None
    rom_elf,rom_sym_cmd = load_aux_elf(args.rom_elf)
    if not args.core:
        loader = ESPCoreDumpFlashLoader(args.off, port=args.port, baud=args.baud)
        core_fname, log_saved = loader.create_corefile(args.save_core, exe_name=args.prog, rom_elf=rom_elf)
        if not core_fname:
            logging.error("Failed to create corefile!")
            loader.cleanup()
            return
    else:
        core_fname = args.core
        if args.core_format and args.core_format != 'elf':
            loader = ESPCoreDumpFileLoader(core_fname, args.core_format == 'b64')
            core_fname, log_saved = loader.create_corefile(args.save_core, exe_name=args.prog, rom_elf=rom_elf)
            if not core_fname:
                logging.error("Failed to create corefile!")
                loader.cleanup()
                return

    p = subprocess.Popen(bufsize=0,
                         args=[args.gdb,
                               '--nw',  # ignore .gdbinit
                               '--core=%s' % core_fname,  # core file,
                               '-ex', rom_sym_cmd,
                               args.prog
                               ],
                         stdin=None, stdout=None, stderr=None,
                         close_fds=CLOSE_FDS
                         )
    p.wait()

    if loader:
        if not args.core and not args.save_core:
            loader.remove_tmp_file(core_fname)
        loader.cleanup()
    print('Done!')


def info_corefile(args):
    """ Command to load core dump from file or flash and print it's data in user friendly form
    """
    global CLOSE_FDS

    def gdbmi_console_stream_handler(ln):
        sys.stdout.write(ln)
        sys.stdout.flush()

    def gdbmi_read2prompt(f, out_handlers=None):
        while True:
            ln = f.readline().decode('utf-8').rstrip(' \r\n')
            if ln == '(gdb)':
                break
            elif len(ln) == 0:
                break
            elif out_handlers:
                for h in out_handlers:
                    if ln.startswith(out_handlers[h].TAG):
                        out_handlers[h].execute(ln)
                        break

    def gdbmi_start(handlers, gdb_cmds):
        gdb_args = [args.gdb,
                    '--quiet',  # inhibit dumping info at start-up
                    '--nx',  # inhibit window interface
                    '--nw',  # ignore .gdbinit
                    '--interpreter=mi2',  # use GDB/MI v2
                    '--core=%s' % core_fname]  # core file
        for c in gdb_cmds:
            gdb_args += ['-ex', c]
        gdb_args.append(args.prog)
        p = subprocess.Popen(bufsize=0,
                             args=gdb_args,
                             stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                             close_fds=CLOSE_FDS)
        gdbmi_read2prompt(p.stdout, handlers)
        return p

    def gdbmi_cmd_exec(p, handlers, gdbmi_cmd):
        for t in handlers:
            handlers[t].result_class = None
        p.stdin.write(bytearray("%s\n" % gdbmi_cmd, encoding='utf-8'))
        gdbmi_read2prompt(p.stdout, handlers)
        if not handlers[GDBMIResultHandler.TAG].result_class or handlers[GDBMIResultHandler.TAG].result_class == GDBMIResultHandler.RC_EXIT:
            logging.error("GDB exited (%s / %s)!" % (handlers[GDBMIResultHandler.TAG].result_class, handlers[GDBMIResultHandler.TAG].result_str))
            p.wait()
            logging.error("Problem occured! GDB exited, restart it.")
            p = gdbmi_start(handlers, [])
        elif handlers[GDBMIResultHandler.TAG].result_class != GDBMIResultHandler.RC_DONE:
            logging.error("GDB/MI command failed (%s / %s)!" % (handlers[GDBMIResultHandler.TAG].result_class, handlers[GDBMIResultHandler.TAG].result_str))
        return p

    def gdbmi_getinfo(p, handlers, gdb_cmd):
        return gdbmi_cmd_exec(p, handlers, "-interpreter-exec console \"%s\"" % gdb_cmd)

    def gdbmi_get_thread_ids(p):
        handlers = {}
        result = GDBMIThreadListIdsHandler(verbose=False)
        handlers[GDBMIResultHandler.TAG] = result
        handlers[GDBMIStreamConsoleHandler.TAG] = GDBMIStreamConsoleHandler(None, verbose=False)
        p = gdbmi_cmd_exec(p, handlers, "-thread-list-ids")
        return p,result.threads,result.current_thread

    def gdbmi_switch_thread(p, thr_id):
        handlers = {}
        result = GDBMIThreadSelectHandler(verbose=False)
        handlers[GDBMIResultHandler.TAG] = result
        handlers[GDBMIStreamConsoleHandler.TAG] = GDBMIStreamConsoleHandler(None, verbose=False)
        return gdbmi_cmd_exec(p, handlers, "-thread-select %s" % thr_id)

    def gdbmi_get_thread_info(p, thr_id=None):
        handlers = {}
        result = GDBMIThreadInfoHandler(verbose=False)
        handlers[GDBMIResultHandler.TAG] = result
        handlers[GDBMIStreamConsoleHandler.TAG] = GDBMIStreamConsoleHandler(None, verbose=False)
        if thr_id:
            cmd = "-thread-info %s" % thr_id
        else:
            cmd = "-thread-info"
        p = gdbmi_cmd_exec(p, handlers, cmd)
        return p,result

    def gdbmi_data_evaluate_expression(p, expr):
        handlers = {}
        result = GDBMIDataEvalHandler(verbose=False)
        handlers[GDBMIResultHandler.TAG] = result
        handlers[GDBMIStreamConsoleHandler.TAG] = GDBMIStreamConsoleHandler(None, verbose=False)
        p = gdbmi_cmd_exec(p, handlers, "-data-evaluate-expression \"%s\"" % expr)
        return p,result

    def gdbmi_data_read_memory(p, addr, fmt, sz, nrows, ncols, off=0, aschar=False):
        handlers = {}
        result = GDBMIDataReadMemoryHandler(verbose=False)
        handlers[GDBMIResultHandler.TAG] = result
        handlers[GDBMIStreamConsoleHandler.TAG] = GDBMIStreamConsoleHandler(None, verbose=False)
        p = gdbmi_cmd_exec(p, handlers, "-data-read-memory -o %d -- %s %s %d %d %d %s" %
                                        (off, addr, fmt, sz, nrows, ncols, "aschar" if aschar else ""))
        return p,result

    def gdbmi_freertos_get_task_name(p, tcb_addr):
        p,res = gdbmi_data_evaluate_expression(p, "(char*)((TCB_t *)0x%x)->pcTaskName" % tcb_addr)
        result = re.match("0x[a-fA-F0-9]+[^']*'([^']*)'", res.value)
        if result:
            return p,result.group(1)
        return p,''

    def gdb2freertos_thread_id(gdb_thread_id):
        return int(gdb_thread_id.replace("process ", ""), 0)

    def gdbmi_get_reg(p, reg):
        p,res = gdbmi_data_evaluate_expression(p, "(void *)$%s" % reg)
        result = re.search(r'(?P<val>0x[a-fA-F0-9]+)', res.value)
        if result:
            return p,int(result.group('val'),0)
        return p,0

    def gdbmi_print_backtrace(p, stack_addr=None):
        if stack_addr:
            p,res = gdbmi_data_read_memory(p, stack_addr, 'x', 4, 1, ESPCoreDumpLoader.XT_STK_FRMSZ)
            if len(res.memory) == 0:
                logging.error("Cannot read stack @ 0x%x!", stack_addr)
                return p
            stack = res.memory[0]['data']
            if int(stack[ESPCoreDumpLoader.XT_STK_EXIT], 0):
                pc = int(stack[ESPCoreDumpLoader.XT_STK_PC], 0)
                ra = int(stack[ESPCoreDumpLoader.XT_STK_AR_START + 0], 0)
                sp = int(stack[ESPCoreDumpLoader.XT_STK_AR_START + 1], 0)
            else:
                pc = int(stack[ESPCoreDumpLoader.XT_SOL_PC], 0)
                ra = int(stack[ESPCoreDumpLoader.XT_SOL_AR_START + 0], 0)
                sp = int(stack[ESPCoreDumpLoader.XT_SOL_AR_START + 1], 0)
        else:
            p,sp = gdbmi_get_reg(p, 'sp')
            p,pc = gdbmi_get_reg(p, 'pc')
            p,ra = gdbmi_get_reg(p, 'a0')
            pc = ESPCoreDumpLoader.correct_pc(pc)
        bt_str = '0x%x:0x%x' % (pc, sp)
        pc = ra
        for i in range(100):
            psp = sp
            if not ESPCoreDumpLoader.stack_is_sane(sp):
                break
            p,res = gdbmi_data_evaluate_expression(p, "*((uint32_t *) (%d - 0x10 + 4))" % sp)
            sp = int(res.value, 0)
            pc = ESPCoreDumpLoader.correct_pc(pc)
            bt_str += ' 0x%x:0x%x' % (pc - 3, sp)
            p,res = gdbmi_data_evaluate_expression(p, "*((uint32_t *) (%d - 0x10))" % psp)
            pc = int(res.value, 0)
            if not ESPCoreDumpLoader.pc_is_sane(pc):
                break
        out_str = subprocess.check_output('%s -C -p -i -f -e %s %s' % (args.addr2line, args.prog, bt_str), shell=True)
        print(out_str)
        return p

    loader = None
    rom_elf,rom_sym_cmd = load_aux_elf(args.rom_elf)
    if not args.core:
        loader = ESPCoreDumpFlashLoader(args.off, port=args.port, baud=args.baud)
        core_fname, log_saved = loader.create_corefile(args.save_core, exe_name=args.prog, rom_elf=rom_elf)
        if not core_fname:
            logging.error("Failed to create corefile!")
            loader.cleanup()
            return
    else:
        core_fname = args.core
        if args.core_format and args.core_format != 'elf':
            loader = ESPCoreDumpFileLoader(core_fname, args.core_format == 'b64')
            core_fname, log_saved = loader.create_corefile(args.save_core, exe_name=args.prog, rom_elf=rom_elf)
            if not core_fname:
                logging.error("Failed to create corefile!")
                loader.cleanup()
                return

    exe_elf = ESPCoreDumpElfFile(args.prog)
    core_elf = ESPCoreDumpElfFile(core_fname)
    merged_segs = []
    core_segs = core_elf.program_segments
    for s in exe_elf.sections:
        merged = False
        for ps in core_segs:
            if ps.addr <= s.addr and ps.addr + len(ps.data) >= s.addr:
                # sec:    |XXXXXXXXXX|
                # seg: |...XXX.............|
                seg_addr = ps.addr
                if ps.addr + len(ps.data) <= s.addr + len(s.data):
                    # sec:        |XXXXXXXXXX|
                    # seg:    |XXXXXXXXXXX...|
                    # merged: |XXXXXXXXXXXXXX|
                    seg_len = len(s.data) + (s.addr - ps.addr)
                else:
                    # sec:        |XXXXXXXXXX|
                    # seg:    |XXXXXXXXXXXXXXXXX|
                    # merged: |XXXXXXXXXXXXXXXXX|
                    seg_len = len(ps.data)
                merged_segs.append((s.name, seg_addr, seg_len, s.attr_str(), True))
                core_segs.remove(ps)
                merged = True
            elif ps.addr >= s.addr and ps.addr <= s.addr + len(s.data):
                # sec:  |XXXXXXXXXX|
                # seg:  |...XXX.............|
                seg_addr = s.addr
                if (ps.addr + len(ps.data)) >= (s.addr + len(s.data)):
                    # sec:    |XXXXXXXXXX|
                    # seg:    |..XXXXXXXXXXX|
                    # merged: |XXXXXXXXXXXXX|
                    seg_len = len(s.data) + (ps.addr + len(ps.data)) - (s.addr + len(s.data))
                else:
                    # sec:    |XXXXXXXXXX|
                    # seg:      |XXXXXX|
                    # merged: |XXXXXXXXXX|
                    seg_len = len(s.data)
                merged_segs.append((s.name, seg_addr, seg_len, s.attr_str(), True))
                core_segs.remove(ps)
                merged = True

        if not merged:
            merged_segs.append((s.name, s.addr, len(s.data), s.attr_str(), False))

    handlers = {}
    handlers[GDBMIResultHandler.TAG] = GDBMIResultHandler(verbose=False)
    handlers[GDBMIStreamConsoleHandler.TAG] = GDBMIStreamConsoleHandler(None, verbose=False)
    p = gdbmi_start(handlers, [rom_sym_cmd])
    extra_note = None
    task_info = {}
    for seg in core_elf.aux_segments:
        if seg.type != ESPCoreDumpElfFile.PT_NOTE:
            continue
        note_read = 0
        while note_read < len(seg.data):
            note = Elf32NoteDesc("", 0, None)
            note_read += note.read(seg.data[note_read:])
            if note.type == ESPCoreDumpLoader.ESP_CORE_DUMP_EXTRA_INFO_TYPE and 'EXTRA_INFO' in note.name:
                extra_note = note
            if note.type == ESPCoreDumpLoader.ESP_CORE_DUMP_TASK_INFO_TYPE and 'TASK_INFO' in note.name:
                task_info_desc = EspCoreDumpTaskStatus(buf=note.desc)
                task_info[task_info_desc.tcb_addr] = task_info_desc
    print("===============================================================")
    print("==================== ESP32 CORE DUMP START ====================")

    handlers[GDBMIResultHandler.TAG].result_class = None
    handlers[GDBMIStreamConsoleHandler.TAG].func = gdbmi_console_stream_handler
    if extra_note:
        extra_info = struct.unpack("<%dL" % (len(extra_note.desc) / struct.calcsize("<L")), extra_note.desc)
        if extra_info[0] == ESPCoreDumpLoader.ESP_COREDUMP_CURR_TASK_MARKER:
            print("\nCrashed task has been skipped.")
        else:
            p,task_name = gdbmi_freertos_get_task_name(p, extra_info[0])
            print("\nCrashed task handle: 0x%x, name: '%s', GDB name: 'process %d'" % (extra_info[0], task_name, extra_info[0]))
    print("\n================== CURRENT THREAD REGISTERS ===================")
    if extra_note:
        exccause = extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EXCCAUSE_IDX + 1]
        exccause_str = xtensa_exception_cause_dict.get(exccause)
        if not exccause_str:
            exccause_str = ("Invalid EXCCAUSE code", "Invalid EXCAUSE description or not found.")
        print("exccause       0x%x (%s)" % (exccause, exccause_str[0]))
        print("excvaddr       0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EXCVADDR_IDX + 1])
        print("epc1           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC1_IDX + 1])
        print("epc2           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC2_IDX + 1])
        print("epc3           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC3_IDX + 1])
        print("epc4           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC4_IDX + 1])
        print("epc5           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC5_IDX + 1])
        print("epc6           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC6_IDX + 1])
        print("epc7           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPC7_IDX + 1])
        print("eps2           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPS2_IDX + 1])
        print("eps3           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPS3_IDX + 1])
        print("eps4           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPS4_IDX + 1])
        print("eps5           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPS5_IDX + 1])
        print("eps6           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPS6_IDX + 1])
        print("eps7           0x%x" % extra_info[1 + 2 * ESPCoreDumpElfFile.REG_EPS7_IDX + 1])
    else:
        print("Exception registers have not been found!")
    p = gdbmi_getinfo(p, handlers, "info registers")
    print("\n==================== CURRENT THREAD STACK =====================")
    if args.no_gdb_backtrace:
        p = gdbmi_print_backtrace(p)
    else:
        p = gdbmi_getinfo(p, handlers, "bt")
    tcb_addr = None
    if extra_note:
        tcb_addr = extra_info[0]
    else:
        p,thr_info_res = gdbmi_get_thread_info(p)
        if not thr_info_res.target_id:
            print("WARNING: Unable to get thread info\n")
        else:
            tcb_addr = gdb2freertos_thread_id(thr_info_res.target_id)
    print("\n======================== THREADS INFO =========================")
    p = gdbmi_getinfo(p, handlers, "info threads")
    # THREADS STACKS
    p,threads,curr_thread = gdbmi_get_thread_ids(p)
    print()
    for thr_id in threads:
        p = gdbmi_switch_thread(p, thr_id)
        p,thr_info_res = gdbmi_get_thread_info(p, thr_id)
        if not thr_info_res.target_id:
            print("WARNING: Unable to switch to thread %s\n" % thr_id)
            continue
        tcb_addr = gdb2freertos_thread_id(thr_info_res.target_id)
        p,task_name = gdbmi_freertos_get_task_name(p, tcb_addr)
        print("==================== THREAD %s (TCB: 0x%x, name: '%s') =====================" % (thr_id, tcb_addr, task_name))
        if args.no_gdb_backtrace:
            p = gdbmi_print_backtrace(p)
        else:
            p = gdbmi_getinfo(p, handlers, "bt")
        print()
    print("\n======================= ALL MEMORY REGIONS ========================")
    print("Name   Address   Size   Attrs")
    for ms in merged_segs:
        print("%s 0x%x 0x%x %s" % (ms[0], ms[1], ms[2], ms[3]))
    for cs in core_segs:
        # core dump exec segments are from ROM, other are belong to tasks (TCB or stack)
        if cs.flags & ESPCoreDumpSegment.PF_X:
            seg_name = 'rom.text'
        else:
            seg_name = 'tasks.data'
        print(".coredump.%s 0x%x 0x%x %s" % (seg_name, cs.addr, len(cs.data), cs.attr_str()))
    if args.print_mem:
        print("\n====================== CORE DUMP MEMORY CONTENTS ========================")
        for cs in core_elf.program_segments:
            # core dump exec segments are from ROM, other are belong to tasks (TCB or stack)
            if cs.flags & ESPCoreDumpSegment.PF_X:
                seg_name = 'rom.text'
            else:
                seg_name = 'tasks.data'
            print(".coredump.%s 0x%x 0x%x %s" % (seg_name, cs.addr, len(cs.data), cs.attr_str()))
            p = gdbmi_getinfo(p, handlers, "x/%dx 0x%x" % (old_div(len(cs.data),4), cs.addr))
    if log_saved:
        print("\n====================== CORE DUMP LOG CONTENTS ========================")

        print('Raw Data:')
        step = 4
        g_raw_data = [log_saved[i:i+step] for i in range(0,len(log_saved[:256]),step)]
        # print(g_raw_data)
        for type_i in range(0,20) :
            print( "%02d" % (type_i) + ":" +
             " Time:"+((g_raw_data[type_i*3])[::-1]).encode('hex') +
             " count:" + ((g_raw_data[type_i*3+1])[::-1]).encode('hex') +
             " data:"+ ((g_raw_data[type_i*3+1])[::-1]).encode('hex'))

        str_data = log_saved[:]
        print('\nString Data:')
        print(str_data)

    print("\n===================== ESP32 CORE DUMP END =====================")
    print("===============================================================")

    p.stdin.write(b'q\n')
    p.wait()
    p.stdin.close()
    p.stdout.close()

    if loader:
        if not args.core and not args.save_core:
            loader.remove_tmp_file(core_fname)
        loader.cleanup()
    print('Done!')


def main():
    parser = argparse.ArgumentParser(description='espcoredump.py v%s - ESP32 Core Dump Utility' % __version__, prog='espcoredump')

    parser.add_argument('--chip', '-c',
                        help='Target chip type',
                        choices=['auto', 'esp32'],
                        default=os.environ.get('ESPTOOL_CHIP', 'auto'))

    parser.add_argument(
        '--port', '-p',
        help='Serial port device',
        default=os.environ.get('ESPTOOL_PORT', esptool.ESPLoader.DEFAULT_PORT))

    parser.add_argument(
        '--baud', '-b',
        help='Serial port baud rate used when flashing/reading',
        type=int,
        default=os.environ.get('ESPTOOL_BAUD', esptool.ESPLoader.ESP_ROM_BAUD))

    subparsers = parser.add_subparsers(
        dest='operation',
        help='Run coredumper {command} -h for additional help')

    parser_debug_coredump = subparsers.add_parser(
        'dbg_corefile',
        help='Starts GDB debugging session with specified corefile')
    parser_debug_coredump.add_argument('--debug', '-d', help='Log level (0..3)', type=int, default=3)
    parser_debug_coredump.add_argument('--gdb', '-g', help='Path to gdb', default='xtensa-esp32-elf-gdb')
    parser_debug_coredump.add_argument('--core', '-c', help='Path to core dump file (if skipped core dump will be read from flash)', type=str)
    parser_debug_coredump.add_argument('--core-format', '-t', help='(elf, raw or b64). File specified with "-c" is an ELF ("elf"), '
                                                                   'raw (raw) or base64-encoded (b64) binary',
                                                                   choices=['b64', 'elf', 'raw'], type=str, default='elf')
    parser_debug_coredump.add_argument('--off', '-o', help='Ofsset of coredump partition in flash '
                                                           '(type "make partition_table" to see).', type=int, default=None)
    parser_debug_coredump.add_argument('--save-core', '-s', help='Save core to file. Othwerwise temporary core file will be deleted. '
                                                                 'Ignored with "-c"', type=str)
    parser_debug_coredump.add_argument('--rom-elf', '-r', help='Path to ROM ELF file.', type=str, default='esp32_rom.elf')
    parser_debug_coredump.add_argument('prog', help='Path to program\'s ELF binary', type=str)

    parser_info_coredump = subparsers.add_parser(
        'info_corefile',
        help='Print core dump info from file')
    parser_info_coredump.add_argument('--debug', '-d', help='Log level (0..3)', type=int, default=3)
    parser_info_coredump.add_argument('--gdb', '-g', help='Path to gdb', default='xtensa-esp32-elf-gdb')
    parser_info_coredump.add_argument('--addr2line', '-a', help='Path to addr2line', default='xtensa-esp32-elf-addr2line')
    parser_info_coredump.add_argument('--core', '-c', help='Path to core dump file (if skipped core dump will be read from flash)', type=str)
    parser_info_coredump.add_argument('--core-format', '-t', help='(elf, raw or b64). File specified with "-c" is an ELF ("elf"), '
                                                                  'raw (raw) or base64-encoded (b64) binary',
                                                                  choices=['b64', 'elf', 'raw'], type=str, default='elf')
    parser_info_coredump.add_argument('--off', '-o', help='Offset of coredump partition in flash (type '
                                                          '"make partition_table" to see).', type=int, default=None)
    parser_info_coredump.add_argument('--save-core', '-s', help='Save core to file. Othwerwise temporary core file will be deleted. '
                                                                'Does not work with "-c"', type=str)
    parser_info_coredump.add_argument('--rom-elf', '-r', help='Path to ROM ELF file.', type=str, default='esp32_rom.elf')
    parser_info_coredump.add_argument('--print-mem', '-m', help='Print memory dump', action='store_true')
    parser_info_coredump.add_argument('--no-gdb-backtrace', '-b', help='Do not use GDB to print backtraces. Use builtin method.', action='store_true')
    parser_info_coredump.add_argument('prog', help='Path to program\'s ELF binary', type=str)

    # internal sanity check - every operation matches a module function of the same name
    for operation in subparsers.choices:
        assert operation in globals(), "%s should be a module function" % operation

    args = parser.parse_args()

    log_level = logging.CRITICAL
    if args.debug == 0:
        log_level = logging.CRITICAL
    elif args.debug == 1:
        log_level = logging.ERROR
    elif args.debug == 2:
        log_level = logging.WARNING
    elif args.debug == 3:
        log_level = logging.INFO
    else:
        log_level = logging.DEBUG
    logging.basicConfig(format='%(levelname)s: %(message)s', level=log_level)

    print('espcoredump.py v%s' % __version__)

    operation_func = globals()[args.operation]
    operation_func(args)


if __name__ == '__main__':
    try:
        main()
    except ESPCoreDumpError as e:
        print('\nA fatal error occurred: %s' % e)
        sys.exit(2)