/*

 * Copyright (c) 2013-2017, Intel Corporation

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 *  * Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *  * Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *  * Neither the name of Intel Corporation nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#if defined(FEATURE_ELF)

# include "load_elf.h"

#endif /* defined(FEATURE_ELF) */

#include "pt_cpu.h"

#include "intel-pt.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <inttypes.h>

#include <errno.h>

#include <xed-interface.h>

/* The type of decoder to be used. */

enum ptxed_decoder_type {

	pdt_insn_decoder,

	pdt_block_decoder

};

/* The decoder to use. */

struct ptxed_decoder {

	/* The decoder type. */

	enum ptxed_decoder_type type;

	/* The actual decoder. */

	union {

		/* If @type == pdt_insn_decoder */

		struct pt_insn_decoder *insn;

		/* If @type == pdt_block_decoder */

		struct pt_block_decoder *block;

	} variant;

};

/* A collection of options. */

struct ptxed_options {

	/* Do not print the instruction. */

	uint32_t dont_print_insn:1;

	/* Remain as quiet as possible - excluding error messages. */

	uint32_t quiet:1;

	/* Print statistics (overrides quiet). */

	uint32_t print_stats:1;

	/* Print information about section loads and unloads. */

	uint32_t track_image:1;

	/* Track blocks in the output.

	 *

	 * This only applies to the block decoder.

	 */

	uint32_t track_blocks:1;

	/* Print in AT&T format. */

	uint32_t att_format:1;

	/* Print the offset into the trace file. */

	uint32_t print_offset:1;

	/* Print the current timestamp. */

	uint32_t print_time:1;

	/* Print the raw bytes for an insn. */

	uint32_t print_raw_insn:1;

	/* Perform checks. */

	uint32_t check:1;

};

/* A collection of flags selecting which stats to collect/print. */

enum ptxed_stats_flag {

	/* Collect number of instructions. */

	ptxed_stat_insn		= (1 << 0),

	/* Collect number of blocks. */

	ptxed_stat_blocks	= (1 << 1)

};

/* A collection of statistics. */

struct ptxed_stats {

	/* The number of instructions. */

	uint64_t insn;

	/* The number of blocks.

	 *

	 * This only applies to the block decoder.

	 */

	uint64_t blocks;

	/* A collection of flags saying which statistics to collect/print. */

	uint32_t flags;

};

static int ptxed_have_decoder(const struct ptxed_decoder *decoder)

{

	/* It suffices to check for one decoder in the variant union. */

	return decoder && decoder->variant.insn;

}

static void ptxed_free_decoder(struct ptxed_decoder *decoder)

{

	if (!decoder)

		return;

	switch (decoder->type) {

	case pdt_insn_decoder:

		pt_insn_free_decoder(decoder->variant.insn);

		break;

	case pdt_block_decoder:

		pt_blk_free_decoder(decoder->variant.block);

		break;

	}

}

static void version(const char *name)

{

	struct pt_version v = pt_library_version();

	printf("%s-%d.%d.%d%s / libipt-%" PRIu8 ".%" PRIu8 ".%" PRIu32 "%s\n",

	       name, PT_VERSION_MAJOR, PT_VERSION_MINOR, PT_VERSION_BUILD,

	       PT_VERSION_EXT, v.major, v.minor, v.build, v.ext);

}

static void help(const char *name)

{

	printf("usage: %s [<options>]\n\n", name);

	printf("options:\n");

	printf("  --help|-h                            this text.\n");

	printf("  --version                            display version information and exit.\n");

	printf("  --att                                print instructions in att format.\n");

	printf("  --no-inst                            do not print instructions (only addresses).\n");

	printf("  --quiet|-q                           do not print anything (except errors).\n");

	printf("  --offset                             print the offset into the trace file.\n");

	printf("  --time                               print the current timestamp.\n");

	printf("  --raw-insn                           print the raw bytes of each instruction.\n");

	printf("  --check                              perform checks (expensive).\n");

	printf("  --stat                               print statistics (even when quiet).\n");

	printf("                                       collects all statistics unless one or more are selected.\n");

	printf("  --stat:insn                          collect number of instructions.\n");

	printf("  --verbose|-v                         print various information (even when quiet).\n");

	printf("  --pt <file>[:<from>[-<to>]]          load the processor trace data from <file>.\n");

	printf("                                       an optional offset or range can be given.\n");

#if defined(FEATURE_ELF)

	printf("  --elf <<file>[:<base>]               load an ELF from <file> at address <base>.\n");

	printf("                                       use the default load address if <base> is omitted.\n");

#endif /* defined(FEATURE_ELF) */

	printf("  --raw <file>[:<from>[-<to>]]:<base>  load a raw binary from <file> at address <base>.\n");

	printf("                                       an optional offset or range can be given.\n");

	printf("  --cpu none|auto|f/m[/s]              set cpu to the given value and decode according to:\n");

	printf("                                         none     spec (default)\n");

	printf("                                         auto     current cpu\n");

	printf("                                         f/m[/s]  family/model[/stepping]\n");

	printf("  --mtc-freq <n>                       set the MTC frequency (IA32_RTIT_CTL[17:14]) to <n>.\n");

	printf("  --nom-freq <n>                       set the nominal frequency (MSR_PLATFORM_INFO[15:8]) to <n>.\n");

	printf("  --cpuid-0x15.eax                     set the value of cpuid[0x15].eax.\n");

	printf("  --cpuid-0x15.ebx                     set the value of cpuid[0x15].ebx.\n");

	printf("  --insn-decoder                       use the instruction flow decoder (default).\n");

	printf("  --block-decoder                      use the block decoder.\n");

	printf("  --block:show-blocks                  show blocks in the output.\n");

	printf("  --block:end-on-call                  set the end-on-call block decoder flag.\n");

	printf("\n");

#if defined(FEATURE_ELF)

	printf("You must specify at least one binary or ELF file (--raw|--elf).\n");

#else /* defined(FEATURE_ELF) */

	printf("You must specify at least one binary file (--raw).\n");

#endif /* defined(FEATURE_ELF) */

	printf("You must specify exactly one processor trace file (--pt).\n");

}

static int extract_base(char *arg, uint64_t *base)

{

	char *sep, *rest;

	sep = strrchr(arg, ':');

	if (sep) {

		uint64_t num;

		if (!sep[1])

			return 0;

		errno = 0;

		num = strtoull(sep+1, &rest, 0);

		if (errno || *rest)

			return 0;

		*base = num;

		*sep = 0;

		return 1;

	}

	return 0;

}

static int parse_range(const char *arg, uint64_t *begin, uint64_t *end)

{

	char *rest;

	if (!arg || !*arg)

		return 0;

	errno = 0;

	*begin = strtoull(arg, &rest, 0);

	if (errno)

		return -1;

	if (!*rest)

		return 1;

	if (*rest != '-')

		return -1;

	*end = strtoull(rest+1, &rest, 0);

	if (errno || *rest)

		return -1;

	return 2;

}

/* Preprocess a filename argument.

 *

 * A filename may optionally be followed by a file offset or a file range

 * argument separated by ':'.  Split the original argument into the filename

 * part and the offset/range part.

 *

 * If no end address is specified, set @size to zero.

 * If no offset is specified, set @offset to zero.

 *

 * Returns zero on success, a negative error code otherwise.

 */

static int preprocess_filename(char *filename, uint64_t *offset, uint64_t *size)

{

	uint64_t begin, end;

	char *range;

	int parts;

	if (!filename || !offset || !size)

		return -pte_internal;

	/* Search from the end as the filename may also contain ':'. */

	range = strrchr(filename, ':');

	if (!range) {

		*offset = 0ull;

		*size = 0ull;

		return 0;

	}

	/* Let's try to parse an optional range suffix.

	 *

	 * If we can, remove it from the filename argument.

	 * If we can not, assume that the ':' is part of the filename, e.g. a

	 * drive letter on Windows.

	 */

	parts = parse_range(range + 1, &begin, &end;;

	if (parts <= 0) {

		*offset = 0ull;

		*size = 0ull;

		return 0;

	}

	if (parts == 1) {

		*offset = begin;

		*size = 0ull;

		*range = 0;

		return 0;

	}

	if (parts == 2) {

		if (end <= begin)

			return -pte_invalid;

		*offset = begin;

		*size = end - begin;

		*range = 0;

		return 0;

	}

	return -pte_internal;

}

static int load_file(uint8_t **buffer, size_t *psize, const char *filename,

		     uint64_t offset, uint64_t size, const char *prog)

{

	uint8_t *content;

	size_t read;

	FILE *file;

	long fsize, begin, end;

	int errcode;

	if (!buffer || !psize || !filename || !prog) {

		fprintf(stderr, "%s: internal error.\n", prog ? prog : "");

		return -1;

	}

	errno = 0;

	file = fopen(filename, "rb");

	if (!file) {

		fprintf(stderr, "%s: failed to open %s: %d.\n",

			prog, filename, errno);

		return -1;

	}

	errcode = fseek(file, 0, SEEK_END);

	if (errcode) {

		fprintf(stderr, "%s: failed to determine size of %s: %d.\n",

			prog, filename, errno);

		goto err_file;

	}

	fsize = ftell(file);

	if (fsize < 0) {

		fprintf(stderr, "%s: failed to determine size of %s: %d.\n",

			prog, filename, errno);

		goto err_file;

	}

	begin = (long) offset;

	if (((uint64_t) begin != offset) || (fsize <= begin)) {

		fprintf(stderr,

			"%s: bad offset 0x%" PRIx64 " into %s.\n",

			prog, offset, filename);

		goto err_file;

	}

	end = fsize;

	if (size) {

		uint64_t range_end;

		range_end = offset + size;

		if ((uint64_t) end < range_end) {

			fprintf(stderr,

				"%s: bad range 0x%" PRIx64 " in %s.\n",

				prog, range_end, filename);

			goto err_file;

		}

		end = (long) range_end;

	}

	fsize = end - begin;

	content = malloc(fsize);

	if (!content) {

		fprintf(stderr, "%s: failed to allocated memory %s.\n",

			prog, filename);

		goto err_file;

	}

	errcode = fseek(file, begin, SEEK_SET);

	if (errcode) {

		fprintf(stderr, "%s: failed to load %s: %d.\n",

			prog, filename, errno);

		goto err_content;

	}

	read = fread(content, fsize, 1, file);

	if (read != 1) {

		fprintf(stderr, "%s: failed to load %s: %d.\n",

			prog, filename, errno);

		goto err_content;

	}

	fclose(file);

	*buffer = content;

	*psize = fsize;

	return 0;

err_content:

	free(content);

err_file:

	fclose(file);

	return -1;

}

static int load_pt(struct pt_config *config, char *arg, const char *prog)

{

	uint64_t foffset, fsize;

	uint8_t *buffer;

	size_t size;

	int errcode;

	errcode = preprocess_filename(arg, &foffset, &fsize);

	if (errcode < 0) {

		fprintf(stderr, "%s: bad file %s: %s.\n", prog, arg,

			pt_errstr(pt_errcode(errcode)));

		return -1;

	}

	errcode = load_file(&buffer, &size, arg, foffset, fsize, prog);

	if (errcode < 0)

		return errcode;

	config->begin = buffer;

	config->end = buffer + size;

	return 0;

}

static int load_raw(struct pt_image_section_cache *iscache,

		    struct pt_image *image, char *arg, const char *prog)

{

	uint64_t base, foffset, fsize;

	int isid, errcode, has_base;

	has_base = extract_base(arg, &base);

	if (has_base <= 0)

		return -1;

	errcode = preprocess_filename(arg, &foffset, &fsize);

	if (errcode < 0) {

		fprintf(stderr, "%s: bad file %s: %s.\n", prog, arg,

			pt_errstr(pt_errcode(errcode)));

		return -1;

	}

	if (!fsize)

		fsize = UINT64_MAX;

	isid = pt_iscache_add_file(iscache, arg, foffset, fsize, base);

	if (isid < 0) {

		fprintf(stderr, "%s: failed to add %s at 0x%" PRIx64 ": %s.\n",

			prog, arg, base, pt_errstr(pt_errcode(isid)));

		return -1;

	}

	errcode = pt_image_add_cached(image, iscache, isid, NULL);

	if (errcode < 0) {

		fprintf(stderr, "%s: failed to add %s at 0x%" PRIx64 ": %s.\n",

			prog, arg, base, pt_errstr(pt_errcode(errcode)));

		return -1;

	}

	return 0;

}

static xed_machine_mode_enum_t translate_mode(enum pt_exec_mode mode)

{

	switch (mode) {

	case ptem_unknown:

		return XED_MACHINE_MODE_INVALID;

	case ptem_16bit:

		return XED_MACHINE_MODE_LEGACY_16;

	case ptem_32bit:

		return XED_MACHINE_MODE_LEGACY_32;

	case ptem_64bit:

		return XED_MACHINE_MODE_LONG_64;

	}

	return XED_MACHINE_MODE_INVALID;

}

static const char *visualize_iclass(enum pt_insn_class iclass)

{

	switch (iclass) {

	case ptic_error:

		return "unknown/error";

	case ptic_other:

		return "other";

	case ptic_call:

		return "near call";

	case ptic_return:

		return "near return";

	case ptic_jump:

		return "near jump";

	case ptic_cond_jump:

		return "cond jump";

	case ptic_far_call:

		return "far call";

	case ptic_far_return:

		return "far return";

	case ptic_far_jump:

		return "far jump";

	}

	return "undefined";

}

static void check_insn_iclass(const xed_inst_t *inst,

			      const struct pt_insn *insn, uint64_t offset)

{

	xed_category_enum_t category;

	xed_iclass_enum_t iclass;

	if (!inst || !insn) {

		printf("[internal error]\n");

		return;

	}

	category = xed_inst_category(inst);

	iclass = xed_inst_iclass(inst);

	switch (insn->iclass) {

	case ptic_error:

		break;

	case ptic_other:

		switch (category) {

		default:

			return;

		case XED_CATEGORY_CALL:

		case XED_CATEGORY_RET:

		case XED_CATEGORY_COND_BR:

		case XED_CATEGORY_UNCOND_BR:

		case XED_CATEGORY_INTERRUPT:

		case XED_CATEGORY_SYSCALL:

		case XED_CATEGORY_SYSRET:

			break;

		}

		break;

	case ptic_call:

		if (iclass == XED_ICLASS_CALL_NEAR)

			return;

		break;

	case ptic_return:

		if (iclass == XED_ICLASS_RET_NEAR)

			return;

		break;

	case ptic_jump:

		if (iclass == XED_ICLASS_JMP)

			return;

		break;

	case ptic_cond_jump:

		if (category == XED_CATEGORY_COND_BR)

			return;

		break;

	case ptic_far_call:

		switch (iclass) {

		default:

			break;

		case XED_ICLASS_CALL_FAR:

		case XED_ICLASS_INT:

		case XED_ICLASS_INT1:

		case XED_ICLASS_INT3:

		case XED_ICLASS_INTO:

		case XED_ICLASS_SYSCALL:

		case XED_ICLASS_SYSCALL_AMD:

		case XED_ICLASS_SYSENTER:

		case XED_ICLASS_VMCALL:

			return;

		}

		break;

	case ptic_far_return:

		switch (iclass) {

		default:

			break;

		case XED_ICLASS_RET_FAR:

		case XED_ICLASS_IRET:

		case XED_ICLASS_IRETD:

		case XED_ICLASS_IRETQ:

		case XED_ICLASS_SYSRET:

		case XED_ICLASS_SYSRET_AMD:

		case XED_ICLASS_SYSEXIT:

		case XED_ICLASS_VMLAUNCH:

		case XED_ICLASS_VMRESUME:

			return;

		}

		break;

	case ptic_far_jump:

		if (iclass == XED_ICLASS_JMP_FAR)

			return;

		break;

	}

	/* If we get here, @insn->iclass doesn't match XED's classification. */

	printf("[%" PRIx64 ", %" PRIx64 ": iclass error: iclass: %s, "

	       "xed iclass: %s, category: %s]\n", offset, insn->ip,

	       visualize_iclass(insn->iclass), xed_iclass_enum_t2str(iclass),

	       xed_category_enum_t2str(category));

}

static void check_insn_decode(xed_decoded_inst_t *inst,

			      const struct pt_insn *insn, uint64_t offset)

{

	xed_error_enum_t errcode;

	if (!inst || !insn) {

		printf("[internal error]\n");

		return;

	}

	xed_decoded_inst_set_mode(inst, translate_mode(insn->mode),

				  XED_ADDRESS_WIDTH_INVALID);

	/* Decode the instruction (again).

	 *

	 * We may have decoded the instruction already for printing.  In this

	 * case, we will decode it twice.

	 *

	 * The more common use-case, however, is to check the instruction class

	 * while not printing instructions since the latter is too expensive for

	 * regular use with long traces.

	 */

	errcode = xed_decode(inst, insn->raw, insn->size);

	if (errcode != XED_ERROR_NONE) {

		printf("[%" PRIx64 ", %" PRIx64 ": xed error: (%u) %s]\n",

		       offset, insn->ip, errcode,

		       xed_error_enum_t2str(errcode));

		return;

	}

	if (!xed_decoded_inst_valid(inst)) {

		printf("[%" PRIx64 ", %" PRIx64 ": xed error: "

		       "invalid instruction]\n", offset, insn->ip);

		return;

	}

}

static void check_insn(const struct pt_insn *insn, uint64_t offset)

{

	xed_decoded_inst_t inst;

	xed_decoded_inst_zero(&inst);

	check_insn_decode(&inst, insn, offset);

	/* We need a valid instruction in order to do further checks.

	 *

	 * Invalid instructions have already been diagnosed.

	 */

	if (!xed_decoded_inst_valid(&inst))

		return;

	check_insn_iclass(xed_decoded_inst_inst(&inst), insn, offset);

}

static void xed_print_insn(const xed_decoded_inst_t *inst, uint64_t ip,

			   const struct ptxed_options *options)

{

	xed_print_info_t pi;

	char buffer[256];

	xed_bool_t ok;

	if (!inst || !options) {

		printf(" [internal error]");

		return;

	}

	if (options->print_raw_insn) {

		xed_uint_t length, i;

		length = xed_decoded_inst_get_length(inst);

		for (i = 0; i < length; ++i)

			printf(" %02x", xed_decoded_inst_get_byte(inst, i));

		for (; i < pt_max_insn_size; ++i)

			printf("   ");

	}

	xed_init_print_info(&pi);

	pi.p = inst;

	pi.buf = buffer;

	pi.blen = sizeof(buffer);

	pi.runtime_address = ip;

	if (options->att_format)

		pi.syntax = XED_SYNTAX_ATT;

	ok = xed_format_generic(&pi);

	if (!ok) {

		printf(" [xed print error]");

		return;

	}

	printf("  %s", buffer);

}

static void print_insn(const struct pt_insn *insn, xed_state_t *xed,

		       const struct ptxed_options *options, uint64_t offset,

		       uint64_t time)

{

	if (!insn || !options) {

		printf("[internal error]\n");

		return;

	}

	if (insn->resynced)

		printf("[overflow]\n");

	if (insn->enabled)

		printf("[enabled]\n");

	if (insn->resumed)

		printf("[resumed]\n");

	if (insn->speculative)

		printf("? ");

	if (options->print_offset)

		printf("%016" PRIx64 "  ", offset);

	if (options->print_time)

		printf("%016" PRIx64 "  ", time);

	printf("%016" PRIx64, insn->ip);

	if (!options->dont_print_insn) {

		xed_machine_mode_enum_t mode;

		xed_decoded_inst_t inst;

		xed_error_enum_t errcode;

		mode = translate_mode(insn->mode);

		xed_state_set_machine_mode(xed, mode);

		xed_decoded_inst_zero_set_mode(&inst, xed);

		errcode = xed_decode(&inst, insn->raw, insn->size);

		switch (errcode) {

		case XED_ERROR_NONE:

			xed_print_insn(&inst, insn->ip, options);

			break;

		default:

			printf(" [xed decode error: (%u) %s]", errcode,

			       xed_error_enum_t2str(errcode));

			break;

		}

	}

	printf("\n");

	if (insn->interrupted)

		printf("[interrupt]\n");

	if (insn->aborted)

		printf("[aborted]\n");

	if (insn->committed)

		printf("[committed]\n");

	if (insn->disabled)

		printf("[disabled]\n");

	if (insn->stopped)

		printf("[stopped]\n");

}

static void diagnose_insn(const char *errtype, struct pt_insn_decoder *decoder,

			  struct pt_insn *insn, int errcode)

{

	int err;

	uint64_t pos;

	err = pt_insn_get_offset(decoder, &pos;;

	if (err < 0) {

		printf("could not determine offset: %s\n",

		       pt_errstr(pt_errcode(err)));

		printf("[?, %" PRIx64 ": %s: %s]\n", insn->ip, errtype,

		       pt_errstr(pt_errcode(errcode)));

	} else

		printf("[%" PRIx64 ", %" PRIx64 ": %s: %s]\n", pos,

		       insn->ip, errtype, pt_errstr(pt_errcode(errcode)));

}

static void decode_insn(struct pt_insn_decoder *decoder,

			const struct ptxed_options *options,

			struct ptxed_stats *stats)

{

	xed_state_t xed;

	uint64_t offset, sync, time;

	if (!options) {

		printf("[internal error]\n");

		return;

	}

	xed_state_zero(&xed);

	offset = 0ull;

	sync = 0ull;

	time = 0ull;

	for (;;) {

		struct pt_insn insn;

		int errcode;

		/* Initialize the IP - we use it for error reporting. */

		insn.ip = 0ull;

		errcode = pt_insn_sync_forward(decoder);

		if (errcode < 0) {

			uint64_t new_sync;

			if (errcode == -pte_eos)

				break;

			diagnose_insn("sync error", decoder, &insn, errcode);

			/* Let's see if we made any progress.  If we haven't,

			 * we likely never will.  Bail out.

			 *

			 * We intentionally report the error twice to indicate

			 * that we tried to re-sync.  Maybe it even changed.

			 */

			errcode = pt_insn_get_offset(decoder, &new_sync);

			if (errcode < 0 || (new_sync <= sync))

				break;

			sync = new_sync;

			continue;

		}

		for (;;) {

			if (options->print_offset || options->check) {

				errcode = pt_insn_get_offset(decoder, &offset);

				if (errcode < 0)

					break;

			}

			if (options->print_time) {

				errcode = pt_insn_time(decoder, &time, NULL,

						       NULL);

				if (errcode < 0)

					break;