Register.xcc
Benoit Dupont de Dinechin (Benoit.Dupont-de-Dinechin@st.com).
Copyright 2002 - 2007 STMicroelectronics. Copyright 1995 - 1998 Commissariat a l'Energie Atomique.
This program is free software; you can redistribute it and/or modify it under the terms of either (at your option): the GNU General Public License (GPL) version 2; the GNU Lesser General Public License (LGPL) version 2.1; any later version of these licences as published by the Free Software Foundation.
Register_name_— Names for the Register enumeration.
extern const char * Register_name_(Register this); extern const char * Register_name(Register this);
Register_names— The names of this Register.
const char ** Register_names(Register this);
Register_regFile— The RegFile of this Register.
RegFile Register_regFile(Register this);
Register_isWired— True if this Register is wired.
bool Register_isWired(Register this);
RegisterStorageCells— Sequence of StorageCell(s).
struct RegisterStorageCells_ { int8_t COUNT; StorageCell ITEMS[RegisterStorageCells_COUNT_MAX]; };
RegisterStorageCells_count— Count of StorageCell(s) in this RegisterStorageCells.
static inline int RegisterStorageCells_count(const_RegisterStorageCells this) { return RegisterStorageCells_COUNT(this); }
RegisterStorageCells_items— StorageCell(s) in this RegisterStorageCells.
static inline const StorageCell * RegisterStorageCells_items(const_RegisterStorageCells this) { return RegisterStorageCells_ITEMS(this); }
RegisterStorageCells_access— Access a StorageCell in this RegisterStorageCells.
static inline StorageCell RegisterStorageCells_access(const_RegisterStorageCells this, int index) { Except_CHECK((unsigned)index < RegisterStorageCells_COUNT(this)); return (StorageCell)RegisterStorageCells_ITEMS(this)[index]; }
RegisterStorageCells_FOREACH_StorageCell— Iterate this RegisterStorageCells.
#define RegisterStorageCells_FOREACH_StorageCell(this, cell) { \ const StorageCell *RegisterStorageCells_ITEMS = RegisterStorageCells_items(this); \ int RegisterStorageCells_COUNT = RegisterStorageCells_count(this); \ int RegisterStorageCells_INDEX = 0; \ for (; RegisterStorageCells_INDEX < RegisterStorageCells_COUNT; RegisterStorageCells_INDEX++) { \ int cell = RegisterStorageCells_ITEMS[RegisterStorageCells_INDEX]; #define RegisterStorageCells_ENDEACH_StorageCell \ } \ }
Register_storageCells— This Register RegisterStorageCells.
const_RegisterStorageCells Register_storageCells(Register this);
Register_minReadStage— This Register minimum read stage for each Processor.
int Register_minReadStage(Register this, Processor processor);
RegisterList— Non-mutable list of Register(s).
struct RegisterList_ { //@args uint8_t COUNT; Register ITEMS[RegisterList_COUNT_MAX]; };
RegisterList_count— Count the Register(s) in this RegisterList.
static inline int RegisterList_count(const_RegisterList this) { return RegisterList_COUNT(this); }
RegisterList_first— First item of the RegisterList. Return: The first Register.
static inline Register RegisterList_first(const_RegisterList this) { Except_REQUIRE(RegisterList_COUNT(this) > 0); return (Register)RegisterList_ITEMS(this)[0]; }
RegisterList_access— Access the RegisterList by index. index: The index. Return: Corresponding Register.
static inline Register RegisterList_access(const_RegisterList this, int32_t index) { Except_REQUIRE(0 <= index && index < RegisterList_COUNT(this)); return (Register)RegisterList_ITEMS(this)[index]; }
RegisterList_items— For use by RegisterList_FOREACH_Register.
static inline const Register * RegisterList_items(const_RegisterList this) { return RegisterList_ITEMS(this); }
RegisterList_FOREACH_Register— Iterate over this RegisterList Register(s).
#define RegisterList_FOREACH_Register(this, registre) { \ const Register *RegisterList_ITEMS = RegisterList_items(this); \ int RegisterList_COUNT = RegisterList_count(this), RegisterList_INDEX = 0; \ for (; RegisterList_INDEX < RegisterList_COUNT; RegisterList_INDEX++) { \ int registre = RegisterList_ITEMS[RegisterList_INDEX]; #define RegisterList_ENDEACH_Register \ } \ }
RegisterList_contains— True if this RegisterList contains the given Register.
bool RegisterList_contains(const_RegisterList this, Register member);
Register_isLifetime— Test if this Register Lifetime should be minimized.
bool Register_isLifetime(Register this, Convention convention);
RegisterSet— Set of architectural registers.
See the CCL/RegisterSet.xcc code to add RegisterSet methods.
struct RegisterSet_ { //@args RegisterSetWord WORDS[RegisterSet_WORDCOUNT]; };
RegisterSet_words— Return the RegisterSet word array.
static inline const RegisterSetWord * RegisterSet_words(const_RegisterSet this) { return RegisterSet_WORDS(this); }
RegisterSet_isEmpty— True iff this RegisterSet is empty.
bool RegisterSet_isEmpty(const_RegisterSet this);
RegisterSet_count— Count members contained in the RegisterSet.
- Return
- The count of members in this RegisterSet.
int RegisterSet_count(const_RegisterSet this);
RegisterSet_first— First Register in this RegisterSet.
Register RegisterSet_first(const_RegisterSet this);
RegisterSet_empty— Empty this RegisterSet.
void RegisterSet_empty(RegisterSet this);
RegisterSet_choose— Choose and remove a member of the RegisterSet.
- Return
- Valid Register or Register_ if this RegisterSet is empty.
Register RegisterSet_choose(RegisterSet this);
RegisterSet_nextMember— Get the next Register of the RegisterSet.
Register RegisterSet_nextMember(const_RegisterSet this, Register member);
RegisterSet_chooseFromLast— Choose and remove a member of the RegisterSet starting from the last_reg, e.g., if rn was last used, rn+1 will be return if it is avaiable.
- Return
- Valid Register or Register_ if this RegisterSet is empty.
Register RegisterSet_chooseFromLast(RegisterSet set, Register last_reg);
RegisterSet_contains— Test a member for containment.
- Return
- True if this RegisterSet contains member.
bool RegisterSet_contains(const_RegisterSet this, Register member);
RegisterSet_insert— Insert a member in this RegisterSet.
- Return
- False iff member was already contained in this RegisterSet.
bool RegisterSet_insert(RegisterSet this, Register member);
RegisterSet_remove— Remove a member from this RegisterSet.
- Return
- False iff member was not contained in this RegisterSet.
bool RegisterSet_remove(RegisterSet this, Register member);
RegisterSet_equals— Test for RegisterSet equality.
bool RegisterSet_equals(const_RegisterSet this, const_RegisterSet that);
RegisterSet_union— Union of this RegisterSet with that RegisterSet.
void RegisterSet_union(RegisterSet this, const_RegisterSet that);
RegisterSet_inter— Intersect this RegisterSet with that RegisterSet.
void RegisterSet_inter(RegisterSet this, const_RegisterSet that);
RegisterSet_diff— Remove that RegisterSet members from this RegisterSet.
void RegisterSet_diff(RegisterSet this, const_RegisterSet that);
RegisterSet_FOREACH_Register— Iterate over this RegisterSet registers
#define RegisterSet_FOREACH_Register(this, registre) { \ int registre = Register__UNDEF; \ const_RegisterSet RegisterSet_THIS = (this); \ int RegisterSet_COUNT = RegisterSet_WORDCOUNT, RegisterSet_I, RegisterSet_J; \ for (RegisterSet_I = 0; RegisterSet_I < RegisterSet_COUNT; RegisterSet_I++) { \ RegisterSetWord RegisterSet_WORD = RegisterSet_WORDS(RegisterSet_THIS)[RegisterSet_I]; \ for (RegisterSet_J = 0; RegisterSet_J < RegisterSet_WORDBITS; \ RegisterSet_J++, RegisterSet_WORD >>= 1, registre++) { \ if (RegisterSet_WORD & 1) { #define RegisterSet_ENDEACH_Register \ } \ } \ if (RegisterSet_J != RegisterSet_WORDBITS) break; \ } \ }
RegisterSet_pretty— Pretty-print this RegisterSet.
bool RegisterSet_pretty(const_RegisterSet this, FILE *file);
RegisterAction— Action on a Register for scoreboarding and bundling.
struct RegisterAction_ { Register REGISTER; // Implicit register if rank == 0. RegClass REGCLASS; // RegClass if not implicit register. int8_t XXXINDEX; // Index of argument or result. int8_t RANK; // Operand rank in Operands. int8_t STAGE; // Access stage in the pipeline. };
RegisterAction_register— Register of this RegisterAction.
static inline Register RegisterAction_register(const_RegisterAction this) { return (Register)RegisterAction_REGISTER(this); }
RegisterAction_regClass— RegClass of this RegisterAction.
static inline RegClass RegisterAction_regClass(const_RegisterAction this) { return (RegClass)RegisterAction_REGCLASS(this); }
RegisterAction_xxxIndex— Index of argument or result OperatorParameter(s).
static inline int RegisterAction_xxxIndex(const_RegisterAction this) { return RegisterAction_XXXINDEX(this); }
RegisterAction_rank— Rank of this RegisterAction in the Instance Operand list.
- Return
- 0 if the RegisterAction has no corresponding Operand.
static inline int RegisterAction_rank(const_RegisterAction this) { return RegisterAction_RANK(this); }
RegisterAction_stage— The pipeline stage of this RegisterAction.
static inline int RegisterAction_stage(const_RegisterAction this) { return RegisterAction_STAGE(this); }
RegisterAction_setStage— Set the pipeline stage of this RegisterAction.
static inline void RegisterAction_setStage(RegisterAction this, int stage) { *RegisterAction__STAGE(this) = stage; }
RegisterActionArray— Array of RegisterAction(s).
struct RegisterActionArray_ { uint8_t READCOUNT; // Count of Read RegisterAction(s). uint8_t READSTART; // Start index of variant Read RegisterAction(s). uint8_t WRITECOUNT; // Count of Write RegisterAction(s). uint8_t WRITESTART; // Start index of variant Write RegisterAction(s). RegisterAction_ *ITEMS; // This RegisterActionArray items. };
RegisterActionArray_readCount— Count of Read RegisterAction(s).
static inline int RegisterActionArray_readCount(const_RegisterActionArray this) { return RegisterActionArray_READCOUNT(this); }
RegisterActionArray_readStart— Start index of variant Read RegisterAction(s).
static inline int RegisterActionArray_readStart(const_RegisterActionArray this) { return RegisterActionArray_READSTART(this); }
RegisterActionArray_writeCount— Count of Write RegisterAction(s).
static inline int RegisterActionArray_writeCount(const_RegisterActionArray this) { return RegisterActionArray_WRITECOUNT(this); }
RegisterActionArray_writeStart— Start index of variant Write RegisterAction(s).
static inline int RegisterActionArray_writeStart(const_RegisterActionArray this) { return RegisterActionArray_WRITESTART(this); }
RegisterActionArray_count— Count of Read and Write RegisterAction(s).
static inline int RegisterActionArray_count(const_RegisterActionArray this) { return RegisterActionArray_READCOUNT(this) + RegisterActionArray_WRITECOUNT(this); }
RegisterActionArray_readActions— this RegisterActionArray read RegisterAction(s).
static inline const RegisterAction_ * RegisterActionArray_readActions(const_RegisterActionArray this) { return RegisterActionArray_ITEMS(this) + 0; }
RegisterActionArray_writeActions— this RegisterActionArray write RegisterAction(s).
static inline const RegisterAction_ * RegisterActionArray_writeActions(const_RegisterActionArray this) { return RegisterActionArray_ITEMS(this) + RegisterActionArray_READCOUNT(this); }
RegisterActionArray_items— For use by RegisterActionArray_FOREACH_RegisterAction.
static inline const RegisterAction_ * RegisterActionArray_items(const_RegisterActionArray this) { return RegisterActionArray_ITEMS(this); }
RegisterActionArray_FOREACH_RegisterAction— Iterate over this RegisterActionArray RegisterAction(s).
#define RegisterActionArray_FOREACH_RegisterAction(this, action) { \ const RegisterAction_ *RegisterActionArray_ITEMS = RegisterActionArray_items(this); \ int RegisterActionArray_COUNT = RegisterActionArray_count(this); \ int RegisterActionArray_INDEX = 0; \ for (; RegisterActionArray_INDEX < RegisterActionArray_COUNT; \ RegisterActionArray_INDEX++) { \ const_RegisterAction action = RegisterActionArray_ITEMS + \ RegisterActionArray_INDEX; #define RegisterActionArray_ENDEACH_RegisterAction \ } \ }
RegisterActionArray_FORREAD_RegisterAction— Iterate over this RegisterActionArray Read RegisterAction(s).
#define RegisterActionArray_FORREAD_RegisterAction(this, action) { \ const RegisterAction_ *RegisterActionArray_ITEMS = RegisterActionArray_items(this); \ int RegisterActionArray_READCOUNT = RegisterActionArray_readCount(this); \ int RegisterActionArray_INDEX = 0; \ for (; RegisterActionArray_INDEX < RegisterActionArray_READCOUNT; \ RegisterActionArray_INDEX++) { \ const_RegisterAction action = RegisterActionArray_ITEMS + \ RegisterActionArray_INDEX; #define RegisterActionArray_ENDREAD_RegisterAction \ } \ }
RegisterActionArray_FORWRITE_RegisterAction— Iterate over this RegisterActionArray Write RegisterAction(s).
#define RegisterActionArray_FORWRITE_RegisterAction(this, action) { \ const RegisterAction_ *RegisterActionArray_ITEMS = RegisterActionArray_items(this); \ int RegisterActionArray_READCOUNT = RegisterActionArray_readCount(this); \ int RegisterActionArray_COUNT = RegisterActionArray_count(this); \ int RegisterActionArray_INDEX = RegisterActionArray_READCOUNT; \ for (; RegisterActionArray_INDEX < RegisterActionArray_COUNT; \ RegisterActionArray_INDEX++) { \ const_RegisterAction action = RegisterActionArray_ITEMS + \ RegisterActionArray_INDEX; #define RegisterActionArray_ENDWRITE_RegisterAction \ } \ }