diff --git a/btf_encoder.c b/btf_encoder.c
index fd04008..2697214 100644
--- a/btf_encoder.c
+++ b/btf_encoder.c
@@ -34,6 +34,9 @@
 #include <pthread.h>
 
 #define BTF_ENCODER_MAX_PROTO	512
+#define BTF_IDS_SECTION		".BTF_ids"
+#define BTF_ID_FUNC_PFX		"__BTF_ID__func__"
+#define BTF_KFUNC_TYPE_TAG	"kfunc"
 
 /* state used to do later encoding of saved functions */
 struct btf_encoder_state {
@@ -1352,6 +1355,200 @@ out:
 	return err;
 }
 
+/*
+ * Parse BTF_ID symbol and return the kfunc name.
+ *
+ * Returns:
+ *	Callee-owned string containing kfunc name if successful.
+ *	NULL if !kfunc or on error.
+ */
+static char *get_kfunc_name(const char *sym)
+{
+	char *kfunc, *end;
+
+	if (strncmp(sym, BTF_ID_FUNC_PFX, sizeof(BTF_ID_FUNC_PFX) - 1))
+		return NULL;
+
+	/* Strip prefix */
+	kfunc = strdup(sym + sizeof(BTF_ID_FUNC_PFX) - 1);
+
+	/* Strip suffix */
+	end = strrchr(kfunc, '_');
+	if (!end || *(end - 1) != '_') {
+		free(kfunc);
+		return NULL;
+	}
+	*(end - 1) = '\0';
+
+	return kfunc;
+}
+
+static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, const char *kfunc)
+{
+	int nr_types, type_id, err = -1;
+	struct btf *btf = encoder->btf;
+
+	nr_types = btf__type_cnt(btf);
+	for (type_id = 1; type_id < nr_types; type_id++) {
+		const struct btf_type *type;
+		const char *name;
+
+		type = btf__type_by_id(btf, type_id);
+		if (!type) {
+			fprintf(stderr, "%s: malformed BTF, can't resolve type for ID %d\n",
+				__func__, type_id);
+			goto out;
+		}
+
+		if (!btf_is_func(type))
+			continue;
+
+		name = btf__name_by_offset(btf, type->name_off);
+		if (!name) {
+			fprintf(stderr, "%s: malformed BTF, can't resolve name for ID %d\n",
+				__func__, type_id);
+			goto out;
+		}
+
+		if (strcmp(name, kfunc))
+		    continue;
+
+		err = btf__add_decl_tag(btf, BTF_KFUNC_TYPE_TAG, type_id, -1);
+		if (err < 0) {
+			fprintf(stderr, "%s: failed to insert kfunc decl tag for '%s': %d\n",
+				__func__, kfunc, err);
+			goto out;
+		}
+
+		err = 0;
+		break;
+	}
+
+out:
+	return err;
+}
+
+static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder)
+{
+	const char *filename = encoder->filename;
+	GElf_Shdr shdr_mem, *shdr;
+	int symbols_shndx = -1;
+	int idlist_shndx = -1;
+	Elf_Scn *scn = NULL;
+	Elf_Data *symbols;
+	int fd, err = -1;
+	size_t strtabidx;
+	Elf *elf = NULL;
+	size_t strndx;
+	char *secname;
+	int nr_syms;
+	int i = 0;
+
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		fprintf(stderr, "Cannot open %s\n", filename);
+		goto out;
+	}
+
+	if (elf_version(EV_CURRENT) == EV_NONE) {
+		elf_error("Cannot set libelf version");
+		goto out;
+	}
+
+	elf = elf_begin(fd, ELF_C_READ, NULL);
+	if (elf == NULL) {
+		elf_error("Cannot update ELF file");
+		goto out;
+	}
+
+	/* Location symbol table and .BTF_ids sections */
+	elf_getshdrstrndx(elf, &strndx);
+	while ((scn = elf_nextscn(elf, scn)) != NULL) {
+		Elf_Data *data;
+
+		i++;
+		shdr = gelf_getshdr(scn, &shdr_mem);
+		if (shdr == NULL) {
+			elf_error("Failed to get ELF section(%d) hdr", i);
+			goto out;
+		}
+
+		secname = elf_strptr(elf, strndx, shdr->sh_name);
+		if (!secname) {
+			elf_error("Failed to get ELF section(%d) hdr name", i);
+			goto out;
+		}
+
+		data = elf_getdata(scn, 0);
+		if (!data) {
+			elf_error("Failed to get ELF section(%d) data", i);
+			goto out;
+		}
+
+		if (shdr->sh_type == SHT_SYMTAB) {
+			symbols_shndx = i;
+			symbols = data;
+			strtabidx = shdr->sh_link;
+		} else if (!strcmp(secname, BTF_IDS_SECTION)) {
+			idlist_shndx = i;
+		}
+	}
+
+	/* Cannot resolve symbol or .BTF_ids sections. Nothing to do. */
+	if (symbols_shndx == -1 || idlist_shndx == -1) {
+		err = 0;
+		goto out;
+	}
+
+	/*
+	 * Look for __BTF_ID__func__ symbols in .BTF_ids section and
+	 * inject BTF decl tags for each of them.
+	 */
+	scn = elf_getscn(elf, symbols_shndx);
+	if (!scn) {
+		elf_error("Failed to get ELF symbol table");
+		goto out;
+	}
+
+	shdr = gelf_getshdr(scn, &shdr_mem);
+	if (!shdr) {
+		elf_error("Failed to get ELF symbol table header");
+		goto out;
+	}
+
+	nr_syms = shdr->sh_size / shdr->sh_entsize;
+	for (i = 0; i < nr_syms; i++) {
+		char *kfunc, *name;
+		GElf_Sym sym;
+		int err;
+
+		if (!gelf_getsym(symbols, i, &sym)) {
+			elf_error("Failed to get ELF symbol(%d)", i);
+			goto out;
+		}
+
+		if (sym.st_shndx != idlist_shndx)
+			continue;
+
+		name = elf_strptr(elf, strtabidx, sym.st_name);
+		kfunc = get_kfunc_name(name);
+		if (!kfunc)
+			continue;
+
+		err = btf_encoder__tag_kfunc(encoder, kfunc);
+		if (err) {
+			fprintf(stderr, "%s: failed to tag kfunc '%s'\n", __func__, kfunc);
+			free(kfunc);
+			goto out;
+		}
+		free(kfunc);
+	}
+
+	err = 0;
+out:
+	return err;
+}
+
 int btf_encoder__encode(struct btf_encoder *encoder)
 {
 	int err;
@@ -1366,6 +1563,11 @@ int btf_encoder__encode(struct btf_encoder *encoder)
 	if (btf__type_cnt(encoder->btf) == 1)
 		return 0;
 
+	if (btf_encoder__tag_kfuncs(encoder)) {
+		fprintf(stderr, "%s: failed to tag kfuncs!\n", __func__);
+		return -1;
+	}
+
 	if (btf__dedup(encoder->btf, NULL)) {
 		fprintf(stderr, "%s: btf__dedup failed!\n", __func__);
 		return -1;
