|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2 of the GNU General Public License as 00007 published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU General Public License along 00021 with this program; if not, write the Free Software Foundation, Inc., 59 00022 Temple Place - Suite 330, Boston MA 02111-1307, USA. 00023 00024 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00025 Mountain View, CA 94043, or: 00026 00027 http://www.sgi.com 00028 00029 For further information regarding this notice, see: 00030 00031 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00032 00033 */ 00034 00035 00036 00037 /* USMID: "\n@(#)5.0_pl/sources/i_cvrt.c 5.34 10/28/99 10:03:56\n" */ 00038 00039 # include "defines.h" /* Machine dependent ifdefs */ 00040 00041 # include "host.m" /* Host machine dependent macros.*/ 00042 # include "host.h" /* Host machine dependent header.*/ 00043 # include "target.m" /* Target machine dependent macros.*/ 00044 # include "target.h" /* Target machine dependent header.*/ 00045 00046 # include "globals.m" 00047 # include "tokens.m" 00048 # include "sytb.m" 00049 # include "debug.m" 00050 # include "s_globals.m" 00051 # include "i_cvrt.m" 00052 00053 # include "globals.h" 00054 # include "tokens.h" 00055 # include "sytb.h" 00056 # include "p_globals.h" 00057 # include "s_globals.h" 00058 # include "i_cvrt.h" 00059 00060 00061 /*****************************************************************\ 00062 |* Function prototypes of static functions declared in this file *| 00063 \*****************************************************************/ 00064 00065 static void allocate_pdg_link_tbls(void); 00066 static void clean_pdg_link_tbls_for_nested_pu(void); 00067 static void cvrt_exp_to_pdg(int, fld_type); 00068 static void cvrt_ir_to_pdg(int); 00069 static void cvrt_proc_to_pdg(char *,boolean); 00070 static void cvrt_sytb_to_pdg(void); 00071 static void finish_symbolic_expr(void); 00072 static TYPE get_basic_type(int, int, int); 00073 static TYPE get_type_desc(int); 00074 static void send_attr_ntry(int); 00075 static void send_darg_list(int, int); 00076 static TYPE send_derived_type(int,int); 00077 static void send_dummy_procedure(int); 00078 static void send_label(int); 00079 static void send_label_def(int); 00080 static void send_mod_file_name(void); 00081 static void send_namelist_group(int,int); 00082 static void send_interface_list(int); 00083 static TYPE send_non_standard_aligned_type(int, int); 00084 static void send_procedure(int, int, int); 00085 static void send_stor_blk(int, int *); 00086 00087 /*****************************************************************\ 00088 |* Static data used in this module. *| 00089 \*****************************************************************/ 00090 00091 static pdg_type_tbl_type *RESTRICT pdg_type_tbl; 00092 00093 static int data_value_idx; 00094 static int global_attr_idx; 00095 static int blank_pad_text; 00096 static int data_attr; 00097 static int data_character_bit_length; 00098 static boolean stack_data_object; 00099 static boolean whole_subscript; 00100 static boolean whole_substring; 00101 static boolean stack_data_constant; 00102 static boolean symbolic_constant_expr; 00103 static int processing_call; 00104 static int user_call; 00105 static int io_ctl_list; 00106 static int is_subscript; 00107 static int nested_array = 0 ; 00108 static int curr_sh; 00109 static int io_type; 00110 static int case_cmic_vpr_idx; 00111 static int guard_cmic_vpr_idx; 00112 static int doparallel_cmic_vpr_idx; 00113 static int parallel_cmic_vpr_idx; 00114 static boolean processing_io_stmt; 00115 static TYPE null_type; 00116 static TYPE pdg_type_void; 00117 static int pdg_type_tbl_idx; 00118 static int pdg_type_tbl_inc; 00119 static int pdg_type_tbl_init_size; 00120 static int pdg_type_tbl_limit = (1 << 16) - 1; 00121 static int pdg_type_tbl_num_wds = HOST_BYTES_TO_WORDS( 00122 (sizeof(pdg_type_tbl_type))); 00123 static int pdg_type_tbl_size; 00124 static int pdg_type_tbl_largest_idx; 00125 00126 static int pdg_basic_type[Num_Basic_Types] = { 00127 Integral, 00128 L_ogical, 00129 Floating_Pt, 00130 C_omplex, 00131 CRI_Pointer, 00132 BT_func_ptr, 00133 CRI_Pointer_Char, 00134 T_ypeless, 00135 Char_Fortran, 00136 S_tructure}; 00137 00138 static char *p_proc[] = { 00139 "Unknown_Proc", 00140 "Extern_Proc", 00141 "Intern_Proc_Ref", 00142 "Dummy_Proc", 00143 "Intern_Proc", 00144 "Imported_Proc", 00145 "Module_Proc", 00146 "Intrin_src_Proc"}; 00147 00148 static char *p_obj_sym_class[] = { 00149 "Unknown_Sym", 00150 "User_Variable", 00151 "Dummy_Arg", 00152 "Function_Rslt", 00153 "Compiler_Temp", 00154 "Cray_Pointee", 00155 "Component", 00156 "Vector_Temp", 00157 "Vector_Maskk", 00158 "Vector_Iota", 00159 "MPP_Object", 00160 "Call_Dummy", 00161 "Dummy_Procedure", 00162 "Hosted_User_Variable", 00163 "Hosted_Dummy_Arg", 00164 "Scratch_Symbol", 00165 "Hosted_Dummy_Procedure", 00166 "Hosted_Compiler_Temp", 00167 "Name" }; 00168 00169 static char *p_return[] = { 00170 "Unknown_Return", 00171 "Normal_Return", 00172 "Void_Return", 00173 "Alternate_Return" }; 00174 00175 static char *p_atp_pgm_unit[] = { 00176 "Pgm_Unknown", 00177 "C Function", 00178 "ERROR", 00179 "Function", 00180 "Subroutine", 00181 "Program", 00182 "Blockdata", 00183 "Module" }; 00184 00185 static char *p_boolean[] = { 00186 "F", 00187 "T"}; 00188 00189 static char *p_label[] = { 00190 "Lbl_Unknown", 00191 "Lbl_User", 00192 "Lbl_Format", 00193 "Lbl_Internal", 00194 "Lbl_Debug", 00195 "Lbl_Cstrct" }; 00196 00197 static char *p_dbg_label[] = { 00198 "Ldbg_None", 00199 "Ldbg_Stmt_Lbl", 00200 "Ldbg_Exit_Point", 00201 "Ldbg_End_Prologue", 00202 "Ldbg_Start_Epilogue", 00203 "Ldbg_Construct_Name", 00204 "Ldbg_Loop_Lbl", 00205 "Ldbg_User_Lbl" }; 00206 00207 static char *p_intent[] = { 00208 "Intent_Unseen", 00209 "Intent_In", 00210 "Intent_Out", 00211 "Intent_Inout" }; 00212 00213 static char *p_io[] = { 00214 "Write", 00215 "Read", 00216 "Write_Namelist", 00217 "Read_Namelist" }; 00218 00219 static char *p_sequence[] = { 00220 "Unknown_Seq", 00221 "Unsequenced", 00222 "Numeric_Seq", 00223 "Char_Seq", 00224 "Mixed_Seq" }; 00225 00226 static char *p_sb_blk_type_str[] = { 00227 "Unknown", 00228 "Static", 00229 "Stack", 00230 "Formal", 00231 "Common", 00232 "Extern", 00233 "Exported", 00234 "Task_Common", 00235 "Soft_External", 00236 "Global_Breg", 00237 "Global_Treg", 00238 "Static_Named", 00239 "Based", 00240 "Equivalenced", 00241 "Restricted", 00242 "Distributed", 00243 "LM_Static", 00244 "LM_Common", 00245 "LM_Extern", 00246 "Auxiliary", 00247 "Static_Local", 00248 "Non_Local_Stack", 00249 "Non_Local_Formal", 00250 "Hosted_Stack", 00251 "Threadprivate", 00252 "Coment" }; 00253 00254 static char *p_table_type[] = { 00255 "Unknown", 00256 "Basic", 00257 "Pointer", 00258 "Array", 00259 "Function" }; 00260 00261 static char *p_distribution[] = { 00262 "No_Distribution", 00263 "Block_Distribution", 00264 "Cyclic_Distribution", 00265 "Star_Distribution" }; 00266 00267 static char *p_basic_type[] = { 00268 "Unknown", 00269 "Logical", 00270 "Typeless", 00271 "Void", 00272 "Char_Fortran", 00273 "Char_C", 00274 "Struct", 00275 "Union", 00276 "Integral", 00277 "Floating_Pt", 00278 "Complex", 00279 "Cray_Pointer", 00280 "Cray_Pointer_Ch", 00281 "Cray_Parcel" }; 00282 00283 static char *p_const_class[] = { 00284 "No_Const", 00285 "Arith_Const", 00286 "Addr_Const", 00287 "Pattern_Const", 00288 "Array_Const", 00289 "Struct_Const", 00290 "Null_Arg_Const" }; 00291 00292 static char *p_tasking_context[] = { 00293 "Context_None", 00294 "Context_Private", 00295 "Context_Shared", 00296 "Context_Value", 00297 "Context_Iterate", 00298 "Context_Getfirst", 00299 "Context_Control", 00300 "Context_Induction", 00301 "Context_PE_Res_Func", 00302 "Context_PE_Res_Loop", 00303 "Context_Lastlocal", 00304 "Context_Affinity", 00305 "Context_Nest", 00306 "Context_Lastthread", 00307 "Context_Omp_Reduction_Max", 00308 "Context_Omp_Reduction_Min", 00309 "Context_Omp_Reduction_Band", 00310 "Context_Omp_Reduction_Bor", 00311 "Context_Omp_Reduction_Bneqv", 00312 "Context_Omp_Reduction_Plus", 00313 "Context_Omp_Reduction_Mult", 00314 "Context_Omp_Reduction_Minus", 00315 "Context_Omp_Reduction_And", 00316 "Context_Omp_Reduction_Or", 00317 "Context_Omp_Reduction_Eqv", 00318 "Context_Omp_Reduction_Neqv", 00319 "Context_Omp_Private", 00320 "Context_Omp_Shared", 00321 "Context_Omp_Firstprivate", 00322 "Context_Omp_Lastprivate", 00323 "Context_Omp_Copyprivate", 00324 "Context_Omp_Copyin", 00325 "Context_Omp_Affinity", 00326 "Context_Omp_Nest", 00327 "Context_Omp_Flush", 00328 00329 /* eraxxon: OpenAD directive */ 00330 "Context_OpenAD_XXX", 00331 "Context_OpenAD_Dependent", 00332 "Context_OpenAD_Independent", 00333 "Context_OpenAD_Simple" 00334 }; 00335 00336 int pdg_align[8] = {0, /* Signifies no alignment */ 00337 Bit_Align, 00338 Byte_Align, 00339 Parcel_Align, 00340 HWord_Align, 00341 Word_Align, 00342 DWord_Align, 00343 FWord_Align 00344 }; 00345 00346 00347 /******************************************************************************\ 00348 |* *| 00349 |* Description: *| 00350 |* Perform blank padding for a user implied DO. *| 00351 |* *| 00352 |* Input parameters: *| 00353 |* NONE *| 00354 |* *| 00355 |* Output parameters: *| 00356 |* NONE *| 00357 |* *| 00358 |* Returns: *| 00359 |* NOTHING *| 00360 |* *| 00361 \******************************************************************************/ 00362 void blank_padding (long64 pad, 00363 long64 offset) 00364 00365 { 00366 # if defined(_HOST_LITTLE_ENDIAN) 00367 long a_blank = (long)' '; 00368 #else 00369 long a_blank = (long)' ' << (sizeof(long)*CHAR_BIT - CHAR_BIT); 00370 # endif 00371 TYPE basic; 00372 00373 00374 TRACE (Func_Entry, "blank_padding", NULL); 00375 00376 /* stack a blank */ 00377 00378 basic = get_basic_type(Character_1, Align_Bit, NULL_IDX); 00379 00380 PDG_DBG_PRINT_START 00381 PDG_DBG_PRINT_C("fei_constant"); 00382 PDG_DBG_PRINT_T("(1) type", basic); 00383 PDG_DBG_PRINT_S("(2) const class", p_const_class[Pattern_Const]); 00384 PDG_DBG_PRINT_LD("(3) const", a_blank); 00385 PDG_DBG_PRINT_D("(4) bit length", CHAR_BIT); 00386 PDG_DBG_PRINT_END 00387 00388 # ifdef _ENABLE_FEI 00389 fei_constant(basic, Pattern_Const, (char *) &a_blank, (long64) CHAR_BIT); 00390 # endif 00391 00392 PDG_DBG_PRINT_START 00393 PDG_DBG_PRINT_C("fei_static_next_simple_init"); 00394 PDG_DBG_PRINT_D("(1) CHAR_BIT", CHAR_BIT); 00395 PDG_DBG_PRINT_LLD("(2) pad", pad); 00396 PDG_DBG_PRINT_LLD("(3) offset", offset); 00397 PDG_DBG_PRINT_D("(4) unused", 0); 00398 PDG_DBG_PRINT_END 00399 00400 # ifdef _ENABLE_FEI 00401 fei_static_next_simple_init((long64) CHAR_BIT, 00402 pad, 00403 offset, 00404 0); 00405 # endif 00406 00407 TRACE (Func_Exit, "blank_padding", NULL); 00408 00409 return; 00410 } /* blank_padding */ 00411 00412 00413 00414 00415 00416 /******************************************************************************\ 00417 |* *| 00418 |* Description: *| 00419 |* Start up the interface. *| 00420 |* *| 00421 |* Input parameters: *| 00422 |* none *| 00423 |* *| 00424 |* Output parameters: *| 00425 |* none *| 00426 |* *| 00427 |* Returns: nothing *| 00428 |* *| 00429 \******************************************************************************/ 00430 00431 void init_PDGCS(void) 00432 00433 { 00434 char *code_file_name; 00435 char compiler_name[8]; 00436 long flags = 0; 00437 char path_name[MAX_FILE_NAME_SIZE]; 00438 extern char release_level[8]; 00439 extern char *command_name; 00440 00441 TRACE (Func_Entry, "init_PDGCS", NULL); 00442 00443 if (dump_flags.preinline) { 00444 code_file_name = NULL; 00445 } 00446 else if (binary_output) { 00447 code_file_name = bin_file; 00448 } 00449 else if (assembly_output) { 00450 code_file_name = assembly_file; 00451 } 00452 else { 00453 return; /* No binary or cal output - exit */ 00454 } 00455 00456 /* Need to open the debug file if dumping the PDGCS interface calls. */ 00457 if (dump_flags.pdgcs) { 00458 init_debug_file(); 00459 } 00460 00461 getcwd (path_name, MAX_FILE_NAME_SIZE); 00462 00463 compiler_name[0] = 'C'; 00464 compiler_name[1] = 'F'; 00465 compiler_name[2] = 'T'; 00466 compiler_name[3] = '9'; 00467 compiler_name[4] = '0'; 00468 compiler_name[5] = NULL_CHAR; 00469 00470 00471 flags = flags | 00472 ((long) cmd_line_flags.dalign << PDGCS_INITIALIZE_DOUBLE_ALIGN)| 00473 ((long) assembly_output << PDGCS_INITIALIZE_OBJ_FILE)| 00474 ((long) (cmd_line_flags.debug_lvl == Debug_Lvl_1) 00475 << PDGCS_INITIALIZE_PART_DEBUG)| 00476 ((long) (cmd_line_flags.debug_lvl == Debug_Lvl_2) 00477 << PDGCS_INITIALIZE_OPT_DEBUG)| 00478 ((long) on_off_flags.atexpert << PDGCS_INITIALIZE_ATEXPERT)| 00479 ((long) on_off_flags.upper_case_names << PDGCS_INITIALIZE_KERNEL)| 00480 ((long) (cmd_line_flags.debug_lvl <= Debug_Lvl_2) 00481 << PDGCS_INITIALIZE_DBG_TABLES)| 00482 ((long) (!on_off_flags.round_mult_operations) 00483 << PDGCS_INITIALIZE_TRUNCATE)| 00484 (!((cif_flags & MESSAGE_RECS) || opt_flags.msgs) 00485 << PDGCS_INITIALIZE_NO_OPT_MSGS)| 00486 ((long) (cmd_line_flags.solaris_profile || on_off_flags.flowtrace_option) 00487 << PDGCS_INITIALIZE_FLOWTRACE)| 00488 ((long) (opt_flags.unroll_lvl == Unroll_Lvl_2) 00489 << PDGCS_INITIALIZE_MEM_HIER_OPT)| 00490 ((long) cmd_line_flags.small_pic_model << PDGCS_INITIALIZE_SMALL_PIC)| 00491 ((long) cmd_line_flags.large_pic_model << PDGCS_INITIALIZE_BIG_PIC)| 00492 (!opt_flags.neg_msgs << PDGCS_INITIALIZE_NO_NEG_MSGS)| 00493 ((long) dump_flags.mp << PDGCS_INITIALIZE_MP)| 00494 ((long) on_off_flags.MPP_apprentice << PDGCS_INITIALIZE_APPRENTICE)| 00495 ((long) on_off_flags.shared_to_private_coer<< PDGCS_INITIALIZE_S2P_COERCE)| 00496 ((long) opt_flags.jump << PDGCS_INITIALIZE_CCG_JUMPS)| 00497 ((long) opt_flags.opt_info << PDGCS_INITIALIZE_OPT_INFO)| 00498 ((long) on_off_flags.integer_1_and_2 << PDGCS_INITIALIZE_INTEGER_1_2)| 00499 (((long) opt_flags.split_lvl == Split_Lvl_2) 00500 << PDGCS_INITIALIZE_STREAMSPLIT); 00501 00502 PDG_DBG_PRINT_START 00503 PDG_DBG_PRINT_C("PDGCS_initialize"); 00504 PDG_DBG_PRINT_S("compiler_name", compiler_name); 00505 PDG_DBG_PRINT_S("(1) language", "PDGCS_Fortran_90"); 00506 PDG_DBG_PRINT_LO("(2) flags", flags); 00507 PDG_DBG_PRINT_S("(3) command_name", command_name); 00508 PDG_DBG_PRINT_S("(4) release_level", release_level); 00509 PDG_DBG_PRINT_S("(5) code_file_name", code_file_name); 00510 PDG_DBG_PRINT_S("(6) list_file_name", (char *) &assembly_listing_file); 00511 PDG_DBG_PRINT_D("(7) trunc bits", cmd_line_flags.truncate_bits); 00512 PDG_DBG_PRINT_LD("(8) CCG flags", ccg_dump_flags); 00513 PDG_DBG_PRINT_S("(9) src_path_name", get_src_path_name()); 00514 PDG_DBG_PRINT_S("(10) cif_file_name", (char *) &cif_name); 00515 PDG_DBG_PRINT_S("(11) debug_file_name", (char *) &debug_file_name); 00516 PDG_DBG_PRINT_LD("(12) debug file ptr", (long) debug_file); 00517 PDG_DBG_PRINT_LD("(13) cif file ptr", (long) cif_actual_file); 00518 PDG_DBG_PRINT_S("(14) GL_FILE_NAME", GL_FILE_NAME_PTR(1)); 00519 PDG_DBG_PRINT_S("(15) path name", path_name); 00520 PDG_DBG_PRINT_D("(16) N$PE", cmd_line_flags.MPP_num_pes); 00521 PDG_DBG_PRINT_D("(17) meta test", dump_flags.pvp_test); 00522 PDG_DBG_PRINT_END 00523 00524 # ifdef _ENABLE_FEI 00525 PDGCS_initialize(Fortran_90, 00526 flags, 00527 command_name, 00528 release_level, 00529 code_file_name, 00530 (char *)&assembly_listing_file, 00531 cmd_line_flags.truncate_bits, 00532 ccg_dump_flags, 00533 get_src_path_name(), 00534 (char *)&cif_name, 00535 (char *)&debug_file_name, 00536 debug_file, 00537 cif_actual_file, 00538 GL_FILE_NAME_PTR(1), 00539 path_name, 00540 cmd_line_flags.MPP_num_pes, 00541 dump_flags.pvp_test); 00542 # endif 00543 00544 00545 TRACE (Func_Exit, "init_PDGCS", NULL); 00546 00547 return; 00548 00549 } /* init_PDGCS */ 00550 00551 00552 00553 00554 /******************************************************************************\ 00555 |* *| 00556 |* Description: *| 00557 |* This does initialization, calls the routines to pass the symbol *| 00558 |* and the IR to PDG. It then does cleanup. This routine should *| 00559 |* handle internal program units. (Whichever way it's decided). *| 00560 |* *| 00561 |* Input parameters: *| 00562 |* NONE *| 00563 |* *| 00564 |* Output parameters: *| 00565 |* NONE *| 00566 |* *| 00567 |* Returns: *| 00568 |* NOTHING *| 00569 |* *| 00570 \******************************************************************************/ 00571 void cvrt_to_pdg (char *compiler_gen_date) 00572 00573 { 00574 int align; 00575 int i; 00576 int bit_size; 00577 int flags; 00578 00579 # if defined(_TARGET_OS_MAX) || defined(_TARGET_OS_UNICOS) 00580 int child_idx; 00581 # endif 00582 00583 00584 TRACE (Func_Entry, "cvrt_to_pdg", NULL); 00585 00586 /* This drives the PDGCS interface for a program unit. It is called once */ 00587 /* for each BLOCKDATA, PROGRAM, SUBROUTINE, MODULE, external SUBROUTINE or */ 00588 /* external FUNCTION. */ 00589 00590 /* Initialize variables and tables here. */ 00591 00592 case_cmic_vpr_idx = NULL_IDX; 00593 guard_cmic_vpr_idx = NULL_IDX; 00594 00595 init_directive(3); 00596 00597 for (i = 1; i <= global_line_tbl_idx; i++) { 00598 PDG_DBG_PRINT_START 00599 PDG_DBG_PRINT_C("cwh_add_to_used_files_table"); 00600 PDG_DBG_PRINT_S("(1) path", GL_FILE_NAME_PTR(i)); 00601 PDG_DBG_PRINT_D("(2) one", 1); 00602 PDG_DBG_PRINT_END 00603 00604 # if defined(GENERATE_WHIRL) 00605 cwh_add_to_used_files_table(GL_FILE_NAME_PTR(i), 1); 00606 # endif 00607 } 00608 00609 PDG_DBG_PRINT_START 00610 PDG_DBG_PRINT_C("fei_descriptor"); 00611 PDG_DBG_PRINT_O("(1) flags", 0); 00612 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 00613 PDG_DBG_PRINT_D("(3) bit_size", 0); 00614 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[V_oid]); 00615 PDG_DBG_PRINT_D("(5) aux info", 0); 00616 PDG_DBG_PRINT_D("(6) alignment", 0); 00617 PDG_DBG_PRINT_END 00618 # ifdef _ENABLE_FEI 00619 pdg_type_void = fei_descriptor(0, 00620 Basic, 00621 0, 00622 V_oid, 00623 0, 00624 0); 00625 # endif 00626 PDG_DBG_PRINT_START 00627 PDG_DBG_PRINT_T("(r) type", pdg_type_void); 00628 PDG_DBG_PRINT_END 00629 00630 pgm_unit_start_line = SH_GLB_LINE(SCP_FIRST_SH_IDX(curr_scp_idx)); 00631 00632 # if defined(_TARGET_OS_MAX) || defined(_TARGET_OS_UNICOS) 00633 00634 /* On Cray systems, */ 00635 /* Modules must go thru first, because MODULE PDT's must be first. Clear */ 00636 /* SCP_FIRST_CHILD_IDX for the module, so its children do not get sent */ 00637 /* thru. (cvrt_proc_to_pdg finds the innermost child and sends it first.) */ 00638 /* After the module is sent thru, send all its children via the normal */ 00639 /* order. Then when that's thru send the module information table. */ 00640 00641 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) == Module ) { 00642 00643 00644 child_idx = SCP_FIRST_CHILD_IDX(curr_scp_idx); 00645 SCP_FIRST_CHILD_IDX(curr_scp_idx) = NULL_IDX; 00646 00647 cvrt_proc_to_pdg(compiler_gen_date,FALSE); 00648 00649 if (child_idx != NULL_IDX) { 00650 curr_scp_idx = child_idx; 00651 cvrt_proc_to_pdg(compiler_gen_date,TRUE); 00652 } 00653 00654 curr_scp_idx = MAIN_SCP_IDX; 00655 00656 if (on_off_flags.module_to_mod) { 00657 send_mod_file_name(); /* Sends the file name */ 00658 create_mod_info_tbl(); /* Creates the table. */ 00659 output_mod_info_file(); /* Writes the table. */ 00660 } 00661 else { /* Cray and MPP go out in a special &%% module because of segldr.*/ 00662 send_mod_file_name(); 00663 } 00664 free_tables(); 00665 } 00666 else { 00667 cvrt_proc_to_pdg(compiler_gen_date,FALSE); 00668 } 00669 00670 # else 00671 cvrt_proc_to_pdg(compiler_gen_date,FALSE); 00672 # endif 00673 00674 TBL_FREE(pdg_link_tbl); 00675 TBL_FREE(pdg_type_tbl); 00676 00677 TRACE (Func_Exit, "cvrt_to_pdg", NULL); 00678 00679 return; 00680 00681 } /* cvrt_to_pdg */ 00682 00683 00684 00685 /******************************************************************************\ 00686 |* *| 00687 |* Description: *| 00688 |* This does initialization, calls the routines to pass the symbol *| 00689 |* and the IR to PDG. It then does cleanup. *| 00690 |* *| 00691 |* Input parameters: *| 00692 |* NONE *| 00693 |* *| 00694 |* Output parameters: *| 00695 |* NONE *| 00696 |* *| 00697 |* Returns: *| 00698 |* NOTHING *| 00699 |* *| 00700 \******************************************************************************/ 00701 static void cvrt_proc_to_pdg (char *compiler_gen_date,boolean is_child) 00702 00703 { 00704 boolean check_scp = TRUE; 00705 int ismodule = 0; 00706 int mobes_sades; 00707 char *name_ptr; 00708 long opt_flag; 00709 int pgm_attr_idx; 00710 int pgm_code = 0; 00711 int pgm_data = 0; 00712 int save_curr_scp_idx; 00713 int w2f_types=0; 00714 00715 extern void dim_reshape_pass_driver(void); 00716 extern void runtime_ptr_chk_driver(void); 00717 00718 TRACE (Func_Entry, "cvrt_proc_to_pdg", NULL); 00719 00720 PROCESS_SIBLING: 00721 00722 /* The innermost children go thru the interface first. The external */ 00723 /* procedure goes thru last. */ 00724 00725 00726 /* since in *.w2f.f we add an extra module "w2f__types" 00727 * to fix real kind problems,we don't want to generate 00728 * a PU in WHIRL representation,so if the PU is a module 00729 * named "w2f__types" then igore it in cvrt-to-PDG processing 00730 * ---------fzhao 00731 */ 00732 00733 pgm_attr_idx = SCP_ATTR_IDX(curr_scp_idx); 00734 name_ptr = &name_pool[ATP_EXT_NAME_IDX(pgm_attr_idx)].name_char; 00735 00736 if (ATP_PGM_UNIT(pgm_attr_idx)==Module && 00737 strncmp("w2f__types",name_ptr,10)==0){ 00738 w2f_types =1; 00739 goto HERE1; 00740 } 00741 00742 if (!is_child ) /* do not re-allocate the table for nested PUs--FMZ */ 00743 allocate_pdg_link_tbls(); 00744 00745 if (SCP_FIRST_CHILD_IDX(curr_scp_idx) != NULL_IDX) { 00746 save_curr_scp_idx = curr_scp_idx; 00747 curr_scp_idx = SCP_FIRST_CHILD_IDX(curr_scp_idx); 00748 cvrt_proc_to_pdg(compiler_gen_date ,TRUE); 00749 curr_scp_idx = save_curr_scp_idx; 00750 } 00751 00752 if (opt_flags.reshape) { 00753 dim_reshape_pass_driver(); 00754 } 00755 00756 if (cmd_line_flags.runtime_ptr_chk) { 00757 runtime_ptr_chk_driver(); 00758 } 00759 00760 clean_pdg_link_tbls_for_nested_pu(); 00761 00762 /* 00763 allocate_pdg_link_tbls(); 00764 */ 00765 00766 /* pgm_attr_idx = SCP_ATTR_IDX(curr_scp_idx); */ 00767 00768 ATP_SCP_ALIVE(pgm_attr_idx) = TRUE; 00769 stmt_start_line = SH_GLB_LINE(SCP_FIRST_SH_IDX(curr_scp_idx)); 00770 stmt_start_col = 0; 00771 00772 cvrt_sytb_to_pdg(); 00773 00774 /* name_ptr = &name_pool[ATP_EXT_NAME_IDX(pgm_attr_idx)].name_char; */ 00775 00776 PDG_DBG_PRINT_START 00777 PDG_DBG_PRINT_C("PDGCS_comp_unit"); 00778 PDG_DBG_PRINT_S("(1) name_ptr", name_ptr); 00779 PDG_DBG_PRINT_D("(2) unused", 0); 00780 PDG_DBG_PRINT_END 00781 00782 # ifdef _ENABLE_FEI 00783 PDGCS_comp_unit(name_ptr, NULL_IDX); 00784 # endif 00785 00786 opt_flag = 00787 ((long) opt_flags.aggress << PDGCS_NEW_PROC_IGNORE_THROTTLE)| 00788 ((long) (cmd_line_flags.debug_lvl != Debug_Lvl_0) 00789 << PDGCS_NEW_PROC_ELIM_DEAD_CODE)| 00790 ((long) opt_flags.pattern << PDGCS_NEW_PROC_PATTERN_MATCHING)| 00791 ((long) on_off_flags.reciprical_divide << PDGCS_NEW_PROC_IEEE_RECIPS)| 00792 ((long) (opt_flags.task_lvl == Task_Lvl_3) 00793 << PDGCS_NEW_PROC_TASK_INNER_LOOPS)| 00794 ((long) cmd_line_flags.runtime_conformance << PDGCS_NEW_PROC_CONFORM_CHECK)| 00795 ((long) opt_flags.ieeeconform << PDGCS_NEW_PROC_IEEE_CONFORM)| 00796 ((long) cmd_line_flags.do_UDB_checks << PDGCS_NEW_PROC_DO_UBD_ANALYSIS); 00797 00798 send_attr_ntry(pgm_attr_idx); 00799 00800 mobes_sades = ATP_USES_EREGS(pgm_attr_idx) ? 512 : 0; 00801 00802 PDG_DBG_PRINT_START 00803 PDG_DBG_PRINT_C("PDGCS_new_proc"); 00804 PDG_DBG_PRINT_D("(1) num ir", 2000); 00805 PDG_DBG_PRINT_LD("(2) PDG_AT_IDX", PDG_AT_IDX(pgm_attr_idx)); 00806 PDG_DBG_PRINT_D("(3) alt entries", SCP_ALT_ENTRY_CNT(curr_scp_idx)); 00807 PDG_DBG_PRINT_D("(4) scalar level", opt_flags.scalar_lvl); 00808 PDG_DBG_PRINT_D("(5) vector level", opt_flags.vector_lvl); 00809 PDG_DBG_PRINT_D("(6) task level", opt_flags.task_lvl); 00810 PDG_DBG_PRINT_LO("(7) flags", opt_flag); 00811 PDG_DBG_PRINT_D("(8) user mobes", mobes_sades); 00812 PDG_DBG_PRINT_D("(9) user sades", mobes_sades); 00813 PDG_DBG_PRINT_D("(10) pipeline level", opt_flags.pipeline_lvl); 00814 PDG_DBG_PRINT_D("(11) stream level", opt_flags.stream_lvl); 00815 PDG_DBG_PRINT_END 00816 00817 00818 # ifdef _ENABLE_FEI 00819 if (ATP_PGM_UNIT(pgm_attr_idx)==Module) 00820 ismodule=1; 00821 if (ATP_PGM_UNIT(pgm_attr_idx)==Blockdata) 00822 ismodule=2; 00823 PDGCS_new_proc(2000, 00824 PDG_AT_IDX(pgm_attr_idx), 00825 SCP_ALT_ENTRY_CNT(curr_scp_idx), 00826 opt_flags.scalar_lvl, 00827 opt_flags.vector_lvl, 00828 opt_flags.task_lvl, 00829 opt_flag, 00830 mobes_sades, 00831 mobes_sades, 00832 opt_flags.pipeline_lvl, 00833 opt_flags.stream_lvl, 00834 ismodule); 00835 # endif 00836 00837 cvrt_ir_to_pdg(curr_scp_idx); 00838 00839 ATP_SCP_ALIVE(pgm_attr_idx) = FALSE; 00840 00841 if (cmd_line_flags.debug_lvl <= Debug_Lvl_2) { 00842 PDG_DBG_PRINT_START 00843 PDG_DBG_PRINT_C("PDGCS_debug_init"); 00844 PDG_DBG_PRINT_S("(1) src path name", get_src_path_name()); 00845 PDG_DBG_PRINT_S("(2) gen date", compiler_gen_date); 00846 PDG_DBG_PRINT_END 00847 00848 # ifdef _ENABLE_FEI 00849 PDGCS_debug_init(get_src_path_name(), 00850 compiler_gen_date); 00851 # endif 00852 } 00853 00854 PDG_DBG_PRINT_START 00855 # ifdef _DEBUG 00856 fflush(debug_file); 00857 # endif 00858 PDG_DBG_PRINT_END 00859 00860 /* 00861 If this is the outermost parent scope and this is not a module, 00862 free all the tables. 00863 */ 00864 00865 if (curr_scp_idx == MAIN_SCP_IDX && 00866 (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) != Module )) { /* ???? */ 00867 free_tables(); 00868 check_scp = FALSE; /* Tables are gone */ 00869 } 00870 00871 HERE1: 00872 # if !defined(_TARGET_OS_MAX) && !defined(_TARGET_OS_UNICOS) 00873 if (curr_scp_idx == MAIN_SCP_IDX && 00874 ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) == Module) { 00875 00876 /* Cray and MPP go out in a special &%% module because of segldr. */ 00877 if (!w2f_types) 00878 send_mod_file_name(); /* Sends the file name */ 00879 create_mod_info_tbl(); /* Creates the table. */ 00880 output_mod_info_file(); /* Writes the table. */ 00881 free_tables(); 00882 check_scp = FALSE; /* Tables are gone */ 00883 } 00884 # endif 00885 00886 if (w2f_types) 00887 goto HERE; 00888 00889 PDG_DBG_PRINT_START 00890 PDG_DBG_PRINT_C("PDGCS_do_proc"); 00891 PDG_DBG_PRINT_END 00892 00893 # ifdef _ENABLE_FEI 00894 PDGCS_do_proc(); /* Start up the backend */ 00895 # endif 00896 00897 PDG_DBG_PRINT_START 00898 PDG_DBG_PRINT_C("PDGCS_end_procs"); 00899 PDG_DBG_PRINT_D("(1) pgm_code", pgm_code); 00900 PDG_DBG_PRINT_D("(2) pgm_data", pgm_data); 00901 PDG_DBG_PRINT_END 00902 00903 # ifdef _ENABLE_FEI 00904 PDGCS_end_procs(&pgm_code, 00905 &pgm_data); 00906 # endif 00907 00908 PDG_DBG_PRINT_START 00909 PDG_DBG_PRINT_D("(r) pgm_code", pgm_code); 00910 PDG_DBG_PRINT_D("(r) pgm_data", pgm_data); 00911 PDG_DBG_PRINT_END 00912 00913 00914 00915 code_size = code_size + pgm_code; 00916 data_size = data_size + pgm_data; 00917 00918 PDG_DBG_PRINT_START 00919 PDG_DBG_PRINT_C("PDGCS_end_comp_unit"); 00920 PDG_DBG_PRINT_END 00921 00922 # ifdef _ENABLE_FEI 00923 PDGCS_end_comp_unit(); 00924 # endif 00925 00926 HERE: 00927 00928 if (check_scp && SCP_SIBLING_IDX(curr_scp_idx) != NULL_IDX) { 00929 curr_scp_idx = SCP_SIBLING_IDX(curr_scp_idx); 00930 goto PROCESS_SIBLING; 00931 } 00932 00933 TRACE (Func_Exit, "cvrt_proc_to_pdg", NULL); 00934 00935 return; 00936 00937 } /* cvrt_proc_to_pdg */ 00938 00939 00940 00941 /******************************************************************************\ 00942 |* *| 00943 |* Description: *| 00944 |* Get the next data value from the constant list following a data *| 00945 |* statement. *| 00946 |* *| 00947 |* Input parameters: *| 00948 |* NONE *| 00949 |* *| 00950 |* Output parameters: *| 00951 |* NONE *| 00952 |* *| 00953 |* Returns: *| 00954 |* NOTHING *| 00955 |* *| 00956 \******************************************************************************/ 00957 void push_data_value (int t_idx) 00958 00959 { 00960 char *new_str_ptr; 00961 char *old_str_ptr; 00962 boolean ignore_types; 00963 long_type target_length; 00964 int idx; 00965 int l_idx; 00966 fld_type fld; 00967 int cn_idx; 00968 int type_idx; 00969 int new_str_idx; 00970 long64 len; 00971 long64 rep_count; 00972 long64 stride; 00973 long64 padd = 0; 00974 long64 num_chars; 00975 int i; 00976 00977 00978 TRACE (Func_Entry, "push_data_value", NULL); 00979 00980 if (IL_LIST_CNT(data_value_idx) == 0) { 00981 data_value_idx = IL_NEXT_LIST_IDX(data_value_idx); 00982 } 00983 00984 IL_LIST_CNT(data_value_idx) = IL_LIST_CNT(data_value_idx) - 1; 00985 00986 /* stack the linearizable object */ 00987 00988 data_attr = NULL_IDX; 00989 stack_data_object = TRUE; 00990 cvrt_exp_to_pdg(IL_IDX(t_idx), 00991 IL_FLD(t_idx)); 00992 stack_data_object = FALSE; 00993 00994 ignore_types = FALSE; 00995 00996 switch (IL_FLD(data_value_idx)) { 00997 00998 case CN_Tbl_Idx : 00999 idx = IL_IDX(data_value_idx); 01000 fld = IL_FLD(data_value_idx); 01001 rep_count = (long64) 1; 01002 stride = (long64) 0; 01003 cn_idx = IL_IDX(data_value_idx); 01004 01005 if (TYP_TYPE(CN_TYPE_IDX(idx)) == Typeless || 01006 (TYP_TYPE(CN_TYPE_IDX(idx)) == Character && 01007 TYP_TYPE(ATD_TYPE_IDX(data_attr)) != Character)) { 01008 ignore_types = TRUE; 01009 } 01010 break; 01011 01012 case IR_Tbl_Idx : 01013 if (IR_FLD_R(IL_IDX(data_value_idx)) == CN_Tbl_Idx) { 01014 idx = IR_IDX_R(IL_IDX(data_value_idx)); 01015 fld = IR_FLD_R(IL_IDX(data_value_idx)); 01016 rep_count = (long64) 1; 01017 stride = (long64) 0; 01018 cn_idx = IR_IDX_R(IL_IDX(data_value_idx)); 01019 01020 if (TYP_TYPE(CN_TYPE_IDX(idx)) == Typeless || 01021 (TYP_TYPE(CN_TYPE_IDX(idx)) == Character && 01022 TYP_TYPE(ATD_TYPE_IDX(data_attr)) != Character)) { 01023 ignore_types = TRUE; 01024 } 01025 } 01026 else { /* we have a Mult_Opr - blank pad here */ 01027 idx = IR_IDX_R(IR_IDX_R(IL_IDX(data_value_idx))); 01028 fld = IR_FLD_R(IR_IDX_R(IL_IDX(data_value_idx))); 01029 rep_count = CN_INT_TO_C(IR_IDX_L(IR_IDX_R(IL_IDX(data_value_idx)))); 01030 stride = (long64) CHAR_BIT; 01031 cn_idx = CN_INTEGER_ZERO_IDX; 01032 } 01033 break; 01034 } 01035 01036 01037 if ((TYP_TYPE(CN_TYPE_IDX(cn_idx)) == Character) && 01038 ((IR_OPR(blank_pad_text) == Whole_Substring_Opr) || 01039 (IR_OPR(blank_pad_text) == Substring_Opr))) { 01040 num_chars = CN_INT_TO_C(TYP_IDX(CN_TYPE_IDX(cn_idx))); 01041 l_idx = IR_IDX_R(blank_pad_text); /* first list item */ 01042 l_idx = IL_NEXT_LIST_IDX(l_idx); /* second list item */ 01043 l_idx = IL_NEXT_LIST_IDX(l_idx); /* third list item */ 01044 padd = CN_INT_TO_C(IL_IDX(l_idx)); 01045 padd = padd - num_chars; 01046 } 01047 01048 if (padd < 0) { /* need to truncate constant */ 01049 01050 /* JEFFL - Why does target_length come out of the table */ 01051 /* and go back in with no changes? */ 01052 /* Also target_len will not hold a 64 bit int */ 01053 /* on a 32 bit platform. It needs too. */ 01054 01055 target_length = CN_CONST(IL_IDX(l_idx)); 01056 CLEAR_TBL_NTRY(type_tbl, TYP_WORK_IDX); 01057 TYP_TYPE(TYP_WORK_IDX) = Character; 01058 TYP_LINEAR(TYP_WORK_IDX) = CHARACTER_DEFAULT_TYPE; 01059 TYP_CHAR_CLASS(TYP_WORK_IDX) = Const_Len_Char; 01060 TYP_FLD(TYP_WORK_IDX) = CN_Tbl_Idx; 01061 TYP_IDX(TYP_WORK_IDX) = ntr_const_tbl(CG_INTEGER_DEFAULT_TYPE, 01062 FALSE, 01063 &target_length); 01064 type_idx = ntr_type_tbl(); 01065 01066 new_str_idx = ntr_const_tbl(type_idx, TRUE, NULL); 01067 new_str_ptr = (char *) &CN_CONST(new_str_idx); 01068 old_str_ptr = (char *) &CN_CONST(idx); 01069 len = CN_INT_TO_C(TYP_IDX(type_idx)); 01070 01071 for (i = 0; i < len; i++) { 01072 new_str_ptr[i] = old_str_ptr[i]; 01073 } 01074 01075 idx = new_str_idx; 01076 } 01077 01078 /* stack the constant */ 01079 stack_data_constant = TRUE; 01080 cvrt_exp_to_pdg(idx, fld); 01081 stack_data_constant = FALSE; 01082 01083 PDG_DBG_PRINT_START 01084 PDG_DBG_PRINT_C("fei_static_simple_init"); 01085 PDG_DBG_PRINT_LLD("(1) rep_count", rep_count); 01086 PDG_DBG_PRINT_LLD("(2) stride", stride); 01087 PDG_DBG_PRINT_D("(3) ignore_types", ignore_types); 01088 PDG_DBG_PRINT_D("(4) unused", 0); 01089 PDG_DBG_PRINT_END 01090 01091 # ifdef _ENABLE_FEI 01092 fei_static_simple_init(rep_count, 01093 stride, 01094 ignore_types, 01095 0); 01096 # endif 01097 01098 if (padd > 0) { /* if blank padding necessary on a user implied DO */ 01099 blank_padding(padd, (long64) (num_chars * CHAR_BIT)); 01100 } 01101 01102 TRACE (Func_Exit, "push_data_value", NULL); 01103 01104 return; 01105 01106 } /* push_data_value */ 01107 01108 01109 /******************************************************************************\ 01110 |* *| 01111 |* Description: *| 01112 |* *| 01113 |* Input parameters: *| 01114 |* NONE *| 01115 |* *| 01116 |* Output parameters: *| 01117 |* NONE *| 01118 |* *| 01119 |* Returns: *| 01120 |* NOTHING *| 01121 |* *| 01122 \******************************************************************************/ 01123 static void cvrt_sytb_to_pdg(void) 01124 { 01125 int al_idx; 01126 int attr_idx; 01127 int name_idx; 01128 int unused; 01129 int scp_idx; 01130 01131 01132 TRACE (Func_Entry, "cvrt_sytb_to_pdg", NULL); 01133 01134 /* Need PDG symbols for current program unit and all the parents, because */ 01135 /* send_stor_blk may use them. Assign PDG symbol ids, but do not send */ 01136 /* them over until the rest of the symbols have been sent thru. This is */ 01137 /* because the Dummy Args may have been host associated and need to go */ 01138 /* through first so the defined, and inner_ref, def flags are set */ 01139 /* correctly. */ 01140 01141 scp_idx = curr_scp_idx; 01142 01143 while (scp_idx != NULL_IDX) { 01144 attr_idx = SCP_ATTR_IDX(scp_idx); 01145 01146 if (ATP_PGM_UNIT(attr_idx) == Module && scp_idx != curr_scp_idx) { 01147 break; /* DO NOT SEND a parent across if it is a module. */ 01148 } 01149 01150 if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit) { 01151 PDG_DBG_PRINT_START 01152 PDG_DBG_PRINT_C("fei_next_func_idx"); 01153 PDG_DBG_PRINT_END 01154 # ifdef _ENABLE_FEI 01155 PDG_AT_IDX(attr_idx) = fei_next_func_idx(ATP_PGM_UNIT(attr_idx), 01156 ATP_PROC(attr_idx), 01157 ATP_ALT_ENTRY(attr_idx)); 01158 # endif 01159 PDG_DBG_PRINT_START 01160 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 01161 PDG_DBG_PRINT_END 01162 } 01163 else { 01164 PDG_DBG_PRINT_START 01165 PDG_DBG_PRINT_C("fei_next_symbol"); 01166 PDG_DBG_PRINT_END 01167 # ifdef _ENABLE_FEI 01168 PDG_AT_IDX(attr_idx) = fei_next_symbol(TRUE); 01169 # endif 01170 PDG_DBG_PRINT_START 01171 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 01172 PDG_DBG_PRINT_END 01173 } 01174 01175 al_idx = SCP_ENTRY_IDX(scp_idx); 01176 while (al_idx != NULL_IDX) { 01177 attr_idx = AL_ATTR_IDX(al_idx); 01178 01179 if (AT_OBJ_CLASS(attr_idx) == Pgm_Unit) { 01180 PDG_DBG_PRINT_START 01181 PDG_DBG_PRINT_C("fei_next_func_idx"); 01182 PDG_DBG_PRINT_END 01183 # ifdef _ENABLE_FEI 01184 PDG_AT_IDX(attr_idx) = fei_next_func_idx(ATP_PGM_UNIT(attr_idx), 01185 ATP_PROC(attr_idx), 01186 ATP_ALT_ENTRY(attr_idx)); 01187 # endif 01188 PDG_DBG_PRINT_START 01189 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 01190 PDG_DBG_PRINT_END 01191 } 01192 else { 01193 PDG_DBG_PRINT_START 01194 PDG_DBG_PRINT_C("fei_next_symbol"); 01195 PDG_DBG_PRINT_END 01196 # ifdef _ENABLE_FEI 01197 PDG_AT_IDX(attr_idx) = fei_next_symbol(TRUE); 01198 # endif 01199 PDG_DBG_PRINT_START 01200 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 01201 PDG_DBG_PRINT_END 01202 } 01203 al_idx = AL_NEXT_IDX(al_idx); 01204 } 01205 scp_idx = SCP_PARENT_IDX(scp_idx); 01206 } 01207 01208 /* 01209 A stack segment must go over first for CCG. If there is a host stack 01210 for this program unit, send it first. The second argument is a pointer 01211 to a symbol class. This will not be used because the STACK is in the 01212 current scope. Pass a zero'd out integer field. 01213 */ 01214 if (SCP_PARENT_IDX(curr_scp_idx) != NULL_IDX && 01215 SCP_SB_HOSTED_STACK_IDX(SCP_PARENT_IDX(curr_scp_idx)) != NULL_IDX) { 01216 send_stor_blk(SCP_SB_HOSTED_STACK_IDX(SCP_PARENT_IDX(curr_scp_idx)), 01217 &unused); 01218 } 01219 else if (SCP_SB_HOSTED_STACK_IDX(curr_scp_idx) != NULL_IDX) { 01220 send_stor_blk(SCP_SB_HOSTED_STACK_IDX(curr_scp_idx), 01221 &unused); 01222 } 01223 else { 01224 send_stor_blk(SCP_SB_STACK_IDX(curr_scp_idx), 01225 &unused); 01226 } 01227 01228 /* 01229 Sends main entry point, alternate entry points, function 01230 results, all dummy arguments, and any accessed derived types. 01231 */ 01232 send_procedure(SCP_ATTR_IDX(curr_scp_idx), 01233 SCP_ENTRY_IDX(curr_scp_idx), 01234 Definition); 01235 01236 for (name_idx = SCP_LN_FW_IDX(curr_scp_idx) + 1; 01237 name_idx < SCP_LN_LW_IDX(curr_scp_idx); name_idx++) { 01238 attr_idx = LN_ATTR_IDX(name_idx); 01239 send_attr_ntry(attr_idx); 01240 } 01241 01242 al_idx = SCP_ATTR_LIST(curr_scp_idx); 01243 while (al_idx != NULL_IDX) { 01244 send_attr_ntry(AL_ATTR_IDX(al_idx)); 01245 al_idx = AL_NEXT_IDX(al_idx); 01246 } 01247 01248 /* Send all parent procedures. */ 01249 scp_idx = SCP_PARENT_IDX(curr_scp_idx); 01250 while (scp_idx != NULL_IDX) { 01251 01252 send_procedure(SCP_ATTR_IDX(scp_idx), 01253 SCP_ENTRY_IDX(scp_idx), 01254 Parent); 01255 01256 scp_idx = SCP_PARENT_IDX(scp_idx); 01257 } 01258 01259 TRACE (Func_Exit, "cvrt_sytb_to_pdg", NULL); 01260 01261 return; 01262 01263 } /* cvrt_sytb_to_pdg */ 01264 01265 01266 /******************************************************************************\ 01267 |* *| 01268 |* Description: *| 01269 |* *| 01270 |* Input parameters: *| 01271 |* NONE *| 01272 |* *| 01273 |* Output parameters: *| 01274 |* NONE *| 01275 |* *| 01276 |* Returns: *| 01277 |* NOTHING *| 01278 |* *| 01279 \******************************************************************************/ 01280 static void cvrt_exp_to_pdg(int ir_idx, 01281 fld_type field) 01282 { 01283 01284 static boolean high_range_present; 01285 static boolean low_range_present; 01286 static boolean member; 01287 static boolean static_initialization; 01288 01289 long_type loc_value[MAX_WORDS_FOR_NUMERIC]; 01290 int attr_idx; 01291 int type_idx; 01292 int base_attr; 01293 TYPE basic; 01294 int col; 01295 TYPE arg_type; 01296 INT32 big_int; 01297 long64 bit_length = 0; 01298 boolean bound_chk; 01299 int bound_idx = 0; 01300 int cn_idx; 01301 int idx; 01302 int constant_class; 01303 int count; 01304 int dim = 0; 01305 int co_dim = 0; 01306 long64 end; 01307 long64 flags = 0; 01308 int j; 01309 long64 i; 01310 boolean ignore_types; 01311 long64 inc; 01312 opnd_type l_opnd; 01313 int first_task_idx = NULL_IDX; 01314 int last_task_idx = NULL_IDX; 01315 int line; 01316 int list_array[OPEN_MP_LIST_CNT]; 01317 int list_cnt = 0; 01318 int list_idx1; 01319 int list_idx2; 01320 int list_idx3; 01321 int list_idx4; 01322 int name_idx; 01323 int next_idx; 01324 int number_actual_args; 01325 long64 offset; 01326 int path_idx; 01327 long pdg_cn_idx; 01328 long64 rep_count; 01329 int return_kind; 01330 boolean save_symbolic_constant_expr; 01331 int search_idx; 01332 int ss; 01333 long64 start; 01334 INT64 static_subscripts[7]; 01335 long64 stride; 01336 int t_idx; 01337 int task_tbl_idx; 01338 int task_maxcpus_idx; 01339 int task_wdist_idx; 01340 long which; 01341 long assertion; 01342 int task_if_idx = 0; 01343 char *criticalname = 0; 01344 long level = 0; 01345 long span = 1; 01346 long point = 0; 01347 long scheduletype = 0; 01348 int schedulechunk = 0; 01349 long schedtype = 0; 01350 long chunkcount = 0; 01351 long threadcount = 0; 01352 long datacount = 0; 01353 long reductioncount = 0; 01354 long ontocount = 0; 01355 long ordered = 0; 01356 long defaultt = 0; 01357 long nowait = 0; 01358 long varcount = 0; 01359 long C_value = 0; 01360 long prefetch_manual = 0; 01361 long prefetch_array = 0; 01362 int redistribute_array = 0; 01363 long context = -1; 01364 long prefetch_size = -1; 01365 long prefetch_kind = -1; 01366 int stride_list = 0; 01367 int level_list = 0; 01368 int cyclic_list = 0; 01369 int onto_list = 0; 01370 long n1 = 0; 01371 long n2 = 0; 01372 long cyclic_exists = 0; 01373 long onto_exists = 0; 01374 int tmp_ir_idx; 01375 int trip; 01376 TYPE type_desc; 01377 boolean unused; 01378 long64 vv; 01379 int fld; 01380 boolean EXPAND = FALSE; 01381 size_offset_type offset1; 01382 size_offset_type offset2; 01383 opnd_type opnd; 01384 size_offset_type result; 01385 int pe_bd_idx = 0; 01386 long64 arith_constant[4]; 01387 int arg_idx; 01388 int lhs_idx; 01389 int mask_idx; 01390 int proc_idx; 01391 int rhs_idx; 01392 int rename_only_num = 0; 01393 int ro_idx ; 01394 int onlyPredicate = 0; 01395 INTPTR oldpdgatidx; 01396 int listnum = 0; 01397 01398 TRACE (Func_Entry, "cvrt_exp_to_pdg", NULL); 01399 01400 switch (field) { 01401 01402 case NO_Tbl_Idx : 01403 01404 if (processing_call > 0) { 01405 PDG_DBG_PRINT_START 01406 PDG_DBG_PRINT_C("fei_null_expr"); 01407 PDG_DBG_PRINT_END 01408 01409 # ifdef _ENABLE_FEI 01410 if (!is_subscript) 01411 fei_null_expr(); 01412 else 01413 fei_implicit_expr(); 01414 01415 # endif 01416 } else 01417 if (is_subscript) 01418 fei_implicit_expr(); 01419 01420 break; 01421 01422 01423 case IMPLICIT_Tbl_Idx: 01424 fei_implicit_expr(); 01425 break; 01426 01427 case SB_Tbl_Idx : 01428 PDG_DBG_PRINT_START 01429 PDG_DBG_PRINT_C("fei_seg_ref"); 01430 PDG_DBG_PRINT_S("SB_NAME_PTR", SB_NAME_PTR(ir_idx)); 01431 PDG_DBG_PRINT_LD("(1) PDG_SB_IDX", PDG_SB_IDX(ir_idx)); 01432 PDG_DBG_PRINT_END 01433 01434 # if defined(GENERATE_WHIRL) 01435 # ifdef _ENABLE_FEI 01436 fei_seg_ref(PDG_SB_IDX(ir_idx)); 01437 # endif 01438 # endif 01439 break; 01440 01441 01442 case CN_Tbl_Idx : 01443 constant_class = Arith_Const; 01444 01445 if (data_attr != NULL_IDX && 01446 stack_data_constant && 01447 (TYP_TYPE(CN_TYPE_IDX(ir_idx)) == Integer || 01448 TYP_TYPE(CN_TYPE_IDX(ir_idx)) == Real || 01449 TYP_TYPE(CN_TYPE_IDX(ir_idx)) == Complex) && 01450 TYP_LINEAR(ATD_TYPE_IDX(data_attr)) != CRI_Ptr_8 && 01451 TYP_LINEAR(ATD_TYPE_IDX(data_attr)) != CRI_Ch_Ptr_8 && 01452 TYP_LINEAR(ATD_TYPE_IDX(data_attr)) != 01453 TYP_LINEAR(CN_TYPE_IDX(ir_idx))) { 01454 /* PDGCS does not like it if the value is not the same size as the */ 01455 /* target; for example, the value is a double precision constant and */ 01456 /* the target is a single precision variable. So explicitly convert */ 01457 /* the value to the type and kind type parameter of the target for */ 01458 /* all combinations to be consistent. */ 01459 01460 type_idx = ATD_TYPE_IDX(data_attr); 01461 line = 1; col = 1; 01462 if (folder_driver( (char *) &CN_CONST(ir_idx), 01463 CN_TYPE_IDX(ir_idx), 01464 NULL, 01465 NULL_IDX, 01466 loc_value, 01467 &type_idx, 01468 line, 01469 col, 01470 1, 01471 Cvrt_Opr)) 01472 ir_idx = ntr_const_tbl(type_idx, 01473 FALSE, 01474 loc_value); 01475 } 01476 01477 01478 switch (TYP_TYPE(CN_TYPE_IDX(ir_idx))) { 01479 case Character : 01480 bit_length = CN_INT_TO_C(TYP_IDX(CN_TYPE_IDX(ir_idx))); 01481 01482 if (stack_data_constant && 01483 data_character_bit_length != 0 && 01484 IL_FLD(data_character_bit_length) == CN_Tbl_Idx) { 01485 bit_length = CN_INT_TO_C(IL_IDX(data_character_bit_length)); 01486 PDG_CN_IDX(ir_idx) = 0; 01487 } 01488 01489 constant_class = Pattern_Const; 01490 bit_length = bit_length * CHAR_BIT; 01491 data_character_bit_length = 0; 01492 break; 01493 01494 case Typeless : 01495 bit_length = TYP_BIT_LEN(CN_TYPE_IDX(ir_idx)); 01496 constant_class = Pattern_Const; 01497 01498 /* 01499 If the length of the typeless constant is TBPW, 01500 make the constant an arithmetic constant. 01501 */ 01502 if (/* bit_length == TARGET_BITS_PER_WORD || */ 01503 TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Typeless_4 || 01504 TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Typeless_8) { 01505 constant_class = Arith_Const; 01506 } 01507 break; 01508 } 01509 01510 /* 01511 If the constant has never been created; or, we have exceeded the 01512 size of the link table, we want to call fei_constant. 01513 fei_constant will create a new constant and stack it on the 01514 expression stack. A call to fei_push_arith_con or fei_push_pattern_con 01515 assumes that the constant was already created and we can just stack 01516 the saved index for that particular constant. 01517 */ 01518 01519 if (PDG_CN_IDX(ir_idx) == 0 || ir_idx >= pdg_link_tbl_size) { 01520 basic = get_basic_type(CN_TYPE_IDX(ir_idx), 0, NULL_IDX); 01521 01522 01523 if (symbolic_constant_expr) { 01524 PDG_DBG_PRINT_START 01525 PDG_DBG_PRINT_C("fei_arith_con"); 01526 PDG_DBG_PRINT_T("(1) type", basic); 01527 #if defined(_HOST32) && defined(_TARGET64) 01528 PDG_DBG_PRINT_VD("(2) const", CN_CONST(ir_idx)); 01529 #else 01530 PDG_DBG_PRINT_LVD("(2) const", CN_CONST(ir_idx)); 01531 #endif 01532 PDG_DBG_PRINT_END 01533 01534 # ifdef _ENABLE_FEI 01535 PDG_CN_IDX(ir_idx) = fei_arith_con(basic, 01536 (long *)&CN_CONST(ir_idx)); 01537 # endif 01538 PDG_DBG_PRINT_START 01539 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", PDG_CN_IDX(ir_idx)); 01540 PDG_DBG_PRINT_END 01541 01542 PDG_DBG_PRINT_START 01543 PDG_DBG_PRINT_C("npex_constant"); 01544 PDG_DBG_PRINT_LD("(1) PDG_CN_IDX", PDG_CN_IDX(ir_idx)); 01545 PDG_DBG_PRINT_END 01546 01547 # ifdef _ENABLE_FEI 01548 npex_constant(PDG_CN_IDX(ir_idx)); 01549 # endif 01550 } 01551 else { 01552 PDG_DBG_PRINT_START 01553 PDG_DBG_PRINT_C("fei_constant"); 01554 PDG_DBG_PRINT_T("(1) type", basic); 01555 #if defined(_HOST32) && defined(_TARGET64) 01556 PDG_DBG_PRINT_S("(2) class", p_const_class[constant_class]); 01557 PDG_DBG_PRINT_VD("(3) const", CN_CONST(ir_idx)); 01558 PDG_DBG_PRINT_VD("(4) bit length", bit_length); 01559 #else 01560 PDG_DBG_PRINT_S("(2) class", p_const_class[constant_class]); 01561 PDG_DBG_PRINT_LVD("(3) const", CN_CONST(ir_idx)); 01562 PDG_DBG_PRINT_LLD("(4) bit length", bit_length); 01563 #endif 01564 PDG_DBG_PRINT_END 01565 01566 # ifdef _ENABLE_FEI 01567 01568 # if defined(_TARGET_SV2) 01569 if (constant_class == Arith_Const) { 01570 if (TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Complex_4 || 01571 TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Integer_8 || 01572 TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Real_8) { 01573 /* pack the constant up into one 64 bit word */ 01574 arith_constant[0] = CN_CONST(ir_idx); 01575 arith_constant[0] = arith_constant[0] << 32; 01576 arith_constant[0] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 1); 01577 } 01578 else if (TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Complex_8 || 01579 TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Real_16) { 01580 /* pack the constant up into two 64 bit words */ 01581 arith_constant[0] = CN_CONST(ir_idx); 01582 arith_constant[0] = arith_constant[0] << 32; 01583 arith_constant[0] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 1); 01584 arith_constant[1] = CP_CONSTANT(CN_POOL_IDX(ir_idx) + 2); 01585 arith_constant[1] = arith_constant[1] << 32; 01586 arith_constant[1] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 3); 01587 } 01588 else if (TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Complex_16) { 01589 /* pack the constant up into four 64 bit words */ 01590 arith_constant[0] = CN_CONST(ir_idx); 01591 arith_constant[0] = arith_constant[0] << 32; 01592 arith_constant[0] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 1); 01593 arith_constant[1] = CP_CONSTANT(CN_POOL_IDX(ir_idx) + 2); 01594 arith_constant[1] = arith_constant[1] << 32; 01595 arith_constant[1] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 3); 01596 arith_constant[2] = CP_CONSTANT(CN_POOL_IDX(ir_idx) + 4); 01597 arith_constant[2] = arith_constant[2] << 32; 01598 arith_constant[2] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 5); 01599 arith_constant[3] = CP_CONSTANT(CN_POOL_IDX(ir_idx) + 6); 01600 arith_constant[3] = arith_constant[3] << 32; 01601 arith_constant[3] |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 7); 01602 } 01603 else { 01604 arith_constant[0] = CN_CONST(ir_idx); 01605 } 01606 01607 pdg_cn_idx = fei_constant(basic, 01608 constant_class, 01609 (char *) &arith_constant, 01610 bit_length); 01611 } 01612 else { /* Pattern_Const */ 01613 pdg_cn_idx = fei_constant(basic, 01614 constant_class, 01615 (char *) &CN_CONST(ir_idx), 01616 bit_length); 01617 } 01618 01619 # elif defined(_TARGET_OS_MAX) /* JEFFL */ 01620 if (TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Complex_4) { 01621 /* pack the complex constant up into one word */ 01622 i = CN_CONST(ir_idx) << 32; 01623 i |= CP_CONSTANT(CN_POOL_IDX(ir_idx) + 1); 01624 pdg_cn_idx = fei_constant(basic, 01625 constant_class, 01626 (char *) &i, 01627 bit_length); 01628 } 01629 else { 01630 pdg_cn_idx = fei_constant(basic, 01631 constant_class, 01632 (char *) &CN_CONST(ir_idx), 01633 bit_length); 01634 } 01635 # else 01636 pdg_cn_idx = fei_constant(basic, 01637 constant_class, 01638 (char *) &CN_CONST(ir_idx), 01639 bit_length); 01640 # endif 01641 01642 # endif 01643 PDG_DBG_PRINT_START 01644 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", pdg_cn_idx); 01645 PDG_DBG_PRINT_END 01646 01647 if (ir_idx < pdg_link_tbl_size) { 01648 PDG_CN_IDX(ir_idx) = pdg_cn_idx; 01649 } 01650 } 01651 } 01652 else { 01653 if (constant_class == Pattern_Const) { 01654 PDG_DBG_PRINT_START 01655 PDG_DBG_PRINT_C("fei_push_pattern_con"); 01656 PDG_DBG_PRINT_LD("(1) PDG_CN_IDX", PDG_CN_IDX(ir_idx)); 01657 PDG_DBG_PRINT_END 01658 01659 # ifdef _ENABLE_FEI 01660 fei_push_pattern_con(PDG_CN_IDX(ir_idx)); 01661 # endif 01662 } 01663 else if (symbolic_constant_expr) { 01664 PDG_DBG_PRINT_START 01665 PDG_DBG_PRINT_C("npex_constant"); 01666 PDG_DBG_PRINT_LD("(1) PDG_CN_IDX", PDG_CN_IDX(ir_idx)); 01667 PDG_DBG_PRINT_END 01668 01669 # ifdef _ENABLE_FEI 01670 npex_constant(PDG_CN_IDX(ir_idx)); 01671 # endif 01672 } 01673 else { 01674 PDG_DBG_PRINT_START 01675 PDG_DBG_PRINT_C("fei_push_arith_con"); 01676 PDG_DBG_PRINT_LD("(1) PDG_CN_IDX", PDG_CN_IDX(ir_idx)); 01677 PDG_DBG_PRINT_END 01678 01679 # ifdef _ENABLE_FEI 01680 fei_push_arith_con(PDG_CN_IDX(ir_idx)); 01681 # endif 01682 } 01683 } 01684 break; 01685 01686 01687 case IL_Tbl_Idx : 01688 01689 while (ir_idx != NULL_IDX){ 01690 int keep_user_call; 01691 keep_user_call = user_call; 01692 #ifdef SOURCE_TO_SOURCE 01693 if (user_call) { 01694 if (IL_FLD(ir_idx) == IR_Tbl_Idx && 01695 IR_OPR(IL_IDX(ir_idx))==Kwd_Opr) { 01696 ; 01697 } 01698 else { 01699 fei_null_expr(); 01700 } 01701 } 01702 #endif 01703 user_call = 0 ; 01704 cvrt_exp_to_pdg(IL_IDX(ir_idx), 01705 IL_FLD(ir_idx)); 01706 user_call = keep_user_call; 01707 01708 if (processing_call) 01709 fei_arg_associate(IL_ARG_MULTI_FLAGS(ir_idx)); 01710 01711 ir_idx = IL_NEXT_LIST_IDX(ir_idx); 01712 } 01713 01714 break; 01715 01716 01717 case AT_Tbl_Idx : 01718 send_attr_ntry(ir_idx); 01719 01720 # if defined(_TARGET_OS_MAX) 01721 01722 if (AT_OBJ_CLASS(ir_idx) == Data_Obj && ATD_SYMBOLIC_CONSTANT(ir_idx)) { 01723 01724 if (ATD_CLASS(ir_idx) == Variable) { /* N$PEs */ 01725 01726 if (symbolic_constant_expr) { 01727 PDG_DBG_PRINT_START 01728 PDG_DBG_PRINT_C("npex_npes"); 01729 PDG_DBG_PRINT_END 01730 01731 # ifdef _ENABLE_FEI 01732 npex_npes(); 01733 # endif 01734 } 01735 else { 01736 PDG_DBG_PRINT_START 01737 PDG_DBG_PRINT_C("fei_n_pes"); 01738 PDG_DBG_PRINT_END 01739 01740 # ifdef _ENABLE_FEI 01741 fei_n_pes(); 01742 # endif 01743 } 01744 } 01745 else { 01746 01747 if (symbolic_constant_expr) { 01748 PDG_DBG_PRINT_START 01749 PDG_DBG_PRINT_C("npex_push"); 01750 PDG_DBG_PRINT_D("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01751 PDG_DBG_PRINT_END 01752 01753 # ifdef _ENABLE_FEI 01754 npex_push(PDG_AT_IDX(ir_idx)); 01755 # endif 01756 } 01757 else { 01758 PDG_DBG_PRINT_START 01759 PDG_DBG_PRINT_C("npex_to_expr"); 01760 PDG_DBG_PRINT_D("PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01761 PDG_DBG_PRINT_END 01762 01763 # ifdef _ENABLE_FEI 01764 npex_to_expr(PDG_AT_IDX(ir_idx)); 01765 # endif 01766 } 01767 } 01768 break; 01769 } 01770 # endif 01771 01772 01773 if (AT_OBJ_CLASS(ir_idx) == Data_Obj) { 01774 if (ATD_CLASS(ir_idx) == Compiler_Tmp && 01775 ATD_TMP_INIT_NOT_DONE(ir_idx)) { 01776 insert_init_stmt_for_tmp(ir_idx); 01777 } 01778 01779 if (data_attr == NULL_IDX) { 01780 data_attr = ir_idx; 01781 } 01782 01783 if (stack_data_object && member) { 01784 PDG_DBG_PRINT_START 01785 PDG_DBG_PRINT_C("fei_static_member"); 01786 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01787 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01788 PDG_DBG_PRINT_END 01789 01790 # ifdef _ENABLE_FEI 01791 fei_static_member(PDG_AT_IDX(ir_idx)); 01792 # endif 01793 } 01794 else if (stack_data_object) { 01795 PDG_DBG_PRINT_START 01796 PDG_DBG_PRINT_C("fei_static_base"); 01797 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01798 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01799 PDG_DBG_PRINT_END 01800 01801 # ifdef _ENABLE_FEI 01802 fei_static_base(PDG_AT_IDX(ir_idx)); 01803 # endif 01804 } 01805 else if (member) { 01806 PDG_DBG_PRINT_START 01807 PDG_DBG_PRINT_C("fei_member_ref"); 01808 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01809 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01810 PDG_DBG_PRINT_END 01811 01812 # ifdef _ENABLE_FEI 01813 fei_member_ref(PDG_AT_IDX(ir_idx)); 01814 # endif 01815 } 01816 else { 01817 PDG_DBG_PRINT_START 01818 PDG_DBG_PRINT_C("fei_object_ref"); 01819 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01820 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01821 PDG_DBG_PRINT_D("(2) whole_subscript", whole_subscript); 01822 PDG_DBG_PRINT_D("(3) whole_substring", whole_substring); 01823 PDG_DBG_PRINT_END 01824 01825 # ifdef _ENABLE_FEI 01826 fei_object_ref(PDG_AT_IDX(ir_idx), 01827 whole_subscript, 01828 whole_substring); 01829 # endif 01830 } 01831 } 01832 else if (AT_OBJ_CLASS(ir_idx) == Namelist_Grp) { 01833 PDG_DBG_PRINT_START 01834 PDG_DBG_PRINT_C("fei_namelist_ref"); 01835 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01836 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01837 PDG_DBG_PRINT_END 01838 01839 # ifdef _ENABLE_FEI 01840 fei_namelist_ref(PDG_AT_IDX(ir_idx)); 01841 # endif 01842 } 01843 else if (AT_OBJ_CLASS(ir_idx) == Pgm_Unit && 01844 ATP_PROC(ir_idx) == Dummy_Proc) { 01845 PDG_DBG_PRINT_START 01846 PDG_DBG_PRINT_C("fei_object_ref"); 01847 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01848 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01849 PDG_DBG_PRINT_D("(2) whole_subscript", whole_subscript); 01850 PDG_DBG_PRINT_D("(3) whole_substring", whole_substring); 01851 PDG_DBG_PRINT_END 01852 01853 # ifdef _ENABLE_FEI 01854 fei_object_ref(PDG_AT_IDX(ir_idx), 01855 whole_subscript, 01856 whole_substring); 01857 # endif 01858 } 01859 else if (AT_OBJ_CLASS(ir_idx) == Pgm_Unit) { 01860 PDG_DBG_PRINT_START 01861 PDG_DBG_PRINT_C("fei_function_ref"); 01862 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01863 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01864 PDG_DBG_PRINT_END 01865 01866 # ifdef _ENABLE_FEI 01867 fei_function_ref(PDG_AT_IDX(ir_idx)); 01868 # endif 01869 } 01870 else if (AT_OBJ_CLASS(ir_idx) == Label) { 01871 PDG_DBG_PRINT_START 01872 PDG_DBG_PRINT_C("fei_label_ref"); 01873 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(ir_idx)); 01874 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(ir_idx)); 01875 PDG_DBG_PRINT_END 01876 01877 # ifdef _ENABLE_FEI 01878 fei_label_ref(PDG_AT_IDX(ir_idx)); 01879 # endif 01880 } 01881 01882 break; 01883 01884 01885 01886 case IR_Tbl_Idx : 01887 01888 # if 0 01889 # ifdef _DEBUG 01890 if (IR_TYPE_IDX(ir_idx) == NULL_IDX) { 01891 print_ir(ir_idx); 01892 PRINTMSG(IR_LINE_NUM(ir_idx), 993, Internal, 01893 IR_COL_NUM(ir_idx)); 01894 } 01895 01896 if (IR_LINE_NUM(ir_idx) <= 0) { 01897 print_ir(ir_idx); 01898 PRINTMSG(1, 1150, Internal, IR_COL_NUM(ir_idx)); 01899 } 01900 01901 if ((IR_FLD_L(ir_idx) == AT_Tbl_Idx || 01902 IR_FLD_L(ir_idx) == CN_Tbl_Idx) && 01903 IR_LINE_NUM_L(ir_idx) <= 0) { 01904 print_ir(ir_idx); 01905 PRINTMSG(1, 1150, Internal, IR_COL_NUM(ir_idx)); 01906 } 01907 01908 if ((IR_FLD_R(ir_idx) == AT_Tbl_Idx || 01909 IR_FLD_R(ir_idx) == CN_Tbl_Idx) && 01910 IR_LINE_NUM_R(ir_idx) <= 0) { 01911 01912 print_ir(ir_idx); 01913 PRINTMSG(1, 1150, Internal, IR_COL_NUM(ir_idx)); 01914 } 01915 01916 if (IR_FLD_L(ir_idx) == IL_Tbl_Idx) { 01917 list_idx1 = IR_IDX_L(ir_idx); 01918 01919 while (list_idx1) { 01920 if ((IL_FLD(list_idx1) == AT_Tbl_Idx || 01921 IL_FLD(list_idx1) == CN_Tbl_Idx) && 01922 IL_LINE_NUM(list_idx1) <= 0) { 01923 01924 print_ir(ir_idx); 01925 PRINTMSG(1, 1150, Internal, IR_COL_NUM(ir_idx)); 01926 } 01927 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 01928 } 01929 } 01930 01931 if (IR_FLD_R(ir_idx) == IL_Tbl_Idx) { 01932 list_idx1 = IR_IDX_R(ir_idx); 01933 01934 while (list_idx1) { 01935 if ((IL_FLD(list_idx1) == AT_Tbl_Idx || 01936 IL_FLD(list_idx1) == CN_Tbl_Idx) && 01937 IL_LINE_NUM(list_idx1) <= 0) { 01938 01939 print_ir(ir_idx); 01940 PRINTMSG(1, 1150, Internal, IR_COL_NUM(ir_idx)); 01941 } 01942 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 01943 } 01944 } 01945 # endif 01946 01947 # endif 01948 switch (IR_OPR(ir_idx)) { 01949 01950 case Stmt_Expansion_Opr: 01951 # ifdef _DEBUG 01952 PRINTMSG(IR_LINE_NUM(ir_idx), 626, Internal, IR_COL_NUM(ir_idx), 01953 "no Stmt_Expansion_Opr", "cvrt_exp_to_pdg"); 01954 # endif 01955 /* send the left opnd anyway */ 01956 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 01957 IR_FLD_L(ir_idx)); 01958 break; 01959 01960 case Case_Range_Opr : 01961 if (IR_IDX_L(ir_idx) == NULL_IDX) { 01962 low_range_present = FALSE; 01963 } 01964 else { 01965 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 01966 IR_FLD_L(ir_idx)); 01967 low_range_present = TRUE; 01968 } 01969 01970 if (IR_IDX_R(ir_idx) == NULL_IDX) { 01971 high_range_present = FALSE; 01972 } 01973 else { 01974 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 01975 IR_FLD_R(ir_idx)); 01976 high_range_present = TRUE; 01977 } 01978 break; 01979 01980 01981 01982 01983 case Case_Opr : 01984 if (IR_IDX_L(ir_idx) != NULL_IDX) { 01985 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 01986 IR_FLD_L(ir_idx)); 01987 01988 big_int = CN_INT_TO_C(IR_IDX_R(ir_idx)); 01989 01990 PDG_DBG_PRINT_START 01991 PDG_DBG_PRINT_C("fei_new_select_case"); 01992 PDG_DBG_PRINT_S("(1) low_range", p_boolean[low_range_present]); 01993 PDG_DBG_PRINT_S("(2) high_range", p_boolean[high_range_present]); 01994 #if defined(_HOST32) && defined(_TARGET64) 01995 PDG_DBG_PRINT_D("(3) const", big_int); 01996 #else 01997 PDG_DBG_PRINT_VD("(3) const", big_int); 01998 #endif 01999 PDG_DBG_PRINT_END 02000 02001 02002 # ifdef _ENABLE_FEI 02003 fei_new_select_case(low_range_present, 02004 high_range_present, 02005 big_int); 02006 # endif 02007 low_range_present = FALSE; 02008 high_range_present = FALSE; 02009 } 02010 break; 02011 02012 02013 02014 02015 02016 case Select_Opr : 02017 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02018 IR_FLD_L(ir_idx)); 02019 02020 list_idx1 = IR_IDX_R(ir_idx); /* num cases */ 02021 list_idx2 = IL_NEXT_LIST_IDX(list_idx1); /* branch around label */ 02022 list_idx3 = IL_NEXT_LIST_IDX(list_idx2); /* default label */ 02023 02024 if (IR_LIST_CNT_R(ir_idx) == 2) { 02025 list_idx3 = list_idx2; 02026 } 02027 02028 send_attr_ntry(IL_IDX(list_idx3)); 02029 big_int = CN_INT_TO_C(IL_IDX(list_idx1)); 02030 02031 02032 PDG_DBG_PRINT_START 02033 PDG_DBG_PRINT_C("fei_new_select"); 02034 #if defined(_HOST32) && defined(_TARGET64) 02035 PDG_DBG_PRINT_D("(1) num cases", big_int); 02036 #else 02037 PDG_DBG_PRINT_VD("(1) num cases", big_int); 02038 #endif 02039 PDG_DBG_PRINT_LD("(2) default label", PDG_AT_IDX(IL_IDX(list_idx3))); 02040 PDG_DBG_PRINT_LD("(3) br around lbl", PDG_AT_IDX(IL_IDX(list_idx2))); 02041 PDG_DBG_PRINT_END 02042 02043 # ifdef _ENABLE_FEI 02044 fei_new_select(big_int, 02045 PDG_AT_IDX(IL_IDX(list_idx3)), 02046 PDG_AT_IDX(IL_IDX(list_idx2))); 02047 # endif 02048 break; 02049 02050 02051 02052 case Ptr_Asg_Opr : 02053 if ((IR_FLD_L(ir_idx) == AT_Tbl_Idx) && 02054 (AT_OBJ_CLASS(IR_IDX_L(ir_idx)) == Label)) { 02055 02056 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 02057 IR_FLD_R(ir_idx)); 02058 02059 PDG_DBG_PRINT_START 02060 PDG_DBG_PRINT_C("fei_label_addr"); 02061 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_L(ir_idx))); 02062 PDG_DBG_PRINT_END 02063 02064 # ifdef _ENABLE_FEI 02065 fei_label_addr(PDG_AT_IDX(IR_IDX_L(ir_idx))); 02066 # endif 02067 } 02068 else { 02069 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02070 IR_FLD_L(ir_idx)); 02071 02072 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 02073 IR_FLD_R(ir_idx)); 02074 } 02075 02076 PDG_DBG_PRINT_START 02077 PDG_DBG_PRINT_C("fei_pstore"); 02078 PDG_DBG_PRINT_END 02079 02080 # ifdef _ENABLE_FEI 02081 fei_pstore(pdg_type_void); 02082 # endif 02083 break; 02084 02085 02086 02087 #if 0 02088 case Ptr_Asg_Opr : 02089 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02090 IR_FLD_L(ir_idx)); 02091 02092 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 02093 IR_FLD_R(ir_idx)); 02094 02095 PDG_DBG_PRINT_START 02096 PDG_DBG_PRINT_C("fei_dv_ptr_asg"); 02097 PDG_DBG_PRINT_END 02098 02099 # ifdef _ENABLE_FEI 02100 fei_dv_ptr_asg(); 02101 # endif 02102 break; 02103 #endif 02104 02105 02106 case Array_Construct_Opr: 02107 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 02108 IR_FLD_R(ir_idx)); 02109 02110 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0,NULL_IDX); 02111 02112 PDG_DBG_PRINT_START 02113 PDG_DBG_PRINT_C("fei_array_construct"); 02114 PDG_DBG_PRINT_END 02115 02116 # ifdef _ENABLE_FEI 02117 fei_array_construct(IR_LIST_CNT_R(ir_idx),basic); 02118 #endif 02119 break; 02120 02121 02122 case Length_Opr : 02123 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02124 IR_FLD_L(ir_idx)); 02125 02126 PDG_DBG_PRINT_START 02127 PDG_DBG_PRINT_C("fei_length"); 02128 PDG_DBG_PRINT_END 02129 02130 # ifdef _ENABLE_FEI 02131 fei_length(); 02132 # endif 02133 break; 02134 02135 02136 02137 02138 case Getpos_Opr : 02139 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02140 IR_FLD_L(ir_idx)); 02141 02142 PDG_DBG_PRINT_START 02143 PDG_DBG_PRINT_C("fei_getpos"); 02144 PDG_DBG_PRINT_END 02145 02146 # ifdef _ENABLE_FEI 02147 fei_getpos(); 02148 # endif 02149 break; 02150 02151 02152 02153 case Unit_Opr : 02154 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02155 IR_FLD_L(ir_idx)); 02156 02157 PDG_DBG_PRINT_START 02158 PDG_DBG_PRINT_C("fei_unit"); 02159 PDG_DBG_PRINT_END 02160 02161 # ifdef _ENABLE_FEI 02162 fei_unit(); 02163 # endif 02164 break; 02165 02166 02167 02168 02169 02170 02171 case Index_Opr : 02172 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02173 IR_FLD_L(ir_idx)); 02174 02175 PDG_DBG_PRINT_START 02176 PDG_DBG_PRINT_C("fei_index"); 02177 PDG_DBG_PRINT_END 02178 02179 # ifdef _ENABLE_FEI 02180 fei_index(); 02181 # endif 02182 break; 02183 02184 02185 02186 02187 case Cmplx_Opr : 02188 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02189 IR_FLD_L(ir_idx)); 02190 02191 basic = get_basic_type(IR_TYPE_IDX(ir_idx), 0, NULL_IDX); 02192 02193 PDG_DBG_PRINT_START 02194 PDG_DBG_PRINT_C("fei_complex"); 02195 PDG_DBG_PRINT_END 02196 02197 # ifdef _ENABLE_FEI 02198 fei_complex(basic); 02199 # endif 02200 break; 02201 02202 02203 02204 02205 case Concat_Opr : 02206 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02207 IR_FLD_L(ir_idx)); 02208 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02209 02210 PDG_DBG_PRINT_START 02211 PDG_DBG_PRINT_C("fei_concat"); 02212 PDG_DBG_PRINT_D("(1) num ops", IR_LIST_CNT_L(ir_idx)); 02213 PDG_DBG_PRINT_END 02214 02215 # ifdef _ENABLE_FEI 02216 fei_concat(IR_LIST_CNT_L(ir_idx)); 02217 # endif 02218 break; 02219 02220 02221 02222 02223 02224 02225 02226 case Lock_Release_Opr : 02227 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02228 IR_FLD_L(ir_idx)); 02229 02230 PDG_DBG_PRINT_START 02231 PDG_DBG_PRINT_C("fei_lock_release"); 02232 PDG_DBG_PRINT_END 02233 02234 # if defined(GENERATE_WHIRL) 02235 # ifdef _ENABLE_FEI 02236 fei_lock_release(); 02237 # endif 02238 # endif 02239 02240 break; 02241 02242 02243 02244 02245 case Omp_Test_Lock_Opr : 02246 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02247 IR_FLD_L(ir_idx)); 02248 02249 PDG_DBG_PRINT_START 02250 PDG_DBG_PRINT_C("fei_omp_test_lock"); 02251 PDG_DBG_PRINT_END 02252 02253 # ifdef _ENABLE_FEI 02254 fei_omp_test_lock(); 02255 # endif 02256 break; 02257 02258 02259 02260 02261 case Omp_Set_Lock_Opr : 02262 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02263 IR_FLD_L(ir_idx)); 02264 02265 PDG_DBG_PRINT_START 02266 PDG_DBG_PRINT_C("fei_omp_set_lock"); 02267 PDG_DBG_PRINT_END 02268 02269 # ifdef _ENABLE_FEI 02270 fei_omp_set_lock(); 02271 # endif 02272 break; 02273 02274 02275 02276 02277 02278 case Omp_Unset_Lock_Opr : 02279 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02280 IR_FLD_L(ir_idx)); 02281 02282 PDG_DBG_PRINT_START 02283 PDG_DBG_PRINT_C("fei_omp_unset_lock"); 02284 PDG_DBG_PRINT_END 02285 02286 # ifdef _ENABLE_FEI 02287 fei_omp_unset_lock(); 02288 # endif 02289 break; 02290 02291 02292 02293 02294 02295 02296 case Synchronize_Opr : 02297 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02298 IR_FLD_L(ir_idx)); 02299 02300 PDG_DBG_PRINT_START 02301 PDG_DBG_PRINT_C("fei_synchronize"); 02302 PDG_DBG_PRINT_END 02303 02304 # if defined(GENERATE_WHIRL) 02305 # ifdef _ENABLE_FEI 02306 fei_synchronize(); 02307 # endif 02308 # endif 02309 02310 break; 02311 02312 02313 02314 02315 case Compare_And_Swap_Opr : 02316 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02317 IR_FLD_L(ir_idx)); 02318 02319 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02320 02321 PDG_DBG_PRINT_START 02322 PDG_DBG_PRINT_C("fei_compare_and_swap"); 02323 PDG_DBG_PRINT_END 02324 02325 # if defined(GENERATE_WHIRL) 02326 # ifdef _ENABLE_FEI 02327 fei_compare_and_swap(basic); 02328 # endif 02329 # endif 02330 02331 break; 02332 02333 02334 02335 02336 case Lock_Test_And_Set_Opr : 02337 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02338 IR_FLD_L(ir_idx)); 02339 02340 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02341 02342 PDG_DBG_PRINT_START 02343 PDG_DBG_PRINT_C("fei_lock_test_and_set"); 02344 PDG_DBG_PRINT_END 02345 02346 # if defined(GENERATE_WHIRL) 02347 # ifdef _ENABLE_FEI 02348 fei_lock_test_and_set(basic); 02349 # endif 02350 # endif 02351 02352 break; 02353 02354 02355 02356 02357 02358 case Fetch_And_Add_Opr : 02359 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02360 IR_FLD_L(ir_idx)); 02361 02362 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02363 02364 PDG_DBG_PRINT_START 02365 PDG_DBG_PRINT_C("fei_fetch_and_add"); 02366 PDG_DBG_PRINT_END 02367 02368 # if defined(GENERATE_WHIRL) 02369 # ifdef _ENABLE_FEI 02370 fei_fetch_and_add(basic); 02371 # endif 02372 # endif 02373 02374 break; 02375 02376 02377 02378 02379 case Add_And_Fetch_Opr : 02380 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02381 IR_FLD_L(ir_idx)); 02382 02383 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02384 02385 PDG_DBG_PRINT_START 02386 PDG_DBG_PRINT_C("fei_add_and_fetch"); 02387 PDG_DBG_PRINT_END 02388 02389 # if defined(GENERATE_WHIRL) 02390 # ifdef _ENABLE_FEI 02391 fei_add_and_fetch(basic); 02392 # endif 02393 # endif 02394 02395 break; 02396 02397 02398 02399 02400 02401 case Fetch_And_And_Opr : 02402 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02403 IR_FLD_L(ir_idx)); 02404 02405 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02406 02407 PDG_DBG_PRINT_START 02408 PDG_DBG_PRINT_C("fei_fetch_and_and"); 02409 PDG_DBG_PRINT_END 02410 02411 # if defined(GENERATE_WHIRL) 02412 # ifdef _ENABLE_FEI 02413 fei_fetch_and_and(basic); 02414 # endif 02415 # endif 02416 02417 break; 02418 02419 02420 02421 02422 02423 case And_And_Fetch_Opr : 02424 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02425 IR_FLD_L(ir_idx)); 02426 02427 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02428 02429 PDG_DBG_PRINT_START 02430 PDG_DBG_PRINT_C("fei_and_and_fetch"); 02431 PDG_DBG_PRINT_END 02432 02433 # if defined(GENERATE_WHIRL) 02434 # ifdef _ENABLE_FEI 02435 fei_and_and_fetch(basic); 02436 # endif 02437 # endif 02438 02439 break; 02440 02441 02442 02443 02444 02445 case Fetch_And_Nand_Opr : 02446 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02447 IR_FLD_L(ir_idx)); 02448 02449 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02450 02451 PDG_DBG_PRINT_START 02452 PDG_DBG_PRINT_C("fei_fetch_and_nand"); 02453 PDG_DBG_PRINT_END 02454 02455 # if defined(GENERATE_WHIRL) 02456 # ifdef _ENABLE_FEI 02457 fei_fetch_and_nand(basic); 02458 # endif 02459 # endif 02460 02461 break; 02462 02463 02464 02465 02466 02467 case Nand_And_Fetch_Opr : 02468 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02469 IR_FLD_L(ir_idx)); 02470 02471 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02472 02473 PDG_DBG_PRINT_START 02474 PDG_DBG_PRINT_C("fei_nand_and_fetch"); 02475 PDG_DBG_PRINT_END 02476 02477 # if defined(GENERATE_WHIRL) 02478 # ifdef _ENABLE_FEI 02479 fei_nand_and_fetch(basic); 02480 # endif 02481 # endif 02482 02483 break; 02484 02485 02486 02487 02488 02489 02490 case Fetch_And_Or_Opr : 02491 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02492 IR_FLD_L(ir_idx)); 02493 02494 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02495 02496 PDG_DBG_PRINT_START 02497 PDG_DBG_PRINT_C("fei_fetch_and_or"); 02498 PDG_DBG_PRINT_END 02499 02500 # if defined(GENERATE_WHIRL) 02501 # ifdef _ENABLE_FEI 02502 fei_fetch_and_or(basic); 02503 # endif 02504 # endif 02505 02506 break; 02507 02508 02509 02510 02511 case Or_And_Fetch_Opr : 02512 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02513 IR_FLD_L(ir_idx)); 02514 02515 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02516 02517 PDG_DBG_PRINT_START 02518 PDG_DBG_PRINT_C("fei_or_and_fetch"); 02519 PDG_DBG_PRINT_END 02520 02521 # if defined(GENERATE_WHIRL) 02522 # ifdef _ENABLE_FEI 02523 fei_or_and_fetch(basic); 02524 # endif 02525 # endif 02526 02527 break; 02528 02529 02530 02531 02532 case Fetch_And_Sub_Opr : 02533 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02534 IR_FLD_L(ir_idx)); 02535 02536 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02537 02538 PDG_DBG_PRINT_START 02539 PDG_DBG_PRINT_C("fei_fetch_sub_add"); 02540 PDG_DBG_PRINT_END 02541 02542 # if defined(GENERATE_WHIRL) 02543 # ifdef _ENABLE_FEI 02544 fei_fetch_and_sub(basic); 02545 # endif 02546 # endif 02547 02548 break; 02549 02550 02551 02552 02553 case Sub_And_Fetch_Opr : 02554 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02555 IR_FLD_L(ir_idx)); 02556 02557 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02558 02559 PDG_DBG_PRINT_START 02560 PDG_DBG_PRINT_C("fei_sub_and_fetch"); 02561 PDG_DBG_PRINT_END 02562 02563 # if defined(GENERATE_WHIRL) 02564 # ifdef _ENABLE_FEI 02565 fei_sub_and_fetch(basic); 02566 # endif 02567 # endif 02568 02569 break; 02570 02571 02572 02573 02574 02575 02576 case Fetch_And_Xor_Opr : 02577 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02578 IR_FLD_L(ir_idx)); 02579 02580 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02581 02582 PDG_DBG_PRINT_START 02583 PDG_DBG_PRINT_C("fei_fetch_and_xor"); 02584 PDG_DBG_PRINT_END 02585 02586 # if defined(GENERATE_WHIRL) 02587 # ifdef _ENABLE_FEI 02588 fei_fetch_and_xor(basic); 02589 # endif 02590 # endif 02591 02592 break; 02593 02594 02595 02596 02597 case Xor_And_Fetch_Opr : 02598 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02599 IR_FLD_L(ir_idx)); 02600 02601 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02602 02603 PDG_DBG_PRINT_START 02604 PDG_DBG_PRINT_C("fei_xor_and_fetch"); 02605 PDG_DBG_PRINT_END 02606 02607 # if defined(GENERATE_WHIRL) 02608 # ifdef _ENABLE_FEI 02609 fei_xor_and_fetch(basic); 02610 # endif 02611 # endif 02612 02613 break; 02614 02615 02616 02617 02618 02619 02620 02621 02622 case Mmx_Opr : 02623 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02624 IR_FLD_L(ir_idx)); 02625 02626 PDG_DBG_PRINT_START 02627 PDG_DBG_PRINT_C("fei_mbmx"); 02628 PDG_DBG_PRINT_END 02629 02630 # ifdef _ENABLE_FEI 02631 fei_mbmx(); 02632 # endif 02633 02634 break; 02635 02636 02637 02638 02639 02640 02641 case Mldmx_Opr : 02642 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02643 IR_FLD_L(ir_idx)); 02644 02645 PDG_DBG_PRINT_START 02646 PDG_DBG_PRINT_C("fei_mbmxl"); 02647 PDG_DBG_PRINT_END 02648 02649 # ifdef _ENABLE_FEI 02650 fei_mbmxl(); 02651 # endif 02652 02653 break; 02654 02655 02656 02657 02658 02659 02660 02661 case Mld_Opr : 02662 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02663 IR_FLD_L(ir_idx)); 02664 02665 PDG_DBG_PRINT_START 02666 PDG_DBG_PRINT_C("fei_mbld"); 02667 PDG_DBG_PRINT_END 02668 02669 # ifdef _ENABLE_FEI 02670 fei_mbld(); 02671 # endif 02672 02673 break; 02674 02675 02676 02677 02678 02679 02680 02681 case Mul_Opr : 02682 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02683 IR_FLD_L(ir_idx)); 02684 02685 PDG_DBG_PRINT_START 02686 PDG_DBG_PRINT_C("fei_mbul"); 02687 PDG_DBG_PRINT_END 02688 02689 # ifdef _ENABLE_FEI 02690 fei_mbul(); 02691 # endif 02692 break; 02693 02694 02695 02696 02697 02698 02699 case Mcbl_Opr : 02700 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02701 IR_FLD_L(ir_idx)); 02702 02703 PDG_DBG_PRINT_START 02704 PDG_DBG_PRINT_C("fei_mbclr"); 02705 PDG_DBG_PRINT_END 02706 02707 # ifdef _ENABLE_FEI 02708 fei_mbclr(); 02709 # endif 02710 02711 break; 02712 02713 02714 02715 02716 02717 02718 02719 02720 case Real_Div_To_Int_Opr : 02721 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02722 IR_FLD_L(ir_idx)); 02723 02724 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 02725 IR_FLD_R(ir_idx)); 02726 02727 PDG_DBG_PRINT_START 02728 PDG_DBG_PRINT_C("fei_ridiv"); 02729 PDG_DBG_PRINT_END 02730 02731 # ifdef _ENABLE_FEI 02732 fei_ridiv(); 02733 # endif 02734 02735 break; 02736 02737 02738 02739 02740 02741 02742 02743 02744 02745 02746 02747 case Modulo_Opr : 02748 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02749 IR_FLD_L(ir_idx)); 02750 02751 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02752 02753 PDG_DBG_PRINT_START 02754 PDG_DBG_PRINT_C("fei_modulo"); 02755 PDG_DBG_PRINT_END 02756 02757 # ifdef _ENABLE_FEI 02758 fei_modulo(basic); 02759 # endif 02760 02761 break; 02762 02763 02764 02765 02766 02767 02768 02769 02770 case Len_Trim_Opr : 02771 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02772 IR_FLD_L(ir_idx)); 02773 02774 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02775 02776 PDG_DBG_PRINT_START 02777 PDG_DBG_PRINT_C("fei_len_trim"); 02778 PDG_DBG_PRINT_END 02779 02780 # ifdef _ENABLE_FEI 02781 fei_len_trim(); 02782 # endif 02783 02784 break; 02785 02786 02787 02788 02789 02790 02791 02792 case Nearest_Opr : 02793 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02794 IR_FLD_L(ir_idx)); 02795 02796 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02797 02798 PDG_DBG_PRINT_START 02799 PDG_DBG_PRINT_C("fei_near"); 02800 PDG_DBG_PRINT_END 02801 02802 # ifdef _ENABLE_FEI 02803 fei_near(basic); 02804 # endif 02805 02806 break; 02807 02808 02809 02810 02811 02812 02813 case Rrspacing_Opr : 02814 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02815 IR_FLD_L(ir_idx)); 02816 02817 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02818 02819 PDG_DBG_PRINT_START 02820 PDG_DBG_PRINT_C("fei_rrspace"); 02821 PDG_DBG_PRINT_END 02822 02823 # ifdef _ENABLE_FEI 02824 fei_rrspace(basic); 02825 # endif 02826 02827 break; 02828 02829 02830 02831 02832 02833 02834 case Scale_Opr : 02835 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02836 IR_FLD_L(ir_idx)); 02837 02838 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02839 02840 PDG_DBG_PRINT_START 02841 PDG_DBG_PRINT_C("fei_scale"); 02842 PDG_DBG_PRINT_END 02843 02844 # ifdef _ENABLE_FEI 02845 fei_scale(basic); 02846 # endif 02847 02848 break; 02849 02850 02851 02852 02853 02854 02855 case Scan_Opr : 02856 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02857 IR_FLD_L(ir_idx)); 02858 02859 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02860 02861 PDG_DBG_PRINT_START 02862 PDG_DBG_PRINT_C("fei_scan"); 02863 PDG_DBG_PRINT_END 02864 02865 # ifdef _ENABLE_FEI 02866 fei_scan(basic); 02867 # endif 02868 02869 break; 02870 02871 02872 02873 02874 02875 02876 02877 case Set_Exponent_Opr : 02878 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02879 IR_FLD_L(ir_idx)); 02880 02881 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02882 02883 PDG_DBG_PRINT_START 02884 PDG_DBG_PRINT_C("fei_set_exponent"); 02885 PDG_DBG_PRINT_END 02886 02887 # ifdef _ENABLE_FEI 02888 fei_set_exponent(basic); 02889 # endif 02890 02891 break; 02892 02893 02894 02895 02896 02897 02898 02899 case Verify_Opr : 02900 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02901 IR_FLD_L(ir_idx)); 02902 02903 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02904 02905 PDG_DBG_PRINT_START 02906 PDG_DBG_PRINT_C("fei_verify"); 02907 PDG_DBG_PRINT_END 02908 02909 # ifdef _ENABLE_FEI 02910 fei_verify(basic); 02911 # endif 02912 02913 break; 02914 02915 02916 02917 02918 02919 02920 02921 02922 02923 case Spacing_Opr : 02924 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02925 IR_FLD_L(ir_idx)); 02926 02927 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02928 02929 PDG_DBG_PRINT_START 02930 PDG_DBG_PRINT_C("fei_space"); 02931 PDG_DBG_PRINT_END 02932 02933 # ifdef _ENABLE_FEI 02934 fei_space(basic); 02935 # endif 02936 02937 break; 02938 02939 02940 02941 02942 02943 02944 02945 02946 case Ceiling_Opr : 02947 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02948 IR_FLD_L(ir_idx)); 02949 02950 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02951 02952 PDG_DBG_PRINT_START 02953 PDG_DBG_PRINT_C("fei_ceiling"); 02954 PDG_DBG_PRINT_END 02955 02956 # ifdef _ENABLE_FEI 02957 fei_ceiling(basic); 02958 # endif 02959 02960 break; 02961 02962 02963 02964 02965 02966 02967 02968 case Adjustl_Opr : 02969 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02970 IR_FLD_L(ir_idx)); 02971 02972 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02973 02974 PDG_DBG_PRINT_START 02975 PDG_DBG_PRINT_C("fei_adjustl"); 02976 PDG_DBG_PRINT_END 02977 02978 # ifdef _ENABLE_FEI 02979 fei_adjustl(basic); 02980 # endif 02981 02982 break; 02983 02984 02985 02986 02987 02988 case Adjustr_Opr : 02989 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 02990 IR_FLD_L(ir_idx)); 02991 02992 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 02993 02994 PDG_DBG_PRINT_START 02995 PDG_DBG_PRINT_C("fei_adjustr"); 02996 PDG_DBG_PRINT_END 02997 02998 # ifdef _ENABLE_FEI 02999 fei_adjustr(basic); 03000 # endif 03001 03002 break; 03003 03004 03005 03006 03007 03008 03009 case Exponent_Opr : 03010 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03011 IR_FLD_L(ir_idx)); 03012 03013 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03014 03015 PDG_DBG_PRINT_START 03016 PDG_DBG_PRINT_C("fei_exponent"); 03017 PDG_DBG_PRINT_END 03018 03019 # ifdef _ENABLE_FEI 03020 fei_exponent(basic); 03021 # endif 03022 03023 break; 03024 03025 03026 03027 03028 03029 case Fraction_Opr : 03030 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03031 IR_FLD_L(ir_idx)); 03032 03033 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03034 03035 PDG_DBG_PRINT_START 03036 PDG_DBG_PRINT_C("fei_fraction"); 03037 PDG_DBG_PRINT_END 03038 03039 # ifdef _ENABLE_FEI 03040 fei_fraction(); 03041 # endif 03042 03043 break; 03044 03045 03046 03047 03048 03049 03050 03051 03052 case Cvmgt_Opr : 03053 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03054 IR_FLD_L(ir_idx)); 03055 03056 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03057 03058 PDG_DBG_PRINT_START 03059 PDG_DBG_PRINT_C("fei_select"); 03060 PDG_DBG_PRINT_END 03061 03062 # ifdef _ENABLE_FEI 03063 fei_select(basic); 03064 # endif 03065 03066 break; 03067 03068 03069 03070 03071 03072 case Csmg_Opr : 03073 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03074 IR_FLD_L(ir_idx)); 03075 03076 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03077 03078 PDG_DBG_PRINT_START 03079 PDG_DBG_PRINT_C("fei_mbits"); 03080 PDG_DBG_PRINT_END 03081 03082 03083 # ifdef _ENABLE_FEI 03084 fei_mbits(basic); 03085 # endif 03086 03087 break; 03088 03089 03090 03091 03092 03093 03094 case Rtc_Opr : 03095 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03096 03097 PDG_DBG_PRINT_START 03098 PDG_DBG_PRINT_C("fei_rtc"); 03099 PDG_DBG_PRINT_END 03100 03101 # ifdef _ENABLE_FEI 03102 fei_rtc(basic); 03103 # endif 03104 03105 break; 03106 03107 03108 03109 03110 case My_Pe_Opr : 03111 PDG_DBG_PRINT_START 03112 PDG_DBG_PRINT_C("fei_my_pe"); 03113 PDG_DBG_PRINT_END 03114 03115 # ifdef _ENABLE_FEI 03116 fei_my_pe(); 03117 # endif 03118 03119 break; 03120 03121 03122 03123 03124 03125 case Numarg_Opr : 03126 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03127 IR_FLD_L(ir_idx)); 03128 03129 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03130 03131 PDG_DBG_PRINT_START 03132 PDG_DBG_PRINT_C("fei_numargs"); 03133 PDG_DBG_PRINT_END 03134 03135 # ifdef _ENABLE_FEI 03136 fei_numargs(basic); 03137 # endif 03138 03139 break; 03140 03141 03142 03143 03144 03145 03146 # ifdef _HIGH_LEVEL_DO_LOOP_FORM 03147 03148 case Loop_Info_Opr : 03149 switch (SH_STMT_TYPE(curr_sh)) { 03150 case Do_Iterative_Stmt : 03151 03152 /* SH for the stmt that ends the loop. */ 03153 03154 line = (IR_FLD_L(ir_idx) == SH_Tbl_Idx) ? 03155 SH_GLB_LINE(IR_IDX_L(ir_idx)) : 0; 03156 03157 if (IL_FLD(IR_IDX_R(ir_idx)) == IL_Tbl_Idx) { 03158 idx = IL_IDX(IR_IDX_R(ir_idx)); 03159 } 03160 else { 03161 idx = IR_IDX_R(ir_idx); 03162 } 03163 cvrt_exp_to_pdg(IL_IDX(idx), /* LCV */ 03164 IL_FLD(idx)); 03165 03166 idx = IL_NEXT_LIST_IDX(idx); 03167 cvrt_exp_to_pdg(IL_IDX(idx), /* stack start */ 03168 IL_FLD(idx)); 03169 03170 idx = IL_NEXT_LIST_IDX(idx); 03171 cvrt_exp_to_pdg(IL_IDX(idx), /* stack end */ 03172 IL_FLD(idx)); 03173 03174 idx = IL_NEXT_LIST_IDX(idx); 03175 cvrt_exp_to_pdg(IL_IDX(idx), /* stack inc */ 03176 IL_FLD(idx)); 03177 03178 03179 PDG_DBG_PRINT_START 03180 PDG_DBG_PRINT_C("fei_doloop"); 03181 PDG_DBG_PRINT_D("(1) line", line); 03182 PDG_DBG_PRINT_END 03183 03184 # ifdef _ENABLE_FEI 03185 fei_doloop(line); 03186 # endif 03187 break; 03188 03189 03190 case Do_While_Stmt : 03191 idx = IR_IDX_R(ir_idx); 03192 cvrt_exp_to_pdg(IL_IDX(idx), /* condition */ 03193 IL_FLD(idx)); 03194 03195 PDG_DBG_PRINT_START 03196 PDG_DBG_PRINT_C("fei_dowhile"); 03197 PDG_DBG_PRINT_END 03198 03199 # ifdef _ENABLE_FEI 03200 fei_dowhile(); 03201 # endif 03202 break; 03203 03204 03205 case Do_Infinite_Stmt : 03206 PDG_DBG_PRINT_START 03207 PDG_DBG_PRINT_C("fei_doforever"); 03208 PDG_DBG_PRINT_END 03209 03210 # ifdef _ENABLE_FEI 03211 fei_doforever(); 03212 # endif 03213 break; 03214 03215 } 03216 break; 03217 03218 03219 03220 03221 case Loop_End_Opr : 03222 PDG_DBG_PRINT_START 03223 PDG_DBG_PRINT_C("fei_enddo"); 03224 PDG_DBG_PRINT_END 03225 03226 # ifdef _ENABLE_FEI 03227 fei_enddo(); 03228 # endif 03229 break; 03230 # endif 03231 03232 03233 03234 03235 03236 # if defined(GENERATE_WHIRL) 03237 case Mvbits_Opr : 03238 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03239 IR_FLD_L(ir_idx)); 03240 03241 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 03242 IR_FLD_R(ir_idx)); 03243 03244 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03245 03246 PDG_DBG_PRINT_START 03247 PDG_DBG_PRINT_C("fei_mvbits"); 03248 PDG_DBG_PRINT_END 03249 03250 # ifdef _ENABLE_FEI 03251 fei_mvbits(basic); 03252 # endif 03253 03254 break; 03255 03256 03257 case Ishftc_Opr : 03258 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03259 IR_FLD_L(ir_idx)); 03260 03261 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03262 03263 PDG_DBG_PRINT_START 03264 PDG_DBG_PRINT_C("fei_ishftc"); 03265 PDG_DBG_PRINT_END 03266 03267 # ifdef _ENABLE_FEI 03268 fei_ishftc(basic); 03269 # endif 03270 03271 break; 03272 03273 03274 03275 case Ibits_Opr : 03276 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03277 IR_FLD_L(ir_idx)); 03278 03279 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03280 03281 PDG_DBG_PRINT_START 03282 PDG_DBG_PRINT_C("fei_ibits"); 03283 PDG_DBG_PRINT_END 03284 03285 # ifdef _ENABLE_FEI 03286 fei_ibits(basic); 03287 # endif 03288 03289 break; 03290 # endif 03291 03292 03293 03294 03295 case Abs_Opr : 03296 case Paren_Opr : 03297 case Const_Tmp_Loc_Opr : 03298 case Loc_Opr : 03299 case Ieee_Finite_Opr : 03300 case Ieee_Is_Nan_Opr : 03301 case Ieee_Class_Opr : 03302 case Uplus_Opr : 03303 case Uminus_Opr : 03304 case Not_Opr : 03305 case Bnot_Opr : 03306 case Floor_Opr : 03307 case Clen_Opr : 03308 case Conjg_Opr : 03309 case Mask_Opr : 03310 case Int_Opr : 03311 case Logical_Opr : 03312 case Real_Opr : 03313 case Ichar_Opr : 03314 case Char_Opr : 03315 case Cvrt_Opr : 03316 case Cvrt_Unsigned_Opr : 03317 case Ranget_Opr : 03318 case Ranset_Opr : 03319 case Dim_Opr : 03320 case Aint_Opr : 03321 case Leadz_Opr : 03322 case Poppar_Opr : 03323 case Popcnt_Opr : 03324 case Nint_Opr : 03325 case Anint_Opr : 03326 case Sign_Opr : 03327 case Cot_Opr : 03328 case Exp_Opr : 03329 case Sqrt_Opr : 03330 case Acos_Opr : 03331 case Asin_Opr : 03332 case Atan_Opr : 03333 case Aimag_Opr : 03334 case Atan2_Opr : 03335 case Cosh_Opr : 03336 case Sinh_Opr : 03337 case Tanh_Opr : 03338 case Cos_Opr : 03339 case Sin_Opr : 03340 case Tan_Opr : 03341 case Log_E_Opr : 03342 case Log_10_Opr : 03343 case Cosd_Opr : 03344 case Sind_Opr : 03345 case Tand_Opr : 03346 case Acosd_Opr : 03347 case Asind_Opr : 03348 case Atand_Opr : 03349 case Atan2d_Opr : 03350 03351 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03352 IR_FLD_L(ir_idx)); 03353 03354 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 03355 03356 switch (IR_OPR(ir_idx)) { 03357 case Abs_Opr : 03358 PDG_DBG_PRINT_START 03359 PDG_DBG_PRINT_C("fei_abs"); 03360 PDG_DBG_PRINT_END 03361 # ifdef _ENABLE_FEI 03362 fei_abs(basic); 03363 # endif 03364 break; 03365 03366 case Paren_Opr : 03367 PDG_DBG_PRINT_START 03368 PDG_DBG_PRINT_C("fei_paren"); 03369 PDG_DBG_PRINT_END 03370 # ifdef _ENABLE_FEI 03371 fei_paren(basic,processing_call); 03372 # endif 03373 break; 03374 03375 case Const_Tmp_Loc_Opr : 03376 PDG_DBG_PRINT_START 03377 PDG_DBG_PRINT_C("fei_addr_con"); 03378 PDG_DBG_PRINT_END 03379 # ifdef _ENABLE_FEI 03380 fei_addr_con(basic); 03381 # endif 03382 break; 03383 03384 case Loc_Opr : 03385 PDG_DBG_PRINT_START 03386 PDG_DBG_PRINT_C("fei_addr"); 03387 PDG_DBG_PRINT_END 03388 # ifdef _ENABLE_FEI 03389 fei_addr(basic); 03390 # endif 03391 break; 03392 03393 case Ieee_Finite_Opr : 03394 PDG_DBG_PRINT_START 03395 PDG_DBG_PRINT_C("fei_isfinite"); 03396 PDG_DBG_PRINT_END 03397 # ifdef _ENABLE_FEI 03398 fei_isfinite(basic); 03399 # endif 03400 break; 03401 03402 case Ieee_Is_Nan_Opr : 03403 PDG_DBG_PRINT_START 03404 PDG_DBG_PRINT_C("fei_isnan"); 03405 PDG_DBG_PRINT_END 03406 # ifdef _ENABLE_FEI 03407 fei_isnan(basic); 03408 # endif 03409 break; 03410 03411 case Ieee_Class_Opr : 03412 PDG_DBG_PRINT_START 03413 PDG_DBG_PRINT_C("fei_fpclass"); 03414 PDG_DBG_PRINT_END 03415 # ifdef _ENABLE_FEI 03416 fei_fpclass(basic); 03417 # endif 03418 break; 03419 03420 case Uplus_Opr : 03421 break; 03422 03423 case Uminus_Opr : 03424 PDG_DBG_PRINT_START 03425 PDG_DBG_PRINT_C("fei_uminus"); 03426 PDG_DBG_PRINT_END 03427 # ifdef _ENABLE_FEI 03428 fei_uminus(basic); 03429 # endif 03430 break; 03431 03432 case Not_Opr : 03433 PDG_DBG_PRINT_START 03434 PDG_DBG_PRINT_C("fei_lneg"); 03435 PDG_DBG_PRINT_END 03436 # ifdef _ENABLE_FEI 03437 fei_lneg(basic); 03438 # endif 03439 break; 03440 03441 case Bnot_Opr : 03442 PDG_DBG_PRINT_START 03443 PDG_DBG_PRINT_C("fei_bneg"); 03444 PDG_DBG_PRINT_END 03445 # ifdef _ENABLE_FEI 03446 fei_bneg(basic); 03447 # endif 03448 break; 03449 03450 case Floor_Opr : 03451 PDG_DBG_PRINT_START 03452 PDG_DBG_PRINT_C("fei_floor"); 03453 PDG_DBG_PRINT_END 03454 # ifdef _ENABLE_FEI 03455 fei_floor(basic); 03456 # endif 03457 break; 03458 03459 case Clen_Opr : 03460 03461 PDG_DBG_PRINT_START 03462 PDG_DBG_PRINT_C("fei_len"); 03463 PDG_DBG_PRINT_END 03464 # ifdef _ENABLE_FEI 03465 /* fei_len(basic); */ 03466 fei_len(); 03467 # endif 03468 break; 03469 03470 case Conjg_Opr : 03471 PDG_DBG_PRINT_START 03472 PDG_DBG_PRINT_C("fei_conjg"); 03473 PDG_DBG_PRINT_END 03474 # ifdef _ENABLE_FEI 03475 fei_conjg(basic); 03476 # endif 03477 break; 03478 03479 case Mask_Opr : 03480 PDG_DBG_PRINT_START 03481 PDG_DBG_PRINT_C("fei_mask"); 03482 PDG_DBG_PRINT_END 03483 # ifdef _ENABLE_FEI 03484 fei_mask(basic); 03485 # endif 03486 break; 03487 03488 case Int_Opr : 03489 case Logical_Opr : 03490 case Real_Opr : 03491 case Ichar_Opr : 03492 case Char_Opr : 03493 case Cvrt_Opr : 03494 case Cvrt_Unsigned_Opr : 03495 PDG_DBG_PRINT_START 03496 PDG_DBG_PRINT_C("fei_cvtop"); 03497 PDG_DBG_PRINT_END 03498 # ifdef _ENABLE_FEI 03499 fei_cvtop(basic); 03500 # endif 03501 break; 03502 03503 case Ranget_Opr : 03504 PDG_DBG_PRINT_START 03505 PDG_DBG_PRINT_C("fei_ranget"); 03506 PDG_DBG_PRINT_END 03507 # ifdef _ENABLE_FEI 03508 fei_ranget(basic); 03509 # endif 03510 break; 03511 03512 case Ranset_Opr : 03513 PDG_DBG_PRINT_START 03514 PDG_DBG_PRINT_C("fei_ranset"); 03515 PDG_DBG_PRINT_END 03516 # ifdef _ENABLE_FEI 03517 fei_ranset(basic); 03518 # endif 03519 break; 03520 03521 case Dim_Opr : 03522 PDG_DBG_PRINT_START 03523 PDG_DBG_PRINT_C("fei_pos_diff"); 03524 PDG_DBG_PRINT_END 03525 # ifdef _ENABLE_FEI 03526 fei_pos_diff(basic); 03527 # endif 03528 break; 03529 03530 case Aint_Opr : 03531 PDG_DBG_PRINT_START 03532 PDG_DBG_PRINT_C("fei_trunc"); 03533 PDG_DBG_PRINT_END 03534 # ifdef _ENABLE_FEI 03535 fei_trunc(basic); 03536 # endif 03537 break; 03538 03539 case Leadz_Opr : 03540 arg_type = null_type; 03541 03542 # if defined(GENERATE_WHIRL) 03543 if (IR_FLD_L(ir_idx) == IL_Tbl_Idx) { 03544 arg_idx = IR_IDX_L(ir_idx); 03545 03546 if (IL_FLD(arg_idx) == AT_Tbl_Idx) { 03547 if (AT_OBJ_CLASS(IL_IDX(arg_idx)) == Data_Obj) { 03548 arg_type = get_basic_type(ATD_TYPE_IDX(IL_IDX(arg_idx)), 03549 0, 03550 NULL_IDX); 03551 } 03552 } 03553 else if (IL_FLD(arg_idx) == CN_Tbl_Idx) { 03554 arg_type = get_basic_type(CN_TYPE_IDX(IL_IDX(arg_idx)), 03555 0, 03556 NULL_IDX); 03557 } 03558 else if (IL_FLD(arg_idx) == IR_Tbl_Idx) { 03559 arg_type = get_basic_type(IR_TYPE_IDX(IL_IDX(arg_idx)), 03560 0, 03561 NULL_IDX); 03562 } 03563 } 03564 # endif 03565 03566 PDG_DBG_PRINT_START 03567 PDG_DBG_PRINT_C("fei_leadz"); 03568 PDG_DBG_PRINT_END 03569 # ifdef _ENABLE_FEI 03570 fei_leadz(basic, arg_type); 03571 # endif 03572 break; 03573 03574 case Poppar_Opr : 03575 arg_type = null_type; 03576 03577 # if defined(GENERATE_WHIRL) 03578 if (IR_FLD_L(ir_idx) == IL_Tbl_Idx) { 03579 arg_idx = IR_IDX_L(ir_idx); 03580 03581 if (IL_FLD(arg_idx) == AT_Tbl_Idx) { 03582 if (AT_OBJ_CLASS(IL_IDX(arg_idx)) == Data_Obj) { 03583 arg_type = get_basic_type(ATD_TYPE_IDX(IL_IDX(arg_idx)), 03584 0, 03585 NULL_IDX); 03586 } 03587 } 03588 else if (IL_FLD(arg_idx) == CN_Tbl_Idx) { 03589 arg_type = get_basic_type(CN_TYPE_IDX(IL_IDX(arg_idx)), 03590 0, 03591 NULL_IDX); 03592 } 03593 else if (IL_FLD(arg_idx) == IR_Tbl_Idx) { 03594 arg_type = get_basic_type(IR_TYPE_IDX(IL_IDX(arg_idx)), 03595 0, 03596 NULL_IDX); 03597 } 03598 } 03599 # endif 03600 03601 PDG_DBG_PRINT_START 03602 PDG_DBG_PRINT_C("fei_poppar"); 03603 PDG_DBG_PRINT_END 03604 # ifdef _ENABLE_FEI 03605 fei_poppar(basic, arg_type); 03606 # endif 03607 break; 03608 03609 case Popcnt_Opr : 03610 arg_type = null_type; 03611 03612 # if defined(GENERATE_WHIRL) 03613 if (IR_FLD_L(ir_idx) == IL_Tbl_Idx) { 03614 arg_idx = IR_IDX_L(ir_idx); 03615 03616 if (IL_FLD(arg_idx) == AT_Tbl_Idx) { 03617 if (AT_OBJ_CLASS(IL_IDX(arg_idx)) == Data_Obj) { 03618 arg_type = get_basic_type(ATD_TYPE_IDX(IL_IDX(arg_idx)), 03619 0, 03620 NULL_IDX); 03621 } 03622 } 03623 else if (IL_FLD(arg_idx) == CN_Tbl_Idx) { 03624 arg_type = get_basic_type(CN_TYPE_IDX(IL_IDX(arg_idx)), 03625 0, 03626 NULL_IDX); 03627 } 03628 else if (IL_FLD(arg_idx) == IR_Tbl_Idx) { 03629 arg_type = get_basic_type(IR_TYPE_IDX(IL_IDX(arg_idx)), 03630 0, 03631 NULL_IDX); 03632 } 03633 } 03634 # endif 03635 03636 PDG_DBG_PRINT_START 03637 PDG_DBG_PRINT_C("fei_popcnt"); 03638 PDG_DBG_PRINT_END 03639 # ifdef _ENABLE_FEI 03640 fei_popcnt(basic, arg_type); 03641 # endif 03642 break; 03643 03644 case Nint_Opr : 03645 case Anint_Opr : 03646 PDG_DBG_PRINT_START 03647 PDG_DBG_PRINT_C("fei_round"); 03648 PDG_DBG_PRINT_END 03649 # ifdef _ENABLE_FEI 03650 fei_round(basic); 03651 # endif 03652 break; 03653 03654 case Sign_Opr : 03655 PDG_DBG_PRINT_START 03656 PDG_DBG_PRINT_C("fei_sign_xfer"); 03657 PDG_DBG_PRINT_END 03658 # ifdef _ENABLE_FEI 03659 fei_sign_xfer(basic); 03660 # endif 03661 break; 03662 03663 case Cot_Opr : 03664 PDG_DBG_PRINT_START 03665 PDG_DBG_PRINT_C("fei_cot"); 03666 PDG_DBG_PRINT_END 03667 # ifdef _ENABLE_FEI 03668 fei_cot(basic); 03669 # endif 03670 break; 03671 03672 case Exp_Opr : 03673 PDG_DBG_PRINT_START 03674 PDG_DBG_PRINT_C("fei_exp"); 03675 PDG_DBG_PRINT_END 03676 # ifdef _ENABLE_FEI 03677 fei_exp(basic); 03678 # endif 03679 break; 03680 03681 case Sqrt_Opr : 03682 PDG_DBG_PRINT_START 03683 PDG_DBG_PRINT_C("fei_sqrt"); 03684 PDG_DBG_PRINT_END 03685 # ifdef _ENABLE_FEI 03686 fei_sqrt(basic); 03687 # endif 03688 break; 03689 03690 case Acos_Opr : 03691 PDG_DBG_PRINT_START 03692 PDG_DBG_PRINT_C("fei_acos"); 03693 PDG_DBG_PRINT_END 03694 # ifdef _ENABLE_FEI 03695 fei_acos(basic); 03696 # endif 03697 break; 03698 03699 case Asin_Opr : 03700 PDG_DBG_PRINT_START 03701 PDG_DBG_PRINT_C("fei_asin"); 03702 PDG_DBG_PRINT_END 03703 # ifdef _ENABLE_FEI 03704 fei_asin(basic); 03705 # endif 03706 break; 03707 03708 case Atan_Opr : 03709 PDG_DBG_PRINT_START 03710 PDG_DBG_PRINT_C("fei_atan"); 03711 PDG_DBG_PRINT_END 03712 # ifdef _ENABLE_FEI 03713 fei_atan(basic); 03714 # endif 03715 break; 03716 03717 case Aimag_Opr : 03718 PDG_DBG_PRINT_START 03719 PDG_DBG_PRINT_C("fei_imag"); 03720 PDG_DBG_PRINT_END 03721 # ifdef _ENABLE_FEI 03722 fei_imag(basic); 03723 # endif 03724 break; 03725 03726 case Atan2_Opr : 03727 PDG_DBG_PRINT_START 03728 PDG_DBG_PRINT_C("fei_atan2"); 03729 PDG_DBG_PRINT_END 03730 # ifdef _ENABLE_FEI 03731 fei_atan2(basic); 03732 # endif 03733 break; 03734 03735 case Cosh_Opr : 03736 PDG_DBG_PRINT_START 03737 PDG_DBG_PRINT_C("fei_cosh"); 03738 PDG_DBG_PRINT_END 03739 # ifdef _ENABLE_FEI 03740 fei_cosh(basic); 03741 # endif 03742 break; 03743 03744 case Sinh_Opr : 03745 PDG_DBG_PRINT_START 03746 PDG_DBG_PRINT_C("fei_sinh"); 03747 PDG_DBG_PRINT_END 03748 # ifdef _ENABLE_FEI 03749 fei_sinh(basic); 03750 # endif 03751 break; 03752 03753 case Tanh_Opr : 03754 PDG_DBG_PRINT_START 03755 PDG_DBG_PRINT_C("fei_tanh"); 03756 PDG_DBG_PRINT_END 03757 # ifdef _ENABLE_FEI 03758 fei_tanh(basic); 03759 # endif 03760 break; 03761 03762 case Cos_Opr : 03763 PDG_DBG_PRINT_START 03764 PDG_DBG_PRINT_C("fei_cos"); 03765 PDG_DBG_PRINT_END 03766 # ifdef _ENABLE_FEI 03767 fei_cos(basic); 03768 # endif 03769 break; 03770 03771 case Sin_Opr : 03772 PDG_DBG_PRINT_START 03773 PDG_DBG_PRINT_C("fei_sin"); 03774 PDG_DBG_PRINT_END 03775 # ifdef _ENABLE_FEI 03776 fei_sin(basic); 03777 # endif 03778 break; 03779 03780 case Tan_Opr : 03781 PDG_DBG_PRINT_START 03782 PDG_DBG_PRINT_C("fei_tan"); 03783 PDG_DBG_PRINT_END 03784 # ifdef _ENABLE_FEI 03785 fei_tan(basic); 03786 # endif 03787 break; 03788 03789 case Log_E_Opr : 03790 PDG_DBG_PRINT_START 03791 PDG_DBG_PRINT_C("fei_log"); 03792 PDG_DBG_PRINT_END 03793 # ifdef _ENABLE_FEI 03794 fei_log(basic); 03795 # endif 03796 break; 03797 03798 case Log_10_Opr : 03799 PDG_DBG_PRINT_START 03800 PDG_DBG_PRINT_C("fei_log10"); 03801 PDG_DBG_PRINT_END 03802 # ifdef _ENABLE_FEI 03803 fei_log10(basic); 03804 # endif 03805 break; 03806 03807 case Cosd_Opr : 03808 PDG_DBG_PRINT_START 03809 PDG_DBG_PRINT_C("fei_cosd"); 03810 PDG_DBG_PRINT_END 03811 # ifdef _ENABLE_FEI 03812 fei_cosd(basic); 03813 # endif 03814 break; 03815 03816 case Sind_Opr : 03817 PDG_DBG_PRINT_START 03818 PDG_DBG_PRINT_C("fei_sind"); 03819 PDG_DBG_PRINT_END 03820 # ifdef _ENABLE_FEI 03821 fei_sind(basic); 03822 # endif 03823 break; 03824 03825 case Tand_Opr : 03826 PDG_DBG_PRINT_START 03827 PDG_DBG_PRINT_C("fei_tand"); 03828 PDG_DBG_PRINT_END 03829 # ifdef _ENABLE_FEI 03830 fei_tand(basic); 03831 # endif 03832 break; 03833 03834 case Acosd_Opr : 03835 PDG_DBG_PRINT_START 03836 PDG_DBG_PRINT_C("fei_acosd"); 03837 PDG_DBG_PRINT_END 03838 # ifdef _ENABLE_FEI 03839 fei_acosd(basic); 03840 # endif 03841 break; 03842 03843 case Asind_Opr : 03844 PDG_DBG_PRINT_START 03845 PDG_DBG_PRINT_C("fei_asind"); 03846 PDG_DBG_PRINT_END 03847 # ifdef _ENABLE_FEI 03848 fei_asind(basic); 03849 # endif 03850 break; 03851 03852 case Atand_Opr : 03853 PDG_DBG_PRINT_START 03854 PDG_DBG_PRINT_C("fei_atand"); 03855 PDG_DBG_PRINT_END 03856 # ifdef _ENABLE_FEI 03857 fei_atand(basic); 03858 # endif 03859 break; 03860 03861 case Atan2d_Opr : 03862 PDG_DBG_PRINT_START 03863 PDG_DBG_PRINT_C("fei_atan2d"); 03864 PDG_DBG_PRINT_END 03865 # ifdef _ENABLE_FEI 03866 fei_atan2d(basic); 03867 # endif 03868 break; 03869 } 03870 break; 03871 03872 03873 03874 03875 03876 03877 03878 case Alt_Return_Opr : 03879 case Asg_Opr : 03880 case Dv_Whole_Copy_Opr : 03881 case Dv_Def_Asg_Opr : 03882 03883 if ((IR_FLD_L(ir_idx) == AT_Tbl_Idx) && 03884 (AT_OBJ_CLASS(IR_IDX_L(ir_idx)) == Label)) { 03885 03886 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 03887 IR_FLD_R(ir_idx)); 03888 03889 PDG_DBG_PRINT_START 03890 PDG_DBG_PRINT_C("fei_label_addr"); 03891 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_L(ir_idx))); 03892 PDG_DBG_PRINT_END 03893 03894 # ifdef _ENABLE_FEI 03895 fei_label_addr(PDG_AT_IDX(IR_IDX_L(ir_idx))); 03896 # endif 03897 } 03898 else { 03899 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03900 IR_FLD_L(ir_idx)); 03901 03902 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 03903 IR_FLD_R(ir_idx)); 03904 } 03905 03906 PDG_DBG_PRINT_START 03907 PDG_DBG_PRINT_C("fei_store"); 03908 PDG_DBG_PRINT_END 03909 03910 # ifdef _ENABLE_FEI 03911 fei_store(pdg_type_void); 03912 # endif 03913 break; 03914 03915 03916 03917 03918 03919 case Flat_Array_Asg_Opr : 03920 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03921 IR_FLD_L(ir_idx)); 03922 03923 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 03924 IR_FLD_R(ir_idx)); 03925 03926 PDG_DBG_PRINT_START 03927 PDG_DBG_PRINT_C("fei_non_conform_store"); 03928 PDG_DBG_PRINT_END 03929 03930 # ifdef _ENABLE_FEI 03931 fei_non_conform_store(pdg_type_void); 03932 # endif 03933 break; 03934 03935 03936 # ifdef _SAVE_IO_STMT 03937 case Start_Io_Opr : 03938 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03939 IR_FLD_L(ir_idx)); 03940 03941 PDG_DBG_PRINT_START 03942 PDG_DBG_PRINT_C("fei_start_ioblock"); 03943 PDG_DBG_PRINT_END 03944 03945 # ifdef _ENABLE_FEI 03946 fei_start_ioblock(); 03947 # endif 03948 break; 03949 03950 03951 03952 case End_Io_Opr : 03953 PDG_DBG_PRINT_START 03954 PDG_DBG_PRINT_C("fei_end_ioblock"); 03955 PDG_DBG_PRINT_END 03956 03957 # ifdef _ENABLE_FEI 03958 fei_end_ioblock(); 03959 # endif 03960 break; 03961 # endif 03962 03963 03964 03965 03966 case Readsm_Opr : 03967 PDG_DBG_PRINT_START 03968 PDG_DBG_PRINT_C("fei_readsm"); 03969 PDG_DBG_PRINT_END 03970 03971 # ifdef _ENABLE_FEI 03972 fei_readsm(); 03973 # endif 03974 break; 03975 03976 03977 03978 case Read_Unformatted_Opr : 03979 io_type = READ_STMT; 03980 03981 processing_call = processing_call + 1; 03982 processing_io_stmt = TRUE; 03983 03984 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 03985 IR_FLD_L(ir_idx)); 03986 03987 PDG_DBG_PRINT_START 03988 PDG_DBG_PRINT_C("fei_control_list"); 03989 PDG_DBG_PRINT_S("(1) io_type", p_io[io_type]); 03990 PDG_DBG_PRINT_END 03991 03992 # ifdef _ENABLE_FEI 03993 fei_control_list(io_type); 03994 # endif 03995 03996 io_ctl_list = TRUE; 03997 03998 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 03999 IR_FLD_R(ir_idx)); 04000 04001 io_ctl_list = FALSE; 04002 04003 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04004 list_cnt = IR_LIST_CNT_R(ir_idx); 04005 04006 PDG_DBG_PRINT_START 04007 PDG_DBG_PRINT_C("fei_IO_list"); 04008 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 04009 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04010 PDG_DBG_PRINT_END 04011 04012 # ifdef _ENABLE_FEI 04013 fei_IO_list(list_cnt, io_type); 04014 # endif 04015 } 04016 04017 PDG_DBG_PRINT_START 04018 PDG_DBG_PRINT_C("fei_unformatted_read"); 04019 PDG_DBG_PRINT_END 04020 04021 # ifdef _ENABLE_FEI 04022 fei_unformatted_read(); 04023 # endif 04024 04025 processing_io_stmt = FALSE; 04026 processing_call = processing_call - 1; 04027 break; 04028 04029 04030 04031 04032 04033 case Backspace_Opr: 04034 # if defined(_FILE_IO_OPRS) 04035 processing_call = processing_call + 1; 04036 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04037 IR_FLD_L(ir_idx)); 04038 04039 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04040 IR_FLD_R(ir_idx)); 04041 04042 PDG_DBG_PRINT_START 04043 PDG_DBG_PRINT_C("fei_backspace"); 04044 PDG_DBG_PRINT_END 04045 04046 fei_backspace(); 04047 processing_call = processing_call - 1; 04048 # endif 04049 break; 04050 04051 04052 04053 04054 case Close_Opr: 04055 # if defined(_FILE_IO_OPRS) 04056 processing_call = processing_call + 1; 04057 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04058 IR_FLD_L(ir_idx)); 04059 04060 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04061 IR_FLD_R(ir_idx)); 04062 04063 PDG_DBG_PRINT_START 04064 PDG_DBG_PRINT_C("fei_close"); 04065 PDG_DBG_PRINT_END 04066 04067 fei_close(); 04068 processing_call = processing_call - 1; 04069 # endif 04070 break; 04071 04072 04073 04074 04075 04076 case Endfile_Opr: 04077 # if defined(_FILE_IO_OPRS) 04078 processing_call = processing_call + 1; 04079 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04080 IR_FLD_L(ir_idx)); 04081 04082 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04083 IR_FLD_R(ir_idx)); 04084 04085 PDG_DBG_PRINT_START 04086 PDG_DBG_PRINT_C("fei_endfile"); 04087 PDG_DBG_PRINT_END 04088 04089 fei_endfile(); 04090 processing_call = processing_call - 1; 04091 # endif 04092 break; 04093 04094 04095 04096 04097 04098 case Inquire_Opr: 04099 # if defined(_FILE_IO_OPRS) 04100 processing_call = processing_call + 1; 04101 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04102 IR_FLD_L(ir_idx)); 04103 04104 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04105 IR_FLD_R(ir_idx)); 04106 04107 PDG_DBG_PRINT_START 04108 PDG_DBG_PRINT_C("fei_inquire"); 04109 PDG_DBG_PRINT_END 04110 04111 fei_inquire(); 04112 processing_call = processing_call - 1; 04113 # endif 04114 break; 04115 04116 04117 04118 04119 04120 case Open_Opr: 04121 # if defined(_FILE_IO_OPRS) 04122 processing_call = processing_call + 1; 04123 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04124 IR_FLD_L(ir_idx)); 04125 04126 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04127 IR_FLD_R(ir_idx)); 04128 04129 PDG_DBG_PRINT_START 04130 PDG_DBG_PRINT_C("fei_open"); 04131 PDG_DBG_PRINT_END 04132 04133 fei_open(); 04134 processing_call = processing_call - 1; 04135 # endif 04136 break; 04137 04138 04139 04140 04141 case Rewind_Opr: 04142 # if defined(_FILE_IO_OPRS) 04143 processing_call = processing_call + 1; 04144 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04145 IR_FLD_L(ir_idx)); 04146 04147 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04148 IR_FLD_R(ir_idx)); 04149 04150 PDG_DBG_PRINT_START 04151 PDG_DBG_PRINT_C("fei_rewind"); 04152 PDG_DBG_PRINT_END 04153 04154 fei_rewind(); 04155 processing_call = processing_call - 1; 04156 # endif 04157 break; 04158 04159 04160 case Io_Item_Type_Code_Opr: 04161 make_io_type_code(IR_TYPE_IDX(ir_idx), loc_value); 04162 basic = get_basic_type(IO_TYPE_CODE_TYPE, 04163 type_alignment_tbl[IO_TYPE_CODE_TYPE], 04164 NULL_IDX); 04165 04166 PDG_DBG_PRINT_START 04167 PDG_DBG_PRINT_C("fei_arith_con"); 04168 PDG_DBG_PRINT_T("(1) type", basic); 04169 #if defined(_HOST32) && defined(_TARGET64) 04170 PDG_DBG_PRINT_VD("(2) value", loc_value[0]); 04171 #else 04172 PDG_DBG_PRINT_LVD("(2) value", loc_value[0]); 04173 #endif 04174 PDG_DBG_PRINT_END 04175 04176 # ifdef _ENABLE_FEI 04177 pdg_cn_idx = fei_arith_con(basic, (long *)loc_value); 04178 # endif 04179 PDG_DBG_PRINT_START 04180 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", pdg_cn_idx); 04181 PDG_DBG_PRINT_END 04182 04183 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04184 IR_FLD_L(ir_idx)); 04185 04186 04187 PDG_DBG_PRINT_START 04188 PDG_DBG_PRINT_C("fei_push_arith_con"); 04189 PDG_DBG_PRINT_LD("(1) PDG_CN_IDX", pdg_cn_idx); 04190 PDG_DBG_PRINT_END 04191 04192 # ifdef _ENABLE_FEI 04193 fei_push_arith_con(pdg_cn_idx); 04194 # endif 04195 04196 PDG_DBG_PRINT_START 04197 PDG_DBG_PRINT_C("fei_iotype"); 04198 PDG_DBG_PRINT_END 04199 04200 # ifdef _ENABLE_FEI 04201 fei_iotype(); 04202 # endif 04203 break; 04204 04205 04206 04207 case Write_Unformatted_Opr : 04208 io_type = WRITE_STMT; 04209 processing_call = processing_call + 1; 04210 processing_io_stmt = TRUE; 04211 io_ctl_list = TRUE; 04212 04213 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04214 IR_FLD_L(ir_idx)); 04215 04216 PDG_DBG_PRINT_START 04217 PDG_DBG_PRINT_C("fei_control_list"); 04218 PDG_DBG_PRINT_S("(1) io_type", p_io[io_type]); 04219 PDG_DBG_PRINT_END 04220 04221 # ifdef _ENABLE_FEI 04222 fei_control_list(io_type); 04223 # endif 04224 io_ctl_list = FALSE; 04225 04226 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04227 IR_FLD_R(ir_idx)); 04228 /* io_ctl_list = FALSE; */ 04229 04230 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04231 list_cnt = IR_LIST_CNT_R(ir_idx); 04232 04233 PDG_DBG_PRINT_START 04234 PDG_DBG_PRINT_C("fei_IO_list"); 04235 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 04236 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04237 PDG_DBG_PRINT_END 04238 04239 # ifdef _ENABLE_FEI 04240 fei_IO_list(list_cnt, io_type); 04241 # endif 04242 } 04243 04244 PDG_DBG_PRINT_START 04245 PDG_DBG_PRINT_C("fei_unformatted_write"); 04246 PDG_DBG_PRINT_END 04247 04248 # ifdef _ENABLE_FEI 04249 fei_unformatted_write(); 04250 # endif 04251 04252 processing_io_stmt = FALSE; 04253 processing_call = processing_call - 1; 04254 break; 04255 04256 04257 04258 04259 case Read_Namelist_Opr : 04260 io_type = READ_NML_STMT; 04261 # if !(defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) 04262 /* remove the namelist group attr from the format item */ 04263 list_idx1 = IR_IDX_L(ir_idx); 04264 for (i = 0; i < 7; i++) { 04265 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 04266 } 04267 04268 IL_FLD(list_idx1) = NO_Tbl_Idx; 04269 IL_IDX(list_idx1) = NULL_IDX; 04270 # endif 04271 04272 processing_call = processing_call + 1; 04273 processing_io_stmt = TRUE; 04274 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04275 IR_FLD_L(ir_idx)); 04276 04277 PDG_DBG_PRINT_START 04278 PDG_DBG_PRINT_C("fei_control_list"); 04279 PDG_DBG_PRINT_S("(1) io_type", p_io[io_type]); 04280 PDG_DBG_PRINT_END 04281 04282 # ifdef _ENABLE_FEI 04283 fei_control_list(io_type); 04284 # endif 04285 io_ctl_list = TRUE; 04286 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04287 IR_FLD_R(ir_idx)); 04288 04289 io_ctl_list = FALSE; 04290 04291 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04292 list_cnt = IR_LIST_CNT_R(ir_idx); 04293 04294 PDG_DBG_PRINT_START 04295 PDG_DBG_PRINT_C("fei_IO_list"); 04296 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 04297 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04298 PDG_DBG_PRINT_END 04299 04300 # ifdef _ENABLE_FEI 04301 fei_IO_list(list_cnt, io_type); 04302 # endif 04303 } 04304 04305 PDG_DBG_PRINT_START 04306 PDG_DBG_PRINT_C("fei_namelist_read"); 04307 PDG_DBG_PRINT_END 04308 04309 # ifdef _ENABLE_FEI 04310 fei_namelist_read(); 04311 # endif 04312 04313 processing_io_stmt = FALSE; 04314 processing_call = processing_call - 1; 04315 break; 04316 04317 04318 04319 04320 04321 04322 case Write_Namelist_Opr : 04323 io_type = WRITE_NML_STMT; 04324 04325 # if !(defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) 04326 /* remove the namelist group attr from the format item */ 04327 list_idx1 = IR_IDX_L(ir_idx); 04328 for (i = 0; i < 7; i++) { 04329 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 04330 } 04331 04332 IL_FLD(list_idx1) = NO_Tbl_Idx; 04333 IL_IDX(list_idx1) = NULL_IDX; 04334 # endif 04335 04336 processing_call = processing_call + 1; 04337 processing_io_stmt = TRUE; 04338 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04339 IR_FLD_L(ir_idx)); 04340 04341 PDG_DBG_PRINT_START 04342 PDG_DBG_PRINT_C("fei_control_list"); 04343 PDG_DBG_PRINT_S("(1) io_type", p_io[io_type]); 04344 PDG_DBG_PRINT_END 04345 04346 # ifdef _ENABLE_FEI 04347 fei_control_list(io_type); 04348 # endif 04349 io_ctl_list = TRUE; 04350 04351 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04352 IR_FLD_R(ir_idx)); 04353 io_ctl_list = FALSE; 04354 04355 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04356 list_cnt = IR_LIST_CNT_R(ir_idx); 04357 04358 PDG_DBG_PRINT_START 04359 PDG_DBG_PRINT_C("fei_IO_list"); 04360 PDG_DBG_PRINT_D("(1) list count", list_cnt); 04361 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04362 PDG_DBG_PRINT_END 04363 04364 # ifdef _ENABLE_FEI 04365 fei_IO_list(list_cnt, io_type); 04366 # endif 04367 } 04368 04369 PDG_DBG_PRINT_START 04370 PDG_DBG_PRINT_C("fei_namelist_write"); 04371 PDG_DBG_PRINT_END 04372 04373 # ifdef _ENABLE_FEI 04374 fei_namelist_write(); 04375 # endif 04376 04377 processing_io_stmt = FALSE; 04378 processing_call = processing_call - 1; 04379 break; 04380 04381 04382 04383 04384 04385 case Read_Formatted_Opr : 04386 io_type = READ_STMT; 04387 processing_call = processing_call + 1; 04388 processing_io_stmt = TRUE; 04389 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04390 IR_FLD_L(ir_idx)); 04391 04392 PDG_DBG_PRINT_START 04393 PDG_DBG_PRINT_C("fei_control_list"); 04394 PDG_DBG_PRINT_S("(1) io_type", p_io[io_type]); 04395 PDG_DBG_PRINT_END 04396 04397 # ifdef _ENABLE_FEI 04398 fei_control_list(io_type); 04399 # endif 04400 /* io_ctl_list = TRUE; */ 04401 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04402 IR_FLD_R(ir_idx)); 04403 /* io_ctl_list = FALSE; */ 04404 04405 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04406 list_cnt = IR_LIST_CNT_R(ir_idx); 04407 04408 PDG_DBG_PRINT_START 04409 PDG_DBG_PRINT_C("fei_IO_list"); 04410 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 04411 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04412 PDG_DBG_PRINT_END 04413 04414 # ifdef _ENABLE_FEI 04415 fei_IO_list(list_cnt, io_type); 04416 # endif 04417 } 04418 04419 PDG_DBG_PRINT_START 04420 PDG_DBG_PRINT_C("fei_formatted_read"); 04421 PDG_DBG_PRINT_END 04422 04423 # ifdef _ENABLE_FEI 04424 fei_formatted_read(); 04425 # endif 04426 04427 processing_io_stmt = FALSE; 04428 processing_call = processing_call - 1; 04429 break; 04430 04431 04432 04433 04434 04435 04436 case Write_Formatted_Opr : 04437 io_type = WRITE_STMT; 04438 processing_call = processing_call + 1; 04439 processing_io_stmt = TRUE; 04440 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04441 IR_FLD_L(ir_idx)); 04442 04443 PDG_DBG_PRINT_START 04444 PDG_DBG_PRINT_C("fei_control_list"); 04445 PDG_DBG_PRINT_S("(1) io_type", p_io[io_type]); 04446 PDG_DBG_PRINT_END 04447 04448 # ifdef _ENABLE_FEI 04449 fei_control_list(io_type); 04450 # endif 04451 /* io_ctl_list = TRUE; */ 04452 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04453 IR_FLD_R(ir_idx)); 04454 /* io_ctl_list = FALSE; */ 04455 04456 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04457 list_cnt = IR_LIST_CNT_R(ir_idx); 04458 04459 PDG_DBG_PRINT_START 04460 PDG_DBG_PRINT_C("fei_IO_list"); 04461 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 04462 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04463 PDG_DBG_PRINT_END 04464 04465 # ifdef _ENABLE_FEI 04466 fei_IO_list(list_cnt, io_type); 04467 # endif 04468 } 04469 04470 PDG_DBG_PRINT_START 04471 PDG_DBG_PRINT_C("fei_formatted_write"); 04472 PDG_DBG_PRINT_END 04473 04474 # ifdef _ENABLE_FEI 04475 fei_formatted_write(); 04476 # endif 04477 04478 processing_io_stmt = FALSE; 04479 processing_call = processing_call - 1; 04480 break; 04481 04482 04483 04484 04485 04486 case Inquire_Iolength_Opr: 04487 io_type = WRITE_STMT; 04488 processing_call = processing_call + 1; 04489 processing_io_stmt = TRUE; 04490 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04491 IR_FLD_L(ir_idx)); 04492 04493 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04494 IR_FLD_R(ir_idx)); 04495 04496 if (IR_IDX_R(ir_idx) != NULL_IDX) { 04497 list_cnt = IR_LIST_CNT_R(ir_idx); 04498 04499 PDG_DBG_PRINT_START 04500 PDG_DBG_PRINT_C("fei_IO_list"); 04501 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 04502 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 04503 PDG_DBG_PRINT_END 04504 04505 # ifdef _ENABLE_FEI 04506 fei_IO_list(list_cnt, io_type); 04507 # endif 04508 } 04509 04510 PDG_DBG_PRINT_START 04511 PDG_DBG_PRINT_C("fei_iolength"); 04512 PDG_DBG_PRINT_END 04513 04514 # ifdef _ENABLE_FEI 04515 fei_iolength(); 04516 # endif 04517 04518 processing_io_stmt = FALSE; 04519 processing_call = processing_call - 1; 04520 break; 04521 04522 04523 04524 04525 04526 04527 04528 04529 04530 04531 04532 04533 case Fcd_Opr : 04534 case Int_Mult_Upper_Opr : 04535 case Ieee_Unordered_Opr : 04536 case Ieee_Remainder_Opr : 04537 case Ieee_Real_Opr : 04538 case Ieee_Int_Opr : 04539 case Ieee_Copy_Sign_Opr : 04540 case Ieee_Exponent_Opr : 04541 case Ieee_Next_After_Opr : 04542 case Ieee_Binary_Scale_Opr : 04543 case Mod_Opr : 04544 case Eq_Opr : 04545 case Ne_Opr : 04546 case Lg_Opr : 04547 case Lt_Opr : 04548 case Llt_Opr : 04549 case Le_Opr : 04550 case Lle_Opr : 04551 case Gt_Opr : 04552 case Lgt_Opr : 04553 case Ge_Opr : 04554 case Lge_Opr : 04555 case And_Opr : 04556 case Band_Opr : 04557 case Or_Opr : 04558 case Bor_Opr : 04559 case Eqv_Opr : 04560 case Neqv_Opr : 04561 case Bneqv_Opr : 04562 case Beqv_Opr : 04563 case Plus_Opr : 04564 case Minus_Opr : 04565 case Div_Opr : 04566 case Mult_Opr : 04567 case Dprod_Opr : 04568 case Power_Opr : 04569 case Shifta_Opr : 04570 case Shiftr_Opr : 04571 case Shiftl_Opr : 04572 case Shift_Opr : 04573 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04574 IR_FLD_L(ir_idx)); 04575 04576 if (IR_FLD_R(ir_idx) != NO_Tbl_Idx) { 04577 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 04578 IR_FLD_R(ir_idx)); 04579 } 04580 04581 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 04582 04583 switch (IR_OPR(ir_idx)) { 04584 case Fcd_Opr : 04585 PDG_DBG_PRINT_START 04586 PDG_DBG_PRINT_C("fei_fcd"); 04587 PDG_DBG_PRINT_END 04588 # ifdef _ENABLE_FEI 04589 fei_fcd(basic); 04590 # endif 04591 break; 04592 04593 case Int_Mult_Upper_Opr : 04594 PDG_DBG_PRINT_START 04595 PDG_DBG_PRINT_C("fei_multiply_high"); 04596 PDG_DBG_PRINT_END 04597 # ifdef _ENABLE_FEI 04598 fei_multiply_high(basic); 04599 # endif 04600 break; 04601 04602 case Ieee_Unordered_Opr : 04603 PDG_DBG_PRINT_START 04604 PDG_DBG_PRINT_C("fei_isunordered"); 04605 PDG_DBG_PRINT_END 04606 # ifdef _ENABLE_FEI 04607 fei_isunordered(basic); 04608 # endif 04609 break; 04610 04611 case Ieee_Remainder_Opr : 04612 PDG_DBG_PRINT_START 04613 PDG_DBG_PRINT_C("fei_remainder"); 04614 PDG_DBG_PRINT_END 04615 # ifdef _ENABLE_FEI 04616 fei_remainder(basic); 04617 # endif 04618 break; 04619 04620 case Ieee_Real_Opr : 04621 PDG_DBG_PRINT_START 04622 PDG_DBG_PRINT_C("fei_ieee_round"); 04623 PDG_DBG_PRINT_END 04624 # ifdef _ENABLE_FEI 04625 fei_ieee_round(basic); 04626 # endif 04627 break; 04628 04629 case Ieee_Int_Opr : 04630 PDG_DBG_PRINT_START 04631 PDG_DBG_PRINT_C("fei_ieee_trunc"); 04632 PDG_DBG_PRINT_END 04633 # ifdef _ENABLE_FEI 04634 fei_ieee_trunc(basic); 04635 # endif 04636 break; 04637 04638 case Ieee_Copy_Sign_Opr : 04639 # if defined(GENERATE_WHIRL) 04640 PDG_DBG_PRINT_START 04641 PDG_DBG_PRINT_C("fei_ieee_sign_xfer"); 04642 PDG_DBG_PRINT_END 04643 # ifdef _ENABLE_FEI 04644 fei_ieee_sign_xfer(basic); 04645 # endif 04646 # else 04647 PDG_DBG_PRINT_START 04648 PDG_DBG_PRINT_C("fei_sign_xfer"); 04649 PDG_DBG_PRINT_END 04650 # ifdef _ENABLE_FEI 04651 fei_sign_xfer(basic); 04652 # endif 04653 # endif 04654 break; 04655 04656 case Ieee_Exponent_Opr : 04657 PDG_DBG_PRINT_START 04658 PDG_DBG_PRINT_C("fei_logb"); 04659 PDG_DBG_PRINT_END 04660 # ifdef _ENABLE_FEI 04661 fei_logb(basic); 04662 # endif 04663 break; 04664 04665 case Ieee_Next_After_Opr : 04666 PDG_DBG_PRINT_START 04667 PDG_DBG_PRINT_C("fei_nextafter"); 04668 PDG_DBG_PRINT_END 04669 # ifdef _ENABLE_FEI 04670 fei_nextafter(basic); 04671 # endif 04672 break; 04673 04674 case Ieee_Binary_Scale_Opr : 04675 PDG_DBG_PRINT_START 04676 PDG_DBG_PRINT_C("fei_scalb"); 04677 PDG_DBG_PRINT_END 04678 # ifdef _ENABLE_FEI 04679 fei_scalb(basic); 04680 # endif 04681 break; 04682 04683 case Mod_Opr : 04684 PDG_DBG_PRINT_START 04685 PDG_DBG_PRINT_C("fei_mod"); 04686 PDG_DBG_PRINT_END 04687 # ifdef _ENABLE_FEI 04688 fei_mod(basic); 04689 # endif 04690 break; 04691 04692 case Eq_Opr : 04693 PDG_DBG_PRINT_START 04694 PDG_DBG_PRINT_C("fei_eq"); 04695 PDG_DBG_PRINT_END 04696 # ifdef _ENABLE_FEI 04697 fei_eq(basic); 04698 # endif 04699 break; 04700 04701 case Ne_Opr : 04702 PDG_DBG_PRINT_START 04703 PDG_DBG_PRINT_C("fei_ne"); 04704 PDG_DBG_PRINT_END 04705 # ifdef _ENABLE_FEI 04706 fei_ne(basic); 04707 # endif 04708 break; 04709 04710 case Lg_Opr : 04711 PDG_DBG_PRINT_START 04712 PDG_DBG_PRINT_C("fei_islg"); 04713 PDG_DBG_PRINT_END 04714 # ifdef _ENABLE_FEI 04715 fei_islg(basic); 04716 # endif 04717 break; 04718 04719 case Lt_Opr : 04720 case Llt_Opr : 04721 PDG_DBG_PRINT_START 04722 PDG_DBG_PRINT_C("fei_lt"); 04723 PDG_DBG_PRINT_END 04724 # ifdef _ENABLE_FEI 04725 fei_lt(basic); 04726 # endif 04727 break; 04728 04729 case Le_Opr : 04730 case Lle_Opr : 04731 PDG_DBG_PRINT_START 04732 PDG_DBG_PRINT_C("fei_le"); 04733 PDG_DBG_PRINT_END 04734 # ifdef _ENABLE_FEI 04735 fei_le(basic); 04736 # endif 04737 break; 04738 04739 case Gt_Opr : 04740 case Lgt_Opr : 04741 PDG_DBG_PRINT_START 04742 PDG_DBG_PRINT_C("fei_gt"); 04743 PDG_DBG_PRINT_END 04744 # ifdef _ENABLE_FEI 04745 fei_gt(basic); 04746 # endif 04747 break; 04748 04749 case Ge_Opr : 04750 case Lge_Opr : 04751 PDG_DBG_PRINT_START 04752 PDG_DBG_PRINT_C("fei_ge"); 04753 PDG_DBG_PRINT_END 04754 # ifdef _ENABLE_FEI 04755 fei_ge(basic); 04756 # endif 04757 break; 04758 04759 case And_Opr : 04760 PDG_DBG_PRINT_START 04761 PDG_DBG_PRINT_C("fei_land"); 04762 PDG_DBG_PRINT_END 04763 # ifdef _ENABLE_FEI 04764 fei_land(basic); 04765 # endif 04766 break; 04767 04768 case Band_Opr : 04769 PDG_DBG_PRINT_START 04770 PDG_DBG_PRINT_C("fei_and"); 04771 PDG_DBG_PRINT_END 04772 # ifdef _ENABLE_FEI 04773 fei_and(basic); 04774 # endif 04775 break; 04776 04777 case Or_Opr : 04778 PDG_DBG_PRINT_START 04779 PDG_DBG_PRINT_C("fei_lor"); 04780 PDG_DBG_PRINT_END 04781 # ifdef _ENABLE_FEI 04782 fei_lor(basic); 04783 # endif 04784 break; 04785 04786 case Bor_Opr : 04787 PDG_DBG_PRINT_START 04788 PDG_DBG_PRINT_C("fei_or"); 04789 PDG_DBG_PRINT_END 04790 # ifdef _ENABLE_FEI 04791 fei_or(basic); 04792 # endif 04793 break; 04794 04795 case Eqv_Opr : 04796 PDG_DBG_PRINT_START 04797 PDG_DBG_PRINT_C("fei_leqv"); 04798 PDG_DBG_PRINT_END 04799 # ifdef _ENABLE_FEI 04800 fei_leqv(basic); 04801 # endif 04802 break; 04803 04804 case Neqv_Opr : 04805 PDG_DBG_PRINT_START 04806 PDG_DBG_PRINT_C("fei_lxor"); 04807 PDG_DBG_PRINT_END 04808 # ifdef _ENABLE_FEI 04809 fei_lxor(basic); 04810 # endif 04811 break; 04812 04813 case Bneqv_Opr : 04814 PDG_DBG_PRINT_START 04815 PDG_DBG_PRINT_C("fei_xor"); 04816 PDG_DBG_PRINT_END 04817 # ifdef _ENABLE_FEI 04818 fei_xor(basic); 04819 # endif 04820 break; 04821 04822 case Beqv_Opr : 04823 PDG_DBG_PRINT_START 04824 PDG_DBG_PRINT_C("fei_eqv"); 04825 PDG_DBG_PRINT_END 04826 # ifdef _ENABLE_FEI 04827 fei_eqv(basic); 04828 # endif 04829 break; 04830 04831 case Plus_Opr : 04832 PDG_DBG_PRINT_START 04833 PDG_DBG_PRINT_C("fei_plus"); 04834 PDG_DBG_PRINT_END 04835 # ifdef _ENABLE_FEI 04836 fei_plus(basic); 04837 # endif 04838 break; 04839 04840 case Minus_Opr : 04841 PDG_DBG_PRINT_START 04842 PDG_DBG_PRINT_C("fei_minus"); 04843 PDG_DBG_PRINT_END 04844 # ifdef _ENABLE_FEI 04845 fei_minus(basic); 04846 # endif 04847 break; 04848 04849 case Div_Opr : 04850 PDG_DBG_PRINT_START 04851 PDG_DBG_PRINT_C("fei_div"); 04852 PDG_DBG_PRINT_END 04853 # ifdef _ENABLE_FEI 04854 fei_div(basic); 04855 # endif 04856 break; 04857 04858 case Mult_Opr : 04859 case Dprod_Opr : 04860 PDG_DBG_PRINT_START 04861 PDG_DBG_PRINT_C("fei_mult"); 04862 PDG_DBG_PRINT_END 04863 # ifdef _ENABLE_FEI 04864 fei_mult(basic); 04865 # endif 04866 break; 04867 04868 case Power_Opr : 04869 PDG_DBG_PRINT_START 04870 PDG_DBG_PRINT_C("fei_exponentiate"); 04871 PDG_DBG_PRINT_END 04872 # ifdef _ENABLE_FEI 04873 fei_exponentiate(basic); 04874 # endif 04875 break; 04876 04877 case Shifta_Opr : 04878 PDG_DBG_PRINT_START 04879 PDG_DBG_PRINT_C("fei_ashift"); 04880 PDG_DBG_PRINT_END 04881 # ifdef _ENABLE_FEI 04882 fei_ashift(basic); 04883 # endif 04884 break; 04885 04886 case Shiftr_Opr : 04887 PDG_DBG_PRINT_START 04888 PDG_DBG_PRINT_C("fei_rshift"); 04889 PDG_DBG_PRINT_END 04890 # ifdef _ENABLE_FEI 04891 fei_rshift(basic); 04892 # endif 04893 break; 04894 04895 case Shiftl_Opr : 04896 PDG_DBG_PRINT_START 04897 PDG_DBG_PRINT_C("fei_lshift"); 04898 PDG_DBG_PRINT_END 04899 # ifdef _ENABLE_FEI 04900 fei_lshift(basic); 04901 # endif 04902 break; 04903 04904 case Shift_Opr : 04905 PDG_DBG_PRINT_START 04906 PDG_DBG_PRINT_C("fei_new_binop_cshift"); 04907 PDG_DBG_PRINT_END 04908 # ifdef _ENABLE_FEI 04909 fei_new_binop_cshift(basic); 04910 # endif 04911 break; 04912 04913 } 04914 break; 04915 04916 04917 04918 04919 04920 04921 04922 04923 04924 04925 04926 04927 case Entry_Opr : 04928 if (ATP_ALT_ENTRY(IR_IDX_L(ir_idx))) { 04929 PDG_DBG_PRINT_START 04930 PDG_DBG_PRINT_C("fei_entry_pt"); 04931 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_L(ir_idx))); 04932 PDG_DBG_PRINT_END 04933 04934 # ifdef _ENABLE_FEI 04935 fei_entry_pt(PDG_AT_IDX(IR_IDX_L(ir_idx))); 04936 # endif 04937 } 04938 break; 04939 04940 04941 case Label_Opr : 04942 attr_idx = IR_IDX_L(ir_idx); 04943 04944 if (ATL_CLASS(attr_idx) == Lbl_Format || 04945 (ATL_CLASS(attr_idx) <= Lbl_User && !ATL_EXECUTABLE(attr_idx))) { 04946 /* Intentionally blank */ 04947 } 04948 else { 04949 send_label_def(ir_idx); 04950 } 04951 break; 04952 04953 04954 04955 case Whole_Substring_Opr : 04956 case Substring_Opr : 04957 whole_substring = IR_OPR(ir_idx) == Whole_Substring_Opr; 04958 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 04959 IR_FLD_L(ir_idx)); 04960 whole_substring = FALSE; 04961 04962 bound_chk = cmd_line_flags.runtime_substring; 04963 04964 if (IR_BOUNDS_DONE(ir_idx)) { 04965 bound_chk = FALSE; 04966 } 04967 04968 04969 list_idx1 = IR_IDX_R(ir_idx); 04970 list_idx2 = IL_NEXT_LIST_IDX(list_idx1); 04971 list_idx3 = IL_NEXT_LIST_IDX(list_idx2); 04972 04973 if (stack_data_object) { 04974 big_int = CN_INT_TO_C(IL_IDX(list_idx1)); 04975 04976 PDG_DBG_PRINT_START 04977 PDG_DBG_PRINT_C("fei_static_substr"); 04978 #if defined(_HOST32) && defined(_TARGET64) 04979 PDG_DBG_PRINT_D("(1) constant", big_int); 04980 #else 04981 PDG_DBG_PRINT_VD("(1) constant", big_int); 04982 #endif 04983 PDG_DBG_PRINT_END 04984 04985 # ifdef _ENABLE_FEI 04986 fei_static_substr(big_int); 04987 # endif 04988 04989 data_character_bit_length = list_idx3; 04990 break; 04991 } 04992 04993 cvrt_exp_to_pdg(IL_IDX(list_idx1), 04994 IL_FLD(list_idx1)); 04995 04996 /* The third value is the length. */ 04997 cvrt_exp_to_pdg(IL_IDX(list_idx3), 04998 IL_FLD(list_idx3)); 04999 05000 PDG_DBG_PRINT_START 05001 PDG_DBG_PRINT_C("fei_substr"); 05002 PDG_DBG_PRINT_D("(1) bound_chk", bound_chk); 05003 PDG_DBG_PRINT_END 05004 05005 # ifdef _ENABLE_FEI 05006 fei_substr(bound_chk); 05007 # endif 05008 break; 05009 05010 05011 05012 05013 05014 case Return_Opr : 05015 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05016 IR_FLD_L(ir_idx)); 05017 05018 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 05019 IR_FLD_R(ir_idx)); 05020 05021 if (IR_IDX_L(ir_idx) != NULL_IDX) { 05022 return_kind = Alternate_Return; 05023 } 05024 else if (IR_IDX_R(ir_idx) != NULL_IDX) { 05025 return_kind = Normal_Return; 05026 } 05027 else { 05028 return_kind = Void_Return; 05029 } 05030 05031 PDG_DBG_PRINT_START 05032 PDG_DBG_PRINT_C("fei_return"); 05033 PDG_DBG_PRINT_S("(1) return_kind", p_return[return_kind]); 05034 PDG_DBG_PRINT_T("(2) type", pdg_type_void); 05035 PDG_DBG_PRINT_END 05036 05037 # ifdef _ENABLE_FEI 05038 fei_return(return_kind, pdg_type_void); 05039 # endif 05040 break; 05041 05042 05043 05044 05045 case Stop_Opr: 05046 # ifdef _STOP_IS_OPR 05047 /* stop code is in list item on right */ 05048 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 05049 IR_FLD_R(ir_idx)); 05050 05051 PDG_DBG_PRINT_START 05052 PDG_DBG_PRINT_C("fei_stop"); 05053 PDG_DBG_PRINT_END 05054 05055 # ifdef _ENABLE_FEI 05056 fei_stop(); 05057 # endif 05058 05059 # else 05060 PRINTMSG(IR_LINE_NUM(ir_idx), 626, Internal, 05061 IR_COL_NUM(ir_idx), 05062 "no Stop_Opr", "cvrt_exp_to_pdg"); 05063 # endif 05064 break; 05065 05066 05067 05068 05069 05070 05071 case Matmul_Opr : 05072 case Spread_Opr : 05073 case Reshape_Opr : 05074 case Transpose_Opr : 05075 case Sum_Opr : 05076 case Eoshift_Opr : 05077 case Maxval_Opr : 05078 case Minval_Opr : 05079 case Maxloc_Opr : 05080 case Minloc_Opr : 05081 case All_Opr : 05082 case Any_Opr : 05083 case Count_Opr : 05084 case Product_Opr : 05085 case Unpack_Opr : 05086 case Pack_Opr : 05087 case Cshift_Opr : 05088 case Dot_Product_Opr : 05089 case Dot_Product_Logical_Opr : 05090 processing_call = processing_call + 1; 05091 05092 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05093 IR_FLD_L(ir_idx)); 05094 05095 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 05096 05097 switch (IR_OPR(ir_idx)) { 05098 case Matmul_Opr : 05099 PDG_DBG_PRINT_START 05100 PDG_DBG_PRINT_C("fei_matmul"); 05101 PDG_DBG_PRINT_END 05102 # ifdef _ENABLE_FEI 05103 fei_matmul(basic); 05104 # endif 05105 break; 05106 05107 case Spread_Opr : 05108 PDG_DBG_PRINT_START 05109 PDG_DBG_PRINT_C("fei_spread"); 05110 PDG_DBG_PRINT_END 05111 # ifdef _ENABLE_FEI 05112 fei_spread(basic); 05113 # endif 05114 break; 05115 05116 case Reshape_Opr : 05117 PDG_DBG_PRINT_START 05118 PDG_DBG_PRINT_C("fei_reshape"); 05119 PDG_DBG_PRINT_END 05120 # ifdef _ENABLE_FEI 05121 fei_reshape(basic); 05122 # endif 05123 break; 05124 05125 case Transpose_Opr : 05126 PDG_DBG_PRINT_START 05127 PDG_DBG_PRINT_C("fei_transpose"); 05128 PDG_DBG_PRINT_END 05129 # ifdef _ENABLE_FEI 05130 fei_transpose(basic); 05131 # endif 05132 break; 05133 05134 case Sum_Opr : 05135 PDG_DBG_PRINT_START 05136 PDG_DBG_PRINT_C("fei_sum"); 05137 PDG_DBG_PRINT_END 05138 # ifdef _ENABLE_FEI 05139 fei_sum(basic); 05140 # endif 05141 break; 05142 05143 case Eoshift_Opr : 05144 PDG_DBG_PRINT_START 05145 PDG_DBG_PRINT_C("fei_eoshift"); 05146 PDG_DBG_PRINT_END 05147 # ifdef _ENABLE_FEI 05148 fei_eoshift(basic); 05149 # endif 05150 break; 05151 05152 case Maxval_Opr : 05153 PDG_DBG_PRINT_START 05154 PDG_DBG_PRINT_C("fei_maxval"); 05155 PDG_DBG_PRINT_END 05156 # ifdef _ENABLE_FEI 05157 fei_maxval(basic); 05158 # endif 05159 break; 05160 05161 case Minval_Opr : 05162 PDG_DBG_PRINT_START 05163 PDG_DBG_PRINT_C("fei_minval"); 05164 PDG_DBG_PRINT_END 05165 # ifdef _ENABLE_FEI 05166 fei_minval(basic); 05167 # endif 05168 break; 05169 05170 case Maxloc_Opr : 05171 PDG_DBG_PRINT_START 05172 PDG_DBG_PRINT_C("fei__maxloc"); 05173 PDG_DBG_PRINT_END 05174 # ifdef _ENABLE_FEI 05175 fei__maxloc(basic); 05176 # endif 05177 break; 05178 05179 case Minloc_Opr : 05180 PDG_DBG_PRINT_START 05181 PDG_DBG_PRINT_C("fei__minloc"); 05182 PDG_DBG_PRINT_END 05183 # ifdef _ENABLE_FEI 05184 fei__minloc(basic); 05185 # endif 05186 break; 05187 05188 case All_Opr : 05189 PDG_DBG_PRINT_START 05190 PDG_DBG_PRINT_C("fei_all"); 05191 PDG_DBG_PRINT_END 05192 # ifdef _ENABLE_FEI 05193 fei_all(basic); 05194 # endif 05195 break; 05196 05197 case Any_Opr : 05198 PDG_DBG_PRINT_START 05199 PDG_DBG_PRINT_C("fei_any"); 05200 PDG_DBG_PRINT_END 05201 # ifdef _ENABLE_FEI 05202 fei_any(basic); 05203 # endif 05204 break; 05205 05206 case Count_Opr : 05207 PDG_DBG_PRINT_START 05208 PDG_DBG_PRINT_C("fei_count"); 05209 PDG_DBG_PRINT_END 05210 # ifdef _ENABLE_FEI 05211 fei_count(basic); 05212 # endif 05213 break; 05214 05215 case Product_Opr : 05216 PDG_DBG_PRINT_START 05217 PDG_DBG_PRINT_C("fei_product"); 05218 PDG_DBG_PRINT_END 05219 # ifdef _ENABLE_FEI 05220 fei_product(basic); 05221 # endif 05222 break; 05223 05224 case Unpack_Opr : 05225 PDG_DBG_PRINT_START 05226 PDG_DBG_PRINT_C("fei_unpack"); 05227 PDG_DBG_PRINT_END 05228 # ifdef _ENABLE_FEI 05229 fei_unpack(basic); 05230 # endif 05231 break; 05232 05233 case Pack_Opr : 05234 PDG_DBG_PRINT_START 05235 PDG_DBG_PRINT_C("fei_pack"); 05236 PDG_DBG_PRINT_END 05237 # ifdef _ENABLE_FEI 05238 fei_pack(basic); 05239 # endif 05240 break; 05241 05242 case Cshift_Opr : 05243 PDG_DBG_PRINT_START 05244 PDG_DBG_PRINT_C("fei_cshift"); 05245 PDG_DBG_PRINT_END 05246 # ifdef _ENABLE_FEI 05247 fei_cshift(basic); 05248 # endif 05249 break; 05250 05251 case Dot_Product_Opr : 05252 PDG_DBG_PRINT_START 05253 PDG_DBG_PRINT_C("fei_dot_product"); 05254 PDG_DBG_PRINT_END 05255 # ifdef _ENABLE_FEI 05256 fei_dot_product(basic); 05257 # endif 05258 break; 05259 05260 case Dot_Product_Logical_Opr : 05261 PDG_DBG_PRINT_START 05262 PDG_DBG_PRINT_C("fei_dot_product_logical)"); 05263 PDG_DBG_PRINT_END 05264 # if defined(GENERATE_WHIRL) 05265 # ifdef _ENABLE_FEI 05266 fei_dot_product_logical(basic); 05267 # endif 05268 # endif 05269 break; 05270 } 05271 05272 processing_call = processing_call - 1; 05273 break; 05274 05275 05276 05277 05278 05279 05280 05281 05282 05283 05284 05285 05286 case Memory_Barrier_Opr : 05287 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05288 IR_FLD_L(ir_idx)); 05289 05290 PDG_DBG_PRINT_START 05291 PDG_DBG_PRINT_C("fei_loc_cmr"); 05292 PDG_DBG_PRINT_END 05293 05294 # ifdef _ENABLE_FEI 05295 fei_loc_cmr(); 05296 # endif 05297 break; 05298 05299 05300 05301 05302 05303 case Write_Memory_Barrier_Opr : 05304 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05305 IR_FLD_L(ir_idx)); 05306 05307 PDG_DBG_PRINT_START 05308 PDG_DBG_PRINT_C("fei_wmb"); 05309 PDG_DBG_PRINT_END 05310 05311 # ifdef _ENABLE_FEI 05312 fei_wmb(); 05313 # endif 05314 break; 05315 05316 05317 05318 05319 05320 05321 case Remote_Write_Barrier_Opr : 05322 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05323 IR_FLD_L(ir_idx)); 05324 05325 PDG_DBG_PRINT_START 05326 PDG_DBG_PRINT_C("fei_rem_cmr"); 05327 PDG_DBG_PRINT_END 05328 05329 # ifdef _ENABLE_FEI 05330 fei_rem_cmr(); 05331 # endif 05332 break; 05333 05334 05335 05336 05337 05338 05339 05340 case Get_Ieee_Status_Opr : 05341 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05342 IR_FLD_L(ir_idx)); 05343 05344 PDG_DBG_PRINT_START 05345 PDG_DBG_PRINT_C("fei_readsr"); 05346 PDG_DBG_PRINT_END 05347 05348 # ifdef _ENABLE_FEI 05349 fei_readsr(); 05350 # endif 05351 break; 05352 05353 05354 05355 05356 05357 case Set_Ieee_Status_Opr : 05358 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05359 IR_FLD_L(ir_idx)); 05360 05361 PDG_DBG_PRINT_START 05362 PDG_DBG_PRINT_C("fei_set_ieee_stat"); 05363 PDG_DBG_PRINT_END 05364 05365 # ifdef _ENABLE_FEI 05366 fei_set_ieee_stat(); 05367 # endif 05368 break; 05369 05370 05371 05372 05373 05374 case Get_Ieee_Exceptions_Opr : 05375 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05376 IR_FLD_L(ir_idx)); 05377 05378 PDG_DBG_PRINT_START 05379 PDG_DBG_PRINT_C("fei_get_all_estat"); 05380 PDG_DBG_PRINT_END 05381 05382 # ifdef _ENABLE_FEI 05383 fei_get_all_estat(); 05384 # endif 05385 break; 05386 05387 05388 05389 05390 05391 case Set_Ieee_Exceptions_Opr : 05392 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05393 IR_FLD_L(ir_idx)); 05394 05395 PDG_DBG_PRINT_START 05396 PDG_DBG_PRINT_C("fei_set_all_estat"); 05397 PDG_DBG_PRINT_END 05398 05399 # ifdef _ENABLE_FEI 05400 fei_set_all_estat(); 05401 # endif 05402 break; 05403 05404 05405 05406 05407 05408 case Test_Ieee_Exception_Opr : 05409 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05410 IR_FLD_L(ir_idx)); 05411 05412 PDG_DBG_PRINT_START 05413 PDG_DBG_PRINT_C("fei_test_estat"); 05414 PDG_DBG_PRINT_END 05415 05416 # ifdef _ENABLE_FEI 05417 fei_test_estat(); 05418 # endif 05419 break; 05420 05421 05422 05423 05424 05425 case Clear_Ieee_Exception_Opr : 05426 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05427 IR_FLD_L(ir_idx)); 05428 05429 PDG_DBG_PRINT_START 05430 PDG_DBG_PRINT_C("fei_set_estat"); 05431 PDG_DBG_PRINT_END 05432 05433 # ifdef _ENABLE_FEI 05434 fei_set_estat(); 05435 # endif 05436 break; 05437 05438 05439 05440 05441 05442 case Set_Ieee_Exception_Opr : 05443 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05444 IR_FLD_L(ir_idx)); 05445 05446 PDG_DBG_PRINT_START 05447 PDG_DBG_PRINT_C("fei_set_estat"); 05448 PDG_DBG_PRINT_END 05449 05450 # ifdef _ENABLE_FEI 05451 fei_set_estat(); 05452 # endif 05453 break; 05454 05455 05456 05457 05458 05459 case Get_Ieee_Interrupts_Opr : 05460 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05461 IR_FLD_L(ir_idx)); 05462 05463 PDG_DBG_PRINT_START 05464 PDG_DBG_PRINT_C("fei_get_interupt"); 05465 PDG_DBG_PRINT_END 05466 05467 # ifdef _ENABLE_FEI 05468 fei_get_interupt(); 05469 # endif 05470 break; 05471 05472 05473 05474 05475 case Set_Ieee_Interrupts_Opr : 05476 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05477 IR_FLD_L(ir_idx)); 05478 05479 PDG_DBG_PRINT_START 05480 PDG_DBG_PRINT_C("fei_set_interupt"); 05481 PDG_DBG_PRINT_END 05482 05483 # ifdef _ENABLE_FEI 05484 fei_set_interupt(); 05485 # endif 05486 break; 05487 05488 05489 05490 05491 05492 case Test_Ieee_Interrupt_Opr : 05493 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05494 IR_FLD_L(ir_idx)); 05495 05496 PDG_DBG_PRINT_START 05497 PDG_DBG_PRINT_C("fei_test_interupt"); 05498 PDG_DBG_PRINT_END 05499 05500 # ifdef _ENABLE_FEI 05501 fei_test_interupt(); 05502 # endif 05503 break; 05504 05505 05506 05507 05508 05509 05510 05511 05512 case Enable_Ieee_Interrupt_Opr : 05513 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05514 IR_FLD_L(ir_idx)); 05515 05516 PDG_DBG_PRINT_START 05517 PDG_DBG_PRINT_C("fei_enbl_interupt"); 05518 PDG_DBG_PRINT_END 05519 05520 # ifdef _ENABLE_FEI 05521 fei_enbl_interupt(); 05522 # endif 05523 break; 05524 05525 05526 05527 05528 05529 05530 05531 case Disable_Ieee_Interrupt_Opr : 05532 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05533 IR_FLD_L(ir_idx)); 05534 05535 PDG_DBG_PRINT_START 05536 PDG_DBG_PRINT_C("fei_dsbl_interupt"); 05537 PDG_DBG_PRINT_END 05538 05539 # ifdef _ENABLE_FEI 05540 fei_dsbl_interupt(); 05541 # endif 05542 break; 05543 05544 05545 05546 05547 05548 case Get_Ieee_Rounding_Mode_Opr : 05549 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05550 IR_FLD_L(ir_idx)); 05551 05552 PDG_DBG_PRINT_START 05553 PDG_DBG_PRINT_C("fei_get_rmode"); 05554 PDG_DBG_PRINT_END 05555 05556 # ifdef _ENABLE_FEI 05557 fei_get_rmode(); 05558 # endif 05559 break; 05560 05561 05562 05563 05564 case Set_Ieee_Rounding_Mode_Opr : 05565 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05566 IR_FLD_L(ir_idx)); 05567 05568 PDG_DBG_PRINT_START 05569 PDG_DBG_PRINT_C("fei_set_rmode"); 05570 PDG_DBG_PRINT_END 05571 05572 # ifdef _ENABLE_FEI 05573 fei_set_rmode(); 05574 # endif 05575 break; 05576 05577 05578 05579 05580 05581 05582 05583 05584 05585 05586 05587 05588 05589 05590 05591 05592 05593 05594 05595 05596 05597 05598 case Alloc_Opr : 05599 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05600 IR_FLD_L(ir_idx)); 05601 05602 PDG_DBG_PRINT_START 05603 PDG_DBG_PRINT_C("fei_alloc"); 05604 PDG_DBG_PRINT_END 05605 05606 # ifdef _ENABLE_FEI 05607 fei_alloc(); 05608 # endif 05609 break; 05610 05611 05612 05613 05614 case Malloc_Opr : 05615 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05616 IR_FLD_L(ir_idx)); 05617 05618 PDG_DBG_PRINT_START 05619 PDG_DBG_PRINT_C("fei_malloc"); 05620 PDG_DBG_PRINT_END 05621 05622 # ifdef _ENABLE_FEI 05623 # if defined(GENERATE_WHIRL) 05624 fei_malloc(); 05625 # endif 05626 # endif 05627 break; 05628 05629 05630 05631 05632 05633 case SSD_Alloc_Opr : 05634 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05635 IR_FLD_L(ir_idx)); 05636 05637 PDG_DBG_PRINT_START 05638 PDG_DBG_PRINT_C("fei_ssd_alloc"); 05639 PDG_DBG_PRINT_END 05640 05641 # ifdef _ENABLE_FEI 05642 fei_ssd_alloc(); 05643 # endif 05644 break; 05645 05646 05647 05648 05649 case Symmetric_Alloc_Opr : 05650 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05651 IR_FLD_L(ir_idx)); 05652 05653 PDG_DBG_PRINT_START 05654 PDG_DBG_PRINT_C("fei_mpp_symmetric_alloc"); 05655 PDG_DBG_PRINT_END 05656 05657 # ifdef _ENABLE_FEI 05658 fei_mpp_symmetric_alloc(); 05659 # endif 05660 break; 05661 05662 05663 05664 05665 05666 case Dealloc_Opr : 05667 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05668 IR_FLD_L(ir_idx)); 05669 05670 PDG_DBG_PRINT_START 05671 PDG_DBG_PRINT_C("fei_free"); 05672 PDG_DBG_PRINT_END 05673 05674 # ifdef _ENABLE_FEI 05675 fei_free(); 05676 # endif 05677 break; 05678 05679 05680 05681 05682 case Free_Opr : 05683 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05684 IR_FLD_L(ir_idx)); 05685 05686 PDG_DBG_PRINT_START 05687 PDG_DBG_PRINT_C("fei_mfree"); 05688 PDG_DBG_PRINT_END 05689 05690 # ifdef _ENABLE_FEI 05691 # if defined(GENERATE_WHIRL) 05692 fei_mfree(); 05693 # endif 05694 # endif 05695 break; 05696 05697 05698 05699 05700 05701 05702 case SSD_Dealloc_Opr : 05703 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05704 IR_FLD_L(ir_idx)); 05705 05706 PDG_DBG_PRINT_START 05707 PDG_DBG_PRINT_C("fei_ssd_free"); 05708 PDG_DBG_PRINT_END 05709 05710 # ifdef _ENABLE_FEI 05711 fei_ssd_free(); 05712 # endif 05713 break; 05714 05715 05716 05717 case Symmetric_Dealloc_Opr : 05718 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05719 IR_FLD_L(ir_idx)); 05720 05721 PDG_DBG_PRINT_START 05722 PDG_DBG_PRINT_C("fei_mpp_symmetric_free"); 05723 PDG_DBG_PRINT_END 05724 05725 # ifdef _ENABLE_FEI 05726 fei_mpp_symmetric_free(); 05727 # endif 05728 break; 05729 05730 05731 05732 05733 case Copyin_Bound_Opr : 05734 # if defined(GENERATE_WHIRL) 05735 send_attr_ntry(IR_IDX_L(ir_idx)); 05736 05737 PDG_DBG_PRINT_START 05738 PDG_DBG_PRINT_C("fei_copyin_bound"); 05739 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_L(ir_idx))); 05740 PDG_DBG_PRINT_END 05741 05742 # ifdef _ENABLE_FEI 05743 fei_copyin_bound(PDG_AT_IDX(IR_IDX_L(ir_idx))); 05744 # endif 05745 # endif 05746 break; 05747 05748 05749 05750 case Copy_In_Opr : 05751 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05752 IR_FLD_L(ir_idx)); 05753 05754 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 05755 IR_FLD_R(ir_idx)); 05756 05757 PDG_DBG_PRINT_START 05758 PDG_DBG_PRINT_C("fei_copyin"); 05759 PDG_DBG_PRINT_END 05760 05761 # ifdef _ENABLE_FEI 05762 fei_copyin(); 05763 # endif 05764 break; 05765 05766 05767 05768 05769 05770 05771 case Copy_Out_Opr : 05772 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05773 IR_FLD_L(ir_idx)); 05774 05775 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 05776 IR_FLD_R(ir_idx)); 05777 05778 PDG_DBG_PRINT_START 05779 PDG_DBG_PRINT_C("fei_copyout"); 05780 PDG_DBG_PRINT_END 05781 05782 # ifdef _ENABLE_FEI 05783 fei_copyout(); 05784 # endif 05785 break; 05786 05787 case Kwd_Opr: /*FMZ August 2005 */ 05788 #ifdef SOURCE_TO_SOURCE 05789 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), /* Kwd */ 05790 IR_FLD_L(ir_idx)); 05791 #endif 05792 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), /* argument */ 05793 IR_FLD_R(ir_idx)); 05794 break; 05795 05796 case Struct_Opr : 05797 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05798 IR_FLD_L(ir_idx)); 05799 05800 data_attr = NULL_IDX; 05801 member = TRUE; 05802 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 05803 IR_FLD_R(ir_idx)); 05804 member = FALSE; 05805 05806 if (stack_data_object) { 05807 break; 05808 } 05809 05810 if (IR_FLD_L(ir_idx)==AT_Tbl_Idx ) 05811 type_idx = ATD_TYPE_IDX(IR_IDX_L(ir_idx)); 05812 else 05813 type_idx = IR_TYPE_IDX(IR_IDX_L(ir_idx)); 05814 05815 basic = get_basic_type(type_idx,0, NULL_IDX); 05816 05817 PDG_DBG_PRINT_START 05818 PDG_DBG_PRINT_C("fei_field_dot"); 05819 PDG_DBG_PRINT_END 05820 05821 # ifdef _ENABLE_FEI 05822 # if 0 05823 fei_field_dot(null_type); 05824 # else 05825 fei_field_dot(basic); 05826 # endif 05827 05828 # endif 05829 05830 break; 05831 05832 05833 05834 05835 05836 05837 case Triplet_Opr : 05838 05839 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 05840 IR_FLD_L(ir_idx)); 05841 05842 PDG_DBG_PRINT_START 05843 PDG_DBG_PRINT_C("fei_subscr_triplet"); 05844 PDG_DBG_PRINT_END 05845 05846 # ifdef _ENABLE_FEI 05847 /* fei_subscr_triplet(pdg_type_void); */ 05848 fei_subscr_src_triplet(pdg_type_void); 05849 # endif 05850 break; 05851 05852 05853 05854 05855 case Max_Opr : 05856 case Min_Opr : 05857 tmp_ir_idx = IR_IDX_L(ir_idx); 05858 count = 0; 05859 while (tmp_ir_idx != NULL_IDX) { 05860 if (IL_IDX(tmp_ir_idx) != NULL_IDX) { 05861 cvrt_exp_to_pdg(IL_IDX(tmp_ir_idx), 05862 IL_FLD(tmp_ir_idx)); 05863 05864 count = count + 1; 05865 } 05866 tmp_ir_idx = IL_NEXT_LIST_IDX(tmp_ir_idx); 05867 } 05868 05869 basic = get_basic_type(IR_TYPE_IDX(ir_idx),0, NULL_IDX); 05870 05871 if (IR_OPR(ir_idx) == Min_Opr) { 05872 PDG_DBG_PRINT_START 05873 PDG_DBG_PRINT_C("fei_min"); 05874 PDG_DBG_PRINT_D("(1) count", count); 05875 PDG_DBG_PRINT_T("(2) type", basic); 05876 PDG_DBG_PRINT_END 05877 # ifdef _ENABLE_FEI 05878 fei_min(count, basic); 05879 # endif 05880 } 05881 else { 05882 PDG_DBG_PRINT_START 05883 PDG_DBG_PRINT_C("fei_max"); 05884 PDG_DBG_PRINT_D("(1) count", count); 05885 PDG_DBG_PRINT_T("(2) type", basic); 05886 PDG_DBG_PRINT_END 05887 # ifdef _ENABLE_FEI 05888 fei_max(count, basic); 05889 # endif 05890 } 05891 break; 05892 05893 05894 05895 05896 05897 05898 05899 case Implied_Do_Opr : 05900 if (processing_io_stmt) 05901 { 05902 if (static_initialization) { 05903 /* skip over DO control variable before starting loop */ 05904 search_idx = IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx)); 05905 05906 trip = 1; 05907 while (trip != 4) { 05908 if (trip == 1) { /* start */ 05909 COPY_OPND(l_opnd, IL_OPND(search_idx)); 05910 vv = 1; 05911 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 05912 COPY_OPND(IL_OPND(search_idx), l_opnd); 05913 start = CN_INT_TO_C(cn_idx); 05914 } 05915 05916 if (trip == 2) { /* end */ 05917 COPY_OPND(l_opnd, IL_OPND(search_idx)); 05918 vv = 1; 05919 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 05920 COPY_OPND(IL_OPND(search_idx), l_opnd); 05921 end = CN_INT_TO_C(cn_idx); 05922 } 05923 05924 if (trip == 3) { /* inc */ 05925 COPY_OPND(l_opnd, IL_OPND(search_idx)); 05926 vv = 1; 05927 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 05928 COPY_OPND(IL_OPND(search_idx), l_opnd); 05929 inc = CN_INT_TO_C(cn_idx); 05930 } 05931 05932 trip = trip + 1; 05933 search_idx = IL_NEXT_LIST_IDX(search_idx); 05934 } 05935 05936 /* Save the guts of the LCV attr. Store them in a constant entry */ 05937 /* pointed to by ATD_TMP_IDX. */ 05938 05939 GET_LCV_CONST(IL_IDX(IR_IDX_R(ir_idx)), 05940 loc_value[0], /* target constant */ 05941 num_host_wds[TYP_LINEAR( 05942 ATD_TYPE_IDX(IL_IDX(IR_IDX_R(ir_idx))))]); 05943 05944 ATD_FLD(IL_IDX(IR_IDX_R(ir_idx))) = CN_Tbl_Idx; 05945 ATD_TMP_IDX(IL_IDX(IR_IDX_R(ir_idx))) = 05946 ntr_const_tbl(ATD_TYPE_IDX(IL_IDX(IR_IDX_R(ir_idx))), 05947 FALSE, 05948 loc_value); 05949 05950 if (inc > 0) { /* run the loop forward */ 05951 for (i = start; i <= end; i = i + inc) { 05952 05953 if (search_idx == NULL_IDX) { 05954 cn_idx = C_INT_TO_CN(NULL_IDX, i); /* Macro sets type */ 05955 } 05956 else { 05957 COPY_OPND(l_opnd, IL_OPND(search_idx)); 05958 vv = i; 05959 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 05960 COPY_OPND(IL_OPND(search_idx), l_opnd); 05961 } 05962 05963 SET_LCV_CONST(IL_IDX(IR_IDX_R(ir_idx)), 05964 CN_CONST(cn_idx), 05965 num_host_wds[TYP_LINEAR( 05966 ATD_TYPE_IDX(IL_IDX(IR_IDX_R(ir_idx))))]); 05967 05968 t_idx = IR_IDX_L(ir_idx); 05969 while (t_idx != NULL_IDX) { 05970 05971 if ((IL_FLD(t_idx) == IR_Tbl_Idx) && 05972 (IR_OPR(IL_IDX(t_idx)) == Implied_Do_Opr)) { 05973 cvrt_exp_to_pdg(IL_IDX(t_idx), 05974 IL_FLD(t_idx)); 05975 } 05976 else { 05977 blank_pad_text = IL_IDX(t_idx); 05978 push_data_value(t_idx); 05979 } 05980 05981 t_idx = IL_NEXT_LIST_IDX(t_idx); 05982 } 05983 } 05984 } 05985 else { /* increment is <= 0 */ 05986 for (i = start; i >= end; i = i + inc) { 05987 05988 if (search_idx == NULL_IDX) { 05989 cn_idx = C_INT_TO_CN(NULL_IDX, i); /* Macro sets type */ 05990 } 05991 else { 05992 COPY_OPND(l_opnd, IL_OPND(search_idx)); 05993 vv = i; 05994 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 05995 COPY_OPND(IL_OPND(search_idx), l_opnd); 05996 } 05997 05998 SET_LCV_CONST(IL_IDX(IR_IDX_R(ir_idx)), 05999 CN_CONST(cn_idx), 06000 num_host_wds[TYP_LINEAR( 06001 ATD_TYPE_IDX(IL_IDX(IR_IDX_R(ir_idx))))]); 06002 06003 t_idx = IR_IDX_L(ir_idx); 06004 while (t_idx != NULL_IDX) { 06005 06006 if ((IL_FLD(t_idx) == IR_Tbl_Idx) && 06007 (IR_OPR(IL_IDX(t_idx)) == Implied_Do_Opr)) { 06008 cvrt_exp_to_pdg(IL_IDX(t_idx), 06009 IL_FLD(t_idx)); 06010 } 06011 else { 06012 blank_pad_text = IL_IDX(t_idx); 06013 push_data_value(t_idx); 06014 } 06015 06016 t_idx = IL_NEXT_LIST_IDX(t_idx); 06017 } 06018 } 06019 } 06020 06021 /* Restore the guts of the LCV temp attr. */ 06022 SET_LCV_CONST(IL_IDX(IR_IDX_R(ir_idx)), 06023 CN_CONST(ATD_TMP_IDX(IL_IDX(IR_IDX_R(ir_idx)))), 06024 num_host_wds[TYP_LINEAR( 06025 ATD_TYPE_IDX(IL_IDX(IR_IDX_R(ir_idx))))]); 06026 06027 } 06028 else { 06029 search_idx = IR_IDX_R(ir_idx); 06030 while (search_idx != NULL_IDX) { 06031 cvrt_exp_to_pdg(IL_IDX(search_idx), 06032 IL_FLD(search_idx)); 06033 06034 search_idx = IL_NEXT_LIST_IDX(search_idx); 06035 } 06036 06037 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06038 IR_FLD_L(ir_idx)); 06039 06040 PDG_DBG_PRINT_START 06041 PDG_DBG_PRINT_C("fei_IO_list"); 06042 PDG_DBG_PRINT_D("(1) list count", IR_LIST_CNT_L(ir_idx)); 06043 PDG_DBG_PRINT_S("(2) io_type", p_io[io_type]); 06044 PDG_DBG_PRINT_END 06045 06046 # ifdef _ENABLE_FEI 06047 fei_IO_list(IR_LIST_CNT_L(ir_idx), io_type); 06048 # endif 06049 06050 PDG_DBG_PRINT_START 06051 PDG_DBG_PRINT_C("fei_implied_do"); 06052 PDG_DBG_PRINT_END 06053 06054 # ifdef _ENABLE_FEI 06055 fei_implied_do(); 06056 # endif 06057 06058 } 06059 } 06060 else /*not in IO stmt,therefore don't generate IO_ITEM */ 06061 06062 { 06063 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06064 IR_FLD_L(ir_idx)); 06065 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 06066 IR_FLD_R(ir_idx)); 06067 06068 PDG_DBG_PRINT_START 06069 PDG_DBG_PRINT_C("fei_noio_implied_do"); 06070 PDG_DBG_PRINT_END 06071 06072 # ifdef _ENABLE_FEI 06073 fei_noio_implied_do(); 06074 # endif 06075 06076 } 06077 break; 06078 06079 06080 06081 06082 06083 case Init_Opr : 06084 if ((IR_FLD_L(ir_idx) == IR_Tbl_Idx) && 06085 (IR_OPR(IR_IDX_L(ir_idx)) == Implied_Do_Opr)) { 06086 06087 static_initialization = TRUE; 06088 06089 data_value_idx = IR_IDX_R(ir_idx); 06090 while (data_value_idx != NULL_IDX) { 06091 if (IL_FLD(data_value_idx) == IR_Tbl_Idx) { 06092 IL_LIST_CNT(data_value_idx) = 06093 CN_INT_TO_C(IR_IDX_L(IL_IDX(data_value_idx))); 06094 } 06095 else { 06096 IL_LIST_CNT(data_value_idx) = 1; 06097 } 06098 data_value_idx = IL_NEXT_LIST_IDX(data_value_idx); 06099 } 06100 data_value_idx = IR_IDX_R(ir_idx); 06101 06102 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06103 IR_FLD_L(ir_idx)); 06104 06105 static_initialization = FALSE; 06106 } 06107 else { 06108 data_attr = NULL_IDX; 06109 stack_data_object = TRUE; 06110 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), /* stack the object */ 06111 IR_FLD_L(ir_idx)); 06112 stack_data_object = FALSE; 06113 06114 list_idx1 = IR_IDX_R(ir_idx); 06115 stack_data_constant = TRUE; 06116 cvrt_exp_to_pdg(IL_IDX(list_idx1), /* stack the constant */ 06117 IL_FLD(list_idx1)); 06118 stack_data_constant = FALSE; 06119 06120 list_idx2 = IL_NEXT_LIST_IDX(list_idx1); 06121 list_idx3 = IL_NEXT_LIST_IDX(list_idx2); 06122 06123 if (TYP_TYPE(CN_TYPE_IDX(IL_IDX(list_idx1))) == Typeless || 06124 (TYP_TYPE(CN_TYPE_IDX(IL_IDX(list_idx1))) == Character && 06125 TYP_TYPE(ATD_TYPE_IDX(data_attr)) != Character)) { 06126 ignore_types = TRUE; 06127 } 06128 else { 06129 ignore_types = FALSE; 06130 } 06131 rep_count = CN_INT_TO_C(IL_IDX(list_idx2)); 06132 stride = CN_INT_TO_C(IL_IDX(list_idx3)); 06133 06134 # if defined(_TARGET_OS_MAX) || defined(_HOST32) 06135 06136 /* JEFFL - Is this necessary for HOST32 ? */ 06137 if (TYP_LINEAR(CN_TYPE_IDX(IL_IDX(list_idx3))) != Integer_8) { 06138 SIGN_EXTEND(stride); 06139 } 06140 # endif 06141 06142 PDG_DBG_PRINT_START 06143 PDG_DBG_PRINT_C("fei_static_simple_init"); 06144 PDG_DBG_PRINT_LLD("(1) rep_count", rep_count); 06145 PDG_DBG_PRINT_LLD("(2) stride", stride); 06146 PDG_DBG_PRINT_D("(3) ignore_types", ignore_types); 06147 PDG_DBG_PRINT_D("(4) unused", 0); 06148 PDG_DBG_PRINT_END 06149 06150 # ifdef _ENABLE_FEI 06151 fei_static_simple_init(rep_count, 06152 stride, 06153 ignore_types, 06154 0); 06155 # endif 06156 } 06157 06158 break; 06159 06160 06161 06162 case Init_Reloc_Opr : 06163 data_attr = NULL_IDX; 06164 stack_data_object = TRUE; 06165 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), /* stack the object */ 06166 IR_FLD_L(ir_idx)); 06167 stack_data_object = FALSE; 06168 06169 offset = 0; 06170 06171 # ifdef _INIT_RELOC_BASE_OFFSET 06172 06173 offset2.idx = IL_IDX(IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx))); 06174 offset2.fld = IL_FLD(IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx))); 06175 06176 COPY_OPND(opnd, IL_OPND(IR_IDX_R(ir_idx))); 06177 attr_idx = find_left_attr(&opnd); 06178 send_attr_ntry(attr_idx); 06179 offset1.idx = ATD_OFFSET_IDX(attr_idx); 06180 offset1.fld = ATD_OFFSET_FLD(attr_idx); 06181 result.idx = ATD_OFFSET_IDX( 06182 SB_FIRST_ATTR_IDX(ATD_STOR_BLK_IDX(attr_idx))); 06183 result.fld = ATD_OFFSET_FLD( 06184 SB_FIRST_ATTR_IDX(ATD_STOR_BLK_IDX(attr_idx))); 06185 06186 size_offset_binary_calc(&offset1, &result, Minus_Opr, &result); 06187 size_offset_binary_calc(&offset2, &result, Plus_Opr, &result); 06188 06189 /* Someday this may not be a constant. (KAYKAY) */ 06190 06191 if (result.fld == CN_Tbl_Idx) { 06192 offset = CN_INT_TO_C(CN_CONST(result.idx)); 06193 06194 # if defined(_TARGET_OS_MAX) || defined(_HOST32) /* JEFFL - BRIANJ */ 06195 if (TYP_LINEAR(CN_TYPE_IDX(result.idx)) != Integer_8) { 06196 SIGN_EXTEND(offset); 06197 } 06198 # endif 06199 } 06200 else { 06201 offset = F_INT_TO_C(result.constant, TYP_LINEAR(result.type_idx)); 06202 } 06203 06204 attr_idx = SB_FIRST_ATTR_IDX(ATD_STOR_BLK_IDX(attr_idx)); 06205 send_attr_ntry(attr_idx); 06206 06207 OPND_FLD(opnd) = AT_Tbl_Idx; 06208 OPND_IDX(opnd) = attr_idx; 06209 OPND_LINE_NUM(opnd) = IR_LINE_NUM(ir_idx); 06210 OPND_COL_NUM(opnd) = IR_COL_NUM(ir_idx); 06211 06212 if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character) { 06213 unused = gen_whole_substring(&opnd, 0); 06214 } 06215 06216 /* assumes there is a loc or aloc on top */ 06217 COPY_OPND(IR_OPND_L(IL_IDX(IR_IDX_R(ir_idx))), opnd); 06218 # endif 06219 06220 cvrt_exp_to_pdg(IL_IDX(IR_IDX_R(ir_idx)), 06221 IL_FLD(IR_IDX_R(ir_idx))); 06222 06223 PDG_DBG_PRINT_START 06224 PDG_DBG_PRINT_C("fei_static_simple_reloc_init"); 06225 PDG_DBG_PRINT_LLD("(1) offset", offset); 06226 PDG_DBG_PRINT_LLD("(2) rep count", (long64) 1); 06227 PDG_DBG_PRINT_D("(3) stride", TARGET_BITS_PER_WORD); 06228 PDG_DBG_PRINT_LLD("(4) bit size", (long64) 0); 06229 PDG_DBG_PRINT_D("(5) ignore_types", 1); 06230 PDG_DBG_PRINT_END 06231 06232 # ifdef _ENABLE_FEI 06233 fei_static_simple_reloc_init(offset, 06234 (long64) 1, 06235 (long64) TARGET_BITS_PER_WORD, 06236 (long64) 0, 06237 1); 06238 # endif 06239 break; 06240 06241 06242 06243 case Whole_Subscript_Opr : 06244 case Section_Subscript_Opr: 06245 case Subscript_Opr : 06246 nested_array++; 06247 if (!is_subscript) 06248 is_subscript = TRUE; 06249 06250 whole_subscript = IR_WHOLE_ARRAY(ir_idx); 06251 06252 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06253 IR_FLD_L(ir_idx)); 06254 06255 whole_subscript = FALSE; 06256 06257 06258 if (IR_OPR(ir_idx) == Whole_Subscript_Opr && 06259 !processing_io_stmt && 06260 IR_CONTIG_ARRAY(ir_idx) != 0 ) { 06261 06262 /* this is a contiguous array. */ 06263 /* call fei_as_ref and ignore subscripts */ 06264 06265 PDG_DBG_PRINT_START 06266 PDG_DBG_PRINT_C("fei_as_ref"); 06267 PDG_DBG_PRINT_END 06268 06269 # ifdef _ENABLE_FEI 06270 fei_as_ref(null_type); 06271 # endif 06272 break; 06273 } 06274 06275 if (IR_OPR(ir_idx) == Whole_Subscript_Opr && 06276 processing_call) { 06277 is_subscript = FALSE; 06278 nested_array = 0; 06279 break; 06280 } 06281 06282 attr_idx = find_base_attr(&IR_OPND_L(ir_idx), &line, &col); 06283 bound_idx = ATD_ARRAY_IDX(attr_idx); 06284 # if defined(COARRAY_FORTRAN) 06285 pe_bd_idx = ATD_PE_ARRAY_IDX(attr_idx); 06286 # endif 06287 06288 base_attr = find_left_attr(&(IR_OPND_L(ir_idx))); 06289 06290 bound_chk = (cdir_switches.bounds || 06291 ATD_BOUNDS_CHECK(base_attr)) && 06292 !ATD_NOBOUNDS_CHECK(base_attr); 06293 06294 bound_chk &= ! (IR_WHOLE_ARRAY(ir_idx)); 06295 06296 if (IR_BOUNDS_DONE(ir_idx)) { 06297 bound_chk = FALSE; 06298 } 06299 06300 next_idx = IR_IDX_R(ir_idx); 06301 dim = IR_LIST_CNT_R(ir_idx); 06302 /* while (dim != 1) { */ 06303 while (dim > 1) { 06304 next_idx = IL_NEXT_LIST_IDX(next_idx); 06305 dim = dim - 1; 06306 } 06307 06308 /* dim = IR_LIST_CNT_R(ir_idx); */ 06309 dim = BD_RANK(bound_idx); 06310 ss = 0; 06311 06312 # if defined(COARRAY_FORTRAN) 06313 /* co_dim could be 0 if the coarray referenced without co_rank */ 06314 /* co_dim = BD_RANK(pe_bd_idx); */ 06315 06316 co_dim = IR_LIST_CNT_R(ir_idx)-BD_RANK(bound_idx); 06317 06318 while (co_dim > 0) { 06319 06320 if (stack_data_object) { 06321 COPY_OPND(l_opnd, IL_OPND(next_idx)); 06322 /* l_opnd will always be a scalar expression here */ 06323 vv = 1; 06324 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 06325 COPY_OPND(IL_OPND(next_idx), l_opnd); 06326 static_subscripts[ss] = CN_INT_TO_C(cn_idx); 06327 06328 # if defined(_TARGET_OS_MAX) || defined(_HOST32) /* JEFFL */ 06329 if (TYP_LINEAR(CN_TYPE_IDX(cn_idx)) != Integer_8) { 06330 SIGN_EXTEND(static_subscripts[ss]); 06331 } 06332 # endif 06333 goto CONTINUE_CO; 06334 } 06335 06336 cvrt_exp_to_pdg(IL_IDX(next_idx), 06337 IL_FLD(next_idx)); 06338 06339 if (ATD_IM_A_DOPE(attr_idx)) { 06340 cvrt_exp_to_pdg(IR_IDX_L(IR_IDX_L(ir_idx)), 06341 IR_FLD_L(IR_IDX_L(ir_idx))); 06342 06343 PDG_DBG_PRINT_START 06344 PDG_DBG_PRINT_C("fei_get_dv_low_bnd"); 06345 PDG_DBG_PRINT_D("(1) dim", dim); 06346 PDG_DBG_PRINT_D("(2) expand immed", EXPAND); 06347 PDG_DBG_PRINT_END 06348 # ifdef _ENABLE_FEI 06349 fei_get_dv_low_bnd(dim, EXPAND); 06350 # endif 06351 } 06352 # if defined(COARRAY_FORTRAN) && defined(_TARGET_OS_MAX) 06353 else if (IL_PE_SUBSCRIPT(next_idx)) { 06354 cvrt_exp_to_pdg(CN_INTEGER_ONE_IDX, 06355 CN_Tbl_Idx); 06356 } 06357 # endif 06358 else { 06359 if (BD_ARRAY_CLASS(pe_bd_idx)!= Deferred_Shape && 06360 BD_ARRAY_CLASS(pe_bd_idx)!= Deferred_Shape1) 06361 06362 cvrt_exp_to_pdg(BD_LB_IDX(pe_bd_idx, co_dim), 06363 BD_LB_FLD(pe_bd_idx, co_dim)); 06364 else fei_implicit_expr(); 06365 } 06366 06367 if (ATD_IM_A_DOPE(attr_idx)) { 06368 cvrt_exp_to_pdg(IR_IDX_L(IR_IDX_L(ir_idx)), 06369 IR_FLD_L(IR_IDX_L(ir_idx))); 06370 06371 PDG_DBG_PRINT_START 06372 PDG_DBG_PRINT_C("fei_get_dv_extent"); 06373 PDG_DBG_PRINT_D("(1) dim", dim); 06374 PDG_DBG_PRINT_D("(2) expand immed", EXPAND); 06375 PDG_DBG_PRINT_END 06376 # ifdef _ENABLE_FEI 06377 fei_get_dv_extent(dim, EXPAND); 06378 # endif 06379 } 06380 # if defined(COARRAY_FORTRAN) && defined(_TARGET_OS_MAX) 06381 else if (IL_PE_SUBSCRIPT(next_idx)) { 06382 cvrt_exp_to_pdg(BD_LEN_IDX(pe_bd_idx), 06383 BD_LEN_FLD(pe_bd_idx)); 06384 } 06385 # endif 06386 else { 06387 if (BD_ARRAY_CLASS(pe_bd_idx)!= Deferred_Shape && 06388 BD_ARRAY_CLASS(pe_bd_idx)!= Deferred_Shape1) 06389 cvrt_exp_to_pdg(BD_XT_IDX(pe_bd_idx, co_dim), 06390 BD_XT_FLD(pe_bd_idx, co_dim)); 06391 else fei_implicit_expr(); 06392 } 06393 06394 if (ATD_IM_A_DOPE(attr_idx)) { 06395 cvrt_exp_to_pdg(IR_IDX_L(IR_IDX_L(ir_idx)), 06396 IR_FLD_L(IR_IDX_L(ir_idx))); 06397 06398 PDG_DBG_PRINT_START 06399 PDG_DBG_PRINT_C("fei_get_dv_str_mult"); 06400 PDG_DBG_PRINT_D("(1) dim", dim); 06401 PDG_DBG_PRINT_D("(2) expand immed", EXPAND); 06402 PDG_DBG_PRINT_END 06403 # ifdef _ENABLE_FEI 06404 fei_get_dv_str_mult(dim, EXPAND); 06405 # endif 06406 } 06407 # if defined(_EXTENDED_CRI_CHAR_POINTER) 06408 else if (AT_OBJ_CLASS(attr_idx) == Data_Obj && 06409 ATD_CLASS(attr_idx) == CRI_Pointee && 06410 TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character && 06411 TYP_CHAR_CLASS(ATD_TYPE_IDX(attr_idx)) == 06412 Assumed_Size_Char) { 06413 cvrt_exp_to_pdg(BD_SM_IDX(pe_bd_idx, co_dim), 06414 BD_SM_FLD(pe_bd_idx, co_dim)); 06415 06416 cvrt_exp_to_pdg(attr_idx, AT_Tbl_Idx); 06417 06418 basic = get_basic_type(ATD_TYPE_IDX(attr_idx), 06419 ATD_ALIGNMENT(attr_idx), 06420 attr_idx); 06421 06422 PDG_DBG_PRINT_START 06423 PDG_DBG_PRINT_C("fei_len"); 06424 PDG_DBG_PRINT_END 06425 06426 # ifdef _ENABLE_FEI 06427 /* fei_len(basic); */ 06428 fei_len(); 06429 # endif 06430 06431 basic = get_basic_type(INTEGER_DEFAULT_TYPE, 06432 type_alignment_tbl[INTEGER_DEFAULT_TYPE], 06433 NULL_IDX); 06434 06435 PDG_DBG_PRINT_START 06436 PDG_DBG_PRINT_C("fei_mult"); 06437 PDG_DBG_PRINT_END 06438 06439 # ifdef _ENABLE_FEI 06440 fei_mult(basic); 06441 # endif 06442 } 06443 # endif 06444 # if defined(COARRAY_FORTRAN) && defined(_TARGET_OS_MAX) 06445 else if (IL_PE_SUBSCRIPT(next_idx)) { 06446 cvrt_exp_to_pdg(CN_INTEGER_ONE_IDX, 06447 CN_Tbl_Idx); 06448 } 06449 # endif 06450 else { 06451 if (BD_ARRAY_CLASS(pe_bd_idx)!= Deferred_Shape && 06452 BD_ARRAY_CLASS(pe_bd_idx)!= Deferred_Shape1) 06453 06454 cvrt_exp_to_pdg(BD_SM_IDX(pe_bd_idx, co_dim), 06455 BD_SM_FLD(pe_bd_idx, co_dim)); 06456 else fei_implicit_expr(); 06457 } 06458 06459 if (BD_ARRAY_CLASS(pe_bd_idx) == Assumed_Size) { 06460 if (BD_RANK(pe_bd_idx) == IR_LIST_CNT_R(ir_idx) && ss == 0) { 06461 bound_chk = FALSE; 06462 } 06463 } 06464 06465 PDG_DBG_PRINT_START 06466 PDG_DBG_PRINT_C("fei_subscr_size"); 06467 PDG_DBG_PRINT_T("(1) type", pdg_type_void); 06468 PDG_DBG_PRINT_D("(2) bound_chk", bound_chk); 06469 PDG_DBG_PRINT_END 06470 # ifdef _ENABLE_FEI 06471 fei_subscr_size(pdg_type_void, bound_chk); 06472 # endif 06473 06474 if (ATD_IM_A_DOPE(attr_idx)) { 06475 PDG_DBG_PRINT_START 06476 PDG_DBG_PRINT_C("fei_nseq_subscr"); 06477 PDG_DBG_PRINT_T("(1) type", null_type); 06478 PDG_DBG_PRINT_END 06479 # ifdef _ENABLE_FEI 06480 fei_nseq_subscr(null_type); 06481 # endif 06482 } 06483 else { 06484 PDG_DBG_PRINT_START 06485 PDG_DBG_PRINT_C("fei_seq_subscr"); 06486 PDG_DBG_PRINT_T("(1) type", null_type); 06487 PDG_DBG_PRINT_END 06488 # ifdef _ENABLE_FEI 06489 fei_seq_subscr(null_type,IR_LIST_CNT_R(ir_idx)); 06490 # endif 06491 } 06492 06493 CONTINUE_CO: 06494 next_idx = IL_PREV_LIST_IDX(next_idx); 06495 co_dim =co_dim - 1; 06496 ss = ss + 1; 06497 } 06498 06499 # endif /*COARRAY */ 06500 06501 while (dim > 0) { 06502 06503 if (stack_data_object) { 06504 COPY_OPND(l_opnd, IL_OPND(next_idx)); 06505 /* l_opnd will always be a scalar expression here */ 06506 vv = 1; 06507 cn_idx = get_next_array_expr_element(&l_opnd, &vv); 06508 COPY_OPND(IL_OPND(next_idx), l_opnd); 06509 static_subscripts[ss] = CN_INT_TO_C(cn_idx); 06510 06511 # if defined(_TARGET_OS_MAX) || defined(_HOST32) /* JEFFL */ 06512 if (TYP_LINEAR(CN_TYPE_IDX(cn_idx)) != Integer_8) { 06513 SIGN_EXTEND(static_subscripts[ss]); 06514 } 06515 # endif 06516 goto CONTINUE; 06517 } 06518 06519 cvrt_exp_to_pdg(IL_IDX(next_idx), 06520 IL_FLD(next_idx)); 06521 06522 if (ATD_IM_A_DOPE(attr_idx)) { 06523 cvrt_exp_to_pdg(IR_IDX_L(IR_IDX_L(ir_idx)), 06524 IR_FLD_L(IR_IDX_L(ir_idx))); 06525 06526 PDG_DBG_PRINT_START 06527 PDG_DBG_PRINT_C("fei_get_dv_low_bnd"); 06528 PDG_DBG_PRINT_D("(1) dim", dim); 06529 PDG_DBG_PRINT_D("(2) expand immed", EXPAND); 06530 PDG_DBG_PRINT_END 06531 # ifdef _ENABLE_FEI 06532 fei_get_dv_low_bnd(dim, EXPAND); 06533 # endif 06534 } 06535 # if defined(COARRAY_FORTRAN) && defined(_TARGET_OS_MAX) 06536 else if (IL_PE_SUBSCRIPT(next_idx)) { 06537 cvrt_exp_to_pdg(CN_INTEGER_ONE_IDX, 06538 CN_Tbl_Idx); 06539 } 06540 # endif 06541 else { 06542 if (BD_ARRAY_CLASS(bound_idx)!= Deferred_Shape && 06543 BD_ARRAY_CLASS(bound_idx)!= Deferred_Shape1) 06544 06545 cvrt_exp_to_pdg(BD_LB_IDX(bound_idx, dim), 06546 BD_LB_FLD(bound_idx, dim)); 06547 else fei_implicit_expr(); 06548 } 06549 06550 if (ATD_IM_A_DOPE(attr_idx)) { 06551 cvrt_exp_to_pdg(IR_IDX_L(IR_IDX_L(ir_idx)), 06552 IR_FLD_L(IR_IDX_L(ir_idx))); 06553 06554 PDG_DBG_PRINT_START 06555 PDG_DBG_PRINT_C("fei_get_dv_extent"); 06556 PDG_DBG_PRINT_D("(1) dim", dim); 06557 PDG_DBG_PRINT_D("(2) expand immed", EXPAND); 06558 PDG_DBG_PRINT_END 06559 # ifdef _ENABLE_FEI 06560 fei_get_dv_extent(dim, EXPAND); 06561 # endif 06562 } 06563 # if defined(COARRAY_FORTRAN) && defined(_TARGET_OS_MAX) 06564 else if (IL_PE_SUBSCRIPT(next_idx)) { 06565 cvrt_exp_to_pdg(BD_LEN_IDX(pe_bd_idx), 06566 BD_LEN_FLD(pe_bd_idx)); 06567 } 06568 # endif 06569 else { 06570 if (BD_ARRAY_CLASS(bound_idx)!= Deferred_Shape && 06571 BD_ARRAY_CLASS(bound_idx)!= Deferred_Shape1) 06572 if (BD_XT_IDX(bound_idx, dim)) 06573 cvrt_exp_to_pdg(BD_XT_IDX(bound_idx, dim), 06574 BD_XT_FLD(bound_idx, dim)); 06575 else fei_implicit_expr(); 06576 else fei_implicit_expr(); 06577 } 06578 06579 if (ATD_IM_A_DOPE(attr_idx)) { 06580 cvrt_exp_to_pdg(IR_IDX_L(IR_IDX_L(ir_idx)), 06581 IR_FLD_L(IR_IDX_L(ir_idx))); 06582 06583 PDG_DBG_PRINT_START 06584 PDG_DBG_PRINT_C("fei_get_dv_str_mult"); 06585 PDG_DBG_PRINT_D("(1) dim", dim); 06586 PDG_DBG_PRINT_D("(2) expand immed", EXPAND); 06587 PDG_DBG_PRINT_END 06588 # ifdef _ENABLE_FEI 06589 fei_get_dv_str_mult(dim, EXPAND); 06590 # endif 06591 } 06592 # if defined(_EXTENDED_CRI_CHAR_POINTER) 06593 else if (AT_OBJ_CLASS(attr_idx) == Data_Obj && 06594 ATD_CLASS(attr_idx) == CRI_Pointee && 06595 TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character && 06596 TYP_CHAR_CLASS(ATD_TYPE_IDX(attr_idx)) == 06597 Assumed_Size_Char) { 06598 cvrt_exp_to_pdg(BD_SM_IDX(bound_idx, dim), 06599 BD_SM_FLD(bound_idx, dim)); 06600 06601 cvrt_exp_to_pdg(attr_idx, AT_Tbl_Idx); 06602 06603 basic = get_basic_type(ATD_TYPE_IDX(attr_idx), 06604 ATD_ALIGNMENT(attr_idx), 06605 attr_idx); 06606 06607 PDG_DBG_PRINT_START 06608 PDG_DBG_PRINT_C("fei_len"); 06609 PDG_DBG_PRINT_END 06610 06611 # ifdef _ENABLE_FEI 06612 /* fei_len(basic); */ 06613 fei_len(); 06614 # endif 06615 06616 basic = get_basic_type(INTEGER_DEFAULT_TYPE, 06617 type_alignment_tbl[INTEGER_DEFAULT_TYPE], 06618 NULL_IDX); 06619 06620 PDG_DBG_PRINT_START 06621 PDG_DBG_PRINT_C("fei_mult"); 06622 PDG_DBG_PRINT_END 06623 06624 # ifdef _ENABLE_FEI 06625 fei_mult(basic); 06626 # endif 06627 } 06628 # endif 06629 # if defined(COARRAY_FORTRAN) && defined(_TARGET_OS_MAX) 06630 else if (IL_PE_SUBSCRIPT(next_idx)) { 06631 cvrt_exp_to_pdg(CN_INTEGER_ONE_IDX, 06632 CN_Tbl_Idx); 06633 } 06634 # endif 06635 else { 06636 if (BD_ARRAY_CLASS(bound_idx)!= Deferred_Shape && 06637 BD_ARRAY_CLASS(bound_idx)!= Deferred_Shape1) 06638 06639 cvrt_exp_to_pdg(BD_SM_IDX(bound_idx, dim), 06640 BD_SM_FLD(bound_idx, dim)); 06641 else fei_implicit_expr(); 06642 } 06643 06644 if (BD_ARRAY_CLASS(bound_idx) == Assumed_Size) { 06645 if (BD_RANK(bound_idx) == IR_LIST_CNT_R(ir_idx) && ss == 0) { 06646 bound_chk = FALSE; 06647 } 06648 } 06649 06650 PDG_DBG_PRINT_START 06651 PDG_DBG_PRINT_C("fei_subscr_size"); 06652 PDG_DBG_PRINT_T("(1) type", pdg_type_void); 06653 PDG_DBG_PRINT_D("(2) bound_chk", bound_chk); 06654 PDG_DBG_PRINT_END 06655 # ifdef _ENABLE_FEI 06656 fei_subscr_size(pdg_type_void, bound_chk); 06657 # endif 06658 06659 if (ATD_IM_A_DOPE(attr_idx)) { 06660 PDG_DBG_PRINT_START 06661 PDG_DBG_PRINT_C("fei_nseq_subscr"); 06662 PDG_DBG_PRINT_T("(1) type", null_type); 06663 PDG_DBG_PRINT_END 06664 # ifdef _ENABLE_FEI 06665 fei_nseq_subscr(null_type); 06666 # endif 06667 } 06668 else { 06669 PDG_DBG_PRINT_START 06670 PDG_DBG_PRINT_C("fei_seq_subscr"); 06671 PDG_DBG_PRINT_T("(1) type", null_type); 06672 PDG_DBG_PRINT_END 06673 # ifdef _ENABLE_FEI 06674 fei_seq_subscr(null_type,IR_LIST_CNT_R(ir_idx)); 06675 # endif 06676 } 06677 06678 CONTINUE: 06679 next_idx = IL_PREV_LIST_IDX(next_idx); 06680 dim = dim - 1; 06681 ss = ss + 1; 06682 } 06683 06684 06685 if (stack_data_object) { 06686 PDG_DBG_PRINT_START 06687 PDG_DBG_PRINT_C("fei_static_subscripts"); 06688 for (i = 0; i < ss; i++) { 06689 PDG_DBG_PRINT_LLD("static subscript", static_subscripts[i]); 06690 } 06691 PDG_DBG_PRINT_END 06692 06693 # ifdef _ENABLE_FEI 06694 fei_static_subscripts(static_subscripts); 06695 # endif 06696 } 06697 06698 nested_array--; 06699 if (!nested_array) 06700 is_subscript = FALSE; 06701 06702 break; 06703 06704 case Present_Opr : 06705 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06706 IR_FLD_L(ir_idx)); 06707 06708 PDG_DBG_PRINT_START 06709 PDG_DBG_PRINT_C("fei_present"); 06710 PDG_DBG_PRINT_END 06711 06712 # ifdef _ENABLE_FEI 06713 fei_present(); 06714 # endif 06715 break; 06716 06717 06718 06719 06720 case Argchck_Present_Opr : 06721 PDG_DBG_PRINT_START 06722 PDG_DBG_PRINT_C("fei_argchk"); 06723 PDG_DBG_PRINT_END 06724 06725 # ifdef _ENABLE_FEI 06726 fei_argchk(); 06727 # endif 06728 06729 break; 06730 06731 06732 06733 06734 case Argchck_Loc_Opr : 06735 PDG_DBG_PRINT_START 06736 PDG_DBG_PRINT_C("fei_argloc"); 06737 PDG_DBG_PRINT_END 06738 06739 # ifdef _ENABLE_FEI 06740 fei_argloc(); 06741 # endif 06742 06743 break; 06744 06745 06746 06747 06748 06749 case Aloc_Opr : 06750 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06751 IR_FLD_L(ir_idx)); 06752 06753 global_attr_idx = NULL_IDX; 06754 global_attr_idx = find_left_attr(&(IR_OPND_L(ir_idx))); 06755 basic = get_basic_type(IR_TYPE_IDX(ir_idx), 0, NULL_IDX); 06756 global_attr_idx = NULL_IDX; 06757 06758 PDG_DBG_PRINT_START 06759 PDG_DBG_PRINT_C("fei_arg_addr"); 06760 PDG_DBG_PRINT_END 06761 06762 # ifdef _ENABLE_FEI 06763 fei_arg_addr(basic); 06764 # endif 06765 break; 06766 06767 06768 case Alloc_Obj_Opr: 06769 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06770 IR_FLD_L(ir_idx)); 06771 break; 06772 06773 06774 case Dv_Deref_Opr : 06775 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06776 IR_FLD_L(ir_idx)); 06777 06778 PDG_DBG_PRINT_START 06779 PDG_DBG_PRINT_C("fei_dv_deref"); 06780 PDG_DBG_PRINT_END 06781 06782 # ifdef _ENABLE_FEI 06783 fei_dv_deref(null_type); 06784 # endif 06785 break; 06786 06787 06788 06789 06790 06791 case Dv_Whole_Def_Opr : 06792 processing_call = processing_call + 1; 06793 06794 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06795 IR_FLD_L(ir_idx)); 06796 06797 PDG_DBG_PRINT_START 06798 PDG_DBG_PRINT_C("fei_dv_def"); 06799 PDG_DBG_PRINT_D("dim", IR_DV_DIM(ir_idx)); 06800 PDG_DBG_PRINT_END 06801 06802 # ifdef _ENABLE_FEI 06803 fei_dv_def(IR_DV_DIM(ir_idx)); 06804 # endif 06805 processing_call = processing_call - 1; 06806 break; 06807 06808 06809 06810 06811 06812 06813 06814 06815 case Dv_Access_Stride_Mult : 06816 case Dv_Access_Extent : 06817 case Dv_Access_Low_Bound : 06818 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06819 IR_FLD_L(ir_idx)); 06820 06821 switch (IR_OPR(ir_idx)) { 06822 case Dv_Access_Stride_Mult : 06823 PDG_DBG_PRINT_START 06824 PDG_DBG_PRINT_C("fei_get_dv_str_mult"); 06825 PDG_DBG_PRINT_D("(1) dim", IR_DV_DIM(ir_idx)); 06826 PDG_DBG_PRINT_D("(2) expand", EXPAND); 06827 PDG_DBG_PRINT_END 06828 # ifdef _ENABLE_FEI 06829 fei_get_dv_str_mult(IR_DV_DIM(ir_idx), EXPAND); 06830 # endif 06831 break; 06832 06833 case Dv_Access_Extent : 06834 PDG_DBG_PRINT_START 06835 PDG_DBG_PRINT_C("fei_get_dv_extent"); 06836 PDG_DBG_PRINT_D("(1) dim", IR_DV_DIM(ir_idx)); 06837 PDG_DBG_PRINT_D("(2) expand", EXPAND); 06838 PDG_DBG_PRINT_END 06839 # ifdef _ENABLE_FEI 06840 fei_get_dv_extent(IR_DV_DIM(ir_idx), EXPAND); 06841 # endif 06842 break; 06843 06844 case Dv_Access_Low_Bound : 06845 PDG_DBG_PRINT_START 06846 PDG_DBG_PRINT_C("fei_get_dv_low_bnd"); 06847 PDG_DBG_PRINT_D("(1) dim", IR_DV_DIM(ir_idx)); 06848 PDG_DBG_PRINT_D("(2) expand", EXPAND); 06849 PDG_DBG_PRINT_END 06850 # ifdef _ENABLE_FEI 06851 fei_get_dv_low_bnd(IR_DV_DIM(ir_idx), EXPAND); 06852 # endif 06853 break; 06854 } 06855 break; 06856 06857 06858 06859 06860 06861 06862 06863 06864 case Dv_Set_Stride_Mult : 06865 case Dv_Set_Extent : 06866 case Dv_Set_Low_Bound : 06867 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06868 IR_FLD_L(ir_idx)); 06869 06870 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 06871 IR_FLD_R(ir_idx)); 06872 06873 switch (IR_OPR(ir_idx)) { 06874 case Dv_Set_Stride_Mult : 06875 PDG_DBG_PRINT_START 06876 PDG_DBG_PRINT_C("fei_set_dv_str_mult"); 06877 PDG_DBG_PRINT_D("(1) dim", IR_DV_DIM(ir_idx)); 06878 PDG_DBG_PRINT_END 06879 # ifdef _ENABLE_FEI 06880 fei_set_dv_str_mult(IR_DV_DIM(ir_idx)); 06881 # endif 06882 break; 06883 06884 case Dv_Set_Extent : 06885 PDG_DBG_PRINT_START 06886 PDG_DBG_PRINT_C("fei_set_dv_extent"); 06887 PDG_DBG_PRINT_D("(1) dim", IR_DV_DIM(ir_idx)); 06888 PDG_DBG_PRINT_END 06889 # ifdef _ENABLE_FEI 06890 fei_set_dv_extent(IR_DV_DIM(ir_idx)); 06891 # endif 06892 break; 06893 06894 case Dv_Set_Low_Bound : 06895 PDG_DBG_PRINT_START 06896 PDG_DBG_PRINT_C("fei_set_dv_low_bnd"); 06897 PDG_DBG_PRINT_D("(1) dim", IR_DV_DIM(ir_idx)); 06898 PDG_DBG_PRINT_END 06899 # ifdef _ENABLE_FEI 06900 fei_set_dv_low_bnd(IR_DV_DIM(ir_idx)); 06901 # endif 06902 break; 06903 } 06904 break; 06905 06906 06907 06908 06909 06910 06911 06912 case Dv_Set_Base_Addr : 06913 case Dv_Set_El_Len : 06914 case Dv_Set_Assoc : 06915 case Dv_Set_Ptr_Alloc : 06916 case Dv_Set_P_Or_A : 06917 case Dv_Set_A_Contig : 06918 case Dv_Set_N_Dim : 06919 case Dv_Set_Typ_Code : 06920 case Dv_Set_Orig_Base : 06921 case Dv_Set_Orig_Size : 06922 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06923 IR_FLD_L(ir_idx)); 06924 06925 if (IR_FLD_R(ir_idx) != NO_Tbl_Idx) { 06926 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 06927 IR_FLD_R(ir_idx)); 06928 } 06929 06930 switch (IR_OPR(ir_idx)) { 06931 case Dv_Set_Base_Addr : 06932 fld = 1; 06933 break; 06934 case Dv_Set_El_Len : 06935 fld = 2; 06936 break; 06937 case Dv_Set_Assoc : 06938 fld = 3; 06939 break; 06940 case Dv_Set_Ptr_Alloc : 06941 fld = 4; 06942 break; 06943 case Dv_Set_P_Or_A : 06944 fld = 5; 06945 break; 06946 case Dv_Set_A_Contig : 06947 fld = 6; 06948 break; 06949 case Dv_Set_N_Dim : 06950 fld = 7; 06951 break; 06952 case Dv_Set_Typ_Code : 06953 fld = 8; 06954 break; 06955 case Dv_Set_Orig_Base : 06956 fld = 9; 06957 break; 06958 case Dv_Set_Orig_Size : 06959 fld = 10; 06960 break; 06961 } 06962 06963 PDG_DBG_PRINT_START 06964 PDG_DBG_PRINT_C("fei_set_dv_hdr_fld"); 06965 PDG_DBG_PRINT_D("(1) field num", fld); 06966 PDG_DBG_PRINT_END 06967 # ifdef _ENABLE_FEI 06968 fei_set_dv_hdr_fld(fld); 06969 # endif 06970 break; 06971 06972 06973 06974 06975 06976 case Dv_Access_Base_Addr : 06977 case Dv_Access_El_Len : 06978 case Dv_Access_Assoc : 06979 case Dv_Access_Ptr_Alloc : 06980 case Dv_Access_P_Or_A : 06981 case Dv_Access_A_Contig : 06982 case Dv_Access_N_Dim : 06983 case Dv_Access_Typ_Code : 06984 case Dv_Access_Orig_Base : 06985 case Dv_Access_Orig_Size : 06986 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 06987 IR_FLD_L(ir_idx)); 06988 06989 if (IR_FLD_R(ir_idx) != NO_Tbl_Idx) { 06990 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 06991 IR_FLD_R(ir_idx)); 06992 } 06993 06994 switch (IR_OPR(ir_idx)) { 06995 case Dv_Access_Base_Addr : 06996 fld = 1; 06997 break; 06998 case Dv_Access_El_Len : 06999 fld = 2; 07000 break; 07001 case Dv_Access_Assoc : 07002 fld = 3; 07003 break; 07004 case Dv_Access_Ptr_Alloc : 07005 fld = 4; 07006 break; 07007 case Dv_Access_P_Or_A : 07008 fld = 5; 07009 break; 07010 case Dv_Access_A_Contig : 07011 fld = 6; 07012 break; 07013 case Dv_Access_N_Dim : 07014 fld = 7; 07015 break; 07016 case Dv_Access_Typ_Code : 07017 fld = 8; 07018 break; 07019 case Dv_Access_Orig_Base : 07020 fld = 9; 07021 break; 07022 case Dv_Access_Orig_Size : 07023 fld = 10; 07024 break; 07025 } 07026 07027 PDG_DBG_PRINT_START 07028 PDG_DBG_PRINT_C("fei_get_dv_hdr_fld"); 07029 PDG_DBG_PRINT_D("(1) field num", fld); 07030 PDG_DBG_PRINT_END 07031 # ifdef _ENABLE_FEI 07032 fei_get_dv_hdr_fld(fld); 07033 # endif 07034 break; 07035 07036 07037 07038 07039 07040 case Allocate_Opr : 07041 case Deallocate_Opr : 07042 /* do the right side first */ 07043 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 07044 IR_FLD_R(ir_idx)); 07045 07046 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07047 IR_FLD_L(ir_idx)); 07048 07049 PDG_DBG_PRINT_START 07050 PDG_DBG_PRINT_C("fei_allocate"); 07051 PDG_DBG_PRINT_D("(1) list count", IR_LIST_CNT_L(ir_idx) + 3); 07052 PDG_DBG_PRINT_END 07053 07054 # ifdef _ENABLE_FEI 07055 fei_allocate(IR_LIST_CNT_L(ir_idx) + 3); 07056 # endif 07057 break; 07058 07059 07060 07061 case Call_Opr : 07062 processing_call = processing_call + 1; 07063 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07064 IR_FLD_L(ir_idx)); 07065 07066 if (IR_IDX_R(ir_idx) != NULL_IDX && 07067 IR_LIST_CNT_R(ir_idx) > 0) { 07068 user_call = 1; 07069 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 07070 IR_FLD_R(ir_idx)); 07071 user_call = 0; 07072 } 07073 07074 if (IR_IDX_R(ir_idx) == NULL_IDX) { 07075 number_actual_args = 0; 07076 } 07077 else { 07078 number_actual_args = IR_LIST_CNT_R(ir_idx); 07079 } 07080 07081 if (ATP_PGM_UNIT(IR_IDX_L(ir_idx)) == Subroutine ) { /* || */ 07082 /* ATP_EXTRA_DARG(IR_IDX_L(ir_idx))) */ 07083 type_desc = pdg_type_void; 07084 07085 if (ATP_HAS_ALT_RETURN(IR_IDX_L(ir_idx))) { 07086 type_desc = get_basic_type(CG_INTEGER_DEFAULT_TYPE, 07087 type_alignment_tbl[CG_INTEGER_DEFAULT_TYPE], 07088 NULL_IDX); 07089 } 07090 } 07091 else { 07092 type_desc = get_type_desc(IR_IDX_L(ir_idx)); 07093 } 07094 07095 flags = 0; 07096 flags |= ATP_DOES_NOT_RETURN(IR_IDX_L(ir_idx)) 07097 << FEI_CALL_DOES_NOT_RETURN; 07098 07099 /* Always pass FALSE for the alternate return argument. PDGCS does */ 07100 /* not use this for Fortran 90. */ 07101 07102 PDG_DBG_PRINT_START 07103 PDG_DBG_PRINT_C("fei_call"); 07104 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(IR_IDX_L(ir_idx))); 07105 PDG_DBG_PRINT_D("(1) num actual args", number_actual_args); 07106 PDG_DBG_PRINT_T("(2) type", type_desc); 07107 PDG_DBG_PRINT_S("(3) call type", "By_Value"); 07108 PDG_DBG_PRINT_S("(4) alt return", p_boolean[FALSE]); 07109 PDG_DBG_PRINT_D("(5) IR_INLINE_STATE", IR_INLINE_STATE(ir_idx)); 07110 PDG_DBG_PRINT_LLO("(6) flags", flags); 07111 PDG_DBG_PRINT_END 07112 07113 # ifdef _ENABLE_FEI 07114 fei_call(number_actual_args, 07115 type_desc, 07116 By_Value_Call, 07117 FALSE, 07118 IR_INLINE_STATE(ir_idx), 07119 flags); 07120 # endif 07121 processing_call = processing_call - 1; 07122 break; 07123 07124 07125 07126 case Br_Uncond_Opr : 07127 send_attr_ntry(IR_IDX_R(ir_idx)); 07128 07129 PDG_DBG_PRINT_START 07130 PDG_DBG_PRINT_C("fei_goto"); 07131 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_R(ir_idx))); 07132 PDG_DBG_PRINT_END 07133 07134 # ifdef _ENABLE_FEI 07135 fei_goto(PDG_AT_IDX(IR_IDX_R(ir_idx))); 07136 # endif 07137 break; 07138 07139 07140 07141 07142 07143 case Br_True_Opr : 07144 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07145 IR_FLD_L(ir_idx)); 07146 07147 send_attr_ntry(IR_IDX_R(ir_idx)); 07148 07149 PDG_DBG_PRINT_START 07150 PDG_DBG_PRINT_C("fei_brtrue"); 07151 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_R(ir_idx))); 07152 PDG_DBG_PRINT_END 07153 07154 # ifdef _ENABLE_FEI 07155 fei_brtrue(PDG_AT_IDX(IR_IDX_R(ir_idx))); 07156 # endif 07157 break; 07158 07159 07160 case If_Opr: 07161 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07162 IR_FLD_L(ir_idx)); 07163 07164 PDG_DBG_PRINT_START 07165 PDG_DBG_PRINT_C("fei_if"); 07166 PDG_DBG_PRINT_END 07167 # ifdef _HIGH_LEVEL_IF_FORM 07168 # ifdef _ENABLE_FEI 07169 fei_if(); 07170 # endif 07171 # endif 07172 break; 07173 07174 07175 case Else_Opr: 07176 07177 PDG_DBG_PRINT_START 07178 PDG_DBG_PRINT_C("fei_else"); 07179 PDG_DBG_PRINT_END 07180 # ifdef _HIGH_LEVEL_IF_FORM 07181 # ifdef _ENABLE_FEI 07182 fei_else(); 07183 # endif 07184 # endif 07185 break; 07186 07187 case Endif_Opr: 07188 07189 PDG_DBG_PRINT_START 07190 PDG_DBG_PRINT_C("fei_endif"); 07191 PDG_DBG_PRINT_END 07192 # ifdef _HIGH_LEVEL_IF_FORM 07193 # ifdef _ENABLE_FEI 07194 fei_endif(); 07195 # endif 07196 # endif 07197 break; 07198 07199 07200 07201 case Br_Aif_Opr : 07202 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07203 IR_FLD_L(ir_idx)); 07204 07205 send_attr_ntry(IL_IDX(IR_IDX_R(ir_idx))); 07206 07207 send_attr_ntry(IL_IDX(IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx)))); 07208 07209 send_attr_ntry(IL_IDX(IL_NEXT_LIST_IDX( 07210 IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx))))); 07211 07212 PDG_DBG_PRINT_START 07213 PDG_DBG_PRINT_C("fei_arith_goto"); 07214 PDG_DBG_PRINT_LD("label idx1", PDG_AT_IDX(IL_IDX(IR_IDX_R(ir_idx)))); 07215 PDG_DBG_PRINT_LD("label idx2", PDG_AT_IDX(IL_IDX(IL_NEXT_LIST_IDX( 07216 IR_IDX_R(ir_idx))))); 07217 PDG_DBG_PRINT_LD("label idx3", PDG_AT_IDX(IL_IDX(IL_NEXT_LIST_IDX( 07218 IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx)))))); 07219 PDG_DBG_PRINT_END 07220 07221 # ifdef _ENABLE_FEI 07222 fei_arith_goto( 07223 PDG_AT_IDX(IL_IDX(IR_IDX_R(ir_idx))), 07224 PDG_AT_IDX(IL_IDX(IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx)))), 07225 PDG_AT_IDX(IL_IDX(IL_NEXT_LIST_IDX( 07226 IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx)))))); 07227 # endif 07228 break; 07229 07230 07231 07232 07233 07234 case Br_Asg_Opr : 07235 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07236 IR_FLD_L(ir_idx)); 07237 07238 list_cnt = 0; 07239 i = SCP_ASSIGN_LBL_CHAIN(curr_scp_idx); 07240 07241 while (i != NULL_IDX) { 07242 send_attr_ntry(i); 07243 07244 PDG_DBG_PRINT_START 07245 PDG_DBG_PRINT_C("fei_label_ref"); 07246 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(i)); 07247 PDG_DBG_PRINT_END 07248 07249 # ifdef _ENABLE_FEI 07250 fei_label_ref(PDG_AT_IDX(i)); 07251 # endif 07252 07253 list_cnt = list_cnt + 1; 07254 i = ATL_NEXT_ASG_LBL_IDX(i); 07255 } 07256 07257 PDG_DBG_PRINT_START 07258 PDG_DBG_PRINT_C("fei_indirect_goto"); 07259 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 07260 PDG_DBG_PRINT_D("(2) TRUE", TRUE); 07261 PDG_DBG_PRINT_END 07262 07263 # ifdef _ENABLE_FEI 07264 fei_indirect_goto(list_cnt, TRUE); 07265 # endif 07266 break; 07267 07268 07269 07270 07271 case Br_Index_Opr : 07272 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07273 IR_FLD_L(ir_idx)); 07274 07275 list_cnt = IR_LIST_CNT_R(ir_idx); 07276 tmp_ir_idx = IR_IDX_R(ir_idx); 07277 07278 for (i = 0; i < list_cnt; i++) { 07279 send_attr_ntry(IL_IDX(tmp_ir_idx)); 07280 07281 PDG_DBG_PRINT_START 07282 PDG_DBG_PRINT_C("fei_label_ref"); 07283 PDG_DBG_PRINT_LD("(1) label idx", PDG_AT_IDX(IL_IDX(tmp_ir_idx))); 07284 PDG_DBG_PRINT_END 07285 07286 # ifdef _ENABLE_FEI 07287 fei_label_ref(PDG_AT_IDX(IL_IDX(tmp_ir_idx))); 07288 # endif 07289 tmp_ir_idx = IL_NEXT_LIST_IDX(tmp_ir_idx); 07290 } 07291 07292 PDG_DBG_PRINT_START 07293 PDG_DBG_PRINT_C("fei_indirect_goto"); 07294 PDG_DBG_PRINT_D("(1) list cnt", list_cnt); 07295 PDG_DBG_PRINT_D("(2) FALSE", FALSE); 07296 PDG_DBG_PRINT_END 07297 07298 # ifdef _ENABLE_FEI 07299 fei_indirect_goto(list_cnt, FALSE); 07300 # endif 07301 break; 07302 07303 07304 07305 07306 07307 07308 case Where_Opr : 07309 if (IR_LIST_CNT_L(ir_idx) == 4) { 07310 /* defined assignment */ 07311 # if defined(GENERATE_WHIRL) 07312 proc_idx = IR_IDX_L(ir_idx); 07313 lhs_idx = IL_NEXT_LIST_IDX(proc_idx); 07314 mask_idx = IL_NEXT_LIST_IDX(lhs_idx); 07315 rhs_idx = IL_NEXT_LIST_IDX(mask_idx); 07316 cvrt_exp_to_pdg(IL_IDX(proc_idx), 07317 IL_FLD(proc_idx)); 07318 07319 cvrt_exp_to_pdg(IL_IDX(lhs_idx), 07320 IL_FLD(lhs_idx)); 07321 07322 cvrt_exp_to_pdg(IL_IDX(rhs_idx), 07323 IL_FLD(rhs_idx)); 07324 07325 cvrt_exp_to_pdg(IL_IDX(mask_idx), 07326 IL_FLD(mask_idx)); 07327 # else 07328 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07329 IR_FLD_L(ir_idx)); 07330 # endif 07331 07332 PDG_DBG_PRINT_START 07333 PDG_DBG_PRINT_C("fei_where"); 07334 PDG_DBG_PRINT_END 07335 07336 # ifdef _ENABLE_FEI 07337 fei_where(TRUE, IR_INLINE_STATE(ir_idx)); 07338 # endif 07339 } 07340 else { 07341 # if defined(GENERATE_WHIRL) 07342 lhs_idx = IR_IDX_L(ir_idx); 07343 mask_idx = IL_NEXT_LIST_IDX(lhs_idx); 07344 rhs_idx = IL_NEXT_LIST_IDX(mask_idx); 07345 cvrt_exp_to_pdg(IL_IDX(lhs_idx), 07346 IL_FLD(lhs_idx)); 07347 07348 cvrt_exp_to_pdg(IL_IDX(rhs_idx), 07349 IL_FLD(rhs_idx)); 07350 07351 cvrt_exp_to_pdg(IL_IDX(mask_idx), 07352 IL_FLD(mask_idx)); 07353 # else 07354 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07355 IR_FLD_L(ir_idx)); 07356 # endif 07357 07358 PDG_DBG_PRINT_START 07359 PDG_DBG_PRINT_C("fei_where"); 07360 PDG_DBG_PRINT_END 07361 07362 # ifdef _ENABLE_FEI 07363 fei_where(FALSE, 0); 07364 # endif 07365 } 07366 break; 07367 07368 07369 case Where_Cnstrct_Opr: 07370 case Else_Where_Mask_Opr: 07371 case Else_Where_Opr: 07372 /* these are ignored */ 07373 break; 07374 07375 07376 case Bounds_Cdir_Opr : 07377 case Nobounds_Cdir_Opr : 07378 bounds_cdir_handler(ir_idx); 07379 break; 07380 07381 07382 07383 07384 07385 case Case_Cmic_Opr: 07386 PDG_DBG_PRINT_START 07387 PDG_DBG_PRINT_C("fei_par_case"); 07388 PDG_DBG_PRINT_D("(1) cmic vpr idx", case_cmic_vpr_idx); 07389 PDG_DBG_PRINT_D("(2) line num", IR_LINE_NUM(ir_idx)); 07390 PDG_DBG_PRINT_END 07391 07392 # ifdef _ENABLE_FEI 07393 task_tbl_idx = fei_par_case(case_cmic_vpr_idx, 07394 IR_LINE_NUM(ir_idx)); 07395 # endif 07396 07397 if (case_cmic_vpr_idx == NULL_IDX) { 07398 case_cmic_vpr_idx = task_tbl_idx; 07399 } 07400 break; 07401 07402 07403 07404 07405 07406 07407 07408 case Endcase_Cmic_Opr: 07409 PDG_DBG_PRINT_START 07410 PDG_DBG_PRINT_C("fei_par_endcase"); 07411 PDG_DBG_PRINT_D("(1) cmic vpr idx", case_cmic_vpr_idx); 07412 PDG_DBG_PRINT_D("(2) line num", IR_LINE_NUM(ir_idx)); 07413 PDG_DBG_PRINT_END 07414 07415 # ifdef _ENABLE_FEI 07416 fei_par_endcase(case_cmic_vpr_idx, IR_LINE_NUM(ir_idx)); 07417 # endif 07418 07419 case_cmic_vpr_idx = NULL_IDX; 07420 break; 07421 07422 07423 07424 07425 case Send_Cmic_Opr: 07426 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx || 07427 IR_FLD_L(ir_idx) == AT_Tbl_Idx) { 07428 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07429 IR_FLD_L(ir_idx)); 07430 point = 1; 07431 } 07432 07433 /* process IF clause */ 07434 if (IR_FLD_R(ir_idx) == AT_Tbl_Idx) { 07435 send_attr_ntry(IR_IDX_R(ir_idx)); 07436 task_if_idx = PDG_AT_IDX(IR_IDX_R(ir_idx)); 07437 } 07438 07439 PDG_DBG_PRINT_START 07440 PDG_DBG_PRINT_C("fei_task_send"); 07441 PDG_DBG_PRINT_LD("(1) point", point); 07442 PDG_DBG_PRINT_D("(2) task_if_idx", task_if_idx); 07443 PDG_DBG_PRINT_END 07444 07445 # ifdef _ENABLE_FEI 07446 fei_task_send(point, task_if_idx); 07447 # endif 07448 07449 break; 07450 07451 07452 07453 07454 case Wait_Cmic_Opr: 07455 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx || 07456 IR_FLD_L(ir_idx) == AT_Tbl_Idx) { 07457 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07458 IR_FLD_L(ir_idx)); 07459 point = 1; 07460 } 07461 07462 if (IR_FLD_R(ir_idx) == CN_Tbl_Idx) { 07463 span = (long) CN_INT_TO_C(IR_IDX_R(ir_idx)); 07464 } 07465 07466 PDG_DBG_PRINT_START 07467 PDG_DBG_PRINT_C("fei_task_wait"); 07468 PDG_DBG_PRINT_LD("(1) point", point); 07469 PDG_DBG_PRINT_LD("(2) span", span); 07470 PDG_DBG_PRINT_END 07471 07472 # ifdef _ENABLE_FEI 07473 fei_task_wait(point, span); 07474 # endif 07475 07476 break; 07477 07478 07479 07480 case Guard_Cmic_Opr: 07481 if (IR_FLD_L(ir_idx) == AT_Tbl_Idx) { 07482 send_attr_ntry(IR_IDX_L(ir_idx)); 07483 } 07484 07485 PDG_DBG_PRINT_START 07486 PDG_DBG_PRINT_C("fei_guard"); 07487 PDG_DBG_PRINT_LD("(1) idx", (IR_FLD_L(ir_idx) == NO_Tbl_Idx) ? 07488 0 : PDG_AT_IDX(IR_IDX_L(ir_idx))); 07489 PDG_DBG_PRINT_D("(2) line num", IR_LINE_NUM(ir_idx)); 07490 PDG_DBG_PRINT_END 07491 07492 # ifdef _ENABLE_FEI 07493 guard_cmic_vpr_idx = fei_guard((IR_FLD_L(ir_idx) == NO_Tbl_Idx) ? 07494 0 : PDG_AT_IDX(IR_IDX_L(ir_idx)), 07495 IR_LINE_NUM(ir_idx)); 07496 # endif 07497 07498 break; 07499 07500 07501 07502 07503 07504 07505 case Endguard_Cmic_Opr: 07506 if (IR_FLD_L(ir_idx) == AT_Tbl_Idx) { 07507 send_attr_ntry(IR_IDX_L(ir_idx)); 07508 } 07509 07510 PDG_DBG_PRINT_START 07511 PDG_DBG_PRINT_C("fei_endguard"); 07512 PDG_DBG_PRINT_LD("(1) guard idx", (IR_FLD_L(ir_idx) == NO_Tbl_Idx) ? 0 : 07513 PDG_AT_IDX(IR_IDX_L(ir_idx))); 07514 PDG_DBG_PRINT_D("(2) line num", IR_LINE_NUM(ir_idx)); 07515 PDG_DBG_PRINT_END 07516 07517 # ifdef _ENABLE_FEI 07518 fei_endguard(guard_cmic_vpr_idx, 07519 (IR_FLD_L(ir_idx) == NO_Tbl_Idx) ? 0 : 07520 PDG_AT_IDX(IR_IDX_L(ir_idx)), 07521 IR_LINE_NUM(ir_idx)); 07522 # endif 07523 07524 guard_cmic_vpr_idx = NULL_IDX; 07525 break; 07526 07527 07528 07529 07530 07531 case Numcpus_Cmic_Opr : 07532 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07533 IR_FLD_L(ir_idx)); 07534 07535 PDG_DBG_PRINT_START 07536 PDG_DBG_PRINT_C("fei_numcpus"); 07537 PDG_DBG_PRINT_D("(1) line num", IR_LINE_NUM(ir_idx)); 07538 PDG_DBG_PRINT_END 07539 07540 # ifdef _ENABLE_FEI 07541 fei_numcpus(IR_LINE_NUM(ir_idx)); 07542 # endif 07543 break; 07544 07545 07546 07547 07548 07549 07550 case Ranf_Opr : 07551 basic = get_basic_type(IR_TYPE_IDX(ir_idx), 0, NULL_IDX); 07552 07553 PDG_DBG_PRINT_START 07554 PDG_DBG_PRINT_C("fei_ranf"); 07555 PDG_DBG_PRINT_END 07556 07557 # ifdef _ENABLE_FEI 07558 fei_ranf(basic); 07559 # endif 07560 07561 break; 07562 07563 07564 07565 07566 07567 07568 07569 case Regionbegin_Star_Opr: 07570 case Regionend_Star_Opr: 07571 case End_Critical_Section_Par_Opr: 07572 case End_Parallel_Par_Opr: 07573 case Section_Par_Opr: 07574 case Barrier_Par_Opr: 07575 switch (IR_OPR(ir_idx)) { 07576 case Regionbegin_Star_Opr: 07577 PDG_DBG_PRINT_START 07578 PDG_DBG_PRINT_C("fei_regionbegin"); 07579 PDG_DBG_PRINT_END 07580 # if defined(GENERATE_WHIRL) 07581 # ifdef _ENABLE_FEI 07582 fei_regionbegin(); 07583 # endif 07584 # endif 07585 break; 07586 07587 case Regionend_Star_Opr : 07588 PDG_DBG_PRINT_START 07589 PDG_DBG_PRINT_C("fei_regionend"); 07590 PDG_DBG_PRINT_END 07591 # if defined(GENERATE_WHIRL) 07592 # ifdef _ENABLE_FEI 07593 fei_regionend(); 07594 # endif 07595 # endif 07596 break; 07597 07598 case End_Critical_Section_Par_Opr : 07599 PDG_DBG_PRINT_START 07600 PDG_DBG_PRINT_C("fei_endcriticalsection"); 07601 PDG_DBG_PRINT_END 07602 # if defined(GENERATE_WHIRL) 07603 # ifdef _ENABLE_FEI 07604 fei_endcriticalsection(); 07605 # endif 07606 # endif 07607 break; 07608 07609 case End_Parallel_Par_Opr : 07610 PDG_DBG_PRINT_START 07611 PDG_DBG_PRINT_C("fei_endparallel"); 07612 PDG_DBG_PRINT_END 07613 # if defined(GENERATE_WHIRL) 07614 # ifdef _ENABLE_FEI 07615 fei_endparallel(); 07616 # endif 07617 # endif 07618 break; 07619 07620 case Section_Par_Opr : 07621 PDG_DBG_PRINT_START 07622 PDG_DBG_PRINT_C("fei_section"); 07623 PDG_DBG_PRINT_END 07624 # if defined(GENERATE_WHIRL) 07625 # ifdef _ENABLE_FEI 07626 fei_section(); 07627 # endif 07628 # endif 07629 break; 07630 07631 case Barrier_Par_Opr : 07632 PDG_DBG_PRINT_START 07633 PDG_DBG_PRINT_C("fei_barrier"); 07634 PDG_DBG_PRINT_END 07635 # ifdef _ENABLE_FEI 07636 # if defined(GENERATE_WHIRL) 07637 fei_barrier(); 07638 # endif 07639 # endif 07640 break; 07641 } 07642 break; 07643 07644 07645 07646 07647 07648 07649 07650 07651 07652 07653 case End_Pdo_Par_Opr: 07654 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 07655 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 07656 } 07657 07658 PDG_DBG_PRINT_START 07659 PDG_DBG_PRINT_C("fei_endpdo"); 07660 PDG_DBG_PRINT_LD("(1) nowait", nowait); 07661 PDG_DBG_PRINT_END 07662 07663 07664 # if defined(GENERATE_WHIRL) 07665 # ifdef _ENABLE_FEI 07666 fei_endpdo(nowait); 07667 # endif 07668 # endif 07669 break; 07670 07671 07672 07673 07674 case End_Psection_Par_Opr: 07675 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 07676 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 07677 } 07678 07679 PDG_DBG_PRINT_START 07680 PDG_DBG_PRINT_C("fei_endpsection"); 07681 PDG_DBG_PRINT_LD("(1) nowait", nowait); 07682 PDG_DBG_PRINT_END 07683 07684 07685 # if defined(GENERATE_WHIRL) 07686 # ifdef _ENABLE_FEI 07687 fei_endpsection(nowait); 07688 # endif 07689 # endif 07690 break; 07691 07692 07693 07694 case End_Singleprocess_Par_Opr: 07695 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 07696 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 07697 } 07698 07699 PDG_DBG_PRINT_START 07700 PDG_DBG_PRINT_C("fei_endsingleprocess"); 07701 PDG_DBG_PRINT_LD("(1) nowait", nowait); 07702 PDG_DBG_PRINT_END 07703 07704 07705 # if defined(GENERATE_WHIRL) 07706 # ifdef _ENABLE_FEI 07707 fei_endsingleprocess(nowait); 07708 # endif 07709 # endif 07710 break; 07711 07712 07713 07714 07715 case Critical_Section_Par_Opr: 07716 if (IR_FLD_L(ir_idx) != NO_Tbl_Idx) { 07717 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 07718 IR_FLD_L(ir_idx)); 07719 varcount = 1; 07720 } 07721 07722 PDG_DBG_PRINT_START 07723 PDG_DBG_PRINT_C("fei_criticalsection"); 07724 PDG_DBG_PRINT_LD("(1) varcount", varcount); 07725 PDG_DBG_PRINT_END 07726 07727 07728 # if defined(GENERATE_WHIRL) 07729 # ifdef _ENABLE_FEI 07730 fei_criticalsection(varcount); 07731 # endif 07732 # endif 07733 break; 07734 07735 07736 case User_Code_Start_Opr: 07737 PDG_DBG_PRINT_START 07738 PDG_DBG_PRINT_C("fei_user_code_start"); 07739 PDG_DBG_PRINT_END 07740 07741 # if defined(GENERATE_WHIRL) 07742 # ifdef _ENABLE_FEI 07743 fei_user_code_start(); 07744 # endif 07745 # endif 07746 break; 07747 07748 07749 07750 case Psection_Par_Opr: 07751 case Singleprocess_Par_Opr: 07752 case Parallel_Do_Par_Opr: 07753 case Parallel_Par_Opr: 07754 case Pdo_Par_Opr: 07755 case Doacross_Dollar_Opr: 07756 list_idx1 = IR_IDX_L(ir_idx); 07757 07758 for (i = 0; i < MP_DIR_LIST_CNT; i++) { 07759 list_array[i] = list_idx1; 07760 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 07761 } 07762 07763 07764 /* process IF clause */ 07765 if (IL_FLD(list_array[MP_DIR_IF_IDX]) == NO_Tbl_Idx) { 07766 task_if_idx = 0; 07767 } 07768 else { 07769 send_attr_ntry(IL_IDX(list_array[MP_DIR_IF_IDX])); 07770 task_if_idx = PDG_AT_IDX(IL_IDX(list_array[MP_DIR_IF_IDX])); 07771 } 07772 07773 07774 /* process ORDERED clause */ 07775 if (IL_FLD(list_array[MP_DIR_ORDERED_IDX]) == CN_Tbl_Idx) { 07776 ordered = (long) CN_INT_TO_C(IL_IDX(list_array[MP_DIR_ORDERED_IDX])); 07777 } 07778 07779 07780 /* process SCHEDTYPE clause */ 07781 if (IL_FLD(list_array[MP_DIR_MP_SCHEDTYPE_IDX]) == CN_Tbl_Idx) { 07782 schedtype = (long) 07783 CN_INT_TO_C(IL_IDX(list_array[MP_DIR_MP_SCHEDTYPE_IDX])); 07784 } 07785 07786 07787 /* process LASTTHREAD clause */ 07788 if (IL_FLD(list_array[MP_DIR_LASTTHREAD_IDX]) == AT_Tbl_Idx) { 07789 send_attr_ntry(IL_IDX(list_array[MP_DIR_LASTTHREAD_IDX])); 07790 07791 PDG_DBG_PRINT_START 07792 PDG_DBG_PRINT_C("fei_task_var"); 07793 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 07794 PDG_AT_IDX(IL_IDX(list_array[MP_DIR_LASTTHREAD_IDX]))); 07795 PDG_DBG_PRINT_S("(2) context", 07796 p_tasking_context[Context_Lastthread]); 07797 PDG_DBG_PRINT_END 07798 07799 # ifdef _ENABLE_FEI 07800 last_task_idx = fei_task_var( 07801 PDG_AT_IDX(IL_IDX(list_array[MP_DIR_LASTTHREAD_IDX])), 07802 Context_Lastthread); 07803 # endif 07804 } 07805 07806 07807 /* process SHARED clause */ 07808 if (IL_FLD(list_array[MP_DIR_SHARE_IDX]) == IL_Tbl_Idx) { 07809 list_idx2 = IL_IDX(list_array[MP_DIR_SHARE_IDX]); 07810 07811 while (list_idx2) { 07812 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 07813 send_attr_ntry(IL_IDX(list_idx2)); 07814 07815 PDG_DBG_PRINT_START 07816 PDG_DBG_PRINT_C("fei_task_var"); 07817 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 07818 PDG_AT_IDX(IL_IDX(list_idx2))); 07819 PDG_DBG_PRINT_S("(2) context", 07820 p_tasking_context[Context_Shared]); 07821 07822 PDG_DBG_PRINT_END 07823 07824 # ifdef _ENABLE_FEI 07825 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 07826 Context_Shared); 07827 # endif 07828 07829 } 07830 07831 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 07832 } 07833 } 07834 07835 07836 /* process LASTLOCAL clause */ 07837 if (IL_FLD(list_array[MP_DIR_LASTLOCAL_IDX]) == IL_Tbl_Idx) { 07838 list_idx2 = IL_IDX(list_array[MP_DIR_LASTLOCAL_IDX]); 07839 07840 while (list_idx2) { 07841 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 07842 send_attr_ntry(IL_IDX(list_idx2)); 07843 07844 PDG_DBG_PRINT_START 07845 PDG_DBG_PRINT_C("fei_task_var"); 07846 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 07847 PDG_AT_IDX(IL_IDX(list_idx2))); 07848 PDG_DBG_PRINT_S("(2) context", 07849 p_tasking_context[Context_Lastlocal]); 07850 07851 PDG_DBG_PRINT_END 07852 07853 # ifdef _ENABLE_FEI 07854 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 07855 Context_Lastlocal); 07856 # endif 07857 07858 } 07859 07860 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 07861 } 07862 } 07863 07864 07865 07866 07867 07868 07869 /* process PRIVATE clause */ 07870 if (IL_FLD(list_array[MP_DIR_LOCAL_IDX]) == IL_Tbl_Idx) { 07871 list_idx2 = IL_IDX(list_array[MP_DIR_LOCAL_IDX]); 07872 07873 while (list_idx2) { 07874 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 07875 send_attr_ntry(IL_IDX(list_idx2)); 07876 07877 PDG_DBG_PRINT_START 07878 PDG_DBG_PRINT_C("fei_task_var"); 07879 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 07880 PDG_AT_IDX(IL_IDX(list_idx2))); 07881 PDG_DBG_PRINT_S("(2) context", 07882 p_tasking_context[Context_Private]); 07883 07884 PDG_DBG_PRINT_END 07885 07886 # ifdef _ENABLE_FEI 07887 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 07888 Context_Private); 07889 # endif 07890 07891 } 07892 07893 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 07894 } 07895 } 07896 07897 07898 07899 07900 /* process NEST clause */ 07901 if (IL_FLD(list_array[MP_DIR_NEST_IDX]) == IL_Tbl_Idx) { 07902 list_idx2 = IL_IDX(list_array[MP_DIR_NEST_IDX]); 07903 07904 while (list_idx2) { 07905 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 07906 send_attr_ntry(IL_IDX(list_idx2)); 07907 07908 PDG_DBG_PRINT_START 07909 PDG_DBG_PRINT_C("fei_task_var"); 07910 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 07911 PDG_AT_IDX(IL_IDX(list_idx2))); 07912 PDG_DBG_PRINT_S("(2) context", 07913 p_tasking_context[Context_Nest]); 07914 PDG_DBG_PRINT_END 07915 07916 # ifdef _ENABLE_FEI 07917 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 07918 Context_Nest); 07919 # endif 07920 07921 } 07922 07923 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 07924 } 07925 } 07926 07927 07928 07929 /* process AFFINITY clause */ 07930 if (IL_FLD(list_array[MP_DIR_AFFINITY_IDX]) == IL_Tbl_Idx) { 07931 list_idx2 = IL_IDX(list_array[MP_DIR_AFFINITY_IDX]); 07932 07933 while (list_idx2 != NULL_IDX) { 07934 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 07935 send_attr_ntry(IL_IDX(list_idx2)); 07936 07937 PDG_DBG_PRINT_START 07938 PDG_DBG_PRINT_C("fei_task_var"); 07939 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 07940 PDG_AT_IDX(IL_IDX(list_idx2))); 07941 PDG_DBG_PRINT_S("(2) context", 07942 p_tasking_context[Context_Affinity]); 07943 PDG_DBG_PRINT_END 07944 07945 # ifdef _ENABLE_FEI 07946 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 07947 Context_Affinity); 07948 # endif 07949 07950 } 07951 07952 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 07953 } 07954 07955 cvrt_exp_to_pdg(IL_IDX(list_array[MP_DIR_THREAD_DATA_IDX]), 07956 IL_FLD(list_array[MP_DIR_THREAD_DATA_IDX])); 07957 07958 cvrt_exp_to_pdg(IL_IDX(list_array[MP_DIR_THREAD_DATA_IDX]), 07959 IL_FLD(list_array[MP_DIR_THREAD_DATA_IDX])); 07960 07961 which = (long) CN_INT_TO_C(IL_IDX(list_array[MP_DIR_IS_THREAD_IDX])); 07962 07963 if (which == 1) { 07964 threadcount = 1; 07965 } 07966 else { 07967 datacount = 1; 07968 } 07969 } 07970 07971 07972 07973 07974 /* process ONTO clause */ 07975 if (IL_FLD(list_array[MP_DIR_ONTO_IDX]) == IL_Tbl_Idx) { 07976 list_idx2 = IL_IDX(list_array[MP_DIR_ONTO_IDX]); 07977 07978 ontocount = 0; 07979 while (list_idx2 != NULL_IDX) { 07980 cvrt_exp_to_pdg(IL_IDX(list_idx2), 07981 IL_FLD(list_idx2)); 07982 07983 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 07984 ontocount = ontocount + 1; 07985 } 07986 } 07987 07988 07989 07990 07991 /* process REDUCTION clause */ 07992 if (IL_FLD(list_array[MP_DIR_REDUCTION_IDX]) == IL_Tbl_Idx) { 07993 list_idx2 = IL_IDX(list_array[MP_DIR_REDUCTION_IDX]); 07994 07995 reductioncount = 0; 07996 while (list_idx2 != NULL_IDX) { 07997 cvrt_exp_to_pdg(IL_IDX(list_idx2), 07998 IL_FLD(list_idx2)); 07999 08000 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 08001 reductioncount = reductioncount + 1; 08002 } 08003 } 08004 08005 08006 08007 /* process CHUNK clause */ 08008 if (IL_FLD(list_array[MP_DIR_CHUNK_IDX]) != NO_Tbl_Idx) { 08009 cvrt_exp_to_pdg(IL_IDX(list_array[MP_DIR_CHUNK_IDX]), 08010 IL_FLD(list_array[MP_DIR_CHUNK_IDX])); 08011 chunkcount = 1; 08012 } 08013 08014 08015 08016 switch (IR_OPR(ir_idx)) { 08017 08018 case Doacross_Dollar_Opr : 08019 PDG_DBG_PRINT_START 08020 PDG_DBG_PRINT_C("fei_doacross"); 08021 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 08022 PDG_DBG_PRINT_LD("(2) schedtype", schedtype); 08023 PDG_DBG_PRINT_LD("(3) threadcount", threadcount); 08024 PDG_DBG_PRINT_LD("(4) datacount", datacount); 08025 PDG_DBG_PRINT_LD("(5) ontocount", ontocount); 08026 PDG_DBG_PRINT_LD("(6) reductioncount", reductioncount); 08027 PDG_DBG_PRINT_LD("(7) chunkcount", chunkcount); 08028 PDG_DBG_PRINT_END 08029 08030 # if defined(GENERATE_WHIRL) 08031 # ifdef _ENABLE_FEI 08032 fei_doacross(task_if_idx, 08033 schedtype, 08034 threadcount, 08035 datacount, 08036 ontocount, 08037 reductioncount, 08038 chunkcount); 08039 08040 # endif 08041 # endif 08042 break; 08043 08044 08045 08046 case Pdo_Par_Opr : 08047 PDG_DBG_PRINT_START 08048 PDG_DBG_PRINT_C("fei_pdo"); 08049 PDG_DBG_PRINT_LD("(1) schedtype", schedtype); 08050 PDG_DBG_PRINT_LD("(2) ordered", ordered); 08051 PDG_DBG_PRINT_LD("(3) threadcount", threadcount); 08052 PDG_DBG_PRINT_LD("(4) datacount", datacount); 08053 PDG_DBG_PRINT_LD("(5) ontocount", ontocount); 08054 PDG_DBG_PRINT_LD("(6) reductioncount", reductioncount); 08055 PDG_DBG_PRINT_LD("(7) chunkcount", chunkcount); 08056 PDG_DBG_PRINT_END 08057 08058 # if defined(GENERATE_WHIRL) 08059 # ifdef _ENABLE_FEI 08060 fei_pdo(schedtype, 08061 ordered, 08062 threadcount, 08063 datacount, 08064 ontocount, 08065 reductioncount, 08066 chunkcount); 08067 # endif 08068 # endif 08069 break; 08070 08071 08072 08073 case Parallel_Do_Par_Opr : 08074 PDG_DBG_PRINT_START 08075 PDG_DBG_PRINT_C("fei_paralleldo"); 08076 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 08077 PDG_DBG_PRINT_LD("(2) schedtype", schedtype); 08078 PDG_DBG_PRINT_LD("(3) threadcount", threadcount); 08079 PDG_DBG_PRINT_LD("(4) datacount", datacount); 08080 PDG_DBG_PRINT_LD("(5) ontocount", ontocount); 08081 PDG_DBG_PRINT_LD("(6) reductioncount", reductioncount); 08082 PDG_DBG_PRINT_LD("(7) chunkcount", chunkcount); 08083 PDG_DBG_PRINT_END 08084 08085 08086 # if defined(GENERATE_WHIRL) 08087 # ifdef _ENABLE_FEI 08088 fei_paralleldo(task_if_idx, 08089 schedtype, 08090 threadcount, 08091 datacount, 08092 ontocount, 08093 reductioncount, 08094 chunkcount); 08095 # endif 08096 # endif 08097 break; 08098 08099 08100 08101 08102 case Parallel_Par_Opr : 08103 PDG_DBG_PRINT_START 08104 PDG_DBG_PRINT_C("fei_parallel"); 08105 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 08106 PDG_DBG_PRINT_END 08107 08108 08109 # if defined(GENERATE_WHIRL) 08110 # ifdef _ENABLE_FEI 08111 fei_parallel(task_if_idx); 08112 # endif 08113 # endif 08114 break; 08115 08116 08117 08118 case Singleprocess_Par_Opr : 08119 PDG_DBG_PRINT_START 08120 PDG_DBG_PRINT_C("fei_singleprocess"); 08121 PDG_DBG_PRINT_END 08122 08123 08124 # if defined(GENERATE_WHIRL) 08125 # ifdef _ENABLE_FEI 08126 fei_singleprocess(); 08127 # endif 08128 # endif 08129 break; 08130 08131 08132 08133 08134 case Psection_Par_Opr: 08135 PDG_DBG_PRINT_START 08136 PDG_DBG_PRINT_C("fei_psection"); 08137 PDG_DBG_PRINT_END 08138 08139 08140 # if defined(GENERATE_WHIRL) 08141 # ifdef _ENABLE_FEI 08142 fei_psection(); 08143 # endif 08144 # endif 08145 break; 08146 08147 } 08148 break; 08149 08150 08151 08152 08153 08154 case Concurrentize_Star_Opr: 08155 PDG_DBG_PRINT_START 08156 PDG_DBG_PRINT_C("fei_concurrentize"); 08157 PDG_DBG_PRINT_D("(1) state", TRUE); 08158 PDG_DBG_PRINT_END 08159 08160 # if defined(GENERATE_WHIRL) 08161 # ifdef _ENABLE_FEI 08162 fei_concurrentize(TRUE); 08163 # endif 08164 # endif 08165 08166 break; 08167 08168 08169 08170 08171 08172 case Noconcurrentize_Star_Opr: 08173 PDG_DBG_PRINT_START 08174 PDG_DBG_PRINT_C("fei_concurrentize"); 08175 PDG_DBG_PRINT_D("(1) state", FALSE); 08176 PDG_DBG_PRINT_END 08177 08178 # if defined(GENERATE_WHIRL) 08179 # ifdef _ENABLE_FEI 08180 fei_concurrentize(FALSE); 08181 # endif 08182 # endif 08183 08184 break; 08185 08186 08187 08188 08189 08190 08191 08192 08193 case Interchange_Dir_Opr: 08194 08195 # if defined(GENERATE_WHIRL) 08196 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08197 IR_FLD_L(ir_idx)); 08198 08199 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 08200 IR_FLD_R(ir_idx)); 08201 08202 PDG_DBG_PRINT_START 08203 PDG_DBG_PRINT_C("fei_interchange"); 08204 PDG_DBG_PRINT_D("(1) expressions", IR_LIST_CNT_L(ir_idx)); 08205 PDG_DBG_PRINT_END 08206 08207 # ifdef _ENABLE_FEI 08208 fei_interchange(IR_LIST_CNT_L(ir_idx)); 08209 # endif 08210 # endif 08211 break; 08212 08213 08214 08215 08216 08217 08218 case Blockable_Dir_Opr: 08219 08220 # if defined(GENERATE_WHIRL) 08221 08222 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08223 IR_FLD_L(ir_idx)); 08224 08225 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 08226 IR_FLD_R(ir_idx)); 08227 08228 PDG_DBG_PRINT_START 08229 PDG_DBG_PRINT_C("fei_blockable"); 08230 PDG_DBG_PRINT_D("(1) expressions", IR_LIST_CNT_L(ir_idx)); 08231 PDG_DBG_PRINT_END 08232 08233 # ifdef _ENABLE_FEI 08234 fei_blockable(IR_LIST_CNT_L(ir_idx)); 08235 # endif 08236 # endif 08237 break; 08238 08239 08240 08241 case Fission_Star_Opr: 08242 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08243 IR_FLD_L(ir_idx)); 08244 08245 PDG_DBG_PRINT_START 08246 PDG_DBG_PRINT_C("fei_fission"); 08247 PDG_DBG_PRINT_END 08248 08249 # if defined(GENERATE_WHIRL) 08250 # ifdef _ENABLE_FEI 08251 fei_fission(); 08252 # endif 08253 # endif 08254 break; 08255 08256 08257 08258 08259 case Flush_Star_Opr: 08260 list_cnt = 0; 08261 if (IR_FLD_L(ir_idx) == IL_Tbl_Idx) { 08262 list_cnt = IR_LIST_CNT_L(ir_idx); 08263 } 08264 08265 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08266 IR_FLD_L(ir_idx)); 08267 08268 PDG_DBG_PRINT_START 08269 PDG_DBG_PRINT_C("fei_flush"); 08270 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 08271 PDG_DBG_PRINT_END 08272 08273 08274 # if defined(GENERATE_WHIRL) 08275 # ifdef _ENABLE_FEI 08276 fei_flush(list_cnt); 08277 # endif 08278 # endif 08279 break; 08280 08281 case Fuse_Star_Opr: 08282 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08283 IR_FLD_L(ir_idx)); 08284 08285 if (IR_FLD_R(ir_idx) == CN_Tbl_Idx) { 08286 level = (long) CN_INT_TO_C(IR_IDX_R(ir_idx)); 08287 } 08288 08289 PDG_DBG_PRINT_START 08290 PDG_DBG_PRINT_C("fei_fuse"); 08291 PDG_DBG_PRINT_LD("(1) level", level); 08292 PDG_DBG_PRINT_END 08293 08294 # if defined(GENERATE_WHIRL) 08295 # ifdef _ENABLE_FEI 08296 fei_fuse(level); 08297 # endif 08298 # endif 08299 break; 08300 08301 08302 08303 08304 08305 08306 08307 08308 case Assert_Star_Opr: 08309 assertion = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 08310 08311 if (IR_FLD_R(ir_idx) == NO_Tbl_Idx) { 08312 count = 0; 08313 } 08314 else if (IR_FLD_R(ir_idx) == IL_Tbl_Idx) { 08315 count = IR_LIST_CNT_R(ir_idx); 08316 } 08317 else { 08318 count = 1; 08319 } 08320 08321 if (IR_FLD_R(ir_idx) != NO_Tbl_Idx) { 08322 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 08323 IR_FLD_R(ir_idx)); 08324 } 08325 08326 PDG_DBG_PRINT_START 08327 PDG_DBG_PRINT_C("fei_assert"); 08328 PDG_DBG_PRINT_LD("(1) assertion", assertion); 08329 PDG_DBG_PRINT_D("(2) count ", count); 08330 PDG_DBG_PRINT_END 08331 08332 # if defined(GENERATE_WHIRL) 08333 # ifdef _ENABLE_FEI 08334 fei_assert(assertion, count); 08335 # endif 08336 # endif 08337 break; 08338 08339 08340 08341 08342 08343 case Unroll_Star_Opr: 08344 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08345 IR_FLD_L(ir_idx)); 08346 08347 PDG_DBG_PRINT_START 08348 PDG_DBG_PRINT_C("fei_unroll"); 08349 PDG_DBG_PRINT_END 08350 08351 # if defined(GENERATE_WHIRL) 08352 # ifdef _ENABLE_FEI 08353 fei_unroll(); 08354 # endif 08355 # endif 08356 break; 08357 08358 08359 08360 08361 08362 case Section_Nongp_Star_Opr: 08363 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08364 IR_FLD_L(ir_idx)); 08365 08366 PDG_DBG_PRINT_START 08367 PDG_DBG_PRINT_C("fei_section_nongp"); 08368 PDG_DBG_PRINT_D("(1) list count", IR_LIST_CNT_L(ir_idx)); 08369 PDG_DBG_PRINT_END 08370 08371 # if defined(GENERATE_WHIRL) 08372 # ifdef _ENABLE_FEI 08373 fei_section_nongp(IR_LIST_CNT_L(ir_idx)); 08374 # endif 08375 # endif 08376 break; 08377 08378 08379 08380 08381 08382 08383 case Section_Gp_Star_Opr: 08384 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08385 IR_FLD_L(ir_idx)); 08386 08387 PDG_DBG_PRINT_START 08388 PDG_DBG_PRINT_C("fei_section_gp"); 08389 PDG_DBG_PRINT_D("(1) list count", IR_LIST_CNT_L(ir_idx)); 08390 PDG_DBG_PRINT_END 08391 08392 # if defined(GENERATE_WHIRL) 08393 # ifdef _ENABLE_FEI 08394 fei_section_gp(IR_LIST_CNT_L(ir_idx)); 08395 # endif 08396 # endif 08397 break; 08398 08399 08400 08401 08402 08403 case Copyin_Dollar_Opr: 08404 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08405 IR_FLD_L(ir_idx)); 08406 08407 PDG_DBG_PRINT_START 08408 PDG_DBG_PRINT_C("fei_copy_in"); 08409 PDG_DBG_PRINT_D("(1) list count", IR_LIST_CNT_L(ir_idx)); 08410 PDG_DBG_PRINT_END 08411 08412 # if defined(GENERATE_WHIRL) 08413 # ifdef _ENABLE_FEI 08414 fei_copy_in(IR_LIST_CNT_L(ir_idx)); 08415 # endif 08416 # endif 08417 break; 08418 08419 08420 08421 08422 08423 08424 08425 08426 08427 case Align_Symbol_Star_Opr: 08428 if (IR_FLD_L(ir_idx) == NO_Tbl_Idx) { 08429 list_cnt = 0; 08430 } 08431 else { 08432 list_cnt = 1; 08433 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08434 IR_FLD_L(ir_idx)); 08435 } 08436 08437 if (IR_FLD_R(ir_idx) == CN_Tbl_Idx) { 08438 C_value = (long) CN_INT_TO_C(IR_IDX_R(ir_idx)); 08439 } 08440 08441 PDG_DBG_PRINT_START 08442 PDG_DBG_PRINT_C("fei_align_symbol"); 08443 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 08444 PDG_DBG_PRINT_LD("(2) C_value", C_value); 08445 PDG_DBG_PRINT_END 08446 08447 08448 # if defined(GENERATE_WHIRL) 08449 # ifdef _ENABLE_FEI 08450 fei_align_symbol(list_cnt, C_value); 08451 # endif 08452 # endif 08453 08454 break; 08455 08456 08457 08458 08459 08460 case Fill_Symbol_Star_Opr: 08461 if (IR_FLD_L(ir_idx) == NO_Tbl_Idx) { 08462 list_cnt = 0; 08463 } 08464 else { 08465 list_cnt = 1; 08466 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08467 IR_FLD_L(ir_idx)); 08468 } 08469 08470 if (IR_FLD_R(ir_idx) == CN_Tbl_Idx) { 08471 C_value = (long) CN_INT_TO_C(IR_IDX_R(ir_idx)); 08472 } 08473 08474 PDG_DBG_PRINT_START 08475 PDG_DBG_PRINT_C("fei_fill_symbol"); 08476 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 08477 PDG_DBG_PRINT_LD("(2) C_value", C_value); 08478 PDG_DBG_PRINT_END 08479 08480 08481 # if defined(GENERATE_WHIRL) 08482 # ifdef _ENABLE_FEI 08483 fei_fill_symbol(list_cnt, C_value); 08484 # endif 08485 # endif 08486 break; 08487 08488 08489 08490 08491 08492 08493 08494 case Blockingsize_Dir_Opr: 08495 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08496 IR_FLD_L(ir_idx)); 08497 08498 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 08499 IR_FLD_R(ir_idx)); 08500 08501 PDG_DBG_PRINT_START 08502 PDG_DBG_PRINT_C("fei_blocking_size"); 08503 PDG_DBG_PRINT_END 08504 08505 # if !defined(_TARGET_OS_MAX) 08506 # ifdef _ENABLE_FEI 08507 fei_blocking_size(); 08508 # endif 08509 # endif 08510 break; 08511 08512 08513 08514 08515 case Purpleconditional_Star_Opr: 08516 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08517 IR_FLD_L(ir_idx)); 08518 08519 PDG_DBG_PRINT_START 08520 PDG_DBG_PRINT_C("fei_purple_conditional"); 08521 PDG_DBG_PRINT_END 08522 08523 # if defined(GENERATE_WHIRL) 08524 # ifdef _ENABLE_FEI 08525 fei_purple_conditional(); 08526 # endif 08527 # endif 08528 break; 08529 08530 08531 08532 08533 08534 08535 case Opaque_Star_Opr: 08536 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08537 IR_FLD_L(ir_idx)); 08538 08539 PDG_DBG_PRINT_START 08540 PDG_DBG_PRINT_C("fei_opaque"); 08541 PDG_DBG_PRINT_END 08542 08543 # if defined(GENERATE_WHIRL) 08544 # ifdef _ENABLE_FEI 08545 fei_opaque(); 08546 # endif 08547 # endif 08548 break; 08549 08550 08551 08552 08553 08554 08555 08556 case Purpleunconditional_Star_Opr: 08557 PDG_DBG_PRINT_START 08558 PDG_DBG_PRINT_C("fei_purple_unconditional"); 08559 PDG_DBG_PRINT_END 08560 08561 # if defined(GENERATE_WHIRL) 08562 # ifdef _ENABLE_FEI 08563 fei_purple_unconditional(); 08564 # endif 08565 # endif 08566 break; 08567 08568 08569 08570 08571 case Dynamic_Dollar_Opr: 08572 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08573 IR_FLD_L(ir_idx)); 08574 08575 list_cnt = IR_LIST_CNT_L(ir_idx); 08576 08577 PDG_DBG_PRINT_START 08578 PDG_DBG_PRINT_C("fei_dynamic"); 08579 PDG_DBG_PRINT_D("(1) list count", list_cnt); 08580 PDG_DBG_PRINT_END 08581 08582 # if defined(GENERATE_WHIRL) 08583 # ifdef _ENABLE_FEI 08584 fei_dynamic(list_cnt); 08585 # endif 08586 # endif 08587 break; 08588 08589 08590 08591 08592 08593 case Page_Place_Dollar_Opr: 08594 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 08595 IR_FLD_L(ir_idx)); 08596 08597 PDG_DBG_PRINT_START 08598 PDG_DBG_PRINT_C("fei_page_place"); 08599 PDG_DBG_PRINT_END 08600 08601 # if defined(GENERATE_WHIRL) 08602 # ifdef _ENABLE_FEI 08603 fei_page_place(); 08604 # endif 08605 # endif 08606 break; 08607 08608 08609 08610 08611 case Prefetch_Manual_Star_Opr: 08612 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 08613 prefetch_manual = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 08614 } 08615 08616 PDG_DBG_PRINT_START 08617 PDG_DBG_PRINT_C("fei_prefetch_manual"); 08618 PDG_DBG_PRINT_LD("(1) prefetch_manual", prefetch_manual); 08619 PDG_DBG_PRINT_END 08620 08621 # if defined(GENERATE_WHIRL) 08622 # ifdef _ENABLE_FEI 08623 fei_prefetch_manual(prefetch_manual); 08624 # endif 08625 # endif 08626 break; 08627 08628 08629 08630 08631 08632 08633 case Prefetch_Star_Opr: 08634 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 08635 n1 = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 08636 } 08637 08638 if (IR_FLD_R(ir_idx) == CN_Tbl_Idx) { 08639 n2 = (long) CN_INT_TO_C(IR_IDX_R(ir_idx)); 08640 } 08641 08642 PDG_DBG_PRINT_START 08643 PDG_DBG_PRINT_C("fei_prefetch"); 08644 PDG_DBG_PRINT_LD("(1) n1", n1); 08645 PDG_DBG_PRINT_LD("(2) n2", n2); 08646 PDG_DBG_PRINT_END 08647 08648 # if defined(GENERATE_WHIRL) 08649 # ifdef _ENABLE_FEI 08650 fei_prefetch(n1, n2); 08651 # endif 08652 # endif 08653 break; 08654 08655 08656 08657 08658 08659 08660 case Prefetch_Ref_Disable_Star_Opr: 08661 if (IR_FLD_L(ir_idx) == AT_Tbl_Idx) { 08662 send_attr_ntry(IR_IDX_L(ir_idx)); 08663 prefetch_array = (long) PDG_AT_IDX(IR_IDX_L(ir_idx)); 08664 } 08665 08666 if (IR_FLD_R(ir_idx) == CN_Tbl_Idx) { 08667 prefetch_size = (long) CN_INT_TO_C(IR_IDX_R(ir_idx)); 08668 } 08669 08670 PDG_DBG_PRINT_START 08671 PDG_DBG_PRINT_C("fei_prefetch_ref_disable"); 08672 PDG_DBG_PRINT_LD("(1) prefetch_array", prefetch_array); 08673 PDG_DBG_PRINT_LD("(2) prefetch_size", prefetch_size); 08674 PDG_DBG_PRINT_END 08675 08676 # if defined(GENERATE_WHIRL) 08677 # ifdef _ENABLE_FEI 08678 fei_prefetch_ref_disable(prefetch_array, prefetch_size); 08679 # endif 08680 # endif 08681 break; 08682 08683 08684 08685 08686 08687 08688 08689 case Prefetch_Ref_Star_Opr: 08690 list_idx1 = IR_IDX_L(ir_idx); 08691 08692 for (i = 0; i < 5; i++) { 08693 list_array[i] = list_idx1; 08694 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 08695 } 08696 08697 /* stack the array reference */ 08698 cvrt_exp_to_pdg(IL_IDX(list_array[0]), 08699 IL_FLD(list_array[0])); 08700 08701 /* stack the stride list - 1 or 2 items in list */ 08702 cvrt_exp_to_pdg(IL_IDX(list_array[1]), 08703 IL_FLD(list_array[1])); 08704 if (IL_FLD(list_array[1]) != NO_Tbl_Idx) { 08705 stride_list = IL_LIST_CNT(list_array[1]); 08706 } 08707 08708 /* stack the level list - 1 or 2 items in list */ 08709 cvrt_exp_to_pdg(IL_IDX(list_array[2]), 08710 IL_FLD(list_array[2])); 08711 if (IL_FLD(list_array[2]) != NO_Tbl_Idx) { 08712 level_list = IL_LIST_CNT(list_array[2]); 08713 } 08714 08715 if (IL_FLD(list_array[3]) == CN_Tbl_Idx) { 08716 prefetch_kind = (long) CN_INT_TO_C(IL_IDX(list_array[3])); 08717 } 08718 08719 if (IL_FLD(list_array[4]) == CN_Tbl_Idx) { 08720 prefetch_size = (long) CN_INT_TO_C(IL_IDX(list_array[4])); 08721 } 08722 08723 PDG_DBG_PRINT_START 08724 PDG_DBG_PRINT_C("fei_prefetch_ref"); 08725 PDG_DBG_PRINT_D("(1) stride_list", stride_list); 08726 PDG_DBG_PRINT_D("(2) level_list", level_list); 08727 PDG_DBG_PRINT_LD("(3) prefetch_kind", prefetch_kind); 08728 PDG_DBG_PRINT_LD("(4) prefetch_size", prefetch_size); 08729 PDG_DBG_PRINT_END 08730 08731 # if defined(GENERATE_WHIRL) 08732 # ifdef _ENABLE_FEI 08733 fei_prefetch_ref(stride_list, 08734 level_list, 08735 prefetch_kind, 08736 prefetch_size); 08737 # endif 08738 # endif 08739 08740 break; 08741 08742 08743 08744 08745 08746 08747 case Redistribute_Dollar_Opr: 08748 if (IR_FLD_L(ir_idx) == AT_Tbl_Idx) { 08749 send_attr_ntry(IR_IDX_L(ir_idx)); 08750 redistribute_array = PDG_AT_IDX(IR_IDX_L(ir_idx)); 08751 } 08752 08753 cyclic_list = IR_IDX_R(ir_idx); 08754 list_cnt = IL_LIST_CNT(cyclic_list); 08755 onto_list = IL_NEXT_LIST_IDX(cyclic_list); 08756 cyclic_list = IL_IDX(cyclic_list); 08757 08758 if (onto_list) { 08759 onto_list = IL_IDX(onto_list); 08760 } 08761 08762 for (j = 1; j <= list_cnt; j++) { 08763 cyclic_exists = 0; 08764 onto_exists = 0; 08765 08766 if (onto_list) { 08767 cvrt_exp_to_pdg(IL_IDX(onto_list), 08768 IL_FLD(onto_list)); 08769 if (IL_FLD(onto_list) != NO_Tbl_Idx) { 08770 onto_exists = 1; 08771 } 08772 } 08773 08774 cvrt_exp_to_pdg(IL_IDX(cyclic_list), 08775 IL_FLD(cyclic_list)); 08776 if (IL_FLD(cyclic_list) != NO_Tbl_Idx) { 08777 cyclic_exists = 1; 08778 } 08779 08780 PDG_DBG_PRINT_START 08781 PDG_DBG_PRINT_C("fei_redistribute"); 08782 PDG_DBG_PRINT_S("AT_OBJ_NAME", 08783 AT_OBJ_NAME_PTR(IR_IDX_L(ir_idx))); 08784 PDG_DBG_PRINT_D("(1) array", redistribute_array); 08785 PDG_DBG_PRINT_D("(2) dimension", j); 08786 PDG_DBG_PRINT_D("(3) distribution", IL_DISTRIBUTION(cyclic_list)); 08787 PDG_DBG_PRINT_LD("(4) cyclic_exists", cyclic_exists); 08788 PDG_DBG_PRINT_LD("(5) onto_exists", onto_exists); 08789 PDG_DBG_PRINT_END 08790 08791 # if defined(GENERATE_WHIRL) 08792 # ifdef _ENABLE_FEI 08793 fei_redistribute(redistribute_array, 08794 j, 08795 IL_DISTRIBUTION(cyclic_list), 08796 cyclic_exists, 08797 onto_exists); 08798 # endif 08799 # endif 08800 cyclic_list = IL_NEXT_LIST_IDX(cyclic_list); 08801 08802 if (onto_list) { 08803 onto_list = IL_NEXT_LIST_IDX(onto_list); 08804 } 08805 } 08806 break; 08807 08808 08809 08810 case Doall_Cmic_Opr: 08811 list_idx1 = IR_IDX_L(ir_idx); 08812 08813 for (i = 0; i < 10; i++) { 08814 list_array[i] = list_idx1; 08815 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 08816 } 08817 08818 first_task_idx = NULL_IDX; 08819 last_task_idx = first_task_idx; 08820 08821 /* process SHARED list */ 08822 08823 if (IL_FLD(list_array[1]) == IL_Tbl_Idx) { 08824 list_idx2 = IL_IDX(list_array[1]); 08825 08826 while (list_idx2) { 08827 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 08828 send_attr_ntry(IL_IDX(list_idx2)); 08829 08830 PDG_DBG_PRINT_START 08831 PDG_DBG_PRINT_C("fei_task_var"); 08832 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 08833 PDG_AT_IDX(IL_IDX(list_idx2))); 08834 PDG_DBG_PRINT_S("(2) context", 08835 p_tasking_context[Context_Shared]); 08836 PDG_DBG_PRINT_END 08837 08838 # ifdef _ENABLE_FEI 08839 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 08840 Context_Shared); 08841 # endif 08842 08843 if (first_task_idx == NULL_IDX) { 08844 first_task_idx = last_task_idx; 08845 } 08846 } 08847 08848 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 08849 } 08850 } 08851 08852 /* process PRIVATE list */ 08853 08854 if (IL_FLD(list_array[2]) == IL_Tbl_Idx) { 08855 list_idx2 = IL_IDX(list_array[2]); 08856 08857 idx = Context_Private; 08858 # if defined(GENERATE_WHIRL) 08859 if (IL_FLD(list_array[6]) == CN_Tbl_Idx) { /* SAVELAST */ 08860 idx = Context_Lastlocal; 08861 } 08862 # endif 08863 08864 while (list_idx2) { 08865 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 08866 send_attr_ntry(IL_IDX(list_idx2)); 08867 08868 PDG_DBG_PRINT_START 08869 PDG_DBG_PRINT_C("fei_task_var"); 08870 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 08871 PDG_AT_IDX(IL_IDX(list_idx2))); 08872 PDG_DBG_PRINT_S("(2) context", p_tasking_context[idx]); 08873 PDG_DBG_PRINT_END 08874 08875 # ifdef _ENABLE_FEI 08876 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 08877 idx); 08878 # endif 08879 08880 if (first_task_idx == NULL_IDX) { 08881 first_task_idx = last_task_idx; 08882 } 08883 } 08884 08885 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 08886 } 08887 } 08888 08889 /* process GETFIRST list */ 08890 08891 if (IL_FLD(list_array[3]) == IL_Tbl_Idx) { 08892 list_idx2 = IL_IDX(list_array[3]); 08893 08894 while (list_idx2) { 08895 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 08896 send_attr_ntry(IL_IDX(list_idx2)); 08897 08898 PDG_DBG_PRINT_START 08899 PDG_DBG_PRINT_C("fei_task_var"); 08900 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 08901 PDG_AT_IDX(IL_IDX(list_idx2))); 08902 PDG_DBG_PRINT_S("(2) context", 08903 p_tasking_context[Context_Getfirst]); 08904 PDG_DBG_PRINT_END 08905 08906 # ifdef _ENABLE_FEI 08907 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 08908 Context_Getfirst); 08909 # endif 08910 08911 if (first_task_idx == NULL_IDX) { 08912 first_task_idx = last_task_idx; 08913 } 08914 } 08915 08916 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 08917 } 08918 } 08919 08920 08921 /* process CONTROL list */ 08922 08923 if (IL_FLD(list_array[5]) == IL_Tbl_Idx) { 08924 list_idx2 = IL_IDX(list_array[5]); 08925 08926 while (list_idx2) { 08927 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 08928 send_attr_ntry(IL_IDX(list_idx2)); 08929 08930 PDG_DBG_PRINT_START 08931 PDG_DBG_PRINT_C("fei_task_var"); 08932 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 08933 PDG_AT_IDX(IL_IDX(list_idx2))); 08934 PDG_DBG_PRINT_S("(2) context", 08935 p_tasking_context[Context_Control]); 08936 PDG_DBG_PRINT_END 08937 08938 # ifdef _ENABLE_FEI 08939 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 08940 Context_Control); 08941 # endif 08942 08943 if (first_task_idx == NULL_IDX) { 08944 first_task_idx = last_task_idx; 08945 } 08946 } 08947 08948 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 08949 } 08950 } 08951 08952 j = 0; 08953 08954 if (IL_FLD(list_array[4]) == CN_Tbl_Idx) { 08955 /* AUTOSCOPE */ 08956 j = j + 2; 08957 } 08958 08959 if (IL_FLD(list_array[6]) == CN_Tbl_Idx) { 08960 /* SAVELAST */ 08961 j = j + 1; 08962 } 08963 08964 if (IL_FLD(list_array[0]) == NO_Tbl_Idx) { 08965 task_if_idx = 0; 08966 } 08967 else { 08968 send_attr_ntry(IL_IDX(list_array[0])); 08969 task_if_idx = PDG_AT_IDX(IL_IDX(list_array[0])); 08970 } 08971 08972 if (IL_FLD(list_array[7]) == NO_Tbl_Idx) { 08973 task_maxcpus_idx = 0; 08974 } 08975 else { 08976 send_attr_ntry(IL_IDX(list_array[7])); 08977 task_maxcpus_idx = PDG_AT_IDX(IL_IDX(list_array[7])); 08978 } 08979 08980 if (IL_FLD(list_array[9]) == NO_Tbl_Idx) { 08981 task_wdist_idx = 0; 08982 } 08983 else { 08984 send_attr_ntry(IL_IDX(list_array[9])); 08985 task_wdist_idx = PDG_AT_IDX(IL_IDX(list_array[9])); 08986 } 08987 08988 send_attr_ntry(IR_IDX_R(ir_idx)); 08989 big_int = CN_INT_TO_C(IL_IDX(list_array[8])); 08990 08991 PDG_DBG_PRINT_START 08992 PDG_DBG_PRINT_C("fei_doall"); 08993 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 08994 PDG_DBG_PRINT_D("(2) maxcpus idx", task_maxcpus_idx); 08995 PDG_DBG_PRINT_D("(3) first task idx", first_task_idx); 08996 PDG_DBG_PRINT_D("(4) last task idx", last_task_idx); 08997 PDG_DBG_PRINT_LD("(5) obj idx", PDG_AT_IDX(IR_IDX_R(ir_idx))); 08998 #if defined(_HOST32) && defined(_TARGET64) 08999 PDG_DBG_PRINT_D("(6) const", big_int); 09000 #else 09001 PDG_DBG_PRINT_VD("(6) const", big_int); 09002 #endif 09003 PDG_DBG_PRINT_D("(7) wdist idx", task_wdist_idx); 09004 PDG_DBG_PRINT_D("(8) ", j); 09005 PDG_DBG_PRINT_D("(9) line num", IR_LINE_NUM(ir_idx)); 09006 PDG_DBG_PRINT_END 09007 09008 # ifdef _ENABLE_FEI 09009 fei_doall(task_if_idx, 09010 task_maxcpus_idx, 09011 first_task_idx, 09012 last_task_idx, 09013 PDG_AT_IDX(IR_IDX_R(ir_idx)), 09014 big_int, 09015 task_wdist_idx, 09016 j, 09017 IR_LINE_NUM(ir_idx)); 09018 # endif 09019 09020 break; 09021 09022 09023 09024 09025 09026 case Doparallel_Cmic_Opr: 09027 list_idx1 = IR_IDX_L(ir_idx); 09028 09029 for (i = 0; i < 2; i++) { 09030 list_array[i] = list_idx1; 09031 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 09032 } 09033 09034 if (IL_FLD(list_array[1]) == NO_Tbl_Idx) { 09035 task_wdist_idx = 0; 09036 } 09037 else { 09038 send_attr_ntry(IL_IDX(list_array[1])); 09039 task_wdist_idx = PDG_AT_IDX(IL_IDX(list_array[1])); 09040 } 09041 09042 send_attr_ntry(IR_IDX_R(ir_idx)); 09043 big_int = CN_INT_TO_C(IL_IDX(list_array[0])); 09044 09045 PDG_DBG_PRINT_START 09046 PDG_DBG_PRINT_C("fei_doparallel"); 09047 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(IR_IDX_R(ir_idx))); 09048 #if defined(_HOST32) && defined(_TARGET64) 09049 PDG_DBG_PRINT_D("(2) const", big_int); 09050 #else 09051 PDG_DBG_PRINT_VD("(2) const", big_int); 09052 #endif 09053 PDG_DBG_PRINT_D("(3) task idx", task_wdist_idx); 09054 PDG_DBG_PRINT_D("(4) line num", IR_LINE_NUM(ir_idx)); 09055 PDG_DBG_PRINT_END 09056 09057 09058 # ifdef _ENABLE_FEI 09059 doparallel_cmic_vpr_idx = 09060 fei_doparallel(PDG_AT_IDX(IR_IDX_R(ir_idx)), 09061 big_int, 09062 task_wdist_idx, 09063 IR_LINE_NUM(ir_idx)); 09064 # endif 09065 09066 break; 09067 09068 09069 09070 09071 case Enddo_Cmic_Opr: 09072 09073 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 09074 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 09075 } 09076 09077 PDG_DBG_PRINT_START 09078 PDG_DBG_PRINT_C("fei_task_endloop"); 09079 PDG_DBG_PRINT_D("(1) pdg idx", doparallel_cmic_vpr_idx); 09080 PDG_DBG_PRINT_D("(2) line num", IR_LINE_NUM(ir_idx)); 09081 PDG_DBG_PRINT_LD("(3) nowait", nowait); 09082 PDG_DBG_PRINT_END 09083 09084 # ifdef _ENABLE_FEI 09085 fei_task_endloop(doparallel_cmic_vpr_idx, 09086 IR_LINE_NUM(ir_idx), 09087 nowait); 09088 # endif 09089 doparallel_cmic_vpr_idx = NULL_IDX; 09090 break; 09091 09092 09093 09094 09095 09096 09097 case Parallel_Cmic_Opr: 09098 list_idx1 = IR_IDX_L(ir_idx); 09099 09100 for (i = 0; i < 7; i++) { 09101 list_array[i] = list_idx1; 09102 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 09103 } 09104 09105 first_task_idx = NULL_IDX; 09106 09107 /* process SHARED list */ 09108 09109 if (IL_FLD(list_array[1]) == IL_Tbl_Idx) { 09110 list_idx2 = IL_IDX(list_array[1]); 09111 09112 while (list_idx2) { 09113 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09114 send_attr_ntry(IL_IDX(list_idx2)); 09115 09116 PDG_DBG_PRINT_START 09117 PDG_DBG_PRINT_C("fei_task_var"); 09118 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09119 PDG_AT_IDX(IL_IDX(list_idx2))); 09120 PDG_DBG_PRINT_S("(2) context", 09121 p_tasking_context[Context_Shared]); 09122 PDG_DBG_PRINT_END 09123 09124 # ifdef _ENABLE_FEI 09125 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09126 Context_Shared); 09127 # endif 09128 09129 if (first_task_idx == NULL_IDX) { 09130 first_task_idx = last_task_idx; 09131 } 09132 } 09133 09134 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09135 } 09136 } 09137 09138 /* process PRIVATE list */ 09139 09140 if (IL_FLD(list_array[2]) == IL_Tbl_Idx) { 09141 list_idx2 = IL_IDX(list_array[2]); 09142 09143 while (list_idx2) { 09144 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09145 send_attr_ntry(IL_IDX(list_idx2)); 09146 09147 PDG_DBG_PRINT_START 09148 PDG_DBG_PRINT_C("fei_task_var"); 09149 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09150 PDG_AT_IDX(IL_IDX(list_idx2))); 09151 PDG_DBG_PRINT_S("(2) context", 09152 p_tasking_context[Context_Private]); 09153 PDG_DBG_PRINT_END 09154 09155 # ifdef _ENABLE_FEI 09156 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09157 Context_Private); 09158 # endif 09159 09160 if (first_task_idx == NULL_IDX) { 09161 first_task_idx = last_task_idx; 09162 } 09163 } 09164 09165 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09166 } 09167 } 09168 09169 /* process GETFIRST list */ 09170 09171 if (IL_FLD(list_array[3]) == IL_Tbl_Idx) { 09172 list_idx2 = IL_IDX(list_array[3]); 09173 09174 while (list_idx2) { 09175 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09176 send_attr_ntry(IL_IDX(list_idx2)); 09177 09178 PDG_DBG_PRINT_START 09179 PDG_DBG_PRINT_C("fei_task_var"); 09180 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09181 PDG_AT_IDX(IL_IDX(list_idx2))); 09182 PDG_DBG_PRINT_S("(2) context", 09183 p_tasking_context[Context_Getfirst]); 09184 PDG_DBG_PRINT_END 09185 09186 # ifdef _ENABLE_FEI 09187 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09188 Context_Getfirst); 09189 # endif 09190 09191 if (first_task_idx == NULL_IDX) { 09192 first_task_idx = last_task_idx; 09193 } 09194 } 09195 09196 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09197 } 09198 } 09199 09200 /* process CONTROL list */ 09201 09202 if (IL_FLD(list_array[5]) == IL_Tbl_Idx) { 09203 list_idx2 = IL_IDX(list_array[5]); 09204 09205 while (list_idx2) { 09206 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09207 send_attr_ntry(IL_IDX(list_idx2)); 09208 09209 PDG_DBG_PRINT_START 09210 PDG_DBG_PRINT_C("fei_task_var"); 09211 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09212 PDG_AT_IDX(IL_IDX(list_idx2))); 09213 PDG_DBG_PRINT_S("(2) context", 09214 p_tasking_context[Context_Control]); 09215 PDG_DBG_PRINT_END 09216 09217 # ifdef _ENABLE_FEI 09218 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09219 Context_Control); 09220 # endif 09221 09222 if (first_task_idx == NULL_IDX) { 09223 first_task_idx = last_task_idx; 09224 } 09225 } 09226 09227 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09228 } 09229 } 09230 09231 i = 0L; 09232 09233 if (IL_FLD(list_array[4]) == CN_Tbl_Idx) { 09234 i = 2; 09235 } 09236 09237 if (IL_FLD(list_array[0]) == NO_Tbl_Idx) { 09238 task_if_idx = 0; 09239 } 09240 else { 09241 send_attr_ntry(IL_IDX(list_array[0])); 09242 task_if_idx = PDG_AT_IDX(IL_IDX(list_array[0])); 09243 } 09244 09245 if (IL_FLD(list_array[6]) == NO_Tbl_Idx) { 09246 task_maxcpus_idx = 0; 09247 } 09248 else { 09249 send_attr_ntry(IL_IDX(list_array[6])); 09250 task_maxcpus_idx = PDG_AT_IDX(IL_IDX(list_array[6])); 09251 } 09252 09253 PDG_DBG_PRINT_START 09254 PDG_DBG_PRINT_C("fei_parallel_region"); 09255 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 09256 PDG_DBG_PRINT_D("(2) maxcpus idx", task_maxcpus_idx); 09257 PDG_DBG_PRINT_D("(3) first task idx", first_task_idx); 09258 PDG_DBG_PRINT_D("(4) last task idx", last_task_idx); 09259 PDG_DBG_PRINT_D("(5) line num", IR_LINE_NUM(ir_idx)); 09260 PDG_DBG_PRINT_D("(6) ", (int) i); 09261 PDG_DBG_PRINT_END 09262 09263 # ifdef _ENABLE_FEI 09264 parallel_cmic_vpr_idx = fei_parallel_region(task_if_idx, 09265 task_maxcpus_idx, 09266 first_task_idx, 09267 last_task_idx, 09268 IR_LINE_NUM(ir_idx), 09269 i); 09270 # endif 09271 09272 break; 09273 09274 09275 09276 09277 09278 case Endparallel_Cmic_Opr: 09279 PDG_DBG_PRINT_START 09280 PDG_DBG_PRINT_C("fei_endparallel_region"); 09281 PDG_DBG_PRINT_D("(1) cmic vpr idx", doparallel_cmic_vpr_idx); 09282 PDG_DBG_PRINT_D("(2) line num", IR_LINE_NUM(ir_idx)); 09283 PDG_DBG_PRINT_END 09284 09285 # ifdef _ENABLE_FEI 09286 fei_endparallel_region(parallel_cmic_vpr_idx, IR_LINE_NUM(ir_idx)); 09287 # endif 09288 parallel_cmic_vpr_idx = NULL_IDX; 09289 break; 09290 09291 09292 09293 09294 09295 case Suppress_Opr: 09296 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09297 IR_FLD_L(ir_idx)); 09298 09299 send_label_def(ir_idx); 09300 break; 09301 09302 09303 case Use_Opr: 09304 09305 /* we add a use stmt "use w2f__types" in *.w2f.f files 09306 * we don't want this stmt appearing in the WHIRL representation 09307 * when recompile the generated code,so just igore the stmt 09308 * "use w2f__types" in cvrt_to_PDG processing 09309 * ------fzhao 09310 */ 09311 09312 if (strncasecmp("w2f__types",AT_OBJ_NAME_PTR(IR_IDX_L(ir_idx)),10) == 0) 09313 break; 09314 09315 09316 if (ATP_USE_LIST(IR_IDX_L(ir_idx)) != NULL_IDX) { 09317 ro_idx = ATP_USE_LIST(IR_IDX_L(ir_idx)); 09318 while (ro_idx != NULL_IDX) { 09319 fei_rename_list(&name_pool[AT_NAME_IDX(RO_NAME_ATTR(ro_idx))].name_char); 09320 09321 ++rename_only_num; 09322 fei_rename_list(&name_pool[AT_ORIG_NAME_IDX(RO_NAME_ATTR(ro_idx))].name_char); 09323 ++rename_only_num; 09324 ro_idx = RO_NEXT_IDX(ro_idx); 09325 } 09326 } 09327 09328 09329 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09330 IR_FLD_L(ir_idx)); 09331 if (ATP_USE_TYPE(IR_IDX_L(ir_idx)) == Use_Only) 09332 onlyPredicate = 1; 09333 09334 fei_use(rename_only_num,onlyPredicate); 09335 09336 # if defined(_MODULE_TO_DOT_o) 09337 if (!on_off_flags.module_to_mod && 09338 # else 09339 if ( 09340 # endif 09341 !ATP_IN_CURRENT_COMPILE(IR_IDX_L(ir_idx))) { 09342 09343 09344 PDG_DBG_PRINT_START 09345 PDG_DBG_PRINT_C("fei_next_name"); 09346 PDG_DBG_PRINT_D("(1) logical", TRUE); 09347 PDG_DBG_PRINT_END 09348 09349 # ifdef _ENABLE_FEI 09350 path_idx = fei_next_name(TRUE); 09351 # endif 09352 09353 PDG_DBG_PRINT_START 09354 PDG_DBG_PRINT_C("fei_name"); 09355 PDG_DBG_PRINT_S("(1) name_ptr", 09356 &name_pool[ATP_MOD_PATH_IDX(IR_IDX_L(ir_idx))].name_char); 09357 PDG_DBG_PRINT_D("(2) unused", 0); 09358 PDG_DBG_PRINT_D("(3) unused", 0); 09359 PDG_DBG_PRINT_D("(4) unused", 0); 09360 PDG_DBG_PRINT_D("(5) index to use", path_idx); 09361 PDG_DBG_PRINT_END 09362 09363 # ifdef _ENABLE_FEI 09364 09365 fei_name(&name_pool[ATP_MOD_PATH_IDX(IR_IDX_L(ir_idx))].name_char, 09366 0, 09367 0, 09368 0, 09369 path_idx); 09370 # endif 09371 09372 09373 PDG_DBG_PRINT_START 09374 PDG_DBG_PRINT_C("fei_next_name"); 09375 PDG_DBG_PRINT_D("(1) logical", TRUE); 09376 PDG_DBG_PRINT_END 09377 09378 # ifdef _ENABLE_FEI 09379 name_idx = fei_next_name(TRUE); 09380 # endif 09381 09382 PDG_DBG_PRINT_START 09383 PDG_DBG_PRINT_C("fei_name"); 09384 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", 09385 AT_OBJ_NAME_PTR(IR_IDX_L(ir_idx))); 09386 PDG_DBG_PRINT_D("(2) unused", 0); 09387 PDG_DBG_PRINT_D("(3) unused", 0); 09388 PDG_DBG_PRINT_D("(4) unused", 0); 09389 PDG_DBG_PRINT_D("(5) index to use", name_idx); 09390 PDG_DBG_PRINT_END 09391 09392 # ifdef _ENABLE_FEI 09393 fei_name(AT_OBJ_NAME_PTR(IR_IDX_L(ir_idx)), 09394 0, 09395 0, 09396 0, 09397 name_idx); 09398 # endif 09399 09400 name_idx = fei_next_name(TRUE); 09401 09402 09403 PDG_DBG_PRINT_START 09404 PDG_DBG_PRINT_C("fei_add_use_path"); 09405 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09406 PDG_AT_IDX(SCP_ATTR_IDX(curr_scp_idx))); 09407 PDG_DBG_PRINT_D("(2) path index", path_idx); 09408 PDG_DBG_PRINT_D("(3) name index", name_idx); 09409 PDG_DBG_PRINT_END 09410 09411 # ifdef _ENABLE_FEI 09412 fei_add_use_path(PDG_AT_IDX(SCP_ATTR_IDX(curr_scp_idx)), 09413 path_idx, 09414 name_idx); 09415 09416 #if 0 09417 /* here add send all rename as ST item 09418 here add fei_use(module_name,boolen with only or not) 09419 */ 09420 if (ATP_USE_LIST(IR_IDX_L(ir_idx) != NULL_IDX)) 09421 printf("rename_only_list?\n"); 09422 #endif 09423 09424 09425 # endif 09426 } 09427 break; 09428 09429 09430 09431 09432 case Symbolic_Mult_Opr: 09433 save_symbolic_constant_expr = symbolic_constant_expr; 09434 symbolic_constant_expr = TRUE; 09435 09436 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09437 IR_FLD_L(ir_idx)); 09438 09439 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09440 IR_FLD_R(ir_idx)); 09441 09442 PDG_DBG_PRINT_START 09443 PDG_DBG_PRINT_C("npex_mult"); 09444 PDG_DBG_PRINT_END 09445 09446 # ifdef _ENABLE_FEI 09447 npex_mult(); 09448 # endif 09449 09450 symbolic_constant_expr = save_symbolic_constant_expr; 09451 09452 if (!symbolic_constant_expr) { 09453 finish_symbolic_expr(); 09454 } 09455 break; 09456 09457 09458 09459 09460 09461 case Symbolic_Div_Opr: 09462 save_symbolic_constant_expr = symbolic_constant_expr; 09463 symbolic_constant_expr = TRUE; 09464 09465 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09466 IR_FLD_L(ir_idx)); 09467 09468 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09469 IR_FLD_R(ir_idx)); 09470 09471 PDG_DBG_PRINT_START 09472 PDG_DBG_PRINT_C("npex_div"); 09473 PDG_DBG_PRINT_END 09474 09475 # ifdef _ENABLE_FEI 09476 npex_div(); 09477 # endif 09478 09479 symbolic_constant_expr = save_symbolic_constant_expr; 09480 09481 if (!symbolic_constant_expr) { 09482 finish_symbolic_expr(); 09483 } 09484 break; 09485 09486 09487 09488 09489 case Symbolic_Plus_Opr: 09490 save_symbolic_constant_expr = symbolic_constant_expr; 09491 symbolic_constant_expr = TRUE; 09492 09493 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09494 IR_FLD_L(ir_idx)); 09495 09496 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09497 IR_FLD_R(ir_idx)); 09498 09499 PDG_DBG_PRINT_START 09500 PDG_DBG_PRINT_C("npex_plus"); 09501 PDG_DBG_PRINT_END 09502 09503 # ifdef _ENABLE_FEI 09504 npex_plus(); 09505 # endif 09506 09507 symbolic_constant_expr = save_symbolic_constant_expr; 09508 09509 if (!symbolic_constant_expr) { 09510 finish_symbolic_expr(); 09511 } 09512 break; 09513 09514 09515 09516 09517 09518 case Symbolic_Minus_Opr: 09519 save_symbolic_constant_expr = symbolic_constant_expr; 09520 symbolic_constant_expr = TRUE; 09521 09522 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09523 IR_FLD_L(ir_idx)); 09524 09525 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09526 IR_FLD_R(ir_idx)); 09527 09528 PDG_DBG_PRINT_START 09529 PDG_DBG_PRINT_C("npex_minus"); 09530 PDG_DBG_PRINT_END 09531 09532 # ifdef _ENABLE_FEI 09533 npex_minus(); 09534 # endif 09535 09536 symbolic_constant_expr = save_symbolic_constant_expr; 09537 09538 if (!symbolic_constant_expr) { 09539 finish_symbolic_expr(); 09540 } 09541 break; 09542 09543 09544 09545 09546 09547 case Symbolic_Uminus_Opr : 09548 save_symbolic_constant_expr = symbolic_constant_expr; 09549 symbolic_constant_expr = TRUE; 09550 09551 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09552 IR_FLD_L(ir_idx)); 09553 09554 PDG_DBG_PRINT_START 09555 PDG_DBG_PRINT_C("npex_uminus"); 09556 PDG_DBG_PRINT_END 09557 09558 # ifdef _ENABLE_FEI 09559 npex_uminus(); 09560 # endif 09561 09562 symbolic_constant_expr = save_symbolic_constant_expr; 09563 09564 if (!symbolic_constant_expr) { 09565 finish_symbolic_expr(); 09566 } 09567 break; 09568 09569 09570 09571 09572 case Symbolic_Uplus_Opr : 09573 save_symbolic_constant_expr = symbolic_constant_expr; 09574 symbolic_constant_expr = TRUE; 09575 09576 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09577 IR_FLD_L(ir_idx)); 09578 09579 09580 symbolic_constant_expr = save_symbolic_constant_expr; 09581 09582 if (!symbolic_constant_expr) { 09583 finish_symbolic_expr(); 09584 } 09585 break; 09586 09587 09588 09589 09590 case Symbolic_Mod_Opr: 09591 save_symbolic_constant_expr = symbolic_constant_expr; 09592 symbolic_constant_expr = TRUE; 09593 09594 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09595 IR_FLD_L(ir_idx)); 09596 09597 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09598 IR_FLD_R(ir_idx)); 09599 09600 PDG_DBG_PRINT_START 09601 PDG_DBG_PRINT_C("npex_mod"); 09602 PDG_DBG_PRINT_END 09603 09604 # ifdef _ENABLE_FEI 09605 npex_mod(); 09606 # endif 09607 09608 symbolic_constant_expr = save_symbolic_constant_expr; 09609 09610 if (!symbolic_constant_expr) { 09611 finish_symbolic_expr(); 09612 } 09613 break; 09614 09615 09616 09617 09618 case Symbolic_Shiftr_Opr: 09619 save_symbolic_constant_expr = symbolic_constant_expr; 09620 symbolic_constant_expr = TRUE; 09621 09622 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09623 IR_FLD_L(ir_idx)); 09624 09625 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09626 IR_FLD_R(ir_idx)); 09627 09628 PDG_DBG_PRINT_START 09629 PDG_DBG_PRINT_C("npex_shiftr"); 09630 PDG_DBG_PRINT_END 09631 09632 # ifdef _ENABLE_FEI 09633 npex_shiftr(); 09634 # endif 09635 09636 symbolic_constant_expr = save_symbolic_constant_expr; 09637 09638 if (!symbolic_constant_expr) { 09639 finish_symbolic_expr(); 09640 } 09641 break; 09642 09643 09644 09645 09646 09647 case Symbolic_Shiftl_Opr: 09648 save_symbolic_constant_expr = symbolic_constant_expr; 09649 symbolic_constant_expr = TRUE; 09650 09651 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 09652 IR_FLD_L(ir_idx)); 09653 09654 cvrt_exp_to_pdg(IR_IDX_R(ir_idx), 09655 IR_FLD_R(ir_idx)); 09656 09657 PDG_DBG_PRINT_START 09658 PDG_DBG_PRINT_C("npex_shiftl"); 09659 PDG_DBG_PRINT_END 09660 09661 # ifdef _ENABLE_FEI 09662 npex_shiftl(); 09663 # endif 09664 09665 symbolic_constant_expr = save_symbolic_constant_expr; 09666 09667 if (!symbolic_constant_expr) { 09668 finish_symbolic_expr(); 09669 } 09670 break; 09671 09672 09673 09674 09675 09676 case Symbolic_Max_Opr : 09677 save_symbolic_constant_expr = symbolic_constant_expr; 09678 symbolic_constant_expr = TRUE; 09679 09680 tmp_ir_idx = IR_IDX_L(ir_idx); 09681 count = 0; 09682 09683 while (tmp_ir_idx != NULL_IDX) { 09684 09685 if (IL_IDX(tmp_ir_idx) != NULL_IDX) { 09686 cvrt_exp_to_pdg(IL_IDX(tmp_ir_idx), 09687 IL_FLD(tmp_ir_idx)); 09688 count += 1; 09689 } 09690 tmp_ir_idx = IL_NEXT_LIST_IDX(tmp_ir_idx); 09691 } 09692 09693 09694 PDG_DBG_PRINT_START 09695 PDG_DBG_PRINT_C("npex_max"); 09696 PDG_DBG_PRINT_END 09697 09698 # ifdef _TARGET_OS_MAX 09699 # ifdef _ENABLE_FEI 09700 npex_max(); 09701 # endif 09702 # endif 09703 09704 symbolic_constant_expr = save_symbolic_constant_expr; 09705 09706 if (!symbolic_constant_expr) { 09707 finish_symbolic_expr(); 09708 } 09709 break; 09710 09711 09712 09713 09714 09715 case Symbolic_Min_Opr : 09716 save_symbolic_constant_expr = symbolic_constant_expr; 09717 symbolic_constant_expr = TRUE; 09718 09719 tmp_ir_idx = IR_IDX_L(ir_idx); 09720 count = 0; 09721 09722 while (tmp_ir_idx != NULL_IDX) { 09723 09724 if (IL_IDX(tmp_ir_idx) != NULL_IDX) { 09725 cvrt_exp_to_pdg(IL_IDX(tmp_ir_idx), 09726 IL_FLD(tmp_ir_idx)); 09727 count += 1; 09728 } 09729 tmp_ir_idx = IL_NEXT_LIST_IDX(tmp_ir_idx); 09730 } 09731 09732 09733 PDG_DBG_PRINT_START 09734 PDG_DBG_PRINT_C("npex_min"); 09735 PDG_DBG_PRINT_END 09736 09737 # ifdef _TARGET_OS_MAX 09738 # ifdef _ENABLE_FEI 09739 npex_min(); 09740 # endif 09741 # endif 09742 09743 symbolic_constant_expr = save_symbolic_constant_expr; 09744 09745 if (!symbolic_constant_expr) { 09746 finish_symbolic_expr(); 09747 } 09748 break; 09749 09750 09751 09752 case Parallel_Open_Mp_Opr: 09753 case Do_Open_Mp_Opr: 09754 case Sections_Open_Mp_Opr: 09755 case Single_Open_Mp_Opr: 09756 case Paralleldo_Open_Mp_Opr: 09757 case Parallelsections_Open_Mp_Opr: 09758 case Parallelworkshare_Open_Mp_Opr: 09759 case Endsingle_Open_Mp_Opr: 09760 case Flush_Open_Mp_Opr: 09761 list_idx1 = IR_IDX_L(ir_idx); 09762 09763 for (i = 0; i < OPEN_MP_LIST_CNT; i++) { 09764 list_array[i] = list_idx1; 09765 list_idx1 = IL_NEXT_LIST_IDX(list_idx1); 09766 } 09767 09768 09769 /* process IF clause */ 09770 if (IL_FLD(list_array[OPEN_MP_IF_IDX]) == AT_Tbl_Idx) { 09771 send_attr_ntry(IL_IDX(list_array[OPEN_MP_IF_IDX])); 09772 task_if_idx = PDG_AT_IDX(IL_IDX(list_array[OPEN_MP_IF_IDX])); 09773 } 09774 09775 09776 09777 09778 /* process PRIVATE clause */ 09779 if (IL_FLD(list_array[OPEN_MP_PRIVATE_IDX]) == IL_Tbl_Idx) { 09780 list_idx2 = IL_IDX(list_array[OPEN_MP_PRIVATE_IDX]); 09781 09782 while (list_idx2) { 09783 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09784 send_attr_ntry(IL_IDX(list_idx2)); 09785 09786 PDG_DBG_PRINT_START 09787 PDG_DBG_PRINT_C("fei_task_var"); 09788 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09789 PDG_AT_IDX(IL_IDX(list_idx2))); 09790 PDG_DBG_PRINT_S("(2) context", 09791 p_tasking_context[Context_Omp_Private]); 09792 PDG_DBG_PRINT_END 09793 09794 # ifdef _ENABLE_FEI 09795 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09796 Context_Omp_Private); 09797 # endif 09798 09799 } 09800 09801 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09802 } 09803 } 09804 09805 09806 09807 /* process SHARED clause */ 09808 if (IL_FLD(list_array[OPEN_MP_SHARED_IDX]) == IL_Tbl_Idx) { 09809 list_idx2 = IL_IDX(list_array[OPEN_MP_SHARED_IDX]); 09810 09811 while (list_idx2) { 09812 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09813 send_attr_ntry(IL_IDX(list_idx2)); 09814 09815 PDG_DBG_PRINT_START 09816 PDG_DBG_PRINT_C("fei_task_var"); 09817 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09818 PDG_AT_IDX(IL_IDX(list_idx2))); 09819 PDG_DBG_PRINT_S("(2) context", 09820 p_tasking_context[Context_Omp_Shared]); 09821 PDG_DBG_PRINT_END 09822 09823 # ifdef _ENABLE_FEI 09824 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09825 Context_Omp_Shared); 09826 # endif 09827 09828 } 09829 09830 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09831 } 09832 } 09833 09834 09835 09836 /* process FIRSTPRIVATE clause */ 09837 if (IL_FLD(list_array[OPEN_MP_FIRSTPRIVATE_IDX]) == IL_Tbl_Idx) { 09838 list_idx2 = IL_IDX(list_array[OPEN_MP_FIRSTPRIVATE_IDX]); 09839 09840 while (list_idx2) { 09841 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09842 send_attr_ntry(IL_IDX(list_idx2)); 09843 09844 PDG_DBG_PRINT_START 09845 PDG_DBG_PRINT_C("fei_task_var"); 09846 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09847 PDG_AT_IDX(IL_IDX(list_idx2))); 09848 PDG_DBG_PRINT_S("(2) context", 09849 p_tasking_context[Context_Omp_Firstprivate]); 09850 PDG_DBG_PRINT_END 09851 09852 # ifdef _ENABLE_FEI 09853 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09854 Context_Omp_Firstprivate); 09855 # endif 09856 09857 } 09858 09859 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09860 } 09861 } 09862 09863 09864 09865 /* process DEFAULT clause */ 09866 if (IL_FLD(list_array[OPEN_MP_DEFAULT_IDX]) == CN_Tbl_Idx) { 09867 defaultt =(long)CN_INT_TO_C(IL_IDX(list_array[OPEN_MP_DEFAULT_IDX])); 09868 } 09869 09870 09871 09872 09873 /* process COPYIN clause */ 09874 if (IL_FLD(list_array[OPEN_MP_COPYIN_IDX]) == IL_Tbl_Idx) { 09875 list_idx2 = IL_IDX(list_array[OPEN_MP_COPYIN_IDX]); 09876 09877 while (list_idx2) { 09878 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09879 send_attr_ntry(IL_IDX(list_idx2)); 09880 09881 PDG_DBG_PRINT_START 09882 PDG_DBG_PRINT_C("fei_task_var"); 09883 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09884 PDG_AT_IDX(IL_IDX(list_idx2))); 09885 PDG_DBG_PRINT_S("(2) context", 09886 p_tasking_context[Context_Omp_Copyin]); 09887 PDG_DBG_PRINT_END 09888 09889 # ifdef _ENABLE_FEI 09890 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 09891 Context_Omp_Copyin); 09892 # endif 09893 09894 } 09895 09896 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09897 } 09898 } 09899 09900 09901 09902 09903 09904 /* process REDUCTION clause */ 09905 if (IL_FLD(list_array[OPEN_MP_REDUCTION_OPR_IDX]) == IL_Tbl_Idx && 09906 IL_FLD(list_array[OPEN_MP_REDUCTION_LIST_IDX]) == IL_Tbl_Idx) { 09907 list_idx2 = IL_IDX(list_array[OPEN_MP_REDUCTION_OPR_IDX]); 09908 list_idx3 = IL_IDX(list_array[OPEN_MP_REDUCTION_LIST_IDX]); 09909 09910 while (list_idx2) { 09911 if (IL_FLD(list_idx2) == IR_Tbl_Idx && 09912 IL_FLD(list_idx3) == IL_Tbl_Idx) { 09913 list_idx4 = IL_IDX(list_idx3); 09914 while (list_idx4) { 09915 09916 switch (IR_OPR(IL_IDX(list_idx2))) { 09917 case Max_Opr : 09918 context = Context_Omp_Reduction_Max; 09919 break; 09920 case Min_Opr : 09921 context = Context_Omp_Reduction_Min; 09922 break; 09923 case Band_Opr : 09924 context = Context_Omp_Reduction_Band; 09925 break; 09926 case Bor_Opr : 09927 context = Context_Omp_Reduction_Bor; 09928 break; 09929 case Bneqv_Opr : 09930 context = Context_Omp_Reduction_Bneqv; 09931 break; 09932 case Plus_Opr : 09933 context = Context_Omp_Reduction_Plus; 09934 break; 09935 case Mult_Opr : 09936 context = Context_Omp_Reduction_Mult; 09937 break; 09938 case Minus_Opr : 09939 context = Context_Omp_Reduction_Minus; 09940 break; 09941 case And_Opr : 09942 context = Context_Omp_Reduction_And; 09943 break; 09944 case Or_Opr : 09945 context = Context_Omp_Reduction_Or; 09946 break; 09947 case Eqv_Opr : 09948 context = Context_Omp_Reduction_Eqv; 09949 break; 09950 case Neqv_Opr : 09951 context = Context_Omp_Reduction_Neqv; 09952 break; 09953 } 09954 09955 if (IL_FLD(list_idx4) == AT_Tbl_Idx) { 09956 send_attr_ntry(IL_IDX(list_idx4)); 09957 09958 PDG_DBG_PRINT_START 09959 PDG_DBG_PRINT_C("fei_task_var"); 09960 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09961 PDG_AT_IDX(IL_IDX(list_idx4))); 09962 PDG_DBG_PRINT_S("(2) context", 09963 p_tasking_context[context]); 09964 PDG_DBG_PRINT_END 09965 09966 # ifdef _ENABLE_FEI 09967 last_task_idx = fei_task_var( 09968 PDG_AT_IDX(IL_IDX(list_idx4)), 09969 context); 09970 # endif 09971 } 09972 list_idx4 = IL_NEXT_LIST_IDX(list_idx4); 09973 } 09974 } 09975 09976 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 09977 list_idx3 = IL_NEXT_LIST_IDX(list_idx3); 09978 } 09979 } 09980 09981 09982 09983 09984 09985 09986 /* process LASTPRIVATE clause */ 09987 if (IL_FLD(list_array[OPEN_MP_LASTPRIVATE_IDX]) == IL_Tbl_Idx) { 09988 list_idx2 = IL_IDX(list_array[OPEN_MP_LASTPRIVATE_IDX]); 09989 09990 while (list_idx2) { 09991 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 09992 send_attr_ntry(IL_IDX(list_idx2)); 09993 09994 PDG_DBG_PRINT_START 09995 PDG_DBG_PRINT_C("fei_task_var"); 09996 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 09997 PDG_AT_IDX(IL_IDX(list_idx2))); 09998 PDG_DBG_PRINT_S("(2) context", 09999 p_tasking_context[Context_Omp_Lastprivate]); 10000 PDG_DBG_PRINT_END 10001 10002 # ifdef _ENABLE_FEI 10003 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 10004 Context_Omp_Lastprivate); 10005 # endif 10006 10007 } 10008 10009 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 10010 } 10011 } 10012 10013 10014 10015 10016 /* process ORDERED clause */ 10017 if (IL_FLD(list_array[OPEN_MP_ORDERED_IDX]) == CN_Tbl_Idx) { 10018 ordered = (long)CN_INT_TO_C(IL_IDX(list_array[OPEN_MP_ORDERED_IDX])); 10019 } 10020 10021 10022 10023 /* process SCHEDULE (type) clause */ 10024 if (IL_FLD(list_array[OPEN_MP_SCHEDULE_TYPE_IDX]) == CN_Tbl_Idx) { 10025 scheduletype = (long) 10026 CN_INT_TO_C(IL_IDX(list_array[OPEN_MP_SCHEDULE_TYPE_IDX])); 10027 } 10028 10029 10030 10031 /* process SCHEDULE (chunk) clause */ 10032 if (IL_FLD(list_array[OPEN_MP_SCHEDULE_CHUNK_IDX]) == AT_Tbl_Idx) { 10033 send_attr_ntry(IL_IDX(list_array[OPEN_MP_SCHEDULE_CHUNK_IDX])); 10034 schedulechunk = 10035 PDG_AT_IDX(IL_IDX(list_array[OPEN_MP_SCHEDULE_CHUNK_IDX])); 10036 } 10037 10038 10039 10040 /* process NEST clause */ 10041 if (IL_FLD(list_array[OPEN_MP_NEST_IDX]) == IL_Tbl_Idx) { 10042 list_idx2 = IL_IDX(list_array[OPEN_MP_NEST_IDX]); 10043 10044 while (list_idx2) { 10045 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 10046 send_attr_ntry(IL_IDX(list_idx2)); 10047 10048 PDG_DBG_PRINT_START 10049 PDG_DBG_PRINT_C("fei_task_var"); 10050 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 10051 PDG_AT_IDX(IL_IDX(list_idx2))); 10052 PDG_DBG_PRINT_S("(2) context", 10053 p_tasking_context[Context_Omp_Nest]); 10054 PDG_DBG_PRINT_END 10055 10056 # ifdef _ENABLE_FEI 10057 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 10058 Context_Omp_Nest); 10059 # endif 10060 10061 } 10062 10063 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 10064 } 10065 } 10066 10067 10068 10069 /* process AFFINITY clause */ 10070 if (IL_FLD(list_array[OPEN_MP_AFFINITY_IDX]) == IL_Tbl_Idx) { 10071 list_idx2 = IL_IDX(list_array[OPEN_MP_AFFINITY_IDX]); 10072 10073 while (list_idx2 != NULL_IDX) { 10074 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 10075 send_attr_ntry(IL_IDX(list_idx2)); 10076 10077 PDG_DBG_PRINT_START 10078 PDG_DBG_PRINT_C("fei_task_var"); 10079 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 10080 PDG_AT_IDX(IL_IDX(list_idx2))); 10081 PDG_DBG_PRINT_S("(2) context", 10082 p_tasking_context[Context_Omp_Affinity]); 10083 PDG_DBG_PRINT_END 10084 10085 # ifdef _ENABLE_FEI 10086 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 10087 Context_Omp_Affinity); 10088 # endif 10089 10090 } 10091 10092 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 10093 } 10094 10095 cvrt_exp_to_pdg(IL_IDX(list_array[OPEN_MP_THREAD_DATA_IDX]), 10096 IL_FLD(list_array[OPEN_MP_THREAD_DATA_IDX])); 10097 10098 cvrt_exp_to_pdg(IL_IDX(list_array[OPEN_MP_THREAD_DATA_IDX]), 10099 IL_FLD(list_array[OPEN_MP_THREAD_DATA_IDX])); 10100 10101 which = (long)CN_INT_TO_C(IL_IDX(list_array[OPEN_MP_IS_THREAD_IDX])); 10102 if (which == 1) { 10103 threadcount = 1; 10104 } 10105 else { 10106 datacount = 1; 10107 } 10108 } 10109 10110 10111 10112 10113 /* process ONTO clause */ 10114 if (IL_FLD(list_array[OPEN_MP_ONTO_IDX]) == IL_Tbl_Idx) { 10115 list_idx2 = IL_IDX(list_array[OPEN_MP_ONTO_IDX]); 10116 10117 ontocount = 0; 10118 while (list_idx2 != NULL_IDX) { 10119 cvrt_exp_to_pdg(IL_IDX(list_idx2), 10120 IL_FLD(list_idx2)); 10121 10122 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 10123 ontocount = ontocount + 1; 10124 } 10125 } 10126 10127 10128 10129 /* process COPYPRIVATE clause */ 10130 if (IL_FLD(list_array[OPEN_MP_COPYPRIVATE_IDX]) == IL_Tbl_Idx) { 10131 list_idx2 = IL_IDX(list_array[OPEN_MP_COPYPRIVATE_IDX]); 10132 10133 while (list_idx2) { 10134 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 10135 send_attr_ntry(IL_IDX(list_idx2)); 10136 10137 PDG_DBG_PRINT_START 10138 PDG_DBG_PRINT_C("fei_task_var"); 10139 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 10140 PDG_AT_IDX(IL_IDX(list_idx2))); 10141 PDG_DBG_PRINT_S("(2) context", 10142 p_tasking_context[Context_Omp_Copyprivate]); 10143 PDG_DBG_PRINT_END 10144 10145 # ifdef _ENABLE_FEI 10146 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 10147 Context_Omp_Copyprivate); 10148 # endif 10149 10150 } 10151 10152 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 10153 } 10154 } 10155 10156 10157 10158 /* process FLUSH clause */ 10159 /* there is no FLUSH clause in OpenMP ([email protected]) */ 10160 /* we fake this clause in order to treat FLUSH directive the same as the others */ 10161 if (IL_FLD(list_array[OPEN_MP_FLUSH_IDX]) == IL_Tbl_Idx) { 10162 list_idx2 = IL_IDX(list_array[OPEN_MP_FLUSH_IDX]); 10163 10164 while (list_idx2) { 10165 if (IL_FLD(list_idx2) == AT_Tbl_Idx) { 10166 send_attr_ntry(IL_IDX(list_idx2)); 10167 10168 PDG_DBG_PRINT_START 10169 PDG_DBG_PRINT_C("fei_task_var"); 10170 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 10171 PDG_AT_IDX(IL_IDX(list_idx2))); 10172 PDG_DBG_PRINT_S("(2) context", 10173 p_tasking_context[Context_Omp_Flush]); 10174 PDG_DBG_PRINT_END 10175 10176 # ifdef _ENABLE_FEI 10177 last_task_idx = fei_task_var(PDG_AT_IDX(IL_IDX(list_idx2)), 10178 Context_Omp_Flush); 10179 # endif 10180 10181 } 10182 10183 list_idx2 = IL_NEXT_LIST_IDX(list_idx2); 10184 } 10185 } 10186 10187 10188 10189 10190 10191 switch (IR_OPR(ir_idx)) { 10192 10193 case Parallel_Open_Mp_Opr: 10194 PDG_DBG_PRINT_START 10195 PDG_DBG_PRINT_C("fei_parallel_open_mp"); 10196 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 10197 PDG_DBG_PRINT_LD("(2) defaultt", defaultt); 10198 PDG_DBG_PRINT_END 10199 10200 # ifdef _ENABLE_FEI 10201 fei_parallel_open_mp(task_if_idx, 10202 defaultt); 10203 10204 # endif 10205 break; 10206 10207 10208 10209 case Do_Open_Mp_Opr: 10210 PDG_DBG_PRINT_START 10211 PDG_DBG_PRINT_C("fei_do_open_mp"); 10212 PDG_DBG_PRINT_LD("(1) ordered", ordered); 10213 PDG_DBG_PRINT_LD("(2) scheduletype", scheduletype); 10214 PDG_DBG_PRINT_D("(3) schedulechunk", schedulechunk); 10215 PDG_DBG_PRINT_LD("(4) threadcount", threadcount); 10216 PDG_DBG_PRINT_LD("(5) datacount", datacount); 10217 PDG_DBG_PRINT_LD("(6) ontocount", ontocount); 10218 PDG_DBG_PRINT_END 10219 10220 # ifdef _ENABLE_FEI 10221 fei_do_open_mp(ordered, 10222 scheduletype, 10223 schedulechunk, 10224 threadcount, 10225 datacount, 10226 ontocount); 10227 # endif 10228 break; 10229 10230 10231 10232 case Sections_Open_Mp_Opr: 10233 PDG_DBG_PRINT_START 10234 PDG_DBG_PRINT_C("fei_sections_open_mp"); 10235 PDG_DBG_PRINT_END 10236 10237 10238 # ifdef _ENABLE_FEI 10239 fei_sections_open_mp(); 10240 # endif 10241 break; 10242 10243 10244 10245 case Single_Open_Mp_Opr: 10246 PDG_DBG_PRINT_START 10247 PDG_DBG_PRINT_C("fei_single_open_mp"); 10248 PDG_DBG_PRINT_END 10249 10250 10251 # ifdef _ENABLE_FEI 10252 fei_single_open_mp(); 10253 # endif 10254 break; 10255 10256 10257 10258 case Paralleldo_Open_Mp_Opr: 10259 PDG_DBG_PRINT_START 10260 PDG_DBG_PRINT_C("fei_paralleldo_open_mp"); 10261 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 10262 PDG_DBG_PRINT_LD("(2) defaultt", defaultt); 10263 PDG_DBG_PRINT_LD("(3) ordered", ordered); 10264 PDG_DBG_PRINT_LD("(4) scheduletype", scheduletype); 10265 PDG_DBG_PRINT_D("(5) schedulechunk", schedulechunk); 10266 PDG_DBG_PRINT_LD("(6) threadcount", threadcount); 10267 PDG_DBG_PRINT_LD("(7) datacount", datacount); 10268 PDG_DBG_PRINT_LD("(8) ontocount", ontocount); 10269 PDG_DBG_PRINT_END 10270 10271 10272 # ifdef _ENABLE_FEI 10273 fei_paralleldo_open_mp(task_if_idx, 10274 defaultt, 10275 ordered, 10276 scheduletype, 10277 schedulechunk, 10278 threadcount, 10279 datacount, 10280 ontocount); 10281 # endif 10282 break; 10283 10284 10285 10286 case Parallelsections_Open_Mp_Opr: 10287 PDG_DBG_PRINT_START 10288 PDG_DBG_PRINT_C("fei_parallelsections_open_mp"); 10289 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 10290 PDG_DBG_PRINT_LD("(2) defaultt", defaultt); 10291 PDG_DBG_PRINT_END 10292 10293 10294 # ifdef _ENABLE_FEI 10295 fei_parallelsections_open_mp(task_if_idx, 10296 defaultt); 10297 # endif 10298 break; 10299 10300 10301 10302 case Parallelworkshare_Open_Mp_Opr: 10303 PDG_DBG_PRINT_START 10304 PDG_DBG_PRINT_C("fei_parallelworkshare_open_mp"); 10305 PDG_DBG_PRINT_D("(1) if idx", task_if_idx); 10306 PDG_DBG_PRINT_LD("(2) defaultt", defaultt); 10307 PDG_DBG_PRINT_END 10308 10309 10310 # ifdef _ENABLE_FEI 10311 fei_parallelworkshare_open_mp(task_if_idx, 10312 defaultt); 10313 # endif 10314 break; 10315 10316 10317 10318 case Workshare_Open_Mp_Opr: 10319 PDG_DBG_PRINT_START 10320 PDG_DBG_PRINT_C("fei_workshare_open_mp"); 10321 PDG_DBG_PRINT_END 10322 10323 10324 # ifdef _ENABLE_FEI 10325 fei_workshare_open_mp(); 10326 # endif 10327 break; 10328 10329 10330 10331 case Endsingle_Open_Mp_Opr: 10332 PDG_DBG_PRINT_START 10333 PDG_DBG_PRINT_C("fei_endsingle_open_mp"); 10334 PDG_DBG_PRINT_LD("(1) nowait", nowait); 10335 PDG_DBG_PRINT_END 10336 10337 10338 # ifdef _ENABLE_FEI 10339 fei_endsingle_open_mp(nowait); 10340 # endif 10341 break; 10342 10343 10344 10345 case Flush_Open_Mp_Opr: 10346 PDG_DBG_PRINT_START 10347 PDG_DBG_PRINT_C("fei_flush_open_mp"); 10348 PDG_DBG_PRINT_D("(1) list_cnt", list_cnt); 10349 PDG_DBG_PRINT_END 10350 10351 10352 # ifdef _ENABLE_FEI 10353 fei_flush_open_mp(); 10354 # endif 10355 break; 10356 } 10357 break; 10358 10359 10360 10361 10362 case Barrier_Open_Mp_Opr: 10363 PDG_DBG_PRINT_START 10364 PDG_DBG_PRINT_C("fei_barrier_open_mp"); 10365 PDG_DBG_PRINT_END 10366 10367 10368 # ifdef _ENABLE_FEI 10369 fei_barrier_open_mp(); 10370 # endif 10371 break; 10372 10373 10374 10375 case Master_Open_Mp_Opr: 10376 PDG_DBG_PRINT_START 10377 PDG_DBG_PRINT_C("fei_master_open_mp"); 10378 PDG_DBG_PRINT_END 10379 10380 10381 # ifdef _ENABLE_FEI 10382 fei_master_open_mp(); 10383 # endif 10384 break; 10385 10386 10387 10388 case Workshare_Open_Mp_Opr: 10389 PDG_DBG_PRINT_START 10390 PDG_DBG_PRINT_C("fei_workshare_open_mp"); 10391 PDG_DBG_PRINT_END 10392 10393 10394 # ifdef _ENABLE_FEI 10395 fei_workshare_open_mp(); 10396 # endif 10397 break; 10398 10399 10400 10401 case Endmaster_Open_Mp_Opr: 10402 PDG_DBG_PRINT_START 10403 PDG_DBG_PRINT_C("fei_endmaster_open_mp"); 10404 PDG_DBG_PRINT_END 10405 10406 10407 # ifdef _ENABLE_FEI 10408 fei_endmaster_open_mp(); 10409 # endif 10410 break; 10411 10412 10413 10414 case Ordered_Open_Mp_Opr: 10415 PDG_DBG_PRINT_START 10416 PDG_DBG_PRINT_C("fei_ordered_open_mp"); 10417 PDG_DBG_PRINT_END 10418 10419 10420 # ifdef _ENABLE_FEI 10421 fei_ordered_open_mp(); 10422 # endif 10423 break; 10424 10425 10426 10427 case Endordered_Open_Mp_Opr: 10428 PDG_DBG_PRINT_START 10429 PDG_DBG_PRINT_C("fei_endordered_open_mp"); 10430 PDG_DBG_PRINT_END 10431 10432 10433 # ifdef _ENABLE_FEI 10434 fei_endordered_open_mp(); 10435 # endif 10436 break; 10437 10438 10439 10440 case Endparalleldo_Open_Mp_Opr: 10441 PDG_DBG_PRINT_START 10442 PDG_DBG_PRINT_C("fei_endparalleldo_open_mp"); 10443 PDG_DBG_PRINT_END 10444 10445 10446 # ifdef _ENABLE_FEI 10447 fei_endparalleldo_open_mp(); 10448 # endif 10449 break; 10450 10451 10452 10453 case Endparallel_Open_Mp_Opr: 10454 PDG_DBG_PRINT_START 10455 PDG_DBG_PRINT_C("fei_endparallel_open_mp"); 10456 PDG_DBG_PRINT_END 10457 10458 10459 # ifdef _ENABLE_FEI 10460 fei_endparallel_open_mp(); 10461 # endif 10462 break; 10463 10464 10465 10466 case Endparallelsections_Open_Mp_Opr: 10467 PDG_DBG_PRINT_START 10468 PDG_DBG_PRINT_C("fei_endparallelsections_open_mp"); 10469 PDG_DBG_PRINT_END 10470 10471 10472 # ifdef _ENABLE_FEI 10473 fei_endparallelsections_open_mp(); 10474 # endif 10475 break; 10476 10477 10478 10479 case Endparallelworkshare_Open_Mp_Opr: 10480 PDG_DBG_PRINT_START 10481 PDG_DBG_PRINT_C("fei_endparallelworkshare_open_mp"); 10482 PDG_DBG_PRINT_END 10483 10484 10485 # ifdef _ENABLE_FEI 10486 fei_endparallelworkshare_open_mp(); 10487 # endif 10488 break; 10489 10490 10491 10492 case Section_Open_Mp_Opr: 10493 PDG_DBG_PRINT_START 10494 PDG_DBG_PRINT_C("fei_section_open_mp"); 10495 PDG_DBG_PRINT_END 10496 10497 10498 # ifdef _ENABLE_FEI 10499 fei_section_open_mp(); 10500 # endif 10501 break; 10502 10503 10504 10505 case Enddo_Open_Mp_Opr: 10506 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 10507 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 10508 } 10509 10510 PDG_DBG_PRINT_START 10511 PDG_DBG_PRINT_C("fei_enddo_open_mp"); 10512 PDG_DBG_PRINT_LD("(1) nowait", nowait); 10513 PDG_DBG_PRINT_END 10514 10515 10516 # ifdef _ENABLE_FEI 10517 fei_enddo_open_mp(nowait); 10518 # endif 10519 break; 10520 10521 10522 10523 case Endsections_Open_Mp_Opr: 10524 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 10525 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 10526 } 10527 10528 PDG_DBG_PRINT_START 10529 PDG_DBG_PRINT_C("fei_endsections_open_mp"); 10530 PDG_DBG_PRINT_LD("(1) nowait", nowait); 10531 PDG_DBG_PRINT_END 10532 10533 10534 # ifdef _ENABLE_FEI 10535 fei_endsections_open_mp(nowait); 10536 # endif 10537 break; 10538 10539 10540 10541 10542 case Endworkshare_Open_Mp_Opr: 10543 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 10544 nowait = (long) CN_INT_TO_C(IR_IDX_L(ir_idx)); 10545 } 10546 10547 PDG_DBG_PRINT_START 10548 PDG_DBG_PRINT_C("fei_endworkshare_open_mp"); 10549 PDG_DBG_PRINT_LD("(1) nowait", nowait); 10550 PDG_DBG_PRINT_END 10551 10552 10553 # ifdef _ENABLE_FEI 10554 fei_endworkshare_open_mp(nowait); 10555 # endif 10556 break; 10557 10558 10559 10560 10561 case Critical_Open_Mp_Opr: 10562 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 10563 criticalname = (char *) &CN_CONST(IR_IDX_L(ir_idx)); 10564 } 10565 10566 PDG_DBG_PRINT_START 10567 PDG_DBG_PRINT_C("fei_critical_open_mp"); 10568 PDG_DBG_PRINT_S("(1) criticalname", criticalname); 10569 PDG_DBG_PRINT_END 10570 10571 10572 # ifdef _ENABLE_FEI 10573 fei_critical_open_mp(criticalname); 10574 # endif 10575 break; 10576 10577 10578 10579 case Atomic_Open_Mp_Opr: 10580 PDG_DBG_PRINT_START 10581 PDG_DBG_PRINT_C("fei_atomic_open_mp"); 10582 PDG_DBG_PRINT_END 10583 10584 10585 # ifdef _ENABLE_FEI 10586 fei_atomic_open_mp(); 10587 # endif 10588 break; 10589 10590 10591 10592 10593 case Endcritical_Open_Mp_Opr: 10594 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 10595 criticalname = (char *) &CN_CONST(IR_IDX_L(ir_idx)); 10596 } 10597 10598 PDG_DBG_PRINT_START 10599 PDG_DBG_PRINT_C("fei_endcritical_open_mp"); 10600 PDG_DBG_PRINT_S("(1) criticalname", criticalname); 10601 PDG_DBG_PRINT_END 10602 10603 10604 # ifdef _ENABLE_FEI 10605 fei_endcritical_open_mp(criticalname); 10606 # endif 10607 break; 10608 10609 10610 10611 /* eraxxon: OpenAD directive */ 10612 case XXX_OpenAD_Opr: { 10613 char* str; 10614 if (IR_FLD_L(ir_idx) == CN_Tbl_Idx) { 10615 str = (char *) &CN_CONST(IR_IDX_L(ir_idx)); 10616 } 10617 10618 PDG_DBG_PRINT_START 10619 PDG_DBG_PRINT_C("fei_xxx_openad"); 10620 PDG_DBG_PRINT_S("(1) string", str); 10621 PDG_DBG_PRINT_END 10622 10623 # ifdef _ENABLE_FEI 10624 fei_xxx_openad(str); 10625 # endif 10626 break; 10627 } 10628 10629 case Dependent_OpenAD_Opr: 10630 case Independent_OpenAD_Opr: { 10631 operator_type op = Dependent_OpenAD_Opr; 10632 CONTEXT_TYPE ctxt = Context_OpenAD_Dependent; 10633 if (IR_OPR(ir_idx) == Independent_OpenAD_Opr) { 10634 op = Independent_OpenAD_Opr; 10635 ctxt = Context_OpenAD_Independent; 10636 } 10637 10638 /* The list should be of length 1 */ 10639 list_idx1 = IR_IDX_L(ir_idx); 10640 list_idx2 = IL_IDX(list_idx1); 10641 10642 send_attr_ntry(list_idx2); 10643 10644 PDG_DBG_PRINT_START 10645 PDG_DBG_PRINT_C("fei_task_var"); 10646 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(list_idx2)); 10647 PDG_DBG_PRINT_S("(2) context", p_tasking_context[ctxt]); 10648 PDG_DBG_PRINT_END 10649 10650 # ifdef _ENABLE_FEI 10651 last_task_idx = fei_task_var(PDG_AT_IDX(list_idx2), ctxt); 10652 # endif 10653 10654 PDG_DBG_PRINT_START 10655 PDG_DBG_PRINT_C("fei_dependent_independent_openad"); 10656 PDG_DBG_PRINT_END 10657 10658 # ifdef _ENABLE_FEI 10659 fei_dependent_independent_openad(); 10660 # endif 10661 break; 10662 } 10663 10664 10665 case Simple_OpenAD_Opr: 10666 case EndSimple_OpenAD_Opr: 10667 /* FIXME */ 10668 break; 10669 10670 10671 case Nullify_Opr: 10672 cvrt_exp_to_pdg(IR_IDX_L(ir_idx), 10673 IR_FLD_L(ir_idx)); 10674 10675 ir_idx = IR_IDX_L(ir_idx); 10676 10677 while (ir_idx !=NULL_IDX) { 10678 ir_idx = IL_NEXT_LIST_IDX(ir_idx); 10679 ++listnum; 10680 } 10681 10682 10683 fei_nullify(listnum); 10684 break; 10685 10686 10687 } 10688 } 10689 10690 10691 TRACE (Func_Exit, "cvrt_exp_to_pdg", NULL); 10692 10693 return; 10694 10695 } /* cvrt_exp_to_pdg */ 10696 10697 10698 10699 /******************************************************************************\ 10700 |* *| 10701 |* Description: *| 10702 |* *| 10703 |* Input parameters: *| 10704 |* NONE *| 10705 |* *| 10706 |* Output parameters: *| 10707 |* NONE *| 10708 |* *| 10709 |* Returns: *| 10710 |* NOTHING *| 10711 |* *| 10712 \******************************************************************************/ 10713 static void finish_symbolic_expr() 10714 { 10715 int npex_expr_idx; 10716 10717 10718 TRACE (Func_Entry, "finish_symbolic_expr", NULL); 10719 10720 PDG_DBG_PRINT_START 10721 PDG_DBG_PRINT_C("npex_end"); 10722 PDG_DBG_PRINT_END 10723 10724 # ifdef _ENABLE_FEI 10725 npex_expr_idx = npex_end(); 10726 # endif 10727 10728 PDG_DBG_PRINT_START 10729 PDG_DBG_PRINT_D("(r) npex_expr_idx", npex_expr_idx); 10730 PDG_DBG_PRINT_END 10731 10732 PDG_DBG_PRINT_START 10733 PDG_DBG_PRINT_C("npex_to_expr"); 10734 PDG_DBG_PRINT_D("npex_expr_idx", npex_expr_idx); 10735 PDG_DBG_PRINT_END 10736 10737 # ifdef _ENABLE_FEI 10738 npex_to_expr(npex_expr_idx); 10739 # endif 10740 10741 TRACE (Func_Exit, "finish_symbolic_expr", NULL); 10742 10743 return; 10744 10745 } /* finish_symbolic_expr */ 10746 10747 10748 /******************************************************************************\ 10749 |* *| 10750 |* Description: *| 10751 |* *| 10752 |* Input parameters: *| 10753 |* NONE *| 10754 |* *| 10755 |* Output parameters: *| 10756 |* NONE *| 10757 |* *| 10758 |* Returns: *| 10759 |* NOTHING *| 10760 |* *| 10761 \******************************************************************************/ 10762 static void cvrt_ir_to_pdg(int scp_idx) 10763 { 10764 long flag; 10765 10766 10767 TRACE (Func_Entry, "cvrt_ir_to_pdg", NULL); 10768 10769 curr_sh = SCP_FIRST_SH_IDX(scp_idx); 10770 10771 PDG_DBG_PRINT_START 10772 PDG_DBG_PRINT_C("fei_proc_body"); 10773 PDG_DBG_PRINT_D("(1) SH_GLB_LINE", SH_GLB_LINE(curr_sh)); 10774 PDG_DBG_PRINT_END 10775 10776 # ifdef _ENABLE_FEI 10777 fei_proc_body(SH_GLB_LINE(curr_sh)); 10778 # endif 10779 10780 while (curr_sh != NULL_IDX) { 10781 10782 flag = ((long) (SH_STMT_TYPE(curr_sh) == Automatic_Base_Calc_Stmt) 10783 << FEI_STMT_ARY_BASE); 10784 10785 flag = flag | ((long) (SH_STMT_TYPE(curr_sh) == Automatic_Base_Size_Stmt) 10786 << FEI_STMT_ARY_SIZE); 10787 10788 flag = flag | ((long) SH_COMPILER_GEN(curr_sh) << FEI_STMT_INTERNAL); 10789 10790 PDG_DBG_PRINT_START 10791 PDG_DBG_PRINT_C("fei_stmt"); 10792 PDG_DBG_PRINT_D("(1) SH_GLB_LINE", SH_GLB_LINE(curr_sh)); 10793 PDG_DBG_PRINT_LO("(2) flags", flag); 10794 PDG_DBG_PRINT_END 10795 10796 # ifdef _ENABLE_FEI 10797 fei_stmt(SH_GLB_LINE(curr_sh), flag); 10798 # endif 10799 10800 if (SH_IR_IDX(curr_sh) != NULL_IDX) { 10801 stmt_start_line = SH_GLB_LINE(curr_sh); 10802 cvrt_exp_to_pdg(SH_IR_IDX(curr_sh), IR_Tbl_Idx); 10803 } 10804 10805 curr_sh = SH_NEXT_IDX(curr_sh); 10806 } 10807 10808 TRACE (Func_Exit, "cvrt_ir_to_pdg", NULL); 10809 10810 return; 10811 10812 } /* cvrt_ir_to_pdg */ 10813 10814 10815 10816 /******************************************************************************\ 10817 |* *| 10818 |* Description: *| 10819 |* *| 10820 |* Input parameters: *| 10821 |* NONE *| 10822 |* *| 10823 |* Output parameters: *| 10824 |* NONE *| 10825 |* *| 10826 |* Returns: *| 10827 |* NOTHING *| 10828 |* *| 10829 \******************************************************************************/ 10830 10831 static TYPE get_basic_type(int type_idx, 10832 int alignment, 10833 int input_attr_idx) 10834 10835 { 10836 int align; 10837 long64 bit_size; 10838 INTPTR cdx; 10839 int flags = 0; 10840 TYPE idx; 10841 10842 # if !defined(_ALTERNATIVE_INTERFACE_FOR_POINTEES) 10843 int attr_idx; 10844 int p_idx; 10845 int save_pdg_at_idx; 10846 # endif 10847 int dt_attr_idx; 10848 10849 10850 TRACE (Func_Entry, "get_basic_type", NULL); 10851 10852 /* The concept of alignment is only implmented for IRIX platforms */ 10853 /* Compare the alignment being passed in with the default alignment */ 10854 /* for the type. If the alignment coming in is less than the default */ 10855 /* alignment, call fei_descriptor with the smaller alignment. */ 10856 10857 idx = null_type; 10858 10859 if (input_attr_idx != NULL_IDX && ATD_VOLATILE(input_attr_idx)) { 10860 flags = flags | (1 << FEI_DESCRIPTOR_VOLAT_C); 10861 } 10862 10863 switch (TYP_TYPE(type_idx)) { 10864 10865 case Typeless: 10866 align = pdg_align[type_alignment_tbl[Long_Typeless]]; 10867 10868 PDG_DBG_PRINT_START 10869 PDG_DBG_PRINT_C("fei_descriptor"); 10870 PDG_DBG_PRINT_O("(1) flags", flags); 10871 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 10872 PDG_DBG_PRINT_LLD("(3) bit len", TYP_BIT_LEN(type_idx)); 10873 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[T_ypeless]); 10874 PDG_DBG_PRINT_D("(5) aux info", 0); 10875 PDG_DBG_PRINT_D("(6) alignment", align); 10876 PDG_DBG_PRINT_END 10877 # ifdef _ENABLE_FEI 10878 idx = fei_descriptor(flags, 10879 Basic, 10880 TYP_BIT_LEN(type_idx), /* JEFFL bit_len is 64 now */ 10881 T_ypeless, 10882 0, 10883 align); 10884 # endif 10885 PDG_DBG_PRINT_START 10886 PDG_DBG_PRINT_T("(r) type", idx); 10887 PDG_DBG_PRINT_END 10888 break; 10889 10890 10891 10892 case CRI_Parcel_Ptr: 10893 if (global_attr_idx == NULL_IDX) { 10894 PRINTMSG(1, 993, Internal, 1); 10895 } 10896 10897 # ifdef _ALTERNATIVE_INTERFACE_FOR_POINTEES 10898 PDG_DBG_PRINT_START 10899 PDG_DBG_PRINT_C("fei_descriptor"); 10900 PDG_DBG_PRINT_O("(1) flags", flags); 10901 PDG_DBG_PRINT_S("(2) table type", p_table_type[Func_tion]); 10902 PDG_DBG_PRINT_LD("(3) PDG_AT_IDX", PDG_AT_IDX(global_attr_idx)); 10903 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[BT_func_ptr]); 10904 PDG_DBG_PRINT_D("(5) aux info", 0); 10905 PDG_DBG_PRINT_D("(6) alignment", 0); 10906 PDG_DBG_PRINT_END 10907 # ifdef _ENABLE_FEI 10908 idx = fei_descriptor(flags, 10909 Func_tion, 10910 PDG_AT_IDX(global_attr_idx), 10911 BT_func_ptr, 10912 0, 10913 0); 10914 # endif 10915 PDG_DBG_PRINT_START 10916 PDG_DBG_PRINT_T("(r) type", idx); 10917 PDG_DBG_PRINT_END 10918 10919 # else 10920 10921 attr_idx = global_attr_idx; 10922 save_pdg_at_idx = PDG_AT_IDX(attr_idx); 10923 PDG_AT_IDX(attr_idx) = NULL_IDX; 10924 10925 send_procedure(attr_idx, 10926 NULL_IDX, /* No alt entries or parent procs */ 10927 Definition); 10928 10929 PDG_DBG_PRINT_START 10930 PDG_DBG_PRINT_C("fei_pointee"); 10931 PDG_DBG_PRINT_T("(1) type", pdg_type_void); 10932 PDG_DBG_PRINT_END 10933 # ifdef _ENABLE_FEI 10934 p_idx = fei_pointee(pdg_type_void); 10935 # endif 10936 PDG_DBG_PRINT_START 10937 PDG_DBG_PRINT_D("(r) p_idx", p_idx); 10938 PDG_DBG_PRINT_END 10939 10940 10941 10942 PDG_DBG_PRINT_START 10943 PDG_DBG_PRINT_C("fei_descriptor"); 10944 PDG_DBG_PRINT_O("(1) flags", flags); 10945 PDG_DBG_PRINT_S("(2) table type", p_table_type[Func_tion]); 10946 PDG_DBG_PRINT_D("(3) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 10947 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[V_oid]); 10948 PDG_DBG_PRINT_D("(5) aux info", p_idx); 10949 PDG_DBG_PRINT_D("(6) alignment", 0); 10950 PDG_DBG_PRINT_END 10951 # ifdef _ENABLE_FEI 10952 idx = fei_descriptor(flags, 10953 Func_tion, 10954 PDG_AT_IDX(attr_idx), 10955 V_oid, 10956 p_idx, 10957 0); 10958 # endif 10959 PDG_DBG_PRINT_START 10960 PDG_DBG_PRINT_T("(r) type", idx); 10961 PDG_DBG_PRINT_END 10962 10963 10964 10965 10966 PDG_DBG_PRINT_START 10967 PDG_DBG_PRINT_C("fei_pointee"); 10968 PDG_DBG_PRINT_T("(1) idx", idx); 10969 PDG_DBG_PRINT_END 10970 # ifdef _ENABLE_FEI 10971 p_idx = fei_pointee(idx); 10972 # endif 10973 PDG_DBG_PRINT_START 10974 PDG_DBG_PRINT_D("(r) p_idx", p_idx); 10975 PDG_DBG_PRINT_END 10976 10977 10978 10979 10980 PDG_DBG_PRINT_START 10981 PDG_DBG_PRINT_C("fei_descriptor"); 10982 PDG_DBG_PRINT_O("(1) flags", flags); 10983 PDG_DBG_PRINT_S("(2) table type", p_table_type[Pointer]); 10984 PDG_DBG_PRINT_D("(3) p_idx", p_idx); 10985 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[V_oid]); 10986 PDG_DBG_PRINT_D("(5) aux info", 0); 10987 PDG_DBG_PRINT_D("(6) alignment", 0); 10988 PDG_DBG_PRINT_END 10989 # ifdef _ENABLE_FEI 10990 idx = fei_descriptor(flags, 10991 Pointer, 10992 p_idx, 10993 V_oid, 10994 0, 10995 0); 10996 # endif 10997 PDG_DBG_PRINT_START 10998 PDG_DBG_PRINT_T("(r) type", idx); 10999 PDG_DBG_PRINT_END 11000 11001 PDG_AT_IDX(attr_idx) = save_pdg_at_idx; 11002 # endif 11003 break; 11004 11005 11006 11007 case Integer: 11008 case Logical: 11009 case Real: 11010 case Complex: 11011 case CRI_Ch_Ptr: 11012 idx = send_non_standard_aligned_type(alignment, type_idx); 11013 break; 11014 11015 11016 case Character: 11017 switch (TYP_CHAR_CLASS(type_idx)) { 11018 case Assumed_Size_Char: 11019 case Var_Len_Char: 11020 if (global_attr_idx != NULL_IDX) { 11021 if (ATD_CLASS(global_attr_idx) == CRI__Pointee && 11022 ATD_PTR_IDX(global_attr_idx) != NULL_IDX) { 11023 global_attr_idx = ATD_PTR_IDX(global_attr_idx); 11024 } 11025 11026 if (ATD_STOR_BLK_IDX(global_attr_idx) != NULL_IDX && 11027 SB_SCP_IDX(ATD_STOR_BLK_IDX(global_attr_idx)) != curr_scp_idx) { 11028 flags = flags | (1 << FEI_DESCRIPTOR_HOSTED_TYPE); 11029 } 11030 } 11031 11032 send_attr_ntry(TYP_IDX(type_idx)); 11033 flags = flags | (1 << FEI_DESCRIPTOR_AUTO_F); 11034 11035 PDG_DBG_PRINT_START 11036 PDG_DBG_PRINT_C("fei_descriptor"); 11037 PDG_DBG_PRINT_O("(1) flags", flags); 11038 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 11039 PDG_DBG_PRINT_LD("(3) PDG_AT_IDX", PDG_AT_IDX(TYP_IDX(type_idx))); 11040 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[Char_Fortran]); 11041 PDG_DBG_PRINT_D("(5) aux info", CHAR_BIT); 11042 PDG_DBG_PRINT_D("(6) alignment", Align_Bit); 11043 PDG_DBG_PRINT_END 11044 # ifdef _ENABLE_FEI 11045 idx = fei_descriptor(flags, 11046 Basic, 11047 PDG_AT_IDX(TYP_IDX(type_idx)), 11048 Char_Fortran, 11049 CHAR_BIT, 11050 Align_Bit); 11051 # endif 11052 PDG_DBG_PRINT_START 11053 PDG_DBG_PRINT_T("(r) type", idx); 11054 PDG_DBG_PRINT_END 11055 break; 11056 11057 11058 case Const_Len_Char: 11059 if (global_attr_idx != NULL_IDX) { 11060 if (ATD_CLASS(global_attr_idx) == CRI__Pointee && 11061 ATD_PTR_IDX(global_attr_idx) != NULL_IDX) { 11062 global_attr_idx = ATD_PTR_IDX(global_attr_idx); 11063 } 11064 11065 if (ATD_STOR_BLK_IDX(global_attr_idx) != NULL_IDX && 11066 SB_SCP_IDX(ATD_STOR_BLK_IDX(global_attr_idx)) != curr_scp_idx) { 11067 flags = flags | (1 << FEI_DESCRIPTOR_HOSTED_TYPE); 11068 } 11069 } 11070 bit_size = CN_INT_TO_C(TYP_IDX(type_idx)); 11071 bit_size = bit_size * CHAR_BIT; 11072 11073 idx = get_basic_type(Integer_8,type_alignment_tbl[Integer_8],NULL_IDX); 11074 11075 PDG_DBG_PRINT_START 11076 PDG_DBG_PRINT_C("fei_arith_con"); 11077 PDG_DBG_PRINT_T("(1) type", idx); 11078 PDG_DBG_PRINT_LLD("(2) bit_size", bit_size); 11079 PDG_DBG_PRINT_END 11080 # ifdef _ENABLE_FEI 11081 cdx = fei_arith_con(idx, (long *)&bit_size); 11082 # endif 11083 PDG_DBG_PRINT_START 11084 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", cdx); 11085 PDG_DBG_PRINT_END 11086 11087 11088 PDG_DBG_PRINT_START 11089 PDG_DBG_PRINT_C("fei_descriptor"); 11090 PDG_DBG_PRINT_O("(1) flags", flags); 11091 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 11092 PDG_DBG_PRINT_LD("(3) PDG_CN_IDX", cdx); 11093 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[Char_Fortran]); 11094 PDG_DBG_PRINT_D("(5) aux info", CHAR_BIT); 11095 PDG_DBG_PRINT_D("(6) alignment", Align_Bit); 11096 PDG_DBG_PRINT_END 11097 # ifdef _ENABLE_FEI 11098 idx = fei_descriptor(flags, 11099 Basic, 11100 cdx, 11101 Char_Fortran, 11102 CHAR_BIT, 11103 Align_Bit); 11104 # endif 11105 PDG_DBG_PRINT_START 11106 PDG_DBG_PRINT_T("(r) type", idx); 11107 PDG_DBG_PRINT_END 11108 break; 11109 } 11110 break; 11111 11112 11113 case Structure: 11114 dt_attr_idx = TYP_IDX(type_idx); 11115 if (curr_scp_idx==ATT_SCP_IDX(dt_attr_idx)) 11116 idx = send_derived_type(type_idx,FALSE); 11117 else 11118 idx = send_derived_type(type_idx,TRUE); 11119 break; 11120 11121 11122 case CRI_Ptr: 11123 # ifdef _TARGET32 11124 if (TYP_PTR_INCREMENT(type_idx) > TARGET_BITS_PER_WORD) { 11125 PDG_DBG_PRINT_START 11126 PDG_DBG_PRINT_C("fei_descriptor"); 11127 PDG_DBG_PRINT_O("(1) flags", flags); 11128 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 11129 PDG_DBG_PRINT_D("(3) bit_size", storage_bit_size_tbl[CRI_Ptr_8]); 11130 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[CRI_Pointer]); 11131 PDG_DBG_PRINT_D("(5) aux info", DWord_Align); 11132 PDG_DBG_PRINT_D("(6) alignment", 0); 11133 PDG_DBG_PRINT_END 11134 # ifdef _ENABLE_FEI 11135 idx = fei_descriptor(flags, 11136 Basic, 11137 storage_bit_size_tbl[CRI_Ptr_8], 11138 CRI_Pointer, 11139 DWord_Align, 11140 0); 11141 # endif 11142 PDG_DBG_PRINT_START 11143 PDG_DBG_PRINT_T("(r) type", idx); 11144 PDG_DBG_PRINT_END 11145 } 11146 else 11147 # endif 11148 11149 if (TYP_PTR_INCREMENT(type_idx) >= TARGET_BITS_PER_WORD) { 11150 PDG_DBG_PRINT_START 11151 PDG_DBG_PRINT_C("fei_descriptor"); 11152 PDG_DBG_PRINT_O("(1) flags", flags); 11153 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 11154 PDG_DBG_PRINT_D("(3) unused", 0); 11155 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[CRI_Pointer]); 11156 PDG_DBG_PRINT_D("(5) aux info", Word_Align); 11157 PDG_DBG_PRINT_D("(6) alignment", 0); 11158 PDG_DBG_PRINT_END 11159 # ifdef _ENABLE_FEI 11160 idx = fei_descriptor(flags, 11161 Basic, 11162 0, 11163 CRI_Pointer, 11164 Word_Align, 11165 0); 11166 # endif 11167 PDG_DBG_PRINT_START 11168 PDG_DBG_PRINT_T("(r) type", idx); 11169 PDG_DBG_PRINT_END 11170 } 11171 else { 11172 PDG_DBG_PRINT_START 11173 PDG_DBG_PRINT_C("fei_descriptor"); 11174 PDG_DBG_PRINT_O("(1) flags", flags); 11175 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 11176 PDG_DBG_PRINT_D("(3) unused", 0); 11177 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[CRI_Pointer]); 11178 PDG_DBG_PRINT_D("(5) aux info", HWord_Align); 11179 PDG_DBG_PRINT_D("(6) alignment", 0); 11180 PDG_DBG_PRINT_END 11181 # ifdef _ENABLE_FEI 11182 idx = fei_descriptor(flags, 11183 Basic, 11184 0, 11185 CRI_Pointer, 11186 HWord_Align, 11187 0); 11188 # endif 11189 PDG_DBG_PRINT_START 11190 PDG_DBG_PRINT_T("(r) type", idx); 11191 PDG_DBG_PRINT_END 11192 } 11193 break; 11194 11195 } 11196 11197 TRACE (Func_Exit, "get_basic_type", NULL); 11198 11199 return(idx); 11200 11201 } /* get_basic_type */ 11202 11203 11204 #if 0 11205 inline void 11206 Set_TY_is_f90_pointer (TY& ty) { ty.flags |= TY_IS_F90_POINTER; } 11207 #endif 11208 11209 11210 11211 /******************************************************************************\ 11212 |* *| 11213 |* Description: *| 11214 |* *| 11215 |* Input parameters: *| 11216 |* NONE *| 11217 |* *| 11218 |* Output parameters: *| 11219 |* NONE *| 11220 |* *| 11221 |* Returns: *| 11222 |* NOTHING *| 11223 |* *| 11224 \******************************************************************************/ 11225 11226 static TYPE get_type_desc(int input_idx) 11227 { 11228 int bd_idx = 0; 11229 int dist_idx; 11230 int distribution = 0; 11231 int kind_type = 0; 11232 int attr_idx; 11233 int temp_attr_idx; 11234 int basic_type; 11235 long64 extent; 11236 int i = 1; 11237 long64 lbound; 11238 long64 ubound; 11239 int flag = 0; 11240 boolean lb_vble = FALSE; 11241 boolean lb_symcon = FALSE; 11242 boolean ub_vble = FALSE; 11243 boolean ub_symcon = FALSE; 11244 boolean xt_vble = FALSE; 11245 boolean xt_symcon = FALSE; 11246 boolean lb_empty = FALSE; 11247 boolean ub_empty = FALSE; 11248 boolean xt_empty = FALSE; 11249 /* boolean ub_star = FALSE; */ 11250 long pdg_array_idx; 11251 int rank; 11252 size_offset_type size; 11253 long64 span; 11254 boolean template_tmp = FALSE; 11255 int tmp_idx; 11256 int type_flag = 0; 11257 TYPE type_idx; 11258 11259 int pe_bd_idx = 0; 11260 11261 11262 TRACE (Func_Entry, "get_type_desc", NULL); 11263 11264 type_idx = null_type; 11265 11266 switch (AT_OBJ_CLASS(input_idx)) { 11267 case Data_Obj: 11268 attr_idx = input_idx; 11269 global_attr_idx = attr_idx; 11270 type_idx = get_basic_type(ATD_TYPE_IDX(attr_idx), 11271 ATD_ALIGNMENT(attr_idx), 11272 attr_idx); 11273 11274 global_attr_idx = NULL_IDX; 11275 break; 11276 11277 case Pgm_Unit: 11278 if (ATP_PGM_UNIT(input_idx) == Function) { 11279 attr_idx = ATP_RSLT_IDX(input_idx); 11280 11281 /* If this is an array or character, the tmps are just templates. */ 11282 /* They are never defined or referenced in the IR. We need to send */ 11283 /* over the referenced tmps to PDGCS. Put them in the current */ 11284 /* stack block so that they do not end up causing host association. */ 11285 /* Or in the case of functions defined in interface blocks, they */ 11286 /* do not have valid storage. Have to restore storage, in case */ 11287 /* this is an internal or module procedure. The storage must be */ 11288 /* correct when that routine is sent across. */ 11289 11290 if (ATP_EXPL_ITRFC(input_idx) && !ATP_SCP_ALIVE(input_idx)) { 11291 template_tmp = TRUE; 11292 11293 if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character && 11294 TYP_CHAR_CLASS(ATD_TYPE_IDX(attr_idx)) != Const_Len_Char && 11295 PDG_AT_IDX(TYP_IDX(ATD_TYPE_IDX(attr_idx))) == NULL_IDX) { 11296 tmp_idx = TYP_IDX(ATD_TYPE_IDX(attr_idx)); 11297 COPY_ATTR_NTRY(AT_WORK_IDX, tmp_idx); 11298 AT_REFERENCED(tmp_idx) = Referenced; 11299 ATD_OFFSET_ASSIGNED(tmp_idx) = FALSE; 11300 ATD_STOR_BLK_IDX(tmp_idx) = SCP_SB_STACK_IDX(curr_scp_idx); 11301 send_attr_ntry(tmp_idx); 11302 COPY_ATTR_NTRY(tmp_idx, AT_WORK_IDX); 11303 } 11304 } 11305 11306 type_idx = get_basic_type(ATD_TYPE_IDX(attr_idx), 11307 ATD_ALIGNMENT(attr_idx), 11308 attr_idx); 11309 } 11310 else { 11311 type_idx = pdg_type_void; 11312 goto EXIT; 11313 } 11314 break; 11315 } /* switch */ 11316 11317 fei_init_global_vars(); 11318 if (ATD_IM_A_DOPE(attr_idx)) { 11319 rank = (ATD_ARRAY_IDX(attr_idx) == NULL_IDX) ? 0 : 11320 BD_RANK(ATD_ARRAY_IDX(attr_idx)); 11321 11322 if (ATD_STOR_BLK_IDX(attr_idx) != NULL_IDX && 11323 SB_SCP_IDX(ATD_STOR_BLK_IDX(attr_idx)) != curr_scp_idx) { 11324 type_flag = type_flag | (1 << FEI_DOPE_VECTOR_HOSTED_TYPE); 11325 } 11326 11327 type_flag = type_flag | 11328 (ATD_POINTER(attr_idx) << FEI_DOPE_VECTOR_POINTER); 11329 11330 PDG_DBG_PRINT_START 11331 PDG_DBG_PRINT_C("fei_dope_vector"); 11332 PDG_DBG_PRINT_D("(1) rank", rank); 11333 PDG_DBG_PRINT_T("(2) type", type_idx); 11334 PDG_DBG_PRINT_O("(3) flags", type_flag); 11335 PDG_DBG_PRINT_END 11336 11337 # ifdef _ENABLE_FEI 11338 # endif 11339 } 11340 else if (ATD_ARRAY_IDX(attr_idx) != NULL_IDX) { 11341 bd_idx = ATD_ARRAY_IDX(attr_idx); 11342 dist_idx = ATD_DISTRIBUTION_IDX(attr_idx); 11343 basic_type = pdg_basic_type[TYP_TYPE(ATD_TYPE_IDX(attr_idx))]; 11344 11345 switch (TYP_LINEAR(ATD_TYPE_IDX(attr_idx))) { 11346 case Integer_1: 11347 case Logical_1: 11348 kind_type = 1; 11349 break; 11350 11351 case Integer_2: 11352 case Logical_2: 11353 kind_type = 2; 11354 break; 11355 11356 case Integer_4: 11357 case Logical_4: 11358 case Complex_4: 11359 case Real_4: 11360 kind_type = 4; 11361 break; 11362 11363 case Integer_8: 11364 case Logical_8: 11365 case Complex_8: 11366 case Real_8: 11367 kind_type = 8; 11368 break; 11369 11370 case Complex_16: 11371 case Real_16: 11372 kind_type = 16; 11373 break; 11374 } 11375 11376 temp_attr_idx = attr_idx; 11377 11378 if (ATD_CLASS(attr_idx) == CRI__Pointee && 11379 ATD_PTR_IDX(attr_idx) != NULL_IDX) { 11380 temp_attr_idx = ATD_PTR_IDX(attr_idx); 11381 } 11382 else if (ATD_AUTOMATIC(attr_idx) && 11383 ATD_AUTO_BASE_IDX(attr_idx) != NULL_IDX) { 11384 temp_attr_idx = ATD_AUTO_BASE_IDX(attr_idx); 11385 } 11386 11387 if (ATD_STOR_BLK_IDX(temp_attr_idx) != NULL_IDX && 11388 SB_SCP_IDX(ATD_STOR_BLK_IDX(temp_attr_idx)) != curr_scp_idx) { 11389 type_flag = type_flag | (1 << FEI_DESCRIPTOR_HOSTED_TYPE); 11390 } 11391 11392 size = stor_bit_size_of(attr_idx, FALSE, FALSE); 11393 11394 if (size.fld == CN_Tbl_Idx) { 11395 span = CN_INT_TO_C(size.idx); 11396 } 11397 else { 11398 span = F_INT_TO_C(size.constant, TYP_LINEAR(size.type_idx)); 11399 } 11400 11401 # ifdef _DEBUG 11402 if (! BD_RESOLVED(bd_idx)) { 11403 PRINTMSG(1, 626, Internal, 1, 11404 "resolved bounds entry", 11405 "get_type_desc"); 11406 } 11407 # endif 11408 11409 pe_bd_idx = ATD_PE_ARRAY_IDX(attr_idx); 11410 11411 for (i = 1; i <= BD_RANK(bd_idx); i++) { 11412 11413 if (BD_LB_FLD(bd_idx, i) == NO_Tbl_Idx) 11414 { 11415 lb_empty = TRUE; 11416 } 11417 11418 else { 11419 11420 if (BD_LB_FLD(bd_idx, i) == CN_Tbl_Idx) { 11421 lbound = CN_INT_TO_C(BD_LB_IDX(bd_idx, i)); 11422 lb_vble = FALSE; 11423 } 11424 else { 11425 lbound = BD_LB_IDX(bd_idx, i); 11426 lb_vble = TRUE; 11427 11428 # ifdef _TARGET_OS_MAX 11429 lb_symcon = ATD_SYMBOLIC_CONSTANT(lbound); 11430 lb_vble = !ATD_SYMBOLIC_CONSTANT(lbound); 11431 # endif 11432 11433 if (PDG_AT_IDX(lbound) == NULL_IDX) { 11434 11435 if (template_tmp) { 11436 COPY_ATTR_NTRY(AT_WORK_IDX, lbound); 11437 AT_REFERENCED(lbound) = Referenced; 11438 ATD_OFFSET_ASSIGNED(lbound) = FALSE; 11439 ATD_STOR_BLK_IDX(lbound) = SCP_SB_STACK_IDX(curr_scp_idx); 11440 send_attr_ntry(lbound); 11441 COPY_ATTR_NTRY(lbound, AT_WORK_IDX); 11442 } 11443 else { 11444 send_attr_ntry(lbound); 11445 } 11446 } 11447 lbound = PDG_AT_IDX(lbound); 11448 } 11449 } 11450 if (BD_UB_FLD(bd_idx, i) == NO_Tbl_Idx) { 11451 11452 ub_empty = TRUE; 11453 } 11454 else { 11455 if (BD_UB_FLD(bd_idx, i) == CN_Tbl_Idx) { 11456 ubound = CN_INT_TO_C(BD_UB_IDX(bd_idx, i)); 11457 ub_vble = FALSE; 11458 } 11459 else { 11460 ubound = BD_UB_IDX(bd_idx, i); 11461 ub_vble = TRUE; 11462 11463 # ifdef _TARGET_OS_MAX 11464 ub_symcon = ATD_SYMBOLIC_CONSTANT(ubound); 11465 ub_vble = !ATD_SYMBOLIC_CONSTANT(ubound); 11466 # endif 11467 11468 if (PDG_AT_IDX(ubound) == NULL_IDX) { 11469 11470 if (template_tmp) { 11471 COPY_ATTR_NTRY(AT_WORK_IDX, ubound); 11472 AT_REFERENCED(ubound) = Referenced; 11473 ATD_OFFSET_ASSIGNED(ubound) = FALSE; 11474 ATD_STOR_BLK_IDX(ubound) = SCP_SB_STACK_IDX(curr_scp_idx); 11475 send_attr_ntry(ubound); 11476 COPY_ATTR_NTRY(ubound, AT_WORK_IDX); 11477 } 11478 else { 11479 send_attr_ntry(ubound); 11480 } 11481 } 11482 ubound = PDG_AT_IDX(ubound); 11483 } 11484 } 11485 11486 if (BD_XT_FLD(bd_idx,i) == NO_Tbl_Idx) { 11487 xt_empty = TRUE; 11488 span = (long64) 0; 11489 } 11490 else { 11491 if (BD_XT_FLD(bd_idx, i) == CN_Tbl_Idx) { 11492 if (BD_XT_IDX(bd_idx,i)) 11493 extent = CN_INT_TO_C(BD_XT_IDX(bd_idx, i)); 11494 else 11495 extent = BD_XT_IDX(bd_idx,i); 11496 11497 xt_vble = FALSE; 11498 span = extent * span; 11499 } 11500 else { 11501 extent = BD_XT_IDX(bd_idx, i); 11502 xt_vble = TRUE; 11503 11504 # ifdef _TARGET_OS_MAX 11505 xt_symcon = ATD_SYMBOLIC_CONSTANT(extent); 11506 xt_vble = !ATD_SYMBOLIC_CONSTANT(extent); 11507 # endif 11508 11509 if (PDG_AT_IDX(extent) == NULL_IDX) { 11510 11511 if (template_tmp) { 11512 COPY_ATTR_NTRY(AT_WORK_IDX, extent); 11513 AT_REFERENCED(extent) = Referenced; 11514 ATD_OFFSET_ASSIGNED(extent) = FALSE; 11515 ATD_STOR_BLK_IDX(extent) = SCP_SB_STACK_IDX(curr_scp_idx); 11516 send_attr_ntry(extent); 11517 COPY_ATTR_NTRY(extent, AT_WORK_IDX); 11518 } 11519 else { 11520 send_attr_ntry(extent); 11521 } 11522 } 11523 extent = PDG_AT_IDX(extent); 11524 span = (long64) 0; 11525 } 11526 } 11527 11528 flag = (lb_symcon << FEI_ARRAY_DIMEN_SCON_LB)| 11529 (lb_vble << FEI_ARRAY_DIMEN_VARY_LB)| 11530 (ub_symcon << FEI_ARRAY_DIMEN_SCON_UB)| 11531 (ub_vble << FEI_ARRAY_DIMEN_VARY_UB)| 11532 (xt_symcon << FEI_ARRAY_DIMEN_SCON_EXT)| 11533 (xt_vble << FEI_ARRAY_DIMEN_VARY_EXT)| 11534 (lb_empty << FEI_ARRAY_DIMEN_EMPTY_LB)| 11535 (xt_empty << FEI_ARRAY_DIMEN_EMPTY_EXT)| 11536 (ub_empty << FEI_ARRAY_DIMEN_EMPTY_UB); 11537 11538 flag |= (BD_FLOW_DEPENDENT(bd_idx) << FEI_ARRAY_DIMEN_FLOW_DEPENDENT); 11539 11540 11541 temp_attr_idx = attr_idx; 11542 if (ATD_CLASS(attr_idx) == CRI__Pointee && 11543 ATD_PTR_IDX(attr_idx) != NULL_IDX) { 11544 temp_attr_idx = ATD_PTR_IDX(attr_idx); 11545 } 11546 11547 if (ATD_STOR_BLK_IDX(temp_attr_idx) != NULL_IDX && 11548 SB_SCP_IDX(ATD_STOR_BLK_IDX(temp_attr_idx)) != curr_scp_idx) { 11549 flag = flag | (1 << FEI_ARRAY_DIMEN_HOSTED_TYPE); 11550 } 11551 11552 if (dist_idx != NULL_IDX) { 11553 if (BD_CYCLIC_IDX(dist_idx, i) != NULL_IDX) { 11554 cvrt_exp_to_pdg(BD_CYCLIC_IDX(dist_idx, i), 11555 BD_CYCLIC_FLD(dist_idx, i)); 11556 flag = flag | (1 << FEI_ARRAY_DIMEN_DIST_EXPR); 11557 } 11558 11559 if (BD_ONTO_IDX(dist_idx, i) != NULL_IDX) { 11560 cvrt_exp_to_pdg(BD_ONTO_IDX(dist_idx, i), 11561 BD_ONTO_FLD(dist_idx, i)); 11562 flag = flag | (1 << FEI_ARRAY_DIMEN_ONTO_EXPR); 11563 } 11564 11565 distribution = BD_DISTRIBUTION(dist_idx, i); 11566 11567 flag = flag | (BD_DISTRIBUTE_RESHAPE(dist_idx) << 11568 FEI_ARRAY_DIMEN_DIST_RESHAPE); 11569 } 11570 11571 PDG_DBG_PRINT_START 11572 PDG_DBG_PRINT_C("fei_array_dimen"); 11573 PDG_DBG_PRINT_O("(1) flags", flag); 11574 PDG_DBG_PRINT_LLD("(2) lbound", lbound); 11575 PDG_DBG_PRINT_LLD("(3) extent", extent); 11576 PDG_DBG_PRINT_D("(4) rank", i); 11577 PDG_DBG_PRINT_T("(5) type", type_idx); 11578 PDG_DBG_PRINT_LLD("(6) span", span); 11579 PDG_DBG_PRINT_S("(7) distribution", p_distribution[distribution]); 11580 PDG_DBG_PRINT_LLD("(8) ubound", ubound); 11581 PDG_DBG_PRINT_END 11582 11583 # ifdef _ENABLE_FEI 11584 pdg_array_idx = fei_array_dimen(flag, 11585 lbound, 11586 extent, 11587 i, 11588 type_idx, 11589 span, 11590 distribution, 11591 ubound); 11592 # endif 11593 11594 # if defined(GENERATE_WHIRL) 11595 if (i == BD_RANK(bd_idx) && pe_bd_idx == 0) { 11596 # endif 11597 PDG_DBG_PRINT_START 11598 PDG_DBG_PRINT_C("fei_descriptor"); 11599 PDG_DBG_PRINT_O("(1) flags", type_flag); 11600 PDG_DBG_PRINT_S("(2) table type", p_table_type[Array]); 11601 PDG_DBG_PRINT_LD("(3) pdg_array_idx", pdg_array_idx); 11602 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[basic_type]); 11603 PDG_DBG_PRINT_D("(5) aux info", kind_type); 11604 PDG_DBG_PRINT_D("(6) alignment",pdg_align[ATD_ALIGNMENT(attr_idx)]); 11605 PDG_DBG_PRINT_END 11606 # ifdef _ENABLE_FEI 11607 11608 /* 11609 * add flags for different type of array---fzhao 11610 */ 11611 if (ATD_ARRAY_IDX(attr_idx) != NULL_IDX) { 11612 11613 switch (BD_ARRAY_CLASS(ATD_ARRAY_IDX(attr_idx))) { 11614 case Assumed_Size: 11615 type_flag = type_flag | ( 1 << FEI_ASSUMED_SIZE_ARRAY); 11616 break; 11617 11618 case Assumed_Shape: 11619 type_flag = type_flag | ( 1 << FEI_ASSUMD_SHAPE_ARRAY); 11620 break; 11621 11622 case Deferred_Shape1: 11623 type_flag = type_flag | (1 << FEI_DEFERRED_SHAPE_ARRAY); 11624 break; 11625 11626 case Deferred_Shape: 11627 type_flag = type_flag | (1 << FEI_DEFERRED_SHAPE_ARRAY); 11628 break; 11629 } 11630 } 11631 11632 type_idx = fei_descriptor(type_flag, 11633 Array, 11634 pdg_array_idx, 11635 basic_type, 11636 kind_type, 11637 pdg_align[ATD_ALIGNMENT(attr_idx)]); 11638 # endif 11639 PDG_DBG_PRINT_START 11640 PDG_DBG_PRINT_T("(r) type", type_idx); 11641 PDG_DBG_PRINT_END 11642 11643 # if defined(GENERATE_WHIRL) 11644 } 11645 # endif 11646 } 11647 } 11648 11649 # if defined(COARRAY_FORTRAN) 11650 11651 pe_bd_idx = ATD_PE_ARRAY_IDX(attr_idx); 11652 if (pe_bd_idx) { 11653 dist_idx = ATD_DISTRIBUTION_IDX(attr_idx); 11654 basic_type = pdg_basic_type[TYP_TYPE(ATD_TYPE_IDX(attr_idx))]; 11655 11656 switch (TYP_LINEAR(ATD_TYPE_IDX(attr_idx))) { 11657 case Integer_1: 11658 case Logical_1: 11659 kind_type = 1; 11660 break; 11661 11662 case Integer_2: 11663 case Logical_2: 11664 kind_type = 2; 11665 break; 11666 11667 case Integer_4: 11668 case Logical_4: 11669 case Complex_4: 11670 case Real_4: 11671 kind_type = 4; 11672 break; 11673 11674 case Integer_8: 11675 case Logical_8: 11676 case Complex_8: 11677 case Real_8: 11678 kind_type = 8; 11679 break; 11680 11681 case Complex_16: 11682 case Real_16: 11683 kind_type = 16; 11684 break; 11685 } 11686 11687 11688 temp_attr_idx = attr_idx; 11689 11690 if (ATD_CLASS(attr_idx) == CRI__Pointee && 11691 ATD_PTR_IDX(attr_idx) != NULL_IDX) { 11692 temp_attr_idx = ATD_PTR_IDX(attr_idx); 11693 } 11694 else if (ATD_AUTOMATIC(attr_idx) && 11695 ATD_AUTO_BASE_IDX(attr_idx) != NULL_IDX) { 11696 temp_attr_idx = ATD_AUTO_BASE_IDX(attr_idx); 11697 } 11698 11699 if (ATD_STOR_BLK_IDX(temp_attr_idx) != NULL_IDX && 11700 SB_SCP_IDX(ATD_STOR_BLK_IDX(temp_attr_idx)) != curr_scp_idx) { 11701 type_flag = type_flag | (1 << FEI_DESCRIPTOR_HOSTED_TYPE); 11702 } 11703 11704 size = stor_bit_size_of(attr_idx, FALSE, FALSE); 11705 11706 if (size.fld == CN_Tbl_Idx) { 11707 span = CN_INT_TO_C(size.idx); 11708 } 11709 else { 11710 span = F_INT_TO_C(size.constant, TYP_LINEAR(size.type_idx)); 11711 } 11712 11713 # ifdef _DEBUG 11714 if (! BD_RESOLVED(pe_bd_idx)) { 11715 PRINTMSG(1, 626, Internal, 1, 11716 "resolved bounds entry", 11717 "get_type_desc"); 11718 } 11719 # endif 11720 11721 for (i = 1; i <= BD_RANK(pe_bd_idx); i++) { 11722 11723 if (BD_LB_FLD(pe_bd_idx, i) == NO_Tbl_Idx) 11724 { 11725 lb_empty = TRUE; 11726 } 11727 11728 else { 11729 11730 if (BD_LB_FLD(pe_bd_idx, i) == CN_Tbl_Idx) { 11731 lbound = CN_INT_TO_C(BD_LB_IDX(pe_bd_idx, i)); 11732 lb_vble = FALSE; 11733 } 11734 else { 11735 lbound = BD_LB_IDX(pe_bd_idx, i); 11736 lb_vble = TRUE; 11737 11738 # ifdef _TARGET_OS_MAX 11739 lb_symcon = ATD_SYMBOLIC_CONSTANT(lbound); 11740 lb_vble = !ATD_SYMBOLIC_CONSTANT(lbound); 11741 # endif 11742 11743 if (PDG_AT_IDX(lbound) == NULL_IDX) { 11744 11745 if (template_tmp) { 11746 COPY_ATTR_NTRY(AT_WORK_IDX, lbound); 11747 AT_REFERENCED(lbound) = Referenced; 11748 ATD_OFFSET_ASSIGNED(lbound) = FALSE; 11749 ATD_STOR_BLK_IDX(lbound) = SCP_SB_STACK_IDX(curr_scp_idx); 11750 send_attr_ntry(lbound); 11751 COPY_ATTR_NTRY(lbound, AT_WORK_IDX); 11752 } 11753 else { 11754 send_attr_ntry(lbound); 11755 } 11756 } 11757 lbound = PDG_AT_IDX(lbound); 11758 } 11759 } 11760 if (BD_UB_FLD(pe_bd_idx, i) == NO_Tbl_Idx) { 11761 11762 ub_empty = TRUE; 11763 } 11764 else { 11765 if (BD_UB_FLD(pe_bd_idx, i) == CN_Tbl_Idx) { 11766 ubound = CN_INT_TO_C(BD_UB_IDX(pe_bd_idx, i)); 11767 ub_vble = FALSE; 11768 } 11769 else { 11770 ubound = BD_UB_IDX(pe_bd_idx, i); 11771 ub_vble = TRUE; 11772 11773 # ifdef _TARGET_OS_MAX 11774 ub_symcon = ATD_SYMBOLIC_CONSTANT(ubound); 11775 ub_vble = !ATD_SYMBOLIC_CONSTANT(ubound); 11776 # endif 11777 11778 if (PDG_AT_IDX(ubound) == NULL_IDX) { 11779 11780 if (template_tmp) { 11781 COPY_ATTR_NTRY(AT_WORK_IDX, ubound); 11782 AT_REFERENCED(ubound) = Referenced; 11783 ATD_OFFSET_ASSIGNED(ubound) = FALSE; 11784 ATD_STOR_BLK_IDX(ubound) = SCP_SB_STACK_IDX(curr_scp_idx); 11785 send_attr_ntry(ubound); 11786 COPY_ATTR_NTRY(ubound, AT_WORK_IDX); 11787 } 11788 else { 11789 send_attr_ntry(ubound); 11790 } 11791 } 11792 ubound = PDG_AT_IDX(ubound); 11793 } 11794 } 11795 11796 if (BD_XT_FLD(pe_bd_idx,i) == NO_Tbl_Idx) { 11797 xt_empty = TRUE; 11798 span = (long64) 0; 11799 } 11800 else { 11801 if (BD_XT_FLD(pe_bd_idx, i) == CN_Tbl_Idx) { 11802 extent = CN_INT_TO_C(BD_XT_IDX(pe_bd_idx, i)); 11803 xt_vble = FALSE; 11804 span = extent * span; 11805 } 11806 else { 11807 extent = BD_XT_IDX(pe_bd_idx, i); 11808 xt_vble = TRUE; 11809 11810 # ifdef _TARGET_OS_MAX 11811 xt_symcon = ATD_SYMBOLIC_CONSTANT(extent); 11812 xt_vble = !ATD_SYMBOLIC_CONSTANT(extent); 11813 # endif 11814 11815 if (PDG_AT_IDX(extent) == NULL_IDX) { 11816 11817 if (template_tmp) { 11818 COPY_ATTR_NTRY(AT_WORK_IDX, extent); 11819 AT_REFERENCED(extent) = Referenced; 11820 ATD_OFFSET_ASSIGNED(extent) = FALSE; 11821 ATD_STOR_BLK_IDX(extent) = SCP_SB_STACK_IDX(curr_scp_idx); 11822 send_attr_ntry(extent); 11823 COPY_ATTR_NTRY(extent, AT_WORK_IDX); 11824 } 11825 else { 11826 send_attr_ntry(extent); 11827 } 11828 } 11829 extent = PDG_AT_IDX(extent); 11830 span = (long64) 0; 11831 } 11832 } 11833 11834 flag = (lb_symcon << FEI_ARRAY_DIMEN_SCON_LB)| 11835 (lb_vble << FEI_ARRAY_DIMEN_VARY_LB)| 11836 (ub_symcon << FEI_ARRAY_DIMEN_SCON_UB)| 11837 (ub_vble << FEI_ARRAY_DIMEN_VARY_UB)| 11838 (xt_symcon << FEI_ARRAY_DIMEN_SCON_EXT)| 11839 (xt_vble << FEI_ARRAY_DIMEN_VARY_EXT)| 11840 (lb_empty << FEI_ARRAY_DIMEN_EMPTY_LB)| 11841 (xt_empty << FEI_ARRAY_DIMEN_EMPTY_EXT)| 11842 (ub_empty << FEI_ARRAY_DIMEN_EMPTY_UB); 11843 11844 flag |= (BD_FLOW_DEPENDENT(pe_bd_idx) << FEI_ARRAY_DIMEN_FLOW_DEPENDENT); 11845 11846 temp_attr_idx = attr_idx; 11847 if (ATD_CLASS(attr_idx) == CRI__Pointee && 11848 ATD_PTR_IDX(attr_idx) != NULL_IDX) { 11849 temp_attr_idx = ATD_PTR_IDX(attr_idx); 11850 } 11851 11852 if (ATD_STOR_BLK_IDX(temp_attr_idx) != NULL_IDX && 11853 SB_SCP_IDX(ATD_STOR_BLK_IDX(temp_attr_idx)) != curr_scp_idx) { 11854 flag = flag | (1 << FEI_ARRAY_DIMEN_HOSTED_TYPE); 11855 } 11856 11857 if (dist_idx != NULL_IDX) { 11858 if (BD_CYCLIC_IDX(dist_idx, i) != NULL_IDX) { 11859 cvrt_exp_to_pdg(BD_CYCLIC_IDX(dist_idx, i), 11860 BD_CYCLIC_FLD(dist_idx, i)); 11861 flag = flag | (1 << FEI_ARRAY_DIMEN_DIST_EXPR); 11862 } 11863 11864 if (BD_ONTO_IDX(dist_idx, i) != NULL_IDX) { 11865 cvrt_exp_to_pdg(BD_ONTO_IDX(dist_idx, i), 11866 BD_ONTO_FLD(dist_idx, i)); 11867 flag = flag | (1 << FEI_ARRAY_DIMEN_ONTO_EXPR); 11868 } 11869 11870 distribution = BD_DISTRIBUTION(dist_idx, i); 11871 11872 flag = flag | (BD_DISTRIBUTE_RESHAPE(dist_idx) << 11873 FEI_ARRAY_DIMEN_DIST_RESHAPE); 11874 } 11875 11876 11877 PDG_DBG_PRINT_START 11878 PDG_DBG_PRINT_C("fei_co_array_dimen"); 11879 PDG_DBG_PRINT_O("(1) flags", flag); 11880 PDG_DBG_PRINT_LLD("(2) lbound", lbound); 11881 PDG_DBG_PRINT_LLD("(3) extent", extent); 11882 PDG_DBG_PRINT_D("(4) rank", i); 11883 PDG_DBG_PRINT_T("(5) type", type_idx); 11884 PDG_DBG_PRINT_LLD("(6) span", span); 11885 PDG_DBG_PRINT_S("(7) distribution", p_distribution[distribution]); 11886 PDG_DBG_PRINT_LLD("(8) ubound", ubound); 11887 PDG_DBG_PRINT_END 11888 11889 # ifdef _ENABLE_FEI 11890 pdg_array_idx = fei_co_array_dimen(flag, 11891 lbound, 11892 extent, 11893 bd_idx?BD_RANK(bd_idx):-1, 11894 i, 11895 type_idx, 11896 span, 11897 distribution, 11898 ubound); 11899 # endif 11900 11901 if (i == BD_RANK(pe_bd_idx)) { 11902 11903 PDG_DBG_PRINT_START 11904 PDG_DBG_PRINT_C("fei_descriptor"); 11905 PDG_DBG_PRINT_O("(1) flags", type_flag); 11906 PDG_DBG_PRINT_S("(2) table type", p_table_type[Array]); 11907 PDG_DBG_PRINT_LD("(3) pdg_array_idx", pdg_array_idx); 11908 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[basic_type]); 11909 PDG_DBG_PRINT_D("(5) aux info", kind_type); 11910 PDG_DBG_PRINT_D("(6) alignment", pdg_align[ATD_ALIGNMENT(attr_idx)]); 11911 PDG_DBG_PRINT_END 11912 # ifdef _ENABLE_FEI 11913 11914 /* 11915 * add flags for different type of array---fzhao 11916 */ 11917 if (ATD_ARRAY_IDX(attr_idx) != NULL_IDX) { 11918 11919 switch (BD_ARRAY_CLASS(ATD_ARRAY_IDX(attr_idx))) { 11920 case Assumed_Size: 11921 type_flag = type_flag | ( 1 << FEI_ASSUMED_SIZE_ARRAY); 11922 break; 11923 11924 case Assumed_Shape: 11925 type_flag = type_flag | ( 1 << FEI_ASSUMD_SHAPE_ARRAY); 11926 break; 11927 11928 case Deferred_Shape1: 11929 type_flag = type_flag | (1 << FEI_DEFERRED_SHAPE_ARRAY); 11930 break; 11931 11932 case Deferred_Shape: 11933 type_flag = type_flag | (1 << FEI_DEFERRED_SHAPE_ARRAY); 11934 break; 11935 } 11936 } 11937 11938 type_idx = fei_descriptor(type_flag, 11939 Array, 11940 pdg_array_idx, 11941 basic_type, 11942 kind_type, 11943 pdg_align[ATD_ALIGNMENT(attr_idx)]); 11944 # endif 11945 PDG_DBG_PRINT_START 11946 PDG_DBG_PRINT_T("(r) type", type_idx); 11947 PDG_DBG_PRINT_END 11948 } 11949 } 11950 } 11951 # endif 11952 11953 EXIT: 11954 11955 TRACE (Func_Exit, "get_type_desc", NULL); 11956 11957 return(type_idx); 11958 11959 } /* get_type_desc */ 11960 11961 11962 /******************************************************************************\ 11963 |* *| 11964 |* Description: *| 11965 |* *| 11966 |* Input parameters: *| 11967 |* NONE *| 11968 |* *| 11969 |* Output parameters: *| 11970 |* NONE *| 11971 |* *| 11972 |* Returns: *| 11973 |* NOTHING *| 11974 |* *| 11975 \******************************************************************************/ 11976 static void send_stor_blk(int sb_idx, 11977 int *pdg_sym_class) 11978 11979 { 11980 long64 blk_len = (long64) 0; 11981 int flag; 11982 int host_sb_idx = NULL_IDX; 11983 int local_sb_idx; 11984 char *name_ptr; 11985 int parent_idx; 11986 sb_type_type sb_type; 11987 11988 # if defined(GENERATE_WHIRL) 11989 int i; 11990 char new_name[256]; 11991 # endif 11992 11993 11994 TRACE (Func_Entry, "send_stor_blk", NULL); 11995 11996 if (sb_idx == NULL_IDX) { 11997 goto EXIT; 11998 } 11999 12000 sb_type = SB_BLK_TYPE(sb_idx); 12001 12002 flag = (SB_MODULE(sb_idx) << FEI_SEG_MODULE) | 12003 (SB_SAVED(sb_idx) << FEI_SEG_SAVED) | 12004 (SB_EQUIVALENCED(sb_idx) << FEI_SEG_EQUIVALENCED) | 12005 (SB_DUPLICATE_COMMON(sb_idx) << FEI_SEG_DUPLICATE) | 12006 (SB_VOLATILE(sb_idx) << FEI_SEG_VOLATILE) | 12007 (SB_SYMMETRIC(sb_idx) << FEI_SEG_SHARED); 12008 if (SB_MODULE_IDX (sb_idx)!=NULL_IDX) 12009 flag |= 1 << FEI_SEG_EXTERNAL; 12010 12011 if (sb_type == Threadprivate) { 12012 sb_type = Common; 12013 flag |= 1 << FEI_SEG_THREADPRIVATE; 12014 } 12015 12016 if (sb_type == Coment) { 12017 *pdg_sym_class = Name; 12018 } 12019 12020 switch (SB_LEN_FLD(sb_idx)) { 12021 case CN_Tbl_Idx : 12022 blk_len = CN_INT_TO_C(SB_LEN_IDX(sb_idx)); 12023 break; 12024 12025 case AT_Tbl_Idx : 12026 flag = flag | (1 << FEI_SEG_SCON_LEN); 12027 send_attr_ntry(SB_LEN_IDX(sb_idx)); 12028 blk_len = (long64) PDG_AT_IDX(SB_LEN_IDX(sb_idx)); 12029 break; 12030 } 12031 12032 if (SB_SCP_IDX(sb_idx) != curr_scp_idx) { 12033 12034 if (SB_HOSTED_STACK(sb_idx)) { 12035 sb_type = Non_Local_Stack; 12036 *pdg_sym_class = Hosted_User_Variable; 12037 } 12038 else if (sb_type == Formal) { 12039 sb_type = Non_Local_Formal; 12040 *pdg_sym_class = Hosted_Dummy_Arg; 12041 } 12042 else if (sb_type == Based ||sb_type ==Static) { 12043 12044 12045 *pdg_sym_class = Hosted_User_Variable; 12046 } 12047 else if (PDG_SB_IDX(sb_idx) == NULL_IDX) { 12048 12049 /* Find this block in the local scope. It must be there, */ 12050 /* because it was moved in during attr_link_resolution. */ 12051 local_sb_idx = srch_stor_blk_tbl(SB_NAME_PTR(sb_idx), 12052 SB_NAME_LEN(sb_idx), 12053 curr_scp_idx); 12054 12055 /* local_sb_idx could be NULL if we have a leftover */ 12056 /* storage block from an inlined routine. */ 12057 if (local_sb_idx != NULL_IDX) { 12058 if (PDG_SB_IDX(local_sb_idx) != NULL_IDX) { 12059 PDG_SB_IDX(sb_idx) = PDG_SB_IDX(local_sb_idx); 12060 } 12061 else { 12062 host_sb_idx = sb_idx; 12063 sb_idx = local_sb_idx; 12064 } 12065 } 12066 } 12067 } 12068 else if (SB_HOSTED_STACK(sb_idx)) { 12069 sb_type = Hosted_Stack; 12070 } 12071 12072 if (PDG_SB_IDX(sb_idx) != NULL_IDX) { 12073 goto EXIT; 12074 } 12075 12076 name_ptr = SB_NAME_PTR(sb_idx); 12077 12078 if (sb_type == Task_Common) { /* -a taskcommon switches */ 12079 /* Intentionally blank. */ 12080 } 12081 else if (SB_MODULE(sb_idx)) { /* Module data is Common data. */ 12082 /* sb_type = Common; */ 12083 sb_type = ZModule; 12084 } 12085 else if (sb_type == Static) { 12086 if (SB_HOSTED_STATIC(sb_idx)) { /* Hosted static data is common. */ 12087 flag = flag | (1 << FEI_SEG_DUPLICATE); 12088 sb_type = Common; 12089 } 12090 else { 12091 sb_type = Static_Local; 12092 } 12093 } 12094 12095 /* All local static blocks are converted to a new kind of */ 12096 /* storage class for PDGCS. Basically, the storage class is */ 12097 /* optimized as local common; but, externalized by the loader. */ 12098 12099 if ((opt_flags.inline_lvl > Inline_Lvl_0 || opt_flags.modinline) && 12100 (sb_type == Static_Local || sb_type == Static_Named)) { 12101 flag = flag | (1 << FEI_SEG_LOCAL_COMMON); 12102 } 12103 12104 if (sb_type == Common || sb_type == Task_Common 12105 || sb_type == ZModule ) { 12106 12107 # if defined(GENERATE_WHIRL) 12108 if (! SB_BLANK_COMMON(sb_idx) && 12109 ! SB_NAME_IN_STONE(sb_idx)) { 12110 12111 /* Need all common block names lower case with a trailing _, */ 12112 /* except blank common. */ 12113 12114 for (i = 0; i < SB_NAME_LEN(sb_idx); i++) { 12115 new_name[i] = tolower(name_ptr[i]); 12116 } 12117 12118 new_name[i] = '_'; 12119 12120 for (i = SB_NAME_LEN(sb_idx) + 1; i < 256; i++) { 12121 new_name[i] = '\0'; 12122 } 12123 name_ptr = &new_name[0]; 12124 } 12125 # endif 12126 12127 parent_idx = NULL_IDX; 12128 } 12129 else { 12130 parent_idx = PDG_AT_IDX(SCP_ATTR_IDX(SB_SCP_IDX(sb_idx))); 12131 } 12132 12133 PDG_DBG_PRINT_START 12134 PDG_DBG_PRINT_C("fei_seg"); 12135 PDG_DBG_PRINT_S("(1) name_ptr", name_ptr); 12136 PDG_DBG_PRINT_S("(2) segment type", p_sb_blk_type_str[sb_type]); 12137 PDG_DBG_PRINT_S("(3) parent_idx", 12138 AT_OBJ_NAME_PTR(SCP_ATTR_IDX(SB_SCP_IDX(sb_idx)))); 12139 PDG_DBG_PRINT_D("(4) unused", 0); 12140 PDG_DBG_PRINT_D("(5) unused", 0); 12141 PDG_DBG_PRINT_O("(6) flags", flag); 12142 PDG_DBG_PRINT_D("(7) unused", 0); 12143 PDG_DBG_PRINT_LLD("(8) blk_len", blk_len); 12144 PDG_DBG_PRINT_END 12145 12146 # ifdef _ENABLE_FEI 12147 PDG_SB_IDX(sb_idx) = fei_seg(name_ptr, 12148 sb_type, 12149 parent_idx, 12150 0, 12151 0, 12152 flag, 12153 0, 12154 blk_len); 12155 # endif 12156 12157 PDG_DBG_PRINT_START 12158 PDG_DBG_PRINT_LD("(r) PDG_SB_IDX", PDG_SB_IDX(sb_idx)); 12159 PDG_DBG_PRINT_END 12160 12161 if (host_sb_idx != NULL_IDX) { 12162 PDG_SB_IDX(host_sb_idx) = PDG_SB_IDX(sb_idx); 12163 } 12164 12165 EXIT: 12166 12167 TRACE (Func_Exit, "send_stor_blk", NULL); 12168 12169 return; 12170 12171 } /* send_stor_blk */ 12172 12173 12174 12175 /******************************************************************************\ 12176 |* *| 12177 |* Description: *| 12178 |* send_dummy_procedure sends a dummy procedure. *| 12179 |* *| 12180 |* Input parameters: *| 12181 |* attr_idx -> Index of attr entry for the dummy procedure. *| 12182 |* *| 12183 |* Output parameters: *| 12184 |* NONE *| 12185 |* *| 12186 |* Returns: *| 12187 |* NOTHING *| 12188 |* *| 12189 \******************************************************************************/ 12190 static void send_dummy_procedure(int attr_idx) 12191 12192 { 12193 long64 flag; 12194 long64 size; 12195 size_offset_type stor_size; 12196 TYPE type_idx; 12197 int class; 12198 12199 12200 TRACE (Func_Entry, "send_dummy_procedure", NULL); 12201 12202 send_stor_blk(SCP_SB_DARG_IDX(curr_scp_idx), &class); 12203 12204 class = Dummy_Procedure; 12205 12206 # if defined(GENERATE_WHIRL) 12207 if (curr_scp_idx != ATP_SCP_IDX(attr_idx)) { 12208 class = Hosted_Dummy_Procedure; 12209 } 12210 # endif 12211 12212 if (ATP_RSLT_IDX(attr_idx) == NULL_IDX) { 12213 type_idx = get_type_desc(attr_idx); 12214 } 12215 else { 12216 type_idx = get_type_desc(ATP_RSLT_IDX(attr_idx)); 12217 } 12218 12219 if (ATP_PGM_UNIT(attr_idx) == Function && 12220 TYP_TYPE(ATD_TYPE_IDX(ATP_RSLT_IDX(attr_idx))) == Character) { 12221 stor_size = stor_bit_size_of(attr_idx, FALSE, FALSE); 12222 12223 if (stor_size.fld == CN_Tbl_Idx) { 12224 size = CN_INT_TO_C(stor_size.idx); 12225 } 12226 else { 12227 size = F_INT_TO_C(stor_size.constant, TYP_LINEAR(stor_size.type_idx)); 12228 } 12229 } 12230 else { 12231 size = (long64) TARGET_BITS_PER_WORD; 12232 } 12233 12234 12235 flag = ((long64) AT_REF_IN_CHILD(attr_idx) << FEI_OBJECT_INNER_REF) | 12236 ((long64) AT_DEF_IN_CHILD(attr_idx) << FEI_OBJECT_INNER_DEF) | 12237 ((long64) AT_DEFINED(attr_idx) << FEI_OBJECT_DEFINED); 12238 12239 PDG_DBG_PRINT_START 12240 PDG_DBG_PRINT_C("fei_object"); 12241 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 12242 PDG_DBG_PRINT_T("(2) type", type_idx); 12243 PDG_DBG_PRINT_LLO("(3) flags", flag); 12244 PDG_DBG_PRINT_S("(4) symbol class", p_obj_sym_class[class]); 12245 PDG_DBG_PRINT_S("(5) block", SB_NAME_PTR(SCP_SB_DARG_IDX(curr_scp_idx))); 12246 PDG_DBG_PRINT_D("(6) unused", 0); 12247 PDG_DBG_PRINT_D("(7) unused", 0); 12248 PDG_DBG_PRINT_D("(8) unused", 0); 12249 PDG_DBG_PRINT_S("(9) intent", p_intent[Intent_Inout]); 12250 PDG_DBG_PRINT_LLD("(10) bit size", size); 12251 PDG_DBG_PRINT_D("(11) unused", 0); 12252 PDG_DBG_PRINT_D("(12) storage align", Word_Align); 12253 PDG_DBG_PRINT_D("(13) unused", 0); 12254 PDG_DBG_PRINT_D("(14) unused", 0); 12255 PDG_DBG_PRINT_D("(15) unused", 0); 12256 PDG_DBG_PRINT_D("(16) def line", AT_DEF_LINE(attr_idx)); 12257 PDG_DBG_PRINT_END 12258 12259 # ifdef _ENABLE_FEI 12260 PDG_AT_IDX(attr_idx) = fei_object(AT_OBJ_NAME_PTR(attr_idx), 12261 type_idx, 12262 flag, 12263 class, 12264 PDG_SB_IDX(SCP_SB_DARG_IDX(curr_scp_idx)), 12265 0, 12266 0, 12267 0, 12268 Intent_Inout, 12269 size, 12270 0, 12271 Word_Align, 12272 0, 12273 0, 12274 0, 12275 AT_DEF_LINE(attr_idx), 12276 0); 12277 # endif 12278 12279 PDG_DBG_PRINT_START 12280 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12281 PDG_DBG_PRINT_END 12282 12283 TRACE (Func_Exit, "send_dummy_procedure", NULL); 12284 12285 return; 12286 12287 } /* send_dummy_procedure */ 12288 12289 12290 12291 /******************************************************************************\ 12292 |* *| 12293 |* Description: *| 12294 |* Calls fei_proc to add an entry point of the routine. It also *| 12295 |* handles all the dummy arguments and the function result. *| 12296 |* *| 12297 |* Input parameters: *| 12298 |* attr_idx -> Attr index of entry point. *| 12299 |* alt_entry_idx -> If ATP_ALT_ENTRY, this is the PDG_AT_IDX of the main *| 12300 |* entry point for the alternate entry point. If *| 12301 |* !ATP_ALT_ENTRY and this field is not NULL_IDX this *| 12302 |* is the SCP_ENTRY_IDX for the entry point. *| 12303 |* pdg_sym_idx -> Pdgcs symbol table index where PDGCS should put this *| 12304 |* should put this entry point. *| 12305 |* call_type -> This is an enum and can be a Definition, Parent or *| 12306 |* Imported. These determine which PDGCS inteface *| 12307 |* routine to call and what arguments need to be sent. *| 12308 |* *| 12309 |* Output parameters: *| 12310 |* NONE *| 12311 |* *| 12312 |* Returns: *| 12313 |* NOTHING *| 12314 |* *| 12315 \******************************************************************************/ 12316 static void send_procedure(int attr_idx, 12317 int alt_entry_idx, 12318 int call_type) 12319 12320 { 12321 int darg_pdg_sn_fw_idx = NULL_IDX; 12322 boolean pure; 12323 long64 flag3 = (long64) 0; 12324 int main_entry_idx; 12325 char *name_ptr; 12326 int num_dargs = 0; 12327 int parent_idx; 12328 int pdg_alt_entry_idx = NULL_IDX; 12329 int pgm_unit; 12330 int prev_idx; 12331 int proc; 12332 TYPE type_desc; 12333 int in_interface = ATP_IN_INTERFACE_BLK(attr_idx); 12334 12335 12336 TRACE (Func_Entry, "send_procedure", NULL); 12337 12338 if (call_type == Imported) { 12339 if (ATP_PROC(attr_idx) == Dummy_Proc) { 12340 send_dummy_procedure(attr_idx); 12341 goto EXIT; 12342 } 12343 12344 if (AT_USE_ASSOCIATED(attr_idx) && 12345 AT_REFERENCED(attr_idx) == Not_Referenced && 12346 ATP_IN_INTERFACE_BLK(attr_idx) && 12347 ATP_EXPL_ITRFC(attr_idx) && 12348 ATP_PROC(attr_idx) == Extern_Proc) { 12349 name_ptr = &name_pool[ATP_EXT_NAME_IDX(attr_idx)].name_char; 12350 if (strcmp(AT_OBJ_NAME_PTR(SCP_ATTR_IDX(curr_scp_idx)), 12351 name_ptr) == 0) { 12352 /* 12353 We have a routine being USE associated that is 12354 defined in an INTERFACE block only. The backend must not 12355 see this. 12356 */ 12357 goto EXIT; 12358 } 12359 } 12360 } 12361 12362 pgm_unit = ATP_PGM_UNIT(attr_idx); 12363 name_ptr = &name_pool[ATP_EXT_NAME_IDX(attr_idx)].name_char; 12364 parent_idx = NULL_IDX; 12365 12366 12367 pure = ATP_NOSIDE_EFFECTS(attr_idx) || 12368 ATP_PURE(attr_idx) || 12369 ATP_ELEMENTAL(attr_idx); 12370 12371 flag3 = 12372 ((long64) ATP_VFUNCTION(attr_idx) << FEI_PROC_VFUNC)| 12373 ((long64) pure << FEI_PROC_CNGA)| 12374 ((long64) pure << FEI_PROC_CNAA)| 12375 ((long64) pure << FEI_PROC_CNGO)| 12376 ((long64) pure << FEI_PROC_RNGO)| 12377 ((long64) !SCP_DOES_IO(curr_scp_idx) << FEI_PROC_NOIO)| 12378 ((long64) !SCP_HAS_CALLS(curr_scp_idx) << FEI_PROC_NOCALLS)| 12379 ((long64) ATP_ALL_INTENT_IN(attr_idx) << FEI_PROC_DNDA)| 12380 ((long64) ATP_RECURSIVE(attr_idx) << FEI_PROC_RECURSE)| 12381 ((long64) ATP_HAS_TASK_DIRS(SCP_ATTR_IDX(curr_scp_idx)) 12382 << FEI_PROC_MICROTASK)| 12383 ((long64) opt_flags.taskinner << FEI_PROC_TASKINNER)| 12384 ((long64) !opt_flags.threshold << FEI_PROC_NOTHRESHOLDS)| 12385 ((long64) 1 << FEI_PROC_TOLERANT)| 12386 ((long64) on_off_flags.alloc_autos_on_stack << FEI_PROC_LIMHEAP)| 12387 ((long64) ATP_DCL_EXTERNAL(attr_idx) << FEI_PROC_IMMORT)| 12388 ((long64) ATP_EXTRA_DARG(attr_idx) << FEI_PROC_HASRSLT)| 12389 ((long64) on_off_flags.indef_init << FEI_PROC_INDEFSTK)| 12390 ((long64) (cmd_line_flags.solaris_profile | cdir_switches.flow) 12391 << FEI_PROC_DOFLOWTR)| 12392 ((long64) opt_flags.zeroinc << FEI_PROC_ZEROINC)| 12393 ((long64) ATP_ALIGN(attr_idx) << FEI_PROC_ALGNINST)| 12394 ((long64) ATP_NAME_IN_STONE(attr_idx) << FEI_PROC_PERM_NAME)| 12395 ((long64) on_off_flags.round_mult_operations << FEI_PROC_STRROUND)| 12396 ((long64) !on_off_flags.round_mult_operations << FEI_PROC_TRUNCATE)| 12397 ((long64) (opt_flags.over_index | 12398 ATP_HAS_OVER_INDEXING(SCP_ATTR_IDX(curr_scp_idx))) 12399 << FEI_PROC_NCOADDR)| 12400 ((long64) ((ATP_PGM_UNIT(attr_idx) == Function) & on_off_flags.recursive) 12401 << FEI_PROC_RECURSE)| 12402 ((long64) ((ATP_PGM_UNIT(attr_idx) == Subroutine) & on_off_flags.recursive) 12403 << FEI_PROC_RECURSE)| 12404 ((long64) ((attr_idx == SCP_ATTR_IDX(curr_scp_idx)) & 12405 (ATP_PGM_UNIT(attr_idx) == Module)) 12406 << FEI_PROC_MOD_FIRST)| 12407 ((long64) ((attr_idx == SCP_ATTR_IDX(curr_scp_idx)) & 12408 (ATP_PROC(attr_idx) == Module_Proc)) 12409 << FEI_PROC_MOD_JUST)| 12410 ((long64) (attr_idx == AT_WORK_IDX) << FEI_PROC_MOD_LAST)| 12411 ((long64) ATP_ARGCHCK_CALL(attr_idx) << FEI_PROC_ARG_CHECK)| 12412 ((long64) on_off_flags.zero_init << FEI_PROC_ZERO_INIT)| 12413 ((long64) ATP_OPTIONAL_DIR(attr_idx) << FEI_PROC_OPTIONAL_DIR)| 12414 ((long64) (call_type == Definition) << FEI_PROC_DEFINITION)| 12415 ((long64) (call_type == In_Interface) << FEI_PROC_IN_INTERFACE) | 12416 ((long64) (call_type == Imported) << FEI_PROC_IMPORTED)| 12417 ((long64) AT_MODULE_OBJECT(attr_idx) << FEI_PROC_MODULE)| 12418 ((long64) (AT_MODULE_IDX(attr_idx)) << FEI_PROC_M_IMPORTED)| 12419 ((long64) (call_type == Parent) << FEI_PROC_PARENT)| 12420 ((long64) (ATP_NOSIDE_EFFECTS(attr_idx) | ATP_PURE(attr_idx)) 12421 << FEI_PROC_NOSIDE_EFFECTS)| 12422 ((long64) ATP_ELEMENTAL(attr_idx) << FEI_PROC_ELEMENTAL); 12423 12424 if (ATP_PGM_UNIT(attr_idx) == Module && 12425 (ATP_SCP_IDX(attr_idx) != curr_scp_idx || 12426 !ATP_IN_CURRENT_COMPILE(attr_idx))) { 12427 flag3 = flag3 | ((long64) 1 << FEI_PROC_IMMORT); 12428 } 12429 12430 12431 if (call_type == Definition || call_type == Parent ||call_type == In_Interface) { 12432 if (SCP_ALT_ENTRY_CNT(ATP_SCP_IDX(attr_idx)) > 0) { 12433 flag3 = flag3 | ((long64) 1 << FEI_PROC_HAS_ALT_ENTRY); 12434 } 12435 12436 if (ATP_SGI_GLOBAL_INLINE(attr_idx)) { 12437 flag3 = flag3 | ((long64) 1 << FEI_PROC_GLOBAL_INLINE); 12438 } 12439 12440 proc = ATP_PROC(attr_idx); 12441 if (SCP_PARENT_IDX(curr_scp_idx) != NULL_IDX && 12442 (ATP_PGM_UNIT(SCP_ATTR_IDX(SCP_PARENT_IDX(curr_scp_idx))) != Module 12443 || TRUE)) { 12444 12445 12446 parent_idx = PDG_AT_IDX(SCP_ATTR_IDX(SCP_PARENT_IDX(curr_scp_idx))); 12447 } 12448 12449 if (ATP_PROC(attr_idx) == Unknown_Proc || 12450 ATP_PROC(attr_idx) == Module_Proc ) { 12451 proc = Extern_Proc; 12452 } 12453 12454 if (ATP_PROC(attr_idx) == Intrin_Proc) 12455 proc = Intrin_src_Proc; 12456 12457 if (alt_entry_idx != NULL_IDX) { 12458 if (ATP_ALT_ENTRY(attr_idx)) { 12459 pdg_alt_entry_idx = alt_entry_idx; 12460 flag3 = flag3 | ((long64) 1 << FEI_PROC_ENTRY); 12461 } 12462 else { 12463 PDG_DBG_PRINT_START 12464 PDG_DBG_PRINT_C("fei_next_name"); 12465 PDG_DBG_PRINT_D("(1) logical", TRUE); 12466 PDG_DBG_PRINT_END 12467 12468 # ifdef _ENABLE_FEI 12469 pdg_alt_entry_idx = fei_next_name(TRUE); 12470 # endif 12471 } 12472 } 12473 12474 if (ATP_PROC(attr_idx) == Intern_Proc) { 12475 pdg_alt_entry_idx = parent_idx; 12476 } 12477 } 12478 else if (ATP_PROC(attr_idx) == Intrin_Proc) 12479 { 12480 if (ATP_INTRIN_ENUM(attr_idx)==Sync_Images_Intrinsic || 12481 ATP_INTRIN_ENUM(attr_idx)==Rem_Images_Intrinsic || 12482 ATP_INTRIN_ENUM(attr_idx)==Log2_Images_Intrinsic || 12483 ATP_INTRIN_ENUM(attr_idx)==This_Image_Intrinsic || 12484 ATP_INTRIN_ENUM(attr_idx)==Num_Images_Intrinsic) 12485 proc = Imported_Proc; /*June*/ 12486 else proc = Intrin_src_Proc; 12487 } 12488 12489 else 12490 { 12491 proc = (ATP_PROC(attr_idx) == Intern_Proc) ? Intern_Proc_Refd : 12492 Imported_Proc; 12493 12494 if (attr_idx == glb_tbl_idx[Buffer_In_Attr_Idx]) { 12495 flag3 = flag3 | ((long64) 1 << FEI_PROC_BUFIN); 12496 } 12497 else if (attr_idx == glb_tbl_idx[Buffer_Out_Attr_Idx]) { 12498 flag3 = flag3 | ((long64) 1 << FEI_PROC_BUFOUT); 12499 } 12500 } 12501 12502 switch (pgm_unit) { 12503 12504 case Module: 12505 case Blockdata: 12506 case Program: 12507 case Pgm_Unknown: 12508 type_desc = pdg_type_void; 12509 break; 12510 12511 12512 case Subroutine: 12513 num_dargs = (call_type == Imported) ? 0 : ATP_NUM_DARGS(attr_idx); 12514 12515 if (ATP_HAS_ALT_RETURN(attr_idx)) { 12516 pgm_unit = Function; 12517 type_desc = get_basic_type(CG_INTEGER_DEFAULT_TYPE, 12518 type_alignment_tbl[CG_INTEGER_DEFAULT_TYPE], 12519 NULL_IDX); 12520 } 12521 else { 12522 type_desc = pdg_type_void; 12523 } 12524 break; 12525 12526 12527 case Function: 12528 num_dargs = (call_type == Imported) ? 0 : ATP_NUM_DARGS(attr_idx); 12529 12530 # if 0 12531 if (ATP_EXTRA_DARG(attr_idx)) { 12532 pgm_unit = Subroutine; 12533 type_desc = pdg_type_void; 12534 } 12535 else 12536 # endif 12537 /* 12538 Need to send the attr_idx to 12539 get_type_desc, because we need 12540 to determine if these bounds are 12541 template bounds or real bounds. 12542 */ 12543 type_desc = get_type_desc(attr_idx); 12544 12545 if (call_type == Definition || 12546 call_type == In_Interface || 12547 (call_type == Parent && 12548 SB_HOSTED_STACK(ATD_STOR_BLK_IDX(ATP_RSLT_IDX(attr_idx))))) { 12549 12550 /* 12551 Send the function result if this is a definition or if the 12552 result has been host associated. The result gets host 12553 associated if a reference is made to the function or the 12554 result and they have the same name. Since at the symbol 12555 table level we don't know if the function is being called 12556 or if the result is being host associated, we assume that 12557 both things are happening. 12558 */ 12559 12560 if (!ATP_EXTRA_DARG(attr_idx)) 12561 send_attr_ntry(ATP_RSLT_IDX(attr_idx)); 12562 12563 } 12564 break; 12565 } 12566 12567 if (num_dargs != 0) { 12568 PDG_DBG_PRINT_START 12569 PDG_DBG_PRINT_C("fei_next_name"); 12570 PDG_DBG_PRINT_D("(1) logical", TRUE); 12571 PDG_DBG_PRINT_END 12572 12573 # ifdef _ENABLE_FEI 12574 darg_pdg_sn_fw_idx = fei_next_name(TRUE); 12575 # endif 12576 } 12577 12578 PDG_DBG_PRINT_START 12579 PDG_DBG_PRINT_C("fei_proc"); 12580 PDG_DBG_PRINT_S("(1) name_ptr", name_ptr); 12581 PDG_DBG_PRINT_D("(2) AT_DEF_LINE", AT_DEF_LINE(attr_idx)); 12582 PDG_DBG_PRINT_S("(3) pgm_unit", p_atp_pgm_unit[pgm_unit]); 12583 PDG_DBG_PRINT_S("(4) proc", p_proc[proc]); 12584 PDG_DBG_PRINT_D("(5) num_dargs", num_dargs); 12585 PDG_DBG_PRINT_D("(6) parent_idx", parent_idx); 12586 PDG_DBG_PRINT_D("(7) pdg darg list", darg_pdg_sn_fw_idx); 12587 PDG_DBG_PRINT_D("(8) alt link idx", pdg_alt_entry_idx); 12588 PDG_DBG_PRINT_T("(9) type", type_desc); 12589 PDG_DBG_PRINT_LD("(10) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12590 PDG_DBG_PRINT_LLO("(11) flags", flag3); 12591 PDG_DBG_PRINT_END 12592 # ifdef _ENABLE_FEI 12593 PDG_AT_IDX(attr_idx) = fei_proc(name_ptr, 12594 AT_DEF_LINE(attr_idx), 12595 pgm_unit, 12596 proc, 12597 num_dargs, 12598 parent_idx, 12599 darg_pdg_sn_fw_idx, 12600 pdg_alt_entry_idx, 12601 type_desc, 12602 PDG_AT_IDX(attr_idx), 12603 flag3, 12604 in_interface, 12605 /* since no flag bit for coarray concurrent, we need 12606 to add this one more argument---FMZ 12607 */ 12608 ATP_COARRAY_CONCURRENT(attr_idx)); 12609 # endif 12610 12611 PDG_DBG_PRINT_START 12612 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12613 PDG_DBG_PRINT_END 12614 12615 12616 12617 if (cmd_line_flags.debug_lvl <= Debug_Lvl_2) { 12618 if (ATP_PROC(attr_idx) == Intrin_Proc && FALSE) { 12619 if (ATP_INTERFACE_IDX(attr_idx) != NULL_IDX) { 12620 PDG_DBG_PRINT_START 12621 PDG_DBG_PRINT_C("fei_smt_actual_to_generic"); 12622 PDG_DBG_PRINT_LD("PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12623 PDG_DBG_PRINT_END 12624 12625 # ifdef _ENABLE_FEI 12626 fei_smt_actual_to_generic(PDG_AT_IDX(attr_idx), 12627 AT_OBJ_NAME_PTR(ATP_INTERFACE_IDX(attr_idx))); 12628 # endif 12629 } 12630 } 12631 12632 if (ATP_EXT_NAME_IDX(attr_idx) != AT_NAME_IDX(attr_idx)) { 12633 /* These may be the same even though indexes are different */ 12634 12635 PDG_DBG_PRINT_START 12636 PDG_DBG_PRINT_C("fei_smt_original_to_qualified"); 12637 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12638 PDG_DBG_PRINT_S("(2) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 12639 PDG_DBG_PRINT_END 12640 12641 # ifdef _ENABLE_FEI 12642 fei_smt_original_to_qualified(PDG_AT_IDX(attr_idx), 12643 AT_OBJ_NAME_PTR(attr_idx)); 12644 # endif 12645 } 12646 } 12647 12648 if (num_dargs != 0) { 12649 send_darg_list(attr_idx, darg_pdg_sn_fw_idx); 12650 } 12651 12652 if (alt_entry_idx != NULL_IDX && !ATP_ALT_ENTRY(attr_idx)) { 12653 12654 /* This is a main entry for a definition or a parent. */ 12655 /* Send the alternate entries. */ 12656 12657 prev_idx = NULL_IDX; 12658 main_entry_idx = attr_idx; 12659 12660 while (alt_entry_idx != NULL_IDX) { 12661 attr_idx = AL_ATTR_IDX(alt_entry_idx); 12662 12663 /* Send entry name, result name, and dummy args. Need to */ 12664 /* set ATP_SCP_ALIVE, so if there are any bounds tmps, */ 12665 /* they get the correct storage block. If not, they will */ 12666 /* look like they are host associated. */ 12667 12668 ATP_SCP_ALIVE(attr_idx) = TRUE; 12669 12670 send_procedure(attr_idx, 12671 PDG_AT_IDX(main_entry_idx), 12672 call_type); 12673 12674 ATP_SCP_ALIVE(attr_idx) = FALSE; 12675 12676 name_ptr = &name_pool[ATP_EXT_NAME_IDX(attr_idx)].name_char; 12677 12678 /* prev_idx is a pdgcs index to the name being entered */ 12679 /* in the pdgcs secondary name table. */ 12680 12681 PDG_DBG_PRINT_START 12682 PDG_DBG_PRINT_C("fei_name"); 12683 PDG_DBG_PRINT_S("(1) name_ptr", name_ptr); 12684 PDG_DBG_PRINT_S("(2) table", "PDGCS_Function"); 12685 PDG_DBG_PRINT_LD("(3) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12686 PDG_DBG_PRINT_D("(4) prev_idx", prev_idx); 12687 PDG_DBG_PRINT_D("(5) pdg_alt_entry_idx", pdg_alt_entry_idx); 12688 PDG_DBG_PRINT_END 12689 12690 # ifdef _ENABLE_FEI 12691 prev_idx = fei_name(name_ptr, 12692 Sym_Function, 12693 PDG_AT_IDX(attr_idx), 12694 prev_idx, 12695 pdg_alt_entry_idx); 12696 # endif 12697 alt_entry_idx = AL_NEXT_IDX(alt_entry_idx); 12698 12699 if (alt_entry_idx != NULL_IDX) { 12700 PDG_DBG_PRINT_START 12701 PDG_DBG_PRINT_C("fei_next_name"); 12702 PDG_DBG_PRINT_D("(1) logical", TRUE); 12703 PDG_DBG_PRINT_END 12704 12705 # ifdef _ENABLE_FEI 12706 pdg_alt_entry_idx = fei_next_name(TRUE); 12707 # endif 12708 } 12709 } 12710 } 12711 12712 EXIT: 12713 12714 TRACE (Func_Exit, "send_procedure", NULL); 12715 12716 return; 12717 12718 } /* send_procedure */ 12719 12720 12721 12722 /******************************************************************************\ 12723 |* *| 12724 |* Description: *| 12725 |* *| 12726 |* Input parameters: *| 12727 |* NONE *| 12728 |* *| 12729 |* Output parameters: *| 12730 |* NONE *| 12731 |* *| 12732 |* Returns: *| 12733 |* NOTHING *| 12734 |* *| 12735 \******************************************************************************/ 12736 static TYPE send_derived_type(int type_idx, INT32 nested_attr) 12737 12738 { 12739 int attr_idx; 12740 int cpnt_idx; 12741 int dt_attr_idx; 12742 long flag = 0; 12743 int dt_idx; 12744 int prev_idx; 12745 int sequence; 12746 int sn_idx; 12747 long64 size; 12748 TYPE pdg_type_idx; 12749 12750 12751 TRACE (Func_Entry, "send_derived_type", NULL); 12752 12753 dt_attr_idx = TYP_IDX(type_idx); 12754 12755 while (AT_ATTR_LINK(dt_attr_idx) != NULL_IDX) { 12756 dt_attr_idx = AT_ATTR_LINK(dt_attr_idx); 12757 } 12758 12759 if (PDG_AT_IDX(dt_attr_idx) != NULL_IDX) { 12760 pdg_type_idx = pdg_type_tbl[PDG_AT_TYP_IDX(dt_attr_idx)]; 12761 pdg_type_tbl[type_idx] = pdg_type_idx; 12762 goto EXIT; 12763 } 12764 12765 /* add if dt_attr_idx is imported by use statement, 12766 * check if there is type table entry in whirl, if there is 12767 * a type table entry, just get set pdg_type_idx ---FMZ 12768 */ 12769 if (AT_MODULE_IDX(dt_attr_idx)) { 12770 send_attr_ntry(AT_MODULE_IDX(dt_attr_idx)); 12771 dt_idx = fei_imported_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12772 PDG_AT_IDX(AT_MODULE_IDX(dt_attr_idx))); 12773 if (dt_idx) { 12774 pdg_type_idx = fei_get_pdg_type(dt_idx,Basic, 12775 S_tructure, 12776 ATT_NUM_CPNTS(dt_attr_idx)); 12777 pdg_type_tbl[type_idx] = pdg_type_idx; 12778 PDG_AT_IDX(dt_attr_idx) = dt_idx; 12779 PDG_AT_TYP_IDX(dt_attr_idx) = type_idx; 12780 12781 dt_attr_idx = TYP_IDX(type_idx); 12782 12783 while (AT_ATTR_LINK(dt_attr_idx) != NULL_IDX) { 12784 PDG_AT_IDX(dt_attr_idx) = dt_idx; 12785 dt_attr_idx = AT_ATTR_LINK(dt_attr_idx); 12786 } 12787 /* return pdg_type_idx; */ 12788 goto COMPONT; 12789 } 12790 } 12791 # if 0 /*August 2002*/ 12792 flag = ((long) (ATT_SCP_IDX(dt_attr_idx) != curr_scp_idx) 12793 << FEI_NEXT_TYPE_IDX_HOSTED_TYPE); 12794 #endif 12795 12796 #if 0 12797 PDG_DBG_PRINT_START 12798 PDG_DBG_PRINT_C("fei_next_name"); 12799 PDG_DBG_PRINT_D("(1) logical", TRUE); 12800 PDG_DBG_PRINT_END 12801 12802 # ifdef _ENABLE_FEI 12803 cpnt_idx = fei_next_name(TRUE); 12804 # endif 12805 #endif 12806 12807 PDG_DBG_PRINT_START 12808 PDG_DBG_PRINT_C("fei_next_type_idx"); 12809 PDG_DBG_PRINT_LO("(1) flags", flag); 12810 PDG_DBG_PRINT_D("(2) alignment", pdg_align[ATT_ALIGNMENT(dt_attr_idx)]); 12811 PDG_DBG_PRINT_END 12812 12813 # ifdef _ENABLE_FEI 12814 dt_idx = fei_next_type_idx(flag, pdg_align[ATT_ALIGNMENT(dt_attr_idx)]); 12815 # endif 12816 12817 sequence = (ATT_CHAR_SEQ(dt_attr_idx)) ? Seq_Char : Seq_Mixed; 12818 12819 # if defined(GENERATE_WHIRL) 12820 if (ATT_CHAR_SEQ(dt_attr_idx)) { 12821 sequence = Seq_Char; 12822 } 12823 else if (ATT_DCL_NUMERIC_SEQ(dt_attr_idx)) { 12824 sequence = Seq_Numeric; 12825 } 12826 else if (ATT_SEQUENCE_SET(dt_attr_idx)) { 12827 sequence = Seq_Mixed; 12828 } 12829 else { 12830 sequence = Seq_None; 12831 } 12832 # endif 12833 12834 size = CN_INT_TO_C(ATT_STRUCT_BIT_LEN_IDX(dt_attr_idx)); 12835 12836 PDG_DBG_PRINT_START 12837 PDG_DBG_PRINT_C("fei_user_type"); 12838 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(dt_attr_idx)); 12839 PDG_DBG_PRINT_D("(2) ATT_NUM_CPNTS", ATT_NUM_CPNTS(dt_attr_idx)); 12840 #if 0 12841 PDG_DBG_PRINT_D("(3) cpnt_idx", cpnt_idx); 12842 #endif 12843 PDG_DBG_PRINT_LLD("(3) struct size", size); 12844 PDG_DBG_PRINT_S("(4) sequence", p_sequence[sequence]); 12845 PDG_DBG_PRINT_D("(5) dt_idx", dt_idx); 12846 PDG_DBG_PRINT_D("(6) alignment", pdg_align[ATT_ALIGNMENT(dt_attr_idx)]); 12847 PDG_DBG_PRINT_END 12848 12849 # ifdef _ENABLE_FEI 12850 #if 0 12851 if (AT_ORIG_MODULE_IDX(dt_attr_idx)!=NULL_IDX || 12852 (curr_scp_idx!=1)&& (ATT_SCP_IDX(dt_attr_idx)==1)) 12853 fei_user_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12854 ATT_NUM_CPNTS(dt_attr_idx), 12855 cpnt_idx, 12856 size, 12857 sequence, 12858 dt_idx, 12859 pdg_align[ATT_ALIGNMENT(dt_attr_idx)], 12860 TRUE); 12861 else 12862 fei_user_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12863 ATT_NUM_CPNTS(dt_attr_idx), 12864 cpnt_idx, 12865 size, 12866 sequence, 12867 dt_idx, 12868 pdg_align[ATT_ALIGNMENT(dt_attr_idx)], 12869 FALSE); 12870 #else 12871 12872 /* 12873 if ((AT_ORIG_MODULE_IDX(dt_attr_idx)==NULL_IDX) && 12874 (curr_scp_idx==1) && 12875 (ATT_SCP_IDX(dt_attr_idx)==1)) 12876 */ 12877 /* we may don't need this one AT_MODULE_OBJECT(dt_attr_idx)) */ 12878 if ( !nested_attr && 12879 LN_DEF_LOC(dt_attr_idx) && /*definition */ 12880 AT_MODULE_IDX(dt_attr_idx)==NULL_IDX) /*not imported */ 12881 fei_user_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12882 ATT_NUM_CPNTS(dt_attr_idx), 12883 size, 12884 sequence, 12885 dt_idx, 12886 pdg_align[ATT_ALIGNMENT(dt_attr_idx)], 12887 0, /* for AT_MODULE_IDX(dt_attr_idx) */ 12888 TRUE); 12889 12890 else if (nested_attr) 12891 fei_user_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12892 ATT_NUM_CPNTS(dt_attr_idx), 12893 size, 12894 sequence, 12895 dt_idx, 12896 pdg_align[ATT_ALIGNMENT(dt_attr_idx)], 12897 0, 12898 FALSE); 12899 else if (AT_MODULE_IDX(dt_attr_idx)) { 12900 send_attr_ntry(AT_MODULE_IDX(dt_attr_idx)); 12901 fei_user_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12902 ATT_NUM_CPNTS(dt_attr_idx), 12903 size, 12904 sequence, 12905 dt_idx, 12906 pdg_align[ATT_ALIGNMENT(dt_attr_idx)], 12907 PDG_AT_IDX(AT_MODULE_IDX(dt_attr_idx)), 12908 TRUE); 12909 } 12910 else 12911 fei_user_type(AT_OBJ_NAME_PTR(dt_attr_idx), 12912 ATT_NUM_CPNTS(dt_attr_idx), 12913 size, 12914 sequence, 12915 dt_idx, 12916 pdg_align[ATT_ALIGNMENT(dt_attr_idx)], 12917 0, 12918 TRUE); 12919 12920 #endif 12921 # endif 12922 12923 PDG_DBG_PRINT_START 12924 PDG_DBG_PRINT_C("fei_descriptor"); 12925 PDG_DBG_PRINT_D("(1) flags",0); 12926 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 12927 PDG_DBG_PRINT_D("(3) dt_idx", dt_idx); 12928 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[S_tructure]); 12929 PDG_DBG_PRINT_D("(5) aux info",0); 12930 PDG_DBG_PRINT_D("(6) alignment", pdg_align[ATT_ALIGNMENT(dt_attr_idx)]); 12931 PDG_DBG_PRINT_END 12932 # ifdef _ENABLE_FEI 12933 pdg_type_idx = fei_descriptor(0, 12934 Basic, 12935 dt_idx, 12936 S_tructure, 12937 0, 12938 pdg_align[ATT_ALIGNMENT(dt_attr_idx)]); 12939 # endif 12940 PDG_DBG_PRINT_START 12941 PDG_DBG_PRINT_T("(r) type", pdg_type_idx); 12942 PDG_DBG_PRINT_END 12943 12944 pdg_type_tbl[type_idx] = pdg_type_idx; 12945 PDG_AT_IDX(dt_attr_idx) = dt_idx; 12946 PDG_AT_TYP_IDX(dt_attr_idx) = type_idx; 12947 dt_attr_idx = TYP_IDX(type_idx); 12948 12949 while (AT_ATTR_LINK(dt_attr_idx) != NULL_IDX) { 12950 PDG_AT_IDX(dt_attr_idx) = dt_idx; 12951 dt_attr_idx = AT_ATTR_LINK(dt_attr_idx); 12952 } 12953 12954 COMPONT: 12955 12956 PDG_DBG_PRINT_START 12957 PDG_DBG_PRINT_C("fei_next_name"); 12958 PDG_DBG_PRINT_D("(1) logical", TRUE); 12959 PDG_DBG_PRINT_END 12960 12961 # ifdef _ENABLE_FEI 12962 cpnt_idx = fei_next_name(TRUE); 12963 # endif 12964 12965 prev_idx = NULL_IDX; 12966 sn_idx = ATT_FIRST_CPNT_IDX(dt_attr_idx); 12967 12968 do { 12969 attr_idx = SN_ATTR_IDX(sn_idx); 12970 send_attr_ntry(attr_idx); 12971 12972 PDG_DBG_PRINT_START 12973 PDG_DBG_PRINT_C("fei_name"); 12974 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 12975 PDG_DBG_PRINT_S("(2) table", "PDGCS_Member"); 12976 PDG_DBG_PRINT_LD("(3) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 12977 PDG_DBG_PRINT_D("(4) prev_idx", prev_idx); 12978 PDG_DBG_PRINT_D("(5) cpnt_idx", cpnt_idx); 12979 PDG_DBG_PRINT_END 12980 12981 # ifdef _ENABLE_FEI 12982 prev_idx = fei_name(AT_OBJ_NAME_PTR(attr_idx), 12983 Sym_Member, 12984 PDG_AT_IDX(attr_idx), 12985 prev_idx, 12986 cpnt_idx); 12987 # endif 12988 12989 sn_idx = SN_SIBLING_LINK(sn_idx); 12990 12991 if (sn_idx != NULL_IDX) { 12992 PDG_DBG_PRINT_START 12993 PDG_DBG_PRINT_C("fei_next_name"); 12994 PDG_DBG_PRINT_D("(1) logical", TRUE); 12995 PDG_DBG_PRINT_END 12996 12997 # ifdef _ENABLE_FEI 12998 cpnt_idx = fei_next_name(TRUE); 12999 # endif 13000 } 13001 13002 } while (sn_idx != NULL_IDX); 13003 13004 EXIT: 13005 13006 TRACE (Func_Exit, "send_derived_type", NULL); 13007 13008 return(pdg_type_idx); 13009 13010 } /* send_derived_type */ 13011 13012 13013 13014 /******************************************************************************\ 13015 |* *| 13016 |* Description: *| 13017 |* *| 13018 |* Input parameters: *| 13019 |* NONE *| 13020 |* *| 13021 |* Output parameters: *| 13022 |* NONE *| 13023 |* *| 13024 |* Returns: *| 13025 |* NOTHING *| 13026 |* *| 13027 \******************************************************************************/ 13028 static void send_label(int attr_idx) 13029 13030 { 13031 int label_flag; 13032 int label_class = ATL_CLASS(attr_idx); 13033 char *fmt_ptr = NULL; 13034 13035 13036 TRACE (Func_Entry, "send_label", NULL); 13037 13038 if (!ATL_EXECUTABLE(attr_idx) && ATL_CLASS(attr_idx) <= Lbl_User) { 13039 13040 /* Do not send labels that are on non-executable statements */ 13041 13042 return; 13043 } 13044 13045 label_flag = (ATL_ALIGN(attr_idx) << FEI_LABEL_ALGNINST) | 13046 (opt_flags.loopalign << FEI_LABEL_ALGNLOOP); 13047 13048 switch (ATL_CLASS(attr_idx)) { 13049 13050 case Lbl_Construct: 13051 label_class = Lbl_User; 13052 break; 13053 13054 case Lbl_Format: 13055 fmt_ptr = (char *) &CN_CONST(ATL_FORMAT_TMP(attr_idx)); 13056 break; 13057 13058 } /* End switch */ 13059 13060 PDG_DBG_PRINT_START 13061 PDG_DBG_PRINT_C("fei_label"); 13062 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 13063 PDG_DBG_PRINT_O("(2) flags", label_flag); 13064 PDG_DBG_PRINT_S("(3) label class", p_label[label_class]); 13065 13066 /* if fmt_ptr is NULL, Irix's and Linux's fprintf will just print (null), but 13067 * solaris will dump core! Change them all for compatibility. 13068 */ 13069 PDG_DBG_PRINT_S("(4) fmt_ptr", (fmt_ptr == NULL) ? "null" : fmt_ptr); 13070 PDG_DBG_PRINT_S("(5) ATL_DEBUG_CLASS", 13071 p_dbg_label[ATL_DEBUG_CLASS(attr_idx)]); 13072 PDG_DBG_PRINT_END 13073 13074 # ifdef _ENABLE_FEI 13075 PDG_AT_IDX(attr_idx) = fei_label(AT_OBJ_NAME_PTR(attr_idx), 13076 label_flag, 13077 label_class, 13078 fmt_ptr, 13079 ATL_DEBUG_CLASS(attr_idx)); 13080 # endif 13081 13082 TRACE (Func_Exit, "send_label", NULL); 13083 13084 return; 13085 } /* send_label */ 13086 13087 13088 13089 /******************************************************************************\ 13090 |* *| 13091 |* Description: *| 13092 |* *| 13093 |* Input parameters: *| 13094 |* NONE *| 13095 |* *| 13096 |* Output parameters: *| 13097 |* NONE *| 13098 |* *| 13099 |* Returns: *| 13100 |* NOTHING *| 13101 |* *| 13102 \******************************************************************************/ 13103 static void send_label_def(int ir_idx) 13104 { 13105 int attr_idx; 13106 int blockable_idx; 13107 int cache_bypass_count; 13108 int il_idx; 13109 int interchange_idx; 13110 int interchange_level_idx; 13111 boolean keepme; 13112 long64 label_flag = (long64) 0; 13113 int mark_name_idx; 13114 int safe_distance_idx; 13115 int safevl_idx; 13116 int suppress_cnt = 0; 13117 int task_lvl; 13118 int unroll_idx; 13119 13120 13121 TRACE (Func_Entry, "send_label_def", NULL); 13122 13123 if (IR_OPR(ir_idx) == Label_Opr) { 13124 attr_idx = IR_IDX_L(ir_idx); 13125 keepme = (cmd_line_flags.debug_lvl <= Debug_Lvl_2) || 13126 ATL_IN_ASSIGN(attr_idx); 13127 send_attr_ntry(attr_idx); 13128 } 13129 else { 13130 keepme = FALSE; 13131 attr_idx = IR_IDX_R(ir_idx); 13132 label_flag = label_flag | ((long64) 1 << FEI_LABEL_DEF_NAMED_SUPPRESS); 13133 13134 if (IR_IDX_L(ir_idx) == NULL_IDX) { 13135 /* If nothing in the list, make sure that the CNT is zero. */ 13136 IR_LIST_CNT_L(ir_idx) = 0; 13137 } 13138 else { 13139 suppress_cnt = IR_LIST_CNT_L(ir_idx); 13140 } 13141 } 13142 13143 task_lvl = (ATL_NOTASK(attr_idx)) ? Task_Lvl_0: opt_flags.task_lvl; 13144 13145 label_flag |= 13146 ((long64) ATL_IVDEP(attr_idx) << FEI_LABEL_DEF_NAMED_IVDEP)| 13147 ((long64) ATL_FISSIONABLE(attr_idx) << FEI_LABEL_DEF_NAMED_FISSIONABLE)| 13148 ((long64) ATL_FUSABLE(attr_idx) << FEI_LABEL_DEF_NAMED_FUSABLE)| 13149 ((long64) ATL_NOFISSION(attr_idx) << FEI_LABEL_DEF_NAMED_NOFISSION)| 13150 ((long64) ATL_NOFUSION(attr_idx) << FEI_LABEL_DEF_NAMED_NOFUSION)| 13151 ((long64) ATL_FUSION(attr_idx) << FEI_LABEL_DEF_NAMED_FUSION)| 13152 ((long64) ATL_NOINTERCHANGE(attr_idx) 13153 << FEI_LABEL_DEF_NAMED_NOINTERCHANGE)| 13154 ((long64) ATL_NOBLOCKING(attr_idx) << FEI_LABEL_DEF_NAMED_NOBLOCKING)| 13155 ((long64) ATL_AGGRESSIVEINNERLOOPFISSION(attr_idx) 13156 << FEI_LABEL_DEF_NAMED_AGGRESSIVEINNERLOOPFISSION)| 13157 ((long64) ATL_NORECURRENCE(attr_idx)<< FEI_LABEL_DEF_NAMED_NOREDUCE)| 13158 ((long64) ATL_NOVECTOR(attr_idx) << FEI_LABEL_DEF_NAMED_NOVECTOR)| 13159 ((long64) ATL_STREAM(attr_idx) << FEI_LABEL_DEF_NAMED_STREAM)| 13160 ((long64) ATL_PREFERSTREAM(attr_idx) 13161 << FEI_LABEL_DEF_NAMED_PREFERSTREAM)| 13162 ((long64) ATL_PREFERSTREAM_NOCINV(attr_idx)<< 13163 FEI_LABEL_DEF_NAMED_PSTREAM_NOCINV)| 13164 ((long64) ATL_SHORTLOOP(attr_idx) << FEI_LABEL_DEF_NAMED_SHORTLOOP)| 13165 ((long64) ATL_NOVSEARCH(attr_idx) << FEI_LABEL_DEF_NAMED_NOVSEARCH)| 13166 ((long64) ATL_TOP_OF_LOOP(attr_idx) << FEI_LABEL_DEF_NAMED_LOOPCHK)| 13167 ((long64) ATL_INFORM_ONLY(attr_idx) << FEI_LABEL_DEF_NAMED_INFORM_ONLY)| 13168 ((long64) ATL_BL(attr_idx) << FEI_LABEL_DEF_NAMED_DO_BL)| 13169 ((long64) (task_lvl == Task_Lvl_3) << FEI_LABEL_DEF_NAMED_NOSYNCBARR)| 13170 ((long64) (opt_flags.vector_lvl == Vector_Lvl_3) 13171 << FEI_LABEL_DEF_NAMED_EXTTABLES)| 13172 ((long64) (opt_flags.vector_lvl == Vector_Lvl_3) 13173 << FEI_LABEL_DEF_NAMED_EXTTIME)| 13174 ((long64) (AT_REFERENCED(attr_idx) == Not_Referenced) 13175 << FEI_LABEL_DEF_NAMED_NOT_REFERENCED)| 13176 ((long64) ATL_CNCALL(attr_idx) << FEI_LABEL_DEF_NAMED_CONCCALLS)| 13177 ((long64) ATL_PERMUTATION(attr_idx) << FEI_LABEL_DEF_NAMED_PERMUTATION)| 13178 ((long64) ATL_NEXTSCALAR(attr_idx) << FEI_LABEL_DEF_NAMED_NEXTSCALAR)| 13179 ((long64) ATL_SHORTLOOP128(attr_idx) 13180 << FEI_LABEL_DEF_NAMED_SHORTLOOP128)| 13181 ((long64) ATL_PREFERVECTOR(attr_idx)<< FEI_LABEL_DEF_NAMED_SELECT_VEC)| 13182 ((long64) ATL_PREFERTASK(attr_idx) << FEI_LABEL_DEF_NAMED_SELECT_TASK)| 13183 ((long64) ATL_NOTASK(attr_idx) << FEI_LABEL_DEF_NAMED_NOTASK)| 13184 ((long64) ATL_UNROLL_DIR(attr_idx) << FEI_LABEL_DEF_NAMED_UNROLL)| 13185 ((long64) ATL_SPLIT(attr_idx) << FEI_LABEL_DEF_NAMED_STREAMSPLIT)| 13186 ((long64) ATL_PATTERN(attr_idx) << FEI_LABEL_DEF_NAMED_PATTERN)| 13187 ((long64) ATL_CONSTRUCTOR_LOOP(attr_idx) 13188 << FEI_LABEL_DEF_NAMED_CONSTRUCTOR_LOOP)| 13189 ((long64) ATL_CONCURRENT(attr_idx) << FEI_LABEL_DEF_NAMED_CONCURRENT)| 13190 ((long64) ATL_CASE_LABEL(attr_idx) << FEI_LABEL_DEF_NAMED_CASE); 13191 13192 /* List contains directives in this order */ 13193 /* safevl, Unroll, mark name, maxcpus, cache bypass */ 13194 13195 safevl_idx = NULL_IDX; 13196 unroll_idx = NULL_IDX; 13197 mark_name_idx = NULL_IDX; 13198 cache_bypass_count = 0; 13199 safe_distance_idx = NULL_IDX; 13200 blockable_idx = NULL_IDX; 13201 interchange_idx = NULL_IDX; 13202 interchange_level_idx= NULL_IDX; 13203 13204 if (ATL_DIRECTIVE_LIST(attr_idx) != NULL_IDX) { 13205 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Safevl_Dir_Idx; 13206 13207 if (IL_FLD(il_idx) == CN_Tbl_Idx) { 13208 safevl_idx = IL_IDX(il_idx); 13209 } 13210 13211 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Unroll_Dir_Idx; 13212 13213 if (IL_FLD(il_idx) == CN_Tbl_Idx) { /* UNROLL */ 13214 unroll_idx = IL_IDX(il_idx); 13215 } 13216 13217 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Mark_Dir_Idx; 13218 13219 if (IL_FLD(il_idx) == CN_Tbl_Idx) { /* MARK */ 13220 mark_name_idx = IL_IDX(il_idx); 13221 } 13222 13223 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Cache_Bypass_Dir_Idx; 13224 13225 if (IL_FLD(il_idx) == IL_Tbl_Idx) { /* Cache bypass */ 13226 cache_bypass_count = IL_LIST_CNT(il_idx); 13227 il_idx = IL_IDX(il_idx); 13228 13229 while (il_idx != NULL_IDX) { 13230 cvrt_exp_to_pdg(IL_IDX(il_idx), AT_Tbl_Idx); 13231 il_idx = IL_NEXT_LIST_IDX(il_idx); 13232 } 13233 } 13234 13235 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Concurrent_Dir_Idx; 13236 13237 if (IL_FLD(il_idx) == CN_Tbl_Idx) { 13238 safe_distance_idx = IL_IDX(il_idx); 13239 } 13240 13241 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Blockable_Dir_Idx; 13242 13243 if (IL_FLD(il_idx) == CN_Tbl_Idx) { 13244 blockable_idx = IL_IDX(il_idx); 13245 } 13246 13247 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Interchange_Dir_Idx; 13248 13249 if (IL_FLD(il_idx) == CN_Tbl_Idx) { 13250 interchange_idx = IL_IDX(il_idx); 13251 } 13252 13253 il_idx = IL_IDX(ATL_DIRECTIVE_LIST(attr_idx)) + Interchange_Level_Dir_Idx; 13254 13255 if (IL_FLD(il_idx) == CN_Tbl_Idx) { 13256 interchange_level_idx = IL_IDX(il_idx); 13257 } 13258 } 13259 13260 13261 PDG_DBG_PRINT_START 13262 PDG_DBG_PRINT_C("fei_label_def_named"); 13263 PDG_DBG_PRINT_S("AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 13264 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 13265 PDG_DBG_PRINT_LLO("(2) flags", label_flag); 13266 PDG_DBG_PRINT_D("(3) line num", IR_LINE_NUM(ir_idx)); 13267 PDG_DBG_PRINT_D("(4) suppress cnt", suppress_cnt); 13268 PDG_DBG_PRINT_D("(5) keepme", keepme); 13269 PDG_DBG_PRINT_LVD("(7) safevl", (ATL_IVDEP(attr_idx)? 13270 (long) CN_INT_TO_C(safevl_idx):0)); 13271 PDG_DBG_PRINT_LVD("(8) unroll cnt", ((ATL_UNROLL_DIR(attr_idx)) ? 13272 (long) CN_INT_TO_C(unroll_idx) : 1)); 13273 PDG_DBG_PRINT_S("(9) mark name", mark_name_idx == NULL_IDX ? " " : 13274 (char *)&CN_CONST(mark_name_idx)); 13275 PDG_DBG_PRINT_D("(10) cache bypass ct", cache_bypass_count); 13276 PDG_DBG_PRINT_LVD("(11) safe distance", (safe_distance_idx != NULL_IDX ? 13277 (long) CN_INT_TO_C(safe_distance_idx):0)); 13278 PDG_DBG_PRINT_LVD("(12) blockable grp", (blockable_idx != NULL_IDX ? 13279 (long) CN_INT_TO_C(blockable_idx):0)); 13280 PDG_DBG_PRINT_LVD("(13) interchange grp", (interchange_idx != NULL_IDX ? 13281 (long) CN_INT_TO_C(interchange_idx):0)); 13282 PDG_DBG_PRINT_LVD("(13) interchange lvl",(interchange_level_idx != NULL_IDX? 13283 (long) CN_INT_TO_C(interchange_level_idx):0)); 13284 PDG_DBG_PRINT_END 13285 13286 # ifdef _ENABLE_FEI 13287 fei_label_def_named(PDG_AT_IDX(attr_idx), 13288 label_flag, 13289 IR_LINE_NUM(ir_idx), 13290 suppress_cnt, 13291 keepme, 13292 0, 13293 (ATL_IVDEP(attr_idx) ? 13294 (long) CN_INT_TO_C(safevl_idx) : 0), 13295 (ATL_UNROLL_DIR(attr_idx)) ? 13296 (long) CN_INT_TO_C(unroll_idx) : 1, 13297 mark_name_idx == NULL_IDX ? NULL : 13298 (char *) &CN_CONST(mark_name_idx), 13299 cache_bypass_count, 13300 (safe_distance_idx != NULL_IDX) ? 13301 (long) CN_INT_TO_C(safe_distance_idx) : 0, 13302 (blockable_idx != NULL_IDX) ? 13303 (long) CN_INT_TO_C(blockable_idx) : 0, 13304 (interchange_idx != NULL_IDX) ? 13305 (long) CN_INT_TO_C(interchange_idx) : 0, 13306 (interchange_level_idx != NULL_IDX) ? 13307 (long) CN_INT_TO_C(interchange_level_idx) : 0); 13308 # endif 13309 13310 TRACE (Func_Exit, "send_label_def", NULL); 13311 13312 return; 13313 13314 } /* send_label_def */ 13315 13316 13317 13318 /******************************************************************************\ 13319 |* *| 13320 |* Description: *| 13321 |* *| 13322 |* Input parameters: *| 13323 |* NONE *| 13324 |* *| 13325 |* Output parameters: *| 13326 |* NONE *| 13327 |* *| 13328 |* Returns: *| 13329 |* NOTHING *| 13330 |* *| 13331 \******************************************************************************/ 13332 static void send_namelist_group(int ng_attr_idx,int in_model) 13333 13334 { 13335 int attr_idx; 13336 int count; 13337 int name_idx; 13338 INTPTR prev_idx; 13339 int sn_idx; 13340 13341 13342 TRACE (Func_Entry, "send_namelist_group", NULL); 13343 13344 13345 PDG_DBG_PRINT_START 13346 PDG_DBG_PRINT_C("fei_next_name"); 13347 PDG_DBG_PRINT_D("(1) logical", TRUE); 13348 PDG_DBG_PRINT_END 13349 13350 # ifdef _ENABLE_FEI 13351 name_idx = fei_next_name(TRUE); 13352 # endif 13353 13354 prev_idx = NULL_IDX; 13355 sn_idx = ATN_FIRST_NAMELIST_IDX(ng_attr_idx); 13356 count = 0; 13357 13358 do { 13359 attr_idx = SN_ATTR_IDX(sn_idx); 13360 send_attr_ntry(attr_idx); 13361 13362 PDG_DBG_PRINT_START 13363 PDG_DBG_PRINT_C("fei_name"); 13364 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 13365 PDG_DBG_PRINT_S("(2) table", "PDGCS_Namelist"); 13366 PDG_DBG_PRINT_LD("(3) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 13367 PDG_DBG_PRINT_LD("(4) prev_idx", prev_idx); 13368 PDG_DBG_PRINT_D("(5) name_idx", name_idx); 13369 PDG_DBG_PRINT_END 13370 13371 # ifdef _ENABLE_FEI 13372 prev_idx = fei_name(AT_OBJ_NAME_PTR(attr_idx), 13373 Sym_Namelist, 13374 PDG_AT_IDX(attr_idx), 13375 prev_idx, 13376 name_idx); 13377 # endif 13378 13379 count = count + 1; 13380 sn_idx = SN_SIBLING_LINK(sn_idx); 13381 13382 if (sn_idx != NULL_IDX) { 13383 PDG_DBG_PRINT_START 13384 PDG_DBG_PRINT_C("fei_next_name"); 13385 PDG_DBG_PRINT_D("(1) logical", TRUE); 13386 PDG_DBG_PRINT_END 13387 13388 # ifdef _ENABLE_FEI 13389 name_idx = fei_next_name(TRUE); 13390 # endif 13391 } 13392 } while (sn_idx != NULL_IDX); 13393 13394 PDG_DBG_PRINT_START 13395 PDG_DBG_PRINT_C("fei_namelist"); 13396 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(ng_attr_idx)); 13397 PDG_DBG_PRINT_D("(2) count", count); 13398 PDG_DBG_PRINT_LD("(3) prev_idx", prev_idx); 13399 PDG_DBG_PRINT_END 13400 13401 # ifdef _ENABLE_FEI 13402 # if defined(GENERATE_WHIRL) 13403 PDG_AT_IDX(ng_attr_idx) = fei_namelist(AT_OBJ_NAME_PTR(ng_attr_idx), 13404 count, 13405 prev_idx, 13406 in_model); 13407 # endif 13408 # endif 13409 13410 TRACE (Func_Exit, "send_namelist_group", NULL); 13411 13412 return; 13413 13414 } /* send_namelist_group */ 13415 13416 13417 13418 /*****************************************************************************\ 13419 * Description: 13420 * Send interface block's name plus a list of program unit(including dummy 13421 * argumants 13422 * Input parameters : 13423 * attr_idx of the interface block 13424 * Ouput parameters : 13425 * NONE 13426 * Return: 13427 * Nothing 13428 * 13429 ******************************************************************************/ 13430 static void send_interface_list(int ng_attr_idx) 13431 13432 { 13433 int sn_idx; 13434 int kind_interface = 0; 13435 boolean is_imported; 13436 int i; 13437 int kids_count; 13438 13439 13440 TRACE (Func_Entry, "send_interface_list", NULL); 13441 13442 fei_set_in_interface_processing(); 13443 13444 /* This is an interface block that has the same name as one of */ 13445 /* its program units. The program unit has to go through the */ 13446 /* interface. */ 13447 13448 if (ATI_PROC_IDX(ng_attr_idx) != NULL_IDX && 13449 PDG_AT_IDX(ATI_PROC_IDX(ng_attr_idx)) == NULL_IDX ) { 13450 send_procedure(ATI_PROC_IDX(ng_attr_idx), 13451 NULL_IDX, 13452 In_Interface); 13453 13454 } 13455 13456 13457 /* Need to send generic - explicit names if generating debug tbls */ 13458 13459 kids_count = ATI_NUM_SPECIFICS(ng_attr_idx); 13460 sn_idx = ATI_FIRST_SPECIFIC_IDX(ng_attr_idx); 13461 for (i = 0; i < ATI_NUM_SPECIFICS(ng_attr_idx); i++) { 13462 if (AT_MODULE_IDX(SN_ATTR_IDX(sn_idx))==0 && 13463 ATP_PROC(SN_ATTR_IDX(sn_idx)) != Intrin_Proc ){ 13464 send_procedure(SN_ATTR_IDX(sn_idx), 13465 NULL_IDX, 13466 In_Interface); 13467 fei_gen_func_entry(PDG_AT_IDX(SN_ATTR_IDX(sn_idx))); 13468 } 13469 else kids_count--; 13470 13471 sn_idx = SN_SIBLING_LINK(sn_idx); 13472 } 13473 13474 if (ATI_INTERFACE_CLASS(ng_attr_idx) == Defined_Assign_Interface) 13475 kind_interface = 1; 13476 else 13477 if (ATI_INTERFACE_CLASS(ng_attr_idx)>Defined_Interface) 13478 { 13479 if (ATI_DEFINED_OPR(ng_attr_idx)!=Null_Opr) 13480 kind_interface = 2; 13481 else 13482 kind_interface = 3; 13483 } 13484 13485 /* is_imported = AT_MODULE_IDX(ng_attr_idx); */ 13486 if (AT_MODULE_IDX(ng_attr_idx) ) 13487 is_imported = 1; 13488 else 13489 is_imported =0; 13490 13491 # ifdef _ENABLE_FEI 13492 # if defined(GENERATE_WHIRL) 13493 PDG_AT_IDX(ng_attr_idx) = fei_interface(AT_OBJ_NAME_PTR(ng_attr_idx), 13494 kids_count, 13495 kind_interface, 13496 is_imported); 13497 13498 # endif 13499 # endif 13500 13501 13502 TRACE (Func_Exit, "send_interface_list", NULL); 13503 13504 fei_reset_in_interface_processing(); 13505 13506 return; 13507 13508 } /* send_interface_list */ 13509 13510 13511 13512 13513 13514 13515 13516 /******************************************************************************\ 13517 |* *| 13518 |* Description: *| 13519 |* *| 13520 |* Input parameters: *| 13521 |* NONE *| 13522 |* *| 13523 |* Output parameters: *| 13524 |* NONE *| 13525 |* *| 13526 |* Returns: *| 13527 |* NOTHING *| 13528 |* *| 13529 \******************************************************************************/ 13530 static void allocate_pdg_link_tbls(void) 13531 13532 { 13533 register int i; 13534 int new_size; 13535 long *pdg_tbl_base; 13536 13537 13538 TRACE (Func_Entry, "allocate_pdg_link_tbls", NULL); 13539 13540 /* Allocate and clear out the pdg link table. Find the largest table */ 13541 /* and allocate the pdg link table to this size. */ 13542 13543 new_size = (attr_tbl_idx > const_tbl_idx) ? attr_tbl_idx : const_tbl_idx; 13544 new_size = (new_size > stor_blk_tbl_idx) ? new_size : stor_blk_tbl_idx; 13545 new_size = (new_size > type_tbl_idx) ? new_size : type_tbl_idx; 13546 13547 new_size++; /* Do not use entry 0, so increase size by 1 */ 13548 13549 CHECK_TBL_ALLOC_SIZE(pdg_link_tbl, new_size); 13550 13551 pdg_link_tbl_idx = pdg_link_tbl_size - 1; 13552 pdg_tbl_base = (long *) pdg_link_tbl; 13553 13554 for (i = 0; i < (pdg_link_tbl_size * NUM_PDG_WDS); i++) { 13555 pdg_tbl_base[i] = 0; 13556 } 13557 13558 new_size = type_tbl_idx + 1; 13559 13560 CHECK_TBL_ALLOC_SIZE(pdg_type_tbl, new_size); 13561 pdg_type_tbl_idx = pdg_type_tbl_size - 1; 13562 pdg_tbl_base = (long *) pdg_type_tbl; 13563 13564 for (i = 0; i < (pdg_type_tbl_size * NUM_PDG_TYP_WDS); i++) { 13565 pdg_tbl_base[i] = 0; 13566 } 13567 13568 13569 TRACE (Func_Exit, "allocate_pdg_link_tbls", NULL); 13570 13571 return; 13572 13573 } /* allocate_pdg_link_tbls */ 13574 13575 /******************************************************************************\ 13576 |* *| 13577 |* Description: *| 13578 |* *| 13579 |* Input parameters: *| 13580 |* NONE *| 13581 |* *| 13582 |* Output parameters: *| 13583 |* NONE *| 13584 |* *| 13585 |* Returns: *| 13586 |* NOTHING *| 13587 |* *| 13588 \******************************************************************************/ 13589 13590 static void clean_pdg_link_tbls_for_nested_pu(void) 13591 { 13592 register int attr_idx; 13593 13594 TRACE (Func_Entry, "clean_pdg_link_tbls_for_nested_pu", NULL); 13595 13596 for ( attr_idx=1; attr_idx < pdg_link_tbl_size; attr_idx++ ) 13597 { 13598 if (AT_OBJ_CLASS(attr_idx) == Derived_Type || 13599 (AT_OBJ_CLASS(attr_idx) == Data_Obj && 13600 ATD_CLASS(attr_idx) == Struct_Component)) { 13601 PDG_CN_IDX(attr_idx) = 0; 13602 PDG_SB_IDX(attr_idx) = 0 ; 13603 } 13604 else { 13605 /* clean the pdg link table entries */ 13606 PDG_AT_IDX(attr_idx) = 0; 13607 PDG_AT_TYP_IDX(attr_idx) = 0; 13608 PDG_CN_IDX(attr_idx) = 0; 13609 PDG_SB_IDX(attr_idx) = 0 ; 13610 } 13611 } 13612 13613 TRACE (Func_Exit, "clean_pdg_link_tbls_for_nested_pu", NULL); 13614 return; 13615 } 13616 13617 /******************************************************************************\ 13618 |* *| 13619 |* Description: *| 13620 |* *| 13621 |* Input parameters: *| 13622 |* NONE *| 13623 |* *| 13624 |* Output parameters: *| 13625 |* NONE *| 13626 |* *| 13627 |* Returns: *| 13628 |* NOTHING *| 13629 |* *| 13630 \******************************************************************************/ 13631 static void send_attr_ntry(int attr_idx) 13632 13633 { 13634 char str[3000]; 13635 int len; 13636 # if defined(_TARGET32) 13637 int align = HWord_Align; 13638 # else 13639 int align = Word_Align; 13640 # endif 13641 TYPE basic; 13642 long64 bit_len = 0; 13643 int class = 0; 13644 int const_idx; 13645 13646 /* JEFFL - This is being used as a target constant for make_io */ 13647 13648 long_type constant[2]; 13649 int constant_class; 13650 long64 flag; 13651 int i; 13652 int il_idx; 13653 int al_idx; 13654 int defining_attr = NULL_IDX; 13655 int dv_alias = NULL_IDX; 13656 int intent = Intent_Unseen; 13657 long io_type_code_pdg_idx = NULL_IDX; 13658 long64 offset = 0; 13659 int ptr_align = 0; 13660 long ptr_idx = NULL_IDX; 13661 int sb_idx = NULL_IDX; 13662 int child_idx = NULL_IDX; 13663 size_offset_type size; 13664 int sn_idx; 13665 int save_pdg_cn_const; 13666 boolean save_sym_constant_expr; 13667 boolean sym_offset = FALSE; 13668 boolean nested_attr = FALSE; 13669 TYPE type_idx; 13670 static boolean procs_parameter =FALSE; 13671 13672 # ifdef _TARGET_OS_MAX 13673 long_type ii; 13674 # endif 13675 13676 13677 TRACE (Func_Entry, "send_attr_ntry", NULL); 13678 13679 flag = (long64) 0; 13680 13681 if (PDG_AT_IDX(attr_idx) != NULL_IDX ) { 13682 if (AT_OBJ_CLASS(attr_idx) == Derived_Type && 13683 ATT_SCP_IDX(attr_idx)==curr_scp_idx ) { 13684 if (AT_MODULE_IDX(attr_idx)) { 13685 send_attr_ntry(AT_MODULE_IDX(attr_idx)); 13686 fei_gen_st_for_type(AT_OBJ_NAME_PTR(attr_idx), 13687 pdg_type_tbl[PDG_AT_TYP_IDX(attr_idx)], 13688 PDG_AT_IDX(AT_MODULE_IDX(attr_idx))); 13689 } 13690 else 13691 fei_gen_st_for_type(AT_OBJ_NAME_PTR(attr_idx), 13692 pdg_type_tbl[PDG_AT_TYP_IDX(attr_idx)],0); 13693 } 13694 13695 goto EXIT; /* already sent */ 13696 } 13697 13698 if (!AT_IGNORE_ATTR_LINK(attr_idx)) { 13699 13700 if (AT_ATTR_LINK(attr_idx) != NULL_IDX) { 13701 child_idx = attr_idx; 13702 nested_attr = TRUE; 13703 13704 while (AT_ATTR_LINK(attr_idx) != NULL_IDX) { 13705 attr_idx = AT_ATTR_LINK(attr_idx); 13706 } 13707 13708 if (PDG_AT_IDX(attr_idx) != NULL_IDX) { 13709 PDG_AT_IDX(child_idx) = PDG_AT_IDX(attr_idx); 13710 goto EXIT; /* already sent */ 13711 } 13712 } 13713 } 13714 13715 13716 switch (AT_OBJ_CLASS(attr_idx)) { 13717 case Data_Obj: 13718 13719 switch (ATD_CLASS(attr_idx)) { 13720 13721 case Variable: 13722 # ifdef _TARGET_OS_MAX 13723 /* We do not need to call fei_object for this item. */ 13724 if (ATD_SYMBOLIC_CONSTANT(attr_idx)) { 13725 goto EXIT; 13726 } 13727 # endif 13728 13729 if (ATD_FLD(attr_idx) != NO_Tbl_Idx) { 13730 13731 /* Send associated data initialized temps. */ 13732 13733 if (ATD_FLD(attr_idx) == AT_Tbl_Idx) { 13734 send_attr_ntry(ATD_VARIABLE_TMP_IDX(attr_idx)); 13735 } 13736 else if (ATD_FLD(attr_idx) == IL_Tbl_Idx) { 13737 il_idx = ATD_VARIABLE_TMP_IDX(attr_idx); 13738 13739 while (il_idx != NULL_IDX) { 13740 send_attr_ntry(IL_IDX(il_idx)); 13741 il_idx = IL_NEXT_LIST_IDX(il_idx); 13742 } 13743 } 13744 } 13745 if (procs_parameter){ 13746 flag = flag | ((long64) 1 << FEI_OBJECT_PARAMETER) ; 13747 procs_parameter = FALSE; 13748 } 13749 13750 /* Intentional fall through */ 13751 13752 case Atd_Unknown: 13753 class = User_Variable; 13754 13755 if (ATD_AUTOMATIC(attr_idx)) { 13756 send_attr_ntry(ATD_AUTO_BASE_IDX(attr_idx)); 13757 offset = (long64) PDG_AT_IDX(ATD_AUTO_BASE_IDX(attr_idx)); 13758 } 13759 break; 13760 13761 case CRI__Pointee: 13762 class = CRI_Pointee; 13763 send_attr_ntry(ATD_PTR_IDX(attr_idx)); 13764 ptr_idx = PDG_AT_IDX(ATD_PTR_IDX(attr_idx)); 13765 break; 13766 13767 case Function_Result: 13768 if (SB_BLK_TYPE(ATD_STOR_BLK_IDX(attr_idx)) == Formal ) { 13769 13770 /* The Function_Result has become the first dummy argument */ 13771 13772 intent = Intent_Out; 13773 class = Dummy_Arg; 13774 flag = flag | ((long64) 1 << FEI_OBJECT_RESULT_TEMP); 13775 } 13776 else { 13777 class = Function_Rslt; 13778 flag = flag | ((long64) AT_HOST_ASSOCIATED(attr_idx) << 13779 FEI_OBJECT_RESULT_TEMP); 13780 } 13781 break; 13782 13783 case Dummy_Argument: 13784 13785 # ifdef _NAME_SUBSTITUTION_INLINING 13786 if (!AT_IS_DARG(attr_idx)) { 13787 goto EXIT; 13788 } 13789 # endif 13790 13791 class = Dummy_Arg; 13792 flag = flag | ((long64) ATD_SF_DARG(attr_idx) << FEI_OBJECT_SF_DARG); 13793 flag = flag | ((long64) AT_OPTIONAL(attr_idx) << FEI_OBJECT_OPTIONAL); 13794 13795 intent = ATD_INTENT(attr_idx); 13796 if (intent == Intent_Unseen) { 13797 intent = Intent_Inout; 13798 } 13799 break; 13800 13801 case Compiler_Tmp: 13802 if (ATD_SYMBOLIC_CONSTANT(attr_idx)) { 13803 13804 /* This tmp is a placeholder for the symbolic constant. */ 13805 13806 save_sym_constant_expr = symbolic_constant_expr; 13807 symbolic_constant_expr = TRUE; 13808 13809 if (ATD_FLD(attr_idx) == IR_Tbl_Idx && 13810 (IR_OPR(ATD_TMP_IDX(attr_idx)) == Asg_Opr )) { 13811 cvrt_exp_to_pdg(IR_IDX_R(ATD_TMP_IDX(attr_idx)), 13812 IR_FLD_R(ATD_TMP_IDX(attr_idx))); 13813 } 13814 else { 13815 cvrt_exp_to_pdg(ATD_TMP_IDX(attr_idx), 13816 (fld_type) ATD_FLD(attr_idx)); 13817 } 13818 13819 PDG_DBG_PRINT_START 13820 PDG_DBG_PRINT_C("npex_end"); 13821 PDG_DBG_PRINT_END 13822 13823 # ifdef _ENABLE_FEI 13824 PDG_AT_IDX(attr_idx) = npex_end(); 13825 # endif 13826 PDG_DBG_PRINT_START 13827 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 13828 PDG_DBG_PRINT_END 13829 13830 symbolic_constant_expr = save_sym_constant_expr; 13831 13832 goto EXIT; 13833 } 13834 13835 class = Compiler_Temp; 13836 13837 if (ATD_AUTOMATIC(attr_idx)) { 13838 send_attr_ntry(ATD_AUTO_BASE_IDX(attr_idx)); 13839 offset = (long64) PDG_AT_IDX(ATD_AUTO_BASE_IDX(attr_idx)); 13840 } 13841 # if 0 /*August*/ 13842 # if ! (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) && ! defined(_TARGET_OS_MAX) 13843 if (ATD_DEFINING_ATTR_IDX(attr_idx) != NULL_IDX) { 13844 send_attr_ntry(ATD_DEFINING_ATTR_IDX(attr_idx)); 13845 defining_attr = PDG_AT_IDX(ATD_DEFINING_ATTR_IDX(attr_idx)); 13846 } 13847 # endif 13848 # endif 13849 13850 break; 13851 13852 case Constant: 13853 if (ATD_FLD(attr_idx) == AT_Tbl_Idx ) { 13854 /* Aggregate Constant */ 13855 /* change the tmp to a variable */ 13856 13857 insert_init_stmt_for_tmp(ATD_CONST_IDX(attr_idx)); 13858 13859 ATD_CLASS(ATD_CONST_IDX(attr_idx)) = Variable; 13860 13861 AT_MODULE_OBJECT(ATD_CONST_IDX(attr_idx)) = AT_MODULE_OBJECT(attr_idx); 13862 procs_parameter = TRUE; 13863 send_attr_ntry(ATD_CONST_IDX(attr_idx)); 13864 procs_parameter = FALSE; 13865 13866 ATD_CLASS(ATD_CONST_IDX(attr_idx)) = Compiler_Tmp; 13867 goto EXIT; 13868 13869 } 13870 13871 #if 0 13872 if (cmd_line_flags.debug_lvl > Debug_Lvl_2 && 13873 !cmd_line_flags.dwarf_debug) { 13874 goto EXIT; 13875 } 13876 #endif 13877 13878 if (AT_COMPILER_GEND(attr_idx)) { 13879 goto EXIT; 13880 } 13881 13882 /* Pass parameter information for DEBUG symbol tables. They do not */ 13883 /* need compiler generated constants. */ 13884 13885 const_idx = ATD_CONST_IDX(attr_idx); 13886 type_idx = get_basic_type(ATD_TYPE_IDX(attr_idx), 13887 ATD_ALIGNMENT(attr_idx), 13888 attr_idx); 13889 constant_class = 1; 13890 13891 if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character) { 13892 constant_class = 3; 13893 bit_len = CN_INT_TO_C(TYP_IDX(CN_TYPE_IDX(const_idx))); 13894 bit_len = bit_len * CHAR_BIT; 13895 } 13896 else if (TYP_LINEAR(ATD_TYPE_IDX(attr_idx)) == Long_Typeless) { 13897 constant_class = Pattern_Const; 13898 bit_len = TYP_BIT_LEN(CN_TYPE_IDX(const_idx)); 13899 } 13900 13901 if (PDG_CN_IDX(const_idx) == 0) { 13902 if (bit_len == 0 && TYP_TYPE(ATD_TYPE_IDX(attr_idx)) != Character) { 13903 PDG_DBG_PRINT_START 13904 PDG_DBG_PRINT_C("fei_arith_con"); 13905 PDG_DBG_PRINT_T("(1) type", type_idx); 13906 #if defined(_HOST32) && defined(_TARGET64) 13907 PDG_DBG_PRINT_VD("(2) const", CN_CONST(const_idx)); 13908 #else 13909 PDG_DBG_PRINT_LVD("(2) const", CN_CONST(const_idx)); 13910 #endif 13911 PDG_DBG_PRINT_END 13912 13913 # ifdef _ENABLE_FEI 13914 # ifdef _TARGET_OS_MAX 13915 if (TYP_LINEAR(CN_TYPE_IDX(const_idx)) == Complex_4) { 13916 /* pack the complex constant up into one word */ 13917 ii = CN_CONST(const_idx) << 32; 13918 ii |= CP_CONSTANT(CN_POOL_IDX(const_idx) + 1); 13919 13920 PDG_CN_IDX(const_idx) = fei_arith_con(type_idx, (long *)&ii); 13921 } 13922 else { 13923 PDG_CN_IDX(const_idx) = fei_arith_con(type_idx, 13924 (long *)&CN_CONST(const_idx)); 13925 } 13926 # else 13927 PDG_CN_IDX(const_idx) = fei_arith_con(type_idx, 13928 (long *)&CN_CONST(const_idx)); 13929 # endif 13930 # endif 13931 PDG_DBG_PRINT_START 13932 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", PDG_CN_IDX(const_idx)); 13933 PDG_DBG_PRINT_END 13934 } 13935 else { 13936 PDG_DBG_PRINT_START 13937 PDG_DBG_PRINT_C("fei_pattern_con"); 13938 PDG_DBG_PRINT_T("(1) type", type_idx); 13939 #if defined(_HOST32) && defined(_TARGET64) 13940 PDG_DBG_PRINT_VD("(2) const", CN_CONST(const_idx)); 13941 #else 13942 PDG_DBG_PRINT_LVD("(2) const", CN_CONST(const_idx)); 13943 #endif 13944 PDG_DBG_PRINT_LLD("(3) bit length", bit_len); 13945 PDG_DBG_PRINT_END 13946 13947 # ifdef _ENABLE_FEI 13948 PDG_CN_IDX(const_idx) = fei_pattern_con(type_idx, 13949 (char *)&CN_CONST(const_idx), 13950 bit_len); 13951 # endif 13952 PDG_DBG_PRINT_START 13953 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", PDG_CN_IDX(const_idx)); 13954 PDG_DBG_PRINT_END 13955 } 13956 save_pdg_cn_const = 0; 13957 } 13958 else { 13959 save_pdg_cn_const = PDG_CN_IDX(const_idx); 13960 } 13961 13962 13963 PDG_DBG_PRINT_START 13964 PDG_DBG_PRINT_C("fei_smt_parameter"); 13965 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 13966 PDG_DBG_PRINT_T("(2) type", type_idx); 13967 PDG_DBG_PRINT_LD("(3) PDG_CN_IDX", PDG_CN_IDX(const_idx)); 13968 PDG_DBG_PRINT_D("(4) constant_class", constant_class); 13969 PDG_DBG_PRINT_D("(5) line num", AT_DEF_LINE(attr_idx)); 13970 PDG_DBG_PRINT_END 13971 13972 # ifdef _ENABLE_FEI 13973 /* If it the parameter is not get from use-association 13974 and also is not get from the host-association,then 13975 generate a local symbol table entry to record the definition 13976 */ 13977 if ( !nested_attr && 13978 (!AT_MODULE_OBJECT(attr_idx) || 13979 (AT_MODULE_OBJECT(attr_idx) && 13980 AT_ORIG_MODULE_IDX(attr_idx)==NULL_IDX))) 13981 fei_smt_parameter(AT_OBJ_NAME_PTR(attr_idx), 13982 type_idx, 13983 PDG_CN_IDX(const_idx), 13984 constant_class, 13985 AT_DEF_LINE(attr_idx)); 13986 # endif 13987 13988 #if 0 13989 if (cmd_line_flags.dwarf_debug) { 13990 PDG_CN_IDX(const_idx) = save_pdg_cn_const; 13991 } 13992 #endif 13993 13994 PDG_CN_IDX(const_idx) = save_pdg_cn_const; 13995 13996 goto EXIT; 13997 13998 case Struct_Component: 13999 class = Component; 14000 offset = CN_INT_TO_C(ATD_CPNT_OFFSET_IDX(attr_idx)); 14001 break; 14002 14003 } /* End switch */ 14004 14005 if (ATD_OFFSET_ASSIGNED(attr_idx) && 14006 ATD_CLASS(attr_idx) != Struct_Component) { 14007 14008 if (ATD_OFFSET_FLD(attr_idx) == CN_Tbl_Idx) { 14009 offset = CN_INT_TO_C(ATD_OFFSET_IDX(attr_idx)); 14010 14011 # if defined(_TARGET_OS_MAX) || defined(_HOST32) /* JEFFL ?? */ 14012 if (TYP_LINEAR(CN_TYPE_IDX(ATD_OFFSET_IDX(attr_idx))) != Integer_8){ 14013 SIGN_EXTEND(offset); 14014 } 14015 # endif 14016 } 14017 else if (ATD_OFFSET_FLD(attr_idx) == AT_Tbl_Idx) { 14018 send_attr_ntry(ATD_OFFSET_IDX(attr_idx)); 14019 sym_offset = TRUE; 14020 offset = (long64) PDG_AT_IDX(ATD_OFFSET_IDX(attr_idx)); 14021 } 14022 else { 14023 PRINTMSG(AT_DEF_LINE(attr_idx), 1213, Internal, 14024 AT_DEF_COLUMN(attr_idx), 14025 "ATD_OFFSET_IDX", AT_OBJ_NAME_PTR(attr_idx)); 14026 } 14027 } 14028 14029 /* 1 element */ 14030 size = stor_bit_size_of(attr_idx, FALSE, FALSE); 14031 14032 if (size.fld == CN_Tbl_Idx) { 14033 bit_len = CN_INT_TO_C(size.idx); 14034 } 14035 else { 14036 bit_len = F_INT_TO_C(size.constant, TYP_LINEAR(size.type_idx)); 14037 } 14038 14039 sb_idx = ATD_STOR_BLK_IDX(attr_idx); 14040 14041 if (SB_BLK_TYPE(sb_idx) == Based && 14042 child_idx != NULL_IDX && 14043 !ATD_AUTOMATIC(attr_idx)) { 14044 sb_idx = ATD_STOR_BLK_IDX(child_idx); 14045 } 14046 14047 send_stor_blk(sb_idx, &class); 14048 14049 # if defined(GENERATE_WHIRL) 14050 if (ATD_CLASS(attr_idx) == Compiler_Tmp) { 14051 if (sb_idx != NULL_IDX && 14052 SB_SCP_IDX(sb_idx) != NULL_IDX && 14053 SB_SCP_IDX(sb_idx) != curr_scp_idx && 14054 (!SB_HOSTED_STATIC(sb_idx))) { 14055 class = Hosted_Compiler_Temp; 14056 } 14057 } 14058 # endif 14059 14060 type_idx = get_type_desc(attr_idx); 14061 14062 if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == CRI_Ptr) { 14063 ptr_align = Word_Align; 14064 14065 # if defined(_TARGET32) 14066 if (TYP_PTR_INCREMENT(ATD_TYPE_IDX(attr_idx)) == TARGET_BITS_PER_WORD){ 14067 ptr_align = HWord_Align; /* 32 */ 14068 } 14069 # endif 14070 } 14071 else if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == CRI_Ch_Ptr) { 14072 ptr_align = Byte_Align; 14073 } 14074 else { 14075 ptr_align = 0; 14076 14077 if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Character) { 14078 14079 if (ATD_IN_COMMON(attr_idx) || 14080 ATD_CLASS(attr_idx) == Struct_Component || 14081 ATD_CLASS(attr_idx) == Function_Result) { 14082 align = Byte_Align; 14083 } 14084 } 14085 else if (ATD_CLASS(attr_idx) == Function_Result && 14086 TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Structure) { 14087 align = (ATT_CHAR_SEQ(TYP_IDX(ATD_TYPE_IDX(attr_idx)))) ? 14088 Byte_Align : Word_Align; 14089 } 14090 else if (TYP_TYPE(ATD_TYPE_IDX(attr_idx)) == Structure) { 14091 align = pdg_align[ATT_ALIGNMENT(TYP_IDX(ATD_TYPE_IDX(attr_idx)))]; 14092 } 14093 # if defined(_ALIGN_REAL16_TO_16_BYTES) 14094 14095 else if (TYP_LINEAR(ATD_TYPE_IDX(attr_idx)) == Complex_16 || 14096 TYP_LINEAR(ATD_TYPE_IDX(attr_idx)) == Real_16) { 14097 align = FWord_Align; 14098 } 14099 # endif 14100 14101 # if defined(_INTEGER_1_AND_2) 14102 else if (on_off_flags.integer_1_and_2 && 14103 PACK_8_BIT_TEST_CONDITION(ATD_TYPE_IDX(attr_idx))) { 14104 align = 8; /* Byte_Align */ 14105 } 14106 else if (on_off_flags.integer_1_and_2 && 14107 PACK_16_BIT_TEST_CONDITION(ATD_TYPE_IDX(attr_idx))) { 14108 align = 16; /* Parcel_Align */ 14109 } 14110 # endif 14111 14112 # if defined(_TARGET_PACK_HALF_WORD_TYPES) 14113 14114 /* Complex_4 does not go here because we want it aligned on a 64 bit */ 14115 /* boundary for speed. */ 14116 14117 else if (PACK_HALF_WORD_TEST_CONDITION(ATD_TYPE_IDX(attr_idx))) { 14118 align = HWord_Align; 14119 } 14120 # endif 14121 } 14122 14123 if (ATD_CLASS(attr_idx) == Variable || 14124 ATD_CLASS(attr_idx) == Dummy_Argument || 14125 ATD_CLASS(attr_idx) == Function_Result || 14126 ATD_CLASS(attr_idx) == Struct_Component || 14127 ATD_CLASS(attr_idx) == Compiler_Tmp || 14128 ATD_CLASS(attr_idx) == CRI__Pointee) { 14129 14130 make_io_type_code(ATD_TYPE_IDX(attr_idx), constant); 14131 basic = get_basic_type(IO_TYPE_CODE_TYPE, 14132 type_alignment_tbl[IO_TYPE_CODE_TYPE], 14133 NULL_IDX); 14134 14135 PDG_DBG_PRINT_START 14136 PDG_DBG_PRINT_C("fei_arith_con"); 14137 PDG_DBG_PRINT_T("(1) type", basic); 14138 #if defined(_HOST32) && defined(_TARGET64) 14139 PDG_DBG_PRINT_VD("(2) value", constant[0]); 14140 #else 14141 PDG_DBG_PRINT_LVD("(2) value", constant[0]); 14142 #endif 14143 PDG_DBG_PRINT_END 14144 14145 # ifdef _ENABLE_FEI 14146 io_type_code_pdg_idx = fei_arith_con(basic, 14147 (long *)constant); 14148 # endif 14149 PDG_DBG_PRINT_START 14150 PDG_DBG_PRINT_LD("(r) PDG_CN_IDX", io_type_code_pdg_idx); 14151 PDG_DBG_PRINT_END 14152 } 14153 14154 if (ATD_ARRAY_IDX(attr_idx) != NULL_IDX) { 14155 14156 switch (BD_ARRAY_CLASS(ATD_ARRAY_IDX(attr_idx))) { 14157 case Assumed_Size: 14158 flag = flag | ((long64) 1 << FEI_OBJECT_ASSUMED_SIZE); 14159 break; 14160 14161 case Assumed_Shape: 14162 flag = flag | ((long64) 1 << FEI_OBJECT_ASSUMD_SHAPE); 14163 break; 14164 14165 case Deferred_Shape1: 14166 flag = flag | ((long64) 1 << FEI_OBJECT_DEFERRED_SHAPE); 14167 break; 14168 14169 case Deferred_Shape: 14170 flag = flag | ((long64) 1 << FEI_OBJECT_DEFERRED_SHAPE); 14171 break; 14172 } 14173 } 14174 14175 # ifdef _TARGET_OS_MAX 14176 if ((ATD_CLASS(attr_idx) != Compiler_Tmp && 14177 ATD_CACHE_ALIGN(attr_idx)) || 14178 (ATD_STOR_BLK_IDX(attr_idx) != NULL_IDX && 14179 SB_CACHE_ALIGN(ATD_STOR_BLK_IDX(attr_idx)))) { 14180 14181 flag = flag | ((long64) 1 << FEI_OBJECT_CACHE_ALIGN); 14182 } 14183 # endif 14184 14185 if (ATD_IM_A_DOPE(attr_idx) && 14186 ATD_DV_ALIAS(attr_idx) != NULL_IDX) { 14187 send_attr_ntry(AL_ATTR_IDX(ATD_DV_ALIAS(attr_idx))); 14188 dv_alias = PDG_AT_IDX(AL_ATTR_IDX(ATD_DV_ALIAS(attr_idx))); 14189 14190 al_idx = AL_NEXT_IDX(ATD_DV_ALIAS(attr_idx)); 14191 if (al_idx != NULL_IDX) { 14192 send_attr_ntry(AL_ATTR_IDX(al_idx)); 14193 ptr_idx = PDG_AT_IDX(AL_ATTR_IDX(al_idx)); 14194 } 14195 } 14196 14197 if (SB_DEF_MULT_SCPS(sb_idx)) { 14198 ATD_EQUIV(attr_idx) = TRUE; /* this is set by inlining */ 14199 } 14200 14201 14202 flag = (flag | 14203 ((long64) ATD_TARGET(attr_idx) << FEI_OBJECT_TARGET) | 14204 ((long64) ATD_EQUIV(attr_idx) << FEI_OBJECT_EQUIV) | 14205 ((long64) ATD_SAVED(attr_idx) << FEI_OBJECT_SAVED) | 14206 ((long64) ATD_ALLOCATABLE(attr_idx) << FEI_OBJECT_ALLOCATE) | 14207 ((long64) ATD_OFFSET_ASSIGNED(attr_idx) << FEI_OBJECT_OFF_ASSIGNED) | 14208 ((long64) sym_offset << FEI_OBJECT_SYMCON_OFFST) | 14209 ((long64) ATD_AUXILIARY(attr_idx) << FEI_OBJECT_AUXILIARY) | 14210 ((long64) ATD_DATA_INIT(attr_idx) << FEI_OBJECT_INITIALD) | 14211 ((long64) AT_DEFINED(attr_idx) << FEI_OBJECT_DEFINED) | 14212 ((long64) AT_REF_IN_CHILD(attr_idx) << FEI_OBJECT_INNER_REF) | 14213 ((long64) AT_DEF_IN_CHILD(attr_idx) << FEI_OBJECT_INNER_DEF) | 14214 ((long64) ATD_POINTER(attr_idx) << FEI_OBJECT_DV_IS_PTR) | 14215 ((long64) ATD_IM_A_DOPE(attr_idx) << FEI_OBJECT_IS_DOPE_VEC) | 14216 ((long64) ATD_IN_COMMON(attr_idx) << FEI_OBJECT_IN_COMMON) | 14217 ((long64) ATD_PERMUTATION(attr_idx) << FEI_OBJECT_PERMUTATION) | 14218 ((long64) ATD_SYMMETRIC(attr_idx) << FEI_OBJECT_SYMMETRIC) | 14219 ((long64) ATD_PTR_ASSIGNED(attr_idx) << FEI_OBJECT_PTR_ASSIGNED) | 14220 ((long64) AT_ACTUAL_ARG(attr_idx) << FEI_OBJECT_ACTUAL_ARG) | 14221 ((long64) ATD_READ_ONLY_VAR(attr_idx) << FEI_OBJECT_READ_ONLY) | 14222 ((long64) ATD_NOT_PT_UNIQUE_MEM(attr_idx) 14223 << FEI_OBJECT_NOT_PT_TO_UNIQUE_MEM) | 14224 ((long64) AT_NAMELIST_OBJ(attr_idx) << FEI_OBJECT_NAMELIST_ITEM)| 14225 14226 ((long64) AT_MODULE_OBJECT(attr_idx) << FEI_OBJECT_IN_MODULE) | 14227 ((long64) AT_PRIVATE(attr_idx) << FEI_OBJECT_PRIVATE )); 14228 14229 14230 14231 if (AT_MODULE_IDX(attr_idx)!=NULL_IDX || 14232 AT_ORIG_MODULE_IDX(attr_idx)!=NULL_IDX) { 14233 flag = flag | ((long64) 1 << FEI_OBJECT_EXTERNAL); 14234 } 14235 14236 14237 14238 if (ATD_CLASS(attr_idx) == Compiler_Tmp || 14239 ATD_CLASS(attr_idx) == Variable) { 14240 flag = flag | ((long64) 1 << FEI_OBJECT_ADDRTAKEN); 14241 } 14242 14243 if (class == Component) { 14244 PDG_DBG_PRINT_START 14245 PDG_DBG_PRINT_C("fei_member"); 14246 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 14247 PDG_DBG_PRINT_T("(2) type", type_idx); 14248 PDG_DBG_PRINT_LLD("(3) offset", offset); 14249 PDG_DBG_PRINT_LLD("(4) bit_len", bit_len); 14250 PDG_DBG_PRINT_D("(5) storage align", align); 14251 PDG_DBG_PRINT_D("(6) AT_DEF_LINE", AT_DEF_LINE(attr_idx)); 14252 PDG_DBG_PRINT_LLO("(7) flags", flag); 14253 PDG_DBG_PRINT_LD("(8) io descriptor", io_type_code_pdg_idx); 14254 PDG_DBG_PRINT_END 14255 14256 # ifdef _ENABLE_FEI 14257 PDG_AT_IDX(attr_idx) = fei_member(AT_OBJ_NAME_PTR(attr_idx), 14258 type_idx, 14259 offset, 14260 bit_len, 14261 align, 14262 AT_DEF_LINE(attr_idx), 14263 flag, 14264 io_type_code_pdg_idx); 14265 # endif 14266 } 14267 else { 14268 14269 # ifdef _DEBUG 14270 14271 if (dv_alias != NULL_IDX && defining_attr != NULL_IDX) { 14272 PRINTMSG(AT_DEF_LINE(attr_idx), 626, Internal, 14273 AT_DEF_COLUMN(attr_idx), 14274 "dv_alias or defining_attr", 14275 "send_attr_ntry"); 14276 } 14277 # endif 14278 14279 # if 0 /*August*/ 14280 # if ! (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) && ! defined(_TARGET_OS_MAX) 14281 if (dv_alias == NULL_IDX) { 14282 dv_alias = defining_attr; /* These two are overlayed */ 14283 } 14284 # endif 14285 # endif 14286 14287 14288 /* Null terminate the CDIR$ ID string */ 14289 if (class == Name && ATD_TMP_IDX(attr_idx) != NULL_IDX) { 14290 len = strlen((char *)&CN_CONST(ATD_TMP_IDX(attr_idx))); 14291 # ifdef _DEBUG 14292 if (len > 3000) { 14293 PRINTMSG(AT_DEF_LINE(attr_idx), 626, Internal, 14294 AT_DEF_COLUMN(attr_idx), 14295 "a valid length", 14296 "send_attr_ntry"); 14297 } 14298 # endif 14299 strcpy(str, (char *)&CN_CONST(ATD_TMP_IDX(attr_idx)) ); 14300 len = CN_INT_TO_C(TYP_IDX(CN_TYPE_IDX(ATD_TMP_IDX(attr_idx)))); 14301 # ifdef _DEBUG 14302 if (len > 3000) { 14303 PRINTMSG(AT_DEF_LINE(attr_idx), 626, Internal, 14304 AT_DEF_COLUMN(attr_idx), 14305 "a valid length", 14306 "send_attr_ntry"); 14307 } 14308 # endif 14309 str[len] = NULL_CHAR; 14310 } 14311 14312 PDG_DBG_PRINT_START 14313 PDG_DBG_PRINT_C("fei_object"); 14314 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 14315 PDG_DBG_PRINT_T("(2) type", type_idx); 14316 PDG_DBG_PRINT_LLO("(3) flags", flag); 14317 PDG_DBG_PRINT_S("(4) symbol class", p_obj_sym_class[class]); 14318 PDG_DBG_PRINT_S("(5) PDG_SB_IDX", SB_NAME_PTR(sb_idx)); 14319 PDG_DBG_PRINT_D("(6) dv_alias", dv_alias); 14320 PDG_DBG_PRINT_LD("(7) ptr_idx", ptr_idx); 14321 PDG_DBG_PRINT_LLD("(8) offset", offset); 14322 PDG_DBG_PRINT_S("(9) intent", p_intent[intent]); 14323 PDG_DBG_PRINT_LLD("(10) bit_len", bit_len); 14324 PDG_DBG_PRINT_D("(11) pointee align", ptr_align); 14325 PDG_DBG_PRINT_D("(12) storage align", align); 14326 PDG_DBG_PRINT_D("(13) unused", 0); 14327 PDG_DBG_PRINT_LD("(14) io descriptor", io_type_code_pdg_idx); 14328 PDG_DBG_PRINT_D("(15) unused", 0); 14329 PDG_DBG_PRINT_D("(16) AT_DEF_LINE", AT_DEF_LINE(attr_idx)); 14330 PDG_DBG_PRINT_END 14331 14332 # ifdef _ENABLE_FEI 14333 if (AT_MODULE_IDX(attr_idx)) { 14334 send_attr_ntry(AT_MODULE_IDX(attr_idx)); 14335 PDG_AT_IDX(attr_idx) = fei_object(class == Name ? 14336 str : AT_OBJ_NAME_PTR(attr_idx), 14337 type_idx, 14338 flag, 14339 class, 14340 PDG_SB_IDX(sb_idx), 14341 dv_alias, 14342 ptr_idx, 14343 offset, 14344 intent, 14345 bit_len, 14346 ptr_align, 14347 align, 14348 0, 14349 io_type_code_pdg_idx, 14350 0, 14351 AT_DEF_LINE(attr_idx), 14352 PDG_AT_IDX(AT_MODULE_IDX(attr_idx))); 14353 } 14354 else 14355 PDG_AT_IDX(attr_idx) = fei_object(class == Name ? 14356 str : AT_OBJ_NAME_PTR(attr_idx), 14357 type_idx, 14358 flag, 14359 class, 14360 PDG_SB_IDX(sb_idx), 14361 dv_alias, 14362 ptr_idx, 14363 offset, 14364 intent, 14365 bit_len, 14366 ptr_align, 14367 align, 14368 0, 14369 io_type_code_pdg_idx, 14370 0, 14371 AT_DEF_LINE(attr_idx), 14372 0); 14373 # endif 14374 } 14375 14376 PDG_DBG_PRINT_START 14377 PDG_DBG_PRINT_LD("(r) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 14378 PDG_DBG_PRINT_END 14379 break; 14380 14381 case Pgm_Unit: 14382 if (PDG_AT_IDX(attr_idx) == NULL_IDX) { 14383 /* Send procedure decides what to send over and what not to send. */ 14384 send_procedure(attr_idx, 14385 NULL_IDX, /* No alternate entries for Imported calls */ 14386 Imported); 14387 } 14388 break; 14389 14390 case Label: 14391 send_label(attr_idx); 14392 break; 14393 14394 case Interface: 14395 # if 0 14396 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) != Module ) { 14397 14398 /* This is an interface block that has the same name as one of */ 14399 /* its program units. The program unit has to go through the */ 14400 /* interface. */ 14401 14402 if (ATI_PROC_IDX(attr_idx) != NULL_IDX && 14403 PDG_AT_IDX(ATI_PROC_IDX(attr_idx)) == NULL_IDX) { 14404 send_procedure(ATI_PROC_IDX(attr_idx), 14405 NULL_IDX, 14406 Imported); 14407 } 14408 14409 /* Need to send generic - explicit names if generating debug tbls */ 14410 14411 if (cmd_line_flags.debug_lvl <= Debug_Lvl_2) { 14412 sn_idx = ATI_FIRST_SPECIFIC_IDX(attr_idx); 14413 14414 for (i = 0; i < ATI_NUM_SPECIFICS(attr_idx); i++) { 14415 if (AT_REFERENCED(SN_ATTR_IDX(sn_idx)) != Not_Referenced) { 14416 if (PDG_AT_IDX(SN_ATTR_IDX(sn_idx)) == NULL_IDX) { 14417 send_procedure(SN_ATTR_IDX(sn_idx), 14418 NULL_IDX, 14419 Imported); 14420 } 14421 14422 PDG_DBG_PRINT_START 14423 PDG_DBG_PRINT_C("fei_smt_actual_to_generic"); 14424 PDG_DBG_PRINT_LD("(1) PDG_AT_IDX", 14425 PDG_AT_IDX(SN_ATTR_IDX(sn_idx))); 14426 PDG_DBG_PRINT_S("(2) AT_OBJ_NAME", 14427 AT_OBJ_NAME_PTR(attr_idx)); 14428 PDG_DBG_PRINT_END 14429 14430 # ifdef _ENABLE_FEI 14431 fei_smt_actual_to_generic(PDG_AT_IDX(SN_ATTR_IDX(sn_idx)), 14432 AT_OBJ_NAME_PTR(attr_idx)); 14433 # endif 14434 } 14435 sn_idx = SN_SIBLING_LINK(sn_idx); 14436 } 14437 } 14438 } 14439 14440 # endif 14441 /*************************************************************** 14442 * We need to keep interface information in Whirl so we can output 14443 * "interface" block in w2f.f file,we need to add OPR_INTERFACE in 14444 * Whirl,here we have to generate a bounch of OPR_FUNC_ENTRY and 14445 * send all dummy arguments for "OPR_INTERFACE" 14446 ****************************************************************/ 14447 if (AT_MODULE_OBJECT(attr_idx) && 14448 ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) != Module) 14449 ; 14450 else 14451 if (!AT_IS_INTRIN(attr_idx)||ATI_USER_SPECIFIED(attr_idx)) 14452 send_interface_list(attr_idx); 14453 14454 break; 14455 14456 case Derived_Type: 14457 if (ATT_TY_IDX(attr_idx)==NULL_IDX ) { 14458 CLEAR_TBL_NTRY(type_tbl, TYP_WORK_IDX); 14459 TYP_TYPE(TYP_WORK_IDX) = Structure; 14460 TYP_LINEAR(TYP_WORK_IDX) = Structure_Type; 14461 TYP_IDX(TYP_WORK_IDX) = attr_idx; 14462 ATT_TY_IDX(attr_idx) = ntr_derived_type_tbl(); 14463 TBL_REALLOC_CK(pdg_type_tbl, 1);/*need to enlarge pdg_type_tbl */ 14464 14465 if (curr_scp_idx==ATT_SCP_IDX(attr_idx)) 14466 nested_attr = FALSE; 14467 else 14468 nested_attr= TRUE; 14469 14470 send_derived_type(ATT_TY_IDX(attr_idx),nested_attr); 14471 } 14472 14473 goto EXIT; 14474 14475 case Namelist_Grp: 14476 if (ATP_PGM_UNIT(SCP_ATTR_IDX(curr_scp_idx)) != Module ) { 14477 14478 /* send_namelist_group(attr_idx,0); add a argument for external??? */ 14479 14480 if (AT_MODULE_IDX(attr_idx)!=NULL_IDX || 14481 AT_ORIG_MODULE_IDX(attr_idx)!=NULL_IDX) { /* input from a module */ 14482 send_namelist_group(attr_idx,3); 14483 } else 14484 send_namelist_group(attr_idx,0); 14485 } 14486 else { 14487 if (AT_MODULE_IDX(attr_idx)!=NULL_IDX || 14488 AT_ORIG_MODULE_IDX(attr_idx)!=NULL_IDX) { /* input from a module */ 14489 send_namelist_group(attr_idx,3); 14490 } else 14491 send_namelist_group(attr_idx,1); 14492 } 14493 14494 break; 14495 14496 } /* End switch */ 14497 14498 if (child_idx != NULL_IDX) { 14499 PDG_AT_IDX(child_idx) = PDG_AT_IDX(attr_idx); 14500 } 14501 14502 EXIT: 14503 14504 TRACE (Func_Exit, "send_attr_ntry", NULL); 14505 14506 return; 14507 14508 } /* send_attr_ntry */ 14509 14510 14511 /******************************************************************************\ 14512 |* *| 14513 |* Description: *| 14514 |* This does initialization, calls the routines to pass the symbol *| 14515 |* and the IR to PDG. It then does cleanup. *| 14516 |* *| 14517 |* Input parameters: *| 14518 |* NONE *| 14519 |* *| 14520 |* Output parameters: *| 14521 |* NONE *| 14522 |* *| 14523 |* Returns: *| 14524 |* NOTHING *| 14525 |* *| 14526 \******************************************************************************/ 14527 static void send_mod_file_name (void) 14528 14529 { 14530 int fp_idx; 14531 14532 # if defined(_TARGET_OS_MAX) || defined(_TARGET_OS_UNICOS) 14533 long opt_flag; 14534 int pgm_code = 0; 14535 int pgm_data = 0; 14536 # endif 14537 14538 14539 TRACE (Func_Entry, "send_mod_file_name", NULL); 14540 14541 fp_idx = SCP_FILE_PATH_IDX(MAIN_SCP_IDX); 14542 14543 if (!FP_OUTPUT_TO_O(fp_idx)) { 14544 return; 14545 } 14546 14547 14548 # if defined(_TARGET_OS_MAX) || defined(_TARGET_OS_UNICOS) 14549 14550 CREATE_ID(TOKEN_ID(token), "@%%", 3); 14551 COPY_ATTR_NTRY(AT_WORK_IDX, SCP_ATTR_IDX(MAIN_SCP_IDX)); 14552 14553 if (ATP_PGM_UNIT(AT_WORK_IDX) != Module ||TRUE) { /* Inlinable situation */ 14554 14555 14556 CLEAR_VARIANT_ATTR_INFO(AT_WORK_IDX, Pgm_Unit); 14557 ATP_PGM_UNIT(AT_WORK_IDX) = Module; 14558 } 14559 14560 AT_CIF_SYMBOL_ID(AT_WORK_IDX) = 0; 14561 CLEAR_TBL_NTRY(name_pool, NULL_IDX); 14562 14563 name_pool[NULL_IDX].name_long = TOKEN_STR_WD(token, 0); 14564 AT_NAME_IDX(AT_WORK_IDX) = NULL_IDX; 14565 AT_NAME_LEN(AT_WORK_IDX) = 3; 14566 ATP_EXT_NAME_IDX(AT_WORK_IDX) = NULL_IDX; 14567 ATP_EXT_NAME_LEN(AT_WORK_IDX) = 3; 14568 14569 PDG_DBG_PRINT_START 14570 PDG_DBG_PRINT_C("fei_next_func_idx"); 14571 PDG_DBG_PRINT_END 14572 14573 # ifdef _ENABLE_FEI 14574 PDG_AT_IDX(AT_WORK_IDX) = fei_next_func_idx(ATP_PGM_UNIT(AT_WORK_IDX), 14575 ATP_PROC(AT_WORK_IDX), 14576 ATP_ALT_ENTRY(AT_WORK_IDX)); 14577 # endif 14578 14579 send_procedure(AT_WORK_IDX, 14580 NULL_IDX, /* No alt entries or parent procs */ 14581 Definition); 14582 14583 PDG_DBG_PRINT_START 14584 PDG_DBG_PRINT_C("PDGCS_comp_unit"); 14585 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(AT_WORK_IDX)); 14586 PDG_DBG_PRINT_D("(2) unused", 0); 14587 PDG_DBG_PRINT_END 14588 14589 PDGCS_comp_unit(AT_OBJ_NAME_PTR(AT_WORK_IDX), NULL_IDX); 14590 14591 opt_flag = ((long) opt_flags.aggress << PDGCS_NEW_PROC_IGNORE_THROTTLE)| 14592 ((long) opt_flags.pattern << PDGCS_NEW_PROC_PATTERN_MATCHING)| 14593 ((long) (cmd_line_flags.debug_lvl != Debug_Lvl_0) 14594 << PDGCS_NEW_PROC_ELIM_DEAD_CODE)| 14595 ((long) on_off_flags.reciprical_divide 14596 << PDGCS_NEW_PROC_IEEE_RECIPS)| 14597 ((long) cmd_line_flags.runtime_conformance 14598 << PDGCS_NEW_PROC_CONFORM_CHECK)| 14599 ((long) (opt_flags.task_lvl == Task_Lvl_3) 14600 << PDGCS_NEW_PROC_TASK_INNER_LOOPS)| 14601 ((long) cmd_line_flags.do_UDB_checks 14602 << PDGCS_NEW_PROC_DO_UBD_ANALYSIS); 14603 14604 PDG_DBG_PRINT_START 14605 PDG_DBG_PRINT_C("PDGCS_new_proc"); 14606 PDG_DBG_PRINT_D("(1) num ir", 100); 14607 PDG_DBG_PRINT_D("(2) PDG_AT_IDX", PDG_AT_IDX(AT_WORK_IDX)); 14608 PDG_DBG_PRINT_D("(3) alt entries", 0); 14609 PDG_DBG_PRINT_D("(4) scalar level", opt_flags.scalar_lvl); 14610 PDG_DBG_PRINT_D("(5) vector level", opt_flags.vector_lvl); 14611 PDG_DBG_PRINT_D("(6) task level", opt_flags.task_lvl); 14612 PDG_DBG_PRINT_O("(7) flags", opt_flag); 14613 PDG_DBG_PRINT_D("(8) user mobes", 0); 14614 PDG_DBG_PRINT_D("(9) user sades", 0); 14615 PDG_DBG_PRINT_D("(10) pipeline level", opt_flags.pipeline_lvl); 14616 PDG_DBG_PRINT_D("(11) stream level", opt_flags.stream_lvl); 14617 PDG_DBG_PRINT_END 14618 14619 PDGCS_new_proc(100, 14620 PDG_AT_IDX(AT_WORK_IDX), 14621 0, 14622 opt_flags.scalar_lvl, 14623 opt_flags.vector_lvl, 14624 opt_flags.task_lvl, 14625 opt_flag, 14626 0, 14627 0, 14628 opt_flags.pipeline_lvl, 14629 opt_flags.stream_lvl, 14630 TRUE); 14631 14632 PDG_DBG_PRINT_START 14633 PDG_DBG_PRINT_C("PDGCS_do_proc"); 14634 14635 # ifdef _DEBUG 14636 fflush(debug_file); 14637 # endif 14638 14639 PDG_DBG_PRINT_END 14640 14641 PDGCS_do_proc(); 14642 14643 PDG_DBG_PRINT_START 14644 PDG_DBG_PRINT_C("PDGCS_end_procs"); 14645 PDG_DBG_PRINT_D("(1) pgm code", pgm_code); 14646 PDG_DBG_PRINT_D("(2) pgm data", pgm_data); 14647 PDG_DBG_PRINT_END 14648 14649 PDGCS_end_procs(&pgm_code, 14650 &pgm_data); 14651 14652 create_mod_info_tbl(); 14653 output_mod_info_file(); 14654 14655 # endif 14656 14657 if (fp_idx != NULL_IDX) { 14658 PDG_DBG_PRINT_START 14659 PDG_DBG_PRINT_C("fei_module_file"); 14660 PDG_DBG_PRINT_END 14661 14662 # ifdef _ENABLE_FEI 14663 fei_module_file(FP_NAME_PTR(fp_idx)); 14664 # endif 14665 } 14666 14667 # if defined(_TARGET_OS_MAX) || defined(_TARGET_OS_UNICOS) 14668 14669 PDG_DBG_PRINT_START 14670 PDG_DBG_PRINT_C("PDGCS_end_comp_unit"); 14671 PDG_DBG_PRINT_END 14672 14673 PDGCS_end_comp_unit(); 14674 14675 # endif 14676 14677 TRACE (Func_Exit, "send_mod_file_name", NULL); 14678 14679 return; 14680 14681 } /* send_mod_file_name */ 14682 14683 14684 14685 /******************************************************************************\ 14686 |* *| 14687 |* Description: *| 14688 |* Terminate the interface. *| 14689 |* *| 14690 |* Input parameters: *| 14691 |* none *| 14692 |* *| 14693 |* Output parameters: *| 14694 |* none *| 14695 |* *| 14696 |* Returns: nothing *| 14697 |* *| 14698 \******************************************************************************/ 14699 14700 void terminate_PDGCS(void) 14701 14702 { 14703 14704 TRACE (Func_Entry, "terminate_PDGCS", NULL); 14705 14706 if (binary_output || assembly_output) { 14707 PDG_DBG_PRINT_START 14708 PDG_DBG_PRINT_C("PDGCS_terminate"); 14709 PDG_DBG_PRINT_END 14710 14711 # ifdef _ENABLE_FEI 14712 PDGCS_terminate(); 14713 # endif 14714 } 14715 14716 TRACE (Func_Exit, "terminate_PDGCS", NULL); 14717 14718 return; 14719 14720 } /* terminate_PDGCS */ 14721 14722 14723 14724 /******************************************************************************\ 14725 |* *| 14726 |* Description: *| 14727 |* send_darg_list sends the dummy argument list for the given program. *| 14728 |* *| 14729 |* Input parameters: *| 14730 |* pgm_attr_idx -> Index of attr entry for program unit, whose *| 14731 |* dummy args need to be converted. *| 14732 |* darg_pdg_sn_fw_idx -> PDG secondary name table index where the first *| 14733 |* dummy arg should go. *| 14734 |* *| 14735 |* Output parameters: *| 14736 |* NONE *| 14737 |* *| 14738 |* Returns: *| 14739 |* NOTHING *| 14740 |* *| 14741 \******************************************************************************/ 14742 static void send_darg_list(int pgm_attr_idx, 14743 int darg_pdg_sn_fw_idx) 14744 14745 { 14746 int attr_idx; 14747 int darg_idx; 14748 int end_idx; 14749 int prev_idx; 14750 int sn_idx; 14751 14752 14753 TRACE (Func_Entry, "send_darg_list", NULL); 14754 14755 prev_idx = NULL_IDX; 14756 darg_idx = darg_pdg_sn_fw_idx; 14757 end_idx = ATP_NUM_DARGS(pgm_attr_idx) + ATP_FIRST_IDX(pgm_attr_idx); 14758 14759 14760 14761 sn_idx = ATP_FIRST_IDX(pgm_attr_idx); 14762 14763 do { 14764 attr_idx = SN_ATTR_IDX(sn_idx); 14765 14766 if (PDG_AT_IDX(attr_idx) == NULL_IDX) { 14767 if (AT_OBJ_CLASS(attr_idx) == Data_Obj) { 14768 send_attr_ntry(attr_idx); 14769 } 14770 else { 14771 send_dummy_procedure(attr_idx); 14772 } 14773 } 14774 14775 PDG_DBG_PRINT_START 14776 PDG_DBG_PRINT_C("fei_name"); 14777 PDG_DBG_PRINT_S("(1) AT_OBJ_NAME", AT_OBJ_NAME_PTR(attr_idx)); 14778 PDG_DBG_PRINT_S("(2) table", "PDGCS_Object"); 14779 PDG_DBG_PRINT_LD("(3) PDG_AT_IDX", PDG_AT_IDX(attr_idx)); 14780 PDG_DBG_PRINT_D("(4) prev_idx", prev_idx); 14781 PDG_DBG_PRINT_D("(5) darg_idx", darg_idx); 14782 PDG_DBG_PRINT_END 14783 14784 /* This sets prev_idx to the index being used on this call */ 14785 14786 # ifdef _ENABLE_FEI 14787 prev_idx = fei_name(AT_OBJ_NAME_PTR(attr_idx), 14788 Sym_Object, 14789 PDG_AT_IDX(attr_idx), 14790 prev_idx, 14791 darg_idx); 14792 # endif 14793 14794 14795 if (++sn_idx < end_idx) { 14796 PDG_DBG_PRINT_START 14797 PDG_DBG_PRINT_C("fei_next_name"); 14798 PDG_DBG_PRINT_D("(1) logical", TRUE); 14799 PDG_DBG_PRINT_END 14800 14801 # ifdef _ENABLE_FEI 14802 darg_idx = fei_next_name(TRUE); 14803 # endif 14804 } 14805 } 14806 while (sn_idx != end_idx); 14807 14808 TRACE (Func_Exit, "send_darg_list", NULL); 14809 14810 return; 14811 14812 } /* send_darg_list */ 14813 14814 14815 /******************************************************************************\ 14816 |* *| 14817 |* Description: *| 14818 |* On IRIX systems, the alignment can differ for basic types. *| 14819 |* For example if -align32 is specified, some of the real*8 types will *| 14820 |* start on 32 bit boundaries rather than 64 bit boundaries. When this *| 14821 |* happens, a different type descriptor needs to get send across with *| 14822 |* the alternative alignment. *| 14823 |* *| 14824 |* Input parameters: *| 14825 |* NONE *| 14826 |* *| 14827 |* Output parameters: *| 14828 |* NONE *| 14829 |* *| 14830 |* Returns: *| 14831 |* NOTHING *| 14832 |* *| 14833 \******************************************************************************/ 14834 static TYPE send_non_standard_aligned_type(int align, 14835 int type_idx) 14836 { 14837 int aux_info; 14838 int basic_type; 14839 int bit_size; 14840 int flags = 0; 14841 TYPE pdg_type_idx; 14842 14843 14844 TRACE (Func_Entry, "send_non_standard_aligned_type", NULL); 14845 14846 switch (TYP_LINEAR(type_idx)) { 14847 14848 case Integer_1: 14849 bit_size = bit_size_tbl[Integer_1]; 14850 basic_type = Integral; 14851 aux_info = 1; 14852 flags = 2; 14853 break; 14854 14855 case Integer_2: 14856 bit_size = bit_size_tbl[Integer_2]; 14857 basic_type = Integral; 14858 aux_info = 2; 14859 flags = 2; 14860 break; 14861 14862 case Integer_4: 14863 bit_size = bit_size_tbl[Integer_4]; 14864 basic_type = Integral; 14865 aux_info = 4; 14866 flags = 2; 14867 break; 14868 14869 case Integer_8: 14870 bit_size = bit_size_tbl[Integer_8]; 14871 basic_type = Integral; 14872 aux_info = 8; 14873 flags = 2; 14874 14875 # ifdef _TARGET_HAS_FAST_INTEGER 14876 if (opt_flags.set_allfastint_option || 14877 (opt_flags.set_fastint_option && 14878 TYP_DESC(type_idx) == Default_Typed)) { 14879 bit_size = 46; 14880 aux_info = 6; 14881 } 14882 # endif 14883 break; 14884 14885 case Logical_1: 14886 bit_size = bit_size_tbl[Logical_1]; 14887 basic_type = L_ogical; 14888 aux_info = 1; 14889 break; 14890 14891 case Logical_2: 14892 bit_size = bit_size_tbl[Logical_2]; 14893 basic_type = L_ogical; 14894 aux_info = 2; 14895 break; 14896 14897 case Logical_4: 14898 bit_size = bit_size_tbl[Logical_4]; 14899 basic_type = L_ogical; 14900 aux_info = 4; 14901 break; 14902 14903 case Logical_8: 14904 bit_size = bit_size_tbl[Logical_8]; 14905 basic_type = L_ogical; 14906 aux_info = 8; 14907 break; 14908 14909 case Real_4: 14910 bit_size = bit_size_tbl[Real_4]; 14911 basic_type = Floating_Pt; 14912 aux_info = 4; 14913 break; 14914 14915 case Real_8: 14916 bit_size = bit_size_tbl[Real_8]; 14917 basic_type = Floating_Pt; 14918 aux_info = 8; 14919 break; 14920 14921 case Real_16: 14922 bit_size = bit_size_tbl[Real_16]; 14923 basic_type = Floating_Pt; 14924 aux_info = 16; 14925 break; 14926 14927 case Complex_4: 14928 bit_size = bit_size_tbl[Complex_4]; 14929 basic_type = C_omplex; 14930 aux_info = 4; 14931 break; 14932 14933 case Complex_8: 14934 bit_size = bit_size_tbl[Complex_8]; 14935 basic_type = C_omplex; 14936 aux_info = 8; 14937 break; 14938 14939 case Complex_16: 14940 bit_size = bit_size_tbl[Complex_16]; 14941 basic_type = C_omplex; 14942 aux_info = 16; 14943 break; 14944 14945 case CRI_Ch_Ptr_8: 14946 bit_size = bit_size_tbl[CRI_Ch_Ptr_8]; 14947 basic_type = CRI_Pointer_Char; 14948 aux_info = 0; 14949 break; 14950 14951 default: 14952 PRINTMSG(stmt_start_line, 179, Internal, stmt_start_col, 14953 "send_non_standard_aligned_type"); 14954 break; 14955 } 14956 14957 PDG_DBG_PRINT_START 14958 PDG_DBG_PRINT_C("fei_descriptor"); 14959 PDG_DBG_PRINT_O("(1) flags", flags); 14960 PDG_DBG_PRINT_S("(2) table type", p_table_type[Basic]); 14961 PDG_DBG_PRINT_D("(3) bit_size", bit_size); 14962 PDG_DBG_PRINT_S("(4) basic type", p_basic_type[basic_type]); 14963 PDG_DBG_PRINT_D("(5) aux info", aux_info); 14964 PDG_DBG_PRINT_D("(6) alignment", pdg_align[align]); 14965 PDG_DBG_PRINT_END 14966 # ifdef _ENABLE_FEI 14967 pdg_type_idx = fei_descriptor(flags, 14968 Basic, 14969 bit_size, 14970 basic_type, 14971 aux_info, 14972 pdg_align[align]); 14973 # endif 14974 PDG_DBG_PRINT_START 14975 PDG_DBG_PRINT_T("(r) type", pdg_type_idx); 14976 PDG_DBG_PRINT_END 14977 14978 TRACE (Func_Exit, "send_non_standard_aligned_type", NULL); 14979 14980 return(pdg_type_idx); 14981 14982 } /* send_non_standard_aligned_type */
1.7.6.1 
