Adding upstream version 9.1.upstream/9.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 950 insertions, 0 deletions

diff --git a/tools/frr-llvm-cg.c b/tools/frr-llvm-cg.c
new file mode 100644
index 0000000..3a7222e
--- /dev/null
+++ b/tools/frr-llvm-cg.c
@@ -0,0 +1,950 @@
+// SPDX-License-Identifier: Unlicense
+/* based on example code: https://github.com/sheredom/llvm_bc_parsing_example
+ * which came under the above (un-)license.  does not depend on any FRR
+ * pieces, so no reason to change the license.
+ *
+ * please note that while included in the FRR sources, this tool is in no way
+ * supported or maintained by the FRR community.  it is provided as a
+ * "convenience";  while it worked at some point (using LLVM 8 / 9), it may
+ * easily break with a future LLVM version or any other factors.
+ *
+ * 2020-05-04, David Lamparter
+ */
+
+#include <string.h>
+#include <strings.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+
+#include <llvm-c/BitReader.h>
+#include <llvm-c/BitWriter.h>
+#include <llvm-c/Core.h>
+
+#include <json-c/json.h>
+
+#include "frr-llvm-debuginfo.h"
+
+/* if you want to use this without the special FRRouting defines,
+ * remove the following #define
+ */
+#define FRR_SPECIFIC
+
+static struct dbginfo *dbginfo;
+
+static void dbgloc_add(struct json_object *jsobj, LLVMValueRef obj)
+{
+	unsigned file_len = 0;
+	const char *file = LLVMGetDebugLocFilename(obj, &file_len);
+	unsigned line = LLVMGetDebugLocLine(obj);
+
+	if (!file)
+		file = "???", file_len = 3;
+	else if (file[0] == '.' && file[1] == '/')
+		file += 2, file_len -= 2;
+
+	json_object_object_add(jsobj, "filename",
+			       json_object_new_string_len(file, file_len));
+	json_object_object_add(jsobj, "line", json_object_new_int64(line));
+}
+
+static struct json_object *js_get_or_make(struct json_object *parent,
+					  const char *key,
+					  struct json_object *(*maker)(void))
+{
+	struct json_object *ret;
+
+	ret = json_object_object_get(parent, key);
+	if (ret)
+		return ret;
+	ret = maker();
+	json_object_object_add(parent, key, ret);
+	return ret;
+}
+
+static bool try_struct_fptr(struct json_object *js_call, LLVMValueRef gep,
+			    const char *prefix)
+{
+	unsigned long long val = 0;
+	bool ret = false;
+	LLVMTypeRef ptrtype = LLVMTypeOf(LLVMGetOperand(gep, 0));
+	LLVMValueRef idx;
+
+	/* middle steps like struct a -> struct b a_member; -> fptr */
+	for (int i = 1; ptrtype && i < LLVMGetNumOperands(gep) - 1; i++) {
+		if (LLVMGetTypeKind(ptrtype) == LLVMPointerTypeKind
+		    || LLVMGetTypeKind(ptrtype) == LLVMArrayTypeKind
+		    || LLVMGetTypeKind(ptrtype) == LLVMVectorTypeKind) {
+			ptrtype = LLVMGetElementType(ptrtype);
+			continue;
+		}
+
+		if (LLVMGetTypeKind(ptrtype) != LLVMStructTypeKind)
+			return false;
+
+		idx = LLVMGetOperand(gep, i);
+		if (!LLVMIsConstant(idx))
+			return false;
+		val = LLVMConstIntGetZExtValue(idx);
+
+		unsigned n = LLVMGetNumContainedTypes(ptrtype);
+		LLVMTypeRef arr[n];
+
+		if (val > n)
+			return false;
+
+		LLVMGetSubtypes(ptrtype, arr);
+		ptrtype = arr[val];
+	}
+
+	if (!ptrtype)
+		return false;
+
+	idx = LLVMGetOperand(gep, LLVMGetNumOperands(gep) - 1);
+	if (!LLVMIsConstant(idx))
+		return false;
+
+	val = LLVMConstIntGetZExtValue(idx);
+
+	char *sname = NULL, *mname = NULL;
+
+	if (dbginfo_struct_member(dbginfo, ptrtype, val, &sname, &mname)) {
+		fprintf(stderr, "%s: call to struct %s->%s\n", prefix, sname,
+			mname);
+
+		json_object_object_add(js_call, "type",
+				       json_object_new_string("struct_memb"));
+		json_object_object_add(js_call, "struct",
+				       json_object_new_string(sname));
+		json_object_object_add(js_call, "member",
+				       json_object_new_string(mname));
+		ret = true;
+	}
+	free(sname);
+	free(mname);
+
+	return ret;
+}
+
+static bool details_fptr_vars = false;
+static bool details_fptr_consts = true;
+
+enum called_fn {
+	FN_GENERIC = 0,
+	FN_NONAME,
+	FN_INSTALL_ELEMENT,
+	FN_THREAD_ADD,
+};
+
+static void walk_const_fptrs(struct json_object *js_call, LLVMValueRef value,
+			     const char *prefix, bool *hdr_written)
+{
+	LLVMTypeRef type;
+	LLVMValueKind kind;
+
+	if (LLVMIsAGlobalVariable(value)) {
+		type = LLVMGlobalGetValueType(value);
+		value = LLVMGetInitializer(value);
+	} else {
+		type = LLVMTypeOf(value);
+	}
+
+	if (LLVMIsAFunction(value)) {
+		struct json_object *js_fptrs;
+
+		js_fptrs = js_get_or_make(js_call, "funcptrs",
+					  json_object_new_array);
+
+		size_t fn_len;
+		const char *fn_name = LLVMGetValueName2(value, &fn_len);
+
+		size_t curlen = json_object_array_length(js_fptrs);
+		struct json_object *jsobj;
+		const char *s;
+
+		for (size_t i = 0; i < curlen; i++) {
+			jsobj = json_object_array_get_idx(js_fptrs, i);
+			s = json_object_get_string(jsobj);
+
+			if (s && !strcmp(s, fn_name))
+				return;
+		}
+
+		if (details_fptr_consts && !*hdr_written) {
+			fprintf(stderr,
+				"%s: calls function pointer from constant or global data\n",
+				prefix);
+			*hdr_written = true;
+		}
+		if (details_fptr_consts)
+			fprintf(stderr, "%s-   constant: %.*s()\n",
+				prefix, (int)fn_len, fn_name);
+
+		json_object_array_add(js_fptrs,
+				       json_object_new_string_len(fn_name,
+								  fn_len));
+		return;
+	}
+
+	kind = LLVMGetValueKind(value);
+
+	unsigned len;
+	char *dump;
+
+	switch (kind) {
+	case LLVMUndefValueValueKind:
+	case LLVMConstantAggregateZeroValueKind:
+	case LLVMConstantPointerNullValueKind:
+		/* null pointer / array - ignore */
+		break;
+
+	case LLVMConstantIntValueKind:
+		/* integer - ignore */
+		break;
+
+	case LLVMConstantStructValueKind:
+		len = LLVMCountStructElementTypes(type);
+		for (unsigned i = 0; i < len; i++)
+			walk_const_fptrs(js_call, LLVMGetOperand(value, i),
+					 prefix, hdr_written);
+		break;
+
+	case LLVMConstantArrayValueKind:
+		len = LLVMGetArrayLength(type);
+		for (unsigned i = 0; i < len; i++)
+			walk_const_fptrs(js_call, LLVMGetOperand(value, i),
+					 prefix, hdr_written);
+		return;
+
+	case LLVMConstantExprValueKind:
+		switch (LLVMGetConstOpcode(value)) {
+		case LLVMGetElementPtr:
+			if (try_struct_fptr(js_call, value, prefix)) {
+				*hdr_written = true;
+				return;
+			}
+
+			fprintf(stderr,
+				"%s: calls function pointer from unhandled const GEP\n",
+				prefix);
+			*hdr_written = true;
+			/* fallthru */
+		default:
+			/* to help the user / development */
+			if (!*hdr_written) {
+				fprintf(stderr,
+					"%s: calls function pointer from constexpr\n",
+					prefix);
+				*hdr_written = true;
+			}
+			dump = LLVMPrintValueToString(value);
+			fprintf(stderr, "%s-   [opcode=%d] %s\n", prefix,
+				LLVMGetConstOpcode(value), dump);
+			LLVMDisposeMessage(dump);
+		}
+		return;
+
+	default:
+		/* to help the user / development */
+		if (!*hdr_written) {
+			fprintf(stderr,
+				"%s: calls function pointer from constant or global data\n",
+				prefix);
+			*hdr_written = true;
+		}
+		dump = LLVMPrintValueToString(value);
+		fprintf(stderr,
+			"%s-   value could not be processed:\n"
+			"%s-   [kind=%d] %s\n",
+			prefix, prefix, kind, dump);
+		LLVMDisposeMessage(dump);
+		return;
+	}
+	return;
+}
+
+#ifdef FRR_SPECIFIC
+static bool is_thread_sched(const char *name, size_t len)
+{
+#define thread_prefix "_"
+	static const char *const names[] = {
+		thread_prefix "event_add_read_write",
+		thread_prefix "event_add_timer",
+		thread_prefix "event_add_timer_msec",
+		thread_prefix "event_add_timer_tv",
+		thread_prefix "event_add_event",
+		thread_prefix "event_execute",
+	};
+	size_t i;
+
+	for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
+		if (strlen(names[i]) != len)
+			continue;
+		if (!memcmp(names[i], name, len))
+			return true;
+	}
+	return false;
+}
+#endif
+
+static bool _check_val(bool cond, const char *text, LLVMValueRef dumpval)
+{
+	if (cond)
+		return true;
+
+	char *dump = LLVMPrintValueToString(dumpval);
+	fprintf(stderr, "check failed: %s\ndump:\n\t%s\n", text, dump);
+	LLVMDisposeMessage(dump);
+	return false;
+}
+
+#define check_val(cond, dump)                                                  \
+	if (!_check_val(cond, #cond, dump))                                    \
+		return;
+
+static char *get_string(LLVMValueRef value)
+{
+	if (!LLVMIsAConstant(value))
+		return strdup("!NOT-A-CONST");
+
+	if (LLVMGetValueKind(value) == LLVMConstantExprValueKind
+	    && LLVMGetConstOpcode(value) == LLVMGetElementPtr) {
+		value = LLVMGetOperand(value, 0);
+
+		if (!LLVMIsAConstant(value))
+			return strdup("!NOT-A-CONST-2");
+	}
+
+	if (LLVMIsAGlobalVariable(value))
+		value = LLVMGetInitializer(value);
+
+	size_t len = 0;
+	const char *sval = LLVMGetAsString(value, &len);
+
+	return strndup(sval, len);
+}
+
+static void handle_yang_module(struct json_object *js_special,
+			       LLVMValueRef yang_mod)
+{
+	check_val(LLVMIsAGlobalVariable(yang_mod), yang_mod);
+
+	LLVMValueRef value;
+
+	value = LLVMGetInitializer(yang_mod);
+	LLVMValueKind kind = LLVMGetValueKind(value);
+
+	check_val(kind == LLVMConstantStructValueKind, value);
+
+	size_t var_len = 0;
+	const char *var_name = LLVMGetValueName2(yang_mod, &var_len);
+	char buf_name[var_len + 1];
+
+	memcpy(buf_name, var_name, var_len);
+	buf_name[var_len] = '\0';
+
+	struct json_object *js_yang, *js_yangmod, *js_items;
+
+	js_yang = js_get_or_make(js_special, "yang", json_object_new_object);
+	js_yangmod = js_get_or_make(js_yang, buf_name, json_object_new_object);
+	js_items = js_get_or_make(js_yangmod, "items", json_object_new_array);
+
+	char *mod_name = get_string(LLVMGetOperand(value, 0));
+	json_object_object_add(js_yangmod, "name",
+			       json_object_new_string(mod_name));
+	free(mod_name);
+
+	value = LLVMGetOperand(value, 1);
+	kind = LLVMGetValueKind(value);
+	check_val(kind == LLVMConstantArrayValueKind, value);
+
+	unsigned len = LLVMGetArrayLength(LLVMTypeOf(value));
+
+	for (unsigned i = 0; i < len - 1; i++) {
+		struct json_object *js_item, *js_cbs;
+		LLVMValueRef item = LLVMGetOperand(value, i);
+		char *xpath = get_string(LLVMGetOperand(item, 0));
+
+		js_item = json_object_new_object();
+		json_object_array_add(js_items, js_item);
+
+		json_object_object_add(js_item, "xpath",
+				       json_object_new_string(xpath));
+		js_cbs = js_get_or_make(js_item, "cbs", json_object_new_object);
+
+		free(xpath);
+
+		LLVMValueRef cbs = LLVMGetOperand(item, 1);
+
+		check_val(LLVMGetValueKind(cbs) == LLVMConstantStructValueKind,
+			  value);
+
+		LLVMTypeRef cbs_type = LLVMTypeOf(cbs);
+		unsigned cblen = LLVMCountStructElementTypes(cbs_type);
+
+		for (unsigned i = 0; i < cblen; i++) {
+			LLVMValueRef cb = LLVMGetOperand(cbs, i);
+
+			char *sname = NULL;
+			char *mname = NULL;
+
+			if (dbginfo_struct_member(dbginfo, cbs_type, i, &sname,
+						  &mname)) {
+				(void)0;
+			}
+
+			if (LLVMIsAFunction(cb)) {
+				size_t fn_len;
+				const char *fn_name;
+
+				fn_name = LLVMGetValueName2(cb, &fn_len);
+
+				json_object_object_add(
+					js_cbs, mname,
+					json_object_new_string_len(fn_name,
+								   fn_len));
+			}
+
+			free(sname);
+			free(mname);
+		}
+	}
+}
+
+static void handle_daemoninfo(struct json_object *js_special,
+			      LLVMValueRef daemoninfo)
+{
+	check_val(LLVMIsAGlobalVariable(daemoninfo), daemoninfo);
+
+	LLVMTypeRef type;
+	LLVMValueRef value;
+	unsigned len;
+
+	type = LLVMGlobalGetValueType(daemoninfo);
+	value = LLVMGetInitializer(daemoninfo);
+	LLVMValueKind kind = LLVMGetValueKind(value);
+
+	check_val(kind == LLVMConstantStructValueKind, value);
+
+	int yang_idx = -1;
+
+	len = LLVMCountStructElementTypes(type);
+
+	LLVMTypeRef fieldtypes[len];
+	LLVMGetSubtypes(type, fieldtypes);
+
+	for (unsigned i = 0; i < len; i++) {
+		LLVMTypeRef t = fieldtypes[i];
+
+		if (LLVMGetTypeKind(t) != LLVMPointerTypeKind)
+			continue;
+		t = LLVMGetElementType(t);
+		if (LLVMGetTypeKind(t) != LLVMPointerTypeKind)
+			continue;
+		t = LLVMGetElementType(t);
+		if (LLVMGetTypeKind(t) != LLVMStructTypeKind)
+			continue;
+
+		const char *name = LLVMGetStructName(t);
+		if (!strcmp(name, "struct.frr_yang_module_info"))
+			yang_idx = i;
+	}
+
+	if (yang_idx == -1)
+		return;
+
+	LLVMValueRef yang_mods = LLVMGetOperand(value, yang_idx);
+	LLVMValueRef yang_size = LLVMGetOperand(value, yang_idx + 1);
+
+	check_val(LLVMIsConstant(yang_size), yang_size);
+
+	unsigned long long ival = LLVMConstIntGetZExtValue(yang_size);
+
+	check_val(LLVMGetValueKind(yang_mods) == LLVMConstantExprValueKind
+			  && LLVMGetConstOpcode(yang_mods) == LLVMGetElementPtr,
+		  yang_mods);
+
+	yang_mods = LLVMGetOperand(yang_mods, 0);
+
+	check_val(LLVMIsAGlobalVariable(yang_mods), yang_mods);
+
+	yang_mods = LLVMGetInitializer(yang_mods);
+
+	check_val(LLVMGetValueKind(yang_mods) == LLVMConstantArrayValueKind,
+		  yang_mods);
+
+	len = LLVMGetArrayLength(LLVMTypeOf(yang_mods));
+
+	if (len != ival)
+		fprintf(stderr, "length mismatch - %llu vs. %u\n", ival, len);
+
+	for (unsigned i = 0; i < len; i++) {
+		char *dump;
+
+		LLVMValueRef item = LLVMGetOperand(yang_mods, i);
+		LLVMValueKind kind = LLVMGetValueKind(item);
+
+		check_val(kind == LLVMGlobalVariableValueKind
+				  || kind == LLVMConstantExprValueKind,
+			  item);
+
+		if (kind == LLVMGlobalVariableValueKind)
+			continue;
+
+		LLVMOpcode opcode = LLVMGetConstOpcode(item);
+		switch (opcode) {
+		case LLVMBitCast:
+			item = LLVMGetOperand(item, 0);
+			handle_yang_module(js_special, item);
+			break;
+
+		default:
+			dump = LLVMPrintValueToString(item);
+			printf("[%u] = [opcode=%u] %s\n", i, opcode, dump);
+			LLVMDisposeMessage(dump);
+		}
+	}
+}
+
+static void process_call(struct json_object *js_calls,
+			 struct json_object *js_special,
+			 LLVMValueRef instr,
+			 LLVMValueRef function)
+{
+	struct json_object *js_call, *js_fptrs = NULL;
+
+	LLVMValueRef called = LLVMGetCalledValue(instr);
+
+	if (LLVMIsAInlineAsm(called))
+		return;
+
+	if (LLVMIsAConstantExpr(called)) {
+		LLVMOpcode opcode = LLVMGetConstOpcode(called);
+
+		if (opcode == LLVMBitCast) {
+			LLVMValueRef op0 = LLVMGetOperand(called, 0);
+
+			if (LLVMIsAFunction(op0))
+				called = op0;
+		}
+	}
+
+	size_t called_len = 0;
+	const char *called_name = LLVMGetValueName2(called, &called_len);
+	unsigned n_args = LLVMGetNumArgOperands(instr);
+
+	bool is_external = LLVMIsDeclaration(called);
+
+	js_call = json_object_new_object();
+	json_object_array_add(js_calls, js_call);
+	dbgloc_add(js_call, instr);
+	json_object_object_add(js_call, "is_external",
+			       json_object_new_boolean(is_external));
+
+	if (!called_name || called_len == 0) {
+		json_object_object_add(js_call, "type",
+				       json_object_new_string("indirect"));
+
+		LLVMValueRef last = called;
+
+		size_t name_len = 0;
+		const char *name_c = LLVMGetValueName2(function, &name_len);
+
+#ifdef FRR_SPECIFIC
+		/* information for FRR hooks is dumped for the registration
+		 * in _hook_typecheck; we can safely ignore the funcptr here
+		 */
+		if (strncmp(name_c, "hook_call_", 10) == 0)
+			return;
+#endif
+
+		unsigned file_len = 0;
+		const char *file = LLVMGetDebugLocFilename(instr, &file_len);
+		unsigned line = LLVMGetDebugLocLine(instr);
+
+		char prefix[256];
+		snprintf(prefix, sizeof(prefix), "%.*s:%d:%.*s()",
+			 (int)file_len, file, line, (int)name_len, name_c);
+
+		if (LLVMIsALoadInst(called)
+		    && LLVMIsAGetElementPtrInst(LLVMGetOperand(called, 0))
+		    && try_struct_fptr(js_call, LLVMGetOperand(called, 0),
+				       prefix))
+			goto out_struct_fptr;
+
+		while (LLVMIsALoadInst(last) || LLVMIsAGetElementPtrInst(last))
+			/* skipping over details for GEP here, but meh. */
+			last = LLVMGetOperand(last, 0);
+
+		if (LLVMIsAAllocaInst(last)) {
+			/* "alloca" is just generically all variables on the
+			 * stack, this does not refer to C alloca() calls
+			 *
+			 * looking at the control flow in the function can
+			 * give better results here, it's just not implemented
+			 * (yet?)
+			 */
+			fprintf(stderr,
+				"%s: call to a function pointer variable\n",
+				prefix);
+
+			if (details_fptr_vars) {
+				char *dump = LLVMPrintValueToString(called);
+				printf("%s-   %s\n", prefix, dump);
+				LLVMDisposeMessage(dump);
+			}
+
+			json_object_object_add(
+				js_call, "type",
+				json_object_new_string("stack_fptr"));
+		} else if (LLVMIsACallInst(last)) {
+			/* calling the a function pointer returned from
+			 * another function.
+			 */
+			struct json_object *js_indirect;
+
+			js_indirect = js_get_or_make(js_call, "return_of",
+						     json_object_new_array);
+
+			process_call(js_indirect, js_special, last, function);
+		} else if (LLVMIsAConstant(last)) {
+			/* function pointer is a constant (includes loading
+			 * from complicated constants like structs or arrays.)
+			 */
+			bool hdr_written = false;
+			walk_const_fptrs(js_call, last, prefix, &hdr_written);
+			if (details_fptr_consts && !hdr_written)
+				fprintf(stderr,
+					"%s: calls function pointer from constant or global data, but no non-NULL function pointers found\n",
+					prefix);
+		} else {
+			char *dump = LLVMPrintValueToString(called);
+			fprintf(stderr, "%s: ??? %s\n", prefix, dump);
+			LLVMDisposeMessage(dump);
+		}
+#ifdef FRR_SPECIFIC
+	} else if (!strcmp(called_name, "_install_element")) {
+		LLVMValueRef param0 = LLVMGetOperand(instr, 0);
+		if (!LLVMIsAConstantInt(param0))
+			goto out_nonconst;
+
+		long long vty_node = LLVMConstIntGetSExtValue(param0);
+		json_object_object_add(js_call, "vty_node",
+				       json_object_new_int64(vty_node));
+
+		LLVMValueRef param1 = LLVMGetOperand(instr, 1);
+		if (!LLVMIsAGlobalVariable(param1))
+			goto out_nonconst;
+
+		LLVMValueRef intlz = LLVMGetInitializer(param1);
+		assert(intlz && LLVMIsConstant(intlz));
+
+		LLVMValueKind intlzkind = LLVMGetValueKind(intlz);
+		assert(intlzkind == LLVMConstantStructValueKind);
+
+		LLVMValueRef funcptr = LLVMGetOperand(intlz, 4);
+		assert(LLVMIsAFunction(funcptr));
+
+		size_t target_len = 0;
+		const char *target;
+		target = LLVMGetValueName2(funcptr, &target_len);
+
+		json_object_object_add(
+			js_call, "type",
+			json_object_new_string("install_element"));
+		json_object_object_add(
+			js_call, "target",
+			json_object_new_string_len(target, target_len));
+		return;
+
+	out_nonconst:
+		json_object_object_add(
+			js_call, "target",
+			json_object_new_string("install_element"));
+		return;
+	} else if (is_thread_sched(called_name, called_len)) {
+		json_object_object_add(js_call, "type",
+				       json_object_new_string("thread_sched"));
+		json_object_object_add(
+			js_call, "subtype",
+			json_object_new_string_len(called_name, called_len));
+
+		LLVMValueRef fparam;
+		fparam = LLVMGetOperand(instr, 2);
+		assert(fparam);
+
+		size_t target_len = 0;
+		const char *target;
+		target = LLVMGetValueName2(fparam, &target_len);
+
+		json_object_object_add(js_call, "target",
+				       !target_len ? NULL :
+			       json_object_new_string_len(target, target_len));
+		if (!LLVMIsAFunction(fparam))
+			json_object_object_add(js_call, "target_unresolved",
+					       json_object_new_boolean(true));
+		return;
+	} else if (!strncmp(called_name, "_hook_typecheck_",
+			    strlen("_hook_typecheck_"))) {
+		struct json_object *js_hook, *js_this;
+		const char *hook_name;
+
+		hook_name = called_name + strlen("_hook_typecheck_");
+
+		json_object_object_add(js_call, "type",
+				       json_object_new_string("hook"));
+
+		LLVMValueRef param0 = LLVMGetOperand(instr, 0);
+		if (!LLVMIsAFunction(param0))
+			return;
+
+		size_t target_len = 0;
+		const char *target;
+		target = LLVMGetValueName2(param0, &target_len);
+
+		js_hook = js_get_or_make(js_special, "hooks",
+					 json_object_new_object);
+		js_hook = js_get_or_make(js_hook, hook_name,
+					 json_object_new_array);
+
+		js_this = json_object_new_object();
+		json_object_array_add(js_hook, js_this);
+
+		dbgloc_add(js_this, instr);
+		json_object_object_add(
+			js_this, "target",
+			json_object_new_string_len(target, target_len));
+		return;
+
+		/* TODO (FRR specifics):
+		 * - workqueues - not sure we can do much there
+		 * - zclient->* ?
+		 */
+#endif /* FRR_SPECIFIC */
+	} else if (!strcmp(called_name, "frr_preinit")) {
+		LLVMValueRef daemoninfo = LLVMGetOperand(instr, 0);
+
+		handle_daemoninfo(js_special, daemoninfo);
+
+		json_object_object_add(
+			js_call, "target",
+			json_object_new_string_len(called_name, called_len));
+	} else {
+		json_object_object_add(
+			js_call, "target",
+			json_object_new_string_len(called_name, called_len));
+	}
+
+out_struct_fptr:
+	for (unsigned argno = 0; argno < n_args; argno++) {
+		LLVMValueRef param = LLVMGetOperand(instr, argno);
+		size_t target_len;
+		const char *target_name;
+
+		if (LLVMIsAFunction(param)) {
+			js_fptrs = js_get_or_make(js_call, "funcptrs",
+						  json_object_new_array);
+
+			target_name = LLVMGetValueName2(param, &target_len);
+
+			json_object_array_add(js_fptrs,
+					      json_object_new_string_len(
+						      target_name, target_len));
+		}
+	}
+}
+
+static void process_fn(struct json_object *funcs,
+		       struct json_object *js_special,
+		       LLVMValueRef function)
+{
+	struct json_object *js_func, *js_calls;
+
+	size_t name_len = 0;
+	const char *name_c = LLVMGetValueName2(function, &name_len);
+	char *name;
+
+	name = strndup(name_c, name_len);
+
+	js_func = json_object_object_get(funcs, name);
+	if (js_func) {
+		unsigned file_len = 0;
+		const char *file = LLVMGetDebugLocFilename(function, &file_len);
+		unsigned line = LLVMGetDebugLocLine(function);
+
+		fprintf(stderr, "%.*s:%d:%s(): duplicate definition!\n",
+			(int)file_len, file, line, name);
+		free(name);
+		return;
+	}
+
+	js_func = json_object_new_object();
+	json_object_object_add(funcs, name, js_func);
+	free(name);
+
+	js_calls = json_object_new_array();
+	json_object_object_add(js_func, "calls", js_calls);
+
+	dbgloc_add(js_func, function);
+
+	for (LLVMBasicBlockRef basicBlock = LLVMGetFirstBasicBlock(function);
+	     basicBlock; basicBlock = LLVMGetNextBasicBlock(basicBlock)) {
+
+		for (LLVMValueRef instr = LLVMGetFirstInstruction(basicBlock);
+		     instr; instr = LLVMGetNextInstruction(instr)) {
+
+			if (LLVMIsAIntrinsicInst(instr))
+				continue;
+
+			if (LLVMIsACallInst(instr) || LLVMIsAInvokeInst(instr))
+				process_call(js_calls, js_special, instr,
+					     function);
+		}
+	}
+}
+
+static void help(int retcode)
+{
+	fprintf(stderr,
+		"FRR LLVM bitcode to callgraph analyzer\n"
+		"\n"
+		"usage:  frr-llvm-cg [-q|-v] [-o <JSONOUTPUT>] BITCODEINPUT\n"
+		"\n"
+		"\t-o FILENAME\twrite JSON output to file instead of stdout\n"
+		"\t-v\t\tbe more verbose\n"
+		"\t-q\t\tbe quiet\n"
+		"\n"
+		"BITCODEINPUT must be a LLVM binary bitcode file (not text\n"
+		"representation.)  Use - to read from stdin.\n"
+		"\n"
+		"Note it may be necessary to build this binary tool against\n"
+		"the specific LLVM version that created the bitcode file.\n");
+	exit(retcode);
+}
+
+int main(int argc, char **argv)
+{
+	int opt;
+	const char *out = NULL;
+	const char *inp = NULL;
+	char v_or_q = '\0';
+
+	while ((opt = getopt(argc, argv, "hvqo:")) != -1) {
+		switch (opt) {
+		case 'o':
+			if (out)
+				help(1);
+			out = optarg;
+			break;
+		case 'v':
+			if (v_or_q && v_or_q != 'v')
+				help(1);
+			details_fptr_vars = true;
+			details_fptr_consts = true;
+			v_or_q = 'v';
+			break;
+		case 'q':
+			if (v_or_q && v_or_q != 'q')
+				help(1);
+			details_fptr_vars = false;
+			details_fptr_consts = false;
+			v_or_q = 'q';
+			break;
+		case 'h':
+			help(0);
+			return 0;
+		default:
+			help(1);
+		}
+	}
+
+	if (optind != argc - 1)
+		help(1);
+
+	inp = argv[optind];
+
+	LLVMMemoryBufferRef memoryBuffer;
+	char *message;
+	int ret;
+
+	// check if we are to read our input file from stdin
+	if (!strcmp(inp, "-")) {
+		inp = "<stdin>";
+		ret = LLVMCreateMemoryBufferWithSTDIN(&memoryBuffer, &message);
+	} else {
+		ret = LLVMCreateMemoryBufferWithContentsOfFile(
+			inp, &memoryBuffer, &message);
+	}
+
+	if (ret) {
+		fprintf(stderr, "failed to open %s: %s\n", inp, message);
+		free(message);
+		return 1;
+	}
+
+	// now create our module using the memorybuffer
+	LLVMModuleRef module;
+	if (LLVMParseBitcode2(memoryBuffer, &module)) {
+		fprintf(stderr, "%s: invalid bitcode\n", inp);
+		LLVMDisposeMemoryBuffer(memoryBuffer);
+		return 1;
+	}
+
+	// done with the memory buffer now, so dispose of it
+	LLVMDisposeMemoryBuffer(memoryBuffer);
+
+	dbginfo = dbginfo_load(module);
+
+	struct json_object *js_root, *js_funcs, *js_special;
+
+	js_root = json_object_new_object();
+	js_funcs = json_object_new_object();
+	json_object_object_add(js_root, "functions", js_funcs);
+	js_special = json_object_new_object();
+	json_object_object_add(js_root, "special", js_special);
+
+	// loop through all the functions in the module
+	for (LLVMValueRef function = LLVMGetFirstFunction(module); function;
+	     function = LLVMGetNextFunction(function)) {
+		if (LLVMIsDeclaration(function))
+			continue;
+
+		process_fn(js_funcs, js_special, function);
+	}
+
+	if (out) {
+		char tmpout[strlen(out) + 5];
+
+		snprintf(tmpout, sizeof(tmpout), "%s.tmp", out);
+		ret = json_object_to_file_ext(tmpout, js_root,
+					JSON_C_TO_STRING_PRETTY |
+					JSON_C_TO_STRING_PRETTY_TAB |
+					JSON_C_TO_STRING_NOSLASHESCAPE);
+		if (ret < 0) {
+			fprintf(stderr, "could not write JSON to file\n");
+			return 1;
+		}
+		if (rename(tmpout, out)) {
+			fprintf(stderr, "could not rename JSON output: %s\n",
+				strerror(errno));
+			unlink(tmpout);
+			return 1;
+		}
+	} else {
+		ret = json_object_to_fd(1, js_root,
+					JSON_C_TO_STRING_PRETTY |
+					JSON_C_TO_STRING_PRETTY_TAB |
+					JSON_C_TO_STRING_NOSLASHESCAPE);
+		if (ret < 0) {
+			fprintf(stderr, "could not write JSON to stdout\n");
+			return 1;
+		}
+	}
+
+	LLVMDisposeModule(module);
+
+	return 0;
+}