// SPDX-License-Identifier: GPL-2.0-or-later/* * Copyright (c) 2025, Oracle and/or its affiliates. */ #include <objtool/trace.h> bool trace;int trace_depth; /* * Macros to trace CFI state attributes changes. */ #define TRACE_CFI_ATTR(attr, prev, next, fmt, ...)		\({								\	if ((prev)->attr != (next)->attr)			\		TRACE("%s=" fmt " ", #attr, __VA_ARGS__);	\}) #define TRACE_CFI_ATTR_BOOL(attr, prev, next)			\	TRACE_CFI_ATTR(attr, prev, next,			\		       "%s", (next)->attr ? "true" : "false") #define TRACE_CFI_ATTR_NUM(attr, prev, next, fmt)		\	TRACE_CFI_ATTR(attr, prev, next, fmt, (next)->attr) #define CFI_REG_NAME_MAXLEN   16 /* * Return the name of a register. Note that the same static buffer * is returned if the name is dynamically generated. */static const char *cfi_reg_name(unsigned int reg){	static char rname_buffer[CFI_REG_NAME_MAXLEN];	const char *rname; 	switch (reg) {	case CFI_UNDEFINED:		return "<undefined>";	case CFI_CFA:		return "cfa";	case CFI_SP_INDIRECT:		return "(sp)";	case CFI_BP_INDIRECT:		return "(bp)";	} 	if (reg < CFI_NUM_REGS) {		rname = arch_reg_name[reg];		if (rname)			return rname;	} 	if (snprintf(rname_buffer, CFI_REG_NAME_MAXLEN, "r%d", reg) == -1)		return "<error>"; 	return (const char *)rname_buffer;} /* * Functions and macros to trace CFI registers changes. */ static void trace_cfi_reg(const char *prefix, int reg, const char *fmt,			  int base_prev, int offset_prev,			  int base_next, int offset_next){	char *rname; 	if (base_prev == base_next && offset_prev == offset_next)		return; 	if (prefix)		TRACE("%s:", prefix); 	if (base_next == CFI_UNDEFINED) {		TRACE("%1$s=<undef> ", cfi_reg_name(reg));	} else {		rname = strdup(cfi_reg_name(reg));		TRACE(fmt, rname, cfi_reg_name(base_next), offset_next);		free(rname);	}} static void trace_cfi_reg_val(const char *prefix, int reg,			      int base_prev, int offset_prev,			      int base_next, int offset_next){	trace_cfi_reg(prefix, reg, "%1$s=%2$s%3$+d ",		      base_prev, offset_prev, base_next, offset_next);} static void trace_cfi_reg_ref(const char *prefix, int reg,			      int base_prev, int offset_prev,			      int base_next, int offset_next){	trace_cfi_reg(prefix, reg, "%1$s=(%2$s%3$+d) ",		      base_prev, offset_prev, base_next, offset_next);} #define TRACE_CFI_REG_VAL(reg, prev, next)				\	trace_cfi_reg_val(NULL, reg, prev.base, prev.offset,		\			  next.base, next.offset) #define TRACE_CFI_REG_REF(reg, prev, next)				\	trace_cfi_reg_ref(NULL, reg, prev.base, prev.offset,		\			  next.base, next.offset) void trace_insn_state(struct instruction *insn, struct insn_state *sprev,		      struct insn_state *snext){	struct cfi_state *cprev, *cnext;	int i; 	if (!memcmp(sprev, snext, sizeof(struct insn_state)))		return; 	cprev = &sprev->cfi;	cnext = &snext->cfi; 	disas_print_insn(stderr, objtool_disas_ctx, insn,			 trace_depth - 1, "state: "); 	/* print registers changes */	TRACE_CFI_REG_VAL(CFI_CFA, cprev->cfa, cnext->cfa);	for (i = 0; i < CFI_NUM_REGS; i++) {		TRACE_CFI_REG_VAL(i, cprev->vals[i], cnext->vals[i]);		TRACE_CFI_REG_REF(i, cprev->regs[i], cnext->regs[i]);	} 	/* print attributes changes */	TRACE_CFI_ATTR_NUM(stack_size, cprev, cnext, "%d");	TRACE_CFI_ATTR_BOOL(drap, cprev, cnext);	if (cnext->drap) {		trace_cfi_reg_val("drap", cnext->drap_reg,				  cprev->drap_reg, cprev->drap_offset,				  cnext->drap_reg, cnext->drap_offset);	}	TRACE_CFI_ATTR_BOOL(bp_scratch, cprev, cnext);	TRACE_CFI_ATTR_NUM(instr, sprev, snext, "%d");	TRACE_CFI_ATTR_NUM(uaccess_stack, sprev, snext, "%u"); 	TRACE("\n"); 	insn->trace = 1;} void trace_alt_begin(struct instruction *orig_insn, struct alternative *alt,		     char *alt_name){	struct instruction *alt_insn;	char suffix[2]; 	alt_insn = alt->insn; 	if (alt->type == ALT_TYPE_EX_TABLE) {		/*		 * When there is an exception table then the instruction		 * at the original location is executed but it can cause		 * an exception. In that case, the execution will be		 * redirected to the alternative instruction.		 *		 * The instruction at the original location can have		 * instruction alternatives, so we just print the location		 * of the instruction that can cause the exception and		 * not the instruction itself.		 */		TRACE_ALT_INFO_NOADDR(orig_insn, "/ ", "%s for instruction at 0x%lx <%s+0x%lx>",				      alt_name,				      orig_insn->offset, orig_insn->sym->name,				      orig_insn->offset - orig_insn->sym->offset);	} else {		TRACE_ALT_INFO_NOADDR(orig_insn, "/ ", "%s", alt_name);	} 	if (alt->type == ALT_TYPE_JUMP_TABLE) {		/*		 * For a jump alternative, if the default instruction is		 * a NOP then it is replaced with the jmp instruction,		 * otherwise it is replaced with a NOP instruction.		 */		trace_depth++;		if (orig_insn->type == INSN_NOP) {			suffix[0] = (orig_insn->len == 5) ? 'q' : '\0';			TRACE_ADDR(orig_insn, "jmp%-3s %lx <%s+0x%lx>", suffix,				   alt_insn->offset, alt_insn->sym->name,				   alt_insn->offset - alt_insn->sym->offset);		} else {			TRACE_ADDR(orig_insn, "nop%d", orig_insn->len);			trace_depth--;		}	}} void trace_alt_end(struct instruction *orig_insn, struct alternative *alt,		   char *alt_name){	if (alt->type == ALT_TYPE_JUMP_TABLE && orig_insn->type == INSN_NOP)		trace_depth--;	TRACE_ALT_INFO_NOADDR(orig_insn, "\\ ", "%s", alt_name);}