Ghidra Decompiler Analysis Engine
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
TypeFactory Class Reference

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

#include <type.hh>

Inheritance diagram for TypeFactory:
Inheritance graph
[legend]
Collaboration diagram for TypeFactory:
Collaboration graph
[legend]

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.
 
DatatypefindByName (const string &n)
 Return type of given name. More...
 
DatatypesetName (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...
 
DatatyperestoreXmlType (const Element *el)
 Restore Datatype from XML. More...
 
DatatyperestoreXmlTypeWithCodeFlags (const Element *el, bool isConstructor, bool isDestructor)
 Restore data-type from XML with extra "code" flags. More...
 
TypeVoidgetTypeVoid (void)
 Get the "void" data-type. More...
 
DatatypegetBaseNoChar (int4 s, type_metatype m)
 Get atomic type excluding "char". More...
 
DatatypegetBase (int4 s, type_metatype m)
 Get atomic type. More...
 
DatatypegetBase (int4 s, type_metatype m, const string &n)
 Get named atomic type. More...
 
TypeCodegetTypeCode (void)
 Get an "anonymous" function data-type. More...
 
TypePointergetTypePointerStripArray (int4 s, Datatype *pt, uint4 ws)
 Construct a pointer data-type, stripping an ARRAY level. More...
 
TypePointergetTypePointer (int4 s, Datatype *pt, uint4 ws)
 Construct an absolute pointer data-type. More...
 
TypePointergetTypePointerNoDepth (int4 s, Datatype *pt, uint4 ws)
 Construct a depth limited pointer data-type. More...
 
TypeArraygetTypeArray (int4 as, Datatype *ao)
 Construct an array data-type. More...
 
TypeStructgetTypeStruct (const string &n)
 Create an (empty) structure. More...
 
TypeEnumgetTypeEnum (const string &n)
 Create an (empty) enumeration. More...
 
TypeSpacebasegetTypeSpacebase (AddrSpace *id, const Address &addr)
 Create a "spacebase" type. More...
 
TypeCodegetTypeCode (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...
 
DatatypedownChain (Datatype *ptrtype, uintb &off)
 Find a sub-type matching a pointer and offset. More...
 
Datatypeconcretize (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

DatatypefindByIdLocal (const string &nm, uint8 id) const
 Search locally by name and id. More...
 
virtual DatatypefindById (const string &n, uint8 id)
 Search by name and id. More...
 

Protected Attributes

Architectureglb
 The Architecture object that owns this TypeFactory.
 

Detailed Description

Container class for all Datatype objects in an Architecture.

Constructor & Destructor Documentation

◆ TypeFactory()

TypeFactory::TypeFactory ( Architecture g)

Construct a factory.

Initialize an empty container

Parameters
gis the owning Architecture

Member Function Documentation

◆ cacheCoreTypes()

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.

◆ clear()

void TypeFactory::clear ( void  )

Clear out all types.

Remove all Datatype objects owned by this TypeFactory.

◆ clearNoncore()

void TypeFactory::clearNoncore ( void  )

Clear out non-core types.

Delete anything that isn't a core type.

◆ concretize()

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
ctis the given data-type
Returns
the concrete data-type

◆ dependentOrder()

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
deporderwill hold the generated dependency list of data-types

◆ destroyType()

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
ctis the data-type to destroy

◆ downChain()

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
ptrtypeis the pointer data-type being added to
offis a reference to the offset to add
Returns
a pointer datatype for the component or NULL

◆ findById()

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
nis the name of the data-type
idis the type id of the data-type
Returns
the matching Datatype object

Reimplemented in TypeFactoryGhidra.

◆ findByIdLocal()

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
nis the name of the data-type
idis the type id of the data-type
Returns
the matching Datatype object

◆ findByName()

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

Return type of given name.

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

Parameters
nis the name to search for
Returns
a Datatype object with the name or NULL

◆ getBase() [1/2]

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
sis the desired size
mis the desired meta-type
Returns
the Datatype object

◆ getBase() [2/2]

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
sis the desired size
mis the desired meta-type
nis the desired name
Returns
the Database object

◆ getBaseNoChar()

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
sis the size of the data-type
mis the meta-type of the data-type
Returns
the Datatype object

◆ getTypeArray()

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

Construct an array data-type.

Parameters
asis the number of elements in the desired array
aois the data-type of the array element
Returns
the TypeArray object

◆ getTypeCode() [1/2]

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
modelis the prototype model associated with the function
outtypeis the return type of the function
intypesis the array of input parameters of the function
dotdotdotis true if the function takes variable arguments
Returns
the TypeCode object

◆ getTypeCode() [2/2]

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

◆ getTypeEnum()

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
nis the name of the enumeration
Returns
the TypeEnum object

◆ getTypePointer()

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

Construct an absolute pointer data-type.

Allows "pointer to array" to be constructed

Parameters
sis the size of the pointer
ptis the pointed-to data-type
wsis the wordsize associated with the pointer
Returns
the TypePointer object

◆ getTypePointerNoDepth()

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

Construct a depth limited pointer data-type.

Parameters
sis the size of the pointer
ptis the pointed-to data-type
wsis the wordsize associated with the pointer
Returns
the TypePointer object

◆ getTypePointerStripArray()

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
sis the size of the pointer
ptis the pointed-to data-type
wsis the wordsize associated with the pointer
Returns
the TypePointer object

◆ getTypeSpacebase()

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

Create a "spacebase" type.

Creates the special TypeSpacebase with an associated address space and scope

Parameters
idis the address space
addrspecifies the function scope, or isInvalid() for global scope
Returns
the TypeSpacebase object

◆ getTypeStruct()

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

Create an (empty) structure.

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

Parameters
nis the name of the structure
Returns
the TypeStruct object

◆ getTypeVoid()

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

◆ parseDataOrganization()

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
elis the XML element

◆ parseEnumConfig()

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

◆ restoreXml()

void TypeFactory::restoreXml ( const Element el)

Restore this container from a stream.

Read data-types into this container from an XML stream

Parameters
elis the root XML element

◆ restoreXmlCoreTypes()

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
elis the root XML element

◆ restoreXmlType()

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
elis the XML element describing the data-type
Returns
the restored Datatype object

◆ restoreXmlTypeWithCodeFlags()

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
elis the XML element describing the Datatype
isConstructortoggles "constructor" property on "function" datatypes
isDestructortoggles "destructor" property on "function" datatypes
Returns
the restored Datatype object

◆ saveXml()

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
sis the output stream

◆ saveXmlCoreTypes()

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
sis the output stream

◆ setCoreType()

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
nameis the data-type name
sizeis the size of the data-type
metais the meta-type of the data-type
chartpis true if a character type should be created

◆ setEnumValues()

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
namelistis the list of names in the enumeration
vallistis the corresponding list of values assigned to names in namelist
assignlistis true if the corresponding name in namelist has an assigned value
teis the enumeration object to modify
Returns
true if the modification is successful (no duplicate names)

◆ setFields()

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
fdis the list of fields to set
otis the TypeStruct object to modify
fixedsizeis 0 or the forced size of the structure
flagsare other flags to set on the structure
Returns
true if modification was successful

◆ setName()

Datatype * TypeFactory::setName ( Datatype ct,
const string &  n 
)

Set the given types name.

This routine renames a Datatype object and fixes up cross-referencing

Parameters
ctis the data-type to rename
nis the new name
Returns
the renamed Datatype object

◆ setupSizes()

void TypeFactory::setupSizes ( void  )

Derive some size information from Architecture.

Set up default values for size of "int", structure alignment, and enums.


The documentation for this class was generated from the following files: