00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047 #ifndef symtab_compatible_INCLUDED
00048 #define symtab_compatible_INCLUDED
00049
00050 #define SYMTAB_COMPATIBLE_DEVWARN_LIMIT 2
00051
00052
00053
00054 inline STR_IDX
00055 ST_name_idx (const ST* s) { return s->u1.name_idx; }
00056 inline void
00057 Set_ST_name_idx (ST* s, STR_IDX idx) { s->u1.name_idx = idx; }
00058 inline char *
00059 ST_name (const ST* s) { return &Str_Table[ST_name_idx (s)]; }
00060 #define Set_ST_name(s,idx) Set_ST_name_idx(s,idx)
00061
00062 inline TCON_IDX
00063 ST_tcon (const ST* s) { return s->u1.tcon; }
00064 inline void
00065 Set_ST_tcon (ST* s, TCON_IDX tcon) { s->u1.tcon = tcon; }
00066
00067 inline ST_CLASS
00068 ST_sym_class (const ST* s) { return s->sym_class; }
00069
00070 inline ST_CLASS
00071 ST_class (const ST* s) { return ST_sym_class (s); }
00072
00073 inline ST_CLASS
00074 ST_class (const ST& s) { return ST_sym_class (s); }
00075
00076 inline void
00077 Set_ST_class (ST* s, ST_CLASS c) { s->sym_class = c; }
00078
00079 inline ST_SCLASS
00080 ST_sclass (const ST* s) { return s->storage_class; }
00081
00082 inline void
00083 Set_ST_sclass (ST* s, ST_SCLASS sc) { s->storage_class = sc; }
00084
00085 inline ST_EXPORT
00086 ST_export (const ST* s) { return s->export_class; }
00087 inline void
00088 Set_ST_export (ST* s, ST_EXPORT export_class)
00089 {
00090 #ifdef Is_True_On
00091 ST_Verify_Sclass_Export (ST_sclass (s), export_class, s);
00092 #endif
00093 s->export_class = export_class;
00094 }
00095
00096 inline TY_IDX
00097 ST_type (const ST* s) {
00098 #ifdef Is_True_On
00099 switch (s->sym_class) {
00100 default:
00101 Fail_FmtAssertion ("Invalid argument for ST_type ()");
00102 #ifdef KEY
00103 case CLASS_BLOCK:
00104 #endif
00105 case CLASS_VAR:
00106 case CLASS_CONST:
00107 case CLASS_PREG:
00108 case CLASS_NAME:
00109 return s->u2.type;
00110 case CLASS_FUNC:
00111 Lmt_DevWarn (SYMTAB_COMPATIBLE_DEVWARN_LIMIT,
00112 ("Should use ST_pu_type instead"));
00113 return PU_prototype (Pu_Table[s->u2.pu]);
00114 }
00115 #else
00116 if (s->sym_class == CLASS_FUNC) {
00117 Lmt_DevWarn (SYMTAB_COMPATIBLE_DEVWARN_LIMIT,
00118 ("Should use ST_pu_type instead"));
00119 return PU_prototype (Pu_Table[s->u2.pu]);
00120 } else {
00121 return s->u2.type;
00122 }
00123 #endif // Is_True_On
00124 }
00125 inline void
00126 Set_ST_type (ST* s, TY_IDX t) {
00127 #ifdef Is_True_On
00128 switch (s->sym_class) {
00129 default:
00130 Fail_FmtAssertion ("Invalid argument for ST_type ()");
00131 case CLASS_VAR:
00132 case CLASS_CONST:
00133 case CLASS_PREG:
00134 case CLASS_NAME:
00135 s->u2.type = t;
00136 }
00137 #else
00138 s->u2.type = t;
00139 #endif // Is_True_On
00140 }
00141
00142 inline TY_IDX
00143 ST_pu_type (const ST_IDX s) {
00144 Is_True (St_Table[s].sym_class == CLASS_FUNC, ("Invalid argument for ST_pu"));
00145 return PU_prototype (Pu_Table[ST_pu (St_Table[s])]);
00146 }
00147
00148 inline PU_IDX
00149 ST_pu (const ST* s) {
00150 Is_True (s->sym_class == CLASS_FUNC ||
00151 (s->sym_class == CLASS_NAME &&
00152 ST_asm_function_st(*s)),
00153 ("Invalid argument for ST_pu"));
00154 return s->u2.pu;
00155 }
00156 inline void
00157 Set_ST_pu (ST* s, PU_IDX pu)
00158 {
00159 Is_True (s->sym_class == CLASS_FUNC ||
00160 (s->sym_class == CLASS_NAME &&
00161 ST_asm_function_st(*s)),
00162 ("Invalid argument for ST_pu"));
00163 s->u2.pu = pu;
00164 }
00165
00166 inline BLK_IDX
00167 ST_blk (const ST* s) {
00168 Is_True (s->sym_class == CLASS_BLOCK, ("Invalid argument for ST_blk"));
00169 return s->u2.blk;
00170 }
00171 inline void
00172 Set_ST_blk (ST* s, BLK_IDX b)
00173 {
00174 Is_True (s->sym_class == CLASS_BLOCK, ("Invalid argument for ST_blk"));
00175 s->u2.blk = b;
00176 }
00177
00178 inline ST_IDX
00179 ST_st_idx (const ST* s)
00180 { return (s != NULL? s->st_idx : (ST_IDX) 0); }
00181 inline void
00182 Set_ST_st_idx (ST* s, ST_IDX idx) { s->st_idx = idx; }
00183
00184 inline BOOL
00185 ST_is_weak_symbol (const ST* s) { return s->flags & ST_IS_WEAK_SYMBOL;}
00186 inline void
00187 Set_ST_is_weak_symbol (ST* s) { s->flags |= ST_IS_WEAK_SYMBOL; }
00188 inline void
00189 Clear_ST_is_weak_symbol (ST* s) { s->flags &= ~ST_IS_WEAK_SYMBOL; }
00190
00191 inline BOOL
00192 ST_is_split_common (const ST* s) { return s->flags & ST_IS_SPLIT_COMMON;}
00193 inline void
00194 Set_ST_is_split_common (ST* s) { s->flags |= ST_IS_SPLIT_COMMON; }
00195 inline void
00196 Clear_ST_is_split_common (ST* s) { s->flags &= ~ST_IS_SPLIT_COMMON; }
00197
00198 inline ST_IDX
00199 ST_base_idx (const ST* s)
00200 {
00201 if (ST_is_split_common (s))
00202 return s->st_idx;
00203 else if (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN)
00204 return s->st_idx;
00205 else
00206 return s->base_idx;
00207 }
00208 inline void
00209 Set_ST_base_idx (ST* s, ST_IDX base)
00210 {
00211 if (ST_is_split_common (s))
00212 Lmt_DevWarn (SYMTAB_COMPATIBLE_DEVWARN_LIMIT,
00213 ("Shouldn't set base when split"));
00214 if (ST_is_weak_symbol(s) && ST_sclass(s) == SCLASS_EXTERN)
00215 Lmt_DevWarn (SYMTAB_COMPATIBLE_DEVWARN_LIMIT,
00216 ("Shouldn't set base when weak"));
00217 s->base_idx = base;
00218 }
00219 inline ST*
00220 ST_base (const ST* s) { return &St_Table[ST_base_idx (s)]; }
00221 inline void
00222 Set_ST_base (ST* s, ST* base) { Set_ST_base_idx(s, ST_st_idx(base)); }
00223
00224 inline UINT64
00225 ST_ofst (const ST* s) { return s->offset; }
00226 inline void
00227 Set_ST_ofst (ST* s, UINT64 offset) { s->offset = offset; }
00228
00229
00230
00231 inline BOOL
00232 ST_is_not_used (const ST* s) { return s->flags & ST_IS_NOT_USED;}
00233 inline void
00234 Set_ST_is_not_used (ST* s) { s->flags |= ST_IS_NOT_USED; }
00235 inline void
00236 Clear_ST_is_not_used (ST* s) { s->flags &= ~ST_IS_NOT_USED; }
00237
00238 inline BOOL
00239 ST_is_initialized (const ST* s) { return s->flags & ST_IS_INITIALIZED;}
00240 inline void
00241 Set_ST_is_initialized (ST* s) { s->flags |= ST_IS_INITIALIZED; }
00242 inline void
00243 Clear_ST_is_initialized (ST* s) { s->flags &= ~ST_IS_INITIALIZED; }
00244
00245 inline BOOL
00246 ST_is_return_var (const ST* s) { return s->flags & ST_IS_RETURN_VAR;}
00247 inline void
00248 Set_ST_is_return_var (ST* s) { s->flags |= ST_IS_RETURN_VAR; }
00249 inline void
00250 Clear_ST_is_return_var (ST* s) { s->flags &= ~ST_IS_RETURN_VAR; }
00251
00252 inline BOOL
00253 ST_is_value_parm (const ST* s) { return s->flags & ST_IS_VALUE_PARM;}
00254 inline void
00255 Set_ST_is_value_parm (ST* s) { s->flags |= ST_IS_VALUE_PARM; }
00256 inline void
00257 Clear_ST_is_value_parm (ST* s) { s->flags &= ~ST_IS_VALUE_PARM; }
00258
00259 inline BOOL
00260 ST_promote_parm (const ST* s) { return s->flags & ST_PROMOTE_PARM;}
00261 inline void
00262 Set_ST_promote_parm (ST* s) { s->flags |= ST_PROMOTE_PARM; }
00263 inline void
00264 Clear_ST_promote_parm (ST* s) { s->flags &= ~ST_PROMOTE_PARM; }
00265
00266 inline BOOL
00267 ST_keep_name_w2f (const ST* s) { return s->flags & ST_KEEP_NAME_W2F;}
00268 inline void
00269 Set_ST_keep_name_w2f (ST* s) { s->flags |= ST_KEEP_NAME_W2F; }
00270 inline void
00271 Clear_ST_keep_name_w2f (ST* s) { s->flags &= ~ST_KEEP_NAME_W2F; }
00272
00273 inline BOOL
00274 ST_is_datapool (const ST* s) { return s->flags & ST_IS_DATAPOOL;}
00275 inline void
00276 Set_ST_is_datapool (ST* s) { s->flags |= ST_IS_DATAPOOL; }
00277 inline void
00278 Clear_ST_is_datapool (ST* s) { s->flags &= ~ST_IS_DATAPOOL; }
00279
00280 inline BOOL
00281 ST_is_reshaped (const ST* s) { return s->flags & ST_IS_RESHAPED;}
00282 inline void
00283 Set_ST_is_reshaped (ST* s) { s->flags |= ST_IS_RESHAPED; }
00284 inline void
00285 Clear_ST_is_reshaped (ST* s) { s->flags &= ~ST_IS_RESHAPED; }
00286
00287 inline BOOL
00288 ST_emit_symbol (const ST* s) { return s->flags & ST_EMIT_SYMBOL;}
00289 inline void
00290 Set_ST_emit_symbol (ST* s) { s->flags |= ST_EMIT_SYMBOL; }
00291 inline void
00292 Clear_ST_emit_symbol (ST* s) { s->flags &= ~ST_EMIT_SYMBOL; }
00293
00294 inline BOOL
00295 ST_has_nested_ref (const ST* s) { return s->flags & ST_HAS_NESTED_REF;}
00296 inline void
00297 Set_ST_has_nested_ref (ST* s) { s->flags |= ST_HAS_NESTED_REF; }
00298 inline void
00299 Clear_ST_has_nested_ref (ST* s) { s->flags &= ~ST_HAS_NESTED_REF; }
00300
00301 inline BOOL
00302 ST_init_value_zero (const ST* s) { return s->flags & ST_INIT_VALUE_ZERO;}
00303 inline void
00304 Set_ST_init_value_zero (ST* s) { s->flags |= ST_INIT_VALUE_ZERO; }
00305 inline void
00306 Clear_ST_init_value_zero (ST* s) { s->flags &= ~ST_INIT_VALUE_ZERO; }
00307
00308 inline BOOL
00309 ST_gprel (const ST* s) { return s->flags & ST_GPREL;}
00310 inline void
00311 Set_ST_gprel (ST* s) { s->flags |= ST_GPREL; }
00312 inline void
00313 Clear_ST_gprel (ST* s) { s->flags &= ~ST_GPREL; }
00314
00315 inline BOOL
00316 ST_not_gprel (const ST* s) { return s->flags & ST_NOT_GPREL;}
00317 inline void
00318 Set_ST_not_gprel (ST* s) { s->flags |= ST_NOT_GPREL; }
00319 inline void
00320 Clear_ST_not_gprel (ST* s) { s->flags &= ~ST_NOT_GPREL; }
00321
00322 inline BOOL
00323 ST_is_namelist (const ST* s) { return s->flags & ST_IS_NAMELIST;}
00324 inline void
00325 Set_ST_is_namelist (ST* s) { s->flags |= ST_IS_NAMELIST; }
00326 inline void
00327 Clear_ST_is_namelist (ST* s) { s->flags &= ~ST_IS_NAMELIST; }
00328
00329 inline BOOL
00330 ST_is_f90_target (const ST* s) { return s->flags & ST_IS_F90_TARGET;}
00331 inline void
00332 Set_ST_is_f90_target (ST* s) { s->flags |= ST_IS_F90_TARGET; }
00333 inline void
00334 Clear_ST_is_f90_target (ST* s) { s->flags &= ~ST_IS_F90_TARGET; }
00335
00336 inline BOOL
00337 ST_declared_static (const ST* s) { return s->flags & ST_DECLARED_STATIC;}
00338 inline void
00339 Set_ST_declared_static (ST* s) { s->flags |= ST_DECLARED_STATIC; }
00340 inline void
00341 Clear_ST_declared_static (ST* s) { s->flags &= ~ST_DECLARED_STATIC; }
00342
00343 inline BOOL
00344 ST_is_equivalenced (const ST* s) { return s->flags & ST_IS_EQUIVALENCED;}
00345 inline void
00346 Set_ST_is_equivalenced (ST* s) { s->flags |= ST_IS_EQUIVALENCED; }
00347 inline void
00348 Clear_ST_is_equivalenced (ST* s) { s->flags &= ~ST_IS_EQUIVALENCED; }
00349
00350 inline BOOL
00351 ST_is_fill_align (const ST* s) { return s->flags & ST_IS_FILL_ALIGN;}
00352 inline void
00353 Set_ST_is_fill_align (ST* s) { s->flags |= ST_IS_FILL_ALIGN; }
00354 inline void
00355 Clear_ST_is_fill_align (ST* s) { s->flags &= ~ST_IS_FILL_ALIGN; }
00356
00357 inline BOOL
00358 ST_is_optional_argument (const ST* s) { return s->flags & ST_IS_OPTIONAL_ARGUMENT;}
00359 inline void
00360 Set_ST_is_optional_argument (ST* s) { s->flags |= ST_IS_OPTIONAL_ARGUMENT; }
00361 inline void
00362 Clear_ST_is_optional_argument (ST* s) { s->flags &= ~ST_IS_OPTIONAL_ARGUMENT; }
00363
00364 inline BOOL
00365 ST_is_temp_var (const ST* s) { return s->flags & ST_IS_TEMP_VAR;}
00366 inline void
00367 Set_ST_is_temp_var (ST* s) { s->flags |= ST_IS_TEMP_VAR; }
00368 inline void
00369 Clear_ST_is_temp_var (ST* s) { s->flags &= ~ST_IS_TEMP_VAR; }
00370
00371 inline BOOL
00372 ST_is_const_var (const ST* s) { return s->flags & ST_IS_CONST_VAR;}
00373 inline void
00374 Set_ST_is_const_var (ST* s) { s->flags |= ST_IS_CONST_VAR; }
00375 inline void
00376 Clear_ST_is_const_var (ST* s) { s->flags &= ~ST_IS_CONST_VAR; }
00377
00378 inline BOOL
00379 ST_addr_saved (const ST* s) { return s->flags & ST_ADDR_SAVED;}
00380 inline void
00381 Set_ST_addr_saved (ST* s) { s->flags |= ST_ADDR_SAVED; }
00382 inline void
00383 Clear_ST_addr_saved (ST* s) { s->flags &= ~ST_ADDR_SAVED; }
00384
00385 inline BOOL
00386 ST_addr_passed (const ST* s) { return s->flags & ST_ADDR_PASSED;}
00387 inline void
00388 Set_ST_addr_passed (ST* s) { s->flags |= ST_ADDR_PASSED; }
00389 inline void
00390 Clear_ST_addr_passed (ST* s) { s->flags &= ~ST_ADDR_PASSED; }
00391
00392
00393
00394 inline BOOL
00395 ST_addr_not_saved(const ST &s) { return !(s.flags & ST_ADDR_SAVED); }
00396 inline void
00397 Set_ST_addr_not_saved(ST &s) { s.flags &= ~ST_ADDR_SAVED; }
00398 inline void
00399 Clear_ST_addr_not_saved(ST &s) { s.flags |= ST_ADDR_SAVED; }
00400
00401 inline BOOL
00402 ST_addr_not_passed(const ST &s) { return !(s.flags & ST_ADDR_PASSED); }
00403 inline void
00404 Set_ST_addr_not_passed(ST &s) { s.flags &= ~ST_ADDR_PASSED; }
00405 inline void
00406 Clear_ST_addr_not_passed(ST &s) { s.flags |= ST_ADDR_PASSED; }
00407
00408 inline BOOL
00409 ST_addr_not_saved (const ST* s) { return !(s->flags & ST_ADDR_SAVED); }
00410 inline void
00411 Set_ST_addr_not_saved (ST* s) { s->flags &= ~ST_ADDR_SAVED; }
00412 inline void
00413 Clear_ST_addr_not_saved (ST* s) { s->flags |= ST_ADDR_SAVED; }
00414
00415 inline BOOL
00416 ST_addr_not_passed (const ST* s) { return !(s->flags & ST_ADDR_PASSED);}
00417 inline void
00418 Set_ST_addr_not_passed (ST* s) { s->flags &= ~ST_ADDR_PASSED; }
00419 inline void
00420 Clear_ST_addr_not_passed (ST* s) { s->flags |= ST_ADDR_PASSED; }
00421
00422 inline BOOL
00423 ST_is_thread_private (const ST* s) { return s->flags & ST_IS_THREAD_PRIVATE;}
00424 inline void
00425 Set_ST_is_thread_private (ST* s) { s->flags |= ST_IS_THREAD_PRIVATE; }
00426 inline void
00427 Clear_ST_is_thread_private (ST* s) { s->flags &= ~ST_IS_THREAD_PRIVATE; }
00428
00429 inline BOOL
00430 ST_pt_to_unique_mem (const ST* s) { return s->flags & ST_PT_TO_UNIQUE_MEM;}
00431 inline void
00432 Set_ST_pt_to_unique_mem (ST* s) { s->flags |= ST_PT_TO_UNIQUE_MEM; }
00433 inline void
00434 Clear_ST_pt_to_unique_mem (ST* s) { s->flags &= ~ST_PT_TO_UNIQUE_MEM; }
00435
00436 inline BOOL
00437 ST_pt_to_compiler_generated_mem (const ST* s)
00438 { return s->flags & ST_PT_TO_COMPILER_GENERATED_MEM;}
00439 inline void
00440 Set_ST_pt_to_compiler_generated_mem (ST* s)
00441 { s->flags |= ST_PT_TO_COMPILER_GENERATED_MEM; }
00442 inline void
00443 Clear_ST_pt_to_compiler_generated_mem (ST* s)
00444 { s->flags &= ~ST_PT_TO_COMPILER_GENERATED_MEM; }
00445
00446 inline BOOL
00447 ST_assigned_to_dedicated_preg (const ST* s)
00448 { return s->flags & ST_ASSIGNED_TO_DEDICATED_PREG;}
00449 inline void
00450 Set_ST_assigned_to_dedicated_preg (ST* s)
00451 { s->flags |= ST_ASSIGNED_TO_DEDICATED_PREG; }
00452 inline void
00453 Clear_ST_assigned_to_dedicated_preg (ST* s)
00454 { s->flags &= ~ST_ASSIGNED_TO_DEDICATED_PREG; }
00455
00456 inline BOOL
00457 ST_addr_taken (const ST* s)
00458 {
00459 return ST_addr_saved(s) || ST_addr_passed(s);
00460 }
00461
00462 inline ST*
00463 ST_full (const ST* s) {
00464 FmtAssert (ST_is_split_common (s), ("Expecting a split common"));
00465 return &St_Table[s->base_idx];
00466 }
00467 inline ST*
00468 ST_strong (const ST* s) {
00469 FmtAssert (ST_is_weak_symbol (s), ("Expecting a weak symbol"));
00470 return &St_Table[s->base_idx];
00471 }
00472
00473 inline TCON&
00474 STC_val (const ST* s) { return Tcon_Table[ST_tcon (s)]; }
00475
00476 inline void
00477 Print_ST (FILE *f, const ST* st, BOOL) { st->Print (f); }
00478
00479
00480
00481 inline UINT
00482 TY_id (TY_IDX ty) { return TY_IDX_index (ty); }
00483
00484 inline FLD_HANDLE
00485 TY_flist (const TY& ty) { return TY_fld (ty); }
00486
00487
00488
00489
00490
00491
00492
00493 inline void Print_TY (FILE* f, TY_IDX tyi) {
00494 Ty_Table[tyi].Print (f);
00495 }
00496
00497
00498
00499
00500
00501 inline TY_IDX
00502 TYLIST_item (const TYLIST_IDX tli) { return TYLIST_type(tli); }
00503 inline TYLIST_IDX
00504 TYLIST_next (const TYLIST_IDX tli) { return tli+1; }
00505
00506
00507
00508
00509
00510 inline FLD_HANDLE
00511 FLD_next (FLD_HANDLE f)
00512 {
00513 if (FLD_last_field (f))
00514 return FLD_HANDLE();
00515 else
00516 return FLD_HANDLE (f.Idx() + 1);
00517 }
00518
00519
00520
00521
00522
00523
00524 inline BOOL
00525 TY_AR_const_lbnd (const TY& ty, INT32 i)
00526 {
00527 return ARB_const_lbnd (TY_arb(ty)[i]);
00528 }
00529
00530 inline void
00531 Set_TY_AR_const_lbnd (const TY& ty, INT32 i)
00532 {
00533 Set_ARB_const_lbnd (TY_arb(ty)[i]);
00534 }
00535
00536 inline void
00537 Clear_TY_AR_const_lbnd (const TY& ty, INT32 i)
00538 {
00539 Clear_ARB_const_lbnd (TY_arb(ty)[i]);
00540 }
00541
00542 inline BOOL
00543 TY_AR_const_ubnd (const TY& ty, INT32 i)
00544 {
00545 return ARB_const_ubnd(TY_arb(ty)[i]);
00546 }
00547
00548 inline void
00549 Set_TY_AR_const_ubnd (const TY& ty, INT32 i)
00550 {
00551 Set_ARB_const_ubnd (TY_arb(ty)[i]);
00552 }
00553
00554 inline void
00555 Clear_TY_AR_const_ubnd (const TY& ty, INT32 i)
00556 {
00557 Clear_ARB_const_ubnd (TY_arb(ty)[i]);
00558 }
00559
00560 inline BOOL
00561 TY_AR_const_stride (const TY& ty, INT32 i)
00562 {
00563 return ARB_const_stride(TY_arb(ty)[i]);
00564 }
00565
00566 inline void
00567 Set_TY_AR_const_stride (const TY& ty, INT32 i)
00568 {
00569 Set_ARB_const_stride (TY_arb(ty)[i]);
00570 }
00571
00572 inline void
00573 Clear_TY_AR_const_stride (const TY& ty, INT32 i)
00574 {
00575 Clear_ARB_const_stride (TY_arb(ty)[i]);
00576 }
00577
00578 inline BOOL
00579 TY_AR_last_dimen (const TY& ty, INT32 i)
00580 {
00581 return ARB_last_dimen(TY_arb(ty)[i]);
00582 }
00583
00584 inline INT64
00585 TY_AR_lbnd_val (const TY& ty, INT32 i)
00586 {
00587 return ARB_lbnd_val(TY_arb(ty)[i]);
00588 }
00589
00590 inline void
00591 Set_TY_AR_lbnd_val (const TY& ty, INT32 i, INT64 v)
00592 {
00593 Set_ARB_lbnd_val (TY_arb(ty)[i], v);
00594 }
00595
00596 inline ST_IDX
00597 TY_AR_lbnd_var (const TY& ty, INT32 i)
00598 {
00599 return ARB_lbnd_var(TY_arb(ty)[i]);
00600 }
00601
00602 inline void
00603 Set_TY_AR_lbnd_var (const TY& ty, INT32 i, ST_IDX s)
00604 {
00605 Set_ARB_lbnd_var (TY_arb(ty)[i], s);
00606 }
00607
00608 inline INT64
00609 TY_AR_ubnd_val (const TY& ty, INT32 i)
00610 {
00611 return ARB_ubnd_val(TY_arb(ty)[i]);
00612 }
00613
00614 inline void
00615 Set_TY_AR_ubnd_val (const TY& ty, INT32 i, INT64 v)
00616 {
00617 Set_ARB_ubnd_val (TY_arb(ty)[i], v);
00618 }
00619
00620 inline ST_IDX
00621 TY_AR_ubnd_var (const TY& ty, INT32 i)
00622 {
00623 return ARB_ubnd_var(TY_arb(ty)[i]);
00624 }
00625
00626 inline void
00627 Set_TY_AR_ubnd_var (const TY& ty, INT32 i, ST_IDX s)
00628 {
00629 Set_ARB_ubnd_var (TY_arb(ty)[i], s);
00630 }
00631
00632 inline INT64
00633 TY_AR_stride_val (const TY& ty, INT32 i)
00634 {
00635 return ARB_stride_val(TY_arb(ty)[i]);
00636 }
00637
00638 inline void
00639 Set_TY_AR_stride_val (const TY& ty, INT32 i, INT64 v)
00640 {
00641 Set_ARB_stride_val (TY_arb(ty)[i], v);
00642 }
00643
00644 inline ST_IDX
00645 TY_AR_stride_var (const TY& ty, INT32 i)
00646 {
00647 return ARB_stride_var(TY_arb(ty)[i]);
00648 }
00649
00650 inline void
00651 Set_TY_AR_stride_var (const TY& ty, INT32 i, ST_IDX s)
00652 {
00653 Set_ARB_stride_var (TY_arb(ty)[i], s);
00654 }
00655
00656 inline TY_IDX
00657 TY_AR_etype (const TY& ty) { return TY_etype (ty); }
00658
00659 inline INT32
00660 TY_AR_ndims (const TY& ty)
00661 {
00662 return ARB_dimension (TY_arb (ty));
00663 }
00664
00665
00666
00667
00668 inline BOOL
00669 TY_AR_const_lbnd (const TY_IDX ty_idx, INT32 i)
00670 {
00671 return TY_AR_const_lbnd (Ty_Table[ty_idx], i);
00672 }
00673
00674 inline void
00675 Set_TY_AR_const_lbnd (const TY_IDX ty_idx, INT32 i)
00676 {
00677 Set_TY_AR_const_lbnd (Ty_Table[ty_idx], i);
00678 }
00679
00680 inline void
00681 Clear_TY_AR_const_lbnd (const TY_IDX ty_idx, INT32 i)
00682 {
00683 Clear_TY_AR_const_lbnd (Ty_Table[ty_idx], i);
00684 }
00685
00686 inline BOOL
00687 TY_AR_const_ubnd (const TY_IDX ty_idx, INT32 i)
00688 {
00689 return TY_AR_const_ubnd (Ty_Table[ty_idx], i);
00690 }
00691
00692 inline void
00693 Set_TY_AR_const_ubnd (const TY_IDX ty_idx, INT32 i)
00694 {
00695 Set_TY_AR_const_ubnd (Ty_Table[ty_idx], i);
00696 }
00697
00698 inline void
00699 Clear_TY_AR_const_ubnd (const TY_IDX ty_idx, INT32 i)
00700 {
00701 Clear_TY_AR_const_ubnd (Ty_Table[ty_idx], i);
00702 }
00703
00704 inline BOOL
00705 TY_AR_const_stride (const TY_IDX ty_idx, INT32 i)
00706 {
00707 return TY_AR_const_stride(Ty_Table[ty_idx], i);
00708 }
00709
00710 inline void
00711 Set_TY_AR_const_stride (const TY_IDX ty_idx, INT32 i)
00712 {
00713 Set_TY_AR_const_stride (Ty_Table[ty_idx], i);
00714 }
00715
00716 inline void
00717 Clear_TY_AR_const_stride (const TY_IDX ty_idx, INT32 i)
00718 {
00719 Clear_TY_AR_const_stride (Ty_Table[ty_idx], i);
00720 }
00721
00722 inline BOOL
00723 TY_AR_last_dimen (const TY_IDX ty_idx, INT32 i)
00724 {
00725 return TY_AR_last_dimen(Ty_Table[ty_idx], i);
00726 }
00727
00728 inline INT64
00729 TY_AR_lbnd_val (const TY_IDX ty_idx, INT32 i)
00730 {
00731 return TY_AR_lbnd_val(Ty_Table[ty_idx], i);
00732 }
00733
00734 inline void
00735 Set_TY_AR_lbnd_val (const TY_IDX ty_idx, INT32 i, INT64 v)
00736 {
00737 Set_TY_AR_lbnd_val (Ty_Table[ty_idx], i, v);
00738 }
00739
00740 inline ST_IDX
00741 TY_AR_lbnd_var (const TY_IDX ty_idx, INT32 i)
00742 {
00743 return TY_AR_lbnd_var(Ty_Table[ty_idx], i);
00744 }
00745
00746 inline void
00747 Set_TY_AR_lbnd_var (const TY_IDX ty_idx, INT32 i, ST_IDX s)
00748 {
00749 Set_TY_AR_lbnd_var (Ty_Table[ty_idx], i, s);
00750 }
00751
00752 inline INT64
00753 TY_AR_ubnd_val (const TY_IDX ty_idx, INT32 i)
00754 {
00755 return TY_AR_ubnd_val(Ty_Table[ty_idx], i);
00756 }
00757
00758 inline void
00759 Set_TY_AR_ubnd_val (const TY_IDX ty_idx, INT32 i, INT64 v)
00760 {
00761 Set_TY_AR_ubnd_val (Ty_Table[ty_idx], i, v);
00762 }
00763
00764 inline ST_IDX
00765 TY_AR_ubnd_var (const TY_IDX ty_idx, INT32 i)
00766 {
00767 return TY_AR_ubnd_var(Ty_Table[ty_idx], i);
00768 }
00769
00770 inline void
00771 Set_TY_AR_ubnd_var (const TY_IDX ty_idx, INT32 i, ST_IDX s)
00772 {
00773 Set_TY_AR_ubnd_var (Ty_Table[ty_idx], i, s);
00774 }
00775
00776 inline INT64
00777 TY_AR_stride_val (const TY_IDX ty_idx, INT32 i)
00778 {
00779 return TY_AR_stride_val(Ty_Table[ty_idx], i);
00780 }
00781
00782 inline void
00783 Set_TY_AR_stride_val (const TY_IDX ty_idx, INT32 i, INT64 v)
00784 {
00785 Set_TY_AR_stride_val (Ty_Table[ty_idx], i, v);
00786 }
00787
00788 inline ST_IDX
00789 TY_AR_stride_var (const TY_IDX ty_idx, INT32 i)
00790 {
00791 return TY_AR_stride_var(Ty_Table[ty_idx], i);
00792 }
00793
00794 inline void
00795 Set_TY_AR_stride_var (const TY_IDX ty_idx, INT32 i, ST_IDX s)
00796 {
00797 Set_TY_AR_stride_var (Ty_Table[ty_idx], i, s);
00798 }
00799
00800 inline TY_IDX
00801 TY_AR_etype (const TY_IDX ty_idx) { return TY_AR_etype (Ty_Table[ty_idx]); }
00802
00803 inline INT32
00804 TY_AR_ndims (const TY_IDX ty_idx)
00805 {
00806 return ARB_dimension (TY_arb (Ty_Table[ty_idx]));
00807 }
00808
00809
00810
00811 inline SYMTAB_IDX
00812 PU_lexical_level (const PU_IDX pui) { return Pu_Table[pui].lexical_level; }
00813
00814 inline BOOL
00815 PU_has_exc_scopes (const PU_IDX pui) { return Pu_Table[pui].flags & PU_HAS_EXC_SCOPES; }
00816
00817 inline BOOL
00818 PU_in_elf_section (const PU_IDX pui) { return Pu_Table[pui].flags & PU_IN_ELF_SECTION; }
00819
00820 inline BOOL
00821 PU_is_mainpu (const PU_IDX pui) { return Pu_Table[pui].flags & PU_IS_MAINPU; }
00822
00823 inline UINT64
00824 PU_src_lang (const PU_IDX pui) { return Pu_Table[pui].src_lang; }
00825
00826 inline BOOL
00827 PU_no_inline (const PU_IDX pui) { return Pu_Table[pui].flags & PU_NO_INLINE; }
00828 inline void
00829 Set_PU_no_inline (PU_IDX pui) { Pu_Table[pui].flags |= PU_NO_INLINE; }
00830 inline void
00831 Clear_PU_no_inline (PU_IDX pui) { Pu_Table[pui].flags &= ~PU_NO_INLINE; }
00832
00833 inline BOOL
00834 PU_must_inline (const PU_IDX pui) { return Pu_Table[pui].flags & PU_MUST_INLINE; }
00835 inline void
00836 Set_PU_must_inline (PU_IDX pui) { Pu_Table[pui].flags |= PU_MUST_INLINE; }
00837 inline void
00838 Clear_PU_must_inline (PU_IDX pui) { Pu_Table[pui].flags &= ~PU_MUST_INLINE; }
00839
00840
00841 #define SYMTAB_parent(s) (s-1)
00842
00843
00844
00845 inline STR_IDX
00846 LABEL_name_idx (const LABEL_IDX idx) { return Label_Table[idx].name_idx; }
00847
00848 #define Set_LABEL_kind(l,k) Set_LABEL_KIND(l,k)
00849
00850 inline BOOL
00851 LABEL_begin_eh_range (const LABEL_IDX lbi)
00852 {
00853 return (LABEL_kind(Label_Table[lbi]) == LKIND_BEGIN_EH_RANGE);
00854 }
00855 inline void
00856 Set_LABEL_begin_eh_range (LABEL_IDX lbi)
00857 {
00858 Set_LABEL_kind(Label_Table[lbi], LKIND_BEGIN_EH_RANGE);
00859 }
00860 inline BOOL
00861 LABEL_end_eh_range (const LABEL_IDX lbi)
00862 {
00863 return (LABEL_kind(Label_Table[lbi]) == LKIND_END_EH_RANGE);
00864 }
00865 inline void
00866 Set_LABEL_end_eh_range (LABEL_IDX lbi)
00867 {
00868 Set_LABEL_kind(Label_Table[lbi], LKIND_END_EH_RANGE);
00869 }
00870 inline BOOL
00871 LABEL_target_of_goto_outer_block (const LABEL_IDX lbi)
00872 {
00873 return (LABEL_target_of_goto_outer_block(Label_Table[lbi]));
00874 }
00875 inline void
00876 Set_LABEL_target_of_goto_outer_block (const LABEL_IDX lbi)
00877 {
00878 Set_LABEL_target_of_goto_outer_block(Label_Table[lbi]);
00879 }
00880 inline void
00881 Clear_LABEL_target_of_goto_outer_block (const LABEL_IDX lbi)
00882 {
00883 Clear_LABEL_target_of_goto_outer_block(Label_Table[lbi]);
00884 }
00885 inline BOOL
00886 LABEL_addr_saved (const LABEL_IDX lbi)
00887 {
00888 return (LABEL_addr_saved(Label_Table[lbi]));
00889 }
00890 inline void
00891 Set_LABEL_addr_saved (const LABEL_IDX lbi)
00892 {
00893 Set_LABEL_addr_saved(Label_Table[lbi]);
00894 }
00895 inline void
00896 Clear_LABEL_addr_saved (const LABEL_IDX lbi)
00897 {
00898 Clear_LABEL_addr_saved(Label_Table[lbi]);
00899 }
00900 inline BOOL
00901 LABEL_addr_passed (const LABEL_IDX lbi)
00902 {
00903 return (LABEL_addr_passed(Label_Table[lbi]));
00904 }
00905 inline void
00906 Set_LABEL_addr_passed (const LABEL_IDX lbi)
00907 {
00908 Set_LABEL_addr_passed(Label_Table[lbi]);
00909 }
00910 inline void
00911 Clear_LABEL_addr_passed (const LABEL_IDX lbi)
00912 {
00913 Clear_LABEL_addr_passed(Label_Table[lbi]);
00914 }
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926 #endif // symtab_compatible_INCLUDED
