{

BNFunction* func = BNGetHighLevelILOwnerFunction(m_object);

if (!func)

return nullptr;

return new Function(func);

{

Ref<Function> func = GetFunction();

if (!func)

return nullptr;

return func->GetArchitecture();

{

BNPossibleValueSet ugh = pvs.ToAPIObject();

return BNCacheHighLevelILPossibleValueSet(m_object, &ugh);

{

BNPossibleValueSet api = BNGetCachedHighLevelILPossibleValueSet(m_object, idx);

return PossibleValueSet::FromAPIObject(api);

BNHighLevelILOperation operation, size_t size, ExprId a, ExprId b, ExprId c, ExprId d, ExprId e)

{

return BNHighLevelILAddExpr(m_object, operation, size, a, b, c, d, e);

size_t size, ExprId a, ExprId b, ExprId c, ExprId d, ExprId e)

{

return BNHighLevelILAddExprWithLocation(m_object, operation, addr, sourceOperand, size, a, b, c, d, e);

size_t size, ExprId a, ExprId b, ExprId c, ExprId d, ExprId e)

{

if (loc.valid)

{

return BNHighLevelILAddExprWithLocation(

m_object, operation, loc.address, loc.sourceOperand, size, a, b, c, d, e);

}

return BNHighLevelILAddExpr(m_object, operation, size, a, b, c, d, e);

{

size_t count;

uint64_t* operands = BNHighLevelILGetOperandList(m_object, expr, listOperand, &count);

vector<uint64_t> result;

result.reserve(count);

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

result.push_back(operands[i]);

BNMediumLevelILFreeOperandList(operands);

return result;

{

uint64_t* operandList = new uint64_t[operands.size()];

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

operandList[i] = operands[i];

ExprId result = (ExprId)BNHighLevelILAddOperandList(m_object, operandList, operands.size());

delete[] operandList;

return result;

{

uint64_t* operandList = new uint64_t[operands.size()];

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

operandList[i] = operands[i];

ExprId result = (ExprId)BNHighLevelILAddOperandList(m_object, operandList, operands.size());

delete[] operandList;

return result;

{

uint64_t* operandList = new uint64_t[vars.size() * 2];

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

{

operandList[i * 2] = vars[i].var.ToIdentifier();

operandList[(i * 2) + 1] = vars[i].version;

}

ExprId result = (ExprId)BNHighLevelILAddOperandList(m_object, operandList, vars.size() * 2);

delete[] operandList;

return result;

{

size_t expr = GetIndexForInstruction(i);

return HighLevelILInstruction(this, GetRawNonASTExpr(expr), expr, false, i);

{

if (asFullAst)

return HighLevelILInstruction(this, GetRawExpr(i), i, true, GetInstructionForExpr(i));

return HighLevelILInstruction(this, GetRawNonASTExpr(i), i, false, GetInstructionForExpr(i));

{

size_t count;

BNBasicBlock** blocks = BNGetHighLevelILBasicBlockList(m_object, &count);

vector<Ref<BasicBlock>> result;

result.reserve(count);

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

result.push_back(new BasicBlock(BNNewBasicBlockReference(blocks[i])));

BNFreeBasicBlockList(blocks, count);

return result;

{

BNBasicBlock* block = BNGetHighLevelILBasicBlockForInstruction(m_object, i);

if (!block)

return nullptr;

return new BasicBlock(block);

{

BNHighLevelILFunction* func = BNGetHighLevelILSSAForm(m_object);

if (!func)

return nullptr;

return new HighLevelILFunction(func);

{

BNHighLevelILFunction* func = BNGetHighLevelILNonSSAForm(m_object);

if (!func)

return nullptr;

return new HighLevelILFunction(func);

{

size_t count;

size_t* instrs = BNGetHighLevelILSSAVarUses(m_object, &var.var, var.version, &count);

set<size_t> result;

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

result.insert(instrs[i]);

BNFreeILInstructionList(instrs);

return result;

{

size_t count;

size_t* instrs = BNGetHighLevelILSSAMemoryUses(m_object, version, &count);

set<size_t> result;

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

result.insert(instrs[i]);

BNFreeILInstructionList(instrs);

return result;

{

size_t count;

size_t* versions = BNGetHighLevelILVariableSSAVersions(m_object, &var, &count);

set<size_t> result;

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

result.insert(versions[i]);

BNFreeILInstructionList(versions);

return result;

{

size_t count;

size_t* instrs = BNGetHighLevelILVariableDefinitions(m_object, &var, &count);

set<size_t> result;

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

result.insert(instrs[i]);

BNFreeILInstructionList(instrs);

return result;

{

size_t count;

size_t* instrs = BNGetHighLevelILVariableUses(m_object, &var, &count);

set<size_t> result;

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

result.insert(instrs[i]);

BNFreeILInstructionList(instrs);

return result;

{

BNMediumLevelILFunction* result = BNGetMediumLevelILForHighLevelILFunction(m_object);

if (!result)

return nullptr;

return new MediumLevelILFunction(result);

{

size_t count;

size_t* exprs = BNGetMediumLevelILExprIndexesFromHighLevelIL(m_object, expr, &count);

set<size_t> result;

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

result.insert(exprs[i]);

BNFreeILInstructionList(exprs);

return result;

{

BNVariable* aliasList = new BNVariable[aliases.size()];

size_t i = 0;

for (auto& alias : aliases)

{

aliasList[i].type = alias.type;

aliasList[i].index = alias.index;

aliasList[i].storage = alias.storage;

i++;

}

BNGenerateHighLevelILSSAForm(m_object, aliasList, aliases.size());

delete[] aliasList;

{

size_t count;

BNDisassemblyTextLine* lines =

BNGetHighLevelILExprText(m_object, expr, asFullAst, &count, settings ? settings->GetObject() : nullptr);

vector<DisassemblyTextLine> result = ParseAPIObjectList<DisassemblyTextLine>(lines, count);

BNFreeDisassemblyTextLines(lines, count);

return result;

const HighLevelILInstruction& instr, DisassemblySettings* settings)

{

return GetExprText(instr.exprIndex, instr.ast, settings);

{

HighLevelILInstruction instr = GetInstruction(i);

return GetExprText(instr, settings);

{

BNTypeWithConfidence result = BNGetHighLevelILExprType(m_object, expr);

if (!result.type)

return nullptr;

return Confidence<Ref<Type>>(new Type(result.type), result.confidence);

{

BNTypeWithConfidence tc;

tc.type = type->GetObject();

tc.confidence = type.GetConfidence();

BNSetHighLevelILExprType(m_object, expr, &tc);

const Confidence<Ref<BinaryNinja::Type>>& type)

{

SetExprType(expr.exprIndex, type);

{

BNFlowGraph* graph = BNCreateHighLevelILFunctionGraph(m_object, settings ? settings->GetObject() : nullptr);

return new CoreFlowGraph(graph);

{

BNFlowGraph* graph = BNCreateHighLevelILImmediateFunctionGraph(m_object, settings ? settings->GetObject() : nullptr);

return new CoreFlowGraph(graph);

{

size_t count;

size_t* uses = BNGetHighLevelILUsesForLabel(m_object, label, &count);

set<size_t> result;

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

result.insert(uses[i]);

BNFreeILInstructionList(uses);

return result;

{

size_t count;

BNVariable* vars = BNGetHighLevelILVariables(m_object, &count);

set<Variable> result;

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

result.emplace(vars[i]);

BNFreeVariableList(vars);

return result;

{

size_t count;

BNVariable* vars = BNGetHighLevelILAliasedVariables(m_object, &count);

set<Variable> result;

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

result.emplace(vars[i]);

BNFreeVariableList(vars);

return result;

{

size_t count;

BNVariable* vars = BNGetHighLevelILVariables(m_object, &count);

set<SSAVariable> result;

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

{

size_t versionCount;

size_t* versions = BNGetHighLevelILVariableSSAVersions(m_object, &vars[i], &versionCount);

for (size_t j = 0; j < versionCount; ++j)

result.emplace(vars[i], versions[j]);

BNFreeILInstructionList(versions);

}

BNFreeVariableList(vars);

return result;

{

BNDerivedString strObj = str.ToAPIObject(false);

BNSetHighLevelILDerivedStringReferenceForExpr(m_object, expr, &strObj);

{

BNDerivedString str;

if (!BNGetHighLevelILDerivedStringReferenceForExpr(m_object, expr, &str))

return std::nullopt;

return DerivedString::FromAPIObject(&str, true);

{

if (!HasCollapsableRegions())

return;

// Insert the collapse indicator at the beginning of the line if one isn't already there or the

// one that is there is empty

auto context = HighLevelILInstruction::CanCollapse(instr.operation) ?

(function && function->IsInstructionCollapsed(instr, designator) ? ContentCollapsedContext : ContentExpandedContext) :

ContentCollapsiblePadding;

PrependCollapseIndicator(context, instr.GetInstructionHash(designator));

{

size_t count = 0;

BNInstructionTextToken* tokens = BNHighLevelILTokenEmitterGetCurrentTokens(m_object, &count);

return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count);

{

size_t count;

auto* tokens = AllocAPIObjectList<InstructionTextToken>(newTokens, &count);

BNHighLevelILTokenEmitterSetCurrentTokens(m_object, tokens, count);

FreeAPIObjectList<InstructionTextToken>(tokens, count);

{

size_t count = 0;

BNDisassemblyTextLine* lines = BNHighLevelILTokenEmitterGetLines(m_object, &count);

vector<DisassemblyTextLine> result = ParseAPIObjectList<DisassemblyTextLine>(lines, count);

BNFreeDisassemblyTextLines(lines, count);

return result;

const HighLevelILInstruction& instr, int64_t val, size_t size, uint64_t address)

{

BNAddHighLevelILArrayIndexToken(instr.function->GetObject(), instr.exprIndex, val, size, m_object, address);

DisassemblySettings* settings, BNSymbolDisplayType symbolDisplay, BNOperatorPrecedence precedence,

bool allowShortString)

{

return BNAddHighLevelILPointerTextToken(instr.function->GetObject(), instr.exprIndex, val, m_object,

settings ? settings->GetObject() : nullptr, symbolDisplay, precedence, allowShortString);

DisassemblySettings* settings, BNOperatorPrecedence precedence)

{

BNAddHighLevelILConstantTextToken(instr.function->GetObject(), instr.exprIndex, val, size, m_object,

settings ? settings->GetObject() : nullptr, precedence);

BinaryView* data, Type* type, const HighLevelILInstruction& var, vector<string>& nameList)

{

size_t nameCount = 0;

char** names = BNAddNamesForOuterStructureMembers(

data->GetObject(), type->GetObject(), var.function->GetObject(), var.exprIndex, &nameCount);

vector<string> newNames;

newNames.reserve(nameCount);

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

newNames.push_back(names[i]);

BNFreeStringList(names, nameCount);

nameList.insert(nameList.begin(), newNames.begin(), newNames.end());