├── .editorconfig ├── .gitignore ├── .gitmodules ├── CMakeLists.txt ├── LICENSE ├── README.md ├── examples ├── llil_parser.cpp └── standalone_test.cpp └── src ├── binaryninjacore.cpp ├── core_analysis.cpp ├── core_architecture.cpp ├── core_callingconvention.cpp ├── core_function.cpp ├── core_impl.h ├── core_llil.cpp ├── core_platform.cpp ├── core_plugins.cpp ├── core_ref.h ├── core_settings.cpp ├── core_string.cpp ├── core_types.cpp └── core_utils.h /.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | indent_style = tab 5 | indent_size = 4 6 | tab_width = 4 -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build*/ 2 | cmake-build*/ 3 | .DS_Store 4 | .cache/ -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "binaryninja-api"] 2 | path = binaryninja-api 3 | url = https://github.com/Vector35/binaryninja-api 4 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.21) 2 | 3 | set_property(GLOBAL PROPERTY USE_FOLDERS ON) 4 | 5 | project(binja-standalone-api) 6 | 7 | option(STANDALONE_BUILD_EXAMPLES "Build the examples" ${PROJECT_IS_TOP_LEVEL}) 8 | option(STANDALONE_CORE "Build standalone core (for development only)" ON) 9 | option(STANDALONE_ARCH_X86 "Build the x86 architecture" ON) 10 | option(STANDALONE_ARCH_ARM64 "Build the ARM64 architecture" OFF) 11 | option(STANDALONE_ARCH_ARMV7 "Build the ARMv7 architecture" OFF) 12 | option(STANDALONE_ARCH_MIPS "Build the MIPS architecture" OFF) 13 | option(STANDALONE_ARCH_POWERPC "Build the PowerPC architecture" OFF) 14 | option(STANDALONE_ARCH_RISCV "Build the RISC-V architecture" OFF) 15 | 16 | if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/binaryninja-api" OR NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/binaryninja-api/vendor/fmt") 17 | if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/.git") 18 | execute_process(COMMAND git submodule update --init --recursive 19 | WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} 20 | COMMAND_ECHO STDOUT 21 | COMMAND_ERROR_IS_FATAL ANY 22 | ) 23 | else() 24 | message(FATAL_ERROR "binaryninja-api submodule is not initialized. Please run `git submodule update --init --recursive`") 25 | endif() 26 | endif() 27 | 28 | # Include the unmodified binaryninja-api 29 | set(HEADLESS ON) 30 | set(BN_INTERNAL_BUILD ${STANDALONE_CORE}) 31 | 32 | set(CMAKE_FOLDER_OLD "${CMAKE_FOLDER}") 33 | if(CMAKE_FOLDER) 34 | set(CMAKE_FOLDER "${CMAKE_FOLDER}/binaryninja-api") 35 | else() 36 | set(CMAKE_FOLDER "binaryninja-api") 37 | endif() 38 | add_subdirectory(binaryninja-api) 39 | set(CMAKE_FOLDER "${CMAKE_FOLDER_OLD}") 40 | 41 | # Create the standalone binaryninjacore target 42 | if(STANDALONE_CORE) 43 | add_library(binaryninjacore STATIC) 44 | file(GLOB CORE_SOURCES CONFIGURE_DEPENDS "src/*.cpp" "src/*.h") 45 | target_sources(binaryninjacore PRIVATE 46 | ${CORE_SOURCES} 47 | ) 48 | target_compile_features(binaryninjacore PUBLIC cxx_std_17) 49 | 50 | get_target_property(BINARYNINJA_API_INCLUDE_DIRS binaryninjaapi INTERFACE_INCLUDE_DIRECTORIES) 51 | target_include_directories(binaryninjacore 52 | PRIVATE ${BINARYNINJA_API_INCLUDE_DIRS} 53 | ) 54 | get_target_property(BINARYNINJA_API_LIBRARIES binaryninjaapi INTERFACE_LINK_LIBRARIES) 55 | list(REMOVE_ITEM BINARYNINJA_API_LIBRARIES binaryninjacore) 56 | target_link_libraries(binaryninjacore 57 | PRIVATE ${BINARYNINJA_API_LIBRARIES} 58 | ) 59 | 60 | # Override functions to make the architectures compatible 61 | function(plugin_rpath tgt) 62 | endfunction() 63 | 64 | add_library(arch_all STATIC) 65 | set_target_properties(arch_all PROPERTIES ARCH_LIST "") 66 | 67 | function(add_library tgt linkage) 68 | if(tgt MATCHES "^arch_(.+)$") 69 | message(STATUS "[Hooked] Architecture ${CMAKE_MATCH_1}") 70 | target_link_libraries(arch_all PRIVATE ${tgt}) 71 | get_target_property(arch_list arch_all ARCH_LIST) 72 | set_property(TARGET arch_all PROPERTY ARCH_LIST ${arch_list} ${tgt}) 73 | _add_library(${tgt} STATIC ${ARGN}) 74 | target_compile_definitions(${tgt} PRIVATE 75 | CorePluginInit=CorePluginInit_${tgt} 76 | CorePluginABIVersion=CorePluginABIVersion_${tgt} 77 | CorePluginDependencies=CorePluginDependencies_${tgt} 78 | get_condition=get_condition_${tgt} 79 | get_operation=get_operation_${tgt} 80 | get_shift=get_shift_${tgt} 81 | get_register=get_register_${tgt} 82 | bswap32=bswap32_${tgt} 83 | ) 84 | else() 85 | _add_library(${ARGV}) 86 | endif() 87 | endfunction() 88 | 89 | # Add the architectures 90 | set(BN_CORE_PLUGIN_DIR ${CMAKE_BINARY_DIR}/core_plugins) 91 | set(CMAKE_FOLDER_OLD "${CMAKE_FOLDER}") 92 | if(CMAKE_FOLDER) 93 | set(CMAKE_FOLDER "${CMAKE_FOLDER}/binaryninja-api/arch") 94 | else() 95 | set(CMAKE_FOLDER "binaryninja-api/arch") 96 | endif() 97 | if(STANDALONE_ARCH_X86) 98 | add_subdirectory(binaryninja-api/arch/x86) 99 | endif() 100 | if(STANDALONE_ARCH_ARM64) 101 | add_subdirectory(binaryninja-api/arch/arm64) 102 | endif() 103 | if(STANDALONE_ARCH_ARMV7) 104 | add_subdirectory(binaryninja-api/arch/armv7) 105 | endif() 106 | if(STANDALONE_ARCH_MIPS) 107 | add_subdirectory(binaryninja-api/arch/mips) 108 | endif() 109 | if(STANDALONE_ARCH_POWERPC) 110 | add_subdirectory(binaryninja-api/arch/powerpc) 111 | endif() 112 | if(STANDALONE_ARCH_RISCV) 113 | # TODO: this is implemented in rust, so we need to compile it as a dynamic library 114 | add_subdirectory(binaryninja-api/arch/riscv) 115 | endif() 116 | set(CMAKE_FOLDER "${CMAKE_FOLDER_OLD}") 117 | 118 | # Generate architecture initializer) 119 | get_target_property(arch_list arch_all ARCH_LIST) 120 | if(NOT arch_list) 121 | message(FATAL_ERROR "No architectures were selected") 122 | endif() 123 | set(ARCH_PREFIX "#include \n") 124 | set(ARCH_IMPL "extern \"C\" BINARYNINJAPLUGIN bool CorePluginInit_arch()\n{\n") 125 | foreach(arch ${arch_list}) 126 | set(ARCH_PREFIX "${ARCH_PREFIX}extern \"C\" BINARYNINJAPLUGIN bool CorePluginInit_${arch}()\;\n") 127 | set(ARCH_IMPL "${ARCH_IMPL}\tif(!CorePluginInit_${arch}()) return false\;\n") 128 | endforeach() 129 | set(ARCH_IMPL "${ARCH_IMPL}\treturn true\;\n}\n") 130 | file(WRITE "${CMAKE_BINARY_DIR}/arch_init.cpp" ${ARCH_PREFIX}${ARCH_IMPL}) 131 | 132 | target_sources(arch_all PRIVATE "${CMAKE_BINARY_DIR}/arch_init.cpp") 133 | target_link_libraries(binaryninjacore PRIVATE arch_all) 134 | else() 135 | target_compile_features(binaryninjaapi PUBLIC cxx_std_17) 136 | endif() 137 | 138 | # Add examples 139 | if(STANDALONE_BUILD_EXAMPLES) 140 | add_executable(standalone_test examples/standalone_test.cpp) 141 | target_link_libraries(standalone_test PRIVATE binaryninjaapi) 142 | 143 | add_executable(llil_parser examples/llil_parser.cpp) 144 | target_link_libraries(llil_parser PRIVATE binaryninjaapi) 145 | endif() 146 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Boost Software License - Version 1.0 - August 17th, 2003 2 | 3 | Permission is hereby granted, free of charge, to any person or organization 4 | obtaining a copy of the software and accompanying documentation covered by 5 | this license (the "Software") to use, reproduce, display, distribute, 6 | execute, and transmit the Software, and to prepare derivative works of the 7 | Software, and to permit third-parties to whom the Software is furnished to 8 | do so, all subject to the following: 9 | 10 | The copyright notices in the Software and this entire statement, including 11 | the above license grant, this restriction and the following disclaimer, 12 | must be included in all copies of the Software, in whole or in part, and 13 | all derivative works of the Software, unless such copies or derivative 14 | works are solely in the form of machine-executable object code generated by 15 | a source language processor. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 | DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # binja-standalone-api 2 | 3 | This is a proof-of-concept standalone implementation of [Binary Ninja](https://binary.ninja)'s LLIL. It uses the official [binaryninja-api](https://github.com/Vector35/binaryninja-api) repository without modifications. The goal is to leverage the open source architecture plugins in a standalone environment. There are no plans to implement MLIL/HLIL or other proprietary Binary Ninja features, you should [purchase a license](https://binary.ninja/purchase/). There will be no support provided for this repository. 4 | -------------------------------------------------------------------------------- /examples/llil_parser.cpp: -------------------------------------------------------------------------------- 1 | // Adapted from https://github.com/Vector35/binaryninja-api/blob/7a9a2503aae0c2b92b437b2ea7796efaae93a822/examples/llil_parser/src/llil_parser.cpp 2 | 3 | #include 4 | #include 5 | #include "binaryninjacore.h" 6 | #include "binaryninjaapi.h" 7 | #include "lowlevelilinstruction.h" 8 | 9 | using namespace BinaryNinja; 10 | using namespace std; 11 | 12 | 13 | static void PrintIndent(size_t indent) 14 | { 15 | for (size_t i = 0; i < indent; i++) 16 | printf(" "); 17 | } 18 | 19 | 20 | static void PrintOperation(BNLowLevelILOperation operation) 21 | { 22 | #define ENUM_PRINTER(op) \ 23 | case op: \ 24 | printf(#op); \ 25 | break 26 | 27 | switch (operation) 28 | { 29 | ENUM_PRINTER(LLIL_NOP); 30 | ENUM_PRINTER(LLIL_SET_REG); 31 | ENUM_PRINTER(LLIL_SET_REG_SPLIT); 32 | ENUM_PRINTER(LLIL_SET_FLAG); 33 | ENUM_PRINTER(LLIL_LOAD); 34 | ENUM_PRINTER(LLIL_STORE); 35 | ENUM_PRINTER(LLIL_PUSH); 36 | ENUM_PRINTER(LLIL_POP); 37 | ENUM_PRINTER(LLIL_REG); 38 | ENUM_PRINTER(LLIL_CONST); 39 | ENUM_PRINTER(LLIL_CONST_PTR); 40 | ENUM_PRINTER(LLIL_EXTERN_PTR); 41 | ENUM_PRINTER(LLIL_FLAG); 42 | ENUM_PRINTER(LLIL_FLAG_BIT); 43 | ENUM_PRINTER(LLIL_ADD); 44 | ENUM_PRINTER(LLIL_ADC); 45 | ENUM_PRINTER(LLIL_SUB); 46 | ENUM_PRINTER(LLIL_SBB); 47 | ENUM_PRINTER(LLIL_AND); 48 | ENUM_PRINTER(LLIL_OR); 49 | ENUM_PRINTER(LLIL_XOR); 50 | ENUM_PRINTER(LLIL_LSL); 51 | ENUM_PRINTER(LLIL_LSR); 52 | ENUM_PRINTER(LLIL_ASR); 53 | ENUM_PRINTER(LLIL_ROL); 54 | ENUM_PRINTER(LLIL_RLC); 55 | ENUM_PRINTER(LLIL_ROR); 56 | ENUM_PRINTER(LLIL_RRC); 57 | ENUM_PRINTER(LLIL_MUL); 58 | ENUM_PRINTER(LLIL_MULU_DP); 59 | ENUM_PRINTER(LLIL_MULS_DP); 60 | ENUM_PRINTER(LLIL_DIVU); 61 | ENUM_PRINTER(LLIL_DIVU_DP); 62 | ENUM_PRINTER(LLIL_DIVS); 63 | ENUM_PRINTER(LLIL_DIVS_DP); 64 | ENUM_PRINTER(LLIL_MODU); 65 | ENUM_PRINTER(LLIL_MODU_DP); 66 | ENUM_PRINTER(LLIL_MODS); 67 | ENUM_PRINTER(LLIL_MODS_DP); 68 | ENUM_PRINTER(LLIL_NEG); 69 | ENUM_PRINTER(LLIL_NOT); 70 | ENUM_PRINTER(LLIL_SX); 71 | ENUM_PRINTER(LLIL_ZX); 72 | ENUM_PRINTER(LLIL_LOW_PART); 73 | ENUM_PRINTER(LLIL_JUMP); 74 | ENUM_PRINTER(LLIL_JUMP_TO); 75 | ENUM_PRINTER(LLIL_CALL); 76 | ENUM_PRINTER(LLIL_CALL_STACK_ADJUST); 77 | ENUM_PRINTER(LLIL_TAILCALL); 78 | ENUM_PRINTER(LLIL_RET); 79 | ENUM_PRINTER(LLIL_NORET); 80 | ENUM_PRINTER(LLIL_IF); 81 | ENUM_PRINTER(LLIL_GOTO); 82 | ENUM_PRINTER(LLIL_FLAG_COND); 83 | ENUM_PRINTER(LLIL_CMP_E); 84 | ENUM_PRINTER(LLIL_CMP_NE); 85 | ENUM_PRINTER(LLIL_CMP_SLT); 86 | ENUM_PRINTER(LLIL_CMP_ULT); 87 | ENUM_PRINTER(LLIL_CMP_SLE); 88 | ENUM_PRINTER(LLIL_CMP_ULE); 89 | ENUM_PRINTER(LLIL_CMP_SGE); 90 | ENUM_PRINTER(LLIL_CMP_UGE); 91 | ENUM_PRINTER(LLIL_CMP_SGT); 92 | ENUM_PRINTER(LLIL_CMP_UGT); 93 | ENUM_PRINTER(LLIL_TEST_BIT); 94 | ENUM_PRINTER(LLIL_BOOL_TO_INT); 95 | ENUM_PRINTER(LLIL_ADD_OVERFLOW); 96 | ENUM_PRINTER(LLIL_SYSCALL); 97 | ENUM_PRINTER(LLIL_BP); 98 | ENUM_PRINTER(LLIL_TRAP); 99 | ENUM_PRINTER(LLIL_UNDEF); 100 | ENUM_PRINTER(LLIL_UNIMPL); 101 | ENUM_PRINTER(LLIL_UNIMPL_MEM); 102 | ENUM_PRINTER(LLIL_SET_REG_SSA); 103 | ENUM_PRINTER(LLIL_SET_REG_SSA_PARTIAL); 104 | ENUM_PRINTER(LLIL_SET_REG_SPLIT_SSA); 105 | ENUM_PRINTER(LLIL_REG_SPLIT_DEST_SSA); 106 | ENUM_PRINTER(LLIL_REG_SSA); 107 | ENUM_PRINTER(LLIL_REG_SSA_PARTIAL); 108 | ENUM_PRINTER(LLIL_SET_FLAG_SSA); 109 | ENUM_PRINTER(LLIL_FLAG_SSA); 110 | ENUM_PRINTER(LLIL_FLAG_BIT_SSA); 111 | ENUM_PRINTER(LLIL_CALL_SSA); 112 | ENUM_PRINTER(LLIL_SYSCALL_SSA); 113 | ENUM_PRINTER(LLIL_TAILCALL_SSA); 114 | ENUM_PRINTER(LLIL_CALL_PARAM); 115 | ENUM_PRINTER(LLIL_CALL_STACK_SSA); 116 | ENUM_PRINTER(LLIL_CALL_OUTPUT_SSA); 117 | ENUM_PRINTER(LLIL_LOAD_SSA); 118 | ENUM_PRINTER(LLIL_STORE_SSA); 119 | ENUM_PRINTER(LLIL_REG_PHI); 120 | ENUM_PRINTER(LLIL_FLAG_PHI); 121 | ENUM_PRINTER(LLIL_MEM_PHI); 122 | default: 123 | printf("", operation); 124 | break; 125 | } 126 | } 127 | 128 | 129 | static void PrintFlagCondition(BNLowLevelILFlagCondition cond) 130 | { 131 | switch (cond) 132 | { 133 | ENUM_PRINTER(LLFC_E); 134 | ENUM_PRINTER(LLFC_NE); 135 | ENUM_PRINTER(LLFC_SLT); 136 | ENUM_PRINTER(LLFC_ULT); 137 | ENUM_PRINTER(LLFC_SLE); 138 | ENUM_PRINTER(LLFC_ULE); 139 | ENUM_PRINTER(LLFC_SGE); 140 | ENUM_PRINTER(LLFC_UGE); 141 | ENUM_PRINTER(LLFC_SGT); 142 | ENUM_PRINTER(LLFC_UGT); 143 | ENUM_PRINTER(LLFC_NEG); 144 | ENUM_PRINTER(LLFC_POS); 145 | ENUM_PRINTER(LLFC_O); 146 | ENUM_PRINTER(LLFC_NO); 147 | default: 148 | printf(""); 149 | break; 150 | } 151 | } 152 | 153 | 154 | static void PrintRegister(LowLevelILFunction* func, uint32_t reg) 155 | { 156 | if (LLIL_REG_IS_TEMP(reg)) 157 | printf("temp%d", LLIL_GET_TEMP_REG_INDEX(reg)); 158 | else 159 | { 160 | string name = func->GetArchitecture()->GetRegisterName(reg); 161 | if (name.size() == 0) 162 | printf(""); 163 | else 164 | printf("%s", name.c_str()); 165 | } 166 | } 167 | 168 | 169 | static void PrintFlag(LowLevelILFunction* func, uint32_t flag) 170 | { 171 | if (LLIL_REG_IS_TEMP(flag)) 172 | printf("cond:%d", LLIL_GET_TEMP_REG_INDEX(flag)); 173 | else 174 | { 175 | string name = func->GetArchitecture()->GetFlagName(flag); 176 | if (name.size() == 0) 177 | printf(""); 178 | else 179 | printf("%s", name.c_str()); 180 | } 181 | } 182 | 183 | 184 | static void PrintILExpr(const LowLevelILInstruction& instr, size_t indent) 185 | { 186 | PrintIndent(indent); 187 | PrintOperation(instr.operation); 188 | printf("\n"); 189 | 190 | indent++; 191 | 192 | for (auto& operand : instr.GetOperands()) 193 | { 194 | switch (operand.GetType()) 195 | { 196 | case IntegerLowLevelOperand: 197 | PrintIndent(indent); 198 | printf("int 0x%" PRIx64 "\n", operand.GetInteger()); 199 | break; 200 | 201 | case IndexLowLevelOperand: 202 | PrintIndent(indent); 203 | printf("index %" PRIdPTR "\n", operand.GetIndex()); 204 | break; 205 | 206 | case ExprLowLevelOperand: 207 | PrintILExpr(operand.GetExpr(), indent); 208 | break; 209 | 210 | case RegisterLowLevelOperand: 211 | PrintIndent(indent); 212 | printf("reg "); 213 | PrintRegister(instr.function, operand.GetRegister()); 214 | printf("\n"); 215 | break; 216 | 217 | case FlagLowLevelOperand: 218 | PrintIndent(indent); 219 | printf("flag "); 220 | PrintFlag(instr.function, operand.GetFlag()); 221 | printf("\n"); 222 | break; 223 | 224 | case FlagConditionLowLevelOperand: 225 | PrintIndent(indent); 226 | printf("flag condition "); 227 | PrintFlagCondition(operand.GetFlagCondition()); 228 | printf("\n"); 229 | break; 230 | 231 | case SSARegisterLowLevelOperand: 232 | PrintIndent(indent); 233 | printf("ssa reg "); 234 | PrintRegister(instr.function, operand.GetSSARegister().reg); 235 | printf("#%" PRIdPTR "\n", operand.GetSSARegister().version); 236 | break; 237 | 238 | case SSAFlagLowLevelOperand: 239 | PrintIndent(indent); 240 | printf("ssa flag "); 241 | PrintFlag(instr.function, operand.GetSSAFlag().flag); 242 | printf("#%" PRIdPTR "\n", operand.GetSSAFlag().version); 243 | break; 244 | 245 | case IndexListLowLevelOperand: 246 | PrintIndent(indent); 247 | printf("index list "); 248 | for (auto i : operand.GetIndexList()) 249 | printf("%" PRIdPTR " ", i); 250 | printf("\n"); 251 | break; 252 | 253 | case SSARegisterListLowLevelOperand: 254 | PrintIndent(indent); 255 | printf("ssa reg list "); 256 | for (auto i : operand.GetSSARegisterList()) 257 | { 258 | PrintRegister(instr.function, i.reg); 259 | printf("#%" PRIdPTR " ", i.version); 260 | } 261 | printf("\n"); 262 | break; 263 | 264 | case SSAFlagListLowLevelOperand: 265 | PrintIndent(indent); 266 | printf("ssa reg list "); 267 | for (auto i : operand.GetSSAFlagList()) 268 | { 269 | PrintFlag(instr.function, i.flag); 270 | printf("#%" PRIdPTR " ", i.version); 271 | } 272 | printf("\n"); 273 | break; 274 | 275 | default: 276 | PrintIndent(indent); 277 | printf("\n"); 278 | break; 279 | } 280 | } 281 | } 282 | 283 | Ref GetLowLevelILTestFunction(Architecture* arch) 284 | { 285 | static auto platform = BNCreatePlatform(arch->GetObject(), "test-platform"); 286 | auto addr = 0x10000; 287 | Ref fn = new Function(BNCreateUserFunction(nullptr, platform, addr)); 288 | Ref il = new LowLevelILFunction(arch, fn); 289 | std::vector test = { 0x48, 0x8B, 0x42, 0x24, 0x78 }; // mov rax, qword ptr [rdx+0x78] 290 | size_t size = test.size(); 291 | arch->GetInstructionLowLevelIL(test.data(), addr, size, *il); 292 | il->Finalize(); 293 | return il; 294 | } 295 | 296 | int main(int argc, char* argv[]) 297 | { 298 | if (!InitPlugins()) 299 | { 300 | puts("Failed to initialize plugins"); 301 | return EXIT_FAILURE; 302 | } 303 | 304 | auto arch = Architecture::GetByName("x86_64"); 305 | if(!arch) 306 | { 307 | puts("Failed to get x86_64 architecture"); 308 | return EXIT_FAILURE; 309 | } 310 | 311 | auto il = GetLowLevelILTestFunction(arch); 312 | if (!il) 313 | { 314 | printf(" Does not have LLIL\n\n"); 315 | return EXIT_FAILURE; 316 | } 317 | 318 | // Loop through all blocks in the function 319 | for (auto& block : il->GetBasicBlocks()) 320 | { 321 | // Loop though each instruction in the block 322 | for (size_t instrIndex = block->GetStart(); instrIndex < block->GetEnd(); instrIndex++) 323 | { 324 | // Fetch IL instruction 325 | LowLevelILInstruction instr = (*il)[instrIndex]; 326 | 327 | // Display core's intrepretation of the IL instruction 328 | vector tokens; 329 | il->GetInstructionText(nullptr, il->GetArchitecture(), instrIndex, tokens); 330 | printf(" %" PRIdPTR " @ 0x%" PRIx64 " ", instrIndex, instr.address); 331 | for (auto& token : tokens) 332 | printf("%s", token.text.c_str()); 333 | printf("\n"); 334 | 335 | // Generically parse the IL tree and display the parts 336 | PrintILExpr(instr, 2); 337 | 338 | // Example of using visitors to find all constants in the instruction 339 | instr.VisitExprs([&](const LowLevelILInstruction& expr) { 340 | switch (expr.operation) 341 | { 342 | case LLIL_CONST: 343 | case LLIL_CONST_PTR: 344 | case LLIL_EXTERN_PTR: 345 | printf(" Found constant 0x%" PRIx64 "\n", expr.GetConstant()); 346 | return false; // Done parsing this 347 | default: 348 | break; 349 | } 350 | return true; // Parse any subexpressions 351 | }); 352 | 353 | // Example of using the templated accessors for efficiently parsing load instructions 354 | instr.VisitExprs([&](const LowLevelILInstruction& expr) { 355 | switch (expr.operation) 356 | { 357 | case LLIL_LOAD: 358 | if (expr.GetSourceExpr().operation == LLIL_CONST_PTR) 359 | { 360 | printf(" Loading from address 0x%" PRIx64 "\n", 361 | expr.GetSourceExpr().GetConstant()); 362 | return false; // Done parsing this 363 | } 364 | else if (expr.GetSourceExpr().operation == LLIL_EXTERN_PTR) 365 | { 366 | printf(" Loading from address 0x%" PRIx64 "\n", 367 | expr.GetSourceExpr().GetConstant()); 368 | return false; // Done parsing this 369 | } 370 | break; 371 | default: 372 | break; 373 | } 374 | return true; // Parse any subexpressions 375 | }); 376 | } 377 | } 378 | 379 | printf("\n"); 380 | 381 | return EXIT_SUCCESS; 382 | } -------------------------------------------------------------------------------- /examples/standalone_test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace BinaryNinja; 5 | 6 | // Taken from: https://stackoverflow.com/a/24315631 7 | static void ReplaceAll(std::string& s, const std::string& from, const std::string& to) 8 | { 9 | size_t start_pos = 0; 10 | while ((start_pos = s.find(from, start_pos)) != std::string::npos) 11 | { 12 | s.replace(start_pos, from.length(), to); 13 | start_pos += to.length(); // Handles case where 'to' is a substring of 'from' 14 | } 15 | } 16 | 17 | static int hex2int(char ch) 18 | { 19 | if (ch >= '0' && ch <= '9') 20 | return ch - '0'; 21 | if (ch >= 'A' && ch <= 'F') 22 | return ch - 'A' + 10; 23 | if (ch >= 'a' && ch <= 'f') 24 | return ch - 'a' + 10; 25 | return -1; 26 | } 27 | 28 | static bool FromHexImpl(const std::string& text1, std::vector& data, bool reverse) 29 | { 30 | auto text = [&] { 31 | std::string r; 32 | for (auto ch : text1) 33 | { 34 | if (hex2int(ch) != -1) 35 | r.push_back(ch); 36 | } 37 | return r; 38 | }(); 39 | auto size = text.size(); 40 | if (size % 2) 41 | return false; 42 | data.resize(size / 2); 43 | for (size_t i = 0, j = 0; i < size; i += 2, j++) 44 | { 45 | auto high = hex2int(text[i]); 46 | auto low = hex2int(text[i + 1]); 47 | if (high == -1 || low == -1) 48 | return false; 49 | data[reverse ? data.size() - j - 1 : j] = (high << 4) | low; 50 | } 51 | return true; 52 | } 53 | 54 | static std::vector fromhex(std::string text) 55 | { 56 | std::vector d; 57 | ReplaceAll(text, "0x", ""); 58 | FromHexImpl(text, d, false); 59 | return d; 60 | } 61 | 62 | std::string tokensText(const std::vector& tokens) 63 | { 64 | std::string text; 65 | for (const auto& token : tokens) 66 | { 67 | text += token.text; 68 | } 69 | return text; 70 | } 71 | 72 | int main(int argc, char** argv) 73 | { 74 | if (!InitPlugins()) 75 | { 76 | puts("Failed to initialize plugins"); 77 | return EXIT_FAILURE; 78 | } 79 | 80 | auto arch = Architecture::GetByName("x86_64"); 81 | if (!arch) 82 | { 83 | puts("Failed to get x86_64 architecture"); 84 | return EXIT_FAILURE; 85 | } 86 | 87 | std::vector> tests; 88 | auto test = [&tests](const char* hex) 89 | { 90 | tests.push_back(fromhex(hex)); 91 | }; 92 | test("0x33, 0xFF"); // xor edi, edi 93 | test("0x2B, 0xC8"); // sub ecx, eax 94 | test("0xC7, 0x44, 0x24, 0x48, 0x16, 0x00, 0x18, 0x00"); // mov dword ptr ss:[rsp+0x48], 0x180016 95 | test("0x0F, 0x44, 0xD8"); // cmove ebx, eax 96 | test("0xF3, 0xAA"); // rep stosb 97 | test("0xF0, 0x0F, 0xB1, 0x35, 0x4B, 0x78, 0x0F, 0x00"); // 98 | test("F0 41 0F BA 2C 24 01"); // lock bts dword ptr ds:[r12], 0x1 99 | test("E8 1D 8F 05 00"); // call 100 | test("75 02"); // jne 101 | test("C3"); // ret 102 | test("488B4C2478"); // mov rcx, qword ptr [rsp+0x78] 103 | for (const auto& test : tests) 104 | { 105 | auto addr = 0x10000; 106 | Ref il = new LowLevelILFunction(arch); 107 | auto size = test.size(); 108 | std::vector tokens; 109 | arch->GetInstructionText(test.data(), addr, size, tokens); 110 | printf("disassembly: %s\n", tokensText(tokens).c_str()); 111 | auto continueLifting = arch->GetInstructionLowLevelIL(test.data(), addr, size, *il); 112 | il->Finalize(); 113 | //printf("continueLifting: %d\n", continueLifting); 114 | puts("LLIL:"); 115 | 116 | auto instructionCount = il->GetInstructionCount(); 117 | for (size_t i = 0, j = 0; i < instructionCount; i++) 118 | { 119 | auto instr = il->GetInstruction(i); 120 | auto exprId = il->GetIndexForInstruction(i); 121 | for (; j < exprId; j++) 122 | { 123 | il->GetExprText(arch, j, tokens); 124 | printf("\t%%%zu = %s\n", j, tokensText(tokens).c_str()); 125 | } 126 | auto prefix = "[" + std::to_string(i) + "]"; 127 | il->GetExprText(arch, exprId, tokens); 128 | printf("[%zu]\t%%%zu = %s\n", i, exprId, tokensText(tokens).c_str()); 129 | j++; 130 | } 131 | 132 | puts(""); 133 | } 134 | } -------------------------------------------------------------------------------- /src/core_analysis.cpp: -------------------------------------------------------------------------------- 1 | // Analysis 2 | 3 | #include "core_impl.h" 4 | 5 | BINARYNINJACOREAPI void BNAddAnalysisOption(BNBinaryView* view, const char* name) { __debugbreak(); } 6 | BINARYNINJACOREAPI BNFunction* BNAddFunctionForAnalysis( 7 | BNBinaryView* view, BNPlatform* platform, uint64_t addr, bool autoDiscovered, BNType* type) { __debugbreak(); return {}; } 8 | BINARYNINJACOREAPI void BNAddEntryPointForAnalysis(BNBinaryView* view, BNPlatform* platform, uint64_t addr) { __debugbreak(); } 9 | BINARYNINJACOREAPI void BNRemoveAnalysisFunction(BNBinaryView* view, BNFunction* func, bool updateRefs) { __debugbreak(); } 10 | BINARYNINJACOREAPI BNFunction* BNCreateUserFunction(BNBinaryView* view, BNPlatform* platform, uint64_t addr) 11 | { 12 | // TODO: for now we allow creating a function without view 13 | return new BNFunction(platform->mArch, addr); 14 | } 15 | BINARYNINJACOREAPI void BNRemoveUserFunction(BNBinaryView* view, BNFunction* func) { __debugbreak(); } 16 | BINARYNINJACOREAPI bool BNHasInitialAnalysis(BNBinaryView* view) { __debugbreak(); return {}; } 17 | BINARYNINJACOREAPI void BNSetAnalysisHold(BNBinaryView* view, bool enable) { __debugbreak(); } 18 | BINARYNINJACOREAPI void BNUpdateAnalysisAndWait(BNBinaryView* view) { __debugbreak(); } 19 | BINARYNINJACOREAPI void BNUpdateAnalysis(BNBinaryView* view) { __debugbreak(); } 20 | BINARYNINJACOREAPI void BNAbortAnalysis(BNBinaryView* view) { __debugbreak(); } 21 | BINARYNINJACOREAPI bool BNIsFunctionUpdateNeeded(BNFunction* func) { __debugbreak(); return {}; } 22 | BINARYNINJACOREAPI void BNRequestAdvancedFunctionAnalysisData(BNFunction* func) { __debugbreak(); } 23 | BINARYNINJACOREAPI void BNReleaseAdvancedFunctionAnalysisData(BNFunction* func) { __debugbreak(); } 24 | BINARYNINJACOREAPI void BNReleaseAdvancedFunctionAnalysisDataMultiple(BNFunction* func, size_t count) { __debugbreak(); } 25 | 26 | BINARYNINJACOREAPI BNFunction* BNNewFunctionReference(BNFunction* func) 27 | { 28 | return BNRef::Add(func); 29 | } 30 | BINARYNINJACOREAPI void BNFreeFunction(BNFunction* func) 31 | { 32 | BNRef::Release(func); 33 | } 34 | BINARYNINJACOREAPI BNFunction** BNGetAnalysisFunctionList(BNBinaryView* view, size_t* count) { __debugbreak(); return {}; } 35 | BINARYNINJACOREAPI void BNFreeFunctionList(BNFunction** funcs, size_t count) { __debugbreak(); } 36 | BINARYNINJACOREAPI bool BNHasFunctions(BNBinaryView* view) { __debugbreak(); return {}; } 37 | BINARYNINJACOREAPI bool BNHasSymbols(BNBinaryView* view) { __debugbreak(); return {}; } 38 | BINARYNINJACOREAPI bool BNHasDataVariables(BNBinaryView* view) { __debugbreak(); return {}; } 39 | BINARYNINJACOREAPI BNFunction* BNGetAnalysisFunction(BNBinaryView* view, BNPlatform* platform, uint64_t addr) { __debugbreak(); return {}; } 40 | BINARYNINJACOREAPI BNFunction* BNGetRecentAnalysisFunctionForAddress(BNBinaryView* view, uint64_t addr) { __debugbreak(); return {}; } 41 | BINARYNINJACOREAPI BNFunction** BNGetAnalysisFunctionsForAddress(BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 42 | BINARYNINJACOREAPI BNFunction** BNGetAnalysisFunctionsContainingAddress( 43 | BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 44 | BINARYNINJACOREAPI BNFunction* BNGetAnalysisEntryPoint(BNBinaryView* view) { __debugbreak(); return {}; } 45 | BINARYNINJACOREAPI BNFunction** BNGetAllEntryFunctions(BNBinaryView* view, size_t* count) { __debugbreak(); return {}; } 46 | BINARYNINJACOREAPI void BNAddToEntryFunctions(BNBinaryView* view, BNFunction* func) { __debugbreak(); } 47 | 48 | BINARYNINJACOREAPI char* BNGetGlobalCommentForAddress(BNBinaryView* view, uint64_t addr) { __debugbreak(); return {}; } 49 | BINARYNINJACOREAPI uint64_t* BNGetGlobalCommentedAddresses(BNBinaryView* view, size_t* count) { __debugbreak(); return {}; } 50 | BINARYNINJACOREAPI void BNSetGlobalCommentForAddress(BNBinaryView* view, uint64_t addr, const char* comment) { __debugbreak(); } 51 | 52 | BINARYNINJACOREAPI BNBinaryView* BNGetFunctionData(BNFunction* func) { __debugbreak(); return {}; } 53 | BINARYNINJACOREAPI BNArchitecture* BNGetFunctionArchitecture(BNFunction* func) 54 | { 55 | func->mArch->AddRef(); // TODO: correct? 56 | return func->mArch; 57 | } 58 | BINARYNINJACOREAPI BNPlatform* BNGetFunctionPlatform(BNFunction* func) { __debugbreak(); return {}; } 59 | BINARYNINJACOREAPI uint64_t BNGetFunctionStart(BNFunction* func) 60 | { 61 | return func->mStart; 62 | } 63 | BINARYNINJACOREAPI BNSymbol* BNGetFunctionSymbol(BNFunction* func) { __debugbreak(); return {}; } 64 | BINARYNINJACOREAPI bool BNWasFunctionAutomaticallyDiscovered(BNFunction* func) { __debugbreak(); return {}; } 65 | BINARYNINJACOREAPI bool BNFunctionHasUserAnnotations(BNFunction* func) { __debugbreak(); return {}; } 66 | BINARYNINJACOREAPI BNBoolWithConfidence BNCanFunctionReturn(BNFunction* func) { __debugbreak(); return {}; } 67 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsFunctionPure(BNFunction* func) { __debugbreak(); return {}; } 68 | BINARYNINJACOREAPI void BNSetFunctionAutoType(BNFunction* func, BNType* type) { __debugbreak(); } 69 | BINARYNINJACOREAPI void BNSetFunctionUserType(BNFunction* func, BNType* type) { __debugbreak(); } 70 | BINARYNINJACOREAPI bool BNFunctionHasUserType(BNFunction* func) { __debugbreak(); return {}; } 71 | 72 | BINARYNINJACOREAPI char* BNGetFunctionComment(BNFunction* func) { __debugbreak(); return {}; } 73 | BINARYNINJACOREAPI char* BNGetCommentForAddress(BNFunction* func, uint64_t addr) { __debugbreak(); return {}; } 74 | BINARYNINJACOREAPI uint64_t* BNGetCommentedAddresses(BNFunction* func, size_t* count) { __debugbreak(); return {}; } 75 | BINARYNINJACOREAPI void BNFreeAddressList(uint64_t* addrs) { __debugbreak(); } 76 | BINARYNINJACOREAPI void BNSetFunctionComment(BNFunction* func, const char* comment) { __debugbreak(); } 77 | BINARYNINJACOREAPI void BNSetCommentForAddress(BNFunction* func, uint64_t addr, const char* comment) { __debugbreak(); } 78 | 79 | BINARYNINJACOREAPI void BNAddUserCodeReference( 80 | BNFunction* func, BNArchitecture* fromArch, uint64_t fromAddr, uint64_t toAddr) { __debugbreak(); } 81 | BINARYNINJACOREAPI void BNRemoveUserCodeReference( 82 | BNFunction* func, BNArchitecture* fromArch, uint64_t fromAddr, uint64_t toAddr) { __debugbreak(); } 83 | 84 | BINARYNINJACOREAPI void BNAddUserTypeReference( 85 | BNFunction* func, BNArchitecture* fromArch, uint64_t fromAddr, BNQualifiedName* name) { __debugbreak(); } 86 | BINARYNINJACOREAPI void BNRemoveUserTypeReference( 87 | BNFunction* func, BNArchitecture* fromArch, uint64_t fromAddr, BNQualifiedName* name) { __debugbreak(); } 88 | BINARYNINJACOREAPI void BNAddUserTypeFieldReference( 89 | BNFunction* func, BNArchitecture* fromArch, uint64_t fromAddr, BNQualifiedName* name, uint64_t offset, size_t size) { __debugbreak(); } 90 | BINARYNINJACOREAPI void BNRemoveUserTypeFieldReference( 91 | BNFunction* func, BNArchitecture* fromArch, uint64_t fromAddr, BNQualifiedName* name, uint64_t offset, size_t size) { __debugbreak(); } 92 | 93 | BINARYNINJACOREAPI BNBasicBlock* BNNewBasicBlockReference(BNBasicBlock* block) 94 | { 95 | return BNRef::Add(block); 96 | } 97 | BINARYNINJACOREAPI void BNFreeBasicBlock(BNBasicBlock* block) 98 | { 99 | BNRef::Release(block); 100 | } 101 | BINARYNINJACOREAPI BNBasicBlock** BNGetFunctionBasicBlockList(BNFunction* func, size_t* count) { __debugbreak(); return {}; } 102 | BINARYNINJACOREAPI void BNFreeBasicBlockList(BNBasicBlock** blocks, size_t count) 103 | { 104 | // TODO: use count somehow? 105 | delete[] blocks; 106 | } 107 | BINARYNINJACOREAPI BNBasicBlock* BNGetFunctionBasicBlockAtAddress( 108 | BNFunction* func, BNArchitecture* arch, uint64_t addr) { __debugbreak(); return {}; } 109 | BINARYNINJACOREAPI BNBasicBlock* BNGetRecentBasicBlockForAddress(BNBinaryView* view, uint64_t addr) { __debugbreak(); return {}; } 110 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlocksForAddress(BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 111 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlocksStartingAtAddress(BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 112 | 113 | BINARYNINJACOREAPI uint64_t BNGetFunctionHighestAddress(BNFunction* func) { __debugbreak(); return {}; } 114 | BINARYNINJACOREAPI uint64_t BNGetFunctionLowestAddress(BNFunction* func) { __debugbreak(); return {}; } 115 | BINARYNINJACOREAPI BNAddressRange* BNGetFunctionAddressRanges(BNFunction* func, size_t* count) { __debugbreak(); return {}; } 116 | 117 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetFunctionLowLevelIL(BNFunction* func) { __debugbreak(); return {}; } 118 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetFunctionLowLevelILIfAvailable(BNFunction* func) { __debugbreak(); return {}; } 119 | BINARYNINJACOREAPI size_t BNGetLowLevelILForInstruction(BNFunction* func, BNArchitecture* arch, uint64_t addr) { __debugbreak(); return {}; } 120 | BINARYNINJACOREAPI size_t* BNGetLowLevelILInstructionsForAddress( 121 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 122 | BINARYNINJACOREAPI size_t* BNGetLowLevelILExitsForInstruction( 123 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 124 | BINARYNINJACOREAPI void BNFreeILInstructionList(size_t* list) { __debugbreak(); } 125 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetFunctionMediumLevelIL(BNFunction* func) { __debugbreak(); return {}; } 126 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetFunctionMediumLevelILIfAvailable(BNFunction* func) { __debugbreak(); return {}; } 127 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetFunctionMappedMediumLevelIL(BNFunction* func) { __debugbreak(); return {}; } 128 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetFunctionMappedMediumLevelILIfAvailable(BNFunction* func) { __debugbreak(); return {}; } 129 | BINARYNINJACOREAPI BNHighLevelILFunction* BNGetFunctionHighLevelIL(BNFunction* func) { __debugbreak(); return {}; } 130 | BINARYNINJACOREAPI BNHighLevelILFunction* BNGetFunctionHighLevelILIfAvailable(BNFunction* func) { __debugbreak(); return {}; } 131 | BINARYNINJACOREAPI BNLanguageRepresentationFunction* BNGetFunctionLanguageRepresentation(BNFunction* func) { __debugbreak(); return {}; } 132 | BINARYNINJACOREAPI BNLanguageRepresentationFunction* BNGetFunctionLanguageRepresentationIfAvailable(BNFunction* func) { __debugbreak(); return {}; } 133 | 134 | BINARYNINJACOREAPI BNDataBuffer* BNGetConstantData( 135 | BNFunction* func, BNRegisterValueType state, uint64_t value, size_t size) { __debugbreak(); return {}; } 136 | 137 | BINARYNINJACOREAPI BNRegisterValue BNGetRegisterValueAtInstruction( 138 | BNFunction* func, BNArchitecture* arch, uint64_t addr, uint32_t reg) { __debugbreak(); return {}; } 139 | BINARYNINJACOREAPI BNRegisterValue BNGetRegisterValueAfterInstruction( 140 | BNFunction* func, BNArchitecture* arch, uint64_t addr, uint32_t reg) { __debugbreak(); return {}; } 141 | BINARYNINJACOREAPI BNRegisterValue BNGetStackContentsAtInstruction( 142 | BNFunction* func, BNArchitecture* arch, uint64_t addr, int64_t offset, size_t size) { __debugbreak(); return {}; } 143 | BINARYNINJACOREAPI BNRegisterValue BNGetStackContentsAfterInstruction( 144 | BNFunction* func, BNArchitecture* arch, uint64_t addr, int64_t offset, size_t size) { __debugbreak(); return {}; } 145 | BINARYNINJACOREAPI BNRegisterValue BNGetParameterValueAtInstruction( 146 | BNFunction* func, BNArchitecture* arch, uint64_t addr, BNType* functionType, size_t i) { __debugbreak(); return {}; } 147 | BINARYNINJACOREAPI BNRegisterValue BNGetParameterValueAtLowLevelILInstruction( 148 | BNFunction* func, size_t instr, BNType* functionType, size_t i) { __debugbreak(); return {}; } 149 | BINARYNINJACOREAPI void BNFreePossibleValueSet(BNPossibleValueSet* value) { __debugbreak(); } 150 | BINARYNINJACOREAPI uint32_t* BNGetRegistersReadByInstruction( 151 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 152 | BINARYNINJACOREAPI uint32_t* BNGetRegistersWrittenByInstruction( 153 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 154 | BINARYNINJACOREAPI BNStackVariableReference* BNGetStackVariablesReferencedByInstruction( 155 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 156 | BINARYNINJACOREAPI BNStackVariableReference* BNGetStackVariablesReferencedByInstructionIfAvailable( 157 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 158 | BINARYNINJACOREAPI void BNFreeStackVariableReferenceList(BNStackVariableReference* refs, size_t count) { __debugbreak(); } 159 | BINARYNINJACOREAPI BNConstantReference* BNGetConstantsReferencedByInstruction( 160 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 161 | BINARYNINJACOREAPI BNConstantReference* BNGetConstantsReferencedByInstructionIfAvailable( 162 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 163 | BINARYNINJACOREAPI void BNFreeConstantReferenceList(BNConstantReference* refs) { __debugbreak(); } 164 | 165 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetFunctionLiftedIL(BNFunction* func) { __debugbreak(); return {}; } 166 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetFunctionLiftedILIfAvailable(BNFunction* func) { __debugbreak(); return {}; } 167 | BINARYNINJACOREAPI size_t BNGetLiftedILForInstruction(BNFunction* func, BNArchitecture* arch, uint64_t addr) { __debugbreak(); return {}; } 168 | BINARYNINJACOREAPI size_t* BNGetLiftedILInstructionsForAddress( 169 | BNFunction* func, BNArchitecture* arch, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 170 | BINARYNINJACOREAPI size_t* BNGetLiftedILFlagUsesForDefinition(BNFunction* func, size_t i, uint32_t flag, size_t* count) { __debugbreak(); return {}; } 171 | BINARYNINJACOREAPI size_t* BNGetLiftedILFlagDefinitionsForUse(BNFunction* func, size_t i, uint32_t flag, size_t* count) { __debugbreak(); return {}; } 172 | BINARYNINJACOREAPI uint32_t* BNGetFlagsReadByLiftedILInstruction(BNFunction* func, size_t i, size_t* count) { __debugbreak(); return {}; } 173 | BINARYNINJACOREAPI uint32_t* BNGetFlagsWrittenByLiftedILInstruction(BNFunction* func, size_t i, size_t* count) { __debugbreak(); return {}; } 174 | 175 | BINARYNINJACOREAPI BNType* BNGetFunctionType(BNFunction* func) { __debugbreak(); return {}; } 176 | BINARYNINJACOREAPI BNTypeWithConfidence BNGetFunctionReturnType(BNFunction* func) { __debugbreak(); return {}; } 177 | BINARYNINJACOREAPI BNRegisterSetWithConfidence BNGetFunctionReturnRegisters(BNFunction* func) { __debugbreak(); return {}; } 178 | BINARYNINJACOREAPI BNCallingConventionWithConfidence BNGetFunctionCallingConvention(BNFunction* func) { __debugbreak(); return {}; } 179 | BINARYNINJACOREAPI BNParameterVariablesWithConfidence BNGetFunctionParameterVariables(BNFunction* func) { __debugbreak(); return {}; } 180 | BINARYNINJACOREAPI void BNFreeParameterVariables(BNParameterVariablesWithConfidence* vars) { __debugbreak(); } 181 | BINARYNINJACOREAPI BNBoolWithConfidence BNFunctionHasVariableArguments(BNFunction* func) { __debugbreak(); return {}; } 182 | BINARYNINJACOREAPI BNOffsetWithConfidence BNGetFunctionStackAdjustment(BNFunction* func) { __debugbreak(); return {}; } 183 | BINARYNINJACOREAPI BNRegisterStackAdjustment* BNGetFunctionRegisterStackAdjustments(BNFunction* func, size_t* count) { __debugbreak(); return {}; } 184 | BINARYNINJACOREAPI void BNFreeRegisterStackAdjustments(BNRegisterStackAdjustment* adjustments) { __debugbreak(); } 185 | BINARYNINJACOREAPI BNRegisterSetWithConfidence BNGetFunctionClobberedRegisters(BNFunction* func) { __debugbreak(); return {}; } 186 | BINARYNINJACOREAPI void BNFreeRegisterSet(BNRegisterSetWithConfidence* regs) { __debugbreak(); } 187 | 188 | BINARYNINJACOREAPI void BNSetAutoFunctionReturnType(BNFunction* func, BNTypeWithConfidence* type) { __debugbreak(); } 189 | BINARYNINJACOREAPI void BNSetAutoFunctionReturnRegisters(BNFunction* func, BNRegisterSetWithConfidence* regs) { __debugbreak(); } 190 | BINARYNINJACOREAPI void BNSetAutoFunctionCallingConvention( 191 | BNFunction* func, BNCallingConventionWithConfidence* convention) { __debugbreak(); } 192 | BINARYNINJACOREAPI void BNSetAutoFunctionParameterVariables(BNFunction* func, BNParameterVariablesWithConfidence* vars) { __debugbreak(); } 193 | BINARYNINJACOREAPI void BNSetAutoFunctionHasVariableArguments(BNFunction* func, BNBoolWithConfidence* varArgs) { __debugbreak(); } 194 | BINARYNINJACOREAPI void BNSetAutoFunctionCanReturn(BNFunction* func, BNBoolWithConfidence* returns) { __debugbreak(); } 195 | BINARYNINJACOREAPI void BNSetAutoFunctionPure(BNFunction* func, BNBoolWithConfidence* pure) { __debugbreak(); } 196 | BINARYNINJACOREAPI void BNSetAutoFunctionStackAdjustment(BNFunction* func, BNOffsetWithConfidence* stackAdjust) { __debugbreak(); } 197 | BINARYNINJACOREAPI void BNSetAutoFunctionRegisterStackAdjustments( 198 | BNFunction* func, BNRegisterStackAdjustment* adjustments, size_t count) { __debugbreak(); } 199 | BINARYNINJACOREAPI void BNSetAutoFunctionClobberedRegisters(BNFunction* func, BNRegisterSetWithConfidence* regs) { __debugbreak(); } 200 | 201 | BINARYNINJACOREAPI void BNSetUserFunctionReturnType(BNFunction* func, BNTypeWithConfidence* type) { __debugbreak(); } 202 | BINARYNINJACOREAPI void BNSetUserFunctionReturnRegisters(BNFunction* func, BNRegisterSetWithConfidence* regs) { __debugbreak(); } 203 | BINARYNINJACOREAPI void BNSetUserFunctionCallingConvention( 204 | BNFunction* func, BNCallingConventionWithConfidence* convention) { __debugbreak(); } 205 | BINARYNINJACOREAPI void BNSetUserFunctionParameterVariables(BNFunction* func, BNParameterVariablesWithConfidence* vars) { __debugbreak(); } 206 | BINARYNINJACOREAPI void BNSetUserFunctionHasVariableArguments(BNFunction* func, BNBoolWithConfidence* varArgs) { __debugbreak(); } 207 | BINARYNINJACOREAPI void BNSetUserFunctionCanReturn(BNFunction* func, BNBoolWithConfidence* returns) { __debugbreak(); } 208 | BINARYNINJACOREAPI void BNSetUserFunctionPure(BNFunction* func, BNBoolWithConfidence* pure) { __debugbreak(); } 209 | BINARYNINJACOREAPI void BNSetUserFunctionStackAdjustment(BNFunction* func, BNOffsetWithConfidence* stackAdjust) { __debugbreak(); } 210 | BINARYNINJACOREAPI void BNSetUserFunctionRegisterStackAdjustments( 211 | BNFunction* func, BNRegisterStackAdjustment* adjustments, size_t count) { __debugbreak(); } 212 | BINARYNINJACOREAPI void BNSetUserFunctionClobberedRegisters(BNFunction* func, BNRegisterSetWithConfidence* regs) { __debugbreak(); } 213 | 214 | BINARYNINJACOREAPI void BNApplyImportedTypes(BNFunction* func, BNSymbol* sym, BNType* type) { __debugbreak(); } 215 | BINARYNINJACOREAPI void BNApplyAutoDiscoveredFunctionType(BNFunction* func, BNType* type) { __debugbreak(); } 216 | BINARYNINJACOREAPI bool BNFunctionHasExplicitlyDefinedType(BNFunction* func) { __debugbreak(); return {}; } 217 | 218 | BINARYNINJACOREAPI BNDisassemblyTextLine* BNGetFunctionTypeTokens( 219 | BNFunction* func, BNDisassemblySettings* settings, size_t* count) { __debugbreak(); return {}; } 220 | 221 | BINARYNINJACOREAPI BNRegisterValueWithConfidence BNGetFunctionGlobalPointerValue(BNFunction* func) { __debugbreak(); return {}; } 222 | BINARYNINJACOREAPI bool BNFunctionUsesIncomingGlobalPointer(BNFunction* func) { __debugbreak(); return {}; } 223 | BINARYNINJACOREAPI BNRegisterValueWithConfidence BNGetFunctionRegisterValueAtExit(BNFunction* func, uint32_t reg) { __debugbreak(); return {}; } 224 | 225 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsFunctionInlinedDuringAnalysis(BNFunction* func) { __debugbreak(); return {}; } 226 | BINARYNINJACOREAPI void BNSetAutoFunctionInlinedDuringAnalysis(BNFunction* func, BNBoolWithConfidence inlined) { __debugbreak(); } 227 | BINARYNINJACOREAPI void BNSetUserFunctionInlinedDuringAnalysis(BNFunction* func, BNBoolWithConfidence inlined) { __debugbreak(); } 228 | 229 | BINARYNINJACOREAPI bool BNGetInstructionContainingAddress( 230 | BNFunction* func, BNArchitecture* arch, uint64_t addr, uint64_t* start) { __debugbreak(); return {}; } 231 | 232 | BINARYNINJACOREAPI BNFunction* BNGetBasicBlockFunction(BNBasicBlock* block) { __debugbreak(); return {}; } 233 | BINARYNINJACOREAPI BNArchitecture* BNGetBasicBlockArchitecture(BNBasicBlock* block) { __debugbreak(); return {}; } 234 | BINARYNINJACOREAPI BNBasicBlock* BNGetBasicBlockSource(BNBasicBlock* block) { __debugbreak(); return {}; } 235 | BINARYNINJACOREAPI uint64_t BNGetBasicBlockStart(BNBasicBlock* block) 236 | { 237 | return block->start; 238 | } 239 | BINARYNINJACOREAPI uint64_t BNGetBasicBlockEnd(BNBasicBlock* block) 240 | { 241 | return block->end; 242 | } 243 | BINARYNINJACOREAPI uint64_t BNGetBasicBlockLength(BNBasicBlock* block) { __debugbreak(); return {}; } 244 | BINARYNINJACOREAPI BNBasicBlockEdge* BNGetBasicBlockOutgoingEdges(BNBasicBlock* block, size_t* count) { __debugbreak(); return {}; } 245 | BINARYNINJACOREAPI BNBasicBlockEdge* BNGetBasicBlockIncomingEdges(BNBasicBlock* block, size_t* count) { __debugbreak(); return {}; } 246 | BINARYNINJACOREAPI void BNFreeBasicBlockEdgeList(BNBasicBlockEdge* edges, size_t count) { __debugbreak(); } 247 | BINARYNINJACOREAPI bool BNBasicBlockHasUndeterminedOutgoingEdges(BNBasicBlock* block) { __debugbreak(); return {}; } 248 | BINARYNINJACOREAPI bool BNBasicBlockCanExit(BNBasicBlock* block) { __debugbreak(); return {}; } 249 | BINARYNINJACOREAPI void BNBasicBlockSetCanExit(BNBasicBlock* block, bool value) { __debugbreak(); } 250 | BINARYNINJACOREAPI bool BNBasicBlockHasInvalidInstructions(BNBasicBlock* block) { __debugbreak(); return {}; } 251 | BINARYNINJACOREAPI size_t BNGetBasicBlockIndex(BNBasicBlock* block) { __debugbreak(); return {}; } 252 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlockDominators(BNBasicBlock* block, size_t* count, bool post) { __debugbreak(); return {}; } 253 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlockStrictDominators(BNBasicBlock* block, size_t* count, bool post) { __debugbreak(); return {}; } 254 | BINARYNINJACOREAPI BNBasicBlock* BNGetBasicBlockImmediateDominator(BNBasicBlock* block, bool post) { __debugbreak(); return {}; } 255 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlockDominatorTreeChildren(BNBasicBlock* block, size_t* count, bool post) { __debugbreak(); return {}; } 256 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlockDominanceFrontier(BNBasicBlock* block, size_t* count, bool post) { __debugbreak(); return {}; } 257 | BINARYNINJACOREAPI BNBasicBlock** BNGetBasicBlockIteratedDominanceFrontier( 258 | BNBasicBlock** blocks, size_t incomingCount, size_t* outputCount) { __debugbreak(); return {}; } 259 | BINARYNINJACOREAPI bool BNIsILBasicBlock(BNBasicBlock* block) 260 | { 261 | return block->type != BNBasicBlock::Type::Disassembly; 262 | } 263 | BINARYNINJACOREAPI bool BNIsLowLevelILBasicBlock(BNBasicBlock* block) 264 | { 265 | return block->type == BNBasicBlock::Type::LLIL; 266 | } 267 | BINARYNINJACOREAPI bool BNIsMediumLevelILBasicBlock(BNBasicBlock* block) 268 | { 269 | return block->type == BNBasicBlock::Type::MLIL; 270 | } 271 | BINARYNINJACOREAPI bool BNIsHighLevelILBasicBlock(BNBasicBlock* block) 272 | { 273 | return block->type == BNBasicBlock::Type::HLIL; 274 | } 275 | BINARYNINJACOREAPI BNFunctionGraphType BNGetBasicBlockFunctionGraphType(BNBasicBlock* block) { __debugbreak(); return {}; } 276 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetBasicBlockLowLevelILFunction(BNBasicBlock* block) { __debugbreak(); return {}; } 277 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetBasicBlockMediumLevelILFunction(BNBasicBlock* block) { __debugbreak(); return {}; } 278 | BINARYNINJACOREAPI BNHighLevelILFunction* BNGetBasicBlockHighLevelILFunction(BNBasicBlock* block) { __debugbreak(); return {}; } 279 | BINARYNINJACOREAPI bool BNGetBasicBlockInstructionContainingAddress( 280 | BNBasicBlock* block, uint64_t addr, uint64_t* start) { __debugbreak(); return {}; } 281 | BINARYNINJACOREAPI BNBasicBlock* BNGetBasicBlockSourceBlock(BNBasicBlock* block) { __debugbreak(); return {}; } 282 | 283 | BINARYNINJACOREAPI BNDisassemblyTextLine* BNGetBasicBlockDisassemblyText( 284 | BNBasicBlock* block, BNDisassemblySettings* settings, size_t* count) { __debugbreak(); return {}; } 285 | BINARYNINJACOREAPI void BNFreeDisassemblyTextLines(BNDisassemblyTextLine* lines, size_t count) { __debugbreak(); } 286 | 287 | BINARYNINJACOREAPI char* BNGetDisplayStringForInteger( 288 | BNBinaryView* binaryView, BNIntegerDisplayType type, uint64_t value, size_t inputWidth, bool isSigned) { __debugbreak(); return {}; } 289 | BINARYNINJACOREAPI BNDisassemblyTextRenderer* BNCreateDisassemblyTextRenderer( 290 | BNFunction* func, BNDisassemblySettings* settings) { __debugbreak(); return {}; } 291 | BINARYNINJACOREAPI BNDisassemblyTextRenderer* BNCreateLowLevelILDisassemblyTextRenderer( 292 | BNLowLevelILFunction* func, BNDisassemblySettings* settings) { __debugbreak(); return {}; } 293 | BINARYNINJACOREAPI BNDisassemblyTextRenderer* BNCreateMediumLevelILDisassemblyTextRenderer( 294 | BNMediumLevelILFunction* func, BNDisassemblySettings* settings) { __debugbreak(); return {}; } 295 | BINARYNINJACOREAPI BNDisassemblyTextRenderer* BNCreateHighLevelILDisassemblyTextRenderer( 296 | BNHighLevelILFunction* func, BNDisassemblySettings* settings) { __debugbreak(); return {}; } 297 | BINARYNINJACOREAPI BNDisassemblyTextRenderer* BNNewDisassemblyTextRendererReference( 298 | BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 299 | BINARYNINJACOREAPI void BNFreeDisassemblyTextRenderer(BNDisassemblyTextRenderer* renderer) { __debugbreak(); } 300 | BINARYNINJACOREAPI BNFunction* BNGetDisassemblyTextRendererFunction(BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 301 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetDisassemblyTextRendererLowLevelILFunction( 302 | BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 303 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetDisassemblyTextRendererMediumLevelILFunction( 304 | BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 305 | BINARYNINJACOREAPI BNHighLevelILFunction* BNGetDisassemblyTextRendererHighLevelILFunction( 306 | BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 307 | BINARYNINJACOREAPI BNBasicBlock* BNGetDisassemblyTextRendererBasicBlock(BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 308 | BINARYNINJACOREAPI BNArchitecture* BNGetDisassemblyTextRendererArchitecture(BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 309 | BINARYNINJACOREAPI BNDisassemblySettings* BNGetDisassemblyTextRendererSettings(BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 310 | BINARYNINJACOREAPI void BNSetDisassemblyTextRendererBasicBlock( 311 | BNDisassemblyTextRenderer* renderer, BNBasicBlock* block) { __debugbreak(); } 312 | BINARYNINJACOREAPI void BNSetDisassemblyTextRendererArchitecture( 313 | BNDisassemblyTextRenderer* renderer, BNArchitecture* arch) { __debugbreak(); } 314 | BINARYNINJACOREAPI void BNSetDisassemblyTextRendererSettings( 315 | BNDisassemblyTextRenderer* renderer, BNDisassemblySettings* settings) { __debugbreak(); } 316 | BINARYNINJACOREAPI bool BNIsILDisassemblyTextRenderer(BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 317 | BINARYNINJACOREAPI bool BNDisassemblyTextRendererHasDataFlow(BNDisassemblyTextRenderer* renderer) { __debugbreak(); return {}; } 318 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetDisassemblyTextRendererInstructionAnnotations( 319 | BNDisassemblyTextRenderer* renderer, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 320 | BINARYNINJACOREAPI bool BNGetDisassemblyTextRendererInstructionText( 321 | BNDisassemblyTextRenderer* renderer, uint64_t addr, size_t* len, BNDisassemblyTextLine** result, size_t* count) { __debugbreak(); return {}; } 322 | BINARYNINJACOREAPI bool BNGetDisassemblyTextRendererLines( 323 | BNDisassemblyTextRenderer* renderer, uint64_t addr, size_t* len, BNDisassemblyTextLine** result, size_t* count) { __debugbreak(); return {}; } 324 | BINARYNINJACOREAPI BNDisassemblyTextLine* BNPostProcessDisassemblyTextRendererLines(BNDisassemblyTextRenderer* renderer, 325 | uint64_t addr, size_t len, BNDisassemblyTextLine* inLines, size_t inCount, size_t* outCount, 326 | const char* indentSpaces) { __debugbreak(); return {}; } 327 | BINARYNINJACOREAPI void BNResetDisassemblyTextRendererDeduplicatedComments(BNDisassemblyTextRenderer* renderer) { __debugbreak(); } 328 | BINARYNINJACOREAPI bool BNGetDisassemblyTextRendererSymbolTokens(BNDisassemblyTextRenderer* renderer, uint64_t addr, 329 | size_t size, size_t operand, BNInstructionTextToken** result, size_t* count) { __debugbreak(); return {}; } 330 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetDisassemblyTextRendererStackVariableReferenceTokens( 331 | BNDisassemblyTextRenderer* renderer, BNStackVariableReference* ref, size_t* count) { __debugbreak(); return {}; } 332 | BINARYNINJACOREAPI bool BNIsIntegerToken(BNInstructionTextTokenType type) { __debugbreak(); return {}; } 333 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetDisassemblyTextRendererIntegerTokens( 334 | BNDisassemblyTextRenderer* renderer, BNInstructionTextToken* token, BNArchitecture* arch, uint64_t addr, 335 | size_t* count) { __debugbreak(); return {}; } 336 | BINARYNINJACOREAPI BNDisassemblyTextLine* BNDisassemblyTextRendererWrapComment(BNDisassemblyTextRenderer* renderer, 337 | const BNDisassemblyTextLine* inLine, size_t* outLineCount, const char* comment, bool hasAutoAnnotations, 338 | const char* leadingSpaces, const char* indentSpaces) { __debugbreak(); return {}; } 339 | 340 | BINARYNINJACOREAPI void BNMarkFunctionAsRecentlyUsed(BNFunction* func) { __debugbreak(); } 341 | BINARYNINJACOREAPI void BNMarkBasicBlockAsRecentlyUsed(BNBasicBlock* block) { __debugbreak(); } 342 | 343 | BINARYNINJACOREAPI BNReferenceSource* BNGetCodeReferences(BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 344 | BINARYNINJACOREAPI BNReferenceSource* BNGetCodeReferencesInRange( 345 | BNBinaryView* view, uint64_t addr, uint64_t len, size_t* count) { __debugbreak(); return {}; } 346 | BINARYNINJACOREAPI void BNFreeCodeReferences(BNReferenceSource* refs, size_t count) { __debugbreak(); } 347 | BINARYNINJACOREAPI void BNFreeTypeFieldReferences(BNTypeFieldReference* refs, size_t count) { __debugbreak(); } 348 | BINARYNINJACOREAPI void BNFreeILReferences(BNILReferenceSource* refs, size_t count) { __debugbreak(); } 349 | BINARYNINJACOREAPI uint64_t* BNGetCodeReferencesFrom(BNBinaryView* view, BNReferenceSource* src, size_t* count) { __debugbreak(); return {}; } 350 | BINARYNINJACOREAPI uint64_t* BNGetCodeReferencesFromInRange( 351 | BNBinaryView* view, BNReferenceSource* src, uint64_t len, size_t* count) { __debugbreak(); return {}; } 352 | 353 | BINARYNINJACOREAPI uint64_t* BNGetDataReferences(BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 354 | BINARYNINJACOREAPI uint64_t* BNGetDataReferencesInRange(BNBinaryView* view, uint64_t addr, uint64_t len, size_t* count) { __debugbreak(); return {}; } 355 | BINARYNINJACOREAPI uint64_t* BNGetDataReferencesFrom(BNBinaryView* view, uint64_t addr, size_t* count) { __debugbreak(); return {}; } 356 | BINARYNINJACOREAPI uint64_t* BNGetDataReferencesFromInRange( 357 | BNBinaryView* view, uint64_t addr, uint64_t len, size_t* count) { __debugbreak(); return {}; } 358 | BINARYNINJACOREAPI void BNAddUserDataReference(BNBinaryView* view, uint64_t fromAddr, uint64_t toAddr) { __debugbreak(); } 359 | BINARYNINJACOREAPI void BNRemoveUserDataReference(BNBinaryView* view, uint64_t fromAddr, uint64_t toAddr) { __debugbreak(); } 360 | BINARYNINJACOREAPI void BNFreeDataReferences(uint64_t* refs) { __debugbreak(); } 361 | 362 | BINARYNINJACOREAPI void BNFreeTypeReferences(BNTypeReferenceSource* refs, size_t count) { __debugbreak(); } 363 | BINARYNINJACOREAPI void BNFreeTypeFieldReferenceSizeInfo(BNTypeFieldReferenceSizeInfo* refs, size_t count) { __debugbreak(); } 364 | BINARYNINJACOREAPI void BNFreeTypeFieldReferenceTypeInfo(BNTypeFieldReferenceTypeInfo* refs, size_t count) { __debugbreak(); } 365 | BINARYNINJACOREAPI void BNFreeTypeFieldReferenceSizes(size_t* refs, size_t count) { __debugbreak(); } 366 | BINARYNINJACOREAPI void BNFreeTypeFieldReferenceTypes(BNTypeWithConfidence* refs, size_t count) { __debugbreak(); } -------------------------------------------------------------------------------- /src/core_architecture.cpp: -------------------------------------------------------------------------------- 1 | // Architectures 2 | #include "core_impl.h" 3 | 4 | std::map g_architectures; 5 | 6 | static BNArchitecture* firstArch() 7 | { 8 | if (g_architectures.empty()) 9 | __debugbreak(); 10 | return g_architectures.begin()->second; 11 | } 12 | 13 | BINARYNINJACOREAPI BNArchitecture* BNGetArchitectureByName(const char* name) 14 | { 15 | auto it = g_architectures.find(name); 16 | if (it == g_architectures.end()) 17 | return nullptr; 18 | return it->second; 19 | } 20 | BINARYNINJACOREAPI BNArchitecture** BNGetArchitectureList(size_t* count) 21 | { 22 | std::vector archs; 23 | for (auto& pair : g_architectures) 24 | archs.push_back(pair.second); 25 | *count = archs.size(); 26 | auto result = new BNArchitecture * [archs.size()]; 27 | memcpy(result, archs.data(), archs.size() * sizeof(BNArchitecture*)); 28 | return result; 29 | } 30 | BINARYNINJACOREAPI void BNFreeArchitectureList(BNArchitecture** archs) 31 | { 32 | delete[] archs; 33 | } 34 | BINARYNINJACOREAPI BNArchitecture* BNRegisterArchitecture(const char* name, BNCustomArchitecture* arch) 35 | { 36 | auto it = g_architectures.find(name); 37 | if (it == g_architectures.end()) 38 | { 39 | it = g_architectures.emplace(name, new BNArchitecture(*arch)).first; 40 | } 41 | return it->second; 42 | } 43 | BINARYNINJACOREAPI BNArchitecture* BNRegisterArchitectureExtension( 44 | const char* name, BNArchitecture* base, BNCustomArchitecture* arch) 45 | { 46 | // TODO: implement 47 | __debugbreak(); return {}; 48 | } 49 | BINARYNINJACOREAPI void BNAddArchitectureRedirection(BNArchitecture* arch, BNArchitecture* from, BNArchitecture* to) { __debugbreak(); } 50 | BINARYNINJACOREAPI BNArchitecture* BNRegisterArchitectureHook(BNArchitecture* base, BNCustomArchitecture* arch) { __debugbreak(); return {}; } 51 | BINARYNINJACOREAPI void BNFinalizeArchitectureHook(BNArchitecture* base) { __debugbreak(); } 52 | BINARYNINJACOREAPI BNArchitecture* BNGetNativeTypeParserArchitecture(void) { __debugbreak(); return {}; } 53 | 54 | BINARYNINJACOREAPI char* BNGetArchitectureName(BNArchitecture* arch) 55 | { 56 | for (const auto& [name, regArch] : g_architectures) 57 | { 58 | if (regArch == arch) 59 | return BNAllocString(name.c_str()); 60 | } 61 | return nullptr; 62 | } 63 | BINARYNINJACOREAPI BNEndianness BNGetArchitectureEndianness(BNArchitecture* arch) 64 | { 65 | return arch->callbacks.getEndianness(arch->callbacks.context); 66 | } 67 | BINARYNINJACOREAPI size_t BNGetArchitectureAddressSize(BNArchitecture* arch) 68 | { 69 | return arch->callbacks.getAddressSize(arch->callbacks.context); 70 | } 71 | BINARYNINJACOREAPI size_t BNGetArchitectureDefaultIntegerSize(BNArchitecture* arch) 72 | { 73 | return arch->callbacks.getDefaultIntegerSize(arch->callbacks.context); 74 | } 75 | BINARYNINJACOREAPI size_t BNGetArchitectureInstructionAlignment(BNArchitecture* arch) 76 | { 77 | return arch->callbacks.getInstructionAlignment(arch->callbacks.context); 78 | } 79 | BINARYNINJACOREAPI size_t BNGetArchitectureMaxInstructionLength(BNArchitecture* arch) 80 | { 81 | return arch->callbacks.getMaxInstructionLength(arch->callbacks.context); 82 | } 83 | BINARYNINJACOREAPI size_t BNGetArchitectureOpcodeDisplayLength(BNArchitecture* arch) 84 | { 85 | return arch->callbacks.getOpcodeDisplayLength(arch->callbacks.context); 86 | } 87 | BINARYNINJACOREAPI BNArchitecture* BNGetAssociatedArchitectureByAddress(BNArchitecture* arch, uint64_t* addr) 88 | { 89 | return arch->callbacks.getAssociatedArchitectureByAddress(arch->callbacks.context, addr); 90 | } 91 | BINARYNINJACOREAPI bool BNGetInstructionInfo( 92 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t maxLen, BNInstructionInfo* result) 93 | { 94 | return arch->callbacks.getInstructionInfo(arch->callbacks.context, data, addr, maxLen, result); 95 | } 96 | 97 | BINARYNINJACOREAPI bool BNGetInstructionText(BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t* len, 98 | BNInstructionTextToken** result, size_t* count) 99 | { 100 | return arch->callbacks.getInstructionText(arch->callbacks.context, data, addr, len, result, count); 101 | } 102 | BINARYNINJACOREAPI bool BNGetInstructionLowLevelIL( 103 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t* len, BNLowLevelILFunction* il) 104 | { 105 | // TODO: this is a super hack 106 | il->mCurrentAddress = addr; 107 | return arch->callbacks.getInstructionLowLevelIL(arch->callbacks.context, data, addr, len, il); 108 | } 109 | BINARYNINJACOREAPI void BNFreeInstructionText(BNInstructionTextToken* tokens, size_t count) 110 | { 111 | firstArch()->callbacks.freeInstructionText(tokens, count); 112 | } 113 | BINARYNINJACOREAPI void BNFreeInstructionTextLines(BNInstructionTextLine* lines, size_t count) 114 | { 115 | // TODO: implement 116 | __debugbreak(); 117 | } 118 | BINARYNINJACOREAPI char* BNGetArchitectureRegisterName(BNArchitecture* arch, uint32_t reg) 119 | { 120 | return arch->callbacks.getRegisterName(arch->callbacks.context, reg); 121 | } 122 | BINARYNINJACOREAPI char* BNGetArchitectureFlagName(BNArchitecture* arch, uint32_t flag) 123 | { 124 | return arch->callbacks.getFlagName(arch->callbacks.context, flag); 125 | } 126 | BINARYNINJACOREAPI char* BNGetArchitectureFlagWriteTypeName(BNArchitecture* arch, uint32_t flags) 127 | { 128 | return arch->callbacks.getFlagWriteTypeName(arch->callbacks.context, flags); 129 | } 130 | BINARYNINJACOREAPI char* BNGetArchitectureSemanticFlagClassName(BNArchitecture* arch, uint32_t semClass) 131 | { 132 | return arch->callbacks.getSemanticFlagClassName(arch->callbacks.context, semClass); 133 | } 134 | BINARYNINJACOREAPI char* BNGetArchitectureSemanticFlagGroupName(BNArchitecture* arch, uint32_t semGroup) 135 | { 136 | return arch->callbacks.getSemanticFlagGroupName(arch->callbacks.context, semGroup); 137 | } 138 | BINARYNINJACOREAPI uint32_t* BNGetFullWidthArchitectureRegisters(BNArchitecture* arch, size_t* count) 139 | { 140 | return arch->callbacks.getFullWidthRegisters(arch->callbacks.context, count); 141 | } 142 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureRegisters(BNArchitecture* arch, size_t* count) 143 | { 144 | return arch->callbacks.getAllRegisters(arch->callbacks.context, count); 145 | } 146 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureFlags(BNArchitecture* arch, size_t* count) 147 | { 148 | return arch->callbacks.getAllFlags(arch->callbacks.context, count); 149 | } 150 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureFlagWriteTypes(BNArchitecture* arch, size_t* count) 151 | { 152 | return arch->callbacks.getAllFlagWriteTypes(arch->callbacks.context, count); 153 | } 154 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureSemanticFlagClasses(BNArchitecture* arch, size_t* count) 155 | { 156 | return arch->callbacks.getAllSemanticFlagClasses(arch->callbacks.context, count); 157 | } 158 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureSemanticFlagGroups(BNArchitecture* arch, size_t* count) 159 | { 160 | return arch->callbacks.getAllSemanticFlagGroups(arch->callbacks.context, count); 161 | } 162 | BINARYNINJACOREAPI BNFlagRole BNGetArchitectureFlagRole(BNArchitecture* arch, uint32_t flag, uint32_t semClass) 163 | { 164 | return arch->callbacks.getFlagRole(arch->callbacks.context, flag, semClass); 165 | } 166 | BINARYNINJACOREAPI uint32_t* BNGetArchitectureFlagsRequiredForFlagCondition( 167 | BNArchitecture* arch, BNLowLevelILFlagCondition cond, uint32_t semClass, size_t* count) 168 | { 169 | return arch->callbacks.getFlagsRequiredForFlagCondition(arch->callbacks.context, cond, semClass, count); 170 | } 171 | BINARYNINJACOREAPI uint32_t* BNGetArchitectureFlagsRequiredForSemanticFlagGroup( 172 | BNArchitecture* arch, uint32_t semGroup, size_t* count) 173 | { 174 | return arch->callbacks.getFlagsRequiredForSemanticFlagGroup(arch->callbacks.context, semGroup, count); 175 | } 176 | BINARYNINJACOREAPI BNFlagConditionForSemanticClass* BNGetArchitectureFlagConditionsForSemanticFlagGroup( 177 | BNArchitecture* arch, uint32_t semGroup, size_t* count) 178 | { 179 | return arch->callbacks.getFlagConditionsForSemanticFlagGroup(arch->callbacks.context, semGroup, count); 180 | } 181 | BINARYNINJACOREAPI void BNFreeFlagConditionsForSemanticFlagGroup(BNFlagConditionForSemanticClass* conditions) 182 | { 183 | auto arch = firstArch(); 184 | arch->callbacks.freeFlagConditionsForSemanticFlagGroup(arch->callbacks.context, conditions); 185 | } 186 | BINARYNINJACOREAPI uint32_t* BNGetArchitectureFlagsWrittenByFlagWriteType( 187 | BNArchitecture* arch, uint32_t writeType, size_t* count) 188 | { 189 | return arch->callbacks.getFlagsWrittenByFlagWriteType(arch->callbacks.context, writeType, count); 190 | } 191 | BINARYNINJACOREAPI uint32_t BNGetArchitectureSemanticClassForFlagWriteType(BNArchitecture* arch, uint32_t writeType) 192 | { 193 | return arch->callbacks.getSemanticClassForFlagWriteType(arch->callbacks.context, writeType); 194 | } 195 | BINARYNINJACOREAPI size_t BNGetArchitectureFlagWriteLowLevelIL(BNArchitecture* arch, BNLowLevelILOperation op, 196 | size_t size, uint32_t flagWriteType, uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, 197 | BNLowLevelILFunction* il) 198 | { 199 | return arch->callbacks.getFlagWriteLowLevelIL(arch->callbacks.context, op, size, flagWriteType, flag, operands, operandCount, il); 200 | } 201 | BINARYNINJACOREAPI size_t BNGetDefaultArchitectureFlagWriteLowLevelIL(BNArchitecture* arch, BNLowLevelILOperation op, 202 | size_t size, BNFlagRole role, BNRegisterOrConstant* operands, size_t operandCount, BNLowLevelILFunction* il) 203 | { 204 | // TODO: implement 205 | __debugbreak(); return {}; 206 | } 207 | BINARYNINJACOREAPI size_t BNGetArchitectureFlagConditionLowLevelIL( 208 | BNArchitecture* arch, BNLowLevelILFlagCondition cond, uint32_t semClass, BNLowLevelILFunction* il) 209 | { 210 | return arch->callbacks.getFlagConditionLowLevelIL(arch->callbacks.context, cond, semClass, il); 211 | } 212 | BINARYNINJACOREAPI size_t BNGetDefaultArchitectureFlagConditionLowLevelIL( 213 | BNArchitecture* arch, BNLowLevelILFlagCondition cond, uint32_t semClass, BNLowLevelILFunction* il) 214 | { 215 | // TODO: implement 216 | __debugbreak(); return {}; 217 | } 218 | BINARYNINJACOREAPI size_t BNGetArchitectureSemanticFlagGroupLowLevelIL( 219 | BNArchitecture* arch, uint32_t semGroup, BNLowLevelILFunction* il) 220 | { 221 | return arch->callbacks.getSemanticFlagGroupLowLevelIL(arch->callbacks.context, semGroup, il); 222 | } 223 | BINARYNINJACOREAPI uint32_t* BNGetModifiedArchitectureRegistersOnWrite( 224 | BNArchitecture* arch, uint32_t reg, size_t* count) 225 | { 226 | // TODO: implement 227 | __debugbreak(); return {}; 228 | } 229 | BINARYNINJACOREAPI void BNFreeRegisterList(uint32_t* regs) 230 | { 231 | auto arch = firstArch(); 232 | arch->callbacks.freeRegisterList(arch->callbacks.context, regs); 233 | } 234 | BINARYNINJACOREAPI BNRegisterInfo BNGetArchitectureRegisterInfo(BNArchitecture* arch, uint32_t reg) 235 | { 236 | BNRegisterInfo info; 237 | arch->callbacks.getRegisterInfo(arch->callbacks.context, reg, &info); 238 | return info; 239 | } 240 | BINARYNINJACOREAPI uint32_t BNGetArchitectureStackPointerRegister(BNArchitecture* arch) 241 | { 242 | return arch->callbacks.getStackPointerRegister(arch->callbacks.context); 243 | } 244 | BINARYNINJACOREAPI uint32_t BNGetArchitectureLinkRegister(BNArchitecture* arch) 245 | { 246 | return arch->callbacks.getLinkRegister(arch->callbacks.context); 247 | } 248 | BINARYNINJACOREAPI uint32_t* BNGetArchitectureGlobalRegisters(BNArchitecture* arch, size_t* count) 249 | { 250 | return arch->callbacks.getGlobalRegisters(arch->callbacks.context, count); 251 | } 252 | BINARYNINJACOREAPI bool BNIsArchitectureGlobalRegister(BNArchitecture* arch, uint32_t reg) 253 | { 254 | // TODO: implement 255 | __debugbreak(); return {}; 256 | } 257 | BINARYNINJACOREAPI uint32_t* BNGetArchitectureSystemRegisters(BNArchitecture* arch, size_t* count) 258 | { 259 | return arch->callbacks.getSystemRegisters(arch->callbacks.context, count); 260 | } 261 | BINARYNINJACOREAPI bool BNIsArchitectureSystemRegister(BNArchitecture* arch, uint32_t reg) 262 | { 263 | // TODO: implement 264 | __debugbreak(); return {}; 265 | } 266 | BINARYNINJACOREAPI uint32_t BNGetArchitectureRegisterByName(BNArchitecture* arch, const char* name) 267 | { 268 | // TODO: implement 269 | __debugbreak(); return {}; 270 | } 271 | 272 | BINARYNINJACOREAPI char* BNGetArchitectureRegisterStackName(BNArchitecture* arch, uint32_t regStack) 273 | { 274 | return arch->callbacks.getRegisterStackName(arch->callbacks.context, regStack); 275 | } 276 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureRegisterStacks(BNArchitecture* arch, size_t* count) 277 | { 278 | return arch->callbacks.getAllRegisterStacks(arch->callbacks.context, count); 279 | } 280 | BINARYNINJACOREAPI BNRegisterStackInfo BNGetArchitectureRegisterStackInfo(BNArchitecture* arch, uint32_t regStack) 281 | { 282 | BNRegisterStackInfo info; 283 | arch->callbacks.getRegisterStackInfo(arch->callbacks.context, regStack, &info); 284 | return info; 285 | } 286 | BINARYNINJACOREAPI uint32_t BNGetArchitectureRegisterStackForRegister(BNArchitecture* arch, uint32_t reg) 287 | { 288 | // TODO: implement 289 | __debugbreak(); return {}; 290 | } 291 | 292 | BINARYNINJACOREAPI BNIntrinsicClass BNGetArchitectureIntrinsicClass(BNArchitecture* arch, uint32_t intrinsic) 293 | { 294 | return arch->callbacks.getIntrinsicClass(arch->callbacks.context, intrinsic); 295 | } 296 | BINARYNINJACOREAPI char* BNGetArchitectureIntrinsicName(BNArchitecture* arch, uint32_t intrinsic) 297 | { 298 | return arch->callbacks.getIntrinsicName(arch->callbacks.context, intrinsic); 299 | } 300 | BINARYNINJACOREAPI uint32_t* BNGetAllArchitectureIntrinsics(BNArchitecture* arch, size_t* count) 301 | { 302 | return arch->callbacks.getAllIntrinsics(arch->callbacks.context, count); 303 | } 304 | BINARYNINJACOREAPI BNNameAndType* BNGetArchitectureIntrinsicInputs( 305 | BNArchitecture* arch, uint32_t intrinsic, size_t* count) 306 | { 307 | return arch->callbacks.getIntrinsicInputs(arch->callbacks.context, intrinsic, count); 308 | } 309 | BINARYNINJACOREAPI void BNFreeNameAndTypeList(BNNameAndType* nt, size_t count) 310 | { 311 | auto arch = firstArch(); 312 | arch->callbacks.freeNameAndTypeList(arch->callbacks.context, nt, count); 313 | } 314 | BINARYNINJACOREAPI BNTypeWithConfidence* BNGetArchitectureIntrinsicOutputs( 315 | BNArchitecture* arch, uint32_t intrinsic, size_t* count) 316 | { 317 | return arch->callbacks.getIntrinsicOutputs(arch->callbacks.context, intrinsic, count); 318 | } 319 | BINARYNINJACOREAPI void BNFreeOutputTypeList(BNTypeWithConfidence* types, size_t count) 320 | { 321 | auto arch = firstArch(); 322 | arch->callbacks.freeTypeList(arch->callbacks.context, types, count); 323 | } 324 | 325 | BINARYNINJACOREAPI bool BNCanArchitectureAssemble(BNArchitecture* arch) 326 | { 327 | return arch->callbacks.canAssemble(arch->callbacks.context); 328 | } 329 | BINARYNINJACOREAPI bool BNAssemble( 330 | BNArchitecture* arch, const char* code, uint64_t addr, BNDataBuffer* result, char** errors) 331 | { 332 | return arch->callbacks.assemble(arch->callbacks.context, code, addr, result, errors); 333 | } 334 | 335 | BINARYNINJACOREAPI bool BNIsArchitectureNeverBranchPatchAvailable( 336 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t len) 337 | { 338 | return arch->callbacks.isNeverBranchPatchAvailable(arch->callbacks.context, data, addr, len); 339 | } 340 | BINARYNINJACOREAPI bool BNIsArchitectureAlwaysBranchPatchAvailable( 341 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t len) 342 | { 343 | return arch->callbacks.isAlwaysBranchPatchAvailable(arch->callbacks.context, data, addr, len); 344 | } 345 | BINARYNINJACOREAPI bool BNIsArchitectureInvertBranchPatchAvailable( 346 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t len) 347 | { 348 | return arch->callbacks.isInvertBranchPatchAvailable(arch->callbacks.context, data, addr, len); 349 | } 350 | BINARYNINJACOREAPI bool BNIsArchitectureSkipAndReturnZeroPatchAvailable( 351 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t len) 352 | { 353 | return arch->callbacks.isSkipAndReturnZeroPatchAvailable(arch->callbacks.context, data, addr, len); 354 | } 355 | BINARYNINJACOREAPI bool BNIsArchitectureSkipAndReturnValuePatchAvailable( 356 | BNArchitecture* arch, const uint8_t* data, uint64_t addr, size_t len) 357 | { 358 | return arch->callbacks.isSkipAndReturnValuePatchAvailable(arch->callbacks.context, data, addr, len); 359 | } 360 | 361 | BINARYNINJACOREAPI bool BNArchitectureConvertToNop(BNArchitecture* arch, uint8_t* data, uint64_t addr, size_t len) 362 | { 363 | return arch->callbacks.convertToNop(arch->callbacks.context, data, addr, len); 364 | } 365 | BINARYNINJACOREAPI bool BNArchitectureAlwaysBranch(BNArchitecture* arch, uint8_t* data, uint64_t addr, size_t len) 366 | { 367 | return arch->callbacks.alwaysBranch(arch->callbacks.context, data, addr, len); 368 | } 369 | BINARYNINJACOREAPI bool BNArchitectureInvertBranch(BNArchitecture* arch, uint8_t* data, uint64_t addr, size_t len) 370 | { 371 | return arch->callbacks.invertBranch(arch->callbacks.context, data, addr, len); 372 | } 373 | BINARYNINJACOREAPI bool BNArchitectureSkipAndReturnValue( 374 | BNArchitecture* arch, uint8_t* data, uint64_t addr, size_t len, uint64_t value) 375 | { 376 | return arch->callbacks.skipAndReturnValue(arch->callbacks.context, data, addr, len, value); 377 | } 378 | BINARYNINJACOREAPI void BNRegisterArchitectureFunctionRecognizer(BNArchitecture* arch, BNFunctionRecognizer* rec) 379 | { 380 | arch->functionRecognizers.push_back(*rec); 381 | } 382 | 383 | BINARYNINJACOREAPI void BNArchitectureRegisterRelocationHandler( 384 | BNArchitecture* arch, const char* viewName, BNRelocationHandler* handler) 385 | { 386 | arch->relocationHandlers.emplace(viewName, handler); 387 | } 388 | BINARYNINJACOREAPI BNRelocationHandler* BNCreateRelocationHandler(BNCustomRelocationHandler* handler) 389 | { 390 | return new BNRelocationHandler(*handler); 391 | } 392 | BINARYNINJACOREAPI BNRelocationHandler* BNArchitectureGetRelocationHandler(BNArchitecture* arch, const char* viewName) 393 | { 394 | auto it = arch->relocationHandlers.find(viewName); 395 | if (it == arch->relocationHandlers.end()) 396 | return nullptr; 397 | return it->second; 398 | } 399 | BINARYNINJACOREAPI BNRelocationHandler* BNNewRelocationHandlerReference(BNRelocationHandler* handler) 400 | { 401 | return BNRef::Add(handler); 402 | } 403 | BINARYNINJACOREAPI void BNFreeRelocationHandler(BNRelocationHandler* handler) 404 | { 405 | BNRef::Release(handler); 406 | } 407 | BINARYNINJACOREAPI bool BNRelocationHandlerGetRelocationInfo( 408 | BNRelocationHandler* handler, BNBinaryView* data, BNArchitecture* arch, BNRelocationInfo* info, size_t infoCount) 409 | { 410 | return handler->callbacks.getRelocationInfo(handler->callbacks.context, data, arch, info, infoCount); 411 | } 412 | BINARYNINJACOREAPI bool BNRelocationHandlerApplyRelocation(BNRelocationHandler* handler, BNBinaryView* view, 413 | BNArchitecture* arch, BNRelocation* reloc, uint8_t* dest, size_t len) 414 | { 415 | return handler->callbacks.applyRelocation(handler->callbacks.context, view, arch, reloc, dest, len); 416 | } 417 | BINARYNINJACOREAPI bool BNRelocationHandlerDefaultApplyRelocation(BNRelocationHandler* handler, BNBinaryView* view, 418 | BNArchitecture* arch, BNRelocation* reloc, uint8_t* dest, size_t len) 419 | { 420 | // TODO: correct? 421 | return handler->callbacks.applyRelocation(handler->callbacks.context, view, arch, reloc, dest, len); 422 | } 423 | BINARYNINJACOREAPI size_t BNRelocationHandlerGetOperandForExternalRelocation(BNRelocationHandler* handler, 424 | const uint8_t* data, uint64_t addr, size_t length, const BNLowLevelILFunction* il, BNRelocation* relocation) 425 | { 426 | return handler->callbacks.getOperandForExternalRelocation(handler->callbacks.context, data, addr, length, (BNLowLevelILFunction*)il, relocation); 427 | } -------------------------------------------------------------------------------- /src/core_callingconvention.cpp: -------------------------------------------------------------------------------- 1 | // Calling conventions 2 | 3 | #include "core_impl.h" 4 | 5 | BINARYNINJACOREAPI BNCallingConvention* BNCreateCallingConvention( 6 | BNArchitecture* arch, const char* name, BNCustomCallingConvention* cc) 7 | { 8 | return new BNCallingConvention(name, *cc); 9 | } 10 | BINARYNINJACOREAPI void BNRegisterCallingConvention(BNArchitecture* arch, BNCallingConvention* cc) 11 | { 12 | arch->callingConventions.emplace(cc->name, cc); 13 | } 14 | BINARYNINJACOREAPI BNCallingConvention* BNNewCallingConventionReference(BNCallingConvention* cc) 15 | { 16 | return BNRef::Add(cc); 17 | } 18 | BINARYNINJACOREAPI void BNFreeCallingConvention(BNCallingConvention* cc) 19 | { 20 | BNRef::Release(cc); 21 | } 22 | 23 | BINARYNINJACOREAPI BNCallingConvention** BNGetArchitectureCallingConventions(BNArchitecture* arch, size_t* count) { __debugbreak(); return {}; } 24 | BINARYNINJACOREAPI void BNFreeCallingConventionList(BNCallingConvention** list, size_t count) { __debugbreak(); } 25 | BINARYNINJACOREAPI BNCallingConvention* BNGetArchitectureCallingConventionByName( 26 | BNArchitecture* arch, const char* name) { __debugbreak(); return {}; } 27 | 28 | BINARYNINJACOREAPI BNArchitecture* BNGetCallingConventionArchitecture(BNCallingConvention* cc) { __debugbreak(); return {}; } 29 | BINARYNINJACOREAPI char* BNGetCallingConventionName(BNCallingConvention* cc) { __debugbreak(); return {}; } 30 | BINARYNINJACOREAPI uint32_t* BNGetCallerSavedRegisters(BNCallingConvention* cc, size_t* count) { __debugbreak(); return {}; } 31 | BINARYNINJACOREAPI uint32_t* BNGetCalleeSavedRegisters(BNCallingConvention* cc, size_t* count) { __debugbreak(); return {}; } 32 | 33 | BINARYNINJACOREAPI uint32_t* BNGetIntegerArgumentRegisters(BNCallingConvention* cc, size_t* count) { __debugbreak(); return {}; } 34 | BINARYNINJACOREAPI uint32_t* BNGetFloatArgumentRegisters(BNCallingConvention* cc, size_t* count) { __debugbreak(); return {}; } 35 | BINARYNINJACOREAPI bool BNAreArgumentRegistersSharedIndex(BNCallingConvention* cc) { __debugbreak(); return {}; } 36 | BINARYNINJACOREAPI bool BNAreArgumentRegistersUsedForVarArgs(BNCallingConvention* cc) { __debugbreak(); return {}; } 37 | BINARYNINJACOREAPI bool BNIsStackReservedForArgumentRegisters(BNCallingConvention* cc) { __debugbreak(); return {}; } 38 | BINARYNINJACOREAPI bool BNIsStackAdjustedOnReturn(BNCallingConvention* cc) { __debugbreak(); return {}; } 39 | BINARYNINJACOREAPI bool BNIsEligibleForHeuristics(BNCallingConvention* cc) { __debugbreak(); return {}; } 40 | 41 | BINARYNINJACOREAPI uint32_t BNGetIntegerReturnValueRegister(BNCallingConvention* cc) { __debugbreak(); return {}; } 42 | BINARYNINJACOREAPI uint32_t BNGetHighIntegerReturnValueRegister(BNCallingConvention* cc) { __debugbreak(); return {}; } 43 | BINARYNINJACOREAPI uint32_t BNGetFloatReturnValueRegister(BNCallingConvention* cc) { __debugbreak(); return {}; } 44 | BINARYNINJACOREAPI uint32_t BNGetGlobalPointerRegister(BNCallingConvention* cc) { __debugbreak(); return {}; } 45 | 46 | BINARYNINJACOREAPI uint32_t* BNGetImplicitlyDefinedRegisters(BNCallingConvention* cc, size_t* count) { __debugbreak(); return {}; } 47 | BINARYNINJACOREAPI BNRegisterValue BNGetIncomingRegisterValue(BNCallingConvention* cc, uint32_t reg, BNFunction* func) { __debugbreak(); return {}; } 48 | BINARYNINJACOREAPI BNRegisterValue BNGetIncomingFlagValue(BNCallingConvention* cc, uint32_t reg, BNFunction* func) { __debugbreak(); return {}; } 49 | 50 | BINARYNINJACOREAPI BNVariable* BNGetVariablesForParametersDefaultPermittedArgs( 51 | BNCallingConvention* cc, const BNFunctionParameter* params, size_t paramCount, size_t* count) { __debugbreak(); return {}; } 52 | BINARYNINJACOREAPI BNVariable* BNGetVariablesForParameters(BNCallingConvention* cc, const BNFunctionParameter* params, 53 | size_t paramCount, const uint32_t* permittedArgs, size_t permittedArgCount, size_t* count) { __debugbreak(); return {}; } 54 | BINARYNINJACOREAPI BNVariable* BNGetParameterOrderingForVariables( 55 | BNCallingConvention* cc, const BNVariable* paramVars, const BNType** paramTypes, size_t paramCount, size_t* count) { __debugbreak(); return {}; } 56 | BINARYNINJACOREAPI int64_t BNGetStackAdjustmentForVariables( 57 | BNCallingConvention* cc, const BNVariable* paramVars, const BNType** paramTypes, size_t paramCount) { __debugbreak(); return {}; } 58 | BINARYNINJACOREAPI size_t BNGetRegisterStackAdjustments(BNCallingConvention* cc, const uint32_t* returnRegs, 59 | size_t returnRegCount, BNType* returnType, const BNVariable* params, size_t paramCount, const BNType** types, 60 | size_t typeCount, uint32_t** resultRegisters, uint32_t** resultAdjustments) { __debugbreak(); return {}; } 61 | 62 | BINARYNINJACOREAPI BNVariable BNGetIncomingVariableForParameterVariable( 63 | BNCallingConvention* cc, const BNVariable* var, BNFunction* func) { __debugbreak(); return {}; } 64 | BINARYNINJACOREAPI BNVariable BNGetParameterVariableForIncomingVariable( 65 | BNCallingConvention* cc, const BNVariable* var, BNFunction* func) { __debugbreak(); return {}; } 66 | BINARYNINJACOREAPI BNVariable BNGetDefaultIncomingVariableForParameterVariable( 67 | BNCallingConvention* cc, const BNVariable* var) { __debugbreak(); return {}; } 68 | BINARYNINJACOREAPI BNVariable BNGetDefaultParameterVariableForIncomingVariable( 69 | BNCallingConvention* cc, const BNVariable* var) { __debugbreak(); return {}; } 70 | 71 | BINARYNINJACOREAPI BNCallingConvention* BNGetArchitectureDefaultCallingConvention(BNArchitecture* arch) 72 | { 73 | return arch->defaultCallingConvention; 74 | } 75 | BINARYNINJACOREAPI BNCallingConvention* BNGetArchitectureCdeclCallingConvention(BNArchitecture* arch) 76 | { 77 | return arch->cdeclCallingConvention; 78 | } 79 | BINARYNINJACOREAPI BNCallingConvention* BNGetArchitectureStdcallCallingConvention(BNArchitecture* arch) 80 | { 81 | return arch->stdcallCallingConvention; 82 | } 83 | BINARYNINJACOREAPI BNCallingConvention* BNGetArchitectureFastcallCallingConvention(BNArchitecture* arch) 84 | { 85 | return arch->fastcallCallingConvention; 86 | } 87 | BINARYNINJACOREAPI void BNSetArchitectureDefaultCallingConvention(BNArchitecture* arch, BNCallingConvention* cc) 88 | { 89 | arch->defaultCallingConvention = cc; 90 | } 91 | BINARYNINJACOREAPI void BNSetArchitectureCdeclCallingConvention(BNArchitecture* arch, BNCallingConvention* cc) 92 | { 93 | arch->cdeclCallingConvention = cc; 94 | } 95 | BINARYNINJACOREAPI void BNSetArchitectureStdcallCallingConvention(BNArchitecture* arch, BNCallingConvention* cc) 96 | { 97 | arch->stdcallCallingConvention = cc; 98 | } 99 | BINARYNINJACOREAPI void BNSetArchitectureFastcallCallingConvention(BNArchitecture* arch, BNCallingConvention* cc) 100 | { 101 | arch->fastcallCallingConvention = cc; 102 | } -------------------------------------------------------------------------------- /src/core_function.cpp: -------------------------------------------------------------------------------- 1 | #include "core_impl.h" 2 | 3 | -------------------------------------------------------------------------------- /src/core_impl.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "binaryninjaapi.h" 4 | #include "core_ref.h" 5 | #include "lowlevelilinstruction.h" 6 | #include 7 | #include 8 | 9 | struct BNCallingConvention : BNRef 10 | { 11 | std::string name; 12 | BNCustomCallingConvention callbacks; 13 | 14 | BNCallingConvention(std::string name, BNCustomCallingConvention callbacks) : 15 | name(std::move(name)), callbacks(callbacks) 16 | {} 17 | 18 | ~BNCallingConvention() { callbacks.freeObject(callbacks.context); } 19 | }; 20 | 21 | struct BNRelocationHandler : BNRef 22 | { 23 | BNCustomRelocationHandler callbacks; 24 | 25 | explicit BNRelocationHandler(BNCustomRelocationHandler callbacks) : callbacks(callbacks) {} 26 | 27 | ~BNRelocationHandler() { callbacks.freeObject(callbacks.context); } 28 | }; 29 | 30 | struct BNArchitecture : BNRef 31 | { 32 | BNCustomArchitecture callbacks; 33 | std::map callingConventions; 34 | std::map relocationHandlers; 35 | std::vector functionRecognizers; 36 | BNCallingConvention* defaultCallingConvention = nullptr; 37 | BNCallingConvention* cdeclCallingConvention = nullptr; 38 | BNCallingConvention* stdcallCallingConvention = nullptr; 39 | BNCallingConvention* fastcallCallingConvention = nullptr; 40 | 41 | explicit BNArchitecture(BNCustomArchitecture callbacks) : callbacks(callbacks) 42 | { 43 | callbacks.init(callbacks.context, this); 44 | } 45 | }; 46 | 47 | struct BNPlatform : BNRef 48 | { 49 | BinaryNinja::Ref mArch; 50 | std::string mName; 51 | 52 | BNPlatform(BNArchitecture* arch, std::string name) : mArch(arch), mName(std::move(name)) { } 53 | }; 54 | 55 | struct BNBasicBlock : BNRef 56 | { 57 | // TODO: should this be BNFunctionGraphType? 58 | enum class Type 59 | { 60 | Disassembly, 61 | LLIL, 62 | MLIL, 63 | HLIL, 64 | } type = Type::Disassembly; 65 | uint64_t start = 0; 66 | uint64_t end = 0; 67 | }; 68 | 69 | using ExprId = size_t; 70 | using InstructionId = size_t; 71 | 72 | inline uint64_t labelEncode(const BNLowLevelILLabel& label) 73 | { 74 | return label.operand | label.ref << 3; 75 | } 76 | 77 | inline BNLowLevelILLabel labelDecode(uint64_t op) 78 | { 79 | BNLowLevelILLabel label; 80 | label.resolved = false; 81 | label.operand = op & 7; 82 | label.ref = op >> 3; 83 | return label; 84 | } 85 | 86 | struct BNFunction : BNRef 87 | { 88 | BinaryNinja::Ref mArch = nullptr; 89 | uint32_t mStart = -1; 90 | 91 | BNFunction(BNArchitecture* arch, uint64_t start) : mArch(arch), mStart(start) {} 92 | }; 93 | 94 | struct BNLowLevelILFunction : BNRef 95 | { 96 | BinaryNinja::Ref mArch; 97 | BinaryNinja::Ref mOwner; 98 | std::vector mExpressions; 99 | std::vector mInstructions; 100 | uint64_t mCurrentAddress = -1; 101 | std::deque mBasicBlockList; 102 | BNBasicBlock* mCurrentBasicBlock = nullptr; 103 | std::map mBasicBlocks; 104 | std::map mDisassembledInstructions; 105 | std::vector> mOperandLists; 106 | 107 | explicit BNLowLevelILFunction(BNArchitecture* arch, BNFunction* owner) 108 | : mArch(arch) 109 | , mOwner(owner) 110 | { 111 | if (owner != nullptr && owner->mArch.GetPtr() != arch) 112 | __debugbreak(); 113 | mCurrentBasicBlock = &mBasicBlockList.emplace_back(); 114 | mCurrentBasicBlock->type = BNBasicBlock::Type::LLIL; 115 | mCurrentBasicBlock->start = mInstructions.size(); 116 | } 117 | 118 | BinaryNinja::LowLevelILInstruction* NewExpr() 119 | { 120 | auto id = mExpressions.size(); 121 | mExpressions.emplace_back(); 122 | auto& expr = mExpressions.back(); 123 | expr.exprIndex = id; 124 | return &expr; 125 | } 126 | 127 | ExprId AddExpr(BNLowLevelILOperation operation, const BinaryNinja::ILSourceLocation& loc, size_t size, 128 | uint32_t flags, uint64_t a, uint64_t b, uint64_t c, uint64_t d) 129 | { 130 | auto expr = NewExpr(); 131 | expr->operation = operation; 132 | if (loc.valid) 133 | { 134 | expr->address = loc.address; 135 | expr->sourceOperand = loc.sourceOperand; 136 | mCurrentAddress = loc.address; // TODO: HACK 137 | } 138 | else 139 | { 140 | if (mCurrentAddress == -1) 141 | __debugbreak(); 142 | expr->address = mCurrentAddress; 143 | expr->sourceOperand = -1; 144 | } 145 | expr->size = size; 146 | expr->flags = flags; 147 | expr->operands[0] = a; 148 | expr->operands[1] = b; 149 | expr->operands[2] = c; 150 | expr->operands[3] = d; 151 | return expr->exprIndex; 152 | } 153 | 154 | void SetExprSourceOperand(ExprId expr, uint32_t operand) { mExpressions[expr].sourceOperand = operand; } 155 | 156 | InstructionId AddInstruction(ExprId expr) 157 | { 158 | auto instructionIndex = mInstructions.size(); 159 | mInstructions.push_back(expr); 160 | mCurrentBasicBlock->end = mInstructions.size(); 161 | return instructionIndex; 162 | } 163 | 164 | ExprId Goto(BNLowLevelILLabel& label, const BinaryNinja::ILSourceLocation& loc) 165 | { 166 | auto gotoExprId = AddExpr(LLIL_GOTO, loc, 0, 0, labelEncode(label), 0, 0, 0); 167 | if (!label.resolved) 168 | { 169 | label.ref = gotoExprId; 170 | label.operand = 0; 171 | } 172 | return gotoExprId; 173 | } 174 | 175 | ExprId If(ExprId operand, BNLowLevelILLabel& t, BNLowLevelILLabel& f, const BinaryNinja::ILSourceLocation& loc) 176 | { 177 | // We can only adjust one operand, so we need to optimize this 178 | if (&t == &f) 179 | { 180 | // TODO: verify this is loc 181 | return Goto(t, loc); 182 | } 183 | else 184 | { 185 | auto exprId = AddExpr(LLIL_IF, {}, 0, 0, operand, labelEncode(t), labelEncode(f), 0); 186 | if (!t.resolved) 187 | { 188 | t.ref = exprId; 189 | t.operand = 1; 190 | } 191 | if (!f.resolved) 192 | { 193 | f.ref = exprId; 194 | f.operand = 2; 195 | } 196 | return exprId; 197 | } 198 | } 199 | 200 | void MarkLabel(BNLowLevelILLabel& label) 201 | { 202 | if (label.resolved) 203 | return; 204 | 205 | auto nextInstructionId = mInstructions.size(); 206 | 207 | // Walk back the linked list and fix the label references 208 | BNLowLevelILLabel iter = label; 209 | while (iter.ref != 0) 210 | { 211 | auto& fixupExpr = mExpressions[iter.ref]; 212 | auto& fixupOperand = fixupExpr.operands[iter.operand]; 213 | iter = labelDecode(fixupOperand); 214 | fixupOperand = nextInstructionId; 215 | } 216 | 217 | label.resolved = true; 218 | label.ref = 0; 219 | label.operand = nextInstructionId; 220 | 221 | // TODO: record the highest label here 222 | } 223 | 224 | size_t AddOperandList(std::vector operands) 225 | { 226 | auto id = mOperandLists.size(); 227 | mOperandLists.emplace_back(std::move(operands)); 228 | return id; 229 | } 230 | 231 | void Finalize() 232 | { 233 | // TODO: do not create the block early 234 | // Also add NOPs to the end of the block for labels if necessary 235 | } 236 | 237 | BNLowLevelILLabel* GetLabelForAddress(BNArchitecture* arch, ExprId addr) 238 | { 239 | auto found = mBasicBlocks.find(addr); 240 | return found == mBasicBlocks.end() ? nullptr : &found->second; 241 | } 242 | 243 | static const char* op2str(BNLowLevelILOperation op) 244 | { 245 | switch (op) 246 | { 247 | case LLIL_NOP: 248 | return "NOP"; 249 | case LLIL_SET_REG: 250 | return "SET_REG"; 251 | case LLIL_SET_REG_SPLIT: 252 | return "SET_REG_SPLIT"; 253 | case LLIL_SET_FLAG: 254 | return "SET_FLAG"; 255 | case LLIL_SET_REG_STACK_REL: 256 | return "SET_REG_STACK_REL"; 257 | case LLIL_REG_STACK_PUSH: 258 | return "REG_STACK_PUSH"; 259 | case LLIL_LOAD: 260 | return "LOAD"; 261 | case LLIL_STORE: 262 | return "STORE"; 263 | case LLIL_PUSH: 264 | return "PUSH"; 265 | case LLIL_POP: 266 | return "POP"; 267 | case LLIL_REG: 268 | return "REG"; 269 | case LLIL_REG_SPLIT: 270 | return "REG_SPLIT"; 271 | case LLIL_REG_STACK_REL: 272 | return "REG_STACK_REL"; 273 | case LLIL_REG_STACK_POP: 274 | return "REG_STACK_POP"; 275 | case LLIL_REG_STACK_FREE_REG: 276 | return "REG_STACK_FREE_REG"; 277 | case LLIL_REG_STACK_FREE_REL: 278 | return "REG_STACK_FREE_REL"; 279 | case LLIL_CONST: 280 | return "CONST"; 281 | case LLIL_CONST_PTR: 282 | return "CONST_PTR"; 283 | case LLIL_EXTERN_PTR: 284 | return "EXTERN_PTR"; 285 | case LLIL_FLOAT_CONST: 286 | return "FLOAT_CONST"; 287 | case LLIL_FLAG: 288 | return "FLAG"; 289 | case LLIL_FLAG_BIT: 290 | return "FLAG_BIT"; 291 | case LLIL_ADD: 292 | return "ADD"; 293 | case LLIL_ADC: 294 | return "ADC"; 295 | case LLIL_SUB: 296 | return "SUB"; 297 | case LLIL_SBB: 298 | return "SBB"; 299 | case LLIL_AND: 300 | return "AND"; 301 | case LLIL_OR: 302 | return "OR"; 303 | case LLIL_XOR: 304 | return "XOR"; 305 | case LLIL_LSL: 306 | return "LSL"; 307 | case LLIL_LSR: 308 | return "LSR"; 309 | case LLIL_ASR: 310 | return "ASR"; 311 | case LLIL_ROL: 312 | return "ROL"; 313 | case LLIL_RLC: 314 | return "RLC"; 315 | case LLIL_ROR: 316 | return "ROR"; 317 | case LLIL_RRC: 318 | return "RRC"; 319 | case LLIL_MUL: 320 | return "MUL"; 321 | case LLIL_MULU_DP: 322 | return "MULU_DP"; 323 | case LLIL_MULS_DP: 324 | return "MULS_DP"; 325 | case LLIL_DIVU: 326 | return "DIVU"; 327 | case LLIL_DIVU_DP: 328 | return "DIVU_DP"; 329 | case LLIL_DIVS: 330 | return "DIVS"; 331 | case LLIL_DIVS_DP: 332 | return "DIVS_DP"; 333 | case LLIL_MODU: 334 | return "MODU"; 335 | case LLIL_MODU_DP: 336 | return "MODU_DP"; 337 | case LLIL_MODS: 338 | return "MODS"; 339 | case LLIL_MODS_DP: 340 | return "MODS_DP"; 341 | case LLIL_NEG: 342 | return "NEG"; 343 | case LLIL_NOT: 344 | return "NOT"; 345 | case LLIL_SX: 346 | return "SX"; 347 | case LLIL_ZX: 348 | return "ZX"; 349 | case LLIL_LOW_PART: 350 | return "LOW_PART"; 351 | case LLIL_JUMP: 352 | return "JUMP"; 353 | case LLIL_JUMP_TO: 354 | return "JUMP_TO"; 355 | case LLIL_CALL: 356 | return "CALL"; 357 | case LLIL_CALL_STACK_ADJUST: 358 | return "CALL_STACK_ADJUST"; 359 | case LLIL_TAILCALL: 360 | return "TAILCALL"; 361 | case LLIL_RET: 362 | return "RET"; 363 | case LLIL_NORET: 364 | return "NORET"; 365 | case LLIL_IF: 366 | return "IF"; 367 | case LLIL_GOTO: 368 | return "GOTO"; 369 | case LLIL_FLAG_COND: 370 | return "FLAG_COND"; 371 | case LLIL_FLAG_GROUP: 372 | return "FLAG_GROUP"; 373 | case LLIL_CMP_E: 374 | return "CMP_E"; 375 | case LLIL_CMP_NE: 376 | return "CMP_NE"; 377 | case LLIL_CMP_SLT: 378 | return "CMP_SLT"; 379 | case LLIL_CMP_ULT: 380 | return "CMP_ULT"; 381 | case LLIL_CMP_SLE: 382 | return "CMP_SLE"; 383 | case LLIL_CMP_ULE: 384 | return "CMP_ULE"; 385 | case LLIL_CMP_SGE: 386 | return "CMP_SGE"; 387 | case LLIL_CMP_UGE: 388 | return "CMP_UGE"; 389 | case LLIL_CMP_SGT: 390 | return "CMP_SGT"; 391 | case LLIL_CMP_UGT: 392 | return "CMP_UGT"; 393 | case LLIL_TEST_BIT: 394 | return "TEST_BIT"; 395 | case LLIL_BOOL_TO_INT: 396 | return "BOOL_TO_INT"; 397 | case LLIL_ADD_OVERFLOW: 398 | return "ADD_OVERFLOW"; 399 | case LLIL_SYSCALL: 400 | return "SYSCALL"; 401 | case LLIL_BP: 402 | return "BP"; 403 | case LLIL_TRAP: 404 | return "TRAP"; 405 | case LLIL_INTRINSIC: 406 | return "INTRINSIC"; 407 | case LLIL_UNDEF: 408 | return "UNDEF"; 409 | case LLIL_UNIMPL: 410 | return "UNIMPL"; 411 | case LLIL_UNIMPL_MEM: 412 | return "UNIMPL_MEM"; 413 | case LLIL_FADD: 414 | return "FADD"; 415 | case LLIL_FSUB: 416 | return "FSUB"; 417 | case LLIL_FMUL: 418 | return "FMUL"; 419 | case LLIL_FDIV: 420 | return "FDIV"; 421 | case LLIL_FSQRT: 422 | return "FSQRT"; 423 | case LLIL_FNEG: 424 | return "FNEG"; 425 | case LLIL_FABS: 426 | return "FABS"; 427 | case LLIL_FLOAT_TO_INT: 428 | return "FLOAT_TO_INT"; 429 | case LLIL_INT_TO_FLOAT: 430 | return "INT_TO_FLOAT"; 431 | case LLIL_FLOAT_CONV: 432 | return "FLOAT_CONV"; 433 | case LLIL_ROUND_TO_INT: 434 | return "ROUND_TO_INT"; 435 | case LLIL_FLOOR: 436 | return "FLOOR"; 437 | case LLIL_CEIL: 438 | return "CEIL"; 439 | case LLIL_FTRUNC: 440 | return "FTRUNC"; 441 | case LLIL_FCMP_E: 442 | return "FCMP_E"; 443 | case LLIL_FCMP_NE: 444 | return "FCMP_NE"; 445 | case LLIL_FCMP_LT: 446 | return "FCMP_LT"; 447 | case LLIL_FCMP_LE: 448 | return "FCMP_LE"; 449 | case LLIL_FCMP_GE: 450 | return "FCMP_GE"; 451 | case LLIL_FCMP_GT: 452 | return "FCMP_GT"; 453 | case LLIL_FCMP_O: 454 | return "FCMP_O"; 455 | case LLIL_FCMP_UO: 456 | return "FCMP_UO"; 457 | case LLIL_SET_REG_SSA: 458 | return "SET_REG_SSA"; 459 | case LLIL_SET_REG_SSA_PARTIAL: 460 | return "SET_REG_SSA_PARTIAL"; 461 | case LLIL_SET_REG_SPLIT_SSA: 462 | return "SET_REG_SPLIT_SSA"; 463 | case LLIL_SET_REG_STACK_REL_SSA: 464 | return "SET_REG_STACK_REL_SSA"; 465 | case LLIL_SET_REG_STACK_ABS_SSA: 466 | return "SET_REG_STACK_ABS_SSA"; 467 | case LLIL_REG_SPLIT_DEST_SSA: 468 | return "REG_SPLIT_DEST_SSA"; 469 | case LLIL_REG_STACK_DEST_SSA: 470 | return "REG_STACK_DEST_SSA"; 471 | case LLIL_REG_SSA: 472 | return "REG_SSA"; 473 | case LLIL_REG_SSA_PARTIAL: 474 | return "REG_SSA_PARTIAL"; 475 | case LLIL_REG_SPLIT_SSA: 476 | return "REG_SPLIT_SSA"; 477 | case LLIL_REG_STACK_REL_SSA: 478 | return "REG_STACK_REL_SSA"; 479 | case LLIL_REG_STACK_ABS_SSA: 480 | return "REG_STACK_ABS_SSA"; 481 | case LLIL_REG_STACK_FREE_REL_SSA: 482 | return "REG_STACK_FREE_REL_SSA"; 483 | case LLIL_REG_STACK_FREE_ABS_SSA: 484 | return "REG_STACK_FREE_ABS_SSA"; 485 | case LLIL_SET_FLAG_SSA: 486 | return "SET_FLAG_SSA"; 487 | case LLIL_FLAG_SSA: 488 | return "FLAG_SSA"; 489 | case LLIL_FLAG_BIT_SSA: 490 | return "FLAG_BIT_SSA"; 491 | case LLIL_CALL_SSA: 492 | return "CALL_SSA"; 493 | case LLIL_SYSCALL_SSA: 494 | return "SYSCALL_SSA"; 495 | case LLIL_TAILCALL_SSA: 496 | return "TAILCALL_SSA"; 497 | case LLIL_CALL_PARAM: 498 | return "CALL_PARAM"; 499 | case LLIL_CALL_STACK_SSA: 500 | return "CALL_STACK_SSA"; 501 | case LLIL_CALL_OUTPUT_SSA: 502 | return "CALL_OUTPUT_SSA"; 503 | case LLIL_SEPARATE_PARAM_LIST_SSA: 504 | return "SEPARATE_PARAM_LIST_SSA"; 505 | case LLIL_SHARED_PARAM_SLOT_SSA: 506 | return "SHARED_PARAM_SLOT_SSA"; 507 | case LLIL_MEMORY_INTRINSIC_OUTPUT_SSA: 508 | return "MEMORY_INTRINSIC_OUTPUT_SSA"; 509 | case LLIL_LOAD_SSA: 510 | return "LOAD_SSA"; 511 | case LLIL_STORE_SSA: 512 | return "STORE_SSA"; 513 | case LLIL_INTRINSIC_SSA: 514 | return "INTRINSIC_SSA"; 515 | case LLIL_MEMORY_INTRINSIC_SSA: 516 | return "MEMORY_INTRINSIC_SSA"; 517 | case LLIL_REG_PHI: 518 | return "REG_PHI"; 519 | case LLIL_REG_STACK_PHI: 520 | return "REG_STACK_PHI"; 521 | case LLIL_FLAG_PHI: 522 | return "FLAG_PHI"; 523 | case LLIL_MEM_PHI: 524 | return "MEM_PHI"; 525 | } 526 | return ""; 527 | } 528 | 529 | static const char* usage2str(BinaryNinja::LowLevelILOperandUsage usage) 530 | { 531 | using namespace BinaryNinja; 532 | switch (usage) 533 | { 534 | case SourceExprLowLevelOperandUsage: 535 | return "SourceExpr"; 536 | case SourceRegisterLowLevelOperandUsage: 537 | return "SourceRegister"; 538 | case SourceRegisterStackLowLevelOperandUsage: 539 | return "SourceRegisterStack"; 540 | case SourceFlagLowLevelOperandUsage: 541 | return "SourceFlag"; 542 | case SourceSSARegisterLowLevelOperandUsage: 543 | return "SourceSSARegister"; 544 | case SourceSSARegisterStackLowLevelOperandUsage: 545 | return "SourceSSARegisterStack"; 546 | case SourceSSAFlagLowLevelOperandUsage: 547 | return "SourceSSAFlag"; 548 | case DestExprLowLevelOperandUsage: 549 | return "DestExpr"; 550 | case DestRegisterLowLevelOperandUsage: 551 | return "DestRegister"; 552 | case DestRegisterStackLowLevelOperandUsage: 553 | return "DestRegisterStack"; 554 | case DestFlagLowLevelOperandUsage: 555 | return "DestFlag"; 556 | case DestSSARegisterLowLevelOperandUsage: 557 | return "DestSSARegister"; 558 | case DestSSARegisterStackLowLevelOperandUsage: 559 | return "DestSSARegisterStack"; 560 | case DestSSAFlagLowLevelOperandUsage: 561 | return "DestSSAFlag"; 562 | case SemanticFlagClassLowLevelOperandUsage: 563 | return "SemanticFlagClass"; 564 | case SemanticFlagGroupLowLevelOperandUsage: 565 | return "SemanticFlagGroup"; 566 | case PartialRegisterLowLevelOperandUsage: 567 | return "PartialRegister"; 568 | case PartialSSARegisterStackSourceLowLevelOperandUsage: 569 | return "PartialSSARegisterStackSource"; 570 | case StackSSARegisterLowLevelOperandUsage: 571 | return "StackSSARegister"; 572 | case StackMemoryVersionLowLevelOperandUsage: 573 | return "StackMemoryVersion"; 574 | case TopSSARegisterLowLevelOperandUsage: 575 | return "TopSSARegister"; 576 | case LeftExprLowLevelOperandUsage: 577 | return "LeftExpr"; 578 | case RightExprLowLevelOperandUsage: 579 | return "RightExpr"; 580 | case CarryExprLowLevelOperandUsage: 581 | return "CarryExpr"; 582 | case ConditionExprLowLevelOperandUsage: 583 | return "ConditionExpr"; 584 | case HighRegisterLowLevelOperandUsage: 585 | return "HighRegister"; 586 | case HighSSARegisterLowLevelOperandUsage: 587 | return "HighSSARegister"; 588 | case LowRegisterLowLevelOperandUsage: 589 | return "LowRegister"; 590 | case LowSSARegisterLowLevelOperandUsage: 591 | return "LowSSARegister"; 592 | case IntrinsicLowLevelOperandUsage: 593 | return "Intrinsic"; 594 | case ConstantLowLevelOperandUsage: 595 | return "Constant"; 596 | case VectorLowLevelOperandUsage: 597 | return "Vector"; 598 | case StackAdjustmentLowLevelOperandUsage: 599 | return "StackAdjustment"; 600 | case TargetLowLevelOperandUsage: 601 | return "Target"; 602 | case TrueTargetLowLevelOperandUsage: 603 | return "TrueTarget"; 604 | case FalseTargetLowLevelOperandUsage: 605 | return "FalseTarget"; 606 | case BitIndexLowLevelOperandUsage: 607 | return "BitIndex"; 608 | case SourceMemoryVersionLowLevelOperandUsage: 609 | return "SourceMemoryVersion"; 610 | case DestMemoryVersionLowLevelOperandUsage: 611 | return "DestMemoryVersion"; 612 | case FlagConditionLowLevelOperandUsage: 613 | return "FlagCondition"; 614 | case OutputSSARegistersLowLevelOperandUsage: 615 | return "OutputSSARegisters"; 616 | case OutputMemoryVersionLowLevelOperandUsage: 617 | return "OutputMemoryVersion"; 618 | case ParameterExprsLowLevelOperandUsage: 619 | return "ParameterExprs"; 620 | case SourceSSARegistersLowLevelOperandUsage: 621 | return "SourceSSARegisters"; 622 | case SourceSSARegisterStacksLowLevelOperandUsage: 623 | return "SourceSSARegisterStacks"; 624 | case SourceSSAFlagsLowLevelOperandUsage: 625 | return "SourceSSAFlags"; 626 | case OutputRegisterOrFlagListLowLevelOperandUsage: 627 | return "OutputRegisterOrFlagList"; 628 | case OutputSSARegisterOrFlagListLowLevelOperandUsage: 629 | return "OutputSSARegisterOrFlagList"; 630 | case OutputMemoryIntrinsicLowLevelOperandUsage: 631 | return "OutputMemoryIntrinsic"; 632 | case SourceMemoryVersionsLowLevelOperandUsage: 633 | return "SourceMemoryVersions"; 634 | case TargetsLowLevelOperandUsage: 635 | return "Targets"; 636 | case RegisterStackAdjustmentsLowLevelOperandUsage: 637 | return "RegisterStackAdjustments"; 638 | case OffsetLowLevelOperandUsage: 639 | return "Offset"; 640 | } 641 | return ""; 642 | } 643 | 644 | std::vector ExprText( 645 | BNArchitecture* arch, ExprId id, BNDisassemblySettings* settings) 646 | { 647 | using namespace BinaryNinja; 648 | std::vector tokens; 649 | auto& expr = mExpressions.at(id); 650 | BNLowLevelILOperation operation = expr.operation; 651 | tokens.emplace_back(OpcodeToken, op2str(operation)); 652 | if (expr.size > 0) 653 | { 654 | tokens.emplace_back(TextToken, ":" + std::to_string(expr.size * 8)); 655 | } 656 | tokens.emplace_back(OperandSeparatorToken, " "); 657 | // TODO: switch to LowLevelILInstruction::operationOperandIndex 658 | // TODO: check out LowLevelILInstruction::operandTypeForUsage 659 | auto itr = LowLevelILInstruction::operationOperandUsage.find(operation); 660 | if (itr != LowLevelILInstruction::operationOperandUsage.end()) 661 | { 662 | const auto& operandUsage = itr->second; 663 | for (size_t usageIndex = 0, operandIndex = 0; usageIndex < operandUsage.size(); 664 | usageIndex++, operandIndex++) 665 | { 666 | if (usageIndex > 0) 667 | tokens.emplace_back(OperandSeparatorToken, ", "); 668 | auto usage = operandUsage[usageIndex]; 669 | if (operandIndex >= 4) 670 | __debugbreak(); 671 | auto operand = expr.operands[operandIndex]; 672 | tokens.emplace_back(TextToken, usage2str(usage)); 673 | tokens.emplace_back(TextToken, ":"); 674 | switch (usage) 675 | { 676 | case SourceExprLowLevelOperandUsage: 677 | case DestExprLowLevelOperandUsage: 678 | case LeftExprLowLevelOperandUsage: 679 | case RightExprLowLevelOperandUsage: 680 | case CarryExprLowLevelOperandUsage: 681 | case ConditionExprLowLevelOperandUsage: 682 | tokens.emplace_back(TextToken, "%" + std::to_string(operand)); 683 | break; 684 | case SourceRegisterLowLevelOperandUsage: 685 | case DestRegisterLowLevelOperandUsage: 686 | { 687 | auto name = arch->callbacks.getRegisterName(arch->callbacks.context, (uint32_t)operand); 688 | tokens.emplace_back(RegisterToken, name); 689 | BNFreeString(name); 690 | break; 691 | } 692 | case ConstantLowLevelOperandUsage: 693 | { 694 | char hex[64] = ""; 695 | sprintf(hex, "0x%llX", operand); 696 | tokens.emplace_back(IntegerToken, hex); 697 | break; 698 | } 699 | case SemanticFlagGroupLowLevelOperandUsage: 700 | { 701 | auto name = arch->callbacks.getSemanticFlagGroupName(arch->callbacks.context, (uint32_t)operand); 702 | tokens.emplace_back(RegisterToken, name); 703 | BNFreeString(name); 704 | break; 705 | } 706 | case SourceFlagLowLevelOperandUsage: 707 | case DestFlagLowLevelOperandUsage: 708 | { 709 | auto name = arch->callbacks.getFlagName(arch->callbacks.context, (uint32_t)operand); 710 | tokens.emplace_back(RegisterToken, name); 711 | BNFreeString(name); 712 | break; 713 | } 714 | case IntrinsicLowLevelOperandUsage: 715 | { 716 | auto name = arch->callbacks.getIntrinsicName(arch->callbacks.context, (uint32_t)operand); 717 | tokens.emplace_back(KeywordToken, name); 718 | BNFreeString(name); 719 | break; 720 | } 721 | case OutputRegisterOrFlagListLowLevelOperandUsage: 722 | { 723 | auto count = operand; 724 | operand = expr.operands[++operandIndex]; 725 | tokens.emplace_back(TextToken, "RegOrFlagList:["); 726 | const auto& operandList = mOperandLists.at(operand); 727 | if (count != operandList.size()) 728 | __debugbreak(); 729 | for (size_t i = 0; i < operandList.size(); i++) 730 | { 731 | if (i > 0) 732 | { 733 | tokens.emplace_back(OperandSeparatorToken, ","); 734 | } 735 | auto regOrFlag = RegisterOrFlag::FromIdentifier(operandList[i]); 736 | if (regOrFlag.IsFlag()) 737 | { 738 | auto name = arch->callbacks.getFlagName(arch->callbacks.context, regOrFlag.GetFlag()); 739 | tokens.emplace_back(RegisterToken, name); 740 | BNFreeString(name); 741 | } 742 | else 743 | { 744 | auto name = 745 | arch->callbacks.getRegisterName(arch->callbacks.context, regOrFlag.GetRegister()); 746 | tokens.emplace_back(RegisterToken, name); 747 | BNFreeString(name); 748 | } 749 | } 750 | tokens.emplace_back(TextToken, "]"); 751 | break; 752 | } 753 | case TargetLowLevelOperandUsage: 754 | case TrueTargetLowLevelOperandUsage: 755 | case FalseTargetLowLevelOperandUsage: 756 | { 757 | auto label = labelDecode(operand); 758 | tokens.emplace_back(TextToken, "[" + std::to_string(label.operand) + "]"); 759 | if (label.ref != 0) 760 | tokens.emplace_back(TextToken, "->%" + std::to_string(label.ref) + ":unresolved"); 761 | break; 762 | } 763 | case ParameterExprsLowLevelOperandUsage: 764 | { 765 | if (operandIndex == 0) 766 | { 767 | auto count = operand; 768 | const auto& operandList = mOperandLists.at(operand); 769 | if (operandList.size() != count) 770 | __debugbreak(); 771 | 772 | tokens.emplace_back(TextToken, "OperandList:["); 773 | for (size_t i = 0; i < operandList.size(); i++) 774 | { 775 | if (i > 0) 776 | tokens.emplace_back(OperandSeparatorToken, ", "); 777 | tokens.emplace_back(TextToken, "%" + std::to_string(operandList[i])); 778 | } 779 | tokens.emplace_back(TextToken, "]"); 780 | } 781 | else 782 | { 783 | tokens.emplace_back(TextToken, "%" + std::to_string(operand)); 784 | } 785 | break; 786 | } 787 | default: 788 | tokens.emplace_back(TextToken, "unsupported:" + std::to_string(operand)); 789 | break; 790 | } 791 | } 792 | } 793 | else if (operation == LLIL_CALL_PARAM) 794 | { 795 | auto count = expr.operands[0]; 796 | auto operandListId = expr.operands[1]; 797 | const auto& operandList = mOperandLists.at(operandListId); 798 | if (operandList.size() != count) 799 | __debugbreak(); 800 | tokens.emplace_back(TextToken, "OperandList:["); 801 | for (size_t i = 0; i < count; i++) 802 | { 803 | if (i > 0) 804 | tokens.emplace_back(OperandSeparatorToken, ", "); 805 | tokens.emplace_back(TextToken, "%" + std::to_string(operandList[i])); 806 | } 807 | tokens.emplace_back(TextToken, "]"); 808 | } 809 | else 810 | { 811 | __debugbreak(); 812 | tokens.emplace_back(TextToken, "(unknown operand usage)"); 813 | } 814 | return tokens; 815 | } 816 | 817 | std::vector InstructionText( 818 | BNFunction* func, BNArchitecture* arch, 819 | size_t i, BNDisassemblySettings* settings) 820 | { 821 | using namespace BinaryNinja; 822 | 823 | std::vector tokens; 824 | tokens.emplace_back(TextToken, "NOT IMPLEMENTED!"); 825 | return tokens; 826 | } 827 | }; 828 | -------------------------------------------------------------------------------- /src/core_llil.cpp: -------------------------------------------------------------------------------- 1 | // Low-level IL 2 | 3 | #include "core_impl.h" 4 | 5 | BINARYNINJACOREAPI BNLowLevelILFunction* BNCreateLowLevelILFunction(BNArchitecture* arch, BNFunction* func) 6 | { 7 | return new BNLowLevelILFunction(arch, func); 8 | } 9 | BINARYNINJACOREAPI BNLowLevelILFunction* BNNewLowLevelILFunctionReference(BNLowLevelILFunction* func) 10 | { 11 | return BNRef::Add(func); 12 | } 13 | BINARYNINJACOREAPI void BNFreeLowLevelILFunction(BNLowLevelILFunction* func) 14 | { 15 | BNRef::Release(func); 16 | } 17 | BINARYNINJACOREAPI BNFunction* BNGetLowLevelILOwnerFunction(BNLowLevelILFunction* func) 18 | { 19 | func->mOwner->AddRef(); // TODO: correct? 20 | return func->mOwner; 21 | } 22 | BINARYNINJACOREAPI uint64_t BNLowLevelILGetCurrentAddress(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 23 | BINARYNINJACOREAPI void BNLowLevelILSetCurrentAddress(BNLowLevelILFunction* func, BNArchitecture* arch, uint64_t addr) { __debugbreak(); } 24 | BINARYNINJACOREAPI void BNLowLevelILSetCurrentSourceBlock(BNLowLevelILFunction* func, BNBasicBlock* source) { __debugbreak(); } 25 | BINARYNINJACOREAPI size_t BNLowLevelILGetInstructionStart( 26 | BNLowLevelILFunction* func, BNArchitecture* arch, uint64_t addr) { __debugbreak(); return {}; } 27 | BINARYNINJACOREAPI void BNLowLevelILClearIndirectBranches(BNLowLevelILFunction* func) { __debugbreak(); } 28 | BINARYNINJACOREAPI void BNLowLevelILSetIndirectBranches( 29 | BNLowLevelILFunction* func, BNArchitectureAndAddress* branches, size_t count) { __debugbreak(); } 30 | BINARYNINJACOREAPI size_t BNLowLevelILAddExpr(BNLowLevelILFunction* func, BNLowLevelILOperation operation, size_t size, 31 | uint32_t flags, uint64_t a, uint64_t b, uint64_t c, uint64_t d) 32 | { 33 | return func->AddExpr(operation, {}, size, flags, a, b, c, d); 34 | } 35 | BINARYNINJACOREAPI size_t BNLowLevelILAddExprWithLocation(BNLowLevelILFunction* func, uint64_t addr, 36 | uint32_t sourceOperand, BNLowLevelILOperation operation, size_t size, uint32_t flags, uint64_t a, uint64_t b, 37 | uint64_t c, uint64_t d) 38 | { 39 | return func->AddExpr(operation, {addr, sourceOperand}, size, flags, a, b, c, d); 40 | } 41 | BINARYNINJACOREAPI void BNLowLevelILSetExprSourceOperand(BNLowLevelILFunction* func, size_t expr, uint32_t operand) 42 | { 43 | func->SetExprSourceOperand(expr, operand); 44 | } 45 | BINARYNINJACOREAPI size_t BNLowLevelILAddInstruction(BNLowLevelILFunction* func, size_t expr) 46 | { 47 | return func->AddInstruction(expr); 48 | } 49 | BINARYNINJACOREAPI size_t BNLowLevelILGoto(BNLowLevelILFunction* func, BNLowLevelILLabel* label) 50 | { 51 | return func->Goto(*label, {}); 52 | } 53 | BINARYNINJACOREAPI size_t BNLowLevelILGotoWithLocation( 54 | BNLowLevelILFunction* func, BNLowLevelILLabel* label, uint64_t addr, uint32_t sourceOperand) 55 | { 56 | return func->Goto(*label, {addr, sourceOperand}); 57 | } 58 | BINARYNINJACOREAPI size_t BNLowLevelILIf( 59 | BNLowLevelILFunction* func, uint64_t op, BNLowLevelILLabel* t, BNLowLevelILLabel* f) 60 | { 61 | return func->If(op, *t, *f, {}); 62 | } 63 | BINARYNINJACOREAPI size_t BNLowLevelILIfWithLocation(BNLowLevelILFunction* func, uint64_t op, BNLowLevelILLabel* t, 64 | BNLowLevelILLabel* f, uint64_t addr, uint32_t sourceOperand) 65 | { 66 | return func->If(op, *t, *f, {addr, sourceOperand}); 67 | } 68 | BINARYNINJACOREAPI void BNLowLevelILInitLabel(BNLowLevelILLabel* label) 69 | { 70 | label->resolved = false; 71 | label->ref = 0; 72 | label->operand = 0; 73 | } 74 | BINARYNINJACOREAPI void BNLowLevelILMarkLabel(BNLowLevelILFunction* func, BNLowLevelILLabel* label) 75 | { 76 | func->MarkLabel(*label); 77 | } 78 | BINARYNINJACOREAPI void BNFinalizeLowLevelILFunction(BNLowLevelILFunction* func) 79 | { 80 | func->Finalize(); 81 | } 82 | BINARYNINJACOREAPI void BNGenerateLowLevelILSSAForm(BNLowLevelILFunction* func) { __debugbreak(); } 83 | 84 | BINARYNINJACOREAPI void BNPrepareToCopyLowLevelILFunction(BNLowLevelILFunction* func, BNLowLevelILFunction* src) { __debugbreak(); } 85 | BINARYNINJACOREAPI void BNPrepareToCopyLowLevelILBasicBlock(BNLowLevelILFunction* func, BNBasicBlock* block) { __debugbreak(); } 86 | BINARYNINJACOREAPI BNLowLevelILLabel* BNGetLabelForLowLevelILSourceInstruction( 87 | BNLowLevelILFunction* func, size_t instr) { __debugbreak(); return {}; } 88 | 89 | BINARYNINJACOREAPI size_t BNLowLevelILAddLabelMap( 90 | BNLowLevelILFunction* func, uint64_t* values, BNLowLevelILLabel** labels, size_t count) { __debugbreak(); return {}; } 91 | BINARYNINJACOREAPI size_t BNLowLevelILAddOperandList(BNLowLevelILFunction* func, uint64_t* operands, size_t count) 92 | { 93 | return func->AddOperandList(std::vector(operands, operands + count)); 94 | } 95 | BINARYNINJACOREAPI uint64_t* BNLowLevelILGetOperandList( 96 | BNLowLevelILFunction* func, size_t expr, size_t operand, size_t* count) 97 | { 98 | __debugbreak(); 99 | return nullptr; 100 | } 101 | BINARYNINJACOREAPI void BNLowLevelILFreeOperandList(uint64_t* operands) 102 | { 103 | __debugbreak(); 104 | } 105 | 106 | BINARYNINJACOREAPI BNLowLevelILInstruction BNGetLowLevelILByIndex(BNLowLevelILFunction* func, size_t i) 107 | { 108 | return func->mExpressions.at(i); 109 | } 110 | BINARYNINJACOREAPI size_t BNGetLowLevelILIndexForInstruction(BNLowLevelILFunction* func, size_t i) 111 | { 112 | auto exprId = func->mInstructions.at(i); 113 | return exprId; 114 | } 115 | BINARYNINJACOREAPI size_t BNGetLowLevelILInstructionForExpr(BNLowLevelILFunction* func, size_t expr) 116 | { 117 | return func->mExpressions.at(expr).instructionIndex; 118 | } 119 | BINARYNINJACOREAPI size_t BNGetLowLevelILInstructionCount(BNLowLevelILFunction* func) 120 | { 121 | return func->mInstructions.size(); 122 | } 123 | BINARYNINJACOREAPI size_t BNGetLowLevelILExprCount(BNLowLevelILFunction* func) 124 | { 125 | return func->mExpressions.size(); 126 | } 127 | 128 | BINARYNINJACOREAPI void BNUpdateLowLevelILOperand( 129 | BNLowLevelILFunction* func, size_t instr, size_t operandIndex, uint64_t value) { __debugbreak(); } 130 | BINARYNINJACOREAPI void BNReplaceLowLevelILExpr(BNLowLevelILFunction* func, size_t expr, size_t newExpr) { __debugbreak(); } 131 | BINARYNINJACOREAPI void BNSetLowLevelILExprAttributes(BNLowLevelILFunction* func, size_t expr, uint32_t attributes) { __debugbreak(); } 132 | 133 | BINARYNINJACOREAPI void BNAddLowLevelILLabelForAddress(BNLowLevelILFunction* func, BNArchitecture* arch, uint64_t addr) { __debugbreak(); } 134 | BINARYNINJACOREAPI BNLowLevelILLabel* BNGetLowLevelILLabelForAddress( 135 | BNLowLevelILFunction* func, BNArchitecture* arch, uint64_t addr) 136 | { 137 | return func->GetLabelForAddress(arch, addr); 138 | } 139 | 140 | BINARYNINJACOREAPI bool BNGetLowLevelILExprText(BNLowLevelILFunction* func, BNArchitecture* arch, size_t i, 141 | BNDisassemblySettings* settings, BNInstructionTextToken** tokens, size_t* count) 142 | { 143 | auto vecTokens = func->ExprText(arch, i, settings); 144 | *tokens = BinaryNinja::InstructionTextToken::CreateInstructionTextTokenList(vecTokens); 145 | *count = vecTokens.size(); 146 | return !vecTokens.empty(); // TODO 147 | } 148 | 149 | BINARYNINJACOREAPI bool BNGetLowLevelILInstructionText(BNLowLevelILFunction* il, BNFunction* func, BNArchitecture* arch, 150 | size_t i, BNDisassemblySettings* settings, BNInstructionTextToken** tokens, size_t* count) 151 | { 152 | auto vecTokens = il->InstructionText(func, arch, i, settings); 153 | *tokens = BinaryNinja::InstructionTextToken::CreateInstructionTextTokenList(vecTokens); 154 | *count = vecTokens.size(); 155 | return !vecTokens.empty(); // TODO 156 | } 157 | 158 | BINARYNINJACOREAPI uint32_t BNGetLowLevelILTemporaryRegisterCount(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 159 | BINARYNINJACOREAPI uint32_t BNGetLowLevelILTemporaryFlagCount(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 160 | 161 | BINARYNINJACOREAPI BNBasicBlock** BNGetLowLevelILBasicBlockList(BNLowLevelILFunction* func, size_t* count) 162 | { 163 | *count = func->mBasicBlockList.size(); 164 | auto result = new BNBasicBlock*[*count]; 165 | for (size_t i = 0; i < *count; i++) 166 | { 167 | // TODO: AddRef? 168 | result[i] = &func->mBasicBlockList.at(i); 169 | } 170 | return result; 171 | } 172 | BINARYNINJACOREAPI BNBasicBlock* BNGetLowLevelILBasicBlockForInstruction(BNLowLevelILFunction* func, size_t i) { __debugbreak(); return {}; } 173 | 174 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetLowLevelILSSAForm(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 175 | BINARYNINJACOREAPI BNLowLevelILFunction* BNGetLowLevelILNonSSAForm(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 176 | BINARYNINJACOREAPI size_t BNGetLowLevelILSSAInstructionIndex(BNLowLevelILFunction* func, size_t instr) { __debugbreak(); return {}; } 177 | BINARYNINJACOREAPI size_t BNGetLowLevelILNonSSAInstructionIndex(BNLowLevelILFunction* func, size_t instr) { __debugbreak(); return {}; } 178 | BINARYNINJACOREAPI size_t BNGetLowLevelILSSAExprIndex(BNLowLevelILFunction* func, size_t expr) { __debugbreak(); return {}; } 179 | BINARYNINJACOREAPI size_t BNGetLowLevelILNonSSAExprIndex(BNLowLevelILFunction* func, size_t expr) { __debugbreak(); return {}; } 180 | 181 | BINARYNINJACOREAPI size_t BNGetLowLevelILSSARegisterDefinition( 182 | BNLowLevelILFunction* func, uint32_t reg, size_t version) { __debugbreak(); return {}; } 183 | BINARYNINJACOREAPI size_t BNGetLowLevelILSSAFlagDefinition(BNLowLevelILFunction* func, uint32_t reg, size_t version) { __debugbreak(); return {}; } 184 | BINARYNINJACOREAPI size_t BNGetLowLevelILSSAMemoryDefinition(BNLowLevelILFunction* func, size_t version) { __debugbreak(); return {}; } 185 | BINARYNINJACOREAPI size_t* BNGetLowLevelILSSARegisterUses( 186 | BNLowLevelILFunction* func, uint32_t reg, size_t version, size_t* count) { __debugbreak(); return {}; } 187 | BINARYNINJACOREAPI size_t* BNGetLowLevelILSSAFlagUses( 188 | BNLowLevelILFunction* func, uint32_t reg, size_t version, size_t* count) { __debugbreak(); return {}; } 189 | BINARYNINJACOREAPI size_t* BNGetLowLevelILSSAMemoryUses(BNLowLevelILFunction* func, size_t version, size_t* count) { __debugbreak(); return {}; } 190 | 191 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILSSARegisterValue( 192 | BNLowLevelILFunction* func, uint32_t reg, size_t version) { __debugbreak(); return {}; } 193 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILSSAFlagValue( 194 | BNLowLevelILFunction* func, uint32_t flag, size_t version) { __debugbreak(); return {}; } 195 | 196 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILExprValue(BNLowLevelILFunction* func, size_t expr) { __debugbreak(); return {}; } 197 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleExprValues( 198 | BNLowLevelILFunction* func, size_t expr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 199 | 200 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILRegisterValueAtInstruction( 201 | BNLowLevelILFunction* func, uint32_t reg, size_t instr) { __debugbreak(); return {}; } 202 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILRegisterValueAfterInstruction( 203 | BNLowLevelILFunction* func, uint32_t reg, size_t instr) { __debugbreak(); return {}; } 204 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleRegisterValuesAtInstruction( 205 | BNLowLevelILFunction* func, uint32_t reg, size_t instr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 206 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleRegisterValuesAfterInstruction( 207 | BNLowLevelILFunction* func, uint32_t reg, size_t instr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 208 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILFlagValueAtInstruction( 209 | BNLowLevelILFunction* func, uint32_t flag, size_t instr) { __debugbreak(); return {}; } 210 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILFlagValueAfterInstruction( 211 | BNLowLevelILFunction* func, uint32_t flag, size_t instr) { __debugbreak(); return {}; } 212 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleFlagValuesAtInstruction( 213 | BNLowLevelILFunction* func, uint32_t flag, size_t instr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 214 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleFlagValuesAfterInstruction( 215 | BNLowLevelILFunction* func, uint32_t flag, size_t instr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 216 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILStackContentsAtInstruction( 217 | BNLowLevelILFunction* func, int64_t offset, size_t len, size_t instr) { __debugbreak(); return {}; } 218 | BINARYNINJACOREAPI BNRegisterValue BNGetLowLevelILStackContentsAfterInstruction( 219 | BNLowLevelILFunction* func, int64_t offset, size_t len, size_t instr) { __debugbreak(); return {}; } 220 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleStackContentsAtInstruction(BNLowLevelILFunction* func, 221 | int64_t offset, size_t len, size_t instr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 222 | BINARYNINJACOREAPI BNPossibleValueSet BNGetLowLevelILPossibleStackContentsAfterInstruction(BNLowLevelILFunction* func, 223 | int64_t offset, size_t len, size_t instr, BNDataFlowQueryOption* options, size_t optionCount) { __debugbreak(); return {}; } 224 | 225 | BINARYNINJACOREAPI uint32_t* BNGetLowLevelRegisters(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 226 | BINARYNINJACOREAPI uint32_t* BNGetLowLevelRegisterStacks(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 227 | BINARYNINJACOREAPI uint32_t* BNGetLowLevelFlags(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 228 | 229 | BINARYNINJACOREAPI uint32_t* BNGetLowLevelSSARegistersWithoutVersions(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 230 | BINARYNINJACOREAPI uint32_t* BNGetLowLevelSSARegisterStacksWithoutVersions(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 231 | BINARYNINJACOREAPI uint32_t* BNGetLowLevelSSAFlagsWithoutVersions(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 232 | 233 | BINARYNINJACOREAPI size_t* BNGetLowLevelRegisterSSAVersions( 234 | BNLowLevelILFunction* func, const uint32_t var, size_t* count) { __debugbreak(); return {}; } 235 | BINARYNINJACOREAPI size_t* BNGetLowLevelRegisterStackSSAVersions( 236 | BNLowLevelILFunction* func, const uint32_t var, size_t* count) { __debugbreak(); return {}; } 237 | BINARYNINJACOREAPI size_t* BNGetLowLevelFlagSSAVersions(BNLowLevelILFunction* func, const uint32_t var, size_t* count) { __debugbreak(); return {}; } 238 | 239 | BINARYNINJACOREAPI size_t* BNGetLowLevelMemoryVersions(BNLowLevelILFunction* func, size_t* count) { __debugbreak(); return {}; } 240 | 241 | BINARYNINJACOREAPI void BNFreeLLILVariablesList(uint32_t* vars) { __debugbreak(); } 242 | BINARYNINJACOREAPI void BNFreeLLILVariableVersionList(size_t* versions) { __debugbreak(); } 243 | 244 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetMediumLevelILForLowLevelIL(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 245 | BINARYNINJACOREAPI BNMediumLevelILFunction* BNGetMappedMediumLevelIL(BNLowLevelILFunction* func) { __debugbreak(); return {}; } 246 | BINARYNINJACOREAPI size_t BNGetMediumLevelILInstructionIndex(BNLowLevelILFunction* func, size_t instr) { __debugbreak(); return {}; } 247 | BINARYNINJACOREAPI size_t BNGetMediumLevelILExprIndex(BNLowLevelILFunction* func, size_t expr) { __debugbreak(); return {}; } 248 | BINARYNINJACOREAPI size_t* BNGetMediumLevelILExprIndexes(BNLowLevelILFunction* func, size_t expr, size_t* count) { __debugbreak(); return {}; } 249 | BINARYNINJACOREAPI size_t BNGetMappedMediumLevelILInstructionIndex(BNLowLevelILFunction* func, size_t instr) { __debugbreak(); return {}; } 250 | BINARYNINJACOREAPI size_t BNGetMappedMediumLevelILExprIndex(BNLowLevelILFunction* func, size_t expr) { __debugbreak(); return {}; } -------------------------------------------------------------------------------- /src/core_platform.cpp: -------------------------------------------------------------------------------- 1 | #include "core_impl.h" 2 | 3 | // Platforms 4 | BINARYNINJACOREAPI BNPlatform* BNCreatePlatform(BNArchitecture* arch, const char* name) 5 | { 6 | return new BNPlatform(arch, name); 7 | } 8 | BINARYNINJACOREAPI BNPlatform* BNCreatePlatformWithTypes( 9 | BNArchitecture* arch, const char* name, const char* typeFile, const char** includeDirs, size_t includeDirCount) { 10 | __debugbreak(); return {}; 11 | } 12 | BINARYNINJACOREAPI BNPlatform* BNCreateCustomPlatform(BNArchitecture* arch, const char* name, BNCustomPlatform* impl) { __debugbreak(); return {}; } 13 | BINARYNINJACOREAPI BNPlatform* BNCreateCustomPlatformWithTypes(BNArchitecture* arch, const char* name, 14 | BNCustomPlatform* impl, const char* typeFile, const char** includeDirs, size_t includeDirCount) { 15 | __debugbreak(); return {}; 16 | } 17 | BINARYNINJACOREAPI void BNRegisterPlatform(const char* os, BNPlatform* platform) { __debugbreak(); } 18 | BINARYNINJACOREAPI BNPlatform* BNNewPlatformReference(BNPlatform* platform) 19 | { 20 | return BNRef::Add(platform); 21 | } 22 | BINARYNINJACOREAPI void BNFreePlatform(BNPlatform* platform) 23 | { 24 | BNRef::Release(platform); 25 | } 26 | 27 | BINARYNINJACOREAPI char* BNGetPlatformName(BNPlatform* platform) { __debugbreak(); return {}; } 28 | BINARYNINJACOREAPI BNArchitecture* BNGetPlatformArchitecture(BNPlatform* platform) { __debugbreak(); return {}; } 29 | 30 | BINARYNINJACOREAPI BNPlatform* BNGetPlatformByName(const char* name) { __debugbreak(); return {}; } 31 | BINARYNINJACOREAPI BNPlatform** BNGetPlatformList(size_t* count) { __debugbreak(); return {}; } 32 | BINARYNINJACOREAPI BNPlatform** BNGetPlatformListByArchitecture(BNArchitecture* arch, size_t* count) { __debugbreak(); return {}; } 33 | BINARYNINJACOREAPI BNPlatform** BNGetPlatformListByOS(const char* os, size_t* count) { __debugbreak(); return {}; } 34 | BINARYNINJACOREAPI BNPlatform** BNGetPlatformListByOSAndArchitecture( 35 | const char* os, BNArchitecture* arch, size_t* count) { 36 | __debugbreak(); return {}; 37 | } 38 | BINARYNINJACOREAPI void BNFreePlatformList(BNPlatform** platform, size_t count) { __debugbreak(); } 39 | BINARYNINJACOREAPI char** BNGetPlatformOSList(size_t* count) { __debugbreak(); return {}; } 40 | BINARYNINJACOREAPI void BNFreePlatformOSList(char** list, size_t count) { __debugbreak(); } 41 | 42 | BINARYNINJACOREAPI BNCallingConvention* BNGetPlatformDefaultCallingConvention(BNPlatform* platform) { __debugbreak(); return {}; } 43 | BINARYNINJACOREAPI BNCallingConvention* BNGetPlatformCdeclCallingConvention(BNPlatform* platform) { __debugbreak(); return {}; } 44 | BINARYNINJACOREAPI BNCallingConvention* BNGetPlatformStdcallCallingConvention(BNPlatform* platform) { __debugbreak(); return {}; } 45 | BINARYNINJACOREAPI BNCallingConvention* BNGetPlatformFastcallCallingConvention(BNPlatform* platform) { __debugbreak(); return {}; } 46 | BINARYNINJACOREAPI BNCallingConvention** BNGetPlatformCallingConventions(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 47 | BINARYNINJACOREAPI BNCallingConvention* BNGetPlatformSystemCallConvention(BNPlatform* platform) { __debugbreak(); return {}; } 48 | 49 | BINARYNINJACOREAPI void BNRegisterPlatformCallingConvention(BNPlatform* platform, BNCallingConvention* cc) { __debugbreak(); } 50 | BINARYNINJACOREAPI void BNRegisterPlatformDefaultCallingConvention(BNPlatform* platform, BNCallingConvention* cc) { __debugbreak(); } 51 | BINARYNINJACOREAPI void BNRegisterPlatformCdeclCallingConvention(BNPlatform* platform, BNCallingConvention* cc) { __debugbreak(); } 52 | BINARYNINJACOREAPI void BNRegisterPlatformStdcallCallingConvention(BNPlatform* platform, BNCallingConvention* cc) { __debugbreak(); } 53 | BINARYNINJACOREAPI void BNRegisterPlatformFastcallCallingConvention(BNPlatform* platform, BNCallingConvention* cc) { __debugbreak(); } 54 | BINARYNINJACOREAPI void BNSetPlatformSystemCallConvention(BNPlatform* platform, BNCallingConvention* cc) { __debugbreak(); } 55 | 56 | BINARYNINJACOREAPI uint32_t* BNGetPlatformGlobalRegisters(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 57 | BINARYNINJACOREAPI BNType* BNGetPlatformGlobalRegisterType(BNPlatform* platform, uint32_t reg) { __debugbreak(); return {}; } 58 | BINARYNINJACOREAPI void BNPlatformAdjustTypeParserInput(BNPlatform* platform, BNTypeParser* parser, 59 | const char* const* argumentsIn, size_t argumentsLenIn, const char* const* sourceFileNamesIn, 60 | const char* const* sourceFileValuesIn, size_t sourceFilesLenIn, char*** argumentsOut, size_t* argumentsLenOut, 61 | char*** sourceFileNamesOut, char*** sourceFileValuesOut, size_t* sourceFilesLenOut) { 62 | __debugbreak(); 63 | } 64 | 65 | BINARYNINJACOREAPI BNPlatform* BNGetArchitectureStandalonePlatform(BNArchitecture* arch) { __debugbreak(); return {}; } 66 | 67 | BINARYNINJACOREAPI BNPlatform* BNGetRelatedPlatform(BNPlatform* platform, BNArchitecture* arch) { __debugbreak(); return {}; } 68 | BINARYNINJACOREAPI void BNAddRelatedPlatform(BNPlatform* platform, BNArchitecture* arch, BNPlatform* related) { __debugbreak(); } 69 | BINARYNINJACOREAPI BNPlatform** BNGetRelatedPlatforms(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 70 | BINARYNINJACOREAPI BNPlatform* BNGetAssociatedPlatformByAddress(BNPlatform* platform, uint64_t* addr) { __debugbreak(); return {}; } 71 | 72 | BINARYNINJACOREAPI BNTypeContainer* BNGetPlatformTypeContainer(BNPlatform* platform) { __debugbreak(); return {}; } 73 | BINARYNINJACOREAPI BNQualifiedNameAndType* BNGetPlatformTypes(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 74 | BINARYNINJACOREAPI BNQualifiedNameAndType* BNGetPlatformVariables(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 75 | BINARYNINJACOREAPI BNQualifiedNameAndType* BNGetPlatformFunctions(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 76 | BINARYNINJACOREAPI BNSystemCallInfo* BNGetPlatformSystemCalls(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 77 | BINARYNINJACOREAPI void BNFreeSystemCallList(BNSystemCallInfo* syscalls, size_t count) { __debugbreak(); } 78 | BINARYNINJACOREAPI BNType* BNGetPlatformTypeByName(BNPlatform* platform, BNQualifiedName* name) { __debugbreak(); return {}; } 79 | BINARYNINJACOREAPI BNType* BNGetPlatformVariableByName(BNPlatform* platform, BNQualifiedName* name) { __debugbreak(); return {}; } 80 | BINARYNINJACOREAPI BNType* BNGetPlatformFunctionByName(BNPlatform* platform, BNQualifiedName* name, bool exactMatch) { __debugbreak(); return {}; } 81 | BINARYNINJACOREAPI char* BNGetPlatformSystemCallName(BNPlatform* platform, uint32_t number) { __debugbreak(); return {}; } 82 | BINARYNINJACOREAPI BNType* BNGetPlatformSystemCallType(BNPlatform* platform, uint32_t number) { __debugbreak(); return {}; } 83 | 84 | BINARYNINJACOREAPI BNTypeLibrary** BNGetPlatformTypeLibraries(BNPlatform* platform, size_t* count) { __debugbreak(); return {}; } 85 | BINARYNINJACOREAPI BNTypeLibrary** BNGetPlatformTypeLibrariesByName( 86 | BNPlatform* platform, const char* depName, size_t* count) { 87 | __debugbreak(); return {}; 88 | } -------------------------------------------------------------------------------- /src/core_plugins.cpp: -------------------------------------------------------------------------------- 1 | // Plugin initialization 2 | 3 | #include 4 | 5 | extern "C" BINARYNINJAPLUGIN bool CorePluginInit_arch(); 6 | 7 | static bool g_archInitialized = false; 8 | 9 | BINARYNINJACOREAPI bool BNInitPlugins(bool allowUserPlugins) 10 | { 11 | if(!g_archInitialized) 12 | { 13 | if(!CorePluginInit_arch()) 14 | return false; 15 | g_archInitialized = true; 16 | } 17 | return true; 18 | } 19 | BINARYNINJACOREAPI bool BNInitCorePlugins(void) { return BNInitPlugins(false); } // Deprecated, use BNInitPlugins 20 | BINARYNINJACOREAPI void BNDisablePlugins(void) { __debugbreak(); } 21 | BINARYNINJACOREAPI bool BNIsPluginsEnabled(void) { __debugbreak(); return {}; } 22 | BINARYNINJACOREAPI void BNInitUserPlugins(void) { BNInitPlugins(true); } // Deprecated, use BNInitPlugins 23 | BINARYNINJACOREAPI void BNInitRepoPlugins(void) { __debugbreak(); } 24 | 25 | BINARYNINJACOREAPI char* BNGetInstallDirectory(void) { __debugbreak(); return {}; } 26 | BINARYNINJACOREAPI char* BNGetBundledPluginDirectory(void) { __debugbreak(); return {}; } 27 | BINARYNINJACOREAPI void BNSetBundledPluginDirectory(const char* path) { __debugbreak(); } 28 | BINARYNINJACOREAPI char* BNGetUserDirectory(void) { __debugbreak(); return {}; } 29 | BINARYNINJACOREAPI char* BNGetUserPluginDirectory(void) { __debugbreak(); return {}; } 30 | BINARYNINJACOREAPI char* BNGetRepositoriesDirectory(void) { __debugbreak(); return {}; } 31 | BINARYNINJACOREAPI char* BNGetSettingsFileName(void) { __debugbreak(); return {}; } 32 | BINARYNINJACOREAPI void BNSaveLastRun(void) { __debugbreak(); } 33 | 34 | BINARYNINJACOREAPI char* BNGetPathRelativeToBundledPluginDirectory(const char* path) { __debugbreak(); return {}; } 35 | BINARYNINJACOREAPI char* BNGetPathRelativeToUserPluginDirectory(const char* path) { __debugbreak(); return {}; } 36 | BINARYNINJACOREAPI char* BNGetPathRelativeToUserDirectory(const char* path) { __debugbreak(); return {}; } 37 | 38 | BINARYNINJACOREAPI bool BNExecuteWorkerProcess(const char* path, const char** args, BNDataBuffer* input, char** output, 39 | char** error, bool stdoutIsText, bool stderrIsText) { __debugbreak(); return {}; } 40 | 41 | BINARYNINJACOREAPI void BNSetCurrentPluginLoadOrder(BNPluginLoadOrder order) { __debugbreak(); } 42 | BINARYNINJACOREAPI void BNAddRequiredPluginDependency(const char* name) { __debugbreak(); } 43 | BINARYNINJACOREAPI void BNAddOptionalPluginDependency(const char* name) { __debugbreak(); } -------------------------------------------------------------------------------- /src/core_ref.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "core_utils.h" 6 | 7 | // TODO: confirm this implementation is correct 8 | struct BNRef 9 | { 10 | int refCount = 1; 11 | 12 | template 13 | static T* Add(T* obj) 14 | { 15 | static_assert(std::is_base_of_v, "T must be derived from BNRef"); 16 | if (obj) 17 | obj->refCount++; 18 | return obj; 19 | } 20 | 21 | template 22 | static void Release(T* obj) 23 | { 24 | static_assert(std::is_base_of_v, "T must be derived from BNRef"); 25 | if (obj && --obj->refCount == 0) 26 | delete obj; 27 | } 28 | 29 | void AddRef() 30 | { 31 | Add(this); 32 | } 33 | 34 | void Release() 35 | { 36 | Release(this); 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /src/core_settings.cpp: -------------------------------------------------------------------------------- 1 | // Settings APIs 2 | #include "core_ref.h" 3 | #include 4 | 5 | #include 6 | #include "json/json.h" 7 | 8 | struct BNSettings : BNRef 9 | { 10 | std::unique_ptr reader; 11 | std::map aliases; 12 | std::map settings; 13 | std::map state; 14 | 15 | BNSettings() 16 | { 17 | Json::CharReaderBuilder builder; 18 | reader.reset(builder.newCharReader()); 19 | } 20 | 21 | bool RegisterSetting(const char* key, const char* properties) 22 | { 23 | // deserialize the properties string into a Json::Value 24 | Json::Value root; 25 | std::string errors; 26 | if (!reader->parse(properties, properties + strlen(properties), &root, &errors)) 27 | { 28 | printf("Failed to parse settings properties: %s\n", errors.c_str()); 29 | return false; 30 | } 31 | for (auto alias : root.get("aliases", Json::Value(Json::arrayValue))) 32 | { 33 | aliases[alias.asString()] = key; 34 | } 35 | settings[key] = root; 36 | state[key] = root.get("default", ""); 37 | return true; 38 | } 39 | 40 | bool GetBool(const char* key, BNBinaryView* view, BNSettingsScope* scope) 41 | { 42 | auto it = state.find(key); 43 | if (it == state.end()) 44 | return false; 45 | return it->second.isBool() ? it->second.asBool() : false; 46 | } 47 | 48 | std::string GetString(const char* key, BNBinaryView* view, BNSettingsScope* scope) 49 | { 50 | auto it = state.find(key); 51 | if (it == state.end()) 52 | return nullptr; 53 | return it->second.asString(); 54 | } 55 | }; 56 | 57 | BINARYNINJACOREAPI BNSettings* BNCreateSettings(const char* schemaId) { return new BNSettings(); } 58 | BINARYNINJACOREAPI BNSettings* BNNewSettingsReference(BNSettings* settings) { return BNRef::Add(settings); } 59 | BINARYNINJACOREAPI void BNFreeSettings(BNSettings* settings) { BNRef::Release(settings); } 60 | BINARYNINJACOREAPI bool BNLoadSettingsFile( 61 | BNSettings* settings, const char* fileName, BNSettingsScope scope, BNBinaryView* view) { __debugbreak(); return {}; } 62 | BINARYNINJACOREAPI void BNSettingsSetResourceId(BNSettings* settings, const char* resourceId) { __debugbreak(); } 63 | BINARYNINJACOREAPI bool BNSettingsRegisterGroup(BNSettings* settings, const char* group, const char* title) { __debugbreak(); return {}; } 64 | BINARYNINJACOREAPI bool BNSettingsRegisterSetting(BNSettings* settings, const char* key, const char* properties) { return settings->RegisterSetting(key, properties); } 65 | BINARYNINJACOREAPI bool BNSettingsContains(BNSettings* settings, const char* key) { __debugbreak(); return {}; } 66 | BINARYNINJACOREAPI bool BNSettingsIsEmpty(BNSettings* settings) { __debugbreak(); return {}; } 67 | BINARYNINJACOREAPI const char** BNSettingsKeysList(BNSettings* settings, size_t* inoutSize) { __debugbreak(); return {}; } 68 | BINARYNINJACOREAPI const char** BNSettingsQueryPropertyStringList( 69 | BNSettings* settings, const char* key, const char* property, size_t* inoutSize) { __debugbreak(); return {}; } 70 | BINARYNINJACOREAPI bool BNSettingsUpdateProperty(BNSettings* settings, const char* key, const char* property) { __debugbreak(); return {}; } 71 | BINARYNINJACOREAPI bool BNSettingsUpdateBoolProperty( 72 | BNSettings* settings, const char* key, const char* property, bool value) { __debugbreak(); return {}; } 73 | BINARYNINJACOREAPI bool BNSettingsUpdateDoubleProperty( 74 | BNSettings* settings, const char* key, const char* property, double value) { __debugbreak(); return {}; } 75 | BINARYNINJACOREAPI bool BNSettingsUpdateInt64Property( 76 | BNSettings* settings, const char* key, const char* property, int64_t value) { __debugbreak(); return {}; } 77 | BINARYNINJACOREAPI bool BNSettingsUpdateUInt64Property( 78 | BNSettings* settings, const char* key, const char* property, uint64_t value) { __debugbreak(); return {}; } 79 | BINARYNINJACOREAPI bool BNSettingsUpdateStringProperty( 80 | BNSettings* settings, const char* key, const char* property, const char* value) { __debugbreak(); return {}; } 81 | BINARYNINJACOREAPI bool BNSettingsUpdateStringListProperty( 82 | BNSettings* settings, const char* key, const char* property, const char** value, size_t size) { __debugbreak(); return {}; } 83 | 84 | BINARYNINJACOREAPI bool BNSettingsDeserializeSchema( 85 | BNSettings* settings, const char* schema, BNSettingsScope scope, bool merge) { __debugbreak(); return {}; } 86 | BINARYNINJACOREAPI char* BNSettingsSerializeSchema(BNSettings* settings) { __debugbreak(); return {}; } 87 | BINARYNINJACOREAPI bool BNDeserializeSettings( 88 | BNSettings* settings, const char* contents, BNBinaryView* view, BNSettingsScope scope) { __debugbreak(); return {}; } 89 | BINARYNINJACOREAPI char* BNSerializeSettings(BNSettings* settings, BNBinaryView* view, BNSettingsScope scope) { __debugbreak(); return {}; } 90 | 91 | BINARYNINJACOREAPI bool BNSettingsReset( 92 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope scope) { __debugbreak(); return {}; } 93 | BINARYNINJACOREAPI bool BNSettingsResetAll( 94 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, bool schemaOnly) { __debugbreak(); return {}; } 95 | 96 | BINARYNINJACOREAPI bool BNSettingsGetBool( 97 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope) { return settings->GetBool(key, view, scope); } 98 | BINARYNINJACOREAPI double BNSettingsGetDouble( 99 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope) { __debugbreak(); return {}; } 100 | BINARYNINJACOREAPI int64_t BNSettingsGetInt64( 101 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope) { __debugbreak(); return {}; } 102 | BINARYNINJACOREAPI uint64_t BNSettingsGetUInt64( 103 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope) { __debugbreak(); return {}; } 104 | BINARYNINJACOREAPI char* BNSettingsGetString( 105 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope) 106 | { 107 | return BNAllocString(settings->GetString(key, view, scope).c_str()); 108 | } 109 | BINARYNINJACOREAPI const char** BNSettingsGetStringList( 110 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope, size_t* inoutSize) { __debugbreak(); return {}; } 111 | 112 | BINARYNINJACOREAPI char* BNSettingsGetJson( 113 | BNSettings* settings, const char* key, BNBinaryView* view, BNSettingsScope* scope) { __debugbreak(); return {}; } 114 | 115 | BINARYNINJACOREAPI bool BNSettingsSetBool( 116 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, bool value) { __debugbreak(); return {}; } 117 | BINARYNINJACOREAPI bool BNSettingsSetDouble( 118 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, double value) { __debugbreak(); return {}; } 119 | BINARYNINJACOREAPI bool BNSettingsSetInt64( 120 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, int64_t value) { __debugbreak(); return {}; } 121 | BINARYNINJACOREAPI bool BNSettingsSetUInt64( 122 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, uint64_t value) { __debugbreak(); return {}; } 123 | BINARYNINJACOREAPI bool BNSettingsSetString( 124 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, const char* value) { __debugbreak(); return {}; } 125 | BINARYNINJACOREAPI bool BNSettingsSetStringList( 126 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, const char** value, size_t size) { __debugbreak(); return {}; } 127 | BINARYNINJACOREAPI bool BNSettingsSetJson( 128 | BNSettings* settings, BNBinaryView* view, BNSettingsScope scope, const char* key, const char* value) { __debugbreak(); return {}; } -------------------------------------------------------------------------------- /src/core_string.cpp: -------------------------------------------------------------------------------- 1 | // String 2 | #include 3 | 4 | #include "binaryninjacore.h" 5 | 6 | BINARYNINJACOREAPI char* BNAllocString(const char* contents) 7 | { 8 | return strdup(contents); 9 | } 10 | 11 | BINARYNINJACOREAPI void BNFreeString(char* str) 12 | { 13 | free(str); 14 | } 15 | 16 | BINARYNINJACOREAPI char** BNAllocStringList(const char** contents, size_t size) 17 | { 18 | char** result = (char**)malloc(size * sizeof(char*)); 19 | for (size_t i = 0; i < size; i++) 20 | result[i] = BNAllocString(contents[i]); 21 | return result; 22 | } 23 | BINARYNINJACOREAPI void BNFreeStringList(char** strs, size_t count) 24 | { 25 | for (size_t i = 0; i < count; i++) 26 | BNFreeString(strs[i]); 27 | free(strs); 28 | } -------------------------------------------------------------------------------- /src/core_types.cpp: -------------------------------------------------------------------------------- 1 | // Types 2 | #include 3 | 4 | #include "binaryninjacore.h" 5 | #include "core_ref.h" 6 | 7 | struct BNType : BNRef 8 | { 9 | virtual ~BNType() = default; 10 | }; 11 | 12 | struct BNVoidType : BNType 13 | {}; 14 | 15 | struct BNBoolType : BNType 16 | {}; 17 | 18 | struct BNIntegerType : BNType 19 | { 20 | size_t width; 21 | BNBoolWithConfidence sign; 22 | std::string altName; 23 | 24 | BNIntegerType(size_t width, BNBoolWithConfidence sign, const char* altName) : width(width), sign(sign), altName(std::move(altName)) {} 25 | }; 26 | 27 | struct BNFloatType : BNType 28 | { 29 | size_t width; 30 | std::string altName; 31 | 32 | BNFloatType(size_t width, std::string altName) : width(width), altName(std::move(altName)) {} 33 | }; 34 | 35 | struct BNWideCharType : BNType 36 | { 37 | size_t width; 38 | std::string altName; 39 | 40 | BNWideCharType(size_t width, std::string altName) : width(width), altName(std::move(altName)) {} 41 | }; 42 | 43 | struct BNArrayType : BNType 44 | { 45 | BNTypeWithConfidence type; 46 | uint64_t elem; 47 | 48 | BNArrayType(BNTypeWithConfidence type, uint64_t elem) : type(type), elem(elem) {} 49 | }; 50 | 51 | BINARYNINJACOREAPI bool BNTypesEqual(BNType* a, BNType* b) { __debugbreak(); return {}; } 52 | BINARYNINJACOREAPI bool BNTypesNotEqual(BNType* a, BNType* b) { __debugbreak(); return {}; } 53 | BINARYNINJACOREAPI BNType* BNCreateVoidType(void) { return new BNVoidType(); } 54 | BINARYNINJACOREAPI BNType* BNCreateBoolType(void) { return new BNBoolType(); } 55 | BINARYNINJACOREAPI BNType* BNCreateIntegerType(size_t width, BNBoolWithConfidence* sign, const char* altName) { return new BNIntegerType(width, *sign, altName); } 56 | BINARYNINJACOREAPI BNType* BNCreateFloatType(size_t width, const char* altName) { return new BNFloatType(width, altName); } 57 | BINARYNINJACOREAPI BNType* BNCreateWideCharType(size_t width, const char* altName) { return new BNWideCharType(width, altName); } 58 | BINARYNINJACOREAPI BNType* BNCreateStructureType(BNStructure* s) { __debugbreak(); return {}; } 59 | BINARYNINJACOREAPI BNType* BNCreateEnumerationType( 60 | BNArchitecture* arch, BNEnumeration* e, size_t width, BNBoolWithConfidence* isSigned) { __debugbreak(); return {}; } 61 | BINARYNINJACOREAPI BNType* BNCreateEnumerationTypeOfWidth( 62 | BNEnumeration* e, size_t width, BNBoolWithConfidence* isSigned) { __debugbreak(); return {}; } 63 | BINARYNINJACOREAPI BNType* BNCreatePointerType(BNArchitecture* arch, const BNTypeWithConfidence* const type, 64 | BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, BNReferenceType refType) { __debugbreak(); return {}; } 65 | BINARYNINJACOREAPI BNType* BNCreatePointerTypeOfWidth(size_t width, const BNTypeWithConfidence* const type, 66 | BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, BNReferenceType refType) { __debugbreak(); return {}; } 67 | BINARYNINJACOREAPI BNType* BNCreateArrayType(const BNTypeWithConfidence* const type, uint64_t elem) { return new BNArrayType(*type, elem); } 68 | BINARYNINJACOREAPI BNType* BNCreateFunctionType(BNTypeWithConfidence* returnValue, 69 | BNCallingConventionWithConfidence* callingConvention, BNFunctionParameter* params, size_t paramCount, 70 | BNBoolWithConfidence* varArg, BNBoolWithConfidence* canReturn, BNOffsetWithConfidence* stackAdjust, 71 | uint32_t* regStackAdjustRegs, BNOffsetWithConfidence* regStackAdjustValues, size_t regStackAdjustCount, 72 | BNRegisterSetWithConfidence* returnRegs, BNNameType ft, BNBoolWithConfidence* pure) { __debugbreak(); return {}; } 73 | BINARYNINJACOREAPI BNType* BNNewTypeReference(BNType* type) { return BNRef::Add(type); } 74 | BINARYNINJACOREAPI BNType* BNDuplicateType(BNType* type) { __debugbreak(); return {}; } 75 | BINARYNINJACOREAPI char* BNGetTypeAndName(BNType* type, BNQualifiedName* name, BNTokenEscapingType escaping) { __debugbreak(); return {}; } 76 | BINARYNINJACOREAPI void BNFreeType(BNType* type) { BNRef::Release(type); } 77 | BINARYNINJACOREAPI void BNFreeTypeList(BNType** types, size_t count) { __debugbreak(); } 78 | 79 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateTypeBuilderFromType(BNType* type) { __debugbreak(); return {}; } 80 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateVoidTypeBuilder(void) { __debugbreak(); return {}; } 81 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateBoolTypeBuilder(void) { __debugbreak(); return {}; } 82 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateIntegerTypeBuilder( 83 | size_t width, BNBoolWithConfidence* sign, const char* altName) { __debugbreak(); return {}; } 84 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateFloatTypeBuilder(size_t width, const char* altName) { __debugbreak(); return {}; } 85 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateWideCharTypeBuilder(size_t width, const char* altName) { __debugbreak(); return {}; } 86 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateStructureTypeBuilder(BNStructure* s) { __debugbreak(); return {}; } 87 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateStructureTypeBuilderWithBuilder(BNStructureBuilder* s) { __debugbreak(); return {}; } 88 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateEnumerationTypeBuilder( 89 | BNArchitecture* arch, BNEnumeration* e, size_t width, BNBoolWithConfidence* isSigned) { __debugbreak(); return {}; } 90 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateEnumerationTypeBuilderWithBuilder( 91 | BNArchitecture* arch, BNEnumerationBuilder* e, size_t width, BNBoolWithConfidence* isSigned) { __debugbreak(); return {}; } 92 | BINARYNINJACOREAPI BNTypeBuilder* BNCreatePointerTypeBuilder(BNArchitecture* arch, 93 | const BNTypeWithConfidence* const type, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, 94 | BNReferenceType refType) { __debugbreak(); return {}; } 95 | BINARYNINJACOREAPI BNTypeBuilder* BNCreatePointerTypeBuilderOfWidth(size_t width, 96 | const BNTypeWithConfidence* const type, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, 97 | BNReferenceType refType) { __debugbreak(); return {}; } 98 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateArrayTypeBuilder(const BNTypeWithConfidence* const type, uint64_t elem) { __debugbreak(); return {}; } 99 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateFunctionTypeBuilder(BNTypeWithConfidence* returnValue, 100 | BNCallingConventionWithConfidence* callingConvention, BNFunctionParameter* params, size_t paramCount, 101 | BNBoolWithConfidence* varArg, BNBoolWithConfidence* canReturn, BNOffsetWithConfidence* stackAdjust, 102 | uint32_t* regStackAdjustRegs, BNOffsetWithConfidence* regStackAdjustValues, size_t regStackAdjustCount, 103 | BNRegisterSetWithConfidence* returnRegs, BNNameType ft, BNBoolWithConfidence* pure) { __debugbreak(); return {}; } 104 | BINARYNINJACOREAPI BNType* BNFinalizeTypeBuilder(BNTypeBuilder* type) { __debugbreak(); return {}; } 105 | BINARYNINJACOREAPI BNTypeBuilder* BNDuplicateTypeBuilder(BNTypeBuilder* type) { __debugbreak(); return {}; } 106 | BINARYNINJACOREAPI char* BNGetTypeBuilderTypeAndName(BNTypeBuilder* type, BNQualifiedName* name) { __debugbreak(); return {}; } 107 | BINARYNINJACOREAPI void BNFreeTypeBuilder(BNTypeBuilder* type) { __debugbreak(); } 108 | 109 | BINARYNINJACOREAPI BNQualifiedName BNTypeGetTypeName(BNType* nt) { __debugbreak(); return {}; } 110 | BINARYNINJACOREAPI BNTypeClass BNGetTypeClass(BNType* type) { __debugbreak(); return {}; } 111 | BINARYNINJACOREAPI uint64_t BNGetTypeWidth(BNType* type) { __debugbreak(); return {}; } 112 | BINARYNINJACOREAPI size_t BNGetTypeAlignment(BNType* type) { __debugbreak(); return {}; } 113 | BINARYNINJACOREAPI BNIntegerDisplayType BNGetIntegerTypeDisplayType(BNType* type) { __debugbreak(); return {}; } 114 | BINARYNINJACOREAPI void BNSetIntegerTypeDisplayType(BNTypeBuilder* type, BNIntegerDisplayType displayType) { __debugbreak(); } 115 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeSigned(BNType* type) { __debugbreak(); return {}; } 116 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeConst(BNType* type) { __debugbreak(); return {}; } 117 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeVolatile(BNType* type) { __debugbreak(); return {}; } 118 | BINARYNINJACOREAPI bool BNIsTypeFloatingPoint(BNType* type) { __debugbreak(); return {}; } 119 | BINARYNINJACOREAPI BNTypeWithConfidence BNGetChildType(BNType* type) { __debugbreak(); return {}; } 120 | BINARYNINJACOREAPI BNCallingConventionWithConfidence BNGetTypeCallingConvention(BNType* type) { __debugbreak(); return {}; } 121 | BINARYNINJACOREAPI BNFunctionParameter* BNGetTypeParameters(BNType* type, size_t* count) { __debugbreak(); return {}; } 122 | BINARYNINJACOREAPI void BNFreeTypeParameterList(BNFunctionParameter* types, size_t count) { __debugbreak(); } 123 | BINARYNINJACOREAPI BNBoolWithConfidence BNTypeHasVariableArguments(BNType* type) { __debugbreak(); return {}; } 124 | BINARYNINJACOREAPI BNBoolWithConfidence BNFunctionTypeCanReturn(BNType* type) { __debugbreak(); return {}; } 125 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypePure(BNType* type) { __debugbreak(); return {}; } 126 | BINARYNINJACOREAPI BNStructure* BNGetTypeStructure(BNType* type) { __debugbreak(); return {}; } 127 | BINARYNINJACOREAPI BNEnumeration* BNGetTypeEnumeration(BNType* type) { __debugbreak(); return {}; } 128 | BINARYNINJACOREAPI BNNamedTypeReference* BNGetTypeNamedTypeReference(BNType* type) { __debugbreak(); return {}; } 129 | BINARYNINJACOREAPI uint64_t BNGetTypeElementCount(BNType* type) { __debugbreak(); return {}; } 130 | BINARYNINJACOREAPI uint64_t BNGetTypeOffset(BNType* type) { __debugbreak(); return {}; } 131 | BINARYNINJACOREAPI BNOffsetWithConfidence BNGetTypeStackAdjustment(BNType* type) { __debugbreak(); return {}; } 132 | BINARYNINJACOREAPI BNQualifiedName BNTypeGetStructureName(BNType* type) { __debugbreak(); return {}; } 133 | BINARYNINJACOREAPI BNNamedTypeReference* BNGetRegisteredTypeName(BNType* type) { __debugbreak(); return {}; } 134 | BINARYNINJACOREAPI BNReferenceType BNTypeGetReferenceType(BNType* type) { __debugbreak(); return {}; } 135 | BINARYNINJACOREAPI BNPointerBaseType BNTypeGetPointerBaseType(BNType* type) { __debugbreak(); return {}; } 136 | BINARYNINJACOREAPI int64_t BNTypeGetPointerBaseOffset(BNType* type) { __debugbreak(); return {}; } 137 | BINARYNINJACOREAPI char* BNGetTypeAlternateName(BNType* type) { __debugbreak(); return {}; } 138 | BINARYNINJACOREAPI uint32_t BNTypeGetSystemCallNumber(BNType* type) { __debugbreak(); return {}; } 139 | BINARYNINJACOREAPI bool BNTypeIsSystemCall(BNType* type) { __debugbreak(); return {}; } 140 | BINARYNINJACOREAPI BNPointerSuffix* BNGetTypePointerSuffix(BNType* type, size_t* count) { __debugbreak(); return {}; } 141 | BINARYNINJACOREAPI char* BNGetTypePointerSuffixString(BNType* type) { __debugbreak(); return {}; } 142 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypePointerSuffixTokens( 143 | BNType* type, uint8_t baseConfidence, size_t* count) { __debugbreak(); return {}; } 144 | BINARYNINJACOREAPI void BNFreePointerSuffixList(BNPointerSuffix* suffix, size_t count) { __debugbreak(); } 145 | 146 | BINARYNINJACOREAPI char* BNGetTypeString(BNType* type, BNPlatform* platform, BNTokenEscapingType escaping) { __debugbreak(); return {}; } 147 | BINARYNINJACOREAPI char* BNGetTypeStringBeforeName(BNType* type, BNPlatform* platform, BNTokenEscapingType escaping) { __debugbreak(); return {}; } 148 | BINARYNINJACOREAPI char* BNGetTypeStringAfterName(BNType* type, BNPlatform* platform, BNTokenEscapingType escaping) { __debugbreak(); return {}; } 149 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeTokens( 150 | BNType* type, BNPlatform* platform, uint8_t baseConfidence, BNTokenEscapingType escaping, size_t* count) { __debugbreak(); return {}; } 151 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeTokensBeforeName( 152 | BNType* type, BNPlatform* platform, uint8_t baseConfidence, BNTokenEscapingType escaping, size_t* count) { __debugbreak(); return {}; } 153 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeTokensAfterName( 154 | BNType* type, BNPlatform* platform, uint8_t baseConfidence, BNTokenEscapingType escaping, size_t* count) { __debugbreak(); return {}; } 155 | 156 | BINARYNINJACOREAPI BNType* BNTypeWithReplacedStructure(BNType* type, BNStructure* from, BNStructure* to) { __debugbreak(); return {}; } 157 | BINARYNINJACOREAPI BNType* BNTypeWithReplacedEnumeration(BNType* type, BNEnumeration* from, BNEnumeration* to) { __debugbreak(); return {}; } 158 | BINARYNINJACOREAPI BNType* BNTypeWithReplacedNamedTypeReference( 159 | BNType* type, BNNamedTypeReference* from, BNNamedTypeReference* to) { __debugbreak(); return {}; } 160 | 161 | BINARYNINJACOREAPI bool BNAddTypeMemberTokens(BNType* type, BNBinaryView* data, BNInstructionTextToken** tokens, 162 | size_t* tokenCount, int64_t offset, char*** nameList, size_t* nameCount, size_t size, bool indirect) { __debugbreak(); return {}; } 163 | BINARYNINJACOREAPI BNTypeDefinitionLine* BNGetTypeLines(BNType* type, BNTypeContainer* types, const char* name, 164 | int paddingCols, bool collapsed, BNTokenEscapingType escaping, size_t* count) { __debugbreak(); return {}; } 165 | BINARYNINJACOREAPI void BNFreeTypeDefinitionLineList(BNTypeDefinitionLine* list, size_t count) { __debugbreak(); } 166 | 167 | BINARYNINJACOREAPI BNQualifiedName BNTypeBuilderGetTypeName(BNTypeBuilder* nt) { __debugbreak(); return {}; } 168 | BINARYNINJACOREAPI void BNTypeBuilderSetTypeName(BNTypeBuilder* type, BNQualifiedName* name) { __debugbreak(); } 169 | BINARYNINJACOREAPI void BNTypeBuilderSetAlternateName(BNTypeBuilder* type, const char* name) { __debugbreak(); } 170 | BINARYNINJACOREAPI BNTypeClass BNGetTypeBuilderClass(BNTypeBuilder* type) { __debugbreak(); return {}; } 171 | BINARYNINJACOREAPI void BNTypeBuilderSetSystemCallNumber(BNTypeBuilder* type, bool v, uint32_t n) { __debugbreak(); } 172 | BINARYNINJACOREAPI uint64_t BNGetTypeBuilderWidth(BNTypeBuilder* type) { __debugbreak(); return {}; } 173 | BINARYNINJACOREAPI size_t BNGetTypeBuilderAlignment(BNTypeBuilder* type) { __debugbreak(); return {}; } 174 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeBuilderSigned(BNTypeBuilder* type) { __debugbreak(); return {}; } 175 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeBuilderConst(BNTypeBuilder* type) { __debugbreak(); return {}; } 176 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeBuilderVolatile(BNTypeBuilder* type) { __debugbreak(); return {}; } 177 | BINARYNINJACOREAPI bool BNIsTypeBuilderFloatingPoint(BNTypeBuilder* type) { __debugbreak(); return {}; } 178 | BINARYNINJACOREAPI BNTypeWithConfidence BNGetTypeBuilderChildType(BNTypeBuilder* type) { __debugbreak(); return {}; } 179 | BINARYNINJACOREAPI BNCallingConventionWithConfidence BNGetTypeBuilderCallingConvention(BNTypeBuilder* type) { __debugbreak(); return {}; } 180 | BINARYNINJACOREAPI BNFunctionParameter* BNGetTypeBuilderParameters(BNTypeBuilder* type, size_t* count) { __debugbreak(); return {}; } 181 | BINARYNINJACOREAPI BNBoolWithConfidence BNTypeBuilderHasVariableArguments(BNTypeBuilder* type) { __debugbreak(); return {}; } 182 | BINARYNINJACOREAPI BNBoolWithConfidence BNFunctionTypeBuilderCanReturn(BNTypeBuilder* type) { __debugbreak(); return {}; } 183 | BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypeBuilderPure(BNTypeBuilder* type) { __debugbreak(); return {}; } 184 | BINARYNINJACOREAPI BNStructure* BNGetTypeBuilderStructure(BNTypeBuilder* type) { __debugbreak(); return {}; } 185 | BINARYNINJACOREAPI BNEnumeration* BNGetTypeBuilderEnumeration(BNTypeBuilder* type) { __debugbreak(); return {}; } 186 | BINARYNINJACOREAPI BNNamedTypeReference* BNGetTypeBuilderNamedTypeReference(BNTypeBuilder* type) { __debugbreak(); return {}; } 187 | BINARYNINJACOREAPI void BNSetTypeBuilderNamedTypeReference(BNTypeBuilder* type, BNNamedTypeReference* ntr) { __debugbreak(); } 188 | BINARYNINJACOREAPI uint64_t BNGetTypeBuilderElementCount(BNTypeBuilder* type) { __debugbreak(); return {}; } 189 | BINARYNINJACOREAPI uint64_t BNGetTypeBuilderOffset(BNTypeBuilder* type) { __debugbreak(); return {}; } 190 | BINARYNINJACOREAPI void BNSetTypeBuilderOffset(BNTypeBuilder* type, uint64_t offset) { __debugbreak(); } 191 | BINARYNINJACOREAPI void BNSetTypeBuilderPointerBase( 192 | BNTypeBuilder* type, BNPointerBaseType baseType, int64_t baseOffset) { __debugbreak(); } 193 | BINARYNINJACOREAPI void BNSetFunctionTypeBuilderCanReturn(BNTypeBuilder* type, BNBoolWithConfidence* canReturn) { __debugbreak(); } 194 | BINARYNINJACOREAPI void BNSetTypeBuilderPure(BNTypeBuilder* type, BNBoolWithConfidence* pure) { __debugbreak(); } 195 | BINARYNINJACOREAPI void BNSetFunctionTypeBuilderParameters( 196 | BNTypeBuilder* type, BNFunctionParameter* params, size_t paramCount) { __debugbreak(); } 197 | BINARYNINJACOREAPI void BNTypeBuilderSetWidth(BNTypeBuilder* type, size_t width) { __debugbreak(); } 198 | BINARYNINJACOREAPI void BNTypeBuilderSetAlignment(BNTypeBuilder* type, size_t alignment) { __debugbreak(); } 199 | BINARYNINJACOREAPI void BNTypeBuilderSetConst(BNTypeBuilder* type, BNBoolWithConfidence* cnst) { __debugbreak(); } 200 | BINARYNINJACOREAPI void BNTypeBuilderSetVolatile(BNTypeBuilder* type, BNBoolWithConfidence* vltl) { __debugbreak(); } 201 | BINARYNINJACOREAPI void BNTypeBuilderSetSigned(BNTypeBuilder* type, BNBoolWithConfidence* sign) { __debugbreak(); } 202 | BINARYNINJACOREAPI void BNTypeBuilderSetChildType(BNTypeBuilder* type, BNTypeWithConfidence* child) { __debugbreak(); } 203 | BINARYNINJACOREAPI BNOffsetWithConfidence BNGetTypeBuilderStackAdjustment(BNTypeBuilder* type) { __debugbreak(); return {}; } 204 | BINARYNINJACOREAPI BNQualifiedName BNTypeBuilderGetStructureName(BNTypeBuilder* type) { __debugbreak(); return {}; } 205 | BINARYNINJACOREAPI BNReferenceType BNTypeBuilderGetReferenceType(BNTypeBuilder* type) { __debugbreak(); return {}; } 206 | BINARYNINJACOREAPI BNPointerBaseType BNTypeBuilderGetPointerBaseType(BNTypeBuilder* type) { __debugbreak(); return {}; } 207 | BINARYNINJACOREAPI int64_t BNTypeBuilderGetPointerBaseOffset(BNTypeBuilder* type) { __debugbreak(); return {}; } 208 | BINARYNINJACOREAPI char* BNGetTypeBuilderAlternateName(BNTypeBuilder* type) { __debugbreak(); return {}; } 209 | BINARYNINJACOREAPI bool BNTypeBuilderIsSystemCall(BNTypeBuilder* type) { __debugbreak(); return {}; } 210 | BINARYNINJACOREAPI uint32_t BNTypeBuilderGetSystemCallNumber(BNTypeBuilder* type) { __debugbreak(); return {}; } 211 | BINARYNINJACOREAPI void BNTypeBuilderSetStackAdjustment(BNTypeBuilder* type, BNOffsetWithConfidence* adjust) { __debugbreak(); } 212 | BINARYNINJACOREAPI BNPointerSuffix* BNGetTypeBuilderPointerSuffix(BNTypeBuilder* type, size_t* count) { __debugbreak(); return {}; } 213 | BINARYNINJACOREAPI char* BNGetTypeBuilderPointerSuffixString(BNTypeBuilder* type) { __debugbreak(); return {}; } 214 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeBuilderPointerSuffixTokens( 215 | BNTypeBuilder* type, uint8_t baseConfidence, size_t* count) { __debugbreak(); return {}; } 216 | BINARYNINJACOREAPI void BNAddTypeBuilderPointerSuffix(BNTypeBuilder* type, BNPointerSuffix ps) { __debugbreak(); } 217 | BINARYNINJACOREAPI void BNSetTypeBuilderPointerSuffix(BNTypeBuilder* type, BNPointerSuffix* suffix, size_t count) { __debugbreak(); } 218 | 219 | BINARYNINJACOREAPI char* BNGetTypeBuilderString(BNTypeBuilder* type, BNPlatform* platform) { __debugbreak(); return {}; } 220 | BINARYNINJACOREAPI char* BNGetTypeBuilderStringBeforeName(BNTypeBuilder* type, BNPlatform* platform) { __debugbreak(); return {}; } 221 | BINARYNINJACOREAPI char* BNGetTypeBuilderStringAfterName(BNTypeBuilder* type, BNPlatform* platform) { __debugbreak(); return {}; } 222 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeBuilderTokens( 223 | BNTypeBuilder* type, BNPlatform* platform, uint8_t baseConfidence, size_t* count) { __debugbreak(); return {}; } 224 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeBuilderTokensBeforeName( 225 | BNTypeBuilder* type, BNPlatform* platform, uint8_t baseConfidence, size_t* count) { __debugbreak(); return {}; } 226 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeBuilderTokensAfterName( 227 | BNTypeBuilder* type, BNPlatform* platform, uint8_t baseConfidence, size_t* count) { __debugbreak(); return {}; } 228 | 229 | BINARYNINJACOREAPI BNType* BNCreateNamedTypeReference( 230 | BNNamedTypeReference* nt, size_t width, size_t align, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl) { __debugbreak(); return {}; } 231 | BINARYNINJACOREAPI BNType* BNCreateNamedTypeReferenceFromTypeAndId(const char* id, BNQualifiedName* name, BNType* type) { __debugbreak(); return {}; } 232 | BINARYNINJACOREAPI BNType* BNCreateNamedTypeReferenceFromType(BNBinaryView* view, BNQualifiedName* name) { __debugbreak(); return {}; } 233 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilder( 234 | BNNamedTypeReference* nt, size_t width, size_t align, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl) { __debugbreak(); return {}; } 235 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderWithBuilder(BNNamedTypeReferenceBuilder* nt, 236 | size_t width, size_t align, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl) { __debugbreak(); return {}; } 237 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderFromTypeAndId( 238 | const char* id, BNQualifiedName* name, BNType* type) { __debugbreak(); return {}; } 239 | BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderFromType(BNBinaryView* view, BNQualifiedName* name) { __debugbreak(); return {}; } 240 | BINARYNINJACOREAPI BNNamedTypeReference* BNCreateNamedType( 241 | BNNamedTypeReferenceClass cls, const char* id, BNQualifiedName* name) { __debugbreak(); return {}; } 242 | BINARYNINJACOREAPI BNNamedTypeReferenceClass BNGetTypeReferenceClass(BNNamedTypeReference* nt) { __debugbreak(); return {}; } 243 | BINARYNINJACOREAPI char* BNGetTypeReferenceId(BNNamedTypeReference* nt) { __debugbreak(); return {}; } 244 | BINARYNINJACOREAPI BNQualifiedName BNGetTypeReferenceName(BNNamedTypeReference* nt) { __debugbreak(); return {}; } 245 | BINARYNINJACOREAPI void BNFreeQualifiedName(BNQualifiedName* name) { __debugbreak(); } 246 | BINARYNINJACOREAPI void BNFreeQualifiedNameArray(BNQualifiedName* names, size_t count) { __debugbreak(); } 247 | BINARYNINJACOREAPI void BNFreeNamedTypeReference(BNNamedTypeReference* nt) { __debugbreak(); } 248 | BINARYNINJACOREAPI BNNamedTypeReference* BNNewNamedTypeReference(BNNamedTypeReference* nt) { __debugbreak(); return {}; } 249 | 250 | BINARYNINJACOREAPI BNNamedTypeReferenceBuilder* BNCreateNamedTypeBuilder( 251 | BNNamedTypeReferenceClass cls, const char* id, BNQualifiedName* name) { __debugbreak(); return {}; } 252 | BINARYNINJACOREAPI void BNFreeNamedTypeReferenceBuilder(BNNamedTypeReferenceBuilder* s) { __debugbreak(); } 253 | BINARYNINJACOREAPI void BNSetNamedTypeReferenceBuilderTypeClass( 254 | BNNamedTypeReferenceBuilder* s, BNNamedTypeReferenceClass type) { __debugbreak(); } 255 | BINARYNINJACOREAPI void BNSetNamedTypeReferenceBuilderTypeId(BNNamedTypeReferenceBuilder* s, const char* id) { __debugbreak(); } 256 | BINARYNINJACOREAPI void BNSetNamedTypeReferenceBuilderName(BNNamedTypeReferenceBuilder* s, BNQualifiedName* name) { __debugbreak(); } 257 | BINARYNINJACOREAPI BNNamedTypeReference* BNFinalizeNamedTypeReferenceBuilder(BNNamedTypeReferenceBuilder* s) { __debugbreak(); return {}; } 258 | BINARYNINJACOREAPI BNNamedTypeReferenceClass BNGetTypeReferenceBuilderClass(BNNamedTypeReferenceBuilder* nt) { __debugbreak(); return {}; } 259 | BINARYNINJACOREAPI char* BNGetTypeReferenceBuilderId(BNNamedTypeReferenceBuilder* nt) { __debugbreak(); return {}; } 260 | BINARYNINJACOREAPI BNQualifiedName BNGetTypeReferenceBuilderName(BNNamedTypeReferenceBuilder* nt) { __debugbreak(); return {}; } 261 | 262 | BINARYNINJACOREAPI BNStructureBuilder* BNCreateStructureBuilder(void) { __debugbreak(); return {}; } 263 | BINARYNINJACOREAPI BNStructureBuilder* BNCreateStructureBuilderWithOptions(BNStructureVariant type, bool packed) { __debugbreak(); return {}; } 264 | BINARYNINJACOREAPI BNStructureBuilder* BNCreateStructureBuilderFromStructure(BNStructure* s) { __debugbreak(); return {}; } 265 | BINARYNINJACOREAPI BNStructureBuilder* BNDuplicateStructureBuilder(BNStructureBuilder* s) { __debugbreak(); return {}; } 266 | BINARYNINJACOREAPI BNStructure* BNFinalizeStructureBuilder(BNStructureBuilder* s) { __debugbreak(); return {}; } 267 | BINARYNINJACOREAPI BNStructure* BNNewStructureReference(BNStructure* s) { __debugbreak(); return {}; } 268 | BINARYNINJACOREAPI void BNFreeStructure(BNStructure* s) { __debugbreak(); } 269 | BINARYNINJACOREAPI void BNFreeStructureBuilder(BNStructureBuilder* s) { __debugbreak(); } 270 | 271 | BINARYNINJACOREAPI BNStructureMember* BNGetStructureMemberByName(BNStructure* s, const char* name) { __debugbreak(); return {}; } 272 | BINARYNINJACOREAPI BNStructureMember* BNGetStructureMemberAtOffset(BNStructure* s, int64_t offset, size_t* idx) { __debugbreak(); return {}; } 273 | BINARYNINJACOREAPI void BNFreeStructureMember(BNStructureMember* s) { __debugbreak(); } 274 | BINARYNINJACOREAPI BNStructureMember* BNGetStructureMembers(BNStructure* s, size_t* count) { __debugbreak(); return {}; } 275 | BINARYNINJACOREAPI void BNFreeStructureMemberList(BNStructureMember* members, size_t count) { __debugbreak(); } 276 | BINARYNINJACOREAPI BNInheritedStructureMember* BNGetStructureMembersIncludingInherited( 277 | BNStructure* s, BNTypeContainer* types, size_t* count) { __debugbreak(); return {}; } 278 | BINARYNINJACOREAPI void BNFreeInheritedStructureMemberList(BNInheritedStructureMember* members, size_t count) { __debugbreak(); } 279 | BINARYNINJACOREAPI BNInheritedStructureMember* BNGetMemberIncludingInheritedAtOffset( 280 | BNStructure* s, BNBinaryView* view, int64_t offset) { __debugbreak(); return {}; } 281 | BINARYNINJACOREAPI void BNFreeInheritedStructureMember(BNInheritedStructureMember* members) { __debugbreak(); } 282 | BINARYNINJACOREAPI uint64_t BNGetStructureWidth(BNStructure* s) { __debugbreak(); return {}; } 283 | BINARYNINJACOREAPI int64_t BNGetStructurePointerOffset(BNStructure* s) { __debugbreak(); return {}; } 284 | BINARYNINJACOREAPI size_t BNGetStructureAlignment(BNStructure* s) { __debugbreak(); return {}; } 285 | BINARYNINJACOREAPI bool BNIsStructurePacked(BNStructure* s) { __debugbreak(); return {}; } 286 | BINARYNINJACOREAPI bool BNIsStructureUnion(BNStructure* s) { __debugbreak(); return {}; } 287 | BINARYNINJACOREAPI bool BNStructurePropagatesDataVariableReferences(BNStructure* s) { __debugbreak(); return {}; } 288 | BINARYNINJACOREAPI BNStructureVariant BNGetStructureType(BNStructure* s) { __debugbreak(); return {}; } 289 | BINARYNINJACOREAPI BNBaseStructure* BNGetBaseStructuresForStructure(BNStructure* s, size_t* count) { __debugbreak(); return {}; } 290 | BINARYNINJACOREAPI void BNFreeBaseStructureList(BNBaseStructure* bases, size_t count) { __debugbreak(); } 291 | 292 | BINARYNINJACOREAPI BNStructure* BNStructureWithReplacedStructure(BNStructure* s, BNStructure* from, BNStructure* to) { __debugbreak(); return {}; } 293 | BINARYNINJACOREAPI BNStructure* BNStructureWithReplacedEnumeration( 294 | BNStructure* s, BNEnumeration* from, BNEnumeration* to) { __debugbreak(); return {}; } 295 | BINARYNINJACOREAPI BNStructure* BNStructureWithReplacedNamedTypeReference( 296 | BNStructure* s, BNNamedTypeReference* from, BNNamedTypeReference* to) { __debugbreak(); return {}; } 297 | 298 | BINARYNINJACOREAPI BNStructureMember* BNGetStructureBuilderMemberByName(BNStructureBuilder* s, const char* name) { __debugbreak(); return {}; } 299 | BINARYNINJACOREAPI BNStructureMember* BNGetStructureBuilderMemberAtOffset( 300 | BNStructureBuilder* s, int64_t offset, size_t* idx) { __debugbreak(); return {}; } 301 | BINARYNINJACOREAPI BNStructureMember* BNGetStructureBuilderMembers(BNStructureBuilder* s, size_t* count) { __debugbreak(); return {}; } 302 | BINARYNINJACOREAPI uint64_t BNGetStructureBuilderWidth(BNStructureBuilder* s) { __debugbreak(); return {}; } 303 | BINARYNINJACOREAPI void BNSetStructureBuilderWidth(BNStructureBuilder* s, uint64_t width) { __debugbreak(); } 304 | BINARYNINJACOREAPI int64_t BNGetStructureBuilderPointerOffset(BNStructureBuilder* s) { __debugbreak(); return {}; } 305 | BINARYNINJACOREAPI void BNSetStructureBuilderPointerOffset(BNStructureBuilder* s, int64_t offset) { __debugbreak(); } 306 | BINARYNINJACOREAPI size_t BNGetStructureBuilderAlignment(BNStructureBuilder* s) { __debugbreak(); return {}; } 307 | BINARYNINJACOREAPI void BNSetStructureBuilderAlignment(BNStructureBuilder* s, size_t align) { __debugbreak(); } 308 | BINARYNINJACOREAPI bool BNIsStructureBuilderPacked(BNStructureBuilder* s) { __debugbreak(); return {}; } 309 | BINARYNINJACOREAPI void BNSetStructureBuilderPacked(BNStructureBuilder* s, bool packed) { __debugbreak(); } 310 | BINARYNINJACOREAPI bool BNIsStructureBuilderUnion(BNStructureBuilder* s) { __debugbreak(); return {}; } 311 | BINARYNINJACOREAPI void BNSetStructureBuilderType(BNStructureBuilder* s, BNStructureVariant type) { __debugbreak(); } 312 | BINARYNINJACOREAPI bool BNStructureBuilderPropagatesDataVariableReferences(BNStructureBuilder* s) { __debugbreak(); return {}; } 313 | BINARYNINJACOREAPI void BNSetStructureBuilderPropagatesDataVariableReferences(BNStructureBuilder* s, bool value) { __debugbreak(); } 314 | BINARYNINJACOREAPI BNStructureVariant BNGetStructureBuilderType(BNStructureBuilder* s) { __debugbreak(); return {}; } 315 | BINARYNINJACOREAPI BNBaseStructure* BNGetBaseStructuresForStructureBuilder(BNStructureBuilder* s, size_t* count) { __debugbreak(); return {}; } 316 | BINARYNINJACOREAPI void BNSetBaseStructuresForStructureBuilder( 317 | BNStructureBuilder* s, BNBaseStructure* bases, size_t count) { __debugbreak(); } 318 | 319 | BINARYNINJACOREAPI void BNAddStructureBuilderMember(BNStructureBuilder* s, const BNTypeWithConfidence* const type, 320 | const char* name, BNMemberAccess access, BNMemberScope scope) { __debugbreak(); } 321 | BINARYNINJACOREAPI void BNAddStructureBuilderMemberAtOffset(BNStructureBuilder* s, 322 | const BNTypeWithConfidence* const type, const char* name, uint64_t offset, bool overwriteExisting, 323 | BNMemberAccess access, BNMemberScope scope) { __debugbreak(); } 324 | BINARYNINJACOREAPI void BNRemoveStructureBuilderMember(BNStructureBuilder* s, size_t idx) { __debugbreak(); } 325 | BINARYNINJACOREAPI void BNReplaceStructureBuilderMember(BNStructureBuilder* s, size_t idx, 326 | const BNTypeWithConfidence* const type, const char* name, bool overwriteExisting) { __debugbreak(); } 327 | 328 | BINARYNINJACOREAPI BNEnumerationBuilder* BNCreateEnumerationBuilder(void) { __debugbreak(); return {}; } 329 | BINARYNINJACOREAPI BNEnumerationBuilder* BNCreateEnumerationBuilderFromEnumeration(BNEnumeration* e) { __debugbreak(); return {}; } 330 | BINARYNINJACOREAPI BNEnumerationBuilder* BNDuplicateEnumerationBuilder(BNEnumerationBuilder* e) { __debugbreak(); return {}; } 331 | BINARYNINJACOREAPI BNEnumeration* BNFinalizeEnumerationBuilder(BNEnumerationBuilder* e) { __debugbreak(); return {}; } 332 | BINARYNINJACOREAPI BNEnumeration* BNNewEnumerationReference(BNEnumeration* e) { __debugbreak(); return {}; } 333 | BINARYNINJACOREAPI void BNFreeEnumeration(BNEnumeration* e) { __debugbreak(); } 334 | BINARYNINJACOREAPI void BNFreeEnumerationBuilder(BNEnumerationBuilder* e) { __debugbreak(); } 335 | 336 | BINARYNINJACOREAPI BNEnumerationMember* BNGetEnumerationMembers(BNEnumeration* e, size_t* count) { __debugbreak(); return {}; } 337 | BINARYNINJACOREAPI BNInstructionTextToken* BNGetEnumerationTokensForValue( 338 | BNEnumeration* e, uint64_t value, uint64_t width, size_t* count, BNType* type) { __debugbreak(); return {}; } 339 | BINARYNINJACOREAPI void BNFreeEnumerationMemberList(BNEnumerationMember* members, size_t count) { __debugbreak(); } 340 | 341 | BINARYNINJACOREAPI BNEnumerationMember* BNGetEnumerationBuilderMembers(BNEnumerationBuilder* e, size_t* count) { __debugbreak(); return {}; } 342 | 343 | BINARYNINJACOREAPI void BNAddEnumerationBuilderMember(BNEnumerationBuilder* e, const char* name) { __debugbreak(); } 344 | BINARYNINJACOREAPI void BNAddEnumerationBuilderMemberWithValue( 345 | BNEnumerationBuilder* e, const char* name, uint64_t value) { __debugbreak(); } 346 | BINARYNINJACOREAPI void BNRemoveEnumerationBuilderMember(BNEnumerationBuilder* e, size_t idx) { __debugbreak(); } 347 | BINARYNINJACOREAPI void BNReplaceEnumerationBuilderMember( 348 | BNEnumerationBuilder* e, size_t idx, const char* name, uint64_t value) { __debugbreak(); } 349 | 350 | BINARYNINJACOREAPI BNStructure* BNCreateStructureFromOffsetAccess( 351 | BNBinaryView* view, BNQualifiedName* name, bool* newMember) { __debugbreak(); return {}; } 352 | BINARYNINJACOREAPI BNTypeWithConfidence BNCreateStructureMemberFromAccess( 353 | BNBinaryView* view, BNQualifiedName* name, uint64_t offset) { __debugbreak(); return {}; } -------------------------------------------------------------------------------- /src/core_utils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if defined(_MSC_VER) 4 | #include 5 | #elif defined(__clang__) 6 | #define __debugbreak() __builtin_debugtrap() 7 | #elif defined(__GNUC__) 8 | #define __debugbreak() __builtin_trap() 9 | #else 10 | #warning Unsupported platform/compiler 11 | #include 12 | #define __debugbreak() raise(SIGTRAP) 13 | #endif // _MSC_VER 14 | 15 | #if defined(_MSC_VER) 16 | #define _strdup strdup 17 | #endif // _MSC_VER --------------------------------------------------------------------------------