|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2 of the GNU General Public License as 00007 published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU General Public License along 00021 with this program; if not, write the Free Software Foundation, Inc., 59 00022 Temple Place - Suite 330, Boston MA 02111-1307, USA. 00023 00024 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00025 Mountain View, CA 94043, or: 00026 00027 http://www.sgi.com 00028 00029 For further information regarding this notice, see: 00030 00031 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00032 00033 */ 00034 00035 00036 /* USMID: "\n@(#)5.0_pl/macros/sytb.m 5.16 09/30/99 15:47:54\n" */ 00037 00038 /**************************\ 00039 |* RESERVED TABLE INDEXES *| 00040 \**************************/ 00041 00042 # define AT_WORK_IDX NULL_IDX /* Attr table work area */ 00043 # define BD_FREE_LIST_IDX NULL_IDX /* Bounds table free list */ 00044 00045 /* WARNING - These must be 1-7. Alot of code has made the asumption that */ 00046 /* rank matches index for these default deferred shape arrays. */ 00047 00048 # define BD_DEFERRED_1_IDX 1 /* Deferred shape - rank 1 */ 00049 # define BD_DEFERRED_2_IDX 2 /* Deferred shape - rank 2 */ 00050 # define BD_DEFERRED_3_IDX 3 /* Deferred shape - rank 3 */ 00051 # define BD_DEFERRED_4_IDX 4 /* Deferred shape - rank 4 */ 00052 # define BD_DEFERRED_5_IDX 5 /* Deferred shape - rank 5 */ 00053 # define BD_DEFERRED_6_IDX 6 /* Deferred shape - rank 6 */ 00054 # define BD_DEFERRED_7_IDX 7 /* Deferred shape - rank 7 */ 00055 00056 # define MAX_NUM_DIMS 7 /* Max # of dimensions we allow. */ 00057 00058 /* If you add a constant macro here, you must change CN_LAST_USED_IDX. */ 00059 00060 # define CN_INTEGER_ZERO_IDX 1 00061 # define CN_INTEGER_ONE_IDX 2 00062 # define CN_INTEGER_TWO_IDX 3 00063 # define CN_INTEGER_THREE_IDX 4 00064 # define CN_INTEGER_NEG_ONE_IDX 5 00065 # define CN_INTEGER_BITS_PER_WORD_IDX 6 00066 # define CN_INTEGER_CHAR_BIT_IDX 7 /* CHAR_BIT from limits.h */ 00067 # define CN_INTEGER_MIN_IDX 8 00068 00069 00070 # define INTRINSIC_SCP_IDX NULL_IDX /* Intrinsic scope. */ 00071 # define MAIN_SCP_IDX 1 /* Scope index of outer program */ 00072 00073 # define NAME_POOL_ZERO_IDX 1 /* The all zero entry - for LN */ 00074 # define NAME_POOL_ONES_IDX 2 /* The all ones entry - for LN */ 00075 00076 # define TYP_WORK_IDX 0 /* Enter type table work area */ 00077 00078 /* The enum Num_Linear_Types gets to the -dp entry in the type tbl. */ 00079 /* It follows all the default linear type entries. */ 00080 00081 # define DOUBLE_PRECISION_TYPE_IDX Num_Linear_Types 00082 # define DOUBLE_COMPLEX_TYPE_IDX Num_Linear_Types + 1 00083 00084 /********************\ 00085 |* SIZES AND LIMITS *| 00086 \********************/ 00087 00088 # ifdef _HOST64 00089 # define NUM_AA_WDS 3 00090 # define NUM_AL_WDS 1 00091 /* # define NUM_AT_WDS 7*/ 00092 # define NUM_AT_WDS 8 00093 # define NUM_BD_WDS 2 00094 # define NUM_BLK_STK_WDS 8 00095 # define NUM_CN_WDS 2 00096 # define OLD_NUM_CN_WDS 1 00097 # define NUM_CP_WDS 1 00098 # define NUM_CS_WDS 1 00099 # define NUM_EQ_WDS 4 00100 # define NUM_FP_WDS 3 00101 # define NUM_GA_WDS 4 00102 # define NUM_GB_WDS 1 00103 # define NUM_GL_WDS 5 00104 # define NUM_GN_WDS 1 00105 # define NUM_HN_WDS 1 00106 # define NUM_IL_WDS 2 00107 # define NUM_IR_WDS 4 00108 # define NUM_LN_WDS 1 00109 # define NUM_ML_WDS 6 00110 # define NUM_NP_WDS 1 00111 # ifdef _WHIRL_HOST64_TARGET64 00112 # define NUM_PDG_WDS 4 00113 # else 00114 # define NUM_PDG_WDS 2 00115 # endif /* _WHIRL_HOST64_TARGET64 */ 00116 # define NUM_RO_WDS 3 00117 # define NUM_SB_WDS 5 00118 # define NUM_SCP_WDS 26 00119 # define NUM_SH_WDS 3 00120 # define NUM_SN_WDS 2 00121 # define NUM_TYP_WDS 2 00122 # else 00123 # define NUM_AA_WDS 6 00124 # define NUM_AL_WDS 2 00125 /*# define NUM_AT_WDS 14 */ 00126 # define NUM_AT_WDS 16 00127 # define NUM_BD_WDS 4 00128 # define NUM_BLK_STK_WDS 16 00129 # define NUM_CN_WDS 4 00130 # define OLD_NUM_CN_WDS 2 00131 # define NUM_CP_WDS 1 00132 # define NUM_CS_WDS 2 00133 # define NUM_EQ_WDS 8 00134 # define NUM_FP_WDS 6 00135 # define NUM_GA_WDS 8 00136 # define NUM_GB_WDS 2 00137 # define NUM_GL_WDS 10 00138 # define NUM_GN_WDS 2 00139 # define NUM_HN_WDS 2 00140 # define NUM_IL_WDS 4 00141 # define NUM_IR_WDS 8 00142 # define NUM_LN_WDS 2 00143 # define NUM_ML_WDS 12 00144 # define NUM_NP_WDS 1 00145 # define NUM_PDG_WDS 4 00146 /* # define NUM_RO_WDS 4 */ 00147 # define NUM_RO_WDS 6 00148 # define NUM_SB_WDS 10 00149 # define NUM_SCP_WDS 52 00150 # define NUM_SH_WDS 6 00151 # define NUM_SN_WDS 4 00152 # define NUM_TYP_WDS 4 00153 # endif 00154 00155 # define SET_POINTER_SIZE (cmd_line_flags.s_pointer8) 00156 00157 # if defined(_DOPE_VECTOR_32_OR_64) 00158 00159 # define DV_DIM_WORD_SIZE ((SET_POINTER_SIZE)? 6 : 3) 00160 # define DV_HD_WORD_SIZE ((SET_POINTER_SIZE)? 12 : 8) 00161 00162 # define DV_BASE_ADDR(DOPE) ((SET_POINTER_SIZE)? \ 00163 (DOPE).ptr64.base_addr : (DOPE).ptr32.base_addr) 00164 # define DV_EL_LEN(DOPE) ((SET_POINTER_SIZE)? \ 00165 (DOPE).ptr64.el_len : (DOPE).ptr32.el_len) 00166 # define DV_ASSOC(DOPE) ((SET_POINTER_SIZE)? \ 00167 (DOPE).ptr64.assoc : (DOPE).ptr32.assoc) 00168 # define DV_PTR_ALLOC(DOPE) ((SET_POINTER_SIZE)? \ 00169 (DOPE).ptr64.ptr_alloc : (DOPE).ptr32.ptr_alloc) 00170 # define DV_P_OR_A(DOPE) ((SET_POINTER_SIZE)? \ 00171 (DOPE).ptr64.p_or_a : (DOPE).ptr32.p_or_a) 00172 # define DV_A_CONTIG(DOPE) ((SET_POINTER_SIZE)? \ 00173 (DOPE).ptr64.a_contig : (DOPE).ptr32.a_contig) 00174 # define DV_NUM_DIMS(DOPE) ((SET_POINTER_SIZE)? \ 00175 (DOPE).ptr64.num_dims : (DOPE).ptr32.num_dims) 00176 # define DV_TYPE_CODE(DOPE) ((SET_POINTER_SIZE)? \ 00177 (DOPE).ptr64.type_code : (DOPE).ptr32.type_code) 00178 # define DV_UNUSED_1(DOPE) ((SET_POINTER_SIZE)? \ 00179 (DOPE).ptr64.unused_1 : (DOPE).ptr32.unused_1) 00180 # define DV_UNUSED_2(DOPE) ((SET_POINTER_SIZE)? \ 00181 (DOPE).ptr64.unused_2 : (DOPE).ptr32.unused_2) 00182 # define DV_UNUSED_3(DOPE) ((SET_POINTER_SIZE)? \ 00183 (DOPE).ptr64.unused_3 : (DOPE).ptr32.unused_3) 00184 # define DV_ORIG_BASE(DOPE) ((SET_POINTER_SIZE)? \ 00185 (DOPE).ptr64.orig_base : (DOPE).ptr32.orig_base) 00186 # define DV_ORIG_SIZE(DOPE) ((SET_POINTER_SIZE)? \ 00187 (DOPE).ptr64.orig_size : (DOPE).ptr32.orig_size) 00188 # define DV_LOW_BOUND(DOPE,IDX) ((SET_POINTER_SIZE)? \ 00189 (DOPE).ptr64.dim[IDX].low_bound : (DOPE).ptr32.dim[IDX].low_bound) 00190 # define DV_EXTENT(DOPE,IDX) ((SET_POINTER_SIZE)? \ 00191 (DOPE).ptr64.dim[IDX].extent : (DOPE).ptr32.dim[IDX].extent) 00192 # define DV_STRIDE_MULT(DOPE,IDX) ((SET_POINTER_SIZE)? \ 00193 (DOPE).ptr64.dim[IDX].stride_mult : (DOPE).ptr32.dim[IDX].stride_mult) 00194 00195 # define DV_SET_BASE_ADDR(DOPE,RHS) \ 00196 { if (SET_POINTER_SIZE)(DOPE).ptr64.base_addr = (RHS); \ 00197 else (DOPE).ptr32.base_addr = (RHS); } 00198 # define DV_SET_EL_LEN(DOPE,RHS) \ 00199 { if (SET_POINTER_SIZE)(DOPE).ptr64.el_len = (RHS); \ 00200 else (DOPE).ptr32.el_len = (RHS); } 00201 # define DV_SET_ASSOC(DOPE,RHS) \ 00202 { if (SET_POINTER_SIZE)(DOPE).ptr64.assoc = (RHS); \ 00203 else (DOPE).ptr32.assoc = (RHS); } 00204 # define DV_SET_PTR_ALLOC(DOPE,RHS) \ 00205 { if (SET_POINTER_SIZE)(DOPE).ptr64.ptr_alloc = (RHS); \ 00206 else (DOPE).ptr32.ptr_alloc = (RHS); } 00207 # define DV_SET_P_OR_A(DOPE,RHS) \ 00208 { if (SET_POINTER_SIZE)(DOPE).ptr64.p_or_a = (RHS); \ 00209 else (DOPE).ptr32.p_or_a = (RHS); } 00210 # define DV_SET_A_CONTIG(DOPE,RHS) \ 00211 { if (SET_POINTER_SIZE)(DOPE).ptr64.a_contig = (RHS); \ 00212 else (DOPE).ptr32.a_contig = (RHS); } 00213 # define DV_SET_NUM_DIMS(DOPE,RHS) \ 00214 { if (SET_POINTER_SIZE)(DOPE).ptr64.num_dims = (RHS); \ 00215 else (DOPE).ptr32.num_dims = (RHS); } 00216 # define DV_SET_TYPE_CODE(DOPE,RHS) \ 00217 { if (SET_POINTER_SIZE)(DOPE).ptr64.type_code = (RHS); \ 00218 else (DOPE).ptr32.type_code = (RHS); } 00219 # define DV_SET_UNUSED_1(DOPE,RHS) \ 00220 { if (SET_POINTER_SIZE)(DOPE).ptr64.unused_1 = (RHS); \ 00221 else (DOPE).ptr32.unused_1 = (RHS); } 00222 # define DV_SET_UNUSED_2(DOPE,RHS) \ 00223 { if (SET_POINTER_SIZE)(DOPE).ptr64.unused_2 = (RHS); \ 00224 else (DOPE).ptr32.unused_2 = (RHS); } 00225 # define DV_SET_UNUSED_3(DOPE,RHS) \ 00226 { if (SET_POINTER_SIZE)(DOPE).ptr64.unused_3 = (RHS); \ 00227 else (DOPE).ptr32.unused_3 = (RHS); } 00228 # define DV_SET_ORIG_BASE(DOPE,RHS) \ 00229 { if (SET_POINTER_SIZE)(DOPE).ptr64.orig_base = (RHS); \ 00230 else (DOPE).ptr32.orig_base = (RHS); } 00231 # define DV_SET_ORIG_SIZE(DOPE,RHS) \ 00232 { if (SET_POINTER_SIZE)(DOPE).ptr64.orig_size = (RHS); \ 00233 else (DOPE).ptr32.orig_size = (RHS); } 00234 # define DV_SET_LOW_BOUND(DOPE,IDX,RHS) \ 00235 { if (SET_POINTER_SIZE)(DOPE).ptr64.dim[IDX].low_bound = (RHS); \ 00236 else (DOPE).ptr32.dim[IDX].low_bound = (RHS); } 00237 # define DV_SET_EXTENT(DOPE,IDX,RHS) \ 00238 { if (SET_POINTER_SIZE)(DOPE).ptr64.dim[IDX].extent = (RHS); \ 00239 else (DOPE).ptr32.dim[IDX].extent = (RHS); } 00240 # define DV_SET_STRIDE_MULT(DOPE,IDX,RHS) \ 00241 { if (SET_POINTER_SIZE)(DOPE).ptr64.dim[IDX].stride_mult = (RHS); \ 00242 else (DOPE).ptr32.dim[IDX].stride_mult = (RHS); } 00243 00244 # else /* _DOPE_VECTOR_32 and DOPE_VECTOR_64 */ 00245 00246 # define DV_DIM_WORD_SIZE 3 /* Size of dope vector dimen */ 00247 # define DV_HD_WORD_SIZE 6 /* Size of dope vector header */ 00248 00249 # define DV_BASE_ADDR(DOPE) (DOPE).base_addr 00250 # define DV_EL_LEN(DOPE) (DOPE).el_len 00251 # define DV_ASSOC(DOPE) (DOPE).assoc 00252 # define DV_PTR_ALLOC(DOPE) (DOPE).ptr_alloc 00253 # define DV_P_OR_A(DOPE) (DOPE).p_or_a 00254 # define DV_A_CONTIG(DOPE) (DOPE).a_contig 00255 # define DV_NUM_DIMS(DOPE) (DOPE).num_dims 00256 # define DV_TYPE_CODE(DOPE) (DOPE).type_code 00257 # define DV_UNUSED_1(DOPE) (DOPE).unused_1 00258 # define DV_UNUSED_2(DOPE) (DOPE).unused_2 00259 # define DV_UNUSED_3(DOPE) (DOPE).unused_3 00260 # define DV_ORIG_BASE(DOPE) (DOPE).orig_base 00261 # define DV_ORIG_SIZE(DOPE) (DOPE).orig_size 00262 # define DV_LOW_BOUND(DOPE,IDX) (DOPE).dim[IDX].low_bound 00263 # define DV_EXTENT(DOPE,IDX) (DOPE).dim[IDX].extent 00264 # define DV_STRIDE_MULT(DOPE,IDX) (DOPE).dim[IDX].stride_mult 00265 00266 00267 # define DV_SET_BASE_ADDR(DOPE,RHS) (DOPE).base_addr = (RHS) 00268 # define DV_SET_EL_LEN(DOPE,RHS) (DOPE).el_len = (RHS) 00269 # define DV_SET_ASSOC(DOPE,RHS) (DOPE).assoc = (RHS) 00270 # define DV_SET_PTR_ALLOC(DOPE,RHS) (DOPE).ptr_alloc = (RHS) 00271 # define DV_SET_P_OR_A(DOPE,RHS) (DOPE).p_or_a = (RHS) 00272 # define DV_SET_A_CONTIG(DOPE,RHS) (DOPE).a_contig = (RHS) 00273 # define DV_SET_NUM_DIMS(DOPE,RHS) (DOPE).num_dims = (RHS) 00274 # define DV_SET_TYPE_CODE(DOPE,RHS) (DOPE).type_code = (RHS) 00275 # define DV_SET_UNUSED_1(DOPE,RHS) (DOPE).unused_1 = (RHS) 00276 # define DV_SET_UNUSED_2(DOPE,RHS) (DOPE).unused_2 = (RHS) 00277 # define DV_SET_UNUSED_3(DOPE,RHS) (DOPE).unused_3 = (RHS) 00278 # define DV_SET_ORIG_BASE(DOPE,RHS) (DOPE).orig_base = (RHS) 00279 # define DV_SET_ORIG_SIZE(DOPE,RHS) (DOPE).orig_size = (RHS) 00280 # define DV_SET_LOW_BOUND(DOPE,IDX,RHS) (DOPE).dim[IDX].low_bound = (RHS) 00281 # define DV_SET_EXTENT(DOPE,IDX,RHS) (DOPE).dim[IDX].extent = (RHS) 00282 # define DV_SET_STRIDE_MULT(DOPE,IDX,RHS) (DOPE).dim[IDX].stride_mult = (RHS) 00283 # endif 00284 00285 # define MAX_GENERATED_LABELS 99999 /* Max num compiler gen'd lbls*/ 00286 # define MAX_IMPL_CHS 26 /* number of ASCII characters */ 00287 # define MAX_ALTERNATE_ENTRIES 65535 /* Max num alt entries. */ 00288 00289 00290 /********************************************************\ 00291 |* NOTE: FIELD_BITS ARE BIT SIZES FOR THE VARIOUS IDX *| 00292 |* FIELDS FOR ALL TABLES. THESE MUST BE KEPT UP TO *| 00293 |* DATE TO CHECK FOR OVERFLOW OF THESE IDX FIELDS. THEY *| 00294 |* REPRESENT THE SMALLEST BIT LENGTH OF ALL THE IDX *| 00295 |* FIELDS FOR EACH TABLE TYPE. *| 00296 \********************************************************/ 00297 00298 # define BD_LAST_USED_IDX 7 /* last reserved index */ 00299 # define CN_LAST_USED_IDX 8 00300 # define CP_LAST_USED_IDX 7 /* last reserved index */ 00301 00302 # define CS_LAST_USED_IDX 1000 /* Must be the same as the initial */ 00303 /* size of the const_search_tbl. */ 00304 00305 # define NP_LAST_USED_IDX 2 /* last reserved index */ 00306 # define TYP_LAST_USED_IDX Num_Linear_Types + 1 /* 2 extra entries */ 00307 00308 # define MAX_INTRIN_TBL_SIZE 13400 /* max entries in intrinsic table */ 00309 00310 # define MAX_INTRIN_MAP_SIZE 59 /* max entries in intrinsic map */ 00311 00312 # define MAX_INLINE_ARGS 256 /* max actual args allowed on a */ 00313 /* call to be inlined */ 00314 00315 # define MAX_INLINE_LABELS 1000 /* max number of labels allowed in */ 00316 /* a routine being inlined */ 00317 00318 # define MAX_INLINE_IR 100000 /* max number of IR entries allowed */ 00319 /* in a given routine */ 00320 00321 # define MAX_INLINED_ROUTINES 1000 /* max number of distinct routines */ 00322 /* inlined with a given routine */ 00323 00324 00325 /******************************\ 00326 |* OBJECT REPLACEMENT STRINGS *| 00327 \******************************/ 00328 00329 # define STORAGE_WORD_SIZE(BIT_SIZE) (TARGET_BITS_TO_WORDS((BIT_SIZE))) 00330 00331 00332 00333 /* ATTRIBUTE TABLE */ 00334 00335 /* Common attribute definitions for all object classes */ 00336 00337 00338 # define AT_ACCESS_SET(IDX) attr_aux_tbl[IDX].fld.access_set 00339 # define AT_ACTUAL_ARG(IDX) attr_tbl[IDX].fld.passed_as_arg 00340 # define AT_ALT_DARG(IDX) attr_tbl[IDX].fld.alt_darg 00341 # define AT_ARG_TO_KIND(IDX) attr_aux_tbl[IDX].fld.arg_to_kind 00342 # define AT_ATTR_LINK(IDX) attr_tbl[IDX].fld.attr_link 00343 # define AT_CIF_DONE(IDX) attr_aux_tbl[IDX].fld.cif_done 00344 # define AT_CIF_IN_USAGE_REC(IDX) attr_aux_tbl[IDX].fld.cif_usage_rec 00345 # define AT_CIF_SYMBOL_ID(IDX) attr_aux_tbl[IDX].fld.cif_sym_id 00346 # define AT_CIF_USE_IN_BND(IDX) attr_aux_tbl[IDX].fld.cif_use_in_bnd 00347 # define AT_COMPILER_GEND(IDX) attr_tbl[IDX].fld.compiler_gend 00348 # define AT_DCL_ERR(IDX) attr_tbl[IDX].fld.dcl_err 00349 # define AT_DEF_LINE(IDX) attr_aux_tbl[IDX].fld.def_line 00350 # define AT_DEF_COLUMN(IDX) attr_aux_tbl[IDX].fld.def_column 00351 # define AT_DEF_IN_CHILD(IDX) attr_tbl[IDX].fld.def_in_child 00352 # define AT_DEFINED(IDX) attr_tbl[IDX].fld.defined 00353 # define AT_ELEMENTAL_INTRIN(IDX) attr_tbl[IDX].fld.elemental_intrin 00354 # define AT_HOST_ASSOCIATED(IDX) attr_tbl[IDX].fld.host_associated 00355 # define AT_IGNORE_ATTR_LINK(IDX) attr_tbl[IDX].fld.ignore_attr_link 00356 # define AT_IS_DARG(IDX) attr_tbl[IDX].fld.is_darg 00357 # define AT_IS_INTRIN(IDX) attr_tbl[IDX].fld.is_intrin 00358 # define AT_LOCKED_IN(IDX) attr_aux_tbl[IDX].fld.locked_in 00359 # define AT_MODULE_IDX(IDX) attr_tbl[IDX].fld.module_idx 00360 # define AT_MODULE_OBJECT(IDX) attr_tbl[IDX].fld.module_object 00361 # define AT_NAME_IDX(IDX) attr_tbl[IDX].fld.name_idx 00362 # define AT_NAME_LEN(IDX) attr_tbl[IDX].fld.length 00363 # define AT_NAMELIST_OBJ(IDX) attr_tbl[IDX].fld.namelist_obj 00364 # define AT_NOT_VISIBLE(IDX) attr_tbl[IDX].fld.not_visible 00365 # define AT_OBJ_CLASS(IDX) attr_tbl[IDX].fld.object_class 00366 # define AT_OBJ_NAME(IDX) name_pool[AT_NAME_IDX(IDX)].name_char 00367 # define AT_OBJ_NAME_LONG(IDX) &(name_pool[AT_NAME_IDX(IDX)].name_long) 00368 # define AT_OBJ_NAME_PTR(IDX) &name_pool[AT_NAME_IDX(IDX)].name_char 00369 # define AT_OPTIONAL(IDX) attr_tbl[IDX].fld.optional 00370 # define AT_ORIG_MODULE_IDX(IDX) attr_tbl[IDX].fld.orig_module_idx 00371 # define AT_ORIG_NAME_IDX(IDX) attr_tbl[IDX].fld.orig_name_idx 00372 # define AT_ORIG_NAME_LEN(IDX) attr_tbl[IDX].fld.orig_name_len 00373 # define AT_ORIG_NAME_PTR(IDX) &name_pool[AT_ORIG_NAME_IDX(IDX)].name_char 00374 # define AT_ORIG_NAME(IDX) name_pool[AT_ORIG_NAME_IDX(IDX)].name_char 00375 # define AT_ORIG_NAME_LONG(IDX) &(name_pool[AT_ORIG_NAME_IDX(IDX)].name_long) 00376 # define AT_PRIVATE(IDX) attr_tbl[IDX].fld.private_access 00377 # define AT_REF_IN_CHILD(IDX) attr_tbl[IDX].fld.ref_in_child 00378 # define AT_REFERENCED(IDX) attr_tbl[IDX].fld.referenced 00379 # define AT_SEMANTICS_DONE(IDX) attr_aux_tbl[IDX].fld.semantics_done 00380 # define AT_TYPED(IDX) attr_tbl[IDX].fld.typed 00381 # define AT_USE_ASSOCIATED(IDX) attr_tbl[IDX].fld.use_associated 00382 00383 /* Remove in 5.0 */ 00384 00385 # define OLD_AT_HOST_ASSOCIATED(IDX) attr_tbl[IDX].old.host_associated 00386 # define OLD_AT_MODULE_IDX(IDX) attr_tbl[IDX].old.module_idx 00387 # define OLD_AT_MODULE_OBJECT(IDX) attr_tbl[IDX].old.module_object 00388 # define OLD_AT_NOT_VISIBLE(IDX) attr_tbl[IDX].old.not_visible 00389 # define OLD_AT_OBJ_CLASS(IDX) attr_tbl[IDX].old.object_class 00390 # define OLD_AT_USE_ASSOCIATED(IDX) attr_tbl[IDX].old.use_associated 00391 00392 00393 00394 /* Remove in 5.0 */ 00395 /* Cannot variant check these, because AT_OBJ_CLASS has moved */ 00396 00397 # define OLD_ATD_ALIGN_SYMBOL(IDX) attr_tbl[IDX].old.flag13 00398 # define OLD_ATD_ARRAY_IDX(IDX) attr_tbl[IDX].old.field5 00399 # define OLD_ATD_DISTRIBUTION_IDX(IDX) attr_tbl[IDX].old.field14 00400 # define OLD_ATD_FILL_SYMBOL(IDX) attr_tbl[IDX].old.flag14 00401 # define OLD_ATD_OFFSET_ASSIGNED(IDX) attr_tbl[IDX].old.flag16 00402 # define OLD_ATD_PE_ARRAY_IDX(IDX) attr_tbl[IDX].old.field15 00403 # define OLD_ATD_TYPE_IDX(IDX) attr_tbl[IDX].old.field1 00404 # define OLD_ATI_NUM_SPECIFICS(IDX) attr_tbl[IDX].old.field5 00405 # define OLD_ATL_CYCLE_LBL(IDX) attr_tbl[IDX].old.flag15 00406 # define OLD_ATL_DIRECTIVE_LIST(IDX) attr_tbl[IDX].fld2.field23 00407 # define OLD_ATL_NOTASK(IDX) attr_tbl[IDX].old.flag14 00408 # define OLD_ATL_PREFERVECTOR(IDX) attr_tbl[IDX].old.flag16 00409 # define OLD_ATL_TOP_OF_LOOP(IDX) attr_tbl[IDX].old.flag13 00410 # define OLD_ATP_EXPL_ITRFC(IDX) attr_tbl[IDX].old.flag14 00411 # define OLD_ATP_EXTERNAL_INTRIN(IDX) attr_tbl[IDX].old.flag16 00412 # define OLD_ATP_EXTRA_DARG(IDX) attr_tbl[IDX].old.flag15 00413 # define OLD_ATP_NUM_DARGS(IDX) attr_tbl[IDX].old.field5 00414 # define OLD_ATP_MOD_PATH_LEN(IDX) attr_tbl[IDX].old.field6 00415 # define OLD_ATP_SAVE_ALL(IDX) attr_tbl[IDX].old.flag13 00416 00417 /* Definitions for data object class */ 00418 00419 # ifdef _DEBUG 00420 # define ATD_ALIGN_SYMBOL(IDX) \ 00421 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00422 attr_tbl : sytb_var_error("ATD_ALIGN_SYMBOL", IDX)) \ 00423 [IDX].fld.flag21 00424 # else 00425 # define ATD_ALIGN_SYMBOL(IDX) attr_tbl[IDX].fld.flag21 00426 # endif 00427 00428 # ifdef _DEBUG 00429 # define ATD_ALIGNMENT(IDX) \ 00430 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00431 attr_tbl : sytb_var_error("ATD_ALIGNMENT", IDX)) \ 00432 [IDX].fld2.alignment 00433 # else 00434 # define ATD_ALIGNMENT(IDX) attr_tbl[IDX].fld2.alignment 00435 # endif 00436 00437 # ifdef _DEBUG 00438 # define ATD_ALLOCATABLE(IDX) \ 00439 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00440 attr_tbl : sytb_var_error("ATD_ALLOCATABLE", IDX)) \ 00441 [IDX].fld.flag6 00442 # else 00443 # define ATD_ALLOCATABLE(IDX) attr_tbl[IDX].fld.flag6 00444 # endif 00445 00446 /* 00447 # ifdef _DEBUG 00448 # define ATD_ARRAY_IDX(IDX) \ 00449 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00450 attr_tbl : sytb_var_error("ATD_ARRAY_IDX", IDX)) \ 00451 [IDX].fld.field1 00452 # else 00453 */ 00454 # define ATD_ARRAY_IDX(IDX) attr_tbl[IDX].fld.field1 00455 /* # endif */ 00456 00457 # ifdef _DEBUG 00458 # define ATD_ASG_TMP(IDX) \ 00459 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00460 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 00461 attr_tbl : sytb_var_error("ATD_ASG_TMP", IDX)) \ 00462 [IDX].fld.flag49 00463 # else 00464 # define ATD_ASG_TMP(IDX) attr_tbl[IDX].fld.flag49 00465 # endif 00466 00467 # ifdef _DEBUG 00468 # define ATD_ASSIGN_TMP_IDX(IDX) \ 00469 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00470 attr_tbl[IDX].fld.secondary_info == Variable) ? \ 00471 attr_tbl : sytb_var_error("ATD_ASSIGN_TMP_IDX", IDX)) \ 00472 [IDX].fld.field8 00473 # else 00474 # define ATD_ASSIGN_TMP_IDX(IDX) attr_tbl[IDX].fld.field8 00475 # endif 00476 00477 # ifdef _DEBUG 00478 /* This checks ATD_AUTOMATIC */ 00479 # define ATD_AUTO_BASE_IDX(IDX) \ 00480 ((AT_OBJ_CLASS(IDX) == Data_Obj && attr_tbl[IDX].fld.flag12) ? \ 00481 attr_tbl : sytb_var_error("ATD_AUTO_BASE_IDX", IDX)) \ 00482 [IDX].fld.field13 00483 # else 00484 # define ATD_AUTO_BASE_IDX(IDX) attr_tbl[IDX].fld.field13 00485 # endif 00486 00487 # ifdef _DEBUG 00488 # define ATD_AUTOMATIC(IDX) \ 00489 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00490 attr_tbl : sytb_var_error("ATD_AUTOMATIC", IDX)) \ 00491 [IDX].fld.flag12 00492 # else 00493 # define ATD_AUTOMATIC(IDX) attr_tbl[IDX].fld.flag12 00494 # endif 00495 00496 # ifdef _DEBUG 00497 # define ATD_AUXILIARY(IDX) \ 00498 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00499 attr_tbl : sytb_var_error("ATD_AUXILIARY", IDX)) \ 00500 [IDX].fld.flag9 00501 # else 00502 # define ATD_AUXILIARY(IDX) attr_tbl[IDX].fld.flag9 00503 # endif 00504 00505 # ifdef _DEBUG 00506 # define ATD_BOUNDS_CHECK(IDX) \ 00507 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00508 attr_tbl : sytb_var_error("ATD_BOUNDS_CHECK", IDX)) \ 00509 [IDX].fld.flag31 00510 # else 00511 # define ATD_BOUNDS_CHECK(IDX) attr_tbl[IDX].fld.flag31 00512 # endif 00513 00514 # ifdef _DEBUG 00515 # define ATD_CACHE_ALIGN(IDX) \ 00516 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00517 attr_tbl : sytb_var_error("ATD_CACHE_ALIGN", IDX)) \ 00518 [IDX].fld.flag26 00519 # else 00520 # define ATD_CACHE_ALIGN(IDX) attr_tbl[IDX].fld.flag26 00521 # endif 00522 00523 # ifdef _DEBUG 00524 # define ATD_CACHE_BYPASS_ARRAY(IDX) \ 00525 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00526 attr_tbl : sytb_var_error("ATD_CACHE_BYPASS_ARRAY", IDX)) \ 00527 [IDX].fld.flag39 00528 # else 00529 # define ATD_CACHE_BYPASS_ARRAY(IDX) attr_tbl[IDX].fld.flag39 00530 # endif 00531 00532 00533 # ifdef _DEBUG 00534 # define ATD_CACHE_NOALLOC(IDX) \ 00535 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00536 attr_tbl : sytb_var_error("ATD_CACHE_NOALLOC", IDX)) \ 00537 [IDX].fld.flag43 00538 # else 00539 # define ATD_CACHE_NOALLOC(IDX) attr_tbl[IDX].fld.flag43 00540 # endif 00541 00542 00543 # ifdef _DEBUG 00544 # define ATD_CHAR_LEN_IN_DV(IDX) \ 00545 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00546 attr_tbl : sytb_var_error("ATD_CHAR_LEN_IN_DV", IDX)) \ 00547 [IDX].fld.flag11 00548 # else 00549 # define ATD_CHAR_LEN_IN_DV(IDX) attr_tbl[IDX].fld.flag11 00550 # endif 00551 00552 00553 # ifdef _DEBUG 00554 # define ATD_CLASS(IDX) \ 00555 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00556 attr_tbl : sytb_var_error("ATD_CLASS", IDX)) \ 00557 [IDX].fld.secondary_info 00558 # else 00559 # define ATD_CLASS(IDX) attr_tbl[IDX].fld.secondary_info 00560 # endif 00561 00562 # ifdef _DEBUG 00563 # define ATD_CONST_IDX(IDX) \ 00564 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00565 attr_tbl[IDX].fld.secondary_info == Constant) ? \ 00566 attr_tbl : sytb_var_error("ATD_CONST_IDX", IDX)) \ 00567 [IDX].fld.field4 00568 # else 00569 # define ATD_CONST_IDX(IDX) attr_tbl[IDX].fld.field4 00570 # endif 00571 00572 # ifdef _DEBUG 00573 # define ATD_COPY_ASSUMED_SHAPE(IDX) \ 00574 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00575 attr_tbl : sytb_var_error("ATD_COPY_ASSUMED_SHAPE", IDX)) \ 00576 [IDX].fld.flag36 00577 # else 00578 # define ATD_COPY_ASSUMED_SHAPE(IDX) attr_tbl[IDX].fld.flag36 00579 # endif 00580 00581 # ifdef _DEBUG 00582 # define ATD_CPNT_INIT_IDX(IDX) \ 00583 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00584 attr_tbl[IDX].fld.secondary_info == Struct_Component) ? \ 00585 attr_tbl : sytb_var_error("ATD_CPNT_INIT_IDX", IDX)) \ 00586 [IDX].fld.field4 00587 # else 00588 # define ATD_CPNT_INIT_IDX(IDX) attr_tbl[IDX].fld.field4 00589 # endif 00590 00591 # ifdef _DEBUG 00592 # define ATD_CPNT_OFFSET_IDX(IDX) \ 00593 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00594 attr_tbl[IDX].fld.secondary_info == Struct_Component) ? \ 00595 attr_tbl : sytb_var_error("ATD_CPNT_OFFSET_IDX", IDX)) \ 00596 [IDX].fld.field13 00597 # else 00598 # define ATD_CPNT_OFFSET_IDX(IDX) attr_tbl[IDX].fld.field13 00599 # endif 00600 00601 # ifdef _DEBUG 00602 # define ATD_DATA_INIT(IDX) \ 00603 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00604 attr_tbl : sytb_var_error("ATD_DATA_INIT", IDX)) \ 00605 [IDX].fld.flag2 00606 # else 00607 # define ATD_DATA_INIT(IDX) attr_tbl[IDX].fld.flag2 00608 # endif 00609 00610 # ifdef _DEBUG 00611 # define ATD_DCL_EQUIV(IDX) \ 00612 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00613 attr_tbl : sytb_var_error("ATD_DCL_EQUIV", IDX)) \ 00614 [IDX].fld.flag10 00615 # else 00616 # define ATD_DCL_EQUIV(IDX) attr_tbl[IDX].fld.flag10 00617 # endif 00618 00619 # ifdef _DEBUG 00620 # define ATD_DEFINING_ATTR_IDX(IDX) \ 00621 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00622 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 00623 attr_tbl : sytb_var_error("ATD_DEFINING_ATTR_IDX", IDX)) \ 00624 [IDX].fld.field8 00625 # else 00626 # define ATD_DEFINING_ATTR_IDX(IDX) attr_tbl[IDX].fld.field8 00627 # endif 00628 00629 # ifdef _DEBUG 00630 # define ATD_DERIVED_TYPE_IDX(IDX) \ 00631 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00632 attr_tbl[IDX].fld.secondary_info == Struct_Component) ? \ 00633 attr_tbl : sytb_var_error("ATD_DERIVED_TYPE_IDX", IDX)) \ 00634 [IDX].fld.field8 00635 # else 00636 # define ATD_DERIVED_TYPE_IDX(IDX) attr_tbl[IDX].fld.field8 00637 # endif 00638 00639 # ifdef _DEBUG 00640 # define ATD_DISTRIBUTION_IDX(IDX) \ 00641 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00642 attr_tbl : sytb_var_error("ATD_DISTRIBUTION_IDX", IDX)) \ 00643 [IDX].fld2.distribution_idx 00644 # else 00645 # define ATD_DISTRIBUTION_IDX(IDX) attr_tbl[IDX].fld2.distribution_idx 00646 # endif 00647 00648 # ifdef _DEBUG 00649 # define ATD_WAS_SCOPED(IDX) \ 00650 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00651 attr_tbl : sytb_var_error("ATD_WAS_SCOPED", IDX)) \ 00652 [IDX].fld.flag45 00653 # else 00654 # define ATD_WAS_SCOPED(IDX) attr_tbl[IDX].fld.flag45 00655 # endif 00656 00657 # ifdef _DEBUG 00658 # define ATD_DV_ALIAS(IDX) \ 00659 (((AT_OBJ_CLASS(IDX) == Data_Obj) && \ 00660 ((comp_phase == Inlining) || (comp_phase == Pdg_Conversion))) ? \ 00661 attr_aux_tbl : attr_aux_var_error("ATD_DV_ALIAS", IDX)) \ 00662 [IDX].fld.field3 00663 # else 00664 # define ATD_DV_ALIAS(IDX) attr_aux_tbl[IDX].fld.field3 00665 # endif 00666 00667 # ifdef _DEBUG 00668 # define ATD_DYNAMIC(IDX) \ 00669 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00670 attr_tbl : sytb_var_error("ATD_DYNAMIC", IDX)) \ 00671 [IDX].fld.flag41 00672 # else 00673 # define ATD_DYNAMIC(IDX) attr_tbl[IDX].fld.flag41 00674 # endif 00675 00676 # ifdef _DEBUG 00677 # define ATD_ELEMENTAL_CALL_TMP(IDX) \ 00678 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00679 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 00680 attr_tbl : sytb_var_error("ATD_ELEMENTAL_CALL_TMP", IDX)) \ 00681 [IDX].fld.flag50 00682 # else 00683 # define ATD_ELEMENTAL_CALL_TMP(IDX) attr_tbl[IDX].fld.flag50 00684 # endif 00685 00686 00687 # ifdef _DEBUG 00688 # define ATD_EQUIV(IDX) \ 00689 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00690 attr_tbl : sytb_var_error("ATD_EQUIV", IDX)) \ 00691 [IDX].fld.flag8 00692 # else 00693 # define ATD_EQUIV(IDX) attr_tbl[IDX].fld.flag8 00694 # endif 00695 00696 # ifdef _DEBUG 00697 # define ATD_EQUIV_IN_BNDS_EXPR(IDX) \ 00698 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00699 attr_aux_tbl:attr_aux_var_error("ATD_EQUIV_IN_BNDS_EXPR", IDX))\ 00700 [IDX].fld.flag5 00701 # else 00702 # define ATD_EQUIV_IN_BNDS_EXPR(IDX) attr_aux_tbl[IDX].fld.flag5 00703 # endif 00704 00705 # ifdef _DEBUG 00706 # define ATD_EQUIV_LIST(IDX) \ 00707 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00708 attr_aux_tbl : attr_aux_var_error("ATD_EQUIV_LIST", IDX)) \ 00709 [IDX].fld.field2 00710 # else 00711 # define ATD_EQUIV_LIST(IDX) attr_aux_tbl[IDX].fld.field2 00712 # endif 00713 00714 # ifdef _DEBUG 00715 # define ATD_EXPR_EVAL_TMP(IDX) \ 00716 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00717 attr_aux_tbl:attr_aux_var_error("ATD_EXPR_EVAL_TMP", IDX)) \ 00718 [IDX].fld.flag2 00719 # else 00720 # define ATD_EXPR_EVAL_TMP(IDX) attr_aux_tbl[IDX].fld.flag2 00721 # endif 00722 00723 # ifdef _DEBUG 00724 # define ATD_FILL_SYMBOL(IDX) \ 00725 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00726 attr_tbl : sytb_var_error("ATD_FILL_SYMBOL", IDX)) \ 00727 [IDX].fld.flag22 00728 # else 00729 # define ATD_FILL_SYMBOL(IDX) attr_tbl[IDX].fld.flag22 00730 # endif 00731 00732 # ifdef _DEBUG 00733 # define ATD_FIRST_SEEN_IL_IDX(IDX) \ 00734 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00735 attr_aux_tbl : attr_aux_var_error("ATD_FIRST_SEEN_IL_IDX",IDX))\ 00736 [IDX].fld.field3 00737 # else 00738 # define ATD_FIRST_SEEN_IL_IDX(IDX) attr_aux_tbl[IDX].fld.field3 00739 # endif 00740 00741 # ifdef _DEBUG 00742 # define ATD_FLD(IDX) \ 00743 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00744 attr_tbl : sytb_var_error("ATD_FLD", IDX)) \ 00745 [IDX].fld.field2 00746 # else 00747 # define ATD_FLD(IDX) attr_tbl[IDX].fld.field2 00748 # endif 00749 00750 # ifdef _DEBUG 00751 # define ATD_FORALL_INDEX(IDX) \ 00752 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00753 attr_aux_tbl : attr_aux_var_error("ATD_FORALL_INDEX", IDX)) \ 00754 [IDX].fld.flag8 00755 # else 00756 # define ATD_FORALL_INDEX(IDX) attr_aux_tbl[IDX].fld.flag8 00757 # endif 00758 00759 # ifdef _DEBUG 00760 # define ATD_FUNC_IDX(IDX) \ 00761 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00762 attr_tbl[IDX].fld.secondary_info == Function_Result) ? \ 00763 attr_tbl : sytb_var_error("ATD_FUNC_IDX", IDX)) \ 00764 [IDX].fld.field4 00765 # else 00766 # define ATD_FUNC_IDX(IDX) attr_tbl[IDX].fld.field4 00767 # endif 00768 00769 # ifdef _DEBUG 00770 # define ATD_IGNORE_TKR(IDX) \ 00771 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00772 attr_tbl : sytb_var_error("ATD_IGNORE_TKR", IDX)) \ 00773 [IDX].fld.flag48 00774 # else 00775 # define ATD_IGNORE_TKR(IDX) attr_tbl[IDX].fld.flag48 00776 # endif 00777 00778 # ifdef _DEBUG 00779 # define ATD_IM_A_DOPE(IDX) \ 00780 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00781 attr_tbl : sytb_var_error("ATD_IM_A_DOPE", IDX)) \ 00782 [IDX].fld.flag3 00783 # else 00784 # define ATD_IM_A_DOPE(IDX) attr_tbl[IDX].fld.flag3 00785 # endif 00786 00787 # ifdef _DEBUG 00788 # define ATD_IMP_DO_LCV(IDX) \ 00789 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00790 attr_aux_tbl : attr_aux_var_error("ATD_IMP_DO_LCV", IDX)) \ 00791 [IDX].fld.flag10 00792 # else 00793 # define ATD_IMP_DO_LCV(IDX) attr_aux_tbl[IDX].fld.flag10 00794 # endif 00795 00796 # ifdef _DEBUG 00797 # define ATD_IN_ASSIGN(IDX) \ 00798 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00799 attr_aux_tbl : attr_aux_var_error("ATD_IN_ASSIGN", IDX)) \ 00800 [IDX].fld.flag9 00801 # else 00802 # define ATD_IN_ASSIGN(IDX) attr_aux_tbl[IDX].fld.flag9 00803 # endif 00804 00805 # ifdef _DEBUG 00806 # define ATD_IN_COMMON(IDX) \ 00807 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00808 attr_tbl : sytb_var_error("ATD_IN_COMMON", IDX)) \ 00809 [IDX].fld.flag7 00810 # else 00811 # define ATD_IN_COMMON(IDX) attr_tbl[IDX].fld.flag7 00812 # endif 00813 00814 # ifdef _DEBUG 00815 # define ATD_INTENT(IDX) \ 00816 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00817 attr_tbl : sytb_var_error("ATD_INTENT", IDX)) \ 00818 [IDX].fld.field3 00819 # else 00820 # define ATD_INTENT(IDX) attr_tbl[IDX].fld.field3 00821 # endif 00822 00823 # ifdef _DEBUG 00824 # define ATD_INTRIN_DARG(IDX) \ 00825 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00826 attr_tbl[IDX].fld.secondary_info == Dummy_Argument) ? \ 00827 attr_tbl : sytb_var_error("ATD_INTRIN_DARG", IDX)) \ 00828 [IDX].fld.flag27 00829 # else 00830 # define ATD_INTRIN_DARG(IDX) attr_tbl[IDX].fld.flag27 00831 # endif 00832 00833 # ifdef _DEBUG 00834 # define ATD_INTRIN_DARG_TYPE(IDX) \ 00835 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00836 attr_tbl[IDX].fld.secondary_info == Dummy_Argument) ? \ 00837 attr_tbl : sytb_var_error("ATD_INTRIN_DARG_TYPE", IDX)) \ 00838 [IDX].fldd.field32_12 00839 # else 00840 # define ATD_INTRIN_DARG_TYPE(IDX) attr_tbl[IDX].fldd.field32_12 00841 # endif 00842 00843 # ifdef _DEBUG 00844 # define ATD_LCV_IS_CONST(IDX) \ 00845 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00846 attr_tbl : sytb_var_error("ATD_LCV_IS_CONST", IDX)) \ 00847 [IDX].fld.flag18 00848 # else 00849 # define ATD_LCV_IS_CONST(IDX) attr_tbl[IDX].fld.flag18 00850 # endif 00851 00852 # ifdef _DEBUG 00853 # define ATD_LIVE_DO_VAR(IDX) \ 00854 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00855 attr_aux_tbl : attr_aux_var_error("ATD_LIVE_DO_VAR", IDX)) \ 00856 [IDX].fld.flag1 00857 # else 00858 # define ATD_LIVE_DO_VAR(IDX) attr_aux_tbl[IDX].fld.flag1 00859 # endif 00860 00861 # ifdef _DEBUG 00862 # define ATD_NEXT_MEMBER_IDX(IDX) \ 00863 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00864 (attr_tbl[IDX].fld.secondary_info == Variable || \ 00865 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp)) ? \ 00866 attr_tbl : sytb_var_error("ATD_NEXT_MEMBER_IDX", IDX)) \ 00867 [IDX].fld.field16 00868 # else 00869 # define ATD_NEXT_MEMBER_IDX(IDX) attr_tbl[IDX].fld.field16 00870 # endif 00871 00872 # ifdef _DEBUG 00873 # define ATD_NO_ENTRY_LIST(IDX) \ 00874 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00875 attr_aux_tbl : attr_aux_var_error("ATD_NO_ENTRY_LIST", IDX)) \ 00876 [IDX].fld.field1 00877 # else 00878 # define ATD_NO_ENTRY_LIST(IDX) attr_aux_tbl[IDX].fld.field1 00879 # endif 00880 00881 # ifdef _DEBUG 00882 # define ATD_NOBOUNDS_CHECK(IDX) \ 00883 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00884 attr_tbl : sytb_var_error("ATD_NOBOUNDS_CHECK", IDX)) \ 00885 [IDX].fld.flag32 00886 # else 00887 # define ATD_NOBOUNDS_CHECK(IDX) attr_tbl[IDX].fld.flag32 00888 # endif 00889 00890 /* 00891 # ifdef _DEBUG 00892 # define ATD_NOT_PT_UNIQUE_MEM(IDX) \ 00893 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00894 attr_tbl : sytb_var_error("ATD_NOT_PT_UNIQUE_MEM", IDX)) \ 00895 [IDX].fld.flag51 00896 # else 00897 */ 00898 # define ATD_NOT_PT_UNIQUE_MEM(IDX) attr_tbl[IDX].fld.flag51 00899 /* # endif */ 00900 00901 # ifdef _DEBUG 00902 # define ATD_OFFSET_ASSIGNED(IDX) \ 00903 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00904 attr_tbl : sytb_var_error("ATD_OFFSET_ASSIGNED", IDX)) \ 00905 [IDX].fld.flag40 00906 # else 00907 # define ATD_OFFSET_ASSIGNED(IDX) attr_tbl[IDX].fld.flag40 00908 # endif 00909 00910 # ifdef _DEBUG 00911 # define ATD_OFFSET_FLD(IDX) \ 00912 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00913 (attr_tbl[IDX].fld.secondary_info == Variable || \ 00914 attr_tbl[IDX].fld.secondary_info == Function_Result || \ 00915 attr_tbl[IDX].fld.secondary_info == Struct_Component || \ 00916 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp)) ? \ 00917 attr_tbl : sytb_var_error("ATD_OFFSET_FLD", IDX)) \ 00918 [IDX].fld2.field22 00919 # else 00920 # define ATD_OFFSET_FLD(IDX) attr_tbl[IDX].fld2.field22 00921 # endif 00922 00923 # ifdef _DEBUG 00924 # define ATD_OFFSET_IDX(IDX) \ 00925 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00926 (attr_tbl[IDX].fld.secondary_info == Variable || \ 00927 attr_tbl[IDX].fld.secondary_info == Function_Result || \ 00928 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp)) ? \ 00929 attr_tbl : sytb_var_error("ATD_OFFSET_IDX", IDX)) \ 00930 [IDX].fld.field13 00931 # else 00932 # define ATD_OFFSET_IDX(IDX) attr_tbl[IDX].fld.field13 00933 # endif 00934 00935 # ifdef _DEBUG 00936 # define ATD_PARENT_OBJECT(IDX) \ 00937 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00938 attr_aux_tbl : attr_aux_var_error("ATD_PARENT_OBJECT", IDX)) \ 00939 [IDX].fld.flag7 00940 # else 00941 # define ATD_PARENT_OBJECT(IDX) attr_aux_tbl[IDX].fld.flag7 00942 # endif 00943 00944 # ifdef _DEBUG 00945 # define ATD_PE_ARRAY_IDX(IDX) \ 00946 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00947 attr_tbl : sytb_var_error("ATD_PE_ARRAY_IDX", IDX)) \ 00948 [IDX].fld.field10 00949 # else 00950 # define ATD_PE_ARRAY_IDX(IDX) attr_tbl[IDX].fld.field10 00951 # endif 00952 00953 # ifdef _DEBUG 00954 # define ATD_PERMUTATION(IDX) \ 00955 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00956 attr_tbl : sytb_var_error("ATD_PERMUTATION", IDX)) \ 00957 [IDX].fld.flag30 00958 # else 00959 # define ATD_PERMUTATION(IDX) attr_tbl[IDX].fld.flag30 00960 # endif 00961 00962 # ifdef _DEBUG 00963 # define ATD_POINTER(IDX) \ 00964 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00965 attr_tbl : sytb_var_error("ATD_POINTER", IDX)) \ 00966 [IDX].fld.flag5 00967 # else 00968 # define ATD_POINTER(IDX) attr_tbl[IDX].fld.flag5 00969 # endif 00970 00971 # ifdef _DEBUG 00972 # define ATD_PTR_ASSIGNED(IDX) \ 00973 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00974 attr_tbl : sytb_var_error("ATD_PTR_ASSIGNED", IDX)) \ 00975 [IDX].fld.flag20 00976 # else 00977 # define ATD_PTR_ASSIGNED(IDX) attr_tbl[IDX].fld.flag20 00978 # endif 00979 00980 # ifdef _DEBUG 00981 # define ATD_PTR_HALF_WORD(IDX) \ 00982 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 00983 attr_aux_tbl : attr_aux_var_error("ATD_PTR_HALF_WORD", IDX)) \ 00984 [IDX].fld.flag3 00985 # else 00986 # define ATD_PTR_HALF_WORD(IDX) attr_aux_tbl[IDX].fld.flag3 00987 # endif 00988 00989 # ifdef _DEBUG 00990 # define ATD_PTR_IDX(IDX) \ 00991 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 00992 attr_tbl[IDX].fld.secondary_info == CRI__Pointee) ? \ 00993 attr_tbl : sytb_var_error("ATD_PTR_IDX", IDX)) \ 00994 [IDX].fld.field8 00995 # else 00996 # define ATD_PTR_IDX(IDX) attr_tbl[IDX].fld.field8 00997 # endif 00998 00999 # ifdef _DEBUG 01000 # define ATD_PTR_TYPE_SET(IDX) \ 01001 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01002 attr_aux_tbl : attr_aux_var_error("ATD_PTR_TYPE_SET", IDX)) \ 01003 [IDX].fld.flag4 01004 # else 01005 # define ATD_PTR_TYPE_SET(IDX) attr_aux_tbl[IDX].fld.flag4 01006 # endif 01007 01008 # ifdef _DEBUG 01009 # define ATD_PURE(IDX) \ 01010 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01011 attr_tbl : sytb_var_error("ATD_PURE", IDX)) \ 01012 [IDX].fld.flag38 01013 # else 01014 # define ATD_PURE(IDX) attr_tbl[IDX].fld.flag38 01015 # endif 01016 01017 # ifdef _DEBUG 01018 # define ATD_READ_ONLY_VAR(IDX) \ 01019 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01020 attr_tbl : sytb_var_error("ATD_READ_ONLY_VAR", IDX)) \ 01021 [IDX].fld.flag52 01022 # else 01023 # define ATD_READ_ONLY_VAR(IDX) attr_tbl[IDX].fld.flag52 01024 # endif 01025 01026 # ifdef _DEBUG 01027 # define ATD_SAVED(IDX) \ 01028 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01029 attr_tbl : sytb_var_error("ATD_SAVED", IDX)) \ 01030 [IDX].fld.flag4 01031 # else 01032 # define ATD_SAVED(IDX) attr_tbl[IDX].fld.flag4 01033 # endif 01034 01035 # ifdef _DEBUG 01036 # define ATD_SECTION_GP(IDX) \ 01037 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01038 attr_tbl : sytb_var_error("ATD_SECTION_GP", IDX)) \ 01039 [IDX].fld.flag19 01040 # else 01041 # define ATD_SECTION_GP(IDX) attr_tbl[IDX].fld.flag19 01042 # endif 01043 01044 # ifdef _DEBUG 01045 # define ATD_SECTION_NON_GP(IDX) \ 01046 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01047 attr_tbl : sytb_var_error("ATD_SECTION_NON_GP", IDX)) \ 01048 [IDX].fld.flag29 01049 # else 01050 # define ATD_SECTION_NON_GP(IDX) attr_tbl[IDX].fld.flag29 01051 # endif 01052 01053 01054 # ifdef _DEBUG 01055 # define ATD_SF_ARG_IDX(IDX) \ 01056 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01057 attr_tbl[IDX].fld.secondary_info == Dummy_Argument) ? \ 01058 attr_tbl : sytb_var_error("ATD_SF_ARG_IDX", IDX)) \ 01059 [IDX].fld.field4 01060 # else 01061 # define ATD_SF_ARG_IDX(IDX) attr_tbl[IDX].fld.field4 01062 # endif 01063 01064 # ifdef _DEBUG 01065 # define ATD_SF_DARG(IDX) \ 01066 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01067 attr_tbl[IDX].fld.secondary_info == Dummy_Argument) ? \ 01068 attr_tbl : sytb_var_error("ATD_SF_DARG", IDX)) \ 01069 [IDX].fld.flag28 01070 # else 01071 # define ATD_SF_DARG(IDX) attr_tbl[IDX].fld.flag28 01072 # endif 01073 01074 # ifdef _DEBUG 01075 # define ATD_SF_LINK(IDX) \ 01076 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01077 attr_tbl[IDX].fld.secondary_info == Dummy_Argument) ? \ 01078 attr_tbl : sytb_var_error("ATD_SF_LINK", IDX)) \ 01079 [IDX].fld.field13 01080 # else 01081 # define ATD_SF_LINK(IDX) attr_tbl[IDX].fld.field13 01082 # endif 01083 01084 # ifdef _DEBUG 01085 # define ATD_STACK(IDX) \ 01086 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01087 attr_tbl : sytb_var_error("ATD_STACK", IDX)) \ 01088 [IDX].fld.flag37 01089 # else 01090 # define ATD_STACK(IDX) attr_tbl[IDX].fld.flag37 01091 # endif 01092 01093 # ifdef _DEBUG 01094 # define ATD_STOR_BLK_IDX(IDX) \ 01095 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01096 attr_tbl : sytb_var_error("ATD_STOR_BLK_IDX", IDX)) \ 01097 [IDX].fld.field6 01098 # else 01099 # define ATD_STOR_BLK_IDX(IDX) attr_tbl[IDX].fld.field6 01100 # endif 01101 01102 # ifdef _DEBUG 01103 # define ATD_RESHAPE_ARRAY_IDX(IDX) \ 01104 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01105 attr_tbl : sytb_var_error("ATD_RESHAPE_ARRAY_IDX", IDX)) \ 01106 [IDX].fld.field7 01107 # else 01108 # define ATD_RESHAPE_ARRAY_IDX(IDX) attr_tbl[IDX].fld.field7 01109 # endif 01110 01111 # ifdef _DEBUG 01112 # define ATD_SYMMETRIC(IDX) \ 01113 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01114 attr_tbl : sytb_var_error("ATD_SYMMETRIC", IDX)) \ 01115 [IDX].fld.flag33 01116 # else 01117 # define ATD_SYMMETRIC(IDX) attr_tbl[IDX].fld.flag33 01118 # endif 01119 01120 # ifdef _DEBUG 01121 # define ATD_RESHAPE_ARRAY_OPT(IDX) \ 01122 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01123 attr_tbl : sytb_var_error("ATD_RESHAPE_ARRAY_OPT", IDX)) \ 01124 [IDX].fld.flag17 01125 # else 01126 # define ATD_RESHAPE_ARRAY_OPT(IDX) attr_tbl[IDX].fld.flag17 01127 # endif 01128 01129 /* This flag is overlayed with ATD_TMP_NEEDS_CIF. This flag is only */ 01130 /* pertinent to variables but we don't need to check for that because it can */ 01131 /* never be set for a temp because temps are created by the compiler. */ 01132 01133 # ifdef _DEBUG 01134 # define ATD_SEEN_AS_IO_LCV(IDX) \ 01135 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01136 attr_tbl : sytb_var_error("ATD_SEEN_AS_IO_LCV", IDX)) \ 01137 [IDX].fld.flag34 01138 # else 01139 # define ATD_SEEN_AS_IO_LCV(IDX) attr_tbl[IDX].fld.flag34 01140 # endif 01141 01142 # ifdef _DEBUG 01143 # define ATD_SEEN_AS_LCV(IDX) \ 01144 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01145 attr_tbl : sytb_var_error("ATD_SEEN_AS_LCV", IDX)) \ 01146 [IDX].fld.flag25 01147 # else 01148 # define ATD_SEEN_AS_LCV(IDX) attr_tbl[IDX].fld.flag25 01149 # endif 01150 01151 # ifdef _DEBUG 01152 # define ATD_SEEN_IN_IMP_DO(IDX) \ 01153 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01154 attr_tbl : sytb_var_error("ATD_SEEN_IN_IMP_DO", IDX)) \ 01155 [IDX].fld.flag23 01156 # else 01157 # define ATD_SEEN_IN_IMP_DO(IDX) attr_tbl[IDX].fld.flag23 01158 # endif 01159 01160 # ifdef _DEBUG 01161 # define ATD_SEEN_OUTSIDE_IMP_DO(IDX) \ 01162 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01163 attr_tbl : sytb_var_error("ATD_SEEN_OUTSIDE_IMP_DO",IDX)) \ 01164 [IDX].fld.flag24 01165 # else 01166 # define ATD_SEEN_OUTSIDE_IMP_DO(IDX) attr_tbl[IDX].fld.flag24 01167 # endif 01168 01169 # ifdef _DEBUG 01170 # define ATD_SYMBOLIC_CONSTANT(IDX) \ 01171 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01172 attr_tbl : sytb_var_error("ATD_SYMBOLIC_CONSTANT", IDX)) \ 01173 [IDX].fld.flag35 01174 # else 01175 # define ATD_SYMBOLIC_CONSTANT(IDX) attr_tbl[IDX].fld.flag35 01176 # endif 01177 01178 # ifdef _DEBUG 01179 # define ATD_TARGET(IDX) \ 01180 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01181 attr_tbl : sytb_var_error("ATD_TARGET", IDX)) \ 01182 [IDX].fld.flag1 01183 # else 01184 # define ATD_TARGET(IDX) attr_tbl[IDX].fld.flag1 01185 # endif 01186 01187 # ifdef _DEBUG 01188 # define ATD_TASK_COPYIN(IDX) \ 01189 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01190 attr_aux_tbl:attr_aux_var_error("ATD_TASK_COPYIN", IDX)) \ 01191 [IDX].fld.flag18 01192 # else 01193 # define ATD_TASK_COPYIN(IDX) attr_aux_tbl[IDX].fld.flag18 01194 # endif 01195 01196 # ifdef _DEBUG 01197 # define ATD_TASK_GETFIRST(IDX) \ 01198 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01199 attr_aux_tbl:attr_aux_var_error("ATD_TASK_GETFIRST", IDX)) \ 01200 [IDX].fld.flag13 01201 # else 01202 # define ATD_TASK_GETFIRST(IDX) attr_aux_tbl[IDX].fld.flag13 01203 # endif 01204 01205 # ifdef _DEBUG 01206 # define ATD_TASK_COPYPRIVATE(IDX) \ 01207 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01208 attr_aux_tbl:attr_aux_var_error("ATD_TASK_COPYPRIVATE", IDX)) \ 01209 [IDX].fld.flag15 01210 # else 01211 # define ATD_TASK_COPYPRIVATE(IDX) attr_aux_tbl[IDX].fld.flag15 01212 # endif 01213 01214 # ifdef _DEBUG 01215 # define ATD_TASK_FIRSTPRIVATE(IDX) \ 01216 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01217 attr_aux_tbl:attr_aux_var_error("ATD_TASK_FIRSTPRIVATE", IDX)) \ 01218 [IDX].fld.flag17 01219 # else 01220 # define ATD_TASK_FIRSTPRIVATE(IDX) attr_aux_tbl[IDX].fld.flag17 01221 # endif 01222 01223 /* there is no FLUSH clause in OpenMP ([email protected]) */ 01224 /* we fake this clause in order to treat FLUSH directive the same as the others */ 01225 # ifdef _DEBUG 01226 # define ATD_TASK_FLUSH(IDX) \ 01227 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01228 attr_aux_tbl:attr_aux_var_error("ATD_TASK_COPYPRIVATE", IDX)) \ 01229 [IDX].fld.flag16 01230 # else 01231 # define ATD_TASK_FLUSH(IDX) attr_aux_tbl[IDX].fld.flag16 01232 # endif 01233 01234 # ifdef _DEBUG 01235 # define ATD_TASK_LASTLOCAL(IDX) \ 01236 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01237 attr_aux_tbl:attr_aux_var_error("ATD_TASK_LASTLOCAL", IDX)) \ 01238 [IDX].fld.flag14 01239 # else 01240 # define ATD_TASK_LASTLOCAL(IDX) attr_aux_tbl[IDX].fld.flag14 01241 # endif 01242 01243 # ifdef _DEBUG 01244 # define ATD_TASK_LASTPRIVATE(IDX) \ 01245 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01246 attr_aux_tbl:attr_aux_var_error("ATD_TASK_LASTPRIVATE", IDX)) \ 01247 [IDX].fld.flag19 01248 # else 01249 # define ATD_TASK_LASTPRIVATE(IDX) attr_aux_tbl[IDX].fld.flag19 01250 # endif 01251 01252 # ifdef _DEBUG 01253 # define ATD_TASK_LASTTHREAD(IDX) \ 01254 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01255 attr_aux_tbl:attr_aux_var_error("ATD_TASK_LASTTHREAD", IDX)) \ 01256 [IDX].fld.flag16 01257 # else 01258 # define ATD_TASK_LASTTHREAD(IDX) attr_aux_tbl[IDX].fld.flag16 01259 # endif 01260 01261 # ifdef _DEBUG 01262 # define ATD_TASK_PRIVATE(IDX) \ 01263 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01264 attr_aux_tbl:attr_aux_var_error("ATD_TASK_PRIVATE", IDX)) \ 01265 [IDX].fld.flag12 01266 # else 01267 # define ATD_TASK_PRIVATE(IDX) attr_aux_tbl[IDX].fld.flag12 01268 # endif 01269 01270 # ifdef _DEBUG 01271 # define ATD_TASK_REDUCTION(IDX) \ 01272 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01273 attr_aux_tbl:attr_aux_var_error("ATD_TASK_REDUCTION", IDX)) \ 01274 [IDX].fld.flag15 01275 # else 01276 # define ATD_TASK_REDUCTION(IDX) attr_aux_tbl[IDX].fld.flag15 01277 # endif 01278 01279 # ifdef _DEBUG 01280 # define ATD_TASK_SHARED(IDX) \ 01281 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01282 attr_aux_tbl:attr_aux_var_error("ATD_TASK_SHARED", IDX)) \ 01283 [IDX].fld.flag11 01284 # else 01285 # define ATD_TASK_SHARED(IDX) attr_aux_tbl[IDX].fld.flag11 01286 # endif 01287 01288 # ifdef _DEBUG 01289 # define ATD_TMP_GEN_ZERO(IDX) \ 01290 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01291 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 01292 attr_tbl : sytb_var_error("ATD_TMP_GEN_ZERO", IDX)) \ 01293 [IDX].fld.flag28 01294 # else 01295 # define ATD_TMP_GEN_ZERO(IDX) attr_tbl[IDX].fld.flag28 01296 # endif 01297 01298 # ifdef _DEBUG 01299 # define ATD_TMP_HAS_CVRT_OPR(IDX) \ 01300 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01301 attr_aux_tbl:attr_aux_var_error("ATD_TMP_HAS_CVRT_OPR", IDX)) \ 01302 [IDX].fld.flag6 01303 # else 01304 # define ATD_TMP_HAS_CVRT_OPR(IDX) attr_aux_tbl[IDX].fld.flag6 01305 # endif 01306 01307 /* # ifdef _DEBUG 01308 # define ATD_TMP_IDX(IDX) \ 01309 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01310 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 01311 attr_tbl : sytb_var_error("ATD_TMP_IDX", IDX)) \ 01312 [IDX].fld.field4 01313 # else 01314 */ 01315 # define ATD_TMP_IDX(IDX) attr_tbl[IDX].fld.field4 01316 01317 /* # endif */ 01318 01319 # ifdef _DEBUG 01320 # define ATD_TMP_INIT_NOT_DONE(IDX) \ 01321 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01322 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 01323 attr_tbl : sytb_var_error("ATD_TMP_INIT_NOT_DONE", IDX)) \ 01324 [IDX].fld.flag26 01325 # else 01326 # define ATD_TMP_INIT_NOT_DONE(IDX) attr_tbl[IDX].fld.flag26 01327 # endif 01328 01329 # ifdef _DEBUG 01330 # define ATD_TMP_NEEDS_CIF(IDX) \ 01331 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01332 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 01333 attr_tbl : sytb_var_error("ATD_TMP_NEEDS_CIF", IDX)) \ 01334 [IDX].fld.flag34 01335 # else 01336 # define ATD_TMP_NEEDS_CIF(IDX) attr_tbl[IDX].fld.flag34 01337 # endif 01338 01339 # ifdef _DEBUG 01340 # define ATD_TMP_SEMANTICS_DONE(IDX) \ 01341 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01342 attr_tbl[IDX].fld.secondary_info == Compiler_Tmp) ? \ 01343 attr_tbl : sytb_var_error("ATD_TMP_SEMANTICS_DONE", IDX)) \ 01344 [IDX].fld.flag27 01345 # else 01346 # define ATD_TMP_SEMANTICS_DONE(IDX) attr_tbl[IDX].fld.flag27 01347 # endif 01348 01349 # ifdef _DEBUG 01350 # define ATD_TOO_BIG_FOR_DV(IDX) \ 01351 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01352 attr_tbl : sytb_var_error("ATD_TOO_BIG_FOR_DV", IDX)) \ 01353 [IDX].fld.flag44 01354 # else 01355 # define ATD_TOO_BIG_FOR_DV(IDX) attr_tbl[IDX].fld.flag44 01356 # endif 01357 01358 # if 0 01359 # ifdef _DEBUG 01360 # define ATD_TYPE_IDX(IDX) \ 01361 ((AT_OBJ_CLASS(IDX) == Data_Obj || \ 01362 AT_OBJ_CLASS(IDX) == Interface || \ 01363 AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 01364 attr_tbl : sytb_var_error("ATD_TYPE_IDX", IDX)) \ 01365 [IDX].fld.field5 01366 # else 01367 # define ATD_TYPE_IDX(IDX) attr_tbl[IDX].fld.field5 01368 # endif 01369 # endif 01370 # define ATD_TYPE_IDX(IDX) attr_tbl[IDX].fld.field5 01371 01372 01373 # ifdef _DEBUG 01374 # define ATD_VARIABLE_TMP_IDX(IDX) \ 01375 ((AT_OBJ_CLASS(IDX) == Data_Obj && \ 01376 attr_tbl[IDX].fld.secondary_info == Variable) ? \ 01377 attr_tbl : sytb_var_error("ATD_VARIABLE_TMP_IDX", IDX)) \ 01378 [IDX].fld.field4 01379 # else 01380 # define ATD_VARIABLE_TMP_IDX(IDX) attr_tbl[IDX].fld.field4 01381 # endif 01382 01383 # ifdef _DEBUG 01384 # define ATD_VOLATILE(IDX) \ 01385 ((AT_OBJ_CLASS(IDX) == Data_Obj) ? \ 01386 attr_tbl : sytb_var_error("ATD_VOLATILE", IDX)) \ 01387 [IDX].fld.flag42 01388 # else 01389 # define ATD_VOLATILE(IDX) attr_tbl[IDX].fld.flag42 01390 # endif 01391 01392 01393 /* Definitions for interface class */ 01394 01395 # ifdef _DEBUG 01396 # define ATI_CIF_SCOPE_ID(IDX) \ 01397 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01398 attr_aux_tbl : attr_aux_var_error("ATI_CIF_SCOPE_ID", IDX)) \ 01399 [IDX].fld.field3 01400 # else 01401 # define ATI_CIF_SCOPE_ID(IDX) attr_aux_tbl[IDX].fld.field3 01402 # endif 01403 01404 # ifdef _DEBUG 01405 # define ATI_CIF_SEEN_IN_CALL(IDX) \ 01406 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01407 attr_tbl : sytb_var_error("ATI_CIF_SEEN_IN_CALL", IDX)) \ 01408 [IDX].fld.flag5 01409 # else 01410 # define ATI_CIF_SEEN_IN_CALL(IDX) attr_tbl[IDX].fld.flag5 01411 # endif 01412 01413 # ifdef _DEBUG 01414 # define ATI_DCL_INTRINSIC(IDX) \ 01415 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01416 attr_tbl : sytb_var_error("ATI_DCL_INTRINSIC", IDX)) \ 01417 [IDX].fld.flag3 01418 # else 01419 # define ATI_DCL_INTRINSIC(IDX) attr_tbl[IDX].fld.flag3 01420 # endif 01421 01422 # ifdef _DEBUG 01423 # define ATI_DEFINED_OPR(IDX) \ 01424 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01425 attr_tbl : sytb_var_error("ATI_DEFINED_OPR", IDX)) \ 01426 [IDX].fld.field6 01427 # else 01428 # define ATI_DEFINED_OPR(IDX) attr_tbl[IDX].fld.field6 01429 # endif 01430 01431 # ifdef _DEBUG 01432 # define ATI_FIRST_SPECIFIC_IDX(IDX) \ 01433 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01434 attr_tbl : sytb_var_error("ATI_FIRST_SPECIFIC_IDX", IDX)) \ 01435 [IDX].fld.field10 01436 # else 01437 # define ATI_FIRST_SPECIFIC_IDX(IDX) attr_tbl[IDX].fld.field10 01438 # endif 01439 01440 # ifdef _DEBUG 01441 # define ATI_GENERIC_INTRINSIC(IDX) \ 01442 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01443 attr_tbl : sytb_var_error("ATI_GENERIC_INTRINSIC", IDX)) \ 01444 [IDX].fld.flag7 01445 # else 01446 # define ATI_GENERIC_INTRINSIC(IDX) attr_tbl[IDX].fld.flag7 01447 # endif 01448 01449 # ifdef _DEBUG 01450 # define ATI_HAS_NON_MOD_PROC(IDX) \ 01451 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01452 attr_tbl : sytb_var_error("ATI_HAS_NON_MOD_PROC", IDX)) \ 01453 [IDX].fld.flag6 01454 # else 01455 # define ATI_HAS_NON_MOD_PROC(IDX) attr_tbl[IDX].fld.flag6 01456 # endif 01457 01458 # ifdef _DEBUG 01459 # define ATI_INLINE_ALWAYS(IDX) \ 01460 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01461 attr_tbl : sytb_var_error("ATI_INLINE_ALWAYS", IDX)) \ 01462 [IDX].fld.flag8 01463 # else 01464 # define ATI_INLINE_ALWAYS(IDX) attr_tbl[IDX].fld.flag8 01465 # endif 01466 01467 # ifdef _DEBUG 01468 # define ATI_INLINE_NEVER(IDX) \ 01469 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01470 attr_tbl : sytb_var_error("ATI_INLINE_NEVER", IDX)) \ 01471 [IDX].fld.flag9 01472 # else 01473 # define ATI_INLINE_NEVER(IDX) attr_tbl[IDX].fld.flag9 01474 # endif 01475 01476 # ifdef _DEBUG 01477 # define ATI_IPA_DIR_SPECIFIED(IDX) \ 01478 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01479 attr_tbl : sytb_var_error("ATI_IPA_DIR_SPECIFIED", IDX)) \ 01480 [IDX].fld.flag12 01481 # else 01482 # define ATI_IPA_DIR_SPECIFIED(IDX) attr_tbl[IDX].fld.flag12 01483 # endif 01484 01485 # ifdef _DEBUG 01486 # define ATI_INTERFACE_CLASS(IDX) \ 01487 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01488 attr_tbl : sytb_var_error("ATI_INTERFACE_CLASS", IDX)) \ 01489 [IDX].fld.secondary_info 01490 # else 01491 # define ATI_INTERFACE_CLASS(IDX) attr_tbl[IDX].fld.secondary_info 01492 # endif 01493 01494 # ifdef _DEBUG 01495 # define ATI_INTRIN_PASSABLE(IDX) \ 01496 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01497 attr_tbl : sytb_var_error("ATI_INTRIN_PASSABLE", IDX)) \ 01498 [IDX].fld.flag1 01499 # else 01500 # define ATI_INTRIN_PASSABLE(IDX) attr_tbl[IDX].fld.flag1 01501 # endif 01502 01503 # ifdef _DEBUG 01504 # define ATI_INTRIN_TBL_IDX(IDX) \ 01505 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01506 attr_tbl : sytb_var_error("ATI_INTRIN_TBL_IDX", IDX)) \ 01507 [IDX].fld.field13 01508 # else 01509 # define ATI_INTRIN_TBL_IDX(IDX) attr_tbl[IDX].fld.field13 01510 # endif 01511 01512 # ifdef _DEBUG 01513 # define ATI_NUM_SPECIFICS(IDX) \ 01514 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01515 attr_tbl : sytb_var_error("ATI_NUM_SPECIFICS", IDX)) \ 01516 [IDX].fld.field14 01517 # else 01518 # define ATI_NUM_SPECIFICS(IDX) attr_tbl[IDX].fld.field14 01519 # endif 01520 01521 # ifdef _DEBUG 01522 # define ATI_PROC_IDX(IDX) \ 01523 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01524 attr_tbl : sytb_var_error("ATI_PROC_IDX", IDX)) \ 01525 [IDX].fld.field8 01526 # else 01527 # define ATI_PROC_IDX(IDX) attr_tbl[IDX].fld.field8 01528 # endif 01529 01530 # ifdef _DEBUG 01531 # define ATI_SGI_ROUTINE_INLINE(IDX) \ 01532 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01533 attr_tbl : sytb_var_error("ATI_SGI_ROUTINE_INLINE", IDX)) \ 01534 [IDX].fld.flag10 01535 # else 01536 # define ATI_SGI_ROUTINE_INLINE(IDX) attr_tbl[IDX].fld.flag10 01537 # endif 01538 01539 # ifdef _DEBUG 01540 # define ATI_SGI_ROUTINE_NOINLINE(IDX) \ 01541 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01542 attr_tbl : sytb_var_error("ATI_SGI_ROUTINE_NOINLINE", IDX)) \ 01543 [IDX].fld.flag11 01544 # else 01545 # define ATI_SGI_ROUTINE_NOINLINE(IDX) attr_tbl[IDX].fld.flag11 01546 # endif 01547 01548 # ifdef _DEBUG 01549 # define ATI_UNNAMED_INTERFACE(IDX) \ 01550 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01551 attr_tbl : sytb_var_error("ATI_UNNAMED_INTERFACE", IDX)) \ 01552 [IDX].fld.flag2 01553 # else 01554 # define ATI_UNNAMED_INTERFACE(IDX) attr_tbl[IDX].fld.flag2 01555 # endif 01556 01557 01558 # ifdef _DEBUG 01559 # define ATI_USER_SPECIFIED(IDX) \ 01560 ((AT_OBJ_CLASS(IDX) == Interface) ? \ 01561 attr_tbl : sytb_var_error("ATI_USER_SPECIFIED", IDX)) \ 01562 [IDX].fld.flag4 01563 # else 01564 # define ATI_USER_SPECIFIED(IDX) attr_tbl[IDX].fld.flag4 01565 # endif 01566 01567 01568 /* Definitions for label class */ 01569 01570 # ifdef _DEBUG 01571 # define ATL_AGGRESSIVEINNERLOOPFISSION(IDX) \ 01572 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01573 attr_tbl:sytb_var_error("ATL_AGGRESSIVEINNERLOOPFISSION",IDX)) \ 01574 [IDX].fld.flag31 01575 # else 01576 # define ATL_AGGRESSIVEINNERLOOPFISSION(IDX) attr_tbl[IDX].fld.flag31 01577 # endif 01578 01579 # ifdef _DEBUG 01580 # define ATL_ALIGN(IDX) \ 01581 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01582 attr_tbl : sytb_var_error("ATL_ALIGN", IDX)) \ 01583 [IDX].fld.flag12 01584 # else 01585 # define ATL_ALIGN(IDX) attr_tbl[IDX].fld.flag12 01586 # endif 01587 01588 # ifdef _DEBUG 01589 # define ATL_ASG_LBL_CHAIN_START(IDX) \ 01590 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01591 attr_tbl : sytb_var_error("ATL_ASG_LBL_CHAIN_START", IDX)) \ 01592 [IDX].fld.flag21 01593 # else 01594 # define ATL_ASG_LBL_CHAIN_START(IDX) attr_tbl[IDX].fld.flag21 01595 # endif 01596 01597 # ifdef _DEBUG 01598 # define ATL_BL(IDX) \ 01599 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01600 attr_tbl : sytb_var_error("ATL_BL", IDX)) \ 01601 [IDX].fld.flag11 01602 # else 01603 # define ATL_BL(IDX) attr_tbl[IDX].fld.flag11 01604 # endif 01605 01606 # ifdef _DEBUG 01607 # define ATL_BLK_STMT_IDX(IDX) \ 01608 ((AT_OBJ_CLASS(IDX) == Label && \ 01609 attr_tbl[IDX].fld.secondary_info <= Lbl_User) ? \ 01610 attr_tbl : sytb_var_error("ATL_BLK_STMT_IDX", IDX)) \ 01611 [IDX].fld.field10 01612 # else 01613 # define ATL_BLK_STMT_IDX(IDX) attr_tbl[IDX].fld.field10 01614 # endif 01615 01616 # ifdef _DEBUG 01617 # define ATL_CLASS(IDX) \ 01618 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01619 attr_tbl : sytb_var_error("ATL_CLASS", IDX)) \ 01620 [IDX].fld.secondary_info 01621 # else 01622 # define ATL_CLASS(IDX) attr_tbl[IDX].fld.secondary_info 01623 # endif 01624 01625 # ifdef _DEBUG 01626 # define ATL_CMIC_BLK_STMT_IDX(IDX) \ 01627 ((AT_OBJ_CLASS(IDX) == Label && \ 01628 attr_tbl[IDX].fld.secondary_info != Lbl_Format) ? \ 01629 attr_tbl : sytb_var_error("ATL_CMIC_BLK_STMT_IDX", IDX)) \ 01630 [IDX].fld.field4 01631 # else 01632 # define ATL_CMIC_BLK_STMT_IDX(IDX) attr_tbl[IDX].fld.field4 01633 # endif 01634 01635 # ifdef _DEBUG 01636 # define ATL_CONCURRENT(IDX) \ 01637 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01638 attr_tbl : sytb_var_error("ATL_CONCURRENT", IDX)) \ 01639 [IDX].fld.flag33 01640 # else 01641 # define ATL_CONCURRENT(IDX) attr_tbl[IDX].fld.flag33 01642 # endif 01643 01644 # ifdef _DEBUG 01645 # define ATL_CONSTRUCTOR_LOOP(IDX) \ 01646 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01647 attr_tbl : sytb_var_error("ATL_CONSTRUCTOR_LOOP", IDX)) \ 01648 [IDX].fld.flag34 01649 # else 01650 # define ATL_CONSTRUCTOR_LOOP(IDX) attr_tbl[IDX].fld.flag34 01651 # endif 01652 01653 # ifdef _DEBUG 01654 # define ATL_CNCALL(IDX) \ 01655 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01656 attr_tbl : sytb_var_error("ATL_CNCALL", IDX)) \ 01657 [IDX].fld.flag18 01658 # else 01659 # define ATL_CNCALL(IDX) attr_tbl[IDX].fld.flag18 01660 # endif 01661 01662 # ifdef _DEBUG 01663 # define ATL_CYCLE_LBL(IDX) \ 01664 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01665 attr_tbl : sytb_var_error("ATL_CYCLE_LBL", IDX)) \ 01666 [IDX].fld.flag38 01667 # else 01668 # define ATL_CYCLE_LBL(IDX) attr_tbl[IDX].fld.flag38 01669 # endif 01670 01671 # ifdef _DEBUG 01672 # define ATL_DEBUG_CLASS(IDX) \ 01673 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01674 attr_tbl : sytb_var_error("ATL_DEBUG_CLASS", IDX)) \ 01675 [IDX].fld.field2 01676 # else 01677 # define ATL_DEBUG_CLASS(IDX) attr_tbl[IDX].fld.field2 01678 # endif 01679 01680 # ifdef _DEBUG 01681 # define ATL_DEF_STMT_IDX(IDX) \ 01682 ((AT_OBJ_CLASS(IDX) == Label && AT_DEFINED(IDX)) ? \ 01683 attr_tbl : sytb_var_error("ATL_DEF_STMT_IDX", IDX)) \ 01684 [IDX].fld.field13 01685 # else 01686 # define ATL_DEF_STMT_IDX(IDX) attr_tbl[IDX].fld.field13 01687 # endif 01688 01689 # ifdef _DEBUG 01690 # define ATL_CASE_LABEL(IDX) \ 01691 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01692 attr_tbl : sytb_var_error("ATL_CASE_LABEL", IDX)) \ 01693 [IDX].fld.flag25 01694 # else 01695 # define ATL_CASE_LABEL(IDX) attr_tbl[IDX].fld.flag25 01696 # endif 01697 01698 # ifdef _DEBUG 01699 # define ATL_DIRECTIVE_LIST(IDX) \ 01700 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01701 attr_tbl : sytb_var_error("ATL_DIRECTIVE_LIST", IDX)) \ 01702 [IDX].fld.field14 01703 # else 01704 # define ATL_DIRECTIVE_LIST(IDX) attr_tbl[IDX].fld.field14 01705 # endif 01706 01707 # ifdef _DEBUG 01708 # define ATL_EXECUTABLE(IDX) \ 01709 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01710 attr_tbl : sytb_var_error("ATL_EXECUTABLE", IDX)) \ 01711 [IDX].fld.flag2 01712 # else 01713 # define ATL_EXECUTABLE(IDX) attr_tbl[IDX].fld.flag2 01714 # endif 01715 01716 # ifdef _DEBUG 01717 # define ATL_FISSIONABLE(IDX) \ 01718 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01719 attr_tbl : sytb_var_error("ATL_FISSIONABLE", IDX)) \ 01720 [IDX].fld.flag26 01721 # else 01722 # define ATL_FISSIONABLE(IDX) attr_tbl[IDX].fld.flag26 01723 # endif 01724 01725 /* # ifdef _DEBUG 01726 # define ATL_FORMAT_TMP(IDX) \ 01727 ((AT_OBJ_CLASS(IDX) == Label && \ 01728 attr_tbl[IDX].fld.secondary_info == Lbl_Format) ? \ 01729 attr_tbl : sytb_var_error("ATL_FORMAT_TMP", IDX)) \ 01730 [IDX].fld.field10 01731 # else 01732 */ 01733 # define ATL_FORMAT_TMP(IDX) attr_tbl[IDX].fld.field10 01734 /* # endif */ 01735 01736 # ifdef _DEBUG 01737 # define ATL_FUSABLE(IDX) \ 01738 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01739 attr_tbl : sytb_var_error("ATL_FUSABLE", IDX)) \ 01740 [IDX].fld.flag28 01741 # else 01742 # define ATL_FUSABLE(IDX) attr_tbl[IDX].fld.flag28 01743 # endif 01744 01745 # ifdef _DEBUG 01746 # define ATL_FUSION(IDX) \ 01747 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01748 attr_tbl : sytb_var_error("ATL_FUSION", IDX)) \ 01749 [IDX].fld.flag35 01750 # else 01751 # define ATL_FUSION(IDX) attr_tbl[IDX].fld.flag35 01752 # endif 01753 01754 # ifdef _DEBUG 01755 # define ATL_FWD_REF_IDX(IDX) \ 01756 ((AT_OBJ_CLASS(IDX) == Label && !(AT_DEFINED(IDX))) ? \ 01757 attr_tbl : sytb_var_error("ATL_FWD_REF_IDX", IDX)) \ 01758 [IDX].fld.field13 01759 # else 01760 # define ATL_FWD_REF_IDX(IDX) attr_tbl[IDX].fld.field13 01761 # endif 01762 01763 # ifdef _DEBUG 01764 # define ATL_IN_ASSIGN(IDX) \ 01765 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01766 attr_tbl : sytb_var_error("ATL_IN_ASSIGN", IDX)) \ 01767 [IDX].fld.flag1 01768 # else 01769 # define ATL_IN_ASSIGN(IDX) attr_tbl[IDX].fld.flag1 01770 # endif 01771 01772 # ifdef _DEBUG 01773 # define ATL_IN_ASSIGN_LBL_CHAIN(IDX) \ 01774 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01775 attr_tbl : sytb_var_error("ATL_IN_ASSIGN_LBL_CHAIN", IDX)) \ 01776 [IDX].fld.flag3 01777 # else 01778 # define ATL_IN_ASSIGN_LBL_CHAIN(IDX) attr_tbl[IDX].fld.flag3 01779 # endif 01780 01781 # ifdef _DEBUG 01782 # define ATL_IVDEP(IDX) \ 01783 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01784 attr_tbl : sytb_var_error("ATL_IVDEP", IDX)) \ 01785 [IDX].fld.flag4 01786 # else 01787 # define ATL_IVDEP(IDX) attr_tbl[IDX].fld.flag4 01788 # endif 01789 01790 # ifdef _DEBUG 01791 # define ATL_MAXCPUS(IDX) \ 01792 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01793 attr_tbl : sytb_var_error("ATL_MAXCPUS", IDX)) \ 01794 [IDX].fld.flag23 01795 # else 01796 # define ATL_MAXCPUS(IDX) attr_tbl[IDX].fld.flag23 01797 # endif 01798 01799 # ifdef _DEBUG 01800 # define ATL_NEW_LBL_IDX(IDX) \ 01801 ((AT_OBJ_CLASS(IDX) == Label && \ 01802 attr_tbl[IDX].fld.secondary_info == Lbl_Internal) ? \ 01803 attr_tbl : sytb_var_error("ATL_NEW_LBL_IDX", IDX)) \ 01804 [IDX].fld.field10 01805 # else 01806 # define ATL_NEW_LBL_IDX(IDX) attr_tbl[IDX].fld.field10 01807 # endif 01808 01809 # ifdef _DEBUG 01810 # define ATL_NEXT_ASG_LBL_IDX(IDX) \ 01811 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01812 attr_tbl : sytb_var_error("ATL_NEXT_ASG_LBL_IDX", IDX)) \ 01813 [IDX].fld.field8 01814 # else 01815 # define ATL_NEXT_ASG_LBL_IDX(IDX) attr_tbl[IDX].fld.field8 01816 # endif 01817 01818 # ifdef _DEBUG 01819 # define ATL_NEXTSCALAR(IDX) \ 01820 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01821 attr_tbl : sytb_var_error("ATL_NEXTSCALAR", IDX)) \ 01822 [IDX].fld.flag10 01823 # else 01824 # define ATL_NEXTSCALAR(IDX) attr_tbl[IDX].fld.flag10 01825 # endif 01826 01827 # ifdef _DEBUG 01828 # define ATL_NOBLOCKING(IDX) \ 01829 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01830 attr_tbl : sytb_var_error("ATL_NOBLOCKING", IDX)) \ 01831 [IDX].fld.flag32 01832 # else 01833 # define ATL_NOBLOCKING(IDX) attr_tbl[IDX].fld.flag32 01834 # endif 01835 01836 # ifdef _DEBUG 01837 # define ATL_NOFISSION(IDX) \ 01838 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01839 attr_tbl : sytb_var_error("ATL_NOFISSION", IDX)) \ 01840 [IDX].fld.flag27 01841 # else 01842 # define ATL_NOFISSION(IDX) attr_tbl[IDX].fld.flag27 01843 # endif 01844 01845 # ifdef _DEBUG 01846 # define ATL_NOFUSION(IDX) \ 01847 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01848 attr_tbl : sytb_var_error("ATL_NOFUSION", IDX)) \ 01849 [IDX].fld.flag29 01850 # else 01851 # define ATL_NOFUSION(IDX) attr_tbl[IDX].fld.flag29 01852 # endif 01853 01854 # ifdef _DEBUG 01855 # define ATL_NOINTERCHANGE(IDX) \ 01856 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01857 attr_tbl : sytb_var_error("ATL_NOINTERCHANGE", IDX)) \ 01858 [IDX].fld.flag30 01859 # else 01860 # define ATL_NOINTERCHANGE(IDX) attr_tbl[IDX].fld.flag30 01861 # endif 01862 01863 # ifdef _DEBUG 01864 # define ATL_NORECURRENCE(IDX) \ 01865 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01866 attr_tbl : sytb_var_error("ATL_NORECURRENCE", IDX)) \ 01867 [IDX].fld.flag5 01868 # else 01869 # define ATL_NORECURRENCE(IDX) attr_tbl[IDX].fld.flag5 01870 # endif 01871 01872 # ifdef _DEBUG 01873 # define ATL_NOTASK(IDX) \ 01874 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01875 attr_tbl : sytb_var_error("ATL_NOTASK", IDX)) \ 01876 [IDX].fld.flag37 01877 # else 01878 # define ATL_NOTASK(IDX) attr_tbl[IDX].fld.flag37 01879 # endif 01880 01881 # ifdef _DEBUG 01882 # define ATL_NOVECTOR(IDX) \ 01883 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01884 attr_tbl : sytb_var_error("ATL_NOVECTOR", IDX)) \ 01885 [IDX].fld.flag6 01886 # else 01887 # define ATL_NOVECTOR(IDX) attr_tbl[IDX].fld.flag6 01888 # endif 01889 01890 # ifdef _DEBUG 01891 # define ATL_NOVSEARCH(IDX) \ 01892 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01893 attr_tbl : sytb_var_error("ATL_NOVSEARCH", IDX)) \ 01894 [IDX].fld.flag9 01895 # else 01896 # define ATL_NOVSEARCH(IDX) attr_tbl[IDX].fld.flag9 01897 # endif 01898 01899 # ifdef _DEBUG 01900 # define ATL_PATTERN(IDX) \ 01901 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01902 attr_tbl : sytb_var_error("ATL_PATTERN", IDX)) \ 01903 [IDX].fld.flag24 01904 # else 01905 # define ATL_PATTERN(IDX) attr_tbl[IDX].fld.flag24 01906 # endif 01907 01908 # ifdef _DEBUG 01909 # define ATL_PERMUTATION(IDX) \ 01910 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01911 attr_tbl : sytb_var_error("ATL_PERMUTATION", IDX)) \ 01912 [IDX].fld.flag19 01913 # else 01914 # define ATL_PERMUTATION(IDX) attr_tbl[IDX].fld.flag19 01915 # endif 01916 01917 # ifdef _DEBUG 01918 # define ATL_PP_FORMAT_TMP(IDX) \ 01919 ((AT_OBJ_CLASS(IDX) == Label && \ 01920 attr_tbl[IDX].fld.secondary_info == Lbl_Format) ? \ 01921 attr_tbl : sytb_var_error("ATL_PP_FORMAT_TMP", IDX)) \ 01922 [IDX].fld.field4 01923 # else 01924 # define ATL_PP_FORMAT_TMP(IDX) attr_tbl[IDX].fld.field4 01925 # endif 01926 01927 # ifdef _DEBUG 01928 # define ATL_PREFERSTREAM(IDX) \ 01929 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01930 attr_tbl : sytb_var_error("ATL_PREFERSTREAM", IDX)) \ 01931 [IDX].fld.flag41 01932 # else 01933 # define ATL_PREFERSTREAM(IDX) attr_tbl[IDX].fld.flag41 01934 # endif 01935 01936 # ifdef _DEBUG 01937 # define ATL_PREFERSTREAM_NOCINV(IDX) \ 01938 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01939 attr_tbl : sytb_var_error("ATL_PREFERSTREAM_NOCINV", IDX)) \ 01940 [IDX].fld.flag43 01941 # else 01942 # define ATL_PREFERSTREAM_NOCINV(IDX) attr_tbl[IDX].fld.flag43 01943 # endif 01944 01945 # ifdef _DEBUG 01946 # define ATL_PREFERTASK(IDX) \ 01947 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01948 attr_tbl : sytb_var_error("ATL_PREFERTASK", IDX)) \ 01949 [IDX].fld.flag20 01950 # else 01951 # define ATL_PREFERTASK(IDX) attr_tbl[IDX].fld.flag20 01952 # endif 01953 01954 # ifdef _DEBUG 01955 # define ATL_PREFERVECTOR(IDX) \ 01956 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01957 attr_tbl : sytb_var_error("ATL_PREFERVECTOR", IDX)) \ 01958 [IDX].fld.flag39 01959 # else 01960 # define ATL_PREFERVECTOR(IDX) attr_tbl[IDX].fld.flag39 01961 # endif 01962 01963 # ifdef _DEBUG 01964 # define ATL_SHORTLOOP(IDX) \ 01965 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01966 attr_tbl : sytb_var_error("ATL_SHORTLOOP", IDX)) \ 01967 [IDX].fld.flag7 01968 # else 01969 # define ATL_SHORTLOOP(IDX) attr_tbl[IDX].fld.flag7 01970 # endif 01971 01972 # ifdef _DEBUG 01973 # define ATL_SHORTLOOP128(IDX) \ 01974 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01975 attr_tbl : sytb_var_error("ATL_SHORTLOOP128", IDX)) \ 01976 [IDX].fld.flag8 01977 # else 01978 # define ATL_SHORTLOOP128(IDX) attr_tbl[IDX].fld.flag8 01979 # endif 01980 01981 # ifdef _DEBUG 01982 # define ATL_SPLIT(IDX) \ 01983 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01984 attr_tbl : sytb_var_error("ATL_SPLIT", IDX)) \ 01985 [IDX].fld.flag22 01986 # else 01987 # define ATL_SPLIT(IDX) attr_tbl[IDX].fld.flag22 01988 # endif 01989 01990 # ifdef _DEBUG 01991 # define ATL_STREAM(IDX) \ 01992 ((AT_OBJ_CLASS(IDX) == Label) ? \ 01993 attr_tbl : sytb_var_error("ATL_STREAM", IDX)) \ 01994 [IDX].fld.flag40 01995 # else 01996 # define ATL_STREAM(IDX) attr_tbl[IDX].fld.flag40 01997 # endif 01998 01999 # ifdef _DEBUG 02000 # define ATL_INFORM_ONLY(IDX) \ 02001 ((AT_OBJ_CLASS(IDX) == Label) ? \ 02002 attr_tbl : sytb_var_error("ATL_INFORM_ONLY", IDX)) \ 02003 [IDX].fld.flag42 02004 # else 02005 # define ATL_INFORM_ONLY(IDX) attr_tbl[IDX].fld.flag42 02006 # endif 02007 02008 # ifdef _DEBUG 02009 # define ATL_TOP_OF_LOOP(IDX) \ 02010 ((AT_OBJ_CLASS(IDX) == Label) ? \ 02011 attr_tbl : sytb_var_error("ATL_TOP_OF_LOOP", IDX)) \ 02012 [IDX].fld.flag36 02013 # else 02014 # define ATL_TOP_OF_LOOP(IDX) attr_tbl[IDX].fld.flag36 02015 # endif 02016 02017 # ifdef _DEBUG 02018 # define ATL_UNROLL_DIR(IDX) \ 02019 ((AT_OBJ_CLASS(IDX) == Label) ? \ 02020 attr_tbl : sytb_var_error("ATL_UNROLL_DIR", IDX)) \ 02021 [IDX].fld.flag17 02022 # else 02023 # define ATL_UNROLL_DIR(IDX) attr_tbl[IDX].fld.flag17 02024 # endif 02025 02026 02027 02028 /* Definitions for namelist class */ 02029 02030 # ifdef _DEBUG 02031 # define ATN_FIRST_NAMELIST_IDX(IDX) \ 02032 ((AT_OBJ_CLASS(IDX) == Namelist_Grp) ? \ 02033 attr_tbl : sytb_var_error("ATN_FIRST_NAMELIST_IDX", IDX)) \ 02034 [IDX].fld.field13 02035 # else 02036 # define ATN_FIRST_NAMELIST_IDX(IDX) attr_tbl[IDX].fld.field13 02037 # endif 02038 02039 # ifdef _DEBUG 02040 # define ATN_LAST_NAMELIST_IDX(IDX) \ 02041 ((AT_OBJ_CLASS(IDX) == Namelist_Grp) ? \ 02042 attr_tbl : sytb_var_error("ATN_LAST_NAMELIST_IDX", IDX)) \ 02043 [IDX].fld.field10 02044 # else 02045 # define ATN_LAST_NAMELIST_IDX(IDX) attr_tbl[IDX].fld.field10 02046 # endif 02047 02048 # ifdef _DEBUG 02049 # define ATN_NAMELIST_DESC(IDX) \ 02050 ((AT_OBJ_CLASS(IDX) == Namelist_Grp) ? \ 02051 attr_tbl : sytb_var_error("ATN_NAMELIST_DESC", IDX)) \ 02052 [IDX].fld.field4 02053 # else 02054 # define ATN_NAMELIST_DESC(IDX) attr_tbl[IDX].fld.field4 02055 # endif 02056 02057 # ifdef _DEBUG 02058 # define ATN_NUM_NAMELIST(IDX) \ 02059 ((AT_OBJ_CLASS(IDX) == Namelist_Grp) ? \ 02060 attr_tbl : sytb_var_error("ATN_NUM_NAMELIST", IDX)) \ 02061 [IDX].fld.field5 02062 # else 02063 # define ATN_NUM_NAMELIST(IDX) attr_tbl[IDX].fld.field5 02064 # endif 02065 02066 02067 /* Definitions for program unit class */ 02068 02069 # ifdef _DEBUG 02070 # define ATP_ALIGN(IDX) \ 02071 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02072 attr_tbl : sytb_var_error("ATP_ALIGN", IDX)) \ 02073 [IDX].fld.flag32 02074 # else 02075 # define ATP_ALIGN(IDX) attr_tbl[IDX].fld.flag32 02076 # endif 02077 02078 # ifdef _DEBUG 02079 # define ATP_ALL_INTENT_IN(IDX) \ 02080 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02081 attr_tbl : sytb_var_error("ATP_ALL_INTENT_IN", IDX)) \ 02082 [IDX].fld.flag3 02083 # else 02084 # define ATP_ALL_INTENT_IN(IDX) attr_tbl[IDX].fld.flag3 02085 # endif 02086 02087 # ifdef _DEBUG 02088 # define ATP_ALT_ENTRY(IDX) \ 02089 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02090 attr_tbl : sytb_var_error("ATP_ALT_ENTRY", IDX)) \ 02091 [IDX].fld.flag2 02092 # else 02093 # define ATP_ALT_ENTRY(IDX) attr_tbl[IDX].fld.flag2 02094 # endif 02095 02096 # ifdef _DEBUG 02097 # define ATP_ARGCHCK_CALL(IDX) \ 02098 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02099 attr_tbl : sytb_var_error("ATP_ARGCHCK_CALL", IDX)) \ 02100 [IDX].fld.flag24 02101 # else 02102 # define ATP_ARGCHCK_CALL(IDX) attr_tbl[IDX].fld.flag24 02103 # endif 02104 02105 # ifdef _DEBUG 02106 # define ATP_ARGCHCK_ENTRY(IDX) \ 02107 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02108 attr_tbl : sytb_var_error("ATP_ARGCHCK_ENTRY", IDX)) \ 02109 [IDX].fld.flag25 02110 # else 02111 # define ATP_ARGCHCK_ENTRY(IDX) attr_tbl[IDX].fld.flag25 02112 # endif 02113 02114 # ifdef _DEBUG 02115 # define ATP_CIF_DARG_PROC(IDX) \ 02116 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02117 attr_aux_tbl : attr_aux_var_error("ATP_CIF_DARG_PROC", IDX)) \ 02118 [IDX].fld.flag1 02119 # else 02120 # define ATP_CIF_DARG_PROC(IDX) attr_aux_tbl[IDX].fld.flag1 02121 # endif 02122 02123 # ifdef _DEBUG 02124 # define ATP_DCL_EXTERNAL(IDX) \ 02125 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02126 attr_tbl : sytb_var_error("ATP_DCL_EXTERNAL", IDX)) \ 02127 [IDX].fld.flag10 02128 # else 02129 # define ATP_DCL_EXTERNAL(IDX) attr_tbl[IDX].fld.flag10 02130 # endif 02131 02132 # ifdef _DEBUG 02133 # define ATP_DOES_NOT_RETURN(IDX) \ 02134 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02135 attr_tbl : sytb_var_error("ATP_DOES_NOT_RETURN", IDX)) \ 02136 [IDX].fld.flag49 02137 # else 02138 # define ATP_DOES_NOT_RETURN(IDX) attr_tbl[IDX].fld.flag49 02139 # endif 02140 02141 # ifdef _DEBUG 02142 # define ATP_DUMMY_PROC_LINK(IDX) \ 02143 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02144 attr_tbl[IDX].fld.field2 == Dummy_Proc) ? \ 02145 attr_tbl : sytb_var_error("ATP_DUMMY_PROC_LINK", IDX)) \ 02146 [IDX].fld.field4 02147 # else 02148 # define ATP_DUMMY_PROC_LINK(IDX) attr_tbl[IDX].fld.field4 02149 # endif 02150 02151 # ifdef _DEBUG 02152 # define ATP_DUPLICATE_INTERFACE_IDX(IDX) \ 02153 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02154 attr_aux_tbl:attr_aux_var_error("ATP_DUPLICATE_INTERFACE_IDX",IDX)) \ 02155 [IDX].fld.field4 02156 # else 02157 # define ATP_DUPLICATE_INTERFACE_IDX(IDX) attr_aux_tbl[IDX].fld.field4 02158 # endif 02159 02160 /* 02161 March# ifdef _DEBUG 02162 # define ATP_ELEMENTAL(IDX) \ 02163 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02164 attr_tbl : sytb_var_error("ATP_ELEMENTAL", IDX)) \ 02165 [IDX].fld.flag31 02166 # else 02167 */ 02168 # define ATP_ELEMENTAL(IDX) attr_tbl[IDX].fld.flag31 02169 /* # endif */ 02170 02171 # ifdef _DEBUG 02172 # define ATP_ENTRY_LABEL_SH_IDX(IDX) \ 02173 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02174 attr_aux_tbl:attr_aux_var_error("ATP_ENTRY_LABEL_SH_IDX",IDX)) \ 02175 [IDX].fld.field3 02176 # else 02177 # define ATP_ENTRY_LABEL_SH_IDX(IDX) attr_aux_tbl[IDX].fld.field3 02178 # endif 02179 02180 # ifdef _DEBUG 02181 # define ATP_EXT_NAME_IDX(IDX) \ 02182 (AT_OBJ_CLASS(IDX) == Pgm_Unit ? \ 02183 attr_tbl : sytb_var_error("ATP_EXT_NAME_IDX", IDX)) \ 02184 [IDX].fld.field13 02185 # else 02186 # define ATP_EXT_NAME_IDX(IDX) attr_tbl[IDX].fld.field13 02187 # endif 02188 02189 # define ATP_EXT_NAME(IDX) name_pool[ATP_EXT_NAME_IDX(IDX)].name_char 02190 # define ATP_EXT_NAME_LONG(IDX) &(name_pool[ATP_EXT_NAME_IDX(IDX)].name_long) 02191 # define ATP_EXT_NAME_PTR(IDX) &name_pool[ATP_EXT_NAME_IDX(IDX)].name_char 02192 02193 # ifdef _DEBUG 02194 # define ATP_EXT_NAME_LEN(IDX) \ 02195 (AT_OBJ_CLASS(IDX) == Pgm_Unit ? \ 02196 attr_tbl : sytb_var_error("ATP_EXT_NAME_LEN", IDX)) \ 02197 [IDX].fld.field12 02198 # else 02199 # define ATP_EXT_NAME_LEN(IDX) attr_tbl[IDX].fld.field12 02200 # endif 02201 02202 /* # ifdef _DEBUG 02203 # define ATP_EXPL_ITRFC(IDX) \ 02204 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02205 attr_tbl : sytb_var_error("ATP_EXPL_ITRFC", IDX)) \ 02206 [IDX].fld.flag41 02207 # else 02208 */ 02209 # define ATP_EXPL_ITRFC(IDX) attr_tbl[IDX].fld.flag41 02210 /* # endif */ 02211 02212 # ifdef _DEBUG 02213 # define ATP_EXTERNAL_INTRIN(IDX) \ 02214 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02215 attr_tbl : sytb_var_error("ATP_EXTERNAL_INTRIN", IDX)) \ 02216 [IDX].fld.flag43 02217 # else 02218 # define ATP_EXTERNAL_INTRIN(IDX) attr_tbl[IDX].fld.flag43 02219 # endif 02220 02221 /* # ifdef _DEBUG 02222 # define ATP_EXTRA_DARG(IDX) \ 02223 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02224 attr_tbl : sytb_var_error("ATP_EXTRA_DARG", IDX)) \ 02225 [IDX].fld.flag42 02226 # else 02227 */ 02228 # define ATP_EXTRA_DARG(IDX) attr_tbl[IDX].fld.flag42 02229 /* # endif */ 02230 02231 # ifdef _DEBUG 02232 # define ATP_FIRST_IDX(IDX) \ 02233 (((AT_OBJ_CLASS(IDX) == Pgm_Unit) && \ 02234 (attr_tbl[IDX].fld.secondary_info != Module)) || \ 02235 (AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 02236 attr_tbl : sytb_var_error("ATP_FIRST_IDX", IDX)) \ 02237 [IDX].fld.field14 02238 # else 02239 # define ATP_FIRST_IDX(IDX) attr_tbl[IDX].fld.field14 02240 # endif 02241 02242 # ifdef _DEBUG 02243 # define ATP_FIRST_SH_IDX(IDX) \ 02244 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02245 attr_tbl[IDX].fld.secondary_info != Module && \ 02246 attr_tbl[IDX].fld.field2 != Intrin_Proc) ? \ 02247 attr_tbl : sytb_var_error("ATP_FIRST_SH_IDX", IDX)) \ 02248 [IDX].fld.field4 02249 # else 02250 # define ATP_FIRST_SH_IDX(IDX) attr_tbl[IDX].fld.field4 02251 # endif 02252 02253 # ifdef _DEBUG 02254 # define ATP_GLOBAL_ATTR_IDX(IDX) \ 02255 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02256 attr_tbl : sytb_var_error("ATP_GLOBAL_ATTR_IDX", IDX)) \ 02257 [IDX].fld.field16 02258 # else 02259 # define ATP_GLOBAL_ATTR_IDX(IDX) attr_tbl[IDX].fld.field16 02260 # endif 02261 02262 # ifdef _DEBUG 02263 # define ATP_HAS_ALT_RETURN(IDX) \ 02264 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02265 attr_tbl : sytb_var_error("ATP_HAS_ALT_RETURN", IDX)) \ 02266 [IDX].fld.flag9 02267 # else 02268 # define ATP_HAS_ALT_RETURN(IDX) attr_tbl[IDX].fld.flag9 02269 # endif 02270 02271 # ifdef _DEBUG 02272 # define ATP_HAS_OVER_INDEXING(IDX) \ 02273 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02274 attr_tbl : sytb_var_error("ATP_HAS_OVER_INDEXING", IDX)) \ 02275 [IDX].fld.flag26 02276 # else 02277 # define ATP_HAS_OVER_INDEXING(IDX) attr_tbl[IDX].fld.flag26 02278 # endif 02279 02280 # ifdef _DEBUG 02281 # define ATP_HAS_TASK_DIRS(IDX) \ 02282 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02283 attr_tbl : sytb_var_error("ATP_HAS_TASK_DIRS", IDX)) \ 02284 [IDX].fld.flag27 02285 # else 02286 # define ATP_HAS_TASK_DIRS(IDX) attr_tbl[IDX].fld.flag27 02287 # endif 02288 02289 # ifdef _DEBUG 02290 # define ATP_IMPLICIT_USE_MODULE(IDX) \ 02291 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02292 attr_aux_tbl: attr_aux_var_error("ATP_IMPLICIT_USE_MODULE",IDX)) \ 02293 [IDX].fld.flag5 02294 # else 02295 # define ATP_IMPLICIT_USE_MODULE(IDX) attr_aux_tbl[IDX].fld.flag5 02296 # endif 02297 02298 # ifdef _DEBUG 02299 # define ATP_IN_INTERFACE_BLK(IDX) \ 02300 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02301 attr_tbl : sytb_var_error("ATP_IN_INTERFACE_BLK", IDX)) \ 02302 [IDX].fld.flag11 02303 # else 02304 # define ATP_IN_INTERFACE_BLK(IDX) attr_tbl[IDX].fld.flag11 02305 # endif 02306 02307 # ifdef _DEBUG 02308 # define ATP_IN_UNNAMED_INTERFACE(IDX) \ 02309 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02310 attr_tbl : sytb_var_error("ATP_IN_UNNAMED_INTERFACE", IDX)) \ 02311 [IDX].fld.flag18 02312 # else 02313 # define ATP_IN_UNNAMED_INTERFACE(IDX) attr_tbl[IDX].fld.flag18 02314 # endif 02315 02316 # ifdef _DEBUG 02317 # define ATP_INDIRECT_MODULE(IDX) \ 02318 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02319 attr_aux_tbl : attr_aux_var_error("ATP_INDIRECT_MODULE", IDX)) \ 02320 [IDX].fld.flag2 02321 # else 02322 # define ATP_INDIRECT_MODULE(IDX) attr_aux_tbl[IDX].fld.flag2 02323 # endif 02324 02325 # ifdef _DEBUG 02326 # define ATP_INLINE_ALWAYS(IDX) \ 02327 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02328 attr_tbl : sytb_var_error("ATP_INLINE_ALWAYS", IDX)) \ 02329 [IDX].fld.flag22 02330 # else 02331 # define ATP_INLINE_ALWAYS(IDX) attr_tbl[IDX].fld.flag22 02332 # endif 02333 02334 # ifdef _DEBUG 02335 # define ATP_INLINE_NEVER(IDX) \ 02336 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02337 attr_tbl : sytb_var_error("ATP_INLINE_NEVER", IDX)) \ 02338 [IDX].fld.flag23 02339 # else 02340 # define ATP_INLINE_NEVER(IDX) attr_tbl[IDX].fld.flag23 02341 # endif 02342 02343 /* 02344 March # ifdef _DEBUG 02345 # define ATP_INTERFACE_IDX(IDX) \ 02346 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02347 attr_tbl[IDX].fld.field2 == Intrin_Proc) ? \ 02348 attr_tbl : sytb_var_error("ATP_INTERFACE_IDX", IDX)) \ 02349 [IDX].fld.field4 02350 # else 02351 */ 02352 # define ATP_INTERFACE_IDX(IDX) attr_tbl[IDX].fld.field4 02353 /* # endif */ 02354 02355 /* 02356 March# ifdef _DEBUG 02357 # define ATP_INTRIN_ENUM(IDX) \ 02358 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02359 attr_tbl[IDX].fld.field2 == Intrin_Proc) ? \ 02360 attr_tbl : sytb_var_error("ATP_INTRIN_ENUM", IDX)) \ 02361 [IDX].fld.field10 02362 # else 02363 */ 02364 # define ATP_INTRIN_ENUM(IDX) attr_tbl[IDX].fld.field10 02365 /* # endif */ 02366 02367 # ifdef _DEBUG 02368 # define ATP_IN_CURRENT_COMPILE(IDX) \ 02369 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02370 attr_aux_tbl: attr_aux_var_error("ATP_IN_CURRENT_COMPILE",IDX))\ 02371 [IDX].fld.flag4 02372 # else 02373 # define ATP_IN_CURRENT_COMPILE(IDX) attr_aux_tbl[IDX].fld.flag4 02374 # endif 02375 02376 # ifdef _DEBUG 02377 # define ATP_MAY_INLINE(IDX) \ 02378 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02379 attr_tbl : sytb_var_error("ATP_MAY_INLINE", IDX)) \ 02380 [IDX].fld.flag21 02381 # else 02382 # define ATP_MAY_INLINE(IDX) attr_tbl[IDX].fld.flag21 02383 # endif 02384 02385 # ifdef _DEBUG 02386 # define ATP_MOD_PATH_IDX(IDX) \ 02387 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02388 attr_tbl[IDX].fld.secondary_info == Module) ? \ 02389 attr_tbl : sytb_var_error("ATP_MOD_PATH_IDX", IDX)) \ 02390 [IDX].fld.field4 02391 # else 02392 # define ATP_MOD_PATH_IDX(IDX) attr_tbl[IDX].fld.field4 02393 # endif 02394 02395 # define ATP_MOD_PATH_NAME_PTR(IDX) &name_pool[ATP_MOD_PATH_IDX(IDX)].name_char 02396 02397 # ifdef _DEBUG 02398 # define ATP_MOD_PATH_LEN(IDX) \ 02399 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02400 attr_tbl[IDX].fld.secondary_info == Module) ? \ 02401 attr_tbl : sytb_var_error("ATP_MOD_PATH_LEN", IDX)) \ 02402 [IDX].fld.field6 02403 # else 02404 # define ATP_MOD_PATH_LEN(IDX) attr_tbl[IDX].fld.field6 02405 # endif 02406 02407 # ifdef _DEBUG 02408 # define ATP_MODULE_STR_IDX(IDX) \ 02409 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02410 attr_tbl[IDX].fld.secondary_info == Module) ? \ 02411 attr_tbl : sytb_var_error("ATP_MODULE_STR_IDX", IDX)) \ 02412 [IDX].fld.field10 02413 # else 02414 # define ATP_MODULE_STR_IDX(IDX) attr_tbl[IDX].fld.field10 02415 # endif 02416 02417 /* # ifdef _DEBUG 02418 # define ATP_NAME_IN_STONE(IDX) \ 02419 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02420 attr_tbl : sytb_var_error("ATP_NAME_IN_STONE", IDX)) \ 02421 [IDX].fld.flag20 02422 # else 02423 */ 02424 # define ATP_NAME_IN_STONE(IDX) attr_tbl[IDX].fld.flag20 02425 /* # endif */ 02426 02427 # ifdef _DEBUG 02428 # define ATP_NO_ENTRY_LIST(IDX) \ 02429 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02430 attr_aux_tbl : attr_aux_var_error("ATP_NO_ENTRY_LIST", IDX)) \ 02431 [IDX].fld.field1 02432 # else 02433 # define ATP_NO_ENTRY_LIST(IDX) attr_aux_tbl[IDX].fld.field1 02434 # endif 02435 02436 # ifdef _DEBUG 02437 # define ATP_NON_ANSI_INTRIN(IDX) \ 02438 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02439 attr_tbl : sytb_var_error("ATP_NON_ANSI_INTRIN", IDX)) \ 02440 [IDX].fld.flag6 02441 # else 02442 # define ATP_NON_ANSI_INTRIN(IDX) attr_tbl[IDX].fld.flag6 02443 # endif 02444 02445 # ifdef _DEBUG 02446 # define ATP_NOSIDE_EFFECTS(IDX) \ 02447 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02448 attr_tbl : sytb_var_error("ATP_NOSIDE_EFFECTS", IDX)) \ 02449 [IDX].fld.flag5 02450 # else 02451 # define ATP_NOSIDE_EFFECTS(IDX) attr_tbl[IDX].fld.flag5 02452 # endif 02453 02454 # ifdef _DEBUG 02455 # define ATP_NUM_DARGS(IDX) \ 02456 (((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02457 attr_tbl[IDX].fld.secondary_info != Module) || \ 02458 AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 02459 attr_tbl : sytb_var_error("ATP_NUM_DARGS", IDX)) \ 02460 [IDX].fld.field6 02461 # else 02462 # define ATP_NUM_DARGS(IDX) attr_tbl[IDX].fld.field6 02463 # endif 02464 02465 # ifdef _DEBUG 02466 # define ATP_PARENT_IDX(IDX) \ 02467 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02468 attr_tbl[IDX].fld.secondary_info != Module) ? \ 02469 attr_tbl : sytb_var_error("ATP_PARENT_IDX", IDX)) \ 02470 [IDX].fld.field10 02471 # else 02472 # define ATP_PARENT_IDX(IDX) attr_tbl[IDX].fld.field10 02473 # endif 02474 02475 # ifdef _DEBUG 02476 # define ATP_PGM_UNIT(IDX) \ 02477 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02478 attr_tbl : sytb_var_error("ATP_PGM_UNIT", IDX)) \ 02479 [IDX].fld.secondary_info 02480 # else 02481 # define ATP_PGM_UNIT(IDX) attr_tbl[IDX].fld.secondary_info 02482 # endif 02483 02484 # ifdef _DEBUG 02485 # define ATP_OPTIONAL_DIR(IDX) \ 02486 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02487 attr_tbl : sytb_var_error("ATP_OPTIONAL_DIR", IDX)) \ 02488 [IDX].fld.flag44 02489 # else 02490 # define ATP_OPTIONAL_DIR(IDX) attr_tbl[IDX].fld.flag44 02491 # endif 02492 02493 /* # ifdef _DEBUG 02494 # define ATP_PROC(IDX) \ 02495 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02496 attr_tbl : sytb_var_error("ATP_PROC", IDX)) \ 02497 [IDX].fld.field2 02498 # else 02499 */ 02500 # define ATP_PROC(IDX) attr_tbl[IDX].fld.field2 02501 /* # endif */ 02502 02503 # ifdef _DEBUG 02504 # define ATP_PURE(IDX) \ 02505 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02506 attr_tbl : sytb_var_error("ATP_PURE", IDX)) \ 02507 [IDX].fld.flag30 02508 # else 02509 # define ATP_PURE(IDX) attr_tbl[IDX].fld.flag30 02510 # endif 02511 02512 # ifdef _DEBUG 02513 # define ATP_RECURSIVE(IDX) \ 02514 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02515 attr_tbl : sytb_var_error("ATP_RECURSIVE", IDX)) \ 02516 [IDX].fld.flag1 02517 # else 02518 # define ATP_RECURSIVE(IDX) attr_tbl[IDX].fld.flag1 02519 # endif 02520 02521 /* 02522 March# ifdef _DEBUG 02523 # define ATP_RSLT_IDX(IDX) \ 02524 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02525 ATP_PGM_UNIT(IDX) != Module) ? \ 02526 attr_tbl : sytb_var_error("ATP_RSLT_IDX", IDX)) \ 02527 [IDX].fld.field8 02528 # else 02529 */ 02530 # define ATP_RSLT_IDX(IDX) attr_tbl[IDX].fld.field8 02531 /* # endif */ 02532 02533 # ifdef _DEBUG 02534 # define ATP_RSLT_NAME(IDX) \ 02535 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02536 attr_tbl : sytb_var_error("ATP_RSLT_NAME", IDX)) \ 02537 [IDX].fld.flag12 02538 # else 02539 # define ATP_RSLT_NAME(IDX) attr_tbl[IDX].fld.flag12 02540 # endif 02541 02542 # ifdef _DEBUG 02543 # define ATP_SAVE_ALL(IDX) \ 02544 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02545 attr_tbl : sytb_var_error("ATP_SAVE_ALL", IDX)) \ 02546 [IDX].fld.flag34 02547 # else 02548 # define ATP_SAVE_ALL(IDX) attr_tbl[IDX].fld.flag34 02549 # endif 02550 02551 # ifdef _DEBUG 02552 # define ATP_SCP_ALIVE(IDX) \ 02553 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02554 attr_tbl : sytb_var_error("ATP_SCP_ALIVE", IDX)) \ 02555 [IDX].fld.flag8 02556 # else 02557 # define ATP_SCP_ALIVE(IDX) attr_tbl[IDX].fld.flag8 02558 # endif 02559 02560 # ifdef _DEBUG 02561 # define ATP_SCP_IDX(IDX) \ 02562 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02563 attr_aux_tbl : attr_aux_var_error("ATP_SCP_IDX", IDX)) \ 02564 [IDX].fld.field5 02565 # else 02566 # define ATP_SCP_IDX(IDX) attr_aux_tbl[IDX].fld.field5 02567 # endif 02568 02569 # ifdef _DEBUG 02570 # define ATP_SGI_LOCAL_INLINE(IDX) \ 02571 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02572 attr_aux_tbl : attr_aux_var_error("ATP_SGI_LOCAL_INLINE",IDX)) \ 02573 [IDX].fld.flag6 02574 # else 02575 # define ATP_SGI_LOCAL_INLINE(IDX) attr_aux_tbl[IDX].fld.flag6 02576 # endif 02577 02578 # ifdef _DEBUG 02579 # define ATP_SGI_LOCAL_NOINLINE(IDX) \ 02580 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02581 attr_aux_tbl : attr_aux_var_error("ATP_SGI_LOCAL_NOINLINE",IDX)) \ 02582 [IDX].fld.flag7 02583 # else 02584 # define ATP_SGI_LOCAL_NOINLINE(IDX) attr_aux_tbl[IDX].fld.flag7 02585 # endif 02586 02587 # ifdef _DEBUG 02588 # define ATP_SGI_GLOBAL_INLINE(IDX) \ 02589 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02590 attr_tbl : sytb_var_error("ATP_SGI_GLOBAL_INLINE", IDX)) \ 02591 [IDX].fld.flag35 02592 # else 02593 # define ATP_SGI_GLOBAL_INLINE(IDX) attr_tbl[IDX].fld.flag35 02594 # endif 02595 02596 # ifdef _DEBUG 02597 # define ATP_SGI_GLOBAL_NOINLINE(IDX) \ 02598 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02599 attr_tbl : sytb_var_error("ATP_SGI_GLOBAL_NOINLINE", IDX)) \ 02600 [IDX].fld.flag36 02601 # else 02602 # define ATP_SGI_GLOBAL_NOINLINE(IDX) attr_tbl[IDX].fld.flag36 02603 # endif 02604 02605 # ifdef _DEBUG 02606 # define ATP_SGI_ROUTINE_INLINE(IDX) \ 02607 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02608 attr_tbl : sytb_var_error("ATP_SGI_ROUTINE_INLINE", IDX)) \ 02609 [IDX].fld.flag38 02610 # else 02611 # define ATP_SGI_ROUTINE_INLINE(IDX) attr_tbl[IDX].fld.flag38 02612 # endif 02613 02614 # ifdef _DEBUG 02615 # define ATP_SGI_ROUTINE_NOINLINE(IDX) \ 02616 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02617 attr_tbl : sytb_var_error("ATP_SGI_ROUTINE_NOINLINE", IDX)) \ 02618 [IDX].fld.flag37 02619 # else 02620 # define ATP_SGI_ROUTINE_NOINLINE(IDX) attr_tbl[IDX].fld.flag37 02621 # endif 02622 02623 # ifdef _DEBUG 02624 # define ATP_STACK_DIR(IDX) \ 02625 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02626 attr_tbl : sytb_var_error("ATP_STACK_DIR", IDX)) \ 02627 [IDX].fld.flag7 02628 # else 02629 # define ATP_STACK_DIR(IDX) attr_tbl[IDX].fld.flag7 02630 # endif 02631 02632 # ifdef _DEBUG 02633 # define ATP_SYMMETRIC(IDX) \ 02634 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02635 attr_tbl : sytb_var_error("ATP_SYMMETRIC", IDX)) \ 02636 [IDX].fld.flag28 02637 # else 02638 # define ATP_SYMMETRIC(IDX) attr_tbl[IDX].fld.flag28 02639 # endif 02640 02641 # ifdef _DEBUG 02642 # define ATP_SYSTEM_MODULE(IDX) \ 02643 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02644 attr_aux_tbl : attr_aux_var_error("ATP_SYSTEM_MODULE", IDX)) \ 02645 [IDX].fld.flag3 02646 # else 02647 # define ATP_SYSTEM_MODULE(IDX) attr_aux_tbl[IDX].fld.flag3 02648 # endif 02649 02650 # ifdef _DEBUG 02651 # define ATP_TASK_SHARED(IDX) \ 02652 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02653 attr_tbl : sytb_var_error("ATP_TASK_SHARED", IDX)) \ 02654 [IDX].fld.flag19 02655 # else 02656 # define ATP_TASK_SHARED(IDX) attr_tbl[IDX].fld.flag19 02657 # endif 02658 02659 # ifdef _DEBUG 02660 # define ATP_USE_LIST(IDX) \ 02661 ((AT_OBJ_CLASS(IDX) == Pgm_Unit && \ 02662 attr_tbl[IDX].fld.secondary_info == Module) ? \ 02663 attr_aux_tbl : attr_aux_var_error("ATP_USE_LIST", IDX)) \ 02664 [IDX].fld.field2 02665 # else 02666 # define ATP_USE_LIST(IDX) attr_aux_tbl[IDX].fld.field2 02667 # endif 02668 02669 # ifdef _DEBUG 02670 # define ATP_USE_TYPE(IDX) \ 02671 (AT_OBJ_CLASS(IDX) == Pgm_Unit ? \ 02672 attr_tbl : sytb_var_error("ATP_USE_TYPE", IDX)) \ 02673 [IDX].fld.field3 02674 # else 02675 # define ATP_USE_TYPE(IDX) attr_tbl[IDX].fld.field3 02676 # endif 02677 02678 # ifdef _DEBUG 02679 # define ATP_USES_EREGS(IDX) \ 02680 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02681 attr_tbl : sytb_var_error("ATP_USES_EREGS", IDX)) \ 02682 [IDX].fld.flag29 02683 # else 02684 # define ATP_USES_EREGS(IDX) attr_tbl[IDX].fld.flag29 02685 # endif 02686 02687 # ifdef _DEBUG 02688 # define ATP_VFUNCTION(IDX) \ 02689 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02690 attr_tbl : sytb_var_error("ATP_VFUNCTION", IDX)) \ 02691 [IDX].fld.flag4 02692 # else 02693 # define ATP_VFUNCTION(IDX) attr_tbl[IDX].fld.flag4 02694 # endif 02695 02696 /* add a flag for coarray fortran "cosubroutine" and "cofunction" */ 02697 # ifdef _DEBUG 02698 # define ATP_COARRAY_CONCURRENT(IDX) \ 02699 ((AT_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 02700 attr_tbl : sytb_var_error("ATP_COARRAY_CONCURRENT", IDX)) \ 02701 [IDX].fld.is_concurrent 02702 # else 02703 # define ATP_COARRAY_CONCURRENT(IDX) attr_tbl[IDX].fld.is_concurrent 02704 # endif 02705 02706 02707 02708 02709 02710 /* Symbol table definitions for statement functions. */ 02711 02712 # ifdef _DEBUG 02713 # define ATS_SF_ACTIVE(IDX) \ 02714 ((AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 02715 attr_tbl : sytb_var_error("ATS_SF_ACTIVE", IDX)) \ 02716 [IDX].fld.flag1 02717 # else 02718 # define ATS_SF_ACTIVE(IDX) attr_tbl[IDX].fld.flag1 02719 # endif 02720 02721 # ifdef _DEBUG 02722 # define ATS_SF_FLD(IDX) \ 02723 ((AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 02724 attr_tbl : sytb_var_error("ATS_SF_FLD", IDX)) \ 02725 [IDX].fld.secondary_info 02726 # else 02727 # define ATS_SF_FLD(IDX) attr_tbl[IDX].fld.secondary_info 02728 # endif 02729 02730 # ifdef _DEBUG 02731 # define ATS_SF_IDX(IDX) \ 02732 ((AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 02733 attr_tbl : sytb_var_error("ATS_SF_IDX", IDX)) \ 02734 [IDX].fld.field4 02735 # else 02736 # define ATS_SF_IDX(IDX) attr_tbl[IDX].fld.field4 02737 # endif 02738 02739 # ifdef _DEBUG 02740 # define ATS_SF_SEMANTICS_DONE(IDX) \ 02741 ((AT_OBJ_CLASS(IDX) == Stmt_Func) ? \ 02742 attr_tbl : sytb_var_error("ATS_SF_SEMANTICS_DONE", IDX)) \ 02743 [IDX].fld.flag2 02744 # else 02745 # define ATS_SF_SEMANTICS_DONE(IDX) attr_tbl[IDX].fld.flag2 02746 # endif 02747 02748 02749 /* definitions for derived types - ATT */ 02750 02751 /* Remove in 5.0 */ 02752 02753 # ifdef _DEBUG 02754 # define OLD_ATT_16_BIT_ALIGN(IDX) \ 02755 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02756 attr_tbl : sytb_var_error("OLD_ATT_16_BIT_ALIGN", IDX)) \ 02757 [IDX].fld.flag27 02758 # else 02759 # define OLD_ATT_16_BIT_ALIGN(IDX) attr_tbl[IDX].fld.flag27 02760 # endif 02761 02762 # ifdef _DEBUG 02763 # define OLD_ATT_8_BIT_ALIGN(IDX) \ 02764 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02765 attr_tbl : sytb_var_error("OLD_ATT_8_BIT_ALIGN", IDX)) \ 02766 [IDX].fld.flag28 02767 # else 02768 # define OLD_ATT_8_BIT_ALIGN(IDX) attr_tbl[IDX].fld.flag28 02769 # endif 02770 02771 # ifdef _DEBUG 02772 # define OLD_ATT_HALF_WORD_ALIGN(IDX) \ 02773 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02774 attr_tbl : sytb_var_error("OLD_ATT_HALF_WORD_ALIGN", IDX)) \ 02775 [IDX].fld.flag26 02776 # else 02777 # define OLD_ATT_HALF_WORD_ALIGN(IDX) attr_tbl[IDX].fld.flag26 02778 # endif 02779 02780 02781 /* Since even without any variable associate with a derived type,we still 02782 * need a type table entry,we add ATT_TY_IDX here to record the corresponding 02783 * type table entry in the attr_tbl entry. ---fzhao 02784 */ 02785 02786 # ifdef _DEBUG 02787 # define ATT_TY_IDX(IDX) \ 02788 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02789 attr_tbl : sytb_var_error("ATT_TY_IDX", IDX)) \ 02790 [IDX].fld.field5 02791 # else 02792 # define ATT_TY_IDX(IDX) attr_tbl[IDX].fld.field5 02793 # endif 02794 02795 02796 # ifdef _DEBUG 02797 # define ATT_ALIGNMENT(IDX) \ 02798 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02799 attr_tbl : sytb_var_error("ATT_ALIGNMENT", IDX)) \ 02800 [IDX].fld.field8 02801 # else 02802 # define ATT_ALIGNMENT(IDX) attr_tbl[IDX].fld.field8 02803 # endif 02804 02805 # ifdef _DEBUG 02806 # define ATT_CHAR_CPNT(IDX) \ 02807 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02808 attr_tbl : sytb_var_error("ATT_CHAR_CPNT", IDX)) \ 02809 [IDX].fld.flag22 02810 # else 02811 # define ATT_CHAR_CPNT(IDX) attr_tbl[IDX].fld.flag22 02812 # endif 02813 02814 # ifdef _DEBUG 02815 # define ATT_CHAR_SEQ(IDX) \ 02816 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02817 attr_tbl : sytb_var_error("ATT_CHAR_SEQ", IDX)) \ 02818 [IDX].fld.flag20 02819 # else 02820 # define ATT_CHAR_SEQ(IDX) attr_tbl[IDX].fld.flag20 02821 # endif 02822 02823 # ifdef _DEBUG 02824 # define ATT_CIF_DT_ID(IDX) \ 02825 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02826 attr_aux_tbl : attr_aux_var_error("ATT_CIF_DT_ID", IDX)) \ 02827 [IDX].fld.field4 02828 # else 02829 # define ATT_CIF_DT_ID(IDX) attr_aux_tbl[IDX].fld.field4 02830 # endif 02831 02832 # ifdef _DEBUG 02833 # define ATT_DALIGN_ME(IDX) \ 02834 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02835 attr_tbl : sytb_var_error("ATT_DALIGN_ME", IDX)) \ 02836 [IDX].fld.flag24 02837 # else 02838 # define ATT_DALIGN_ME(IDX) attr_tbl[IDX].fld.flag24 02839 # endif 02840 02841 # ifdef _DEBUG 02842 # define ATT_DCL_NUMERIC_SEQ(IDX) \ 02843 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02844 attr_tbl : sytb_var_error("ATT_DCL_NUMERIC_SEQ", IDX)) \ 02845 [IDX].fld.flag25 02846 # else 02847 # define ATT_DCL_NUMERIC_SEQ(IDX) attr_tbl[IDX].fld.flag25 02848 # endif 02849 02850 # ifdef _DEBUG 02851 # define ATT_DEFAULT_INITIALIZED(IDX) \ 02852 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02853 attr_tbl : sytb_var_error("ATT_DEFAULT_INITIALIZED", IDX)) \ 02854 [IDX].fld.flag29 02855 # else 02856 # define ATT_DEFAULT_INITIALIZED(IDX) attr_tbl[IDX].fld.flag29 02857 # endif 02858 02859 # ifdef _DEBUG 02860 # define ATT_FIRST_CPNT_IDX(IDX) \ 02861 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02862 attr_tbl : sytb_var_error("ATT_FIRST_CPNT_IDX", IDX)) \ 02863 [IDX].fld.field10 02864 # else 02865 # define ATT_FIRST_CPNT_IDX(IDX) attr_tbl[IDX].fld.field10 02866 # endif 02867 02868 # ifdef _DEBUG 02869 # define ATT_GLOBAL_TYPE_IDX(IDX) \ 02870 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02871 attr_tbl : sytb_var_error("ATT_GLOBAL_TYPE_IDX", IDX)) \ 02872 [IDX].fld.field6 02873 # else 02874 # define ATT_GLOBAL_TYPE_IDX(IDX) attr_tbl[IDX].fld.field6 02875 # endif 02876 02877 # ifdef _DEBUG 02878 # define ATT_LABEL_LIST_IDX(IDX) \ 02879 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02880 attr_aux_tbl : attr_aux_var_error("ATT_LABEL_LIST_IDX", IDX)) \ 02881 [IDX].fld.field2 02882 # else 02883 # define ATT_LABEL_LIST_IDX(IDX) attr_aux_tbl[IDX].fld.field2 02884 # endif 02885 02886 # ifdef _DEBUG 02887 # define ATT_NON_DEFAULT_CPNT(IDX) \ 02888 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02889 attr_tbl : sytb_var_error("ATT_NON_DEFAULT_CPNT", IDX)) \ 02890 [IDX].fld.flag23 02891 # else 02892 # define ATT_NON_DEFAULT_CPNT(IDX) attr_tbl[IDX].fld.flag23 02893 # endif 02894 02895 02896 /* fzhao from 5==>_m*/ 02897 # ifdef _DEBUG 02898 # define ATT_NUM_CPNTS(IDX) \ 02899 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02900 attr_tbl : sytb_var_error("ATT_NUM_CPNTS", IDX)) \ 02901 [IDX].fld.field_m 02902 # else 02903 # define ATT_NUM_CPNTS(IDX) attr_tbl[IDX].fld.field_m 02904 # endif 02905 02906 # ifdef _DEBUG 02907 # define ATT_NUMERIC_CPNT(IDX) \ 02908 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02909 attr_tbl : sytb_var_error("ATT_NUMERIC_CPNT", IDX)) \ 02910 [IDX].fld.flag21 02911 # else 02912 # define ATT_NUMERIC_CPNT(IDX) attr_tbl[IDX].fld.flag21 02913 # endif 02914 02915 # ifdef _DEBUG 02916 # define ATT_POINTER_CPNT(IDX) \ 02917 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02918 attr_tbl : sytb_var_error("ATT_POINTER_CPNT", IDX)) \ 02919 [IDX].fld.flag19 02920 # else 02921 # define ATT_POINTER_CPNT(IDX) attr_tbl[IDX].fld.flag19 02922 # endif 02923 02924 # ifdef _DEBUG 02925 # define ATT_PRIVATE_CPNT(IDX) \ 02926 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02927 attr_tbl : sytb_var_error("ATT_PRIVATE_CPNT", IDX)) \ 02928 [IDX].fld.flag17 02929 # else 02930 # define ATT_PRIVATE_CPNT(IDX) attr_tbl[IDX].fld.flag17 02931 # endif 02932 02933 # ifdef _DEBUG 02934 # define ATT_SCP_IDX(IDX) \ 02935 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02936 attr_aux_tbl : attr_aux_var_error("ATT_SCP_IDX", IDX)) \ 02937 [IDX].fld.field1 02938 # else 02939 # define ATT_SCP_IDX(IDX) attr_aux_tbl[IDX].fld.field1 02940 # endif 02941 02942 # ifdef _DEBUG 02943 # define ATT_SEQUENCE_SET(IDX) \ 02944 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02945 attr_tbl : sytb_var_error("ATT_SEQUENCE_SET", IDX)) \ 02946 [IDX].fld.flag18 02947 # else 02948 # define ATT_SEQUENCE_SET(IDX) attr_tbl[IDX].fld.flag18 02949 # endif 02950 02951 # ifdef _DEBUG 02952 # define ATT_STRUCT_BIT_LEN_FLD(IDX) \ 02953 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02954 attr_tbl : sytb_var_error("ATT_STRUCT_BIT_LEN_FLD", IDX)) \ 02955 [IDX].fld2.field22 02956 # else 02957 # define ATT_STRUCT_BIT_LEN_FLD(IDX) attr_tbl[IDX].fld2.field22 02958 # endif 02959 02960 # ifdef _DEBUG 02961 # define ATT_STRUCT_BIT_LEN_IDX(IDX) \ 02962 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02963 attr_tbl : sytb_var_error("ATT_STRUCT_BIT_LEN_IDX", IDX)) \ 02964 [IDX].fld.field13 02965 # else 02966 # define ATT_STRUCT_BIT_LEN_IDX(IDX) attr_tbl[IDX].fld.field13 02967 # endif 02968 02969 # ifdef _DEBUG 02970 # define ATT_UNIQUE_ID(IDX) \ 02971 ((AT_OBJ_CLASS(IDX) == Derived_Type) ? \ 02972 attr_aux_tbl : attr_aux_var_error("ATT_UNIQUE_ID", IDX)) \ 02973 [IDX].fld.field3 02974 # else 02975 # define ATT_UNIQUE_ID(IDX) attr_aux_tbl[IDX].fld.field3 02976 # endif 02977 02978 02979 02980 /* ATTR LIST TABLE */ 02981 02982 # define AL_ATTR_IDX(IDX) attr_list_tbl[IDX].attr_idx 02983 # define AL_EQ_IDX(IDX) attr_list_tbl[IDX].attr_idx 02984 # define AL_NEXT_IDX(IDX) attr_list_tbl[IDX].next_idx 02985 # define AL_IDX_IS_EQ(IDX) attr_list_tbl[IDX].flag1 02986 # define AL_FREE(IDX) attr_list_tbl[IDX].flag2 02987 02988 /* prev_idx field is a special field available for specific */ 02989 /* uses and it is overloaded. If you use it, give it a */ 02990 /* specific name for its use and be careful. */ 02991 02992 # define AL_ENTRY_COUNT(IDX) attr_list_tbl[IDX].prev_idx 02993 # define AL_PREV_MODULE_IDX(IDX) attr_list_tbl[IDX].prev_idx 02994 02995 02996 /* BOUNDS TABLE - Common */ 02997 02998 # define BD_ARRAY_CLASS(IDX) bounds_tbl[IDX].hdr.array_class 02999 # define BD_ARRAY_SIZE(IDX) bounds_tbl[IDX].hdr.array_size 03000 # define BD_COLUMN_NUM(IDX) bounds_tbl[IDX].hdr.column_num 03001 # define BD_DCL_ERR(IDX) bounds_tbl[IDX].hdr.error 03002 # define BD_DIST_NTRY(IDX) bounds_tbl[IDX].hdr.dist_ntry 03003 # define BD_DISTRIBUTE_RESHAPE(IDX) bounds_tbl[IDX].hdr.dist_reshape 03004 # define BD_GLOBAL_IDX(IDX) bounds_tbl[IDX].hdr.global_idx 03005 # define BD_LEN_FLD(IDX) bounds_tbl[IDX].hdr.len_fld 03006 # define BD_LEN_IDX(IDX) bounds_tbl[IDX].hdr.len_idx 03007 # define BD_LINE_NUM(IDX) bounds_tbl[IDX].hdr.line_num 03008 # define BD_NEXT_FREE_NTRY(IDX) bounds_tbl[IDX].hdr.next_free_ntry 03009 # define BD_NTRY_SIZE(IDX) bounds_tbl[IDX].hdr.ntry_size 03010 # define BD_RANK(IDX) bounds_tbl[IDX].hdr.rank 03011 # define BD_RESOLVED(IDX) bounds_tbl[IDX].hdr.resolved 03012 # define BD_USED_NTRY(IDX) bounds_tbl[IDX].hdr.used_ntry 03013 # define BD_FLOW_DEPENDENT(IDX) bounds_tbl[IDX].hdr.flow_dep 03014 03015 03016 /* BOUNDS TABLE - Dimensions */ 03017 03018 # ifdef _DEBUG 03019 # define BD_LB_FLD(IDX,DIM) \ 03020 ((!BD_DIST_NTRY(IDX)) ? \ 03021 bounds_tbl : bd_var_error("BD_LB_FLD", IDX)) \ 03022 [(IDX)+(DIM)].dim.lb_fld 03023 # else 03024 # define BD_LB_FLD(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.lb_fld 03025 # endif 03026 03027 # ifdef _DEBUG 03028 # define BD_LB_IDX(IDX,DIM) \ 03029 ((!BD_DIST_NTRY(IDX)) ? \ 03030 bounds_tbl : bd_var_error("BD_LB_IDX", IDX)) \ 03031 [(IDX)+(DIM)].dim.lb_idx 03032 # else 03033 # define BD_LB_IDX(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.lb_idx 03034 # endif 03035 03036 # ifdef _DEBUG 03037 # define BD_SM_IDX(IDX,DIM) \ 03038 ((!BD_DIST_NTRY(IDX)) ? \ 03039 bounds_tbl : bd_var_error("BD_SM_IDX", IDX)) \ 03040 [(IDX)+(DIM)].dim.sm_idx 03041 # else 03042 # define BD_SM_IDX(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.sm_idx 03043 # endif 03044 03045 # ifdef _DEBUG 03046 # define BD_SM_FLD(IDX,DIM) \ 03047 ((!BD_DIST_NTRY(IDX)) ? \ 03048 bounds_tbl : bd_var_error("BD_SM_FLD", IDX)) \ 03049 [(IDX)+(DIM)].dim.sm_fld 03050 # else 03051 # define BD_SM_FLD(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.sm_fld 03052 # endif 03053 03054 # ifdef _DEBUG 03055 # define BD_UB_FLD(IDX,DIM) \ 03056 ((!BD_DIST_NTRY(IDX)) ? \ 03057 bounds_tbl : bd_var_error("BD_UB_FLD", IDX)) \ 03058 [(IDX)+(DIM)].dim.ub_fld 03059 # else 03060 # define BD_UB_FLD(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.ub_fld 03061 # endif 03062 03063 # ifdef _DEBUG 03064 # define BD_UB_IDX(IDX,DIM) \ 03065 ((!BD_DIST_NTRY(IDX)) ? \ 03066 bounds_tbl : bd_var_error("BD_UB_IDX", IDX)) \ 03067 [(IDX)+(DIM)].dim.ub_idx 03068 # else 03069 # define BD_UB_IDX(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.ub_idx 03070 # endif 03071 03072 # ifdef _DEBUG 03073 # define BD_XT_FLD(IDX,DIM) \ 03074 ((!BD_DIST_NTRY(IDX)) ? \ 03075 bounds_tbl : bd_var_error("BD_XT_FLD", IDX)) \ 03076 [(IDX)+(DIM)].dim.xt_fld 03077 # else 03078 # define BD_XT_FLD(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.xt_fld 03079 # endif 03080 03081 # ifdef _DEBUG 03082 # define BD_XT_IDX(IDX,DIM) \ 03083 ((!BD_DIST_NTRY(IDX)) ? \ 03084 bounds_tbl : bd_var_error("BD_XT_IDX", IDX)) \ 03085 [(IDX)+(DIM)].dim.xt_idx 03086 # else 03087 # define BD_XT_IDX(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dim.xt_idx 03088 # endif 03089 03090 /* BOUNDS TABLE - Distribution Info */ 03091 03092 # ifdef _DEBUG 03093 # define BD_CYCLIC_FLD(IDX,DIM) \ 03094 ((BD_DIST_NTRY(IDX)) ? \ 03095 bounds_tbl : bd_var_error("BD_CYCLIC_FLD", IDX)) \ 03096 [(IDX)+(DIM)].dist.cyclic_fld 03097 # else 03098 # define BD_CYCLIC_FLD(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dist.cyclic_fld 03099 # endif 03100 03101 # ifdef _DEBUG 03102 # define BD_CYCLIC_IDX(IDX,DIM) \ 03103 ((BD_DIST_NTRY(IDX)) ? \ 03104 bounds_tbl : bd_var_error("BD_CYCLIC_IDX", IDX)) \ 03105 [(IDX)+(DIM)].dist.cyclic_idx 03106 # else 03107 # define BD_CYCLIC_IDX(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dist.cyclic_idx 03108 # endif 03109 03110 # ifdef _DEBUG 03111 # define BD_ONTO_FLD(IDX,DIM) \ 03112 ((BD_DIST_NTRY(IDX)) ? \ 03113 bounds_tbl : bd_var_error("BD_ONTO_FLD", IDX)) \ 03114 [(IDX)+(DIM)].dist.onto_fld 03115 # else 03116 # define BD_ONTO_FLD(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dist.onto_fld 03117 # endif 03118 03119 # ifdef _DEBUG 03120 # define BD_ONTO_IDX(IDX,DIM) \ 03121 ((BD_DIST_NTRY(IDX)) ? \ 03122 bounds_tbl : bd_var_error("BD_ONTO_IDX", IDX)) \ 03123 [(IDX)+(DIM)].dist.onto_idx 03124 # else 03125 # define BD_ONTO_IDX(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dist.onto_idx 03126 # endif 03127 03128 # ifdef _DEBUG 03129 # define BD_DISTRIBUTION(IDX,DIM) \ 03130 ((BD_DIST_NTRY(IDX)) ? \ 03131 bounds_tbl : bd_var_error("BD_DISTRIBUTION", IDX)) \ 03132 [(IDX)+(DIM)].dist.distribution 03133 # else 03134 # define BD_DISTRIBUTION(IDX,DIM) bounds_tbl[(IDX)+(DIM)].dist.distribution 03135 # endif 03136 03137 03138 /* CONSTANT TABLE, CONSTANT SEARCH TABLE and CONSTANT POOL definitions */ 03139 03140 # define CS_CN_IDX(IDX) const_search_tbl[IDX].const_tbl_idx 03141 03142 # define CN_BOZ_CONSTANT(IDX) const_tbl[IDX].boz_constant 03143 # define CN_BOOLEAN_CONSTANT(IDX) const_tbl[IDX].boolean_constant 03144 # define CN_HOLLERITH_ENDIAN(IDX) const_tbl[IDX].hollerith_endian 03145 # define CN_HOLLERITH_TYPE(IDX) const_tbl[IDX].hollerith_fld 03146 # define CN_EXTRA_ZERO_WORD(IDX) const_tbl[IDX].extra_zero_word 03147 # define CN_POOL_IDX(IDX) const_tbl[IDX].const_pool_idx 03148 # define CN_CONST(IDX) const_pool[CN_POOL_IDX(IDX)] 03149 # define CN_TYPE_IDX(IDX) const_tbl[IDX].type_idx 03150 # define CN_LEFT_CHILD(IDX) const_tbl[IDX].left_child 03151 # define CN_RIGHT_CHILD(IDX) const_tbl[IDX].right_child 03152 # define CN_BALANCE_FACTOR(IDX) const_tbl[IDX].balance_factor 03153 03154 # define CP_CONSTANT(IDX) const_pool[IDX] 03155 03156 03157 /* EQUIV TABLE */ 03158 03159 # define EQ_ATTR_IDX(IDX) equiv_tbl[IDX].attr_idx 03160 # define EQ_COLUMN_NUM(IDX) equiv_tbl[IDX].column_num 03161 # define EQ_DALIGN_ME(IDX) equiv_tbl[IDX].dalign_me 03162 # define EQ_DALIGN_SHIFT(IDX) equiv_tbl[IDX].dalign_shift 03163 # define EQ_DO_NOT_DALIGN(IDX) equiv_tbl[IDX].do_not_dalign 03164 # define EQ_ERROR(IDX) equiv_tbl[IDX].error 03165 # define EQ_GRP_END_IDX(IDX) equiv_tbl[IDX].grp_end_idx 03166 # define EQ_GRP_IDX(IDX) equiv_tbl[IDX].grp_idx 03167 # define EQ_LINE_NUM(IDX) equiv_tbl[IDX].line_num 03168 # define EQ_LIST_IDX(IDX) equiv_tbl[IDX].list_idx 03169 # define EQ_MERGED(IDX) equiv_tbl[IDX].merged 03170 # define EQ_NEXT_EQUIV_GRP(IDX) equiv_tbl[IDX].next_equiv_grp 03171 # define EQ_NEXT_EQUIV_OBJ(IDX) equiv_tbl[IDX].next_equiv_obj 03172 # define EQ_OFFSET_FLD(IDX) equiv_tbl[IDX].fld 03173 # define EQ_OFFSET_IDX(IDX) equiv_tbl[IDX].offset_idx 03174 # define EQ_OPND_FLD(IDX) equiv_tbl[IDX].opnd_fld 03175 # define EQ_OPND_IDX(IDX) equiv_tbl[IDX].opnd_idx 03176 # define EQ_SEARCH_DONE(IDX) equiv_tbl[IDX].search_done 03177 # define EQ_SEMANTICS_DONE(IDX) equiv_tbl[IDX].semantics_done 03178 # define EQ_SUBSTRINGED(IDX) equiv_tbl[IDX].substring 03179 03180 03181 /* FILE PATH TABLE */ 03182 03183 # define FP_CIF_ID(IDX) file_path_tbl[IDX].cif_id 03184 # define FP_CLASS(IDX) file_path_tbl[IDX].file_class 03185 # define FP_TMP_FILE(IDX) file_path_tbl[IDX].tmp_file 03186 # define FP_FILE_IDX(IDX) file_path_tbl[IDX].file_idx 03187 # define FP_MODULE_IDX(IDX) file_path_tbl[IDX].next_idx 03188 # define FP_MODULE_INLINE_IDX(IDX) file_path_tbl[IDX].module_inline_idx 03189 # define FP_NAME_IDX(IDX) file_path_tbl[IDX].name_idx 03190 # define FP_NAME_LEN(IDX) file_path_tbl[IDX].name_len 03191 # define FP_NAME(IDX) (str_pool[FP_NAME_IDX(IDX)].name_char) 03192 # define FP_NAME_LONG(IDX) &(str_pool[FP_NAME_IDX(IDX)].name_long) 03193 # define FP_NAME_PTR(IDX) &str_pool[FP_NAME_IDX(IDX)].name_char 03194 # define FP_NEXT_FILE_IDX(IDX) file_path_tbl[IDX].next_file_idx 03195 # define FP_OFFSET(IDX) file_path_tbl[IDX].offset 03196 # define FP_OUTPUT_TO_O(IDX) file_path_tbl[IDX].output_to_o 03197 # define FP_SRCH_THE_FILE(IDX) file_path_tbl[IDX].srch_the_file 03198 # define FP_SYSTEM_FILE(IDX) file_path_tbl[IDX].system_file 03199 03200 /* GLOBAL ATTRIBUTE TABLE */ 03201 03202 /* Common attribute definitions for all object classes */ 03203 03204 # define GA_COMPILER_GEND(IDX) global_attr_tbl[IDX].fld.compiler_gend 03205 # define GA_DEF_LINE(IDX) global_attr_tbl[IDX].fld.def_line 03206 # define GA_DEF_COLUMN(IDX) global_attr_tbl[IDX].fld.def_column 03207 # define GA_DEFINED(IDX) global_attr_tbl[IDX].fld.defined 03208 # define GA_MODULE_IDX(IDX) global_attr_tbl[IDX].fld.module_idx 03209 # define GA_NAME_IDX(IDX) global_attr_tbl[IDX].fld.name_idx 03210 # define GA_NAME_LEN(IDX) global_attr_tbl[IDX].fld.length 03211 # define GA_OBJ_CLASS(IDX) global_attr_tbl[IDX].fld.object_class 03212 # define GA_OBJ_NAME_LONG(IDX) &(str_pool[GA_NAME_IDX(IDX)].name_long) 03213 # define GA_OBJ_NAME_PTR(IDX) &str_pool[GA_NAME_IDX(IDX)].name_char 03214 # define GA_OPTIONAL(IDX) global_attr_tbl[IDX].fld.optional 03215 # define GA_ORIG_NAME_LEN(IDX) global_attr_tbl[IDX].fld.orig_name_len 03216 # define GA_ORIG_NAME_IDX(IDX) global_attr_tbl[IDX].fld.orig_name_idx 03217 # define GA_ORIG_NAME_PTR(IDX) &str_pool[GA_ORIG_NAME_IDX(IDX)].name_char 03218 # define GA_ORIG_NAME_LONG(IDX) &(str_pool[GA_ORIG_NAME_IDX(IDX)].name_long) 03219 # define GA_REFERENCED(IDX) global_attr_tbl[IDX].fld.referenced 03220 # define GA_USE_ASSOCIATED(IDX) global_attr_tbl[IDX].fld.use_associated 03221 03222 /* Definitions for data object class */ 03223 03224 # ifdef _DEBUG 03225 # define GAD_ARRAY_ELEMENT_REF(IDX) \ 03226 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03227 global_attr_tbl : ga_var_error("GAD_ARRAY_ELEMENT_REF", IDX)) \ 03228 [IDX].fld.flag5 03229 # else 03230 # define GAD_ARRAY_ELEMENT_REF(IDX) global_attr_tbl[IDX].fld.flag5 03231 # endif 03232 03233 # ifdef _DEBUG 03234 # define GAD_ARRAY_IDX(IDX) \ 03235 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03236 global_attr_tbl : ga_var_error("GAD_ARRAY_IDX", IDX)) \ 03237 [IDX].fld.field3 03238 # else 03239 # define GAD_ARRAY_IDX(IDX) global_attr_tbl[IDX].fld.field3 03240 # endif 03241 03242 # ifdef _DEBUG 03243 # define GAD_ASSUMED_SHAPE_ARRAY(IDX) \ 03244 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03245 global_attr_tbl : ga_var_error("GAD_ASSUMED_SHAPE_ARRAY", IDX))\ 03246 [IDX].fld.flag2 03247 # else 03248 # define GAD_ASSUMED_SHAPE_ARRAY(IDX) global_attr_tbl[IDX].fld.flag2 03249 # endif 03250 03251 # ifdef _DEBUG 03252 # define GAD_CLASS(IDX) \ 03253 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03254 global_attr_tbl : ga_var_error("GAD_CLASS", IDX)) \ 03255 [IDX].fld.field5 03256 # else 03257 # define GAD_CLASS(IDX) global_attr_tbl[IDX].fld.field5 03258 # endif 03259 03260 # ifdef _DEBUG 03261 # define GAD_HOLLERITH(IDX) \ 03262 (((GA_OBJ_CLASS(IDX) == Data_Obj) && \ 03263 (GAD_CLASS(IDX) == Constant)) ? \ 03264 global_attr_tbl : ga_var_error("GAD_HOLLERITH", IDX)) \ 03265 [IDX].fld.field4 03266 # else 03267 # define GAD_HOLLERITH(IDX) global_attr_tbl[IDX].fld.field4 03268 # endif 03269 03270 # ifdef _DEBUG 03271 # define GAD_IGNORE_TKR(IDX) \ 03272 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03273 global_attr_tbl : ga_var_error("GAD_IGNORE_TKR", IDX)) \ 03274 [IDX].fld.flag1 03275 # else 03276 # define GAD_IGNORE_TKR(IDX) global_attr_tbl[IDX].fld.flag1 03277 # endif 03278 03279 # ifdef _DEBUG 03280 # define GAD_INTENT(IDX) \ 03281 (((GA_OBJ_CLASS(IDX) == Data_Obj) && \ 03282 (GAD_CLASS(IDX) == Dummy_Argument)) ? \ 03283 global_attr_tbl : ga_var_error("GAD_INTENT", IDX)) \ 03284 [IDX].fld.field4 03285 # else 03286 # define GAD_INTENT(IDX) global_attr_tbl[IDX].fld.field4 03287 # endif 03288 03289 # ifdef _DEBUG 03290 # define GAD_NEXT_IDX(IDX) \ 03291 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03292 global_attr_tbl : ga_var_error("GAD_NEXT_IDX", IDX)) \ 03293 [IDX].fld.field8 03294 # else 03295 # define GAD_NEXT_IDX(IDX) global_attr_tbl[IDX].fld.field8 03296 # endif 03297 03298 # ifdef _DEBUG 03299 # define GAD_POINTER(IDX) \ 03300 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03301 global_attr_tbl : ga_var_error("GAD_POINTER", IDX)) \ 03302 [IDX].fld.flag3 03303 # else 03304 # define GAD_POINTER(IDX) global_attr_tbl[IDX].fld.flag3 03305 # endif 03306 03307 # ifdef _DEBUG 03308 # define GAD_RANK(IDX) \ 03309 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03310 global_attr_tbl : ga_var_error("GAD_RANK", IDX)) \ 03311 [IDX].fld.field2 03312 # else 03313 # define GAD_RANK(IDX) global_attr_tbl[IDX].fld.field2 03314 # endif 03315 03316 # ifdef _DEBUG 03317 # define GAD_TARGET(IDX) \ 03318 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03319 global_attr_tbl : ga_var_error("GAD_TARGET", IDX)) \ 03320 [IDX].fld.flag4 03321 # else 03322 # define GAD_TARGET(IDX) global_attr_tbl[IDX].fld.flag4 03323 # endif 03324 03325 # ifdef _DEBUG 03326 # define GAD_TYPE_IDX(IDX) \ 03327 ((GA_OBJ_CLASS(IDX) == Data_Obj) ? \ 03328 global_attr_tbl : ga_var_error("GAD_TYPE_IDX", IDX)) \ 03329 [IDX].fld.field1 03330 # else 03331 # define GAD_TYPE_IDX(IDX) global_attr_tbl[IDX].fld.field1 03332 # endif 03333 03334 /* Definitions for common block class */ 03335 03336 # ifdef _DEBUG 03337 # define GAC_ALIGN_SYMBOL(IDX) \ 03338 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03339 global_attr_tbl : ga_var_error("GAC_ALIGN_SYMBOL", IDX)) \ 03340 [IDX].fld.flag5 03341 # else 03342 # define GAC_ALIGN_SYMBOL(IDX) global_attr_tbl[IDX].fld.flag5 03343 # endif 03344 03345 # ifdef _DEBUG 03346 # define GAC_AUXILIARY(IDX) \ 03347 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03348 global_attr_tbl : ga_var_error("GAC_AUXILIARY", IDX)) \ 03349 [IDX].fld.flag1 03350 # else 03351 # define GAC_AUXILIARY(IDX) global_attr_tbl[IDX].fld.flag1 03352 # endif 03353 03354 # ifdef _DEBUG 03355 # define GAC_CACHE_ALIGN(IDX) \ 03356 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03357 global_attr_tbl : ga_var_error("GAC_CACHE_ALIGN", IDX)) \ 03358 [IDX].fld.flag2 03359 # else 03360 # define GAC_CACHE_ALIGN(IDX) global_attr_tbl[IDX].fld.flag2 03361 # endif 03362 03363 # ifdef _DEBUG 03364 # define GAC_EQUIVALENCED(IDX) \ 03365 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03366 global_attr_tbl : ga_var_error("GAC_EQUIVALENCED", IDX)) \ 03367 [IDX].fld.flag4 03368 # else 03369 # define GAC_EQUIVALENCED(IDX) global_attr_tbl[IDX].fld.flag4 03370 # endif 03371 03372 # ifdef _DEBUG 03373 # define GAC_FILL_SYMBOL(IDX) \ 03374 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03375 global_attr_tbl : ga_var_error("GAC_FILL_SYMBOL", IDX)) \ 03376 [IDX].fld.flag6 03377 # else 03378 # define GAC_FILL_SYMBOL(IDX) global_attr_tbl[IDX].fld.flag6 03379 # endif 03380 03381 # ifdef _DEBUG 03382 # define GAC_FIRST_MEMBER_IDX(IDX) \ 03383 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03384 global_attr_tbl : ga_var_error("GAC_FIRST_MEMBER_IDX", IDX)) \ 03385 [IDX].fld.field3 03386 # else 03387 # define GAC_FIRST_MEMBER_IDX(IDX) global_attr_tbl[IDX].fld.field3 03388 # endif 03389 03390 # ifdef _DEBUG 03391 # define GAC_FOUND_DIFFS(IDX) \ 03392 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03393 global_attr_tbl : ga_var_error("GAC_FOUND_DIFFS", IDX)) \ 03394 [IDX].fld.flag7 03395 # else 03396 # define GAC_FOUND_DIFFS(IDX) global_attr_tbl[IDX].fld.flag7 03397 # endif 03398 03399 # ifdef _DEBUG 03400 # define GAC_PGM_UNIT_IDX(IDX) \ 03401 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03402 global_attr_tbl : ga_var_error("GAC_PGM_UNIT_IDX", IDX)) \ 03403 [IDX].fld.field1 03404 # else 03405 # define GAC_PGM_UNIT_IDX(IDX) global_attr_tbl[IDX].fld.field1 03406 # endif 03407 03408 # ifdef _DEBUG 03409 # define GAC_SECTION_GP(IDX) \ 03410 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03411 global_attr_tbl : ga_var_error("GAC_SECTION_GP", IDX)) \ 03412 [IDX].fld.flag8 03413 # else 03414 # define GAC_SECTION_GP(IDX) global_attr_tbl[IDX].fld.flag8 03415 # endif 03416 03417 # ifdef _DEBUG 03418 # define GAC_SECTION_NON_GP(IDX) \ 03419 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03420 global_attr_tbl : ga_var_error("GAC_SECTION_NON_GP", IDX)) \ 03421 [IDX].fld.flag9 03422 # else 03423 # define GAC_SECTION_NON_GP(IDX) global_attr_tbl[IDX].fld.flag9 03424 # endif 03425 03426 # ifdef _DEBUG 03427 # define GAC_TASK_COMMON(IDX) \ 03428 ((GA_OBJ_CLASS(IDX) == Common_Block) ? \ 03429 global_attr_tbl : ga_var_error("GAC_TASK_COMMON", IDX)) \ 03430 [IDX].fld.flag3 03431 # else 03432 # define GAC_TASK_COMMON(IDX) global_attr_tbl[IDX].fld.flag3 03433 # endif 03434 03435 03436 /* Definitions for program unit class */ 03437 03438 # ifdef _DEBUG 03439 # define GAP_ELEMENTAL(IDX) \ 03440 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03441 global_attr_tbl : ga_var_error("GAP_ELEMENTAL", IDX)) \ 03442 [IDX].fld.flag3 03443 # else 03444 # define GAP_ELEMENTAL(IDX) global_attr_tbl[IDX].fld.flag3 03445 # endif 03446 03447 # ifdef _DEBUG 03448 # define GAP_FIRST_IDX(IDX) \ 03449 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03450 global_attr_tbl : ga_var_error("GAP_FIRST_IDX", IDX)) \ 03451 [IDX].fld.field1 03452 # else 03453 # define GAP_FIRST_IDX(IDX) global_attr_tbl[IDX].fld.field1 03454 # endif 03455 03456 # ifdef _DEBUG 03457 # define GAP_FP_IDX(IDX) \ 03458 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03459 global_attr_tbl : ga_var_error("GAP_FP_IDX", IDX)) \ 03460 [IDX].fld.field6 03461 # else 03462 # define GAP_FP_IDX(IDX) global_attr_tbl[IDX].fld.field6 03463 # endif 03464 03465 # ifdef _DEBUG 03466 # define GAP_GLOBAL_DIR(IDX) \ 03467 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03468 global_attr_tbl : ga_var_error("GAP_GLOBAL_DIR", IDX)) \ 03469 [IDX].fld.flag9 03470 # else 03471 # define GAP_GLOBAL_DIR(IDX) global_attr_tbl[IDX].fld.flag9 03472 # endif 03473 03474 # ifdef _DEBUG 03475 # define GAP_IN_INTERFACE_BLK(IDX) \ 03476 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03477 global_attr_tbl : ga_var_error("GAP_IN_INTERFACE_BLK", IDX)) \ 03478 [IDX].fld.flag2 03479 # else 03480 # define GAP_IN_INTERFACE_BLK(IDX) global_attr_tbl[IDX].fld.flag2 03481 # endif 03482 03483 /* # ifdef _DEBUG 03484 # define GAP_NEEDS_EXPL_ITRFC(IDX) \ 03485 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03486 global_attr_tbl : ga_var_error("GAP_NEEDS_EXPL_ITRFC", IDX)) \ 03487 [IDX].fld.flag1 03488 # else 03489 */ 03490 # define GAP_NEEDS_EXPL_ITRFC(IDX) global_attr_tbl[IDX].fld.flag1 03491 /* # endif */ 03492 03493 # ifdef _DEBUG 03494 # define GAP_NEXT_PGM_UNIT_IDX(IDX) \ 03495 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03496 global_attr_tbl : ga_var_error("GAP_NEXT_PGM_UNIT_IDX", IDX)) \ 03497 [IDX].fld.field8 03498 # else 03499 # define GAP_NEXT_PGM_UNIT_IDX(IDX) global_attr_tbl[IDX].fld.field8 03500 # endif 03501 03502 # ifdef _DEBUG 03503 # define GAP_NOSIDE_EFFECTS(IDX) \ 03504 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03505 global_attr_tbl : ga_var_error("GAP_NOSIDE_EFFECTS", IDX)) \ 03506 [IDX].fld.flag5 03507 # else 03508 # define GAP_NOSIDE_EFFECTS(IDX) global_attr_tbl[IDX].fld.flag5 03509 # endif 03510 03511 # ifdef _DEBUG 03512 # define GAP_NUM_DARGS(IDX) \ 03513 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03514 global_attr_tbl : ga_var_error("GAP_NUM_DARGS", IDX)) \ 03515 [IDX].fld.field7 03516 # else 03517 # define GAP_NUM_DARGS(IDX) global_attr_tbl[IDX].fld.field7 03518 # endif 03519 03520 # ifdef _DEBUG 03521 # define GAP_PGM_UNIT(IDX) \ 03522 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03523 global_attr_tbl : ga_var_error("GAP_PGM_UNIT", IDX)) \ 03524 [IDX].fld.field5 03525 # else 03526 # define GAP_PGM_UNIT(IDX) global_attr_tbl[IDX].fld.field5 03527 # endif 03528 03529 # ifdef _DEBUG 03530 # define GAP_PGM_UNIT_DEFINED(IDX) \ 03531 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03532 global_attr_tbl : ga_var_error("GAP_PGM_UNIT_DEFINED", IDX)) \ 03533 [IDX].fld.flag4 03534 # else 03535 # define GAP_PGM_UNIT_DEFINED(IDX) global_attr_tbl[IDX].fld.flag4 03536 # endif 03537 03538 # ifdef _DEBUG 03539 # define GAP_PURE(IDX) \ 03540 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03541 global_attr_tbl : ga_var_error("GAP_PURE", IDX)) \ 03542 [IDX].fld.flag6 03543 # else 03544 # define GAP_PURE(IDX) global_attr_tbl[IDX].fld.flag6 03545 # endif 03546 03547 # ifdef _DEBUG 03548 # define GAP_RECURSIVE(IDX) \ 03549 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03550 global_attr_tbl : ga_var_error("GAP_RECURSIVE", IDX)) \ 03551 [IDX].fld.flag7 03552 # else 03553 # define GAP_RECURSIVE(IDX) global_attr_tbl[IDX].fld.flag7 03554 # endif 03555 03556 # ifdef _DEBUG 03557 # define GAP_RSLT_IDX(IDX) \ 03558 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03559 global_attr_tbl : ga_var_error("GAP_RSLT_IDX", IDX)) \ 03560 [IDX].fld.field3 03561 # else 03562 # define GAP_RSLT_IDX(IDX) global_attr_tbl[IDX].fld.field3 03563 # endif 03564 03565 # ifdef _DEBUG 03566 # define GAP_INLINE_STATE(IDX) \ 03567 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03568 global_attr_tbl : ga_var_error("GAP_INLINE_STATE", IDX)) \ 03569 [IDX].fld.field2 03570 # else 03571 # define GAP_INLINE_STATE(IDX) global_attr_tbl[IDX].fld.field2 03572 # endif 03573 03574 # ifdef _DEBUG 03575 # define GAP_VFUNCTION(IDX) \ 03576 ((GA_OBJ_CLASS(IDX) == Pgm_Unit) ? \ 03577 global_attr_tbl : ga_var_error("GAP_VFUNCTION", IDX)) \ 03578 [IDX].fld.flag8 03579 # else 03580 # define GAP_VFUNCTION(IDX) global_attr_tbl[IDX].fld.flag8 03581 # endif 03582 03583 03584 /* definitions for derived types - GAT */ 03585 03586 # ifdef _DEBUG 03587 # define GAT_FIRST_CPNT_IDX(IDX) \ 03588 ((GA_OBJ_CLASS(IDX) == Derived_Type) ? \ 03589 global_attr_tbl : ga_var_error("GAT_FIRST_CPNT_IDX", IDX)) \ 03590 [IDX].fld.field1 03591 # else 03592 # define GAT_FIRST_CPNT_IDX(IDX) global_attr_tbl[IDX].fld.field1 03593 # endif 03594 03595 # ifdef _DEBUG 03596 # define GAT_NUM_CPNTS(IDX) \ 03597 ((GA_OBJ_CLASS(IDX) == Derived_Type) ? \ 03598 global_attr_tbl : ga_var_error("GAT_NUM_CPNTS", IDX)) \ 03599 [IDX].fld.field3 03600 # else 03601 # define GAT_NUM_CPNTS(IDX) global_attr_tbl[IDX].fld.field3 03602 # endif 03603 03604 # ifdef _DEBUG 03605 # define GAT_PRIVATE_CPNT(IDX) \ 03606 ((GA_OBJ_CLASS(IDX) == Derived_Type) ? \ 03607 global_attr_tbl : ga_var_error("GAT_PRIVATE_CPNT", IDX)) \ 03608 [IDX].fld.flag1 03609 # else 03610 # define GAT_PRIVATE_CPNT(IDX) global_attr_tbl[IDX].fld.flag1 03611 # endif 03612 03613 # ifdef _DEBUG 03614 # define GAT_SEQUENCE_SET(IDX) \ 03615 ((GA_OBJ_CLASS(IDX) == Derived_Type) ? \ 03616 global_attr_tbl : ga_var_error("GAT_SEQUENCE_SET", IDX)) \ 03617 [IDX].fld.flag2 03618 # else 03619 # define GAT_SEQUENCE_SET(IDX) global_attr_tbl[IDX].fld.flag2 03620 # endif 03621 03622 # ifdef _DEBUG 03623 # define GAT_STRUCT_LIN_TYPE(IDX) \ 03624 ((GA_OBJ_CLASS(IDX) == Derived_Type) ? \ 03625 global_attr_tbl : ga_var_error("GAT_STRUCT_LIN_TYPE", IDX)) \ 03626 [IDX].wd.field32_6 03627 # else 03628 # define GAT_STRUCT_LIN_TYPE(IDX) global_attr_tbl[IDX].wd.field32_6 03629 # endif 03630 03631 # ifdef _DEBUG 03632 # define GAT_STRUCT_BIT_LEN(IDX) \ 03633 ((GA_OBJ_CLASS(IDX) == Derived_Type) ? \ 03634 global_attr_tbl : ga_var_error("GAT_STRUCT_BIT_LEN", IDX)) \ 03635 [IDX].wd.length 03636 # else 03637 # define GAT_STRUCT_BIT_LEN(IDX) global_attr_tbl[IDX].wd.length 03638 # endif 03639 03640 /* GLOBAL BOUNDS TABLE - Common */ 03641 03642 # define GB_ARRAY_CLASS(IDX) global_bounds_tbl[IDX].hdr.array_class 03643 # define GB_ARRAY_SIZE(IDX) global_bounds_tbl[IDX].hdr.array_size 03644 # define GB_RANK(IDX) global_bounds_tbl[IDX].hdr.rank 03645 03646 /* GLOBAL BOUNDS TABLE - Dimensions */ 03647 03648 # define GB_LOWER_BOUND(IDX,DIM) global_bounds_tbl[(IDX)+(DIM*3)-2].len 03649 # define GB_UPPER_BOUND(IDX,DIM) global_bounds_tbl[(IDX)+(DIM*3)-1].len 03650 # define GB_LB_TYPE(IDX,DIM) global_bounds_tbl[(IDX)+(DIM*3)].type.lb_type 03651 # define GB_UB_TYPE(IDX,DIM) global_bounds_tbl[(IDX)+(DIM*3)].type.ub_type 03652 03653 /* GLOBAL LINE TABLE */ 03654 03655 # define GL_CIF_FILE_ID(IDX) global_line_tbl[IDX].cif_file_id 03656 # define GL_FILE_LINE(IDX) global_line_tbl[IDX].file_line 03657 # define GL_FILE_NAME_IDX(IDX) global_line_tbl[IDX].file_name_idx 03658 # define GL_FILE_NAME_LEN(IDX) global_line_tbl[IDX].file_name_len 03659 # define GL_GLOBAL_LINE(IDX) global_line_tbl[IDX].global_line 03660 # define GL_INCLUDE_FILE_COL(IDX) global_line_tbl[IDX].incld_file_col 03661 # define GL_INCLUDE_FILE_LINE(IDX) global_line_tbl[IDX].incld_file_line 03662 # define GL_PATH_NAME_IDX(IDX) global_line_tbl[IDX].path_name_idx 03663 # define GL_PATH_NAME_LEN(IDX) global_line_tbl[IDX].path_name_len 03664 # define GL_SOURCE_LINES(IDX) global_line_tbl[IDX].source_lines 03665 03666 # define GL_FILE_NAME_LONG(IDX) &(str_pool[GL_FILE_NAME_IDX(IDX)].name_long) 03667 # define GL_FILE_NAME_PTR(IDX) &str_pool[GL_FILE_NAME_IDX(IDX)].name_char 03668 03669 # define GL_PATH_NAME_LONG(IDX) &(str_pool[GL_PATH_NAME_IDX(IDX)].name_long) 03670 # define GL_PATH_NAME_PTR(IDX) &str_pool[GL_PATH_NAME_IDX(IDX)].name_char 03671 03672 03673 /* GLOBAL NAME TABLE */ 03674 03675 # define GN_ATTR_IDX(IDX) global_name_tbl[IDX].attr_idx 03676 # define GN_NAME_IDX(IDX) global_name_tbl[IDX].name_idx 03677 # define GN_NAME_LEN(IDX) global_name_tbl[IDX].name_len 03678 # define GN_NAME_LONG(IDX) &(str_pool[GN_NAME_IDX(IDX)].name_long) 03679 # define GN_NAME_PTR(IDX) &str_pool[GN_NAME_IDX(IDX)].name_char 03680 03681 /* GLOBAL TYPE TABLE */ 03682 03683 # define GT_BIT_LEN(IDX) global_type_tbl[IDX].fld.bit_len 03684 # define GT_CHAR_CLASS(IDX) global_type_tbl[IDX].fld.char_class 03685 # define GT_DCL_VALUE(IDX) global_type_tbl[IDX].fld.dcl_value 03686 # define GT_DESC(IDX) global_type_tbl[IDX].fld.desc 03687 # define GT_STRUCT_IDX(IDX) global_type_tbl[IDX].fld.type_idx 03688 # define GT_LENGTH(IDX) global_type_tbl[IDX].wd.length 03689 # define GT_LENGTH_LIN_TYPE(IDX) global_type_tbl[IDX].fld.len_lin_type 03690 # define GT_LINEAR_TYPE(IDX) global_type_tbl[IDX].fld.linear_type 03691 # define GT_PTR_INCREMENT(IDX) \ 03692 global_type_tbl[IDX].wd.length[MAX_WORDS_FOR_INTEGER] 03693 # define GT_TYPE(IDX) global_type_tbl[IDX].fld.type 03694 03695 /* HIDDEN NAME TABLE */ 03696 03697 # define HN_ATTR_IDX(IDX) hidden_name_tbl[IDX].attr_idx 03698 # define HN_NAME_IDX(IDX) hidden_name_tbl[IDX].name_idx 03699 # define HN_NAME_LEN(IDX) hidden_name_tbl[IDX].name_len 03700 03701 03702 /* SCOPE TABLE definitions */ 03703 03704 # define SCP_ATTR_IDX(IDX) scp_tbl[IDX].wd[0].fld1.field2 03705 # define SCP_LN_FW_IDX(IDX) scp_tbl[IDX].wd[1].fld1.field2 03706 # define SCP_LN_LW_IDX(IDX) scp_tbl[IDX].wd[2].fld1.field2 03707 # define SCP_FIRST_SH_IDX(IDX) scp_tbl[IDX].wd[3].fld1.field2 03708 # define SCP_LAST_SH_IDX(IDX) scp_tbl[IDX].wd[4].fld1.field2 03709 # define SCP_EXIT_IR_SH_IDX(IDX) scp_tbl[IDX].wd[5].fld1.field2 03710 # define SCP_ASSIGN_LBL_CHAIN(IDX) scp_tbl[IDX].wd[6].fld1.field2 03711 # define SCP_CIF_ID(IDX) scp_tbl[IDX].wd[7].fld1.field2 03712 # define SCP_HN_FW_IDX(IDX) scp_tbl[IDX].wd[8].fld1.field2 03713 # define SCP_HN_LW_IDX(IDX) scp_tbl[IDX].wd[9].fld1.field2 03714 # define SCP_OPTIONAL_CHAR_TMP(IDX) scp_tbl[IDX].wd[10].fld1.field2 03715 # define SCP_RETURN_LABEL(IDX) scp_tbl[IDX].wd[11].fld1.field2 03716 # define SCP_COPY_ASSUMED_LIST(IDX) scp_tbl[IDX].wd[12].fld1.field2 03717 # define SCP_WHICH_ENTRY_TMP(IDX) scp_tbl[IDX].wd[13].fld1.field2 03718 # define SCP_RESHAPE_ARRAY_LIST(IDX) scp_tbl[IDX].wd[14].fld1.field2 03719 03720 # define SCP_DEFAULT_STORAGE(IDX) scp_tbl[IDX].wd[24].fld2.field4 03721 # define SCP_LEVEL(IDX) scp_tbl[IDX].wd[23].fld2.field4 03722 # define SCP_CIF_ERR_LIST(IDX) scp_tbl[IDX].wd[23].fld2.field5 03723 03724 # define SCP_IS_INTERFACE(IDX) scp_tbl[IDX].wd[0].fld1.flag1 03725 # define SCP_IN_ERR(IDX) scp_tbl[IDX].wd[0].fld1.flag2 03726 # define SCP_IS_USED_PROC(IDX) scp_tbl[IDX].wd[0].fld1.flag3 03727 # define SCP_IMPL_NONE(IDX) scp_tbl[IDX].wd[1].fld1.flag1 03728 # define SCP_PARENT_NONE(IDX) scp_tbl[IDX].wd[1].fld1.flag2 03729 # define SCP_COPY_ASSUMED_SHAPE(IDX) scp_tbl[IDX].wd[1].fld1.flag3 03730 # define SCP_IGNORE_TKR(IDX) scp_tbl[IDX].wd[2].fld1.flag1 03731 # define SCP_HAS_CALLS(IDX) scp_tbl[IDX].wd[2].fld1.flag2 03732 # define SCP_DOES_IO(IDX) scp_tbl[IDX].wd[2].fld1.flag3 03733 # define SCP_INLINE_SGI(IDX) scp_tbl[IDX].wd[3].fld1.flag2 03734 # define SCP_NOINLINE_SGI(IDX) scp_tbl[IDX].wd[3].fld1.flag3 03735 # define SCP_DBG_PRINT_SYTB(IDX) scp_tbl[IDX].wd[25].fld1.flag1 03736 # define SCP_DBG_PRINT_STMT(IDX) scp_tbl[IDX].wd[25].fld1.flag2 03737 03738 # define SCP_SIBLING_IDX(IDX) scp_tbl[IDX].wd[0].fld1.field3 03739 # define SCP_LAST_CHILD_IDX(IDX) scp_tbl[IDX].wd[1].fld1.field3 03740 # define SCP_TMP_FW_IDX2(IDX) scp_tbl[IDX].wd[2].fld1.field3 03741 # define SCP_PARENT_IDX(IDX) scp_tbl[IDX].wd[3].fld1.field3 03742 # define SCP_FIRST_CHILD_IDX(IDX) scp_tbl[IDX].wd[4].fld1.field3 03743 # define SCP_NUM_CHILDREN(IDX) scp_tbl[IDX].wd[5].fld1.field3 03744 # define SCP_DARG_LIST(IDX) scp_tbl[IDX].wd[6].fld1.field3 03745 # define SCP_ENTRY_IDX(IDX) scp_tbl[IDX].wd[7].fld1.field3 03746 # define SCP_USED_MODULE_LIST(IDX) scp_tbl[IDX].wd[8].fld1.field3 03747 # define SCP_FIRST_EQUIV_GRP(IDX) scp_tbl[IDX].wd[9].fld1.field3 03748 # define SCP_TMP_LIST(IDX) scp_tbl[IDX].wd[10].fld1.field3 03749 # define SCP_TMP_FW_IDX(IDX) scp_tbl[IDX].wd[11].fld1.field3 03750 # define SCP_SB_HOSTED_STACK_IDX(IDX) scp_tbl[IDX].wd[12].fld1.field3 03751 # define SCP_SB_STACK_IDX(IDX) scp_tbl[IDX].wd[13].fld1.field3 03752 # define SCP_SB_BASED_IDX(IDX) scp_tbl[IDX].wd[14].fld1.field3 03753 # define SCP_SB_DARG_IDX(IDX) scp_tbl[IDX].wd[15].fld1.field3 03754 # define SCP_SB_STATIC_IDX(IDX) scp_tbl[IDX].wd[16].fld1.field3 03755 # define SCP_SB_SYMMETRIC_IDX(IDX) scp_tbl[IDX].wd[17].fld1.field3 03756 # define SCP_ATTR_LIST_END(IDX) scp_tbl[IDX].wd[18].fld1.field3 03757 # define SCP_SB_HOSTED_STATIC_IDX(IDX) scp_tbl[IDX].wd[19].fld1.field3 03758 # define SCP_SB_STATIC_INIT_IDX(IDX) scp_tbl[IDX].wd[20].fld1.field3 03759 # define SCP_ATTR_LIST(IDX) scp_tbl[IDX].wd[21].fld1.field3 03760 # define SCP_ALT_ENTRY_CNT(IDX) scp_tbl[IDX].wd[22].fld1.field3 03761 # define SCP_SB_STATIC_UNINIT_IDX(IDX) scp_tbl[IDX].wd[23].fld1.field3 03762 # define SCP_SB_HOSTED_DATA_IDX(IDX) scp_tbl[IDX].wd[24].fld1.field3 03763 # define SCP_FILE_PATH_IDX(IDX) scp_tbl[IDX].wd[25].fld1.field3 03764 03765 /* IMPLICIT TABLE definitions */ 03766 03767 # define IMPL_IDX(CH) CH - 'A' 03768 # define IM_SET(SIDX,IDX) scp_tbl[SIDX].wd[IDX].fld1.typed 03769 # define IM_STORAGE(SIDX,IDX) scp_tbl[SIDX].wd[IDX].fld1.storage 03770 # define IM_TYPE_IDX(SIDX,IDX) scp_tbl[SIDX].wd[IDX].fld1.type_idx 03771 03772 /* IR TABLE */ 03773 # define OLD_IR_OPR(IDX) old_ir_tbl[IDX].opr.the_operator 03774 # define OLD_IR_RANK(IDX) old_ir_tbl[IDX].opr.rank 03775 # define OLD_IR_DV_DIM(IDX) old_ir_tbl[IDX].opr.dim 03776 03777 # define IR_COL_NUM(IDX) ir_tbl[IDX].opr.col_num 03778 # define IR_LINE_NUM(IDX) ir_tbl[IDX].opr.line_num 03779 # define IR_NEXT_IDX(IDX) ir_tbl[IDX].opr.line_num 03780 # define IR_OPR(IDX) ir_tbl[IDX].opr.the_operator 03781 # define IR_TYPE_IDX(IDX) ir_tbl[IDX].opr.type_idx 03782 03783 # define IR_RANK(IDX) ir_tbl[IDX].opr.rank 03784 # define IR_DV_DIM(IDX) ir_tbl[IDX].opr.dim 03785 # define IR_CONTIG_ARRAY(IDX) ir_tbl[IDX].opr.dim 03786 # define IR_WHOLE_ARRAY(IDX) ir_tbl[IDX].opr.dim 03787 # define IR_INLINE_STATE(IDX) ir_tbl[IDX].opr.dim 03788 03789 # define IR_COL_NUM_L(IDX) ir_tbl[IDX].op_l.col_num 03790 # define IR_FLD_L(IDX) ir_tbl[IDX].op_l.fld 03791 # define IR_IDX_L(IDX) ir_tbl[IDX].op_l.idx 03792 # define IR_LINE_NUM_L(IDX) ir_tbl[IDX].op_l.line_num 03793 # define IR_LIST_CNT_L(IDX) ir_tbl[IDX].op_l.line_num 03794 # define IR_SHORT_CIRCUIT_L(IDX) ir_tbl[IDX].op_l.flag_1 03795 # define IR_ARRAY_SYNTAX(IDX) ir_tbl[IDX].op_l.flag_2 03796 03797 # define IR_COL_NUM_R(IDX) ir_tbl[IDX].op_r.col_num 03798 # define IR_FLD_R(IDX) ir_tbl[IDX].op_r.fld 03799 # define IR_IDX_R(IDX) ir_tbl[IDX].op_r.idx 03800 # define IR_LINE_NUM_R(IDX) ir_tbl[IDX].op_r.line_num 03801 # define IR_LIST_CNT_R(IDX) ir_tbl[IDX].op_r.line_num 03802 # define IR_SHORT_CIRCUIT_R(IDX) ir_tbl[IDX].op_r.flag_1 03803 # define IR_BOUNDS_DONE(IDX) ir_tbl[IDX].op_r.flag_2 03804 03805 # define IR_OPND_L(IDX) ir_tbl[IDX].op_l 03806 # define IR_OPND_R(IDX) ir_tbl[IDX].op_r 03807 03808 03809 /* IR LIST TABLE */ 03810 03811 # define IL_NEXT_LIST_IDX(IDX) ir_list_tbl[IDX].il.link.nxt_idx 03812 # define IL_IDX(IDX) ir_list_tbl[IDX].il.op.idx 03813 # define IL_LINE_NUM(IDX) ir_list_tbl[IDX].il.op.line_num 03814 # define IL_COL_NUM(IDX) ir_list_tbl[IDX].il.op.col_num 03815 # define IL_LIST_CNT(IDX) ir_list_tbl[IDX].il.op.line_num 03816 # define IL_FLD(IDX) ir_list_tbl[IDX].il.op.fld 03817 # define IL_ARG_DESC_VARIANT(IDX) ir_list_tbl[IDX].il.link.arg_desc 03818 # define IL_ARG_MULTI_FLAGS(IDX) ir_list_tbl[IDX].il.link.multi_flags 03819 03820 # ifdef _DEBUG 03821 # define IL_PREV_LIST_IDX(IDX) \ 03822 (! IL_ARG_DESC_VARIANT(IDX) ? \ 03823 ir_list_tbl : ir_list_var_error("IL_PREV_LIST_IDX", IDX)) \ 03824 [IDX].il.link.prev_idx 03825 # else 03826 # define IL_PREV_LIST_IDX(IDX) ir_list_tbl[IDX].il.link.prev_idx 03827 # endif 03828 03829 # ifdef _DEBUG 03830 # define IL_ARG_DESC_IDX(IDX) \ 03831 (IL_ARG_DESC_VARIANT(IDX) ? \ 03832 ir_list_tbl : ir_list_var_error("IL_ARG_DESC_IDX", IDX)) \ 03833 [IDX].il.link.prev_idx 03834 # else 03835 # define IL_ARG_DESC_IDX(IDX) ir_list_tbl[IDX].il.link.prev_idx 03836 # endif 03837 03838 /* flags for array subscript lists */ 03839 # define IL_VECTOR_SUBSCRIPT(IDX) ir_list_tbl[IDX].il.link.flag_1 03840 # define IL_CONSTANT_SUBSCRIPT(IDX) ir_list_tbl[IDX].il.link.flag_2 03841 # define IL_PE_SUBSCRIPT(IDX) ir_list_tbl[IDX].il.link.flag_3 03842 03843 /* flags for io control lists */ 03844 # define IL_NAMELIST_EXPECTED(IDX) ir_list_tbl[IDX].il.link.flag_1 03845 # define IL_FORMAT_EXPECTED(IDX) ir_list_tbl[IDX].il.link.flag_2 03846 03847 /* flags for io list */ 03848 # define IL_HAS_FUNCTIONS(IDX) ir_list_tbl[IDX].il.link.flag_1 03849 # define IL_MUST_BE_LOOP(IDX) ir_list_tbl[IDX].il.link.flag_2 03850 # define IL_MUST_FLATTEN(IDX) ir_list_tbl[IDX].il.link.flag_3 03851 # define IL_HAS_CONSTRUCTOR(IDX) ir_list_tbl[IDX].il.link.flag_4 03852 # define IL_STRUCT_REF(IDX) ir_list_tbl[IDX].il.link.flag_5 03853 # define IL_INTRIN_PLACE_HOLDER(IDX) ir_list_tbl[IDX].il.link.flag_6 03854 # define IL_NONDEFAULT_IMP_DO_LCV(IDX) ir_list_tbl[IDX].il.link.flag_7 03855 # define IL_DISTRIBUTION_VARIANT(IDX) ir_list_tbl[IDX].il.link.flag_8 03856 03857 /* Flags for label forward ref lists. See MISC above for values. */ 03858 # define IL_FORWARD_REF(IDX) ir_list_tbl[IDX].il.link.for_ref 03859 # define IL_DISTRIBUTION(IDX) ir_list_tbl[IDX].il.link.for_ref 03860 03861 # define IL_WORD(IDX,WD) ir_list_tbl[IDX].words[WD] 03862 # define IL_ELEMENT(IDX) ir_list_tbl[IDX].il_long64.lwd2 03863 03864 # define IL_OPND(IDX) ir_list_tbl[IDX].il.op 03865 03866 03867 /* STMT HEADER TABLE */ 03868 03869 # define SH_CIF_SKIP_ME(IDX) sh_tbl[IDX].cif_skip_me 03870 # define SH_COL_NUM(IDX) sh_tbl[IDX].col_num 03871 # define SH_COMPILER_GEN(IDX) sh_tbl[IDX].compiler_gen 03872 # define SH_DOALL_LOOP_END(IDX) sh_tbl[IDX].doall_loop_end 03873 # define SH_ERR_FLG(IDX) sh_tbl[IDX].stmt_parse_err 03874 # define SH_GLB_LINE(IDX) sh_tbl[IDX].glb_line_num 03875 # define SH_ACTION_STMT(IDX) sh_tbl[IDX].action_stmt 03876 # define SH_INLINING_ATTEMPTED(IDX) sh_tbl[IDX].inlining_attempted 03877 # define SH_IR_IDX(IDX) sh_tbl[IDX].ir_idx 03878 # define SH_LABELED(IDX) sh_tbl[IDX].labeled 03879 # define SH_LOOP_END(IDX) sh_tbl[IDX].loop_end 03880 # define SH_NEXT_IDX(IDX) sh_tbl[IDX].next_sh_idx 03881 # define SH_P2_SKIP_ME(IDX) sh_tbl[IDX].skip_pass_2 03882 # define SH_PARENT_BLK_IDX(IDX) sh_tbl[IDX].parent_blk_idx 03883 # define SH_PREV_IDX(IDX) sh_tbl[IDX].prev_sh_idx 03884 # define OLD_SH_STMT_TYPE(IDX) sh_tbl[IDX].old_stmt_type 03885 # define SH_STMT_TYPE(IDX) sh_tbl[IDX].stmt_type 03886 03887 03888 /* Global ir,il, and sh tables */ 03889 03890 /* GLOBAL IR TABLE */ 03891 03892 # define GL_IR_COL_NUM(IDX) global_ir_tbl[IDX].opr.col_num 03893 # define GL_IR_LINE_NUM(IDX) global_ir_tbl[IDX].opr.line_num 03894 # define GL_IR_NEXT_IDX(IDX) global_ir_tbl[IDX].opr.line_num 03895 # define GL_IR_OPR(IDX) global_ir_tbl[IDX].opr.the_operator 03896 # define GL_IR_TYPE_IDX(IDX) global_ir_tbl[IDX].opr.type_idx 03897 03898 # define GL_IR_RANK(IDX) global_ir_tbl[IDX].opr.rank 03899 # define GL_IR_DV_DIM(IDX) global_ir_tbl[IDX].opr.dim 03900 # define GL_IR_CONTIG_ARRAY(IDX) global_ir_tbl[IDX].opr.dim 03901 # define GL_IR_WHOLE_ARRAY(IDX) global_ir_tbl[IDX].opr.dim 03902 # define GL_IR_INLINE_STATE(IDX) global_ir_tbl[IDX].opr.dim 03903 03904 # define GL_IR_COL_NUM_L(IDX) global_ir_tbl[IDX].op_l.col_num 03905 # define GL_IR_FLD_L(IDX) global_ir_tbl[IDX].op_l.fld 03906 # define GL_IR_IDX_L(IDX) global_ir_tbl[IDX].op_l.idx 03907 # define GL_IR_LINE_NUM_L(IDX) global_ir_tbl[IDX].op_l.line_num 03908 # define GL_IR_LIST_CNT_L(IDX) global_ir_tbl[IDX].op_l.line_num 03909 # define GL_IR_SHORT_CIRCUIT_L(IDX) global_ir_tbl[IDX].op_l.flag_1 03910 # define GL_IR_ARRAY_SYNTAX(IDX) global_ir_tbl[IDX].op_l.flag_2 03911 03912 # define GL_IR_COL_NUM_R(IDX) global_ir_tbl[IDX].op_r.col_num 03913 # define GL_IR_FLD_R(IDX) global_ir_tbl[IDX].op_r.fld 03914 # define GL_IR_IDX_R(IDX) global_ir_tbl[IDX].op_r.idx 03915 # define GL_IR_LINE_NUM_R(IDX) global_ir_tbl[IDX].op_r.line_num 03916 # define GL_IR_LIST_CNT_R(IDX) global_ir_tbl[IDX].op_r.line_num 03917 # define GL_IR_SHORT_CIRCUIT_R(IDX) global_ir_tbl[IDX].op_r.flag_1 03918 03919 # define GL_IR_OPND_L(IDX) global_ir_tbl[IDX].op_l 03920 # define GL_IR_OPND_R(IDX) global_ir_tbl[IDX].op_r 03921 03922 03923 /* GLOBAL IR LIST TABLE */ 03924 03925 # define GL_IL_NEXT_LIST_IDX(IDX) global_ir_list_tbl[IDX].il.link.nxt_idx 03926 # define GL_IL_IDX(IDX) global_ir_list_tbl[IDX].il.op.idx 03927 # define GL_IL_LINE_NUM(IDX) global_ir_list_tbl[IDX].il.op.line_num 03928 # define GL_IL_COL_NUM(IDX) global_ir_list_tbl[IDX].il.op.col_num 03929 # define GL_IL_LIST_CNT(IDX) global_ir_list_tbl[IDX].il.op.line_num 03930 # define GL_IL_FLD(IDX) global_ir_list_tbl[IDX].il.op.fld 03931 # define GL_IL_ARG_DESC_VARIANT(IDX) global_ir_list_tbl[IDX].il.link.arg_desc 03932 03933 # define GL_IL_PREV_LIST_IDX(IDX) global_ir_list_tbl[IDX].il.link.prev_idx 03934 # define GL_IL_ARG_DESC_IDX(IDX) global_ir_list_tbl[IDX].il.link.prev_idx 03935 03936 /* flags for array subscript lists */ 03937 # define GL_IL_VECTOR_SUBSCRIPT(IDX) global_ir_list_tbl[IDX].il.link.flag_1 03938 # define GL_IL_CONSTANT_SUBSCRIPT(IDX) global_ir_list_tbl[IDX].il.link.flag_2 03939 # define GL_IL_PE_SUBSCRIPT(IDX) global_ir_list_tbl[IDX].il.link.flag_3 03940 03941 /* flags for io control lists */ 03942 # define GL_IL_NAMELIST_EXPECTED(IDX) global_ir_list_tbl[IDX].il.link.flag_1 03943 # define GL_IL_FORMAT_EXPECTED(IDX) global_ir_list_tbl[IDX].il.link.flag_2 03944 03945 /* flags for io list */ 03946 # define GL_IL_HAS_FUNCTIONS(IDX) global_ir_list_tbl[IDX].il.link.flag_1 03947 # define GL_IL_MUST_BE_LOOP(IDX) global_ir_list_tbl[IDX].il.link.flag_2 03948 # define GL_IL_MUST_FLATTEN(IDX) global_ir_list_tbl[IDX].il.link.flag_3 03949 # define GL_IL_HAS_CONSTRUCTOR(IDX) global_ir_list_tbl[IDX].il.link.flag_4 03950 # define GL_IL_STRUCT_REF(IDX) global_ir_list_tbl[IDX].il.link.flag_5 03951 # define GL_IL_INTRIN_PLACE_HOLDER(IDX) global_ir_list_tbl[IDX].il.link.flag_6 03952 # define GL_IL_NONDEFAULT_IMP_DO_LCV(IDX) global_ir_list_tbl[IDX].il.link.flag_7 03953 # define GL_IL_DISTRIBUTION_VARIANT(IDX) global_ir_list_tbl[IDX].il.link.flag_8 03954 03955 /* Flags for label forward ref lists. See MISC above for values. */ 03956 # define GL_IL_FORWARD_REF(IDX) global_ir_list_tbl[IDX].il.link.for_ref 03957 # define GL_IL_DISTRIBUTION(IDX) global_ir_list_tbl[IDX].il.link.for_ref 03958 03959 # define GL_IL_WORD(IDX,WD) global_ir_list_tbl[IDX].words[WD] 03960 03961 # define GL_IL_OPND(IDX) global_ir_list_tbl[IDX].il.op 03962 03963 03964 /* STMT HEADER TABLE */ 03965 03966 # define GL_SH_CIF_SKIP_ME(IDX) global_sh_tbl[IDX].cif_skip_me 03967 # define GL_SH_COL_NUM(IDX) global_sh_tbl[IDX].col_num 03968 # define GL_SH_COMPILER_GEN(IDX) global_sh_tbl[IDX].compiler_gen 03969 # define GL_SH_DOALL_LOOP_END(IDX) global_sh_tbl[IDX].doall_loop_end 03970 # define GL_SH_ERR_FLG(IDX) global_sh_tbl[IDX].stmt_parse_err 03971 # define GL_SH_GLB_LINE(IDX) global_sh_tbl[IDX].glb_line_num 03972 # define GL_SH_INLINING_ATTEMPTED(IDX) global_sh_tbl[IDX].inlining_attempted 03973 # define GL_SH_IR_IDX(IDX) global_sh_tbl[IDX].ir_idx 03974 # define GL_SH_LABELED(IDX) global_sh_tbl[IDX].labeled 03975 # define GL_SH_LOOP_END(IDX) global_sh_tbl[IDX].loop_end 03976 # define GL_SH_NEXT_IDX(IDX) global_sh_tbl[IDX].next_sh_idx 03977 # define GL_SH_P2_SKIP_ME(IDX) global_sh_tbl[IDX].skip_pass_2 03978 # define GL_SH_PARENT_BLK_IDX(IDX) global_sh_tbl[IDX].parent_blk_idx 03979 # define GL_SH_PREV_IDX(IDX) global_sh_tbl[IDX].prev_sh_idx 03980 # define GL_SH_STMT_TYPE(IDX) global_sh_tbl[IDX].stmt_type 03981 03982 /* MOD LINK TABLE */ 03983 03984 # define ML_AT_IDX(IDX) mod_link_tbl[IDX].at_idx 03985 # define ML_AT_COMPRESSED_IDX(IDX) mod_link_tbl[IDX].at_compressed 03986 # define ML_AT_KEEP_ME(IDX) mod_link_tbl[IDX].at_keep_me 03987 # define ML_AT_LN_NAME(IDX) mod_link_tbl[IDX].at_ln_name 03988 # define ML_AT_SEARCHED(IDX) mod_link_tbl[IDX].at_searched 03989 # define ML_AT_SEARCH_ME(IDX) mod_link_tbl[IDX].at_search_me 03990 # define ML_BD_IDX(IDX) mod_link_tbl[IDX].bd_idx 03991 # define ML_BD_KEEP_ME(IDX) mod_link_tbl[IDX].bd_keep_me 03992 # define ML_CN_IDX(IDX) mod_link_tbl[IDX].cn_idx 03993 # define ML_CN_KEEP_ME(IDX) mod_link_tbl[IDX].cn_keep_me 03994 # define ML_CP_DALIGN_ME(IDX) mod_link_tbl[IDX].cp_dalign_me 03995 # define ML_CP_IDX(IDX) mod_link_tbl[IDX].cp_idx 03996 # define ML_CP_KEEP_ME(IDX) mod_link_tbl[IDX].cp_keep_me 03997 # define ML_CP_LEN(IDX) mod_link_tbl[IDX].cp_len 03998 # define ML_IL_IDX(IDX) mod_link_tbl[IDX].il_idx 03999 # define ML_IL_KEEP_ME(IDX) mod_link_tbl[IDX].il_keep_me 04000 # define ML_IR_IDX(IDX) mod_link_tbl[IDX].ir_idx 04001 # define ML_IR_KEEP_ME(IDX) mod_link_tbl[IDX].ir_keep_me 04002 # define ML_LN_IDX(IDX) mod_link_tbl[IDX].ln_idx 04003 # define ML_LN_KEEP_ME(IDX) mod_link_tbl[IDX].ln_keep_me 04004 # define ML_NP_IDX(IDX) mod_link_tbl[IDX].np_idx 04005 # define ML_NP_KEEP_ME(IDX) mod_link_tbl[IDX].np_keep_me 04006 # define ML_NP_LEN(IDX) mod_link_tbl[IDX].np_len 04007 # define ML_SB_IDX(IDX) mod_link_tbl[IDX].sb_idx 04008 # define ML_SB_KEEP_ME(IDX) mod_link_tbl[IDX].sb_keep_me 04009 # define ML_SH_IDX(IDX) mod_link_tbl[IDX].sh_idx 04010 # define ML_SH_KEEP_ME(IDX) mod_link_tbl[IDX].sh_keep_me 04011 # define ML_SN_IDX(IDX) mod_link_tbl[IDX].sn_idx 04012 # define ML_SN_KEEP_ME(IDX) mod_link_tbl[IDX].sn_keep_me 04013 # define ML_TYP_IDX(IDX) mod_link_tbl[IDX].typ_idx 04014 # define ML_TYP_KEEP_ME(IDX) mod_link_tbl[IDX].typ_keep_me 04015 04016 04017 /* LOCAL NAME TABLE */ 04018 04019 # define LN_ATTR_IDX(IDX) loc_name_tbl[IDX].attr_idx 04020 # define LN_DEF_LOC(IDX) loc_name_tbl[IDX].def_locally 04021 # define LN_IN_ONLY_LIST(IDX) loc_name_tbl[IDX].in_only_list 04022 # define LN_NAME_IDX(IDX) loc_name_tbl[IDX].name_idx 04023 # define LN_NAME_LEN(IDX) loc_name_tbl[IDX].name_len 04024 # define LN_NAME_LONG(IDX) &(name_pool[LN_NAME_IDX(IDX)].name_long) 04025 # define LN_NEW_NAME(IDX) loc_name_tbl[IDX].new_name 04026 # define LN_RENAMED(IDX) loc_name_tbl[IDX].renamed 04027 04028 04029 /* MOD LINK TABLE */ 04030 04031 # define PDG_AT_IDX(IDX) pdg_link_tbl[IDX].at_idx 04032 # define PDG_AT_TYP_IDX(IDX) pdg_link_tbl[IDX].at_typ_idx 04033 # define PDG_CN_IDX(IDX) pdg_link_tbl[IDX].cn_idx 04034 # define PDG_SB_IDX(IDX) pdg_link_tbl[IDX].sb_idx 04035 04036 04037 /* RENAME ONLY TABLE */ 04038 04039 # define RO_COLUMN_NUM(IDX) rename_only_tbl[IDX].column_num 04040 # define RO_DUPLICATE_RENAME(IDX) rename_only_tbl[IDX].duplicate_rename 04041 # define RO_LINE_NUM(IDX) rename_only_tbl[IDX].line_num 04042 # define RO_NAME_IDX(IDX) rename_only_tbl[IDX].name_idx 04043 # define RO_NAME_LEN(IDX) rename_only_tbl[IDX].name_len 04044 # define RO_NAME_LONG(IDX) &(name_pool[RO_NAME_IDX(IDX)].name_long) 04045 # define RO_NAME_PTR(IDX) &name_pool[RO_NAME_IDX(IDX)].name_char 04046 # define RO_NEXT_IDX(IDX) rename_only_tbl[IDX].next_idx 04047 # define RO_RENAME_IDX(IDX) rename_only_tbl[IDX].rename_idx 04048 # define RO_RENAME_NAME(IDX) rename_only_tbl[IDX].rename_name 04049 # define RO_NAME_ATTR(IDX) rename_only_tbl[IDX].attr_idx 04050 04051 04052 /* SECONDARY NAME TABLE */ 04053 04054 # define SN_ATTR_IDX(IDX) sec_name_tbl[IDX].attr_idx 04055 # define SN_COLUMN_NUM(IDX) sec_name_tbl[IDX].column_num 04056 # define SN_LINE_NUM(IDX) sec_name_tbl[IDX].line_num 04057 # define SN_MATCHED_DARG(IDX) sec_name_tbl[IDX].matched 04058 # define SN_NAME_IDX(IDX) sec_name_tbl[IDX].name_idx 04059 # define SN_NAME_LEN(IDX) sec_name_tbl[IDX].length 04060 # define SN_SIBLING_LINK(IDX) sec_name_tbl[IDX].sibling_link 04061 04062 04063 /* STORAGE BLOCK TABLE */ 04064 04065 # define SB_ALIGN_SYMBOL(IDX) stor_blk_tbl[IDX].fld.align_symbol 04066 # define SB_AUXILIARY(IDX) stor_blk_tbl[IDX].fld.auxiliary 04067 # define SB_BLANK_COMMON(IDX) stor_blk_tbl[IDX].fld.blank_common 04068 # define SB_BLK_HAS_NPES(IDX) stor_blk_tbl[IDX].fld.blk_has_npes 04069 # define SB_BLK_TYPE(IDX) stor_blk_tbl[IDX].fld.sb_type 04070 # define OLD_SB_BLK_TYPE(IDX) stor_blk_tbl[IDX].fld.old_sb_type 04071 # define SB_CACHE_ALIGN(IDX) stor_blk_tbl[IDX].fld.cache_align 04072 # define SB_CIF_SYMBOL_ID(IDX) stor_blk_tbl[IDX].fld.cif_idx 04073 # define SB_COMMON_NEEDS_OFFSET(IDX) stor_blk_tbl[IDX].fld.needs_offset 04074 # define SB_DCL_ERR(IDX) stor_blk_tbl[IDX].fld.dcl_err 04075 # define SB_DCL_COMMON_DIR(IDX) stor_blk_tbl[IDX].fld.dcl_common_dir 04076 # define SB_DEF_COLUMN(IDX) stor_blk_tbl[IDX].fld.def_column 04077 # define SB_DEF_MULT_SCPS(IDX) stor_blk_tbl[IDX].fld.def_mult_scps 04078 # define SB_DEF_LINE(IDX) stor_blk_tbl[IDX].fld.def_line 04079 # define SB_DUPLICATE_COMMON(IDX) stor_blk_tbl[IDX].fld.duplicate_common 04080 # define SB_EQUIVALENCED(IDX) stor_blk_tbl[IDX].fld.equivalenced 04081 # define SB_FILL_SYMBOL(IDX) stor_blk_tbl[IDX].fld.fill_symbol 04082 # define SB_FIRST_ATTR_IDX(IDX) stor_blk_tbl[IDX].fld.first_attr_idx 04083 # define SB_HAS_RENAMES(IDX) stor_blk_tbl[IDX].fld.has_renames 04084 # define SB_HIDDEN(IDX) stor_blk_tbl[IDX].fld.hidden 04085 # define SB_HOST_ASSOCIATED(IDX) stor_blk_tbl[IDX].fld.host_associated 04086 # define SB_HOSTED_STACK(IDX) stor_blk_tbl[IDX].fld.hosted_stack 04087 # define SB_HOSTED_STATIC(IDX) stor_blk_tbl[IDX].fld.hosted_static 04088 # define SB_IS_COMMON(IDX) stor_blk_tbl[IDX].fld.is_common 04089 # define SB_LAST_ATTR_LIST(IDX) stor_blk_tbl[IDX].fld.last_attr_list 04090 # define SB_LEN_FLD(IDX) stor_blk_tbl[IDX].fld.len_fld 04091 # define SB_LEN_IDX(IDX) stor_blk_tbl[IDX].fld.len_idx 04092 # define SB_MERGED_BLK_IDX(IDX) stor_blk_tbl[IDX].fld.merged_blk_idx 04093 # define SB_MODULE_IDX(IDX) stor_blk_tbl[IDX].fld.module_idx 04094 # define SB_MODULE(IDX) stor_blk_tbl[IDX].fld.module 04095 # define SB_NAME_IDX(IDX) stor_blk_tbl[IDX].fld.name_idx 04096 # define SB_NAME_PTR(IDX) &name_pool[SB_NAME_IDX(IDX)].name_char 04097 # define SB_NAME_LONG(IDX) &(name_pool[SB_NAME_IDX(IDX)].name_long) 04098 # define SB_NAME(IDX) name_pool[SB_NAME_IDX(IDX)].name_char 04099 # define SB_NAME_IN_STONE(IDX) stor_blk_tbl[IDX].fld.name_in_stone 04100 # define SB_NAME_LEN(IDX) stor_blk_tbl[IDX].fld.name_len 04101 # define SB_ORIG_SCP_IDX(IDX) stor_blk_tbl[IDX].fld.orig_scp_idx 04102 # define SB_PAD_AMOUNT(IDX) stor_blk_tbl[IDX].fld.pad_amount 04103 # define SB_PAD_AMOUNT_SET(IDX) stor_blk_tbl[IDX].fld.pad_amount_set 04104 # define SB_PAD_BLK(IDX) stor_blk_tbl[IDX].fld.pad_blk 04105 # define SB_RUNTIME_INIT(IDX) stor_blk_tbl[IDX].fld.runtime_init 04106 # define SB_SAVED(IDX) stor_blk_tbl[IDX].fld.saved 04107 # define SB_SCP_IDX(IDX) stor_blk_tbl[IDX].fld.scp_idx 04108 # define SB_SECTION_GP(IDX) stor_blk_tbl[IDX].fld.section_gp 04109 # define SB_SECTION_NON_GP(IDX) stor_blk_tbl[IDX].fld.section_non_gp 04110 # define SB_SYMMETRIC(IDX) stor_blk_tbl[IDX].fld.symmetric 04111 # define SB_USE_ASSOCIATED(IDX) stor_blk_tbl[IDX].fld.use_associated 04112 # define SB_VOLATILE(IDX) stor_blk_tbl[IDX].fld.x_volatile 04113 04114 04115 /* TYPE TABLE */ 04116 04117 # define TYP_BIT_LEN(IDX) type_tbl[IDX].fld.bit_len 04118 # define TYP_BIT_LEN_F(IDX) type_tbl[IDX].wd.length 04119 # define TYP_CHAR_CLASS(IDX) type_tbl[IDX].fld.char_class 04120 # define TYP_DCL_VALUE(IDX) type_tbl[IDX].fld.dcl_value 04121 # define TYP_DECLARED_DBL(IDX) type_tbl[IDX].fld.declared_dbl 04122 # define TYP_DESC(IDX) type_tbl[IDX].fld.desc 04123 # define TYP_DP_HIT_ME(IDX) type_tbl[IDX].fld.dp_hit_me 04124 # define TYP_FLD(IDX) type_tbl[IDX].fld.type_fld 04125 # define TYP_IDX(IDX) type_tbl[IDX].fld.type_idx 04126 # define TYP_IS_BYTE(IDX) type_tbl[IDX].fld.type_is_byte 04127 # define TYP_LINEAR(IDX) type_tbl[IDX].fld.linear_type 04128 # define TYP_ORIG_LEN_IDX(IDX) type_tbl[IDX].fld.bit_len 04129 # define TYP_PTR_INCREMENT(IDX) type_tbl[IDX].fld.bit_len 04130 # define TYP_RESOLVED(IDX) type_tbl[IDX].fld.resolved 04131 # define TYP_TYPE(IDX) type_tbl[IDX].fld.type 04132 # define TYP_KIND_CONST(IDX) type_tbl[IDX].fld.kind_const 04133 # define TYP_KIND_DOUBLE(IDX) type_tbl[IDX].fld.kind_double 04134 04135 # define OLD_TYP_DP_HIT_ME(IDX) type_tbl[IDX].wd.old_dp_hit_me 04136 # define OLD_TYP_FLD(IDX) type_tbl[IDX].fld.old_type_fld 04137 # define OLD_TYP_RESOLVED(IDX) type_tbl[IDX].wd.old_resolved 04138 # define OLD_TYP_TYPE(IDX) type_tbl[IDX].wd.old_type 04139 04140 04141 04142 /* SYMBOL TABLE SEARCH AND ENTER MACROS */ 04143 04144 /* Used for secondary name table pool index and length. */ 04145 04146 # define MSK_NAME_IDX 0000000000000077777777 04147 # define MSK_NAME_LEN 0000000000000000000377 04148 04149 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 04150 # define SN_NP_IDX(IDX) (sn_tbl_base[(IDX)<<1] & MSK_NAME_IDX) 04151 # else 04152 # define SN_NP_IDX(IDX) SN_NAME_IDX(IDX) 04153 # endif 04154 04155 # if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 04156 # define SN_LEN(IDX) ((sn_tbl_base[(IDX)<<1]>>24)&MSK_NAME_LEN) 04157 # else 04158 # define SN_LEN(IDX) SN_NAME_LEN(IDX) 04159 # endif 04160 04161 /* Cray shift is logical, SUN's and Alpha is arithmetic and */ 04162 /* preserves the sign bit */ 04163 04164 # ifdef _HOST_OS_UNICOS 04165 # define RIGHT_JUSTIFY_SIGN_BIT(I) (I) >> (8 * sizeof(long) - 1) 04166 # else 04167 # define RIGHT_JUSTIFY_SIGN_BIT(I) ((unsigned long) (I) >> (8 * sizeof(long)-1)) 04168 # endif 04169 04170 # define STRIDE_CALC(SEG_LEN) (((SEG_LEN) + _MAXVL - 1) / _MAXVL) 04171 # define WORD_LEN(ID_LEN) ((ID_LEN) + sizeof(long)) / sizeof(long) 04172 04173 04174 /***********************************************\ 04175 |* STATEMENT/FUNCTION-LIKE REPLACEMENT STRINGS *| 04176 \***********************************************/ 04177 04178 # define CLEAR_ATTR_NTRY(IDX) \ 04179 CLEAR_TBL_NTRY(attr_tbl, IDX); \ 04180 CLEAR_TBL_NTRY(attr_aux_tbl, IDX); 04181 04182 # define CLEAR_TBL_NTRY(TBL,IDX) \ 04183 { \ 04184 long *_tbl_idx; \ 04185 int _tbl_i; \ 04186 int _size; \ 04187 _tbl_idx = ((long *) (&TBL[IDX])); \ 04188 _size = TBL##_num_wds; \ 04189 Pragma("_CRI shortloop") \ 04190 for (_tbl_i = 0; _tbl_i < _size; _tbl_i++) { \ 04191 *(_tbl_idx) = 0; \ 04192 _tbl_idx++; \ 04193 } \ 04194 } 04195 04196 # define COPY_ATTR_NTRY(TO, FROM) \ 04197 attr_tbl[TO] = attr_tbl[FROM]; \ 04198 attr_aux_tbl[TO] = attr_aux_tbl[FROM]; 04199 04200 04201 # define COPY_TBL_NTRY(TBL, TO, FROM) \ 04202 { \ 04203 long *_to_idx, *_from_idx; \ 04204 int _idx; \ 04205 int _size; \ 04206 _from_idx = ((long *) (&TBL[FROM])); \ 04207 _to_idx = ((long *) (&TBL[TO])); \ 04208 _size = TBL##_num_wds; \ 04209 Pragma("_CRI shortloop") \ 04210 for (_idx = 0; _idx < _size; _idx++) { \ 04211 *(_to_idx) = *(_from_idx); \ 04212 _to_idx++; \ 04213 _from_idx++; \ 04214 } \ 04215 } 04216 04217 # define COPY_GL_TBL_NTRY(TBL1, TBL2, TO, FROM) \ 04218 { \ 04219 long *_to_idx, *_from_idx; \ 04220 int _idx; \ 04221 _from_idx = ((long *) (&TBL2[FROM])); \ 04222 _to_idx = ((long *) (&TBL1[TO])); \ 04223 Pragma("_CRI shortloop") \ 04224 for (_idx = 0; _idx < TBL2##_num_wds; _idx++) { \ 04225 *(_to_idx) = *(_from_idx); \ 04226 _to_idx++; \ 04227 _from_idx++; \ 04228 } \ 04229 } 04230 04231 04232 # define COPY_BD_NTRY(TO, FROM) \ 04233 { \ 04234 int _idx, _bd_num; \ 04235 int _size; \ 04236 long *_to_idx, *_from_idx; \ 04237 _from_idx = ((long *) (&bounds_tbl[FROM])); \ 04238 _to_idx = ((long *) (&bounds_tbl[TO])); \ 04239 _bd_num = BD_NTRY_SIZE(FROM); \ 04240 _size = NUM_BD_WDS * _bd_num; \ 04241 Pragma("_CRI shortloop") \ 04242 for (_idx = 0; _idx < _size; _idx++) { \ 04243 *(_to_idx) = *(_from_idx); \ 04244 _to_idx++; \ 04245 _from_idx++; \ 04246 } \ 04247 } 04248 04249 04250 # define CREATE_ERR_ATTR(IDX, LINE, COL, CLASS) \ 04251 { \ 04252 int _al_idx; \ 04253 int _err_idx; \ 04254 NTR_ATTR_TBL(_err_idx); \ 04255 AT_DCL_ERR(IDX) = TRUE; \ 04256 COPY_COMMON_ATTR_INFO(IDX, _err_idx, CLASS); \ 04257 AT_ATTR_LINK(_err_idx) = NULL_IDX; \ 04258 AT_DEF_LINE(_err_idx) = LINE; \ 04259 AT_DEF_COLUMN(_err_idx) = COL; \ 04260 IDX = _err_idx; \ 04261 NTR_ATTR_LIST_TBL(_al_idx); \ 04262 AL_ATTR_IDX(_al_idx) = _err_idx; \ 04263 AL_NEXT_IDX(_al_idx) = SCP_CIF_ERR_LIST(curr_scp_idx); \ 04264 SCP_CIF_ERR_LIST(curr_scp_idx) = _al_idx; \ 04265 } 04266 04267 /* This macro copies common fields from on attr entry to another. Class is */ 04268 /* what AT_OBJ_CLASS should end up being after the copy, in the TO attr. */ 04269 /* CLASS is passed in to prevent variant problems, because AT_OBJ_CLASS is */ 04270 /* used to decide which variant is active. */ 04271 04272 # ifdef _HOST64 04273 # define COPY_COMMON_ATTR_INFO(FROM, TO, CLASS) \ 04274 {attr_tbl[(TO)].wd[0] = attr_tbl[(FROM)].wd[0]; \ 04275 attr_tbl[(TO)].wd[1] = attr_tbl[(FROM)].wd[1]; \ 04276 attr_tbl[(TO)].fldd.field32_5 = attr_tbl[(FROM)].fldd.field32_5; \ 04277 attr_aux_tbl[(TO)].wd[0] = attr_aux_tbl[(FROM)].wd[0]; \ 04278 AT_OBJ_CLASS(TO) = CLASS; \ 04279 AT_CIF_SYMBOL_ID(TO) = 0; \ 04280 AT_CIF_DONE(TO) = FALSE; \ 04281 } 04282 # else 04283 # define COPY_COMMON_ATTR_INFO(FROM, TO, CLASS) \ 04284 {attr_tbl[(TO)].wd[0] = attr_tbl[(FROM)].wd[0]; \ 04285 attr_tbl[(TO)].wd[1] = attr_tbl[(FROM)].wd[1]; \ 04286 attr_tbl[(TO)].wd[2] = attr_tbl[(FROM)].wd[2]; \ 04287 attr_tbl[(TO)].wd[3] = attr_tbl[(FROM)].wd[3]; \ 04288 attr_tbl[(TO)].wd[4] = attr_tbl[(FROM)].wd[4]; \ 04289 attr_aux_tbl[(TO)].wd[0] = attr_aux_tbl[(FROM)].wd[0]; \ 04290 attr_aux_tbl[(TO)].wd[1] = attr_aux_tbl[(FROM)].wd[1]; \ 04291 AT_OBJ_CLASS(TO) = CLASS; \ 04292 AT_CIF_SYMBOL_ID(TO) = 0; \ 04293 AT_CIF_DONE(TO) = FALSE; \ 04294 } 04295 # endif 04296 04297 # ifdef _HOST64 04298 # define COPY_VARIANT_ATTR_INFO(FROM, TO, CLASS) \ 04299 {attr_tbl[(TO)].fldd.field32_6 = attr_tbl[(FROM)].fldd.field32_6; \ 04300 attr_tbl[(TO)].wd[3] = attr_tbl[(FROM)].wd[3]; \ 04301 attr_tbl[(TO)].wd[4] = attr_tbl[(FROM)].wd[4]; \ 04302 attr_tbl[(TO)].wd[5] = attr_tbl[(FROM)].wd[5]; \ 04303 attr_tbl[(TO)].wd[6] = attr_tbl[(FROM)].wd[6]; \ 04304 attr_aux_tbl[(TO)].wd[1] = attr_aux_tbl[(FROM)].wd[1]; \ 04305 attr_aux_tbl[(TO)].wd[2] = attr_aux_tbl[(FROM)].wd[2]; \ 04306 AT_OBJ_CLASS(TO) = CLASS; \ 04307 } 04308 # else 04309 # define COPY_VARIANT_ATTR_INFO(FROM, TO, CLASS) \ 04310 {attr_tbl[(TO)].wd[5] = attr_tbl[(FROM)].wd[5]; \ 04311 attr_tbl[(TO)].wd[6] = attr_tbl[(FROM)].wd[6]; \ 04312 attr_tbl[(TO)].wd[7] = attr_tbl[(FROM)].wd[7]; \ 04313 attr_tbl[(TO)].wd[8] = attr_tbl[(FROM)].wd[8]; \ 04314 attr_tbl[(TO)].wd[9] = attr_tbl[(FROM)].wd[9]; \ 04315 attr_tbl[(TO)].wd[10] = attr_tbl[(FROM)].wd[10]; \ 04316 attr_tbl[(TO)].wd[11] = attr_tbl[(FROM)].wd[11]; \ 04317 attr_tbl[(TO)].wd[12] = attr_tbl[(FROM)].wd[12]; \ 04318 attr_tbl[(TO)].wd[13] = attr_tbl[(FROM)].wd[13]; \ 04319 attr_aux_tbl[(TO)].wd[2] = attr_aux_tbl[(FROM)].wd[2]; \ 04320 attr_aux_tbl[(TO)].wd[3] = attr_aux_tbl[(FROM)].wd[3]; \ 04321 attr_aux_tbl[(TO)].wd[4] = attr_aux_tbl[(FROM)].wd[4]; \ 04322 attr_aux_tbl[(TO)].wd[5] = attr_aux_tbl[(FROM)].wd[5]; \ 04323 AT_OBJ_CLASS(TO) = CLASS; \ 04324 } 04325 # endif 04326 04327 04328 /* This macro clears variant fields in the attr entry. AT_OBJ_CLASS = CLASS */ 04329 /* CLASS is passed in to prevent variant problems, because AT_OBJ_CLASS is */ 04330 /* used to decide which variant is active. */ 04331 04332 # ifdef _HOST64 04333 # define CLEAR_VARIANT_ATTR_INFO(IDX, CLASS) \ 04334 {attr_tbl[(IDX)].fldd.field32_6 = 0; \ 04335 attr_tbl[(IDX)].wd[3] = 0; \ 04336 attr_tbl[(IDX)].wd[4] = 0; \ 04337 attr_tbl[(IDX)].wd[5] = 0; \ 04338 attr_tbl[(IDX)].wd[6] = 0; \ 04339 AT_OBJ_CLASS(IDX) = CLASS; \ 04340 attr_aux_tbl[(IDX)].wd[1] = 0; \ 04341 attr_aux_tbl[(IDX)].wd[2] = 0; \ 04342 } 04343 # else 04344 # define CLEAR_VARIANT_ATTR_INFO(IDX, CLASS) \ 04345 {attr_tbl[(IDX)].wd[5] = 0; \ 04346 attr_tbl[(IDX)].wd[6] = 0; \ 04347 attr_tbl[(IDX)].wd[7] = 0; \ 04348 attr_tbl[(IDX)].wd[8] = 0; \ 04349 attr_tbl[(IDX)].wd[9] = 0; \ 04350 attr_tbl[(IDX)].wd[10] = 0; \ 04351 attr_tbl[(IDX)].wd[11] = 0; \ 04352 attr_tbl[(IDX)].wd[12] = 0; \ 04353 attr_tbl[(IDX)].wd[13] = 0; \ 04354 AT_OBJ_CLASS(IDX) = CLASS; \ 04355 attr_aux_tbl[(IDX)].wd[2] = 0; \ 04356 attr_aux_tbl[(IDX)].wd[3] = 0; \ 04357 attr_aux_tbl[(IDX)].wd[4] = 0; \ 04358 attr_aux_tbl[(IDX)].wd[5] = 0; \ 04359 } 04360 # endif 04361 04362 /* Use to make a Function result for an attribute. The attribute must be a */ 04363 /* Pgm_Unit. Adding any of the following to a Pgm_Unit attr with */ 04364 /* Pgm_Unknown will force it to a Function: TYPE, DIMENSION, POINTER, */ 04365 /* TARGET, VFUNCTION, or declaring it to be a NAMELIST object. Also, */ 04366 /* this is needed by call_list_semantics when something is being called */ 04367 /* as a Function, but is still a Pgm_Unknown. This only creates the */ 04368 /* result attr and links it up. Typing and anything else must be done */ 04369 /* by the caller. */ 04370 04371 04372 # define CREATE_FUNC_RSLT(AT_IDX, RSLT_IDX) \ 04373 NTR_ATTR_TBL(RSLT_IDX); \ 04374 COPY_COMMON_ATTR_INFO(AT_IDX, RSLT_IDX, Data_Obj); \ 04375 ATD_CLASS(RSLT_IDX) = Function_Result; \ 04376 ATD_FUNC_IDX(RSLT_IDX) = AT_IDX; \ 04377 ATP_RSLT_IDX(AT_IDX) = RSLT_IDX; 04378 04379 04380 # define FREE_IR_LIST_NODE(IDX) \ 04381 IL_NEXT_LIST_IDX(IDX) = IL_NEXT_LIST_IDX(NULL_IDX); \ 04382 IL_NEXT_LIST_IDX(NULL_IDX) = IDX; 04383 04384 04385 # define FREE_IR_NODE(IDX) \ 04386 IR_NEXT_IDX(IDX) = IR_NEXT_IDX(NULL_IDX); \ 04387 IR_NEXT_IDX(NULL_IDX) = IDX; 04388 04389 04390 # define FREE_SH_NODE(IDX) \ 04391 SH_NEXT_IDX(IDX) = SH_NEXT_IDX(NULL_IDX); \ 04392 SH_NEXT_IDX(NULL_IDX) = IDX; 04393 04394 # define FREE_GL_IR_LIST_NODE(IDX) \ 04395 GL_IL_NEXT_LIST_IDX(IDX) = GL_IL_NEXT_LIST_IDX(NULL_IDX); \ 04396 GL_IL_NEXT_LIST_IDX(NULL_IDX) = IDX; 04397 04398 04399 # define FREE_GL_IR_NODE(IDX) \ 04400 GL_IR_NEXT_IDX(IDX) = GL_IR_NEXT_IDX(NULL_IDX); \ 04401 GL_IR_NEXT_IDX(NULL_IDX) = IDX; 04402 04403 04404 # define FREE_GL_SH_NODE(IDX) \ 04405 GL_SH_NEXT_IDX(IDX) = GL_SH_NEXT_IDX(NULL_IDX); \ 04406 GL_SH_NEXT_IDX(NULL_IDX) = IDX; 04407 04408 04409 04410 # define GEN_COMPILER_TMP_ASG(IR_IDX, ATTR_IDX, SEM_DONE, LINE, COL, TYPE_IDX, \ 04411 SCOPE) \ 04412 {NTR_IR_TBL(IR_IDX); \ 04413 ATTR_IDX = gen_compiler_tmp(LINE,COL,SCOPE,TRUE); \ 04414 AT_SEMANTICS_DONE(ATTR_IDX) = SEM_DONE; \ 04415 ATD_TYPE_IDX(ATTR_IDX) = TYPE_IDX; \ 04416 ATD_TMP_IDX(ATTR_IDX) = IR_IDX; \ 04417 ATD_FLD(ATTR_IDX) = IR_Tbl_Idx; \ 04418 ATD_STOR_BLK_IDX(ATTR_IDX) = SCP_SB_STACK_IDX(curr_scp_idx); \ 04419 AT_DEFINED(ATTR_IDX) = TRUE; \ 04420 IR_OPR(IR_IDX) = Asg_Opr; \ 04421 IR_TYPE_IDX(IR_IDX) = ATD_TYPE_IDX(ATTR_IDX); \ 04422 IR_FLD_L(IR_IDX) = AT_Tbl_Idx; \ 04423 IR_IDX_L(IR_IDX) = ATTR_IDX; \ 04424 IR_LINE_NUM_L(IR_IDX) = LINE; \ 04425 IR_LINE_NUM(IR_IDX) = LINE; \ 04426 IR_COL_NUM_L(IR_IDX) = COL; \ 04427 IR_COL_NUM(IR_IDX) = COL; \ 04428 } 04429 04430 # define IS_STMT_ENTITY(ATTR_IDX) \ 04431 (AT_OBJ_CLASS(ATTR_IDX) == Data_Obj && \ 04432 ATD_SEEN_AS_LCV(ATTR_IDX) && \ 04433 ! ATD_SEEN_IN_IMP_DO(ATTR_IDX) && \ 04434 ! ATD_SEEN_OUTSIDE_IMP_DO(ATTR_IDX)) 04435 04436 # define NTR_ATTR_TBL(ATTR_IDX) \ 04437 TBL_REALLOC_CK(attr_tbl, 1); \ 04438 CLEAR_TBL_NTRY(attr_tbl, attr_tbl_idx); \ 04439 TBL_REALLOC_CK(attr_aux_tbl, 1); \ 04440 CLEAR_TBL_NTRY(attr_aux_tbl, attr_aux_tbl_idx); \ 04441 ATTR_IDX = attr_tbl_idx; 04442 04443 # define NTR_ATTR_LIST_TBL(ATTR_LIST_IDX) \ 04444 {int _idx; \ 04445 _idx = ntr_attr_list_tbl(); \ 04446 ATTR_LIST_IDX = _idx;} 04447 04448 # define ADD_ATTR_TO_LOCAL_LIST(AT_IDX) add_attr_to_local_list(AT_IDX); 04449 04450 04451 # define NTR_EQ_TBL(EQ_IDX) \ 04452 TBL_REALLOC_CK(equiv_tbl, 1); \ 04453 CLEAR_TBL_NTRY(equiv_tbl, equiv_tbl_idx); \ 04454 EQ_OFFSET_FLD(equiv_tbl_idx) = CN_Tbl_Idx; \ 04455 EQ_OFFSET_IDX(equiv_tbl_idx) = CN_INTEGER_ZERO_IDX; \ 04456 EQ_IDX = equiv_tbl_idx; 04457 04458 /* If a module is to be read on a 64 bit system, it requires a full 64 bit */ 04459 /* word following the name pool entry. If the name pool entry was originally */ 04460 /* created on a 32 bit system, it would only have a 32 bit word following it. */ 04461 /* This macro is used to add an extra 32 bit word when this is a cross */ 04462 /* compiler from a 32 bit system to a 64 bit system. */ 04463 04464 # if defined(_TARGET64) && defined(_HOST32) 04465 # define EXTRA_WORD 1 04466 # else 04467 # define EXTRA_WORD 0 04468 # endif 04469 04470 # define NTR_NAME_POOL(NAME, LEN, NP_IDX) \ 04471 {register long *_name_id; \ 04472 register int _np_idx; \ 04473 register int _start_idx; \ 04474 register int _wd_len; \ 04475 _name_id = NAME; \ 04476 _wd_len = WORD_LEN(LEN) + EXTRA_WORD; \ 04477 _start_idx = name_pool_idx + 1; \ 04478 NP_IDX = _start_idx; \ 04479 TBL_REALLOC_CK(name_pool,_wd_len); \ 04480 for (_np_idx = 0; _np_idx < _wd_len; _np_idx++) { \ 04481 name_pool[_start_idx+_np_idx].name_long = _name_id[_np_idx]; \ 04482 } \ 04483 } 04484 04485 04486 # define NTR_IR_LIST_TBL(IR_LIST_IDX) \ 04487 {int _idx; \ 04488 _idx = ntr_ir_list_tbl(); \ 04489 IR_LIST_IDX = _idx;} 04490 04491 04492 04493 # define NTR_IR_TBL(IR_IDX) \ 04494 {int _idx; \ 04495 _idx = ntr_ir_tbl(); \ 04496 IR_IDX = _idx;} 04497 04498 # define NTR_GL_IR_LIST_TBL(IR_LIST_IDX) \ 04499 {int _idx; \ 04500 _idx = ntr_gl_ir_list_tbl(); \ 04501 IR_LIST_IDX = _idx;} 04502 04503 04504 04505 # define NTR_GL_IR_TBL(IR_IDX) \ 04506 {int _idx; \ 04507 _idx = ntr_gl_ir_tbl(); \ 04508 IR_IDX = _idx;} 04509 04510 04511 04512 # define NTR_SCP_TBL(SCP_IDX) \ 04513 TBL_REALLOC_CK(scp_tbl,1); \ 04514 CLEAR_TBL_NTRY(scp_tbl, scp_tbl_idx); \ 04515 SCP_IDX = scp_tbl_idx; 04516 04517 04518 # define NTR_SN_TBL(SN_IDX) \ 04519 TBL_REALLOC_CK(sec_name_tbl,1); \ 04520 CLEAR_TBL_NTRY(sec_name_tbl, sec_name_tbl_idx); \ 04521 SN_IDX = sec_name_tbl_idx; 04522 04523 04524 # define NTR_INTERFACE_IN_SN_TBL(SN_IDX, AT_IDX, PARENT_IDX, LINE, COLUMN) \ 04525 NTR_SN_TBL(SN_IDX); \ 04526 SN_ATTR_IDX(SN_IDX) = AT_IDX; \ 04527 SN_NAME_LEN(SN_IDX) = AT_NAME_LEN(AT_IDX); \ 04528 SN_NAME_IDX(SN_IDX) = AT_NAME_IDX(AT_IDX); \ 04529 SN_LINE_NUM(SN_IDX) = LINE; \ 04530 SN_COLUMN_NUM(SN_IDX) = COLUMN; \ 04531 SN_SIBLING_LINK(SN_IDX) = ATI_FIRST_SPECIFIC_IDX(PARENT_IDX);\ 04532 ATI_FIRST_SPECIFIC_IDX(PARENT_IDX)= SN_IDX; \ 04533 ATI_NUM_SPECIFICS(PARENT_IDX) += 1; 04534 04535 04536 #if defined(_HOST64) && !defined(_WHIRL_HOST64_TARGET64) 04537 # define NTR_NAME_IN_LN_TBL(ENTER_NAME_IDX, NEW_NAME_IDX) \ 04538 {long *_name_tbl_base; \ 04539 int _idx; \ 04540 _name_tbl_base = (long *) loc_name_tbl; \ 04541 Pragma("_CRI ivdep") \ 04542 for (_idx = SCP_LN_LW_IDX(curr_scp_idx); \ 04543 _idx>= ENTER_NAME_IDX; _idx--) { \ 04544 _name_tbl_base[_idx] = _name_tbl_base[_idx-1]; \ 04545 } \ 04546 loc_name_tbl[ENTER_NAME_IDX] = loc_name_tbl[NEW_NAME_IDX]; \ 04547 } 04548 #else 04549 # define NTR_NAME_IN_LN_TBL(ENTER_NAME_IDX, NEW_NAME_IDX) \ 04550 {int _idx; \ 04551 Pragma("_CRI ivdep") \ 04552 for (_idx = SCP_LN_LW_IDX(curr_scp_idx); \ 04553 _idx>= ENTER_NAME_IDX; _idx--) { \ 04554 loc_name_tbl[_idx] = loc_name_tbl[_idx-1]; \ 04555 } \ 04556 loc_name_tbl[ENTER_NAME_IDX] = loc_name_tbl[NEW_NAME_IDX]; \ 04557 } 04558 # endif 04559 04560 04561 # define SET_IMPL_TYPE(AT_IDX) \ 04562 {int _i_idx; \ 04563 _i_idx = IMPL_IDX(AT_OBJ_NAME(AT_IDX)); \ 04564 ATD_TYPE_IDX(AT_IDX) = IM_TYPE_IDX(curr_scp_idx, _i_idx); \ 04565 } 04566 04567 04568 # define SET_IMPL_TYPE_IN_SCP(AT_IDX, SCP_IDX) \ 04569 {int _i_idx; \ 04570 _i_idx = IMPL_IDX(AT_OBJ_NAME(AT_IDX)); \ 04571 ATD_TYPE_IDX(AT_IDX) = IM_TYPE_IDX(SCP_IDX, _i_idx); \ 04572 } 04573 04574 # define BITS_TO_WORDS(BIT_SIZE, ALIGN_TO) \ 04575 bits_and_bytes_to_words(&(BIT_SIZE), (ALIGN_TO == 64) ? 63:31, \ 04576 (ALIGN_TO == 64) ? 6 : 5); 04577 04578 # define BYTES_TO_WORDS(BIT_SIZE, ALIGN_TO) \ 04579 bits_and_bytes_to_words(&(BIT_SIZE), (ALIGN_TO == 64) ? 7:3, \ 04580 (ALIGN_TO == 64) ? 3 : 2); 04581 04582 /* This routine will test the value held in an integer array (c) against */ 04583 /* the value held in TRUE_VALUE to see if the they match. This is to */ 04584 /* the cases when a logical result from a fold is two machine words. */ 04585 04586 # if defined(_TARGET32) && !defined(_TARGET_LITTLE_ENDIAN) 04587 # define THIS_IS_TRUE(THE_CONSTANT, TYPE_IDX) \ 04588 ((THE_CONSTANT)[(TYP_LINEAR(TYPE_IDX) == Logical_8) ? 1:0] == TRUE_VALUE) 04589 # else /* TARGET64 */ 04590 # define THIS_IS_TRUE(THE_CONSTANT, TYPE_IDX) \ 04591 ((THE_CONSTANT)[0] == TRUE_VALUE) 04592 # endif 04593 04594 04595 # if defined(_HOST64) && defined(_TARGET64) 04596 # define CONVERT_CVAL_TO_STR(CONSTANT, TYPE_IDX, RESULT) \ 04597 convert_to_string(CONSTANT, TYPE_IDX, RESULT) 04598 # else 04599 # define CONVERT_CVAL_TO_STR(CONSTANT, TYPE_IDX, RESULT) \ 04600 convert_cval_to_string(CONSTANT, TYPE_IDX, RESULT) 04601 # endif 04602 04603 04604 /******************************************************************************\ 04605 |* *| 04606 |* The following macros are used to convert host and target integer constant. *| 04607 |* be used in 'C' arithmetic and comparison. *| 04608 |* *| 04609 |* C_TO_F_INT : C host integer const to target const in an array of long_type*| 04610 |* C_INT_TO_CN : C host integer const to the constant table. *| 04611 |* CN_INT_TO_C : Constant table entry to C host integer const *| 04612 |* F_INT_TO_C : Target integer constant (array of long_type) to C host int *| 04613 |* *| 04614 |* target integer constant is declared long_type con[MAX_WORDS_FOR_INTEGER]*| 04615 |* A host integer constant is declared long64 con *| 04616 |* *| 04617 |* Arithmetic on target integer constants must be done with calls to folder. *| 04618 |* Arithmetic on host integer constants can be done with 'C' code. *| 04619 |* *| 04620 |* The underlying defs for long_type and long64 are in target.h *| 04621 |* *| 04622 \******************************************************************************/ 04623 04624 04625 # if defined(_TARGET64) && defined(_HOST64) 04626 # define F_INT_TO_C(ARRAY,LIN_TYPE) *(ARRAY) 04627 # elif (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) 04628 # define F_INT_TO_C(ARRAY,LIN_TYPE) \ 04629 ((LIN_TYPE == Integer_8 || LIN_TYPE == Typeless_8) \ 04630 ? *((long64 *) (ARRAY)):(long64) *(ARRAY)) 04631 # else 04632 # define F_INT_TO_C(ARRAY,LIN_TYPE) f_int_to_cval(ARRAY, LIN_TYPE) 04633 # endif 04634 04635 # if defined(_TARGET_OS_MAX) 04636 # define CN_INT_TO_C(IDX) mpp_cn_int_to_c(IDX) 04637 # else 04638 # define CN_INT_TO_C(IDX) \ 04639 F_INT_TO_C(&CN_CONST(IDX), TYP_LINEAR(CN_TYPE_IDX(IDX))) 04640 # endif 04641 04642 # define C_INT_TO_CN(TYPE_IDX, CONST) \ 04643 ntr_int_const_tbl(TYPE_IDX, (long64) (CONST)) 04644 04645 /* Extra care is taken here, because CONST might be a literal */ 04646 /* constant, so an address cannot be taken of CONST. */ 04647 04648 /* 09Feb01[sos] was: # if defined(_TARGET64) && defined(_HOST64) */ 04649 # if defined(_TARGET64) 04650 # define C_TO_F_INT(ARRAY, CONST, LIN_TYPE) ARRAY[0] = CONST 04651 # elif (defined(_TARGET_OS_IRIX) || defined(_TARGET_OS_LINUX)) 04652 # define C_TO_F_INT(ARRAY, CONST, LIN_TYPE) \ 04653 { \ 04654 long *_cn_ptr; \ 04655 long64 _big_cn; \ 04656 if (LIN_TYPE == Integer_8 || LIN_TYPE == Typeless_8) { \ 04657 _big_cn = (long64) CONST; \ 04658 _cn_ptr = (long *) &_big_cn; \ 04659 ARRAY[0] = *_cn_ptr; \ 04660 ARRAY[1] = *(++_cn_ptr); \ 04661 } else { \ 04662 ARRAY[0] = (long) CONST; \ 04663 ARRAY[1] = 0; \ 04664 } } 04665 # else 04666 # define C_TO_F_INT(ARRAY, CONST, LIN_TYPE) \ 04667 { \ 04668 long64 _con; \ 04669 _con = (long64) CONST; \ 04670 cval_to_f_int(ARRAY, &_con, LIN_TYPE); \ 04671 } 04672 # endif 04673
1.7.6.1 
