Exemple #1
0
void end_if_semantics (void)

{
   int  	if_ir_idx;
   int  	if_sh_idx;
   int		il_idx;
   int		ir_idx;
   int  	lbl_idx;
   int  	sh_idx;
   opnd_type	tmp_opnd;


   TRACE (Func_Entry, "end_if_semantics", NULL);


   /* Walk back through the IF construct to find the IF construct SH.         */
   /* If it's marked in error, bail.					      */

   if_sh_idx = SH_PARENT_BLK_IDX(curr_stmt_sh_idx);

   while (SH_STMT_TYPE(if_sh_idx) != If_Cstrct_Stmt) {

      if (SH_STMT_TYPE(if_sh_idx) == Else_Stmt) {
         if_sh_idx = IR_IDX_L(SH_IR_IDX(if_sh_idx));
      }
      else {
         if_sh_idx = IL_IDX(IL_NEXT_LIST_IDX(IR_IDX_R(SH_IR_IDX(if_sh_idx))));
      }
   }

   if (SH_ERR_FLG(if_sh_idx)) {
      goto EXIT;
   }

   lbl_idx = IL_IDX(IL_NEXT_LIST_IDX(IR_IDX_R(SH_IR_IDX(if_sh_idx))));
   AT_DEFINED(lbl_idx)       = TRUE;
   AT_DEF_LINE(lbl_idx)      = stmt_start_line;
   ATL_DEF_STMT_IDX(lbl_idx) = curr_stmt_sh_idx;
   AT_REFERENCED(lbl_idx)    = Referenced;


   /* If the last clause of the IF construct is an ELSE IF, generate a        */
   /* CONTINUE statement to define its branch-around label.                   */

   if (SH_STMT_TYPE(SH_PARENT_BLK_IDX(curr_stmt_sh_idx)) == Else_If_Stmt) {
      gen_sh(Before, Continue_Stmt, stmt_start_line, stmt_start_col,
             FALSE,
             TRUE,					/* Labeled.	      */
             TRUE);					/* Compiler-generated */

      sh_idx              = SH_PREV_IDX(curr_stmt_sh_idx);
      NTR_IR_TBL(ir_idx);
      SH_IR_IDX(sh_idx)   = ir_idx;
      IR_OPR(ir_idx)      = Label_Opr;
      IR_TYPE_IDX(ir_idx) = TYPELESS_DEFAULT_TYPE;
      IR_LINE_NUM(ir_idx) = stmt_start_line;
      IR_COL_NUM(ir_idx)  = stmt_start_col;
      IR_LINE_NUM_L(ir_idx) = stmt_start_line;
      IR_COL_NUM_L(ir_idx)  = stmt_start_col;
      IR_FLD_L(ir_idx)    = AT_Tbl_Idx;
      lbl_idx             =
         IL_IDX(IR_IDX_R(SH_IR_IDX(SH_PARENT_BLK_IDX(curr_stmt_sh_idx))));
      IR_IDX_L(ir_idx)    = lbl_idx; 

      AT_DEFINED(lbl_idx)       = TRUE;
      AT_DEF_LINE(lbl_idx)      = stmt_start_line;
      ATL_DEF_STMT_IDX(lbl_idx) = sh_idx;
      AT_REFERENCED(lbl_idx)    = Referenced;
   }


   /* Generate a CONTINUE statement to define the "end IF" label.             */
   /* If there were no ELSE IF's and no ELSE, get the label from the first IL */
   /* attached to the right operand of the If_Opr IR attached to the If_Cstrct*/
   /* SH.  Otherwise, get the label from the second IL.			      */

   gen_sh(Before, Continue_Stmt, stmt_start_line, stmt_start_col,
          FALSE,
          TRUE,						/* Labeled.	      */
          TRUE);					/* Compiler-generated */

   sh_idx                            = SH_PREV_IDX(curr_stmt_sh_idx);
   NTR_IR_TBL(ir_idx);
   SH_IR_IDX(sh_idx)                 = ir_idx;
   IR_OPR(ir_idx)                    = Label_Opr;
   IR_TYPE_IDX(ir_idx)               = TYPELESS_DEFAULT_TYPE;
   IR_LINE_NUM(ir_idx)               = stmt_start_line;
   IR_COL_NUM(ir_idx)                = stmt_start_col;
   IR_LINE_NUM_L(ir_idx)             = stmt_start_line;
   IR_COL_NUM_L(ir_idx)              = stmt_start_col;
   IR_FLD_L(ir_idx)                  = AT_Tbl_Idx;

   if_ir_idx = SH_IR_IDX(if_sh_idx);

   if (SH_STMT_TYPE(SH_PARENT_BLK_IDX(curr_stmt_sh_idx)) == If_Cstrct_Stmt) {
      lbl_idx = IL_IDX(IR_IDX_R(if_ir_idx)); 
   }
   else {
      lbl_idx = IL_IDX(IL_NEXT_LIST_IDX(IR_IDX_R(if_ir_idx)));
   }
   
   IR_IDX_L(ir_idx)           = lbl_idx;

   AT_DEFINED(lbl_idx)        = TRUE;
   AT_DEF_LINE(lbl_idx)       = stmt_start_line;
   ATL_DEF_STMT_IDX(lbl_idx)  = sh_idx;
   AT_REFERENCED(lbl_idx)     = Referenced;


   /* Walk back through the IF construct and transfer the branch around label */
   /* for each ELSE IF and for the IF itself to the right operand of each     */
   /* Br_True IR (replacing the IL list).  The IL_OPND is copied to a temp    */
   /* first because sometimes assignments get a little funky using these      */
   /* macros if the target is also being used to access the source.           */
   /* LRR:  If we're gettting tight on space, could also delete the IL nodes. */

   if_sh_idx = SH_PARENT_BLK_IDX(curr_stmt_sh_idx);

   while (SH_STMT_TYPE(if_sh_idx) != If_Cstrct_Stmt) {

      if (SH_STMT_TYPE(if_sh_idx) == Else_Stmt) {
         sh_idx            = if_sh_idx;
         if_sh_idx         = IR_IDX_L(SH_IR_IDX(if_sh_idx));
         SH_IR_IDX(sh_idx) = NULL_IDX;
      }
      else {
         il_idx = IL_NEXT_LIST_IDX(IR_IDX_R(SH_IR_IDX(if_sh_idx)));
         COPY_OPND(tmp_opnd, IL_OPND(IR_IDX_R(SH_IR_IDX(if_sh_idx))));
         COPY_OPND(IR_OPND_R(SH_IR_IDX(if_sh_idx)), tmp_opnd);
         if_sh_idx = IL_IDX(il_idx);
      }
   }

   COPY_OPND(tmp_opnd, IL_OPND(IR_IDX_R(if_ir_idx)));
   COPY_OPND(IR_OPND_R(if_ir_idx), tmp_opnd);

EXIT:

   TRACE (Func_Exit, "end_if_semantics", NULL);

   return;

}  /* end_if_semantics */
Exemple #2
0
void gen_default_init_code(int	 attr_idx)

{
   expr_arg_type	expr_desc;
   operator_type	operator;
   opnd_type    	opnd;


   TRACE (Func_Entry, "gen_default_init_code", NULL);

   if (AT_DCL_ERR(attr_idx)) {
      goto EXIT;
   }

   if (SB_RUNTIME_INIT(ATD_STOR_BLK_IDX(attr_idx))) {

      /* The var is on the stack, or is automatic, a darg or a func  */
      /* result.  Generate runtime code for the initialization.      */

      operator = Asg_Opr;
   }
   else if (ATD_IN_COMMON(attr_idx)) {
      operator = Init_Opr;

# if 0
# if defined(_TARGET_OS_SOLARIS) || (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX) || defined(_TARGET_OS_DARWIN))
      func = gen_common_dv_init;
# else
      func = gen_static_dv_whole_def;
# endif
# endif
   }
   else {
      operator = Init_Opr;
   }

   if (!ATD_IM_A_DOPE(attr_idx) &&
       TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Structure           &&
       ATT_DEFAULT_INITIALIZED(TYP_IDX(ATD_TYPE_IDX(attr_idx))) &&
       !AT_DCL_ERR(TYP_IDX(ATD_TYPE_IDX(attr_idx)))) {

      OPND_FLD(opnd)      = AT_Tbl_Idx;
      OPND_IDX(opnd)      = attr_idx;
      OPND_LINE_NUM(opnd) = AT_DEF_LINE(attr_idx);
      OPND_COL_NUM(opnd)  = AT_DEF_COLUMN(attr_idx);

# if defined(_F_MINUS_MINUS)
      if (ATD_ARRAY_IDX(attr_idx) || ATD_PE_ARRAY_IDX(attr_idx)) {
# else
      if (ATD_ARRAY_IDX(attr_idx)) {
# endif
         gen_whole_subscript(&opnd, &expr_desc);
      }

      process_all_initialized_cpnts(&opnd, 
                                    TYP_IDX(ATD_TYPE_IDX(attr_idx)),
                                    operator);
   }

EXIT:

   TRACE (Func_Exit, "gen_default_init_code", NULL);

   return;

}  /* gen_default_init_code */

/******************************************************************************\
|*									      *|
|* Description:								      *|
|*	recursively go through all components of a structure to look for      *|
|*      default initialization. Then call the supplied routine func for       *|
|*	processing.							      *|
|*									      *|
|* Input parameters:							      *|
|*	left_opnd - current base of sub-object reference.                     *|
|*      type_idx  - defined type attr.                                        *|
|*      operator  - Whether to use Init_Opr or Asg_Opr.                       *|
|*									      *|
|* Output parameters:							      *|
|*	NONE								      *|
|*									      *|
|* Returns:								      *|
|*	NOTHING								      *|
|*									      *|
\******************************************************************************/

static void process_all_initialized_cpnts(opnd_type    *left_opnd,
					  int		type_idx,
					  operator_type	operator)

{
   int			attr_idx;
   expr_arg_type	expr_desc;
   opnd_type		expr_opnd;
   int			init_idx;
   int			ir_idx;
   int			list_idx;
   opnd_type		opnd;
   int			sn_idx;


   TRACE (Func_Entry, "process_all_initialized_cpnts", NULL);

   sn_idx = ATT_FIRST_CPNT_IDX(type_idx);

   while (sn_idx != NULL_IDX) {
      attr_idx = SN_ATTR_IDX(sn_idx);  /* A component */

      if (ATD_CPNT_INIT_IDX(attr_idx) != NULL_IDX) {
         NTR_IR_TBL(ir_idx);

         IR_OPR(ir_idx)		= Struct_Opr;
         IR_TYPE_IDX(ir_idx)	= ATD_TYPE_IDX(attr_idx);
         IR_LINE_NUM(ir_idx)	= AT_DEF_LINE(attr_idx);
         IR_COL_NUM(ir_idx)	= AT_DEF_COLUMN(attr_idx);

         COPY_OPND(IR_OPND_L(ir_idx), (*left_opnd));

         IR_FLD_R(ir_idx)	= AT_Tbl_Idx;
         IR_IDX_R(ir_idx)	= attr_idx;
         IR_LINE_NUM_R(ir_idx)	= AT_DEF_LINE(attr_idx);
         IR_COL_NUM_R(ir_idx)	= AT_DEF_COLUMN(attr_idx);

         if (IR_FLD_L(ir_idx) == IR_Tbl_Idx) {
             IR_RANK(ir_idx)	= IR_RANK(IR_IDX_L(ir_idx));
         }

         NTR_IR_TBL(init_idx);

         IR_OPR(init_idx)	= operator;
         IR_LINE_NUM(init_idx)	= AT_DEF_LINE(attr_idx);
         IR_COL_NUM(init_idx)	= AT_DEF_COLUMN(attr_idx);
         IR_TYPE_IDX(init_idx)	= TYPELESS_DEFAULT_TYPE;
         IR_FLD_L(init_idx)	= IR_Tbl_Idx;
         IR_IDX_L(init_idx)	= ir_idx;
         IR_LINE_NUM_L(init_idx)= AT_DEF_LINE(attr_idx);
         IR_COL_NUM_L(init_idx)	= AT_DEF_COLUMN(attr_idx);

         if (operator == Asg_Opr) {

            if (ATD_FLD(attr_idx) == IR_Tbl_Idx) {

               /* This should be an Init_Opr */

               if (IR_OPR(ATD_CPNT_INIT_IDX(attr_idx)) != Init_Opr) {
                  PRINTMSG(AT_DEF_LINE(attr_idx), 626, Internal,
                           AT_DEF_COLUMN(attr_idx),
                           "An Init Opr",
                           "process_all_initialized_cpnts");
               }

               COPY_OPND(IR_OPND_R(init_idx),
                         IL_OPND(IR_IDX_R(ATD_CPNT_INIT_IDX(attr_idx))));
            }
            else {
               IR_IDX_R(init_idx)	= ATD_CPNT_INIT_IDX(attr_idx);
               IR_FLD_R(init_idx)	= (fld_type) ATD_FLD(attr_idx);
               IR_LINE_NUM_R(init_idx)	= AT_DEF_LINE(attr_idx);
               IR_COL_NUM_R(init_idx)	= AT_DEF_COLUMN(attr_idx);
            }

            if (ATD_ARRAY_IDX(attr_idx) != NULL_IDX ||
                TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character) {   
               xref_state		= CIF_No_Usage_Rec;
               expr_desc.rank		= 0;
               OPND_FLD(expr_opnd)	= IR_Tbl_Idx;
               OPND_IDX(expr_opnd)	= ir_idx;;

               if (expr_semantics(&expr_opnd, &expr_desc)) {
                  COPY_OPND(IR_OPND_L(init_idx), expr_opnd);
               }
            }

            gen_sh(After,
                   Assignment_Stmt,
                   AT_DEF_LINE(attr_idx),
                   AT_DEF_COLUMN(attr_idx),
                   FALSE,
                   FALSE,
                   TRUE);
         }
         else {  /* Init_Opr */

            if (ATD_FLD(attr_idx) == IR_Tbl_Idx) {

               /* This should be an Init_Opr */

               if (IR_OPR(ATD_CPNT_INIT_IDX(attr_idx)) != Init_Opr) {
                  PRINTMSG(AT_DEF_LINE(attr_idx), 626, Internal,
                           AT_DEF_COLUMN(attr_idx),
                           "An Init Opr",
                           "process_all_initialized_cpnts");
               }

               IR_FLD_R(init_idx)	= IL_Tbl_Idx;
               IR_IDX_R(init_idx)	= IR_IDX_R(ATD_CPNT_INIT_IDX(attr_idx));
               IR_LIST_CNT_R(init_idx)	= 3;
            }
            else {
               NTR_IR_LIST_TBL(list_idx);
               IR_FLD_R(init_idx)	= IL_Tbl_Idx;
               IR_IDX_R(init_idx)	= list_idx;
               IR_LIST_CNT_R(init_idx)	= 3;
               IL_IDX(list_idx)		= ATD_CPNT_INIT_IDX(attr_idx);
               IL_FLD(list_idx)		= (fld_type) ATD_FLD(attr_idx);
               IL_LINE_NUM(list_idx)	= AT_DEF_LINE(attr_idx);
               IL_COL_NUM(list_idx)	= AT_DEF_COLUMN(attr_idx);
       
               NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));

               IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;

               list_idx			= IL_NEXT_LIST_IDX(list_idx);
               IL_FLD(list_idx)		= CN_Tbl_Idx;
               IL_IDX(list_idx)		= CN_INTEGER_ONE_IDX;
               IL_LINE_NUM(list_idx)	= AT_DEF_LINE(attr_idx);
               IL_COL_NUM(list_idx)	= AT_DEF_COLUMN(attr_idx);

               NTR_IR_LIST_TBL(IL_NEXT_LIST_IDX(list_idx));

               IL_PREV_LIST_IDX(IL_NEXT_LIST_IDX(list_idx)) = list_idx;

               list_idx			= IL_NEXT_LIST_IDX(list_idx);
               IL_FLD(list_idx)		= CN_Tbl_Idx;
               IL_IDX(list_idx)		= CN_INTEGER_ZERO_IDX;
               IL_LINE_NUM(list_idx)	= AT_DEF_LINE(attr_idx);
               IL_COL_NUM(list_idx)	= AT_DEF_COLUMN(attr_idx);
            }

            gen_sh(After,
                   Type_Init_Stmt,
                   AT_DEF_LINE(attr_idx),
                   AT_DEF_COLUMN(attr_idx),
                   FALSE,
                   FALSE,
                   TRUE);
         }

         SH_P2_SKIP_ME(curr_stmt_sh_idx) = TRUE;
         SH_IR_IDX(curr_stmt_sh_idx)	 = init_idx;
      }
      else if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Structure           &&
               ATT_DEFAULT_INITIALIZED(TYP_IDX(ATD_TYPE_IDX(attr_idx)))) {

         NTR_IR_TBL(ir_idx);
         IR_OPR(ir_idx)		= Struct_Opr;
         IR_TYPE_IDX(ir_idx)	= ATD_TYPE_IDX(attr_idx);
         IR_LINE_NUM(ir_idx)	= AT_DEF_LINE(attr_idx);
         IR_COL_NUM(ir_idx)	= AT_DEF_COLUMN(attr_idx);

         COPY_OPND(IR_OPND_L(ir_idx), (*left_opnd));

         IR_FLD_R(ir_idx)	= AT_Tbl_Idx;
         IR_IDX_R(ir_idx)	= attr_idx;
         IR_LINE_NUM_R(ir_idx)	= AT_DEF_LINE(attr_idx);
         IR_COL_NUM_R(ir_idx)	= AT_DEF_COLUMN(attr_idx);
         OPND_FLD(opnd)		= IR_Tbl_Idx;
         OPND_IDX(opnd)		= ir_idx;

         if (IR_FLD_L(ir_idx) == IR_Tbl_Idx) {
             IR_RANK(ir_idx)	= IR_RANK(IR_IDX_L(ir_idx));
         }

         if (ATD_ARRAY_IDX(attr_idx) != NULL_IDX) {
            gen_whole_subscript(&opnd, &expr_desc);
         }

         process_all_initialized_cpnts(&opnd, 
                                       TYP_IDX(ATD_TYPE_IDX(attr_idx)),
                                       operator);

      }

      sn_idx = SN_SIBLING_LINK(sn_idx);
   }

   TRACE (Func_Exit, "process_all_initialized_cpnts", NULL);

   return;

}  /* process_all_initialized_cpnts */