From 2161816481322887864999289688022906323855 Mon Sep 17 00:00:00 2001 From: Glenn Smith Date: Thu, 26 Sep 2024 01:33:07 -0400 Subject: Add various missing Type/TypeBuilder getters and settersa --- binaryninjaapi.h | 15 +++++++++++++++ binaryninjacore.h | 5 +++++ type.cpp | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 55 insertions(+) diff --git a/binaryninjaapi.h b/binaryninjaapi.h index 7bbd2d48..04d8bd6d 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -8721,6 +8721,12 @@ namespace BinaryNinja { */ Confidence> GetCallingConvention() const; + /*! For Function Types, get the calling convention name + + \return The calling convention name + */ + BNCallingConventionName GetCallingConventionName() const; + /*! For Function Types, get a list of parameters \return A vector of FunctionParameters @@ -8733,6 +8739,12 @@ namespace BinaryNinja { */ Confidence HasVariableArguments() const; + /*! Has no effect currently, just used by the demangler + + \return If the type has the "has template arguments" flag set + */ + bool HasTemplateArguments() const; + /*! For Function Types, whether a function can return (is not marked noreturn) \return Whether the function can return @@ -9142,6 +9154,7 @@ namespace BinaryNinja { Confidence> GetChildType() const; Confidence> GetCallingConvention() const; + BNCallingConventionName GetCallingConventionName() const; std::vector GetParameters() const; Confidence HasVariableArguments() const; Confidence CanReturn() const; @@ -9159,6 +9172,8 @@ namespace BinaryNinja { TypeBuilder& SetConst(const Confidence& cnst); TypeBuilder& SetVolatile(const Confidence& vltl); TypeBuilder& SetChildType(const Confidence>& child); + TypeBuilder& SetCallingConvention(const Confidence>& cc); + TypeBuilder& SetCallingConventionName(BNCallingConventionName cc); TypeBuilder& SetSigned(const Confidence& vltl); TypeBuilder& SetTypeName(const QualifiedName& name); TypeBuilder& SetAlternateName(const std::string& name); diff --git a/binaryninjacore.h b/binaryninjacore.h index a80f0a20..45c06e4d 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -5966,9 +5966,11 @@ extern "C" BINARYNINJACOREAPI bool BNIsTypeFloatingPoint(BNType* type); BINARYNINJACOREAPI BNTypeWithConfidence BNGetChildType(BNType* type); BINARYNINJACOREAPI BNCallingConventionWithConfidence BNGetTypeCallingConvention(BNType* type); + BINARYNINJACOREAPI BNCallingConventionName BNGetTypeCallingConventionName(BNType* type); BINARYNINJACOREAPI BNFunctionParameter* BNGetTypeParameters(BNType* type, size_t* count); BINARYNINJACOREAPI void BNFreeTypeParameterList(BNFunctionParameter* types, size_t count); BINARYNINJACOREAPI BNBoolWithConfidence BNTypeHasVariableArguments(BNType* type); + BINARYNINJACOREAPI bool BNTypeHasTemplateArguments(BNType* type); BINARYNINJACOREAPI BNBoolWithConfidence BNFunctionTypeCanReturn(BNType* type); BINARYNINJACOREAPI BNBoolWithConfidence BNIsTypePure(BNType* type); BINARYNINJACOREAPI BNStructure* BNGetTypeStructure(BNType* type); @@ -6023,6 +6025,7 @@ extern "C" BINARYNINJACOREAPI bool BNIsTypeBuilderFloatingPoint(BNTypeBuilder* type); BINARYNINJACOREAPI BNTypeWithConfidence BNGetTypeBuilderChildType(BNTypeBuilder* type); BINARYNINJACOREAPI BNCallingConventionWithConfidence BNGetTypeBuilderCallingConvention(BNTypeBuilder* type); + BINARYNINJACOREAPI BNCallingConventionName BNGetTypeBuilderCallingConventionName(BNTypeBuilder* type); BINARYNINJACOREAPI BNFunctionParameter* BNGetTypeBuilderParameters(BNTypeBuilder* type, size_t* count); BINARYNINJACOREAPI BNBoolWithConfidence BNTypeBuilderHasVariableArguments(BNTypeBuilder* type); BINARYNINJACOREAPI BNBoolWithConfidence BNFunctionTypeBuilderCanReturn(BNTypeBuilder* type); @@ -6045,6 +6048,8 @@ extern "C" BINARYNINJACOREAPI void BNTypeBuilderSetVolatile(BNTypeBuilder* type, BNBoolWithConfidence* vltl); BINARYNINJACOREAPI void BNTypeBuilderSetSigned(BNTypeBuilder* type, BNBoolWithConfidence* sign); BINARYNINJACOREAPI void BNTypeBuilderSetChildType(BNTypeBuilder* type, BNTypeWithConfidence* child); + BINARYNINJACOREAPI void BNTypeBuilderSetCallingConvention(BNTypeBuilder* type, BNCallingConventionWithConfidence* cc); + BINARYNINJACOREAPI void BNTypeBuilderSetCallingConventionName(BNTypeBuilder* type, BNCallingConventionName cc); BINARYNINJACOREAPI BNOffsetWithConfidence BNGetTypeBuilderStackAdjustment(BNTypeBuilder* type); BINARYNINJACOREAPI BNQualifiedName BNTypeBuilderGetStructureName(BNTypeBuilder* type); BINARYNINJACOREAPI BNReferenceType BNTypeBuilderGetReferenceType(BNTypeBuilder* type); diff --git a/type.cpp b/type.cpp index 42ef40b9..45e20463 100644 --- a/type.cpp +++ b/type.cpp @@ -602,6 +602,12 @@ Confidence> Type::GetCallingConvention() const } +BNCallingConventionName Type::GetCallingConventionName() const +{ + return BNGetTypeCallingConventionName(m_object); +} + + vector Type::GetParameters() const { size_t count; @@ -633,6 +639,12 @@ Confidence Type::HasVariableArguments() const } +bool Type::HasTemplateArguments() const +{ + return BNTypeHasTemplateArguments(m_object); +} + + Confidence Type::CanReturn() const { BNBoolWithConfidence result = BNFunctionTypeCanReturn(m_object); @@ -1491,6 +1503,23 @@ TypeBuilder& TypeBuilder::SetChildType(const Confidence>& child) } +TypeBuilder& TypeBuilder::SetCallingConvention(const Confidence>& cc) +{ + BNCallingConventionWithConfidence ccwc; + ccwc.convention = cc->GetObject(); + ccwc.confidence = cc.GetConfidence(); + BNTypeBuilderSetCallingConvention(m_object, &ccwc); + return *this; +} + + +TypeBuilder& TypeBuilder::SetCallingConventionName(BNCallingConventionName cc) +{ + BNTypeBuilderSetCallingConventionName(m_object, cc); + return *this; +} + + Confidence> TypeBuilder::GetCallingConvention() const { BNCallingConventionWithConfidence cc = BNGetTypeBuilderCallingConvention(m_object); @@ -1500,6 +1529,12 @@ Confidence> TypeBuilder::GetCallingConvention() const } +BNCallingConventionName TypeBuilder::GetCallingConventionName() const +{ + return BNGetTypeBuilderCallingConventionName(m_object); +} + + vector TypeBuilder::GetParameters() const { size_t count; -- cgit v1.3.1