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
00048
00049
00050
00051
00052
00053
00054
00055
00056 #ifndef symtab_access_INCLUDED
00057 #define symtab_access_INCLUDED
00058
00059
00060
00061
00062
00063 class FLD_HANDLE
00064 {
00065 private:
00066 FLD* entry;
00067 FLD_IDX idx;
00068
00069 public:
00070 FLD_HANDLE () : entry (NULL), idx (0) {}
00071
00072 explicit FLD_HANDLE (FLD_IDX fld_idx) :
00073 entry (fld_idx == 0 ? NULL : &Fld_Table[fld_idx]), idx (fld_idx) {}
00074
00075 FLD_HANDLE (FLD* fld, FLD_IDX fld_idx) : entry (fld), idx (fld_idx) {
00076 Is_True ((fld_idx == 0 && fld == NULL) || (&Fld_Table[fld_idx] == fld),
00077 ("Inconsistent FLD* and FLD_IDX"));
00078 }
00079
00080 FLD_HANDLE (const FLD_HANDLE& fld) : entry (fld.entry), idx (fld.idx) {}
00081
00082 FLD_HANDLE (const FLD_ITER& iter) : entry (&(*iter)), idx (iter.Index()) {}
00083
00084 FLD* Entry () const { return entry; }
00085 FLD_IDX Idx () const { return idx; }
00086
00087 BOOL operator== (const FLD_HANDLE& fld) const {
00088 return idx == fld.idx;
00089 }
00090
00091 BOOL operator!= (const FLD_HANDLE& fld) const {
00092 return idx != fld.idx;
00093 }
00094
00095
00096 BOOL Is_Null () const { return idx == 0; }
00097 };
00098
00099 class ARB_HANDLE
00100 {
00101 private:
00102 ARB* entry;
00103 ARB_IDX idx;
00104
00105 public:
00106 ARB_HANDLE () : entry (NULL), idx (0) {}
00107
00108 explicit ARB_HANDLE (ARB_IDX arb_idx) :
00109 entry (arb_idx == 0 ? NULL : &Arb_Table[arb_idx]), idx (arb_idx) {}
00110
00111 ARB_HANDLE (ARB* arb, ARB_IDX arb_idx) : entry (arb), idx (arb_idx) {
00112 Is_True ((arb_idx == 0 && arb == NULL) || (&Arb_Table[arb_idx] == arb),
00113 ("Inconsistent ARB* and ARB_IDX"));
00114 }
00115
00116 ARB_HANDLE (const ARB_HANDLE& arb) : entry (arb.entry), idx (arb.idx) {}
00117
00118 ARB_HANDLE (const ARB_ITER& iter) : entry (&(*iter)), idx (iter.Index()) {}
00119
00120 ARB* Entry () const { return entry; }
00121 ARB_IDX Idx () const { return idx; }
00122
00123 BOOL operator== (const ARB_HANDLE& arb) const {
00124 return idx == arb.idx;
00125 }
00126
00127 ARB_HANDLE operator[] (INT32 i) {
00128 return ARB_HANDLE(idx + i);
00129 }
00130
00131 BOOL Is_Null () const { return idx == 0; }
00132 };
00133
00134
00135
00136
00137 inline STR_IDX
00138 ST_name_idx (const ST& s) { return s.u1.name_idx; }
00139 inline void
00140 Set_ST_name_idx (ST& s, STR_IDX idx) { s.u1.name_idx = idx; }
00141 inline char *
00142 ST_name (const ST& s) { return &Str_Table[ST_name_idx (s)]; }
00143
00144 inline TCON_IDX
00145 ST_tcon (const ST& s) { return s.u1.tcon; }
00146 inline void
00147 Set_ST_tcon (ST& s, TCON_IDX tcon) { s.u1.tcon = tcon; }
00148
00149 inline ST_CLASS
00150 ST_sym_class (const ST& s) { return s.sym_class; }
00151 inline void
00152 Set_ST_sym_class (ST& s, ST_CLASS c) { s.sym_class = c; }
00153
00154 inline ST_SCLASS
00155 ST_storage_class (const ST& s) { return s.storage_class; }
00156 inline void
00157 Set_ST_storage_class (ST& s, ST_SCLASS sc) { s.storage_class = sc; }
00158
00159 inline ST_SCLASS
00160 ST_sclass (const ST& s) { return s.storage_class; }
00161 inline void
00162 Set_ST_sclass (ST& s, ST_SCLASS sc) { s.storage_class = sc; }
00163
00164 inline ST_EXPORT
00165 ST_export (const ST& s) { return s.export_class; }
00166 inline void
00167 Set_ST_export (ST& s, ST_EXPORT eclass) { s.export_class = eclass; }
00168
00169 inline TY_IDX
00170 ST_type (const ST& s) {
00171 #ifdef Is_True_On
00172 switch (s.sym_class) {
00173 default:
00174 Fail_FmtAssertion ("Invalid argument for ST_type ()");
00175 case CLASS_VAR:
00176 case CLASS_CONST:
00177 case CLASS_PREG:
00178 case CLASS_NAME:
00179 return s.u2.type;
00180 }
00181 #else
00182 return s.u2.type;
00183 #endif // Is_True_On
00184 }
00185 inline void
00186 Set_ST_type (ST& s, TY_IDX t) {
00187 #ifdef Is_True_On
00188 switch (s.sym_class) {
00189 default:
00190 Fail_FmtAssertion ("Invalid argument for ST_type ()");
00191 case CLASS_VAR:
00192 case CLASS_CONST:
00193 case CLASS_PREG:
00194 case CLASS_NAME:
00195 s.u2.type = t;
00196 }
00197 #else
00198 s.u2.type = t;
00199 #endif // Is_True_On
00200 }
00201
00202 inline PU_IDX
00203 ST_pu (const ST& s) {
00204 Is_True (s.sym_class == CLASS_FUNC ||
00205 (s.sym_class == CLASS_NAME &&
00206 (s.flags & ST_ASM_FUNCTION_ST)),
00207 ("Invalid argument for ST_pu"));
00208 return s.u2.pu;
00209 }
00210 inline void
00211 Set_ST_pu (ST& s, PU_IDX pu)
00212 {
00213 Is_True (s.sym_class == CLASS_FUNC ||
00214 (s.sym_class == CLASS_NAME &&
00215 s.flags & ST_ASM_FUNCTION_ST),
00216 ("Invalid argument for ST_pu"));
00217 s.u2.pu = pu;
00218 }
00219
00220 inline BLK_IDX
00221 ST_blk (const ST& s) {
00222 Is_True (s.sym_class == CLASS_BLOCK, ("Invalid argument for ST_blk"));
00223 return s.u2.blk;
00224 }
00225 inline void
00226 Set_ST_blk (ST& s, BLK_IDX b)
00227 {
00228 Is_True (s.sym_class == CLASS_BLOCK, ("Invalid argument for ST_blk"));
00229 s.u2.blk = b;
00230 }
00231
00232 inline ST_IDX
00233 ST_st_idx (const ST& s) { return s.st_idx; }
00234 inline void
00235 Set_ST_st_idx (ST& s, ST_IDX idx) { s.st_idx = idx; }
00236
00237 inline ST*
00238 ST_ptr (ST_IDX idx) { return &(St_Table[idx]); }
00239
00240 inline UINT64
00241 ST_ofst (const ST& s) { return s.offset; }
00242 inline void
00243 Set_ST_ofst (ST& s, UINT64 offset) { s.offset = offset; }
00244
00245
00246
00247
00248
00249 inline BOOL
00250 ST_is_weak_symbol (const ST& s) { return s.flags & ST_IS_WEAK_SYMBOL;}
00251 inline void
00252 Set_ST_is_weak_symbol (ST& s) { s.flags |= ST_IS_WEAK_SYMBOL; }
00253 inline void
00254 Clear_ST_is_weak_symbol (ST& s) { s.flags &= ~ST_IS_WEAK_SYMBOL; }
00255
00256 inline BOOL
00257 ST_is_split_common (const ST& s) { return s.flags & ST_IS_SPLIT_COMMON;}
00258 inline void
00259 Set_ST_is_split_common (ST& s) { s.flags |= ST_IS_SPLIT_COMMON; }
00260 inline void
00261 Clear_ST_is_split_common (ST& s) { s.flags &= ~ST_IS_SPLIT_COMMON; }
00262
00263 inline ST_IDX
00264 ST_base_idx (const ST& s)
00265 {
00266 if (ST_is_split_common (s))
00267 return s.st_idx;
00268 else if (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN)
00269 return s.st_idx;
00270 else
00271 return s.base_idx;
00272 }
00273 inline void
00274 Set_ST_base_idx (ST& s, ST_IDX base)
00275 {
00276 if (ST_is_split_common (s))
00277 DevWarn ("Shouldn't set base when split");
00278 else if (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN)
00279 DevWarn ("Shouldn't set base when weak");
00280 s.base_idx = base;
00281 }
00282
00283 inline ST_IDX
00284 ST_strong_idx (const ST& s)
00285 {
00286 Is_True (ST_is_weak_symbol (s), ("Expecting a weak symbol"));
00287 return (ST_sclass (s) == SCLASS_EXTERN) ? s.base_idx : s.st_idx;
00288 }
00289 inline void
00290 Set_ST_strong_idx (ST& s, ST_IDX base)
00291 {
00292 Is_True (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN,
00293 ("Expecting an external weak symbol"));
00294 s.base_idx = base;
00295 }
00296
00297 inline ST_IDX
00298 ST_full_idx (const ST& s)
00299 {
00300 Is_True (ST_is_split_common (s), ("Expecting a splict common"));
00301 return s.base_idx;
00302 }
00303 inline void
00304 Set_ST_full_idx (ST& s, ST_IDX base)
00305 {
00306 Is_True (ST_is_split_common (s), ("Expecting a splict common"));
00307 s.base_idx = base;
00308 }
00309
00310 inline BOOL
00311 ST_is_not_used (const ST& s) { return s.flags & ST_IS_NOT_USED;}
00312 inline void
00313 Set_ST_is_not_used (ST& s) { s.flags |= ST_IS_NOT_USED; }
00314 inline void
00315 Clear_ST_is_not_used (ST& s) { s.flags &= ~ST_IS_NOT_USED; }
00316
00317 inline BOOL
00318 ST_is_initialized (const ST& s) { return s.flags & ST_IS_INITIALIZED;}
00319 inline void
00320 Set_ST_is_initialized (ST& s) { s.flags |= ST_IS_INITIALIZED; }
00321 inline void
00322 Clear_ST_is_initialized (ST& s) { s.flags &= ~ST_IS_INITIALIZED; }
00323
00324 inline BOOL
00325 ST_is_return_var (const ST& s) { return s.flags & ST_IS_RETURN_VAR;}
00326 inline void
00327 Set_ST_is_return_var (ST& s) { s.flags |= ST_IS_RETURN_VAR; }
00328 inline void
00329 Clear_ST_is_return_var (ST& s) { s.flags &= ~ST_IS_RETURN_VAR; }
00330
00331 inline BOOL
00332 ST_is_value_parm (const ST& s) { return s.flags & ST_IS_VALUE_PARM;}
00333 inline void
00334 Set_ST_is_value_parm (ST& s) { s.flags |= ST_IS_VALUE_PARM; }
00335 inline void
00336 Clear_ST_is_value_parm (ST& s) { s.flags &= ~ST_IS_VALUE_PARM; }
00337
00338 inline BOOL
00339 ST_promote_parm (const ST& s) { return s.flags & ST_PROMOTE_PARM;}
00340 inline void
00341 Set_ST_promote_parm (ST& s) { s.flags |= ST_PROMOTE_PARM; }
00342 inline void
00343 Clear_ST_promote_parm (ST& s) { s.flags &= ~ST_PROMOTE_PARM; }
00344
00345 inline BOOL
00346 ST_keep_name_w2f (const ST& s) { return s.flags & ST_KEEP_NAME_W2F;}
00347 inline void
00348 Set_ST_keep_name_w2f (ST& s) { s.flags |= ST_KEEP_NAME_W2F; }
00349 inline void
00350 Clear_ST_keep_name_w2f (ST& s) { s.flags &= ~ST_KEEP_NAME_W2F; }
00351
00352 inline BOOL
00353 ST_is_datapool (const ST& s) { return s.flags & ST_IS_DATAPOOL;}
00354 inline void
00355 Set_ST_is_datapool (ST& s) { s.flags |= ST_IS_DATAPOOL; }
00356 inline void
00357 Clear_ST_is_datapool (ST& s) { s.flags &= ~ST_IS_DATAPOOL; }
00358
00359 inline BOOL
00360 ST_is_reshaped (const ST& s) { return s.flags & ST_IS_RESHAPED;}
00361 inline void
00362 Set_ST_is_reshaped (ST& s) { s.flags |= ST_IS_RESHAPED; }
00363 inline void
00364 Clear_ST_is_reshaped (ST& s) { s.flags &= ~ST_IS_RESHAPED; }
00365
00366 inline BOOL
00367 ST_emit_symbol (const ST& s) { return s.flags & ST_EMIT_SYMBOL;}
00368 inline void
00369 Set_ST_emit_symbol (ST& s) { s.flags |= ST_EMIT_SYMBOL; }
00370 inline void
00371 Clear_ST_emit_symbol (ST& s) { s.flags &= ~ST_EMIT_SYMBOL; }
00372
00373 inline BOOL
00374 ST_has_nested_ref (const ST& s) { return s.flags & ST_HAS_NESTED_REF;}
00375 inline void
00376 Set_ST_has_nested_ref (ST& s) { s.flags |= ST_HAS_NESTED_REF; }
00377 inline void
00378 Clear_ST_has_nested_ref (ST& s) { s.flags &= ~ST_HAS_NESTED_REF; }
00379
00380 inline BOOL
00381 ST_init_value_zero (const ST& s) { return s.flags & ST_INIT_VALUE_ZERO;}
00382 inline void
00383 Set_ST_init_value_zero (ST& s) { s.flags |= ST_INIT_VALUE_ZERO; }
00384 inline void
00385 Clear_ST_init_value_zero (ST& s) { s.flags &= ~ST_INIT_VALUE_ZERO; }
00386
00387 inline BOOL
00388 ST_gprel (const ST& s) { return s.flags & ST_GPREL;}
00389 inline void
00390 Set_ST_gprel (ST& s) { s.flags |= ST_GPREL; }
00391 inline void
00392 Clear_ST_gprel (ST& s) { s.flags &= ~ST_GPREL; }
00393
00394 inline BOOL
00395 ST_not_gprel (const ST& s) { return s.flags & ST_NOT_GPREL;}
00396 inline void
00397 Set_ST_not_gprel (ST& s) { s.flags |= ST_NOT_GPREL; }
00398 inline void
00399 Clear_ST_not_gprel (ST& s) { s.flags &= ~ST_NOT_GPREL; }
00400
00401 inline BOOL
00402 ST_is_namelist (const ST& s) { return s.flags & ST_IS_NAMELIST;}
00403 inline void
00404 Set_ST_is_namelist (ST& s) { s.flags |= ST_IS_NAMELIST; }
00405 inline void
00406 Clear_ST_is_namelist (ST& s) { s.flags &= ~ST_IS_NAMELIST; }
00407
00408 inline BOOL
00409 ST_is_f90_target (const ST& s) { return s.flags & ST_IS_F90_TARGET;}
00410 inline void
00411 Set_ST_is_f90_target (ST& s) { s.flags |= ST_IS_F90_TARGET; }
00412 inline void
00413 Clear_ST_is_f90_target (ST& s) { s.flags &= ~ST_IS_F90_TARGET; }
00414
00415 inline BOOL
00416 ST_declared_static (const ST& s) { return s.flags & ST_DECLARED_STATIC;}
00417 inline void
00418 Set_ST_declared_static (ST& s) { s.flags |= ST_DECLARED_STATIC; }
00419 inline void
00420 Clear_ST_declared_static (ST& s) { s.flags &= ~ST_DECLARED_STATIC; }
00421
00422 inline BOOL
00423 ST_is_equivalenced (const ST& s) { return s.flags & ST_IS_EQUIVALENCED;}
00424 inline void
00425 Set_ST_is_equivalenced (ST& s) { s.flags |= ST_IS_EQUIVALENCED; }
00426 inline void
00427 Clear_ST_is_equivalenced (ST& s) { s.flags &= ~ST_IS_EQUIVALENCED; }
00428
00429 inline BOOL
00430 ST_is_fill_align (const ST& s) { return s.flags & ST_IS_FILL_ALIGN;}
00431 inline void
00432 Set_ST_is_fill_align (ST& s) { s.flags |= ST_IS_FILL_ALIGN; }
00433 inline void
00434 Clear_ST_is_fill_align (ST& s) { s.flags &= ~ST_IS_FILL_ALIGN; }
00435
00436 inline BOOL
00437 ST_is_optional_argument (const ST& s) { return s.flags & ST_IS_OPTIONAL_ARGUMENT;}
00438 inline void
00439 Set_ST_is_optional_argument (ST& s) { s.flags |= ST_IS_OPTIONAL_ARGUMENT; }
00440 inline void
00441 Clear_ST_is_optional_argument (ST& s) { s.flags &= ~ST_IS_OPTIONAL_ARGUMENT; }
00442
00443 inline BOOL
00444 ST_is_temp_var (const ST& s) { return s.flags & ST_IS_TEMP_VAR;}
00445 inline void
00446 Set_ST_is_temp_var (ST& s) { s.flags |= ST_IS_TEMP_VAR; }
00447 inline void
00448 Clear_ST_is_temp_var (ST& s) { s.flags &= ~ST_IS_TEMP_VAR; }
00449
00450 inline BOOL
00451 ST_is_const_var (const ST& s) { return s.flags & ST_IS_CONST_VAR;}
00452 inline void
00453 Set_ST_is_const_var (ST& s) { s.flags |= ST_IS_CONST_VAR; }
00454 inline void
00455 Clear_ST_is_const_var (ST& s) { s.flags &= ~ST_IS_CONST_VAR; }
00456
00457 inline BOOL
00458 ST_addr_saved (const ST& s) { return s.flags & ST_ADDR_SAVED;}
00459 inline void
00460 Set_ST_addr_saved (ST& s) { s.flags |= ST_ADDR_SAVED; }
00461 inline void
00462 Clear_ST_addr_saved (ST& s) { s.flags &= ~ST_ADDR_SAVED; }
00463
00464 inline BOOL
00465 ST_addr_passed (const ST& s) { return s.flags & ST_ADDR_PASSED;}
00466 inline void
00467 Set_ST_addr_passed (ST& s) { s.flags |= ST_ADDR_PASSED; }
00468 inline void
00469 Clear_ST_addr_passed (ST& s) { s.flags &= ~ST_ADDR_PASSED; }
00470
00471 inline BOOL
00472 ST_is_thread_private (const ST& s) { return s.flags & ST_IS_THREAD_PRIVATE;}
00473 inline void
00474 Set_ST_is_thread_private (ST& s) { s.flags |= ST_IS_THREAD_PRIVATE; }
00475 inline void
00476 Clear_ST_is_thread_private (ST& s) { s.flags &= ~ST_IS_THREAD_PRIVATE; }
00477
00478 inline BOOL
00479 ST_pt_to_unique_mem (const ST& s) { return s.flags & ST_PT_TO_UNIQUE_MEM;}
00480 inline void
00481 Set_ST_pt_to_unique_mem (ST& s) { s.flags |= ST_PT_TO_UNIQUE_MEM; }
00482 inline void
00483 Clear_ST_pt_to_unique_mem (ST& s) { s.flags &= ~ST_PT_TO_UNIQUE_MEM; }
00484
00485 inline BOOL
00486 ST_pt_to_compiler_generated_mem (const ST& s)
00487 { return s.flags & ST_PT_TO_COMPILER_GENERATED_MEM;}
00488 inline void
00489 Set_ST_pt_to_compiler_generated_mem (ST& s)
00490 { s.flags |= ST_PT_TO_COMPILER_GENERATED_MEM; }
00491 inline void
00492 Clear_ST_pt_to_compiler_generated_mem (ST& s)
00493 { s.flags &= ~ST_PT_TO_COMPILER_GENERATED_MEM; }
00494
00495 inline BOOL
00496 ST_is_shared_auto (const ST& s) { return s.flags & ST_IS_SHARED_AUTO;}
00497 inline void
00498 Set_ST_is_shared_auto (ST& s) { s.flags |= ST_IS_SHARED_AUTO; }
00499 inline void
00500 Clear_ST_is_shared_auto (ST& s) { s.flags &= ~ST_IS_SHARED_AUTO; }
00501
00502 inline BOOL
00503 ST_assigned_to_dedicated_preg (const ST& s)
00504 { return s.flags & ST_ASSIGNED_TO_DEDICATED_PREG; }
00505 inline void
00506 Set_ST_assigned_to_dedicated_preg (ST& s)
00507 { s.flags |= ST_ASSIGNED_TO_DEDICATED_PREG; }
00508 inline void
00509 Clear_ST_assigned_to_dedicated_preg (ST& s)
00510 { s.flags &= ~ST_ASSIGNED_TO_DEDICATED_PREG; }
00511
00512 inline BOOL
00513 ST_asm_function_st(const ST& s) { return s.flags & ST_ASM_FUNCTION_ST; }
00514 inline void
00515 Set_ST_asm_function_st(ST &s) { s.flags |= ST_ASM_FUNCTION_ST; }
00516 inline void
00517 Clear_ST_asm_function_st(ST &s) { s.flags &= ~ST_ASM_FUNCTION_ST; }
00518
00519
00520 inline BOOL
00521 ST_has_named_section (const ST* s) { return s->flags & ST_HAS_NAMED_SECTION; }
00522 inline void
00523 Set_ST_has_named_section (ST* s) { s->flags |= ST_HAS_NAMED_SECTION; }
00524 inline void
00525 Clear_ST_has_named_section (ST* s) { s->flags &= ~ST_HAS_NAMED_SECTION; }
00526
00527 #ifdef KEY
00528 inline BOOL
00529 ST_one_per_pu (const ST* s) { return s->flags_ext & ST_ONE_PER_PU; }
00530 inline void
00531 Set_ST_one_per_pu (ST* s) { s->flags_ext |= ST_ONE_PER_PU; }
00532 inline void
00533 Clear_ST_one_per_pu (ST* s) { s->flags_ext &= ~ST_ONE_PER_PU; }
00534
00535 inline BOOL
00536 ST_copy_constructor_st(const ST* s) { return s->flags_ext & ST_COPY_CONSTRUCTOR_ST; }
00537 inline void
00538 Set_ST_copy_constructor_st(ST* s) { s->flags_ext |= ST_COPY_CONSTRUCTOR_ST; }
00539 inline void
00540 Clear_ST_copy_constructor_st(ST* s) { s->flags_ext &= ~ST_COPY_CONSTRUCTOR_ST; }
00541
00542 inline BOOL
00543 ST_initv_in_other_st (const ST* s) { return s->flags_ext & ST_INITV_IN_OTHER_ST; }
00544 inline void
00545 Set_ST_initv_in_other_st (ST* s) { s->flags_ext |= ST_INITV_IN_OTHER_ST; }
00546 inline void
00547 Clear_ST_initv_in_other_st (ST* s) { s->flags_ext &= ~ST_INITV_IN_OTHER_ST; }
00548
00549 #ifdef TARG_SL
00550 inline BOOL
00551 ST_in_v1buf (const ST* s) { return s->flags_ext & ST_IN_V1BUF; }
00552 inline void
00553 Set_ST_in_v1buf (ST *s) { s->flags_ext |= ST_IN_V1BUF; }
00554 inline void
00555 Clear_ST_in_v1buf (ST *s) { s->flags_ext &= ~ST_IN_V1BUF; }
00556
00557 inline BOOL
00558 ST_in_v2buf (const ST* s) { return s->flags_ext & ST_IN_V2BUF; }
00559 inline void
00560 Set_ST_in_v2buf (ST *s) { s->flags_ext |= ST_IN_V2BUF; }
00561 inline void
00562 Clear_ST_in_v2buf (ST *s) { s->flags_ext &= ~ST_IN_V2BUF; }
00563
00564 inline BOOL
00565 ST_in_v4buf (const ST* s) { return s->flags_ext & ST_IN_V4BUF; }
00566 inline void
00567 Set_ST_in_v4buf (ST *s) { s->flags_ext |= ST_IN_V4BUF; }
00568 inline void
00569 Clear_ST_in_v4buf (ST *s) { s->flags_ext &= ~ST_IN_V4BUF; }
00570
00571 inline BOOL
00572 ST_in_vbuf (const ST *s) {
00573 return (ST_in_v1buf(s) || ST_in_v2buf(s) || ST_in_v4buf(s));
00574 }
00575
00576 inline BOOL
00577 ST_in_sdram (const ST* s) { return s->flags_ext & ST_IN_SDRAM; }
00578 inline void
00579 Set_ST_in_sdram (ST *s) { s->flags_ext |= ST_IN_SDRAM; }
00580 inline void
00581 Clear_ST_in_sdram (ST *s) { s->flags_ext &= ~ST_IN_SDRAM; }
00582
00583 inline BOOL
00584 ST_in_sbuf (const ST* s) { return s->flags_ext & ST_IN_SBUF; }
00585 inline void
00586 Set_ST_in_sbuf (ST *s) { s->flags_ext |= ST_IN_SBUF; }
00587 inline void
00588 Clear_ST_in_sbuf (ST *s) { s->flags_ext &= ~ST_IN_SBUF; }
00589
00590 inline BOOL
00591 ST_is_vbuf_ofst (const ST* s) { return s->flags_ext & ST_IS_VBUF_OFFSET; }
00592 inline void
00593 Set_ST_is_vbuf_ofst (ST *s) { s->flags_ext |= ST_IS_VBUF_OFFSET; }
00594 inline void
00595 Clear_ST_is_vbuf_ofst (ST *s) { s->flags_ext &= ~ST_IS_VBUF_OFFSET; }
00596
00597 inline BOOL
00598 ST_is_sbuf_ofst (const ST* s) { return s->flags_ext & ST_IS_SBUF_OFFSET; }
00599 inline void
00600 Set_ST_is_sbuf_ofst (ST *s) { s->flags_ext |= ST_IS_SBUF_OFFSET; }
00601 inline void
00602 Clear_ST_is_sbuf_ofst (ST *s) { s->flags_ext &= ~ST_IS_SBUF_OFFSET; }
00603 #endif // TARG_SL
00604
00605 inline BOOL
00606 ST_is_inintialized_in_f90 (const ST* s) { return s->flags_ext & ST_IS_INITIALIZED_IN_F90; }
00607 inline void
00608 Set_ST_is_inintialized_in_f90 (ST *s) { s->flags_ext |= ST_IS_INITIALIZED_IN_F90; }
00609 inline void
00610 Clear_ST_is_inintialized_in_f90 (ST *s) { s->flags_ext &= ~ST_IS_INITIALIZED_IN_F90; }
00611
00612 inline BOOL
00613 ST_is_method_func (const ST* s) { return s->flags_ext & ST_IS_METHOD_FUNC; }
00614 inline void
00615 Set_ST_is_method_func (ST* s) { s->flags_ext |= ST_IS_METHOD_FUNC; }
00616 inline void
00617 Reset_ST_is_method_func (ST* s) { s->flags_ext &= ~ST_IS_METHOD_FUNC; }
00618
00619 inline BOOL
00620 ST_is_this_ptr (const ST* s) { return s->flags_ext & ST_IS_THIS_PTR; }
00621 inline void
00622 Set_ST_is_this_ptr (ST* s) { s->flags_ext |= ST_IS_THIS_PTR; }
00623 inline void
00624 Reset_ST_is_this_ptr (ST* s) { s->flags_ext &= ~ST_IS_THIS_PTR; }
00625
00626 #ifdef TARG_NVISA
00627 inline BOOL
00628 ST_in_global_mem (const ST* s) { return (s->memory_space == MEMORY_GLOBAL); }
00629 inline void
00630 Set_ST_in_global_mem (ST *s) { s->memory_space = MEMORY_GLOBAL; }
00631
00632 inline BOOL
00633 ST_in_local_mem (const ST* s) { return (s->memory_space == MEMORY_LOCAL); }
00634 inline void
00635 Set_ST_in_local_mem (ST *s) { s->memory_space = MEMORY_LOCAL; }
00636
00637 inline BOOL
00638 ST_in_shared_mem (const ST* s) { return (s->memory_space == MEMORY_SHARED); }
00639 inline void
00640 Set_ST_in_shared_mem (ST *s) { s->memory_space = MEMORY_SHARED; }
00641
00642 inline BOOL
00643 ST_in_constant_mem (const ST* s) { return (s->memory_space == MEMORY_CONSTANT); }
00644 inline void
00645 Set_ST_in_constant_mem (ST *s) { s->memory_space = MEMORY_CONSTANT; }
00646
00647 inline BOOL
00648 ST_in_texture_mem (const ST* s) { return (s->memory_space == MEMORY_TEXTURE); }
00649 inline void
00650 Set_ST_in_texture_mem (ST *s) { s->memory_space = MEMORY_TEXTURE; }
00651
00652 inline BOOL
00653 ST_in_param_mem (const ST* s) { return (s->memory_space == MEMORY_PARAM); }
00654 inline void
00655 Set_ST_in_param_mem (ST *s) { s->memory_space = MEMORY_PARAM; }
00656 #endif
00657
00658 inline BOOL
00659 ST_is_pure_vfunc (const ST* s) { return s->flags_ext & ST_IS_PURE_VFUNC; }
00660 inline void
00661 Set_ST_is_pure_vfunc (ST* s) { s->flags_ext |= ST_IS_PURE_VFUNC; }
00662 inline void
00663 Reset_ST_is_pure_vfunc (ST* s) { s->flags_ext &= ~ST_IS_PURE_VFUNC; }
00664
00665 inline BOOL
00666 ST_is_thread_local (const ST* s) { return s->flags_ext & ST_IS_THREAD_LOCAL;}
00667 inline void
00668 Set_ST_is_thread_local (ST* s) { s->flags_ext |= ST_IS_THREAD_LOCAL; }
00669 inline void
00670 Reset_ST_is_thread_local (ST* s) { s->flags_ext &= ~ST_IS_THREAD_LOCAL; }
00671 inline BOOL
00672 ST_is_thread_local (const ST& s) { return s.flags_ext & ST_IS_THREAD_LOCAL; }
00673 inline void
00674 Set_ST_is_thread_local (ST& s) { s.flags_ext |= ST_IS_THREAD_LOCAL; }
00675 inline void
00676 Reset_ST_is_thread_local (ST& s) { s.flags_ext &= ~ST_IS_THREAD_LOCAL; }
00677 inline void
00678 Clear_ST_is_thread_local (ST* s) { s->flags_ext &= ~ST_IS_THREAD_LOCAL; }
00679 #endif
00680
00681
00682
00683
00684
00685 inline TARGET_INFO_IDX
00686 PU_target_idx (const PU& pu) { return pu.target_idx; }
00687 inline void
00688 Set_PU_target_idx (PU& pu, TARGET_INFO_IDX idx) { pu.target_idx = idx; }
00689
00690 inline TY_IDX
00691 PU_prototype (const PU& pu) { return pu.prototype; }
00692 inline void
00693 Set_PU_prototype (PU& pu, TY_IDX ty) { pu.prototype = ty; }
00694
00695 inline UINT8
00696 PU_gp_group (const PU& pu) { return pu.gp_group; }
00697 inline void
00698 Set_PU_gp_group (PU& pu, mUINT8 grp) { pu.gp_group = grp; }
00699
00700 inline SYMTAB_IDX
00701 PU_lexical_level (const PU& pu) { return pu.lexical_level; }
00702 inline void
00703 Set_PU_lexical_level (PU& pu, SYMTAB_IDX l) { pu.lexical_level = l; }
00704
00705 inline INITO_IDX
00706 PU_misc_info (const PU& pu) { return pu.misc; }
00707 inline void
00708 Set_PU_misc_info (PU& pu, INITO_IDX i) { pu.misc = i; }
00709
00710 inline TY_IDX
00711 PU_base_class (const PU& pu) { return pu.base_class; }
00712 inline void
00713 Set_PU_base_class (PU& pu, TY_IDX ty_idx) { pu.base_class = ty_idx; }
00714
00715 #ifdef TARG_NVISA
00716 inline SYMTAB_IDX
00717 PU_thread_limit(const PU& pu) { return pu.thread_limit; }
00718 inline void
00719 Set_PU_thread_limit (PU& pu, int l) { pu.thread_limit = l; }
00720
00721 inline SYMTAB_IDX
00722 PU_block_limit(const PU& pu) { return pu.block_limit; }
00723 inline void
00724 Set_PU_block_limit (PU& pu, int l) { pu.block_limit = l; }
00725 #endif
00726
00727
00728
00729
00730
00731 inline BOOL
00732 PU_is_pure (const PU& pu) { return pu.flags & PU_IS_PURE; }
00733 inline void
00734 Set_PU_is_pure (PU& pu) { pu.flags |= PU_IS_PURE; }
00735 inline void
00736 Clear_PU_is_pure (PU& pu) { pu.flags &= ~PU_IS_PURE; }
00737
00738 inline BOOL
00739 PU_no_side_effects (const PU& pu) { return pu.flags & PU_NO_SIDE_EFFECTS; }
00740 inline void
00741 Set_PU_no_side_effects (PU& pu) { pu.flags |= PU_NO_SIDE_EFFECTS; }
00742 inline void
00743 Clear_PU_no_side_effects (PU& pu) { pu.flags &= ~PU_NO_SIDE_EFFECTS; }
00744
00745 inline BOOL
00746 PU_is_inline_function (const PU& pu) { return pu.flags & PU_IS_INLINE_FUNCTION; }
00747 inline void
00748 Set_PU_is_inline_function (PU& pu) { pu.flags |= PU_IS_INLINE_FUNCTION; }
00749 inline void
00750 Clear_PU_is_inline_function (PU& pu) { pu.flags &= ~PU_IS_INLINE_FUNCTION; }
00751
00752 inline BOOL
00753 PU_no_inline (const PU& pu) { return pu.flags & PU_NO_INLINE; }
00754 inline void
00755 Set_PU_no_inline (PU& pu) { pu.flags |= PU_NO_INLINE; }
00756 inline void
00757 Clear_PU_no_inline (PU& pu) { pu.flags &= ~PU_NO_INLINE; }
00758
00759 inline BOOL
00760 PU_must_inline (const PU& pu) { return pu.flags & PU_MUST_INLINE; }
00761 inline void
00762 Set_PU_must_inline (PU& pu) { pu.flags |= PU_MUST_INLINE; }
00763 inline void
00764 Clear_PU_must_inline (PU& pu) { pu.flags &= ~PU_MUST_INLINE; }
00765
00766 inline BOOL
00767 PU_no_delete (const PU& pu) { return pu.flags & PU_NO_DELETE; }
00768 inline void
00769 Set_PU_no_delete (PU& pu) { pu.flags |= PU_NO_DELETE; }
00770 inline void
00771 Clear_PU_no_delete (PU& pu) { pu.flags &= ~PU_NO_DELETE; }
00772
00773 inline BOOL
00774 PU_has_exc_scopes (const PU& pu) { return pu.flags & PU_HAS_EXC_SCOPES; }
00775 inline void
00776 Set_PU_has_exc_scopes (PU& pu) { pu.flags |= PU_HAS_EXC_SCOPES; }
00777 inline void
00778 Clear_PU_has_exc_scopes (PU& pu) { pu.flags &= ~PU_HAS_EXC_SCOPES; }
00779
00780 inline BOOL
00781 PU_is_nested_func (const PU& pu) { return pu.flags & PU_IS_NESTED_FUNC; }
00782 inline void
00783 Set_PU_is_nested_func (PU& pu) { pu.flags |= PU_IS_NESTED_FUNC; }
00784 inline void
00785 Clear_PU_is_nested_func (PU& pu) { pu.flags &= ~PU_IS_NESTED_FUNC; }
00786
00787 inline BOOL
00788 PU_has_non_mangled_call (const PU& pu) { return pu.flags & PU_HAS_NON_MANGLED_CALL; }
00789 inline void
00790 Set_PU_has_non_mangled_call (PU& pu) { pu.flags |= PU_HAS_NON_MANGLED_CALL; }
00791 inline void
00792 Clear_PU_has_non_mangled_call (PU& pu) { pu.flags &= ~PU_HAS_NON_MANGLED_CALL; }
00793
00794 inline BOOL
00795 PU_args_aliased (const PU& pu) { return pu.flags & PU_ARGS_ALIASED; }
00796 inline void
00797 Set_PU_args_aliased (PU& pu) { pu.flags |= PU_ARGS_ALIASED; }
00798 inline void
00799 Clear_PU_args_aliased (PU& pu) { pu.flags &= ~PU_ARGS_ALIASED; }
00800
00801 inline BOOL
00802 PU_needs_fill_align_lowering (const PU& pu) {
00803 return pu.flags & PU_NEEDS_FILL_ALIGN_LOWERING;
00804 }
00805 inline void
00806 Set_PU_needs_fill_align_lowering (PU& pu) {
00807 pu.flags |= PU_NEEDS_FILL_ALIGN_LOWERING;
00808 }
00809 inline void
00810 Clear_PU_needs_fill_align_lowering (PU& pu) {
00811 pu.flags &= ~PU_NEEDS_FILL_ALIGN_LOWERING;
00812 }
00813
00814 inline BOOL
00815 PU_needs_t9 (const PU& pu) { return pu.flags & PU_NEEDS_T9; }
00816 inline void
00817 Set_PU_needs_t9 (PU& pu) { pu.flags |= PU_NEEDS_T9; }
00818 inline void
00819 Clear_PU_needs_t9 (PU& pu) { pu.flags &= ~PU_NEEDS_T9; }
00820
00821 inline BOOL
00822 PU_has_very_high_whirl (const PU& pu) { return pu.flags & PU_HAS_VERY_HIGH_WHIRL; }
00823 inline void
00824 Set_PU_has_very_high_whirl (PU& pu) { pu.flags |= PU_HAS_VERY_HIGH_WHIRL; }
00825 inline void
00826 Clear_PU_has_very_high_whirl (PU& pu) { pu.flags &= ~PU_HAS_VERY_HIGH_WHIRL; }
00827
00828 inline BOOL
00829 PU_has_altentry (const PU& pu) { return pu.flags & PU_HAS_ALTENTRY; }
00830 inline void
00831 Set_PU_has_altentry (PU& pu) { pu.flags |= PU_HAS_ALTENTRY; }
00832 inline void
00833 Clear_PU_has_altentry (PU& pu) { pu.flags &= ~PU_HAS_ALTENTRY; }
00834
00835 inline BOOL
00836 PU_recursive (const PU& pu) { return pu.flags & PU_RECURSIVE; }
00837 inline void
00838 Set_PU_recursive (PU& pu) { pu.flags |= PU_RECURSIVE; }
00839 inline void
00840 Clear_PU_recursive (PU& pu) { pu.flags &= ~PU_RECURSIVE; }
00841
00842 inline BOOL
00843 PU_is_mainpu (const PU& pu) { return pu.flags & PU_IS_MAINPU; }
00844 inline void
00845 Set_PU_is_mainpu (PU& pu) { pu.flags |= PU_IS_MAINPU; }
00846 inline void
00847 Clear_PU_is_mainpu (PU& pu) { pu.flags &= ~PU_IS_MAINPU; }
00848
00849 inline BOOL
00850 PU_uplevel (const PU& pu) { return pu.flags & PU_UPLEVEL; }
00851 inline void
00852 Set_PU_uplevel (PU& pu) { pu.flags |= PU_UPLEVEL; }
00853 inline void
00854 Clear_PU_uplevel (PU& pu) { pu.flags &= ~PU_UPLEVEL; }
00855
00856 inline BOOL
00857 PU_mp_needs_lno (const PU& pu) { return pu.flags & PU_MP_NEEDS_LNO; }
00858 inline void
00859 Set_PU_mp_needs_lno (PU& pu) { pu.flags |= PU_MP_NEEDS_LNO; }
00860 inline void
00861 Clear_PU_mp_needs_lno (PU& pu) { pu.flags &= ~PU_MP_NEEDS_LNO; }
00862
00863 inline BOOL
00864 PU_has_alloca (const PU& pu) { return pu.flags & PU_HAS_ALLOCA; }
00865 inline void
00866 Set_PU_has_alloca (PU& pu) { pu.flags |= PU_HAS_ALLOCA; }
00867 inline void
00868 Clear_PU_has_alloca (PU& pu) { pu.flags &= ~PU_HAS_ALLOCA; }
00869
00870 inline BOOL
00871 PU_in_elf_section (const PU& pu) { return pu.flags & PU_IN_ELF_SECTION; }
00872 inline void
00873 Set_PU_in_elf_section (PU& pu) { pu.flags |= PU_IN_ELF_SECTION; }
00874 inline void
00875 Clear_PU_in_elf_section (PU& pu) { pu.flags &= ~PU_IN_ELF_SECTION; }
00876
00877 inline BOOL
00878 PU_has_mp (const PU& pu) { return pu.flags & PU_HAS_MP; }
00879 inline void
00880 Set_PU_has_mp (PU& pu) { pu.flags |= PU_HAS_MP; }
00881 inline void
00882 Clear_PU_has_mp (PU& pu) { pu.flags &= ~PU_HAS_MP; }
00883
00884 inline BOOL
00885 PU_mp (const PU& pu) { return pu.flags & PU_MP; }
00886 inline void
00887 Set_PU_mp (PU& pu) { pu.flags |= PU_MP; }
00888 inline void
00889 Clear_PU_mp (PU& pu) { pu.flags &= ~PU_MP; }
00890
00891 inline BOOL
00892 PU_has_namelist (const PU& pu) { return pu.flags & PU_HAS_NAMELIST; }
00893 inline void
00894 Set_PU_has_namelist (PU& pu) { pu.flags |= PU_HAS_NAMELIST; }
00895 inline void
00896 Clear_PU_has_namelist (PU& pu) { pu.flags &= ~PU_HAS_NAMELIST; }
00897
00898 inline BOOL
00899 PU_has_return_address (const PU& pu) { return pu.flags & PU_HAS_RETURN_ADDRESS; }
00900 inline void
00901 Set_PU_has_return_address (PU& pu) { pu.flags |= PU_HAS_RETURN_ADDRESS; }
00902 inline void
00903 Clear_PU_has_return_address (PU& pu) { pu.flags &= ~PU_HAS_RETURN_ADDRESS; }
00904
00905 inline BOOL
00906 PU_has_region (const PU& pu) { return pu.flags & PU_HAS_REGION; }
00907 inline void
00908 Set_PU_has_region (PU& pu) { pu.flags |= PU_HAS_REGION; }
00909 inline void
00910 Clear_PU_has_region (PU& pu) { pu.flags &= ~PU_HAS_REGION; }
00911
00912 inline BOOL
00913 PU_has_inlines (const PU& pu) { return pu.flags & PU_HAS_INLINES; }
00914 inline void
00915 Set_PU_has_inlines (PU& pu) { pu.flags |= PU_HAS_INLINES; }
00916 inline void
00917 Clear_PU_has_inlines (PU& pu) { pu.flags &= ~PU_HAS_INLINES; }
00918
00919 inline BOOL
00920 PU_calls_setjmp (const PU& pu) { return pu.flags & PU_CALLS_SETJMP; }
00921 inline void
00922 Set_PU_calls_setjmp (PU& pu) { pu.flags |= PU_CALLS_SETJMP; }
00923 inline void
00924 Clear_PU_calls_setjmp (PU& pu) { pu.flags &= ~PU_CALLS_SETJMP; }
00925
00926 inline BOOL
00927 PU_calls_longjmp (const PU& pu) { return pu.flags & PU_CALLS_LONGJMP; }
00928 inline void
00929 Set_PU_calls_longjmp (PU& pu) { pu.flags |= PU_CALLS_LONGJMP; }
00930 inline void
00931 Clear_PU_calls_longjmp (PU& pu) { pu.flags &= ~PU_CALLS_LONGJMP; }
00932
00933 inline BOOL
00934 PU_ipa_addr_analysis (const PU& pu) { return pu.flags & PU_IPA_ADDR_ANALYSIS; }
00935 inline void
00936 Set_PU_ipa_addr_analysis (PU& pu) { pu.flags |= PU_IPA_ADDR_ANALYSIS; }
00937 inline void
00938 Clear_PU_ipa_addr_analysis (PU& pu) { pu.flags &= ~PU_IPA_ADDR_ANALYSIS; }
00939
00940 inline BOOL
00941 PU_smart_addr_analysis (const PU& pu) { return pu.flags & PU_SMART_ADDR_ANALYSIS; }
00942 inline void
00943 Set_PU_smart_addr_analysis (PU& pu) { pu.flags |= PU_SMART_ADDR_ANALYSIS; }
00944 inline void
00945 Clear_PU_smart_addr_analysis (PU& pu) { pu.flags &= ~PU_SMART_ADDR_ANALYSIS; }
00946
00947 inline BOOL
00948 PU_has_global_pragmas (const PU& pu) { return pu.flags & PU_HAS_GLOBAL_PRAGMAS; }
00949 inline void
00950 Set_PU_has_global_pragmas (PU& pu) { pu.flags |= PU_HAS_GLOBAL_PRAGMAS; }
00951 inline void
00952 Clear_PU_has_global_pragmas (PU& pu) { pu.flags &= ~PU_HAS_GLOBAL_PRAGMAS; }
00953
00954 inline BOOL
00955 PU_has_user_alloca (const PU& pu) { return (pu.flags & PU_HAS_USER_ALLOCA) != 0; }
00956 inline void
00957 Set_PU_has_user_alloca (PU& pu) { pu.flags |= PU_HAS_USER_ALLOCA; }
00958 inline void
00959 Clear_PU_has_user_alloca (PU& pu) { pu.flags &= ~PU_HAS_USER_ALLOCA; }
00960
00961 inline BOOL
00962 PU_has_unknown_control_flow (const PU& pu) { return (pu.flags & PU_HAS_UNKNOWN_CONTROL_FLOW) != 0; }
00963 inline void
00964 Set_PU_has_unknown_control_flow (PU& pu) { pu.flags |= PU_HAS_UNKNOWN_CONTROL_FLOW; }
00965 inline void
00966 Clear_PU_has_unknown_control_flow (PU& pu) { pu.flags &= ~PU_HAS_UNKNOWN_CONTROL_FLOW; }
00967
00968 inline BOOL
00969 PU_has_syscall_linkage (const PU& pu) { return pu.flags & PU_HAS_SYSCALL_LINKAGE; }
00970 inline void
00971 Set_PU_has_syscall_linkage (PU& pu) { pu.flags |= PU_HAS_SYSCALL_LINKAGE; }
00972 inline void
00973 Clear_PU_has_syscall_linkage (PU& pu) { pu.flags &= ~PU_HAS_SYSCALL_LINKAGE; }
00974
00975 inline BOOL
00976 PU_is_thunk (const PU& pu) { return (pu.flags & PU_IS_THUNK) != 0; }
00977 inline void
00978 Set_PU_is_thunk (PU& pu) { pu.flags |= PU_IS_THUNK; }
00979 inline void
00980 Clear_PU_is_thunk (PU& pu) { pu.flags &= ~PU_IS_THUNK; }
00981
00982 #ifdef KEY
00983 inline BOOL
00984 PU_needs_manual_unwinding (const PU& pu) { return (pu.flags & PU_NEEDS_MANUAL_UNWINDING) != 0;}
00985 inline void
00986 Set_PU_needs_manual_unwinding (PU& pu) { pu.flags |= PU_NEEDS_MANUAL_UNWINDING;}
00987 inline void
00988 Clear_PU_needs_manual_unwinding (PU& pu) { pu.flags &= ~PU_NEEDS_MANUAL_UNWINDING;}
00989
00990 inline BOOL
00991 PU_is_extern_inline (const PU& pu) { return (pu.flags & PU_IS_EXTERN_INLINE) != 0; }
00992 inline void
00993 Set_PU_is_extern_inline (PU& pu) { pu.flags |= PU_IS_EXTERN_INLINE; }
00994 inline void
00995 Clear_PU_is_extern_inline (PU& pu) { pu.flags &= ~PU_IS_EXTERN_INLINE; }
00996
00997 inline BOOL
00998 PU_mp_lower_generated (const PU& pu) { return (pu.flags & PU_MP_LOWER_GENERATED) != 0; }
00999 inline void
01000 Set_PU_mp_lower_generated (PU& pu) { pu.flags |= PU_MP_LOWER_GENERATED; }
01001 inline void
01002 Clear_PU_mp_lower_generated (PU& pu) { pu.flags &= ~PU_MP_LOWER_GENERATED; }
01003
01004 inline BOOL
01005 PU_is_operator (const PU& pu) { return (pu.flags & PU_IS_OPERATOR) != 0; }
01006 inline void
01007 Set_PU_is_operator (PU& pu) { pu.flags |= PU_IS_OPERATOR; }
01008 inline void
01009 Clear_PU_is_operator (PU& pu) { pu.flags &= ~PU_IS_OPERATOR; }
01010
01011 inline BOOL
01012 PU_is_malloc (const PU& pu) { return (pu.flags & PU_IS_MALLOC) != 0; }
01013 inline void
01014 Set_PU_is_malloc (PU& pu) { pu.flags |= PU_IS_MALLOC; }
01015 inline void
01016 Clear_PU_is_malloc (PU& pu) { pu.flags &= ~PU_IS_MALLOC; }
01017
01018 inline BOOL
01019 PU_has_attr_malloc (const PU& pu) { return (pu.flags & PU_HAS_ATTR_MALLOC) != 0; }
01020 inline void
01021 Set_PU_has_attr_malloc (PU& pu) { pu.flags |= PU_HAS_ATTR_MALLOC; }
01022 inline void
01023 Clear_PU_has_attr_malloc (PU& pu) { pu.flags &= ~PU_HAS_ATTR_MALLOC; }
01024
01025 inline BOOL
01026 PU_has_attr_pure (const PU& pu) { return (pu.flags & PU_HAS_ATTR_PURE) != 0; }
01027 inline void
01028 Set_PU_has_attr_pure (PU& pu) { pu.flags |= PU_HAS_ATTR_PURE; }
01029 inline void
01030 Clear_PU_has_attr_pure (PU& pu) { pu.flags &= ~PU_HAS_ATTR_PURE; }
01031
01032 inline BOOL
01033 PU_has_attr_noreturn (PU& pu) { return (pu.flags & PU_HAS_ATTR_NORETURN) != 0; }
01034 inline void
01035 Set_PU_has_attr_noreturn (PU& pu) { pu.flags |= PU_HAS_ATTR_NORETURN; }
01036 inline void
01037 Clear_PU_has_attr_noreturn (PU& pu) { pu.flags &= ~PU_HAS_ATTR_NORETURN; }
01038
01039 inline BOOL
01040 PU_is_marked_inline (const PU& pu) { return (pu.flags & PU_IS_MARKED_INLINE) != 0; }
01041 inline void
01042 Set_PU_is_marked_inline (PU& pu) { pu.flags |= PU_IS_MARKED_INLINE; }
01043 inline void
01044 Clear_PU_is_marked_inline (PU& pu) { pu.flags &= ~PU_IS_MARKED_INLINE; }
01045
01046 inline BOOL
01047 PU_no_instrument (const PU& pu) { return (pu.flags & PU_NO_INSTRUMENT) != 0; }
01048 inline void
01049 Set_PU_no_instrument (PU& pu) { pu.flags |= PU_NO_INSTRUMENT; }
01050 inline void
01051 Clear_PU_no_instrument (PU& pu) { pu.flags &= ~PU_NO_INSTRUMENT; }
01052
01053 inline BOOL
01054 PU_need_trampoline (const PU& pu) { return (pu.flags & PU_NEED_TRAMPOLINE) != 0; }
01055 inline void
01056 Set_PU_need_trampoline (PU& pu) { pu.flags |= PU_NEED_TRAMPOLINE; }
01057
01058 inline BOOL
01059 PU_has_nonlocal_goto_label (const PU& pu) { return (pu.flags & PU_HAS_NONLOCAL_GOTO_LABEL) != 0; }
01060 inline void
01061 Set_PU_has_nonlocal_goto_label (PU& pu) { pu.flags |= PU_HAS_NONLOCAL_GOTO_LABEL; }
01062
01063 inline BOOL
01064 PU_has_goto_outer_block (const PU& pu) { return (pu.flags & PU_HAS_GOTO_OUTER_BLOCK) != 0; }
01065 inline void
01066 Set_PU_has_goto_outer_block (PU& pu) { pu.flags |= PU_HAS_GOTO_OUTER_BLOCK; }
01067 #endif
01068
01069 #ifdef TARG_X8664
01070 inline BOOL
01071 PU_ff2c_abi (const PU& pu) { return (pu.flags & PU_FF2C_ABI) != 0;}
01072 inline void
01073 Set_PU_ff2c_abi (PU& pu) { pu.flags |= PU_FF2C_ABI; }
01074 inline void
01075 Clear_PU_ff2c_abi (PU& pu) { pu.flags &= ~PU_FF2C_ABI; }
01076 #endif
01077
01078 inline BOOL
01079 PU_is_cdecl (const PU_IDX pui) { return (Pu_Table[pui].flags & PU_IS_CDECL) != 0; }
01080 inline void
01081 Set_PU_is_cdecl (PU_IDX pui) { Pu_Table[pui].flags |= PU_IS_CDECL; }
01082 inline void
01083 Clear_PU_is_cdecl (PU_IDX pui) { Pu_Table[pui].flags &= ~PU_IS_CDECL; }
01084
01085 inline UINT64
01086 PU_src_lang (const PU& pu) { return pu.src_lang; }
01087
01088 inline BOOL
01089 PU_mixed_lang (const PU& pu) { return (pu.src_lang & PU_MIXED_LANG) != 0; }
01090 inline void
01091 Set_PU_mixed_lang (PU& pu) { pu.src_lang |= PU_MIXED_LANG; }
01092 inline void
01093 Clear_PU_mixed_lang (PU& pu) { pu.src_lang &= ~PU_MIXED_LANG; }
01094
01095 inline BOOL
01096 PU_c_lang (const PU& pu) { return (pu.src_lang & PU_C_LANG) != 0; }
01097 inline void
01098 Set_PU_c_lang (PU& pu) { pu.src_lang |= PU_C_LANG; }
01099 inline void
01100 Clear_PU_c_lang (PU& pu) { pu.src_lang &= ~PU_C_LANG; }
01101
01102 inline BOOL
01103 PU_cxx_lang (const PU& pu) { return (pu.src_lang & PU_CXX_LANG) != 0; }
01104 inline void
01105 Set_PU_cxx_lang (PU& pu) { pu.src_lang |= PU_CXX_LANG; }
01106 inline void
01107 Clear_PU_cxx_lang (PU& pu) { pu.src_lang &= ~PU_CXX_LANG; }
01108
01109 inline BOOL
01110 PU_f77_lang (const PU& pu) { return (pu.src_lang & PU_F77_LANG) != 0; }
01111 inline void
01112 Set_PU_f77_lang (PU& pu) { pu.src_lang |= PU_F77_LANG; }
01113 inline void
01114 Clear_PU_f77_lang (PU& pu) { pu.src_lang &= ~PU_F77_LANG; }
01115
01116 inline BOOL
01117 PU_f90_lang (const PU& pu) { return (pu.src_lang & PU_F90_LANG) != 0; }
01118 inline void
01119 Set_PU_f90_lang (PU& pu) { pu.src_lang |= PU_F90_LANG; }
01120 inline void
01121 Clear_PU_f90_lang (PU& pu) { pu.src_lang &= ~PU_F90_LANG; }
01122
01123 inline BOOL
01124 PU_java_lang (const PU& pu) { return (pu.src_lang & PU_JAVA_LANG) != 0; }
01125 inline void
01126 Set_PU_java_lang (PU& pu) { pu.src_lang |= PU_JAVA_LANG; }
01127 inline void
01128 Clear_PU_java_lang (PU& pu) { pu.src_lang &= ~PU_JAVA_LANG; }
01129
01130 inline BOOL
01131 PU_is_constructor (const PU& pu) { return (pu.flags & PU_IS_CONSTRUCTOR) != 0; }
01132 inline void
01133 Set_PU_is_constructor (PU& pu) { pu.flags |= PU_IS_CONSTRUCTOR; }
01134 inline void
01135 Clear_PU_is_constructor (PU &pu) { pu.flags &= ~PU_IS_CONSTRUCTOR; }
01136
01137
01138
01139
01140
01141
01142
01143 inline UINT64
01144 TY_size (const TY& ty) { return ty.size; }
01145 inline void
01146 Set_TY_size (TY& ty, UINT64 size) { ty.size = size; }
01147 inline void
01148 Set_TY_size (TY_IDX tyi, UINT64 size) {
01149 Set_TY_size(Ty_Table[tyi], size);
01150 }
01151
01152 inline TY_KIND
01153 TY_kind (const TY& ty) { return ty.kind; }
01154 inline void
01155 Set_TY_kind (TY& ty, TY_KIND kind) { ty.kind = kind; }
01156 inline void
01157 Set_TY_kind (TY_IDX tyi, TY_KIND kind) { Set_TY_kind(Ty_Table[tyi], kind); }
01158
01159 inline TYPE_ID
01160 TY_mtype (const TY& ty) { return ty.mtype; }
01161 inline void
01162 Set_TY_mtype (TY& ty, TYPE_ID mtype) { ty.mtype = mtype; }
01163 inline void
01164 Set_TY_mtype (TY_IDX tyi, TYPE_ID mtype){ Set_TY_mtype(Ty_Table[tyi],mtype); }
01165
01166 inline UINT16
01167 TY_flags (const TY& ty) { return ty.flags; }
01168 inline void
01169 Set_TY_flags (TY& ty, mUINT16 flags) { ty.flags = flags; }
01170 inline UINT16
01171 TY_flags (const TY_IDX tyi) { return TY_flags(Ty_Table[tyi]); }
01172 inline void
01173 Set_TY_flags (TY_IDX tyi, mUINT16 flags){ Set_TY_flags(Ty_Table[tyi],flags); }
01174
01175 inline FLD_HANDLE
01176 TY_fld (const TY& ty) { return FLD_HANDLE (ty.Fld ()); }
01177 inline void
01178 Set_TY_fld (TY& ty, FLD_HANDLE fld) { ty.Set_fld (fld.Idx()); }
01179 inline FLD_HANDLE
01180 TY_fld (const TY_IDX tyi) { return TY_fld(Ty_Table[tyi]); }
01181 inline void
01182 Set_TY_fld (TY_IDX tyi, FLD_HANDLE fld) { Set_TY_fld(Ty_Table[tyi], fld); }
01183
01184 inline TYLIST_IDX
01185 TY_tylist (const TY& ty) { return ty.Tylist (); }
01186 inline void
01187 Set_TY_tylist (TY& ty, TYLIST_IDX idx) { ty.Set_tylist (idx); }
01188 inline TYLIST_IDX
01189 TY_tylist (const TY_IDX tyi) { return TY_tylist(Ty_Table[tyi]); }
01190 inline void
01191 Set_TY_tylist (TY_IDX tyi, TYLIST_IDX idx) {
01192 Set_TY_tylist(Ty_Table[tyi],idx);
01193 }
01194
01195 inline ARB_HANDLE
01196 TY_arb (const TY& ty) { return ARB_HANDLE(ty.Arb ()); }
01197 inline void
01198 Set_TY_arb (TY& ty, ARB_HANDLE idx) { ty.Set_arb (idx.Idx()); }
01199 inline ARB_HANDLE
01200 TY_arb (const TY_IDX tyi) { return TY_arb(Ty_Table[tyi]); }
01201 inline void
01202 Set_TY_arb (TY_IDX tyi, ARB_HANDLE idx) { Set_TY_arb(Ty_Table[tyi], idx); }
01203
01204
01205 inline STR_IDX
01206 TY_name_idx (const TY& ty) { return ty.name_idx; }
01207 inline void
01208 Set_TY_name_idx (TY& ty, UINT64 name) { ty.name_idx = name; }
01209 inline STR_IDX
01210 TY_name_idx (const TY_IDX tyi) { return TY_name_idx(Ty_Table[tyi]); }
01211 inline void
01212 Set_TY_name_idx (TY_IDX tyi, UINT64 name) {
01213 Set_TY_name_idx(Ty_Table[tyi], name);
01214 }
01215 inline char *
01216 TY_name (const TY& ty) { return &Str_Table[ty.name_idx]; }
01217
01218 inline TY_IDX
01219 TY_etype (const TY& ty) { return ty.Etype (); }
01220 inline void
01221 Set_TY_etype (TY& ty, TY_IDX idx) { ty.Set_etype (idx); }
01222 inline TY_IDX
01223 TY_etype (const TY_IDX tyi) { return TY_etype(Ty_Table[tyi]); }
01224 inline void
01225 Set_TY_etype (TY_IDX tyi, TY_IDX idx) { Set_TY_etype(Ty_Table[tyi],idx); }
01226
01227 inline TY_IDX
01228 TY_pointed (const TY& ty) { return ty.Pointed (); }
01229 inline void
01230 Set_TY_pointed (TY& ty, TY_IDX idx) { ty.Set_pointed (idx); }
01231 inline TY_IDX
01232 TY_pointed (const TY_IDX tyi) { return Ty_Table[tyi].Pointed (); }
01233 inline void
01234 Set_TY_pointed (TY_IDX tyi, TY_IDX idx) { Set_TY_pointed(Ty_Table[tyi],idx); }
01235
01236 #ifdef KEY
01237 inline ST_IDX
01238 TY_copy_constructor (const TY& ty) { return ty.Copy_constructor (); }
01239 inline void
01240 Set_TY_copy_constructor (TY& ty, ST_IDX idx) { ty.Set_copy_constructor (idx); }
01241 inline ST_IDX
01242 TY_copy_constructor (const TY_IDX tyi) { return Ty_Table[tyi].Copy_constructor (); }
01243 inline void
01244 Set_TY_copy_constructor (TY_IDX tyi, ST_IDX idx) { Set_TY_copy_constructor(Ty_Table[tyi],idx); }
01245 #endif
01246
01247
01248
01249
01250
01251 inline BOOL
01252 TY_is_character (const TY& ty) { return ty.flags & TY_IS_CHARACTER; }
01253 inline void
01254 Set_TY_is_character (TY& ty) { ty.flags |= TY_IS_CHARACTER; }
01255 inline void
01256 Clear_TY_is_character (TY& ty) { ty.flags &= ~TY_IS_CHARACTER; }
01257 inline BOOL
01258 TY_is_character (const TY_IDX tyi) { return TY_is_character(Ty_Table[tyi]); }
01259 inline void
01260 Set_TY_is_character (TY_IDX tyi) { Set_TY_is_character(Ty_Table[tyi]); }
01261 inline void
01262 Clear_TY_is_character (TY_IDX tyi) { Clear_TY_is_character(Ty_Table[tyi]); }
01263
01264 inline BOOL
01265 TY_is_logical (const TY& ty) { return ty.flags & TY_IS_LOGICAL; }
01266 inline void
01267 Set_TY_is_logical (TY& ty) { ty.flags |= TY_IS_LOGICAL; }
01268 inline void
01269 Clear_TY_is_logical (TY& ty) { ty.flags &= ~TY_IS_LOGICAL; }
01270 inline BOOL
01271 TY_is_logical (const TY_IDX tyi) { return TY_is_logical(Ty_Table[tyi]); }
01272 inline void
01273 Set_TY_is_logical (TY_IDX tyi) { Set_TY_is_logical(Ty_Table[tyi]); }
01274 inline void
01275 Clear_TY_is_logical (TY_IDX tyi) { Clear_TY_is_logical(Ty_Table[tyi]); }
01276
01277 inline BOOL
01278 TY_is_union (const TY& ty) { return ty.flags & TY_IS_UNION; }
01279 inline void
01280 Set_TY_is_union (TY& ty) { ty.flags |= TY_IS_UNION; }
01281 inline void
01282 Clear_TY_is_union (TY& ty) { ty.flags &= ~TY_IS_UNION; }
01283 inline BOOL
01284 TY_is_union (const TY_IDX tyi) { return TY_is_union(Ty_Table[tyi]); }
01285 inline void
01286 Set_TY_is_union (TY_IDX tyi) { Set_TY_is_union(Ty_Table[tyi]); }
01287 inline void
01288 Clear_TY_is_union (TY_IDX tyi) { Clear_TY_is_union(Ty_Table[tyi]); }
01289
01290 inline BOOL
01291 TY_is_packed (const TY& ty) { return ty.flags & TY_IS_PACKED; }
01292 inline void
01293 Set_TY_is_packed (TY& ty) { ty.flags |= TY_IS_PACKED; }
01294 inline void
01295 Clear_TY_is_packed (TY& ty) { ty.flags &= ~TY_IS_PACKED; }
01296 inline BOOL
01297 TY_is_packed (const TY_IDX tyi) { return TY_is_packed(Ty_Table[tyi]); }
01298 inline void
01299 Set_TY_is_packed (TY_IDX tyi) { Set_TY_is_packed(Ty_Table[tyi]); }
01300 inline void
01301 Clear_TY_is_packed (TY_IDX tyi) { Clear_TY_is_packed(Ty_Table[tyi]); }
01302
01303 inline BOOL
01304 TY_ptr_as_array (const TY& ty) { return ty.flags & TY_PTR_AS_ARRAY; }
01305 inline void
01306 Set_TY_ptr_as_array (TY& ty) { ty.flags |= TY_PTR_AS_ARRAY; }
01307 inline void
01308 Clear_TY_ptr_as_array (TY& ty) { ty.flags &= ~TY_PTR_AS_ARRAY; }
01309 inline BOOL
01310 TY_ptr_as_array (const TY_IDX tyi) { return TY_ptr_as_array(Ty_Table[tyi]); }
01311 inline void
01312 Set_TY_ptr_as_array (TY_IDX tyi) { Set_TY_ptr_as_array(Ty_Table[tyi]); }
01313 inline void
01314 Clear_TY_ptr_as_array (TY_IDX tyi) { Clear_TY_ptr_as_array(Ty_Table[tyi]); }
01315
01316 #ifdef TARG_NVISA
01317 inline BOOL
01318 TY_can_be_vector (const TY_IDX tyi) { return (TY_flags(Ty_Table[tyi]) & TY_CAN_BE_VECTOR); }
01319 inline void
01320 Set_TY_can_be_vector (TY_IDX tyi) { Set_TY_flags(Ty_Table[tyi], TY_flags(Ty_Table[tyi]) | TY_CAN_BE_VECTOR); }
01321 #endif
01322
01323 inline BOOL
01324 TY_anonymous (const TY& ty) { return ty.flags & TY_ANONYMOUS; }
01325 inline void
01326 Set_TY_anonymous (TY& ty) { ty.flags |= TY_ANONYMOUS; }
01327 inline void
01328 Clear_TY_anonymous (TY& ty) { ty.flags &= ~TY_ANONYMOUS; }
01329 inline BOOL
01330 TY_anonymous (const TY_IDX tyi) { return TY_anonymous(Ty_Table[tyi]); }
01331 inline void
01332 Set_TY_anonymous (TY_IDX tyi) { Set_TY_anonymous(Ty_Table[tyi]); }
01333 inline void
01334 Clear_TY_anonymous (TY_IDX tyi) { Clear_TY_anonymous(Ty_Table[tyi]); }
01335
01336 inline BOOL
01337 TY_split (const TY& ty) { return ty.flags & TY_SPLIT; }
01338 inline void
01339 Set_TY_split (TY& ty) { ty.flags |= TY_SPLIT; }
01340 inline void
01341 Clear_TY_split (TY& ty) { ty.flags &= ~TY_SPLIT; }
01342 inline BOOL
01343 TY_split (const TY_IDX tyi) { return TY_split(Ty_Table[tyi]); }
01344 inline void
01345 Set_TY_split (TY_IDX tyi) { Set_TY_split(Ty_Table[tyi]); }
01346 inline void
01347 Clear_TY_split (TY_IDX tyi) { Clear_TY_split(Ty_Table[tyi]); }
01348
01349 inline BOOL
01350 TY_is_f90_pointer (const TY& ty) { return ty.flags & TY_IS_F90_POINTER; }
01351 inline void
01352 Set_TY_is_f90_pointer (TY& ty) { ty.flags |= TY_IS_F90_POINTER; }
01353 inline void
01354 Clear_TY_is_f90_pointer (TY& ty) { ty.flags &= ~TY_IS_F90_POINTER; }
01355 inline BOOL
01356 TY_is_f90_pointer (const TY_IDX tyi){ return TY_is_f90_pointer(Ty_Table[tyi]);}
01357 inline void
01358 Set_TY_is_f90_pointer (TY_IDX tyi) { Set_TY_is_f90_pointer(Ty_Table[tyi]); }
01359 inline void
01360 Clear_TY_is_f90_pointer (TY_IDX tyi){ Clear_TY_is_f90_pointer(Ty_Table[tyi]); }
01361
01362 inline BOOL
01363 TY_not_in_union (const TY& ty) { return ty.flags & TY_NOT_IN_UNION; }
01364 inline void
01365 Set_TY_not_in_union (TY& ty) { ty.flags |= TY_NOT_IN_UNION; }
01366 inline void
01367 Clear_TY_not_in_union (TY& ty) { ty.flags &= ~TY_NOT_IN_UNION; }
01368 inline BOOL
01369 TY_not_in_union (const TY_IDX tyi) { return TY_not_in_union(Ty_Table[tyi]); }
01370 inline void
01371 Set_TY_not_in_union (TY_IDX tyi) { Set_TY_not_in_union(Ty_Table[tyi]); }
01372 inline void
01373 Clear_TY_not_in_union (TY_IDX tyi) { Clear_TY_not_in_union(Ty_Table[tyi]); }
01374
01375 inline BOOL
01376 TY_no_ansi_alias (const TY& ty) { return ty.flags & TY_NO_ANSI_ALIAS; }
01377 inline void
01378 Set_TY_no_ansi_alias (TY& ty) { ty.flags |= TY_NO_ANSI_ALIAS; }
01379 inline void
01380 Clear_TY_no_ansi_alias (TY& ty) { ty.flags &= ~TY_NO_ANSI_ALIAS; }
01381 inline BOOL
01382 TY_no_ansi_alias (const TY_IDX tyi) { return TY_no_ansi_alias(Ty_Table[tyi]); }
01383 inline void
01384 Set_TY_no_ansi_alias (TY_IDX tyi) { Set_TY_no_ansi_alias(Ty_Table[tyi]); }
01385 inline void
01386 Clear_TY_no_ansi_alias (TY_IDX tyi) { Clear_TY_no_ansi_alias(Ty_Table[tyi]); }
01387
01388 inline BOOL
01389 TY_is_non_pod (const TY& ty) { return ty.flags & TY_IS_NON_POD; }
01390 inline void
01391 Set_TY_is_non_pod (TY& ty) { ty.flags |= TY_IS_NON_POD; }
01392 inline void
01393 Clear_TY_is_non_pod (TY& ty) { ty.flags &= ~TY_IS_NON_POD; }
01394 inline BOOL
01395 TY_is_non_pod (const TY_IDX tyi) { return TY_is_non_pod(Ty_Table[tyi]); }
01396 inline void
01397 Set_TY_is_non_pod (TY_IDX tyi) { Set_TY_is_non_pod(Ty_Table[tyi]); }
01398 inline void
01399 Clear_TY_is_non_pod (TY_IDX tyi) { Clear_TY_is_non_pod(Ty_Table[tyi]); }
01400
01401 #ifdef KEY
01402 inline BOOL
01403 TY_return_in_mem (const TY& ty) { return ty.flags & TY_RETURN_IN_MEM; }
01404 inline void
01405 Set_TY_return_in_mem (TY& ty) { ty.flags |= TY_RETURN_IN_MEM; }
01406 inline void
01407 Clear_TY_return_in_mem (TY& ty) { ty.flags &= ~TY_RETURN_IN_MEM; }
01408 inline BOOL
01409 TY_return_in_mem (const TY_IDX tyi) { return TY_return_in_mem(Ty_Table[tyi]); }
01410 inline void
01411 Set_TY_return_in_mem (TY_IDX tyi) { Set_TY_return_in_mem(Ty_Table[tyi]); }
01412 inline void
01413 Clear_TY_return_in_mem (TY_IDX tyi) { Clear_TY_return_in_mem(Ty_Table[tyi]); }
01414 inline BOOL
01415 TY_content_seen (const TY& ty) { return ty.flags & TY_CONTENT_SEEN; }
01416 inline void
01417 Set_TY_content_seen (TY& ty) { ty.flags |= TY_CONTENT_SEEN; }
01418 inline void
01419 Clear_TY_content_seen (TY& ty) { ty.flags &= ~TY_CONTENT_SEEN; }
01420 inline BOOL
01421 TY_content_seen (const TY_IDX tyi) { return TY_content_seen(Ty_Table[tyi]); }
01422 inline void
01423 Set_TY_content_seen (TY_IDX tyi) { Set_TY_content_seen(Ty_Table[tyi]); }
01424 inline void
01425 Clear_TY_content_seen (TY_IDX tyi) { Clear_TY_content_seen(Ty_Table[tyi]); }
01426
01427 inline BOOL
01428 TY_is_incomplete (const TY& ty) { return ty.flags & TY_IS_INCOMPLETE; }
01429 inline void
01430 Set_TY_is_incomplete (TY& ty) { ty.flags |= TY_IS_INCOMPLETE; }
01431 inline void
01432 Clear_TY_is_incomplete (TY& ty) { ty.flags &= ~TY_IS_INCOMPLETE; }
01433 inline BOOL
01434 TY_is_incomplete (const TY_IDX tyi) { return TY_is_incomplete(Ty_Table[tyi]); }
01435 inline void
01436 Set_TY_is_incomplete (TY_IDX tyi) { Set_TY_is_incomplete(Ty_Table[tyi]); }
01437 inline void
01438 Clear_TY_is_incomplete (TY_IDX tyi) { Clear_TY_is_incomplete(Ty_Table[tyi]); }
01439
01440 inline BOOL
01441 TY_no_split (const TY& ty) { return ty.flags & TY_NO_SPLIT; }
01442 inline void
01443 Set_TY_no_split (TY& ty) { ty.flags |= TY_NO_SPLIT; }
01444 inline void
01445 Clear_TY_no_split (TY& ty) { ty.flags &= ~TY_NO_SPLIT; }
01446 inline BOOL
01447 TY_no_split (const TY_IDX tyi) { return TY_no_split(Ty_Table[tyi]); }
01448 inline void
01449 Set_TY_no_split (TY_IDX tyi) { Set_TY_no_split(Ty_Table[tyi]); }
01450 inline void
01451 Clear_TY_no_split (TY_IDX tyi) { Clear_TY_no_split(Ty_Table[tyi]); }
01452 #endif
01453
01454
01455
01456 inline BOOL
01457 TY_return_to_param (const TY& ty) { return ty.Pu_flags () & TY_RETURN_TO_PARAM; }
01458 inline void
01459 Set_TY_return_to_param (TY& ty) { ty.Set_pu_flag (TY_RETURN_TO_PARAM); }
01460 inline void
01461 Clear_TY_return_to_param (TY& ty) { ty.Clear_pu_flag (TY_RETURN_TO_PARAM); }
01462 inline BOOL
01463 TY_return_to_param (const TY_IDX tyi) {
01464 return TY_return_to_param(Ty_Table[tyi]);
01465 }
01466 inline void
01467 Set_TY_return_to_param (TY_IDX tyi) { Set_TY_return_to_param(Ty_Table[tyi]); }
01468 inline void
01469 Clear_TY_return_to_param (TY_IDX tyi){
01470 Clear_TY_return_to_param(Ty_Table[tyi]);
01471 }
01472
01473 inline BOOL
01474 TY_is_varargs (const TY& ty) { return ty.Pu_flags () & TY_IS_VARARGS; }
01475 inline void
01476 Set_TY_is_varargs (TY& ty) { ty.Set_pu_flag (TY_IS_VARARGS); }
01477 inline void
01478 Clear_TY_is_varargs (TY& ty) { ty.Clear_pu_flag (TY_IS_VARARGS); }
01479 inline BOOL
01480 TY_is_varargs (const TY_IDX tyi) { return TY_is_varargs(Ty_Table[tyi]); }
01481 inline void
01482 Set_TY_is_varargs (TY_IDX tyi) { Set_TY_is_varargs(Ty_Table[tyi]); }
01483 inline void
01484 Clear_TY_is_varargs (TY_IDX tyi) { Clear_TY_is_varargs(Ty_Table[tyi]); }
01485
01486 inline BOOL
01487 TY_has_prototype (const TY_IDX tyi) {
01488 return Ty_Table[tyi].Pu_flags() & TY_HAS_PROTOTYPE;
01489 }
01490 inline void
01491 Set_TY_has_prototype (TY_IDX tyi) {
01492 Ty_Table[tyi].Set_pu_flag (TY_HAS_PROTOTYPE);
01493 }
01494 inline void
01495 Clear_TY_has_prototype (TY_IDX tyi) {
01496 Ty_Table[tyi].Clear_pu_flag (TY_HAS_PROTOTYPE);
01497 }
01498
01499 #ifdef TARG_X8664
01500 inline BOOL
01501 TY_has_sseregister_parm (const TY& ty) {
01502 return ty.Pu_flags () & TY_HAS_SSEREG_PARM;
01503 }
01504 inline void
01505 Set_TY_has_sseregister_parm (TY& ty) {
01506 ty.Set_pu_flag (TY_HAS_SSEREG_PARM);
01507 }
01508 inline BOOL
01509 TY_has_sseregister_parm (const TY_IDX tyi) {
01510 return TY_has_sseregister_parm(Ty_Table[tyi]);
01511 }
01512 inline void
01513 Set_TY_has_sseregister_parm (TY_IDX tyi) {
01514 Set_TY_has_sseregister_parm(Ty_Table[tyi]);
01515 }
01516
01517 inline INT
01518 TY_register_parm (const TY& ty)
01519 {
01520 if ((ty.Pu_flags() & TY_HAS_1_REG_PARM) == 0 &&
01521 (ty.Pu_flags() & TY_HAS_2_REG_PARM) == 0)
01522 return 0;
01523 if ((ty.Pu_flags() & TY_HAS_1_REG_PARM) &&
01524 (ty.Pu_flags() & TY_HAS_2_REG_PARM))
01525 return 3;
01526 if (ty.Pu_flags() & TY_HAS_1_REG_PARM)
01527 return 1;
01528 if (ty.Pu_flags() & TY_HAS_2_REG_PARM)
01529 return 2;
01530 }
01531
01532 inline void
01533 Set_TY_register_parm (TY& ty, INT num)
01534 {
01535 if (num == 0) return;
01536 if (num == 1) ty.Set_pu_flag (TY_HAS_1_REG_PARM);
01537 else if (num == 2) ty.Set_pu_flag (TY_HAS_2_REG_PARM);
01538 else if (num == 3) ty.Set_pu_flag (TY_HAS_3_REG_PARM);
01539 }
01540
01541 inline INT
01542 TY_register_parm (const TY_IDX tyi) {
01543 return TY_register_parm (Ty_Table[tyi]);
01544 }
01545
01546 inline void
01547 Set_TY_register_parm (TY_IDX tyi, INT num) {
01548 Set_TY_register_parm (Ty_Table[tyi], num);
01549 }
01550 #endif
01551
01552
01553
01554
01555
01556 inline STR_IDX
01557 FLD_name_idx (FLD_HANDLE fld) { return fld.Entry()->name_idx; }
01558 inline void
01559 Set_FLD_name_idx (FLD_HANDLE fld, STR_IDX idx){ fld.Entry()->name_idx = idx; }
01560 inline char *
01561 FLD_name (FLD_HANDLE fld) { return &Str_Table[fld.Entry()->name_idx]; }
01562
01563 inline TY_IDX
01564 FLD_type (FLD_HANDLE fld) { return fld.Entry()->type; }
01565 inline void
01566 Set_FLD_type (FLD_HANDLE fld, TY_IDX ty){ fld.Entry()->type = ty; }
01567
01568 inline UINT64
01569 FLD_ofst (FLD_HANDLE fld) { return fld.Entry()->ofst; }
01570 inline void
01571 Set_FLD_ofst (FLD_HANDLE fld, UINT64 ofst) { fld.Entry()->ofst = ofst; }
01572
01573 inline UINT8
01574 FLD_bsize (FLD_HANDLE fld) { return fld.Entry()->bsize; }
01575 inline void
01576 Set_FLD_bsize (FLD_HANDLE fld, UINT8 bsize) { fld.Entry()->bsize = bsize; }
01577
01578 inline UINT8
01579 FLD_bofst (FLD_HANDLE fld) { return fld.Entry()->bofst; }
01580 inline void
01581 Set_FLD_bofst (FLD_HANDLE fld, UINT8 bofst) { fld.Entry()->bofst = bofst; }
01582
01583 inline UINT16
01584 FLD_flags (FLD_HANDLE fld) { return fld.Entry()->flags; }
01585 inline void
01586 Set_FLD_flags (FLD_HANDLE fld, UINT16 flags) { fld.Entry()->flags = flags; }
01587
01588 inline ST_IDX
01589 FLD_st (FLD_HANDLE fld) { return fld.Entry()->st; }
01590 inline void
01591 Set_FLD_st (FLD_HANDLE fld, ST_IDX st) { fld.Entry()->st = st; }
01592
01593
01594
01595
01596
01597 inline BOOL
01598 FLD_last_field (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_LAST_FIELD; }
01599 inline void
01600 Set_FLD_last_field (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_LAST_FIELD; }
01601 inline void
01602 Clear_FLD_last_field (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_LAST_FIELD; }
01603
01604 inline BOOL
01605 FLD_equivalence (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_EQUIVALENCE; }
01606 inline void
01607 Set_FLD_equivalence (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_EQUIVALENCE; }
01608 inline void
01609 Clear_FLD_equivalence (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_EQUIVALENCE; }
01610
01611 inline BOOL
01612 FLD_begin_union (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_BEGIN_UNION; }
01613 inline void
01614 Set_FLD_begin_union (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_BEGIN_UNION; }
01615 inline void
01616 Clear_FLD_begin_union (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_BEGIN_UNION; }
01617
01618 inline BOOL
01619 FLD_end_union (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_END_UNION; }
01620 inline void
01621 Set_FLD_end_union (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_END_UNION; }
01622 inline void
01623 Clear_FLD_end_union (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_END_UNION; }
01624
01625 inline BOOL
01626 FLD_begin_map (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_BEGIN_MAP; }
01627 inline void
01628 Set_FLD_begin_map (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_BEGIN_MAP; }
01629 inline void
01630 Clear_FLD_begin_map (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_BEGIN_MAP; }
01631
01632 inline BOOL
01633 FLD_end_map (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_END_MAP; }
01634 inline void
01635 Set_FLD_end_map (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_END_MAP; }
01636 inline void
01637 Clear_FLD_end_map (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_END_MAP; }
01638
01639 inline BOOL
01640 FLD_is_bit_field (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_IS_BIT_FIELD; }
01641 inline void
01642 Set_FLD_is_bit_field (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_IS_BIT_FIELD; }
01643 inline void
01644 Clear_FLD_is_bit_field (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_IS_BIT_FIELD; }
01645
01646 inline BOOL
01647 FLD_is_anonymous (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_IS_ANONYMOUS; }
01648 inline void
01649 Set_FLD_is_anonymous (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_IS_ANONYMOUS; }
01650 inline void
01651 Clear_FLD_is_anonymous (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_IS_ANONYMOUS; }
01652
01653 inline BOOL
01654 FLD_is_base_class (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_IS_BASE_CLASS; }
01655 inline void
01656 Set_FLD_is_base_class (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_IS_BASE_CLASS; }
01657 inline void
01658 Clear_FLD_is_base_class (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_IS_BASE_CLASS; }
01659
01660
01661
01662
01663
01664 inline TY_IDX
01665 TYLIST_type (TYLIST tylist) { return tylist; }
01666 inline void
01667 Set_TYLIST_type (TYLIST& tylist, TY_IDX ty) { tylist = ty; }
01668
01669
01670
01671 inline TY_IDX
01672 TYLIST_ty (TYLIST_IDX tli) { return Tylist_Table[tli]; }
01673 inline void
01674 Set_TYLIST_ty (TYLIST_IDX tli, TY_IDX ty) { Tylist_Table[tli] = ty; }
01675
01676
01677
01678
01679
01680 inline UINT16
01681 ARB_flags (const ARB_HANDLE arb) { return arb.Entry()->flags; }
01682 inline void
01683 Set_ARB_flags (ARB_HANDLE arb, UINT16 flags){ arb.Entry()->flags = flags; }
01684
01685 inline UINT16
01686 ARB_dimension (const ARB_HANDLE arb) { return arb.Entry()->dimension; }
01687 inline void
01688 Set_ARB_dimension (ARB_HANDLE arb, UINT16 dim){ arb.Entry()->dimension = dim; }
01689
01690 inline INT64
01691 ARB_lbnd_val (const ARB_HANDLE arb) { return arb.Entry()->Lbnd_val (); }
01692 inline void
01693 Set_ARB_lbnd_val (ARB_HANDLE arb, INT64 val) { arb.Entry()->Set_lbnd_val (val); }
01694
01695 inline ST_IDX
01696 ARB_lbnd_var (const ARB_HANDLE arb) { return arb.Entry()->Lbnd_var (); }
01697 inline void
01698 Set_ARB_lbnd_var (ARB_HANDLE arb, ST_IDX var) { arb.Entry()->Set_lbnd_var (var); }
01699
01700 inline INT64
01701 ARB_ubnd_val (const ARB_HANDLE arb) { return arb.Entry()->Ubnd_val (); }
01702 inline void
01703 Set_ARB_ubnd_val (ARB_HANDLE arb, INT64 val) { arb.Entry()->Set_ubnd_val (val); }
01704
01705 inline ST_IDX
01706 ARB_ubnd_var (const ARB_HANDLE arb) { return arb.Entry()->Ubnd_var (); }
01707 inline void
01708 Set_ARB_ubnd_var (ARB_HANDLE arb, ST_IDX var) { arb.Entry()->Set_ubnd_var (var); }
01709
01710 inline INT64
01711 ARB_stride_val (const ARB_HANDLE arb) { return arb.Entry()->Stride_val (); }
01712 inline void
01713 Set_ARB_stride_val (ARB_HANDLE arb, INT64 val){ arb.Entry()->Set_stride_val (val); }
01714
01715 inline ST_IDX
01716 ARB_stride_var (const ARB_HANDLE arb) { return arb.Entry()->Stride_var (); }
01717 inline void
01718 Set_ARB_stride_var (ARB_HANDLE arb, ST_IDX var) { arb.Entry()->Set_stride_var (var); }
01719
01720
01721
01722
01723
01724 inline BOOL
01725 ARB_const_lbnd (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_CONST_LBND; }
01726 inline void
01727 Set_ARB_const_lbnd (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_CONST_LBND; }
01728 inline void
01729 Clear_ARB_const_lbnd (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_CONST_LBND; }
01730
01731 inline BOOL
01732 ARB_const_ubnd (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_CONST_UBND; }
01733 inline void
01734 Set_ARB_const_ubnd (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_CONST_UBND; }
01735 inline void
01736 Clear_ARB_const_ubnd (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_CONST_UBND; }
01737
01738 inline BOOL
01739 ARB_const_stride (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_CONST_STRIDE; }
01740 inline void
01741 Set_ARB_const_stride (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_CONST_STRIDE; }
01742 inline void
01743 Clear_ARB_const_stride (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_CONST_STRIDE; }
01744
01745 inline BOOL
01746 ARB_first_dimen (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_FIRST_DIMEN; }
01747 inline void
01748 Set_ARB_first_dimen (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_FIRST_DIMEN; }
01749 inline void
01750 Clear_ARB_first_dimen (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_FIRST_DIMEN; }
01751
01752 inline BOOL
01753 ARB_last_dimen (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_LAST_DIMEN; }
01754 inline void
01755 Set_ARB_last_dimen (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_LAST_DIMEN; }
01756 inline void
01757 Clear_ARB_last_dimen (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_LAST_DIMEN; }
01758
01759
01760
01761
01762
01763
01764 inline STR_IDX
01765 LABEL_name_idx (const LABEL& lbl) { return lbl.name_idx; }
01766 inline void
01767 Set_LABEL_name_idx (LABEL& lbl, STR_IDX s) { lbl.name_idx = s; }
01768 inline char *
01769 LABEL_name (const LABEL& lbl) { return &Str_Table[lbl.name_idx]; }
01770
01771 inline LABEL_KIND
01772 LABEL_kind (const LABEL& lbl) { return lbl.kind; }
01773 inline void
01774 Set_LABEL_KIND (LABEL& lbl, LABEL_KIND k) { lbl.kind = k; }
01775
01776 inline BOOL
01777 LABEL_target_of_goto_outer_block (const LABEL& l)
01778 { return l.flags & LABEL_TARGET_OF_GOTO_OUTER_BLOCK;}
01779 inline void
01780 Set_LABEL_target_of_goto_outer_block (LABEL& l)
01781 { l.flags |= LABEL_TARGET_OF_GOTO_OUTER_BLOCK; }
01782 inline void
01783 Clear_LABEL_target_of_goto_outer_block (LABEL& l)
01784 { l.flags &= ~LABEL_TARGET_OF_GOTO_OUTER_BLOCK; }
01785
01786 inline BOOL
01787 LABEL_addr_saved (const LABEL& l) { return l.flags & LABEL_ADDR_SAVED;}
01788 inline void
01789 Set_LABEL_addr_saved (LABEL& l) { l.flags |= LABEL_ADDR_SAVED; }
01790 inline void
01791 Clear_LABEL_addr_saved (LABEL& l) { l.flags &= ~LABEL_ADDR_SAVED; }
01792
01793 inline BOOL
01794 LABEL_addr_passed (const LABEL& l) { return l.flags & LABEL_ADDR_PASSED;}
01795 inline void
01796 Set_LABEL_addr_passed (LABEL& l) { l.flags |= LABEL_ADDR_PASSED; }
01797 inline void
01798 Clear_LABEL_addr_passed (LABEL& l) { l.flags &= ~LABEL_ADDR_PASSED; }
01799
01800
01801
01802
01803
01804
01805
01806 inline STR_IDX
01807 PREG_name_idx (const PREG& preg) { return preg.name_idx; }
01808 inline void
01809 Set_PREG_name_idx (PREG& preg, STR_IDX s) { preg.name_idx = s; }
01810 inline void
01811 Set_PREG_name (PREG &preg, const char *const name)
01812 { Set_PREG_name_idx(preg, Save_Str(name)); }
01813 inline char *
01814 PREG_name (const PREG& preg) { return &Str_Table[preg.name_idx]; }
01815
01816
01817
01818
01819
01820
01821
01822 inline ST_IDX
01823 ST_ATTR_st_idx (const ST_ATTR& st_attr) { return st_attr.st_idx; }
01824 inline void
01825 Set_ST_ATTR_st_idx (ST_ATTR& st_attr, ST_IDX st) { st_attr.st_idx = st; }
01826 inline ST_ATTR_KIND
01827 ST_ATTR_kind (const ST_ATTR& st_attr) { return st_attr.kind; }
01828 inline PREG_NUM
01829 ST_ATTR_reg_id (const ST_ATTR& st_attr)
01830 {
01831 Is_True (st_attr.kind == ST_ATTR_DEDICATED_REGISTER,
01832 ("attribute is not for a dedicated register"));
01833 return st_attr.Get_reg_id();
01834 }
01835 inline void
01836 Set_ST_ATTR_reg_id (ST_ATTR& st_attr, PREG_NUM id)
01837 {
01838 st_attr.kind = ST_ATTR_DEDICATED_REGISTER;
01839 st_attr.Set_reg_id (id);
01840 }
01841 inline STR_IDX
01842 ST_ATTR_section_name (const ST_ATTR& st_attr)
01843 {
01844 Is_True (st_attr.kind == ST_ATTR_SECTION_NAME,
01845 ("attribute is not for a section name"));
01846 return st_attr.Get_section_name ();
01847 }
01848 inline void
01849 Set_ST_ATTR_section_name (ST_ATTR& st_attr, STR_IDX name)
01850 {
01851 st_attr.kind = ST_ATTR_SECTION_NAME;
01852 st_attr.Set_section_name (name);
01853 }
01854
01855
01856
01857
01858
01859 inline UINT8
01860 FILE_INFO_gp_group (const FILE_INFO& f) { return f.gp_group; }
01861 inline void
01862 Set_FILE_INFO_gp_group (FILE_INFO& f, mUINT8 grp) { f.gp_group = grp; }
01863
01864 inline BOOL
01865 FILE_INFO_ipa (const FILE_INFO& f) { return f.flags & FI_IPA; }
01866 inline void
01867 Set_FILE_INFO_ipa (FILE_INFO& f) { f.flags |= FI_IPA; }
01868 inline void
01869 Clear_FILE_INFO_ipa (FILE_INFO& f) { f.flags &= ~FI_IPA; }
01870
01871 inline BOOL
01872 FILE_INFO_needs_lno (const FILE_INFO& f){ return f.flags & FI_NEEDS_LNO; }
01873 inline void
01874 Set_FILE_INFO_needs_lno (FILE_INFO& f) { f.flags |= FI_NEEDS_LNO; }
01875 inline void
01876 Clear_FILE_INFO_needs_lno (FILE_INFO& f){ f.flags &= ~FI_NEEDS_LNO; }
01877
01878 inline BOOL
01879 FILE_INFO_has_inlines (const FILE_INFO& f) { return f.flags & FI_HAS_INLINES; }
01880 inline void
01881 Set_FILE_INFO_has_inlines (FILE_INFO& f) { f.flags |= FI_HAS_INLINES; }
01882 inline void
01883 Clear_FILE_INFO_has_inlines (FILE_INFO& f) { f.flags &= ~FI_HAS_INLINES; }
01884
01885 inline BOOL
01886 FILE_INFO_has_mp (const FILE_INFO& f){ return f.flags & FI_HAS_MP; }
01887 inline void
01888 Set_FILE_INFO_has_mp (FILE_INFO& f) { f.flags |= FI_HAS_MP; }
01889 inline void
01890 Clear_FILE_INFO_has_mp (FILE_INFO& f){ f.flags &= ~FI_HAS_MP; }
01891
01892
01893
01894
01895
01896
01897
01898 #if 0
01899 inline ST&
01900 SYMBOL_TABLE::operator[] (ST_IDX idx)
01901 {
01902 SYMTAB_IDX level = ST_IDX_level (idx);
01903 UINT32 index = ST_IDX_index (idx);
01904 return Scope_tab[level].st_tab->Entry (index);
01905 }
01906
01907 inline ST&
01908 SYMBOL_TABLE::operator() (SYMTAB_IDX level, UINT32 index) {
01909 Is_True (Scope_tab[level].st_tab != NULL, ("Uninitialized ST_TAB"));
01910 return Scope_tab[level].st_tab->Entry (index);
01911 }
01912
01913
01914 inline INITO&
01915 INITO_TABLE::operator[] (INITO_IDX idx) {
01916 SYMTAB_IDX level = INITO_IDX_level (idx);
01917 UINT32 index = INITO_IDX_index (idx);
01918 return Scope_tab[level].inito_tab->Entry (index);
01919 }
01920
01921 inline INITO&
01922 INITO_TABLE::operator() (SYMTAB_IDX level, UINT32 index) {
01923 Is_True (Scope_tab[level].inito_tab != NULL, ("Uninitialized INITO_TAB"));
01924 return Scope_tab[level].inito_tab->Entry (index);
01925 }
01926 inline LABEL&
01927 LABEL_TABLE::operator[] (LABEL_IDX idx) {
01928 return Scope_tab[CURRENT_SYMTAB].label_tab->Entry (idx);
01929 }
01930
01931 inline LABEL&
01932 LABEL_TABLE::operator() (SYMTAB_IDX level, LABEL_IDX idx) {
01933 return Scope_tab[level].label_tab->Entry (idx);
01934 }
01935 #endif
01936
01937 inline PREG&
01938 PREG_TABLE::operator[] (PREG_IDX idx) {
01939 return Scope_tab[CURRENT_SYMTAB].preg_tab->Entry (idx);
01940 }
01941
01942 inline PREG&
01943 PREG_TABLE::operator() (SYMTAB_IDX level, PREG_IDX idx) {
01944 return Scope_tab[level].preg_tab->Entry (idx);
01945 }
01946
01947 inline ST_ATTR&
01948 ST_ATTR_TABLE::operator[] (ST_ATTR_IDX idx) {
01949 return Scope_tab[CURRENT_SYMTAB].st_attr_tab->Entry (idx);
01950 }
01951
01952 inline ST_ATTR&
01953 ST_ATTR_TABLE::operator() (SYMTAB_IDX level, ST_ATTR_IDX idx) {
01954 return Scope_tab[level].st_attr_tab->Entry (idx);
01955 }
01956
01957 inline TY&
01958 TYPE_TABLE::operator[] (TY_IDX idx) {
01959 return Ty_tab[TY_IDX_index(idx)];
01960 }
01961
01962 inline TY_TAB*
01963 TYPE_TABLE::operator& () {
01964 return &Ty_tab;
01965 }
01966
01967 #endif // symtab_access_INCLUDED
