{

CallLayout result;

result.parameters.reserve(layout->parameterCount);

for (size_t i = 0; i < layout->parameterCount; i++)

result.parameters.push_back(ValueLocation::FromAPIObject(&layout->parameters[i]));

if (layout->returnValueValid)

result.returnValue = ValueLocation::FromAPIObject(&layout->returnValue);

result.stackAdjustment = layout->stackAdjustment;

for (size_t i = 0; i < layout->registerStackAdjustmentCount; i++)

{

result.registerStackAdjustments[layout->registerStackAdjustmentRegisters[i]] =

layout->registerStackAdjustmentAmounts[i];

}

return result;

{

BNCallLayout result;

result.parameters = new BNValueLocation[parameters.size()];

result.parameterCount = parameters.size();

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

result.parameters[i] = parameters[i].ToAPIObject();

result.returnValue = returnValue.value_or(ValueLocation()).ToAPIObject();

result.returnValueValid = returnValue.has_value();

result.stackAdjustment = stackAdjustment;

result.registerStackAdjustmentCount = registerStackAdjustments.size();

result.registerStackAdjustmentRegisters = new uint32_t[registerStackAdjustments.size()];

result.registerStackAdjustmentAmounts = new int32_t[registerStackAdjustments.size()];

size_t i = 0;

for (auto [reg, adjust] : registerStackAdjustments)

{

result.registerStackAdjustmentRegisters[i] = reg;

result.registerStackAdjustmentAmounts[i] = adjust;

i++;

}

return result;

{

for (size_t i = 0; i < layout->parameterCount; i++)

ValueLocation::FreeAPIObject(&layout->parameters[i]);

delete[] layout->parameters;

ValueLocation::FreeAPIObject(&layout->returnValue);

delete[] layout->registerStackAdjustmentRegisters;

delete[] layout->registerStackAdjustmentAmounts;

{

BNCustomCallingConvention cc;

cc.context = this;

cc.freeObject = FreeCallback;

cc.getCallerSavedRegisters = GetCallerSavedRegistersCallback;

cc.getCalleeSavedRegisters = GetCalleeSavedRegistersCallback;

cc.getIntegerArgumentRegisters = GetIntegerArgumentRegistersCallback;

cc.getFloatArgumentRegisters = GetFloatArgumentRegistersCallback;

cc.getRequiredArgumentRegisters = GetRequiredArgumentRegistersCallback;

cc.getRequiredClobberedRegisters = GetRequiredClobberedRegistersCallback;

cc.freeRegisterList = FreeRegisterListCallback;

cc.areArgumentRegistersSharedIndex = AreArgumentRegistersSharedIndexCallback;

cc.areArgumentRegistersUsedForVarArgs = AreArgumentRegistersUsedForVarArgsCallback;

cc.isStackReservedForArgumentRegisters = IsStackReservedForArgumentRegistersCallback;

cc.isStackAdjustedOnReturn = IsStackAdjustedOnReturnCallback;

cc.isEligibleForHeuristics = IsEligibleForHeuristicsCallback;

cc.getIntegerReturnValueRegister = GetIntegerReturnValueRegisterCallback;

cc.getHighIntegerReturnValueRegister = GetHighIntegerReturnValueRegisterCallback;

cc.getFloatReturnValueRegister = GetFloatReturnValueRegisterCallback;

cc.getGlobalPointerRegisters = GetGlobalPointerRegistersCallback;

cc.getImplicitlyDefinedRegisters = GetImplicitlyDefinedRegistersCallback;

cc.getIncomingRegisterValue = GetIncomingRegisterValueCallback;

cc.getIncomingFlagValue = GetIncomingFlagValueCallback;

cc.getIncomingVariableForParameterVariable = GetIncomingVariableForParameterVariableCallback;

cc.getParameterVariableForIncomingVariable = GetParameterVariableForIncomingVariableCallback;

cc.isReturnTypeRegisterCompatible = IsReturnTypeRegisterCompatibleCallback;

cc.getIndirectReturnValueLocation = GetIndirectReturnValueLocationCallback;

cc.getReturnedIndirectReturnValuePointer = GetReturnedIndirectReturnValuePointerCallback;

cc.isArgumentTypeRegisterCompatible = IsArgumentTypeRegisterCompatibleCallback;

cc.isNonRegisterArgumentIndirect = IsNonRegisterArgumentIndirectCallback;

cc.areStackArgumentsNaturallyAligned = AreStackArgumentsNaturallyAlignedCallback;

cc.areStackArgumentsPushedLeftToRight = AreStackArgumentsPushedLeftToRightCallback;

cc.getCallLayout = GetCallLayoutCallback;

cc.freeCallLayout = FreeCallLayoutCallback;

cc.getReturnValueLocation = GetReturnValueLocationCallback;

cc.freeValueLocation = FreeValueLocationCallback;

cc.getParameterLocations = GetParameterLocationsCallback;

cc.freeParameterLocations = FreeParameterLocationsCallback;

cc.getParameterOrderingForVariables = GetParameterOrderingForVariablesCallback;

cc.freeVariableList = FreeVariableListCallback;

cc.getStackAdjustmentForLocations = GetStackAdjustmentForLocationsCallback;

cc.getRegisterStackAdjustments = GetRegisterStackAdjustmentsCallback;

cc.freeRegisterStackAdjustments = FreeRegisterStackAdjustmentsCallback;

AddRefForRegistration();

m_object = BNCreateCallingConvention(arch->GetObject(), name.c_str(), &cc);

{

CallingConvention* cc = (CallingConvention*)ctxt;

cc->ReleaseForRegistration();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->AreArgumentRegistersSharedIndex();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->AreArgumentRegistersUsedForVarArgs();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->IsStackReservedForArgumentRegisters();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->IsStackAdjustedOnReturn();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->IsEligibleForHeuristics();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->GetIntegerReturnValueRegister();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->GetHighIntegerReturnValueRegister();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->GetFloatReturnValueRegister();

void* ctxt, uint32_t reg, BNFunction* func, BNRegisterValue* result)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<Function> funcObj;

if (func)

funcObj = new Function(BNNewFunctionReference(func));

*result = cc->GetIncomingRegisterValue(reg, funcObj).ToAPIObject();

void* ctxt, uint32_t reg, BNFunction* func, BNRegisterValue* result)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<Function> funcObj;

if (func)

funcObj = new Function(BNNewFunctionReference(func));

*result = cc->GetIncomingFlagValue(reg, funcObj).ToAPIObject();

void* ctxt, const BNVariable* var, BNFunction* func, BNVariable* result)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<Function> funcObj;

if (func)

funcObj = new Function(BNNewFunctionReference(func));

*result = cc->GetIncomingVariableForParameterVariable(*var, funcObj);

void* ctxt, const BNVariable* var, BNFunction* func, BNVariable* result)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<Function> funcObj;

if (func)

funcObj = new Function(BNNewFunctionReference(func));

*result = cc->GetParameterVariableForIncomingVariable(*var, funcObj);

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

Ref<Type> typeObj;

if (type)

typeObj = new Type(BNNewTypeReference(type));

return cc->IsReturnTypeRegisterCompatible(viewObj, typeObj);

{

CallbackRef<CallingConvention> cc(ctxt);

*outVar = cc->GetIndirectReturnValueLocation();

{

CallbackRef<CallingConvention> cc(ctxt);

auto var = cc->GetReturnedIndirectReturnValuePointer();

if (var.has_value())

*outVar = var.value();

return var.has_value();

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

Ref<Type> typeObj;

if (type)

typeObj = new Type(BNNewTypeReference(type));

return cc->IsArgumentTypeRegisterCompatible(viewObj, typeObj);

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

Ref<Type> typeObj;

if (type)

typeObj = new Type(BNNewTypeReference(type));

return cc->IsNonRegisterArgumentIndirect(viewObj, typeObj);

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->AreStackArgumentsNaturallyAligned();

{

CallbackRef<CallingConvention> cc(ctxt);

return cc->AreStackArgumentsPushedLeftToRight();

BNFunctionParameter* params, size_t paramCount, bool hasPermittedRegs, uint32_t* permittedRegs,

size_t permittedRegCount, BNCallLayout* result)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

auto ret = ReturnValue::FromAPIObject(returnValue);

vector<FunctionParameter> paramObjs;

paramObjs.reserve(paramCount);

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

paramObjs.push_back(FunctionParameter::FromAPIObject(&params[i]));

optional<set<uint32_t>> regOpt;

if (hasPermittedRegs)

{

set<uint32_t> regs;

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

regs.insert(permittedRegs[i]);

regOpt = regs;

}

auto layout = cc->GetCallLayout(viewObj, ret, paramObjs, regOpt);

*result = layout.ToAPIObject();

void* ctxt, BNBinaryView* view, BNReturnValue* returnValue, BNValueLocation* outLocation)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

ReturnValue ret = ReturnValue::FromAPIObject(returnValue);

ValueLocation location = cc->GetReturnValueLocation(viewObj, ret);

*outLocation = location.ToAPIObject();

{

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

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

delete[] locations;

BNValueLocation* returnValue, BNValueLocation* locations, BNType** types, size_t paramCount)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

std::optional<ValueLocation> ret;

if (returnValue)

ret = ValueLocation::FromAPIObject(returnValue);

vector<ValueLocation> locationObjs;

locationObjs.reserve(paramCount);

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

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

vector<Ref<Type>> typeObjs;

typeObjs.reserve(paramCount);

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

typeObjs.push_back(new Type(BNNewTypeReference(types[i])));

return cc->GetStackAdjustmentForLocations(viewObj, ret, locationObjs, typeObjs);

BNValueLocation* returnValue, BNValueLocation* params, size_t paramCount, uint32_t** outRegs, int32_t** outAdjust)

{

CallbackRef<CallingConvention> cc(ctxt);

Ref<BinaryView> viewObj;

if (view)

viewObj = new BinaryView(BNNewViewReference(view));

std::optional<ValueLocation> ret;

if (returnValue)

ret = ValueLocation::FromAPIObject(returnValue);

vector<ValueLocation> paramObjs;

paramObjs.reserve(paramCount);

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

paramObjs.push_back(ValueLocation::FromAPIObject(&params[i]));

auto result = cc->GetRegisterStackAdjustments(viewObj, ret, paramObjs);

*outRegs = new uint32_t[result.size()];

*outAdjust = new int32_t[result.size()];

size_t i = 0;

for (auto it = result.begin(); it != result.end(); ++it, ++i)

{

(*outRegs)[i] = it->first;

(*outAdjust)[i] = it->second;

}

return result.size();

{

delete[] regs;

delete[] adjust;

{

char* str = BNGetCallingConventionName(m_object);

string result = str;

BNFreeString(str);

return result;

{

uint32_t reg = GetGlobalPointerRegister();

if (reg == BN_INVALID_REGISTER)

return vector<uint32_t>();

return vector<uint32_t> { reg };

{

uint32_t regStack = GetArchitecture()->GetRegisterStackForRegister(reg);

if ((regStack != BN_INVALID_REGISTER) && (reg == GetArchitecture()->GetRegisterStackInfo(regStack).stackTopReg))

{

RegisterValue value;

value.state = ConstantValue;

value.value = 0;

return value;

}

return RegisterValue();

const vector<FunctionParameter>& params, const optional<set<uint32_t>>& permittedRegs)

{

return GetDefaultCallLayout(view, returnValue, params, permittedRegs);

const optional<ValueLocation>& returnValue, const vector<FunctionParameter>& params,

const optional<set<uint32_t>>& permittedRegs)

{

return GetDefaultParameterLocations(view, returnValue, params, permittedRegs);

BinaryView*, const std::map<Variable, Ref<Type>>& params)

{

return GetDefaultParameterOrderingForVariables(params);

const std::vector<ValueLocation>& locations, const std::vector<Ref<Type>>& types)

{

return GetDefaultStackAdjustmentForLocations(returnValue, locations, types);

BinaryView*, const std::optional<ValueLocation>& returnValue, const std::vector<ValueLocation>& params)

{

return GetDefaultRegisterStackAdjustments(returnValue, params);

const vector<FunctionParameter>& params, const optional<set<uint32_t>>& permittedRegs)

{

BNReturnValue ret = returnValue.ToAPIObject();

BNFunctionParameter* paramArray = new BNFunctionParameter[params.size()];

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

paramArray[i] = params[i].ToAPIObject();

BNCallLayout layout;

if (permittedRegs.has_value())

{

uint32_t* regs = new uint32_t[permittedRegs->size()];

size_t i = 0;

for (auto reg : *permittedRegs)

regs[i++] = reg;

layout = BNGetDefaultCallLayout(

m_object, view ? view->GetObject() : nullptr, &ret, paramArray, params.size(), regs, permittedRegs->size());

delete[] regs;

}

else

{

layout = BNGetDefaultCallLayoutDefaultPermittedArgs(

m_object, view ? view->GetObject() : nullptr, &ret, paramArray, params.size());

}

ReturnValue::FreeAPIObject(&ret);

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

FunctionParameter::FreeAPIObject(&paramArray[i]);

delete[] paramArray;

CallLayout result = CallLayout::FromAPIObject(&layout);

BNFreeCallLayout(&layout);

return result;

{

BNReturnValue ret = returnValue.ToAPIObject();

BNValueLocation location = BNGetDefaultReturnValueLocation(m_object, view ? view->GetObject() : nullptr, &ret);

ReturnValue::FreeAPIObject(&ret);

ValueLocation result = ValueLocation::FromAPIObject(&location);

BNFreeValueLocation(&location);

return result;

const optional<ValueLocation>& returnValue, const vector<FunctionParameter>& params,

const optional<set<uint32_t>>& permittedRegs)

{

BNValueLocation* retOpt = nullptr;

BNValueLocation ret;

if (returnValue.has_value())

{

ret = returnValue->ToAPIObject();

retOpt = &ret;

}

BNFunctionParameter* paramArray = new BNFunctionParameter[params.size()];

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

paramArray[i] = params[i].ToAPIObject();

size_t locationCount = 0;

BNValueLocation* locations;

if (permittedRegs.has_value())

{

uint32_t* regs = new uint32_t[permittedRegs->size()];

size_t i = 0;

for (auto reg : *permittedRegs)

regs[i++] = reg;

locations = BNGetDefaultParameterLocations(m_object, view ? view->GetObject() : nullptr, retOpt, paramArray,

params.size(), regs, permittedRegs->size(), &locationCount);

delete[] regs;

}

else

{

locations = BNGetDefaultParameterLocationsDefaultPermittedArgs(

m_object, view ? view->GetObject() : nullptr, retOpt, paramArray, params.size(), &locationCount);

}

if (retOpt)

ValueLocation::FreeAPIObject(retOpt);

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

FunctionParameter::FreeAPIObject(&paramArray[i]);

delete[] paramArray;

vector<ValueLocation> result;

result.reserve(locationCount);

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

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

BNFreeValueLocationList(locations, locationCount);

return result;

const std::map<Variable, Ref<Type>>& params)

{

BNVariable* vars = new BNVariable[params.size()];

const BNType** types = new const BNType*[params.size()];

size_t i = 0;

for (auto it = params.begin(); it != params.end(); ++it, ++i)

{

vars[i] = it->first;

types[i] = it->second.GetPtr() ? it->second->GetObject() : nullptr;

}

size_t outCount = 0;

auto outVars = BNGetDefaultParameterOrderingForVariables(m_object, vars, types, params.size(), &outCount);

delete[] vars;

delete[] types;

vector<Variable> result;

result.reserve(outCount);

for (i = 0; i < outCount; i++)

result.emplace_back(outVars[i]);

BNFreeVariableList(outVars);

return result;

const std::vector<ValueLocation>& locations, const std::vector<Ref<Type>>& types)

{

BNValueLocation* retOpt = nullptr;

BNValueLocation ret;

if (returnValue.has_value())

{

ret = returnValue->ToAPIObject();

retOpt = &ret;

}

size_t count = locations.size();

if (types.size() < count)

count = types.size();

BNValueLocation* locationArray = new BNValueLocation[count];

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

locationArray[i] = locations[i].ToAPIObject();

const BNType** typeArray = new const BNType*[count];

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

typeArray[i] = types[i] ? types[i]->GetObject() : nullptr;

int64_t result = BNGetDefaultStackAdjustmentForLocations(m_object, retOpt, locationArray, typeArray, count);

if (retOpt)

ValueLocation::FreeAPIObject(retOpt);

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

ValueLocation::FreeAPIObject(&locationArray[i]);