def test_Enumeration(self):
"""Enumeration produced different result"""
inttype = binja.Type.int(4)
enum = binja.Enumeration()
enum.a = 1
enum.append("a", 1)
enum.append("b", 2)
enum.replace(0, "a", 2)
enum.remove(0)
retinfo = [str(enum)]
retinfo += [str((enum == enum) and not (enum != enum))]
return retinfo
def enum_decl(node: Cursor, bv: bn.BinaryView):
bn.log.log_debug(f'enum_decl: Processing enum {node.type.spelling} {node.spelling}')
enum = bn.Enumeration()
for enum_member in node.get_children():
enum.append(enum_member.spelling, enum_member.enum_value)
try:
if node.spelling:
enum_name = node.spelling
else:
enum_name = node.type.spelling
bv.define_user_type(enum_name, bn.Type.enumeration_type(bv.arch, enum))
bn.log.log_debug(f'enum_decl: Successfully processed enum {node.spelling}')
return node.spelling, bn.Type.enumeration_type(bv.arch, enum)
except Exception as e:
bn.log.log_debug(f'enum_decl: Failed Processing enum {node.spelling} with exception {e}')
def _construct_binja_type(self,
ty: Type,
as_specifier: bool = False) -> bn.Type:
assert (not isinstance(ty, str))
if ty.uuid in self._s2b_types:
if as_specifier and ty.name is not None:
ntrc = bn.NamedTypeReferenceClass.UnknownNamedTypeClass
if ty.composite_type is not None:
if ty.composite_type == CompositeType.CLASS_TYPE:
ntrc = bn.NamedTypeReferenceClass.ClassNamedTypeClass
elif ty.composite_type == CompositeType.STRUCT_TYPE:
ntrc = bn.NamedTypeReferenceClass.StructNamedTypeClass
elif ty.composite_type == CompositeType.UNION_TYPE:
ntrc = bn.NamedTypeReferenceClass.UnionNamedTypeClass
elif ty.composite_type == CompositeType.ENUM_TYPE:
ntrc = bn.NamedTypeReferenceClass.EnumNamedTypeClass
binja_type = bn.Type.named_type(
bn.NamedTypeReference(name=ty.name,
type_id=self._generate_typeid(
ty.name),
type_class=ntrc))
else:
return self._s2b_types[ty.uuid]
bv = self._binary_view
if ty.scalar_type:
if ty.scalar_type == ScalarType.BASE_TYPE:
if ty.name in self._base_types:
binja_type = self._base_types[ty.name]
else:
try:
# If this is a parseable type, do that.
binja_type, _ = bv.parse_type_string(ty.name)
self._base_types[ty.name] = binja_type
self._builtin_types.add(ty.name)
except:
# Otherwise, create a named type reference.
binja_type = bn.Type.named_type(
bn.NamedTypeReference(
name=ty.name,
type_id=self._generate_typeid(ty.name)))
self._base_types[ty.name] = binja_type
elif ty.scalar_type == ScalarType.POINTER_TYPE:
target_type = self._construct_binja_type(
ty.element, as_specifier=as_specifier)
binja_type = bn.Type.pointer(
bv.arch,
target_type,
ref_type=bn.ReferenceType.PointerReferenceType)
elif ty.scalar_type == ScalarType.REFERENCE_TYPE:
target_type = self._construct_binja_type(
ty.element, as_specifier=as_specifier)
binja_type = bn.Type.pointer(
bv.arch,
target_type,
ref_type=bn.ReferenceType.ReferenceReferenceType)
elif ty.scalar_type == ScalarType.RVALUE_REFERENCE_TYPE:
target_type = self._construct_binja_type(
ty.element, as_specifier=as_specifier)
binja_type = bn.Type.pointer(
bv.arch,
target_type,
ref_type=bn.ReferenceType.RValueReferenceType)
elif ty.scalar_type == ScalarType.ARRAY_TYPE:
element_type = self._construct_binja_type(
ty.element, as_specifier=as_specifier)
count = 0 if ty.array_count is None else ty.array_count
if count > 65535:
count = 0
binja_type = bn.Type.array(element_type, count)
elif ty.composite_type:
if as_specifier and ty.name is not None:
ntrc = bn.NamedTypeReferenceClass.UnknownNamedTypeClass
if ty.composite_type == CompositeType.CLASS_TYPE:
ntrc = bn.NamedTypeReferenceClass.ClassNamedTypeClass
elif ty.composite_type == CompositeType.STRUCT_TYPE:
ntrc = bn.NamedTypeReferenceClass.StructNamedTypeClass
elif ty.composite_type == CompositeType.UNION_TYPE:
ntrc = bn.NamedTypeReferenceClass.UnionNamedTypeClass
elif ty.composite_type == CompositeType.ENUM_TYPE:
ntrc = bn.NamedTypeReferenceClass.EnumNamedTypeClass
binja_type = bn.Type.named_type(
bn.NamedTypeReference(name=ty.name,
type_id=self._generate_typeid(
ty.name),
type_class=ntrc))
else:
if ty.composite_type in [
CompositeType.CLASS_TYPE, CompositeType.STRUCT_TYPE
]:
struct = bn.Structure()
struct.type = bn.StructureType.StructStructureType if ty.composite_type == CompositeType.STRUCT_TYPE else bn.StructureType.ClassStructureType
if ty.byte_size is not None:
struct.width = ty.byte_size
for m in ty.members:
member_type = self._construct_binja_type(
m.element, as_specifier=True)
member_name = m.name if m.name is not None else ''
if m.offset is not None:
struct.insert(m.offset, member_type, member_name)
binja_type = bn.Type.structure_type(struct)
elif ty.composite_type == CompositeType.UNION_TYPE:
union = bn.Structure()
union.type = bn.StructureType.UnionStructureType
if ty.byte_size is not None:
union.width = ty.byte_size
for m in ty.members:
member_type = self._construct_binja_type(
m.element, as_specifier=as_specifier)
member_name = m.name if m.name is not None else ''
if m.offset is not None:
union.insert(m.offset, member_type, member_name)
binja_type = bn.Type.structure_type(union)
elif ty.composite_type == CompositeType.ENUM_TYPE:
e = bn.Enumeration()
for m in ty.members:
e.append(m.name, m.offset)
binja_type = bn.Type.enumeration_type(
bv.arch, e, ty.byte_size)
elif ty.composite_type == CompositeType.FUNCTION_TYPE:
has_variable_args = False
ret = self._construct_binja_type(ty.element,
as_specifier=True)
params = []
for param in ty.members:
if param.element == Type.variadic():
has_variable_args = True
else:
params.append(
self._construct_binja_type(param.element,
as_specifier=True))
binja_type = bn.Type.function(
ret, params, variable_arguments=has_variable_args)
elif ty.composite_type == CompositeType.PTR_TO_MEMBER_TYPE:
binja_type = self._construct_binja_type(ty.members[1],
as_specifier=True)
elif ty.name is not None:
ntrc = bn.NamedTypeReferenceClass.TypedefNamedTypeClass
binja_type = bn.Type.named_type(
bn.NamedTypeReference(name=ty.name,
type_id=self._generate_typeid(ty.name),
type_class=ntrc))
else:
if ty.element is None:
print(ty.__dict__)
assert (ty.element is not None)
binja_type = self._construct_binja_type(
ty.element, as_specifier=as_specifier).mutable_copy()
if ty.is_constant:
binja_type.const = True
if ty.is_volatile:
binja_type.volatile = True
return binja_type