Add an example for using constant renderers to render unusual floating point constant encodings directly in the decompilation

Author: D0ntPanic

examples/CMakeLists.txt

@@ -1,5 +1,6 @@
 # Personal+ edition (free edition doesn't get plugins due to no API access)
 add_subdirectory(background_task)
+add_subdirectory(bid64_constant)
 add_subdirectory(breakpoint)
 add_subdirectory(encoded_strings)
 add_subdirectory(x86_extension)

examples/bid64_constant/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.15 FATAL_ERROR)
+
+project(bid64_constant CXX C)
+
+add_library(${PROJECT_NAME} SHARED
+    src/bid64_constant.cpp)
+
+if(NOT BN_API_BUILD_EXAMPLES AND NOT BN_INTERNAL_BUILD)
+    # Out-of-tree build
+    find_path(
+        BN_API_PATH
+        NAMES binaryninjaapi.h
+        HINTS ../.. binaryninjaapi $ENV{BN_API_PATH}
+        REQUIRED
+    )
+    add_subdirectory(${BN_API_PATH} api)
+endif()
+
+target_link_libraries(${PROJECT_NAME}
+    binaryninjaapi)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 20
+    CXX_VISIBILITY_PRESET hidden
+    CXX_STANDARD_REQUIRED ON
+    VISIBILITY_INLINES_HIDDEN ON
+    POSITION_INDEPENDENT_CODE ON
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/out/bin)
+
+bn_install_plugin(${PROJECT_NAME})

examples/bid64_constant/sample_binary

@@ -0,0 +1,128 @@
+// This plugin renders 64-bit binary integer decimal floating point constants directly in the
+// decompilation. See the sample binary at `examples/bid64_constant/sample_binary` for an
+// example of a binary that uses this unusual format.
+
+#define _CRT_SECURE_NO_WARNINGS
+#include <cinttypes>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <functional>
+#include <vector>
+#include "binaryninjaapi.h"
+
+using namespace BinaryNinja;
+using namespace std;
+
+
+static string Bid64ToString(bool sign, uint64_t magnitude, int exponent)
+{
+	if (magnitude == 0)
+		exponent = 0;
+
+	string digits = to_string(magnitude);
+	int intPartDigits = digits.length() + exponent;
+
+	string fracDigits;
+	if (intPartDigits < 0)
+		fracDigits = digits;
+	else if (intPartDigits <= digits.length())
+		fracDigits = digits.substr(intPartDigits);
+
+	int trailingZeros = 0;
+	for (size_t i = 0; i < fracDigits.length(); i++)
+	{
+		if (fracDigits[(fracDigits.length() - 1) - i] != '0')
+			break;
+		trailingZeros++;
+	}
+
+	int nonzeroFracDigits = fracDigits.length() - trailingZeros;
+	fracDigits = fracDigits.substr(0, nonzeroFracDigits);
+
+	string result;
+	if (intPartDigits > 0)
+	{
+		for (size_t i = 0; i < intPartDigits; i++)
+		{
+			if (i >= digits.length())
+				result += "0";
+			else
+				result += string(1, digits[i]);
+		}
+	}
+	else
+	{
+		result = "0";
+	}
+
+	if (intPartDigits < 0 && fracDigits.length() > 0)
+	{
+		result += ".";
+		for (size_t i = 0; i < -intPartDigits; i++)
+			result += "0";
+		result += fracDigits;
+	}
+	else if (fracDigits.length() > 0)
+	{
+		result += ".";
+		result += fracDigits;
+	}
+
+	return result;
+}
+
+
+class Bid64ConstantRenderer : public ConstantRenderer
+{
+public:
+	Bid64ConstantRenderer() : ConstantRenderer("bid64_constant")
+	{
+	}
+
+	bool RenderConstant(const HighLevelILInstruction&, Type* type, int64_t val, HighLevelILTokenEmitter& tokens,
+		DisassemblySettings* settings, BNOperatorPrecedence) override
+	{
+		// Typedef name doesn't survive propagation, but check for 8 byte integers with the
+		// alternate name "long long unsigned int", which is what BID_UINT64 is a typedef for.
+		if (!type || type->GetClass() != IntegerTypeClass)
+			return false;
+		if (type->GetWidth() != 8)
+			return false;
+		if (type->GetAlternateName() != "long long unsigned int")
+			return false;
+
+		// Get sign bit and raw exponent
+		bool sign = (val & (1LL << 63)) != 0;
+		int rawExponent = (int)((val >> 53) & 0x3ff);
+		if (rawExponent >= 0x300)
+		{
+			// Don't try and render NaN or infinity
+			return false;
+		}
+
+		// Get magnitude and actual exponent
+		constexpr uint64_t BIAS = 398;
+		int exponent = rawExponent - BIAS;
+		uint64_t magnitude = val & ((1LL << 53) - 1);
+
+		tokens.Append(FloatingPointToken, Bid64ToString(sign, magnitude, exponent) + "_bid");
+		return true;
+	}
+};
+
+
+extern "C"
+{
+	BN_DECLARE_CORE_ABI_VERSION
+
+	BINARYNINJAPLUGIN void CorePluginDependencies()
+	{
+	}
+
+	BINARYNINJAPLUGIN bool CorePluginInit()
+	{
+		ConstantRenderer::Register(new Bid64ConstantRenderer());
+		return true;
+	}
+}

examples/bid64_constant/src/bid64_constant.cpp

@@ -0,0 +1,38 @@
+# This plugin renders 64-bit binary integer decimal floating point constants directly in the
+# decompilation. See the sample binary at `examples/bid64_constant/sample_binary` for an
+# example of a binary that uses this unusual format.
+
+from binaryninja import (ConstantRenderer, InstructionTextToken, InstructionTextTokenType, IntegerType)
+from decimal import Decimal
+
+
+class Bid64ConstantRenderer(ConstantRenderer):
+    renderer_name = "bid64_constant"
+
+    def render_constant(self, instr, type, val, tokens, settings, precedence):
+        # Typedef name doesn't survive propagation, but check for 8 byte integers with the
+        # alternate name "long long unsigned int", which is what BID_UINT64 is a typedef for.
+        if not isinstance(type, IntegerType):
+            return False
+        if type.width != 8:
+            return False
+        if type.altname != 'long long unsigned int':
+            return False
+
+        sign = (val & (1 << 63)) != 0
+        raw_exponent = (val >> 53) & 0x3ff
+        if raw_exponent >= 0x300:
+            # Don't try and render NaN or infinity
+            return False
+
+        bias = 398
+        exponent = raw_exponent - bias
+
+        value = Decimal(val & ((1 << 53) - 1)) * Decimal(10.0) ** Decimal(exponent)
+        if sign:
+            value = -value
+        tokens.append(InstructionTextToken(InstructionTextTokenType.FloatingPointToken, str(value) + "_bid"))
+        return True
+
+
+Bid64ConstantRenderer().register()