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 \
  } \
}