Dominance.xcc

Nikola Puzovic (Nikola.Puzovicst.com). Benoit Dupont de Dinechin (Benoit.Dupont-de-Dinechinst.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.

DominanceFlag— Enumerates the Dominance flags.
typedef enum {
  DominanceFlag_Forward = 0x0,          // Dominance on forward control-flow.
  DominanceFlag_Backward = 0x1,         // Dominance on backward control-flow.
  DominanceFlag_JoinEdges = 0x2,        // Dominance computes BasicBlockEdge_ISJOIN.
  DominanceFlag_TreeOrder = 0x4,        // Dominance with tree order.
  DominanceFlag_Frontiers = 0x8,        // Dominance with frontiers.
  DominanceFlag_MergeSets = 0x10,       // Dominance with merge sets.
} DominanceFlag;
typedef unsigned DominanceFlags;
typedef uint8_t short_DominanceFlags;
Dominance— Forward dominance over a CodeRegion.
struct Dominance_;
  //@access isForward   ((Dominance_flags(this) & DominanceFlag_Backward) == 0)
  //@access isBackward  ((Dominance_flags(this) & DominanceFlag_Backward) != 0)
Dominance_memory— This Dominance Memory.
Memory
Dominance_memory(Dominance this);
Dominance_codeRegion— This Dominance CodeRegion.
CodeRegion
Dominance_codeRegion(Dominance this);
Dominance_flags— This Dominance flags.
unsigned
Dominance_flags(Dominance this);
Dominance_blockCount— This Dominance BasicBlock count.
int32_t
Dominance_blockCount(Dominance this);
Dominance_blockMap— This Dominance BasicBlock map.
const BasicBlock *
Dominance_blockMap(Dominance this);
Dominance_postOrder— For use by Dominance_FORCFGPOST_BasicBlock.
const BasicBlock *
Dominance_postOrder(Dominance this);
Dominance_domDFS— For use by Dominance_FORDOMDFS_BasicBlock.
const BasicBlock *
Dominance_domDFS(Dominance this);
Dominance_postCount— For use by Dominance_FORCFGPOST_BasicBlock.
int32_t
Dominance_postCount(Dominance this);
Dominance_FORCFGPOST_BasicBlock— Iterate BasicBlock(s) in CFG post-order.

Iteration omits the CodeRegion ROOTBLOCK (whose BasicBlock_INDEX = 0).

#define Dominance_FORCFGPOST_BasicBlock(this, basicBlock) { \
  const BasicBlock *Dominance_POSTORDER = Dominance_postOrder(this); \
  int32_t Dominance_POSTCOUNT = Dominance_postCount(this); \
  int32_t Dominance_INDEX = 0; \
  for (; Dominance_INDEX < Dominance_POSTCOUNT - 1; Dominance_INDEX++) { \
    BasicBlock basicBlock = Dominance_POSTORDER[Dominance_INDEX];
#define Dominance_ENDCFGPOST_BasicBlock \
  } \
}
Dominance_FORCFGRPO_BasicBlock— Iterate BasicBlock(s) in CFG reverse post-order.

Iteration omits the CodeRegion ROOTBLOCK (whose BasicBlock_INDEX = 0).

#define Dominance_FORCFGRPO_BasicBlock(this, basicBlock) { \
  const BasicBlock *Dominance_POSTORDER = Dominance_postOrder(this); \
  int32_t Dominance_POSTCOUNT = Dominance_postCount(this); \
  int32_t Dominance_INDEX = Dominance_POSTCOUNT - 2; \
  for (; Dominance_INDEX >= 0; --Dominance_INDEX) { \
    BasicBlock basicBlock = Dominance_POSTORDER[Dominance_INDEX];
#define Dominance_ENDCFGRPO_BasicBlock \
  } \
}
Dominance_FORDOMDFS_BasicBlock— Iterate BasicBlock(s) in DFS pre-order of the dominance tree.

Iteration omits the CodeRegion ROOTBLOCK (whose BasicBlock_INDEX = 0).

#define Dominance_FORDOMDFS_BasicBlock(this, basicBlock) { \
  const BasicBlock *Dominance_DOMDFS = Dominance_domDFS(this); \
  int32_t Dominance_POSTCOUNT = Dominance_postCount(this); \
  int32_t Dominance_DFSINDEX = 1; \
  for (; Dominance_DFSINDEX < Dominance_POSTCOUNT; Dominance_DFSINDEX++) { \
    BasicBlock basicBlock = Dominance_DOMDFS[Dominance_DFSINDEX];
#define Dominance_ENDDOMDFS_BasicBlock \
  } \
}
Dominance_idomIdx— This Dominance immediate dominator indices.
const int32_t *
Dominance_idomIdx(const_Dominance this);
Dominance_basicBlockDominator— Immediate dominator of a BasicBlock.
BasicBlock
Dominance_basicBlockDominator(const_Dominance this, const_BasicBlock basicBlock);
Dominance_preDFN— This Dominance tree DFS preorder numbers.
const int32_t *
Dominance_preDFN(const_Dominance this);
Dominance_lastDFN— This Dominance tree DFS preorder number of last descendent.
const int32_t *
Dominance_lastDFN(const_Dominance this);
Dominance_treeLevel— This Dominance tree levels.
const int32_t *
Dominance_treeLevel(const_Dominance this);
Dominance_children— For use by Dominance_BasicBlock_FORCHILDREN_BasicBlock.
BasicBlockStack_ *
Dominance_children(Dominance this);
#define Dominance_hasChildren(this)     (Dominance_children(this) != NULL)
Dominance_BasicBlock_FORCHILDREN_BasicBlock— Iterate over CHILDREN BasicBlock(s).
#define Dominance_BasicBlock_FORCHILDREN_BasicBlock(this, block, child) { \
  BasicBlockStack Dominance_CHILDREN = Dominance_children(this) + BasicBlock_index(block); \
  BasicBlockStack_FOREACH_BasicBlock(Dominance_CHILDREN, child)
#define Dominance_BasicBlock_ENDCHILDREN_BasicBlock \
  BasicBlockStack_ENDEACH_BasicBlock; \
}
Dominance_basicBlockChildren— Children of a BasicBlock in dominance tree.
const_BasicBlockStack
Dominance_basicBlockChildren(const_Dominance this, const_BasicBlock basicBlock);
Dominance_treeOrder— For use by Dominance_FORDOWNLEVEL_BasicBlock.
const BasicBlock *
Dominance_treeOrder(Dominance this);
#define Dominance_hasTreeOrder(this)    (Dominance_treeOrder(this) != NULL)
Dominance_FORDOWNLEVEL_BasicBlock— Iterate over BasicBlock(s) by increasing TREELEVEL.

Iteration omits the CodeRegion ROOTBLOCK (whose BasicBlock_INDEX = 0).

#define Dominance_FORDOWNLEVEL_BasicBlock(this, block) { \
  const BasicBlock *Dominance_TREEORDER = Dominance_treeOrder(this); \
  int32_t Dominance_POSTCOUNT = Dominance_postCount(this); \
  int32_t Dominance_INDEX = 1; \
  for (; Dominance_INDEX < Dominance_POSTCOUNT; Dominance_INDEX++) { \
    BasicBlock block = Dominance_TREEORDER[Dominance_INDEX];
#define Dominance_ENDDOWNLEVEL_BasicBlock \
  } \
}
Dominance_FORUPLEVEL_BasicBlock— Iterate over BasicBlock(s) by decreasing TREELEVEL.

Iteration omits the CodeRegion ROOTBLOCK (whose BasicBlock_INDEX = 0).

#define Dominance_FORUPLEVEL_BasicBlock(this, block) { \
  const BasicBlock *Dominance_TREEORDER = Dominance_treeOrder(this); \
  int32_t Dominance_POSTCOUNT = Dominance_postCount(this); \
  int32_t Dominance_INDEX = Dominance_POSTCOUNT - 1; \
  for (; Dominance_INDEX > 0; Dominance_INDEX--) { \
    BasicBlock block = Dominance_TREEORDER[Dominance_INDEX];
#define Dominance_ENDUPLEVEL_BasicBlock \
  } \
}
Dominance_frontiers— For use by Dominance_BasicBlock_FORFRONTIER_BasicBlock.
PtrSet_ *
Dominance_frontiers(Dominance this);
#define Dominance_hasFrontiers(this)    (Dominance_frontiers(this) != NULL)
Dominance_BasicBlock_FORFRONTIER_BasicBlock— Iterate over frontier BasicBlock(s).
#define Dominance_BasicBlock_FORFRONTIER_BasicBlock(this, block, frontier_block) { \
  PtrSet Dominance_FRONTIER = Dominance_frontiers(this) + BasicBlock_index(block); \
  const BasicBlock *Dominance_BLOCKMAP = Dominance_blockMap(this); \
  PtrSet_FOREACH(Dominance_FRONTIER, intptr_t, Dominance_BasicBlock_INDEX) { \
    BasicBlock frontier_block = Dominance_BLOCKMAP[Dominance_BasicBlock_INDEX];
#define Dominance_BasicBlock_ENDFRONTIER_BasicBlock \
  } PtrSet_ENDEACH; \
}
Dominance_mergeSets— For use by Dominance_BasicBlock_FORMERGESET_BasicBlock.
PtrSet_ *
Dominance_mergeSets(Dominance this);
#define Dominance_hasMergeSets(this)    (Dominance_mergeSets(this) != NULL)
Dominance_BasicBlock_FORMERGESET_BasicBlock— Iterate over merge set BasicBlock(s).
#define Dominance_BasicBlock_FORMERGESET_BasicBlock(this, block, mergeset_block) { \
  PtrSet Dominance_MERGESET = Dominance_mergeSets(this) + BasicBlock_index(block); \
  const BasicBlock *Dominance_BLOCKMAP = Dominance_blockMap(this); \
  PtrSet_FOREACH(Dominance_MERGESET, intptr_t, Dominance_BasicBlock_INDEX) { \
    BasicBlock mergeset_block = Dominance_BLOCKMAP[Dominance_BasicBlock_INDEX];
#define Dominance_BasicBlock_ENDMERGESET_BasicBlock \
  } PtrSet_ENDEACH; \
}
Dominance_dominates— Non-strict dominance relation between two BasicBlocks.

Application of the (not so) well-known properties of DFS numbering.

For the strict dominance relation, use the following: ( this_block != that_block && Dominance_dominates(this, this_block, that_block))

bool
Dominance_dominates(const_Dominance this,
                    const_BasicBlock this_block,
                    const_BasicBlock that_block);
#define Dominance_DOMINATES(preDFN, lastDFN, this_index, that_index) ( \
     preDFN[this_index] <= preDFN[that_index] \
  && lastDFN[this_index] >= preDFN[that_index] \
)
Dominance_pretty— Pretty-print this Dominance.
bool
Dominance_pretty(Dominance this, FILE *file);