Procedure.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.

Procedure_Factory— IndexedFactory for Procedure(s).
extern IndexedFactory_ Procedure_Factory[1];
Procedure— Represent a Procedure in a Program.
struct Procedure_;
Procedure_memory— This Procedure Memory.
Memory
Procedure_memory(Procedure this);
Procedure_program— This Procedure enclosing Program.
struct Program_ *
Procedure_program(Procedure this);
Procedure_dedicated— This Procedure array of dedicated Temporary(ies).
struct Temporary_ *
Procedure_dedicated(Procedure this);
Procedure_symbol— This Procedure symbol.
Symbol
Procedure_symbol(const_Procedure this);
Procedure_name— This Procedure name.
#define Procedure_name(this)    Symbol_name(Procedure_symbol(this))
Procedure_temporaries— For use by Procedure_FOREACH_Temporary.
IBList
Procedure_temporaries(Procedure this);
Procedure_FOREACH_Temporary— Iterate this Procedure Temporary(ies).
#define Procedure_FOREACH_Temporary(this, temporary) \
  IBList_FOREACH(Procedure_temporaries(this), Temporary_, temporary)
#define Procedure_ENDEACH_Temporary \
  IBList_ENDEACH;
Procedure_makeVirtualTemporary— Make a new virtual register Temporary.
Temporary
Procedure_makeVirtualTemporary(Procedure this, RegFile regFile);
Procedure_copyVirtualTemporary— Make a virtual register Temporary a copy of another.
Temporary
Procedure_copyVirtualTemporary(Procedure this, const_Temporary register_temporary);
Procedure_makeAssignedTemporary— Make a new assigned register Temporary.
Temporary
Procedure_makeAssignedTemporary(Procedure this, Register registre);
Procedure_makeDedicatedTemporary— Make a dedicated register Temporary.

This function commonalizes the dedicated register Temporary(ies).

Temporary
Procedure_makeDedicatedTemporary(Procedure this, Register registre);
Procedure_makeAbsoluteTemporary— Make a new absolute invariant Temporary.
Temporary
Procedure_makeAbsoluteTemporary(Procedure this,
                                ImmediateValue value, Relocation relocation);
Procedure_makeSymbolTemporary— Make a new symbol invariant Temporary.
Temporary
Procedure_makeSymbolTemporary(Procedure this, Symbol symbol,
                              ImmediateValue offset, Relocation relocation);
Procedure_makeLabelTemporary— Make a new label invariant Temporary.
Temporary
Procedure_makeLabelTemporary(Procedure this, Label label,
                             ImmediateValue offset, Relocation relocation);
Procedure_makeModifierTemporary— Make a new Modifier Temporary.
Temporary
Procedure_makeModifierTemporary(Procedure this, Modifier modifier, ModifierMember member);
Procedure_makeRegMaskTemporary— Make a new RegMask Temporary.
Temporary
Procedure_makeRegMaskTemporary(Procedure this);
Procedure_getRemater— Get the rematerialization value of a Temporary.
Temporary
Procedure_getRemater(const_Procedure this, Temporary temporary);
Procedure_setRemater— Associate a Temporary to its rematerialization value.
void
Procedure_setRemater(Procedure this, Temporary temporary, Temporary value);
Procedure_getHomeable— Get the home location of a Temporary.
Temporary
Procedure_getHomeable(const_Procedure this, Temporary temporary);
Procedure_setHomeable— Associate a Temporary to its home location.
void
Procedure_setHomeable(Procedure this, Temporary temporary, Temporary location);
Procedure_blockChain— For use by Procedure_FOREACH_BasicBlock.
IDList
Procedure_blockChain(Procedure this);
Procedure_FOREACH_BasicBlock— Iterate this Procedure BasicBlocks.
#define Procedure_FOREACH_BasicBlock(this, basicBlock) \
  IDList_FOREACH(Procedure_blockChain(this), BasicBlock_, basicBlock)
#define Procedure_FOREACH_BasicBlock_SYNC IDList_FOREACH_SYNC
#define Procedure_ENDEACH_BasicBlock \
  IDList_ENDEACH;
Procedure_FORBACK_BasicBlock— Iterate this Procedure BasicBlocks.
#define Procedure_FORBACK_BasicBlock(this, basicBlock) \
  IDList_FORBACK(Procedure_blockChain(this), BasicBlock_, basicBlock)
#define Procedure_ENDBACK_BasicBlock \
  IDList_ENDBACK;
Procedure_blockCount— Count of this Procedure BasicBlock(s).
int32_t
Procedure_blockCount(Procedure this);
Procedure_discarded— For use by Procedure_DISCARDED_FOREACH_BasicBlock.
IDList
Procedure_discarded(Procedure this);
Procedure_DISCARDED_FOREACH_BasicBlock— Iterate this Procedure discarded BasicBlocks.
#define Procedure_DISCARDED_FOREACH_BasicBlock(this, basicBlock) \
  IDList_FOREACH(Procedure_discarded(this), BasicBlock_, basicBlock)
#define Procedure_DISCARDED_ENDEACH_BasicBlock \
  IDList_ENDEACH;
Procedure_makeBasicBlock— Make a BasicBlock for this Procedure.

This is the BasicBlock creation interface to use before Procedure_buildCodeRegions. After Procedure_buildCodeRegions, one should call CodeRegion_makeBasicBlock.

BasicBlock
Procedure_makeBasicBlock(Procedure this, Processor processor, intptr_t regionId, float frequency);
Procedure_chainBasicBlocks— Chain succ_block to pred_block in the BasicBlock chain.
void
Procedure_chainBasicBlocks(Procedure this, BasicBlock pred_block, BasicBlock succ_block);
Procedure_unchainBasicBlock— Detach basicBlock from this Procedure_blockChain.
void
Procedure_unchainBasicBlock(Procedure this, BasicBlock basicBlock);
Procedure_codeRegions— For use by Procedure_FOREACH_CodeRegion.
IDList
Procedure_codeRegions(Procedure this);
Procedure_FOREACH_CodeRegion— Iterate this Procedure CodeRegion(s).
#define Procedure_FOREACH_CodeRegion(this, codeRegion) { \
  IDList_FOREACH(Procedure_codeRegions(this), CodeRegion_, codeRegion)
#define Procedure_ENDEACH_CodeRegion \
  IDList_ENDEACH \
}
Procedure_FORBACK_CodeRegion— Iterate this Procedure CodeRegion(s).
#define Procedure_FORBACK_CodeRegion(this, codeRegion) { \
  IDList_FORBACK(Procedure_codeRegions(this), CodeRegion_, codeRegion)
#define Procedure_ENDBACK_CodeRegion \
  IDList_ENDBACK \
}
Procedure_firstRegion— The first CodeRegion of this Procedure.
CodeRegion
Procedure_firstRegion(Procedure this);
Procedure_lastRegion— The last CodeRegion of this Procedure.
CodeRegion
Procedure_lastRegion(Procedure this);
Procedure_findCodeRegion— Find a CodeRegion from a region identifier.
CodeRegion
Procedure_findCodeRegion(Procedure this, intptr_t regionId);
Procedure_loopScopes— For use by Procedure_FOREACH_LoopScope.
HTable
Procedure_loopScopes(Procedure this);
Procedure_FOREACH_LoopScope— Iterate this Procedure LoopScope(s).
#define Procedure_FOREACH_LoopScope(this, loopScope) { \
  HTable Procedure_LOOPSCOPES = Procedure_loopScopes(this); \
  HTable_FOREACH(Procedure_LOOPSCOPES, Procedure_KEY, LoopScope_, loopScope) {
#define Procedure_ENDEACH_LoopScope \
  } HTable_ENDEACH \
}
Procedure_findLoopScope— Find a LoopScope from a loop head BasicBlock.
LoopScope
Procedure_findLoopScope(Procedure this, BasicBlock headerBlock);
Procedure_makeLoopScope— Make a LoopScope for a header BasicBlock.
LoopScope
Procedure_makeLoopScope(Procedure this, BasicBlock headerBlock, Configure configure);
Procedure_removeLoopScope— Remove a LoopScope.
bool
Procedure_removeLoopScope(Procedure this, BasicBlock headerBlock);
Procedure_setEntryBlock— Set a BasicBlock as a Procedure entry block.
void
Procedure_setEntryBlock(Procedure this, BasicBlock basicBlock);
Procedure_setExitBlock— Set a BasicBlock as a Procedure exit block.
void
Procedure_setExitBlock(Procedure this, BasicBlock basicBlock);
Procedure_setStartBlock— Set a BasicBlock as trace start block.
void
Procedure_setStartBlock(Procedure this, BasicBlock basicBlock);
Procedure_fixupOpen64— Fixup this Procedure when built from Open64.

The Open64 does not link the function call/return parameters to the actual routine call or return or tail call operation. We restore these links by making these parameters explicit operation arguments or results.

void
Procedure_fixupOpen64(Procedure this, OptimizeFlags activate);
Procedure_fixupDedicated— Fixup this Procedure to enable renaming of dedicated registers
void
Procedure_fixupDedicated(Procedure this, OptimizeFlags activate);
Procedure_buildCodeRegions— Build this Procedure CodeRegion(s) from the BasicBlock(s).
void
Procedure_buildCodeRegions(Procedure this);
Procedure_updateTargetedOperation— Update the target label of an Operation.
void
Procedure_updateTargetedOperation(Procedure this, Operation operation, Label label);
Procedure_updateRelaxedOperation— Update the immediate after inductive relaxation.
void
Procedure_updateRelaxedOperation(Procedure this, Operation operation,
                                 int32_t regIndex, int64_t step, int iteration);
Procedure_pretty— Pretty print this Procedure.
bool
Procedure_pretty(Procedure this, FILE *file);
ProcedureTable— Specialization of IndexedTable for Procedure(s).
struct ProcedureTable_ {
  //@args       Memory memory, int32_t estimate
  IndexedTable_ __;
  //@access MEMORY      IndexedTable_memory(ProcedureTable____(this))
  //@access COUNT       IndexedTable_count(ProcedureTable____(this))
  //@access BASE        (const Procedure *)IndexedTable_base(ProcedureTable____(this))
};
ProcedureTable_FOREACH_Procedure— Iterate this ProcedureTable Procedure(ies).
#define ProcedureTable_FOREACH_Procedure(this, procedure) { \
  IndexedTable_FOREACH_Indexed(ProcedureTable__const(this), \
                                   Procedure, procedure) { \
    int32_t ProcedureTable_Procedure_INDEX = IndexedTable_INDEX;
#define ProcedureTable_ENDEACH_Procedure \
  } IndexedTable_ENDEACH_Indexed; \
}