Variable.xcc

Benoit Dupont de Dinechin (Benoit.Dupont-de-Dinechinst.com). Christophe Guillon (Christophe.Guillonst.com).

Copyright 2007 - 2008 STMicroelectronics.

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.

VariableFlags— Enumerates the Variable flags.
typedef enum {
  VariableFlag_Consuming = 0x1,         // Variable has a CONSUMERS list.
  VariableFlag_Coalesced = 0x2,         // Definition has been coalesced.
  VariableFlag_Unresolved = 0x4,        // Unresolved in Sreedhar.
  VariableFlag_PCOPYDef = 0x10,         // Defined in parallel COPY.
  VariableFlag_PCOPYUse = 0x20,         // Used in parallel COPY.
} enum_VariableFlag;
typedef uint8_t VariableFlags;
#define Variable_isConsuming(this) \
  ((Variable_FLAGS(this) & VariableFlag_Consuming) != 0)
#define Variable_raiseConsuming(this) \
  (*Variable__FLAGS(this) |= VariableFlag_Consuming)
#define Variable_clearConsuming(this) \
  (*Variable__FLAGS(this) &= ~VariableFlag_Consuming)
#define Variable_isCoalesced(this) \
  ((Variable_FLAGS(this) & VariableFlag_Coalesced) != 0)
#define Variable_raiseCoalesced(this) \
  (*Variable__FLAGS(this) |= VariableFlag_Coalesced)
#define Variable_clearCoalesced(this) \
  (*Variable__FLAGS(this) &= ~VariableFlag_Coalesced)
#define Variable_isUnresolved(this) \
  ((Variable_FLAGS(this) & VariableFlag_Unresolved) != 0)
#define Variable_raiseUnresolved(this) \
  (*Variable__FLAGS(this) |= VariableFlag_Unresolved)
#define Variable_clearUnresolved(this) \
  (*Variable__FLAGS(this) &= ~VariableFlag_Unresolved)
#define Variable_isPCOPYDef(this) \
  ((Variable_FLAGS(this) & VariableFlag_PCOPYDef) != 0)
#define Variable_raisePCOPYDef(this) \
  (*Variable__FLAGS(this) |= VariableFlag_PCOPYDef)
#define Variable_clearPCOPYDef(this) \
  (*Variable__FLAGS(this) &= ~VariableFlag_PCOPYDef)
#define Variable_isPCOPYUse(this) \
  ((Variable_FLAGS(this) & VariableFlag_PCOPYUse) != 0)
#define Variable_raisePCOPYUse(this) \
  (*Variable__FLAGS(this) |= VariableFlag_PCOPYUse)
#define Variable_clearPCOPYUse(this) \
  (*Variable__FLAGS(this) &= ~VariableFlag_PCOPYUse)
Variable— SSA form variable.
struct Variable_ {
  //@args       Temporary origin
  Temporary_ __;                        // Base of this Variable.
  //@access TEMPORARY   Variable____(this)
  //@access IDENTITY    Temporary_identity(Variable_TEMPORARY(this))
  //@access INDEX       Temporary_index(Variable_TEMPORARY(this))
  OperationResult_ PRODUCER[1];         // The producer OperationResult.
  //@access DEFUSES     ((DefUses)Variable_PRODUCER(this))
  IDList_ CONSUMERS_;                   // The consumers list of OperationArgument(s).
  //@access CONSUMERS   Variable__CONSUMERS_(this)
  Temporary ORIGIN;                     // The origin Temporary.
  struct Variable_ *WEBLINK;            // Uplink for union-find in the SSA web.
  int32_t WEBRANK;                      // Rank for union-find in the SSA web.
  VariableFlags FLAGS;                  // This Variable flags.
  Register PINNED;                      // Variable is pinned to this register.
  Register LOCALLY;                     // Variable is locally assigned to this register.
  Register GLOBALLY;                    // Variable is globally assigned to this register.
  struct Variable_ *CLASSNEXT;          // Next Variable in congruence class.
  struct VariableClass_ *CONGRUENCE;    // Coalescer congruence class.
  PtrSet_ *NEIGHBORS;                   // Sreedhar unresolved neighbors.
  int32_t ORDERING;                     // Ordering in VariableClass.
  struct Variable_ *IDOM;               // (Decoalescer)
  float WEIGHT;                         // (Decoalescer)
  struct Variable_ *EQUIVALUE;          // Root of class of Variable(s) of same value.
  struct Variable_ *EQUALANCIN;         // For use by interference with equalities.
  struct Variable_ *EQUALANCOUT;        // For use by interference with equalities.
};
Variable_consumers— Used by Variable_CONSUMERS_FOREACH_OperationArgument.
static inline const_IDList
Variable_consumers(const_Variable this)
{
  return Variable_CONSUMERS(this);
}
Variable_addConsumer— Add an OperationArgument to this Variable consumers.
void
Variable_addConsumer(Variable this, Operation operation, int32_t argIndex);
Variable_makeConsumers— Make this Variable consumers list.
void
Variable_makeConsumers(Variable this, Memory memory);
Variable_killConsumers— Kill this Variable consumers list.
void
Variable_killConsumers(Variable this);
Variable_setOperationResult— Set an OperationResult for this Variable.

In SSA form, should always use this function instead of Operation_setResult.

void
Variable_setOperationResult(Variable this, Operation operation, int32_t resIndex);
Variable_setOperationArgument— Set an OperationArgument for this Variable.

In SSA form, should always use this function instead of Operation_setArgument.

void
Variable_setOperationArgument(Variable this, Operation operation, int32_t argIndex);
Variable_findWebRoot— Returns the root of a variable SSA web.
Variable
Variable_findWebRoot(Variable this);
Variable_linkWebRoots— Link the roots of two variable SSA webs.
Variable
Variable_linkWebRoots(Variable this, Variable that);
Variable_compare— Compare two Variable(s) for total ordering.
int
Variable_compare(const_Variable this, const_Variable that);
Variable_Sort— Sort this array of Variable(s) in increasing Variable ORDERING.

See the en.wikibook.org heapsort.

void
Variable_Sort(Variable *base, int32_t count);

Variable_pretty -- Pretty print of this Variable.

bool
Variable_pretty(const_Variable this, FILE *file, int flags);
VariableStack— Stack of Variable(s).
struct VariableStack_ {
  //@args       Memory memory, int maxCount
  PtrSeq_ __;           // Underlying PtrSeq.
};
VariableStack_FOREACH_Variable— Iterate over this VariableStack Variable(s).
#define VariableStack_FOREACH_Variable(this, variable) { \
  const_PtrSeq VariableStack____ = VariableStack__const(this); \
  PtrSeq_FOREACH(VariableStack____, Variable, variable) {
#define VariableStack_ENDEACH_Variable \
  } PtrSeq_ENDEACH \
}
VariableStack_FORBACK_Variable— Iterate over this VariableStack Variable(s).
#define VariableStack_FORBACK_Variable(this, variable) { \
  const_PtrSeq VariableStack____ = VariableStack__const(this); \
  PtrSeq_FORBACK(VariableStack____, Variable, variable) {
#define VariableStack_ENDBACK_Variable \
  } PtrSeq_ENDBACK \
}
VariableClass— Class of Variable(s) used for congruence classes. Implemented as simple linked lists sorted by Variable_ORDERING, Variable_IDENTITY.
struct VariableClass_ {
  //@args       Variable variable
  Variable FIRST;       // First Variable in this VariableClass.
  Variable LAST;        // Last Variable in this VariableClass.
  int32_t COUNT;        // Count of Variable(s) in this VariableClass.
  Register REGISTER;    // Used for register targeting constraints.
  Variable CURDOM;
  Operation CURPHI;
};