// Copyright (c) 2015-2026 Vector 35 Inc

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

// IN THE SOFTWARE.

#include "binaryninjaapi.h"

#include "mediumlevelilinstruction.h"

#include "highlevelilinstruction.h"

#include <cstring>

#include "ffi.h"

using namespace BinaryNinja;

using namespace std;

uint64_t Variable::ToIdentifier() const

{

return BNToVariableIdentifier(this);

}

Variable Variable::FromIdentifier(uint64_t id)

{

return BNFromVariableIdentifier(id);

}

Variable Variable::Register(uint32_t reg)

{

return Variable(RegisterVariableSourceType, reg);

}

Variable Variable::Flag(uint32_t flag)

{

return Variable(FlagVariableSourceType, flag);

}

Variable Variable::StackOffset(int64_t offset)

{

return Variable(StackVariableSourceType, offset);

}

RegisterValue::RegisterValue() : state(UndeterminedValue), value(0), offset(0), size(0) {}

bool RegisterValue::operator==(const RegisterValue& a) const

{

switch (a.state)

{

case EntryValue:

return (state == EntryValue) && (a.value == value);

case ConstantValue:

return (state == ConstantValue) && (a.value == value);

case ConstantPointerValue:

return (state == ConstantPointerValue) && (a.value == value);

case ExternalPointerValue:

return (state == ExternalPointerValue) && (a.value == value) && (a.offset == offset);

case StackFrameOffset:

return (state == StackFrameOffset) && (a.value == value);

case ResultPointerValue:

return (state == ResultPointerValue) && (a.value == value);

case ParameterPointerValue:

return (state == ParameterPointerValue) && (a.value == value) && (a.offset == offset);

case UndeterminedValue:

return state == UndeterminedValue;

case ReturnAddressValue:

return state == ReturnAddressValue;

case ImportedAddressValue:

return (state == ImportedAddressValue) && (a.value == value);

case ConstantDataZeroExtendValue:

return (state == ConstantDataZeroExtendValue) && (a.value == value) && (a.size == size);

case ConstantDataSignExtendValue:

return (state == ConstantDataSignExtendValue) && (a.value == value) && (a.size == size);

case ConstantDataAggregateValue:

return (state == ConstantDataAggregateValue) && (a.value == value) && (a.size == size);

default:

return false;

}

}

bool RegisterValue::operator!=(const RegisterValue& a) const

{

return !((*this) == a);

}

bool RegisterValue::IsConstant() const

{

return (state == ConstantValue) || (state == ConstantPointerValue);

}

bool RegisterValue::IsConstantData() const

{

return ((state & ConstantDataValue) == ConstantDataValue);

}

BNRegisterValue RegisterValue::ToAPIObject()

{

BNRegisterValue result;

result.state = state;

result.value = value;

result.offset = offset;

result.size = size;

return result;

}

ConstantData::ConstantData()

{

state = UndeterminedValue;

value = 0;

size = 0;

}

ConstantData::ConstantData(BNRegisterValueType _state, uint64_t _value)

{

state = _state;

value = _value;

size = 0;

}

ConstantData::ConstantData(BNRegisterValueType _state, uint64_t _value, size_t _size, Ref<Function> _func)

{

state = _state;

value = _value;

size = _size;

func = _func;

}

pair<DataBuffer, BNBuiltinType> ConstantData::ToDataBuffer() const

{

if (func)

return func->GetConstantData(state, value, size);

return make_pair(DataBuffer(), BuiltinNone);

}

RegisterValue ConstantData::ToRegisterValue() const

{

RegisterValue result;

result.state = state;

result.value = value;

result.size = size;

return result;

}

Function::Function(BNFunction* func)

{

m_object = func;

m_advancedAnalysisRequests = 0;

}

Function::~Function()

{

if (m_advancedAnalysisRequests > 0)

BNReleaseAdvancedFunctionAnalysisDataMultiple(m_object, (size_t)m_advancedAnalysisRequests);

}

Ref<BinaryView> Function::GetView() const

{

return new BinaryView(BNGetFunctionData(m_object));

}

Ref<Platform> Function::GetPlatform() const

{

return new CorePlatform(BNGetFunctionPlatform(m_object));

}

Ref<Architecture> Function::GetArchitecture() const

{

return new CoreArchitecture(BNGetFunctionArchitecture(m_object));

}

uint64_t Function::GetStart() const

{

return BNGetFunctionStart(m_object);

}

Ref<Symbol> Function::GetSymbol() const

{

return new Symbol(BNGetFunctionSymbol(m_object));

}

bool Function::IsExported() const

{

Ref<Symbol> sym = GetSymbol();

if (!sym)

return false;

BNSymbolBinding binding = sym->GetBinding();

return (binding == BNSymbolBinding::GlobalBinding) || (binding == BNSymbolBinding::WeakBinding);

}

bool Function::WasAutomaticallyDiscovered() const

{

return BNWasFunctionAutomaticallyDiscovered(m_object);

}

bool Function::HasUserAnnotations() const

{

return BNFunctionHasUserAnnotations(m_object);

}

Confidence<bool> Function::CanReturn() const

{

BNBoolWithConfidence bc = BNCanFunctionReturn(m_object);

return Confidence<bool>(bc.value, bc.confidence);

}

Confidence<bool> Function::IsPure() const

{

BNBoolWithConfidence bc = BNIsFunctionPure(m_object);

return Confidence<bool>(bc.value, bc.confidence);

}

bool Function::HasExplicitlyDefinedType() const

{

return BNFunctionHasExplicitlyDefinedType(m_object);

}

bool Function::NeedsUpdate() const

{

return BNIsFunctionUpdateNeeded(m_object);

}

vector<Ref<BasicBlock>> Function::GetBasicBlocks() const

{

size_t count;

BNBasicBlock** blocks = BNGetFunctionBasicBlockList(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;

}

Ref<BasicBlock> Function::GetBasicBlockAtAddress(Architecture* arch, uint64_t addr) const

{

BNBasicBlock* block = BNGetFunctionBasicBlockAtAddress(m_object, arch->GetObject(), addr);

if (!block)

return nullptr;

return new BasicBlock(block);

}

void Function::MarkRecentUse()

{

BNMarkFunctionAsRecentlyUsed(m_object);

}

string Function::GetComment() const

{

char* comment = BNGetFunctionComment(m_object);

string result = comment;

BNFreeString(comment);

return result;

}

string Function::GetCommentForAddress(uint64_t addr) const

{

char* comment = BNGetCommentForAddress(m_object, addr);

string result = comment;

BNFreeString(comment);

return result;

}

vector<uint64_t> Function::GetCommentedAddresses() const

{

size_t count;

uint64_t* addrs = BNGetCommentedAddresses(m_object, &count);

vector<uint64_t> result;

result.insert(result.end(), addrs, &addrs[count]);

BNFreeAddressList(addrs);

return result;

}

void Function::SetComment(const string& comment)

{

BNSetFunctionComment(m_object, comment.c_str());

}

void Function::SetCommentForAddress(uint64_t addr, const string& comment)

{

BNSetCommentForAddress(m_object, addr, comment.c_str());

}

vector<ReferenceSource> Function::GetCallSites() const

{

size_t count;

BNReferenceSource* refs = BNGetFunctionCallSites(m_object, &count);

vector<ReferenceSource> result;

result.reserve(count);

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

{

ReferenceSource src;

src.func = new Function(BNNewFunctionReference(refs[i].func));

src.arch = new CoreArchitecture(refs[i].arch);

src.addr = refs[i].addr;

result.push_back(src);

}

BNFreeCodeReferences(refs, count);

return result;

}

void Function::AddUserCodeReference(Architecture* fromArch, uint64_t fromAddr, uint64_t toAddr)

{

BNAddUserCodeReference(m_object, fromArch->GetObject(), fromAddr, toAddr);

}

void Function::RemoveUserCodeReference(Architecture* fromArch, uint64_t fromAddr, uint64_t toAddr)

{

BNRemoveUserCodeReference(m_object, fromArch->GetObject(), fromAddr, toAddr);

}

void Function::AddUserTypeReference(Architecture* fromArch, uint64_t fromAddr, const QualifiedName& name)

{

BNQualifiedName nameObj = name.GetAPIObject();

BNAddUserTypeReference(m_object, fromArch->GetObject(), fromAddr, &nameObj);

QualifiedName::FreeAPIObject(&nameObj);

}

void Function::RemoveUserTypeReference(Architecture* fromArch, uint64_t fromAddr, const QualifiedName& name)

{

BNQualifiedName nameObj = name.GetAPIObject();

BNRemoveUserTypeReference(m_object, fromArch->GetObject(), fromAddr, &nameObj);

QualifiedName::FreeAPIObject(&nameObj);

}

void Function::AddUserTypeFieldReference(

Architecture* fromArch, uint64_t fromAddr, const QualifiedName& name, uint64_t offset, size_t size)

{

BNQualifiedName nameObj = name.GetAPIObject();

BNAddUserTypeFieldReference(m_object, fromArch->GetObject(), fromAddr, &nameObj, offset, size);

QualifiedName::FreeAPIObject(&nameObj);

}

void Function::RemoveUserTypeFieldReference(

Architecture* fromArch, uint64_t fromAddr, const QualifiedName& name, uint64_t offset, size_t size)

{

BNQualifiedName nameObj = name.GetAPIObject();

BNRemoveUserTypeFieldReference(m_object, fromArch->GetObject(), fromAddr, &nameObj, offset, size);

QualifiedName::FreeAPIObject(&nameObj);

}

Ref<LowLevelILFunction> Function::GetLowLevelIL() const

{

BNLowLevelILFunction* function = BNGetFunctionLowLevelIL(m_object);

if (!function)

return nullptr;

return new LowLevelILFunction(function);

}

Ref<LowLevelILFunction> Function::GetLowLevelILIfAvailable() const

{

BNLowLevelILFunction* function = BNGetFunctionLowLevelILIfAvailable(m_object);

if (!function)

return nullptr;

return new LowLevelILFunction(function);

}

RegisterValue RegisterValue::FromAPIObject(const BNRegisterValue& value)

{

RegisterValue result;

result.state = value.state;

result.value = value.value;

result.offset = value.offset;

result.size = value.size;

return result;

}

pair<DataBuffer, BNBuiltinType> Function::GetConstantData(BNRegisterValueType state, uint64_t value, size_t size)

{

BNBuiltinType builtin;

auto buffer = DataBuffer(BNGetConstantData(m_object, state, value, size, &builtin));

return make_pair(buffer, builtin);

}

RegisterValue Function::GetRegisterValueAtInstruction(Architecture* arch, uint64_t addr, uint32_t reg)

{

BNRegisterValue value = BNGetRegisterValueAtInstruction(m_object, arch->GetObject(), addr, reg);

return RegisterValue::FromAPIObject(value);

}

RegisterValue Function::GetRegisterValueAfterInstruction(Architecture* arch, uint64_t addr, uint32_t reg)

{

BNRegisterValue value = BNGetRegisterValueAfterInstruction(m_object, arch->GetObject(), addr, reg);

return RegisterValue::FromAPIObject(value);

}

RegisterValue Function::GetStackContentsAtInstruction(Architecture* arch, uint64_t addr, int64_t offset, size_t size)

{

BNRegisterValue value = BNGetStackContentsAtInstruction(m_object, arch->GetObject(), addr, offset, size);

return RegisterValue::FromAPIObject(value);

}

RegisterValue Function::GetStackContentsAfterInstruction(Architecture* arch, uint64_t addr, int64_t offset, size_t size)

{

BNRegisterValue value = BNGetStackContentsAfterInstruction(m_object, arch->GetObject(), addr, offset, size);

return RegisterValue::FromAPIObject(value);

}

RegisterValue Function::GetParameterValueAtInstruction(Architecture* arch, uint64_t addr, Type* functionType, size_t i)

{

BNRegisterValue value = BNGetParameterValueAtInstruction(

m_object, arch->GetObject(), addr, functionType ? functionType->GetObject() : nullptr, i);

return RegisterValue::FromAPIObject(value);

}

RegisterValue Function::GetParameterValueAtLowLevelILInstruction(size_t instr, Type* functionType, size_t i)

{

BNRegisterValue value = BNGetParameterValueAtLowLevelILInstruction(

m_object, instr, functionType ? functionType->GetObject() : nullptr, i);

return RegisterValue::FromAPIObject(value);

}

vector<uint32_t> Function::GetRegistersReadByInstruction(Architecture* arch, uint64_t addr)

{

size_t count;

uint32_t* regs = BNGetRegistersReadByInstruction(m_object, arch->GetObject(), addr, &count);

vector<uint32_t> result;

result.insert(result.end(), regs, &regs[count]);

BNFreeRegisterList(regs);

return result;

}

vector<uint32_t> Function::GetRegistersWrittenByInstruction(Architecture* arch, uint64_t addr)

{

size_t count;

uint32_t* regs = BNGetRegistersWrittenByInstruction(m_object, arch->GetObject(), addr, &count);

vector<uint32_t> result;

result.insert(result.end(), regs, &regs[count]);

BNFreeRegisterList(regs);

return result;

}

vector<StackVariableReference> Function::GetStackVariablesReferencedByInstruction(Architecture* arch, uint64_t addr)

{

size_t count;

BNStackVariableReference* refs =

BNGetStackVariablesReferencedByInstruction(m_object, arch->GetObject(), addr, &count);

vector<StackVariableReference> result;

result.reserve(count);

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

{

StackVariableReference ref;

ref.sourceOperand = refs[i].sourceOperand;

ref.type = Confidence<Ref<Type>>(

refs[i].type ? new Type(BNNewTypeReference(refs[i].type)) : nullptr, refs[i].typeConfidence);

ref.name = refs[i].name;

ref.var = Variable::FromIdentifier(refs[i].varIdentifier);

ref.referencedOffset = refs[i].referencedOffset;

ref.size = refs[i].size;

result.push_back(ref);

}

BNFreeStackVariableReferenceList(refs, count);

return result;

}

vector<StackVariableReference> Function::GetStackVariablesReferencedByInstructionIfAvailable(

Architecture* arch, uint64_t addr)

{

size_t count;

BNStackVariableReference* refs =

BNGetStackVariablesReferencedByInstructionIfAvailable(m_object, arch->GetObject(), addr, &count);

vector<StackVariableReference> result;

result.reserve(count);

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

{

StackVariableReference ref;

ref.sourceOperand = refs[i].sourceOperand;

ref.type = Confidence<Ref<Type>>(

refs[i].type ? new Type(BNNewTypeReference(refs[i].type)) : nullptr, refs[i].typeConfidence);

ref.name = refs[i].name;

ref.var = Variable::FromIdentifier(refs[i].varIdentifier);

ref.referencedOffset = refs[i].referencedOffset;

ref.size = refs[i].size;

result.push_back(ref);

}

BNFreeStackVariableReferenceList(refs, count);

return result;

}

vector<BNConstantReference> Function::GetConstantsReferencedByInstruction(Architecture* arch, uint64_t addr)

{

size_t count;

BNConstantReference* refs = BNGetConstantsReferencedByInstruction(m_object, arch->GetObject(), addr, &count);

vector<BNConstantReference> result;

result.insert(result.end(), &refs[0], &refs[count]);

BNFreeConstantReferenceList(refs);

return result;

}

vector<BNConstantReference> Function::GetConstantsReferencedByInstructionIfAvailable(Architecture* arch, uint64_t addr)

{

size_t count;

BNConstantReference* refs =

BNGetConstantsReferencedByInstructionIfAvailable(m_object, arch->GetObject(), addr, &count);

vector<BNConstantReference> result;

result.insert(result.end(), &refs[0], &refs[count]);

BNFreeConstantReferenceList(refs);

return result;

}

Ref<LowLevelILFunction> Function::GetLiftedIL() const

{

BNLowLevelILFunction* function = BNGetFunctionLiftedIL(m_object);

if (!function)

return nullptr;

return new LowLevelILFunction(function);

}

Ref<LowLevelILFunction> Function::GetLiftedILIfAvailable() const

{

BNLowLevelILFunction* function = BNGetFunctionLiftedILIfAvailable(m_object);

if (!function)

return nullptr;

return new LowLevelILFunction(function);

}

set<size_t> Function::GetLiftedILFlagUsesForDefinition(size_t i, uint32_t flag)

{

size_t count;

size_t* instrs = BNGetLiftedILFlagUsesForDefinition(m_object, i, flag, &count);

set<size_t> result;

result.insert(&instrs[0], &instrs[count]);

BNFreeILInstructionList(instrs);

return result;

}

set<size_t> Function::GetLiftedILFlagDefinitionsForUse(size_t i, uint32_t flag)

{

size_t count;

size_t* instrs = BNGetLiftedILFlagDefinitionsForUse(m_object, i, flag, &count);

set<size_t> result;

result.insert(&instrs[0], &instrs[count]);

BNFreeILInstructionList(instrs);

return result;

}

set<uint32_t> Function::GetFlagsReadByLiftedILInstruction(size_t i)

{

size_t count;

uint32_t* flags = BNGetFlagsReadByLiftedILInstruction(m_object, i, &count);

set<uint32_t> result;

result.insert(&flags[0], &flags[count]);

BNFreeRegisterList(flags);

return result;

}

set<uint32_t> Function::GetFlagsWrittenByLiftedILInstruction(size_t i)

{

size_t count;

uint32_t* flags = BNGetFlagsWrittenByLiftedILInstruction(m_object, i, &count);

set<uint32_t> result;

result.insert(&flags[0], &flags[count]);

BNFreeRegisterList(flags);

return result;

}

Ref<MediumLevelILFunction> Function::GetMediumLevelIL() const

{

BNMediumLevelILFunction* function = BNGetFunctionMediumLevelIL(m_object);

if (!function)

return nullptr;

return new MediumLevelILFunction(function);

}

Ref<MediumLevelILFunction> Function::GetMappedMediumLevelIL() const

{

BNMediumLevelILFunction* function = BNGetFunctionMappedMediumLevelIL(m_object);

if (!function)

return nullptr;

return new MediumLevelILFunction(function);

}

Ref<MediumLevelILFunction> Function::GetMediumLevelILIfAvailable() const

{

BNMediumLevelILFunction* function = BNGetFunctionMediumLevelILIfAvailable(m_object);

if (!function)

return nullptr;

return new MediumLevelILFunction(function);

}

Ref<MediumLevelILFunction> Function::GetMappedMediumLevelILIfAvailable() const

{

BNMediumLevelILFunction* function = BNGetFunctionMappedMediumLevelILIfAvailable(m_object);

if (!function)

return nullptr;

return new MediumLevelILFunction(function);

}

Ref<HighLevelILFunction> Function::GetHighLevelIL() const

{

BNHighLevelILFunction* function = BNGetFunctionHighLevelIL(m_object);

if (!function)

return nullptr;

return new HighLevelILFunction(function);

}

Ref<HighLevelILFunction> Function::GetHighLevelILIfAvailable() const

{

BNHighLevelILFunction* function = BNGetFunctionHighLevelILIfAvailable(m_object);

if (!function)

return nullptr;

return new HighLevelILFunction(function);

}

Ref<LanguageRepresentationFunction> Function::GetLanguageRepresentation(const string& language) const

{

BNLanguageRepresentationFunction* function = BNGetFunctionLanguageRepresentation(m_object, language.c_str());

if (!function)

return nullptr;

return new CoreLanguageRepresentationFunction(function);

}

Ref<LanguageRepresentationFunction> Function::GetLanguageRepresentationIfAvailable(const string& language) const

{

BNLanguageRepresentationFunction* function =

BNGetFunctionLanguageRepresentationIfAvailable(m_object, language.c_str());

if (!function)

return nullptr;

return new CoreLanguageRepresentationFunction(function);

}

Ref<Type> Function::GetType() const

{

return new Type(BNGetFunctionType(m_object));

}

Confidence<Ref<Type>> Function::GetReturnType() const

{

BNTypeWithConfidence tc = BNGetFunctionReturnType(m_object);

Ref<Type> type = tc.type ? new Type(tc.type) : nullptr;

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

}

ReturnValue Function::GetReturnValue() const

{

BNReturnValue ret = BNGetFunctionReturnValue(m_object);

ReturnValue result = ReturnValue::FromAPIObject(&ret);

BNFreeReturnValue(&ret);

return result;

}

bool Function::IsReturnValueDefaultLocation() const

{

return BNIsFunctionReturnValueDefaultLocation(m_object);

}

Confidence<ValueLocation> Function::GetReturnValueLocation() const

{

auto location = BNGetFunctionReturnValueLocation(m_object);

Confidence<ValueLocation> result(ValueLocation::FromAPIObject(&location.location), location.confidence);

BNFreeValueLocation(&location.location);

return result;

}

Confidence<vector<uint32_t>> Function::GetReturnRegisters() const

{

BNRegisterSetWithConfidence regs = BNGetFunctionReturnRegisters(m_object);

vector<uint32_t> regList;

regList.reserve(regs.count);

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

regList.push_back(regs.regs[i]);

Confidence<vector<uint32_t>> result(regList, regs.confidence);

BNFreeRegisterSet(&regs);

return result;

}

Confidence<Ref<CallingConvention>> Function::GetCallingConvention() const

{

BNCallingConventionWithConfidence cc = BNGetFunctionCallingConvention(m_object);

Ref<CallingConvention> convention = cc.convention ? new CoreCallingConvention(cc.convention) : nullptr;

return Confidence<Ref<CallingConvention>>(convention, cc.confidence);

}

Confidence<vector<Variable>> Function::GetParameterVariables() const

{

BNParameterVariablesWithConfidence vars = BNGetFunctionParameterVariables(m_object);

vector<Variable> varList;

varList.reserve(vars.count);

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

varList.emplace_back(vars.vars[i].type, vars.vars[i].index, vars.vars[i].storage);

Confidence<vector<Variable>> result(varList, vars.confidence);

BNFreeParameterVariables(&vars);

return result;

}

Confidence<vector<ValueLocation>> Function::GetParameterLocations() const

{

BNValueLocationListWithConfidence locations = BNGetFunctionParameterLocations(m_object);

vector<ValueLocation> locationList;

locationList.reserve(locations.count);

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

locationList.push_back(ValueLocation::FromAPIObject(&locations.locations[i]));

Confidence<vector<ValueLocation>> result(locationList, locations.confidence);

BNFreeParameterLocations(&locations);

return result;

}

Confidence<bool> Function::HasVariableArguments() const

{

BNBoolWithConfidence bc = BNFunctionHasVariableArguments(m_object);

return Confidence<bool>(bc.value, bc.confidence);

}

Confidence<int64_t> Function::GetStackAdjustment() const

{

BNOffsetWithConfidence oc = BNGetFunctionStackAdjustment(m_object);

return Confidence<int64_t>(oc.value, oc.confidence);

}

map<uint32_t, Confidence<int32_t>> Function::GetRegisterStackAdjustments() const

{

size_t count;

BNRegisterStackAdjustment* regStackAdjust = BNGetFunctionRegisterStackAdjustments(m_object, &count);

map<uint32_t, Confidence<int32_t>> result;

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

result[regStackAdjust[i].regStack] =

Confidence<int32_t>(regStackAdjust[i].adjustment, regStackAdjust[i].confidence);

BNFreeRegisterStackAdjustments(regStackAdjust);

return result;

}

Confidence<set<uint32_t>> Function::GetClobberedRegisters() const

{

BNRegisterSetWithConfidence regs = BNGetFunctionClobberedRegisters(m_object);

set<uint32_t> regSet;

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

regSet.insert(regs.regs[i]);

Confidence<set<uint32_t>> result(regSet, regs.confidence);

BNFreeRegisterSet(&regs);

return result;

}

void Function::SetAutoType(Type* type)

{

BNSetFunctionAutoType(m_object, type->GetObject());

}

void Function::SetAutoReturnType(const Confidence<Ref<Type>>& type)

{

BNTypeWithConfidence tc;

tc.type = type.GetValue() ? type->GetObject() : nullptr;

tc.confidence = type.GetConfidence();

BNSetAutoFunctionReturnType(m_object, &tc);

}

void Function::SetAutoReturnValue(const ReturnValue& rv)

{

BNReturnValue ret = rv.ToAPIObject();

BNSetAutoFunctionReturnValue(m_object, &ret);

ReturnValue::FreeAPIObject(&ret);

}

void Function::SetAutoIsReturnValueDefaultLocation(bool defaultLocation)

{

BNSetAutoIsFunctionReturnValueDefaultLocation(m_object, defaultLocation);

}

void Function::SetAutoReturnValueLocation(const Confidence<ValueLocation>& location)

{

BNValueLocationWithConfidence loc;

loc.location = location->ToAPIObject();

loc.confidence = location.GetConfidence();

BNSetAutoFunctionReturnValueLocation(m_object, &loc);

ValueLocation::FreeAPIObject(&loc.location);

}

void Function::SetAutoCallingConvention(const Confidence<Ref<CallingConvention>>& convention)

{

BNCallingConventionWithConfidence cc;

cc.convention = convention.GetValue() ? convention->GetObject() : nullptr;

cc.confidence = convention.GetConfidence();

BNSetAutoFunctionCallingConvention(m_object, &cc);

}

void Function::SetAutoParameterLocations(const Confidence<std::vector<ValueLocation>>& locations)

{

BNValueLocationListWithConfidence varConf;

varConf.locations = new BNValueLocation[locations->size()];

varConf.count = locations->size();

size_t i = 0;

for (auto it = locations->begin(); it != locations->end(); ++it, ++i)

varConf.locations[i] = it->ToAPIObject();

varConf.confidence = locations.GetConfidence();

BNSetAutoFunctionParameterLocations(m_object, &varConf);

for (i = 0; i < locations->size(); i++)

ValueLocation::FreeAPIObject(&varConf.locations[i]);

delete[] varConf.locations;

}

void Function::SetAutoHasVariableArguments(const Confidence<bool>& varArgs)

{

BNBoolWithConfidence bc;

bc.value = varArgs.GetValue();

bc.confidence = varArgs.GetConfidence();

BNSetAutoFunctionHasVariableArguments(m_object, &bc);

}

void Function::SetAutoCanReturn(const Confidence<bool>& returns)

{

BNBoolWithConfidence bc;

bc.value = returns.GetValue();

bc.confidence = returns.GetConfidence();

BNSetAutoFunctionCanReturn(m_object, &bc);

}

void Function::SetAutoPure(const Confidence<bool>& pure)

{

BNBoolWithConfidence bc;

bc.value = pure.GetValue();

bc.confidence = pure.GetConfidence();

BNSetAutoFunctionPure(m_object, &bc);

}

void Function::SetAutoStackAdjustment(const Confidence<int64_t>& stackAdjust)

{

BNOffsetWithConfidence oc;

oc.value = stackAdjust.GetValue();

oc.confidence = stackAdjust.GetConfidence();

BNSetAutoFunctionStackAdjustment(m_object, &oc);

}

void Function::SetAutoRegisterStackAdjustments(const map<uint32_t, Confidence<int32_t>>& regStackAdjust)

{

BNRegisterStackAdjustment* adjust = new BNRegisterStackAdjustment[regStackAdjust.size()];

size_t i = 0;

for (auto& j : regStackAdjust)

{

adjust[i].regStack = j.first;

adjust[i].adjustment = j.second.GetValue();

adjust[i].confidence = j.second.GetConfidence();

i++;

}

BNSetAutoFunctionRegisterStackAdjustments(m_object, adjust, regStackAdjust.size());

delete[] adjust;

}

void Function::SetAutoClobberedRegisters(const Confidence<std::set<uint32_t>>& clobbered)

{

BNRegisterSetWithConfidence regs;

regs.regs = new uint32_t[clobbered->size()];

regs.count = clobbered->size();

size_t i = 0;

for (auto it = clobbered->begin(); it != clobbered->end(); ++it, ++i)

regs.regs[i] = *it;

regs.confidence = clobbered.GetConfidence();

BNSetAutoFunctionClobberedRegisters(m_object, &regs);

delete[] regs.regs;

}

void Function::SetUserType(Type* type)

{