{

length = 0;

archTransitionByTargetAddr = false;

branchCount = 0;

delaySlots = 0;

{

if (branchCount >= BN_MAX_INSTRUCTION_BRANCHES)

return;

delaySlots = delaySlot;

branchType[branchCount] = type;

branchTarget[branchCount] = target;

branchArch[branchCount++] = arch ? arch->GetObject() : nullptr;

type(TextToken), value(0), width(WidthIsByteCount), size(0), operand(BN_INVALID_OPERAND),

context(NoTokenContext), confidence(BN_FULL_CONFIDENCE), address(0), exprIndex(BN_INVALID_EXPR)

{

if (width == WidthIsByteCount)

{

width = text.size();

}

type(t), text(txt), value(0), width(WidthIsByteCount), size(0), operand(BN_INVALID_OPERAND),

context(NoTokenContext), confidence(confidence), address(0), exprIndex(BN_INVALID_EXPR)

{

if (width == WidthIsByteCount)

{

width = text.size();

}

size_t o, uint8_t c, const vector<string>& n, uint64_t w) :

type(t),

text(txt), value(val), width(w), size(s), operand(o), context(NoTokenContext), confidence(c), address(0),

typeNames(n), exprIndex(BN_INVALID_EXPR)

{

if (width == WidthIsByteCount)

{

width = text.size();

}

const string& txt, uint64_t a, uint64_t val, size_t s, size_t o, uint8_t c, const vector<string>& n, uint64_t w) :

type(t),

text(txt), value(val), width(w), size(s), operand(o), context(ctxt), confidence(c), address(a), typeNames(n),

exprIndex(BN_INVALID_EXPR)

{

if (width == WidthIsByteCount)

{

width = text.size();

}

type(token.type), text(token.text), value(token.value), width(token.width), size(token.size),

operand(token.operand), context(token.context), confidence(token.confidence), address(token.address),

exprIndex(token.exprIndex)

{

typeNames.reserve(token.namesCount);

for (size_t j = 0; j < token.namesCount; j++)

typeNames.push_back(token.typeNames[j]);

if (width == WidthIsByteCount)

{

width = text.size();

}

{

BNInstructionTextToken result;

ConvertInstructionTextToken(*this, &result);

return result;

{

result->type = token.type;

result->text = BNAllocString(token.text.c_str());

result->value = token.value;

result->width = token.width;

result->size = token.size;

result->operand = token.operand;

result->context = token.context;

result->confidence = token.confidence;

result->address = token.address;

result->typeNames = new char*[token.typeNames.size()];

for (size_t i = 0; i < token.typeNames.size(); i++)

result->typeNames[i] = BNAllocString(token.typeNames[i].c_str());

result->namesCount = token.typeNames.size();

result->exprIndex = token.exprIndex;

BNInstructionTextToken* tokens, size_t count)

{

auto result = ConvertInstructionTextTokenList(tokens, count);

BNFreeInstructionText(tokens, count);

return result;

{

BNFreeString(token->text);

for (size_t j = 0; j < token->namesCount; j++)

BNFreeString(token->typeNames[j]);

delete[] token->typeNames;

{

for (size_t i = 0; i < count; i++)

FreeInstructionTextToken(&tokens[i]);

delete[] tokens;

const BNInstructionTextToken* tokens, size_t count)

{

vector<InstructionTextToken> result;

result.reserve(count);

for (size_t i = 0; i < count; i++)

result.emplace_back(tokens[i]);

return result;

{

size_t len = 0;

const uint8_t* opcode = BNLifterInstructionDataGet(m_object, block->GetObject(), addr, &len);

if (!opcode)

return {};

return std::span<const uint8_t>(opcode, len);

{

m_context = context;

if (context->lifterInstructionData)

{

m_lifterInstructionData =

new LifterInstructionData(BNNewLifterInstructionDataReference(context->lifterInstructionData));

}

{

if (!m_indirectBranches)

{

auto& indirectBranches = m_indirectBranches.emplace();

for (size_t i = 0; i < m_context->indirectBranchesCount; i++)

{

ArchAndAddr src(new CoreArchitecture(m_context->indirectBranches[i].sourceArch), m_context->indirectBranches[i].sourceAddr);

ArchAndAddr dst(new CoreArchitecture(m_context->indirectBranches[i].destArch), m_context->indirectBranches[i].destAddr);

indirectBranches[src].insert(dst);

}

}

return *m_indirectBranches;

{

if (m_context->functionArchContext)

return false;

m_context->functionArchContext = p;

return true;

{

BNBasicBlock* block = BNAnalyzeBasicBlocksContextCreateBasicBlock(m_context, arch->GetObject(), start);

if (!block)

return nullptr;

return new BasicBlock(block);

{

if (m_directCodeReferences)

{

auto& directRefs = *m_directCodeReferences;

size_t total = 0;

for (auto& pair : directRefs)

total += pair.second.size();

BNArchitectureAndAddress* sources = new BNArchitectureAndAddress[total];

uint64_t* targets = new uint64_t[total];

size_t i = 0;

for (auto& pair : directRefs)

{

for (auto& src : pair.second)

{

sources[i].arch = src.arch->GetObject();

sources[i].address = src.address;

targets[i] = pair.first;

i++;

}

}

BNAnalyzeBasicBlocksContextSetDirectCodeReferences(m_context, sources, targets, total);

delete[] sources;

delete[] targets;

}

if (m_directNoReturnCalls)

{

auto& directNoReturnCalls = *m_directNoReturnCalls;

BNArchitectureAndAddress* noRets = new BNArchitectureAndAddress[directNoReturnCalls.size()];

size_t i = 0;

for (auto& addr : directNoReturnCalls)

{

noRets[i].arch = addr.arch->GetObject();

noRets[i].address = addr.address;

i++;

}

BNAnalyzeBasicBlocksContextSetDirectNoReturnCalls(m_context, noRets, directNoReturnCalls.size());

delete[] noRets;

}

if (m_haltedDisassemblyAddresses)

{

auto& haltedDisassemblyAddresses = *m_haltedDisassemblyAddresses;

BNArchitectureAndAddress* haltedAddresses = new BNArchitectureAndAddress[haltedDisassemblyAddresses.size()];

size_t i = 0;

for (auto& addr : haltedDisassemblyAddresses)

{

haltedAddresses[i].arch = addr.arch->GetObject();

haltedAddresses[i].address = addr.address;

i++;

}

BNAnalyzeBasicBlocksContextSetHaltedDisassemblyAddresses(m_context, haltedAddresses, haltedDisassemblyAddresses.size());

delete[] haltedAddresses;

}

if (m_inlinedUnresolvedIndirectBranches)

{

auto& inlinedUnresolvedIndirectBranches = *m_inlinedUnresolvedIndirectBranches;

BNArchitectureAndAddress* locations = new BNArchitectureAndAddress[inlinedUnresolvedIndirectBranches.size() * 2];

size_t i = 0;

for (auto& pair : inlinedUnresolvedIndirectBranches)

{

locations[i].arch = pair.first.arch->GetObject();

locations[i].address = pair.first.address;

locations[i + 1].arch = pair.second.arch->GetObject();

locations[i + 1].address = pair.second.address;

i += 2;

}

BNAnalyzeBasicBlocksContextSetInlinedUnresolvedIndirectBranches(m_context, locations, inlinedUnresolvedIndirectBranches.size() * 2);

delete[] locations;

}

if (m_contextualReturns)

{

auto& contextualReturns = *m_contextualReturns;

bool dirty = contextualReturns.size() != m_context->contextualFunctionReturnCount;

if (!dirty)

{

size_t i = 0;

for (auto& pair : contextualReturns)

{

if (pair.first.arch->GetObject() != m_context->contextualFunctionReturnLocations[i].arch

|| pair.first.address != m_context->contextualFunctionReturnLocations[i].address

|| pair.second != m_context->contextualFunctionReturnValues[i])

{

dirty = true;

break;

}

i++;

}

}

if (dirty)

{

BNArchitectureAndAddress* returns = new BNArchitectureAndAddress[contextualReturns.size()];

bool* values = new bool[contextualReturns.size()];

size_t i = 0;

for (auto& pair : contextualReturns)

{

returns[i].arch = pair.first.arch->GetObject();

returns[i].address = pair.first.address;

values[i] = pair.second;

i++;

}

BNAnalyzeBasicBlocksContextSetContextualFunctionReturns(m_context, returns, values, contextualReturns.size());

delete[] returns;

delete[] values;

}

}

{

m_context = context;

m_view = func->GetFunction()->GetView();

m_function = new LowLevelILFunction(BNNewLowLevelILFunctionReference(func->GetObject()));

m_platform = new Platform(BNNewPlatformReference(context->platform));

m_logger = new Logger(BNNewLoggerReference(context->logger));

m_blocks.reserve(context->basicBlockCount);

for (size_t i = 0; i < context->basicBlockCount; i++)

{

m_blocks.emplace_back(new BasicBlock(BNNewBasicBlockReference(context->basicBlocks[i])));

}

for (size_t i = 0; i < context->noReturnCallsCount; i++)

{

ArchAndAddr addr(new CoreArchitecture(context->noReturnCalls[i].arch), context->noReturnCalls[i].address);

m_noReturnCalls.insert(addr);

}

for (size_t i = 0; i < context->contextualFunctionReturnCount; i++)

{

ArchAndAddr addr(new CoreArchitecture(context->contextualFunctionReturnLocations[i].arch),

context->contextualFunctionReturnLocations[i].address);

m_contextualReturns[addr] = context->contextualFunctionReturnValues[i];

}

for (size_t i = 0; i < context->inlinedRemappingEntryCount; i++)

{

ArchAndAddr key(

new CoreArchitecture(context->inlinedRemappingKeys[i].arch), context->inlinedRemappingKeys[i].address);

ArchAndAddr value(

new CoreArchitecture(context->inlinedRemappingValues[i].arch), context->inlinedRemappingValues[i].address);

m_inlinedRemapping[key] = value;

}

for (size_t i = 0; i < context->indirectBranchesCount; i++)

{

ArchAndAddr src(

new CoreArchitecture(context->indirectBranches[i].sourceArch), context->indirectBranches[i].sourceAddr);

ArchAndAddr dest(

new CoreArchitecture(context->indirectBranches[i].destArch), context->indirectBranches[i].destAddr);

if (context->indirectBranches[i].autoDefined)

m_autoIndirectBranches[src].insert(dest);

else

m_userIndirectBranches[src].insert(dest);

}

for (size_t i = 0; i < context->inlinedCallsCount; i++)

{

m_inlinedCalls.insert(context->inlinedCalls[i]);

}

m_functionArchContext = context->functionArchContext;

if (context->lifterInstructionData)

{

m_lifterInstructionData =

new LifterInstructionData(BNNewLifterInstructionDataReference(context->lifterInstructionData));

}

m_containsInlinedFunctions = context->containsInlinedFunctions;

{

size_t blockCount = 0;

BNBasicBlock** bnBlocks =

BNPrepareToCopyForeignFunction(m_function->GetObject(), function->GetObject(), &blockCount);

std::vector<Ref<BasicBlock>> blocks;

blocks.reserve(blockCount);

for (size_t i = 0; i < blockCount; i++)

blocks.emplace_back(new BasicBlock(BNNewBasicBlockReference(bnBlocks[i])));

BNFreeBasicBlockList(bnBlocks, blockCount);

return blocks;

{

size_t inlinedCallsCount = m_inlinedCalls.size();

uint64_t* inlinedCalls = nullptr;

if (inlinedCallsCount)

{

inlinedCalls = new uint64_t[inlinedCallsCount];

size_t i = 0;

for (uint64_t addr : m_inlinedCalls)

inlinedCalls[i++] = addr;

}

BNLowLevelILFunction* il =

BNGetForeignFunctionLiftedIL(func->GetObject(), m_logger->GetObject(), inlinedCallsCount, inlinedCalls);

if (inlinedCalls)

delete[] inlinedCalls;

if (!il)

return nullptr;

return new LowLevelILFunction(il);

{

CallbackRef<Architecture> arch(ctxt);

arch->m_object = obj;

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetEndianness();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetAddressSize();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetDefaultIntegerSize();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetInstructionAlignment();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetLinearSweepInitialAlignment();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetLinearSweepAnalysisCapabilities();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetMaxInstructionLength();

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetOpcodeDisplayLength();

void* ctxt, const uint8_t* data, uint64_t addr, size_t maxLen, BNInstructionInfo* result)

{

CallbackRef<Architecture> arch(ctxt);

InstructionInfo info;

info.delaySlots = result->delaySlots;

bool ok = arch->GetInstructionInfo(data, addr, maxLen, info);

*result = info;

return ok;

void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNInstructionTextToken** result, size_t* count)

{

CallbackRef<Architecture> arch(ctxt);

vector<InstructionTextToken> tokens;

bool ok = arch->GetInstructionText(data, addr, *len, tokens);

if (!ok)

{

*result = nullptr;

*count = 0;

return false;

}

*count = tokens.size();

*result = InstructionTextToken::CreateInstructionTextTokenList(tokens);

return true;

void* context, BNInstructionTextToken** result, size_t* count)

{

CallbackRef<Architecture> arch(ctxt);

vector<InstructionTextToken> tokens;

bool ok = arch->GetInstructionTextWithContext(data, addr, *len, context, tokens);

if (!ok)

{

*result = nullptr;

*count = 0;

return false;

}

*count = tokens.size();

*result = InstructionTextToken::CreateInstructionTextTokenList(tokens);

return true;

{

for (size_t i = 0; i < count; i++)

{

BNFreeString(tokens[i].text);

for (size_t j = 0; j < tokens[j].namesCount; j++)

BNFreeString(tokens[i].typeNames[j]);

delete[] tokens[i].typeNames;

}

delete[] tokens;

void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNLowLevelILFunction* il)

{

CallbackRef<Architecture> arch(ctxt);

Ref<LowLevelILFunction> func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(il)));

return arch->GetInstructionLowLevelIL(data, addr, *len, *func);

BNBasicBlockAnalysisContext* context)

{

CallbackRef<Architecture> arch(ctxt);

BasicBlockAnalysisContext abbc(context);

Ref<Function> func(new Function(BNNewFunctionReference(function)));

arch->AnalyzeBasicBlocks(func, abbc);

{

CallbackRef<Architecture> arch(ctxt);

Ref func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(function)));

FunctionLifterContext flc(func, context);

return arch->LiftFunction(func, flc);

{

CallbackRef<Architecture> arch(ctxt);

arch->FreeFunctionArchContext(context);

{

CallbackRef<Architecture> arch(ctxt);

return arch->GetFlagRole(flag, semClass);