binaryninja-api/constantrenderer.cpp at dev · Vector35/binaryninja-api · GitHub

History

151 lines (115 loc) · 5.21 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

#include "binaryninjaapi.h"

#include "ffi.h"

#include "highlevelilinstruction.h"

using namespace BinaryNinja;

using namespace std;

ConstantRenderer::ConstantRenderer(const std::string& name): m_nameForRegister(name)

{

m_object = nullptr;

}

ConstantRenderer::ConstantRenderer(BNConstantRenderer* renderer)

{

m_object = renderer;

}

string ConstantRenderer::GetName() const

{

char* name = BNGetConstantRendererName(m_object);

string result = name;

BNFreeString(name);

return result;

}

bool ConstantRenderer::IsValidForType(HighLevelILFunction*, Type*)

{

return true;

}

bool ConstantRenderer::RenderConstant(const HighLevelILInstruction&, Type*, int64_t,

HighLevelILTokenEmitter&, DisassemblySettings*, BNOperatorPrecedence)

{

return false;

}

bool ConstantRenderer::RenderConstantPointer(const HighLevelILInstruction&, Type*, int64_t,

HighLevelILTokenEmitter&, DisassemblySettings*, BNSymbolDisplayType, BNOperatorPrecedence)

{

return false;

}

void ConstantRenderer::Register(ConstantRenderer* renderer)

{

BNCustomConstantRenderer callbacks;

callbacks.context = renderer;

callbacks.isValidForType = IsValidForTypeCallback;

callbacks.renderConstant = RenderConstantCallback;

callbacks.renderConstantPointer = RenderConstantPointerCallback;

renderer->AddRefForRegistration();

renderer->m_object = BNRegisterConstantRenderer(renderer->m_nameForRegister.c_str(), &callbacks);

}

bool ConstantRenderer::IsValidForTypeCallback(void* ctxt, BNHighLevelILFunction* hlil, BNType* type)

{

ConstantRenderer* renderer = (ConstantRenderer*)ctxt;

Ref<HighLevelILFunction> hlilObj = new HighLevelILFunction(BNNewHighLevelILFunctionReference(hlil));

Ref<Type> typeObj = new Type(BNNewTypeReference(type));

return renderer->IsValidForType(hlilObj, typeObj);

}

bool ConstantRenderer::RenderConstantCallback(void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type,

int64_t val, BNHighLevelILTokenEmitter* tokens, BNDisassemblySettings* settings,

BNOperatorPrecedence precedence)

{

ConstantRenderer* renderer = (ConstantRenderer*)ctxt;

Ref<HighLevelILFunction> hlilObj = new HighLevelILFunction(BNNewHighLevelILFunctionReference(hlil));

HighLevelILInstruction instr = hlilObj->GetExpr(expr);

Ref<Type> typeObj = new Type(BNNewTypeReference(type));

Ref<HighLevelILTokenEmitter> tokenObj = new HighLevelILTokenEmitter(BNNewHighLevelILTokenEmitterReference(tokens));

Ref<DisassemblySettings> settingsObj = settings ? new DisassemblySettings(BNNewDisassemblySettingsReference(settings)) : nullptr;

return renderer->RenderConstant(instr, typeObj, val, *tokenObj, settingsObj, precedence);

}

bool ConstantRenderer::RenderConstantPointerCallback(void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type,

int64_t val, BNHighLevelILTokenEmitter* tokens, BNDisassemblySettings* settings, BNSymbolDisplayType symbolDisplay,

BNOperatorPrecedence precedence)

{

ConstantRenderer* renderer = (ConstantRenderer*)ctxt;

Ref<HighLevelILFunction> hlilObj = new HighLevelILFunction(BNNewHighLevelILFunctionReference(hlil));

HighLevelILInstruction instr = hlilObj->GetExpr(expr);

Ref<Type> typeObj = new Type(BNNewTypeReference(type));

Ref<HighLevelILTokenEmitter> tokenObj = new HighLevelILTokenEmitter(BNNewHighLevelILTokenEmitterReference(tokens));

Ref<DisassemblySettings> settingsObj = settings ? new DisassemblySettings(BNNewDisassemblySettingsReference(settings)) : nullptr;

return renderer->RenderConstantPointer(instr, typeObj, val, *tokenObj, settingsObj, symbolDisplay, precedence);

}

Ref<ConstantRenderer> ConstantRenderer::GetByName(const std::string& name)

{

BNConstantRenderer* renderer = BNGetConstantRendererByName(name.c_str());

if (!renderer)

return nullptr;

return new CoreConstantRenderer(renderer);

}

vector<Ref<ConstantRenderer>> ConstantRenderer::GetRenderers()

{

size_t count = 0;

BNConstantRenderer** renderers = BNGetConstantRendererList(&count);

vector<Ref<ConstantRenderer>> result;

result.reserve(count);

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

result.push_back(new CoreConstantRenderer(renderers[i]));

BNFreeConstantRendererList(renderers);

return result;

}

CoreConstantRenderer::CoreConstantRenderer(BNConstantRenderer* renderer):

ConstantRenderer(renderer)

{

}

bool CoreConstantRenderer::IsValidForType(HighLevelILFunction* func, Type* type)

{

return BNIsConstantRendererValidForType(m_object, func->GetObject(), type->GetObject());

}

bool CoreConstantRenderer::RenderConstant(const HighLevelILInstruction& instr, Type* type, int64_t val,

HighLevelILTokenEmitter& tokens, DisassemblySettings* settings, BNOperatorPrecedence precedence)

{

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

type->GetObject(), val, tokens.GetObject(), settings ? settings->GetObject() : nullptr, precedence);

}

bool CoreConstantRenderer::RenderConstantPointer(const HighLevelILInstruction& instr, Type* type, int64_t val,

HighLevelILTokenEmitter& tokens, DisassemblySettings* settings, BNSymbolDisplayType symbolDisplay,

BNOperatorPrecedence precedence)

{

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

type->GetObject(), val, tokens.GetObject(), settings ? settings->GetObject() : nullptr,

symbolDisplay, precedence);

}

binaryninja-api/constantrenderer.cpp at dev · Vector35/binaryninja-api · GitHub

Uh oh!

Expand file tree

Breadcrumbs

constantrenderer.cpp

Latest commit

History

Breadcrumbs

constantrenderer.cpp

File metadata and controls