/* Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. This program is free software; you can redistribute it and/or modify it under the terms of version 2 of the GNU General Public License as published by the Free Software Foundation. This program is distributed in the hope that it would be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Further, this software is distributed without any warranty that it is free of the rightful claim of any third person regarding infringement or the like. Any license provided herein, whether implied or otherwise, applies only to this software file. Patent licenses, if any, provided herein do not apply to combinations of this program with other software, or any other product whatsoever. You should have received a copy of the GNU General Public License along with this program; if not, write the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA. Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, Mountain View, CA 94043, or: http://www.sgi.com For further information regarding this notice, see: http://oss.sgi.com/projects/GenInfo/NoticeExplan */ /* -*-Mode: c++;-*- (Tell emacs to use c++ mode) */ // access functions for various symbol tables // this file contains functions for direct read/write to individual field // of each symbol table data structure. Access functions that do not // directly return the value of a field in a struct should be placed in // symtab.h or symtab_util.h. // TODO: This file should really be generated automatically from // symtab_defs.h #ifndef symtab_access_INCLUDED #define symtab_access_INCLUDED //---------------------------------------------------------------------- // unique handles for each structure //---------------------------------------------------------------------- class FLD_HANDLE { private: FLD* entry; FLD_IDX idx; public: FLD_HANDLE () : entry (NULL), idx (0) {} explicit FLD_HANDLE (FLD_IDX fld_idx) : entry (fld_idx == 0 ? NULL : &Fld_Table[fld_idx]), idx (fld_idx) {} FLD_HANDLE (FLD* fld, FLD_IDX fld_idx) : entry (fld), idx (fld_idx) { Is_True ((fld_idx == 0 && fld == NULL) || (&Fld_Table[fld_idx] == fld), ("Inconsistent FLD* and FLD_IDX")); } FLD_HANDLE (const FLD_HANDLE& fld) : entry (fld.entry), idx (fld.idx) {} FLD_HANDLE (const FLD_ITER& iter) : entry (&(*iter)), idx (iter.Index()) {} FLD* Entry () const { return entry; } FLD_IDX Idx () const { return idx; } BOOL operator== (const FLD_HANDLE& fld) const { return idx == fld.idx; } BOOL operator!= (const FLD_HANDLE& fld) const { return idx != fld.idx; } BOOL Is_Null () const { return idx == 0; } }; class ARB_HANDLE { private: ARB* entry; ARB_IDX idx; public: ARB_HANDLE () : entry (NULL), idx (0) {} explicit ARB_HANDLE (ARB_IDX arb_idx) : entry (arb_idx == 0 ? NULL : &Arb_Table[arb_idx]), idx (arb_idx) {} ARB_HANDLE (ARB* arb, ARB_IDX arb_idx) : entry (arb), idx (arb_idx) { Is_True ((arb_idx == 0 && arb == NULL) || (&Arb_Table[arb_idx] == arb), ("Inconsistent ARB* and ARB_IDX")); } ARB_HANDLE (const ARB_HANDLE& arb) : entry (arb.entry), idx (arb.idx) {} ARB_HANDLE (const ARB_ITER& iter) : entry (&(*iter)), idx (iter.Index()) {} ARB* Entry () const { return entry; } ARB_IDX Idx () const { return idx; } BOOL operator== (const ARB_HANDLE& arb) const { return idx == arb.idx; } ARB_HANDLE operator[] (INT32 i) { return ARB_HANDLE(idx + i); } BOOL Is_Null () const { return idx == 0; } }; //---------------------------------------------------------------------- // access functions for ST //---------------------------------------------------------------------- inline STR_IDX ST_name_idx (const ST& s) { return s.u1.name_idx; } inline void Set_ST_name_idx (ST& s, STR_IDX idx) { s.u1.name_idx = idx; } inline char * ST_name (const ST& s) { return &Str_Table[ST_name_idx (s)]; } inline TCON_IDX ST_tcon (const ST& s) { return s.u1.tcon; } inline void Set_ST_tcon (ST& s, TCON_IDX tcon) { s.u1.tcon = tcon; } inline ST_CLASS ST_sym_class (const ST& s) { return s.sym_class; } inline void Set_ST_sym_class (ST& s, ST_CLASS c) { s.sym_class = c; } inline ST_SCLASS ST_storage_class (const ST& s) { return s.storage_class; } inline void Set_ST_storage_class (ST& s, ST_SCLASS sc) { s.storage_class = sc; } inline ST_SCLASS ST_sclass (const ST& s) { return s.storage_class; } inline void Set_ST_sclass (ST& s, ST_SCLASS sc) { s.storage_class = sc; } inline ST_EXPORT ST_export (const ST& s) { return s.export_class; } inline void Set_ST_export (ST& s, ST_EXPORT eclass) { s.export_class = eclass; } inline TY_IDX ST_type (const ST& s) { #ifdef Is_True_On switch (s.sym_class) { default: Fail_FmtAssertion ("Invalid argument for ST_type ()"); case CLASS_VAR: case CLASS_CONST: case CLASS_PREG: case CLASS_NAME: return s.u2.type; } #else return s.u2.type; #endif // Is_True_On } inline void Set_ST_type (ST& s, TY_IDX t) { #ifdef Is_True_On switch (s.sym_class) { default: Fail_FmtAssertion ("Invalid argument for ST_type ()"); case CLASS_VAR: case CLASS_CONST: case CLASS_PREG: case CLASS_NAME: s.u2.type = t; } #else s.u2.type = t; #endif // Is_True_On } inline PU_IDX ST_pu (const ST& s) { Is_True (s.sym_class == CLASS_FUNC || (s.sym_class == CLASS_NAME && (s.flags & ST_ASM_FUNCTION_ST)), ("Invalid argument for ST_pu")); return s.u2.pu; } inline void Set_ST_pu (ST& s, PU_IDX pu) { Is_True (s.sym_class == CLASS_FUNC || (s.sym_class == CLASS_NAME && s.flags & ST_ASM_FUNCTION_ST), ("Invalid argument for ST_pu")); s.u2.pu = pu; } inline BLK_IDX ST_blk (const ST& s) { Is_True (s.sym_class == CLASS_BLOCK, ("Invalid argument for ST_blk")); return s.u2.blk; } inline void Set_ST_blk (ST& s, BLK_IDX b) { Is_True (s.sym_class == CLASS_BLOCK, ("Invalid argument for ST_blk")); s.u2.blk = b; } inline ST_IDX ST_st_idx (const ST& s) { return s.st_idx; } inline void Set_ST_st_idx (ST& s, ST_IDX idx) { s.st_idx = idx; } inline ST* ST_ptr (ST_IDX idx) { return &(St_Table[idx]); } inline UINT64 ST_ofst (const ST& s) { return s.offset; } inline void Set_ST_ofst (ST& s, UINT64 offset) { s.offset = offset; } //---------------------------------------------------------------------- // ST flags //---------------------------------------------------------------------- inline BOOL ST_is_weak_symbol (const ST& s) { return s.flags & ST_IS_WEAK_SYMBOL;} inline void Set_ST_is_weak_symbol (ST& s) { s.flags |= ST_IS_WEAK_SYMBOL; } inline void Clear_ST_is_weak_symbol (ST& s) { s.flags &= ~ST_IS_WEAK_SYMBOL; } inline BOOL ST_is_split_common (const ST& s) { return s.flags & ST_IS_SPLIT_COMMON;} inline void Set_ST_is_split_common (ST& s) { s.flags |= ST_IS_SPLIT_COMMON; } inline void Clear_ST_is_split_common (ST& s) { s.flags &= ~ST_IS_SPLIT_COMMON; } inline ST_IDX ST_base_idx (const ST& s) { if (ST_is_split_common (s)) return s.st_idx; else if (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN) return s.st_idx; else return s.base_idx; } inline void Set_ST_base_idx (ST& s, ST_IDX base) { if (ST_is_split_common (s)) DevWarn ("Shouldn't set base when split"); else if (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN) DevWarn ("Shouldn't set base when weak"); s.base_idx = base; } inline ST_IDX ST_strong_idx (const ST& s) { Is_True (ST_is_weak_symbol (s), ("Expecting a weak symbol")); return (ST_sclass (s) == SCLASS_EXTERN) ? s.base_idx : s.st_idx; } inline void Set_ST_strong_idx (ST& s, ST_IDX base) { Is_True (ST_is_weak_symbol (s) && ST_sclass(s) == SCLASS_EXTERN, ("Expecting an external weak symbol")); s.base_idx = base; } inline ST_IDX ST_full_idx (const ST& s) { Is_True (ST_is_split_common (s), ("Expecting a splict common")); return s.base_idx; } inline void Set_ST_full_idx (ST& s, ST_IDX base) { Is_True (ST_is_split_common (s), ("Expecting a splict common")); s.base_idx = base; } inline BOOL ST_is_not_used (const ST& s) { return s.flags & ST_IS_NOT_USED;} inline void Set_ST_is_not_used (ST& s) { s.flags |= ST_IS_NOT_USED; } inline void Clear_ST_is_not_used (ST& s) { s.flags &= ~ST_IS_NOT_USED; } inline BOOL ST_is_initialized (const ST& s) { return s.flags & ST_IS_INITIALIZED;} inline void Set_ST_is_initialized (ST& s) { s.flags |= ST_IS_INITIALIZED; } inline void Clear_ST_is_initialized (ST& s) { s.flags &= ~ST_IS_INITIALIZED; } inline BOOL ST_is_return_var (const ST& s) { return s.flags & ST_IS_RETURN_VAR;} inline void Set_ST_is_return_var (ST& s) { s.flags |= ST_IS_RETURN_VAR; } inline void Clear_ST_is_return_var (ST& s) { s.flags &= ~ST_IS_RETURN_VAR; } inline BOOL ST_is_value_parm (const ST& s) { return s.flags & ST_IS_VALUE_PARM;} inline void Set_ST_is_value_parm (ST& s) { s.flags |= ST_IS_VALUE_PARM; } inline void Clear_ST_is_value_parm (ST& s) { s.flags &= ~ST_IS_VALUE_PARM; } inline BOOL ST_promote_parm (const ST& s) { return s.flags & ST_PROMOTE_PARM;} inline void Set_ST_promote_parm (ST& s) { s.flags |= ST_PROMOTE_PARM; } inline void Clear_ST_promote_parm (ST& s) { s.flags &= ~ST_PROMOTE_PARM; } inline BOOL ST_keep_name_w2f (const ST& s) { return s.flags & ST_KEEP_NAME_W2F;} inline void Set_ST_keep_name_w2f (ST& s) { s.flags |= ST_KEEP_NAME_W2F; } inline void Clear_ST_keep_name_w2f (ST& s) { s.flags &= ~ST_KEEP_NAME_W2F; } inline BOOL ST_is_datapool (const ST& s) { return s.flags & ST_IS_DATAPOOL;} inline void Set_ST_is_datapool (ST& s) { s.flags |= ST_IS_DATAPOOL; } inline void Clear_ST_is_datapool (ST& s) { s.flags &= ~ST_IS_DATAPOOL; } inline BOOL ST_is_reshaped (const ST& s) { return s.flags & ST_IS_RESHAPED;} inline void Set_ST_is_reshaped (ST& s) { s.flags |= ST_IS_RESHAPED; } inline void Clear_ST_is_reshaped (ST& s) { s.flags &= ~ST_IS_RESHAPED; } inline BOOL ST_emit_symbol (const ST& s) { return s.flags & ST_EMIT_SYMBOL;} inline void Set_ST_emit_symbol (ST& s) { s.flags |= ST_EMIT_SYMBOL; } inline void Clear_ST_emit_symbol (ST& s) { s.flags &= ~ST_EMIT_SYMBOL; } inline BOOL ST_has_nested_ref (const ST& s) { return s.flags & ST_HAS_NESTED_REF;} inline void Set_ST_has_nested_ref (ST& s) { s.flags |= ST_HAS_NESTED_REF; } inline void Clear_ST_has_nested_ref (ST& s) { s.flags &= ~ST_HAS_NESTED_REF; } inline BOOL ST_init_value_zero (const ST& s) { return s.flags & ST_INIT_VALUE_ZERO;} inline void Set_ST_init_value_zero (ST& s) { s.flags |= ST_INIT_VALUE_ZERO; } inline void Clear_ST_init_value_zero (ST& s) { s.flags &= ~ST_INIT_VALUE_ZERO; } inline BOOL ST_gprel (const ST& s) { return s.flags & ST_GPREL;} inline void Set_ST_gprel (ST& s) { s.flags |= ST_GPREL; } inline void Clear_ST_gprel (ST& s) { s.flags &= ~ST_GPREL; } inline BOOL ST_not_gprel (const ST& s) { return s.flags & ST_NOT_GPREL;} inline void Set_ST_not_gprel (ST& s) { s.flags |= ST_NOT_GPREL; } inline void Clear_ST_not_gprel (ST& s) { s.flags &= ~ST_NOT_GPREL; } inline BOOL ST_is_namelist (const ST& s) { return s.flags & ST_IS_NAMELIST;} inline void Set_ST_is_namelist (ST& s) { s.flags |= ST_IS_NAMELIST; } inline void Clear_ST_is_namelist (ST& s) { s.flags &= ~ST_IS_NAMELIST; } inline BOOL ST_is_f90_target (const ST& s) { return s.flags & ST_IS_F90_TARGET;} inline void Set_ST_is_f90_target (ST& s) { s.flags |= ST_IS_F90_TARGET; } inline void Clear_ST_is_f90_target (ST& s) { s.flags &= ~ST_IS_F90_TARGET; } inline BOOL ST_declared_static (const ST& s) { return s.flags & ST_DECLARED_STATIC;} inline void Set_ST_declared_static (ST& s) { s.flags |= ST_DECLARED_STATIC; } inline void Clear_ST_declared_static (ST& s) { s.flags &= ~ST_DECLARED_STATIC; } inline BOOL ST_is_equivalenced (const ST& s) { return s.flags & ST_IS_EQUIVALENCED;} inline void Set_ST_is_equivalenced (ST& s) { s.flags |= ST_IS_EQUIVALENCED; } inline void Clear_ST_is_equivalenced (ST& s) { s.flags &= ~ST_IS_EQUIVALENCED; } inline BOOL ST_is_fill_align (const ST& s) { return s.flags & ST_IS_FILL_ALIGN;} inline void Set_ST_is_fill_align (ST& s) { s.flags |= ST_IS_FILL_ALIGN; } inline void Clear_ST_is_fill_align (ST& s) { s.flags &= ~ST_IS_FILL_ALIGN; } inline BOOL ST_is_optional_argument (const ST& s) { return s.flags & ST_IS_OPTIONAL_ARGUMENT;} inline void Set_ST_is_optional_argument (ST& s) { s.flags |= ST_IS_OPTIONAL_ARGUMENT; } inline void Clear_ST_is_optional_argument (ST& s) { s.flags &= ~ST_IS_OPTIONAL_ARGUMENT; } inline BOOL ST_is_temp_var (const ST& s) { return s.flags & ST_IS_TEMP_VAR;} inline void Set_ST_is_temp_var (ST& s) { s.flags |= ST_IS_TEMP_VAR; } inline void Clear_ST_is_temp_var (ST& s) { s.flags &= ~ST_IS_TEMP_VAR; } inline BOOL ST_is_const_var (const ST& s) { return s.flags & ST_IS_CONST_VAR;} inline void Set_ST_is_const_var (ST& s) { s.flags |= ST_IS_CONST_VAR; } inline void Clear_ST_is_const_var (ST& s) { s.flags &= ~ST_IS_CONST_VAR; } inline BOOL ST_addr_saved (const ST& s) { return s.flags & ST_ADDR_SAVED;} inline void Set_ST_addr_saved (ST& s) { s.flags |= ST_ADDR_SAVED; } inline void Clear_ST_addr_saved (ST& s) { s.flags &= ~ST_ADDR_SAVED; } inline BOOL ST_addr_passed (const ST& s) { return s.flags & ST_ADDR_PASSED;} inline void Set_ST_addr_passed (ST& s) { s.flags |= ST_ADDR_PASSED; } inline void Clear_ST_addr_passed (ST& s) { s.flags &= ~ST_ADDR_PASSED; } inline BOOL ST_is_thread_private (const ST& s) { return s.flags & ST_IS_THREAD_PRIVATE;} inline void Set_ST_is_thread_private (ST& s) { s.flags |= ST_IS_THREAD_PRIVATE; } inline void Clear_ST_is_thread_private (ST& s) { s.flags &= ~ST_IS_THREAD_PRIVATE; } inline BOOL ST_pt_to_unique_mem (const ST& s) { return s.flags & ST_PT_TO_UNIQUE_MEM;} inline void Set_ST_pt_to_unique_mem (ST& s) { s.flags |= ST_PT_TO_UNIQUE_MEM; } inline void Clear_ST_pt_to_unique_mem (ST& s) { s.flags &= ~ST_PT_TO_UNIQUE_MEM; } inline BOOL ST_pt_to_compiler_generated_mem (const ST& s) { return s.flags & ST_PT_TO_COMPILER_GENERATED_MEM;} inline void Set_ST_pt_to_compiler_generated_mem (ST& s) { s.flags |= ST_PT_TO_COMPILER_GENERATED_MEM; } inline void Clear_ST_pt_to_compiler_generated_mem (ST& s) { s.flags &= ~ST_PT_TO_COMPILER_GENERATED_MEM; } inline BOOL ST_is_shared_auto (const ST& s) { return s.flags & ST_IS_SHARED_AUTO;} inline void Set_ST_is_shared_auto (ST& s) { s.flags |= ST_IS_SHARED_AUTO; } inline void Clear_ST_is_shared_auto (ST& s) { s.flags &= ~ST_IS_SHARED_AUTO; } inline BOOL ST_assigned_to_dedicated_preg (const ST& s) { return s.flags & ST_ASSIGNED_TO_DEDICATED_PREG; } inline void Set_ST_assigned_to_dedicated_preg (ST& s) { s.flags |= ST_ASSIGNED_TO_DEDICATED_PREG; } inline void Clear_ST_assigned_to_dedicated_preg (ST& s) { s.flags &= ~ST_ASSIGNED_TO_DEDICATED_PREG; } inline BOOL ST_asm_function_st(const ST& s) { return s.flags & ST_ASM_FUNCTION_ST; } inline void Set_ST_asm_function_st(ST &s) { s.flags |= ST_ASM_FUNCTION_ST; } inline void Clear_ST_asm_function_st(ST &s) { s.flags &= ~ST_ASM_FUNCTION_ST; } // TODO: should probably replace all ref params with ST* inline BOOL ST_has_named_section (const ST* s) { return s->flags & ST_HAS_NAMED_SECTION; } inline void Set_ST_has_named_section (ST* s) { s->flags |= ST_HAS_NAMED_SECTION; } inline void Clear_ST_has_named_section (ST* s) { s->flags &= ~ST_HAS_NAMED_SECTION; } //---------------------------------------------------------------------- // access functions for PU //---------------------------------------------------------------------- inline TARGET_INFO_IDX PU_target_idx (const PU& pu) { return pu.target_idx; } inline void Set_PU_target_idx (PU& pu, TARGET_INFO_IDX idx) { pu.target_idx = idx; } inline TY_IDX PU_prototype (const PU& pu) { return pu.prototype; } inline void Set_PU_prototype (PU& pu, TY_IDX ty) { pu.prototype = ty; } inline UINT8 PU_gp_group (const PU& pu) { return pu.gp_group; } inline void Set_PU_gp_group (PU& pu, mUINT8 grp) { pu.gp_group = grp; } inline SYMTAB_IDX PU_lexical_level (const PU& pu) { return pu.lexical_level; } inline void Set_PU_lexical_level (PU& pu, SYMTAB_IDX l) { pu.lexical_level = l; } //---------------------------------------------------------------------- // PU flags //---------------------------------------------------------------------- inline BOOL PU_is_pure (const PU& pu) { return pu.flags & PU_IS_PURE; } inline void Set_PU_is_pure (PU& pu) { pu.flags |= PU_IS_PURE; } inline void Clear_PU_is_pure (PU& pu) { pu.flags &= ~PU_IS_PURE; } inline BOOL PU_no_side_effects (const PU& pu) { return pu.flags & PU_NO_SIDE_EFFECTS; } inline void Set_PU_no_side_effects (PU& pu) { pu.flags |= PU_NO_SIDE_EFFECTS; } inline void Clear_PU_no_side_effects (PU& pu) { pu.flags &= ~PU_NO_SIDE_EFFECTS; } inline BOOL PU_is_inline_function (const PU& pu) { return pu.flags & PU_IS_INLINE_FUNCTION; } inline void Set_PU_is_inline_function (PU& pu) { pu.flags |= PU_IS_INLINE_FUNCTION; } inline void Clear_PU_is_inline_function (PU& pu) { pu.flags &= ~PU_IS_INLINE_FUNCTION; } inline BOOL PU_no_inline (const PU& pu) { return pu.flags & PU_NO_INLINE; } inline void Set_PU_no_inline (PU& pu) { pu.flags |= PU_NO_INLINE; } inline void Clear_PU_no_inline (PU& pu) { pu.flags &= ~PU_NO_INLINE; } inline BOOL PU_must_inline (const PU& pu) { return pu.flags & PU_MUST_INLINE; } inline void Set_PU_must_inline (PU& pu) { pu.flags |= PU_MUST_INLINE; } inline void Clear_PU_must_inline (PU& pu) { pu.flags &= ~PU_MUST_INLINE; } inline BOOL PU_no_delete (const PU& pu) { return pu.flags & PU_NO_DELETE; } inline void Set_PU_no_delete (PU& pu) { pu.flags |= PU_NO_DELETE; } inline void Clear_PU_no_delete (PU& pu) { pu.flags &= ~PU_NO_DELETE; } inline BOOL PU_has_exc_scopes (const PU& pu) { return pu.flags & PU_HAS_EXC_SCOPES; } inline void Set_PU_has_exc_scopes (PU& pu) { pu.flags |= PU_HAS_EXC_SCOPES; } inline void Clear_PU_has_exc_scopes (PU& pu) { pu.flags &= ~PU_HAS_EXC_SCOPES; } inline BOOL PU_is_nested_func (const PU& pu) { return pu.flags & PU_IS_NESTED_FUNC; } inline void Set_PU_is_nested_func (PU& pu) { pu.flags |= PU_IS_NESTED_FUNC; } inline void Clear_PU_is_nested_func (PU& pu) { pu.flags &= ~PU_IS_NESTED_FUNC; } inline BOOL PU_has_non_mangled_call (const PU& pu) { return pu.flags & PU_HAS_NON_MANGLED_CALL; } inline void Set_PU_has_non_mangled_call (PU& pu) { pu.flags |= PU_HAS_NON_MANGLED_CALL; } inline void Clear_PU_has_non_mangled_call (PU& pu) { pu.flags &= ~PU_HAS_NON_MANGLED_CALL; } inline BOOL PU_args_aliased (const PU& pu) { return pu.flags & PU_ARGS_ALIASED; } inline void Set_PU_args_aliased (PU& pu) { pu.flags |= PU_ARGS_ALIASED; } inline void Clear_PU_args_aliased (PU& pu) { pu.flags &= ~PU_ARGS_ALIASED; } inline BOOL PU_needs_fill_align_lowering (const PU& pu) { return pu.flags & PU_NEEDS_FILL_ALIGN_LOWERING; } inline void Set_PU_needs_fill_align_lowering (PU& pu) { pu.flags |= PU_NEEDS_FILL_ALIGN_LOWERING; } inline void Clear_PU_needs_fill_align_lowering (PU& pu) { pu.flags &= ~PU_NEEDS_FILL_ALIGN_LOWERING; } inline BOOL PU_needs_t9 (const PU& pu) { return pu.flags & PU_NEEDS_T9; } inline void Set_PU_needs_t9 (PU& pu) { pu.flags |= PU_NEEDS_T9; } inline void Clear_PU_needs_t9 (PU& pu) { pu.flags &= ~PU_NEEDS_T9; } inline BOOL PU_has_very_high_whirl (const PU& pu) { return pu.flags & PU_HAS_VERY_HIGH_WHIRL; } inline void Set_PU_has_very_high_whirl (PU& pu) { pu.flags |= PU_HAS_VERY_HIGH_WHIRL; } inline void Clear_PU_has_very_high_whirl (PU& pu) { pu.flags &= ~PU_HAS_VERY_HIGH_WHIRL; } inline BOOL PU_has_altentry (const PU& pu) { return pu.flags & PU_HAS_ALTENTRY; } inline void Set_PU_has_altentry (PU& pu) { pu.flags |= PU_HAS_ALTENTRY; } inline void Clear_PU_has_altentry (PU& pu) { pu.flags &= ~PU_HAS_ALTENTRY; } inline BOOL PU_recursive (const PU& pu) { return pu.flags & PU_RECURSIVE; } inline void Set_PU_recursive (PU& pu) { pu.flags |= PU_RECURSIVE; } inline void Clear_PU_recursive (PU& pu) { pu.flags &= ~PU_RECURSIVE; } inline BOOL PU_is_mainpu (const PU& pu) { return pu.flags & PU_IS_MAINPU; } inline void Set_PU_is_mainpu (PU& pu) { pu.flags |= PU_IS_MAINPU; } inline void Clear_PU_is_mainpu (PU& pu) { pu.flags &= ~PU_IS_MAINPU; } inline BOOL PU_uplevel (const PU& pu) { return pu.flags & PU_UPLEVEL; } inline void Set_PU_uplevel (PU& pu) { pu.flags |= PU_UPLEVEL; } inline void Clear_PU_uplevel (PU& pu) { pu.flags &= ~PU_UPLEVEL; } inline BOOL PU_mp_needs_lno (const PU& pu) { return pu.flags & PU_MP_NEEDS_LNO; } inline void Set_PU_mp_needs_lno (PU& pu) { pu.flags |= PU_MP_NEEDS_LNO; } inline void Clear_PU_mp_needs_lno (PU& pu) { pu.flags &= ~PU_MP_NEEDS_LNO; } inline BOOL PU_has_alloca (const PU& pu) { return pu.flags & PU_HAS_ALLOCA; } inline void Set_PU_has_alloca (PU& pu) { pu.flags |= PU_HAS_ALLOCA; } inline void Clear_PU_has_alloca (PU& pu) { pu.flags &= ~PU_HAS_ALLOCA; } inline BOOL PU_in_elf_section (const PU& pu) { return pu.flags & PU_IN_ELF_SECTION; } inline void Set_PU_in_elf_section (PU& pu) { pu.flags |= PU_IN_ELF_SECTION; } inline void Clear_PU_in_elf_section (PU& pu) { pu.flags &= ~PU_IN_ELF_SECTION; } inline BOOL PU_has_mp (const PU& pu) { return pu.flags & PU_HAS_MP; } inline void Set_PU_has_mp (PU& pu) { pu.flags |= PU_HAS_MP; } inline void Clear_PU_has_mp (PU& pu) { pu.flags &= ~PU_HAS_MP; } inline BOOL PU_mp (const PU& pu) { return pu.flags & PU_MP; } inline void Set_PU_mp (PU& pu) { pu.flags |= PU_MP; } inline void Clear_PU_mp (PU& pu) { pu.flags &= ~PU_MP; } inline BOOL PU_has_namelist (const PU& pu) { return pu.flags & PU_HAS_NAMELIST; } inline void Set_PU_has_namelist (PU& pu) { pu.flags |= PU_HAS_NAMELIST; } inline void Clear_PU_has_namelist (PU& pu) { pu.flags &= ~PU_HAS_NAMELIST; } inline BOOL PU_has_return_address (const PU& pu) { return pu.flags & PU_HAS_RETURN_ADDRESS; } inline void Set_PU_has_return_address (PU& pu) { pu.flags |= PU_HAS_RETURN_ADDRESS; } inline void Clear_PU_has_return_address (PU& pu) { pu.flags &= ~PU_HAS_RETURN_ADDRESS; } inline BOOL PU_has_region (const PU& pu) { return pu.flags & PU_HAS_REGION; } inline void Set_PU_has_region (PU& pu) { pu.flags |= PU_HAS_REGION; } inline void Clear_PU_has_region (PU& pu) { pu.flags &= ~PU_HAS_REGION; } inline BOOL PU_has_inlines (const PU& pu) { return pu.flags & PU_HAS_INLINES; } inline void Set_PU_has_inlines (PU& pu) { pu.flags |= PU_HAS_INLINES; } inline void Clear_PU_has_inlines (PU& pu) { pu.flags &= ~PU_HAS_INLINES; } inline BOOL PU_calls_setjmp (const PU& pu) { return pu.flags & PU_CALLS_SETJMP; } inline void Set_PU_calls_setjmp (PU& pu) { pu.flags |= PU_CALLS_SETJMP; } inline void Clear_PU_calls_setjmp (PU& pu) { pu.flags &= ~PU_CALLS_SETJMP; } inline BOOL PU_calls_longjmp (const PU& pu) { return pu.flags & PU_CALLS_LONGJMP; } inline void Set_PU_calls_longjmp (PU& pu) { pu.flags |= PU_CALLS_LONGJMP; } inline void Clear_PU_calls_longjmp (PU& pu) { pu.flags &= ~PU_CALLS_LONGJMP; } inline BOOL PU_ipa_addr_analysis (const PU& pu) { return pu.flags & PU_IPA_ADDR_ANALYSIS; } inline void Set_PU_ipa_addr_analysis (PU& pu) { pu.flags |= PU_IPA_ADDR_ANALYSIS; } inline void Clear_PU_ipa_addr_analysis (PU& pu) { pu.flags &= ~PU_IPA_ADDR_ANALYSIS; } inline BOOL PU_smart_addr_analysis (const PU& pu) { return pu.flags & PU_SMART_ADDR_ANALYSIS; } inline void Set_PU_smart_addr_analysis (PU& pu) { pu.flags |= PU_SMART_ADDR_ANALYSIS; } inline void Clear_PU_smart_addr_analysis (PU& pu) { pu.flags &= ~PU_SMART_ADDR_ANALYSIS; } inline BOOL PU_has_global_pragmas (const PU& pu) { return pu.flags & PU_HAS_GLOBAL_PRAGMAS; } inline void Set_PU_has_global_pragmas (PU& pu) { pu.flags |= PU_HAS_GLOBAL_PRAGMAS; } inline void Clear_PU_has_global_pragmas (PU& pu) { pu.flags &= ~PU_HAS_GLOBAL_PRAGMAS; } inline BOOL PU_has_user_alloca (const PU& pu) { return (pu.flags & PU_HAS_USER_ALLOCA) != 0; } inline void Set_PU_has_user_alloca (PU& pu) { pu.flags |= PU_HAS_USER_ALLOCA; } inline void Clear_PU_has_user_alloca (PU& pu) { pu.flags &= ~PU_HAS_USER_ALLOCA; } inline BOOL PU_has_unknown_control_flow (const PU& pu) { return (pu.flags & PU_HAS_UNKNOWN_CONTROL_FLOW) != 0; } inline void Set_PU_has_unknown_control_flow (PU& pu) { pu.flags |= PU_HAS_UNKNOWN_CONTROL_FLOW; } inline void Clear_PU_has_unknown_control_flow (PU& pu) { pu.flags &= ~PU_HAS_UNKNOWN_CONTROL_FLOW; } inline BOOL PU_has_syscall_linkage (const PU& pu) { return pu.flags & PU_HAS_SYSCALL_LINKAGE; } inline void Set_PU_has_syscall_linkage (PU& pu) { pu.flags |= PU_HAS_SYSCALL_LINKAGE; } inline void Clear_PU_has_syscall_linkage (PU& pu) { pu.flags &= ~PU_HAS_SYSCALL_LINKAGE; } inline BOOL PU_is_thunk (const PU& pu) { return (pu.flags & PU_IS_THUNK) != 0; } inline void Set_PU_is_thunk (PU& pu) { pu.flags |= PU_IS_THUNK; } inline void Clear_PU_is_thunk (PU& pu) { pu.flags &= ~PU_IS_THUNK; } inline UINT64 PU_src_lang (const PU& pu) { return pu.src_lang; } inline BOOL PU_mixed_lang (const PU& pu) { return (pu.src_lang & PU_MIXED_LANG) != 0; } inline void Set_PU_mixed_lang (PU& pu) { pu.src_lang |= PU_MIXED_LANG; } inline void Clear_PU_mixed_lang (PU& pu) { pu.src_lang &= ~PU_MIXED_LANG; } inline BOOL PU_c_lang (const PU& pu) { return (pu.src_lang & PU_C_LANG) != 0; } inline void Set_PU_c_lang (PU& pu) { pu.src_lang |= PU_C_LANG; } inline void Clear_PU_c_lang (PU& pu) { pu.src_lang &= ~PU_C_LANG; } inline BOOL PU_cxx_lang (const PU& pu) { return (pu.src_lang & PU_CXX_LANG) != 0; } inline void Set_PU_cxx_lang (PU& pu) { pu.src_lang |= PU_CXX_LANG; } inline void Clear_PU_cxx_lang (PU& pu) { pu.src_lang &= ~PU_CXX_LANG; } inline BOOL PU_f77_lang (const PU& pu) { return (pu.src_lang & PU_F77_LANG) != 0; } inline void Set_PU_f77_lang (PU& pu) { pu.src_lang |= PU_F77_LANG; } inline void Clear_PU_f77_lang (PU& pu) { pu.src_lang &= ~PU_F77_LANG; } inline BOOL PU_f90_lang (const PU& pu) { return (pu.src_lang & PU_F90_LANG) != 0; } inline void Set_PU_f90_lang (PU& pu) { pu.src_lang |= PU_F90_LANG; } inline void Clear_PU_f90_lang (PU& pu) { pu.src_lang &= ~PU_F90_LANG; } inline BOOL PU_java_lang (const PU& pu) { return (pu.src_lang & PU_JAVA_LANG) != 0; } inline void Set_PU_java_lang (PU& pu) { pu.src_lang |= PU_JAVA_LANG; } inline void Clear_PU_java_lang (PU& pu) { pu.src_lang &= ~PU_JAVA_LANG; } // PU_ftn_lang (f77 or f90) is defined in symtab.h // PU_has_nested (f77 or f90) is defined in symtab.h //---------------------------------------------------------------------- // access functions for TY //---------------------------------------------------------------------- inline UINT64 TY_size (const TY& ty) { return ty.size; } inline void Set_TY_size (TY& ty, UINT64 size) { ty.size = size; } inline void Set_TY_size (TY_IDX tyi, UINT64 size) { Set_TY_size(Ty_Table[tyi], size); } inline UINT64 TY_adjusted_size (const TY& ty) { return ty.adjusted_size; } inline UINT64 TY_adjusted_size (TY_IDX ty_idx) {return TY_adjusted_size (Ty_Table[ty_idx]); } inline void Set_TY_adjusted_size (TY& ty, UINT64 size) { ty.adjusted_size = size; } inline void Set_TY_adjusted_size (TY_IDX tyi, UINT64 size) { Set_TY_adjusted_size(Ty_Table[tyi], size); } inline TY_KIND TY_kind (const TY& ty) { return ty.kind; } inline void Set_TY_kind (TY& ty, TY_KIND kind) { ty.kind = kind; } inline void Set_TY_kind (TY_IDX tyi, TY_KIND kind) { Set_TY_kind(Ty_Table[tyi], kind); } inline TYPE_ID TY_mtype (const TY& ty) { return ty.mtype; } inline void Set_TY_mtype (TY& ty, TYPE_ID mtype) { ty.mtype = mtype; } inline void Set_TY_mtype (TY_IDX tyi, TYPE_ID mtype){ Set_TY_mtype(Ty_Table[tyi],mtype); } inline UINT16 TY_flags (const TY& ty) { return ty.flags; } inline void Set_TY_flags (TY& ty, mUINT16 flags) { ty.flags = flags; } inline UINT16 TY_flags (const TY_IDX tyi) { return TY_flags(Ty_Table[tyi]); } inline void Set_TY_flags (TY_IDX tyi, mUINT16 flags){ Set_TY_flags(Ty_Table[tyi],flags); } inline FLD_HANDLE TY_fld (const TY& ty) { return FLD_HANDLE (ty.Fld ()); } inline void Set_TY_fld (TY& ty, FLD_HANDLE fld) { ty.Set_fld (fld.Idx()); } inline FLD_HANDLE TY_fld (const TY_IDX tyi) { return TY_fld(Ty_Table[tyi]); } inline void Set_TY_fld (TY_IDX tyi, FLD_HANDLE fld) { Set_TY_fld(Ty_Table[tyi], fld); } inline TYLIST_IDX TY_tylist (const TY& ty) { return ty.Tylist (); } inline void Set_TY_tylist (TY& ty, TYLIST_IDX idx) { ty.Set_tylist (idx); } inline TYLIST_IDX TY_tylist (const TY_IDX tyi) { return TY_tylist(Ty_Table[tyi]); } inline void Set_TY_tylist (TY_IDX tyi, TYLIST_IDX idx) { Set_TY_tylist(Ty_Table[tyi],idx); } inline ARB_HANDLE TY_arb (const TY& ty) { return ARB_HANDLE(ty.Arb ()); } inline void Set_TY_arb (TY& ty, ARB_HANDLE idx) { ty.Set_arb (idx.Idx()); } inline ARB_HANDLE TY_arb (const TY_IDX tyi) { return TY_arb(Ty_Table[tyi]); } inline void Set_TY_arb (TY_IDX tyi, ARB_HANDLE idx) { Set_TY_arb(Ty_Table[tyi], idx); } inline STR_IDX TY_name_idx (const TY& ty) { return ty.name_idx; } inline void Set_TY_name_idx (TY& ty, UINT64 name) { ty.name_idx = name; } inline STR_IDX TY_name_idx (const TY_IDX tyi) { return TY_name_idx(Ty_Table[tyi]); } inline void Set_TY_name_idx (TY_IDX tyi, UINT64 name) { Set_TY_name_idx(Ty_Table[tyi], name); } inline char * TY_name (const TY& ty) { return &Str_Table[ty.name_idx]; } inline TY_IDX TY_etype (const TY& ty) { return ty.Etype (); } inline void Set_TY_etype (TY& ty, TY_IDX idx) { ty.Set_etype (idx); } inline TY_IDX TY_etype (const TY_IDX tyi) { return TY_etype(Ty_Table[tyi]); } inline void Set_TY_etype (TY_IDX tyi, TY_IDX idx) { Set_TY_etype(Ty_Table[tyi],idx); } inline TY_IDX TY_pointed (const TY& ty) { return ty.Pointed (); } inline void Set_TY_pointed (TY& ty, TY_IDX idx) { ty.Set_pointed (idx); } inline TY_IDX TY_pointed (const TY_IDX tyi) { return Ty_Table[tyi].Pointed (); } inline void Set_TY_pointed (TY_IDX tyi, TY_IDX idx) { Set_TY_pointed(Ty_Table[tyi],idx); } //---------------------------------------------------------------------- // TY flags //---------------------------------------------------------------------- inline BOOL TY_is_character (const TY& ty) { return ty.flags & TY_IS_CHARACTER; } inline void Set_TY_is_character (TY& ty) { ty.flags |= TY_IS_CHARACTER; } inline void Clear_TY_is_character (TY& ty) { ty.flags &= ~TY_IS_CHARACTER; } inline BOOL TY_is_character (const TY_IDX tyi) { return TY_is_character(Ty_Table[tyi]); } inline void Set_TY_is_character (TY_IDX tyi) { Set_TY_is_character(Ty_Table[tyi]); } inline void Clear_TY_is_character (TY_IDX tyi) { Clear_TY_is_character(Ty_Table[tyi]); } inline BOOL TY_is_logical (const TY& ty) { return ty.flags & TY_IS_LOGICAL; } inline void Set_TY_is_logical (TY& ty) { ty.flags |= TY_IS_LOGICAL; } inline void Clear_TY_is_logical (TY& ty) { ty.flags &= ~TY_IS_LOGICAL; } inline BOOL TY_is_logical (const TY_IDX tyi) { return TY_is_logical(Ty_Table[tyi]); } inline void Set_TY_is_logical (TY_IDX tyi) { Set_TY_is_logical(Ty_Table[tyi]); } inline void Clear_TY_is_logical (TY_IDX tyi) { Clear_TY_is_logical(Ty_Table[tyi]); } inline BOOL TY_is_union (const TY& ty) { return ty.flags & TY_IS_UNION; } inline void Set_TY_is_union (TY& ty) { ty.flags |= TY_IS_UNION; } inline void Clear_TY_is_union (TY& ty) { ty.flags &= ~TY_IS_UNION; } inline BOOL TY_is_union (const TY_IDX tyi) { return TY_is_union(Ty_Table[tyi]); } inline void Set_TY_is_union (TY_IDX tyi) { Set_TY_is_union(Ty_Table[tyi]); } inline void Clear_TY_is_union (TY_IDX tyi) { Clear_TY_is_union(Ty_Table[tyi]); } inline BOOL TY_is_packed (const TY& ty) { return ty.flags & TY_IS_PACKED; } inline void Set_TY_is_packed (TY& ty) { ty.flags |= TY_IS_PACKED; } inline void Clear_TY_is_packed (TY& ty) { ty.flags &= ~TY_IS_PACKED; } inline BOOL TY_is_packed (const TY_IDX tyi) { return TY_is_packed(Ty_Table[tyi]); } inline void Set_TY_is_packed (TY_IDX tyi) { Set_TY_is_packed(Ty_Table[tyi]); } inline void Clear_TY_is_packed (TY_IDX tyi) { Clear_TY_is_packed(Ty_Table[tyi]); } #define UPC_ANON_PREFIX "_bupc_anonymous" inline BOOL TY_is_anonymous(TY_IDX tyi) { const char prefix[] = UPC_ANON_PREFIX; const int len = sizeof(prefix) - 1; const char *name = TY_name(Ty_Table[tyi]); return name && !strncmp(name, prefix, len); } inline UINT32 TY_block_size (const TY& ty) { return ty.block_size;} inline void Set_TY_block_size (TY &ty, UINT32 size) {ty.block_size = size;} inline UINT32 TY_block_size (TY_IDX tyi) { return TY_block_size(Ty_Table[tyi]); } inline void Set_TY_block_size (TY_IDX tyi, UINT32 size) { Set_TY_block_size(Ty_Table[tyi], size); } inline BOOL TY_is_shared (const TY& ty) { return ty.flags & TY_IS_SHARED; } inline void Set_TY_is_shared (TY& ty) { ty.flags |= TY_IS_SHARED; } inline void Clear_TY_is_shared (TY& ty) { ty.flags &= ~TY_IS_SHARED; } inline BOOL TY_is_shared (const TY_IDX tyi) { return TY_is_shared(Ty_Table[tyi]); } inline void Set_TY_is_shared (TY_IDX tyi) { Set_TY_is_shared(Ty_Table[tyi]); } inline void Clear_TY_is_shared (TY_IDX tyi) { Clear_TY_is_shared(Ty_Table[tyi]); } inline BOOL TY_is_strict (const TY& ty) { return ty.flags & TY_IS_STRICT; } inline void Set_TY_is_strict (TY& ty) { ty.flags |= TY_IS_STRICT; } inline void Clear_TY_is_strict (TY& ty) { ty.flags &= ~TY_IS_STRICT; } inline BOOL TY_is_strict (const TY_IDX tyi) { return TY_is_strict(Ty_Table[tyi]); } inline void Set_TY_is_strict (TY_IDX tyi) { Set_TY_is_strict(Ty_Table[tyi]); } inline void Clear_TY_is_strict (TY_IDX tyi) { Clear_TY_is_strict(Ty_Table[tyi]); } inline BOOL TY_is_relaxed (const TY& ty) { return ty.flags & TY_IS_RELAXED; } inline void Set_TY_is_relaxed (TY& ty) { ty.flags |= TY_IS_RELAXED; } inline void Clear_TY_is_relaxed (TY& ty) { ty.flags &= ~TY_IS_RELAXED; } inline BOOL TY_is_relaxed (const TY_IDX tyi) { return TY_is_relaxed(Ty_Table[tyi]); } inline void Set_TY_is_relaxed (TY_IDX tyi) { Set_TY_is_relaxed(Ty_Table[tyi]); } inline void Clear_TY_is_relaxed (TY_IDX tyi) { Clear_TY_is_relaxed(Ty_Table[tyi]); } inline BOOL TY_is_written (const TY& ty) { return ty.flags & TY_IS_WRITTEN; } inline void Set_TY_is_written (TY& ty) { ty.flags |= TY_IS_WRITTEN; } inline void Clear_TY_is_written (TY& ty) { ty.flags &= ~TY_IS_WRITTEN; } inline BOOL TY_is_written (const TY_IDX tyi) { return TY_is_written(Ty_Table[tyi]); } inline void Set_TY_is_written (TY_IDX tyi) { Set_TY_is_written(Ty_Table[tyi]); } inline void Clear_TY_is_written (TY_IDX tyi) { Clear_TY_is_written(Ty_Table[tyi]); } inline BOOL TY_uses_threads (const TY& ty) { return ty.flags & TY_USES_THREADS; } inline void Set_TY_uses_threads (TY& ty) { ty.flags |= TY_USES_THREADS; } inline void Clear_TY_uses_threads (TY& ty) { ty.flags &= ~TY_USES_THREADS; } inline BOOL TY_uses_threads (const TY_IDX tyi) { return TY_uses_threads(Ty_Table[tyi]); } inline void Set_TY_uses_threads (TY_IDX tyi) { Set_TY_uses_threads(Ty_Table[tyi]); } inline void Clear_TY_uses_threads (TY_IDX tyi) { Clear_TY_uses_threads(Ty_Table[tyi]); } inline BOOL TY_ptr_as_array (const TY& ty) { return ty.flags & TY_PTR_AS_ARRAY; } inline void Set_TY_ptr_as_array (TY& ty) { ty.flags |= TY_PTR_AS_ARRAY; } inline void Clear_TY_ptr_as_array (TY& ty) { ty.flags &= ~TY_PTR_AS_ARRAY; } inline BOOL TY_ptr_as_array (const TY_IDX tyi) { return TY_ptr_as_array(Ty_Table[tyi]); } inline void Set_TY_ptr_as_array (TY_IDX tyi) { Set_TY_ptr_as_array(Ty_Table[tyi]); } inline void Clear_TY_ptr_as_array (TY_IDX tyi) { Clear_TY_ptr_as_array(Ty_Table[tyi]); } inline BOOL TY_anonymous (const TY& ty) { return ty.flags & TY_ANONYMOUS; } inline void Set_TY_anonymous (TY& ty) { ty.flags |= TY_ANONYMOUS; } inline void Clear_TY_anonymous (TY& ty) { ty.flags &= ~TY_ANONYMOUS; } inline BOOL TY_anonymous (const TY_IDX tyi) { return TY_anonymous(Ty_Table[tyi]); } inline void Set_TY_anonymous (TY_IDX tyi) { Set_TY_anonymous(Ty_Table[tyi]); } inline void Clear_TY_anonymous (TY_IDX tyi) { Clear_TY_anonymous(Ty_Table[tyi]); } inline BOOL TY_split (const TY& ty) { return ty.flags & TY_SPLIT; } inline void Set_TY_split (TY& ty) { ty.flags |= TY_SPLIT; } inline void Clear_TY_split (TY& ty) { ty.flags &= ~TY_SPLIT; } inline BOOL TY_split (const TY_IDX tyi) { return TY_split(Ty_Table[tyi]); } inline void Set_TY_split (TY_IDX tyi) { Set_TY_split(Ty_Table[tyi]); } inline void Clear_TY_split (TY_IDX tyi) { Clear_TY_split(Ty_Table[tyi]); } inline BOOL TY_is_f90_pointer (const TY& ty) { return ty.flags & TY_IS_F90_POINTER; } inline void Set_TY_is_f90_pointer (TY& ty) { ty.flags |= TY_IS_F90_POINTER; } inline void Clear_TY_is_f90_pointer (TY& ty) { ty.flags &= ~TY_IS_F90_POINTER; } inline BOOL TY_is_f90_pointer (const TY_IDX tyi){ return TY_is_f90_pointer(Ty_Table[tyi]);} inline void Set_TY_is_f90_pointer (TY_IDX tyi) { Set_TY_is_f90_pointer(Ty_Table[tyi]); } inline void Clear_TY_is_f90_pointer (TY_IDX tyi){ Clear_TY_is_f90_pointer(Ty_Table[tyi]); } inline BOOL TY_not_in_union (const TY& ty) { return ty.flags & TY_NOT_IN_UNION; } inline void Set_TY_not_in_union (TY& ty) { ty.flags |= TY_NOT_IN_UNION; } inline void Clear_TY_not_in_union (TY& ty) { ty.flags &= ~TY_NOT_IN_UNION; } inline BOOL TY_not_in_union (const TY_IDX tyi) { return TY_not_in_union(Ty_Table[tyi]); } inline void Set_TY_not_in_union (TY_IDX tyi) { Set_TY_not_in_union(Ty_Table[tyi]); } inline void Clear_TY_not_in_union (TY_IDX tyi) { Clear_TY_not_in_union(Ty_Table[tyi]); } inline BOOL TY_no_ansi_alias (const TY& ty) { return ty.flags & TY_NO_ANSI_ALIAS; } inline void Set_TY_no_ansi_alias (TY& ty) { ty.flags |= TY_NO_ANSI_ALIAS; } inline void Clear_TY_no_ansi_alias (TY& ty) { ty.flags &= ~TY_NO_ANSI_ALIAS; } inline BOOL TY_no_ansi_alias (const TY_IDX tyi) { return TY_no_ansi_alias(Ty_Table[tyi]); } inline void Set_TY_no_ansi_alias (TY_IDX tyi) { Set_TY_no_ansi_alias(Ty_Table[tyi]); } inline void Clear_TY_no_ansi_alias (TY_IDX tyi) { Clear_TY_no_ansi_alias(Ty_Table[tyi]); } inline BOOL TY_is_non_pod (const TY& ty) { return ty.flags & TY_IS_NON_POD; } inline void Set_TY_is_non_pod (TY& ty) { ty.flags |= TY_IS_NON_POD; } inline void Clear_TY_is_non_pod (TY& ty) { ty.flags &= ~TY_IS_NON_POD; } inline BOOL TY_is_non_pod (const TY_IDX tyi) { return TY_is_non_pod(Ty_Table[tyi]); } inline void Set_TY_is_non_pod (TY_IDX tyi) { Set_TY_is_non_pod(Ty_Table[tyi]); } inline void Clear_TY_is_non_pod (TY_IDX tyi) { Clear_TY_is_non_pod(Ty_Table[tyi]); } // TY pu_flags inline BOOL TY_return_to_param (const TY& ty) { return ty.Pu_flags () & TY_RETURN_TO_PARAM; } inline void Set_TY_return_to_param (TY& ty) { ty.Set_pu_flag (TY_RETURN_TO_PARAM); } inline void Clear_TY_return_to_param (TY& ty) { ty.Clear_pu_flag (TY_RETURN_TO_PARAM); } inline BOOL TY_return_to_param (const TY_IDX tyi) { return TY_return_to_param(Ty_Table[tyi]); } inline void Set_TY_return_to_param (TY_IDX tyi) { Set_TY_return_to_param(Ty_Table[tyi]); } inline void Clear_TY_return_to_param (TY_IDX tyi){ Clear_TY_return_to_param(Ty_Table[tyi]); } inline BOOL TY_is_varargs (const TY& ty) { return ty.Pu_flags () & TY_IS_VARARGS; } inline void Set_TY_is_varargs (TY& ty) { ty.Set_pu_flag (TY_IS_VARARGS); } inline void Clear_TY_is_varargs (TY& ty) { ty.Clear_pu_flag (TY_IS_VARARGS); } inline BOOL TY_is_varargs (const TY_IDX tyi) { return TY_is_varargs(Ty_Table[tyi]); } inline void Set_TY_is_varargs (TY_IDX tyi) { Set_TY_is_varargs(Ty_Table[tyi]); } inline void Clear_TY_is_varargs (TY_IDX tyi) { Clear_TY_is_varargs(Ty_Table[tyi]); } inline BOOL TY_has_prototype (const TY_IDX tyi) { return Ty_Table[tyi].Pu_flags() & TY_HAS_PROTOTYPE; } inline void Set_TY_has_prototype (TY_IDX tyi) { Ty_Table[tyi].Set_pu_flag (TY_HAS_PROTOTYPE); } inline void Clear_TY_has_prototype (TY_IDX tyi) { Ty_Table[tyi].Clear_pu_flag (TY_HAS_PROTOTYPE); } //---------------------------------------------------------------------- // access functions for FLD //---------------------------------------------------------------------- inline STR_IDX FLD_name_idx (FLD_HANDLE fld) { return fld.Entry()->name_idx; } inline void Set_FLD_name_idx (FLD_HANDLE fld, STR_IDX idx){ fld.Entry()->name_idx = idx; } inline char * FLD_name (FLD_HANDLE fld) { return &Str_Table[fld.Entry()->name_idx]; } inline TY_IDX FLD_type (FLD_HANDLE fld) { return fld.Entry()->type; } inline void Set_FLD_type (FLD_HANDLE fld, TY_IDX ty){ fld.Entry()->type = ty; } inline UINT64 FLD_ofst (FLD_HANDLE fld) { return fld.Entry()->ofst; } inline void Set_FLD_ofst (FLD_HANDLE fld, UINT64 ofst) { fld.Entry()->ofst = ofst; } inline UINT64 FLD_adjusted_ofst (FLD_HANDLE fld) { return fld.Entry()->adjusted_ofst; } inline void Set_FLD_adjusted_ofst (FLD_HANDLE fld, UINT64 ofst) { fld.Entry()->adjusted_ofst = ofst; } inline TY_IDX FLD_orig_type (FLD_HANDLE fld) {return fld.Entry()->orig_type; } inline void Set_FLD_orig_type (FLD_HANDLE fld, TY_IDX ty) {fld.Entry()->orig_type = ty; } inline UINT8 FLD_bsize (FLD_HANDLE fld) { return fld.Entry()->bsize; } inline void Set_FLD_bsize (FLD_HANDLE fld, UINT8 bsize) { fld.Entry()->bsize = bsize; } inline UINT8 FLD_bofst (FLD_HANDLE fld) { return fld.Entry()->bofst; } inline void Set_FLD_bofst (FLD_HANDLE fld, UINT8 bofst) { fld.Entry()->bofst = bofst; } inline UINT16 FLD_flags (FLD_HANDLE fld) { return fld.Entry()->flags; } inline void Set_FLD_flags (FLD_HANDLE fld, UINT16 flags) { fld.Entry()->flags = flags; } inline ST_IDX FLD_st (FLD_HANDLE fld) { return fld.Entry()->st; } inline void Set_FLD_st (FLD_HANDLE fld, ST_IDX st) { fld.Entry()->st = st; } //---------------------------------------------------------------------- // FLD flags //---------------------------------------------------------------------- inline BOOL FLD_last_field (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_LAST_FIELD; } inline void Set_FLD_last_field (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_LAST_FIELD; } inline void Clear_FLD_last_field (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_LAST_FIELD; } inline BOOL FLD_equivalence (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_EQUIVALENCE; } inline void Set_FLD_equivalence (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_EQUIVALENCE; } inline void Clear_FLD_equivalence (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_EQUIVALENCE; } inline BOOL FLD_begin_union (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_BEGIN_UNION; } inline void Set_FLD_begin_union (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_BEGIN_UNION; } inline void Clear_FLD_begin_union (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_BEGIN_UNION; } inline BOOL FLD_end_union (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_END_UNION; } inline void Set_FLD_end_union (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_END_UNION; } inline void Clear_FLD_end_union (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_END_UNION; } inline BOOL FLD_begin_map (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_BEGIN_MAP; } inline void Set_FLD_begin_map (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_BEGIN_MAP; } inline void Clear_FLD_begin_map (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_BEGIN_MAP; } inline BOOL FLD_end_map (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_END_MAP; } inline void Set_FLD_end_map (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_END_MAP; } inline void Clear_FLD_end_map (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_END_MAP; } inline BOOL FLD_is_bit_field (FLD_HANDLE fld) { return fld.Entry()->flags & FLD_IS_BIT_FIELD; } inline void Set_FLD_is_bit_field (FLD_HANDLE fld) { fld.Entry()->flags |= FLD_IS_BIT_FIELD; } inline void Clear_FLD_is_bit_field (FLD_HANDLE fld) { fld.Entry()->flags &= ~FLD_IS_BIT_FIELD; } //---------------------------------------------------------------------- // access functions for TYLIST //---------------------------------------------------------------------- inline TY_IDX TYLIST_type (TYLIST tylist) { return tylist; } inline void Set_TYLIST_type (TYLIST& tylist, TY_IDX ty) { tylist = ty; } //---------------------------------------------------------------------- // access functions for ARB //---------------------------------------------------------------------- inline UINT16 ARB_flags (const ARB_HANDLE arb) { return arb.Entry()->flags; } inline void Set_ARB_flags (ARB_HANDLE arb, UINT16 flags){ arb.Entry()->flags = flags; } inline UINT16 ARB_dimension (const ARB_HANDLE arb) { return arb.Entry()->dimension; } inline void Set_ARB_dimension (ARB_HANDLE arb, UINT16 dim){ arb.Entry()->dimension = dim; } inline INT64 ARB_lbnd_val (const ARB_HANDLE arb) { return arb.Entry()->Lbnd_val (); } inline void Set_ARB_lbnd_val (ARB_HANDLE arb, INT64 val) { arb.Entry()->Set_lbnd_val (val); } inline ST_IDX ARB_lbnd_var (const ARB_HANDLE arb) { return arb.Entry()->Lbnd_var (); } inline void Set_ARB_lbnd_var (ARB_HANDLE arb, ST_IDX var) { arb.Entry()->Set_lbnd_var (var); } inline INT64 ARB_ubnd_val (const ARB_HANDLE arb) { return arb.Entry()->Ubnd_val (); } inline void Set_ARB_ubnd_val (ARB_HANDLE arb, INT64 val) { arb.Entry()->Set_ubnd_val (val); } inline ST_IDX ARB_ubnd_var (const ARB_HANDLE arb) { return arb.Entry()->Ubnd_var (); } inline void Set_ARB_ubnd_var (ARB_HANDLE arb, ST_IDX var) { arb.Entry()->Set_ubnd_var (var); } inline INT64 ARB_stride_val (const ARB_HANDLE arb) { return arb.Entry()->Stride_val (); } inline void Set_ARB_stride_val (ARB_HANDLE arb, INT64 val){ arb.Entry()->Set_stride_val (val); } inline ST_IDX ARB_stride_var (const ARB_HANDLE arb) { return arb.Entry()->Stride_var (); } inline void Set_ARB_stride_var (ARB_HANDLE arb, ST_IDX var) { arb.Entry()->Set_stride_var (var); } //---------------------------------------------------------------------- // ARB flags //---------------------------------------------------------------------- inline BOOL ARB_const_lbnd (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_CONST_LBND; } inline void Set_ARB_const_lbnd (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_CONST_LBND; } inline void Clear_ARB_const_lbnd (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_CONST_LBND; } inline BOOL ARB_const_ubnd (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_CONST_UBND; } inline void Set_ARB_const_ubnd (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_CONST_UBND; } inline void Clear_ARB_const_ubnd (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_CONST_UBND; } inline BOOL ARB_const_stride (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_CONST_STRIDE; } inline void Set_ARB_const_stride (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_CONST_STRIDE; } inline void Clear_ARB_const_stride (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_CONST_STRIDE; } inline BOOL ARB_first_dimen (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_FIRST_DIMEN; } inline void Set_ARB_first_dimen (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_FIRST_DIMEN; } inline void Clear_ARB_first_dimen (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_FIRST_DIMEN; } inline BOOL ARB_last_dimen (const ARB_HANDLE arb) { return arb.Entry()->flags & ARB_LAST_DIMEN; } inline void Set_ARB_last_dimen (ARB_HANDLE arb) { arb.Entry()->flags |= ARB_LAST_DIMEN; } inline void Clear_ARB_last_dimen (ARB_HANDLE arb) { arb.Entry()->flags &= ~ARB_LAST_DIMEN; } //---------------------------------------------------------------------- // access functions for LABEL //---------------------------------------------------------------------- inline STR_IDX LABEL_name_idx (const LABEL& lbl) { return lbl.name_idx; } inline void Set_LABEL_name_idx (LABEL& lbl, STR_IDX s) { lbl.name_idx = s; } inline char * LABEL_name (const LABEL& lbl) { return &Str_Table[lbl.name_idx]; } inline LABEL_KIND LABEL_kind (const LABEL& lbl) { return lbl.kind; } inline void Set_LABEL_KIND (LABEL& lbl, LABEL_KIND k) { lbl.kind = k; } inline BOOL LABEL_target_of_goto_outer_block (const LABEL& l) { return l.flags & LABEL_TARGET_OF_GOTO_OUTER_BLOCK;} inline void Set_LABEL_target_of_goto_outer_block (LABEL& l) { l.flags |= LABEL_TARGET_OF_GOTO_OUTER_BLOCK; } inline void Clear_LABEL_target_of_goto_outer_block (LABEL& l) { l.flags &= ~LABEL_TARGET_OF_GOTO_OUTER_BLOCK; } inline BOOL LABEL_addr_saved (const LABEL& l) { return l.flags & LABEL_ADDR_SAVED;} inline void Set_LABEL_addr_saved (LABEL& l) { l.flags |= LABEL_ADDR_SAVED; } inline void Clear_LABEL_addr_saved (LABEL& l) { l.flags &= ~LABEL_ADDR_SAVED; } inline BOOL LABEL_addr_passed (const LABEL& l) { return l.flags & LABEL_ADDR_PASSED;} inline void Set_LABEL_addr_passed (LABEL& l) { l.flags |= LABEL_ADDR_PASSED; } inline void Clear_LABEL_addr_passed (LABEL& l) { l.flags &= ~LABEL_ADDR_PASSED; } //---------------------------------------------------------------------- // access functions for PREG //---------------------------------------------------------------------- inline STR_IDX PREG_name_idx (const PREG& preg) { return preg.name_idx; } inline void Set_PREG_name_idx (PREG& preg, STR_IDX s) { preg.name_idx = s; } inline void Set_PREG_name (PREG &preg, const char *const name) { Set_PREG_name_idx(preg, Save_Str(name)); } inline char * PREG_name (const PREG& preg) { return &Str_Table[preg.name_idx]; } //---------------------------------------------------------------------- // access functions for ST_ATTR //---------------------------------------------------------------------- inline ST_IDX ST_ATTR_st_idx (const ST_ATTR& st_attr) { return st_attr.st_idx; } inline void Set_ST_ATTR_st_idx (ST_ATTR& st_attr, ST_IDX st) { st_attr.st_idx = st; } inline ST_ATTR_KIND ST_ATTR_kind (const ST_ATTR& st_attr) { return st_attr.kind; } inline PREG_NUM ST_ATTR_reg_id (const ST_ATTR& st_attr) { Is_True (st_attr.kind == ST_ATTR_DEDICATED_REGISTER, ("attribute is not for a dedicated register")); return st_attr.u.reg_id; } inline void Set_ST_ATTR_reg_id (ST_ATTR& st_attr, PREG_NUM id) { st_attr.kind = ST_ATTR_DEDICATED_REGISTER; st_attr.u.reg_id = id; } inline STR_IDX ST_ATTR_section_name (const ST_ATTR& st_attr) { Is_True (st_attr.kind == ST_ATTR_SECTION_NAME, ("attribute is not for a section name")); return st_attr.u.section_name; } inline void Set_ST_ATTR_section_name (ST_ATTR& st_attr, STR_IDX name) { st_attr.kind = ST_ATTR_SECTION_NAME; st_attr.u.section_name = name; } //---------------------------------------------------------------------- // access functions for FILE_INFO //---------------------------------------------------------------------- inline UINT8 FILE_INFO_gp_group (const FILE_INFO& f) { return f.gp_group; } inline void Set_FILE_INFO_gp_group (FILE_INFO& f, mUINT8 grp) { f.gp_group = grp; } inline BOOL FILE_INFO_ipa (const FILE_INFO& f) { return f.flags & FI_IPA; } inline void Set_FILE_INFO_ipa (FILE_INFO& f) { f.flags |= FI_IPA; } inline void Clear_FILE_INFO_ipa (FILE_INFO& f) { f.flags &= ~FI_IPA; } inline BOOL FILE_INFO_needs_lno (const FILE_INFO& f){ return f.flags & FI_NEEDS_LNO; } inline void Set_FILE_INFO_needs_lno (FILE_INFO& f) { f.flags |= FI_NEEDS_LNO; } inline void Clear_FILE_INFO_needs_lno (FILE_INFO& f){ f.flags &= ~FI_NEEDS_LNO; } inline BOOL FILE_INFO_has_inlines (const FILE_INFO& f) { return f.flags & FI_HAS_INLINES; } inline void Set_FILE_INFO_has_inlines (FILE_INFO& f) { f.flags |= FI_HAS_INLINES; } inline void Clear_FILE_INFO_has_inlines (FILE_INFO& f) { f.flags &= ~FI_HAS_INLINES; } inline BOOL FILE_INFO_has_mp (const FILE_INFO& f){ return f.flags & FI_HAS_MP; } inline void Set_FILE_INFO_has_mp (FILE_INFO& f) { f.flags |= FI_HAS_MP; } inline void Clear_FILE_INFO_has_mp (FILE_INFO& f){ f.flags &= ~FI_HAS_MP; } //---------------------------------------------------------------------- // access functions for the TABLES //---------------------------------------------------------------------- #if 0 inline ST& SYMBOL_TABLE::operator[] (ST_IDX idx) { SYMTAB_IDX level = ST_IDX_level (idx); UINT32 index = ST_IDX_index (idx); return Scope_tab[level].st_tab->Entry (index); } inline ST& SYMBOL_TABLE::operator() (SYMTAB_IDX level, UINT32 index) { Is_True (Scope_tab[level].st_tab != NULL, ("Uninitialized ST_TAB")); return Scope_tab[level].st_tab->Entry (index); } inline INITO& INITO_TABLE::operator[] (INITO_IDX idx) { SYMTAB_IDX level = INITO_IDX_level (idx); UINT32 index = INITO_IDX_index (idx); return Scope_tab[level].inito_tab->Entry (index); } inline INITO& INITO_TABLE::operator() (SYMTAB_IDX level, UINT32 index) { Is_True (Scope_tab[level].inito_tab != NULL, ("Uninitialized INITO_TAB")); return Scope_tab[level].inito_tab->Entry (index); } #endif inline LABEL& LABEL_TABLE::operator[] (LABEL_IDX idx) { return Scope_tab[CURRENT_SYMTAB].label_tab->Entry (idx); } inline LABEL& LABEL_TABLE::operator() (SYMTAB_IDX level, LABEL_IDX idx) { return Scope_tab[level].label_tab->Entry (idx); } inline PREG& PREG_TABLE::operator[] (PREG_IDX idx) { return Scope_tab[CURRENT_SYMTAB].preg_tab->Entry (idx); } inline PREG& PREG_TABLE::operator() (SYMTAB_IDX level, PREG_IDX idx) { return Scope_tab[level].preg_tab->Entry (idx); } inline ST_ATTR& ST_ATTR_TABLE::operator[] (ST_ATTR_IDX idx) { return Scope_tab[CURRENT_SYMTAB].st_attr_tab->Entry (idx); } inline ST_ATTR& ST_ATTR_TABLE::operator() (SYMTAB_IDX level, ST_ATTR_IDX idx) { return Scope_tab[level].st_attr_tab->Entry (idx); } inline TY& TYPE_TABLE::operator[] (TY_IDX idx) { return Ty_tab[TY_IDX_index(idx)]; } inline TY_TAB* TYPE_TABLE::operator& () { return &Ty_tab; } #endif // symtab_access_INCLUDED