package coins.ir.hir;

 

import coins.*;

import coins.ir.IrList; //##12

import coins.ir.*;

import coins.ir.hir.*;

import coins.sym.*;

import coins.flow.*;

import java.util.*;

 

//========================================//

//                          (##20):Revised on Feb., Mar. 2003-.

//                          (##19):Revised on Dec. 2002-.

//                          (##14):Revised on Jun. 2002.

//                          (##12):Revised on Mar. 2002.

//                          (##10):Revised on Nov., Dec. 2001.

//                          (##9): Revised on Oct. 2001.

 

/** HIR interface:

<PRE>

 * High Level Intermediate Representation (HIR) interface.

 * All HIR classes implement all methods declared in HIR interface

 * and IR interface which is inherited by the HIR interface.

 * See IR, Stmt, Exp, Sym interfaces and HirRoot class.

 *

 * Preliminaries

 *   High level intermediate representation is composed of operation

 *   information in a tree form, symbol information, data flow

 *   information, and others.

 *   The operation information tree is composed of nodes and edges.

 *   A node with children is called as nonleaf node and a node without

 *   child is called a leaf node.

 *   The term "node" means either leaf node or nonleaf node,

 *   the term "subtree" means either pure subtree composed of

 *   several nonleafs and leafs, or one leaf.

 *

 * Class/interface hierarchy:

 *   (Root is a class, others are interfaces.

 *    An interface xxx is implemented by corresponding class

 *    named xxxImpl or xxx_Impl.)

 *

 * Root

 * |

 * |- Sym

 * |   |- ...

 * |

 * |- Flow

 * |   |- ...

 * |

 * |- IR

 *     |- IR_factory    // IR object creation factory.

 *     |- IrList        // List of indefinite number of objects.

 *     |   |- HirList   // IrList whose elements are HIR objects. //##12

 *     |

 *     |- LIR           // Low level Intermediate Representation

 *     |   |- ...

 *     |

 *     |- HIR // High level Intermediate Representation.

 *         |  // Usual operations on HIR are done by using HIR methods.

 *         |

 *         |- Program         // Program definition node.

 *         |- SubpDefinition  // Subprogram definition node.

 *         |- HirSeq          // Sequence of definite number of

 *         |                  // HIR objects.

 *         |- HirList         // IrList whose elements are HIR objects.

 *         |                  // (Multi-inheritance of interface) //##14

 *         |- Stmt            // Statement

 *         |   |- LabeledStmt // Labeled statement.

 *         |   |- AssignStmt  // Assignment statement.

 *         |   |- IfStmt      // If-statement.

 *         |   |- JumpStmt    // Jump (goto) statement.

 *         |   |              //  (Jump unconditionally)

 *         |   |- LoopStmt    // Loop statement.

 *         |   |   |- ForLoop     // For-loop.

 *         |   |   |- WhileLoop   // While-loop.

 *         |   |   |- UntilLoop   // Repeat-until loop.

 *         |   |   |- IndexedLoop // Loop with index range

 *         |   |                  // (such as Fortran DO loop).

 *         |   |- ReturnStmt   // Return statement.

 *         |   |- SwitchStmt   // Switch (case) statement.

 *         |   |- BlockStmt    // Block representing a sequence

 *         |   |               //   of statements.

 *         |   |- ExpStmt      // Expression treated as a statement.

 *         |   |               // Call statement is treated as an

 *         |   |               // expression statement of function call.

 *         |   |               // Loop start condition expression has

 *         |   |               // label and treated as ExpStmt.

 *         |   |- InfStmt      // An information node

 *         |                   // which can be treated as a statement.

 *         |                   //  (pragma, comment line, etc.)

 *         |- LabelDef         // Label definition node.

 * //      |- InfNode          // IR information node.        //##17 DELETED

 * //      |                   //  (pragma, comment line, etc.)

 *         |- Exp  // Expression

 *             |- ConstNode // Constant node

 *             |- SymNode   // Symbol node

 *             |   |- VarNode   // Variable name node.

 * //          |   |   |- ParamNode // formal parameter name node

 * //          |   |   |            //##16 DELETED

 *             |   |   |- ElemNode  // struct/union element name node

 *             |   |                //##16 not DELETED

 *             |   |- SubpNode  // Subprogram name node.

 *             |   |- LabelNode // Label reference node.

 *             |   |- TypeNode  // Type name node.

 *             |

 *             |- SubscriptedExp // Subscripted variable.

 *             |- PointedExp     // Pointed object.

 *             |- QualifiedExp   // Qualified variable.

 *             |- FunctionExp    // Function call expression.

 *             |- PhiExp    // Phi function used in SSA

 *             |- ExpList_  // List of expressions

 *             |            // (implemented as a kind of IrList).

 *             |- NullNode  // Null (no-operation) node

 *

 *  Deleted classes:

 *    ParamNode, //##16

 *    StmtBody, AssignExp,

 *    Nonleaf, Leaf, HIRdetail, BBlock, PBlock, ExitStmt,

 *    ContinueStmt. (##10)

 *

 * Abstract syntax of HIR:

 *

 *  Abstract syntax of HIR is shown as BNF syntax

 *  in the form ( operationCode attr child1 child2 ... ),

 *  where, child1 represents source operand 1, child2 represents

 *  source operand 2,  ... .  Instance of HIR may be regarded

 *  as a tree attached with operands as its subtree.

 *  The result operand is represented by the root node

 *  of the tree. The attr represents attributes

 *  such as type of the tree, etc.

 *  (Each node may be attached an expression identifier (expId)

 *  as an attribute. In such case, the expId attached to

 *  the root node of a subtree may be regarded as the identifier

 *  corresponding to the result value of the operation

 *  specified by the subtree.)

 *  Each child is also a subtree of the same form.

 *  Some child may be null.  //##20

 *  The operationCode and attr are not subtree but

 *  information attached to the root node of the subtree.

 *  (This notation is not explaining parse tree of HIR but

 *  explaining abstract syntax tree of HIR.)

 *

 *  Notations in the following BNF descriptions..

 *    identifier starting with lower case letter except attr: terminal

 *    identifier starting with upper case letter:  nonterminal

 *      identifier ending with "_":

 *             nonterminal that is not an interface

 *      identifier that does not end with "_":

 *             nonterminal representing an interface

 *    xxxCode: operation code xxx

 *    xxxSym : symbol recorded in the symbol table

 *            progSym : program name symbol

 *            subpSym : subprogram name symbol

 *            varSym  : variable name symbol

 *                      (including array/struct/union name symbol)

 *            paramSym: formal parameter name symbol

 *            elemSym : struct/union element name symbol

 *    //      fieldSym: field name symbol of a class

 *    //      classSym: class name symbol

 *            labelSym: label name symbol

 *            typeSym : type name symbol

 *    xxxConst: constant recorded in the symbol table

 *            intConst   : integer constant

 *                         (int/short/long/unsigned int/ ...)

 *            floatConst : floating constant (float/double/ ...)

 *            charConst  : character constant (signed/unsigned)

 *            stringConst: character string constant

 *            boolConst  : boolean constant

 *                        (true is 1, false is 0 in integer)

 *    intConstValue:    integer constant

 *                      (not a symbol table entry but value itself).

 *    stringConstValue: string  constant

 *                      (not a symbol table entry but value itself).

 *    null       : empty

 *    NullNode   : a leaf node with operation code null.

 *    List_of_xxx: java.util.List with elements xxxx. (##10)

 *

 *  Note:

 *    Following items are not represented as a subtree

 *    dangling to a node but are represented as information

 *    attached to the node. They are not traversed when HIR tree

 *    is traversed but can be get by applying corresponding HIR

 *    methods to the node.

 *        Operation code     (xxxCode)

 *        Symbol table entry (xxxSym)

 *        Constant symbol    (xxxConst)

 *        Symbol table       (SymTable, GlobalSymTable_, LocalSymTable_)

 *        attr               (attribute such as node type which is

 *                            a symbol representing the type

 *                            of the result of HIR subtree.)

 *    Items represented as a subtree is indicated by @ to clarify.

 *    (@ is not a syntactic component but a postfix marker

 *     to decrease misunderstanding.)

 *

 *  Program   ->             // Program represents a compile unit.

 *     ( progCode attr       //

 *       GlobalSymTable_     // Global symbols of the program

 *       ProgSym_ @          // Program name (may be null).

 *       InitiationPart_ @   // Initial value specification.

 *       SubpList_ @ )       // Subprogram definition list.

 *  ProgSym_  ->

 *     ( symCode attr progSym )   // Program name symbol.

 *   | null

 *  GlobalSymTable_  ->   // Global symbol table of the program.

 *     SymTable           // As for SymTable, see Sym and SymTable.

 *   | null

 *  InitiationPart_ ->    // Initial value specification (##14)

 *     InitiationBlock_

 *   | NullNode

 *  InitiationBlock_ ->   // Block containing initiation statements.

 *     ( blockCode attr

 *       InitiationStmtSeq_ @ )

 *  InitiationStmtSeq_ -> // Sequence of initiation statements

 *     InitiationStmt_ @ InitiationStmtSeq_ @

 *   | null

 *  InitiationStmt_ ->    // Initiation statement

 *     ( setDataCode attr         // with Exp_l_: l-value

 *        Exp_l_ @ ValueSpec_ @ ) // ValueSpec_: constant Exp.

 *   | AssignStmt

 *  ValueSpec_ ->

 *      ConstNode         // Constant value

 *   | ( listCode attr    // List of ValueSpec_

 *       List_of_ValueSpec_ @ )

 *   | ( repeatCode attr           // Repeat ValueSpec_

 *       ValueSpec_ @ intConst @ ) //   intConst-times.

 *  SubpList_ ->

 *     ( listCode attr     // Subprogram definition list

 *       List_of_SubpDefinition @ )

 *  SubpDefinition ->      // Subprogram definition

 *     ( subpCode attr

 *       LocalSymTable_    // SymTable local in the subprogram.

 *       SubpNode @        // Subprogram name.

 *       InitiationPart_ @ // Subprogram initiation.

 *       BlockStmt @  // HIR subprogram body

 *                    // (Control flow should be ended by return).

 *       LIR @ )      // LIR representation for the subprogram.

 *  SubpNode  ->      // Subprogram name node.

 *     ( symCode attr

 *       subpSym )

 *  LocalSymTable_ -> // Local symbol table (for subprogram, block, etc.)

 *     SymTable

 *   | null

 *  BlockStmt ->

 *     ( blockCode attr

 *       LocalSymTable_  // Define symbols local in the block.

 *       StmtSeq_ @ )    // Block makes a sequence of statements

 *                       // to be treated as one statement.

 *            // Statements in StmtSeq_ can be get

 *            // by getFirstStmt() and getNextStmt().

 *  StmtSeq_  ->

 *     Stmt @ StmtSeq_ @  // Statement sequence is a statement

 *   | null               // followed by statements or empty.

 *  Stmt      ->          // Statement is

 *     LabeledStmt        // a statement with label definitions or

 *   | StmtBody_          // a statement without label definition.

 *  LabeledStmt ->        // Labeled statement.

 *     ( labeledStmtCode attr

 *        LabelDefinitionList_ @ // List of label definitions.

 *        StmtBody_ @ )       // Statement body (statement that is

 *                            // peeled label off).

 *  LabelDefinitionList_ ->   // List of LabelDef nodes.

 *     ( listCode attr

 *       List_of_LabelDef @ )

 *  LabelDef   ->             // Label definition node.

 *     ( labelDefCode attr

 *       labelSym )

 *  StmtBody_  ->     // Statement body.

 *     AssignStmt     // Assignment statement.

 *   | IfStmt         // If statement.

 *   | JumpStmt       // Jump (goto) statement.

 *   | LoopStmt       // Loop statement.

 *   | CallStmt_      // Subprogram call statement.

 *   | ReturnStmt     // Return statement.

 *   | SwitchStmt     // Switch (case selection) statement.

 *   | BlockStmt      // Block statement.

 *   | ExpStmt        // Expression treated as a statement.

 *

 *  AssignStmt ->     // Assign statement.

 *     ( assignCode attr

 *       Exp_l_ @     // l_value expression

 *       Exp @ )      // Expression to be assigned.

 *   | ( CompoundAssignOperator_ attr  // HIR-C only

 *       Exp_l_ @

 *       Exp @ )

 *   | ( IncrDecrOperator_ attr        // HIR-C only

 *       Exp_l_ @ )

 *  Exp_l_  ->              // l-value expression is

 *     Exp                  // an expression representing an object

 *                          // (memory area to contain data).

 *  IfStmt    ->            // If statement

 *    ( ifCode attr

 *       ConditionalExp_ @  // Conditional expression.

 *       ThenPart_ @        // Then-part

 *       ElsePart_ @        // Else-part.

 *       LabeledNull_ @ )   // End-of-if label.

 *  ThenPart  ->

 *     LabeledStmt   // Executed if ConditionalExp is true.

 *   | null          //

 *  ElsePart  ->

 *     LabeledStmt   // Executed if ConditionalExp is false.

 *   | null          //

 *  LabeledNull_    ->          // LabeledNull_ is

 *     ( labeledStmtCode attr   // a labeled statement

 *       LabelDefinitionList_ @ // with null stmt body.

 *       null @ )

 *  JumpStmt  ->

 *     ( jumpCode attr  // Jump to the statement with

 *       LabelNode @ )  // specified label.

 *  LoopStmt ->  // Loop statement is either for-loop, while-loop,

 *               // until-loop, indexed loop, or other general loop.

 *               // All of them are implemented as a general loop

 *               // with some restriction depending on the loop type.

 *               // Compiler components (other than front part) should

 *               // treat general loop, that is, do not assume some child

 *               // is null without checking whether the child is null

 *               // or not.

 *    ( LoopCode_ attr     // Loop kind code.

 *      LoopInitPart_ @    // Loop initiation part to be executed

 *                         // before repetition. This may be null.

 *      ConditionalInitPart_ @ // Conditional initiation part.

 *                         // Executed once if attached loop

 *                         // start condition is satisfied.

 *                         // See LoopStmt interface for detail.

 *      StartConditionPart_ @  // Loop start conditional expression

 *                         // with loopBackLabel.

 *                         // If true, pass through to LoopBody_,

 *                         // otherwise transfer to LoopEndPart_.

 *                         // If loop start condition part is null,

 *                         //  pass through to LoopBody_.

 *      LoopBody_ @        // Loop body repetitively executed.

 *                         // Pass through to EndCondition_.

 *                         // It is a block statement (BlockStmt)

 *                         // with loop start label and the blcok

 *                         // statement contains a labeled statement

 *                         // with loopStepLabel as its last statement.

 *                         // This should not be null but the block may

 *                         // have no executable statement and contains

 *                         // only a labeled statement with loopStepLabel.

 *                         // "continue" jumps to the loopStepLabel.

 *                         // The loopStepLabel may be omitted if

 *                         // there is no "jump loopStepLabel".

 *     EndCondition_ @     // Loop end condition expression.

 *                         // If true, transfer to LoopEndPart_,

 *                         // otherwise pass through to

 *                         // LoopStepPart_.

 *     LoopStepPart_ @     // Loop step part executed

 *                         // before jumping to loopBackLabel.

 *     LoopEndPart_ @ )    // Loop end part

 *                         // with loopEndLabel.

 *                         // "exit" (break in C) jumps to here.

 *     IndexedLoop_ attr   // Attributes for IndexedLoop. //##21

 *                         // Not given for other loops.  //##21

 *  LoopCode_ attr ->

 *     whileCode attr      // while-loop

 *   | forCode attr        // for-loop

 *   | untilCode attr      // until-loop

 *   | indexedLoopCode attr// indexed-loop //##21

 *   | loopCode attr       // general loop other than above loops. //##21

 *  LoopInitPart_   ->  // Loop initiation part.

 *     Stmt

 *   | null

 *  ConditionalInitPart_ ->  // Executed at first time only.

 *     Stmt              // Semantics of this is the same

 *   | null              // to the following if-statement with label:

 *                       //   if (exp_of_StartCondition_) {

 *                       //     statement of ConditionalInitPart_;

 *                       //     goto loopStartlabel of LoopBody_;

 *                       //   }else

 *                       //     goto loopEndlabel:

 *                       // where, statement of ConditionalInitPart_

 *                       // is executed once if start condition

 *                       // (exp_of_StartCondition_) is true.

 *                       // Control transfers to LoobBody_

 *                       // if the exp_of_StartCondition_ is true.

 *  StartConditionPart_ ->      // Show start condition with

 *     ( labeledStmtCode attr   // loopBacklabel.

 *       LabelDefinitionList_ @

 *       ExpStmtOrNull_ @ )     // loopStartConditionExpression.

 *  LoopBody_  ->               // Block statement with loopBodyLabel.

 *     ( labeledStmtCode attr   // The last statement of the block

 *       LabelDefinitionList_ @ // is a LabeledNull_ statement with

 *       BlockStmt_ @ )         // loopStepLabel.

 *  EndCondition_ ->            // ExpStmt showing loop end condition.

 *     ExpStmtOrNull_

 *  LoopStepPart_  ->    // Statement to be executed before jumping

 *     Stmt              // to loopBackLabel.

 *   | null

 *  LoopEndPart_  ->     // LabeledNull_ statement with loopEndLabel.

 *     LabeledNull_

 *  NullOrStmt_ ->       // Usually null but it may be

 *     null              // a statement (created during

 *   | Stmt              // HIR transformation). //##20

 *  ExpStmtOrNull_ ->    // Expression statement or null.

 *     ExpStmt

 *   | null

 *  IndexedLoop_ attr  -> // Attributes for IndexedLoop.

 *     loopIndex attr     // Loop index (induction variable).

 *                        // See getLoopIndex().

 *     startValue attr    // Start value of the loop index.

 *                        // See getStartValue().

 *     endValue attr      // End value of the loop index.

 *                        // See getEndValue().

 *     stepValue attr     // Step value for the loop index.

 *                        // See getStepValue().

 *

 *  // Note. LoopInf may contain goto-loop that is difficult or

 *  //   impossible to be represent by above LoopStmt.

 *  //   (goto-loop is not implemented by LoopStmt.) //##21

 *

 *  // LoopStmt is executed as follows:

 *  //   LoopInitPart_;

 *  //   if (loopStartConditionExpression != null) {

 *  //     if (loopStartConditionExpression == true) {

 *  //       ConditionalInitPart_;

 *  //       jump to loopBodyLabel;

 *  //     }else

 *  //       jump to loopEndLabel;

 *  //   }else

 *  //     jump to loopBodyLabel;

 *  //   loopBackLabel:

 *  //     if ((loopStartConditionExpression != null)&&

 *  //         (loopStartConditionExpression == false))

 *  //       jump to loopEndLabel;

 *  //   loopBodyLabel:

 *  //     Start of BlockStmt of LoopBody_

 *  //       Stastement sequence of the BlockStmt;

 *  //       loopStepLabel:;

 *  //     End of BlockStmt of LoopBody_

 *  //     if ((loopEndConditionExpression != null)&&

 *  //         (loopEndConditionExpression == false))

 *  //       jump to loopEndLabel;

 *  //     LoopStepPart;

 *  //     jump to loopBackLabel;

 *  //   loopEndLabel:

 *  //     Loop end part;

 *

 *  // BEGIN #21

 *  // ForStmt is created as a general loop where contents of

 *  //   ConditionalInitPart_, EndCondition_, LoopEndPart_

 *  //   are null at first (but they may become not null

 *  //   by some optimizing transformation).

 *  //   See isSimpleForLoop().

 *  // WhileStmt is created as a general loop where contents of

 *  //   LoopInitPart_, ConditionalInitPart_, EndCondition_,

 *  //   LoopStepPart_, LoopEndPart_

 *  //   are null at first (but they may become not null

 *  //   by some optimizing transformation).

 *  //   See isSimpleWhileLoop().

 *  // UntilStmt is created as a general loop where contents of

 *  //   LoopInitPart, ConditionalInitPart_, StartCondition_,

 *  //   LoopStepPart_, LoopEndPart_

 *  //   are null at first (but they may become not null

 *  //   by some optimizing transformation).

 *  //   See isSimpleUntilLoop().

 *  // IndexedLoopStmt is created as a general loop where contents of

 *  //   ConditionalInitPart_, EndCondition_, LoopEndPart_

 *  //   are null at first (but they may become not null

 *  //   by some optimizing transformation).

 *  //   See isSimpleIndexedLoop().

 *  // IndexedLoopStmt represents a Fortran type loop where

 *  //   value of loop index is incremented or decremented by loop

 *  //   step value starting from loop start value and stops

 *  //   to loop before crossing the barrier of loop end value.

 *  //   (See IndexedLoopStmt interface.)

 *  // Indexed loop attributes (IndexedLoopAttr_) are available

 *  // only for IndexedLoopStmt.

 *  // END #21

 *

 *  // BEGIN old specifications

 *  // Following specifications of LoopStmt are covered by

 *  // the previous specifications of LoopStmt.

 *  // LoopStmt  ->

 *  //    WhileStmt         // While-loop

 *  //  | ForStmt           // For-loop

 *  //  | UntilStmt         // Repeat-until-loop

 *  //  | IndexedLoopStmt   // Loop with index range

 *  // WhileStmt ->

 *  //    ( whileCode attr

 *  //      NullOrStmt_ @     // Loop initiation part //##20

 *  //      ExpStmt @         // ExpStmt in conditional

 *  //                        // initiation part

 *  //      StartCondition_ @ // Loop start condition

 *  //                        // with loopBackLabel.

 *  //      LoopBody_ @       // Loop body statement.

 *  //      LabeledNull_ @    // Loop end condition (null)

 *  //                        // with loopStepLabel

 *  //      LabeledNull_ @    // continue statement jumps here.

 *  //      LabeledNull_ @    // Loop end part with loopEndLabel

 *  //                        // (exit statement jumps to here.)

 *  //      null @ )          // No index range.

 *  //              // Repetitively execute while ConditionalExp_ is true.

 *  // ForStmt   ->

 *  //    ( forCode attr      // C-type for-loop statement.

 *  //      LoopInitStmt_ @   // Loop initiation statement.

 *  //      ExpStmt @         // ExpStmt in conditional

 *  //                        // initiation part

 *  //      LoopCondition_ @  // Loop start condition

 *  //                        // with loopBackLabel.

 *  //      LoopBody_ @       // Loop body statement.

 *  //      LabeledNull_ @    // Loop end condition (null)

 *  //                        // with loopStepLabel

 *  //      LoopStepPart_ @   // continue statement jumps here.

 *  //      LabeledNull_ @    // Loop end part with loopEndLabel

 *  //      null @ )          // No index range.

 *  // UntilStmt ->

 *  //    ( untilCode attr

 *  //      NullOrStmt_ @     // Loop initiation part

 *  //      NullOrStmt_ @     // Conditional initiation part

 *  //      LabeledNull_ @    // Loop start condition

 *  //                        // with loopBackLabel.

 *  //      LoopBody_ @       // Loop body statement.

 *  //      LoopCondition_ @  // Loop end condition (null)

 *  //                        // with loopStepLabel

 *  //      LabeledNull_ @    // continue statement jumps here.

 *  //      LabeledNull_ @    // Loop end part with loopEndLabel

 *  //      null @ )          // No index range.

 *  //                  // Repetitively execute until ConditionalExp_

 *  //                  // becomes true.

 *  // IndexedLoop_ ->  //##21

 *  //   ( indexedLoopCode attr

 *  //     LoopInitPart_ @        // This part may be null.

 *  //     ConditionalInitPart_ @ // This part may be null.

 *  //     StartConditionPart_ @  // LabeledStmt with null statement body.

 *  //                        // Its label is loopBackLabel.

 *  //     LoopBody_ @        // A block statement (BlockStmt)

 *  //                        // with loop start label and the blcok

 *  //                        // statement contains a labeled statement

 *  //                        // with loopStepLabel as its last statement.

 *  //    EndCondition_ @     // This part is null.

 *  //    LoopStepPart_ @     // This part may be null.

 *  //    LoopEndPart_ @      // LabeledNull_ with loopEndLabel.

 *  //    IndexRange_ @ )     // Index range may be null in general loop.

 *  // IndexRange_ ->       // Show the summary of loop control for loops

 *  //    ( seqCode attr    // with variable incremented/decremented.

 *  //      VarNode @       // Induction variable.

 *  //      Exp @           // LoopStartBound.

 *  //      Exp @           // LoopEndBound.

 *  //      Exp @ )         // StepValue for the induction variable.

 *  //  | null

 *  // LoopCondition_  ->

 *  //    ( labeledStmtCode attr    // Expression statement

 *  //      LabelDefinitionList_ @  // with label.

 *  //      ExpStmt @ )

 *  // The indexed loop is the same to a general loop having

 *  // following components:

 *  // LoopInitPart_ is ( assignCode attr VarNode loopStartBound ),

 *  // loopStartConditionExpression is either

 *  //   ( cmpLeCode attr VarNode loopEndBound ) or

 *  //   ( cmpGeCode attr VarNode loopEndBound )

 *  //   (If stepValue is plus, then former is taken, otherwise

 *  //    latter is taken.),

 *  // LoopStepPart_ is

 *  //   ( assignCode attr VarNode

 *  //      ( addCode attr VarNode stepValue )).

 *  // END old specifications

 *

 *  CallStmt_   ->         // Subprogram call statement.

 *     ( expStmtCode attr  // Expression statement

 *       FunctionExp @ )   // with FunctionExp.

 *  FunctionExp ->         // Subprogram call expression.

 *     ( callCode attr

 *       Exp @             // Expression specifying

 *                         // subprogram to be called.

 *       ExpList_ @ )      // Actual parameter list.

 *  ReturnStmt ->          // Return statement.

 *     ( returnCode attr

 *       ReturnValue_ @ )  // Return value.

 *  ReturnValue_ ->

 *     Exp

 *   | null

 *  SwitchStmt ->          // Switch statement.

 *     ( switchCode attr

 *       Exp @             // Case selection expression.

 *       JumpTable_ @      // List of constants and statement labels.

 *       Stmt @            // Collection of statements to be selected.

 *       LabeledNull_ @ )  // Indicate end of case statement.

 *  JumpTable_ ->          // Jump table.

 *     ( seqCode attr

 *       JumpList_ @       // List of constant-label pairs.

 *       LabelNode @ )     // Default label.

 *  JumpList_ ->                 // Jump list.

 *     ( listCode attr           // Correlate Exp value

 *       List_of_SwitchCase @ )  // and list of SwitchCase_ pairs.

 *  SwitchCase_ ->       // List of SwitchCase_ pairs.

 *     ( seqCode attr

 *       ConstNode @     // Correlate Exp value and

 *       LabelNode @ )   // switch statement label.

 *  ExpStmt   ->         // Expression statement.

 *     ( expStmtCode attr

 *       Exp @ )         // Expression treated as a Stmt.

 *  NullNode  ->

 *     ( nullCode attr ) // NullNode is a terminal

 *                       // that is not null.

 *  InfNode   ->

 *     ( infCode attr    // Information node (terminal).

 *       InfKind_        // Information kind identifier.

 *       InfObject_  )   // Information.

 *                       // (InfKind_ and InfObject_ are not

 *                       // traversed by HIR traverse operations.)

 *  InfKind_  ->

 *     stringConst // String constant showing the kind of

 *                 // information such as pragma, comment, etc.

 *  InfObject_  -> // Information.

 *     Object      // Object such as Sym, Exp, etc. or

 *                 // a list of Objects. It may or may not be HIR.

 *  ConditionalExp_ ->     // boolean expression

 *     Exp

 *  Exp ->                 // Expression.

 *     Factor_

 *   | UnaryExp_

 *   | BinaryExp_

 *   | SelectExp           // HIR-C only

 *   | NullNode

 *   | InfNode

 *  Factor_  ->

 *     ConstNode

 *   | SymNode

 *   | CompoundVar_

 *   | FunctionExp

 *   | PhiExp

 * //| AssignStmt          // HIR-C

 *   | ExpList_

 *   | HirSeq              // Sequence of objects

 *  UnaryExp_ ->           // Unary expression.

 *     ( UnaryOperator_ attr

 *       Exp @ )

 *   | ( sizeofCode attr　 // size of the type of Exp

 *        Exp @ )  　　　　

 *   | ( sizeofCode attr  // size of the type

 *       TypeNode @ )     // represented by TypeNode.

 *  BinaryExp_ ->         // Binary expression.

 *     ( BinaryOperator_ attr

 *       Exp @

 *       Exp @ )

 *  CompoundVar_ ->    // Compound variable.

 *     SubscriptedExp  // Subscripted variable.

 *   | PointedExp      // Pointed variable.

 *   | QualifiedExp    // Qualified variable.

 *  SubscriptedExp ->  Subscripted variable. //##14

 *     ( subsCode attr // Array with subscript expression.

 *       Exp @       // Expression indicating the array.

 *       Exp @ )     // Subscript expression.

 *   | ( subsCode attr

 *       Exp @       // Expression indicating an array.

 *       ExpList @ ) // List of Subscripts.

 *                   // (1st subscript, 2nd subscript,

 *                   //  etc. for rectangular array.)

 *           // At present, SubscriptedExp takes following form

 *           // but it will be changed as above in near future.

 *               ( subsCode attr   // Array with index expression

 *                 Exp @       // Expression indicating an array.

 *                 ( indexCode attr

 *                   Exp @           // Subscript expression

 *                   ElemSize_ @ ))  // Size of elements (offset

 *                          // corresponding to subscript increment).

 *  ElemSize_    ->    // Element size.

 *     Exp

 *  QualifiedExp ->    // Qualified expression.

 *     ( qualCode attr // Qualified variable

 *       Exp @         // Should represent a structure or union.

 *       ElemNode @ )  // struct/union element.

 * // | ( qualCode attr // Class field

 * //     Exp @         // Should represent a class.

 * //     FieldNode @ ) // Field of the class.

 *  PointedExp ->       // Pointed expression.

 *     ( arrowCode attr // Pointed variable

 *       Exp @          // Expression representing a variable

 *       PointedElem_ @ ) // Pointed element.

 *  PointedElem_ ->

 *     ElemNode  // Pointed element (with displacement).

 *   | null      // Pointed location (0 displacement).

 *  ConstNode ->                      // Constant symbol.

 *     ( constCode attr intConst )    // integer   constant

 *   | ( constCode attr floatConst )  // float     constant

 *   | ( constCode attr charConst )   // character constant

 *   | ( constCode attr stringConst ) // string    constant

 *   | ( constCode attr boolConst )   // boolean   constant

 *  SymNode   ->        // Symbol node.

 *     (symCode Sym )   // Program name, etc.

 *   | VarNode

 * //| ParamNode  //##16 DELETED

 *   | SubpNode

 *   | LabelNode

 *   | ElemNode  //##16 not DELETED

 *   | TypeNode

 *  VarNode   ->

 *     ( symCode attr varSym )   // Variable name node

 *  SubpNode  ->

 *     ( symCode attr subpSym )  // Subprogram name node

 *  LabelNode ->

 *     ( symCode attr labelSym ) // Label reference node

 *  ElemNode  ->

 *     ( symCode attr elemSym )  // structure/union element

 *                                    // name node.

 *  // FieldNode -> ( symCode attr fieldSym ) // Field name node.

 *  TypeNode  ->

 *     ( symCode attr typeSym )  // Type name node

 *  FunctionExp ->     // Function expression.

 *     ( callCode attr

 *       Exp @         // Expression specifying function

 *                     // to be called (SubpNode, etc.).

 *       ExpList_ @ )  // Actual parameter list.

 *  ExpList_   ->

 *     ( listCode attr    // IrList of Exp (List of

 *       List_of_Exp @ )  // expressions in HIR form.)

 *  IrList     ->

 *     ( listCode attr    // A List that can be treated as IR.

 *       List_of_Objects_ @ )

 *  HirList        ->

 *     ( listCode attr    // An IrList that can be treated as HIR.

 *       List_of_Objects_ @ )

 *  HirSeq  ->

 *     ( seqCode attr HIR @ )  // Sequence of some definite

 *   | ( seqCode HIR @  HIR @ ) // number of HIR nodes.

 *   | ( seqCode HIR @  HIR @  HIR @ )

 *   | ( seqCode HIR @  HIR @  HIR @  HIR @ )

 *  PhiExp         ->

 *     (phiCode attr FlowVarList_ @ )  // phi function

 *  FlowVarList_   ->

 *     ( listCode attr

 *       List_of_VarLabelPair @ )

 *                               // List of (Var Label) pairs.

 *  VarLabelPair   ->

 *     ( listCode attr VarNode @  Label @)  //##9

 *  UnaryOperator_ ->

 *     notCode      // bitwise not (~) one's complement

 *                  // logical not for bool (!)

 *   | negCode      // negate (unary minus)

 *   | addrCode     // get address (&)

 *   | contentsCode // get contents of pointed memory

 *   | convCode     // type conversion for basic type

 *   | decayCode    // convert array to pointer

 *   | castCode     // type conversion by cast for pointer

 *   | sizeofCode   // sizeof operator

 *   | encloseCode  // honor parenthesis

 *   | IncrDecrOperator_  // Increment/decrement. HIR-C only.

 *  BinaryOperator_ ->

 *   | addCode      // add                 (+)

 *   | subCode      // subtract            (-)

 *   | offsetCode   // Offset between pointers (HIR-C only)

 *   | multCode     // multiply            (*)

 *   | divCode      // divide              (/)

 *   | modCode      // modulo              (%)

 *   | andCode      // bitwise and            (&)

 *   | orCode       // bitwise or             (|)

 *   | xorCode      // bitwise exclusive or   (^)

 *   | shiftLLCode  // shift left  logical    (<<) //

 *   | shiftRCode   // shift right arithmetic (>>)

 *   | shiftRLCode  // shift right logical    (>>) //

 *   | indexCode    // index (subscript)

 *   | undecayCode  // convert pointer to array //##10

 *   | CompareOperator_

 *   | CompareZeroOperator_            // HIR-C only //##20

 *   | ShortCircuitOperator_           // HIR-C only

 *   | commaCode    // comma operator  // HIR-C only

 *  CompareOperator_ ->

 *     cmpEqCode    // equal

 *   | cmpNeCode    // not equal

 *   | cmpGtCode    // greater than

 *   | cmpGeCode    // greater or equal

 *   | cmpLtCode    // less than

 *   | cmpLeCode    // less or equal

 *  CompareZeroOperator_ ->                // HIR-C only //##20

 *     eqZeroCode   // equal zero          // HIR-C only //##20

 *  ShortCircuitOperator_ ->               // HIR-C only

 *     lgAndCode    // logical and (&&)    // HIR-C only

 *   | lgOrCode     // logical or  (||)    // HIR-C only

 *  IncrDeclOperator_ ->                             // HIR-C only

 *     preIncrCode  // pre-increment  (++) // HIR-C only

 *   | preDecrCode  // pre-decrement  (--) // HIR-C only

 *   | postIncrCode // post-increment (++) // HIR-C only

 *   | postDecrCode // post-decrement (--) // HIR-C only

 *  CompoundAssignmentOperator_ ->         // HIR-C only

 *     multAssignCode   // *=    // HIR-C only

 *   | divAssignCode    // /=    // HIR-C only

 *   | modAssignCode    // %=    // HIR-C only

 *   | addAssignCode    // +=    // HIR-C only

 *   | subAssignCode    // -=    // HIR-C only

 *   | shiftLAssignCode // <<=   // HIR-C only

 *   | shiftRAssignCode // >>=   // HIR-C only

 *   | andAssignCode    // &=    // HIR-C only

 *   | xorAssignCode    // ^=    // HIR-C only

 *   | orAssignCode     // |=    // HIR-C only

 *  SelectExp ->        //  (Exp ? Exp : Exp) // HIR-C only

 *     ( selectCode attr

 *       ConditionalExp @   Exp @  Exp @ )

 *

 *  attr ->             // Attribute attached to the HIR node //##20

 *     typeSym          // Shows the type of HIR subtree.

 *     OptionalAttrSeq_ // Sequence of optional attributes

 *                      // that are not inevitable at the first stage

 *                      // of HIR generation. The optional attributes

 *                      // may be attached to give information used

 *                      // in some specific compiler modules or

 *                      // to help compiling processes.

 *  OptionalAttrSeq_ ->

 *     OptionalAttr_ OptionalAttrSeq_

 *   | null

 *  OptionalAttr_ ->

 *     StmtAttr_      // Attributes for statements

 *   | IndexNumber_   // Index number to identify the HIR node.

 *   | Flag_          // true/false flag.

 *   | InfItem_       // Node-wise information.

 *   | ExpId          // Expression identifier used in flow analysis.

 *   | Work_          // Phase-wise information.

 *  StmtAttr_ ->      // Attributes attached to statement subtrees.

 *     FileName_      // Source program file containing the statement.

 *     LineNumber_    // Line number of the line in which the

 *                    // statement started.

 *  FileName_ ->

 *     stringConstValue

 *  LineNumber_

 *     intConstvalue

 *  IndexNumber_ ->

 *     intConstValue

 *  Flag_ ->

 *     FlagNumber_

 *     FlagValue_

 *  FlagNumber_ ->

 *     intConstValue   // Such as  FLAG_NOCHANGE, FLAG_C_PTR,

 *                     // FLAG_CONST_EXP

 *  FlagValue_ ->

 *     true

 *   | false

 *  InfItem_ ->

 *     InfKind_ InfObject_

 *

 *

 *  Deleted methods:

 *    buildXxx, getSym (use getSym in IR or getSymNodeSym in SymNode)

 *    insertBBlockCode, insertGBlockCode, insertPBlockCode.

 *  Deleted operators:

 *    addUCode, subUCode, multUCode, divUCode.

 *    (Decide by Type attached to each node.)

 *    addA, subA, multA, divA, modA, shiftL.   (##9)

 *    lgNot  (##10)

 *

 *  Construction of HIR objects:

 *  Most HIR objects are constructed by object factory methods

 *  such as program(....), subpDefinition(....), assignStmt(....),

 *  ifStmt(....), exp(....), etc. specified in the HIR interface.

 *  Users are recommended to use the object factory methods so as

 *  to avoid forgetting to specify essential data and to make

 *  relation with other objects.  It is not recommended to use

 *  "new" directly to construct HIR objects.

 *

*** Operator number

  public static final int

    OP_PROG          =  1,   // Program

    OP_SUBP_DEF      =  2,   // SubpDefinition

    OP_LABEL_DEF     =  3,   // LabelDef node

    OP_INF           =  4,   // Information node

    OP_CONST         =  5,   // ConstNode

    OP_SYM           =  6,   // SymNode

    OP_VAR           =  7,   // VarNode

    OP_PARAM         =  8,   // VarNode

    OP_SUBP          =  9,   // SubpNode

    OP_TYPE          = 10,   // TypeNode

    OP_LABEL         = 11,   // LabelNode

    OP_ELEM          = 12,   // ElemNode

    OP_LIST          = 14,   // List of CompilerObjects

                             // such as IR nodes and symbols

    OP_SEQ           = 15,   // Sequence of HIR objects  //##10

    OP_ENCLOSE       = 16,   // Enclose subexpression //##9

 

    OP_SUBS          = 17,   // subscripted variable

    OP_INDEX         = 18,   // index modification of subscripted var

    OP_QUAL          = 19,   // struct/union qualification

    OP_ARROW         = 20,   // pointer reference

 

    OP_STMT          = 21,   // Statement code lower. Stmt is

                             // an abstract class and there is

                             // no instance having OP_STMT.

    OP_LABELED_STMT  = 21,   // Use the same number as Stmt

                             // because Stmt is an abstract class.

    OP_ASSIGN        = 22,   // AssignStmt

    OP_IF            = 23,   // IfStmt

    OP_WHILE         = 24,   // WhileStmt

    OP_FOR           = 25,   // ForStmt

    OP_UNTIL         = 26,   // UntilStmt

    OP_INDEXED_LOOP  = 27,   // IndexedLoopStmt (not yet implemented)

 

    OP_JUMP          = 28,   // JumpStmt

    OP_SWITCH        = 32,   // SwitchStmt

    OP_CALL          = 33,   // Subprogram call

    OP_RETURN        = 34,   // ReturnStmt

    OP_BLOCK         = 35,   // BlockStmt

    OP_EXP_STMT      = 36,   // ExpStmt (expression statement)

    OP_STMT_UPPER    = 37,

 

    OP_ADD           = 38,

    OP_SUB           = 39,

    OP_MULT          = 41,

    OP_DIV           = 42,

    OP_MOD           = 43,

 

    OP_AND           = 46,

    OP_OR            = 47,

    OP_XOR           = 48,

 

    OP_CMP_EQ        = 51,

    OP_CMP_NE        = 52,

    OP_CMP_GT        = 53,

    OP_CMP_GE        = 54,

    OP_CMP_LT        = 55,

    OP_CMP_LE        = 56,

 

    OP_SHIFT_LL      = 58,

    OP_SHIFT_R       = 59,

    OP_SHIFT_RL      = 60,

 

    OP_NOT           = 62,

    OP_NEG           = 63,

 

    OP_ADDR          = 64,

    OP_CONV          = 65,

    OP_DECAY         = 66,

    OP_UNDECAY       = 67,   //##10

    OP_CONTENTS      = 68,

    OP_SIZEOF        = 70,

    OP_SETDATA       = 71,   //##15

    OP_PHI           = 72,

    OP_NULL          = 73,

 

    OP_OFFSET        = 76,

    OP_LG_AND        = 77,

    OP_LG_OR         = 78,

    OP_SELECT        = 79,

    OP_COMMA         = 80,

    OP_EQ_ZERO       = 81,   //##20

    OP_PRE_INCR      = 82,

    OP_PRE_DECR      = 83,

    OP_POST_INCR     = 84,

    OP_POST_DECR     = 85,

    OP_ADD_ASSIGN    = 86,

    OP_SUB_ASSIGN    = 87,

    OP_MULT_ASSIGN   = 88,

    OP_DIV_ASSIGN    = 89,

    OP_MOD_ASSIGN    = 90,

 

    OP_SHIFT_L_ASSIGN= 91,

    OP_SHIFT_R_ASSIGN= 92,

    OP_AND_ASSIGN    = 93,

    OP_OR_ASSIGN     = 94,

    OP_XOR_ASSIGN    = 95,

 

    OP_EXPLIST       = 96, // list   of datacode

    OP_EXPREPEAT     = 97  // repeat of datacode

    ;

 

*** Flag numbers applied to HIR nodes:

static final int     // Flag numbers used in setFlag/getFlag.

                     // They should be a number between 1 to 31.

  FLAG_NOCHANGE = 1, // This subtree should not be

                     // changed in optimization.

  FLAG_C_PTR    = 2, // The operation (add, sub) is

                     // pointer operation peculiar to C.

  FLAG_CONST_EXP= 3; // This subtree is a constant expression.

                     // (constant, address constant, null,

                     //  sizeof fixed-size-variable,

                     //  expression whose operands are all constant

                     //  expression)

    // Flag numbers 24-31 can be used in each phase for apbitrary purpose.

    // They may be destroyed by other phases.

 

*** Coding rules applied to all classes in the sym packege:

 *

 * Methods begin with lower case letter.

 * Constants (final static int, etc.) are spelled in upper case letters.

 * Indentation is 2 characters. Tab is not used for indentation.

 * Formal parameters begin with p.

 * Local variables begin with l.

 * Methods and variables are named so that meaning is easily guessed.

 * Short names less than 3 characters are not used except for

 * very local purpose.

 *

</PRE>

**/

 

public interface

HIR extends IR, Cloneable {    //##18

 

//==== Access methods available to build IR nodes. ====//

//     (Factory methods for creating HIR will be explained later.)

 

/** program: Make a program node.

 *  See Program interface.

 *  @param pProgName: Program name (may be null).

 *  @param pGlobalSymTable: Symbol table for global symbols.

 *  @param pInitiationPart: Initiation statement (may be null).

 *  @param pSubpList: List of subprograms. At first, it may be

 *      an empty list. (See addSubpDefinition of Program interface.)

**/

public Program

program( Sym pProgName, SymTable pGlobalSymTable,

         IR pInitiationPart, IrList pSubpList);

 

/** subpDefifnition:

 *  Make a subprogram definition node and

 *  set symRoot.subpCurrent = pSubpSym,

 *  set symRoot.symTableCurrentSubp = pLocalSymTable.

 *  You may add initiation-part, HIR-body later

 *  by using addInitiationStmt, setHirBody of SubpDefinition

 *  interface.

 *  Start label and end label for the given subprogram

 *  are generated to make getStartLabel(), getEndLabel()

 *  of Subp interface effective.

 *  @param pSubpSym: Subprogram symbol. Should be given.

 *  @param pLocalSymTable: Symbol table local in the subprogram;

 *      If subprogram uses a local symbol table, this should

 *      be given (by using pushSymTable() of SymTable interface).

 *  @return the created SubpDefinition instance.

**/

public SubpDefinition

subpDefinition( Subp pSubpSym, SymTable pLocalSymTable );

 

/** subpDefinition without SymTable

 *  If source language admits no local symbol for subprogram,

 *  use this method to create SubpDefinition without

 *  local symbol table.

 *  Other items are the same as the previous method.

 *  @param pSubpSym: Subprogram symbol. Should be given.

 *  @return the created SubpDefinition instance.

**/

public SubpDefinition

subpDefinition( Subp pSubpSym );

 

/** subpDefinition with full specification.

 *  Other items are the same as the previous method.

 *  @param pSubpSym: Subprogram symbol. Should be given.

 *  @param pLocalSymTable: should be given.

 *  @param pInitiationPart: Initiation statement block. optional.

 *  @param pHirBody: Subprogram body in HIR. optional.

**/

public SubpDefinition

subpDefinition( Subp pSubpSym, SymTable pLocalSymTable,

                BlockStmt pInitiationPart, BlockStmt pHirBody);

 

/** irList: Make an HirList node that makes a LinkedList.

 *  The created list can be treated as an HIR node.

 *  @param pList: List of objects to be included in the HirList;

 *      The elements of the list are an HIR object or Sym object. //##19

 *  @return IrList containing pList;

 *      Resultant list is also an instance of HIR. //##12

**/

public coins.ir.IrList

irList( LinkedList pList );

 

/** irList: Make an empty HirList node that make a LinkedList.

 *  Use methods of IrList to add elements to the list.

 *  The elements to be added are an HIR object or Sym object. //##19

 *  The created list can be treated as an HIR node.

 *  @return an empty IrList;

 *      Resultant list is also an instance of HIR. //##12

**/

public coins.ir.IrList

irList();

 

/** infNode:

 *  Build an InfNode representing some information.

 *  The information may be defined in each compiler for arbitrary purpose.

 *  @param pInfKindInterned: a string to identify the information kind of

 *      the InfNode; It should be an interned string (string with intern()).

 *      See coins.Registry.

 *  @param pInfData : any object to be attached (such as Sym or HIR node);

 *      The object kind is indicated by the pInfKindInterned;

 *      If it is an IrList, then it can represent complicated

 *      information structure.

**/

public InfNode

infNode( String pInfKindInterned, Object pInfData ); //##17

 

/** infStmt:

 *  Build an InfStmt representing some information.

 *  The information may be defined in each compiler for arbitrary purpose.

 *  @param pInfKindInterned: a string to identify the information kind of

 *      the InfNode. It should be an interned string (string with intern());

 *      See coins.Registry.

 *  @param pInfData : any object to be attached (such as Sym or HIR node);

 *      The object kind is indicated by the pInfKindInterned;

 *      If it is an IrList, then it can represent complicated

 *      information structure.

**/

public InfStmt

infStmt( String pInfKindInterned, Object pInfData ); //##17

 

//==== Methods to get/set HIR node information ====//

 

/** getType:

 *  Get the type attached to this node.

 *  The type is usually attached when node is built by HIR

 *  factory methods such as exp.

 *  @return the type attached to this node.

**/

Type

getType();

 

/** setType:

 *  Attach a type to this node.

 *  When HIR node is created by HIR factory methods,

 *  its type is set in the factory methods so that

 *  it is unnecessary to call setType again.

 *  @param pType: type to be attached to this node;

 *      It should represent a proper type corresponding to the

 *      result of subtree represented by this node.

**/

void

setType( Type pType );

 

/** getNextStmt: Get statement next to this statement.

 *  @return the statement next to this statement if

 *      this is a statement; If this is not a statement,

 *      return null.

**/

public Stmt

getNextStmt();

 

/** getBBlock:

 *  Get the basic block containing this node.

 *  @return the basic block containing this node if the subprogram

 *      containing this node is already devided into basic blocks;

 *      return null if basic block is not yet created.

 *  See controlFlowAnal of Flow for the creation of basic blocks.

**/

public BBlock

getBBlock();

 

/** getFlag: returns the value (true/false) of the flag indicated

 *  by pFlagNumber.

 *  See FLAG_NOCHANGE, FLAG_CONST_EXP, etc. of HIR interface.

 *  @param pFlagNumber: flag identification number.

 *  @return the value of the flag.

**/

boolean

getFlag( int pFlagNumber);

 

/** setFlag: sets the flag specified by pFlagNumber.

 *  See FLAG_NOCHANGE, FLAG_CONST_EXP, etc. of HIR interface.

 *  Some local flag numbers can be added in each phase.

 *  @param pFlagNumber: flag identification number.

 *  @param pYesNo: true or false to be set to the flag.

**/

void

setFlag( int pFlagNumber, boolean pYesNo);

 

/** flagsAreAllFalse:

 *  @return true if all flags are false or no flag is set,

 *      false if some flag is true.

**/

boolean

flagsAreAllFalse();

 

/** getFlagBox:

 *  Users are recommended to use getFlag( int pFlagNumber )

 *  except when they understand the treatment of FlagBox

 *  in detail.

 *  @return the flag box attached to this node;

 *      null if flag box is not attached (no flag is set).

**/

public FlagBox

getFlagBox();

 

/** setWork:

 *  Set information privately used in each phase.

 *  @param pWork: any information of arbitrary class to be set to this node;

 *      You may define a new class that represents arbitrary information

 *      and give its reference as pWork.

 *  This method is moved to IR interface.

**/

// void

// setWork( Object pWork );

 

/** getWork:

 *  Get information set by setWork for this node.

 *  Users should cast by the name of the class used in setWork.

 *  @return the information object set by setWork.

 *  This method is moved to IR interface.

**/

// Object

// getWork();

 

//========================================//

 

/** getExpId:

 *  Get the expression identifier assigned to this node.

 *  @return the expression identifier assigned to this node,

 *      or return null if it is not assigned.

**/

ExpId

getExpId();

 

/** setExpId:

 *  Set the expression identifier computed for this node.

**/

void

setExpId( ExpId pExpId );

 

/** setFlowAnalSym:

 *  Set ExpId as the flow analysis symbol for this node.

 *  @param pFlowAnalSym: ExpId to be assigned to this node.

**/

void

setFlowAnalSym( ExpId pFlowAnalSym );

 

/** getChildNumber:

 *  Get the child number of this node.

 *  If not found, return -1.

 *  (Usually, it is unnecessary to use this because

 *   the child number is known by stack, etc.)

**/

public int

getChildNumber();

 

/** isStmt:

 *  @return true if this node is a statement node,

 *      otherwise return false.

**/

public boolean

isStmt();

 

/** isTerminal:

 *  @return true if this node is a terminal node having no child,

 *      otherwise return false. HirList is nonterminal node.

**/

public boolean

isTerminal(); //##20

 

/** getStmtContainingThisNode:

 *  Get the innermost statement or LabeledStmt containing this node

 *  by traversing ancestors of this node.

 *  If this is a statement, then this is the innermost statement.

 *  If the the parent of the innermost statement is  a LabeledStmt,

 *  then the LabeledStmt is returned else the innermost statement

 *  is returned.

 *  @return the innermost statement or LabeledStmt

 *    containing this node.

**/

public Stmt

getStmtContainingThisNode();

 

/** cutParentLink:

 *  Cut both links from/to parent node if they exist.

 *  (Used to prepare for moving a node.)

 *  This method is prepared for factory methods and it is not

 *  recommended to use this method except when user knows the

 *  structure of HIR in detail.

**/

public void

cutParentLink();

 

/** cutParentLink: //##19

 *  Cut both links from/to parent node if they exist.

 *  (Used to prepare for moving a node.)

 *  @param pChildNumber: Show that this node is pChildNumber-th child

 *      of the parent.

 *  This method is prepared for factory methods and it is not

 *  recommended to use this method except when user knows the

 *  structure of HIR in detail.

**/

public void

cutParentLink( int pChildNumber );

 

 

//========== Factory methods to create HIR node ==========//

 

//==== Factory methods to create terminal nodes ====//

 

/** varNode:

 *  Make a VarNode instance having Var symbol pVar.

 *  @param pVar: Variable symbol to be attached to the node.

 *  @return the resultant VarNode.

**/

public VarNode

varNode( Var pVar );

 

// public ParamNode

// paramNode( Param pParam ); //##16 DELETED

 

/** elemNode:

 *  Make an ElemNode instance having Elem symbol pElem.

 *  @param pElem: Struct/union element symbol to be attached to the node.

 *  @return the resultant ElemNode.

**/

public ElemNode

elemNode( Elem pElem ); //##16 not DELETED

 

/** subpNode:

 *  Make a SubpNode instance having Subp symbol pSubp.

 *  @param pSubp: Subprogram symbol to be attached to the node.

 *  @return the resultant SubpNode.

**/

public SubpNode

subpNode( Subp pSubp );

 

/** labelNode:

 *  Make a LabelNode instance having Label symbol pLabel.

 *  (See labelDef.)

 *  @param pLabel: Label symbol to be attached to the node.

 *  @return the resultant LabelNode.

**/

public LabelNode

labelNode( Label pLabel );

 

/** constNode:

 *  Make a ConstNode instance having constant symbol pConst.

 *  @param pConst: Constant symbol to be attached to the node.

 *  @return the resultant ConstNode.

**/

public ConstNode

constNode( Const pConst );

 

/** intConstNode:

 *  Make a ConstNode instance having pIntValue as its value.

 *  The constant value is changed to Const symbol and attached to

 *  the constant node.

 *  @param pIntValue: Integer value to be attached to the node.

 *  @return the resultant ConstNode.

**/

public ConstNode

intConstNode( int pIntValue );

 

/////////////////////////////////////// S.Fukuda 2002.9.3 begin

/** offsetConstNode:

 *  Make a ConstNode instance having pIntValue as its offset value.

 *  The offset value pIntValue is changed to Const symbol and

 *  attached to the constant node.

 *  @param pIntValue: Offset value to be attached to the node.

 *  @return the resultant ConstNode.

**/

public ConstNode

offsetConstNode( int pIntValue );

/////////////////////////////////////// S.Fukuda 2002.9.3 end

 

/** trueNode:

 *  Make a ConstNode instance having boolean true value.

 *  @return the true ConstNode.

**/

public ConstNode

trueNode();

 

/** falseNode:

 *  Make a ConstNode instance having boolean false value.

 *  @return the false ConstNode.

**/

public ConstNode

falseNode();

 

/** symNode:

 *  Make a SymNode instance having pSym as attached symbol.

 *  This method is used for symbols other than Var, Elem, Subp,

 *  Label, and constant.

 *  @param pSym: Symbol to be attached to the node.

 *  @return the resultant SymNode.

**/

public SymNode

symNode( Sym pSym );

 

/** nullNode:

 *  Make a NullNode instance.

 *  @return the NullNode.

**/

public NullNode

nullNode( );

 

/** labelDef:

 *  Make a LabelDef instance that defines the label pLabel.

 *  (See labelNode.)

 *  @param pLabel: Label symbol to be defined.

 *  @return the resultant LabelDef.

**/

public LabelDef

labelDef( Label pLabel );

 

//==== Factory methods to create nonterminal nodes ====//

 

/** exp:

 *  Build unary expression except cast.

 *  @param pOperator: unary operator such as OP_NOT, OP_NEG, etc.

 *       defined in HIR interface.

 *  @param pExp1: operand expression.

 *  @return the resultant unary expression subtree.

**/

public Exp

exp( int pOperator, Exp pExp1 );

 

/** exp:

 *  Build binary expression.

 *  @param pOperator: binary operator such as OP_ADD, OP_MULT, etc.

 *       defined in HIR interface.

 *  @param pExp1: operand 1 expression.

 *  @param pExp2: operand 2 expression.

 *  @return the resultant binary expression subtree.

**/

public Exp

exp( int pOperator, Exp pExp1, Exp pExp2 );

 

/** exp:

 *  Build ternary expression (OP_SELECT, etc.).

 *  @param pExp1: operand 1 expression.

 *  @param pExp2: operand 2 expression.

 *  @param pExp3: operand 3 expression.

 *  @return the resultant ternary expression subtree.

**/

public Exp

exp( int pOperator, Exp pExp1, Exp pExp2, Exp pExp3 );

 

/** castExp:              //##10 Use convExp

 *  Cast pExp to pType.

**/

//## public Exp

//## castExp( Type pType, Exp pExp ); //##10

 

/** decayExp: //##12

 *  Build an expression that decay a vector to a pointer to vector element,

 *  or decay a String into a pointer to Char element.

 *  @param pExp: vector variable or string constant.

 *  @return decay expression with pointer type.

**/

public Exp

decayExp( Exp pExp );

 

/** undecayExp: //##14

 *  Build an expression that undecay a pointer to a vector whose element

 *  type is pointed type.

 *  @param pPointerExp: pointer expression pointing to the

 *      first element of the resultant vector.

 *  @param pElemCount: Expression showing element count of

 *      the resultant vector (constant expression).

 *  @return the vector expression.

**/

public Exp

undecayExp( Exp pPointerExp, ConstNode pElemCount );

public Exp //SF030531

undecayExp( Exp pPointerExp, int pElemCount ); //SF030531

 

/** subscriptedExp:

 *  Build a subscripted expression.

 *  @param pArrayExp: array expression to which subscript is

 *      to be attached;

 *      If multi-dimensional subscript is required, make pArrayExp

 *      as a subscripted variable and add more by this method.

 *  @param pSubscript: subscript expression.

 *  @return subscripted expression node having operation code subsCode.

**/

public SubscriptedExp

subscriptedExp( Exp pArrayExp, Exp pSubscript );

 

/** subscriptedExp with element size parameter:  //##12 To be DELETED

 *  Build a subscripted expression.

 *  @param pArrayExp: array expression to which subscript is

 *      to be attached;

 *      If multi-dimensional subscript is required, make pArrayExp

 *      as a subscripted variable and add more by this method.

 *  @param pSubscript: subscript expression.

 *  @param pElemSize: array element size which is an offset

 *      incremented according to subscript increment.

 *  @return subscripted expression node having operation code subsCode.

**/

public SubscriptedExp

subscriptedExp( Exp pArrayExp, Exp pSubscript, Exp pElemSize );

 

/** qualifiedExp:

 *  Build a qualified expression.

 *  @param pStructUnionExp: expression specifying structure or union

 *      to qualify.

 *  @param pElemNode: An element of pStructUnionExp.

 *  @return qualified expression node having operation code qualCode.

**/

public QualifiedExp

qualifiedExp( Exp pStructUnionExp, ElemNode pElemNode );

 

/** pointedExp:

 *  Build a pointed expression.

 *  @param pStructUnionExp: expression specifying structure or union

 *      whose element is to be pointed.

 *  @param pElemNode: An element of pStructUnionExp.

 *  @return pointed expression node having operation code arrowCode.

**/

public PointedExp

pointedExp( Exp pStructUnionExp, ElemNode pElemNode );

 

/** contentsExp:

 *  Build an expression that gets the contents pointed by pPointerExp.

 *  @param pPointerExp: Expression representing a pointer.

 *  @return the expression that gets the pointed expression.

**/

public Exp

contentsExp( Exp pPointerExp );

 

/** convExp:

 *  Build an expression to convert the type of pExp to pType.

 *  @param pType: Type to which pExp is to be changed.

 *  @param pExp: Expression to be converted.

 *  @return the expression converted to pType.

**/

public Exp

convExp( Type pType, Exp pExp );

 

/** sizeofExp:

 *  Build the expression that get the size of pType.

 *  @param pType: Type of object.

 *  @return the expression representing the size of pType.

**/

public Exp

sizeofExp( Type pType );

 

/** sizeofExp:

 *  Build the expression that get the size of pExp.

 *  @param pExp: Expression whose size is to be taken.

 *  @return the expression representing the size of pExp.

**/

public Exp

sizeofExp( Exp pExp );

 

/** functionExp:

 *  Build a function expression node that computes function value.

 *  The function may have no return value (void return value).

 *  If pFunctionSpec is (addr SubpNode) or SubpNode, then the

 *  subprogram represented by it is added to the call list

 *  of the current subprogram (symRoot.subpCurrent).

 *  @param pFunctionSpec: function specification part which may be either

 *      a function name (SubpNode), or an expression specifying

 *      a function name ((addr SubpNode), etc.).

 *  @param pActualParamList: actual parameter list (made by hirList).

 *  @return function expression node having operation code opCall.

**/

public FunctionExp

functionExp( Exp pFunctionSpec, IrList pActualParamList );

 

/** callStmt:

 *  Build a subprogram call statement.

 *  Parameters are the same as those of functionExp.

 *  @param pSubpSpec: subprogram specification part which may be either

 *      a subprogram name (SubpNode), or an expression specifying

 *      a subprogram name ((addr SubpNode), etc.).

 *  @param pActualParamList: actual parameter list (made by hirList).

 *  @return function expression node having operation code opCall.

**/

public ExpStmt

callStmt( Exp pSubpSpec, IrList pActualParamList );

 

/** assignStmt:

 *  Build an assignemnt statement.

 *  @param pLeft: left hand side (l-value) expression to which

 *      the value of expression is to be assigned.

 *  @param pRight: expression (subtree) that is to be assigned

 *      to pLeftSide.

 *  @return the subtree of the built statement

 *      with statement body operator assignCode.

 **/

public AssignStmt

assignStmt( Exp pLeft, Exp pRight );

 

/** ifStmt:

 *  Build an if-statement with then-part (pThenPart) and

 *  else-part (pElsePart).

 *  Internal labels (then-label and else-label) are generated

 *  to be attached to the then-part and else-part.

 *  If pThenPart or pElsePart is null, a LabeledStmt with null

 *  statement body is generated as then-part or else-part.

 *  (null else-part can be deleted by deleteUselessLabeledStmtOfHir()

 *  of coins.flow.DeleteUnusedLabels1.)

 *  @param pCondition: conditional expression subtree.

 *  @param pThenPart: then-part statement that is executed when

 *      pCondition is true.

 *  @param pElsePart: else-part statement that is executed when

 *      pCondition is false.

 *  @return the subtree of the built statement

 *      with statement body operator OP_IF;

 *      If else-part is not given, it is treated as null.

**/

public IfStmt

ifStmt( Exp pCondition, Stmt pThenPart, Stmt pElsePart );

 

/* whileStmt (simple):

 * Build while-loop statement.

 * If it contains break or continue statement, use getLoopSteplabel()

 * or getLoopEndLabel() of LoopStmt interface to get the label

 * to be used in the jump statement corresponding to the continue

 * or break statement.  User may also use the general

 * whileStmt method that has pLoopStepLabel and pLoopEndLabel.

 * @param pCondition: Loop start condition expression.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @return WhileStmt subtree.

**/

public WhileStmt

whileStmt( Exp pCondition, Stmt pLoopBody );

 

/* whileStmt (general):

 * Build while-loop statement.

 * If user want to make a jump statement corresponding to break or

 * continue statement, generate pLoopStepLabel and pLoopEndLabel by

 * symRoot.symTableCurrent.generateLabel() and use the labels in

 * the jump statement.

 * @param pLoopBacklabel: Label to be attached to the

 *    loop body.

 * @param pCondition: Loop start condition expression.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @param pLoopStepLabel: Label to which continue statement should jump.

 * @param pLoopEndLabel: Label to whicjh break statement should jump.

 * @return WhileStmt subtree.

**/

public WhileStmt

whileStmt( Label pLoopBackLabel, Exp pCondition, Stmt pLoopBody,

           Label pLoopStepLabel, Label pLoopEndLabel );

 

/* forStmt (simple):

 * Build for-loop statement.

 * If it contains break or continue statement, use getLoopSteplabel()

 * or getLoopEndLabel() of LoopStmt interface to get the label

 * to be used in the jump statement corresponding to the continue

 * or break statement.  User may also use the general

 * forStmt method that has pLoopStepLabel and pLoopEndLabel.

 * @param pInitStmt: Loop initiation statement that is executed

 *    before testing the loop start condition.

 * @param pCondition: Loop start condition expression.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @param pStepPart: Step part statement that is executed

 *    at the first of the next iteration.

 * @return forStmt subtree.

**/

public ForStmt

forStmt( Stmt pInitStmt, Exp pCondition,

         Stmt pLoopBody, Stmt pStepPart );

 

/* forStmt (general):

 * Build for-loop statement.

 * @param pInitStmt: Loop initiation statement that is executed

 *    before testing the loop start condition.

 * @param pLoopBacklabel: Label to be attached to the

 *    loop body.

 * @param pCondition: Loop start condition expression.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @param pLoopStepLabel: Label to which break statement should jump.

 * @param pStepPart: Step part statement that is executed

 *    at the first of the next iteration.

 * @param pLoopEndLabel: Label to whicjh break statement should jump.

 * @return forStmt subtree.

**/

public ForStmt

forStmt( Stmt pInitStmt, Label pLoopBackLabel, Exp pCondition,

         Stmt pLoopBody, Label pLoopStepLabel, Stmt pStepPart,

         Label pLoopEndLabel );

 

/* untilStmt (simple):

 * Build until-loop statement.

 * If it contains break or continue statement, use getLoopSteplabel()

 * or getLoopEndLabel() of LoopStmt interface to get the label

 * to be used in the jump statement corresponding to the continue

 * or break statement.  User may also use the general

 * untilStmt method that has pLoopStepLabel and pLoopEndLabel.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @param pCondition: Loop end condition expression.

 * @return untilStmt subtree.

**/

public UntilStmt

untilStmt( Stmt pLoopBody, Exp pCondition );

 

/* untilStmt (general):

 * Build until-loop statement.

 * @param pLoopBacklabel: Label to be attached to the

 *    loop body.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @param pLoopStepLabel: Label to which break statement should jump.

 * @param pCondition: Loop end condition expression.

 * @param pLoopEndLabel: Label to whicjh break statement should jump.

 * @return untilStmt subtree.

**/

public UntilStmt

untilStmt( Label pLoopBackLabel, Stmt pLoopBody, Label pLoopStepLabel,

           Exp pCondition, Label pLoopEndLabel );

 

/* indexedLoopStmt: //##21

 * Build simple indexed-loop (Fortran-type loop) statement.

 * @param pLoopIndex: Simple variable that is incremented

 *    by pStepValue at each repetition of the loop

 *    starting from pStartValue toward pEndValue while not exceeding

 *    pEndvalue; Usually it is an integer variable but

 *    floating variable is also permitted.

 * @param pStartValue: Start value of the loop index.

 * @param pEndValue: End limit of the loop index.

 * @param pStepValue: Step value to be used to increment

 *     the loop index; It should represent positive number.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @return IndexedLoopStmt subtree.

 * @see IndexedLoopStmt.

**/

public IndexedLoopStmt //##21

indexedLoopStmt( Var pLoopIndex, Exp pStartValue,

  Exp pEndValue, Exp pStepValue, Stmt pLoopBody );

 

/* indexedLoopStmt: //##21

 * Build general indexed-loop (Fortran-type loop) statement.

 * @param pLoopIndex: Simple variable that is incremented or

 *    decremented by pStepValue at each repetition of the loop

 *    starting from pStartValue toward pEndValue while not crossinging

 *    pEndvalue; Usually it is an integer variable but

 *    floating variable is also permitted.

 * @param pStartValue: Start value of the loop index.

 * @param pEndValue: End limit of the loop index.

 * @param pStepValue: Step value to be used to increment

 *     the loop index; It should represent positive number.

 * @pUpward: true if the loop index is incremented upward,

 *     false if it is decremented downward; If false,

 *     pEndValue is expected to be less or equal to pStartValue.

 * @param pLoopBody: Loop body to be repetitively executed.

 * @return IndexedLoopStmt subtree.

 * @see IndexedLoopStmt.

**/

public IndexedLoopStmt //##21

indexedLoopStmt( Var pLoopIndex, Exp pStartValue,

  Exp pEndValue, Exp pStepValue, boolean pUpward, Stmt pLoopBody );

 

/** labeledStmt:

 *  Build labeled statement using pLabel as its label and

 *  pStmt as its statement body.

 *  It is recommended to use attachLabel of Stmt

 *  except in HIR access methods to make a labeled statement.

 *  If you want to use labeledStmt, give null as pStmt parameter.

 *  Relations between pStmt and others (such as previousStmt,

 *  nextStmt, parentNode) are not kept. If it is necessary to

 *  transfer such relations to this LabeledStmt, apply

 *  attachLabel method to pStmt instead of calling labeledStmt.

**/

public LabeledStmt

labeledStmt( Label pLabel, Stmt pStmt );

 

/** blockStmt:

 *  Make an instance of block statement that may contain a sequence of

 *  statements.

 *  It is recommended to make an empty block statement by

 *  blockStmt(null) and then add statements by successively calling

 *  addLastStmt method of BlockStmt.

 *  @param pStmtSequence: statement to be included in BlockStmt.

 *  @return the resultant BlockStmt.

**/

public BlockStmt

blockStmt( Stmt pStmtSequence );

 

/** returnStmt:

 *  Build return statement that terminates the execution of

 *      current subprogram under construction.

 *  @param pReturnValue: return value of function subprogram.

 *      If the subprogram has no return value, it is null.

 *  @return the subtree of the built statement

 *      with statement body operator OP_RETURN.

**/

public ReturnStmt

returnStmt( Exp pReturnValue );

 

/** returnStmt:

 *  Build return statement that terminates the execution of

 *  current subprogram under construction.

 *  It has no return value.

 *  @return the subtree of the built statement

 *      with statement body operator OP_RETURN.

**/

public ReturnStmt

returnStmt();

 

/** jumpStmt:

 *  Create a jump statement and increment reference count of pLabelSym.

 *  @param pLabelSym: jump target label.

 *  @return the created jump statement.

**/

public JumpStmt

jumpStmt( Label pLabelSym );

 

/** switchStmt:

 *  Make a SwitchStmt instance.

 *  The jump list pJumpList is a list of pairs of case constant

 *  and case label. Following sequence may create a jump list:

 *     created an empty list by irList() of HIR;

 *     generate a case-label and attach it to the statement

 *        corresponding to the case-constant;

 *     add hir.hirSeq(case-constant node, case-label node) to the list;

 *     repeat the generation of case-label and addition to the jump list;

 *  @param pSelectExp: Expression to select case statement.

 *  @param pJumpList: Jump list that correlate case constant

 *      and case label.

 *  @param pDefaultLabel: label to be attached to default statement part.

 *  @param pSwitchBody: Switch statement body that contains statements

 *      with case-label.

 *  @param pEndLabel: Label as the target of jump corresponding to break.

 *  @return the resultant SwitchStmt.

**/

 

public SwitchStmt

switchStmt( Exp pSelectExp, IrList pJumpList, Label pDefaultLabel,

            Stmt pSwitchBody, Label pEndLabel );

 

/** expStmt:

 *  Create a statement treating pExp as a statement.

 *  ExpStmt appears as loop-condition, call statement, etc.

 *  The loop-condition is an expression but it has label, and so,

 *  it should be ExpStmt. The call statement is a function call

 *  expression treated as a stand alone statement, and so,

 *  it should be ExpStmt.

 *  @param pExp: expression to be treated as a statement.

 *  @return the resultant ExpStmt.

**/

public ExpStmt

expStmt( Exp pExp );

 

/** nullStmt:

 *  Make a statement having NullNode as its statement body.

 *  @return the null statement.

**/

public Stmt

nullStmt();

 

/** phiExp:

 *  Make a phi expression used in SSA.

 *  @param pVar: variable to be selected.

 *  @param pLabel: label attached to a basic block from which

 *     control tranfers.

 *  @return PhiExp.

**/

public PhiExp

phiExp( Var pVar, Label pLabel );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 HIR node.

 *  @return HirSeq with one child.

**/

public HirSeq

hirSeq( HIR pChild1 );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 HIR node.

 *  @param pChild2: Child 2 HIR node.

 *  @return HirSeq with 2 children.

**/

public HirSeq

hirSeq( HIR pChild1, HIR pChild2 );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 HIR node.

 *  @param pChild2: Child 2 HIR node.

 *  @param pChild3: Child 3 HIR node.

 *  @return HirSeq with 3 children.

**/

public HirSeq

hirSeq( HIR pChild1, HIR pChild2, HIR pChild3 );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 HIR node.

 *  @param pChild2: Child 2 HIR node.

 *  @param pChild3: Child 3 HIR node.

 *  @param pChild4: Child 4 HIR node.

 *  @return HirSeq with 4 children.

**/

public HirSeq

hirSeq( HIR pChild1, HIR pChild2, HIR pChild3, HIR pChild4 );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 HIR node.

 *  @param pChild2: Child 2 HIR node.

 *  @param pChild3: Child 3 HIR node.

 *  @param pChild4: Child 4 HIR node.

 *  @param pChild5: Child 5 HIR node.

 *  @return HirSeq with 5 children.

**/

public HirSeq

hirSeq( HIR pChild1, HIR pChild2, HIR pChild3, HIR pChild4, HIR pChild5 );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 IR node.

 *  @return HirSeq with one IR child.

**/

public HirSeq

hirSeq( IR pChild1 );

 

/** hirSeq: Make an HirSeq node that have some definite number of

 *  children.

 *  @param pChild1: Child 1 IR node.

 *  @param pChild2: Child 2 IR node.

 *  @return HirSeq with 2 IR children.

**/

public HirSeq

hirSeq( IR pChild1, IR pChild2 );

 

//==== Primitive methods to make HIR node ====//

//   Not recommmended to be used except in HIR factory methods.

 

/** hirNode:

 *  make an HIR node with no operand.

 *  hirNode methods are not recommmended to be used except in

 *  HIR factory methods.

 *  @param pOperator: Operator constant of HIR.

 *  @return the HIR node.

**/

public HIR

hirNode( int pOperator );

 

public HIR

hirNode( int pOperator, HIR pOperand1 );

 

public HIR

hirNode( int pOperator, HIR pOperand1, HIR pOperand2 );

 

public HIR

hirNode( int pOperator, HIR pOperand1, HIR pOperand2,

         HIR pOperand3 );

 

public HIR

hirNode( int pOperator, HIR pOperand1, HIR pOperand2,

         HIR pOperand3, HIR pOperand4 );

 

/** hirNodeWithN_sources:

 *  Create an HIR node having pOperator as its operator

 *  and n null source operands.

 *  This method is not recommmended to be used except in

 *  HIR factory methods.

 *  @param pOperator: operation code of the node to be created.

 *  @param pSourceNumber: number of null source operands to be

 *      attached to the created node.

 *  @return the created node having pOperator as its operator and

 *      null source operands counting up to pSourceNumber.

**/

public HIR

NodeWithN_sources( int pOperator, int pSourceNumber );

 

//==== Methods to link children to HIR node ====//

//   Not recommmended to be used except in HIR factory methods.

 

public void setChildren( IR p1, IR p2 );

 

public void setChildren( IR p1, IR p2, IR p3 );

 

public void setChildren( IR p1, IR p2, IR p3, IR p4 );

 

public void setChildren( IR p1, IR p2, IR p3, IR p4, IR p5 );

 

//====== Methods for manipulating HIR nodes ======//

 

/** copyWithOperands:

 *  Make a subtree that is the same to this subtree.

 *  (Labels are not renamed.)

 *  In general, a subtree represents the computation of

 *  an operation and also the computation of its operands.

 *  Flow information is invalid as for copied subtree and

 *  should be computed again if required.

 *  If the subtree contains labels, it is recommended to use

 *  copyWithOperandsChangingLabels. Note that, IfStmt, LoopStmt

 *  (for, while, until, etc.), SwitchStmt

 *  contain internal labels and it is recommended to use

 *  copyWithOperandsChangingLabels to the subtree that may contain

 *  these statements.

 *  "this" should be the root node of a subtree contained

 *  in a subprogram body. Subprogram body itself should not be copied.

 *  @return the subtree made by the copy operation.

**/

HIR

copyWithOperands();

 

/** copyWithOperandsChangingLabels:

 *  Make a new subtree that is the same to this subtree.

 *  If this subtree contains a label definition, then

 *  the label is renamed to avoid conflict.

 *  Flow information is invalid as for copied subtree and

 *  should be computed again if required.

 *  "this" should be the root node of a subtree contained

 *  in a subprogram body. Subprogram body should not be copied.

 *  @param pLabelCorrespondence: label correspondence list;

 *      It is usually null; If label correspondence is to be

 *      specified, it should be of the form

 *        (IrList (IrList of original labels) (IrList of new labels) )

 *      "this" subtree should not contain labels listed

 *      in (IrList of new labels) so as escape from infinite

 *      replacement loop; This restriction is satisfied when

 *      pLabelCorrespondence is null;

 *      If this parameter is null, it is computed in this method

 *      and passed to HirModify subclass after calling copyWithOperands

 *      (without changing label).

 *  @return the copied subtree with labels changed.

**/

public HIR

copyWithOperandsChangingLabels( IrList pLabelCorrespondence );

 

/** replaceResultOperand:

 *  Replace result operand (variable) of "this" node by pOperand.

 *  "this" should be a node that can have

 *  result operand, that is, "this" should be HIR assign node or

 *  LIR store node.

 *  If "this" is HIR assign node, its child 1 representing left

 *  hand side variable is replaced by pOperand.

 *  If "this" is LIR store node, the result variable is replaced

 *  by pOperand which may be a simple variable or a register

 *  or some other expression representing address of variable. (##2)

 *  (This method is moved to IR interface.) //##20

 *  @param pOperand: node that takes place of result variable;

 *      If "this" is HIR node then it should be HIR node,

 *      if "this" is LIR node then it should be LIR node.

**/

// void

// replaceResultOperand( IR pOperand );

 

/** replaceResultVar: //##20 To be DELETED. Use replaceResultOperand

 *  Replace result variable of "this" node by pOperand.

 *  "this" should be a node that can have variable as its

 *  result operand, that is, "this" should be HIR assign node or

 *  LIR store node.

 *  If "this" is HIR assign node, its child 1 representing left

 *  hand side variable is replaced by pOperand.

 *  If "this" is LIR store node, the result variable is replaced

 *  by pOperand which may be a simple variable or a register

 *  or some other expression representing address of variable. (##2)

 *  @param pOperand: node that takes place of result variable;

 *      If "this" is HIR node then it should be HIR node,

 *      if "this" is LIR node then it should be LIR node.

**/

void

replaceResultVar( IR pOperand ); //##20 To be DELETED. Use replaceResultOperand

 

/** replaceOperator: //##20 To be DELETED

 *  Replace the operator of "this" node by pOperator.

 *  The operator should have the same number and type of operands.

 *  It is not recommended to use this method.

 *  @param pOperator: operation code for replacement.

**/

void

replaceOperator( int pOperator ); //##20 To be DELETED.

 

/** getClone:  //##20

 *  Make the clone of this node to get a clone in the situation

 *  where clone() can not be used directly.

 *  @return the clone of this node.

**/

// public IR //##20

// getClone()throws CloneNotSupportedException;

 

/** hirClone:  //##20

 *  Make the clone of this node to get a clone in the situation

 *  where clone() can not be used directly.

 *  @return the clone of this node.

 */

public HIR

hirClone()throws CloneNotSupportedException;

 

/** isTree: //##16

 *  Test if this does not violates tree structure, that is,

 *  detect node adherence in branches and

 *  handshake miss in parent-child relation.

 *  Issues message if some node is encountered twice in

 *  the process of traversing this subtree.

 *  @return true if this a tree else return false.

**/

public boolean

isTree();  //##16

 

/** isTree: //##20

 *  Test if this does not violates tree structure, that is,

 *  detect node adherence in branches and

 *  handshake miss in parent-child relation.

 *  Issues message if some node is encountered twice in

 *  the process of traversing this subtree.

 *  @param pVisitedNodes: Give null in usual case;

 *       Set of visited nodes is given when isTree is

 *       invoked recursively by isTree.

 *  @return true if this a tree else return false.

**/

public boolean

isTree(java.util.Set pVisitedNodes );  //##20

 

//==== Iterators to traverse HIR ====//

 

/** subpIterator:

 *  Make an iterator that traverses all subprogram definitions

 *  in the current compile unit.

 *  Sequence of SubpDefinition will be get by using next()

 *  of the iterator successively.

 *  @return the iterator to traverse subprogram definitions.

**/

public Iterator

subpIterator();

 

/** hirIterator:

<PRE>

 *  Get an iterator to traverse all nodes or statements under

 *  pSubtree. YOu can traverse the subtree by following methods

 *  of HirIterator:

 *     next(): traverse all nodes.

 *     getNextStmt(): traverse all statements.

 *     getNextExecutableNode(): traverse executable nodes only.

 *  See HirIterator interface.

 *  @param pSubtree: root of the subtree to be traversed.

 *  @return teh resultant HirIterator.

</PRE>

**/

public HirIterator

hirIterator( IR pSubtree );

 

//## public Iterator

//## lirIterator( IR pSubtree );

 

//==== Visitor/Acceptor to process HIR ====//

 

/**

public void visitHir( HIR pHir);

public void visitChildren( HIR pHir );

**/

 

/** accept:

 *  Acceptor used in HIR visitor.

 *  See HirVisitor, HirVisitorModel1, HirVisitormodel2.

 *  @param pVisitor: HirVisitor

**/

public void

accept( HirVisitor pVisitor );

 

//==== Methods to print HIR node ====//

 

/** toStringShort

 *  Get text string of this node showing node name and index only.

**/

public String toStringShort();

 

/** toStringDetail

 *  Get text string of this node showing detail information.

**/

public String toStringDetail();

 

/** print:

 *  Print this subtree in text format traversing all children

 *  of this node.

 *  "this" may be any subtree (it may be a leaf node).

 *  @param pIndent: number of heading spaces for indentation.

 *  @param pDetail: true if print all main attributes,

 *         false if some detail attributes are to be omitted.

**/

public void print( int pIndent, boolean pDetail );

 

/** getIndentSace:

 *  Get a sequence of spaces specified by pIndent.

 *  @param pIndent: number of spaces to be generated.

 *  @return a string of spaces.

**/

public String getIndentSpace( int pIndent );

 

/** setIndexNumberToAllNodes:

 *  Set sequencial index number to all nodes traversing the subtree

 *  rooted by this node.

 *  @param pStartNumber: starting value of the index.

 *  @return (the last index number) + 1.

**/

public int

setIndexNumberToAllNodes( int pStartNumber );

 

//====== Constants available in HIR classes ======//

 

/** Operator number

**/

  public static final int

    OP_PROG          =  1,   // Program

    OP_SUBP_DEF      =  2,   // SubpDefinition

    OP_LABEL_DEF     =  3,   // LabelDef node

    OP_INF           =  4,   // Information node

    OP_CONST         =  5,   // ConstNode

    OP_SYM           =  6,   // SymNode

    OP_VAR           =  7,   // VarNode

    OP_PARAM         =  8,   // VarNode

    OP_SUBP          =  9,   // SubpNode

    OP_TYPE          = 10,   // TypeNode

    OP_LABEL         = 11,   // LabelNode

    OP_ELEM          = 12,   // ElemNode

 // OP_FIELD         = 13,

                             // OP_CONST - OP_FIELD has a symbol attached

                             // and it is get bey getSym().

    OP_LIST          = 14,   // List of CompilerObjects

                             // such as IR nodes and symbols

    OP_SEQ           = 15,   // Sequence of HIR objects  //##10

    OP_ENCLOSE       = 16,   // Enclose subexpression //##9

 

    OP_SUBS          = 17,   // subscripted variable

    OP_INDEX         = 18,   // index modification of subscripted var

    OP_QUAL          = 19,   // struct/union qualification

    OP_ARROW         = 20,   // pointer reference

 

    OP_STMT          = 21,   // Statement code lower. Stmt is

                             // an abstract class and there is

                             // no instance having OP_STMT.

    OP_LABELED_STMT  = 21,   // Use the same number as Stmt

                             // because Stmt is an abstract class.

    OP_ASSIGN        = 22,   // AssignStmt