// SPDX-License-Identifier: GPL-2.0#include "llvm.h"#include "annotate.h"#include "debug.h"#include "dso.h"#include "map.h"#include "namespaces.h"#include "srcline.h"#include "symbol.h"#include <errno.h>#include <fcntl.h>#include <unistd.h>#include <linux/zalloc.h> #ifdef HAVE_LIBLLVM_SUPPORT#include "llvm-c-helpers.h"#include <llvm-c/Disassembler.h>#include <llvm-c/Target.h>#endif #ifdef HAVE_LIBLLVM_SUPPORTstatic void free_llvm_inline_frames(struct llvm_a2l_frame *inline_frames,				    int num_frames){	if (inline_frames != NULL) {		for (int i = 0; i < num_frames; ++i) {			zfree(&inline_frames[i].filename);			zfree(&inline_frames[i].funcname);		}		zfree(&inline_frames);	}}#endif int llvm__addr2line(const char *dso_name __maybe_unused, u64 addr __maybe_unused,		     char **file __maybe_unused, unsigned int *line __maybe_unused,		     struct dso *dso __maybe_unused, bool unwind_inlines __maybe_unused,		     struct inline_node *node __maybe_unused, struct symbol *sym __maybe_unused){#ifdef HAVE_LIBLLVM_SUPPORT	struct llvm_a2l_frame *inline_frames = NULL;	int num_frames = llvm_addr2line(dso_name, addr, file, line,					node && unwind_inlines, &inline_frames); 	if (num_frames == 0 || !inline_frames) {		/* Error, or we didn't want inlines. */		return num_frames;	} 	for (int i = 0; i < num_frames; ++i) {		struct symbol *inline_sym =			new_inline_sym(dso, sym, inline_frames[i].funcname);		char *srcline = NULL; 		if (inline_frames[i].filename) {			srcline =				srcline_from_fileline(inline_frames[i].filename,						      inline_frames[i].line);		}		if (inline_list__append(inline_sym, srcline, node) != 0) {			free_llvm_inline_frames(inline_frames, num_frames);			return 0;		}	}	free_llvm_inline_frames(inline_frames, num_frames); 	return num_frames;#else	return -1;#endif} #ifdef HAVE_LIBLLVM_SUPPORTstatic void init_llvm(void){	static bool init; 	if (!init) {		LLVMInitializeAllTargetInfos();		LLVMInitializeAllTargetMCs();		LLVMInitializeAllDisassemblers();		init = true;	}} /* * Whenever LLVM wants to resolve an address into a symbol, it calls this * callback. We don't ever actually _return_ anything (in particular, because * it puts quotation marks around what we return), but we use this as a hint * that there is a branch or PC-relative address in the expression that we * should add some textual annotation for after the instruction. The caller * will use this information to add the actual annotation. */struct symbol_lookup_storage {	u64 branch_addr;	u64 pcrel_load_addr;}; static const char *symbol_lookup_callback(void *disinfo, uint64_t value,		       uint64_t *ref_type,		       uint64_t address __maybe_unused,		       const char **ref __maybe_unused){	struct symbol_lookup_storage *storage = disinfo; 	if (*ref_type == LLVMDisassembler_ReferenceType_In_Branch)		storage->branch_addr = value;	else if (*ref_type == LLVMDisassembler_ReferenceType_In_PCrel_Load)		storage->pcrel_load_addr = value;	*ref_type = LLVMDisassembler_ReferenceType_InOut_None;	return NULL;}#endif int symbol__disassemble_llvm(const char *filename, struct symbol *sym,			     struct annotate_args *args __maybe_unused){#ifdef HAVE_LIBLLVM_SUPPORT	struct annotation *notes = symbol__annotation(sym);	struct map *map = args->ms->map;	struct dso *dso = map__dso(map);	u64 start = map__rip_2objdump(map, sym->start);	/* Malloc-ed buffer containing instructions read from disk. */	u8 *code_buf = NULL;	/* Pointer to code to be disassembled. */	const u8 *buf;	u64 buf_len;	u64 pc;	bool is_64bit;	char disasm_buf[2048];	size_t disasm_len;	struct disasm_line *dl;	LLVMDisasmContextRef disasm = NULL;	struct symbol_lookup_storage storage;	char *line_storage = NULL;	size_t line_storage_len = 0;	int ret = -1; 	if (args->options->objdump_path)		return -1; 	buf = dso__read_symbol(dso, filename, map, sym,			       &code_buf, &buf_len, &is_64bit);	if (buf == NULL)		return errno; 	init_llvm();	if (arch__is_x86(args->arch)) {		const char *triplet = is_64bit ? "x86_64-pc-linux" : "i686-pc-linux"; 		disasm = LLVMCreateDisasm(triplet, &storage, /*tag_type=*/0,					  /*get_op_info=*/NULL, symbol_lookup_callback);	} else {		char triplet[64];		const char *features = NULL; 		scnprintf(triplet, sizeof(triplet), "%s-linux-gnu",			  args->arch->name);		if (args->arch->id.e_machine == EM_AARCH64)			features = "+all";		disasm = LLVMCreateDisasmCPUFeatures(triplet, /*cpu=*/"",						     features, &storage,						     /*tag_type=*/0,						     /*get_op_info=*/NULL,						     symbol_lookup_callback);	} 	if (disasm == NULL)		goto err; 	if (args->options->disassembler_style &&	    !strcmp(args->options->disassembler_style, "intel"))		LLVMSetDisasmOptions(disasm,				     LLVMDisassembler_Option_AsmPrinterVariant); 	/*	 * This needs to be set after AsmPrinterVariant, due to a bug in LLVM;	 * setting AsmPrinterVariant makes a new instruction printer, making it	 * forget about the PrintImmHex flag (which is applied before if both	 * are given to the same call).	 */	LLVMSetDisasmOptions(disasm, LLVMDisassembler_Option_PrintImmHex); 	/* add the function address and name */	scnprintf(disasm_buf, sizeof(disasm_buf), "%#"PRIx64" <%s>:",		  start, sym->name); 	args->offset = -1;	args->line = disasm_buf;	args->line_nr = 0;	args->fileloc = NULL;	args->ms->sym = sym; 	dl = disasm_line__new(args);	if (dl == NULL)		goto err; 	annotation_line__add(&dl->al, &notes->src->source); 	pc = start;	for (u64 offset = 0; offset < buf_len; ) {		unsigned int ins_len; 		storage.branch_addr = 0;		storage.pcrel_load_addr = 0; 		/*		 * LLVM's API has the code be disassembled as non-const, cast		 * here as we may be disassembling from mapped read-only memory.		 */		ins_len = LLVMDisasmInstruction(disasm, (u8 *)(buf + offset),						buf_len - offset, pc,						disasm_buf, sizeof(disasm_buf));		if (ins_len == 0)			goto err;		disasm_len = strlen(disasm_buf); 		if (storage.branch_addr != 0) {			char *name = llvm_name_for_code(dso, filename,							storage.branch_addr);			if (name != NULL) {				disasm_len += scnprintf(disasm_buf + disasm_len,							sizeof(disasm_buf) -								disasm_len,							" <%s>", name);				free(name);			}		}		if (storage.pcrel_load_addr != 0) {			char *name = llvm_name_for_data(dso, filename,							storage.pcrel_load_addr);			disasm_len += scnprintf(disasm_buf + disasm_len,						sizeof(disasm_buf) - disasm_len,						"  # %#"PRIx64,						storage.pcrel_load_addr);			if (name) {				disasm_len += scnprintf(disasm_buf + disasm_len,							sizeof(disasm_buf) -							disasm_len,							" <%s>", name);				free(name);			}		} 		args->offset = offset;		args->line = expand_tabs(disasm_buf, &line_storage,					 &line_storage_len);		args->line_nr = 0;		args->fileloc = NULL;		args->ms->sym = sym; 		llvm_addr2line(filename, pc, &args->fileloc,			       (unsigned int *)&args->line_nr, false, NULL); 		dl = disasm_line__new(args);		if (dl == NULL)			goto err; 		annotation_line__add(&dl->al, &notes->src->source); 		free(args->fileloc);		pc += ins_len;		offset += ins_len;	} 	ret = 0; err:	LLVMDisasmDispose(disasm);	free(code_buf);	free(line_storage);	return ret;#else // HAVE_LIBLLVM_SUPPORT	pr_debug("The LLVM disassembler isn't linked in for %s in %s\n",		 sym->name, filename);	return -1;#endif}