Open64: osprey/be/cg/op.h Source File

00001 /*
00002  * Copyright 2002, 2003, 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00003  */
00004 
00005 /*
00006 
00007   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00008 
00009   This program is free software; you can redistribute it and/or modify it
00010   under the terms of version 2 of the GNU General Public License as
00011   published by the Free Software Foundation.
00012 
00013   This program is distributed in the hope that it would be useful, but
00014   WITHOUT ANY WARRANTY; without even the implied warranty of
00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00016 
00017   Further, this software is distributed without any warranty that it is
00018   free of the rightful claim of any third person regarding infringement 
00019   or the like.  Any license provided herein, whether implied or 
00020   otherwise, applies only to this software file.  Patent licenses, if 
00021   any, provided herein do not apply to combinations of this program with 
00022   other software, or any other product whatsoever.  
00023 
00024   You should have received a copy of the GNU General Public License along
00025   with this program; if not, write the Free Software Foundation, Inc., 59
00026   Temple Place - Suite 330, Boston MA 02111-1307, USA.
00027 
00028   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00029   Mountain View, CA 94043, or:
00030 
00031   http://www.sgi.com
00032 
00033   For further information regarding this notice, see:
00034 
00035   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00036 
00037 */
00038 
00039 
00040 /* ====================================================================
00041  * ====================================================================
00042  *
00043  * Module: op.h
00044  * $Revision: 1.21 $
00045  * $Date: 06/03/14 14:38:58-08:00 $
00046  * $Author: tkong@hyalite.keyresearch $
00047  * $Source: /scratch/mee/2.4-65/kpro64-pending/be/cg/SCCS/s.op.h $
00048  *
00049  * CGIR operation structure (OP) and utility routines.
00050  *
00051  * Exported types:
00052  *
00053  *   OP
00054  *     A machine-level operation.  The following accessors are provided.
00055  *     These are lvalues:
00056  *       SRCPOS OP_srcpos(OP *) source position
00057  *
00058  *     These are rvalues with standard Set functions:
00059  *       UINT8 OP_unrolling(OP *op)
00060  *   void Set_OP_unrolling(OP *op, UINT8 unrolling)
00061  *         Whether or not a loop body is unrolled, each OP in the loop
00062  *         body has an associated "unrolling" number.  This number is
00063  *         zero for the original loop body OPs, and incremented by one
00064  *         for each unrolled copy created.
00065  *
00066  *   TODO: document rest of these
00067  *
00068  *     These are rvalues.  They are set by the BB/OPS Insert/Remove routines
00069  *     (see utility routines below and in "bb.h").
00070  *   TOP OP_code(OP *)  opcode
00071  *   BB *OP_bb(OP *)  BB (if any) to which this OP belongs
00072  *   OP *OP_next(OP *)  next OP (if any) in OPS/BB
00073  *   OP *OP_prev(OP *)  previous OP (if any) in OPS/BB
00074  *   UINT16 OP_map_idx(OP*) unique/compact/stable per-BB index
00075  *        (won't change unless OP is moved to diff BB)
00076  *        (undefined if OP_bb(op) == NULL)
00077  *     Constructors:
00078  *   OP *Dup_OP(OP *op)
00079  *      Return a copy of <op>, detached from any BB or OPS.
00080  *   OP *Mk_OP(TOP opr, ...)
00081  *      Create, and return, an OP with opcode <opr>. The variable
00082  *      argument list contains the result TNs, followed immediately
00083  *      by the operand TNs. The topcode determines the number of
00084  *      result and operand parameters. This routine can only be
00085  *      used with topcodes with a fixed number of operands/results.
00086  *   OP *Mk_VarOP(TOP opr, INT results, INT opnds,
00087  *          struct tn **res_tn, 
00088  *          struct tn **opnd_tn)
00089  *      Create, and return, an OP with opcode <opr>. The parameters
00090  *      <results> and <operands> specify the number of results and
00091  *      operands. The results and operands are contained in arrays,
00092  *      pointed to by the parameters <res_tn> and <opnd_tn>.
00093  *      Mk_VarOP is used for topcodes with a variable number of
00094  *      operands/results, but may also be used with fixed topcodes.
00095  *
00096  *     Constants:
00097  *       OP_MAX_FIXED_OPNDS
00098  *       OP_MAX_FIXED_RESULTS
00099  *     The maximum number of fixed operands and results an OP can
00100  *     have. Note that OPs with variable numbers of operands, e.g. asm,
00101  *     will have at least this number, but can have more.
00102  *
00103  *     Accessors:
00104  *   TN *OP_result(OP *op, UINT8 i)
00105  *   void Set_OP_result(OP *op, UINT8 i, TN *tn)
00106  *   TN *OP_opnd(OP *op, UINT8 i)
00107  *   void Set_OP_opnd(OP *op, UINT8 i, TN *tn)
00108  *
00109  *   OPS
00110  *     Internal doubly-linked list of OPS.  The following accessors are
00111  *     provided.  They are all rvalues.  See utility functions below for
00112  *     OPS_Insert/Remove functions to modify OPS.
00113  *       OP *OPS_first(OPS *) first OP (if any) in OPS
00114  *   OP *OPS_last(OPS *)  last OP (if any) in OPS
00115  *     Constructors:
00116  *   OPS *OPS_Create(void)
00117  *     Return a new empty OPS allocated in the PU pool.
00118  *     Initializers:
00119  *   OPS *OPS_Init(OPS *ops)
00120  *     Make <ops> empty and return it.
00121  *     Constants:
00122  *   OPS OPS_EMPTY
00123  *     Empty OPS used to initialize automatically allocated OPS.
00124  *
00125  *
00126  * Utility functions:
00127  *
00128  *   void OP_Change_Opcode(OP *op, TOP opc)
00129  *  Change the opcode of an OP. The new opcode must have the
00130  *  same number of fixed results and operands as the old
00131  *  opcode, and they must both have the same var_opnds property.
00132  *  If the client can't guarantee these conditions, then a
00133  *  new OP should be created.
00134  *
00135  *   void OP_Change_To_Noop(OP *op)
00136  *  Change the specified OP into a generic noop (TOP_noop).
00137  *
00138  *   INT64 OP_Ordering(OP *op1, OP *op2)
00139  *   BOOL OP_Precedes(OP *op1, OP *op2)
00140  *   BOOL OP_Follows(OP *op1, OP *op2)
00141  *   INT32 OP_Order(OP *op1, OP *op2)
00142  *     Requires: OP_bb(op1) == OP_bb(op2) && OP_bb(op1) != NULL
00143  *     OP_Ordering returns an integer indicating the relative order
00144  *     of <op1> and <op2> in the BB.  The value returned is:
00145  *   > 0  iff  <op1> follows <op2>
00146  *   = 0  iff  <op1> and <op2> are the same
00147  *   < 0  iff  <op2> follows <op1>
00148  *     The values returned by OP_Ordering may be very sparsely distributed,
00149  *     and the actual value returned may differ for the same pair of OPs
00150  *     if any other OP is added anywhere in the BB between the calls to
00151  *     OP_Ordering.  OP_Follows(op1,op2) is (OP_Ordering(op1,op2) > 0).
00152  *     OP_Precedes(op1,op2) is (OP_Ordering(op1,op2) < 0).  Provided no OPs
00153  *     are added to the BB between calls to OP_Ordering, the following
00154  *     implications hold:
00155  *  (OP_Ordering(op1,op2) > OP_Ordering(op1,op3)) ==> OP_Follows(op2,op3)
00156  *  (OP_Ordering(op1,op2) < OP_Ordering(op1,op3)) ==> OP_Precedes(op2,op3)
00157  *     OP_Order is similar to OP_Ordering, except that a) the return
00158  *     value is 32 bits, and b) the return value is -1,0,1 (so there
00159  *     is no significance in the magnatude of the values).
00160  *
00161  *   void OPS_Insert_Op(OPS *ops, OP *point, OP *op, BOOL before)
00162  *     Requires: <point> is in <ops>.  <op> isn't in another OPS.
00163  *     Insert <op> in <ops>.  If <point> isn't NULL, insert before
00164  *     <point> if <before> or after it otherwise.  If <point> is NULL
00165  *     insert at start of <ops> if <before>, or end of <ops> otherwise.
00166  *
00167  *   void OPS_Insert_Ops(OPS *ops, OP *point, OPS *insert_ops, BOOL before)
00168  *     Requires: <point> is in <ops>.  <insert_ops> isn't in another OPS.
00169  *     Insert <insert_ops> in <ops>.  If <point> isn't NULL, insert before
00170  *     <point> if <before> or after it otherwise.  If <point> is NULL
00171  *     insert at start of <ops> if <before>, or end of <ops> otherwise.
00172  *
00173  *   void OPS_Insert_Op_Before(OPS *ops, OP *point, OP *op)
00174  *   void OPS_Insert_Op_After(OPS *ops, OP *point, OP *op)
00175  *   void OPS_Append_Op(OPS *ops, OP *op)
00176  *   void OPS_Prepend_Op(OPS *ops, OP *op)
00177  *   void OPS_Insert_Ops_Before(OPS *ops, OP *point, OPS *insert_ops)
00178  *   void OPS_Insert_Ops_After(OPS *ops, OP *point, OPS *insert_ops)
00179  *   void OPS_Append_Ops(OPS *ops, OPS *insert_ops)
00180  *   void OPS_Prepend_Ops(OPS *ops, OPS *insert_ops)
00181  *     More-specific names for the general Insert routines.  These do
00182  *     what you think they should do.
00183  *
00184  *   void OPS_Remove_Op(OPS *ops, OP *op)
00185  *     Requires: <op> is in <ops>.
00186  *     Remove <op> from <ops>.
00187  *
00188  *   void OPS_Remove_Ops(OPS *ops, OP *remove_ops)
00189  *     Requires: <remove_ops> is in <ops>.
00190  *     Remove <remove_ops> from <ops>.
00191  *
00192  *   void OPS_Remove_All(OPS *ops)
00193  *     Make <ops> empty.
00194  *
00195  *   UINT32 OPS_length(OPS *ops)
00196  *     Returns the number of OPs in <ops>.
00197  *
00198  *   void Print_OP(OP *op)
00199  *   void Print_OPs(OP *first)
00200  *   void Print_OPS(OPS *ops)
00201  *     Print OP(s) to the trace file.  Print_OP prints only <op>;
00202  *     Print_OPs prints the list of OPs starting with <first>;
00203  *     Print_OPS prints the OPs in <ops>.
00204  *
00205  *   void Print_OP_No_SrcLine(OP *op)
00206  *   void Print_OPs_No_SrcLines(OP *first)
00207  *   void Print_OPS_No_SrcLines(OPS *ops)
00208  *     Same as above, but don't print lines from source code with the OP(s).
00209  *
00210  *   BOOL OP_Is_Float_Mem(const OP *op)
00211  *     Return a boolean that indicates whether <op> is a floating point
00212  *     memory operation, i.e. a floating point load or store.
00213  *
00214  *   BOOL OP_same_res(OP *op)
00215  *     OPER_same_res(OP_code(op)) indicates that an OP *may* have an
00216  *     operand that needs to be the same register as the result. This
00217  *     function checks a specific instance.  (E.g., the initial unaligned
00218  *     load instruction in an unaligned load pair does NOT need to have
00219  *     its last operand be the same as the result.)
00220  *     OP_same_res is target-specific; it's defined in TARGET/op_targ.h
00221  *
00222  *   BOOL OP_Defs_TN(const OP *op, const struct tn *res)
00223  *   BOOL OP_Refs_TN(const OP *op, const struct tn *opnd)
00224  *     Determine if the OP defines/references the given TN.
00225  *
00226  *   BOOL OP_Defs_Reg(const OP *op, ISA_REGISTER_CLASS rclass, REGISTER reg)
00227  *   BOOL OP_Refs_Reg(const OP *op, ISA_REGISTER_CLASS rclass, REGISTER reg)
00228  *     Determine if the OP defines/references the given register.
00229  *
00230  *   void OP_Base_Offset_TNs(OP *memop, TN **base_tn, TN **offset_tn)
00231  *     A generic utility routine which returns the <base_tn> and the
00232  *     <offset_tn> for the given <memory_op>.
00233  *
00234  *   const INT OP_COPY_OPND
00235  *  For OPs flagged with OP_copy, OP_COPY_OPND gives the operand
00236  *  number the source operand.
00237  *
00238  *   const INT OP_PREDICATE_OPND
00239  *  For OPs flagged with OP_has_predicate, OP_PREDICATE_OPND gives the
00240  *  operand number of the predicate operand.
00241  *
00242  *   BOOL OP_cond_def(OP *)
00243  *     OP_cond_def is an attribute of the OP including its operands.
00244  * 
00245  *     OP_cond_def can be solely derived from the def OP and its uses.
00246  *     For example, OP_cond_def is position independent.  It does not change
00247  *     if the OP is moved into the delay slot of a branch-likely on MIPS.
00248  *     The higher level routines are responsible to model nullify-able delay 
00249  *     slots.
00250  *
00251  *     OP_cond_def is not set for OPi defining TNj for 0 <= j < OP_opnds(OPi)
00252  *     if there is no OPk reachable from OPi referencing a previous defined 
00253  *     value of any TNj.  It is set otherwise.
00254  *
00255  *   BOOL OP_has_implicit_interactions
00256  *     A generic placeholder routine where all OPs with implicit interactions
00257  *     with other OPs in an non-obvious way are placed.
00258  *
00259  *   BOOL TN_Pair_In_OP (OP* op, TN *tn_res, TN* tn_opnd)
00260  *      Returns TRUE if <op> contains <tn_res> as a result
00261  *      and <tn_opnd> as an operand.
00262  *
00263  *   INT TN_Resnum_In_OP (OP* op, TN *tn)
00264  *      This routine assumes that the given <tn> is a result in <op>.
00265  *      It returns an INT that is the value of the result-number for
00266  *      this <tn> in this <op>.
00267  *
00268  *   INT TN_Opernum_In_OP (OP* op, TN *tn)
00269  *      This routine assumes that the given <tn> is an operand in <op>.
00270  *      It returns an INT that is the value of the operand-number for
00271  *      this <tn> in this <op>.
00272  *
00273  * TODO: Complete this interface description.
00274  *
00275  *
00276  * ====================================================================
00277  * ==================================================================== */
00278 
00279 
00280 #ifndef op_INCLUDED
00281 #define op_INCLUDED
00282 
00283 #ifdef TARG_IA64
00284 /* Include the values for the variant field: */
00285 #include "variants.h"
00286 #include <vector>
00287 using std::vector;
00288 #endif
00289 
00290 /* to get the definition of SRCPOS. */
00291 #include "srcpos.h"
00292 
00293 #include "targ_isa_operands.h"
00294 #include "targ_isa_properties.h"
00295 #include "targ_isa_hazards.h"
00296 #include "targ_isa_pack.h"
00297 
00298 /* to get Is_True */
00299 #include "errors.h"
00300 
00301 /* to get definition of REGISTER */
00302 #include "register.h"
00303 
00304 /* to get TYPE_MEM_POOL_ALLOC */
00305 #include "mempool.h"
00306 
00307 /* Declare some structures from elsewhere: */
00308 struct tn;
00309 struct bb;
00310 
00311 /* ---------------------------------------------------------------------
00312  *             OP stuff
00313  * ---------------------------------------------------------------------
00314  */
00315 
00316 /* Define the maximum number of fixed operands and results an OP can
00317  * have. Note that OPs with variable numbers of operands, e.g. asm,
00318  * may have more operands and/or results.
00319  */
00320 #define OP_MAX_FIXED_OPNDS  ISA_OPERAND_max_operands
00321 #define OP_MAX_FIXED_RESULTS  ISA_OPERAND_max_results
00322 
00323 /* HD - To use TN_LIST, and tn.h is not included yet  */
00324 struct TN_LIST;
00325 
00326 /* Define the OP structure: */
00327 typedef struct op OP;
00328 typedef struct op {
00329   SRCPOS  srcpos;   /* source position for the OP */
00330   OP    *next;    /* Next OP in BB list */
00331   OP    *prev;    /* Preceding OP in BB list */
00332   struct bb *bb;    /* BB in which this OP lives */
00333   struct bb *unroll_bb; /* BB just after unrolling */
00334   mUINT32 flags;    /* attributes associated with OP */
00335   mUINT16   order;    /* relative order in BB */
00336   mINT16        variant;        /* Opcode variant */
00337   mUINT16 map_idx;  /* index used by OP_MAPs; unique in BB */
00338   mUINT16 orig_idx; /* index of orig op before unrolling */
00339 #ifdef TARG_IA64
00340   mUINT16 orig_bb_id; /* id of orig bb before speculation */
00341 #endif
00342   mINT16  scycle;   /* Start cycle */
00343   mTOP    opr;    /* Opcode. topcode.h */
00344   mUINT8  unrolling;  /* which unrolled replication (if any) */
00345 #if defined(TARG_SL)
00346   TN_LIST       *extra_result;  /* HD - For sl2, I need an extra list 
00347                                  * of resutl/operand TNs */
00348   TN_LIST       *extra_operand;
00349 #endif
00350   mUINT8  results;  /* Number of results */
00351   mUINT8  opnds;    /* Number of operands */
00352 #ifdef TARG_IA64
00353   mUINT8       hidden_opnds;   /* Number of hidden operands, <opnds> include
00354         * hidden_opnds*/
00355   mUINT8        flag_value_profile;       /* flag to identify value_profile */
00356   mUINT32       value_profile_id;       /* unique ID to indicate value profiled No. */
00357   mUINT8        flag_stride_profile;      /* flag to identify stride_profile */
00358   mUINT32       stride_profile_id;        /*  unique ID to indicate stride profile No. */
00359   mUINT64        exec_count;          /* Number of executed count */
00360   mUINT8        flag_stride_prefetch;     /*flag to identify stride_prefetch */
00361 #endif
00362   struct tn     *res_opnd[10];  /* result/operand array (see OP_sizeof for info)
00363          * !!! THIS FIELD MUST BE LAST !!!
00364          */
00365 } OP;
00366 
00367 /* Return the 'sizeof' the OP struct needed for the specified number
00368  * of operands and results. For the sake of simplicity, the result of 
00369  * the calculation is not rounded up to the alignment of the struct. 
00370  * Note that the sizeof the res_opnd field as declared in the struct 
00371  * is arbitrary and is set to something other than one only for convenience 
00372  * in printing structs in the debugger (OP_sizeof's result is independent 
00373  * of the dimension).
00374  */
00375 #define OP_sizeof(nresults, nopnds) \
00376   ((size_t)(offsetof(OP, res_opnd[0]) + ((nresults) + (nopnds)) * sizeof(TN *)))
00377 
00378 /* Both the operand and result TNs are stored in _res_opnds.
00379  * OP_opnd_offset and OP_result_offset give the offset into the
00380  * array to the start of the operands and results. 
00381  * NOTE: the offset is NOT constant for all OPs!!!
00382  * NOTE: Add_Hidden_Operands() and Remove_Hidden_Operands() also 
00383  *   assume that results are placed right after source operands.  
00384  *   If the layout is changed, these two functions need to be changed
00385  *   too.
00386  */
00387 
00388 #define OP_opnd_offset(o) (0)
00389 #define OP_result_offset(o) OP_opnds(o)
00390 
00391 /* Define the access functions: */
00392 #define OP_srcpos(o)  ((o)->srcpos)
00393 #ifdef KEY
00394 #define OP_variant(o) ((o)->variant)
00395 #endif
00396 #define OP_scycle(o)  ((o)->scycle)
00397 #define OP_flags(o) ((o)->flags)
00398 #ifdef TARG_IA64
00399 #define OP_flags_val_prof(o)    ((o)->flag_value_profile)
00400 #define OP_val_prof_id(o)        ((o)->value_profile_id)
00401 #define OP_flags_srd_prof(o)    ((o)->flag_stride_profile)
00402 #define OP_srd_prof_id(o)        ((o)->stride_profile_id)
00403 #define OP_exec_count(o)        ((o)->exec_count)
00404 #endif
00405 /* These are rvalues */
00406 #define OP_next(o)  ((o)->next+0)
00407 #define OP_prev(o)  ((o)->prev+0)
00408 #define OP_map_idx(o) ((o)->map_idx+0)
00409 #define OP_orig_idx(o)  ((o)->orig_idx+0)
00410 #ifdef TARG_IA64
00411 #define OP_orig_bb_id(o) ((o)->orig_bb_id+0)
00412 #endif
00413 #define OP_unroll_bb(o) ((o)->unroll_bb+0)
00414 #define OP_unrolling(o) ((o)->unrolling+0)
00415 #define OP_bb(o)  ((o)->bb+0)
00416 #define OP_results(o) ((o)->results+0)
00417 #define OP_opnds(o) ((o)->opnds+0)
00418 #ifdef TARG_IA64
00419 #define OP_hidden_opnds(o) ((o)->hidden_opnds+0)
00420 #endif
00421 #define OP_code(o)  ((TOP)(o)->opr)
00422 #define OP_result(o,n)  ((struct tn *)(o)->res_opnd[(n)+OP_result_offset(o)])
00423 #define OP_opnd(o,n)  ((struct tn *)(o)->res_opnd[(n)+OP_opnd_offset(o)])
00424 
00425 #if defined(TARG_SL)
00426 #define OP_extra_rslt(o)  ((TN_LIST*)(o)->extra_result)
00427 #define OP_extra_opnd(o) ((TN_LIST*)(o)->extra_operand)
00428 #endif 
00429 
00430 /* Mutators: */
00431 #define Set_OP_orig_idx(op,idx) ((op)->orig_idx = (idx))
00432 #ifdef TARG_IA64
00433 #define Set_OP_orig_bb_id(op,id) ((op)->orig_bb_id = (id))
00434 #endif
00435 #define Set_OP_unroll_bb(op,bb) ((op)->unroll_bb = (bb))
00436 #define Set_OP_unrolling(op,u)  ((op)->unrolling = (u))
00437 #define Set_OP_result(o,result,tn) \
00438   ((o)->res_opnd[(result) + OP_result_offset(o)] = (tn))
00439 #define Set_OP_opnd(o,opnd,tn) \
00440   ((o)->res_opnd[(opnd) + OP_opnd_offset(o)] = (tn))
00441 
00442 /*
00443  * Define the OP cond def mask.
00444  *
00445  * OP_ALWAYS_UNC_DEF:
00446  *   Results are always unconditionally defined, independent of
00447  *   the value of the control predicate.  No upward exposed use!
00448  *   All unconditional compare falls into this category.
00449  *   All local TN def falls into this category.
00450  *
00451  * OP_ALWAYS_COND_DEF:
00452  *   Results are conditionally defined.  Whether the result is modified
00453  *   cannot not be solely determined by the OP's control predicate.
00454  *   All parallel compare falls into this category.
00455  *
00456  * PREDICATED_DEF:
00457  *   Results are defined if the control predicate evaluates to TRUE.
00458  *
00459  * Please notice that the OP_cond_def_type is sticky.  It does not
00460  * need to updated by optimizations (such as HB and EBO).  It is
00461  * initialized when the OP is first created.   [OP created through
00462  * Mk_OP will have this initialized automatically.  Other means
00463  * of OP creation have to worry about the initialization]
00464  *
00465  * It can be promoted (i.e, from PREDICATED_DEF to ALWAYS_UNC_DEF)
00466  * when any TN is discovered to be local.  Promotion is optional
00467  * in the sense that it is required by optimization, but not
00468  * by correctness.
00469  *
00470  */
00471 enum OP_COND_DEF_KIND {
00472   OP_UNKNOWN_DEF = 0,
00473   OP_ALWAYS_UNC_DEF = 0x800,      
00474   OP_ALWAYS_COND_DEF = 0x1000,
00475   OP_PREDICATED_DEF = 0x1800,
00476   OP_MASK_COND_DEF = 0x1800,   
00477 };
00478 
00479 /* Define the flag masks. */
00480 
00481 #define OP_MASK_GLUE        0x00000001 /* Is OP region "glue"? */
00482 #define OP_MASK_NO_ALIAS      0x00000002 /* Is OP Memop that can't be aliased */
00483 #define OP_MASK_COPY        0x00000004 /* Is OP a COPY? */
00484 #define OP_MASK_FLAG1       0x00000008 /* temporary flag for local use */
00485 #define OP_MASK_VOLATILE      0x00000010 /* Is OP a volatile Memop? */
00486 #define OP_MASK_HOISTED       0x00000020 /* Is there a WN map attatched to a hoisted OP */
00487 #define OP_MASK_END_GROUP     0x00000040 /* Is OP end of an instruction group */
00488 #define OP_MASK_M_UNIT        0x00000080 /* Is OP assigned to M unit */
00489 #define OP_MASK_TAIL_CALL     0x00000100 /* Is OP a tail call? */
00490 #define OP_MASK_BUNDLED       0x00000200 /* Is OP bundled? */
00491 #define OP_MASK_SPECULATIVE   0x00000400 /* Is OP a speculative live-range op? */
00492 /* OP_MAKS_COND_DEF  0x00001800  -- See enum defined above  */
00493 #define OP_MASK_NO_CI_ALIAS   0x00002000 /* no cross-iteration alias */
00494 #define OP_MASK_NO_MOVE_BEFORE_GRA \
00495                               0x00004000 /* do not move this op before GRA */
00496 #define OP_MASK_TAG         0x00008000 /* OP has tag */
00497 #define OP_MASK_SPADJ_PLUS    0x00010000 /* Is OP de-alloca spadjust (plus)? */
00498 #define OP_MASK_SPADJ_MINUS   0x00020000 /* Is OP alloca spadjust (minus)? */
00499 #ifdef TARG_IA64
00500 #define OP_MASK_START_BD      0x00040000 /* Is OP start of a bundle */
00501 #define OP_MASK_SAFE_LOAD     0x00080000 /* Is OP safe load */
00502 #define OP_MASK_SCHEDULED     0x00100000 /* Has OP been scheduled */
00503 #define OP_MASK_CNTL_SPEC     0x00200000 /* Is OP control speculated? */ 
00504 #define OP_MASK_DATA_SPEC     0x00400000 /* Is OP data speculated? */
00505 #define OP_MASK_PREFETCHED    0x00800000 /* Has OP been prefetched? */
00506 #define OP_MASK_IF_CONVERTED  0x01000000 /* Is OP if-converted? */
00507 #define OP_MASK_RENAMED       0x02000000 /* Is OP renamed by GLOS */
00508 #define OP_MASK_SPILL_RESTORE 0x04000000 /* Is OP a spill or restore  */
00509 #define OP_MASK_LD_GOT_ENT    0x08000000 /* load GOT entry */ 
00510 #endif
00511 #define OP_MASK_FIRST_OP_AFTER_PREAMBLE_END  \
00512                               0x10000000 /* first OP following PRAGMA_PREAMBLE_END? */
00513 #define OP_MASK_PREFETCH_DELETED \
00514                               0x20000000 /* prefetch deleted by scheduler */
00515 
00516 #ifdef TARG_X8664
00517 #define OP_MASK_MEMORY_HI     0x00040000 /* Is OP load/store the high 32-bit? */
00518 #define OP_MASK_COMPUTES_GOT  0x00100000 /* Does OP compute GOT ? */
00519 #define OP_MASK_PREFIX_LOCK   0x01000000
00520 #endif
00521 #if defined(TARG_IA64) || defined(TARG_SL) || defined(TARG_MIPS)
00522 # define OP_renamed(op)   (OP_flags(op) & OP_MASK_RENAMED)
00523 # define Set_OP_renamed(o)  (OP_flags(o) |= OP_MASK_RENAMED)
00524 # define Reset_OP_renamed(o)  (OP_flags(o) &= ~OP_MASK_RENAMED)
00525  
00526 #if defined (TARG_MIPS) && !defined(TARG_SL)
00527 #define OP_MASK_RENAMED       0x00100000  /* Is OP renamed during global sched */
00528 #endif
00529 #if defined(TARG_SL) 
00530 #define OP_MASK_RENAMED       0x00100000  /* Is OP renamed during global sched */
00531 #define OP_MASK_BC2_OP        0x00200000  /* Is OP renamed during global sched */
00532 #define OP_MASK_C2_BR_OP      0x00400000
00533 #define OP_MASK_16bit_OP      0x00400000  /* Is OP rechanged as 16-bit OP*/
00534 #define OP_MASK_PAIRED_OP     0x00800000  /* Is OP paired: 2 continus 16-bit OP */ 
00535 #define OP_MASK_ARdep_OP      0x01000000  /* Is OP dep with normal memory OP */
00536 #define OP_bc2_op(op)   (OP_flags(op) & OP_MASK_BC2_OP)
00537 #define Set_OP_bc2_op(o)  (OP_flags(o) |= OP_MASK_BC2_OP)
00538 #define Reset_OP_bc2_op(o)  (OP_flags(o) &= ~OP_MASK_BC2_OP)
00539 #define OP_16bit_op(op)        (OP_flags(op) & OP_MASK_16bit_OP)
00540 #define Set_OP_16bit_op(o)     (OP_flags(o) |= OP_MASK_16bit_OP)
00541 #define Reset_OP_16bit_op(o)   (OP_flags(o) &= ~OP_MASK_16bit_OP)
00542 #define OP_Paired_op(op)       (OP_flags(op) & OP_MASK_PAIRED_OP)
00543 #define Set_OP_Paired_op(o)    (OP_flags(o) |= OP_MASK_PAIRED_OP)
00544 #define Reset_OP_Paired_op(o)  (OP_flags(o) &= ~OP_MASK_PAIRED_OP)
00545 #define OP_c2_br_op(op)   (OP_flags(op) & OP_MASK_C2_BR_OP)
00546 #define Set_OP_c2_br_op(o)  (OP_flags(o) |= OP_MASK_C2_BR_OP)
00547 #define Reset_OP_c2_br_op(o)  (OP_flags(o) &= ~OP_MASK_C2_BR_OP)
00548 #define OP_ARdep(o)           (OP_flags(o) & OP_MASK_ARdep_OP)
00549 #define Set_OP_ARdep(o)       (OP_flags(o) |= OP_MASK_ARdep_OP)
00550 #define Reset_OP_ARdep(o)     (OP_flags(o) &= ~OP_MASK_ARdep_OP)
00551 #endif //TARG_SL
00552 #endif 
00553 
00554 
00555 # define OP_glue(o)   (OP_flags(o) & OP_MASK_GLUE)
00556 # define Set_OP_glue(o)   (OP_flags(o) |= OP_MASK_GLUE)
00557 # define Reset_OP_glue(o) (OP_flags(o) &= ~OP_MASK_GLUE)
00558 # define OP_no_alias(o)   (OP_flags(o) & OP_MASK_NO_ALIAS)
00559 # define Set_OP_no_alias(o) (OP_flags(o) |= OP_MASK_NO_ALIAS)
00560 # define Reset_OP_no_alias(o) (OP_flags(o) &= ~OP_MASK_NO_ALIAS)
00561 # define OP_copy(o)   (OP_flags(o) & OP_MASK_COPY)
00562 # define Set_OP_copy(o)   (OP_flags(o) |= OP_MASK_COPY)
00563 # define Reset_OP_copy(o) (OP_flags(o) &= ~OP_MASK_COPY)
00564 # define OP_flag1(o)    (OP_flags(o) & OP_MASK_FLAG1)
00565 # define Set_OP_flag1(o)  (OP_flags(o) |= OP_MASK_FLAG1)
00566 # define Reset_OP_flag1(o)  (OP_flags(o) &= ~OP_MASK_FLAG1)
00567 # define OP_volatile(o)   (OP_flags(o) & OP_MASK_VOLATILE)
00568 # define Set_OP_volatile(o) (OP_flags(o) |= OP_MASK_VOLATILE)
00569 # define Reset_OP_volatile(o) (OP_flags(o) &= ~OP_MASK_VOLATILE)
00570 # define OP_hoisted(o)    (OP_flags(o) & OP_MASK_HOISTED)
00571 # define Set_OP_hoisted(o)  (OP_flags(o) |= OP_MASK_HOISTED)
00572 # define Reset_OP_hoisted(o)  (OP_flags(o) &= ~OP_MASK_HOISTED)
00573 # define OP_end_group(o)  (OP_flags(o) & OP_MASK_END_GROUP)
00574 # define Set_OP_end_group(o)  (OP_flags(o) |= OP_MASK_END_GROUP)
00575 # define Reset_OP_end_group(o)  (OP_flags(o) &= ~OP_MASK_END_GROUP)
00576 # define OP_m_unit(o)   (OP_flags(o) & OP_MASK_M_UNIT)
00577 # define Set_OP_m_unit(o) (OP_flags(o) |= OP_MASK_M_UNIT)
00578 # define Reset_OP_m_unit(o) (OP_flags(o) &= ~OP_MASK_M_UNIT)
00579 # define OP_tail_call(o)  (OP_flags(o) & OP_MASK_TAIL_CALL)
00580 # define Set_OP_tail_call(o)  (OP_flags(o) |= OP_MASK_TAIL_CALL)
00581 # define Reset_OP_tail_call(o)  (OP_flags(o) &= ~OP_MASK_TAIL_CALL)
00582 # define OP_bundled(o)    (OP_flags(o) & OP_MASK_BUNDLED)
00583 # define Set_OP_bundled(o)  (OP_flags(o) |= OP_MASK_BUNDLED)
00584 # define Reset_OP_bundled(o)  (OP_flags(o) &= ~OP_MASK_BUNDLED)
00585 # define OP_speculative(o)  (OP_flags(o) & OP_MASK_SPECULATIVE)
00586 # define Set_OP_speculative(o)  (OP_flags(o) |= OP_MASK_SPECULATIVE)
00587 # define Reset_OP_speculative(o)(OP_flags(o) &= ~OP_MASK_SPECULATIVE)
00588 # define OP_cond_def_kind(o)  (OP_flags(o) & OP_MASK_COND_DEF)
00589 # define Set_OP_cond_def_kind(o,k) (OP_flags(o) = (OP_flags(o) & ~OP_MASK_COND_DEF) | k)
00590 # define OP_no_ci_alias(o)  (OP_flags(o) & OP_MASK_NO_CI_ALIAS)
00591 # define Set_OP_no_ci_alias(o)  (OP_flags(o) |= OP_MASK_NO_CI_ALIAS)
00592 # define Reset_OP_no_ci_alias(o) (OP_flags(o) &= ~OP_MASK_NO_CI_ALIAS)
00593 # define OP_no_move_before_gra(o) (OP_flags(o) & OP_MASK_NO_MOVE_BEFORE_GRA)
00594 # define Set_OP_no_move_before_gra(o) (OP_flags(o) |= OP_MASK_NO_MOVE_BEFORE_GRA)
00595 # define OP_has_tag(o)    (OP_flags(o) & OP_MASK_TAG)
00596 # define Set_OP_has_tag(o)  (OP_flags(o) |= OP_MASK_TAG)
00597 # define Reset_OP_has_tag(o)  (OP_flags(o) &= ~OP_MASK_TAG)
00598 # define OP_spadjust_plus(o)  (OP_flags(o) & OP_MASK_SPADJ_PLUS)
00599 # define Set_OP_spadjust_plus(o)(OP_flags(o) |= OP_MASK_SPADJ_PLUS)
00600 # define Reset_OP_spadjust_plus(o) (OP_flags(o) &= ~OP_MASK_SPADJ_PLUS)
00601 # define OP_spadjust_minus(o) (OP_flags(o) & OP_MASK_SPADJ_MINUS)
00602 # define Set_OP_spadjust_minus(o) (OP_flags(o) |= OP_MASK_SPADJ_MINUS)
00603 # define Reset_OP_spadjust_minus(o) (OP_flags(o) &= ~OP_MASK_SPADJ_MINUS)
00604 #ifdef TARG_IA64
00605 # define OP_start_bundle(o) (OP_flags(o) & OP_MASK_START_BD)
00606 # define Set_OP_start_bundle(o) (OP_flags(o) |= OP_MASK_START_BD)
00607 # define Reset_OP_start_bundle(o) (OP_flags(o) &= ~OP_MASK_START_BD)
00608 # define OP_safe_load(o) (OP_flags(o) & OP_MASK_SAFE_LOAD)
00609 # define Set_OP_safe_load(o)  (OP_flags(o) |= OP_MASK_SAFE_LOAD)
00610 # define Reset_OP_safe_load(o) (OP_flags(o) &= ~OP_MASK_SAFE_LOAD)
00611 
00612 # define OP_Scheduled(o)       (OP_flags(o) & OP_MASK_SCHEDULED)
00613 # define Set_OP_Scheduled(o)   (OP_flags(o) |= OP_MASK_SCHEDULED)
00614 # define Reset_OP_Scheduled(o) (OP_flags(o) &= ~OP_MASK_SCHEDULED)
00615 
00616 # define OP_Prefetched(o)       (OP_flags(o) & OP_MASK_PREFETCHED)
00617 # define Set_OP_Prefetched(o)   (OP_flags(o) |= OP_MASK_PREFETCHED)
00618 # define Reset_OP_Prefetched(o) (OP_flags(o) &= ~OP_MASK_PREFETCHED)
00619 
00620 //# define OP_catch_nat(o)  (OP_flags(o) & OP_MASK_CATCH_NAT)
00621 //# define Set_OP_catch_nat(o)  (OP_flags(o) |= OP_MASK_CATCH_NAT)
00622 //# define Reset_OP_catch_nat(o)  (OP_flags(o) &= ~OP_MASK_CATCH_NAT)
00623 # define OP_cntl_spec(o)           (OP_flags(o) &  OP_MASK_CNTL_SPEC)
00624 # define Set_OP_cntl_spec(o)       (OP_flags(o) |= OP_MASK_CNTL_SPEC)
00625 # define Reset_OP_cntl_spec(o)     (OP_flags(o) &= ~OP_MASK_CNTL_SPEC)
00626 # define OP_data_spec(o)           (OP_flags(o) &  OP_MASK_DATA_SPEC)
00627 # define Set_OP_data_spec(o)       (OP_flags(o) |= OP_MASK_DATA_SPEC)
00628 # define Reset_OP_data_spec(o)     (OP_flags(o) &= ~OP_MASK_DATA_SPEC)
00629 # define OP_if_converted(o)     (OP_flags(o) & OP_MASK_IF_CONVERTED)
00630 # define Set_OP_if_converted(o)   (OP_flags(o) |= OP_MASK_IF_CONVERTED)
00631 # define Reset_OP_if_converted(o) (OP_flags(o) &= ~OP_MASK_IF_CONVERTED)
00632 # define OP_spill_restore(op)     (OP_flags(op) & OP_MASK_SPILL_RESTORE)
00633 # define Set_OP_spill_restore(o)    (OP_flags(o) |= OP_MASK_SPILL_RESTORE)
00634 # define Reset_OP_spill_restore(o)  (OP_flags(o) &= ~OP_MASK_SPILL_RESTORE)
00635 # define OP_load_GOT_entry(o)           (OP_flags(o) & OP_MASK_LD_GOT_ENT)
00636 # define Set_OP_load_GOT_entry(o)       (OP_flags(o) |= OP_MASK_LD_GOT_ENT)
00637 # define Reset_OP_load_GOT_entry(o)     (OP_flags(o) &= ~OP_MASK_LD_GOT_ENT)
00638 #endif
00639 
00640 #ifdef TARG_X8664
00641 # define OP_memory_hi(o)  (OP_flags(o) & OP_MASK_MEMORY_HI)
00642 # define Set_OP_memory_hi(o)  (OP_flags(o) |= OP_MASK_MEMORY_HI)
00643 # define Reset_OP_memory_hi(o)  (OP_flags(o) &= ~OP_MASK_MEMORY_HI)
00644 # define OP_computes_got(o)     (OP_flags(o) & OP_MASK_COMPUTES_GOT)
00645 # define Set_OP_computes_got(o) (OP_flags(o) |= OP_MASK_COMPUTES_GOT)
00646 # define Set_OP_prefix_lock(o)  (OP_flags(o) |= OP_MASK_PREFIX_LOCK)
00647 # define OP_prefix_lock(o)      (OP_flags(o) & OP_MASK_PREFIX_LOCK)
00648 #endif // TARG_X8664
00649 
00650 # define OP_first_after_preamble_end(o) (OP_flags(o) & OP_MASK_FIRST_OP_AFTER_PREAMBLE_END)
00651 # define Set_OP_first_after_preamble_end(o) (OP_flags(o) |= OP_MASK_FIRST_OP_AFTER_PREAMBLE_END)
00652 # define Reset_OP_first_after_preamble_end(o) (OP_flags(o) &= ~OP_MASK_FIRST_OP_AFTER_PREAMBLE_END)
00653 
00654 # define OP_prefetch_deleted(o) (OP_flags(o) & OP_MASK_PREFETCH_DELETED)
00655 # define Set_OP_prefetch_deleted(o) (OP_flags(o) |= OP_MASK_PREFETCH_DELETED)
00656 # define Reset_OP_prefetch_deleted(o) (OP_flags(o) &= ~OP_MASK_PREFETCH_DELETED)
00657 
00658 extern BOOL OP_cond_def(const OP*);
00659 extern BOOL OP_has_implicit_interactions(OP*);
00660 #if defined(TARG_IA64) || defined(TARG_SL) || defined(TARG_MIPS)
00661 extern BOOL OP_def_return_value (OP*);
00662 #endif
00663 #ifdef TARG_IA64
00664 extern BOOL OP_xfer(OP*);           // After RBG, chk should be taken as xfer.
00665 
00666 extern BOOL OP_restore_b0(OP*);
00667 extern BOOL OP_restore_ar_pfs(OP*);
00668 extern BOOL OP_def_ar_lc(OP*);
00669 extern BOOL OP_use_return_value(OP*); 
00670 #endif
00671 
00672 /* Convenience access macros for properties of the OP */
00673 /* TODO: define all the macros for OP properties. */
00674 #define OP_noop(o)    (TOP_is_noop(OP_code(o)))
00675 #define OP_load(o)    (TOP_is_load(OP_code(o)))
00676 #define OP_store(o)   (TOP_is_store(OP_code(o)))
00677 #define OP_prefetch(o)  (TOP_is_prefetch(OP_code(o)))
00678 #if defined(TARG_SL)        
00679 #define OP_alu(o)              (TOP_is_alu_instr(OP_code(o)))
00680 #endif
00681 #ifdef TARG_X8664
00682 #define OP_load_exe(o)    (TOP_is_load_exe(OP_code(o)))
00683 #define OP_load_exe_store(o)  (TOP_is_load_exe_store(OP_code(o)))
00684 #define OP_memory(o)    (OP_load(o) | OP_store(o) | OP_prefetch(o))
00685 #else
00686 #define OP_memory(o)    (OP_load(o) | OP_store(o) | OP_prefetch(o))
00687 #endif
00688 #define OP_mem_fill_type(o)     (TOP_is_mem_fill_type(OP_code(o)))
00689 #define OP_call(o)    (TOP_is_call(OP_code(o)))
00690 #if defined(TARG_X8664) || defined(TARG_SL) || defined(TARG_NVISA) || defined(TARG_MIPS)
00691 #define OP_xfer(o)    (TOP_is_xfer(OP_code(o)))
00692 #endif
00693 #define OP_cond(o)    (TOP_is_cond(OP_code(o)))
00694 #define OP_likely(o)    (TOP_is_likely(OP_code(o)))
00695 #define OP_dummy(o)   (TOP_is_dummy(OP_code(o)))
00696 #define OP_flop(o)    (TOP_is_flop(OP_code(o)))
00697 #define OP_fadd(o)    (TOP_is_fadd(OP_code(o)))
00698 #define OP_fdiv(o)    (TOP_is_fdiv(OP_code(o)))
00699 #define OP_fmul(o)    (TOP_is_fmul(OP_code(o)))
00700 #define OP_fmisc(o)   (TOP_is_fmisc(OP_code(o)))
00701 #define OP_fsub(o)    (TOP_is_fsub(OP_code(o)))
00702 #define OP_iadd(o)    (TOP_is_iadd(OP_code(o)))
00703 #define OP_ior(o)   (TOP_is_ior(OP_code(o)))
00704 #define OP_ixor(o)    (TOP_is_ixor(OP_code(o)))
00705 #define OP_iand(o)    (TOP_is_iand(OP_code(o)))
00706 #define OP_icmp(o)    (TOP_is_icmp(OP_code(o)))
00707 #define OP_idiv(o)    (TOP_is_idiv(OP_code(o)))
00708 #define OP_imul(o)    (TOP_is_imul(OP_code(o)))
00709 #define OP_isub(o)    (TOP_is_isub(OP_code(o)))
00710 #define OP_madd(o)    (TOP_is_madd(OP_code(o)))
00711 #define OP_sqrt(o)    (TOP_is_sqrt(OP_code(o)))
00712 #define OP_mmmul(o)   (TOP_is_mmmul(OP_code(o)))
00713 #define OP_mmshf(o)   (TOP_is_mmshf(OP_code(o)))
00714 #define OP_mmalu(o)   (TOP_is_mmalu(OP_code(o)))
00715 #define OP_select(o)    (TOP_is_select(OP_code(o)))
00716 #define OP_cond_move(o)   (TOP_is_cond_move(OP_code(o)))
00717 #define OP_uniq_res(o)    (TOP_is_uniq_res(OP_code(o)))
00718 #define OP_unalign_ld(o)  (TOP_is_unalign_ld(OP_code(o)))
00719 #define OP_unalign_store(o) (TOP_is_unalign_store(OP_code(o)))
00720 #define OP_unalign_mem(o) (OP_unalign_ld(o) | OP_unalign_store(o))
00721 #define OP_defs_fcc(o)    (TOP_is_defs_fcc(OP_code(o)))
00722 #define OP_defs_fcr(o)    (TOP_is_defs_fcr(OP_code(o)))
00723 #define OP_defs_fpu_int(o)  (TOP_is_defs_fpu_int(OP_code(o)))
00724 #define OP_defs_fp(o)   (TOP_is_defs_fp(OP_code(o)))
00725 #define OP_refs_fcr(o)    (TOP_is_refs_fcr(OP_code(o)))
00726 #define OP_unsafe(o)            (TOP_is_unsafe(OP_code(o)))
00727 #define OP_jump(o)    (TOP_is_jump(OP_code(o)))
00728 #define OP_ijump(o)   (TOP_is_ijump(OP_code(o)))
00729 #define OP_f_group(o)           (TOP_is_f_group(OP_code(o)))
00730 #define OP_l_group(o)           (TOP_is_l_group(OP_code(o)))
00731 #define OP_privileged(o)        (TOP_is_privileged(OP_code(o)))
00732 #define OP_simulated(o)   (TOP_is_simulated(OP_code(o)))
00733 #define OP_has_predicate(o) (TOP_is_predicated(OP_code(o)))
00734 #define OP_access_reg_bank(o) (TOP_is_access_reg_bank(OP_code(o)))
00735 #define OP_side_effects(o)  (TOP_is_side_effects(OP_code(o)))
00736 #define OP_branch_predict(o)  (TOP_is_branch_predict(OP_code(o)))
00737 #define OP_var_opnds(o)   (TOP_is_var_opnds(OP_code(o)))
00738 #define OP_uncond(o)            (OP_xfer(o) && !OP_cond(o))
00739 #ifdef TARG_X8664
00740 #define OP_x86_style(o)         (TOP_is_x86_style(OP_code(o)))
00741 #define OP_reads_rflags(o)      (TOP_is_read_rflags(OP_code(o)))
00742 #define OP_x87(o)   (TOP_is_x87(OP_code(o)))
00743 #define OP_mmx(o)   (TOP_is_mmx(OP_code(o)))
00744 #endif
00745 
00746 #if defined(TARG_SL) //fork_joint
00747 #define OP_fork(o)              (TOP_is_fork_instr(OP_code(o)))
00748 #define OP_vbuf_load(o)         (TOP_is_c2_v_load(OP_code(o)))
00749 #define OP_sbuf_load(o)         (TOP_is_c2_s_load(OP_code(o)))
00750 #define OP_vbuf_store(o)        (TOP_is_c2_v_store(OP_code(o)))
00751 #define OP_sbuf_store(o)        (TOP_is_c2_s_store(OP_code(o)))
00752 #define OP_has_bypass(o)        (TOP_is_c2_has_bypass(OP_code(o)))
00753 #define OP_c2_load(o)           (TOP_is_c2_load(OP_code(o)))
00754 #define OP_c2_store(o)          (TOP_is_c2_store(OP_code(o)))
00755 
00756 #define OP_c3_load(o)         (TOP_is_c3_load(OP_code(o)))
00757 #define OP_c3_store(o)          (TOP_is_c3_store(OP_code(o)))
00758 
00759 #endif 
00760 
00761 #define OP_operand_info(o)  (ISA_OPERAND_Info(OP_code(o)))
00762 #define OP_has_hazard(o)  (ISA_HAZARD_TOP_Has_Hazard(OP_code(o)))
00763 #define OP_immediate_opnd(o)  (TOP_Immediate_Operand(OP_code(o),NULL))
00764 #define OP_has_immediate(o) (OP_immediate_opnd(o) >= 0)
00765 #define OP_inst_words(o)  (ISA_PACK_Inst_Words(OP_code(o)))
00766 #define OP_find_opnd_use(o,u) (TOP_Find_Operand_Use(OP_code(o),(u)))
00767 
00768 #ifdef TARG_SL
00769 #define OP_memtrap(o)           (TOP_is_memtrap(OP_code(o))) /* memory operation*/
00770 #define OP_no_peephole(o)       (TOP_is_npeep(OP_code(o)))
00771 #endif
00772 
00773 #ifdef TARG_IA64
00774 // bug fix for OSP_87 and OSP_88
00775 #define OP_asm(o)              (OP_code(o)==TOP_asm)
00776 
00777 inline BOOL OP_float_chk(OP *op)
00778 {
00779     mTOP opcode = OP_code(op);
00780     switch (opcode) {
00781     case TOP_chk_f_a:
00782     case TOP_chk_f_s:
00783       return TRUE;
00784     default:
00785       return FALSE;
00786     }
00787 }
00788 
00789 inline BOOL OP_chk_a(OP *op)
00790 {
00791     mTOP opcode = OP_code(op);
00792     switch (opcode) {
00793     case TOP_chk_a:
00794     case TOP_chk_f_a:
00795       return TRUE;
00796     default:
00797       return FALSE;
00798     } 
00799 }
00800    
00801 inline BOOL OP_chk_s(OP *op)
00802 {
00803     mTOP opcode = OP_code(op);
00804     switch (opcode) {
00805     case TOP_chk_s:
00806     case TOP_chk_s_i:
00807     case TOP_chk_s_m:
00808     case TOP_chk_f_s:
00809       return TRUE;
00810     default:
00811       return FALSE;
00812     } 
00813 }
00814 
00815 inline BOOL OP_chk(OP *op)
00816 {
00817     return ( OP_chk_s(op) ||
00818        OP_chk_a(op) );
00819 }
00820 
00821 inline BOOL OP_cmp_unc(OP *op)
00822 {
00823   mTOP opcode = OP_code(op);
00824   switch (opcode) {
00825     case TOP_cmp_eq_unc:
00826     case TOP_cmp_lt_unc:
00827     case TOP_cmp_ltu_unc:
00828     case TOP_cmp_i_eq_unc:
00829     case TOP_cmp_i_lt_unc:
00830     case TOP_cmp_i_ltu_unc:
00831     case TOP_cmp4_eq_unc:
00832     case TOP_cmp4_lt_unc:
00833     case TOP_cmp4_ltu_unc:
00834     case TOP_cmp4_i_eq_unc:
00835     case TOP_cmp4_i_lt_unc:
00836     case TOP_cmp4_i_ltu_unc:
00837     case TOP_fclass_m_unc:
00838     case TOP_fcmp_eq_unc:
00839     case TOP_fcmp_lt_unc:
00840     case TOP_fcmp_le_unc:
00841     case TOP_fcmp_unord_unc:
00842     case TOP_tbit_z_unc:
00843     case TOP_tnat_z_unc:
00844     case TOP_cmp_ne_unc:
00845     case TOP_cmp_le_unc:
00846     case TOP_cmp_gt_unc:
00847     case TOP_cmp_ge_unc:
00848     case TOP_cmp_leu_unc:
00849     case TOP_cmp_gtu_unc:
00850     case TOP_cmp_geu_unc:
00851     case TOP_cmp_i_ne_unc:
00852     case TOP_cmp_i_le_unc:
00853     case TOP_cmp_i_gt_unc:
00854     case TOP_cmp_i_ge_unc:
00855     case TOP_cmp_i_leu_unc:
00856     case TOP_cmp_i_gtu_unc:
00857     case TOP_cmp_i_geu_unc:
00858     case TOP_cmp4_ne_unc:
00859     case TOP_cmp4_le_unc:
00860     case TOP_cmp4_gt_unc:
00861     case TOP_cmp4_ge_unc:
00862     case TOP_cmp4_leu_unc:
00863     case TOP_cmp4_gtu_unc:
00864     case TOP_cmp4_geu_unc:
00865     case TOP_cmp4_i_ne_unc:
00866     case TOP_cmp4_i_le_unc:
00867     case TOP_cmp4_i_gt_unc:
00868     case TOP_cmp4_i_ge_unc:
00869     case TOP_cmp4_i_leu_unc:
00870     case TOP_cmp4_i_gtu_unc:
00871     case TOP_cmp4_i_geu_unc:
00872     case TOP_fclass_nm_unc:
00873     case TOP_fcmp_gt_unc:
00874     case TOP_fcmp_ge_unc:
00875     case TOP_fcmp_neq_unc:
00876     case TOP_fcmp_nlt_unc:
00877     case TOP_fcmp_nle_unc:
00878     case TOP_fcmp_ngt_unc:
00879     case TOP_fcmp_nge_unc:
00880     case TOP_fcmp_ord_unc:
00881     case TOP_tbit_nz_unc:
00882     case TOP_tnat_nz_unc:
00883       return TRUE;
00884     default:
00885       return FALSE;
00886   }
00887 }
00888 #endif
00889 
00890 inline INT OP_result_size(OP *op, INT result)
00891 {
00892   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00893   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Result(oinfo, result);
00894   return ISA_OPERAND_VALTYP_Size(otype);
00895 }
00896 
00897 inline INT OP_opnd_size(OP *op, INT opnd)
00898 {
00899   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00900   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00901   return ISA_OPERAND_VALTYP_Size(otype);
00902 }
00903 
00904 inline BOOL OP_result_is_reg(OP *op, INT result)
00905 {
00906   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00907   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Result(oinfo, result);
00908   return ISA_OPERAND_VALTYP_Is_Register(otype);
00909 }
00910 
00911 inline BOOL OP_opnd_is_reg(OP *op, INT opnd)
00912 {
00913   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00914   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00915   return ISA_OPERAND_VALTYP_Is_Register(otype);
00916 }
00917 
00918 inline BOOL OP_opnd_is_literal(OP *op, INT opnd)
00919 {
00920   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00921   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00922   return ISA_OPERAND_VALTYP_Is_Literal(otype);
00923 }
00924 
00925 inline BOOL OP_opnd_is_enum(OP *op, INT opnd)
00926 {
00927   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00928   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00929   return ISA_OPERAND_VALTYP_Is_Enum(otype);
00930 }
00931 
00932 inline BOOL OP_result_is_signed(OP *op, INT result)
00933 {
00934   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00935   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Result(oinfo, result);
00936   return ISA_OPERAND_VALTYP_Is_Signed(otype);
00937 }
00938 
00939 inline BOOL OP_opnd_is_signed(OP *op, INT opnd)
00940 {
00941   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00942   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00943   return ISA_OPERAND_VALTYP_Is_Signed(otype);
00944 }
00945 
00946 inline BOOL OP_result_is_fpu_int(OP *op, INT result)
00947 {
00948   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00949   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Result(oinfo, result);
00950   return ISA_OPERAND_VALTYP_Is_FPU_Int(otype);
00951 }
00952 
00953 inline BOOL OP_opnd_is_fpu_int(OP *op, INT opnd)
00954 {
00955   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00956   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00957   return ISA_OPERAND_VALTYP_Is_FPU_Int(otype);
00958 }
00959 
00960 inline BOOL OP_opnd_is_pcrel(OP *op, INT opnd)
00961 {
00962   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00963   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00964   return ISA_OPERAND_VALTYP_Is_PCRel(otype);
00965 }
00966 
00967 inline ISA_LIT_CLASS OP_opnd_lit_class(OP *op, INT opnd)
00968 {
00969   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00970   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00971   return ISA_OPERAND_VALTYP_Literal_Class(otype);
00972 }
00973 
00974 inline ISA_REGISTER_CLASS OP_opnd_reg_class(OP *op, INT opnd)
00975 {
00976   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00977   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00978   return ISA_OPERAND_VALTYP_Register_Class(otype);
00979 }
00980 
00981 inline ISA_REGISTER_CLASS OP_result_reg_class(OP *op, INT opnd)
00982 {
00983   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00984   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Result(oinfo, opnd);
00985   return ISA_OPERAND_VALTYP_Register_Class(otype);
00986 }
00987 
00988 inline ISA_REGISTER_SUBCLASS OP_opnd_reg_subclass(OP *op, INT opnd)
00989 {
00990   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00991   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Operand(oinfo, opnd);
00992   return ISA_OPERAND_VALTYP_Register_Subclass(otype);
00993 }
00994 
00995 inline ISA_REGISTER_SUBCLASS OP_result_reg_subclass(OP *op, INT opnd)
00996 {
00997   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
00998   const ISA_OPERAND_VALTYP *otype = ISA_OPERAND_INFO_Result(oinfo, opnd);
00999   return ISA_OPERAND_VALTYP_Register_Subclass(otype);
01000 }
01001 
01002 inline ISA_OPERAND_USE OP_opnd_use(OP *op, INT opnd)
01003 {
01004   const ISA_OPERAND_INFO *oinfo = ISA_OPERAND_Info(OP_code(op));
01005   return ISA_OPERAND_INFO_Use(oinfo, opnd);
01006 }
01007 
01008 #define OP_has_result(o) (OP_results(o) != 0)
01009 
01010 /* Is OP a branch ? */
01011 #define  OP_br(o) (OP_xfer(o) && !OP_call(o))
01012 
01013 /* _fixed_results and _fixed_opnds return how many fixed
01014  * results/operands an instruction has (OP_result/OP_opnds includes
01015  * any variable operands in the count).
01016  */
01017 #define TOP_fixed_results(o)  (ISA_OPERAND_INFO_Results(ISA_OPERAND_Info(o)))
01018 #define TOP_fixed_opnds(o)  (ISA_OPERAND_INFO_Operands(ISA_OPERAND_Info(o)))
01019 #define OP_fixed_results(o) (TOP_fixed_results(OP_code(o)))
01020 #define OP_fixed_opnds(o) (TOP_fixed_opnds(OP_code(o)))
01021 
01022 /* ---------------------------------------------------------------------
01023  *             OPS stuff
01024  * ---------------------------------------------------------------------
01025  */
01026 
01027 typedef struct ops {
01028   struct op *first;
01029   struct op *last;
01030   UINT16 length;
01031 } OPS;
01032 
01033 #define OPS_first(ops) ((ops)->first+0)
01034 #define OPS_last(ops) ((ops)->last+0)
01035 #define OPS_length(ops) ((ops)->length+0)
01036 #define OPS_EMPTY { NULL, NULL, 0 }
01037 
01038 inline OPS *OPS_Create(void)
01039 {
01040   OPS *result = TYPE_MEM_POOL_ALLOC(OPS, &MEM_pu_pool);
01041   result->first = result->last = NULL;
01042   result->length = 0;
01043   return result;
01044 }
01045 
01046 inline void OPS_Remove_All(OPS *ops)
01047 {
01048   ops->first = ops->last = NULL;
01049   ops->length = 0;
01050 }
01051   
01052 inline OPS *OPS_Init(OPS *ops)
01053 {
01054   ops->first = ops->last = NULL;
01055   ops->length = 0;
01056   return ops;
01057 }
01058 
01059 inline void OPS_Remove_Op(OPS *ops, OP *op)
01060 {
01061   OP **prevp = OP_next(op) ? &OP_next(op)->prev : &ops->last;
01062   OP **nextp = OP_prev(op) ? &OP_prev(op)->next : &ops->first;
01063 
01064 #if defined(TARG_NVISA)
01065   FmtAssert(OP_prev(op) || OP_next(op) || ops->first == op, 
01066   ("OPS_Remove_Op: op not in ops"));
01067 #endif
01068   
01069   *prevp = OP_prev(op);
01070   *nextp = OP_next(op);
01071 
01072   op->prev = op->next = NULL;
01073   ops->length--;
01074 }
01075 
01076 inline void OPS_Remove_Ops(OPS *ops, OPS *remove_ops)
01077 {
01078   OP *first = OPS_first(remove_ops);
01079   OP *last = OPS_last(remove_ops);
01080   OP **prevp, **nextp;
01081 
01082   if (first == NULL) return;
01083 
01084   FmtAssert(last != NULL,
01085       ("remove_ops is malformed (last is NULL but first isn't)"));
01086 
01087   prevp = OP_next(last) ? &OP_next(last)->prev : &ops->last;
01088   nextp = OP_prev(first) ? &OP_prev(first)->next : &ops->first;
01089   
01090   *prevp = OP_prev(first);
01091   *nextp = OP_next(last);
01092 
01093   first->prev = last->next = NULL;
01094   ops->length -= OPS_length(remove_ops);
01095 }
01096 
01097 void OPS_Insert_Op_Before(OPS *ops, OP *point, OP *op);
01098 void OPS_Insert_Op_After(OPS *ops, OP *point, OP *op);
01099 void OPS_Append_Op(OPS *ops, OP *op);
01100 void OPS_Prepend_Op(OPS *ops, OP *op);
01101 void OPS_Insert_Ops_Before(OPS *ops, OP *point, OPS *insert_ops);
01102 void OPS_Insert_Ops_After(OPS *ops, OP *point, OPS *insert_ops);
01103 void OPS_Append_Ops(OPS *ops, OPS *insert_ops);
01104 void OPS_Prepend_Ops(OPS *ops, OPS *insert_ops);
01105 void OPS_Insert_Op(OPS *ops, OP *point, OP *op, BOOL before);
01106 void OPS_Insert_Ops(OPS *ops, OP *point, OPS *insert_ops, BOOL before);
01107 
01108 /* ====================================================================
01109  *
01110  * Utility routines which manipulate OPs.
01111  *
01112  * ====================================================================
01113  */
01114 
01115 /* Basic OP generators: */
01116 extern OP *Dup_OP ( OP *op );
01117 
01118 extern void Free_OP_List ( OP *op );  /* Free OP list's space */
01119 
01120 /* OP generation utilities: */
01121 extern OP *Mk_OP (
01122   TOP opr,    /* operator */
01123   ...     /* the results and operands */
01124 );
01125 
01126 extern OP *Mk_VarOP (
01127   TOP opr,    /* operator */
01128   INT results,    /* number of results */
01129   INT opnds,    /* number of operands */
01130   struct tn **res_tn, /* result array */
01131   struct tn **opnd_tn /* operand array */
01132 );
01133 
01134 /* Build OP and append to ops list: */
01135 
01136 inline void Build_OP(TOP opc, OPS *ops)
01137 {
01138   OPS_Append_Op(ops, Mk_OP(opc));
01139 }
01140 
01141 inline void Build_OP(TOP opc, struct tn *t1, OPS *ops)
01142 {
01143   OPS_Append_Op(ops, Mk_OP(opc, t1));
01144 }
01145 
01146 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, OPS *ops)
01147 {
01148   OPS_Append_Op(ops, Mk_OP(opc, t1, t2));
01149 }
01150 
01151 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01152             OPS *ops)
01153 {
01154   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3));
01155 }
01156 
01157 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01158             struct tn *t4, OPS *ops)
01159 {
01160   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4));
01161 }
01162 
01163 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01164             struct tn *t4, struct tn *t5, OPS *ops)
01165 {
01166   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5));
01167 }
01168 
01169 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01170             struct tn *t4, struct tn *t5, struct tn *t6, 
01171             OPS *ops)
01172 {
01173   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6));
01174 }
01175 
01176 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01177             struct tn *t4, struct tn *t5, struct tn *t6, 
01178             struct tn *t7, OPS *ops)
01179 {
01180   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7));
01181 }
01182 
01183 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01184             struct tn *t4, struct tn *t5, struct tn *t6, 
01185             struct tn *t7, struct tn *t8, OPS *ops)
01186 {
01187   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7, t8));
01188 }
01189 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01190             struct tn *t4, struct tn *t5, struct tn *t6, 
01191             struct tn *t7, struct tn *t8, struct tn *t9, 
01192             OPS *ops)
01193 {
01194   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7, t8, t9));
01195 }
01196 #if defined(TARG_SL)
01197 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3, 
01198             struct tn *t4, struct tn *t5, struct tn *t6, 
01199             struct tn *t7, struct tn *t8, struct tn *t9, struct tn *t10,
01200             OPS *ops)
01201 {
01202   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7, t8, t9,t10));
01203 }
01204 
01205 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3,
01206                               struct tn *t4, struct tn *t5, struct tn *t6,
01207                               struct tn *t7, struct tn *t8, struct tn *t9, 
01208                   struct tn *t10, struct tn *t11,
01209                               OPS *ops)
01210 {
01211   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11));
01212 }
01213 
01214 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3,
01215                               struct tn *t4, struct tn *t5, struct tn *t6,
01216                               struct tn *t7, struct tn *t8, struct tn *t9,
01217                               struct tn *t10, struct tn *t11, struct tn *t12,
01218                               OPS *ops)
01219 {
01220   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7, t8, t9,t10,t11, t12));
01221 }
01222 
01223 inline void Build_OP(TOP opc, struct tn *t1, struct tn *t2, struct tn *t3,
01224                               struct tn *t4, struct tn *t5, struct tn *t6,
01225                               struct tn *t7, struct tn *t8, struct tn *t9,
01226                               struct tn *t10, struct tn *t11, struct tn *t12,
01227                               struct tn *t13,
01228                               OPS *ops)
01229 {
01230   OPS_Append_Op(ops, Mk_OP(opc, t1, t2, t3, t4, t5, t6, t7, t8, t9,t10,t11, t12, t13));
01231 }
01232 #endif
01233 /* Determine if the op defines/references the given TN result/operand. */
01234 extern BOOL OP_Defs_TN(const OP *op, const struct tn *res);
01235 extern BOOL OP_Refs_TN(const OP *op, const struct tn *opnd);
01236 
01237 /* Determine if the op defines/references the given register. */
01238 extern BOOL OP_Defs_Reg(const OP *op, ISA_REGISTER_CLASS rclass, REGISTER reg);
01239 extern BOOL OP_Refs_Reg(const OP *op, ISA_REGISTER_CLASS rclass, REGISTER reg);
01240 
01241 inline void OP_Change_Opcode(OP *op, TOP opc)
01242 {
01243   Is_True(   OP_fixed_results(op) == TOP_fixed_results(opc)
01244     && OP_fixed_opnds(op) == TOP_fixed_opnds(opc),
01245     ("different number of results/operands for %s and %s",
01246      TOP_Name(OP_code(op)), TOP_Name(opc)));
01247   Is_True(OP_var_opnds(op) == TOP_is_var_opnds(opc),
01248     ("var_opnds property not same for %s and %s",
01249      TOP_Name(OP_code(op)), TOP_Name(opc)));
01250 
01251   op->opr = (mTOP)opc;
01252 }
01253 
01254 inline void OP_Change_To_Noop(OP *op)
01255 {
01256   op->opr = (mTOP)TOP_noop;
01257   op->opnds = 0;
01258   op->results = 0;
01259   OP_flags(op) = 0;
01260 }
01261 
01262 inline BOOL OP_Precedes(OP *op1, OP *op2)
01263 {
01264   return op1->order < op2->order;
01265 }
01266 
01267 inline BOOL OP_Follows(OP *op1, OP *op2)
01268 {
01269   return op1->order > op2->order;
01270 }
01271 
01272 inline INT64 OP_Ordering(OP *op1, OP *op2)
01273 {
01274   return (INT64)op1->order - (INT64)op2->order;
01275 }
01276 
01277 inline INT32 OP_Order(OP *op1, OP *op2)
01278 {
01279   return -(op1->order < op2->order) | (op2->order < op1->order);
01280 }
01281 
01282 
01283 /* Count the number of real ops/instruction-words emitted by the op.
01284  */
01285 extern INT16 OP_Real_Ops( const OP *op );
01286 extern INT OP_Real_Inst_Words( const OP *op );
01287 
01288 
01289 /* ======================================================================
01290  * Macros to traverse the OPs within a basic block. Use of these macros
01291  * allows us to change the underlying representation of the list OPs
01292  * without affecting most users.
01293  * ======================================================================*/
01294 
01295 #define FOR_ALL_BB_OPs_FWD(bb,op) \
01296     for (op = BB_first_op(bb); op != NULL; op = OP_next(op))
01297 
01298 #define FOR_ALL_BB_OPs_REV(bb,op) \
01299     for (op = BB_last_op(bb); op != NULL; op = OP_prev(op))
01300 
01301 #define FOR_ALL_BB_OPs  FOR_ALL_BB_OPs_FWD
01302 
01303 #define FOR_ALL_OPS_OPs_FWD(ops,op) \
01304     for (op = OPS_first(ops); op && op != OP_next(OPS_last(ops)); \
01305    op = OP_next(op))
01306 
01307 #define FOR_ALL_OPS_OPs_REV(ops,op) \
01308     for (op = OPS_last(ops); op && op != OP_prev(OPS_first(ops)); \
01309    op = OP_prev(op))
01310 
01311 #define FOR_ALL_OPS_OPs FOR_ALL_OPS_OPs_FWD
01312 
01313 void Print_OP ( const OP *op );
01314 #pragma mips_frequency_hint NEVER Print_OP
01315 void Print_OPs( const OP *op );
01316 #pragma mips_frequency_hint NEVER Print_OPs
01317 void Print_OPS( const OPS *ops);
01318 #pragma mips_frequency_hint NEVER Print_OPS
01319 void Print_OP_No_SrcLine( const OP *op);
01320 #pragma mips_frequency_hint NEVER Print_OP_No_SrcLine
01321 void Print_OPs_No_SrcLines( const OP *op );
01322 #pragma mips_frequency_hint NEVER Print_OPs_No_SrcLines
01323 void Print_OPS_No_SrcLines( const OPS *ops);
01324 #pragma mips_frequency_hint NEVER Print_OPS_No_SrcLines
01325 
01326 BOOL OP_Is_Float_Mem(const OP *op);
01327 BOOL OP_Alloca_Barrier(OP *op);
01328 BOOL Is_Delay_Slot_Op (OP *xfer_op, OP *op);
01329 
01330 extern void OP_Base_Offset_TNs(OP *memop, struct tn **base_tn, struct tn **offset_tn);
01331 
01332 #ifdef KEY
01333 extern BOOL TN_Pair_In_OP(OP* op, struct tn *tn_res, struct tn *tn_opnd);
01334 #else
01335 /***********************************************************************
01336  *
01337  *      Return a boolean to indicate if <tn> is both an operand and a
01338  *      result in the given <op>, i.e. is same_res.
01339  *
01340  ***********************************************************************/
01341 
01342 inline BOOL 
01343 TN_Pair_In_OP(OP* op, struct tn *tn_res, struct tn *tn_opnd) 
01344 {
01345   INT i;
01346   for (i = 0; i < OP_results(op); i++) {
01347     if (tn_res == OP_result(op,i)) {
01348       break; 
01349     }
01350   }
01351   if (i == OP_results(op)) {
01352     return FALSE;
01353   }
01354   for (i = 0; i < OP_opnds(op); i++) {
01355     if (tn_opnd == OP_opnd(op,i)) {
01356       return TRUE; 
01357     }
01358   }
01359   return FALSE;
01360 }
01361 #endif  // KEY
01362 
01363 #ifdef KEY
01364 INT TN_Resnum_In_OP (OP* op, struct tn *tn, BOOL match_assigned_reg = FALSE); 
01365 #else
01366 /***********************************************************************
01367  *
01368  *      This routine assumes that the given <tn> is a result in <op>.
01369  *      It returns an INT that is the value of the result-number for
01370  *      this <tn> in this <op>.
01371  *
01372  ***********************************************************************/
01373 
01374 inline INT 
01375 TN_Resnum_In_OP (OP* op, struct tn *tn) 
01376 {
01377   for (INT i = 0; i < OP_results(op); i++) {
01378     if (tn == OP_result(op,i)) {
01379       return i;
01380     }
01381   }
01382   FmtAssert (FALSE,
01383              ("TN_resnum_in_OP: Could not find <tn> in results list\n"));
01384   return -1;
01385 }
01386 #endif  // KEY
01387 
01388 /***********************************************************************
01389  *
01390  *      This routine assumes that the given <tn> is an operand in <op>.
01391  *      It returns an INT that is the value of the operand-number for
01392  *      this <tn> in this <op>.
01393  *
01394  ***********************************************************************/
01395 
01396 inline INT 
01397 TN_Opernum_In_OP (OP* op, struct tn *tn) 
01398 {
01399   for (INT i = 0; i < OP_opnds(op); i++) {
01400     if (tn == OP_opnd(op, i)) {
01401       return i;
01402     }
01403   }
01404   FmtAssert (FALSE,
01405              ("TN_Opernum_in_OP: Could not find <tn> in operands list\n"));
01406   return -1;
01407 }
01408 
01409 #ifdef TARG_IA64
01410 inline void
01411 Remove_Hidden_Operands (OP* op) {
01412   if (op->hidden_opnds == 0) return;
01413 
01414   // remove the results to upward so that there is 
01415   // no gap between operands and resutls 
01416   INT from_idx, to_idx;
01417   from_idx = op->opnds;
01418 
01419   op->opnds -= op->hidden_opnds;
01420   to_idx = op->opnds;
01421 
01422   for (INT i = 0; i < op->results; i++) {
01423     op->res_opnd[to_idx++] = op->res_opnd[from_idx++];
01424   }
01425 
01426   op->hidden_opnds = 0;
01427 }
01428 
01429 void Add_Hidden_Operands (OP* op, const vector<struct tn*> & opnds);
01430 
01431 inline BOOL Is_Hidden_Opnd (OP* op, UINT8 opnd) {
01432   return OP_hidden_opnds(op) != 0 && opnd < OP_opnds(op) &&
01433     opnd >= (OP_opnds(op) - OP_hidden_opnds(op));
01434 }
01435 #endif
01436 
01437 /* Is <op> a copy from a callee-saves register into its save-TN?  */
01438 BOOL OP_Is_Copy_To_Save_TN (const OP*);
01439 
01440 /*  Is <op> a copy to a callee-saves register from its save-TN?  */
01441 BOOL OP_Is_Copy_From_Save_TN (const OP* );
01442 
01443 
01444 
01445 #include "op_targ.h"
01446 
01447 #endif /* op_INCLUDED */
01448