Polaris: VariableSymbol.h Source File

VariableSymbol.h Go to the documentation of this file. /// #ifndef _VARIABLE_SYMBOL_H #define _VARIABLE_SYMBOL_H /// /// \class VariableSymbol /// \brief a Symbol of class VARIABLE_CLASS /// \defgroup Polaris /// \ingroup Polaris /// C++ VDL /// \see Symbol.h /// \see Symbol.h /// \see VariableSymbol.h /// \see Symbol.cc /// /// \endcode /// \section Description Description /// A VariableSymbol is a Symbol representing a Fortran variable. /// /// The additional fields it adds to Symbol's fields are /// the type, equivalence, dim, formal and common fields. /// /// The type field indicates the type of variable. /// /// The equivalence field is a pointer to an Equivalence /// class if this Symbol is associated with any /// equivalences. /// /// The dim field is a list of array bounds if this symbol /// is an array (if is_array() is true -- if not, this /// list will be empty). /// /// The shared_dim field is a list of shared distributions if this /// symbol is shared (if is_shared() is true -- if not, this /// list will be empty). /// /// The formal field indicates whether or not this variable /// is a formal variable of a function or subroutine. /// /// The allocatable field indicates whether this is an array /// which may be dynamically allocated. /// /// The common field is a pointer to a CommonBlock structure /// if this variable is a commoned variable. /// /// The only virtual methods inherited from Symbol which are /// valid for this class (which will not give errors messages, /// with the exception of Symbol::is_array()) are those which /// are explicitly overridden here. /// /// See Symbol for more information. /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #ifndef _SYMBOL_H #include "Symbol.h" #endif /// #include "../SharedDims.h" /// class VariableSymbol : public Symbol { friend class CommonBlock; friend class PostPass; protected: Type _type; unsigned _formal:1, _saved:1, _initial_value:1, _global:1, _allocatable:1; Equivalence *_equivalence; ArrayDims _dim; SharedDims _shared_dim; CommonBlock *_common; virtual void _dims(ArrayDims *); Expression *_shared_expr; ///<_ points to Expression in the AS_SHARED assertion in FLOW_ENTRY_STMT ///<_ if this symbol is shared. (only applicable to T3D now) Symbol *_gsa_base_symbol; ///< If non-NULL, this symbol is a symbol generated for the GSA representation ///< and points to the symbol with the original name. public: VariableSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, ArrayBounds * bounds1 = 0, ArrayBounds * bounds2 = 0, ArrayBounds * bounds3 = 0, ArrayBounds * bounds4 = 0, ArrayBounds * bounds5 = 0, ArrayBounds * bounds6 = 0, ArrayBounds * bounds7 = 0); ///< Constructor. Equivalence and CommonBlock information, if ///< desired, must be entered separately using the appropriate ///< functions. ///< If the variable is an array, the dimension bounds may be ///< initialized here, up to 5 dimensions. If more are needed, ///< insert them directly into the array dimensions field using ///< code such as ///< ///< VariableSymbol *var("VAR1", make_type(INTEGER_TYPE), ///< IS_FORMAL, NOT_SAVED); ///< var.dim().ins_last(new ArrayBounds(new IntConstExpr(1), ///< new IntconstExpr(100)); ///< // First dimension is '1:100' ///< etc. VariableSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayBounds * bounds1 = 0, ArrayBounds * bounds2 = 0, ArrayBounds * bounds3 = 0, ArrayBounds * bounds4 = 0, ArrayBounds * bounds5 = 0, ArrayBounds * bounds6 = 0, ArrayBounds * bounds7 = 0); VariableSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayDims * dims); VariableSymbol(const char *name, const Type & type, ALLOC_BOOL allocatable, FORMAL_BOOL formal, SAVED_BOOL saved, ArrayBounds * bounds1 = 0, ArrayBounds * bounds2 = 0, ArrayBounds * bounds3 = 0, ArrayBounds * bounds4 = 0, ArrayBounds * bounds5 = 0, ArrayBounds * bounds6 = 0, ArrayBounds * bounds7 = 0); VariableSymbol(const char *name, const Type & type, ALLOC_BOOL allocatable, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayBounds * bounds1 = 0, ArrayBounds * bounds2 = 0, ArrayBounds * bounds3 = 0, ArrayBounds * bounds4 = 0, ArrayBounds * bounds5 = 0, ArrayBounds * bounds6 = 0, ArrayBounds * bounds7 = 0); VariableSymbol(const char *name, const Type & type, ALLOC_BOOL allocatable, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayDims * dims); VariableSymbol(const VariableSymbol & vsym); VariableSymbol & operator = (const VariableSymbol & vsym); bool is_gsa_symbol() const; ///< True if there is a pointer to the GSA base variable (_gsa_base_symbol). Symbol & gsa_base_symbol() const ; ///< Returns the value of _gsa_base_symbol (NULL if this is not a GSA-generated symbol) void gsa_base_symbol( Symbol & base_ptr ); ///< Deposits a value in _gsa_base_symbol virtual Symbol *clone() const; ///< Clone constructor -- returns base pointer to a new clone of ///< this Symbol. virtual Symbol *clone_all() const; ///< Clone constructor -- returns base pointer to a new clone of ///< this Symbol. virtual ~VariableSymbol(); virtual const Type & type() const; virtual void type(const Type & type); virtual Equivalence *equivalence_ref() const; virtual void equivalence(Equivalence & e, int byte_base); virtual void clear_equivalence(); virtual const ArrayDims & dim() const; virtual ArrayDims & dim() ; virtual const SharedDims & shared_dim() const; virtual SharedDims & shared_dim() ; virtual INITIAL_BOOL initial_value() const; virtual void initial_value(INITIAL_BOOL ourbool); virtual ALLOC_BOOL allocatable() const; virtual void allocatable(ALLOC_BOOL ourbool); virtual FORMAL_BOOL formal() const; virtual void formal(FORMAL_BOOL ourbool); virtual SAVED_BOOL saved() const; virtual void saved(SAVED_BOOL ourbool); virtual GLOBAL_BOOL global() const; virtual void global(GLOBAL_BOOL ourbool); virtual const CommonBlock *common_ref() const; virtual CommonBlock *common_ref() ; virtual void common(CommonBlock & cb, int index); ///< Insert this variable into common block cb at position ///< index (1 = first element). ///< If the variable previously was in a different common block, ///< it is automatically removed from the common block. Then ///< it is automatically inserted into the given common block's (cb) ///< list. Finally, the variable's common field ///< is updated to the value of cb. Thus, to change a variable's ///< common block, use either this routine or the routine in ///< CommonBlock.h, but not both. virtual void shared_expr(Expression *shared); ///< 'shared' must be an expression whose 'symbol' is this itself. ///< and it must DISTRIBUTE_OP or ID_OP virtual void set_to_private(); ///< this symbol turns back to be a private by resetting _shared_expr to 0 virtual Expression *shared_expr() const; ///<_ If thie is VariableSymbol and shared data object, it returns to the ///<_ pointer to its correspoding distribution expression. ///<_ The returned expression must be either ID_OP or DISTRIBUTE_OP. ///<_ If this is private, it returns 0. (only applicable to Cray T3D) virtual void clear_common(); virtual int is_scalar() const; virtual int is_array() const; virtual int is_shared() const; virtual int is_pointer() const; virtual int size() const; ///< Return the size in bytes of the memory refered to by the symbol. virtual void print(ostream & o) const; ///< Print onto stream 'o' virtual void fill_in(const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef>&stmts, const Dictionary<VoidPtrDef>&commons, const Dictionary<VoidPtrDef>&equivalences); ///< Fill in all relevant info from a binstr object int structures_OK() const; ///< Check the structure of the data for errors or inconsistency ///< Return 0 and print error message if problems found, otherwise ///< return 1 without message. virtual void exchange_convert( VDL &vdl ); ///< Convert the Symbol into the exchange format. virtual void relink_dptrs(ProgramUnit & p); ///< Change all pointers found in a VariableSymbol element to ///< point into the given ProgramUnit. }; inline VariableSymbol::VariableSymbol(const VariableSymbol &vsym) : Symbol(vsym._tag, VARIABLE_CLASS) { *this = vsym; } inline int VariableSymbol::is_pointer() const { return 0; } inline void VariableSymbol::_dims (ArrayDims * dims) { _dim = *dims; } inline bool VariableSymbol::is_gsa_symbol( ) const { if (_gsa_base_symbol) return true; else return false; } inline Symbol & VariableSymbol::gsa_base_symbol() const { return *_gsa_base_symbol; } inline void VariableSymbol::gsa_base_symbol( Symbol & base_ptr ) { _gsa_base_symbol = &base_ptr; } #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:06:16 2005