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

00001 /*
00002  * Copyright 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: cgexp.h
00044  * $Revision: 1.26 $
00045  * $Date: 06/01/04 18:49:38-08:00 $
00046  * $Author: tkong@hyalite.keyresearch $
00047  * $Source: /scratch/mee/2.4-65/kpro64-pending/be/cg/SCCS/s.cgexp.h $
00048  *
00049  * Description:
00050  * ------------
00051  * This module exports a functional interface for the code expansion 
00052  * phase of the code generator. It provides a set of routines to 
00053  * expand high level operations into a sequence of machine level 
00054  * instructions.
00055  *
00056  * It has several distinct clients:
00057  *
00058  * 1. The translation of WHIRL into machine instructions (whirl2ops.c)
00059  * 2. Spill/restore generation during register allocation (cg_spill.c)
00060  * 3. Generation of new instructions (SWP, entry-exit, CGPREP).
00061  *
00062  * Initialization:
00063  * ---------------
00064  * void Init_CG_Expand (void)
00065  *      Intitialize things for the cgexp phase at the start of each PU.
00066  *
00067  * Overall Structure:
00068  * ------------------
00069  * All the code expansion routines have a common OPS argument.
00070  * The new OPs will be added to this OPS list.
00071  *
00072  * All the code expansion routines have the prefix "Exp_". 
00073  * There are internal routines with the prefix Expand_,
00074  * but those should not be used outside of cgexp.
00075  * ======================================================================
00076  */
00077 
00078 
00079 #ifndef cgexp_INCLUDED
00080 #define cgexp_INCLUDED
00081 
00082 #include "variants.h"
00083 #include "cgtarget.h"
00084 
00085 extern void Init_CG_Expand (void);  /* setup trace flags */
00086 
00087 
00088 /* ======================================================================
00089  * Exp_OP0 / Exp_OP1 / Exp_OP2 / Exp_OP3
00090  *
00091  * All these routines create an OP by putting together the opcode 'opr',
00092  * the result 'r' and the operands. The resulting OP is then expanded
00093  * into machine OPs which are appended to the OPS.
00094  * ======================================================================*/
00095 /* Expand 'op' and append it to <ops>.*/
00096 /* <ops> MUST NOT BE IN A BB. */
00097 extern void Exp_OP (OPCODE opcode, TN *result, TN *op1, TN *op2, TN *op3, 
00098         VARIANT variant, OPS *ops);
00099 #define Exp_OP0(c,r,ops)          Exp_OP(c,r,NULL,NULL,NULL,V_NONE,ops)
00100 #define Exp_OP1(c,r,o1,ops)       Exp_OP(c,r,o1,NULL,NULL,V_NONE,ops)
00101 #define Exp_OP1v(c,r,o1,v,ops)      Exp_OP(c,r,o1,NULL,NULL,v,ops)
00102 #define Exp_OP2(c,r,o1,o2,ops)    Exp_OP(c,r,o1,o2,NULL,V_NONE,ops)
00103 #define Exp_OP2v(c,r,o1,o2,v,ops) Exp_OP(c,r,o1,o2,NULL,v,ops)
00104 #define Exp_OP3(c,r,o1,o2,o3,ops) Exp_OP(c,r,o1,o2,o3,V_NONE,ops)
00105 #define Exp_OP3v(c,r,o1,o2,o3,v,ops)  Exp_OP(c,r,o1,o2,o3,v,ops)
00106 
00107 
00108 /* Generate code to load the address of 'sym'+'ofst' into 'tgt_tn'. 
00109  * The 'call_opr' parameter indicates whether the LDA is for a call.
00110  */
00111 #if defined(TARG_SL)
00112 extern void Exp_Lda (
00113   TYPE_ID mtype, TN *tgt_tn, ST *sym, INT64 ofst, OPERATOR call_opr, OPS *ops,  BOOL is_internal_mem_ofst = FALSE);
00114 #else 
00115 extern void Exp_Lda (
00116   TYPE_ID mtype, TN *tgt_tn, ST *sym, INT64 ofst, OPERATOR call_opr, OPS *ops);
00117 #endif
00118 
00119 /* Generate code to load memory location 'sym'+'ofst' into 'tgt_tn',
00120  * with rtype & desc explicitly given
00121  */
00122 extern void Exp_Load (
00123   TYPE_ID rtype, TYPE_ID desc, TN *tgt_tn, ST *sym, INT64 ofst, OPS *ops, 
00124   VARIANT variant);
00125 
00126 /* Generate code to store 'src_tn' into the memory location 'sym'+'ofst'. */
00127 extern void Exp_Store (
00128   TYPE_ID mtype, TN *src_tn, ST *sym, INT64 ofst, OPS *ops, 
00129   VARIANT variant);
00130 
00131 /* Generate a copy from 'src_tn' to 'tgt_tn'. */
00132 #ifdef TARG_X8664
00133 extern void Exp_COPY (TN *tgt_tn, TN *src_tn, OPS *ops, BOOL copy_pair=FALSE); 
00134 #else
00135 extern void Exp_COPY (TN *tgt_tn, TN *src_tn, OPS *ops); 
00136 #endif
00137 
00138 #if defined(TARG_X8664) || defined(TARG_MIPS)
00139 /* Generate a copy from 'src_tn' to 'tgt_tn' with zero/sign extension. */
00140 extern void Exp_COPY_Ext (TOP opcode, TN *tgt_tn, TN *src_tn, OPS *ops); 
00141 #endif /* TARG_X8664 or TARG_MIPS  */
00142 
00143 /* Given a simulated <op>, expand it into the sequence of instructions
00144  * that must be generated. The <pc_value> is the PC location of the 
00145  * <op>. It is used to generate offsets for branches in the sequence 
00146  * of instructions generated.
00147  */
00148 extern void Exp_Simulated_Op (const OP *op, OPS *ops, INT pc_value);
00149 
00150 /* For the given simulated <op>, return the number of 
00151  * instructions/instruction-words that will be generated after expansion.
00152  */
00153 extern INT Simulated_Op_Real_Ops (const OP *op);
00154 extern INT Simulated_Op_Real_Inst_Words (const OP *op);
00155 
00156 /* Initial expansion of intrinsic call (may not be complete lowering).
00157  * return result TN (if set).
00158  * if creates a loop, then returns loop ops and label for new bb.
00159  */
00160 extern TN * Exp_Intrinsic_Call (
00161   INTRINSIC id, TN *op0, TN *op1, TN *op2, OPS *ops, 
00162   LABEL_IDX *label, OPS *loop_ops);
00163 
00164 #if defined(TARG_SL)
00165 /* Expansion of co-processor instructions */
00166 extern TN * Exp_SL_Intrinsic_Call (INTRINSIC id, WN *intrncall, OPS *ops,
00167              LABEL_IDX *label, OPS *loop_ops, TN* result = NULL);
00168 TN* 
00169 Build_SL_Intrinsic_OP( INTRINSIC id, WN* intrncall, OPS *ops, TN* result =NULL);
00170 #endif
00171 
00172 #ifdef TARG_X8664
00173 /* Expansion of INTRN_SAVEXMMS into TOP_savexmms pseudo instruction */
00174 extern void Exp_Savexmms_Intrinsic(WN *intrncall, TN *rax_tn, LABEL_IDX *label, 
00175            OPS *ops);
00176 
00177 extern void Exp_Landingpadentry_Intrinsic (ST *dest1, ST *dest2, OPS* ops);
00178 
00179 extern void Exp_Fetch_and_And( TN*, TN*, TYPE_ID, OPS* );
00180 extern void Exp_Fetch_and_Or( TN*, TN*, TYPE_ID, OPS* );
00181 extern void Exp_Fetch_and_Xor( TN*, TN*, TYPE_ID, OPS* );
00182 extern TN*  Exp_Compare_and_Swap( TN*, TN*, TN*, TYPE_ID, OPS* );
00183 
00184 /* expand intrinsic op */
00185 extern void Exp_Intrinsic_Op (INTRINSIC id, TN *result, TN *op0, TN *op1, TN *op2, TYPE_ID mtype, OPS *ops);
00186 
00187 #elif defined(TARG_IA64) 
00188 extern void Exp_Intrinsic_Op (INTRINSIC id, TN *result, TN *op0, TN *op1, OPS *ops);
00189 #else
00190 /* expand intrinsic op */
00191 extern void Exp_Intrinsic_Op (INTRINSIC id, TN *result, TN *op0, TN *op1, TYPE_ID mtype, OPS *ops);
00192 #endif // TARG_X8664
00193 
00194 /* Expand TN(const) into a sequence of ops (used in prolog)
00195  */
00196 #ifdef TARG_SL
00197 extern void Exp_Immediate (TN *dest, TN *src, TYPE_ID rtype, OPS *);
00198 #else
00199 extern void Exp_Immediate (TN *dest, TN *src, BOOL is_signed, OPS *);
00200 #endif
00201 
00202 /* create add/sub/mpy op of given mtype */
00203 #define Exp_ADD(mtype,dest,src1,src2,ops) \
00204   Exp_OP2 (OPCODE_make_op(OPR_ADD,mtype,MTYPE_V), dest,src1,src2,ops)
00205 #define Exp_SUB(mtype,dest,src1,src2,ops) \
00206   Exp_OP2 (OPCODE_make_op(OPR_SUB,mtype,MTYPE_V), dest,src1,src2,ops)
00207 #define Exp_MPY(mtype,dest,src1,src2,ops) \
00208   Exp_OP2 (OPCODE_make_op(OPR_MPY,mtype,MTYPE_V), dest,src1,src2,ops)
00209 #define Exp_BAND(mtype,dest,src1,src2,ops)  \
00210   Exp_OP2 (OPCODE_make_op(OPR_BAND,mtype,MTYPE_V), dest,src1,src2,ops)
00211 
00212 /* check whether to eval the condition separate from the select */
00213 extern BOOL Check_Select_Expansion (OPCODE compare);
00214 
00215 #ifdef TARG_X8664
00216 /* create storing vectorized comparison to a preg */
00217 extern void Exp_Stid_And_VComp (
00218         OPCODE stid, TN *result, TN *cmp_kid1, TN *cmp_kid2,
00219         OPCODE compare, OPS *ops);
00220 
00221 /* create select and Vector preg as condition for select */
00222 extern void Exp_Select_And_VLdid (
00223         OPCODE select, TN *result, TN *true_tn, TN *false_tn,
00224         OPCODE compare, TN *vldid, OPS *ops);
00225 #endif
00226 
00227 /* create select and condition for select */
00228 #if defined(TARG_SL)
00229 extern void Exp_Select_And_Condition (
00230         WN* wn_select, OPCODE select, TN *result, TN *true_tn, TN *false_tn,
00231         OPCODE compare, TN *cmp_kid1, TN *cmp_kid2, VARIANT variant, OPS *ops);
00232 #else
00233 extern void Exp_Select_And_Condition (
00234         OPCODE select, TN *result, TN *true_tn, TN *false_tn,
00235         OPCODE compare, TN *cmp_kid1, TN *cmp_kid2, VARIANT variant, OPS *ops);
00236 #endif
00237 
00238 #if defined(TARG_SL)
00239 extern BOOL Exp_Opt_Select_And_Condition (WN * select, TN * result, TN * true_tn,
00240         TN * false_tn, TN * cmp_kid1, TN * cmp_kid2, OPS * ops);
00241 extern void Exp_2inst_MC_Zero (TOP mc_op, TN* dest_tn, TN* true_tn, TN* false_tn, 
00242         TN* cond_tn, TYPE_ID true_type, TYPE_ID false_type, INT unsignedflag, OPS* ops );
00243 #endif
00244 
00245 #if defined(TARG_SL)
00246 extern LABEL_IDX Exp_Select_Part1(
00247         OPCODE select, TN *result, TN *true_tn, TN *false_tn,
00248         OPCODE compare, TN *cmp_kid1, TN *cmp_kid2, OPS *ops);
00249 #endif
00250 
00251 /*
00252  * By default, when we expand multi-instruction sequences, we use a new
00253  * temporary TN for each intermediate result.  This simplifies things for
00254  * CGPREP.  But in some case like spill code and and -O0 code, it is more
00255  * efficient to reuse the same TN for intermediate results.  We reuse the
00256  * TNs when this flag, Reuse_Temp_TNs, is TRUE.
00257  */
00258 extern BOOL Reuse_Temp_TNs;
00259 #define Get_Temp_TN(tn) (Reuse_Temp_TNs ? tn : Build_TN_Like(tn))
00260 
00261 /* Expand a local (to a BB) jump, choosing between a PIC (longer) sequence
00262  * and an absolute (shorter) sequence depending on the compilation mode.
00263  * A jump implies the ability to jump long distances.
00264  */
00265 extern void Exp_Local_Jump(BB *bb, INT64 offset, OPS *ops);
00266 
00267 
00268 /*
00269  * determine if a given symbol is a stack relative reference that will
00270  * require multiple instructions to load or store.
00271  */
00272 extern BOOL Exp_Is_Large_Stack_Sym(ST* sym, INT64 ofst);
00273 
00274 /* generate prefetch inst */
00275 extern void Exp_Prefetch (TOP opc, TN *src1, TN *src2, VARIANT variant, OPS *ops);
00276 
00277 /* generate instructions to extract a bit field */
00278 extern void Exp_Extract_Bits (TYPE_ID rtype, TYPE_ID desc, UINT bit_offset,
00279             UINT bit_size, TN *tgt_tn, TN *src_tn, OPS *ops);
00280 
00281 /* generate instructions to deposit value in a bit field */
00282 extern void Exp_Deposit_Bits (TYPE_ID rtype, TYPE_ID desc, 
00283             UINT bit_offset, UINT bit_size, 
00284             TN *tgt_tn, TN *src1_tn, TN *src2_tn, OPS *ops);
00285 
00286 #ifdef TARG_X8664
00287 /* generate instructions to set a bit field to all 1's */
00288 extern void Exp_Set_Bits (TYPE_ID rtype, TYPE_ID desc,
00289             UINT bit_offset, UINT bit_size, 
00290             TN *tgt_tn, TN *src1_tn, OPS *ops);
00291 
00292 /* expand return instruction */
00293 extern void Exp_Return (TN *return_address, int sp_adjust, OPS *ops);
00294 #else
00295 extern void Exp_Return (TN *return_address, OPS *ops);
00296 #endif
00297 
00298 /* expand call instruction */
00299 extern void Exp_Call (OPERATOR opr, TN *return_address, TN *target, OPS *ops);
00300 
00301 /* expand indirect branch */
00302 extern void Exp_Indirect_Branch (TN *targ_reg, OPS *ops);
00303 
00304 /* expand no-op */
00305 extern void Exp_Noop (OPS *ops);
00306 
00307 /* build spadjust op */
00308 extern void Exp_Spadjust (TN *dest, TN *size, VARIANT variant, OPS *ops);
00309 
00310 /* generate predicate calculation op given an existing comparison operator.
00311  * this could be a branch op, particularly for MIPS.
00312  */
00313 extern void Exp_Pred_Calc(TN* result, OP* cmp_op, COMPARE_TYPE ctype,
00314         BOOL false_result, OPS* ops);
00315 
00316 /* 
00317  *  Generate a generic 2-result predicate operation.
00318  *  COMPARE_type_or sets result1 and result2 true if qual_pred is true
00319  *  COMPARE_type_and sets result1 and result2 false if qual_pred is true
00320  */
00321 extern void Exp_Generic_Pred_Calc(TN* result1, TN *result2, COMPARE_TYPE ctype,
00322           TN *qual_pred, OPS *ops);
00323 
00324 /*
00325  * Used by if conversion. See expand.cxx for details.
00326  */
00327 extern void Exp_True_False_Preds_For_Block(BB *bb,
00328              TN* &true_tn, TN * &false_tn);
00329 #ifdef KEY
00330 /*
00331  * Used to reinitilalize Predicate TNs for HB 
00332  */
00333 extern void HB_Reinit_Pred ();
00334 #endif
00335 
00336 #ifdef TARG_X8664
00337 extern void Expand_Start();
00338 extern void Expand_Finish();
00339 extern void Expand_Cmov (TOP top, TN *result, TN *src, TN *rflags, OPS *ops,
00340        TN *result2 = NULL, TN *src2 = NULL);
00341 #endif
00342 
00343 /* Predicate manipulation routines.
00344  *
00345  * Most if not all of these routines take two result TNs. The second
00346  * result is a complement of the first. If one result is not needed,
00347  * it can be specified as NULL, in which case the utility will allocate
00348  * a temp if necessary, or a dedicated TN for a sink register (if
00349  * the architecture has one). 
00350  */
00351 extern void Exp_Pred_Set(TN *dest, TN *cdest, INT val, OPS *ops);
00352 extern void Exp_Pred_Copy(TN *dest, TN *cdest, TN *src, OPS *ops);
00353 extern void Exp_Pred_Complement(TN *dest, TN *cdest, TN *src, OPS *ops);
00354 extern void Exp_Pred_Compare(TN *dest, TN *cdest, TN *src1, TN *src2, 
00355            VARIANT variant, OPS *ops);
00356 
00357 /* check if target can handle immediate operand;
00358  * True if target can, false if should use target-independent logic.
00359  */
00360 extern BOOL Target_Has_Immediate_Operand (WN *parent, WN *expr);
00361 
00362 #if defined(TARG_SL) 
00363 extern TN * Expand_Expr (WN *expr, WN *parent, TN *result, INTRINSIC intrn_id = INTRINSIC_INVALID);
00364 // On IA-64, Expand_Expr is static in whirl2ops.cxx
00365 //#elif defined(TARG_IA64)
00366 //extern TN * Expand_Expr (WN *expr, WN *parent, TN *result);
00367 /*  for 64bit expand */
00368 extern void Expand_Start();
00369 extern void Expand_Finish();
00370 #endif 
00371 
00372 #ifdef TARG_X8664
00373 extern void CG_Set_Is_Stack_Used();
00374 #endif
00375 
00376 #endif /* cgexp_INCLUDED */