#!/usr/bin/env python3

# SPDX-License-Identifier: BSD-3-Clause
#
# Copyright (c) 2019, Intel Corporation. All rights reserved.
#
# Author: Michal Jerzy Wierzbicki <michalx.wierzbicki@linux.intel.com>
#         Adrian Bonislawski <adrian.bonislawski@linux.intel.com>

# Tool for processing FW stack dumps.
# For more detailed useage, use --help option.

from __future__  import print_function
import argparse
import struct
import os
import sys
import itertools
import re
import shutil
import time
from ctypes      import LittleEndianStructure, BigEndianStructure, c_uint32, c_char
from collections import namedtuple
from operator    import attrgetter
from functools   import partial

def stderr_print(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def stdout_print(*args, **kwargs):
	print(*args, file=sys.stdout, **kwargs)

try:
	from sty import fg, bg, ef, rs, Rule, Render
	CAN_COLOUR=True
except:
	CAN_COLOUR=False

ArchDefinition = namedtuple('ArchDefinition', ['name', 'bitness', 'endianness'])
VALID_ARCHS = {}
[VALID_ARCHS.update({archdef.name : archdef})
	for archdef in [ArchDefinition(*tup) for tup in
	[
		( 'LE32bit',
			32,
			LittleEndianStructure, ),
		( 'LE64bit',
			64,
			LittleEndianStructure, ),
#		( 'BE32bit', #untested, treat as not implemented
#			32,
#			BigEndianStructure, ),
#		( 'BE64bit', #untested, treat as not implemented
#			64,
#			BigEndianStructure, ),
	]]
]

# Exception causes:
# CODE: [Exception cause, excvaddr loaded]
EXCCAUSE_CODE = {
	0: ["IllegalInstructionCause: Illegal instruction", False],
	1: ["SyscallCause: SYSCALL instruction", True],
	2: ["InstructionFetchErrorCause: Processor internal physical address or data error during instruction fetch", True],
	3: ["LoadStoreErrorCause: Processor internal physical address or data error during load or store", True],
	4: ["Level1InterruptCause: Level-1 interrupt as indicated by set level-1 bits in the INTERRUPT register", False],
	5: ["AllocaCause: MOVSP instruction, if caller's registers are not in the register file", False],
	6: ["IntegerDivideByZeroCause: QUOS, QUOU, REMS, or REMU divisor operand is zero", False],
	8: ["PrivilegedCause: Attempt to execute a privileged operation when CRING ? 0", False],
	9: ["LoadStoreAlignmentCause: Load or store to an unaligned address", True],
	12: ["InstrPIFDataErrorCause: PIF data error during instruction fetch", True],
	13: ["LoadStorePIFDataErrorCause: ynchronous PIF data error during LoadStore access", True],
	14: ["InstrPIFAddrErrorCause: PIF address error during instruction fetch", True],
	15: ["LoadStorePIFAddrErrorCause: Synchronous PIF address error during LoadStore access", True],
	16: ["InstTLBMissCause: Error during Instruction TLB refill", True],
	17: ["InstTLBMultiHitCause: Multiple instruction TLB entries matched", True],
	18: ["InstFetchPrivilegeCause: An instruction fetch referenced a virtual address at a ring level less than CRING", True],
	20: ["InstFetchProhibitedCause: An instruction fetch referenced a page mapped with an attribute that does not permit instruction fetch", True],
	24: ["LoadStoreTLBMissCause: Error during TLB refill for a load or store", True],
	25: ["LoadStoreTLBMultiHitCause: Multiple TLB entries matched for a load or store", True],
	26: ["LoadStorePrivilegeCause: A load or store referenced a virtual address at a ring level less than CRING", True],
	28: ["LoadProhibitedCause: A load referenced a page mapped with an attribute that does not permit loads", True],
	29: ["StoreProhibitedCause: A store referenced a page mapped with an attribute that does not permit stores", True],
	32: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	33: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	34: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	35: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	36: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	37: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	38: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False],
	39: ["CoprocessornDisabled: Coprocessor n instruction when cpn disabled. n varies 0..7 as the cause varies 32..39", False]
}

def valid_archs_print():
	archs = ''.join("{0}, ".format(x) for x in VALID_ARCHS)
	archs = archs[:len(archs)-2]
	return "{0}.".format(archs)

TERM_SIZE = shutil.get_terminal_size((120, 20))
AR_WINDOW_WIDTH = 4
IS_COLOUR=False

class argparse_readable_file( argparse.Action):
	def raise_error(self, filepath, reason):
		raise argparse.ArgumentTypeError(
			"is_readable_file:{0} {1}".format(
				filepath,
				reason
			))
	def is_readable_file(self, filepath):
		if not os.path.isfile(filepath):
			self.raise_error(filepath, "is not a valid path")
		if os.access(filepath, os.R_OK):
			return True
		else:
			self.raise_error(filepath, "is not a readable file")
		return False
	def __call__(self, parser, namespace, values, option_string=None):
		filepath = values[0]
		if (self.is_readable_file(filepath)):
			setattr(namespace, self.dest, filepath)

class argparse_writeable_file(argparse.Action):
	def raise_error(self, filepath, reason):
		raise argparse.ArgumentTypeError(
			"is_writeable_file:{0} {1}".format(
				filepath,
				reason
			))
	def is_writeable_file(self, filepath):
		absdir = os.path.abspath(os.path.dirname(filepath))
		if os.path.isdir(absdir) and not os.path.exists(filepath):
			return True
		else:
			if not os.path.isfile(filepath):
				self.raise_error(filepath, "is not a valid path")
			if os.access(filepath, os.W_OK):
				return True
			else:
				self.raise_error(filepath, "is not a writeable file")
		return False
	def __call__(self, parser, namespace, values, option_string=None):
		filepath = values[0]
		if (self.is_writeable_file(filepath)):
			setattr(namespace, self.dest, filepath)
		else:
			self.raise_error(
				filepath,
				"failed to determine whether file is writeable"
			)

class argparse_architecture(  argparse.Action):
	def raise_error(self, value, reason):
		raise argparse.ArgumentTypeError(
			"architecture: {0} {1}".format(
				value,
				reason
			))
	def is_valid_architecture(self, value):
		if value in VALID_ARCHS:
			return True
		return False
	def __call__(self, parser, namespace, values, option_string=None):
		value = values[0]
		if (self.is_valid_architecture(value)):
			setattr(namespace, self.dest, VALID_ARCHS[value])
		else:
			self.raise_error(
				value,
				"is invalid architecture. Valid architectures are: {0}".format(valid_archs_print())
			)

def parse_params():
	parser = argparse.ArgumentParser(
		description="Tool for processing FW stack dumps."
			+" In verbose mode it prints DSP registers, and function call"
			+" addresses in stack up to that which caused core dump."
			+" It then prints either to file or to stdin all gdb"
			+" commands unwrapping those function call addresses to"
			+" function calls in  human readable format."
	)
	ArgTuple = namedtuple('ArgTuple', ['name', 'optionals', 'parent'])
	ArgTuple.__new__.__defaults__ = ((), {}, parser)

	# below cannot be empty once declared
	outputMethod = parser.add_mutually_exclusive_group(required=True)
	inputMethod  = parser.add_mutually_exclusive_group()
	[parent.add_argument(*name, **optionals)
		for name, optionals, parent in sorted([ArgTuple(*x) for x in
			[
				( ( '-a', '--arch'       , ), {
						'type'   : str,
						'help'   :'determine architecture of dump file; valid archs are:  {0}'
							.format(valid_archs_print()),
						'action' : argparse_architecture,
						'nargs'  : 1,
						'default': VALID_ARCHS['LE64bit'],
					},),
				( ( '-v', '--verbose'    , ), {
						'help'  :'increase output verbosity',
						'action':'store_true',
					},),
				( (       '--stdin'      , ), {
						'help'   :'input is from stdin',
						'action' : 'store_true',
					},
					inputMethod),
				( ( '-o', '--outfile'    , ), {
						'type'   : str,
						'help'   :'output is to FILE',
						'action' : argparse_writeable_file,
						'nargs'  : 1,
					},
					outputMethod),
				( (       '--stdout'     , ), {
						'help'   :'output is to stdout',
						'action' :'store_true',
					},
					outputMethod),
				( ( '-c', '--colour', ), {
						'help'  :'set output to be colourful!',
						'action':'store_true',
					},),
				( ( '-l', '--columncount', ), {
						'type'  : int,
						'help'  :'set how many colums to group the output in, ignored without -v',
						'action':'store',
						'nargs' : 1,
					},),
				( ( '-i', '--infile'     , ), {
						'type'   : str,
						'help'   :'path to sys dump bin',
						'action' : argparse_readable_file,
						'nargs'  : 1,
					},
					inputMethod),
			]],
			key=lambda argtup: (argtup.parent.__hash__(), argtup.name)
		)
	]

	parsed = parser.parse_args()

	if parsed.columncount and not parsed.verbose:
		stderr_print("INFO: -l option will be ignored without -v")

	return parsed

def chunks(l, n):
	return [l[i:i + n] for i in range(0, len(l), n)]

def flaten(l):
	return [item for sublist in l for item in sublist]

def raiseIfArchNotValid(arch):
	if arch not in VALID_ARCHS.values():
		raise ValueError(
			"CoreDumpFactory: {0} not in valid architectures: {1}"
				.format(arch, valid_archs_print())
		)
	endiannesses = [arch.endianness for arch in VALID_ARCHS.values()]
	if arch.endianness not in endiannesses:
		raise ValueError(
			"CoreDumpFactory: {0} not in valid endiannesses: {1}"
				.format(endianness, endiannesses)
		)

def FileInfoFactory(arch, filename_length):
	raiseIfArchNotValid(arch)
	class FileInfo(arch.endianness):
		_fields_ = [
			("hdr",  c_uint32),
			("code",  c_uint32),
			("filename", filename_length * c_char),
			("line_no",  c_uint32)
		]
		def __str__(self):
			return "{}:{:d}".format(self.filename.decode(), self.line_no)
	if FileInfo is None:
		raise RuntimeError(
			"FileInfoFactory: failed to produce FileInfo({0})"
				.format(arch.name)
		)
	return FileInfo

class Colourer():
	#TODO: Add detection of 8bit/24bit terminal
	#      Add 8bit/24bit colours (with flag, maybe --colour=24bit)
	#      Use this below as fallback only
	__print = partial(stdout_print)
	if CAN_COLOUR == True:
		__style = {
			'o' : fg.red,
			'O' : fg.yellow,
			'y' : fg.blue,
			'Y' : fg.cyan,
			'D' : fg.white + bg.red,
		}
	matchings          = []
	matchingsInParenth = []
	matchingsInStderr  = []
	def __init__(self):
		if CAN_COLOUR == True:
			self.matchings = [
				(
					lambda x: self.enstyleNumHex(x.group()),
					re.compile(r'\b([A-Fa-f0-9]{8})\b')
				),
				(
					lambda x: '0x' + self.enstyleNumHex(x.group(2)),
					re.compile(r'(0x)([A-Fa-f0-9]{1,})')
				),
				(
					lambda x: self.enstyleNumBin(x.group()),
					re.compile(r'\b(b[01]+)\b')
				),
				(
					r'\1' +
					r'\2' +
					self.enstyle(           fg.green , r'\3') ,
					re.compile(r'(\#)(ar)([0-9]+)\b')
				),
				(
					self.enstyle(bg.green            , r'\1') +
					rs.all + '\n',
					re.compile(r'(\(xt-gdb\)\ *)')
				),
				(
					r'\1' +
					r'\2' +
					self.enstyle(           fg.green   , r'\3') +
					r':'  +
					self.enstyle(           fg.magenta , r'\4') ,
					re.compile(r'(\bat\b\ *)(.+/)?(.*):([0-9]+)')
				),
				(
					lambda x:\
						'in '+
						self.enstyle(fg.green,  x.group(2))+
						self.enstyleFuncParenth(x.group(3)),
					re.compile(r'(\bin\b\ *)([^\ ]+)\ *(\(.*\))')
				),
			]
			self.matchingsInParenth = [
				(
					self.enstyle(           fg.yellow   , r'\1') +
					self.enstyle(           fg.magenta  , r'=' ) +
					r'\2',
					re.compile(r'([\-_a-zA-Z0-9]+)\ *=\ *([^,]+)')
				),
				(
					self.enstyle(           fg.magenta  , r'\1') ,
					re.compile(r'(\ *[\(\)]\ *)')
				),
				(
					self.enstyle(           fg.magenta  , r', ') ,
					re.compile(r'(\ *,\ *)')
				),
			]
			self.matchingsInStderr = [
				(
					self.enstyle(bg.yellow  + fg.black    , r'\1') ,
					re.compile(r'([Ww]arning)')
				),
				(
					self.enstyle(bg.red     + fg.black    , r'\1') ,
					re.compile(r'([Ee]rror)')
				),
				(
					self.enstyle(bg.magenta + fg.black    , r'\1') ,
					re.compile(r'([Ff]atal)')
				),
			]

	def toGroup(self, txt):
		return [ (label, sum(1 for _ in group))
				for label, group in itertools.groupby(txt) ]

	def leadingZero(self, txt, char):
		result = ""
		groups = self.toGroup(txt)
		lead = 0
		if groups[0][0] == '0':
			lead = min(4, groups[0][1])
			result += char.lower() *    lead
		result +=     char.upper() * (4-lead)
		return result

	def findSub(self, txt, mask, sub, char):
		pos = txt.find(sub)
		if pos >= 0:
			return mask[:pos] + char * len(sub) + mask[(len(sub)+pos):]
		else:
			return mask

	def enstyleFuncParenth(self, txt):
		result = txt
		for repl, regex in self.matchingsInParenth:
			result = re.sub(regex, repl, result)
		return result 
		
	def enstyleNumBin(self, txt):
		result = rs.all + bg.magenta + "b"
		prev = ""
		for c in txt[1:]:
			if prev != c:
				prev = c
				result += rs.all
				if c == "0":
					result += fg.red
			result += c
		result += rs.all
		return result

	def enstyleNumHex(self, txt):
		if len(txt) < 8:
			txt = (8-len(txt))*'0' + txt
		p1 = 'o'
		p2 = 'y'
		if txt == "00000000":
			styleMask = p1 * 8
		elif txt.lower() == "deadbeef":
			styleMask = "DDDDDDDD"
		else:
			styleMask = "".join(
				[self.leadingZero(string, style)
				for string, style in [
					(txt[:4], p1),
					(txt[4:], p2),
			]])
			styleMask = "".join(
				[self.findSub(txt, styleMask, string, style)
				for string, style in [
					('dead', 'D'),
			]])

		result = ""
		thisstyle = ''
		for iter, style in enumerate(styleMask):
			if thisstyle != style:
				thisstyle = style
				result += rs.all + self.__style[thisstyle]
			result += txt[iter]
		result += rs.all
		return result

	def enstyleStderr(self, txt):
		if txt is None:
			return ''
		result = txt
		for repl, regex in self.matchingsInStderr:
			result = re.sub(regex, repl, result)
		for repl, regex in self.matchings:
			result = re.sub(regex, repl, result)
		return fg.red + result + rs.all

	def enstyle(self, style, txt):
		return style + txt + rs.all

	def produce_string(self, txt):
		result = txt
		for repl, regex in self.matchings:
			result = re.sub(regex, repl, result)
		return result

	def print(self, txt):
		self.__print(self.produce_string(txt))

def CoreDumpFactory(dsp_arch):
	raiseIfArchNotValid(dsp_arch)
	class CoreDump(dsp_arch.endianness):
		_fields_ = [(x, c_uint32) for x in
				[
					# struct sof_ipc_dsp_oops_arch_hdr {
					"arch",
					"totalsize",
					# }
					# struct sof_ipc_dsp_oops_plat_hdr {
					"configidhi",
					"configidlo",
					"numaregs",
					"stackoffset",
					"stackptr",
					# }
					"exccause",
					"excvaddr",
					"ps"
				]
				+ ["epc" + str(x) for x in range(1,7+1)]
				+ ["eps" + str(x) for x in range(2,7+1)]
				+ [
					"depc",
					"intenable",
					"interrupt",
					"sar",
					"debugcause",
					"windowbase",
					"windowstart",
					"excsave1" # to
				]
			] + [
				("a", dsp_arch.bitness * c_uint32)
			]

		def __init__(self, columncount):
			self.dsp_arch = dsp_arch
			self._fields_
			self.ar_regex = re.compile(r'ar[0-9]+')
			# below: smart column count
			self._longest_field = len(max([x[0] for x in self._fields_], key=len))
			if columncount is not None:
				self.columncount = max (1, int(columncount[0]))
			else:
				self.columncount = max(1,
					int(TERM_SIZE[0]/(self._longest_field + 2 + 2 * AR_WINDOW_WIDTH + 2))
				)
			self.columncount_ar = (
				self.columncount
					if self.columncount <= AR_WINDOW_WIDTH else
				AR_WINDOW_WIDTH * int(self.columncount/AR_WINDOW_WIDTH)
			)

		def __windowbase_shift(self, iter, direction):
			return (iter + self.windowbase * AR_WINDOW_WIDTH * direction)\
				% self.dsp_arch.bitness
		def windowbase_shift_left(self, iter):
			return self.__windowbase_shift(iter, -1)
		def windowbase_shift_right(self, iter):
			return self.__windowbase_shift(iter,  1)

		def reg_from_string(self, string):
			if self.ar_regex.fullmatch(string):
				return self.a[self.windowbase_shift_left(int(string[2:]))]
			else:
				return self.__getattribute__(string)

		def __str__(self):
			string = ""
			string += "exccause"
			return string

		def to_string(self, is_gdb):
			# in case windowbase in dump has invalid value
			windowbase_shift = min(
				self.windowbase * AR_WINDOW_WIDTH,
				self.dsp_arch.bitness
			)
			# flatten + chunk enable to smartly print in N columns
			string = ''.join([self.fmt(is_gdb, x)
				for x in flaten(
					[chunks(word, self.columncount) for word in [
						["arch", "totalsize", "stackptr", "stackoffset"],
						["configidhi", "configidlo", "numaregs"],
					]]
				)
			])

			string += "\n# CPU registers:\n\n"

			string += ''.join([self.fmt(is_gdb, x)
				for x in flaten(
					[chunks(word, self.columncount) for word in [
						["exccause", "excvaddr", "ps"],
						["epc" + str(x) for x in range(1,7+1)],
						["eps" + str(x) for x in range(2,7+1)],
						["depc", "intenable", "interrupt", "sar", "debugcause"],
						["windowbase", "windowstart"],
						["excsave1"],
					]] +
					[chunks(word, self.columncount_ar) for word in [
						["ar" + str(x) for x in itertools.chain(
							range(   windowbase_shift, self.dsp_arch.bitness),
							range(0, windowbase_shift),
						)]
					]]
				)
			])

			if not is_gdb:
				string += "\n"
			return string

		def fmt_gdb_command(self):
			return "set ${}=0x{:08x}\n"

		def fmt_pretty_form(self, separator = "|"):
			return separator + "{:" + str(self._longest_field) + "} {:08x} "

		def fmt_separator(self, name):
			separator = "# "
			return separator

		def fmt_pretty_auto(self, name):
			return self.fmt_pretty_form(self.fmt_separator(name))

		def fmt(self, is_gdb, names):
			if is_gdb:
				fmtr = lambda name: self.fmt_gdb_command()
			else:
				fmtr = lambda name: self.fmt_pretty_auto(name)

			string = ""
			for name in names:
				string += fmtr(name).format(
					name, self.reg_from_string(name)
				)
			if not is_gdb:
				string += "\n"
			return string

		def windowstart_process(self):
			string = ""
			binary = "{0:b}".format(self.windowstart)
			bit_start = len(binary)-1-self.windowbase
			fnc_num = 0
			header = ""

			for it, c in enumerate(binary[bit_start:]):
				if c != "0":
					header += str(fnc_num)
					fnc_num += 1
				else:
					header += " "
			for it, c in enumerate(binary[:bit_start]):
				if c != "0":
					header += str(fnc_num)
					fnc_num += 1
				else:
					header += " "
			header = header[self.windowbase+1:]+ header[:self.windowbase+1]

			string += "# windowbase: {:0X}\n".format(self.windowbase)
			string += "#               {0}\n".format(header)
			string += "# windowstart: b{0}\n\n".format(binary)
			string += "#      reg         a0         a1\n"
			string += "#                  (return)   (sptr)\n"
			string += "#      ---         --------   -------\n"
			fnc_num = 0
			for iter, digit in enumerate(binary[bit_start:]):
				if (digit == '1'):
					reg = "ar{0}".format(AR_WINDOW_WIDTH * (self.windowbase - iter))
					reg1 = "ar{0}".format(AR_WINDOW_WIDTH * (self.windowbase - iter) + 1)
					string += "# {0:2d} ".format(++fnc_num)
					string += self.fmt_pretty_auto(reg).format(
						reg, self.reg_from_string(reg)
					) + "  {:0x} ".format(self.reg_from_string(reg1)) + "\n"
					fnc_num += 1
			for iter, digit in enumerate(binary[:bit_start]):
				if (digit == '1'):
					reg = "ar{0}".format(AR_WINDOW_WIDTH * (len(binary) - 1 - iter))
					reg1 = "ar{0}".format(AR_WINDOW_WIDTH * (len(binary) - 1 - iter) + 1)
					string += "# {0:2d} ".format(++fnc_num)
					string += self.fmt_pretty_auto(reg).format(
						reg, self.reg_from_string(reg)
					) + "  {:0x} ".format(self.reg_from_string(reg1)) + "\n"
					fnc_num += 1
			return string

	if CoreDump is None:
		raise RuntimeError(
			"CoreDumpFactory: failed to produce CoreDump({0})"
				.format(dsp_arch.name)
		)
	return CoreDump

class CoreDumpReader(object):
	def __init__(self, args):
		self.core_dump    = CoreDumpFactory(args.arch)(
			args.columncount
		)
		self.file_info    = FileInfoFactory(args.arch, 32)()

		if IS_COLOUR:
			colourer = Colourer()
		if args.verbose:
			verbosePrint =\
					colourer.print\
				if IS_COLOUR else\
					stdout_print
		else:
			verbosePrint = lambda *discard_this: None

		if   args.stdout:
			stdoutOpen  = lambda: None
			stdoutPrint = print
			stdoutClose = lambda: None
		elif args.outfile:
			#TODO: open file in stdOutOpen
			stdoutDest  = open(args.outfile, "w")
			stdoutOpen  = lambda: None
			stdoutPrint = stdoutDest.write
			stdoutClose = stdoutDest.close
		else:
			raise RuntimeError("CoreDumpReader: No output method.") 

		if   args.stdin:
			inStream = lambda: sys.stdin.buffer
		elif args.infile:
			inStream = lambda: open(args.infile, "rb")
		else:
			raise RuntimeError("CoreDumpReader: No input method.") 

		with inStream() as cd_file:
			[cd_file.readinto(x) for x in [
				self.core_dump,
				self.file_info
			]]
			self.stack = cd_file.read()

		verbosePrint("# Core header:\n")
		verbosePrint(self.core_dump.to_string(0))

		verbosePrint(self.core_dump.windowstart_process())

		stack_base = self.core_dump.stackptr
		stack_dw_num = int(len(self.stack)/AR_WINDOW_WIDTH)
		verbosePrint("# Stack dumped from {:08x} dwords num {:d}"
			.format(stack_base, stack_dw_num))

		stdoutOpen()

		# disable confirmation request for undefined breakpoint
		stdoutPrint("set confirm off\n")

		# for XTOS SOF build
		stdoutPrint("break _MemErrorVector\n")
		# for Zephyr SOF build
		stdoutPrint("break _MemoryExceptionVector_text_start\n")

		stdoutPrint("run\n")
		stdoutPrint(self.core_dump.to_string(1))

		#TODO: make this elegant
		for dw, addr in [(
			struct.unpack("I", self.stack[i*AR_WINDOW_WIDTH : (i+1)*AR_WINDOW_WIDTH])[0],
			stack_base + i*AR_WINDOW_WIDTH
		) for i in range(0, stack_dw_num)]:
			stdoutPrint("set *0x{:08x}=0x{:08x}\n"
				.format(addr, dw))

                # Exccause 63 is reserved for panics; the other causes come
                # from actual exceptions
		if self.core_dump.exccause != 63:
			verbosePrint("\n# *EXCEPTION*\n")
			verbosePrint("# exccause: " + EXCCAUSE_CODE[self.core_dump.exccause][0])
			if EXCCAUSE_CODE[self.core_dump.exccause][1]:
				verbosePrint("# excvaddr: " + str(self.core_dump.excvaddr))
			stdoutPrint('p "Exception location:"\nlist *$epc1\n');
		else:
			verbosePrint("# Location: " + str(self.file_info));

		# TODO: if excsave1 is not empty, pc should be set to that value
		# (exception mode, not forced panic mode)
		stdoutPrint('set $pc=&arch_dump_regs_a\np "backtrace"\nbacktrace\n')
		stdoutClose()

if __name__ == "__main__":
	args = parse_params()
	if args.colour:
		if CAN_COLOUR:
			IS_COLOUR=True
		else:
			stderr_print("INFO: Cannot color the output: module 'sty' not found")
	CoreDumpReader(args)