Container class for all Datatype objects in an Architecture. More...

#include <type.hh>

Inheritance diagram for TypeFactory:

Public Member Functions
	TypeFactory (Architecture *g)
	Construct a factory. More...

void	setupSizes (void)
	Derive some size information from Architecture. More...

void	clear (void)
	Clear out all types. More...

void	clearNoncore (void)
	Clear out non-core types. More...

virtual	~TypeFactory (void)
	Destructor.

void	setStructAlign (int4 al)
	Set the default structure alignment.

int4	getStructAlign (void) const
	Get the default structure alignment.

int4	getSizeOfInt (void) const
	Get the size of the default "int".

Architecture *	getArch (void) const
	Get the Architecture object.

Datatype *	findByName (const string &n)
	Return type of given name. More...

Datatype *	setName (Datatype *ct, const string &n)
	Set the given types name. More...

bool	setFields (vector< TypeField > &fd, TypeStruct *ot, int4 fixedsize, uint4 flags)
	Set fields on a TypeStruct. More...

bool	setEnumValues (const vector< string > &namelist, const vector< uintb > &vallist, const vector< bool > &assignlist, TypeEnum *te)
	Set named values for an enumeration. More...

Datatype *	restoreXmlType (const Element *el)
	Restore Datatype from XML. More...

Datatype *	restoreXmlTypeWithCodeFlags (const Element *el, bool isConstructor, bool isDestructor)
	Restore data-type from XML with extra "code" flags. More...

TypeVoid *	getTypeVoid (void)
	Get the "void" data-type. More...

Datatype *	getBaseNoChar (int4 s, type_metatype m)
	Get atomic type excluding "char". More...

Datatype *	getBase (int4 s, type_metatype m)
	Get atomic type. More...

Datatype *	getBase (int4 s, type_metatype m, const string &n)
	Get named atomic type. More...

TypeCode *	getTypeCode (void)
	Get an "anonymous" function data-type. More...

TypePointer *	getTypePointerStripArray (int4 s, Datatype *pt, uint4 ws)
	Construct a pointer data-type, stripping an ARRAY level. More...

TypePointer *	getTypePointer (int4 s, Datatype *pt, uint4 ws)
	Construct an absolute pointer data-type. More...

TypePointer *	getTypePointerNoDepth (int4 s, Datatype *pt, uint4 ws)
	Construct a depth limited pointer data-type. More...

TypeArray *	getTypeArray (int4 as, Datatype *ao)
	Construct an array data-type. More...

TypeStruct *	getTypeStruct (const string &n)
	Create an (empty) structure. More...

TypeEnum *	getTypeEnum (const string &n)
	Create an (empty) enumeration. More...

TypeSpacebase *	getTypeSpacebase (AddrSpace *id, const Address &addr)
	Create a "spacebase" type. More...

TypeCode *	getTypeCode (ProtoModel model, Datatype outtype, const vector< Datatype * > &intypes, bool dotdotdot)
	Create a "function" datatype. More...

void	destroyType (Datatype *ct)
	Remove a data-type from this. More...

Datatype *	downChain (Datatype *ptrtype, uintb &off)
	Find a sub-type matching a pointer and offset. More...

Datatype *	concretize (Datatype *ct)
	Convert given data-type to concrete form. More...

void	dependentOrder (vector< Datatype * > &deporder) const
	Place all data-types in dependency order. More...

void	saveXml (ostream &s) const
	Save this container to stream. More...

void	saveXmlCoreTypes (ostream &s) const
	Save core types to stream. More...

void	restoreXml (const Element *el)
	Restore this container from a stream. More...

void	restoreXmlCoreTypes (const Element *el)
	Initialize basic type names. More...

void	parseDataOrganization (const Element *el)
	Parse the <data_organization> tag. More...

void	parseEnumConfig (const Element *el)
	Parse the <enum> tag. More...

void	setCoreType (const string &name, int4 size, type_metatype meta, bool chartp)
	Create a core data-type. More...

void	cacheCoreTypes (void)
	Cache common types. More...

Protected Member Functions
Datatype *	findByIdLocal (const string &nm, uint8 id) const
	Search locally by name and id. More...

virtual Datatype *	findById (const string &n, uint8 id)
	Search by name and id. More...

Protected Attributes
Architecture *	glb
	The Architecture object that owns this TypeFactory.

Private Member Functions
Datatype *	findNoName (Datatype &ct)
	Find data-type (in this container) by function. More...

Datatype *	findAdd (Datatype &ct)
	Find data-type in this container or add it. More...

void	orderRecurse (vector< Datatype * > &deporder, DatatypeSet &mark, Datatype *ct) const
	Write out dependency list. More...

Datatype *	restoreXmlTypeNoRef (const Element *el, bool forcecore)
	Restore from an XML tag. More...

void	clearCache (void)
	Clear the common type cache. More...

TypeChar *	getTypeChar (const string &n)
	Create a default "char" type. More...

TypeUnicode *	getTypeUnicode (const string &nm, int4 sz, type_metatype m)
	Create a default "unicode" type. More...

TypeCode *	getTypeCode (const string &n)
	Create a default "code" type. More...

Private Attributes
int4	sizeOfInt
	Size of the core "int" datatype.

int4	align
	Alignment of structures.

int4	enumsize
	Size of an enumerated type.

type_metatype	enumtype
	Default enumeration meta-type (when parsing C)

DatatypeSet	tree
	Datatypes within this factory (sorted by function)

DatatypeNameSet	nametree
	Cross-reference by name.

Datatype *	typecache [9][8]
	Matrix of the most common atomic data-types.

Datatype *	typecache10
	Specially cached 10-byte float type.

Datatype *	typecache16
	Specially cached 16-byte float type.

Datatype *	type_nochar
	Same dimensions as char but acts and displays as an INT.

Detailed Description

Container class for all Datatype objects in an Architecture.

Constructor & Destructor Documentation

TypeFactory::TypeFactory ( Architecture * g )

Construct a factory.

Initialize an empty container

Parameters

g	is the owning Architecture

Member Function Documentation

void TypeFactory::cacheCoreTypes ( void )

Cache common types.

Run through the list of "core" data-types and cache the most commonly accessed ones for quick access (avoiding the tree lookup). The "core" data-types must have been previously initialized.

References Datatype::getMetatype(), Datatype::getSize(), Datatype::isASCII(), Datatype::isCharPrint(), Datatype::isCoreType(), Datatype::isEnumType(), TYPE_BOOL, TYPE_CODE, TYPE_FLOAT, TYPE_INT, TYPE_UINT, TYPE_UNKNOWN, and TYPE_VOID.

Referenced by ArchitectureGhidra::buildTypegrp().

void TypeFactory::clear ( void )

Clear out all types.

Remove all Datatype objects owned by this TypeFactory.

void TypeFactory::clearCache ( void )

private

Clear the common type cache.

Clear the matrix of commonly used atomic types.

void TypeFactory::clearNoncore ( void )

Clear out non-core types.

Delete anything that isn't a core type.

References Datatype::isCoreType().

Referenced by FlushNative::rawAction().

Datatype * TypeFactory::concretize ( Datatype * ct )

Convert given data-type to concrete form.

The data-type propagation system can push around data-types that are partial or are otherwise unrepresentable in the source language. This method substitutes those data-types with a concrete data-type that is representable, or returns the same data-type if is already concrete. Its important that the returned data-type have the same size as the original data-type regardless.

Parameters

ct	is the given data-type

Returns: the concrete data-type

References Datatype::getMetatype(), Datatype::getSize(), Datatype::metatype, TYPE_CODE, and TYPE_UNKNOWN.

Referenced by ScopeLocal::createEntry().

void TypeFactory::dependentOrder ( vector< Datatype * > & deporder ) const

Place all data-types in dependency order.

Place data-types in an order such that if the definition of data-type "a" depends on the definition of data-type "b", then "b" occurs earlier in the order

Parameters

deporder will hold the generated dependency list of data-types

Referenced by PrintC::docTypeDefinitions().

void TypeFactory::destroyType ( Datatype * ct )

Remove a data-type from this.

The indicated Datatype object is removed from this container. Indirect references (via TypeArray TypeStruct etc.) are not affected

Parameters

ct	is the data-type to destroy

References Datatype::isCoreType().

Datatype * TypeFactory::downChain	(	Datatype *	ptrtype,
		uintb &	off
	)

Find a sub-type matching a pointer and offset.

Add a constant offset to a pointer with known data-type. If there is a valid component at that offset, return a pointer to the data-type of the component or NULL otherwise. This routine only goes down one level at most. Pass back the renormalized offset relative to the new data-type

Parameters

ptrtype	is the pointer data-type being added to
off	is a reference to the offset to add

Returns: a pointer datatype for the component or NULL

References Datatype::getMetatype(), Datatype::getSubType(), TypePointer::getWordSize(), Datatype::metatype, TypePointer::ptrto, Datatype::size, TYPE_ARRAY, and TYPE_PTR.

Referenced by TypeOpPtrsub::getOutputToken(), and ActionInferTypes::propagateAddIn2Out().

Datatype * TypeFactory::findAdd ( Datatype & ct )

private

Find data-type in this container or add it.

Use quickest method (name or id is possible) to locate the matching data-type. If its not currently in this container, clone the data-type and add it to the container.

Parameters

ct	is the data-type to match

Returns: the matching Datatype object in this container

References Datatype::clone(), Datatype::compareDependency(), Datatype::getId(), Datatype::id, Datatype::name, and Datatype::printRaw().

Datatype * TypeFactory::findById	(	const string &	n,
		uint8	id
	)

protectedvirtual

Search by name and id.

Search for a Datatype by name and/or id. Derived classes may search outside this container.

Parameters

n	is the name of the data-type
id	is the type id of the data-type

Returns: the matching Datatype object

Reimplemented in TypeFactoryGhidra.

Referenced by TypeFactoryGhidra::findById().

Datatype * TypeFactory::findByIdLocal	(	const string &	n,
		uint8	id
	)		const

protected

Search locally by name and id.

Looking just within this container, find a Datatype by name and/or id.

Parameters

n	is the name of the data-type
id	is the type id of the data-type

Returns: the matching Datatype object

References Datatype::id, and TYPE_UNKNOWN.

Datatype * TypeFactory::findByName ( const string & n )

Return type of given name.

Find type with given name. If there are more than, return first.

Parameters

n	is the name to search for

Returns: a Datatype object with the name or NULL

Datatype * TypeFactory::findNoName ( Datatype & ct )

private

Find data-type (in this container) by function.

Find data-type without reference to name, using the functional comparators For this to work, the type must be built out of dependencies that are already present in this type factory

Parameters

ct	is the data-type to match

Returns: the matching Datatype or NULL

Datatype * TypeFactory::getBase	(	int4	s,
		type_metatype	m
	)

Get atomic type.

Get one of the "base" datatypes. This routine is called a lot, so we go through a cache first.

Parameters

s	is the desired size
m	is the desired meta-type

Returns: the Datatype object

References TYPE_FLOAT, and TYPE_UNKNOWN.

Datatype * TypeFactory::getBase	(	int4	s,
		type_metatype	m,
		const string &	n
	)

Get named atomic type.

Get or create a "base" type with a specified name and properties

Parameters

s	is the desired size
m	is the desired meta-type
n	is the desired name

Returns: the Database object

References Datatype::hashName(), and Datatype::id.

Datatype * TypeFactory::getBaseNoChar	(	int4	s,
		type_metatype	m
	)

Get atomic type excluding "char".

Get a "base" data-type, given its size and metatype. If a 1-byte integer is requested, do NOT return a TypeChar

Parameters

s	is the size of the data-type
m	is the meta-type of the data-type

Returns: the Datatype object

References TYPE_INT.

Referenced by TypeOpIntLeft::getInputLocal(), TypeOpIntRight::getInputLocal(), and TypeOpIntSright::getInputLocal().

TypeArray * TypeFactory::getTypeArray	(	int4	as,
		Datatype *	ao
	)

Construct an array data-type.

Parameters

as	is the number of elements in the desired array
ao	is the data-type of the array element

Returns: the TypeArray object

Referenced by ScopeLocal::createEntry().

TypeChar * TypeFactory::getTypeChar ( const string & n )

private

Create a default "char" type.

This creates a 1-byte character datatype (assumed to use UTF8 encoding)

Parameters

n	is the name to give the data-type

Returns: the new character Datatype object

References Datatype::hashName(), and Datatype::id.

TypeCode * TypeFactory::getTypeCode ( const string & nm )

private

Create a default "code" type.

Create a "function" or "executable" Datatype object This is used for anonymous function pointers with no prototype

Parameters

nm	is the name of the data-type

Returns: the new Datatype object

References Datatype::hashName(), and Datatype::id.

Referenced by ExternRefSymbol::buildNameType(), FunctionSymbol::buildType(), TypeOpCbranch::getInputLocal(), TypeOpCallind::getInputLocal(), TypeOpIndirect::getInputLocal(), and Funcdata::newCodeRef().

TypeCode * TypeFactory::getTypeCode ( void )

Get an "anonymous" function data-type.

Retrieve or create the core "code" Datatype object This has no prototype attached to it and is appropriate for anonymous function pointers.

Returns: the TypeCode object

References TYPE_CODE, and TYPE_FLOAT.

TypeCode * TypeFactory::getTypeCode	(	ProtoModel *	model,
		Datatype *	outtype,
		const vector< Datatype * > &	intypes,
		bool	dotdotdot
	)

Create a "function" datatype.

Creates a TypeCode object and associates a specific function prototype with it.

Parameters

model	is the prototype model associated with the function
outtype	is the return type of the function
intypes	is the array of input parameters of the function
dotdotdot	is true if the function takes variable arguments

Returns: the TypeCode object

References TypeCode::set().

TypeEnum * TypeFactory::getTypeEnum ( const string & n )

Create an (empty) enumeration.

The created enumeration will have no named values and a default configuration Named values must be added later.

Parameters

n	is the name of the enumeration

Returns: the TypeEnum object

References Datatype::enumtype, Datatype::hashName(), and Datatype::id.

TypePointer * TypeFactory::getTypePointer	(	int4	s,
		Datatype *	pt,
		uint4	ws
	)

Construct an absolute pointer data-type.

Allows "pointer to array" to be constructed

Parameters

s	is the size of the pointer
pt	is the pointed-to data-type
ws	is the wordsize associated with the pointer

Returns: the TypePointer object

Referenced by ParamListStandard::assignMap(), ParamListStandardOut::assignMap(), ExternRefSymbol::buildNameType(), TypeOpLoad::getInputCast(), TypeOpStore::getInputCast(), TypeOpCbranch::getInputLocal(), TypeOpCallind::getInputLocal(), TypeOpIndirect::getInputLocal(), ActionInferTypes::propagateAddIn2Out(), ActionInferTypes::propagateTypeEdge(), Funcdata::spacebase(), and Funcdata::spacebaseConstant().

TypePointer * TypeFactory::getTypePointerNoDepth	(	int4	s,
		Datatype *	pt,
		uint4	ws
	)

Construct a depth limited pointer data-type.

Parameters

s	is the size of the pointer
pt	is the pointed-to data-type
ws	is the wordsize associated with the pointer

Returns: the TypePointer object

References Datatype::getMetatype(), Datatype::getSize(), TYPE_PTR, and TYPE_UNKNOWN.

Referenced by ActionInferTypes::propagateTypeEdge().

TypePointer * TypeFactory::getTypePointerStripArray	(	int4	s,
		Datatype *	pt,
		uint4	ws
	)

Construct a pointer data-type, stripping an ARRAY level.

This creates a pointer to a given data-type. If the given data-type is an array, the TYPE_ARRAY property is stripped off, and a pointer to the array element data-type is returned.

Parameters

s	is the size of the pointer
pt	is the pointed-to data-type
ws	is the wordsize associated with the pointer

Returns: the TypePointer object

References Datatype::getMetatype(), and TYPE_ARRAY.

Referenced by Funcdata::spacebaseConstant().

TypeSpacebase * TypeFactory::getTypeSpacebase	(	AddrSpace *	id,
		const Address &	addr
	)

Create a "spacebase" type.

Creates the special TypeSpacebase with an associated address space and scope

Parameters

id	is the address space
addr	specifies the function scope, or isInvalid() for global scope

Returns: the TypeSpacebase object

Referenced by Funcdata::spacebase(), and Funcdata::spacebaseConstant().

TypeStruct * TypeFactory::getTypeStruct ( const string & n )

Create an (empty) structure.

The created structure will have no fields. They must be added later.

Parameters

n	is the name of the structure

Returns: the TypeStruct object

References Datatype::hashName(), and Datatype::id.

TypeUnicode * TypeFactory::getTypeUnicode	(	const string &	nm,
		int4	sz,
		type_metatype	m
	)

private

Create a default "unicode" type.

This creates a multi-byte character data-type (using UTF16 or UTF32 encoding)

Parameters

nm	is the name to give the data-type
sz	is the size of the data-type in bytes
m	is the presumed meta-type when treating the character as an integer

Returns: the new character Datatype object

References Datatype::hashName(), and Datatype::id.

TypeVoid * TypeFactory::getTypeVoid ( void )

Get the "void" data-type.

There should be exactly one instance of the "void" Datatype object, which this fetches

Returns: the "void" data-type

References TypeVoid::clone(), Datatype::getName(), Datatype::hashName(), Datatype::id, TYPE_FLOAT, and TYPE_VOID.

Referenced by ActionDefaultParams::apply(), PrintC::buildTypeStack(), FuncProto::paramShift(), PrintJava::pushTypeStart(), and Override::restoreXml().

void TypeFactory::orderRecurse	(	vector< Datatype * > &	deporder,
		DatatypeSet &	mark,
		Datatype *	ct
	)		const

private

Write out dependency list.

Recursively write out all the components of a data-type in dependency order Component data-types will come before the data-type containing them in the list.

Parameters

deporder	holds the ordered list of data-types to construct
mark	is a "marking" container to prevent cycles
ct	is the data-type to have written out

References Datatype::getDepend(), Datatype::numDepend(), and Datatype::size.

void TypeFactory::parseDataOrganization ( const Element * el )

Parse the <data_organization> tag.

Recover various sizes relevant to this container, such as the default size of "int" and structure alignment, by parsing the <data_organization> tag.

Parameters

el	is the XML element

References Element::getAttributeValue(), Element::getChildren(), and Element::getName().

void TypeFactory::parseEnumConfig ( const Element * el )

Parse the <enum> tag.

Recover default enumeration properties (size and meta-type) from an <enum> XML tag. Should probably consider this deprecated. These values are only used by the internal C parser. param el is the XML element

References Datatype::enumtype, Element::getAttributeValue(), TYPE_INT, TYPE_UINT, and xml_readbool().

void TypeFactory::restoreXml ( const Element * el )

Restore this container from a stream.

Read data-types into this container from an XML stream

Parameters

el	is the root XML element

References Datatype::enumtype, Element::getAttributeValue(), Element::getChildren(), TYPE_INT, TYPE_UINT, and xml_readbool().

void TypeFactory::restoreXmlCoreTypes ( const Element * el )

Initialize basic type names.

Restore data-types from an XML stream into this container This stream is presumed to contain "core" datatypes and the cached matrix will be populated from this set.

Parameters

el	is the root XML element

References Element::getChildren().

Referenced by ArchitectureGhidra::buildTypegrp().

Datatype * TypeFactory::restoreXmlType ( const Element * el )

Restore Datatype from XML.

Restore a Datatype object from an XML tag description: either <type>, <typeref>, or <void>

Parameters

el	is the XML element describing the data-type

Returns: the restored Datatype object

References Element::getAttributeName(), Element::getAttributeValue(), Element::getName(), Element::getNumAttributes(), and Datatype::hashName().

Referenced by TypeFactoryGhidra::findById(), CPoolRecord::restoreXml(), ProtoStoreInternal::restoreXml(), and FuncProto::restoreXml().

Datatype * TypeFactory::restoreXmlTypeNoRef	(	const Element *	el,
		bool	forcecore
	)

private

Restore from an XML tag.

Restore a Datatype object from an XML <type> tag. (Don't use for <typeref> tags) The new Datatype is added to this container

Parameters

el	is the XML element
forcecore	is true if the new type should be labeled as a core type

Returns: the new Datatype object

References Datatype::compareDependency(), Datatype::coretype, TypeStruct::field, Datatype::flags, Element::getAttributeName(), Element::getAttributeValue(), Datatype::getMetatype(), Element::getName(), Element::getNumAttributes(), Datatype::getSize(), Datatype::hashName(), Datatype::hashSize(), Datatype::id, Datatype::restoreXml(), TypeUnicode::restoreXml(), TypePointer::restoreXml(), TypeArray::restoreXml(), TypeEnum::restoreXml(), TypeStruct::restoreXml(), TypeCode::restoreXml(), TypeSpacebase::restoreXml(), Datatype::size, string2metatype(), TYPE_ARRAY, TYPE_CODE, TYPE_INT, TYPE_PTR, TYPE_SPACEBASE, TYPE_STRUCT, TYPE_UNKNOWN, and xml_readbool().

Datatype * TypeFactory::restoreXmlTypeWithCodeFlags	(	const Element *	el,
		bool	isConstructor,
		bool	isDestructor
	)

Restore data-type from XML with extra "code" flags.

Kludge to get flags into code pointer types, when they can't come through XML

Parameters

el	is the XML element describing the Datatype
isConstructor	toggles "constructor" property on "function" datatypes
isDestructor	toggles "destructor" property on "function" datatypes

Returns: the restored Datatype object

References Element::getAttributeName(), Element::getAttributeValue(), Element::getChildren(), Datatype::getMetatype(), Element::getNumAttributes(), TypePointer::ptrto, TypeCode::restoreXml(), Datatype::restoreXmlBasic(), TypeCode::setProperties(), TYPE_PTR, and TypePointer::wordsize.

Referenced by CPoolRecord::restoreXml().

void TypeFactory::saveXml ( ostream & s ) const

Save this container to stream.

All data-types, in dependency order, are written out to an XML stream

Parameters

s	is the output stream

References a_v_b(), a_v_i(), Datatype::enumtype, TYPE_ARRAY, TYPE_INT, TYPE_PTR, and TYPE_STRUCT.

void TypeFactory::saveXmlCoreTypes ( ostream & s ) const

Save core types to stream.

Any data-type within this container marked as "core" will be written to an XML <coretypes> stream.

Parameters

s	is the output stream

References Datatype::getMetatype(), Datatype::isCoreType(), Datatype::saveXml(), TYPE_ARRAY, TYPE_PTR, and TYPE_STRUCT.

Referenced by XmlArchitecture::saveXml(), RawBinaryArchitecture::saveXml(), and BfdArchitecture::saveXml().

void TypeFactory::setCoreType	(	const string &	name,
		int4	size,
		type_metatype	meta,
		bool	chartp
	)

Create a core data-type.

Manually create a "base" core type. This currently must be called before any pointers or arrays are defined off of the type.

Parameters

name	is the data-type name
size	is the size of the data-type
meta	is the meta-type of the data-type
chartp	is true if a character type should be created

References Datatype::coretype, Datatype::flags, TYPE_CODE, and TYPE_VOID.

Referenced by ArchitectureGhidra::buildTypegrp().

bool TypeFactory::setEnumValues	(	const vector< string > &	namelist,
		const vector< uintb > &	vallist,
		const vector< bool > &	assignlist,
		TypeEnum *	te
	)

Set named values for an enumeration.

Set the list of enumeration values and identifiers for a TypeEnum Fill in any values for any names that weren't explicitly assigned and check for duplicates.

Parameters

namelist	is the list of names in the enumeration
vallist	is the corresponding list of values assigned to names in namelist
assignlist	is true if the corresponding name in namelist has an assigned value
te	is the enumeration object to modify

Returns: true if the modification is successful (no duplicate names)

References calc_mask(), Datatype::getSize(), and TypeEnum::setNameMap().

bool TypeFactory::setFields	(	vector< TypeField > &	fd,
		TypeStruct *	ot,
		int4	fixedsize,
		uint4	flags
	)

Set fields on a TypeStruct.

Make sure all the offsets are fully established then set fields of the structure If -fixedsize- is greater than 0, force the final structure to have that size

Parameters

fd	is the list of fields to set
ot	is the TypeStruct object to modify
fixedsize	is 0 or the forced size of the structure
flags	are other flags to set on the structure