wn_core.h

Go to the documentation of this file.
00001 /*
00002 
00003   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00004 
00005   This program is free software; you can redistribute it and/or modify it
00006   under the terms of version 2 of the GNU General Public License as
00007   published by the Free Software Foundation.
00008 
00009   This program is distributed in the hope that it would be useful, but
00010   WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00012 
00013   Further, this software is distributed without any warranty that it is
00014   free of the rightful claim of any third person regarding infringement 
00015   or the like.  Any license provided herein, whether implied or 
00016   otherwise, applies only to this software file.  Patent licenses, if 
00017   any, provided herein do not apply to combinations of this program with 
00018   other software, or any other product whatsoever.  
00019 
00020   You should have received a copy of the GNU General Public License along
00021   with this program; if not, write the Free Software Foundation, Inc., 59
00022   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00023 
00024   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00025   Mountain View, CA 94043, or:
00026 
00027   http://www.sgi.com
00028 
00029   For further information regarding this notice, see:
00030 
00031   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00032 
00033 */
00034 
00035 
00036 #ifndef wn_core_INCLUDED
00037 #define wn_core_INCLUDED
00038 
00039 #ifndef symtab_INCLUDED
00040 #include "symtab.h"
00041 #endif 
00042 
00043 #ifndef irbdata_INCLUDED
00044 #include "irbdata.h"
00045 #endif
00046 
00047 #ifndef wintrinsic_INCLUDED 
00048 #include "wintrinsic.h"
00049 #endif
00050 #ifndef wio_INCLUDED
00051 #include "wio.h"
00052 #endif
00053 
00376 #define MAX_FIELD_ID 0x3ffe
00377 #define UNKNOWN_FIELD_ID 0x3fff
00378 
00379 class WN;
00380 class STMT_WN;
00381 
00382 typedef INT32           WN_OFFSET;
00383 typedef INT64           WN_ESIZE;
00384 typedef INT32           WN_MAP_ID;
00385 
00386 typedef enum REGION_KIND {
00387   REGION_KIND_PRAGMA     = 0x0,
00388   REGION_KIND_FUNC_ENTRY = 0x1,
00389   REGION_KIND_LOOP       = 0x2,
00390   REGION_KIND_OLIMIT     = 0x3,
00391   REGION_KIND_MP         = 0x4,
00392   REGION_KIND_RPI        = 0x5,
00393   REGION_KIND_COLD       = 0x6,
00394   REGION_KIND_SWP        = 0x7,
00395 
00396   REGION_KIND_EH         = 0x8, /* any kind with bit 3 set is EH */
00397   REGION_KIND_TRY        = 0x8,
00398   REGION_KIND_CLEANUP    = 0x9,
00399   REGION_KIND_EXC_SPEC   = 0xa,
00400   REGION_KIND_MASK       = 0xb,
00401   REGION_KIND_GUARD      = 0xc,
00402   REGION_KIND_NULL_CLEANUP = 0xd  /* cleanup with empty destructor */
00403 } REGION_KIND;
00404 
00405 class WN {
00406 public:
00407    union {
00408       struct {
00409          union {
00410             WN_OFFSET       load_offset; 
00411             WN_OFFSET       lda_offset; 
00412             WN_OFFSET       store_offset;
00413             WN_OFFSET       idname_offset;
00414             INT32           num_entries; /* used by computed goto statements; may be used by regions */
00415             TY_IDX          loadx_addr_ty; /* for OPR_ILOADX */
00416             INT16           cvtl_bits;
00417             INT32           label_number;
00418             UINT32          call_flag;
00419             UINT32          if_flag;
00420             UINT32          io_flag;
00421             UINT32          asm_flag;
00422             UINT32          asm_operand_num;
00423             UINT32          eq_logical_flag;
00424             struct {
00425                 mUINT16     trip_est;
00426                 mUINT16     loop_depth;
00427             } li;
00428             struct {
00429                 mUINT16     pragma_flags;
00430                 mUINT16     pragma_id;
00431             } pragma;
00432             TY_IDX          io_item_ty;  /* for IO_ITEM */
00433             struct {
00434                 REGION_KIND region_kind: 4;
00435                 mUINT32     region_id  :28;
00436             } region;
00437          } ua;
00438          union {
00439             ST_IDX          st_idx;     /* for ldid/stid/lda */
00440             TY_IDX          ty;         /* for all types except lda,ldid,stid */
00441                                         /*  and io_item */
00442             INT32           id;
00443             INTRINSIC       intrinsic;
00444             IOSTATEMENT     iostatement;
00445             IOITEM          ioitem;
00446             UINT32          prefetch_flag;
00447             UINT32          loop_flag;
00448             INT32           last_label; /* end of switch */
00449             INITO_IDX       ereg_supp;
00450             UINT32          label_level; /* nest level for target of goto_outer_block */
00451          } ub;
00452       } uu;
00453       WN_ESIZE      element_size;
00454    } u1u2;
00455 
00456    // the following layout was used to minimize aliasing as 
00457    // kid_count is not used in most of the WHIRL nodes.
00458    // this permits loading of wn_operator, rtype and desc as bytes
00459    struct {
00460       OPERATOR          wn_operator : 8;  /* 8 bits of operator       */
00461       TYPE_ID           rtype       : 5;  /* result */
00462       mINT16            kid_count   :14; /* gives kid_count for free */
00463       TYPE_ID           desc        : 5;  /* descriptor type */
00464       INT32             map_id;
00465    } common;
00466 
00467    union {
00468      struct {
00469        WN          *dummy1;
00470        TY_IDX       ty;         /* ty used for lda,ldid,stid,iload */
00471      } ty_fields;
00472      WN            *kids[2];
00473      INT64          const_val;
00474      struct {
00475        UINT32       num_inputs;
00476        UINT32       num_clobbers;
00477      } asm_fields;
00478      struct {
00479        WN          *dummy2;
00480        UINT32       label_flag;
00481      } label_flag_fields;
00482      struct {
00483        WN          *first;
00484        WN          *last;
00485      } block;
00486 
00487       union {
00488         INT64       pragma_arg64;
00489         struct {
00490            INT32    pragma_arg1;
00491            union {
00492              INT32    pragma_arg2;
00493              struct {
00494                mUINT32  pragma_asm_opnd_num : 8;
00495                PREG_NUM pragma_asm_copyout_preg : 24;
00496              } asm_pragma;
00497            };
00498         } up1;
00499         struct {
00500            mINT16   pragma_pad1;
00501            mINT8    pragma_distr_type;
00502            mINT8    pragma_index;
00503            INT32    pragma_preg;
00504         } up2;
00505       } pragma;
00506    } u3;
00507 
00508 #ifndef WN_NO_ACCESSOR_FUNCTIONS
00509 
00510   WN () {}
00511   WN (const WN& wn) { }
00512   WN (const WN* wn) { }
00513   WN& operator= (const WN& wn) { return *this;}
00514   ~WN () {}
00515 
00516 public:
00517 
00518   friend inline WN_OFFSET   WN_load_offset (const WN *);
00519   friend inline WN_OFFSET&  WN_load_offset (WN *);
00520   friend inline WN_OFFSET   WN_lda_offset (const WN *);
00521   friend inline WN_OFFSET&  WN_lda_offset (WN *);
00522   friend inline WN_OFFSET   WN_store_offset (const WN *);
00523   friend inline WN_OFFSET&  WN_store_offset (WN *);
00524   friend inline WN_OFFSET   WN_idname_offset (const WN *);
00525   friend inline WN_OFFSET&  WN_idname_offset (WN *);
00526   friend inline WN_OFFSET   WN_offset (const WN *);
00527   friend inline WN_OFFSET&  WN_offset (WN *);
00528   friend inline INT32       WN_num_entries (const WN *);
00529   friend inline INT32&      WN_num_entries (WN *);
00530 //friend inline TY_IDX      WN_loadx_addr_ty (const WN *);
00531 //friend inline TY_IDX&     WN_loadx_addr_ty (WN *);
00532   friend inline INT16       WN_cvtl_bits (const WN *);
00533   friend inline INT16&      WN_cvtl_bits (WN *);
00534   friend inline INT32&      WN_label_number (WN *);
00535   friend inline INT32       WN_label_number (const WN *);
00536   friend inline UINT32&     WN_call_flag (WN *);
00537   friend inline UINT32      WN_call_flag (const WN *);
00538 
00539   friend inline UINT32&     WN_eq_logical_flag (WN *);
00540   friend inline UINT32      WN_eq_logical_flag (const WN *);
00541 
00542   friend inline UINT32&     WN_if_flag (WN *);
00543   friend inline UINT32      WN_if_flag (const WN *);
00544   friend inline UINT32&     WN_io_flag (WN *);
00545   friend inline UINT32      WN_io_flag (const WN *);
00546   friend inline UINT32&     WN_asm_flag (WN *);
00547   friend inline UINT32      WN_asm_flag (const WN *);
00548   friend inline UINT32&     WN_asm_num_inputs (WN *);
00549   friend inline UINT32      WN_asm_num_inputs (const WN *);
00550   friend inline UINT32&     WN_asm_num_clobbers (WN *);
00551   friend inline UINT32      WN_asm_num_clobbers (const WN *);
00552   friend inline char *      WN_asm_string (const WN *);
00553   friend inline char *      WN_asm_input_constraint (const WN *);
00554   friend inline UINT32      WN_asm_opnd_num(const WN *);
00555   friend inline UINT32&     WN_label_level (WN *);
00556   friend inline UINT32      WN_label_level (const WN *);
00557 
00558   friend inline mUINT16     WN_loop_trip_est (const WN *);
00559   friend inline mUINT16&    WN_loop_trip_est (WN *);
00560   friend inline mUINT16     WN_loop_depth (const WN *);
00561   friend inline mUINT16&    WN_loop_depth (WN *);
00562 
00563   friend inline mUINT16     WN_pragma_flags (const WN *);
00564   friend inline mUINT16&    WN_pragma_flags (WN *);
00565   friend inline mUINT16     WN_pragma (const WN *);
00566   friend inline mUINT16&    WN_pragma (WN *);
00567   friend inline UINT32      WN_pragma_asm_opnd_num (const WN *);
00568   friend inline void        WN_set_pragma_asm_opnd_num (WN *, UINT32);
00569 
00570 //friend inline TY_IDX      WN_io_item_ty (const WN *);
00571 //friend inline TY_IDX&     WN_io_item_ty (WN *);
00572 
00573   friend inline REGION_KIND WN_region_kind (const WN *);
00574   friend inline void        WN_set_region_kind (WN *, REGION_KIND);
00575   friend inline mUINT32     WN_region_id (const WN *);
00576   friend inline void        WN_set_region_id (WN *, mUINT32);
00577 
00578   friend inline ST_IDX      WN_st_idx (const WN *);
00579   friend inline ST_IDX&     WN_st_idx (WN *);
00580 //friend inline TY_IDX      WN_ty (const WN *);
00581 //friend inline TY_IDX&     WN_ty (WN *);
00582   friend inline INTRINSIC   WN_intrinsic (const WN *);
00583   friend inline INTRINSIC&  WN_intrinsic (WN *);
00584   friend inline IOSTATEMENT WN_io_statement(const WN *);
00585   friend inline IOSTATEMENT&  WN_io_statement(WN *);
00586   friend inline IOITEM      WN_io_item(const WN *);
00587   friend inline IOITEM&     WN_io_item(WN *);
00588 //friend inline INT32       WN_num_dim (const WN *);
00589 //friend inline INT32&      WN_num_dim (WN *);
00590   friend inline UINT32      WN_prefetch_flag (const WN *);
00591   friend inline UINT32&     WN_prefetch_flag (WN *);
00592   friend inline UINT32      WN_loop_flag (const WN *);
00593   friend inline UINT32&     WN_loop_flag (WN *);
00594   friend inline INT32       WN_last_label (const WN *);
00595   friend inline INT32&      WN_last_label (WN *);
00596   friend inline INITO_IDX   WN_ereg_supp (const WN *);
00597   friend inline INITO_IDX&  WN_ereg_supp (WN *);
00598 
00599   friend inline WN_ESIZE    WN_element_size (const WN *);
00600   friend inline WN_ESIZE&   WN_element_size (WN *);
00601 
00602   friend inline OPERATOR    WN_operator (const WN *);
00603   friend inline void        WN_set_operator (WN *, OPERATOR);
00604   friend inline TYPE_ID     WN_rtype (const WN *);
00605   friend inline void        WN_set_rtype (WN *, TYPE_ID);
00606   friend inline INT         WN_kid_count (const WN *);
00607   friend inline void        WN_set_kid_count (WN *, UINT);
00608   friend inline UINT        WN_field_id (const WN *);
00609   friend inline void        WN_set_field_id (WN *, UINT);
00610   friend inline UINT        WN_bit_offset (const WN *);
00611   friend inline void        WN_set_bit_offset (WN *, UINT);
00612   friend inline UINT        WN_bit_size (const WN *);
00613   friend inline void        WN_set_bit_size (WN *, UINT);
00614   friend inline TYPE_ID     WN_desc (const WN *);
00615   friend inline void        WN_set_desc (WN *, TYPE_ID);
00616   friend inline INT32       WN_map_id (const WN *);
00617   friend inline INT32&      WN_map_id (WN *);
00618 
00619   friend inline TY_IDX      WN_ty (const WN *, const int);
00620   friend inline TY_IDX&     WN_ty (WN *, const int);
00621   friend inline WN*         WN_kid (const WN *, const int);
00622   friend inline WN*&        WN_kid (WN *, const int);
00623   friend inline WN*         WN_kid0 (const WN *);
00624   friend inline WN*&        WN_kid0 (WN *);
00625   friend inline WN*         WN_kid1 (const WN *);
00626   friend inline WN*&        WN_kid1 (WN *);
00627   friend inline WN*         WN_kid2 (const WN *);
00628   friend inline WN*&        WN_kid2 (WN *);
00629   friend inline WN*         WN_kid3 (const WN *);
00630   friend inline WN*&        WN_kid3 (WN *);
00631   friend inline INT64       WN_const_val (const WN *);
00632   friend inline INT64&      WN_const_val (WN *);
00633   friend inline UINT32      WN_label_flag (const WN *);
00634   friend inline UINT32&     WN_label_flag (WN *);
00635 
00636   friend inline WN*         WN_first (const WN *);
00637   friend inline WN*&        WN_first (WN *);
00638   friend inline WN*         WN_last (const WN *);
00639   friend inline WN*&        WN_last (WN *);
00640 
00641   friend inline INT64       WN_pragma_arg64 (const WN *);
00642   friend inline INT64&      WN_pragma_arg64 (WN *);
00643   friend inline INT32       WN_pragma_arg1 (const WN *);
00644   friend inline INT32&      WN_pragma_arg1 (WN *);
00645   friend inline INT32       WN_pragma_arg2 (const WN *);
00646   friend inline INT32&      WN_pragma_arg2 (WN *);
00647   friend inline mINT8       WN_pragma_distr_type (const WN *);
00648   friend inline mINT8&      WN_pragma_distr_type (WN *);
00649   friend inline mINT8       WN_pragma_index (const WN *);
00650   friend inline mINT8&      WN_pragma_index (WN *);
00651   friend inline INT32       WN_pragma_preg (const WN *);
00652   friend inline INT32&      WN_pragma_preg (WN *);
00653 
00654   friend inline char *      WN_pragma_asm_constraint (const WN *);
00655   friend inline PREG_NUM    WN_pragma_asm_copyout_preg (const WN *);
00656   friend inline void        WN_set_pragma_asm_copyout_preg (WN *, PREG_NUM);
00657 
00658   friend inline OPCODE      WN_opcode (const WN*);
00659   friend inline void        WN_set_opcode (WN*, OPCODE);
00660   friend inline TY_IDX      WN_ty (const WN*);
00661   friend inline void        WN_set_ty (WN*, TY_IDX);
00662   friend inline TY_IDX      WN_load_addr_ty (const WN *);
00663   friend inline void        WN_set_load_addr_ty (WN*, TY_IDX);
00664 
00665   friend inline void        WN_Copy_u1u2 (WN*, const WN*);
00666   friend inline void        WN_Copy_u3 (WN*, const WN*);
00667 
00668 #endif /* WN_NO_ACCESSOR_FUNCTIONS */
00669 };
00670 
00671 #ifndef WN_NO_ACCESSOR_FUNCTIONS
00672 
00673 inline WN_OFFSET  WN_load_offset (const WN* wn) { return wn->u1u2.uu.ua.load_offset; }
00674 inline WN_OFFSET& WN_load_offset (WN* wn) { return wn->u1u2.uu.ua.load_offset; }
00675 inline WN_OFFSET  WN_lda_offset (const WN* wn) { return wn->u1u2.uu.ua.lda_offset; }
00676 inline WN_OFFSET& WN_lda_offset (WN* wn) { return wn->u1u2.uu.ua.lda_offset; }
00677 inline WN_OFFSET  WN_store_offset (const WN* wn) { return wn->u1u2.uu.ua.store_offset; }
00678 inline WN_OFFSET& WN_store_offset (WN* wn) { return wn->u1u2.uu.ua.store_offset; }
00679 inline WN_OFFSET  WN_idname_offset (const WN* wn) { return wn->u1u2.uu.ua.idname_offset; }
00680 inline WN_OFFSET& WN_idname_offset (WN* wn) { return wn->u1u2.uu.ua.idname_offset; }
00681 inline WN_OFFSET  WN_offset (const WN* wn) { return wn->u1u2.uu.ua.idname_offset; }
00682 inline WN_OFFSET& WN_offset (WN* wn) { return wn->u1u2.uu.ua.idname_offset; }
00683 inline INT32  WN_num_entries (const WN* wn) { return wn->u1u2.uu.ua.num_entries; }
00684 inline INT32& WN_num_entries (WN* wn) { return wn->u1u2.uu.ua.num_entries; }
00685 inline INT16 WN_cvtl_bits (const WN* wn) { return wn->u1u2.uu.ua.cvtl_bits; }
00686 inline INT16& WN_cvtl_bits (WN* wn) { return wn->u1u2.uu.ua.cvtl_bits; }
00687 inline INT32 WN_label_number (const WN* wn) { return wn->u1u2.uu.ua.label_number; }
00688 inline INT32& WN_label_number (WN* wn) { return wn->u1u2.uu.ua.label_number; }
00689 inline UINT32 WN_call_flag (const WN* wn) { return wn->u1u2.uu.ua.call_flag; }
00690 inline UINT32& WN_call_flag (WN* wn) { return wn->u1u2.uu.ua.call_flag; }
00691 
00692 inline UINT32 WN_eq_logical_flag (const WN* wn) { return wn->u1u2.uu.ua.eq_logical_flag; }
00693 inline UINT32& WN_eq_logical_flag (WN* wn) { return wn->u1u2.uu.ua.eq_logical_flag; }
00694 
00695 inline UINT32 WN_if_flag (const WN* wn) { return wn->u1u2.uu.ua.if_flag; }
00696 inline UINT32& WN_if_flag (WN* wn) { return wn->u1u2.uu.ua.if_flag; }
00697 inline UINT32 WN_io_flag (const WN* wn) { return wn->u1u2.uu.ua.io_flag; }
00698 inline UINT32& WN_io_flag (WN* wn) { return wn->u1u2.uu.ua.io_flag; }
00699 inline UINT32 WN_asm_flag (const WN *wn) { return wn->u1u2.uu.ua.asm_flag; }
00700 inline UINT32& WN_asm_flag (WN *wn) { return wn->u1u2.uu.ua.asm_flag; }
00701 inline UINT32 WN_label_level (const WN *wn) { return wn->u1u2.uu.ub.label_level; }
00702 inline UINT32& WN_label_level (WN *wn) { return wn->u1u2.uu.ub.label_level; }
00703 inline mUINT16 WN_loop_trip_est (const WN* wn) { return wn->u1u2.uu.ua.li.trip_est; }
00704 inline mUINT16& WN_loop_trip_est (WN* wn) { return wn->u1u2.uu.ua.li.trip_est; }
00705 inline mUINT16 WN_loop_depth (const WN* wn) { return wn->u1u2.uu.ua.li.loop_depth; }
00706 inline mUINT16& WN_loop_depth (WN* wn) { return wn->u1u2.uu.ua.li.loop_depth; }
00707 inline mUINT16 WN_pragma_flags (const WN* wn) { return wn->u1u2.uu.ua.pragma.pragma_flags; }
00708 inline mUINT16& WN_pragma_flags (WN* wn) { return wn->u1u2.uu.ua.pragma.pragma_flags; }
00709 inline mUINT16 WN_pragma (const WN* wn) { return wn->u1u2.uu.ua.pragma.pragma_id; }
00710 inline mUINT16& WN_pragma (WN* wn) { return wn->u1u2.uu.ua.pragma.pragma_id; }
00711 
00712 inline char *WN_pragma_asm_constraint(const WN *wn) { return ST_name(&St_Table[(ST_IDX) WN_pragma_arg1(wn)]); }
00713 inline PREG_NUM WN_pragma_asm_copyout_preg(const WN *wn) { return wn->u3.pragma.up1.asm_pragma.pragma_asm_copyout_preg; }
00714 inline void WN_set_pragma_asm_copyout_preg(WN *wn, PREG_NUM r) { wn->u3.pragma.up1.asm_pragma.pragma_asm_copyout_preg = r; }
00715 inline UINT32 WN_pragma_asm_opnd_num(const WN *wn) { return wn->u3.pragma.up1.asm_pragma.pragma_asm_opnd_num; }
00716 inline void WN_set_pragma_asm_opnd_num(WN *wn, UINT32 i) { wn->u3.pragma.up1.asm_pragma.pragma_asm_opnd_num = i; }
00717 
00718 inline REGION_KIND WN_region_kind (const WN* wn) { return wn->u1u2.uu.ua.region.region_kind; }
00719 inline void WN_set_region_kind (WN* wn, REGION_KIND k) { wn->u1u2.uu.ua.region.region_kind = k; }
00720 inline mUINT32 WN_region_id (const WN* wn) { return wn->u1u2.uu.ua.region.region_id; }
00721 inline void WN_set_region_id (WN* wn, mUINT32 i) { wn->u1u2.uu.ua.region.region_id = i; }
00722 
00723 inline ST_IDX WN_st_idx (const WN* wn) { return wn->u1u2.uu.ub.st_idx; }
00724 inline ST_IDX& WN_st_idx (WN* wn) { return wn->u1u2.uu.ub.st_idx; }
00725 inline INTRINSIC WN_intrinsic (const WN* wn) { return wn->u1u2.uu.ub.intrinsic; }
00726 inline INTRINSIC& WN_intrinsic (WN* wn) { return wn->u1u2.uu.ub.intrinsic; }
00727 inline IOSTATEMENT WN_io_statement(const WN* wn) { return wn->u1u2.uu.ub.iostatement; }
00728 inline IOSTATEMENT& WN_io_statement(WN* wn) { return wn->u1u2.uu.ub.iostatement; }
00729 inline IOITEM WN_io_item(const WN* wn) { return wn->u1u2.uu.ub.ioitem; }
00730 inline IOITEM & WN_io_item(WN* wn) { return wn->u1u2.uu.ub.ioitem; }
00731 inline UINT32 WN_prefetch_flag (const WN* wn) { return wn->u1u2.uu.ub.prefetch_flag; }
00732 inline UINT32& WN_prefetch_flag (WN* wn) { return wn->u1u2.uu.ub.prefetch_flag; }
00733 inline UINT32 WN_loop_flag (const WN* wn) { return wn->u1u2.uu.ub.loop_flag; }
00734 inline UINT32& WN_loop_flag (WN* wn) { return wn->u1u2.uu.ub.loop_flag; }
00735 inline INT32 WN_last_label (const WN* wn) { return wn->u1u2.uu.ub.last_label; }
00736 inline INT32& WN_last_label (WN* wn) { return wn->u1u2.uu.ub.last_label; }
00737 inline INITO_IDX WN_ereg_supp (const WN* wn) { return wn->u1u2.uu.ub.ereg_supp; }
00738 inline INITO_IDX& WN_ereg_supp (WN* wn) { return wn->u1u2.uu.ub.ereg_supp; }
00739 inline WN_ESIZE WN_element_size (const WN* wn) { return wn->u1u2.element_size; }
00740 inline WN_ESIZE& WN_element_size (WN* wn) { return wn->u1u2.element_size; }
00741 
00742 inline OPERATOR   WN_operator (const WN* wn) { return wn->common.wn_operator; }
00743 inline void       WN_set_operator (WN* wn, OPERATOR opr) { wn->common.wn_operator = opr; }
00744 inline TYPE_ID    WN_rtype (const WN* wn) { return wn->common.rtype; }
00745 inline void       WN_set_rtype (WN* wn, TYPE_ID ty) { wn->common.rtype = ty; }
00746 inline INT        WN_kid_count (const WN* wn) { return OPERATOR_nkids(WN_operator(wn)) == -1 ? wn->common.kid_count : OPERATOR_nkids(WN_operator(wn)); }
00747 inline void       WN_set_kid_count (WN* wn, UINT n) { if (OPERATOR_nkids(WN_operator(wn)) == -1) wn->common.kid_count = n; }
00748 inline UINT       WN_field_id (const WN* wn) { return wn->common.kid_count; }
00749 inline void       WN_set_field_id (WN* wn, UINT n) { wn->common.kid_count = (n > MAX_FIELD_ID) ? UNKNOWN_FIELD_ID : n; }
00750 inline UINT       WN_bit_offset (const WN* wn) { return wn->common.kid_count >> 7; }
00751 inline UINT       WN_bit_size (const WN* wn) { return wn->common.kid_count & 0x7f; }
00752 inline void       WN_set_bit_offset_size (WN* wn, UINT ofst, UINT siz) { wn->common.kid_count = ((ofst << 7) + siz); }
00753 inline TYPE_ID    WN_desc (const WN* wn) { return wn->common.desc; }
00754 inline void       WN_set_desc (WN* wn, TYPE_ID ty) { wn->common.desc = ty; }
00755 inline INT32      WN_map_id (const WN* wn) { return wn->common.map_id; }
00756 inline INT32&     WN_map_id (WN* wn) { return wn->common.map_id; }
00757 
00758 inline WN* WN_kid (const WN* wn, const int i) { return wn->u3.kids [i]; }
00759 inline WN*& WN_kid (WN* wn, const int i) { return wn->u3.kids [i]; }
00760 inline WN* WN_kid0 (const WN* wn) { return wn->u3.kids [0]; }
00761 inline WN*& WN_kid0 (WN* wn) { return wn->u3.kids [0]; }
00762 inline WN* WN_kid1 (const WN* wn) { return wn->u3.kids [1]; }
00763 inline WN*& WN_kid1 (WN* wn) { return wn->u3.kids [1]; }
00764 inline WN* WN_kid2 (const WN* wn) { return wn->u3.kids [2]; }
00765 inline WN*& WN_kid2 (WN* wn) { return wn->u3.kids [2]; }
00766 inline WN* WN_kid3 (const WN* wn) { return wn->u3.kids [3]; }
00767 inline WN*& WN_kid3 (WN* wn) { return wn->u3.kids [3]; }
00768 
00769 inline INT64 WN_const_val (const WN* wn) { return wn->u3.const_val; }
00770 inline INT64& WN_const_val (WN* wn) { return wn->u3.const_val; }
00771 inline UINT32 WN_label_flag (const WN* wn) { return wn->u3.label_flag_fields.label_flag; }
00772 inline UINT32& WN_label_flag (WN* wn) { return wn->u3.label_flag_fields.label_flag; }
00773 inline WN* WN_first (const WN* wn) { return wn->u3.block.first; }
00774 inline WN*& WN_first (WN* wn) { return wn->u3.block.first; }
00775 inline WN* WN_last (const WN* wn) { return wn->u3.block.last; }
00776 inline WN*& WN_last (WN* wn) { return wn->u3.block.last; }
00777 inline UINT32 WN_asm_num_inputs (const WN *wn) { return wn->u3.asm_fields.num_inputs; }
00778 inline UINT32& WN_asm_num_inputs (WN *wn) { return wn->u3.asm_fields.num_inputs; }
00779 inline UINT32 WN_asm_opnd_num (const WN *wn) { return wn->u1u2.uu.ua.asm_operand_num; }
00780 inline UINT32& WN_asm_opnd_num (WN *wn) { return wn->u1u2.uu.ua.asm_operand_num; }
00781 inline UINT32 WN_asm_num_clobbers (const WN *wn) { return wn->u3.asm_fields.num_clobbers; }
00782 inline UINT32& WN_asm_num_clobbers (WN *wn) { return wn->u3.asm_fields.num_clobbers; }
00783 inline INT64 WN_pragma_arg64 (const WN* wn) { return wn->u3.pragma.pragma_arg64; }
00784 inline INT64& WN_pragma_arg64 (WN* wn) { return wn->u3.pragma.pragma_arg64; }
00785 inline INT32 WN_pragma_arg1 (const WN* wn) { return wn->u3.pragma.up1.pragma_arg1; }
00786 inline INT32& WN_pragma_arg1 (WN* wn) { return wn->u3.pragma.up1.pragma_arg1; }
00787 inline INT32 WN_pragma_arg2 (const WN* wn) { return wn->u3.pragma.up1.pragma_arg2; }
00788 inline INT32& WN_pragma_arg2 (WN* wn) { return wn->u3.pragma.up1.pragma_arg2; }
00789 inline mINT8 WN_pragma_distr_type (const WN* wn) { return wn->u3.pragma.up2.pragma_distr_type; }
00790 inline mINT8& WN_pragma_distr_type (WN* wn) { return wn->u3.pragma.up2.pragma_distr_type; }
00791 inline mINT8 WN_pragma_index (const WN* wn) { return wn->u3.pragma.up2.pragma_index; }
00792 inline mINT8& WN_pragma_index (WN* wn) { return wn->u3.pragma.up2.pragma_index; }
00793 inline INT32 WN_pragma_preg (const WN* wn) { return wn->u3.pragma.up2.pragma_preg; }
00794 inline INT32& WN_pragma_preg (WN* wn) { return wn->u3.pragma.up2.pragma_preg; }
00795 
00796 
00797 
00798 inline void WN_Copy_u1u2 (WN* dst, const WN* src) { dst->u1u2 = src->u1u2; }
00799 inline void WN_Copy_u3 (WN* dst, const WN* src) { dst->u3 = src->u3; }
00800 
00801 #else
00802 
00803 #define WN_load_offset(x)       ((x)->u1u2.uu.ua.load_offset)
00804 #define WN_lda_offset(x)        ((x)->u1u2.uu.ua.lda_offset)
00805 #define WN_store_offset(x)      ((x)->u1u2.uu.ua.store_offset)
00806 #define WN_idname_offset(x)     ((x)->u1u2.uu.ua.idname_offset)
00807 #define WN_offset(x)            ((x)->u1u2.uu.ua.idname_offset)
00808 #define WN_num_entries(x)       ((x)->u1u2.uu.ua.num_entries)
00809 #define WN_cvtl_bits(x)         ((x)->u1u2.uu.ua.cvtl_bits)
00810 #define WN_label_number(x)      ((x)->u1u2.uu.ua.label_number)
00811 #define WN_call_flag(x)         ((x)->u1u2.uu.ua.call_flag)
00812 
00813 #define WN_eq_logical_flag(x)   ((x)->u1u2.uu.ua.eq_logical_flag)
00814 
00815 #define WN_if_flag(x)           ((x)->u1u2.uu.ua.if_flag)
00816 #define WN_io_flag(x)           ((x)->u1u2.uu.ua.io_flag)
00817 #define WN_asm_flag(x)          ((x)->u1u2.uu.ua.asm_flag)
00818 #define WN_asm_string(x)        (ST_name(WN_st(x)))
00819 #define WN_asm_input_constraint(x) (ST_name(WN_st(x)))
00820 #define WN_loop_trip_est(x)     ((x)->u1u2.uu.ua.li.trip_est)
00821 #define WN_loop_depth(x)        ((x)->u1u2.uu.ua.li.loop_depth)
00822 #define WN_pragma_flags(x)      ((x)->u1u2.uu.ua.pragma.pragma_flags)
00823 #define WN_pragma(x)            ((x)->u1u2.uu.ua.pragma.pragma_id)
00824 #define WN_pragma_asm_constraint(x) (ST_name(&St_Table[(ST_IDX) WN_pragma_arg1(wn)]))
00825 #define WN_pragma_asm_copyout_preg(x) ((PREG_NUM) (x)->u3.pragma.up1.asm_pragma.pragma_asm_copyout_preg)
00826 #define WN_pragma_asm_opnd_num(x) ((x)->u3.pragma.up1.asm_pragma.pragma_asm_opnd_num)
00827 #define WN_region_kind(x)       ((REGION_KIND)((x)->u1u2.uu.ua.region.region_kind))
00828 #define WN_set_region_kind(x,y) ((x)->u1u2.uu.ua.region.region_kind = y)
00829 #define WN_region_id(x)         ((mUINT32)((x)->u1u2.uu.ua.region.region_id))
00830 #define WN_st_idx(x)            ((x)->u1u2.uu.ub.st_idx)
00831 #define WN_intrinsic(x)         ((x)->u1u2.uu.ub.intrinsic)
00832 #define WN_io_statement(x)      ((x)->u1u2.uu.ub.iostatement)
00833 #define WN_io_item(x)           ((x)->u1u2.uu.ub.ioitem)
00834 #define WN_prefetch_flag(x)     ((x)->u1u2.uu.ub.prefetch_flag)
00835 #define WN_loop_flag(x)         ((x)->u1u2.uu.ub.loop_flag)
00836 #define WN_last_label(x)        ((x)->u1u2.uu.ub.last_label)
00837 #define WN_ereg_supp(x)         ((x)->u1u2.uu.ub.ereg_supp)
00838 
00839 #define WN_asm_num_inputs(x)    ((x)->u3.asm_fields.num_inputs)
00840 #define WN_asm_num_clobbers(x)  ((x)->u3.asm_fields.num_clobbers)
00841 
00842 #define WN_asm_opnd_num(x)      ((x)->u1u2.uu.ua.asm_operand_num)
00843 
00844 #define WN_element_size(x)      ((x)->u1u2.element_size)
00845 
00846 #define WN_operator(x)          ((OPERATOR) (x)->common.wn_operator)
00847 #define WN_set_operator(x,y)    ((x)->common.wn_operator = y)
00848 #define WN_rtype(x)             ((TYPE_ID) (x)->common.rtype)
00849 #define WN_set_rtype(x,y)       ((x)->common.rtype = y)
00850 #define WN_kid_count(x)         (OPERATOR_nkids(WN_operator(x)) == -1 ? (x)->common.kid_count : OPERATOR_nkids(WN_operator(x)))
00851 #define WN_set_kid_count(x,y)   if (OPERATOR_nkids(WN_operator(x)) == -1) (x)->common.kid_count = y; else
00852 #define WN_field_id(x)          ((x)->common.kid_count)
00853 #define WN_set_field_id(x,y)    ((x)->common.kid_count = (y > MAX_FIELD_ID) ? UNKNOWN_FIELD_ID : y)
00854 #define WN_bit_offset(x)        ((x)->common.kid_count >> 7)
00855 #define WN_bit_size(x)          ((x)->common.kid_count & 0x7f)
00856 #define WN_set_bit_offset_size(x,y,z) ((x)->common.kid_count = ((y << 7) + z))
00857 #define WN_desc(x)              ((TYPE_ID) (x)->common.desc)
00858 #define WN_set_desc(x,y)        ((x)->common.desc = y)
00859 #define WN_map_id(x)            ((x)->common.map_id)
00860 
00861 #define WN_kid(x,i)             ((x)->u3.kids[i])
00862 #define WN_kid0(x)              WN_kid((x),0)
00863 #define WN_kid1(x)              WN_kid((x),1)
00864 #define WN_kid2(x)              WN_kid((x),2)
00865 #define WN_kid3(x)              WN_kid((x),3)
00866 #define WN_const_val(x)         ((x)->u3.const_val)
00867 #define WN_label_flag(x)        ((x)->u3.label_flag_fields.label_flag)
00868 #define WN_first(x)             ((x)->u3.block.first)
00869 #define WN_last(x)              ((x)->u3.block.last)
00870 #define WN_pragma_arg64(x)      ((x)->u3.pragma.pragma_arg64)
00871 #define WN_pragma_arg1(x)       ((x)->u3.pragma.up1.pragma_arg1)
00872 #define WN_pragma_arg2(x)       ((x)->u3.pragma.up1.pragma_arg2)
00873 #define WN_pragma_distr_type(x) ((x)->u3.pragma.up2.pragma_distr_type)
00874 #define WN_pragma_index(x)      ((x)->u3.pragma.up2.pragma_index)
00875 #define WN_pragma_preg(x)       ((x)->u3.pragma.up2.pragma_preg)
00876 
00877 #define WN_Copy_u1u2(x,y)       ((x)->u1u2 = (y)->u1u2)
00878 #define WN_Copy_u3(x,y)         ((x)->u3 = (y)->u3)
00879 
00880 #endif /* WN_NO_ACCESSOR_FUNCTIONS */
00881 
00882 #define WN_num_dim(x)           (WN_kid_count(x)>>1)
00883 
00884 #define WN_asm_clobbers(x)      (WN_kid0(x))
00885 #define WN_asm_constraints(x)   (WN_kid1(x))
00886 
00887 inline OPCODE
00888 WN_opcode (const WN *wn) {
00889    return OPCODE_make_op (wn->common.wn_operator,
00890                           wn->common.rtype,
00891                           wn->common.desc);
00892 }
00893 
00894 inline void
00895 WN_set_opcode (WN *wn, OPCODE opc) {
00896   wn->common.wn_operator = OPCODE_operator(opc);
00897   wn->common.rtype       = OPCODE_rtype(opc);
00898   wn->common.desc        = OPCODE_desc(opc);
00899 }
00900 
00901 class STMT_WN_BASE {
00902  public:
00903   WN      *prev;
00904   WN      *next;
00905   mUINT64 linenum;
00906 };
00907 
00908 class STMT_WN : public STMT_WN_BASE {
00909 public:
00910   WN       wn;
00911 
00912 #ifndef WN_NO_ACCESSOR_FUNCTIONS
00913   friend inline WN* WN_prev (const WN*);
00914   friend inline WN*& WN_prev (WN*);
00915   friend inline WN* WN_next (const WN*);
00916   friend inline WN*& WN_next (WN*);
00917   friend inline mUINT64 WN_linenum (const WN*);
00918   friend inline mUINT64& WN_linenum (WN*);
00919   friend inline void* WN_StartAddress (WN*);
00920   friend inline WN* WN_prev_free (const STMT_WN*);
00921   friend inline WN*& WN_prev_free (STMT_WN*);
00922   friend inline WN& WN_real_fields (STMT_WN*);
00923 #endif /* WN_NO_ACCESSOR_FUNCTIONS */
00924 };
00925 
00926 //#define WN_OFFSET_IN_STMT_WN (offsetof(STMT_WN,wn))
00927 //#define WN_CAST_WN_TO_STMT_WN(x) ((STMT_WN *)((UINTPS)x - WN_OFFSET_IN_STMT_WN))
00928 
00929 #define WN_CAST_WN_TO_STMT_WN(x) ((STMT_WN *)( (STMT_WN_BASE *)x - 1))
00930 
00931 #ifndef WN_NO_ACCESSOR_FUNCTIONS
00932 inline WN* WN_prev (const WN* wn) { return (WN_CAST_WN_TO_STMT_WN(wn)->prev); }
00933 inline WN*& WN_prev (WN* wn) { return (WN_CAST_WN_TO_STMT_WN(wn)->prev); }
00934 inline WN* WN_next (const WN* wn) { return (WN_CAST_WN_TO_STMT_WN(wn)->next); }
00935 inline WN*& WN_next (WN* wn) { return (WN_CAST_WN_TO_STMT_WN(wn)->next); }
00936 inline mUINT64 WN_linenum (const WN* wn) { return (WN_CAST_WN_TO_STMT_WN(wn)->linenum); }
00937 inline mUINT64& WN_linenum (WN* wn) { return (WN_CAST_WN_TO_STMT_WN(wn)->linenum); }
00938 inline WN* WN_prev_free (const STMT_WN* stmt_wn) { return stmt_wn->prev; }
00939 inline WN*& WN_prev_free (STMT_WN* stmt_wn) { return stmt_wn->prev; }
00940 inline WN& WN_real_fields (STMT_WN* stmt_wn) { return stmt_wn->wn; }
00941 #else
00942 #define WN_next(x)          (WN_CAST_WN_TO_STMT_WN(x)->next)
00943 #define WN_next_func(x)     (WN_CAST_WN_TO_STMT_WN(x)->next)
00944 #define WN_prev(x)          (WN_CAST_WN_TO_STMT_WN(x)->prev)
00945 #define WN_linenum(x)       (WN_CAST_WN_TO_STMT_WN(x)->linenum)
00946 /* Note: the following are only used internally for creating WNs and
00947    maintaining free lists; they should not be used outside of wn.c */
00948 #define WN_real_fields(x)   ((x)->wn)
00949 #define WN_prev_free(x)     ((x)->prev)
00950 #endif /* WN_NO_ACCESSOR_FUNCTIONS */
00951 
00952 #define WN_has_sym(x)           (OPERATOR_has_sym(WN_operator(x)))
00953 
00954 /*REFERENCED*/
00955 inline ST *
00956 WN_st (const WN *x)
00957   {
00958     Is_True(WN_has_sym(x), ("WN_st: wn doesn't have ST field"));
00959     Is_True(ST_IDX_index(WN_st_idx(x)) != 0 ||
00960             WN_st_idx(x) == 0,
00961             ("WN_st: zero index in nonzero level disallowed"));
00962     return (WN_st_idx(x) != 0 ?
00963             &St_Table[WN_st_idx(x)] :
00964             NULL);
00965   }
00966 
00967 #ifndef WN_NO_ACCESSOR_FUNCTIONS
00968 inline char * WN_asm_string(const WN *wn) { return ST_name(WN_st(wn)); }
00969 inline char * WN_asm_input_constraint(const WN *wn) { return ST_name(WN_st(wn)); }
00970 #endif
00971 
00972 #define WN_parm_flag(x)     WN_call_flag(x)
00973 #define WN_region_is_EH(x)  (WN_region_kind(x) & REGION_KIND_EH)
00974 #define WN_label_loop_info(x)   \
00975                 (WN_kid_count(x)>0 ? WN_kid((x),0) : NULL)
00976 #define WN_set_label_loop_info(x,li) (WN_kid0(x) = (li))
00977 
00978 /* for pragma flags */
00979 
00980 #define WN_PRAGMA_COMPILER_GENERATED 0x01
00981 #define WN_PRAGMA_OMP                0x02
00982 
00983 #define WN_pragma_compiler_generated(x) ((WN_pragma_flags(x))&WN_PRAGMA_COMPILER_GENERATED)
00984 #define WN_set_pragma_compiler_generated(x) ((WN_pragma_flags(x))|=WN_PRAGMA_COMPILER_GENERATED)
00985 #define WN_pragma_omp(x) ((WN_pragma_flags(x)) & WN_PRAGMA_OMP)
00986 #define WN_set_pragma_omp(x) ((WN_pragma_flags(x)) |= WN_PRAGMA_OMP)
00987 #define WN_reset_pragma_omp(x) ((WN_pragma_flags(x)) &= ~(WN_PRAGMA_OMP))
00988 
00989 /* for FUNC_ENTRY: */
00990 #define WN_entry_name(x)    WN_st_idx(x)
00991 #define WN_formal(x,i)      WN_kid((x),i)
00992 #define WN_num_formals(x)   (WN_kid_count(x)-3)
00993 #define WN_func_pragmas(x)  WN_kid((x),WN_kid_count(x)-3)
00994 #define WN_func_varrefs(x)  WN_kid((x),WN_kid_count(x)-2)
00995 #define WN_func_body(x)     WN_kid((x),WN_kid_count(x)-1)
00996 #define WN_entry_first(x)   WN_first(WN_func_body(x))
00997 #define WN_entry_last(x)    WN_last(WN_func_body(x))
00998 #define WN_actual(x,i)      WN_kid((x),i)
00999 
01000 /* for DO_LOOP: */
01001 #define WN_index(x)         WN_kid((x),0)
01002 #define WN_start(x)         WN_kid((x),1)
01003 #define WN_end(x)           WN_kid((x),2)
01004 #define WN_step(x)          WN_kid((x),3)
01005 #define WN_do_body(x)       WN_kid((x),4)
01006 #define WN_do_loop_info(x)  \
01007                 (WN_kid_count(x)>5 ? WN_kid((x),5) : NULL)
01008 #define WN_set_do_loop_info(x,li)  (WN_kid((x),5) = (li))
01009 
01010 #define WN_while_test(x)    WN_kid((x),0)
01011 #define WN_while_body(x)    WN_kid((x),1)
01012 
01013 #define WN_if_test(x)       WN_kid((x),0)
01014 #define WN_then(x)          WN_kid((x),1)
01015 #define WN_else(x)          WN_kid((x),2)
01016 #define WN_else_is_empty(x) (WN_first(WN_else(x)) == NULL)
01017 
01018 #define WN_region_exits(x)  WN_kid((x),0)
01019 #define WN_region_pragmas(x) WN_kid((x),1)
01020 #define WN_region_body(x)   WN_kid((x),2)
01021 
01022 #define WN_array_index(x,i) WN_kid((x),WN_num_dim(x)+i+1)
01023 #define WN_array_dim(x,i)   WN_kid((x),i+1)
01024 #define WN_array_base(x)    WN_kid((x),0)
01025 
01026 /* for LOOP_INFO: */
01027 #define WN_loop_induction(x)\
01028                 (WN_kid_count(x)>0 ? WN_kid((x),0) : NULL)
01029 #define WN_set_loop_induction(x,ind) (WN_kid((x),0) = (ind))
01030 #define WN_loop_trip(x)     \
01031                 (WN_kid_count(x)>1 ? WN_kid((x),1) : NULL)
01032 #define WN_set_loop_trip(x,trip) (WN_kid((x),1) = (trip))
01033 
01034 /* for SWITCH: */
01035 #define WN_switch_test(x)       WN_kid((x),0)
01036 #define WN_switch_table(x)      WN_kid((x),1)
01037 #define WN_switch_default(x)    WN_kid((x),2)
01038 
01039 #if (defined(_LP64) || defined(__GNUC__)) && !defined(_SGI_COMPILER_VERSION)
01040 /* workaround for g++ bug */
01041 #else
01042 #define max(a,b)  ((a > b) ? a : b)
01043 #endif
01044 
01045 
01046 
01047 /* ====================================================================
01048  *
01049  * OPERATOR WN_operator(x)
01050  *      Return OPERATOR associated with WN_opcode(x)
01051  *
01052  * BOOL WN_operator_is(x,y)
01053  *      Return true if WN_operator(x) == y
01054  *
01055  * TYPE_ID WN_rtype(x)
01056  * TYPE_ID WN_desc(x)
01057  *      Return type of WN *x
01058  *
01059  * TY *WN_type(x)
01060  *      Return ty of WN *x
01061  *
01062  * ST_CLASS WN_class(x)
01063  *      Return ST_CLASS of WN *x
01064  *
01065  * ST_SCLASS WN_sclass(x)
01066  *      Return ST_SCLASS of WN *x
01067  *
01068  * ====================================================================
01069  */
01070 
01071 /* WN_opcode() compound */
01072 /*
01073 #define WN_operator(x)          (OPCODE_operator(WN_opcode(x)))
01074 #define WN_rtype(x)             (OPCODE_rtype(WN_opcode(x)))
01075 #define WN_desc(x)              (OPCODE_desc(WN_opcode(x)))
01076 */
01077 #define WN_operator_is(x,y)     (WN_operator(x)==(y))
01078 
01079 /* WN_st() compound */
01080 #define WN_class(x)             (ST_class(WN_st(x)))
01081 #define WN_sclass(x)            (ST_sclass(WN_st(x)))
01082 #define WN_type(x)              (ST_type(WN_st(x)))
01083 /*REFERENCED*/
01084 inline TCON&
01085 WN_val (const WN *x)            { return ST_tcon_val (WN_st(x)); }
01086 /*REFERENCED*/
01087 inline TYPE_ID
01088 WN_val_type (const WN *x)       { return TCON_ty (WN_val (x)); }
01089 
01090 
01091 #define WN_has_map_id(x)        (WN_map_id(x)!= -1)
01092 
01093 #define WN_block_empty(x)       (WN_first(x) == NULL)
01094 #define WN_block_nonempty(x)    (WN_first(x) != NULL)
01095 
01096 
01097 
01098 
01099 
01100 /* types */
01101 /*REFERENCED*/
01102 inline TY_IDX WN_ty(const WN *wn)
01103 {
01104   OPERATOR opr;
01105   opr = WN_operator(wn);
01106   if ((opr == OPR_LDA) || (opr == OPR_LDID) || (opr == OPR_STID) ||
01107       (opr == OPR_LDBITS) || (opr == OPR_STBITS)|| (opr == OPR_PSTID)) {
01108     return(wn->u3.ty_fields.ty);
01109   } else if (opr == OPR_IO_ITEM) {
01110     return (wn->u1u2.uu.ua.io_item_ty);
01111   } else {
01112     return (wn->u1u2.uu.ub.ty);
01113   }
01114 }
01115 
01116 /*REFERENCED*/
01117 inline void WN_set_ty(WN *wn, TY_IDX ty)
01118 {
01119   OPERATOR opr;
01120   opr = WN_operator(wn);
01121   if ((opr == OPR_LDA) || (opr == OPR_LDID) || (opr == OPR_STID) ||
01122       (opr == OPR_LDBITS) || (opr == OPR_STBITS)|| (opr == OPR_PSTID)) {
01123     wn->u3.ty_fields.ty = ty;
01124   } else if (opr == OPR_IO_ITEM) {
01125     wn->u1u2.uu.ua.io_item_ty = ty;
01126   } else {
01127     wn->u1u2.uu.ub.ty = ty;
01128   }
01129 }
01130 
01131 
01132 
01133 /*REFERENCED*/
01134 inline TY_IDX WN_load_addr_ty(const WN *wn)
01135 {
01136   OPERATOR opr;
01137   opr = WN_operator(wn);
01138   if (opr == OPR_ILOAD || opr == OPR_ILDBITS) { 
01139     return(wn->u3.ty_fields.ty);
01140   } else {
01141     return (wn->u1u2.uu.ua.loadx_addr_ty);
01142   }
01143 }
01144 
01145 /*REFERENCED*/
01146 inline void WN_set_load_addr_ty(WN *wn, TY_IDX ty)
01147 {
01148   OPERATOR opr;
01149   opr = WN_operator(wn);
01150   if (opr == OPR_ILOAD || opr == OPR_ILDBITS) {
01151     wn->u3.ty_fields.ty = ty;
01152   } else {
01153     wn->u1u2.uu.ua.loadx_addr_ty = ty;
01154   }
01155 }
01156 
01157 
01158 
01159 
01160 /* flags */
01161 /*REFERENCED*/
01162 inline UINT32 WN_flag(const WN *wn)
01163 {
01164   OPERATOR opr;
01165   opr = WN_operator(wn);
01166   switch (opr) {
01167   case OPR_CALL:
01168   case OPR_ICALL:
01169   case OPR_PICCALL:
01170   case OPR_INTRINSIC_CALL:
01171   case OPR_INTRINSIC_OP:
01172   case OPR_REGION:
01173   case OPR_PARM:
01174     return(WN_call_flag(wn));
01175   case OPR_PREFETCH:
01176   case OPR_PREFETCHX:
01177     return(WN_prefetch_flag(wn));
01178   case OPR_IF:
01179     return (WN_if_flag(wn));
01180   case OPR_LOOP_INFO:
01181     return (WN_loop_flag(wn));
01182   case OPR_IO:
01183     return (WN_io_flag(wn));
01184   case OPR_ASM_STMT:
01185     return (WN_asm_flag(wn));
01186 
01187   case OPR_EQ:
01188   case OPR_NE:
01189     return (WN_eq_logical_flag(wn));
01190 
01191   default:
01192     return(WN_label_flag(wn));
01193   }
01194 }
01195 
01196 /*REFERENCED*/
01197 inline void WN_set_flag(WN *wn, UINT32 flag)
01198 {
01199   OPERATOR opr;
01200   opr = WN_operator(wn);
01201   switch (opr) {
01202   case OPR_CALL:
01203   case OPR_ICALL:
01204   case OPR_PICCALL:
01205   case OPR_INTRINSIC_CALL:
01206   case OPR_INTRINSIC_OP:
01207   case OPR_REGION:
01208   case OPR_PARM:
01209     WN_call_flag(wn) = flag;
01210     break;
01211   case OPR_PREFETCH:
01212   case OPR_PREFETCHX:
01213     WN_prefetch_flag(wn) = flag;
01214     break;
01215   case OPR_IF:
01216     WN_if_flag(wn) = flag;
01217     break;
01218   case OPR_IO:
01219     WN_io_flag(wn) = flag;
01220     break;
01221   case OPR_LOOP_INFO:
01222     WN_loop_flag(wn) = flag;
01223     break;
01224   case OPR_EQ:
01225   case OPR_NE:
01226     WN_eq_logical_flag(wn) =flag;
01227 
01228   default:
01229     WN_label_flag(wn) = flag;
01230     break;
01231   }
01232 }
01233 
01234 
01235 /* return starting address of wn */
01236 /*REFERENCED*/
01237 inline void *WN_StartAddress(WN *wn)
01238 {
01239   if (OPCODE_has_next_prev(WN_opcode(wn))) {
01240     return((void *)WN_CAST_WN_TO_STMT_WN(wn));
01241   } else return((void *) wn);
01242 }
01243 
01244 /* return size of wn */
01245 /*REFERENCED*/
01246 inline INT32 WN_Size(WN *wn)
01247 {
01248   INT16 extra_kids = max(0,WN_kid_count(wn)-2);
01249   if (OPCODE_has_next_prev(WN_opcode(wn))) {
01250     return(sizeof(WN) + (2+extra_kids)*sizeof(WN*) + sizeof(mUINT64));
01251   } else {
01252     return(sizeof(WN) + (0+extra_kids)*sizeof(WN*));
01253   }
01254 }
01255 
01256 /*REFERENCED*/
01257 inline void WN_Set_Linenum(WN *wn, INT64 ln)
01258 {
01259   Is_True(OPCODE_has_next_prev(WN_opcode(wn)),
01260         ("can only set line numbers for statements"));
01261   WN_linenum(wn) = ln;
01262 }
01263 
01264 /*REFERENCED*/
01265 inline INT64 WN_Get_Linenum(const WN *wn)
01266 {
01267   if (OPCODE_has_next_prev(WN_opcode(wn))) {
01268     return WN_linenum(wn);
01269   } else {
01270     return 0;
01271   }
01272 }
01273 
01274 
01275 /*REFERENCED*/
01276 inline BOOL WN_Is_Volatile_Mem(const WN *wn)
01277 {
01278   OPCODE opc = WN_opcode(wn);
01279   if (OPCODE_has_1ty(opc) || OPCODE_has_2ty(opc)) {
01280     if (OPCODE_operator(opc) == OPR_ISTORE ||
01281         OPCODE_operator(opc) == OPR_PSTORE ||
01282         OPCODE_operator(opc) == OPR_MSTORE) {
01283       TY_IDX pointed = TY_pointed (Ty_Table[WN_ty (wn)]);
01284       DevAssert(pointed, ("TY_pointed of ISTORE/MSTORE type is NULL"));
01285       return TY_is_volatile(pointed);
01286     } else {
01287       return TY_is_volatile(WN_ty(wn)) ||
01288         OPCODE_has_2ty(opc) && TY_is_volatile(WN_load_addr_ty(wn));
01289     }
01290   }
01291   return FALSE;
01292 }
01293 
01294 
01295 #define WN_IF_IS_GUARD 0x1
01296 #define WN_Is_If_Guard(x)       (WN_if_flag(x) & WN_IF_IS_GUARD)        
01297 #define WN_Set_If_Guard(x)      (WN_if_flag(x) |= WN_IF_IS_GUARD)       
01298 #define WN_Reset_If_Guard(x)    (WN_if_flag(x) &= ~(WN_IF_IS_GUARD))    
01299 
01300 #define WN_IF_IS_MPVERSION 0x2
01301 #define WN_Is_If_MpVersion(x)    (WN_if_flag(x) & WN_IF_IS_MPVERSION)   
01302 #define WN_Set_If_MpVersion(x)   (WN_if_flag(x) |= WN_IF_IS_MPVERSION)  
01303 #define WN_Reset_If_MpVersion(x) (WN_if_flag(x) &= ~(WN_IF_IS_MPVERSION))       
01304 
01305 #define WN_LABEL_BREAK 0x1
01306 #define WN_Label_Is_Break(x)            (WN_label_flag(x) & WN_LABEL_BREAK)
01307 #define WN_Set_Label_Is_Break(x)        (WN_label_flag(x) |= WN_LABEL_BREAK)
01308 #define WN_Reset_Label_Is_Break(x)      (WN_label_flag(x) &= ~(WN_LABEL_BREAK))
01309 
01310 /* WN_loop_flag stuff */
01311 
01312 #define WN_LOOP_INNERMOST 0x1
01313 #define WN_LOOP_WINDDOWN_REG 0x2
01314 #define WN_LOOP_WINDDOWN_CACHE 0x4
01315 #define WN_LOOP_UNIMPORTANT_MISC 0x8
01316 #define WN_LOOP_NZ_TRIP 0x10
01317 
01318 /* Is the trip count estimate based on guessing the size of symbols */
01319 #define WN_LOOP_SYMB_TRIP 0x20
01320 
01321 /* Is the loop an innermost loop */
01322 #define WN_Loop_Innermost(x)            (WN_loop_flag(x) & WN_LOOP_INNERMOST)
01323 #define WN_Set_Loop_Innermost(x)        (WN_loop_flag(x) |= WN_LOOP_INNERMOST)
01324 #define WN_Reset_Loop_Innermost(x)      (WN_loop_flag(x) &= ~WN_LOOP_INNERMOST)
01325 
01326 /* does this loop arise because it is part of register winddown 
01327    from outer unrolling (and therefore its importance is less) */
01328 #define WN_Loop_Winddown_Reg(x)       (WN_loop_flag(x) & WN_LOOP_WINDDOWN_REG)
01329 #define WN_Set_Loop_Winddown_Reg(x)   (WN_loop_flag(x) |= WN_LOOP_WINDDOWN_REG)
01330 #define WN_Reset_Loop_Winddown_Reg(x) \
01331   (WN_loop_flag(x) &= ~WN_LOOP_WINDDOWN_REG)
01332 
01333 /* does this loop arise because it is part of cache winddown 
01334    (and therefore its importance might be less, but probably isn't) */
01335 #define WN_Loop_Winddown_Cache(x) \
01336   (WN_loop_flag(x) & WN_LOOP_WINDDOWN_CACHE)
01337 #define WN_Set_Loop_Winddown_Cache(x) \
01338   (WN_loop_flag(x) |= WN_LOOP_WINDDOWN_CACHE)
01339 #define WN_Reset_Loop_Winddown_Cache(x) \
01340   (WN_loop_flag(x) &= ~WN_LOOP_WINDDOWN_CACHE)
01341 
01342 /* Is this loop deemed to take significantly less execution time than
01343    some other loop, and is therefore need not be optimizes as agressively
01344    at low optimization levels, and is that so for some reason other than
01345    indicated one of the other WN_Loop flags.  Currently, this is only set
01346    for loops that arise from distribution of the imperfect part of a loop
01347    nest. */
01348 #define WN_Loop_Unimportant_Misc(x) \
01349   (WN_loop_flag(x) & WN_LOOP_UNIMPORTANT_MISC)
01350 #define WN_Set_Loop_Unimportant_Misc(x) \
01351   (WN_loop_flag(x) |= WN_LOOP_UNIMPORTANT_MISC)
01352 #define WN_Reset_Loop_Unimportant_Misc(x) \
01353   (WN_loop_flag(x) &= ~WN_LOOP_UNIMPORTANT_MISC)
01354 
01355 #define WN_Loop_Unimportant(x) \
01356   (WN_loop_flag(x) & \
01357    (WN_LOOP_WINDDOWN_CACHE | WN_LOOP_WINDDOWN_REG | WN_LOOP_UNIMPORTANT_MISC))
01358 
01359 #define WN_Loop_Nz_Trip(x)         (WN_loop_flag(x) & WN_LOOP_NZ_TRIP)
01360 #define WN_Set_Loop_Nz_Trip(x)     (WN_loop_flag(x) |= WN_LOOP_NZ_TRIP)
01361 #define WN_Reset_Loop_Nz_Trip(x)   (WN_loop_flag(x) &= ~WN_LOOP_NZ_TRIP)
01362 
01363 #define WN_Loop_Symb_Trip(x)         (WN_loop_flag(x) & WN_LOOP_SYMB_TRIP)
01364 #define WN_Set_Loop_Symb_Trip(x)     (WN_loop_flag(x) |= WN_LOOP_SYMB_TRIP)
01365 #define WN_Reset_Loop_Symb_Trip(x)   (WN_loop_flag(x) &= ~WN_LOOP_SYMB_TRIP)
01366 
01367 #define WN_LABEL_HANDLER_BEGIN 0x2
01368 #define WN_Label_Is_Handler_Begin(x)       (WN_label_flag(x) & \
01369                                             WN_LABEL_HANDLER_BEGIN)
01370 #define WN_Set_Label_Is_Handler_Begin(x)   (WN_label_flag(x) |= \
01371                                             WN_LABEL_HANDLER_BEGIN)
01372 #define WN_Reset_Label_Is_Handler_Begin(x) (WN_label_flag(x) &= \
01373                                           ~(WN_LABEL_HANDLER_BEGIN))
01374 
01375 #define WN_Set_IO_Library(x,y)  (WN_io_flag(x) = (y))
01376 #define WN_IO_Library(x)        ((IOLIB) WN_io_flag(x))
01377 
01378 #define WN_PARM_BY_REFERENCE        0x01
01379 #define WN_PARM_BY_VALUE            0x02
01380 #define WN_PARM_IN                  WN_PARM_BY_VALUE
01381 #define WN_PARM_OUT                 0x04
01382 #define WN_PARM_DUMMY               0x08
01383 /* The next two WN_PARM_READ_ONLY, WN_PARM_PASSED_NOT_SAVED only for C/C++ */
01384 #define WN_PARM_READ_ONLY           0x10 /* parm is only referenced, not
01385                                             modified by the callee */ 
01386 #define WN_PARM_PASSED_NOT_SAVED    0x20 /* parm is passed to callee,
01387                                             however, the callee does not
01388                                             save the address of the parm */
01389 #define WN_PARM_NOT_EXPOSED_USE   0x40  /* there is no exposed use */
01390 #define WN_PARM_IS_KILLED   0x80        /* the parameter is killed, for
01391                                            pass by reference */
01392 
01393 /* following for record detail information about dummy-actual arguments
01394  * association
01395  *  fzhao@rice.edu
01396  */
01397 # define WN_PARM_PASS_ADDRESS                  0x0100 
01398 # define WN_PARM_PASS_ADDRESS_FROM_DV          0x0200
01399 # define WN_PARM_PASS_DV                       0x0400 
01400 # define WN_PARM_PASS_DV_COPY                  0x0800 
01401 # define WN_PARM_COPY_IN                       0x2000
01402 # define WN_PARM_COPY_IN_COPY_OUT              0x4000
01403 # define WN_PARM_MAKE_DV                       0x8000 
01404 # define WN_PARM_COPY_IN_MAKE_DV               0x010000 
01405 # define WN_PARM_MAKE_NEW_DV                   0x020000 
01406 # define WN_PARM_PASS_SECTION_ADDRESS          0x040000 
01407 # define WN_PARM_CHECK_CONTIG_FLAG             0x080000 
01408 
01409 
01410 #define WN_Parm_By_Reference(x)         (WN_parm_flag(x) & WN_PARM_BY_REFERENCE)
01411 #define WN_Set_Parm_By_Reference(x)     (WN_parm_flag(x) |= WN_PARM_BY_REFERENCE)
01412 #define WN_Clear_Parm_By_Reference(x)   (WN_parm_flag(x) &= ~WN_PARM_BY_REFERENCE)
01413 #define WN_Parm_By_Value(x)             (WN_parm_flag(x) & WN_PARM_BY_VALUE)
01414 #define WN_Set_Parm_By_Value(x)         (WN_parm_flag(x) |= WN_PARM_BY_VALUE)
01415 #define WN_Clear_Parm_By_Value(x)       (WN_parm_flag(x) &= ~WN_PARM_BY_VALUE)
01416 #define WN_Parm_In(x)                   (WN_parm_flag(x) & WN_PARM_IN)
01417 #define WN_Set_Parm_In(x)               (WN_parm_flag(x) |= WN_PARM_IN)
01418 #define WN_Parm_Out(x)                  (WN_parm_flag(x) & WN_PARM_OUT)
01419 #define WN_Set_Parm_Out(x)              (WN_parm_flag(x) |= WN_PARM_OUT)
01420 #define WN_Parm_Dummy(x)                (WN_parm_flag(x) & WN_PARM_DUMMY)
01421 #define WN_Set_Parm_Dummy(x)            (WN_parm_flag(x) |= WN_PARM_DUMMY)
01422 #define WN_Parm_Read_Only(x)            (WN_parm_flag(x) & WN_PARM_READ_ONLY)
01423 #define WN_Set_Parm_Read_Only(x)        (WN_parm_flag(x) |= WN_PARM_READ_ONLY)
01424 #define WN_Parm_Passed_Not_Saved(x)     (WN_parm_flag(x) & WN_PARM_PASSED_NOT_SAVED)
01425 #define WN_Set_Parm_Passed_Not_Saved(x) (WN_parm_flag(x) |= WN_PARM_PASSED_NOT_SAVED)
01426 #define WN_Set_Parm_Not_Exposed_Use(x)  (WN_parm_flag(x) |= WN_PARM_NOT_EXPOSED_USE)
01427 #define WN_Parm_Not_Exposed_Use(x)      (WN_parm_flag(x) & WN_PARM_NOT_EXPOSED_USE)
01428 #define WN_Set_Parm_Is_Killed(x)        (WN_parm_flag(x) |= WN_PARM_IS_KILLED)
01429 #define WN_Parm_Is_Killed(x)            (WN_parm_flag(x) & WN_PARM_IS_KILLED)
01430 
01431 #define WN_Parm_Pass_Address(x)         (WN_parm_flag(x) & WN_PARM_PASS_ADDRESS)
01432 #define WN_Set_Parm_Pass_Address(x)     (WN_parm_flag(x) |= WN_PARM_PASS_ADDRESS)
01433 #define WN_Parm_Pass_Address_From_Dv(x)         (WN_parm_flag(x) & WN_PARM_PASS_ADDRESS_FROM_DV)
01434 #define WN_Set_Parm_Pass_Address_From_Dv(x)     (WN_parm_flag(x) |= WN_PARM_PASS_ADDRESS_FROM_DV)
01435 #define WN_Parm_Pass_Dv(x)         (WN_parm_flag(x) & WN_PARM_PASS_DV)
01436 #define WN_Set_Parm_Pass_Dv(x)     (WN_parm_flag(x) |= WN_PARM_PASS_DV)
01437 #define WN_Parm_Pass_Dv_Copy(x)         (WN_parm_flag(x) & WN_PARM_PASS_DV_COPY)
01438 #define WN_Set_Parm_Pass_Dv_Copy(x)     (WN_parm_flag(x) |= WN_PARM_PASS_DV_COPY)
01439 #define WN_Parm_Copy_In(x)         (WN_parm_flag(x) & WN_PARM_COPY_IN)
01440 #define WN_Set_Parm_Copy_In(x)     (WN_parm_flag(x) |= WN_PARM_COPY_IN)
01441 #define WN_Parm_Copy_In_Copy_out(x)         (WN_parm_flag(x) & WN_PARM_BY_REFERENCE)
01442 #define WN_Set_Parm_Copy_In_Copy_out(x)     (WN_parm_flag(x) |= WN_PARM_COPY_IN_COPY_OUT)
01443 #define WN_Parm_Make_Dv(x)         (WN_parm_flag(x) & WN_PARM_MAKE_DV)
01444 #define WN_Set_Parm_Make_Dv(x)     (WN_parm_flag(x) |= WN_PARM_MAKE_DV)
01445 #define WN_Parm_Copy_In_Make_Dv(x)         (WN_parm_flag(x) & WN_PARM_COPY_IN_MAKE_DV)
01446 #define WN_Set_Parm_Copy_In_Make_Dv(x)     (WN_parm_flag(x) |= WN_PARM_COPY_IN_MAKE_DV)
01447 #define WN_Parm_Make_New_Dv(x)         (WN_parm_flag(x) & WN_PARM_MAKE_NEW_DV)
01448 #define WN_Set_Parm_Make_New_Dv(x)     (WN_parm_flag(x) |= WN_PARM_MAKE_NEW_DV)
01449 #define WN_Parm_Pass_Section_Address(x)         (WN_parm_flag(x) & WN_PARM_PASS_SECTION_ADDRESS)
01450 #define WN_Set_Parm_Pass_Section_Address(x)     (WN_parm_flag(x) |= WN_PARM_PASS_SECTION_ADDRESS)
01451 #define WN_Parm_Check_Contig_Flag(x)         (WN_parm_flag(x) & WN_PARM_CHECK_CONTIG_FLAG)
01452 #define WN_Set_Parm_Check_Contig_Flag(x)     (WN_parm_flag(x) |= WN_PARM_CHECK_CONTIG_FLAG)
01453 
01454 #define WN_EQ_IS_LOGICAL        0x01 /*OPR_EQ or OPR_NE is logical opr */
01455 #define WN_Eq_Is_Logical(x)       (WN_eq_logical_flag(x) & WN_EQ_IS_LOGICAL)
01456 #define WN_Set_Eq_Is_Logical(x)   (WN_eq_logical_flag(x) |= WN_EQ_IS_LOGICAL)
01457 #define WN_Reset_Eq_Is_Logical(x) (WN_eq_logical_flag(x) &= WN_EQ_IS_LOGICAL)
01458 
01459 #define WN_CALL_NEVER_RETURN    0x01 /* call will never return */
01460 #define WN_CALL_NON_DATA_MOD    0x02 /* modifies data not present in program */
01461 #define WN_CALL_NON_PARM_MOD    0x04 /* modifies data whose address is not passed as parameter */
01462 #define WN_CALL_PARM_MOD        0x08 /* modifies data whose address is passed as parameter */
01463 #define WN_CALL_NON_DATA_REF    0x10 /* references data not present in program */
01464 #define WN_CALL_NON_PARM_REF    0x20 /* references data whose address is not passed as parameter */
01465 #define WN_CALL_PARM_REF        0x40 /* references data whose address is passed as parameter */
01466 #define WN_CALL_INLINE          0x80 /* marked for IPA to attempt to inline */
01467 #define WN_CALL_DONT_INLINE     0x100   /* marked for IPA to not inline */
01468 #define WN_CALL_DOES_MEM_ALLOC  0x200   /* malloc_like function */
01469 #define WN_CALL_DOES_MEM_FREE   0x400   /* free_like function */
01470 #define WN_CALL_FORTRAN_POINTER_RULE 0x800 /* call obeys fortran semantics as
01471                                               regards points-to
01472                                               relationships */
01473 #define WN_CALL_REPLACE_BY_JUMP 0x1000  /* replace call by jump in thunks */
01474 
01475      /* Some flags make promises when they're clear, and others when
01476       * they're set. The following macro tells us which are
01477       * which. Make sure to update the macro when you add a new
01478       * WN_CALL_* flag.
01479       */
01480 #define WN_CALL_CONSERVATIVE    (WN_CALL_NON_DATA_MOD | \
01481                                  WN_CALL_NON_PARM_MOD | \
01482                                  WN_CALL_PARM_MOD     | \
01483                                  WN_CALL_NON_DATA_REF | \
01484                                  WN_CALL_NON_PARM_REF | \
01485                                  WN_CALL_PARM_REF)
01486 
01487 #define WN_Call_Never_Return(x)         (WN_call_flag(x) & WN_CALL_NEVER_RETURN)
01488 #define WN_Set_Call_Never_Return(x)     (WN_call_flag(x) |= WN_CALL_NEVER_RETURN)
01489 #define WN_Reset_Call_Never_Return(x)   (WN_call_flag(x) &= ~WN_CALL_NEVER_RETURN)
01490 #define WN_Call_Non_Data_Mod(x)         (WN_call_flag(x) & WN_CALL_NON_DATA_MOD)
01491 #define WN_Set_Call_Non_Data_Mod(x)     (WN_call_flag(x) |= WN_CALL_NON_DATA_MOD)
01492 #define WN_Reset_Call_Non_Data_Mod(x)   (WN_call_flag(x) &= ~WN_CALL_NON_DATA_MOD)
01493 #define WN_Call_Non_Data_Ref(x)         (WN_call_flag(x) & WN_CALL_NON_DATA_REF)
01494 #define WN_Set_Call_Non_Data_Ref(x)     (WN_call_flag(x) |= WN_CALL_NON_DATA_REF)
01495 #define WN_Reset_Call_Non_Data_Ref(x)   (WN_call_flag(x) &= ~WN_CALL_NON_DATA_REF)
01496 #define WN_Call_Non_Parm_Mod(x)         (WN_call_flag(x) & WN_CALL_NON_PARM_MOD)
01497 #define WN_Set_Call_Non_Parm_Mod(x)     (WN_call_flag(x) |= WN_CALL_NON_PARM_MOD)
01498 #define WN_Reset_Call_Non_Parm_Mod(x)   (WN_call_flag(x) &= ~WN_CALL_NON_PARM_MOD)
01499 #define WN_Call_Non_Parm_Ref(x)         (WN_call_flag(x) & WN_CALL_NON_PARM_REF)
01500 #define WN_Set_Call_Non_Parm_Ref(x)     (WN_call_flag(x) |= WN_CALL_NON_PARM_REF)
01501 #define WN_Reset_Call_Non_Parm_Ref(x)   (WN_call_flag(x) &= ~WN_CALL_NON_PARM_REF)
01502 #define WN_Call_Parm_Mod(x)             (WN_call_flag(x) & WN_CALL_PARM_MOD)
01503 #define WN_Set_Call_Parm_Mod(x)         (WN_call_flag(x) |= WN_CALL_PARM_MOD)
01504 #define WN_Reset_Call_Parm_Mod(x)       (WN_call_flag(x) &= ~WN_CALL_PARM_MOD)
01505 #define WN_Call_Parm_Ref(x)             (WN_call_flag(x) & WN_CALL_PARM_REF)
01506 #define WN_Set_Call_Parm_Ref(x)         (WN_call_flag(x) |= WN_CALL_PARM_REF)
01507 #define WN_Reset_Call_Parm_Ref(x)       (WN_call_flag(x) &= ~WN_CALL_PARM_REF)
01508 #define WN_Call_Inline(x)               (WN_call_flag(x) & WN_CALL_INLINE)
01509 #define WN_Set_Call_Inline(x)           (WN_call_flag(x) |= WN_CALL_INLINE)
01510 #define WN_Reset_Call_Inline(x)         (WN_call_flag(x) &= ~WN_CALL_INLINE)
01511 #define WN_Call_Dont_Inline(x)          (WN_call_flag(x) & WN_CALL_DONT_INLINE)
01512 #define WN_Set_Call_Dont_Inline(x)      (WN_call_flag(x) |= WN_CALL_DONT_INLINE)
01513 #define WN_Reset_Call_Dont_Inline(x)    (WN_call_flag(x) &= ~WN_CALL_DONT_INLINE)
01514 #define WN_Call_Does_Mem_Alloc(x)       (WN_call_flag(x) & WN_CALL_DOES_MEM_ALLOC)
01515 #define WN_Set_Call_Does_Mem_Alloc(x)   (WN_call_flag(x) |= WN_CALL_DOES_MEM_ALLOC)
01516 #define WN_Reset_Call_Does_Mem_Alloc(x) (WN_call_flag(x) &= ~WN_CALL_DOES_MEM_ALLOC)
01517 #define WN_Call_Does_Mem_Free(x)        (WN_call_flag(x) & WN_CALL_DOES_MEM_FREE)
01518 #define WN_Set_Call_Does_Mem_Free(x)    (WN_call_flag(x) |= WN_CALL_DOES_MEM_FREE)
01519 #define WN_Reset_Call_Does_Mem_Free(x)  (WN_call_flag(x) &= ~WN_CALL_DOES_MEM_FREE)
01520 #define WN_Call_Fortran_Pointer_Rule(x) (WN_call_flag(x) & WN_CALL_FORTRAN_POINTER_RULE)
01521 #define WN_Set_Call_Fortran_Pointer_Rule(x) \
01522                                         (WN_call_flag(x) |= WN_CALL_FORTRAN_POINTER_RULE)
01523 #define WN_Reset_Call_Fortran_Pointer_Rule(x) \
01524                                         (WN_call_flag(x) &= ~WN_CALL_FORTRAN_POINTER_RULE)
01525 #define WN_Call_Replace_By_Jump(x)      (WN_call_flag(x) & WN_CALL_REPLACE_BY_JUMP)
01526 #define WN_Set_Call_Replace_By_Jump(x)  (WN_call_flag(x) |= WN_CALL_REPLACE_BY_JUMP)
01527 #define WN_Reset_Call_Replace_By_Jump(x) (WN_call_flag(x) &= ~WN_CALL_REPLACE_BY_JUMP)
01528 
01529 #define WN_Set_Call_Default_Flags(x)    (WN_call_flag(x) |= WN_CALL_CONSERVATIVE)
01530 #define WN_Call_No_Side_Effect(x)       ((WN_call_flag(x) & (WN_CALL_NON_DATA_MOD | WN_CALL_NON_PARM_MOD | WN_CALL_PARM_MOD)) == 0)
01531 #define WN_Call_Pure(x)                 ((WN_call_flag(x) & (WN_CALL_NON_DATA_MOD | WN_CALL_NON_PARM_MOD | WN_CALL_PARM_MOD | WN_CALL_NON_DATA_REF | WN_CALL_NON_PARM_REF)) == 0)
01532 
01533 /* Macros for OPR_ASM_STMT flag access */
01534 
01535 #define WN_ASM_VOLATILE         0x0001
01536 #define WN_ASM_CLOBBERS_MEM     0x0002
01537 #define WN_ASM_CLOBBERS_CC      0x0004
01538 
01539 #define WN_Asm_Volatile(x)              (WN_asm_flag(x) & WN_ASM_VOLATILE)
01540 #define WN_Set_Asm_Volatile(x)          (WN_asm_flag(x) |= WN_ASM_VOLATILE)
01541 #define WN_Reset_Asm_Volatile(x)        (WN_asm_flag(x) &= ~WN_ASM_VOLATILE)
01542 #define WN_Asm_Clobbers_Mem(x)          (WN_asm_flag(x) & WN_ASM_CLOBBERS_MEM)
01543 #define WN_Set_Asm_Clobbers_Mem(x)      (WN_asm_flag(x) |= WN_ASM_CLOBBERS_MEM)
01544 #define WN_Reset_Asm_Clobbers_Mem(x)    (WN_asm_flag(x) &= ~WN_ASM_CLOBBERS_MEM)
01545 #define WN_Asm_Clobbers_Cc(x)           (WN_asm_flag(x) & WN_ASM_CLOBBERS_CC)
01546 #define WN_Set_Asm_Clobbers_Cc(x)       (WN_asm_flag(x) |= WN_ASM_CLOBBERS_CC)
01547 #define WN_Reset_Asm_Clobbers_Cc(x)     (WN_asm_flag(x) &= ~WN_ASM_CLOBBERS_CC)
01548 
01549 /*
01550  *  Changed to inline function for compatibility.
01551  *  The actual number of kids (kid_count) may be much larger
01552  *  as dummy node are created to encapsulate variables used/modified by 
01553  *  the routine.
01554  *
01555  *      #define WN_num_actuals(x)   (WN_kid_count(x))
01556  */
01557 /*REFERENCED*/
01558 inline mINT16 WN_num_actuals(const WN *wn)
01559 {
01560   INT32 n= WN_kid_count(wn);
01561   INT32 i;
01562   OPERATOR opr = WN_operator(wn);
01563 
01564   /* for indirect calls, the last kid is the address of the procedure 
01565    * being called. So, skip it while counting the parameters. 
01566    */
01567   if (opr == OPR_ICALL || opr == OPR_PICCALL) n--;
01568 
01569   for(i= n-1; i>=0; i--)
01570   {
01571     WN *kid = WN_kid(wn,i);
01572     if (!kid) { continue; } /* eraxxon: handle buggy WHIRL (from mfef90) */
01573 
01574     OPERATOR kid_opr = WN_operator(kid);
01575     if ( (kid_opr != OPR_PARM) || !WN_Parm_Dummy(kid) )
01576     {
01577       return i+1;
01578     }
01579   }
01580   return 0;
01581 }
01582 
01583 /* Flag structure in a prefetch node, and macros to manipulate the flag */
01584 
01585 /***********************************************************************
01586  *
01587  * flag structure
01588  *    3322 2222 2222 1111 1111 11  
01589  *    1098 7654 3210 9876 5432 1098 7654 3210
01590  *    xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
01591  *                                  ^^^^^^^^^ 1st-lev stride   (8 bits,  0.. 7)
01592  *                        ^^^^^^^^^           2nd-lev stride   (8 bits,  8..15)
01593  *              ^^^^^^^^^                     unused           (8 bits, 16..23)
01594  *            ^                               read(0)/write(1) (1 bit,  24)
01595  *           ^                                1 if manual prefetch  (1 bit, 25)
01596  *         ^^                                 unused           (2 bits, 26..27)
01597  *    ^^^^                                    confidence #     (4 bits, 28..31)
01598  *
01599  ***********************************************************************/
01600 
01601 #define PF_GET_READ(flag)       (((~(flag)) >> 24) & 0x1)
01602 #define PF_GET_WRITE(flag)      (((flag)  >> 24) & 0x1)
01603 #define PF_GET_STRIDE_1L(flag)  ((flag)  & 0xff)
01604 #define PF_GET_STRIDE_2L(flag)  (((flag) >> 8)   & 0xff)
01605 #define PF_GET_CONFIDENCE(flag) (((flag) >> 28)  & 0xf)
01606 #define PF_GET_MANUAL(flag)     (((flag) >> 25) & 0x1)
01607 
01608 #define PF_SET_READ(flag)          flag &= 0xfeffffff
01609 #define PF_SET_WRITE(flag)         flag |= 0x01000000
01610 #define PF_SET_STRIDE_1L(flag, x)  flag = (((flag)&0xffffff00) | ((x)&0xff))
01611 #define PF_SET_STRIDE_2L(flag, x)  flag = (((flag)&0xffff00ff) | ((x)&0xff)<<8)
01612 #define PF_SET_CONFIDENCE(flag, x) flag = (((flag)&0x0fffffff) | ((x)&0xf)<<28)
01613 #define PF_SET_MANUAL(flag)        flag |= 0x02000000
01614 #define PF_UNSET_MANUAL(flag)      flag &= 0xfdffffff
01615 
01616 #define WN_pf_read(wn)       (((~(WN_prefetch_flag(wn))) >> 24) & 0x1)
01617 #define WN_pf_write(wn)      (((WN_prefetch_flag(wn))  >> 24) & 0x1)
01618 #define WN_pf_stride_1L(wn)  ((WN_prefetch_flag(wn))  & 0xff)
01619 #define WN_pf_stride_2L(wn)  (((WN_prefetch_flag(wn)) >> 8)   & 0xff)
01620 #define WN_pf_confidence(wn) (((WN_prefetch_flag(wn)) >> 28)  & 0xf)
01621 #define WN_pf_manual(wn)     (((WN_prefetch_flag(wn)) >> 25) & 0x1)
01622 
01623 #define WN_pf_set_read(wn)          WN_prefetch_flag(wn) &= 0xfeffffff
01624 #define WN_pf_set_write(wn)         WN_prefetch_flag(wn) |= 0x01000000
01625 #define WN_pf_set_stride_1L(wn, x)  WN_prefetch_flag(wn) = (((WN_prefetch_flag(wn))&0xffffff00) | ((x)&0xff))
01626 #define WN_pf_set_stride_2L(wn, x)  WN_prefetch_flag(wn) = (((WN_prefetch_flag(wn))&0xffff00ff) | ((x)&0xff)<<8)
01627 #define WN_pf_set_confidence(wn, x) WN_prefetch_flag(wn) = (((WN_prefetch_flag(wn))&0x0fffffff) | ((x)&0xf)<<28)
01628 #define WN_pf_set_manual(wn)        WN_prefetch_flag(wn) |= 0x02000000
01629 #define WN_pf_unset_manual(wn)      WN_prefetch_flag(wn) &= 0xfdffffff
01630 
01631 /* end prefetch macros */
01632 
01633 /*
01634 //Some helper functions for handling struct field accesses
01635 unsigned int Get_Num_Fields(TY_IDX base) {
01636 
01637   if (!TY_Is_Structured(base)) {
01638     return 0;
01639   }
01640   
01641   int num = 0;
01642   FLD_HANDLE fh = TY_fld(base); 
01643   while (true) {
01644     num++;
01645     TY_IDX fld_ty = FLD_type(fh);
01646     num += Get_Num_Fields(fld_ty);
01647     if (FLD_last_field(fh)) {
01648       break;
01649     }
01650     fh = FLD_next(fh);
01651   } 
01652   return num;
01653 }
01654 
01655 TY_IDX Get_Field_Type(TY_IDX base, int field_id) {
01656 
01657   Is_True(TY_Is_Structured(base), ("CALLING GET_FIELD_TYPE with a non struct type"));
01658 
01659   FLD_HANDLE fh = TY_fld(base);
01660   for (int i = 1; i < field_id; i++, fh = FLD_next(fh)) {
01661     TY_IDX fld_ty = FLD_type(fh);
01662     int num_subfld = Get_Num_Fields(fld_ty);
01663     if (i + num_subfld >= field_id) {
01664       return Get_Field_Type(fld_ty, field_id - i);
01665     } else {
01666       i += num_subfld;
01667     }
01668   }
01669   return FLD_type(fh);
01670 }
01671 */
01672 
01673 #endif /* wn_core_INCLUDED */
Generated on Sat Feb 25 2012 05:50:49 for Open64 (mfef90, whirl2f, and IR tools) by  doxygen 1.7.1