Aggregates (Structs and Unions)
temu_Class
Type
struct temu_Class {
temu_Object Super;
void * Impl;
void * VTable;
temu_ObjectCreateFunc Create;
temu_ObjectDisposeFunc Dispose;
}Description
Class object
The TEMU object system is a dynamic object system. Classes are themselves represented as objects (instanciated by meta-classes).
The TEMU class contains among other things the constructor/destructor.
Internally, the hidden implementation provides more capabilities than is exposed
by the temu_Class type.
Fields
| Field | Type | Description |
|---|---|---|
Super |
temu_Object |
Super class of the class instance. |
Impl |
void * |
Internal pointer, do not touch. |
VTable |
void * |
Internal pointer, do not touch. |
Create |
temu_ObjectCreateFunc |
Constructor / create function for creating instances of the class. |
Dispose |
temu_ObjectDisposeFunc |
Destructor / dispose function for disposing instances of the class. |
temu_CreateArg
Description
Generic constructor argument
The object constructors takes an array of key/value pairs as parameters. The values are passed using either:
-
Registered argument in the
Class.newcommand method. -
Explicitly to
temu_createObject(). -
Args parameter to
object-createglobal command.
The object create function would typically scan through the array, finding relevant matching keys.
temu_IfaceRef
Description
Generic interface
In TEMU interfaces are referred to using an object / interface pointer pair. The object is in general passed as the first parameter to functions in the interface. This type provides a generic interface reference where the interface pointer itself is type erased.
While the type is rarely used by itself, it is commonly returned by the TEMU API. To convert to / from this type from / to typed interface references, it is possible to either memcopy or cast field by field.
temu_IfaceRefArray
temu_MemAccessCapabilities
temu_MemTransaction
Type
struct temu_MemTransaction {
uint64_t Va;
uint64_t Pa;
uint64_t Value;
uint64_t Size;
uint64_t Offset;
temu_InitiatorType InitiatorType;
temu_Object * Initiator;
void * Page;
uint64_t Cycles;
uint32_t Flags;
void * IR;
}Description
Generic memory transaction.
This type is kept in sync with the emulator core. The layout is guaranteed. and will remain as is, although more fields may be added (at the bottom).
When the emulator core issues a memory transaction (assuming no ATC hit), the core allocates this structure on the stack and fills in some of the fields with default values. The memory transaction is passed by pointer or reference. By filling in the different fields you can adapt the result of the memory transaction.
Fields
| Field | Type | Description |
|---|---|---|
Va |
uint64_t |
64 bit virtual for unified 32/64 bit interface. |
Pa |
uint64_t |
64 bit physical address |
Value |
uint64_t |
Resulting value (or written value). On MMIO Reads the model fills in this value, and on writes the written value will be stored here. |
Size |
uint64_t |
Two-logarithm of the size of the transaction in bytes it is at most the size of the CPUs max bus size. In case of SPARCv8, this is 4 bytes (double words are issued as two accesses). As this is the 2-log of the size in bytes, a single byte access will have a size of 0, a 2 byte transaction will have size 1, a 4 byte transaction will have size 2 and an 8 byte transaction will have size 3. In TEMU3 this field was changed to an uint64_t from uint8_t. This as it does not add any additional space. And we can repurpose value and size as follows: - The lower 2 bits define the base unit of the transaction (same as before), 0 ⇒ 1 byte, 1 ⇒ 2 bytes, 2 ⇒ 4 bytes, 3 ⇒ 8 bytes. - The upper bits define the number of transferred units 0 implies one unit. If the transferred units is more than 0, we are dealing with a large transaction. These can be used by e.g. RAM models for block transfers etc. In that case the Value field is to be reinterpreted as a pointer to the location of the data. This means that we can use the memory access interface to e.g. read out send lists and similar items. The memory space must thus have a way of determining which type of transaction is legal. The MemoryAccessIface has been extended with a capability query, which if implemented has the ability to query for supported features. |
Offset |
uint64_t |
Used for device models, this will be filled in with the offset from the start address of the device (note it is in practice possible to add a device at multiple locations (which happens in some rare cases)). |
InitiatorType |
temu_InitiatorType |
InitiatorType identifies the type of object starting the transaction. this is only relevant when Initiator is set to non-null, and allows for the specification of device pointers in the initator. This field is new in TEMU 2.2. The field was introduced to support the implementation of I/O MMUs. |
Initiator |
Initiator of the transaction (a CPU object). It can be null, which indicate that the transaction was not initiated by normal CPU activity (e.g. fetch, read or write). When the initiator is null, models should not attempt to stop the processor core, go to idle mode or raise traps (posting events is fine). An example when the initiator is null is when an MMU does a table walk. The MMU will normally special case handle table walks which access un-mapped memory. |
|
Page |
void * |
Page pointer (for caching), this can be filled in by a memory model to have the emulator core inject the page translation in the ATC. If a model sets this, the page pointer will automatically be cleared if the page has attributes (breakpoints, etc). Models that implement normal memory mapped registers should NOT populate the page pointer. |
Cycles |
uint64_t |
Cycle cost for memory access (initialised to 0). |
Flags |
uint32_t |
Flags for use in the memory hierarchy. |
IR |
void * |
Intermediate code for interpreter (internally managed do not modify) |
temu_Object
Type
struct temu_Object {
temu_Class * Class;
char * Name;
struct temu_Object * TimeSource;
temu_Component * Component;
uint64_t LoggingFlags;
int64_t WillDisposeNotification;
int64_t DisposedNotification;
void * UserData;
uint64_t IsClassObject;
uint64_t IsCheckpointable;
}Description
Root object type for all TEMU objects.
The TEMU object system is used for defining models in TEMU.
All models must derive from temu_Object.
Inheritance in C is done by placing a temu_Object field
as the first field in the derived struct.
TEMU by convention use the name Super for the parent field name.
The type contains a UserData void pointer that can be used by for example
simulator integrators.
The UserData field can be written by the user.
The field is guaranteed to not be modified by the TEMU runtime.
| While the convention in C is safe, in C++ it is the responsibility of the user to ensure that the derived type is a standard layout type. |
Fields
| Field | Type | Description |
|---|---|---|
Class |
Class pointer |
|
Name |
char * |
Object name |
TimeSource |
struct temu_Object * |
Timesource object |
Component |
Parent component (null for root comp) |
|
LoggingFlags |
uint64_t |
Log category enabled/disabled |
WillDisposeNotification |
int64_t |
Notification emitted before object is deleted |
DisposedNotification |
int64_t |
Notification emitted after object has been deleted |
UserData |
void * |
User data pointer. This is not saved in snapshots. |
IsClassObject |
uint64_t |
The object is a class object |
IsCheckpointable |
uint64_t |
The object is snapshottable |
temu_SpwRmapDecodedPacket
Type
struct temu_SpwRmapDecodedPacket {
uint32_t TotalSize;
temu_SpwRmapPacketType PacketType;
temu_SpwRmapDecodedCmdField CmdField;
temu_SpwRmapRawHeader RawHeader;
}Fields
| Field | Type | Description |
|---|---|---|
TotalSize |
uint32_t |
Total size of the packet received. |
PacketType |
temu_SpwRmapPacketType |
The packet type as identified by bits [7,6] in instruction. |
CmdField |
temu_SpwRmapDecodedCmdField |
The command field, bits [5,4,3,2] in instruction. |
RawHeader |
temu_SpwRmapRawHeader |
Raw header data access. |
temu_SpwRmapDecodedReadReply
temu_SpwRmapDecodedRmwReply
temu_SpwRmapRmwCmdPacket
Type
struct temu_SpwRmapRmwCmdPacket {
uint8_t AccessSize;
const uint8_t * Data;
const uint8_t * Mask;
uint32_t AvailableDataLength;
uint8_t DataCrc;
}Fields
| Field | Type | Description |
|---|---|---|
AccessSize |
uint8_t |
Size of the access. |
Data |
const uint8_t * |
Pointer to the first data char. |
Mask |
const uint8_t * |
Pointer to the first mask char. |
AvailableDataLength |
uint32_t |
The amount of data available. |
DataCrc |
uint8_t |
Data crc. Valid only if AvailableDataLength > Header.DataLength. |