00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 # include "defines.h"
00040
00041 # include "host.m"
00042 # include "host.h"
00043 # include "target.m"
00044 # include "target.h"
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
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
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
00330 "Context_OpenAD_XXX",
00331 "Context_OpenAD_Dependent",
00332 "Context_OpenAD_Independent",
00333 "Context_OpenAD_Simple"
00334 };
00335
00336 int pdg_align[8] = {0,
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
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
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
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 }
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
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;
00454 }
00455
00456
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 }
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
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
00587
00588
00589
00590
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
00635
00636
00637
00638
00639
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();
00658 create_mod_info_tbl();
00659 output_mod_info_file();
00660 }
00661 else {
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 }
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
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
00723
00724
00725
00726
00727
00728
00729
00730
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 )
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
00764
00765
00766
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
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
00862
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;
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
00877 if (!w2f_types)
00878 send_mod_file_name();
00879 create_mod_info_tbl();
00880 output_mod_info_file();
00881 free_tables();
00882 check_scp = FALSE;
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();
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 }
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
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
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 {
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);
01042 l_idx = IL_NEXT_LIST_IDX(l_idx);
01043 l_idx = IL_NEXT_LIST_IDX(l_idx);
01044 padd = CN_INT_TO_C(IL_IDX(l_idx));
01045 padd = padd - num_chars;
01046 }
01047
01048 if (padd < 0) {
01049
01050
01051
01052
01053
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
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) {
01099 blank_padding(padd, (long64) (num_chars * CHAR_BIT));
01100 }
01101
01102 TRACE (Func_Exit, "push_data_value", NULL);
01103
01104 return;
01105
01106 }
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
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
01135
01136
01137
01138
01139
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;
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
01210
01211
01212
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
01230
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
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 }
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
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
01455
01456
01457
01458
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
01500
01501
01502 if (
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
01512
01513
01514
01515
01516
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
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
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
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 {
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)
01620 if (TYP_LINEAR(CN_TYPE_IDX(ir_idx)) == Complex_4) {
01621
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) {
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
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);
02021 list_idx2 = IL_NEXT_LIST_IDX(list_idx1);
02022 list_idx3 = IL_NEXT_LIST_IDX(list_idx2);
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
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),
03164 IL_FLD(idx));
03165
03166 idx = IL_NEXT_LIST_IDX(idx);
03167 cvrt_exp_to_pdg(IL_IDX(idx),
03168 IL_FLD(idx));
03169
03170 idx = IL_NEXT_LIST_IDX(idx);
03171 cvrt_exp_to_pdg(IL_IDX(idx),
03172 IL_FLD(idx));
03173
03174 idx = IL_NEXT_LIST_IDX(idx);
03175 cvrt_exp_to_pdg(IL_IDX(idx),
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),
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
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
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
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
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
04401 cvrt_exp_to_pdg(IR_IDX_R(ir_idx),
04402 IR_FLD_R(ir_idx));
04403
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
04452 cvrt_exp_to_pdg(IR_IDX_R(ir_idx),
04453 IR_FLD_R(ir_idx));
04454
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
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
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
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:
05788 #ifdef SOURCE_TO_SOURCE
05789 cvrt_exp_to_pdg(IR_IDX_L(ir_idx),
05790 IR_FLD_L(ir_idx));
05791 #endif
05792 cvrt_exp_to_pdg(IR_IDX_R(ir_idx),
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
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
05904 search_idx = IL_NEXT_LIST_IDX(IR_IDX_R(ir_idx));
05905
05906 trip = 1;
05907 while (trip != 4) {
05908 if (trip == 1) {
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) {
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) {
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
05937
05938
05939 GET_LCV_CONST(IL_IDX(IR_IDX_R(ir_idx)),
05940 loc_value[0],
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) {
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);
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 {
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);
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
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
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),
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),
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
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),
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
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)
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
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
06263
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
06303 while (dim > 1) {
06304 next_idx = IL_NEXT_LIST_IDX(next_idx);
06305 dim = dim - 1;
06306 }
06307
06308
06309 dim = BD_RANK(bound_idx);
06310 ss = 0;
06311
06312 # if defined(COARRAY_FORTRAN)
06313
06314
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
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)
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
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
06500
06501 while (dim > 0) {
06502
06503 if (stack_data_object) {
06504 COPY_OPND(l_opnd, IL_OPND(next_idx));
06505
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)
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
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
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
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
07100
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
08698 cvrt_exp_to_pdg(IL_IDX(list_array[0]),
08699 IL_FLD(list_array[0]));
08700
08701
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
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
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
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) {
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
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
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
08956 j = j + 2;
08957 }
08958
08959 if (IL_FLD(list_array[6]) == CN_Tbl_Idx) {
08960
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
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
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
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
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
09306
09307
09308
09309
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
09418
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
10159
10160
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
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
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
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 }
10696
10697
10698
10699
10700
10701
10702
10703
10704
10705
10706
10707
10708
10709
10710
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 }
10746
10747
10748
10749
10750
10751
10752
10753
10754
10755
10756
10757
10758
10759
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 }
10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
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
10853
10854
10855
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),
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,
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 }
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
11214
11215
11216
11217
11218
11219
11220
11221
11222
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
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
11282
11283
11284
11285
11286
11287
11288
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 }
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
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
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 }
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
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
12050
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
12056
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) {
12079
12080 }
12081 else if (SB_MODULE(sb_idx)) {
12082
12083 sb_type = ZModule;
12084 }
12085 else if (sb_type == Static) {
12086 if (SB_HOSTED_STATIC(sb_idx)) {
12087 flag = flag | (1 << FEI_SEG_DUPLICATE);
12088 sb_type = Common;
12089 }
12090 else {
12091 sb_type = Static_Local;
12092 }
12093 }
12094
12095
12096
12097
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
12112
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 }
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
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 }
12288
12289
12290
12291
12292
12293
12294
12295
12296
12297
12298
12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
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
12354
12355
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;
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
12539
12540
12541
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
12552
12553
12554
12555
12556
12557
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
12606
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
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
12655
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
12664
12665
12666
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
12679
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 }
12719
12720
12721
12722
12723
12724
12725
12726
12727
12728
12729
12730
12731
12732
12733
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
12766
12767
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
12788 goto COMPONT;
12789 }
12790 }
12791 # if 0
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
12874
12875
12876
12877
12878 if ( !nested_attr &&
12879 LN_DEF_LOC(dt_attr_idx) &&
12880 AT_MODULE_IDX(dt_attr_idx)==NULL_IDX)
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,
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 }
13011
13012
13013
13014
13015
13016
13017
13018
13019
13020
13021
13022
13023
13024
13025
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
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 }
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
13067
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 }
13086
13087
13088
13089
13090
13091
13092
13093
13094
13095
13096
13097
13098
13099
13100
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
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
13193
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) {
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) {
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) {
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 }
13315
13316
13317
13318
13319
13320
13321
13322
13323
13324
13325
13326
13327
13328
13329
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 }
13415
13416
13417
13418
13419
13420
13421
13422
13423
13424
13425
13426
13427
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
13445
13446
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
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
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 }
13509
13510
13511
13512
13513
13514
13515
13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
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
13541
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++;
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 }
13574
13575
13576
13577
13578
13579
13580
13581
13582
13583
13584
13585
13586
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
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
13620
13621
13622
13623
13624
13625
13626
13627
13628
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
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;
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;
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
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
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
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
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
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
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
13855
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
13883
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
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
13974
13975
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 }
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)
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
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;
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;
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;
14109 }
14110 # endif
14111
14112 # if defined(_TARGET_PACK_HALF_WORD_TYPES)
14113
14114
14115
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;
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
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;
14283 }
14284 # endif
14285 # endif
14286
14287
14288
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
14384 send_procedure(attr_idx,
14385 NULL_IDX,
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
14399
14400
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
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
14443
14444
14445
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);
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
14479
14480 if (AT_MODULE_IDX(attr_idx)!=NULL_IDX ||
14481 AT_ORIG_MODULE_IDX(attr_idx)!=NULL_IDX) {
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) {
14489 send_namelist_group(attr_idx,3);
14490 } else
14491 send_namelist_group(attr_idx,1);
14492 }
14493
14494 break;
14495
14496 }
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 }
14509
14510
14511
14512
14513
14514
14515
14516
14517
14518
14519
14520
14521
14522
14523
14524
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) {
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,
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 }
14682
14683
14684
14685
14686
14687
14688
14689
14690
14691
14692
14693
14694
14695
14696
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 }
14721
14722
14723
14724
14725
14726
14727
14728
14729
14730
14731
14732
14733
14734
14735
14736
14737
14738
14739
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
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 }
14813
14814
14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827
14828
14829
14830
14831
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 }
